Java Glyph类代码示例

import com.badlogic.gdx.graphics.g2d.BitmapFont.Glyph; //导入依赖的package包/类
/** Called when a glyph is freed to clear the state of the glyph for possible later reuse. */
static void reset (Glyph glyph) {
	glyph.id = 0;
	glyph.srcX = 0;
	glyph.srcY = 0;
	glyph.width = 0;
	glyph.height = 0;
	glyph.u = 0;
	glyph.v = 0;
	glyph.u2 = 0;
	glyph.v2 = 0;
	glyph.xoffset = 0;
	glyph.yoffset = 0;
	glyph.xadvance = 0;
	glyph.kerning = null;
	glyph.fixedWidth = false;
}
 

import com.badlogic.gdx.graphics.g2d.BitmapFont.Glyph; //导入依赖的package包/类
/** Copies all contents from the first glyph to the second one. */
static void clone (Glyph from, Glyph to) {
	to.id = from.id;
	to.srcX = from.srcX;
	to.srcY = from.srcY;
	to.width = from.width;
	to.height = from.height;
	to.u = from.u;
	to.v = from.v;
	to.u2 = from.u2;
	to.v2 = from.v2;
	to.xoffset = from.xoffset;
	to.yoffset = from.yoffset;
	to.xadvance = from.xadvance;
	to.kerning = from.kerning; // Keep the same instance, there's no reason to deep clone it
	to.fixedWidth = from.fixedWidth;
}
 

import com.badlogic.gdx.graphics.g2d.BitmapFont.Glyph; //导入依赖的package包/类
@Override
protected void onApply (Glyph glyph, int localIndex) {
	// Calculate progress
	float progressModifier = (1f / intensity) * DEFAULT_INTENSITY;
	float normalFrequency = (1f / frequency) * DEFAULT_FREQUENCY;
	float progressOffset = localIndex / normalFrequency;
	float progress = calculateProgress(progressModifier, progressOffset);

	// Calculate offset
	float y = getLineHeight() * distance * Interpolation.sine.apply(-1, 1, progress) * DEFAULT_DISTANCE;

	// Calculate fadeout
	float fadeout = calculateFadeout();
	y *= fadeout;

	// Apply changes
	glyph.yoffset += y;
}
 

import com.badlogic.gdx.graphics.g2d.BitmapFont.Glyph; //导入依赖的package包/类
@Override
protected void onApply (Glyph glyph, int localIndex) {
	// Calculate progress
	float progressModifier = (1f / intensity) * DEFAULT_INTENSITY;
	float normalFrequency = (1f / frequency) * DEFAULT_FREQUENCY;
	float progressOffset = localIndex / normalFrequency;
	float progress = calculateProgress(progressModifier, -progressOffset, false);

	// Calculate offset
	float interpolation = 0;
	float split = 0.2f;
	if (progress < split) {
		interpolation = Interpolation.pow2Out.apply(0, 1, progress / split);
	} else {
		interpolation = Interpolation.bounceOut.apply(1, 0, (progress - split) / (1f - split));
	}
	float y = getLineHeight() * distance * interpolation * DEFAULT_DISTANCE;

	// Calculate fadeout
	float fadeout = calculateFadeout();
	y *= fadeout;

	// Apply changes
	glyph.yoffset += y;
}
 

import com.badlogic.gdx.graphics.g2d.BitmapFont.Glyph; //导入依赖的package包/类
/** Adds cached glyphs to the active BitmapFontCache as the char index progresses. */
private void addMissingGlyphs () {
	// Add additional glyphs to layout array, if any
	int glyphLeft = glyphCharIndex - cachedGlyphCharIndex;
	if (glyphLeft < 1) return;

	// Get runs
	GlyphLayout layout = super.getGlyphLayout();
	Array<GlyphRun> runs = layout.runs;

	// Iterate through GlyphRuns to find the next glyph spot
	int glyphCount = 0;
	for (int runIndex = 0; runIndex < glyphRunCapacities.size; runIndex++) {
		int runCapacity = glyphRunCapacities.get(runIndex);
		if ((glyphCount + runCapacity) < cachedGlyphCharIndex) {
			glyphCount += runCapacity;
			continue;
		}

		// Get run and increase glyphCount up to its current size
		Array<Glyph> glyphs = runs.get(runIndex).glyphs;
		glyphCount += glyphs.size;

		// Next glyphs go here
		while (glyphLeft > 0) {

			// Skip run if this one is full
			int runSize = glyphs.size;
			if (runCapacity == runSize) {
				break;
			}

			// Put new glyph to this run
			cachedGlyphCharIndex++;
			glyphCount++;
			glyphLeft--;
			glyphs.add(glyphCache.get(cachedGlyphCharIndex));
		}
	}
}
 

