Java tutorial
/******************************************************************************* * Copyright 2011 See AUTHORS file. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. ******************************************************************************/ package com.doom.render; import sun.reflect.generics.reflectiveObjects.NotImplementedException; import com.badlogic.gdx.Gdx; import com.badlogic.gdx.graphics.Color; import com.badlogic.gdx.graphics.GL20; import com.badlogic.gdx.graphics.Mesh; import com.badlogic.gdx.graphics.Mesh.VertexDataType; import com.badlogic.gdx.graphics.Texture; import com.badlogic.gdx.graphics.VertexAttribute; import com.badlogic.gdx.graphics.VertexAttributes.Usage; import com.badlogic.gdx.graphics.g2d.Batch; import com.badlogic.gdx.graphics.g2d.TextureRegion; import com.badlogic.gdx.graphics.glutils.ShaderProgram; import com.badlogic.gdx.math.Matrix4; import com.badlogic.gdx.utils.NumberUtils; /** Draws batched quads using indices. * @see Batch * @author mzechner * @author Nathan Sweet */ public class QuadBatch implements Batch { private Mesh mesh; private final float[] vertices; private int idx = 0; private Texture lastTexture = null; @SuppressWarnings("unused") private float invTexWidth = 0, invTexHeight = 0; private boolean drawing = false; private final Matrix4 transformMatrix = new Matrix4(); private final Matrix4 projectionMatrix = new Matrix4(); private final Matrix4 combinedMatrix = new Matrix4(); private boolean blendingDisabled = false; private int blendSrcFunc = GL20.GL_SRC_ALPHA; private int blendDstFunc = GL20.GL_ONE_MINUS_SRC_ALPHA; private final ShaderProgram shader; private ShaderProgram customShader = null; private boolean ownsShader; float color = Color.WHITE.toFloatBits(); private Color tempColor = new Color(1, 1, 1, 1); /** Number of render calls since the last {@link #begin()}. **/ public int renderCalls = 0; /** Number of rendering calls, ever. Will not be reset unless set manually. **/ public int totalRenderCalls = 0; /** The maximum number of sprites rendered in one batch so far. **/ public int maxSpritesInBatch = 0; /** Constructs a new SpriteBatch with a size of 1000, one buffer, and the default shader. * @see SpriteBatch#SpriteBatch(int, ShaderProgram) */ public QuadBatch() { this(1000, null); } /** Constructs a SpriteBatch with one buffer and the default shader. * @see SpriteBatch#SpriteBatch(int, ShaderProgram) */ public QuadBatch(int size) { this(size, null); } /** Constructs a new SpriteBatch. Sets the projection matrix to an orthographic projection with y-axis point upwards, x-axis * point to the right and the origin being in the bottom left corner of the screen. The projection will be pixel perfect with * respect to the current screen resolution. * <p> * The defaultShader specifies the shader to use. Note that the names for uniforms for this default shader are different than * the ones expect for shaders set with {@link #setShader(ShaderProgram)}. See {@link #createDefaultShader()}. * @param size The max number of sprites in a single batch. Max of 5460. * @param defaultShader The default shader to use. This is not owned by the SpriteBatch and must be disposed separately. */ public QuadBatch(int size, ShaderProgram defaultShader) { // 32767 is max index, so 32767 / 6 - (32767 / 6 % 3) = 5460. if (size > 5460) throw new IllegalArgumentException("Can't have more than 5460 sprites per batch: " + size); mesh = new Mesh(VertexDataType.VertexArray, false, size * 4, size * 6, new VertexAttribute(Usage.Position, 3, ShaderProgram.POSITION_ATTRIBUTE), new VertexAttribute(Usage.TextureCoordinates, 2, ShaderProgram.TEXCOORD_ATTRIBUTE + "0"), new VertexAttribute(Usage.ColorPacked, 4, ShaderProgram.COLOR_ATTRIBUTE)); projectionMatrix.setToOrtho2D(0, 0, Gdx.graphics.getWidth(), Gdx.graphics.getHeight()); vertices = new float[size * (3 + 1 + 2) * 4]; int len = size * 6; short[] indices = new short[len]; short j = 0; for (int i = 0; i < len; i += 6, j += 4) { indices[i] = j; indices[i + 1] = (short) (j + 1); indices[i + 2] = (short) (j + 2); indices[i + 3] = (short) (j + 2); indices[i + 4] = (short) (j + 3); indices[i + 5] = j; } mesh.setIndices(indices); if (defaultShader == null) { shader = createDefaultShader(); ownsShader = true; } else shader = defaultShader; } /** Returns a new instance of the default shader used by SpriteBatch for GL2 when no shader is specified. */ static public ShaderProgram createDefaultShader() { String vertexShader = "attribute vec4 " + ShaderProgram.POSITION_ATTRIBUTE + ";\n" // + "attribute vec4 " + ShaderProgram.COLOR_ATTRIBUTE + ";\n" // + "attribute vec2 " + ShaderProgram.TEXCOORD_ATTRIBUTE + "0;\n" // + "uniform mat4 u_projTrans;\n" // + "varying vec4 v_color;\n" // + "varying vec2 v_texCoords;\n" // + "\n" // + "void main()\n" // + "{\n" // + " v_color = " + ShaderProgram.COLOR_ATTRIBUTE + ";\n" // + " v_texCoords = " + ShaderProgram.TEXCOORD_ATTRIBUTE + "0;\n" // + " gl_Position = u_projTrans * " + ShaderProgram.POSITION_ATTRIBUTE + ";\n" // + "}\n"; String fragmentShader = "#ifdef GL_ES\n" // + "#define LOWP lowp\n" // + "precision mediump float;\n" // + "#else\n" // + "#define LOWP \n" // + "#endif\n" // + "varying LOWP vec4 v_color;\n" // + "varying vec2 v_texCoords;\n" // + "uniform sampler2D u_texture;\n" // + "void main()\n"// + "{\n" // + " gl_FragColor = texture2D(u_texture, v_texCoords) * v_color;\n" // + "}"; ShaderProgram shader = new ShaderProgram(vertexShader, fragmentShader); if (shader.isCompiled() == false) throw new IllegalArgumentException("Error compiling shader: " + shader.getLog()); return shader; } @Override public void begin() { if (drawing) throw new IllegalStateException("SpriteBatch.end must be called before begin."); renderCalls = 0; //Gdx.gl.glDepthMask(false); if (customShader != null) customShader.begin(); else shader.begin(); setupMatrices(); drawing = true; } @Override public void end() { if (!drawing) throw new IllegalStateException("SpriteBatch.begin must be called before end."); if (idx > 0) flush(); lastTexture = null; drawing = false; GL20 gl = Gdx.gl20; gl.glDepthMask(true); if (isBlendingEnabled()) gl.glDisable(GL20.GL_BLEND); if (customShader != null) customShader.end(); else shader.end(); } @Override public void setColor(Color tint) { color = tint.toFloatBits(); } @Override public void setColor(float r, float g, float b, float a) { int intBits = (int) (255 * a) << 24 | (int) (255 * b) << 16 | (int) (255 * g) << 8 | (int) (255 * r); color = NumberUtils.intToFloatColor(intBits); } @Override public void setColor(float color) { this.color = color; } @Override public Color getColor() { int intBits = NumberUtils.floatToIntColor(color); Color color = tempColor; color.r = (intBits & 0xff) / 255f; color.g = ((intBits >>> 8) & 0xff) / 255f; color.b = ((intBits >>> 16) & 0xff) / 255f; color.a = ((intBits >>> 24) & 0xff) / 255f; return color; } @Override public void draw(Texture texture, float x, float y, float originX, float originY, float width, float height, float scaleX, float scaleY, float rotation, int srcX, int srcY, int srcWidth, int srcHeight, boolean flipX, boolean flipY) { throw new NotImplementedException(); } @Override public void draw(Texture texture, float x, float y, float width, float height, int srcX, int srcY, int srcWidth, int srcHeight, boolean flipX, boolean flipY) { throw new NotImplementedException(); } @Override public void draw(Texture texture, float x, float y, int srcX, int srcY, int srcWidth, int srcHeight) { throw new NotImplementedException(); } @Override public void draw(Texture texture, float x, float y, float width, float height, float u, float v, float u2, float v2) { throw new NotImplementedException(); } @Override public void draw(Texture texture, float x, float y) { throw new NotImplementedException(); } @Override public void draw(Texture texture, float x, float y, float width, float height) { throw new NotImplementedException(); } @Override public void draw(Texture texture, float[] spriteVertices, int offset, int count) { if (!drawing) throw new IllegalStateException("SpriteBatch.begin must be called before draw."); int verticesLength = vertices.length; int remainingVertices = verticesLength; if (texture != lastTexture) switchTexture(texture); else { remainingVertices -= idx; if (remainingVertices == 0) { flush(); remainingVertices = verticesLength; } } lastTexture = texture; int copyCount = Math.min(remainingVertices, count); System.arraycopy(spriteVertices, offset, vertices, idx, copyCount); idx += copyCount; count -= copyCount; while (count > 0) { offset += copyCount; flush(); copyCount = Math.min(verticesLength, count); System.arraycopy(spriteVertices, offset, vertices, 0, copyCount); idx += copyCount; count -= copyCount; } } @Override public void draw(TextureRegion region, float x, float y) { draw(region, x, y, region.getRegionWidth(), region.getRegionHeight()); } @Override public void draw(TextureRegion region, float x, float y, float width, float height) { throw new NotImplementedException(); } @Override public void draw(TextureRegion region, float x, float y, float originX, float originY, float width, float height, float scaleX, float scaleY, float rotation) { throw new NotImplementedException(); } @Override public void draw(TextureRegion region, float x, float y, float originX, float originY, float width, float height, float scaleX, float scaleY, float rotation, boolean clockwise) { throw new NotImplementedException(); } @Override public void flush() { if (idx == 0) return; renderCalls++; totalRenderCalls++; int spritesInBatch = idx / 20; if (spritesInBatch > maxSpritesInBatch) maxSpritesInBatch = spritesInBatch; int count = spritesInBatch * 6; lastTexture.bind(); Mesh mesh = this.mesh; mesh.setVertices(vertices, 0, idx); mesh.getIndicesBuffer().position(0); mesh.getIndicesBuffer().limit(count); if (blendingDisabled) { Gdx.gl.glDisable(GL20.GL_BLEND); } else { Gdx.gl.glEnable(GL20.GL_BLEND); if (blendSrcFunc != -1) Gdx.gl.glBlendFunc(blendSrcFunc, blendDstFunc); } mesh.render(customShader != null ? customShader : shader, GL20.GL_TRIANGLES, 0, count); idx = 0; } @Override public void disableBlending() { if (blendingDisabled) return; flush(); blendingDisabled = true; } @Override public void enableBlending() { if (!blendingDisabled) return; flush(); blendingDisabled = false; } @Override public void setBlendFunction(int srcFunc, int dstFunc) { if (blendSrcFunc == srcFunc && blendDstFunc == dstFunc) return; flush(); blendSrcFunc = srcFunc; blendDstFunc = dstFunc; } @Override public int getBlendSrcFunc() { return blendSrcFunc; } @Override public int getBlendDstFunc() { return blendDstFunc; } @Override public void dispose() { mesh.dispose(); if (ownsShader && shader != null) shader.dispose(); } @Override public Matrix4 getProjectionMatrix() { return projectionMatrix; } @Override public Matrix4 getTransformMatrix() { return transformMatrix; } @Override public void setProjectionMatrix(Matrix4 projection) { if (drawing) flush(); projectionMatrix.set(projection); if (drawing) setupMatrices(); } @Override public void setTransformMatrix(Matrix4 transform) { if (drawing) flush(); transformMatrix.set(transform); if (drawing) setupMatrices(); } private void setupMatrices() { combinedMatrix.set(projectionMatrix).mul(transformMatrix); if (customShader != null) { customShader.setUniformMatrix("u_projTrans", combinedMatrix); customShader.setUniformi("u_texture", 0); } else { shader.setUniformMatrix("u_projTrans", combinedMatrix); shader.setUniformi("u_texture", 0); } } private void switchTexture(Texture texture) { flush(); lastTexture = texture; invTexWidth = 1.0f / texture.getWidth(); invTexHeight = 1.0f / texture.getHeight(); } @Override public void setShader(ShaderProgram shader) { if (drawing) { flush(); if (customShader != null) customShader.end(); else this.shader.end(); } customShader = shader; if (drawing) { if (customShader != null) customShader.begin(); else this.shader.begin(); setupMatrices(); } } @Override public boolean isBlendingEnabled() { return !blendingDisabled; } public boolean isDrawing() { return drawing; } }