457 lines
23 KiB
Java
457 lines
23 KiB
Java
/*
|
|
* Minecraft Forge
|
|
* Copyright (c) 2016-2019.
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
* License as published by the Free Software Foundation version 2.1
|
|
* of the License.
|
|
*
|
|
* This library is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
* License along with this library; if not, write to the Free Software
|
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
|
*/
|
|
|
|
package net.minecraftforge.fml.client.gui;
|
|
|
|
import net.minecraft.client.Minecraft;
|
|
import net.minecraft.client.gui.FontRenderer;
|
|
import net.minecraft.client.gui.AbstractGui;
|
|
import net.minecraft.client.renderer.Tessellator;
|
|
import net.minecraft.client.renderer.BufferBuilder;
|
|
import net.minecraft.client.renderer.IRenderTypeBuffer;
|
|
import net.minecraft.client.renderer.Matrix4f;
|
|
import net.minecraft.client.renderer.vertex.DefaultVertexFormats;
|
|
import net.minecraft.item.ItemStack;
|
|
import net.minecraft.util.ResourceLocation;
|
|
import net.minecraftforge.client.event.RenderTooltipEvent;
|
|
import net.minecraftforge.common.MinecraftForge;
|
|
|
|
import org.lwjgl.opengl.GL11;
|
|
|
|
import com.mojang.blaze3d.matrix.MatrixStack;
|
|
import com.mojang.blaze3d.systems.RenderSystem;
|
|
|
|
import java.util.ArrayList;
|
|
import java.util.List;
|
|
|
|
import javax.annotation.Nonnull;
|
|
|
|
/**
|
|
* This class provides several methods and constants used by the Config GUI classes.
|
|
*
|
|
* @author bspkrs
|
|
*/
|
|
public class GuiUtils
|
|
{
|
|
public static final String UNDO_CHAR = "\u21B6";
|
|
public static final String RESET_CHAR = "\u2604";
|
|
public static final String VALID = "\u2714";
|
|
public static final String INVALID = "\u2715";
|
|
|
|
public static int[] colorCodes = new int[] { 0, 170, 43520, 43690, 11141120, 11141290, 16755200, 11184810, 5592405, 5592575, 5635925, 5636095, 16733525, 16733695, 16777045, 16777215,
|
|
0, 42, 10752, 10794, 2752512, 2752554, 2763264, 2763306, 1381653, 1381695, 1392405, 1392447, 4134165, 4134207, 4144917, 4144959 };
|
|
|
|
public static int getColorCode(char c, boolean isLighter)
|
|
{
|
|
return colorCodes[isLighter ? "0123456789abcdef".indexOf(c) : "0123456789abcdef".indexOf(c) + 16];
|
|
}
|
|
/**
|
|
* Draws a textured box of any size (smallest size is borderSize * 2 square) based on a fixed size textured box with continuous borders
|
|
* and filler. It is assumed that the desired texture ResourceLocation object has been bound using
|
|
* Minecraft.getMinecraft().getTextureManager().bindTexture(resourceLocation).
|
|
*
|
|
* @param x x axis offset
|
|
* @param y y axis offset
|
|
* @param u bound resource location image x offset
|
|
* @param v bound resource location image y offset
|
|
* @param width the desired box width
|
|
* @param height the desired box height
|
|
* @param textureWidth the width of the box texture in the resource location image
|
|
* @param textureHeight the height of the box texture in the resource location image
|
|
* @param borderSize the size of the box's borders
|
|
* @param zLevel the zLevel to draw at
|
|
*/
|
|
public static void drawContinuousTexturedBox(int x, int y, int u, int v, int width, int height, int textureWidth, int textureHeight,
|
|
int borderSize, float zLevel)
|
|
{
|
|
drawContinuousTexturedBox(x, y, u, v, width, height, textureWidth, textureHeight, borderSize, borderSize, borderSize, borderSize, zLevel);
|
|
}
|
|
|
|
/**
|
|
* Draws a textured box of any size (smallest size is borderSize * 2 square) based on a fixed size textured box with continuous borders
|
|
* and filler. The provided ResourceLocation object will be bound using
|
|
* Minecraft.getMinecraft().getTextureManager().bindTexture(resourceLocation).
|
|
*
|
|
* @param res the ResourceLocation object that contains the desired image
|
|
* @param x x axis offset
|
|
* @param y y axis offset
|
|
* @param u bound resource location image x offset
|
|
* @param v bound resource location image y offset
|
|
* @param width the desired box width
|
|
* @param height the desired box height
|
|
* @param textureWidth the width of the box texture in the resource location image
|
|
* @param textureHeight the height of the box texture in the resource location image
|
|
* @param borderSize the size of the box's borders
|
|
* @param zLevel the zLevel to draw at
|
|
*/
|
|
public static void drawContinuousTexturedBox(ResourceLocation res, int x, int y, int u, int v, int width, int height, int textureWidth, int textureHeight,
|
|
int borderSize, float zLevel)
|
|
{
|
|
drawContinuousTexturedBox(res, x, y, u, v, width, height, textureWidth, textureHeight, borderSize, borderSize, borderSize, borderSize, zLevel);
|
|
}
|
|
|
|
/**
|
|
* Draws a textured box of any size (smallest size is borderSize * 2 square) based on a fixed size textured box with continuous borders
|
|
* and filler. The provided ResourceLocation object will be bound using
|
|
* Minecraft.getMinecraft().getTextureManager().bindTexture(resourceLocation).
|
|
*
|
|
* @param res the ResourceLocation object that contains the desired image
|
|
* @param x x axis offset
|
|
* @param y y axis offset
|
|
* @param u bound resource location image x offset
|
|
* @param v bound resource location image y offset
|
|
* @param width the desired box width
|
|
* @param height the desired box height
|
|
* @param textureWidth the width of the box texture in the resource location image
|
|
* @param textureHeight the height of the box texture in the resource location image
|
|
* @param topBorder the size of the box's top border
|
|
* @param bottomBorder the size of the box's bottom border
|
|
* @param leftBorder the size of the box's left border
|
|
* @param rightBorder the size of the box's right border
|
|
* @param zLevel the zLevel to draw at
|
|
*/
|
|
public static void drawContinuousTexturedBox(ResourceLocation res, int x, int y, int u, int v, int width, int height, int textureWidth, int textureHeight,
|
|
int topBorder, int bottomBorder, int leftBorder, int rightBorder, float zLevel)
|
|
{
|
|
Minecraft.getInstance().getTextureManager().bindTexture(res);
|
|
drawContinuousTexturedBox(x, y, u, v, width, height, textureWidth, textureHeight, topBorder, bottomBorder, leftBorder, rightBorder, zLevel);
|
|
}
|
|
|
|
/**
|
|
* Draws a textured box of any size (smallest size is borderSize * 2 square) based on a fixed size textured box with continuous borders
|
|
* and filler. It is assumed that the desired texture ResourceLocation object has been bound using
|
|
* Minecraft.getMinecraft().getTextureManager().bindTexture(resourceLocation).
|
|
*
|
|
* @param x x axis offset
|
|
* @param y y axis offset
|
|
* @param u bound resource location image x offset
|
|
* @param v bound resource location image y offset
|
|
* @param width the desired box width
|
|
* @param height the desired box height
|
|
* @param textureWidth the width of the box texture in the resource location image
|
|
* @param textureHeight the height of the box texture in the resource location image
|
|
* @param topBorder the size of the box's top border
|
|
* @param bottomBorder the size of the box's bottom border
|
|
* @param leftBorder the size of the box's left border
|
|
* @param rightBorder the size of the box's right border
|
|
* @param zLevel the zLevel to draw at
|
|
*/
|
|
public static void drawContinuousTexturedBox(int x, int y, int u, int v, int width, int height, int textureWidth, int textureHeight,
|
|
int topBorder, int bottomBorder, int leftBorder, int rightBorder, float zLevel)
|
|
{
|
|
RenderSystem.color4f(1.0F, 1.0F, 1.0F, 1.0F);
|
|
RenderSystem.enableBlend();
|
|
RenderSystem.blendFuncSeparate(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA, 1, 0);
|
|
|
|
int fillerWidth = textureWidth - leftBorder - rightBorder;
|
|
int fillerHeight = textureHeight - topBorder - bottomBorder;
|
|
int canvasWidth = width - leftBorder - rightBorder;
|
|
int canvasHeight = height - topBorder - bottomBorder;
|
|
int xPasses = canvasWidth / fillerWidth;
|
|
int remainderWidth = canvasWidth % fillerWidth;
|
|
int yPasses = canvasHeight / fillerHeight;
|
|
int remainderHeight = canvasHeight % fillerHeight;
|
|
|
|
// Draw Border
|
|
// Top Left
|
|
drawTexturedModalRect(x, y, u, v, leftBorder, topBorder, zLevel);
|
|
// Top Right
|
|
drawTexturedModalRect(x + leftBorder + canvasWidth, y, u + leftBorder + fillerWidth, v, rightBorder, topBorder, zLevel);
|
|
// Bottom Left
|
|
drawTexturedModalRect(x, y + topBorder + canvasHeight, u, v + topBorder + fillerHeight, leftBorder, bottomBorder, zLevel);
|
|
// Bottom Right
|
|
drawTexturedModalRect(x + leftBorder + canvasWidth, y + topBorder + canvasHeight, u + leftBorder + fillerWidth, v + topBorder + fillerHeight, rightBorder, bottomBorder, zLevel);
|
|
|
|
for (int i = 0; i < xPasses + (remainderWidth > 0 ? 1 : 0); i++)
|
|
{
|
|
// Top Border
|
|
drawTexturedModalRect(x + leftBorder + (i * fillerWidth), y, u + leftBorder, v, (i == xPasses ? remainderWidth : fillerWidth), topBorder, zLevel);
|
|
// Bottom Border
|
|
drawTexturedModalRect(x + leftBorder + (i * fillerWidth), y + topBorder + canvasHeight, u + leftBorder, v + topBorder + fillerHeight, (i == xPasses ? remainderWidth : fillerWidth), bottomBorder, zLevel);
|
|
|
|
// Throw in some filler for good measure
|
|
for (int j = 0; j < yPasses + (remainderHeight > 0 ? 1 : 0); j++)
|
|
drawTexturedModalRect(x + leftBorder + (i * fillerWidth), y + topBorder + (j * fillerHeight), u + leftBorder, v + topBorder, (i == xPasses ? remainderWidth : fillerWidth), (j == yPasses ? remainderHeight : fillerHeight), zLevel);
|
|
}
|
|
|
|
// Side Borders
|
|
for (int j = 0; j < yPasses + (remainderHeight > 0 ? 1 : 0); j++)
|
|
{
|
|
// Left Border
|
|
drawTexturedModalRect(x, y + topBorder + (j * fillerHeight), u, v + topBorder, leftBorder, (j == yPasses ? remainderHeight : fillerHeight), zLevel);
|
|
// Right Border
|
|
drawTexturedModalRect(x + leftBorder + canvasWidth, y + topBorder + (j * fillerHeight), u + leftBorder + fillerWidth, v + topBorder, rightBorder, (j == yPasses ? remainderHeight : fillerHeight), zLevel);
|
|
}
|
|
}
|
|
|
|
public static void drawTexturedModalRect(int x, int y, int u, int v, int width, int height, float zLevel)
|
|
{
|
|
final float uScale = 1f / 0x100;
|
|
final float vScale = 1f / 0x100;
|
|
|
|
Tessellator tessellator = Tessellator.getInstance();
|
|
BufferBuilder wr = tessellator.getBuffer();
|
|
wr.begin(GL11.GL_QUADS, DefaultVertexFormats.POSITION_TEX);
|
|
wr.func_225582_a_(x , y + height, zLevel).func_225583_a_( u * uScale, ((v + height) * vScale)).endVertex();
|
|
wr.func_225582_a_(x + width, y + height, zLevel).func_225583_a_((u + width) * uScale, ((v + height) * vScale)).endVertex();
|
|
wr.func_225582_a_(x + width, y , zLevel).func_225583_a_((u + width) * uScale, ( v * vScale)).endVertex();
|
|
wr.func_225582_a_(x , y , zLevel).func_225583_a_( u * uScale, ( v * vScale)).endVertex();
|
|
tessellator.draw();
|
|
}
|
|
|
|
@Nonnull
|
|
private static ItemStack cachedTooltipStack = ItemStack.EMPTY;
|
|
|
|
/**
|
|
* Must be called from {@code GuiScreen.renderToolTip} before {@code GuiScreen.drawHoveringText} is called.
|
|
*
|
|
* @param stack The stack for which a tooltip is about to be drawn.
|
|
*/
|
|
public static void preItemToolTip(@Nonnull ItemStack stack)
|
|
{
|
|
cachedTooltipStack = stack;
|
|
}
|
|
|
|
/**
|
|
* Must be called from {@code GuiScreen.renderToolTip} after {@code GuiScreen.drawHoveringText} is called.
|
|
*/
|
|
public static void postItemToolTip()
|
|
{
|
|
cachedTooltipStack = ItemStack.EMPTY;
|
|
}
|
|
|
|
/**
|
|
* Draws a tooltip box on the screen with text in it.
|
|
* Automatically positions the box relative to the mouse to match Mojang's implementation.
|
|
* Automatically wraps text when there is not enough space on the screen to display the text without wrapping.
|
|
* Can have a maximum width set to avoid creating very wide tooltips.
|
|
*
|
|
* @param textLines the lines of text to be drawn in a hovering tooltip box.
|
|
* @param mouseX the mouse X position
|
|
* @param mouseY the mouse Y position
|
|
* @param screenWidth the available screen width for the tooltip to drawn in
|
|
* @param screenHeight the available screen height for the tooltip to drawn in
|
|
* @param maxTextWidth the maximum width of the text in the tooltip box.
|
|
* Set to a negative number to have no max width.
|
|
* @param font the font for drawing the text in the tooltip box
|
|
*/
|
|
public static void drawHoveringText(List<String> textLines, int mouseX, int mouseY, int screenWidth, int screenHeight, int maxTextWidth, FontRenderer font)
|
|
{
|
|
drawHoveringText(cachedTooltipStack, textLines, mouseX, mouseY, screenWidth, screenHeight, maxTextWidth, font);
|
|
}
|
|
|
|
/**
|
|
* Use this version if calling from somewhere where ItemStack context is available.
|
|
*
|
|
* @see #drawHoveringText(List, int, int, int, int, int, FontRenderer)
|
|
*/
|
|
public static void drawHoveringText(@Nonnull final ItemStack stack, List<String> textLines, int mouseX, int mouseY, int screenWidth, int screenHeight, int maxTextWidth, FontRenderer font)
|
|
{
|
|
if (!textLines.isEmpty())
|
|
{
|
|
RenderTooltipEvent.Pre event = new RenderTooltipEvent.Pre(stack, textLines, mouseX, mouseY, screenWidth, screenHeight, maxTextWidth, font);
|
|
if (MinecraftForge.EVENT_BUS.post(event))
|
|
return;
|
|
mouseX = event.getX();
|
|
mouseY = event.getY();
|
|
screenWidth = event.getScreenWidth();
|
|
screenHeight = event.getScreenHeight();
|
|
maxTextWidth = event.getMaxWidth();
|
|
font = event.getFontRenderer();
|
|
|
|
RenderSystem.disableRescaleNormal();
|
|
RenderSystem.disableDepthTest();
|
|
int tooltipTextWidth = 0;
|
|
|
|
for (String textLine : textLines)
|
|
{
|
|
int textLineWidth = font.getStringWidth(textLine);
|
|
if (textLineWidth > tooltipTextWidth)
|
|
tooltipTextWidth = textLineWidth;
|
|
}
|
|
|
|
boolean needsWrap = false;
|
|
|
|
int titleLinesCount = 1;
|
|
int tooltipX = mouseX + 12;
|
|
if (tooltipX + tooltipTextWidth + 4 > screenWidth)
|
|
{
|
|
tooltipX = mouseX - 16 - tooltipTextWidth;
|
|
if (tooltipX < 4) // if the tooltip doesn't fit on the screen
|
|
{
|
|
if (mouseX > screenWidth / 2)
|
|
tooltipTextWidth = mouseX - 12 - 8;
|
|
else
|
|
tooltipTextWidth = screenWidth - 16 - mouseX;
|
|
needsWrap = true;
|
|
}
|
|
}
|
|
|
|
if (maxTextWidth > 0 && tooltipTextWidth > maxTextWidth)
|
|
{
|
|
tooltipTextWidth = maxTextWidth;
|
|
needsWrap = true;
|
|
}
|
|
|
|
if (needsWrap)
|
|
{
|
|
int wrappedTooltipWidth = 0;
|
|
List<String> wrappedTextLines = new ArrayList<String>();
|
|
for (int i = 0; i < textLines.size(); i++)
|
|
{
|
|
String textLine = textLines.get(i);
|
|
List<String> wrappedLine = font.listFormattedStringToWidth(textLine, tooltipTextWidth);
|
|
if (i == 0)
|
|
titleLinesCount = wrappedLine.size();
|
|
|
|
for (String line : wrappedLine)
|
|
{
|
|
int lineWidth = font.getStringWidth(line);
|
|
if (lineWidth > wrappedTooltipWidth)
|
|
wrappedTooltipWidth = lineWidth;
|
|
wrappedTextLines.add(line);
|
|
}
|
|
}
|
|
tooltipTextWidth = wrappedTooltipWidth;
|
|
textLines = wrappedTextLines;
|
|
|
|
if (mouseX > screenWidth / 2)
|
|
tooltipX = mouseX - 16 - tooltipTextWidth;
|
|
else
|
|
tooltipX = mouseX + 12;
|
|
}
|
|
|
|
int tooltipY = mouseY - 12;
|
|
int tooltipHeight = 8;
|
|
|
|
if (textLines.size() > 1)
|
|
{
|
|
tooltipHeight += (textLines.size() - 1) * 10;
|
|
if (textLines.size() > titleLinesCount)
|
|
tooltipHeight += 2; // gap between title lines and next lines
|
|
}
|
|
|
|
if (tooltipY < 4)
|
|
tooltipY = 4;
|
|
else if (tooltipY + tooltipHeight + 4 > screenHeight)
|
|
tooltipY = screenHeight - tooltipHeight - 4;
|
|
|
|
final int zLevel = 300;
|
|
int backgroundColor = 0xF0100010;
|
|
int borderColorStart = 0x505000FF;
|
|
int borderColorEnd = (borderColorStart & 0xFEFEFE) >> 1 | borderColorStart & 0xFF000000;
|
|
RenderTooltipEvent.Color colorEvent = new RenderTooltipEvent.Color(stack, textLines, tooltipX, tooltipY, font, backgroundColor, borderColorStart, borderColorEnd);
|
|
MinecraftForge.EVENT_BUS.post(colorEvent);
|
|
backgroundColor = colorEvent.getBackground();
|
|
borderColorStart = colorEvent.getBorderStart();
|
|
borderColorEnd = colorEvent.getBorderEnd();
|
|
|
|
drawGradientRect(zLevel, tooltipX - 3, tooltipY - 4, tooltipX + tooltipTextWidth + 3, tooltipY - 3, backgroundColor, backgroundColor);
|
|
drawGradientRect(zLevel, tooltipX - 3, tooltipY + tooltipHeight + 3, tooltipX + tooltipTextWidth + 3, tooltipY + tooltipHeight + 4, backgroundColor, backgroundColor);
|
|
drawGradientRect(zLevel, tooltipX - 3, tooltipY - 3, tooltipX + tooltipTextWidth + 3, tooltipY + tooltipHeight + 3, backgroundColor, backgroundColor);
|
|
drawGradientRect(zLevel, tooltipX - 4, tooltipY - 3, tooltipX - 3, tooltipY + tooltipHeight + 3, backgroundColor, backgroundColor);
|
|
drawGradientRect(zLevel, tooltipX + tooltipTextWidth + 3, tooltipY - 3, tooltipX + tooltipTextWidth + 4, tooltipY + tooltipHeight + 3, backgroundColor, backgroundColor);
|
|
drawGradientRect(zLevel, tooltipX - 3, tooltipY - 3 + 1, tooltipX - 3 + 1, tooltipY + tooltipHeight + 3 - 1, borderColorStart, borderColorEnd);
|
|
drawGradientRect(zLevel, tooltipX + tooltipTextWidth + 2, tooltipY - 3 + 1, tooltipX + tooltipTextWidth + 3, tooltipY + tooltipHeight + 3 - 1, borderColorStart, borderColorEnd);
|
|
drawGradientRect(zLevel, tooltipX - 3, tooltipY - 3, tooltipX + tooltipTextWidth + 3, tooltipY - 3 + 1, borderColorStart, borderColorStart);
|
|
drawGradientRect(zLevel, tooltipX - 3, tooltipY + tooltipHeight + 2, tooltipX + tooltipTextWidth + 3, tooltipY + tooltipHeight + 3, borderColorEnd, borderColorEnd);
|
|
|
|
MinecraftForge.EVENT_BUS.post(new RenderTooltipEvent.PostBackground(stack, textLines, tooltipX, tooltipY, font, tooltipTextWidth, tooltipHeight));
|
|
|
|
IRenderTypeBuffer.Impl renderType = IRenderTypeBuffer.func_228455_a_(Tessellator.getInstance().getBuffer());
|
|
MatrixStack textStack = new MatrixStack();
|
|
textStack.func_227861_a_(0.0D, 0.0D, (double)zLevel);
|
|
Matrix4f textLocation = textStack.func_227866_c_().func_227870_a_();
|
|
|
|
int tooltipTop = tooltipY;
|
|
|
|
for (int lineNumber = 0; lineNumber < textLines.size(); ++lineNumber)
|
|
{
|
|
String line = textLines.get(lineNumber);
|
|
if (line != null)
|
|
font.func_228079_a_(line, (float)tooltipX, (float)tooltipY, -1, true, textLocation, renderType, false, 0, 15728880);
|
|
|
|
if (lineNumber + 1 == titleLinesCount)
|
|
tooltipY += 2;
|
|
|
|
tooltipY += 10;
|
|
}
|
|
|
|
renderType.func_228461_a_();
|
|
|
|
MinecraftForge.EVENT_BUS.post(new RenderTooltipEvent.PostText(stack, textLines, tooltipX, tooltipTop, font, tooltipTextWidth, tooltipHeight));
|
|
|
|
RenderSystem.enableDepthTest();
|
|
RenderSystem.enableRescaleNormal();
|
|
}
|
|
}
|
|
|
|
public static void drawGradientRect(int zLevel, int left, int top, int right, int bottom, int startColor, int endColor)
|
|
{
|
|
float startAlpha = (float)(startColor >> 24 & 255) / 255.0F;
|
|
float startRed = (float)(startColor >> 16 & 255) / 255.0F;
|
|
float startGreen = (float)(startColor >> 8 & 255) / 255.0F;
|
|
float startBlue = (float)(startColor & 255) / 255.0F;
|
|
float endAlpha = (float)(endColor >> 24 & 255) / 255.0F;
|
|
float endRed = (float)(endColor >> 16 & 255) / 255.0F;
|
|
float endGreen = (float)(endColor >> 8 & 255) / 255.0F;
|
|
float endBlue = (float)(endColor & 255) / 255.0F;
|
|
|
|
RenderSystem.disableTexture();
|
|
RenderSystem.enableBlend();
|
|
RenderSystem.disableAlphaTest();
|
|
RenderSystem.defaultBlendFunc();
|
|
RenderSystem.shadeModel(GL11.GL_SMOOTH);
|
|
|
|
Tessellator tessellator = Tessellator.getInstance();
|
|
BufferBuilder buffer = tessellator.getBuffer();
|
|
buffer.begin(GL11.GL_QUADS, DefaultVertexFormats.POSITION_COLOR);
|
|
buffer.func_225582_a_(right, top, zLevel).func_227885_a_(startRed, startGreen, startBlue, startAlpha).endVertex();
|
|
buffer.func_225582_a_( left, top, zLevel).func_227885_a_(startRed, startGreen, startBlue, startAlpha).endVertex();
|
|
buffer.func_225582_a_( left, bottom, zLevel).func_227885_a_( endRed, endGreen, endBlue, endAlpha).endVertex();
|
|
buffer.func_225582_a_(right, bottom, zLevel).func_227885_a_( endRed, endGreen, endBlue, endAlpha).endVertex();
|
|
tessellator.draw();
|
|
|
|
RenderSystem.shadeModel(GL11.GL_FLAT);
|
|
RenderSystem.disableBlend();
|
|
RenderSystem.enableAlphaTest();
|
|
RenderSystem.enableTexture();
|
|
}
|
|
|
|
public static void drawInscribedRect(int x, int y, int boundsWidth, int boundsHeight, int rectWidth, int rectHeight)
|
|
{
|
|
drawInscribedRect(x, y, boundsWidth, boundsHeight, rectWidth, rectHeight, true, true);
|
|
}
|
|
|
|
public static void drawInscribedRect(int x, int y, int boundsWidth, int boundsHeight, int rectWidth, int rectHeight, boolean centerX, boolean centerY)
|
|
{
|
|
if (rectWidth * boundsHeight > rectHeight * boundsWidth) {
|
|
int h = boundsHeight;
|
|
boundsHeight = (int) (boundsWidth * ((double) rectHeight / rectWidth));
|
|
if (centerY) y += (h - boundsHeight) / 2;
|
|
} else {
|
|
int w = boundsWidth;
|
|
boundsWidth = (int) (boundsHeight * ((double) rectWidth / rectHeight));
|
|
if (centerX) x += (w - boundsWidth) / 2;
|
|
}
|
|
|
|
AbstractGui.blit(x, y, boundsWidth, boundsHeight, 0.0f,0.0f, rectWidth, rectHeight, rectWidth, rectHeight);
|
|
}
|
|
}
|