public void drawMesh(
BasicTexture tex, int x, int y, int xyBuffer, int uvBuffer, int indexBuffer, int indexCount) {
float alpha = mAlpha;
if (!bindTexture(tex)) return;
mGLState.setBlendEnabled(mBlendEnabled && (!tex.isOpaque() || alpha < OPAQUE_ALPHA));
mGLState.setTextureAlpha(alpha);
// Reset the texture matrix. We will set our own texture coordinates
// below.
setTextureCoords(0, 0, 1, 1);
saveTransform();
translate(x, y);
mGL.glLoadMatrixf(mMatrixValues, 0);
mGL.glBindBuffer(GL11.GL_ARRAY_BUFFER, xyBuffer);
mGL.glVertexPointer(2, GL11.GL_FLOAT, 0, 0);
mGL.glBindBuffer(GL11.GL_ARRAY_BUFFER, uvBuffer);
mGL.glTexCoordPointer(2, GL11.GL_FLOAT, 0, 0);
mGL.glBindBuffer(GL11.GL_ELEMENT_ARRAY_BUFFER, indexBuffer);
mGL.glDrawElements(GL11.GL_TRIANGLE_STRIP, indexCount, GL11.GL_UNSIGNED_BYTE, 0);
mGL.glBindBuffer(GL11.GL_ARRAY_BUFFER, mBoxCoords);
mGL.glVertexPointer(2, GL11.GL_FLOAT, 0, 0);
mGL.glTexCoordPointer(2, GL11.GL_FLOAT, 0, 0);
restoreTransform();
mCountDrawMesh++;
}
public void drawTexture(
BasicTexture texture, float[] mTextureTransform, int x, int y, int w, int h) {
mGLState.setBlendEnabled(mBlendEnabled && (!texture.isOpaque() || mAlpha < OPAQUE_ALPHA));
if (!bindTexture(texture)) return;
setTextureCoords(mTextureTransform);
mGLState.setTextureAlpha(mAlpha);
textureRect(x, y, w, h);
}
/**
* Bind VBO for a simple quad. Handy for simple custom RenderLayers Vertices: float[]{ -1, -1, -1,
* 1, 1, -1, 1, 1 }
*
* <p>GL.drawArrays(GL20.TRIANGLE_STRIP, 0, 4);
*/
public static void bindQuadVertexVBO(int location) {
if (location >= 0) {
GLState.bindVertexBuffer(mQuadVerticesID);
GLState.enableVertexArrays(location, -1);
gl.vertexAttribPointer(location, 2, GL.FLOAT, false, 0, 0);
}
}
private void drawTexture(BasicTexture texture, int x, int y, int width, int height, float alpha) {
if (width <= 0 || height <= 0) return;
mGLState.setBlendEnabled(mBlendEnabled && (!texture.isOpaque() || alpha < OPAQUE_ALPHA));
if (!bindTexture(texture)) return;
mGLState.setTextureAlpha(alpha);
drawBoundTexture(texture, x, y, width, height);
}
private static GLState stfor(Tex tex, int z, boolean clip) {
TexGL gt;
if (tex instanceof TexGL) gt = (TexGL) tex;
else if ((tex instanceof TexSI) && (((TexSI) tex).parent instanceof TexGL))
gt = (TexGL) ((TexSI) tex).parent;
else throw (new RuntimeException("Cannot use texture for ground-tile rendering: " + tex));
GLState ret;
if (clip)
ret = GLState.compose(Light.deflight, gcol, gt.draw(), gt.clip(), new MapMesh.MLOrder(z));
else ret = GLState.compose(Light.deflight, gcol, gt.draw(), new MapMesh.MLOrder(z));
return (ret);
}
private void createGLState() {
if (_projectionFeature == null) {
_projectionFeature = new ProjectionGLFeature(_projectionMatrix.asMatrix44D());
_glState.addGLFeature(_projectionFeature, false);
} else {
_projectionFeature.setMatrix(_projectionMatrix.asMatrix44D());
}
if (_modelFeature == null) {
_modelFeature = new ModelGLFeature(_modelviewMatrix.asMatrix44D());
_glState.addGLFeature(_modelFeature, false);
} else {
_modelFeature.setMatrix(_modelviewMatrix.asMatrix44D());
}
}
public void add(Rendered r, GLState t) {
if (curp == null) throw (new RuntimeException("Tried to set up relative slot with no parent"));
Object seq = null;
Buffer cos = null;
if ((t == null) && (curp.statroot == null)) {
seq = r.staticp();
curp.cs.copye(cos = new Buffer(cfg), GLState.Slot.Type.SYS);
Cached c;
if ((seq != null) && ((c = prevcache.get(new Cached(r, seq, cos, false))) != null)) {
prevcache.remove(c);
newcache.put(c, c);
add(c, curp.cs);
return;
}
}
Slot s = getslot();
curp.cs.copy(s.os);
if (t != null) t.prep(s.os);
s.os.copy(s.cs);
if (curp.statroot != null) {
s.statroot = curp.statroot;
} else if (seq != null) {
s.statroot = new Cached(r, seq, cos);
}
setup(s, r);
}
public void drawTexture(BasicTexture texture, RectF source, RectF target) {
if (target.width() <= 0 || target.height() <= 0) return;
// Copy the input to avoid changing it.
mDrawTextureSourceRect.set(source);
mDrawTextureTargetRect.set(target);
source = mDrawTextureSourceRect;
target = mDrawTextureTargetRect;
mGLState.setBlendEnabled(mBlendEnabled && (!texture.isOpaque() || mAlpha < OPAQUE_ALPHA));
if (!bindTexture(texture)) return;
convertCoordinate(source, target, texture);
setTextureCoords(source);
mGLState.setTextureAlpha(mAlpha);
textureRect(target.left, target.top, target.width(), target.height());
}
public void drawRect(float x, float y, float width, float height, GLPaint paint) {
GL11 gl = mGL;
mGLState.setColorMode(paint.getColor(), mAlpha);
mGLState.setLineWidth(paint.getLineWidth());
saveTransform();
translate(x, y);
scale(width, height, 1);
gl.glLoadMatrixf(mMatrixValues, 0);
gl.glDrawArrays(GL11.GL_LINE_LOOP, OFFSET_DRAW_RECT, 4);
restoreTransform();
mCountDrawLine++;
}
private boolean bindTexture(BasicTexture texture) {
if (!texture.onBind(this)) return false;
int target = texture.getTarget();
mGLState.setTextureTarget(target);
mGL.glBindTexture(target, texture.getId());
return true;
}
public void drawLine(float x1, float y1, float x2, float y2, GLPaint paint) {
GL11 gl = mGL;
mGLState.setColorMode(paint.getColor(), mAlpha);
mGLState.setLineWidth(paint.getLineWidth());
saveTransform();
translate(x1, y1);
scale(x2 - x1, y2 - y1, 1);
gl.glLoadMatrixf(mMatrixValues, 0);
gl.glDrawArrays(GL11.GL_LINE_STRIP, OFFSET_DRAW_LINE, 2);
restoreTransform();
mCountDrawLine++;
}
private Equ(ED ed) {
this.desc = ed.clone();
this.id = desc.id;
GLState bt = null;
if (bt == null) {
Skeleton.BoneOffset bo = ed.res.res.get().layer(Skeleton.BoneOffset.class, ed.at);
if (bo != null) bt = bo.forpose(pose);
}
if ((bt == null) && (skel instanceof Skeleton.ResourceSkeleton)) {
Skeleton.BoneOffset bo =
((Skeleton.ResourceSkeleton) skel).res.layer(Skeleton.BoneOffset.class, ed.at);
if (bo != null) bt = bo.forpose(pose);
}
if (bt == null) {
Skeleton.Bone bone = skel.bones.get(ed.at);
if (bone != null) bt = pose.bonetrans(bone.idx);
}
if (bt == null)
throw (new RuntimeException(
"Transformation "
+ ed.at
+ " for equipment "
+ ed.res
+ " on skeleton "
+ skel
+ " could not be resolved"));
if ((ed.off.x != 0.0f) || (ed.off.y != 0.0f) || (ed.off.z != 0.0f))
this.et = GLState.compose(bt, Location.xlate(ed.off));
else this.et = bt;
}
public void fillRect(float x, float y, float width, float height, int color) {
mGLState.setColorMode(color, mAlpha);
GL11 gl = mGL;
saveTransform();
translate(x, y);
scale(width, height, 1);
gl.glLoadMatrixf(mMatrixValues, 0);
gl.glDrawArrays(GL11.GL_TRIANGLE_STRIP, OFFSET_FILL_RECT, 4);
restoreTransform();
mCountFillRect++;
}
private void draw() {
GLState.setClearColor(mClearColor);
gl.depthMask(true);
gl.stencilMask(0xFF);
gl.clear(GL.COLOR_BUFFER_BIT | GL.DEPTH_BUFFER_BIT | GL.STENCIL_BUFFER_BIT);
gl.depthMask(false);
gl.stencilMask(0);
GLState.test(false, false);
GLState.blend(false);
GLState.bindTex2D(-1);
GLState.useProgram(-1);
GLState.bindElementBuffer(-1);
GLState.bindVertexBuffer(-1);
mViewport.setFrom(mMap);
if (GLAdapter.debugView) {
/* modify this to scale only the view, to see
* which tiles are rendered */
mViewport.mvp.setScale(0.5f, 0.5f, 1);
mViewport.viewproj.multiplyLhs(mViewport.mvp);
mViewport.proj.multiplyLhs(mViewport.mvp);
}
/* update layers */
LayerRenderer[] layers = mMap.layers().getLayerRenderer();
for (int i = 0, n = layers.length; i < n; i++) {
LayerRenderer renderer = layers[i];
if (!renderer.isInitialized) {
renderer.setup();
renderer.isInitialized = true;
}
renderer.update(mViewport);
if (renderer.isReady) renderer.render(mViewport);
if (GLAdapter.debug) GLUtils.checkGlError(renderer.getClass().getName());
}
if (GLUtils.checkGlOutOfMemory("finish")) {
BufferObject.checkBufferUsage(true);
// FIXME also throw out some textures etc
}
}
public void onSurfaceCreated() {
// log.debug(GL.getString(GL20.EXTENSIONS));
String vendor = gl.getString(GL.VENDOR);
String renderer = gl.getString(GL.RENDERER);
String version = gl.getString(GL.VERSION);
log.debug("{}/{}/{}", vendor, renderer, version);
// Prevent issue with Adreno 3xx series
if (renderer != null && renderer.startsWith("Adreno (TM) 3")) {
log.debug("==> not using glBufferSubData");
GLAdapter.NO_BUFFER_SUB_DATA = true;
}
GLState.init();
// Set up some vertex buffer objects
BufferObject.init(200);
// classes that require GL context for initialization
RenderBuckets.initRenderer();
mNewSurface = true;
}
private void instancify() {
if (!cfg.pref.instancing.val) return;
List<Buffer> instbuf = new ArrayList<Buffer>();
int i = 0;
while ((i < cur) && list[i].d) {
Slot s = list[i];
int o = i + 1;
tryinst:
{
/* XXX: How to handle eyeorder and similar things is... tricky. This is an ugly hack. Please replace. */
if (!(s.r instanceof Rendered.Instanced)
|| (s.os.get(Rendered.order) instanceof Rendered.EyeOrder)) break tryinst;
boolean copy = (s.statroot != null);
instbuf.clear();
instbuf.add(copy ? s.os.copy() : s.os);
for (; (o < cur) && list[o].d; o++) {
Slot t = list[o];
if ((t.r != s.r)
|| (t.statroot != s.statroot)
|| (t.ihash != s.ihash)
|| !s.os.iequals(t.os)) break;
instbuf.add(copy ? t.os.copy() : t.os);
}
if (o - i < INSTANCE_THRESHOLD) break tryinst;
Rendered ir = ((Rendered.Instanced) s.r).instanced(cfg, instbuf);
if (ir == null) break tryinst;
Buffer ist = GLState.inststate(cfg, instbuf);
if (ist == null) break tryinst;
s.r = ir;
s.os = ist;
s.instnum = instbuf.size();
for (int u = i + 1; u < o; u++) list[u].skip = true;
if (ir instanceof Disposable) s.disp = (Disposable) ir;
}
i = o;
}
}
public void onSurfaceChanged(int width, int height) {
// log.debug("onSurfaceChanged: new={}, {}x{}", mNewSurface, width, height);
if (width <= 0 || height <= 0) return;
gl.viewport(0, 0, width, height);
// GL.scissor(0, 0, width, height);
// GL.enable(GL20.SCISSOR_TEST);
gl.clearStencil(0x00);
gl.disable(GL.CULL_FACE);
gl.blendFunc(GL.ONE, GL.ONE_MINUS_SRC_ALPHA);
gl.frontFace(GL.CW);
gl.cullFace(GL.BACK);
if (!mNewSurface) {
mMap.updateMap(false);
return;
}
mNewSurface = false;
/** initialize quad indices used by Texture- and LineTexRenderer */
int[] vboIds = GLUtils.glGenBuffers(2);
mQuadIndicesID = vboIds[0];
short[] indices = new short[MAX_INDICES];
for (int i = 0, j = 0; i < MAX_INDICES; i += 6, j += 4) {
indices[i + 0] = (short) (j + 0);
indices[i + 1] = (short) (j + 1);
indices[i + 2] = (short) (j + 2);
indices[i + 3] = (short) (j + 2);
indices[i + 4] = (short) (j + 1);
indices[i + 5] = (short) (j + 3);
}
ShortBuffer buf = MapRenderer.getShortBuffer(indices.length);
buf.put(indices);
buf.flip();
GLState.bindElementBuffer(mQuadIndicesID);
gl.bufferData(GL.ELEMENT_ARRAY_BUFFER, indices.length * 2, buf, GL.STATIC_DRAW);
GLState.bindElementBuffer(0);
/** initialize default quad */
FloatBuffer floatBuffer = MapRenderer.getFloatBuffer(8);
float[] quad = new float[] {-1, -1, -1, 1, 1, -1, 1, 1};
floatBuffer.put(quad);
floatBuffer.flip();
mQuadVerticesID = vboIds[1];
GLState.bindVertexBuffer(mQuadVerticesID);
gl.bufferData(GL.ARRAY_BUFFER, quad.length * 4, floatBuffer, GL.STATIC_DRAW);
GLState.bindVertexBuffer(0);
GLState.init();
mMap.updateMap(true);
}
public void prep(Buffer buf) {
for (GLState st : states) st.prep(buf);
}
/**
* Bind indices for rendering up to MAX_QUADS (512), ie. MAX_INDICES (512*6) in one draw call.
* Vertex order is 0-1-2 2-1-3
*/
public static void bindQuadIndicesVBO() {
GLState.bindElementBuffer(mQuadIndicesID);
}
private void drawMixed(
BasicTexture from,
int toColor,
float ratio,
int x,
int y,
int width,
int height,
float alpha) {
// change from 0 to 0.01f to prevent getting divided by zero below
if (ratio <= 0.01f) {
drawTexture(from, x, y, width, height, alpha);
return;
} else if (ratio >= 1) {
fillRect(x, y, width, height, toColor);
return;
}
mGLState.setBlendEnabled(
mBlendEnabled && (!from.isOpaque() || !Utils.isOpaque(toColor) || alpha < OPAQUE_ALPHA));
final GL11 gl = mGL;
if (!bindTexture(from)) return;
//
// The formula we want:
// alpha * ((1 - ratio) * from + ratio * to)
//
// The formula that GL supports is in the form of:
// combo * from + (1 - combo) * to * scale
//
// So, we have combo = alpha * (1 - ratio)
// and scale = alpha * ratio / (1 - combo)
//
float combo = alpha * (1 - ratio);
float scale = alpha * ratio / (1 - combo);
// Interpolate the RGB and alpha values between both textures.
mGLState.setTexEnvMode(GL11.GL_COMBINE);
// Specify the interpolation factor via the alpha component of
// GL_TEXTURE_ENV_COLORs.
// RGB component are get from toColor and will used as SRC1
float colorScale = scale * (toColor >>> 24) / (0xff * 0xff);
setTextureColor(
((toColor >>> 16) & 0xff) * colorScale,
((toColor >>> 8) & 0xff) * colorScale,
(toColor & 0xff) * colorScale,
combo);
gl.glTexEnvfv(GL11.GL_TEXTURE_ENV, GL11.GL_TEXTURE_ENV_COLOR, mTextureColor, 0);
gl.glTexEnvf(GL11.GL_TEXTURE_ENV, GL11.GL_COMBINE_RGB, GL11.GL_INTERPOLATE);
gl.glTexEnvf(GL11.GL_TEXTURE_ENV, GL11.GL_COMBINE_ALPHA, GL11.GL_INTERPOLATE);
gl.glTexEnvf(GL11.GL_TEXTURE_ENV, GL11.GL_SRC1_RGB, GL11.GL_CONSTANT);
gl.glTexEnvf(GL11.GL_TEXTURE_ENV, GL11.GL_OPERAND1_RGB, GL11.GL_SRC_COLOR);
gl.glTexEnvf(GL11.GL_TEXTURE_ENV, GL11.GL_SRC1_ALPHA, GL11.GL_CONSTANT);
gl.glTexEnvf(GL11.GL_TEXTURE_ENV, GL11.GL_OPERAND1_ALPHA, GL11.GL_SRC_ALPHA);
// Wire up the interpolation factor for RGB.
gl.glTexEnvf(GL11.GL_TEXTURE_ENV, GL11.GL_SRC2_RGB, GL11.GL_CONSTANT);
gl.glTexEnvf(GL11.GL_TEXTURE_ENV, GL11.GL_OPERAND2_RGB, GL11.GL_SRC_ALPHA);
// Wire up the interpolation factor for alpha.
gl.glTexEnvf(GL11.GL_TEXTURE_ENV, GL11.GL_SRC2_ALPHA, GL11.GL_CONSTANT);
gl.glTexEnvf(GL11.GL_TEXTURE_ENV, GL11.GL_OPERAND2_ALPHA, GL11.GL_SRC_ALPHA);
drawBoundTexture(from, x, y, width, height);
mGLState.setTexEnvMode(GL11.GL_REPLACE);
}
public void dispose() {
if (_mesh != null) _mesh.dispose();
if (_backgroundColor != null) _backgroundColor.dispose();
_glState._release();
}
public void prepo(GLState t) {
t.prep(curp.os);
}
public void prepc(GLState t) {
t.prep(curp.cs);
}
void rootdraw(GLState.Applier state, UI ui, BGL gl) {
GLState.Buffer ibuf = new GLState.Buffer(state.cfg);
gstate.prep(ibuf);
ostate.prep(ibuf);
GOut g = new GOut(gl, state.cgl, state.cfg, state, ibuf, new Coord(w, h));
state.set(ibuf);
g.state(ostate);
g.apply();
gl.glClearColor(0, 0, 0, 1);
gl.glClear(GL.GL_COLOR_BUFFER_BIT);
synchronized (ui) {
ui.draw(g);
}
if (Config.dbtext) {
int y = h - 150;
FastText.aprintf(
g,
new Coord(10, y -= 15),
0,
1,
"FPS: %d (%d%%, %d%% idle)",
fps,
(int) (uidle * 100.0),
(int) (ridle * 100.0));
Runtime rt = Runtime.getRuntime();
long free = rt.freeMemory(), total = rt.totalMemory();
FastText.aprintf(
g,
new Coord(10, y -= 15),
0,
1,
"Mem: %,011d/%,011d/%,011d/%,011d",
free,
total - free,
total,
rt.maxMemory());
FastText.aprintf(g, new Coord(10, y -= 15), 0, 1, "Tex-current: %d", TexGL.num());
FastText.aprintf(g, new Coord(10, y -= 15), 0, 1, "GL progs: %d", g.st.numprogs());
GameUI gi = ui.root.findchild(GameUI.class);
if ((gi != null) && (gi.map != null)) {
try {
FastText.aprintf(
g, new Coord(10, y -= 15), 0, 1, "MV pos: %s (%s)", gi.map.getcc(), gi.map.camera);
} catch (Loading e) {
}
if (gi.map.rls != null)
FastText.aprintf(
g,
new Coord(10, y -= 15),
0,
1,
"Rendered: %,d+%,d(%,d)",
gi.map.rls.drawn,
gi.map.rls.instanced,
gi.map.rls.instancified);
}
if (Resource.remote().qdepth() > 0)
FastText.aprintf(
g,
new Coord(10, y -= 15),
0,
1,
"RQ depth: %d (%d)",
Resource.remote().qdepth(),
Resource.remote().numloaded());
}
Object tooltip;
try {
synchronized (ui) {
tooltip = ui.root.tooltip(mousepos, ui.root);
}
} catch (Loading e) {
tooltip = "...";
}
Tex tt = null;
if (tooltip != null) {
if (tooltip instanceof Text) {
tt = ((Text) tooltip).tex();
} else if (tooltip instanceof Tex) {
tt = (Tex) tooltip;
} else if (tooltip instanceof Indir<?>) {
Indir<?> t = (Indir<?>) tooltip;
Object o = t.get();
if (o instanceof Tex) tt = (Tex) o;
} else if (tooltip instanceof String) {
if (((String) tooltip).length() > 0) tt = (Text.render((String) tooltip)).tex();
}
}
if (tt != null) {
Coord sz = tt.sz();
Coord pos = mousepos.add(sz.inv());
if (pos.x < 0) pos.x = 0;
if (pos.y < 0) pos.y = 0;
g.chcolor(244, 247, 21, 192);
g.rect(pos.add(-3, -3), sz.add(6, 6));
g.chcolor(35, 35, 35, 192);
g.frect(pos.add(-2, -2), sz.add(4, 4));
g.chcolor();
g.image(tt, pos);
}
ui.lasttip = tooltip;
Resource curs = ui.root.getcurs(mousepos);
if (curs != null) {
if (cursmode == "awt") {
if (curs != lastcursor) {
try {
setCursor(makeawtcurs(curs.layer(Resource.imgc).img, curs.layer(Resource.negc).cc));
lastcursor = curs;
} catch (Exception e) {
cursmode = "tex";
}
}
} else if (cursmode == "tex") {
Coord dc = mousepos.add(curs.layer(Resource.negc).cc.inv());
g.image(curs.layer(Resource.imgc), dc);
}
}
state.clean();
GLObject.disposeall(state.cgl, gl);
}
public void usestate(GLState st) {
st.prep(cur2d);
}