You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
920 lines
22 KiB
920 lines
22 KiB
package net.tortuga.util;
|
|
|
|
|
|
import static org.lwjgl.opengl.GL11.*;
|
|
import net.tortuga.textures.TextureManager;
|
|
import net.tortuga.textures.TxQuad;
|
|
|
|
import org.newdawn.slick.opengl.Texture;
|
|
|
|
import com.porcupine.color.HSV;
|
|
import com.porcupine.color.RGB;
|
|
import com.porcupine.coord.Coord;
|
|
import com.porcupine.coord.Rect;
|
|
|
|
|
|
/**
|
|
* Render utilities
|
|
*
|
|
* @author Ondřej Hruška (MightyPork)
|
|
*/
|
|
public class RenderUtils {
|
|
|
|
/**
|
|
* Render quad 2D
|
|
*
|
|
* @param min min coord
|
|
* @param max max coord
|
|
*/
|
|
public static void quadCoord(Coord min, Coord max)
|
|
{
|
|
quadCoord(min.x, min.y, max.x, max.y);
|
|
}
|
|
|
|
|
|
/**
|
|
* Render quad with absolute coords (from screen bottom)
|
|
*
|
|
* @param left left x
|
|
* @param bottom bottom y
|
|
* @param right right x
|
|
* @param top top y
|
|
*/
|
|
public static void quadCoord(double left, double bottom, double right, double top)
|
|
{
|
|
glBegin(GL_QUADS);
|
|
glVertex2d(left, top);
|
|
glVertex2d(right, top);
|
|
glVertex2d(right, bottom);
|
|
glVertex2d(left, bottom);
|
|
glEnd();
|
|
}
|
|
|
|
|
|
/**
|
|
* Render quad with coloured border
|
|
*
|
|
* @param min min
|
|
* @param max max
|
|
* @param border border width
|
|
* @param borderColor border color
|
|
* @param insideColor filling color
|
|
*/
|
|
public static void quadCoordBorder(Coord min, Coord max, double border, RGB borderColor, RGB insideColor)
|
|
{
|
|
quadCoordBorder(min.x, min.y, max.x, max.y, border, borderColor, insideColor);
|
|
}
|
|
|
|
|
|
/**
|
|
* Render quad with coloured border
|
|
*
|
|
* @param minX min x
|
|
* @param minY min y
|
|
* @param maxX max x
|
|
* @param maxY max y
|
|
* @param border border width
|
|
* @param borderColor border color
|
|
* @param insideColor filling color
|
|
*/
|
|
public static void quadCoordBorder(double minX, double minY, double maxX, double maxY, double border, RGB borderColor, RGB insideColor)
|
|
{
|
|
double bdr = border;
|
|
|
|
RenderUtils.setColor(borderColor);
|
|
|
|
//@formatter:off
|
|
RenderUtils.quadCoord(minX, minY, minX + bdr, maxY);
|
|
RenderUtils.quadCoord(maxX - bdr, minY, maxX, maxY);
|
|
RenderUtils.quadCoord(minX + bdr, maxY - bdr, maxX - bdr, maxY);
|
|
RenderUtils.quadCoord(minX + bdr, minY, maxX - bdr, minY + bdr);
|
|
//@formatter:on
|
|
|
|
if (insideColor != null) {
|
|
RenderUtils.setColor(insideColor);
|
|
RenderUtils.quadCoord(minX + bdr, minY + bdr, maxX - bdr, maxY - bdr);
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* Render quad 2D with gradient horizontal
|
|
*
|
|
* @param min min coord
|
|
* @param max max coord
|
|
* @param colorLeft color left
|
|
* @param colorRight color right
|
|
*/
|
|
public static void quadCoordGradH(Coord min, Coord max, RGB colorLeft, RGB colorRight)
|
|
{
|
|
quadCoordGradH(min.x, min.y, max.x, max.y, colorLeft, colorRight);
|
|
}
|
|
|
|
|
|
/**
|
|
* Render quad 2D with gradient horizontal
|
|
*
|
|
* @param minX units from left
|
|
* @param minY units from bottom
|
|
* @param maxX quad width
|
|
* @param maxY quad height
|
|
* @param colorLeft color left
|
|
* @param colorRight color right
|
|
*/
|
|
public static void quadCoordGradH(double minX, double minY, double maxX, double maxY, RGB colorLeft, RGB colorRight)
|
|
{
|
|
glBegin(GL_QUADS);
|
|
setColor(colorLeft);
|
|
glVertex2d(minX, maxY);
|
|
setColor(colorRight);
|
|
glVertex2d(maxX, maxY);
|
|
|
|
setColor(colorRight);
|
|
glVertex2d(maxX, minY);
|
|
setColor(colorLeft);
|
|
glVertex2d(minX, minY);
|
|
glEnd();
|
|
}
|
|
|
|
|
|
/**
|
|
* Render quad 2D with gradient horizontal
|
|
*
|
|
* @param min min coord
|
|
* @param max max coord
|
|
* @param colorOuter color outer
|
|
* @param colorMiddle color inner
|
|
*/
|
|
public static void quadCoordGradHBilinear(Coord min, Coord max, RGB colorOuter, RGB colorMiddle)
|
|
{
|
|
quadCoordGradHBilinear(min.x, min.y, max.x, max.y, colorOuter, colorMiddle);
|
|
}
|
|
|
|
|
|
/**
|
|
* Render quad 2D with gradient horizontal
|
|
*
|
|
* @param minX min x
|
|
* @param minY min y
|
|
* @param maxX max x
|
|
* @param maxY max y
|
|
* @param colorOuter color outer
|
|
* @param colorMiddle color inner
|
|
*/
|
|
public static void quadCoordGradHBilinear(double minX, double minY, double maxX, double maxY, RGB colorOuter, RGB colorMiddle)
|
|
{
|
|
glBegin(GL_QUADS);
|
|
setColor(colorOuter);
|
|
glVertex2d(minX, maxY);
|
|
setColor(colorMiddle);
|
|
glVertex2d((minX + maxX) / 2, maxY);
|
|
|
|
setColor(colorMiddle);
|
|
glVertex2d((minX + maxX) / 2, minY);
|
|
setColor(colorOuter);
|
|
glVertex2d(minX, minY);
|
|
|
|
setColor(colorMiddle);
|
|
glVertex2d((minX + maxX) / 2, maxY);
|
|
setColor(colorOuter);
|
|
glVertex2d(maxX, maxY);
|
|
|
|
setColor(colorOuter);
|
|
glVertex2d(maxX, minY);
|
|
setColor(colorMiddle);
|
|
glVertex2d((minX + maxX) / 2, minY);
|
|
glEnd();
|
|
}
|
|
|
|
|
|
/**
|
|
* Render quad 2D with gradient vertical
|
|
*
|
|
* @param min min coord
|
|
* @param max max coord
|
|
* @param colorTop top color
|
|
* @param colorBottom bottom color
|
|
*/
|
|
public static void quadCoordGradV(Coord min, Coord max, RGB colorTop, RGB colorBottom)
|
|
{
|
|
quadCoordGradV(min.x, min.y, max.x, max.y, colorTop, colorBottom);
|
|
}
|
|
|
|
|
|
/**
|
|
* Render quad 2D with gradient vertical
|
|
*
|
|
* @param minX min X
|
|
* @param minY min Y
|
|
* @param maxX max X
|
|
* @param maxY max Y
|
|
* @param colorTop top color
|
|
* @param colorBottom bottom color
|
|
*/
|
|
public static void quadCoordGradV(double minX, double minY, double maxX, double maxY, RGB colorTop, RGB colorBottom)
|
|
{
|
|
glBegin(GL_QUADS);
|
|
|
|
setColor(colorTop);
|
|
glVertex2d(minX, maxY);
|
|
glVertex2d(maxX, maxY);
|
|
|
|
setColor(colorBottom);
|
|
glVertex2d(maxX, minY);
|
|
glVertex2d(minX, minY);
|
|
glEnd();
|
|
}
|
|
|
|
|
|
/**
|
|
* Render quad 2D with gradient vertical
|
|
*
|
|
* @param min min coord
|
|
* @param max max coord
|
|
* @param colorOuter outer color
|
|
* @param colorMiddle middle color
|
|
*/
|
|
public static void quadCoordGradVBilinear(Coord min, Coord max, RGB colorOuter, RGB colorMiddle)
|
|
{
|
|
quadCoordGradVBilinear(min.x, min.y, max.x, max.y, colorOuter, colorMiddle);
|
|
}
|
|
|
|
|
|
/**
|
|
* Render quad 2D with gradient vertical
|
|
*
|
|
* @param minX min X
|
|
* @param minY min Y
|
|
* @param maxX max X
|
|
* @param maxY max Y
|
|
* @param colorOuter outer color
|
|
* @param colorMiddle middle color
|
|
*/
|
|
public static void quadCoordGradVBilinear(double minX, double minY, double maxX, double maxY, RGB colorOuter, RGB colorMiddle)
|
|
{
|
|
glBegin(GL_QUADS);
|
|
|
|
setColor(colorOuter);
|
|
glVertex2d(minX, maxY);
|
|
glVertex2d(maxX, maxY);
|
|
|
|
setColor(colorMiddle);
|
|
glVertex2d(maxX, (maxY + minY) / 2);
|
|
glVertex2d(minX, (maxY + minY) / 2);
|
|
|
|
setColor(colorMiddle);
|
|
glVertex2d(minX, (maxY + minY) / 2);
|
|
glVertex2d(maxX, (maxY + minY) / 2);
|
|
|
|
setColor(colorOuter);
|
|
glVertex2d(maxX, minY);
|
|
glVertex2d(minX, minY);
|
|
|
|
glEnd();
|
|
}
|
|
|
|
|
|
/**
|
|
* Render quad with coloured border with outset effect
|
|
*
|
|
* @param min min coord
|
|
* @param max max coord
|
|
* @param border border width
|
|
* @param fill fill color
|
|
* @param inset true for inset, false for outset
|
|
*/
|
|
public static void quadCoordOutset(Coord min, Coord max, double border, RGB fill, boolean inset)
|
|
{
|
|
quadCoordOutset(min.x, min.y, max.x, max.y, border, fill, inset);
|
|
}
|
|
|
|
|
|
/**
|
|
* Render quad with coloured border with outset effect
|
|
*
|
|
* @param minX left X
|
|
* @param minY bottom Y
|
|
* @param maxX right X
|
|
* @param maxY top Y
|
|
* @param border border width
|
|
* @param fill fill color
|
|
* @param inset true for inset, false for outset
|
|
*/
|
|
public static void quadCoordOutset(double minX, double minY, double maxX, double maxY, double border, RGB fill, boolean inset)
|
|
{
|
|
HSV hsv = fill.toHSV();
|
|
HSV h;
|
|
|
|
h = hsv.copy();
|
|
h.s *= 0.6;
|
|
RGB a = h.toRGB();
|
|
|
|
h = fill.toHSV();
|
|
h.v *= 0.6;
|
|
RGB b = h.toRGB();
|
|
|
|
RGB leftTopC, rightBottomC;
|
|
|
|
if (!inset) {
|
|
leftTopC = a;
|
|
rightBottomC = b;
|
|
} else {
|
|
leftTopC = b;
|
|
rightBottomC = a;
|
|
}
|
|
|
|
double bdr = border;
|
|
|
|
RenderUtils.setColor(leftTopC);
|
|
|
|
// left + top
|
|
glBegin(GL_QUADS);
|
|
glVertex2d(minX, minY);
|
|
glVertex2d(minX + bdr, minY + bdr);
|
|
glVertex2d(minX + bdr, maxY - bdr);
|
|
glVertex2d(minX, maxY);
|
|
|
|
glVertex2d(minX, maxY);
|
|
glVertex2d(minX + bdr, maxY - bdr);
|
|
glVertex2d(maxX - bdr, maxY - bdr);
|
|
glVertex2d(maxX, maxY);
|
|
glEnd();
|
|
|
|
RenderUtils.setColor(rightBottomC);
|
|
|
|
// right + bottom
|
|
glBegin(GL_QUADS);
|
|
glVertex2d(maxX, minY);
|
|
glVertex2d(maxX, maxY);
|
|
glVertex2d(maxX - bdr, maxY - bdr);
|
|
glVertex2d(maxX - bdr, minY + bdr);
|
|
|
|
glVertex2d(minX, minY);
|
|
glVertex2d(maxX, minY);
|
|
glVertex2d(maxX - bdr, minY + bdr);
|
|
glVertex2d(minX + bdr, minY + bdr);
|
|
glEnd();
|
|
|
|
RenderUtils.setColor(fill);
|
|
RenderUtils.quadCoord(minX + bdr, minY + bdr, maxX - bdr, maxY - bdr);
|
|
}
|
|
|
|
|
|
/**
|
|
* Render quad 2D
|
|
*
|
|
* @param rect rectangle
|
|
*/
|
|
public static void quadRect(Rect rect)
|
|
{
|
|
quadCoord(rect.getMin(), rect.getMax());
|
|
}
|
|
|
|
|
|
/**
|
|
* Render quad 2D
|
|
*
|
|
* @param rect rectangle
|
|
* @param color draw color
|
|
*/
|
|
public static void quadRect(Rect rect, RGB color)
|
|
{
|
|
setColor(color);
|
|
quadCoord(rect.getMin(), rect.getMax());
|
|
}
|
|
|
|
|
|
/**
|
|
* Render quad with coloured border
|
|
*
|
|
* @param rect rect
|
|
* @param border border width
|
|
* @param borderColor border color
|
|
* @param insideColor filling color
|
|
*/
|
|
public static void quadBorder(Rect rect, double border, RGB borderColor, RGB insideColor)
|
|
{
|
|
quadCoordBorder(rect.getMin(), rect.getMax(), border, borderColor, insideColor);
|
|
}
|
|
|
|
|
|
/**
|
|
* Render quad 2D with gradient horizontal
|
|
*
|
|
* @param rect rect
|
|
* @param colorLeft color left
|
|
* @param colorRight color right
|
|
*/
|
|
public static void quadGradH(Rect rect, RGB colorLeft, RGB colorRight)
|
|
{
|
|
quadCoordGradH(rect.getMin(), rect.getMax(), colorLeft, colorRight);
|
|
}
|
|
|
|
|
|
/**
|
|
* Render quad 2D with gradient horizontal
|
|
*
|
|
* @param rect rect
|
|
* @param colorOuter color outer
|
|
* @param colorMiddle color inner
|
|
*/
|
|
public static void quadGradHBilinear(Rect rect, RGB colorOuter, RGB colorMiddle)
|
|
{
|
|
quadCoordGradHBilinear(rect.getMin(), rect.getMax(), colorOuter, colorMiddle);
|
|
}
|
|
|
|
|
|
/**
|
|
* Render quad 2D with gradient vertical
|
|
*
|
|
* @param rect rect
|
|
* @param colorTop top color
|
|
* @param colorBottom bottom color
|
|
*/
|
|
public static void quadGradV(Rect rect, RGB colorTop, RGB colorBottom)
|
|
{
|
|
quadCoordGradV(rect.getMin(), rect.getMax(), colorTop, colorBottom);
|
|
}
|
|
|
|
|
|
/**
|
|
* Render quad 2D with gradient vertical
|
|
*
|
|
* @param rect rect
|
|
* @param colorOuter outer color
|
|
* @param colorMiddle middle color
|
|
*/
|
|
public static void quadGradVBilinear(Rect rect, RGB colorOuter, RGB colorMiddle)
|
|
{
|
|
quadCoordGradVBilinear(rect.getMin(), rect.getMax(), colorOuter, colorMiddle);
|
|
}
|
|
|
|
|
|
/**
|
|
* Render quad with coloured border with outset effect
|
|
*
|
|
* @param rect rectangle
|
|
* @param border border width
|
|
* @param fill fill color
|
|
* @param inset true for inset, false for outset
|
|
*/
|
|
public static void quadRectOutset(Rect rect, double border, RGB fill, boolean inset)
|
|
{
|
|
quadCoordOutset(rect.getMin(), rect.getMax(), border, fill, inset);
|
|
}
|
|
|
|
|
|
/**
|
|
* Render textured rect (texture must be binded already)
|
|
*
|
|
* @param quad rectangle (px)
|
|
* @param textureCoords texture coords (0-1)
|
|
*/
|
|
public static void quadTexturedAbs(Rect quad, Rect textureCoords)
|
|
{
|
|
double left = quad.x1();
|
|
double bottom = quad.y2();
|
|
double right = quad.x2();
|
|
double top = quad.y1();
|
|
|
|
double tleft = textureCoords.x1();
|
|
double tbottom = textureCoords.y1();
|
|
double tright = textureCoords.x2();
|
|
double ttop = textureCoords.y2();
|
|
|
|
glBegin(GL_QUADS);
|
|
glTexCoord2d(tleft, ttop);
|
|
glVertex2d(left, top);
|
|
glTexCoord2d(tright, ttop);
|
|
glVertex2d(right, top);
|
|
glTexCoord2d(tright, tbottom);
|
|
glVertex2d(right, bottom);
|
|
glTexCoord2d(tleft, tbottom);
|
|
glVertex2d(left, bottom);
|
|
glEnd();
|
|
}
|
|
|
|
|
|
/**
|
|
* Render textured rect
|
|
*
|
|
* @param quad rectangle (px)
|
|
* @param txCoords texture coords rectangle (px)
|
|
* @param texture texture instance
|
|
*/
|
|
public static void quadTextured(Rect quad, Rect txCoords, Texture texture)
|
|
{
|
|
quadTextured(quad, txCoords, texture, RGB.WHITE);
|
|
}
|
|
|
|
|
|
/**
|
|
* Render textured rect
|
|
*
|
|
* @param quad rectangle (px)
|
|
* @param txCoords texture coords rectangle (px)
|
|
* @param texture texture instance
|
|
* @param tint color tint
|
|
*/
|
|
public static void quadTextured(Rect quad, Rect txCoords, Texture texture, RGB tint)
|
|
{
|
|
glEnable(GL_TEXTURE_2D);
|
|
setColor(tint);
|
|
TextureManager.bind(texture);
|
|
|
|
quadTexturedAbs(quad, txCoords.div(texture.getImageHeight()));
|
|
|
|
TextureManager.unbind();
|
|
glDisable(GL_TEXTURE_2D);
|
|
}
|
|
|
|
|
|
/**
|
|
* Render textured rect
|
|
*
|
|
* @param quad rectangle (px)
|
|
* @param txquad texture quad
|
|
*/
|
|
public static void quadTextured(Rect quad, TxQuad txquad)
|
|
{
|
|
quadTextured(quad, txquad, RGB.WHITE);
|
|
}
|
|
|
|
|
|
/**
|
|
* Render textured rect
|
|
*
|
|
* @param quad rectangle (px)
|
|
* @param txquad texture instance
|
|
* @param tint color tint
|
|
*/
|
|
public static void quadTextured(Rect quad, TxQuad txquad, RGB tint)
|
|
{
|
|
quadTextured(quad, txquad.uvs, txquad.tx, tint);
|
|
}
|
|
|
|
|
|
/**
|
|
* Render textured frame with borders
|
|
*
|
|
* @param quadRect drawn rectangle (px)
|
|
* @param textureRect rectangle in texture with the basic frame (px)
|
|
* @param yOffsetTimes offset count (move frame down n times)
|
|
* @param texture the texture
|
|
*/
|
|
public static void quadTexturedFrame(Rect quadRect, Rect textureRect, int yOffsetTimes, Texture texture)
|
|
{
|
|
quadTexturedFrame(quadRect, textureRect, yOffsetTimes, texture, RGB.WHITE);
|
|
}
|
|
|
|
|
|
/**
|
|
* Render textured frame with borders
|
|
*
|
|
* @param quadRect drawn rectangle (px)
|
|
* @param textureRect rectangle in texture with the basic frame (px)
|
|
* @param yOffsetTimes offset count (move frame down n times)
|
|
* @param texture the texture
|
|
* @param tint color tint
|
|
*/
|
|
public static void quadTexturedFrame(Rect quadRect, Rect textureRect, int yOffsetTimes, Texture texture, RGB tint)
|
|
{
|
|
Texture tx = texture;
|
|
|
|
int frameHeight = (int) textureRect.getSize().y;
|
|
|
|
int yOffset = yOffsetTimes * frameHeight;
|
|
|
|
double x1 = quadRect.x1();
|
|
double y1 = quadRect.y1();
|
|
double x2 = quadRect.x2();
|
|
double y2 = quadRect.y2();
|
|
|
|
double w = x2 - x1;
|
|
double h = y2 - y1;
|
|
|
|
double tx1 = textureRect.x1();
|
|
double ty1 = textureRect.y1();
|
|
double tx2 = textureRect.x2();
|
|
double ty2 = textureRect.y2();
|
|
|
|
double halfY = h / 2D;
|
|
double halfX = w / 2D;
|
|
|
|
// lt, rt
|
|
// lb, rb
|
|
|
|
Rect verts, uvs;
|
|
|
|
// lt
|
|
verts = new Rect(x1, y2, x1 + halfX, y2 - halfY);
|
|
uvs = new Rect(tx1, ty1, tx1 + halfX, ty1 + halfY);
|
|
uvs.add_ip(0, yOffset);
|
|
quadTextured(verts, uvs, tx, tint);
|
|
|
|
// lb
|
|
verts = new Rect(x1, y2 - halfY, x1 + halfX, y1);
|
|
uvs = new Rect(tx1, ty2 - halfY, tx1 + halfX, ty2);
|
|
uvs.add_ip(0, yOffset);
|
|
quadTextured(verts, uvs, tx, tint);
|
|
|
|
// rt
|
|
verts = new Rect(x1 + halfX, y2, x2, y2 - halfY);
|
|
uvs = new Rect(tx2 - halfX, ty1, tx2, ty1 + halfY);
|
|
uvs.add_ip(0, yOffset);
|
|
quadTextured(verts, uvs, tx, tint);
|
|
|
|
// rb
|
|
verts = new Rect(x1 + halfX, y2 - halfY, x2, y1);
|
|
uvs = new Rect(tx2 - halfX, ty2 - halfY, tx2, ty2);
|
|
uvs.add_ip(0, yOffset);
|
|
quadTextured(verts, uvs, tx, tint);
|
|
|
|
}
|
|
|
|
|
|
/**
|
|
* Render textured frame with borders
|
|
*
|
|
* @param quadRect drawn rectangle (px)
|
|
* @param textureRect rectangle in texture with the basic frame (px)
|
|
* @param texture the texture
|
|
*/
|
|
public static void quadTexturedFrame(Rect quadRect, Rect textureRect, Texture texture)
|
|
{
|
|
quadTexturedFrame(quadRect, textureRect, 0, texture, RGB.WHITE);
|
|
}
|
|
|
|
|
|
/**
|
|
* Render textured frame with borders
|
|
*
|
|
* @param quadRect drawn rectangle (px)
|
|
* @param txquad texture quad
|
|
*/
|
|
public static void quadTexturedFrame(Rect quadRect, TxQuad txquad)
|
|
{
|
|
quadTexturedFrame(quadRect, txquad, 0, RGB.WHITE);
|
|
}
|
|
|
|
|
|
/**
|
|
* Render textured frame with borders
|
|
*
|
|
* @param quadRect drawn rectangle (px)
|
|
* @param txquad texture quad
|
|
* @param yOffsetTimes offset count (move frame down n times)
|
|
*/
|
|
public static void quadTexturedFrame(Rect quadRect, TxQuad txquad, int yOffsetTimes)
|
|
{
|
|
quadTexturedFrame(quadRect, txquad, yOffsetTimes, RGB.WHITE);
|
|
}
|
|
|
|
|
|
/**
|
|
* Render textured frame with borders
|
|
*
|
|
* @param quadRect drawn rectangle (px)
|
|
* @param txquad texture quad
|
|
* @param yOffsetTimes offset count (move frame down n times)
|
|
* @param tint color tint
|
|
*/
|
|
public static void quadTexturedFrame(Rect quadRect, TxQuad txquad, int yOffsetTimes, RGB tint)
|
|
{
|
|
quadTexturedFrame(quadRect, txquad.uvs, yOffsetTimes, txquad.tx, tint);
|
|
}
|
|
|
|
|
|
/**
|
|
* Render textured frame stretching horizontally (rect height = texture rect
|
|
* height)
|
|
*
|
|
* @param quadRect drawn rectangle (px)
|
|
* @param textureRect rectangle in texture with the basic frame (px)
|
|
* @param borderSize size of the unstretched horizontal border
|
|
* @param texture the texture
|
|
*/
|
|
public static void quadTexturedStretchH(Rect quadRect, Rect textureRect, int borderSize, Texture texture)
|
|
{
|
|
quadTexturedStretchH(quadRect, textureRect, borderSize, texture, RGB.WHITE);
|
|
}
|
|
|
|
|
|
/**
|
|
* Render textured frame stretching horizontally (rect height = texture rect
|
|
* height)
|
|
*
|
|
* @param quadRect drawn rectangle (px)
|
|
* @param textureRect rectangle in texture with the basic frame (px)
|
|
* @param borderSize size of the unstretched horizontal border
|
|
* @param texture the texture
|
|
* @param tint color tint
|
|
*/
|
|
public static void quadTexturedStretchH(Rect quadRect, Rect textureRect, int borderSize, Texture texture, RGB tint)
|
|
{
|
|
Texture tx = texture;
|
|
|
|
double x1 = quadRect.x1();
|
|
double y1 = quadRect.y1();
|
|
double x2 = quadRect.x2();
|
|
double y2 = quadRect.y2();
|
|
|
|
double tx1 = textureRect.x1();
|
|
double ty1 = textureRect.y1();
|
|
double tx2 = textureRect.x2();
|
|
double ty2 = textureRect.y2();
|
|
|
|
// lt, mi, rt
|
|
|
|
Rect verts, uvs;
|
|
|
|
// lt
|
|
verts = new Rect(x1, y2, x1 + borderSize, y1);
|
|
uvs = new Rect(tx1, ty1, tx1 + borderSize, ty2);
|
|
quadTextured(verts, uvs, tx, tint);
|
|
|
|
// // mi
|
|
verts = new Rect(x1 + borderSize, y2, x2 - borderSize, y1);
|
|
uvs = new Rect(tx1 + borderSize, ty1, tx2 - borderSize, ty2);
|
|
quadTextured(verts, uvs, tx, tint);
|
|
|
|
// rt
|
|
verts = new Rect(x2 - borderSize, y2, x2, y1);
|
|
uvs = new Rect(tx2 - borderSize, ty1, tx2, ty2);
|
|
quadTextured(verts, uvs, tx, tint);
|
|
}
|
|
|
|
|
|
/**
|
|
* Render textured frame stretching horizontally (rect height = texture rect
|
|
* height)
|
|
*
|
|
* @param quadRect drawn rectangle (px)
|
|
* @param txquad texture quad
|
|
* @param borderSize size of the unstretched horizontal border
|
|
*/
|
|
public static void quadTexturedStretchH(Rect quadRect, TxQuad txquad, int borderSize)
|
|
{
|
|
quadTexturedStretchH(quadRect, txquad, borderSize, RGB.WHITE);
|
|
}
|
|
|
|
|
|
/**
|
|
* Render textured frame stretching horizontally (rect height = texture rect
|
|
* height)
|
|
*
|
|
* @param quadRect drawn rectangle (px)
|
|
* @param txquad texture quad
|
|
* @param borderSize size of the unstretched horizontal border
|
|
* @param tint color tint
|
|
*/
|
|
public static void quadTexturedStretchH(Rect quadRect, TxQuad txquad, int borderSize, RGB tint)
|
|
{
|
|
quadTexturedStretchH(quadRect, txquad.uvs, borderSize, txquad.tx, tint);
|
|
}
|
|
|
|
|
|
/**
|
|
* Render textured frame stretching vertically (rect width = texture rect
|
|
* width)
|
|
*
|
|
* @param quadRect drawn rectangle (px)
|
|
* @param textureRect rectangle in texture with the basic frame (px)
|
|
* @param borderSize size of the unstretched horizontal border
|
|
* @param texture the texture
|
|
*/
|
|
public static void quadTexturedStretchV(Rect quadRect, Rect textureRect, int borderSize, Texture texture)
|
|
{
|
|
quadTexturedStretchV(quadRect, textureRect, borderSize, texture, RGB.WHITE);
|
|
}
|
|
|
|
|
|
/**
|
|
* Render textured frame stretching vertically (rect width = texture rect
|
|
* width)
|
|
*
|
|
* @param quadRect drawn rectangle (px)
|
|
* @param textureRect rectangle in texture with the basic frame (px)
|
|
* @param borderSize size of the unstretched horizontal border
|
|
* @param texture the texture
|
|
* @param tint color tint
|
|
*/
|
|
public static void quadTexturedStretchV(Rect quadRect, Rect textureRect, int borderSize, Texture texture, RGB tint)
|
|
{
|
|
Texture tx = texture;
|
|
|
|
double x1 = quadRect.x1();
|
|
double y1 = quadRect.y1();
|
|
double x2 = quadRect.x2();
|
|
double y2 = quadRect.y2();
|
|
|
|
double tx1 = textureRect.x1();
|
|
double ty1 = textureRect.y1();
|
|
double tx2 = textureRect.x2();
|
|
double ty2 = textureRect.y2();
|
|
|
|
// tp
|
|
// mi
|
|
// bn
|
|
|
|
Rect verts, uvs;
|
|
|
|
// tp
|
|
verts = new Rect(x1, y2, x2, y2 - borderSize);
|
|
uvs = new Rect(tx1, ty1, tx2, ty1 + borderSize);
|
|
quadTextured(verts, uvs, tx, tint);
|
|
|
|
// mi
|
|
verts = new Rect(x1, y2 - borderSize, x2, y1 + borderSize);
|
|
uvs = new Rect(tx1, ty1 + borderSize, tx2, ty2 - borderSize);
|
|
quadTextured(verts, uvs, tx, tint);
|
|
|
|
// rt
|
|
verts = new Rect(x1, y1 + borderSize, x2, y1);
|
|
uvs = new Rect(tx1, ty2 - borderSize, tx2, ty2);
|
|
quadTextured(verts, uvs, tx, tint);
|
|
}
|
|
|
|
|
|
/**
|
|
* Render textured frame stretching vertically (rect width = texture rect
|
|
* width)
|
|
*
|
|
* @param quadRect drawn rectangle (px)
|
|
* @param txquad texture quad
|
|
* @param borderSize size of the unstretched horizontal border
|
|
*/
|
|
public static void quadTexturedStretchV(Rect quadRect, TxQuad txquad, int borderSize)
|
|
{
|
|
quadTexturedStretchV(quadRect, txquad, borderSize, RGB.WHITE);
|
|
}
|
|
|
|
|
|
/**
|
|
* Render textured frame stretching vertically (rect width = texture rect
|
|
* width)
|
|
*
|
|
* @param quadRect drawn rectangle (px)
|
|
* @param txquad texture quad
|
|
* @param borderSize size of the unstretched horizontal border
|
|
* @param tint color tint
|
|
*/
|
|
public static void quadTexturedStretchV(Rect quadRect, TxQuad txquad, int borderSize, RGB tint)
|
|
{
|
|
quadTexturedStretchV(quadRect, txquad.uvs, borderSize, txquad.tx, tint);
|
|
|
|
}
|
|
|
|
|
|
/**
|
|
* Render quad 2D
|
|
*
|
|
* @param left units from left
|
|
* @param bottom units from bottom
|
|
* @param width quad width
|
|
* @param height quad height
|
|
*/
|
|
public static void quadSize(double left, double bottom, double width, double height)
|
|
{
|
|
glBegin(GL_QUADS);
|
|
glVertex2d(left, bottom + height);
|
|
glVertex2d(left + width, bottom + height);
|
|
glVertex2d(left + width, bottom);
|
|
glVertex2d(left, bottom);
|
|
glEnd();
|
|
}
|
|
|
|
|
|
/**
|
|
* Bind GL color
|
|
*
|
|
* @param color RGB color
|
|
*/
|
|
public static void setColor(RGB color)
|
|
{
|
|
if (color != null) glColor4d(color.r, color.g, color.b, color.a);
|
|
}
|
|
|
|
|
|
/**
|
|
* Bind GL color
|
|
*
|
|
* @param color RGB color
|
|
* @param alpha alpha multiplier
|
|
*/
|
|
public static void setColor(RGB color, double alpha)
|
|
{
|
|
if (color != null) glColor4d(color.r, color.g, color.b, color.a * alpha);
|
|
}
|
|
|
|
|
|
/**
|
|
* Translate with coord
|
|
*
|
|
* @param coord coord
|
|
*/
|
|
public static void translate(Coord coord)
|
|
{
|
|
glTranslated(coord.x, coord.y, coord.z);
|
|
}
|
|
}
|
|
|