import com.badlogic.gdx.graphics.g2d.BitmapFont.Glyph; //导入依赖的package包/类
@Override
protected void onApply (Glyph glyph, int localIndex) {
	// Make sure we can hold enough entries for the current index
	if (localIndex >= lastOffsets.size / 2) {
		lastOffsets.setSize(lastOffsets.size + 16);
	}

	// Get last offsets
	float lastX = lastOffsets.get(localIndex * 2);
	float lastY = lastOffsets.get(localIndex * 2 + 1);

	// Calculate new offsets
	float x = getLineHeight() * distance * MathUtils.random(-1, 1) * DEFAULT_DISTANCE;
	float y = getLineHeight() * distance * MathUtils.random(-1, 1) * DEFAULT_DISTANCE;

	// Apply intensity
	float normalIntensity = MathUtils.clamp(intensity * DEFAULT_INTENSITY, 0, 1);
	x = Interpolation.linear.apply(lastX, x, normalIntensity);
	y = Interpolation.linear.apply(lastY, y, normalIntensity);

	// Apply fadeout
	float fadeout = calculateFadeout();
	x *= fadeout;
	y *= fadeout;
	x = Math.round(x);
	y = Math.round(y);

	// Store offsets for the next tick
	lastOffsets.set(localIndex * 2, x);
	lastOffsets.set(localIndex * 2 + 1, y);

	// Apply changes
	glyph.xoffset += x;
	glyph.yoffset += y;
}
 

import com.badlogic.gdx.graphics.g2d.BitmapFont.Glyph; //导入依赖的package包/类
@Override
public Glyph getGlyph (char ch) {
	Glyph glyph = super.getGlyph(ch);
	if ((glyph == null || glyph == missingGlyph) && generators.size > 0) {
              for (int i = 0; i < generators.size; i++) {
                  FreeTypeFontGenerator generator = generators.get(i);
                  glyph = getGlyph(ch, generator);
                  if (glyph != null && glyph != missingGlyph) break;
              }
	}
	if (glyph == null) {
	    glyph = missingGlyph;
          }
	return glyph;
}
 

import com.badlogic.gdx.graphics.g2d.BitmapFont.Glyph; //导入依赖的package包/类
/** Ugly code needed because Array uses an unchecked cast from Object[] to T[] */
private static void setGlyphs(Array<Glyph> array, Object[] newGlyphs) {
    array.clear();
    for (Object obj : newGlyphs) {
        array.add((Glyph)obj);
    }
}
 

import com.badlogic.gdx.graphics.g2d.BitmapFont.Glyph; //导入依赖的package包/类
@Override
public float getKerning(int glyphId) {
    if (glyphCount == 0) {
        return 0f;
    } else if (glyphId != (char)glyphId) {
        return 0f; // libGDX Glyph.getKerning uses char instead of int
    }

    Glyph finalGlyph = getGlyph(glyphLayout, glyphCount - 1);
    int kerning = finalGlyph.getKerning((char)glyphId);
    return scaleXY * kerning;
}
 

import com.badlogic.gdx.graphics.g2d.BitmapFont.Glyph; //导入依赖的package包/类
private static Glyph getGlyph(GlyphLayout layout, int index) {
    int offset = 0;
    for (GlyphRun run : layout.runs) {
        if (index < offset) {
            break;
        }
        if (index - offset < run.glyphs.size) {
            return run.glyphs.get(index - offset);
        }
        offset += run.glyphs.size;
    }
    throw new ArrayIndexOutOfBoundsException(index);
}
 

import com.badlogic.gdx.graphics.g2d.BitmapFont.Glyph; //导入依赖的package包/类
private void requireSequence (CharSequence seq, int start, int end) {
	if (vertexData.length == 1) {
		// don't scan sequence if we just have one page and markup is disabled
		int newGlyphCount = font.markupEnabled ? countGlyphs(seq, start, end) : end - start;
		require(0, newGlyphCount);
	} else {
		for (int i = 0, n = tmpGlyphCount.length; i < n; i++)
			tmpGlyphCount[i] = 0;

		// determine # of glyphs in each page
		while (start < end) {
			char ch = seq.charAt(start++);
			if (ch == '[' && font.markupEnabled) {
				if (!(start < end && seq.charAt(start) == '[')) { // non escaped '['
					while (start < end && seq.charAt(start) != ']')
						start++;
					start++;
					continue;
				}
				start++;
			}
			Glyph g = font.data.getGlyph(ch);
			if (g == null) continue;
			tmpGlyphCount[g.page]++;
		}
		// require that many for each page
		for (int i = 0, n = tmpGlyphCount.length; i < n; i++)
			require(i, tmpGlyphCount[i]);
	}
}
 

import com.badlogic.gdx.graphics.g2d.BitmapFont.Glyph; //导入依赖的package包/类
/** Returns a glyph from this pool. The glyph may be new (from {@link Pool#newObject()}) or reused (previously
 * {@link Pool#free(Object) freed}). */
static Glyph obtain () {
	return pool.obtain();
}
 

import com.badlogic.gdx.graphics.g2d.BitmapFont.Glyph; //导入依赖的package包/类
/** Returns a glyph from this pool and clones it from the given one. The glyph may be new (from {@link Pool#newObject()}) or
 * reused (previously {@link Pool#free(Object) freed}). */
static Glyph obtainClone (Glyph from) {
	Glyph glyph = pool.obtain();
	clone(from, glyph);
	return glyph;
}
 

import com.badlogic.gdx.graphics.g2d.BitmapFont.Glyph; //导入依赖的package包/类
/** Puts the specified glyph in the pool, making it eligible to be returned by {@link #obtain()}. If the pool already contains
 * {@link #max} free glyphs, the specified glyph is reset but not added to the pool. */
static void free (Glyph glyph) {
	pool.free(glyph);
}
 

import com.badlogic.gdx.graphics.g2d.BitmapFont.Glyph; //导入依赖的package包/类
/** Puts the specified glyphs in the pool. Null glyphs within the array are silently ignored.
 * @see #free(Object) */
static void freeAll (Array<Glyph> glyphs) {
	pool.freeAll(glyphs);
}