com.github.mathiewz.slick.font.GlyphPage Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of modernized-slick Show documentation
Show all versions of modernized-slick Show documentation
The main purpose of this libraryis to modernize and maintain the slick2D library.
The newest version!
package com.github.mathiewz.slick.font;
import java.awt.AlphaComposite;
import java.awt.Graphics2D;
import java.awt.RenderingHints;
import java.awt.font.FontRenderContext;
import java.awt.image.BufferedImage;
import java.awt.image.WritableRaster;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.nio.IntBuffer;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
import java.util.NoSuchElementException;
import org.lwjgl.opengl.GL11;
import org.lwjgl.opengl.GL12;
import com.github.mathiewz.slick.Color;
import com.github.mathiewz.slick.Image;
import com.github.mathiewz.slick.UnicodeFont;
import com.github.mathiewz.slick.opengl.TextureImpl;
import com.github.mathiewz.slick.opengl.renderer.Renderer;
import com.github.mathiewz.slick.opengl.renderer.SGL;
/**
* Stores a number of glyphs on a single texture.
*
* @author Nathan Sweet
*/
public class GlyphPage {
/** The interface to OpenGL */
private static final SGL GL = Renderer.get();
/** The maxium size of an individual glyph */
public static final int MAX_GLYPH_SIZE = 256;
/** A temporary working buffer */
private static ByteBuffer scratchByteBuffer = ByteBuffer.allocateDirect(MAX_GLYPH_SIZE * MAX_GLYPH_SIZE * 4);
static {
scratchByteBuffer.order(ByteOrder.LITTLE_ENDIAN);
}
/** A temporary working buffer */
private static IntBuffer scratchIntBuffer = scratchByteBuffer.asIntBuffer();
/** A temporary image used to generate the glyph page */
private static BufferedImage scratchImage = new BufferedImage(MAX_GLYPH_SIZE, MAX_GLYPH_SIZE, BufferedImage.TYPE_INT_ARGB);
/** The graphics context form the temporary image */
private static Graphics2D scratchGraphics = (Graphics2D) scratchImage.getGraphics();
static {
scratchGraphics.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
scratchGraphics.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_ON);
scratchGraphics.setRenderingHint(RenderingHints.KEY_FRACTIONALMETRICS, RenderingHints.VALUE_FRACTIONALMETRICS_ON);
}
/** The render context in which the glyphs will be generated */
public static final FontRenderContext RENDER_CONTEXT = scratchGraphics.getFontRenderContext();
/**
* Get the scratch graphics used to generate the page of glyphs
*
* @return The scratch graphics used to build the page
*/
public static Graphics2D getScratchGraphics() {
return scratchGraphics;
}
/** The font this page is part of */
private final UnicodeFont unicodeFont;
/** The width of this page's image */
private final int pageWidth;
/** The height of this page's image */
private final int pageHeight;
/** The image containing the glyphs */
private final Image pageImage;
/** The x position of the page */
private int pageX;
/** The y position of the page */
private int pageY;
/** The height of the last row on the page */
private int rowHeight;
/** True if the glyphs are ordered */
private boolean orderAscending;
/** The list of glyphs on this page */
private final List pageGlyphs = new ArrayList<>(32);
/**
* Create a new page of glyphs
*
* @param unicodeFont
* The font this page forms part of
* @param pageWidth
* The width of the backing texture.
* @param pageHeight
* The height of the backing texture.
*/
public GlyphPage(UnicodeFont unicodeFont, int pageWidth, int pageHeight) {
this.unicodeFont = unicodeFont;
this.pageWidth = pageWidth;
this.pageHeight = pageHeight;
pageImage = new Image(pageWidth, pageHeight);
}
/**
* Loads glyphs to the backing texture and sets the image on each loaded glyph. Loaded glyphs are removed from the list.
*
* If this page already has glyphs and maxGlyphsToLoad is -1, then this method will return 0 if all the new glyphs don't fit.
* This reduces texture binds when drawing since glyphs loaded at once are typically displayed together.
*
* @param glyphs
* The glyphs to load.
* @param maxGlyphsToLoad
* This is the maximum number of glyphs to load from the list. Set to -1 to attempt to load all the
* glyphs.
* @return The number of glyphs that were actually loaded.
*/
public int loadGlyphs(List glyphs, int maxGlyphsToLoad) {
if (rowHeight != 0 && maxGlyphsToLoad == -1) {
// If this page has glyphs and we are not loading incrementally, return zero if any of the glyphs don't fit.
int testX = pageX;
int testY = pageY;
int testRowHeight = rowHeight;
for (Iterator iter = getIterator(glyphs); iter.hasNext();) {
Glyph glyph = iter.next();
int width = glyph.getWidth();
int height = glyph.getHeight();
if (testX + width >= pageWidth) {
testX = 0;
testY += testRowHeight;
testRowHeight = height;
} else if (height > testRowHeight) {
testRowHeight = height;
}
if (testY + testRowHeight >= pageWidth) {
return 0;
}
testX += width;
}
}
Color.white.bind();
pageImage.bind();
int i = 0;
for (Iterator iter = getIterator(glyphs); iter.hasNext();) {
Glyph glyph = iter.next();
int width = Math.min(MAX_GLYPH_SIZE, glyph.getWidth());
int height = Math.min(MAX_GLYPH_SIZE, glyph.getHeight());
if (rowHeight == 0) {
// The first glyph always fits.
rowHeight = height;
} else if (pageX + width >= pageWidth) {
if (pageY + rowHeight + height >= pageHeight) {
break;
}
pageX = 0;
pageY += rowHeight;
rowHeight = height;
} else if (height > rowHeight) {
if (pageY + height >= pageHeight) {
break;
}
rowHeight = height;
}
renderGlyph(glyph, width, height);
pageGlyphs.add(glyph);
pageX += width;
iter.remove();
i++;
if (i == maxGlyphsToLoad) {
// If loading incrementally, flip orderAscending so it won't change, since we'll probably load the rest next time.
orderAscending = !orderAscending;
break;
}
}
TextureImpl.bindNone();
// Every other batch of glyphs added to a page are sorted the opposite way to attempt to keep same size glyps together.
orderAscending = !orderAscending;
return i;
}
/**
* Loads a single glyph to the backing texture, if it fits.
*
* @param glyph
* The glyph to be rendered
* @param width
* The expected width of the glyph
* @param height
* The expected height of the glyph
*/
private void renderGlyph(Glyph glyph, int width, int height) {
// Draw the glyph to the scratch image using Java2D.
scratchGraphics.setComposite(AlphaComposite.Clear);
scratchGraphics.fillRect(0, 0, MAX_GLYPH_SIZE, MAX_GLYPH_SIZE);
scratchGraphics.setComposite(AlphaComposite.SrcOver);
scratchGraphics.setColor(java.awt.Color.white);
unicodeFont.getEffects().forEach(effect -> effect.draw(scratchImage, scratchGraphics, unicodeFont, glyph));
glyph.setShape(null); // The shape will never be needed again.
WritableRaster raster = scratchImage.getRaster();
int[] row = new int[width];
for (int y = 0; y < height; y++) {
raster.getDataElements(0, y, width, 1, row);
scratchIntBuffer.put(row);
}
GL.glTexSubImage2D(GL11.GL_TEXTURE_2D, 0, pageX, pageY, width, height, GL12.GL_BGRA, GL11.GL_UNSIGNED_BYTE, scratchByteBuffer);
scratchIntBuffer.clear();
glyph.setImage(pageImage.getSubImage(pageX, pageY, width, height));
}
/**
* Returns an iterator for the specified glyphs, sorted either ascending or descending.
*
* @param glyphs
* The glyphs to return if present
* @return An iterator of the sorted list of glyphs
*/
private Iterator getIterator(List glyphs) {
if (orderAscending) {
return glyphs.iterator();
}
final ListIterator iter = glyphs.listIterator(glyphs.size());
return new Iterator() {
@Override
public boolean hasNext() {
return iter.hasPrevious();
}
@Override
public Glyph next() {
if (!hasNext()) {
throw new NoSuchElementException();
}
return iter.previous();
}
@Override
public void remove() {
iter.remove();
}
};
}
/**
* Returns the glyphs stored on this page.
*
* @return A list of {@link Glyph} elements on this page
*/
public List getGlyphs() {
return pageGlyphs;
}
/**
* Returns the backing texture for this page.
*
* @return The image of this page of glyphs
*/
public Image getImage() {
return pageImage;
}
}