|
|
@@ -0,0 +1,2848 @@
|
|
|
+/*
|
|
|
+ * Copyright (c) 2009-2010 jMonkeyEngine
|
|
|
+ * All rights reserved.
|
|
|
+ *
|
|
|
+ * Redistribution and use in source and binary forms, with or without
|
|
|
+ * modification, are permitted provided that the following conditions are
|
|
|
+ * met:
|
|
|
+ *
|
|
|
+ * * Redistributions of source code must retain the above copyright
|
|
|
+ * notice, this list of conditions and the following disclaimer.
|
|
|
+ *
|
|
|
+ * * Redistributions in binary form must reproduce the above copyright
|
|
|
+ * notice, this list of conditions and the following disclaimer in the
|
|
|
+ * documentation and/or other materials provided with the distribution.
|
|
|
+ *
|
|
|
+ * * Neither the name of 'jMonkeyEngine' nor the names of its contributors
|
|
|
+ * may be used to endorse or promote products derived from this software
|
|
|
+ * without specific prior written permission.
|
|
|
+ *
|
|
|
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
|
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
|
|
|
+ * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
|
|
|
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
|
|
|
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
|
|
|
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
|
|
|
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
|
|
|
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
|
|
|
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
|
|
|
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
|
|
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
|
+ */
|
|
|
+
|
|
|
+package com.jme3.renderer.android;
|
|
|
+
|
|
|
+import com.jme3.light.LightList;
|
|
|
+import com.jme3.material.RenderState;
|
|
|
+import com.jme3.math.ColorRGBA;
|
|
|
+import com.jme3.math.Matrix4f;
|
|
|
+import com.jme3.math.Quaternion;
|
|
|
+import com.jme3.math.Vector2f;
|
|
|
+import com.jme3.math.Vector3f;
|
|
|
+import com.jme3.renderer.Caps;
|
|
|
+import com.jme3.renderer.GLObjectManager;
|
|
|
+import com.jme3.renderer.IDList;
|
|
|
+import com.jme3.renderer.Renderer;
|
|
|
+import com.jme3.scene.Mesh;
|
|
|
+import com.jme3.scene.VertexBuffer;
|
|
|
+import com.jme3.scene.VertexBuffer.Format;
|
|
|
+import com.jme3.scene.VertexBuffer.Type;
|
|
|
+import com.jme3.scene.VertexBuffer.Usage;
|
|
|
+import com.jme3.renderer.RenderContext;
|
|
|
+import com.jme3.renderer.RendererException;
|
|
|
+import com.jme3.renderer.Statistics;
|
|
|
+import com.jme3.scene.Mesh.Mode;
|
|
|
+import com.jme3.shader.Attribute;
|
|
|
+import com.jme3.shader.Shader;
|
|
|
+import com.jme3.shader.Shader.ShaderSource;
|
|
|
+import com.jme3.shader.Shader.ShaderType;
|
|
|
+import com.jme3.shader.Uniform;
|
|
|
+import com.jme3.texture.FrameBuffer;
|
|
|
+import com.jme3.texture.FrameBuffer.RenderBuffer;
|
|
|
+import com.jme3.texture.Image;
|
|
|
+import com.jme3.texture.Texture;
|
|
|
+import com.jme3.texture.Texture.WrapAxis;
|
|
|
+import com.jme3.util.BufferUtils;
|
|
|
+import com.jme3.util.IntMap;
|
|
|
+import com.jme3.util.IntMap.Entry;
|
|
|
+import com.jme3.util.ListMap;
|
|
|
+import java.nio.Buffer;
|
|
|
+import java.nio.ByteBuffer;
|
|
|
+import java.nio.DoubleBuffer;
|
|
|
+import java.nio.FloatBuffer;
|
|
|
+import java.nio.IntBuffer;
|
|
|
+import java.nio.ShortBuffer;
|
|
|
+import java.util.EnumSet;
|
|
|
+import java.util.List;
|
|
|
+import java.util.logging.Level;
|
|
|
+import java.util.logging.Logger;
|
|
|
+
|
|
|
+/*
|
|
|
+//import org.lwjgl.opengl.ARBGeometryShader4;
|
|
|
+//import org.lwjgl.opengl.ARBHalfFloatVertex;
|
|
|
+//import org.lwjgl.opengl.ARBVertexArrayObject;
|
|
|
+//import org.lwjgl.opengl.ARBHalfFloatVertex;
|
|
|
+//import org.lwjgl.opengl.ARBVertexArrayObject;
|
|
|
+import org.lwjgl.opengl.ARBDrawBuffers;
|
|
|
+//import org.lwjgl.opengl.ARBDrawInstanced;
|
|
|
+import org.lwjgl.opengl.ARBDrawInstanced;
|
|
|
+import org.lwjgl.opengl.ARBMultisample;
|
|
|
+import org.lwjgl.opengl.ContextCapabilities;
|
|
|
+import org.lwjgl.opengl.EXTTextureArray;
|
|
|
+import org.lwjgl.opengl.EXTTextureFilterAnisotropic;
|
|
|
+import org.lwjgl.opengl.GLContext;
|
|
|
+import org.lwjgl.opengl.NVHalfFloat;
|
|
|
+
|
|
|
+import static org.lwjgl.opengl.GL11.*;
|
|
|
+import static org.lwjgl.opengl.GL12.*;
|
|
|
+import static org.lwjgl.opengl.GL13.*;
|
|
|
+import static org.lwjgl.opengl.GL14.*;
|
|
|
+import static org.lwjgl.opengl.GL15.*;
|
|
|
+import static org.lwjgl.opengl.GL20.*;
|
|
|
+
|
|
|
+import static org.lwjgl.opengl.EXTFramebufferObject.*;
|
|
|
+import static org.lwjgl.opengl.EXTFramebufferMultisample.*;
|
|
|
+import static org.lwjgl.opengl.EXTFramebufferBlit.*;
|
|
|
+import org.lwjgl.opengl.ARBShaderObjects.*;
|
|
|
+import org.lwjgl.opengl.ARBVertexArrayObject;
|
|
|
+//import static org.lwjgl.opengl.ARBDrawInstanced.*;
|
|
|
+*/
|
|
|
+
|
|
|
+import javax.microedition.khronos.egl.EGLConfig;
|
|
|
+import javax.microedition.khronos.egl.EGLContext;
|
|
|
+import javax.microedition.khronos.opengles.GL10;
|
|
|
+
|
|
|
+import android.content.Context;
|
|
|
+import android.graphics.Bitmap;
|
|
|
+import android.graphics.BitmapFactory;
|
|
|
+import android.opengl.GLES10;
|
|
|
+import android.opengl.GLES11;
|
|
|
+import android.opengl.GLES20;
|
|
|
+import android.opengl.GLSurfaceView;
|
|
|
+import android.opengl.GLUtils;
|
|
|
+import android.opengl.Matrix;
|
|
|
+import android.os.SystemClock;
|
|
|
+import android.util.Log;
|
|
|
+
|
|
|
+
|
|
|
+
|
|
|
+public class OGLESShaderRenderer implements Renderer {
|
|
|
+
|
|
|
+ private static final Logger logger = Logger.getLogger(OGLESShaderRenderer.class.getName());
|
|
|
+ private static final boolean VALIDATE_SHADER = false;
|
|
|
+
|
|
|
+ private final ByteBuffer nameBuf = BufferUtils.createByteBuffer(250);
|
|
|
+ private final StringBuilder stringBuf = new StringBuilder(250);
|
|
|
+
|
|
|
+ private final IntBuffer intBuf1 = BufferUtils.createIntBuffer(1);
|
|
|
+ private final IntBuffer intBuf16 = BufferUtils.createIntBuffer(16);
|
|
|
+
|
|
|
+ private final RenderContext context = new RenderContext();
|
|
|
+ private final GLObjectManager objManager = new GLObjectManager();
|
|
|
+ private final EnumSet<Caps> caps = EnumSet.noneOf(Caps.class);
|
|
|
+
|
|
|
+ // current state
|
|
|
+ private Shader boundShader;
|
|
|
+ private int initialDrawBuf, initialReadBuf;
|
|
|
+
|
|
|
+ private int glslVer;
|
|
|
+ private int vertexTextureUnits;
|
|
|
+ private int fragTextureUnits;
|
|
|
+ private int vertexUniforms;
|
|
|
+ private int fragUniforms;
|
|
|
+ private int vertexAttribs;
|
|
|
+ private int maxFBOSamples;
|
|
|
+ private int maxFBOAttachs;
|
|
|
+ private int maxMRTFBOAttachs;
|
|
|
+ private int maxRBSize;
|
|
|
+ private int maxTexSize;
|
|
|
+ private int maxCubeTexSize;
|
|
|
+ private int maxVertCount;
|
|
|
+ private int maxTriCount;
|
|
|
+ private boolean tdc;
|
|
|
+ private FrameBuffer lastFb = null;
|
|
|
+
|
|
|
+ private final Statistics statistics = new Statistics();
|
|
|
+
|
|
|
+ private int vpX, vpY, vpW, vpH;
|
|
|
+ private int clipX, clipY, clipW, clipH;
|
|
|
+
|
|
|
+
|
|
|
+ private final GL10 gl;
|
|
|
+ private boolean powerOf2 = false;
|
|
|
+ private boolean verboseLogging = false;
|
|
|
+ private boolean useVBO = true;
|
|
|
+
|
|
|
+
|
|
|
+ public OGLESShaderRenderer(GL10 gl) {
|
|
|
+ this.gl = gl;
|
|
|
+ }
|
|
|
+
|
|
|
+ public void setUseVA(boolean value) {
|
|
|
+ logger.info("use_VBO [" + useVBO + "] -> [" + (!value) + "]");
|
|
|
+ useVBO = !value;
|
|
|
+ }
|
|
|
+
|
|
|
+ public void setVerboseLogging(boolean value) {
|
|
|
+ logger.info("verboseLogging [" + verboseLogging + "] -> [" + value + "]");
|
|
|
+ verboseLogging = value;
|
|
|
+ }
|
|
|
+
|
|
|
+ protected void updateNameBuffer(){
|
|
|
+ int len = stringBuf.length();
|
|
|
+
|
|
|
+ nameBuf.position(0);
|
|
|
+ nameBuf.limit(len);
|
|
|
+ for (int i = 0; i < len; i++)
|
|
|
+ nameBuf.put((byte)stringBuf.charAt(i));
|
|
|
+
|
|
|
+ nameBuf.rewind();
|
|
|
+ }
|
|
|
+
|
|
|
+ public Statistics getStatistics(){
|
|
|
+ return statistics;
|
|
|
+ }
|
|
|
+
|
|
|
+ public EnumSet<Caps> getCaps(){
|
|
|
+ return caps;
|
|
|
+ }
|
|
|
+
|
|
|
+ public void initialize(){
|
|
|
+
|
|
|
+ logger.info("Vendor: " + GLES20.glGetString(GLES20.GL_VENDOR));
|
|
|
+ logger.info("Renderer: " + GLES20.glGetString(GLES20.GL_RENDERER));
|
|
|
+ logger.info("Version: " + GLES20.glGetString(GLES20.GL_VERSION));
|
|
|
+
|
|
|
+ String shadingLanguageVersion = GLES20.glGetString(GLES20.GL_SHADING_LANGUAGE_VERSION);
|
|
|
+ logger.info("GLES20.Shading Language Version: " + shadingLanguageVersion);
|
|
|
+
|
|
|
+/*
|
|
|
+ ContextCapabilities ctxCaps = GLContext.getCapabilities();
|
|
|
+ if (ctxCaps.OpenGL20){
|
|
|
+ caps.add(Caps.OpenGL20);
|
|
|
+ }
|
|
|
+ if (ctxCaps.OpenGL21){
|
|
|
+ caps.add(Caps.OpenGL21);
|
|
|
+ }
|
|
|
+ if (ctxCaps.OpenGL30){
|
|
|
+ caps.add(Caps.OpenGL30);
|
|
|
+ }
|
|
|
+*/
|
|
|
+ String versionStr = GLES20.glGetString(GLES20.GL_SHADING_LANGUAGE_VERSION);
|
|
|
+ if (versionStr == null || versionStr.equals("")){
|
|
|
+ glslVer = -1;
|
|
|
+ throw new UnsupportedOperationException("GLSL and OpenGL2 is " +
|
|
|
+ "required for the LWJGL " +
|
|
|
+ "renderer!");
|
|
|
+ }
|
|
|
+
|
|
|
+ // Fix issue in TestRenderToMemory when GL_FRONT is the main
|
|
|
+ // buffer being used.
|
|
|
+
|
|
|
+// initialDrawBuf = GLES20.glGetIntegeri(GLES20.GL_DRAW_BUFFER);
|
|
|
+// initialReadBuf = GLES20.glGetIntegeri(GLES20.GL_READ_BUFFER);
|
|
|
+
|
|
|
+ int spaceIdx = versionStr.lastIndexOf(" ");
|
|
|
+ if (spaceIdx >= 1)
|
|
|
+ versionStr = versionStr.substring(spaceIdx, versionStr.length());
|
|
|
+
|
|
|
+ float version = Float.parseFloat(versionStr);
|
|
|
+ glslVer = (int) (version * 100);
|
|
|
+
|
|
|
+ switch (glslVer){
|
|
|
+ default:
|
|
|
+ if (glslVer < 400)
|
|
|
+ break;
|
|
|
+
|
|
|
+ // so that future OpenGL revisions wont break jme3
|
|
|
+
|
|
|
+ // fall through intentional
|
|
|
+ case 400:
|
|
|
+ case 330:
|
|
|
+ case 150:
|
|
|
+ caps.add(Caps.GLSL150);
|
|
|
+ case 140:
|
|
|
+ caps.add(Caps.GLSL140);
|
|
|
+ case 130:
|
|
|
+ caps.add(Caps.GLSL130);
|
|
|
+ case 120:
|
|
|
+ caps.add(Caps.GLSL120);
|
|
|
+ case 110:
|
|
|
+ caps.add(Caps.GLSL110);
|
|
|
+ case 100:
|
|
|
+ caps.add(Caps.GLSL100);
|
|
|
+ break;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (!caps.contains(Caps.GLSL100)){
|
|
|
+ logger.info("Force-adding GLSL100 support, since OpenGL is supported.");
|
|
|
+ caps.add(Caps.GLSL100);
|
|
|
+ }
|
|
|
+
|
|
|
+ GLES20.glGetIntegerv(GLES20.GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS, intBuf16);
|
|
|
+ vertexTextureUnits = intBuf16.get(0);
|
|
|
+ logger.info("VTF Units: " + vertexTextureUnits);
|
|
|
+ if (vertexTextureUnits > 0)
|
|
|
+ caps.add(Caps.VertexTextureFetch);
|
|
|
+
|
|
|
+ GLES20.glGetIntegerv(GLES20.GL_MAX_TEXTURE_IMAGE_UNITS, intBuf16);
|
|
|
+ fragTextureUnits = intBuf16.get(0);
|
|
|
+ logger.info("Texture Units: " + fragTextureUnits);
|
|
|
+/*
|
|
|
+ GLES20.glGetIntegerv(GLES20.GL_MAX_VERTEX_UNIFORM_COMPONENTS, intBuf16);
|
|
|
+ vertexUniforms = intBuf16.get(0);
|
|
|
+ logger.log(Level.FINER, "Vertex Uniforms: {0}", vertexUniforms);
|
|
|
+
|
|
|
+ GLES20.glGetIntegerv(GLES20.GL_MAX_FRAGMENT_UNIFORM_COMPONENTS, intBuf16);
|
|
|
+ fragUniforms = intBuf16.get(0);
|
|
|
+ logger.log(Level.FINER, "Fragment Uniforms: {0}", fragUniforms);
|
|
|
+*/
|
|
|
+
|
|
|
+ GLES20.glGetIntegerv(GLES20.GL_MAX_VERTEX_ATTRIBS, intBuf16);
|
|
|
+ vertexAttribs = intBuf16.get(0);
|
|
|
+ logger.info("Vertex Attributes: " + vertexAttribs);
|
|
|
+
|
|
|
+/*
|
|
|
+ GLES20.glGetIntegerv(GLES20.GL_MAX_VARYING_FLOATS, intBuf16);
|
|
|
+ int varyingFloats = intBuf16.get(0);
|
|
|
+ logger.log(Level.FINER, "Varying Floats: {0}", varyingFloats);
|
|
|
+*/
|
|
|
+
|
|
|
+ GLES20.glGetIntegerv(GLES20.GL_SUBPIXEL_BITS, intBuf16);
|
|
|
+ int subpixelBits = intBuf16.get(0);
|
|
|
+ logger.info("Subpixel Bits: " + subpixelBits);
|
|
|
+/*
|
|
|
+ GLES20.glGetIntegerv(GLES20.GL_MAX_ELEMENTS_VERTICES, intBuf16);
|
|
|
+ maxVertCount = intBuf16.get(0);
|
|
|
+ logger.log(Level.FINER, "Preferred Batch Vertex Count: {0}", maxVertCount);
|
|
|
+
|
|
|
+ GLES20.glGetIntegerv(GLES20.GL_MAX_ELEMENTS_INDICES, intBuf16);
|
|
|
+ maxTriCount = intBuf16.get(0);
|
|
|
+ logger.log(Level.FINER, "Preferred Batch Index Count: {0}", maxTriCount);
|
|
|
+*/
|
|
|
+ GLES20.glGetIntegerv(GLES20.GL_MAX_TEXTURE_SIZE, intBuf16);
|
|
|
+ maxTexSize = intBuf16.get(0);
|
|
|
+ logger.info("Maximum Texture Resolution: " + maxTexSize);
|
|
|
+
|
|
|
+ GLES20.glGetIntegerv(GLES20.GL_MAX_CUBE_MAP_TEXTURE_SIZE, intBuf16);
|
|
|
+ maxCubeTexSize = intBuf16.get(0);
|
|
|
+ logger.info("Maximum CubeMap Resolution: " + maxCubeTexSize);
|
|
|
+
|
|
|
+
|
|
|
+/*
|
|
|
+ if (ctxCaps.GL_ARB_color_buffer_float){
|
|
|
+ // XXX: Require both 16 and 32 bit float support for FloatColorBuffer.
|
|
|
+ if (ctxCaps.GL_ARB_half_float_pixel){
|
|
|
+ caps.add(Caps.FloatColorBuffer);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ if (ctxCaps.GL_ARB_depth_buffer_float){
|
|
|
+ caps.add(Caps.FloatDepthBuffer);
|
|
|
+ }
|
|
|
+
|
|
|
+ if (ctxCaps.GL_ARB_draw_instanced)
|
|
|
+ caps.add(Caps.MeshInstancing);
|
|
|
+
|
|
|
+ if (ctxCaps.GL_ARB_fragment_program)
|
|
|
+ caps.add(Caps.ARBprogram);
|
|
|
+
|
|
|
+ if (ctxCaps.GL_ARB_texture_buffer_object)
|
|
|
+ caps.add(Caps.TextureBuffer);
|
|
|
+
|
|
|
+ if (ctxCaps.GL_ARB_texture_float){
|
|
|
+ if (ctxCaps.GL_ARB_half_float_pixel){
|
|
|
+ caps.add(Caps.FloatTexture);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ if (ctxCaps.GL_ARB_vertex_array_object)
|
|
|
+ caps.add(Caps.VertexBufferArray);
|
|
|
+
|
|
|
+ boolean latc = ctxCaps.GL_EXT_texture_compression_latc;
|
|
|
+ boolean atdc = ctxCaps.GL_ATI_texture_compression_3dc;
|
|
|
+ if (latc || atdc){
|
|
|
+ caps.add(Caps.TextureCompressionLATC);
|
|
|
+ if (atdc && !latc){
|
|
|
+ tdc = true;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ if (ctxCaps.GL_EXT_packed_float){
|
|
|
+ caps.add(Caps.PackedFloatColorBuffer);
|
|
|
+ if (ctxCaps.GL_ARB_half_float_pixel){
|
|
|
+ // because textures are usually uploaded as RGB16F
|
|
|
+ // need half-float pixel
|
|
|
+ caps.add(Caps.PackedFloatTexture);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ if (ctxCaps.GL_EXT_texture_array)
|
|
|
+ caps.add(Caps.TextureArray);
|
|
|
+
|
|
|
+ if (ctxCaps.GL_EXT_texture_shared_exponent)
|
|
|
+ caps.add(Caps.SharedExponentTexture);
|
|
|
+
|
|
|
+ if (ctxCaps.GL_EXT_framebuffer_object){
|
|
|
+ caps.add(Caps.FrameBuffer);
|
|
|
+
|
|
|
+ glGetInteger(GL_MAX_RENDERBUFFER_SIZE_EXT, intBuf16);
|
|
|
+ maxRBSize = intBuf16.get(0);
|
|
|
+ logger.log(Level.FINER, "FBO RB Max Size: {0}", maxRBSize);
|
|
|
+
|
|
|
+ glGetInteger(GL_MAX_COLOR_ATTACHMENTS_EXT, intBuf16);
|
|
|
+ maxFBOAttachs = intBuf16.get(0);
|
|
|
+ logger.log(Level.FINER, "FBO Max renderbuffers: {0}", maxFBOAttachs);
|
|
|
+
|
|
|
+ if (ctxCaps.GL_EXT_framebuffer_multisample){
|
|
|
+ caps.add(Caps.FrameBufferMultisample);
|
|
|
+
|
|
|
+ glGetInteger(GL_MAX_SAMPLES_EXT, intBuf16);
|
|
|
+ maxFBOSamples = intBuf16.get(0);
|
|
|
+ logger.log(Level.FINER, "FBO Max Samples: {0}", maxFBOSamples);
|
|
|
+ }
|
|
|
+
|
|
|
+ if (ctxCaps.GL_ARB_draw_buffers){
|
|
|
+ caps.add(Caps.FrameBufferMRT);
|
|
|
+ glGetInteger(ARBDrawBuffers.GL_MAX_DRAW_BUFFERS_ARB, intBuf16);
|
|
|
+ maxMRTFBOAttachs = intBuf16.get(0);
|
|
|
+ logger.log(Level.FINER, "FBO Max MRT renderbuffers: {0}", maxMRTFBOAttachs);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ if (ctxCaps.GL_ARB_multisample){
|
|
|
+ glGetInteger(ARBMultisample.GL_SAMPLE_BUFFERS_ARB, intBuf16);
|
|
|
+ boolean available = intBuf16.get(0) != 0;
|
|
|
+ glGetInteger(ARBMultisample.GL_SAMPLES_ARB, intBuf16);
|
|
|
+ int samples = intBuf16.get(0);
|
|
|
+ logger.log(Level.FINER, "Samples: {0}", samples);
|
|
|
+ boolean enabled = glIsEnabled(ARBMultisample.GL_MULTISAMPLE_ARB);
|
|
|
+ if (samples > 0 && available && !enabled){
|
|
|
+ glEnable(ARBMultisample.GL_MULTISAMPLE_ARB);
|
|
|
+ }
|
|
|
+ }
|
|
|
+*/
|
|
|
+
|
|
|
+ String extensions = GLES20.glGetString(GLES20.GL_EXTENSIONS);
|
|
|
+
|
|
|
+ logger.info("GL_EXTENSIONS: " + extensions);
|
|
|
+
|
|
|
+ if (extensions.contains("GL_OES_texture_npot"))
|
|
|
+ powerOf2 = true;
|
|
|
+
|
|
|
+ applyRenderState(RenderState.DEFAULT);
|
|
|
+// GLES20.glClearDepthf(1.0f);
|
|
|
+
|
|
|
+ if (verboseLogging)
|
|
|
+ logger.info("GLES20.glDisable(GL10.GL_DITHER)");
|
|
|
+
|
|
|
+ GLES20.glDisable(GL10.GL_DITHER);
|
|
|
+
|
|
|
+ checkGLError();
|
|
|
+
|
|
|
+ if (verboseLogging)
|
|
|
+ logger.info("GLES20.glHint(GL10.GL_PERSPECTIVE_CORRECTION_HINT, GL10.GL_FASTEST)");
|
|
|
+
|
|
|
+ GLES20.glHint(GL10.GL_PERSPECTIVE_CORRECTION_HINT, GL10.GL_FASTEST);
|
|
|
+
|
|
|
+// checkGLError();
|
|
|
+
|
|
|
+ logger.log(Level.INFO, "Caps: " + caps);
|
|
|
+ }
|
|
|
+
|
|
|
+ public void resetGLObjects(){
|
|
|
+ objManager.resetObjects();
|
|
|
+ statistics.clearMemory();
|
|
|
+ boundShader = null;
|
|
|
+ lastFb = null;
|
|
|
+ context.reset();
|
|
|
+ }
|
|
|
+
|
|
|
+ public void cleanup(){
|
|
|
+ objManager.deleteAllObjects(this);
|
|
|
+ statistics.clearMemory();
|
|
|
+ }
|
|
|
+
|
|
|
+ private void checkCap(Caps cap){
|
|
|
+ if (!caps.contains(cap))
|
|
|
+ throw new UnsupportedOperationException("Required capability missing: "+cap.name());
|
|
|
+ }
|
|
|
+
|
|
|
+ /*********************************************************************\
|
|
|
+ |* Render State *|
|
|
|
+ \*********************************************************************/
|
|
|
+ public void setDepthRange(float start, float end){
|
|
|
+
|
|
|
+ if (verboseLogging)
|
|
|
+ logger.info("GLES20.glDepthRangef(" + start + ", " + end + ")");
|
|
|
+ GLES20.glDepthRangef(start, end);
|
|
|
+ checkGLError();
|
|
|
+ }
|
|
|
+
|
|
|
+ public void clearBuffers(boolean color, boolean depth, boolean stencil){
|
|
|
+ int bits = 0;
|
|
|
+ if (color) bits = GLES20.GL_COLOR_BUFFER_BIT;
|
|
|
+ if (depth) bits |= GLES20.GL_DEPTH_BUFFER_BIT;
|
|
|
+ if (stencil) bits |= GLES20.GL_STENCIL_BUFFER_BIT;
|
|
|
+ if (bits != 0) {
|
|
|
+ if (verboseLogging)
|
|
|
+ logger.info("GLES20.glClear(color=" + color + ", depth=" + depth + ", stencil=" + stencil + ")");
|
|
|
+ GLES20.glClear(bits); checkGLError();
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ public void setBackgroundColor(ColorRGBA color){
|
|
|
+ if (verboseLogging)
|
|
|
+ logger.info("GLES20.glClearColor(" + color.r + ", " + color.g + ", " + color.b + ", " + color.a + ")");
|
|
|
+ GLES20.glClearColor(color.r, color.g, color.b, color.a);
|
|
|
+ checkGLError();
|
|
|
+ }
|
|
|
+
|
|
|
+ public void applyRenderState(RenderState state){
|
|
|
+/*
|
|
|
+ if (state.isWireframe() && !context.wireframe){
|
|
|
+ GLES20.glPolygonMode(GLES20.GL_FRONT_AND_BACK, GLES20.GL_LINE);
|
|
|
+ context.wireframe = true;
|
|
|
+ }else if (!state.isWireframe() && context.wireframe){
|
|
|
+ GLES20.glPolygonMode(GLES20.GL_FRONT_AND_BACK, GLES20.GL_FILL);
|
|
|
+ context.wireframe = false;
|
|
|
+ }
|
|
|
+*/
|
|
|
+ if (state.isDepthTest() && !context.depthTestEnabled){
|
|
|
+ if (verboseLogging)
|
|
|
+ logger.info("GLES20.glEnable(GLES20.GL_DEPTH_TEST)");
|
|
|
+ GLES20.glEnable(GLES20.GL_DEPTH_TEST);
|
|
|
+ checkGLError();
|
|
|
+ if (verboseLogging)
|
|
|
+ logger.info("GLES20.glDepthFunc(GLES20.GL_LEQUAL)");
|
|
|
+ GLES20.glDepthFunc(GLES20.GL_LEQUAL);
|
|
|
+ checkGLError();
|
|
|
+ context.depthTestEnabled = true;
|
|
|
+ }else if (!state.isDepthTest() && context.depthTestEnabled){
|
|
|
+ if (verboseLogging)
|
|
|
+ logger.info("GLES20.glDisable(GLES20.GL_DEPTH_TEST)");
|
|
|
+ GLES20.glDisable(GLES20.GL_DEPTH_TEST);
|
|
|
+ checkGLError();
|
|
|
+ context.depthTestEnabled = false;
|
|
|
+ }
|
|
|
+ if (state.isAlphaTest() && !context.alphaTestEnabled){
|
|
|
+// GLES20.glEnable(GLES20.GL_ALPHA_TEST);
|
|
|
+// GLES20.glAlphaFunc(GLES20.GL_GREATER, state.getAlphaFallOff());
|
|
|
+ context.alphaTestEnabled = true;
|
|
|
+ }else if (!state.isAlphaTest() && context.alphaTestEnabled){
|
|
|
+// GLES20.glDisable(GLES20.GL_ALPHA_TEST);
|
|
|
+ context.alphaTestEnabled = false;
|
|
|
+ }
|
|
|
+ if (state.isDepthWrite() && !context.depthWriteEnabled){
|
|
|
+ if (verboseLogging)
|
|
|
+ logger.info("GLES20.glDepthMask(true)");
|
|
|
+ GLES20.glDepthMask(true);
|
|
|
+ checkGLError();
|
|
|
+ context.depthWriteEnabled = true;
|
|
|
+ }else if (!state.isDepthWrite() && context.depthWriteEnabled){
|
|
|
+ if (verboseLogging)
|
|
|
+ logger.info("GLES20.glDepthMask(false)");
|
|
|
+ GLES20.glDepthMask(false);
|
|
|
+ checkGLError();
|
|
|
+ context.depthWriteEnabled = false;
|
|
|
+ }
|
|
|
+ if (state.isColorWrite() && !context.colorWriteEnabled){
|
|
|
+ if (verboseLogging)
|
|
|
+ logger.info("GLES20.glColorMask(true, true, true, true)");
|
|
|
+ GLES20.glColorMask(true,true,true,true);
|
|
|
+ checkGLError();
|
|
|
+ context.colorWriteEnabled = true;
|
|
|
+ }else if (!state.isColorWrite() && context.colorWriteEnabled){
|
|
|
+ if (verboseLogging)
|
|
|
+ logger.info("GLES20.glColorMask(false, false, false, false)");
|
|
|
+ GLES20.glColorMask(false,false,false,false);
|
|
|
+ checkGLError();
|
|
|
+ context.colorWriteEnabled = false;
|
|
|
+ }
|
|
|
+ if (state.isPointSprite() && !context.pointSprite){
|
|
|
+// GLES20.glEnable(GLES20.GL_POINT_SPRITE);
|
|
|
+// GLES20.glTexEnvi(GLES20.GL_POINT_SPRITE, GLES20.GL_COORD_REPLACE, GLES20.GL_TRUE);
|
|
|
+// GLES20.glEnable(GLES20.GL_VERTEX_PROGRAM_POINT_SIZE);
|
|
|
+// GLES20.glPointParameterf(GLES20.GL_POINT_SIZE_MIN, 1.0f);
|
|
|
+ }else if (!state.isPointSprite() && context.pointSprite){
|
|
|
+// GLES20.glDisable(GLES20.GL_POINT_SPRITE);
|
|
|
+ }
|
|
|
+
|
|
|
+ if (state.isPolyOffset()){
|
|
|
+ if (!context.polyOffsetEnabled){
|
|
|
+ if (verboseLogging)
|
|
|
+ logger.info("GLES20.glEnable(GLES20.GL_POLYGON_OFFSET_FILL)");
|
|
|
+ GLES20.glEnable(GLES20.GL_POLYGON_OFFSET_FILL);
|
|
|
+ checkGLError();
|
|
|
+ if (verboseLogging)
|
|
|
+ logger.info("GLES20.glPolygonOffset(" + state.getPolyOffsetFactor() + ", " + state.getPolyOffsetUnits() + ")");
|
|
|
+ GLES20.glPolygonOffset(state.getPolyOffsetFactor(),
|
|
|
+ state.getPolyOffsetUnits());
|
|
|
+ checkGLError();
|
|
|
+ context.polyOffsetEnabled = true;
|
|
|
+ context.polyOffsetFactor = state.getPolyOffsetFactor();
|
|
|
+ context.polyOffsetUnits = state.getPolyOffsetUnits();
|
|
|
+ }else{
|
|
|
+ if (state.getPolyOffsetFactor() != context.polyOffsetFactor
|
|
|
+ || state.getPolyOffsetUnits() != context.polyOffsetUnits){
|
|
|
+ if (verboseLogging)
|
|
|
+ logger.info("GLES20.glPolygonOffset(" + state.getPolyOffsetFactor() + ", " + state.getPolyOffsetUnits() + ")");
|
|
|
+ GLES20.glPolygonOffset(state.getPolyOffsetFactor(),
|
|
|
+ state.getPolyOffsetUnits());
|
|
|
+ checkGLError();
|
|
|
+ context.polyOffsetFactor = state.getPolyOffsetFactor();
|
|
|
+ context.polyOffsetUnits = state.getPolyOffsetUnits();
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }else{
|
|
|
+ if (context.polyOffsetEnabled){
|
|
|
+ if (verboseLogging)
|
|
|
+ logger.info("GLES20.glDisable(GLES20.GL_POLYGON_OFFSET_FILL)");
|
|
|
+ GLES20.glDisable(GLES20.GL_POLYGON_OFFSET_FILL);
|
|
|
+ checkGLError();
|
|
|
+ context.polyOffsetEnabled = false;
|
|
|
+ context.polyOffsetFactor = 0;
|
|
|
+ context.polyOffsetUnits = 0;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ if (state.getFaceCullMode() != context.cullMode){
|
|
|
+ if (state.getFaceCullMode() == RenderState.FaceCullMode.Off) {
|
|
|
+ if (verboseLogging)
|
|
|
+ logger.info("GLES20.glDisable(GLES20.GL_CULL_FACE)");
|
|
|
+ GLES20.glDisable(GLES20.GL_CULL_FACE);
|
|
|
+ } else {
|
|
|
+ if (verboseLogging)
|
|
|
+ logger.info("GLES20.glEnable(GLES20.GL_CULL_FACE)");
|
|
|
+ GLES20.glEnable(GLES20.GL_CULL_FACE);
|
|
|
+ }
|
|
|
+
|
|
|
+ checkGLError();
|
|
|
+
|
|
|
+ switch (state.getFaceCullMode()){
|
|
|
+ case Off:
|
|
|
+ break;
|
|
|
+ case Back:
|
|
|
+ if (verboseLogging)
|
|
|
+ logger.info("GLES20.glCullFace(GLES20.GL_BACK)");
|
|
|
+ GLES20.glCullFace(GLES20.GL_BACK);
|
|
|
+ break;
|
|
|
+ case Front:
|
|
|
+ if (verboseLogging)
|
|
|
+ logger.info("GLES20.glCullFace(GLES20.GL_FRONT)");
|
|
|
+ GLES20.glCullFace(GLES20.GL_FRONT);
|
|
|
+ break;
|
|
|
+ case FrontAndBack:
|
|
|
+ if (verboseLogging)
|
|
|
+ logger.info("GLES20.glCullFace(GLES20.GL_FRONT_AND_BACK)");
|
|
|
+ GLES20.glCullFace(GLES20.GL_FRONT_AND_BACK);
|
|
|
+ break;
|
|
|
+ default:
|
|
|
+ throw new UnsupportedOperationException("Unrecognized face cull mode: "+
|
|
|
+ state.getFaceCullMode());
|
|
|
+ }
|
|
|
+
|
|
|
+ checkGLError();
|
|
|
+
|
|
|
+ context.cullMode = state.getFaceCullMode();
|
|
|
+ }
|
|
|
+
|
|
|
+ if (state.getBlendMode() != context.blendMode){
|
|
|
+ if (state.getBlendMode() == RenderState.BlendMode.Off){
|
|
|
+ if (verboseLogging)
|
|
|
+ logger.info("GLES20.glDisable(GLES20.GL_BLEND)");
|
|
|
+ GLES20.glDisable(GLES20.GL_BLEND);
|
|
|
+ } else {
|
|
|
+ if (verboseLogging)
|
|
|
+ logger.info("GLES20.glEnable(GLES20.GL_BLEND)");
|
|
|
+ GLES20.glEnable(GLES20.GL_BLEND);
|
|
|
+ switch (state.getBlendMode()){
|
|
|
+ case Off:
|
|
|
+ break;
|
|
|
+ case Additive:
|
|
|
+ if (verboseLogging)
|
|
|
+ logger.info("GLES20.glBlendFunc(GLES20.GL_ONE, GLES20.GL_ONE)");
|
|
|
+ GLES20.glBlendFunc(GLES20.GL_ONE, GLES20.GL_ONE);
|
|
|
+ break;
|
|
|
+ case AlphaAdditive:
|
|
|
+ if (verboseLogging)
|
|
|
+ logger.info("GLES20.glBlendFunc(GLES20.GL_SRC_ALPHA, GLES20.GL_ONE)");
|
|
|
+ GLES20.glBlendFunc(GLES20.GL_SRC_ALPHA, GLES20.GL_ONE);
|
|
|
+ break;
|
|
|
+ case Color:
|
|
|
+ if (verboseLogging)
|
|
|
+ logger.info("GLES20.glBlendFunc(GLES20.GL_ONE, GLES20.GL_ONE_MINUS_SRC_COLOR)");
|
|
|
+ GLES20.glBlendFunc(GLES20.GL_ONE, GLES20.GL_ONE_MINUS_SRC_COLOR);
|
|
|
+ break;
|
|
|
+ case Alpha:
|
|
|
+ if (verboseLogging)
|
|
|
+ logger.info("GLES20.glBlendFunc(GLES20.GL_SRC_ALPHA, GLES20.GL_ONE_MINUS_SRC_ALPHA)");
|
|
|
+ GLES20.glBlendFunc(GLES20.GL_SRC_ALPHA, GLES20.GL_ONE_MINUS_SRC_ALPHA);
|
|
|
+ break;
|
|
|
+ case PremultAlpha:
|
|
|
+ if (verboseLogging)
|
|
|
+ logger.info("GLES20.glBlendFunc(GLES20.GL_ONE, GLES20.GL_ONE_MINUS_SRC_ALPHA)");
|
|
|
+ GLES20.glBlendFunc(GLES20.GL_ONE, GLES20.GL_ONE_MINUS_SRC_ALPHA);
|
|
|
+ break;
|
|
|
+ case Modulate:
|
|
|
+ if (verboseLogging)
|
|
|
+ logger.info("GLES20.glBlendFunc(GLES20.GL_DST_COLOR, GLES20.GL_ZERO)");
|
|
|
+ GLES20.glBlendFunc(GLES20.GL_DST_COLOR, GLES20.GL_ZERO);
|
|
|
+ break;
|
|
|
+ case ModulateX2:
|
|
|
+ if (verboseLogging)
|
|
|
+ logger.info("GLES20.glBlendFunc(GLES20.GL_DST_COLOR, GLES20.GL_SRC_COLOR)");
|
|
|
+ GLES20.glBlendFunc(GLES20.GL_DST_COLOR, GLES20.GL_SRC_COLOR);
|
|
|
+ break;
|
|
|
+ default:
|
|
|
+ throw new UnsupportedOperationException("Unrecognized blend mode: "+
|
|
|
+ state.getBlendMode());
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ checkGLError();
|
|
|
+
|
|
|
+ context.blendMode = state.getBlendMode();
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ /*********************************************************************\
|
|
|
+ |* Camera and World transforms *|
|
|
|
+ \*********************************************************************/
|
|
|
+ public void setViewPort(int x, int y, int w, int h){
|
|
|
+ if (x != vpX || vpY != y || vpW != w || vpH != h){
|
|
|
+ if (verboseLogging)
|
|
|
+ logger.info("GLES20.glViewport(" + x + ", " + y + ", " + w + ", " + h + ")");
|
|
|
+ GLES20.glViewport(x, y, w, h);
|
|
|
+ checkGLError();
|
|
|
+ vpX = x;
|
|
|
+ vpY = y;
|
|
|
+ vpW = w;
|
|
|
+ vpH = h;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ public void setClipRect(int x, int y, int width, int height){
|
|
|
+ if (!context.clipRectEnabled){
|
|
|
+ if (verboseLogging)
|
|
|
+ logger.info("GLES20.glEnable(GLES20.GL_SCISSOR_TEST)");
|
|
|
+ GLES20.glEnable(GLES20.GL_SCISSOR_TEST);
|
|
|
+ checkGLError();
|
|
|
+ context.clipRectEnabled = true;
|
|
|
+ }
|
|
|
+ if (clipX != x || clipY != y || clipW != width || clipH != height){
|
|
|
+ if (verboseLogging)
|
|
|
+ logger.info("GLES20.glScissor(" + x + ", " + y + ", " + width + ", " + height + ")");
|
|
|
+ GLES20.glScissor(x, y, width, height);
|
|
|
+ clipX = x;
|
|
|
+ clipY = y;
|
|
|
+ clipW = width;
|
|
|
+ clipH = height;
|
|
|
+ checkGLError();
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ public void clearClipRect(){
|
|
|
+ if (context.clipRectEnabled){
|
|
|
+ if (verboseLogging)
|
|
|
+ logger.info("GLES20.glDisable(GLES20.GL_SCISSOR_TEST)");
|
|
|
+ GLES20.glDisable(GLES20.GL_SCISSOR_TEST);
|
|
|
+ checkGLError();
|
|
|
+ context.clipRectEnabled = false;
|
|
|
+
|
|
|
+ clipX = 0;
|
|
|
+ clipY = 0;
|
|
|
+ clipW = 0;
|
|
|
+ clipH = 0;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ public void onFrame(){
|
|
|
+ objManager.deleteUnused(this);
|
|
|
+// statistics.clearFrame();
|
|
|
+ }
|
|
|
+
|
|
|
+ public void setWorldMatrix(Matrix4f worldMatrix){
|
|
|
+ }
|
|
|
+
|
|
|
+ public void setViewProjectionMatrices(Matrix4f viewMatrix, Matrix4f projMatrix){
|
|
|
+ }
|
|
|
+
|
|
|
+ /*********************************************************************\
|
|
|
+ |* Shaders *|
|
|
|
+ \*********************************************************************/
|
|
|
+
|
|
|
+ protected void updateUniformLocation(Shader shader, Uniform uniform){
|
|
|
+ stringBuf.setLength(0);
|
|
|
+ stringBuf.append(uniform.getName()).append('\0');
|
|
|
+ updateNameBuffer();
|
|
|
+ if (verboseLogging)
|
|
|
+ logger.info("GLES20.glGetUniformLocation(" + shader.getId() + ", " + uniform.getName() + ")");
|
|
|
+ int loc = GLES20.glGetUniformLocation(shader.getId(), uniform.getName());
|
|
|
+ checkGLError();
|
|
|
+ if (loc < 0){
|
|
|
+ uniform.setLocation(-1);
|
|
|
+ // uniform is not declared in shader
|
|
|
+ if (verboseLogging)
|
|
|
+ logger.warning("Uniform [" + uniform.getName() + "] is not declared in shader.");
|
|
|
+ }else{
|
|
|
+ uniform.setLocation(loc);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ protected void updateUniform(Shader shader, Uniform uniform){
|
|
|
+ int shaderId = shader.getId();
|
|
|
+
|
|
|
+ assert uniform.getName() != null;
|
|
|
+ assert shader.getId() > 0;
|
|
|
+
|
|
|
+ if (context.boundShaderProgram != shaderId){
|
|
|
+ if (verboseLogging)
|
|
|
+ logger.info("GLES20.glUseProgram(" + shaderId + ")");
|
|
|
+ GLES20.glUseProgram(shaderId);
|
|
|
+ checkGLError();
|
|
|
+ statistics.onShaderUse(shader, true);
|
|
|
+ boundShader = shader;
|
|
|
+ context.boundShaderProgram = shaderId;
|
|
|
+ }else{
|
|
|
+ statistics.onShaderUse(shader, false);
|
|
|
+ }
|
|
|
+
|
|
|
+ int loc = uniform.getLocation();
|
|
|
+ if (loc == -1) {
|
|
|
+ if (verboseLogging)
|
|
|
+ logger.warning("no location for uniform [" + uniform.getName() + "]");
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (loc == -2){
|
|
|
+ // get uniform location
|
|
|
+ updateUniformLocation(shader, uniform);
|
|
|
+ if (uniform.getLocation() == -1){
|
|
|
+ // not declared, ignore
|
|
|
+
|
|
|
+ if (verboseLogging)
|
|
|
+ logger.warning("not declared uniform: [" + uniform.getName() + "]");
|
|
|
+
|
|
|
+ uniform.clearUpdateNeeded();
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ loc = uniform.getLocation();
|
|
|
+ }
|
|
|
+
|
|
|
+ if (uniform.getVarType() == null) {
|
|
|
+ logger.warning("value is not set yet.");
|
|
|
+ return; // value not set yet..
|
|
|
+ }
|
|
|
+
|
|
|
+ statistics.onUniformSet();
|
|
|
+
|
|
|
+ uniform.clearUpdateNeeded();
|
|
|
+ FloatBuffer fb;
|
|
|
+ switch (uniform.getVarType()){
|
|
|
+ case Float:
|
|
|
+ if (verboseLogging)
|
|
|
+ logger.info("GLES20.glUniform1f set Float. " + uniform.getName());
|
|
|
+ Float f = (Float)uniform.getValue();
|
|
|
+ GLES20.glUniform1f(loc, f.floatValue());
|
|
|
+ break;
|
|
|
+ case Vector2:
|
|
|
+ if (verboseLogging)
|
|
|
+ logger.info("GLES20.glUniform2f set Vector2. " + uniform.getName());
|
|
|
+ Vector2f v2 = (Vector2f)uniform.getValue();
|
|
|
+ GLES20.glUniform2f(loc, v2.getX(), v2.getY());
|
|
|
+ break;
|
|
|
+ case Vector3:
|
|
|
+ if (verboseLogging)
|
|
|
+ logger.info("GLES20.glUniform3f set Vector3. " + uniform.getName());
|
|
|
+ Vector3f v3 = (Vector3f)uniform.getValue();
|
|
|
+ GLES20.glUniform3f(loc, v3.getX(), v3.getY(), v3.getZ());
|
|
|
+ break;
|
|
|
+ case Vector4:
|
|
|
+ if (verboseLogging)
|
|
|
+ logger.info("GLES20.glUniform4f set Vector4." + uniform.getName());
|
|
|
+ Object val = uniform.getValue();
|
|
|
+ if (val instanceof ColorRGBA){
|
|
|
+ ColorRGBA c = (ColorRGBA) val;
|
|
|
+ GLES20.glUniform4f(loc, c.r, c.g, c.b, c.a);
|
|
|
+ }else{
|
|
|
+ Quaternion c = (Quaternion)uniform.getValue();
|
|
|
+ GLES20.glUniform4f(loc, c.getX(), c.getY(), c.getZ(), c.getW());
|
|
|
+ }
|
|
|
+ break;
|
|
|
+ case Boolean:
|
|
|
+ if (verboseLogging)
|
|
|
+ logger.info("GLES20.glUniform1i set Boolean." + uniform.getName());
|
|
|
+ Boolean b = (Boolean)uniform.getValue();
|
|
|
+ GLES20.glUniform1i(loc, b.booleanValue() ? GLES20.GL_TRUE : GLES20.GL_FALSE);
|
|
|
+ break;
|
|
|
+ case Matrix3:
|
|
|
+ if (verboseLogging)
|
|
|
+ logger.info("GLES20.glUniformMatrix3fv set Matrix3." + uniform.getName());
|
|
|
+ fb = (FloatBuffer)uniform.getValue();
|
|
|
+ assert fb.remaining() == 9;
|
|
|
+ GLES20.glUniformMatrix3fv(loc, 1, false, fb);
|
|
|
+ break;
|
|
|
+ case Matrix4:
|
|
|
+ if (verboseLogging)
|
|
|
+ logger.info("GLES20.glUniformMatrix4fv set Matrix4." + uniform.getName());
|
|
|
+ fb = (FloatBuffer)uniform.getValue();
|
|
|
+ assert fb.remaining() == 16;
|
|
|
+ GLES20.glUniformMatrix4fv(loc, 1, false, fb);
|
|
|
+ break;
|
|
|
+ case FloatArray:
|
|
|
+ if (verboseLogging)
|
|
|
+ logger.info("GLES20.glUniform1fv set FloatArray." + uniform.getName());
|
|
|
+ fb = (FloatBuffer)uniform.getValue();
|
|
|
+ GLES20.glUniform1fv(loc, 1, fb);
|
|
|
+ break;
|
|
|
+ case Vector2Array:
|
|
|
+ if (verboseLogging)
|
|
|
+ logger.info("GLES20.glUniform2fv set Vector2Array." + uniform.getName());
|
|
|
+ fb = (FloatBuffer)uniform.getValue();
|
|
|
+ GLES20.glUniform2fv(loc, 1, fb);
|
|
|
+ break;
|
|
|
+ case Vector3Array:
|
|
|
+ if (verboseLogging)
|
|
|
+ logger.info("GLES20.glUniform3fv set Vector3Array." + uniform.getName());
|
|
|
+ fb = (FloatBuffer)uniform.getValue();
|
|
|
+ GLES20.glUniform3fv(loc, 1, fb);
|
|
|
+ break;
|
|
|
+ case Vector4Array:
|
|
|
+ if (verboseLogging)
|
|
|
+ logger.info("GLES20.glUniform4fv set Vector4Array." + uniform.getName());
|
|
|
+ fb = (FloatBuffer)uniform.getValue();
|
|
|
+ GLES20.glUniform4fv(loc, 1, fb);
|
|
|
+ break;
|
|
|
+ case Matrix4Array:
|
|
|
+ if (verboseLogging)
|
|
|
+ logger.info("GLES20.glUniform4fv set Matrix4Array." + uniform.getName());
|
|
|
+ fb = (FloatBuffer)uniform.getValue();
|
|
|
+ GLES20.glUniformMatrix4fv(loc, 1, false, fb);
|
|
|
+ break;
|
|
|
+ case Int:
|
|
|
+ if (verboseLogging)
|
|
|
+ logger.info("GLES20.glUniform1i set Int." + uniform.getName());
|
|
|
+ Integer i = (Integer)uniform.getValue();
|
|
|
+ GLES20.glUniform1i(loc, i.intValue());
|
|
|
+ break;
|
|
|
+ default:
|
|
|
+ throw new UnsupportedOperationException("Unsupported uniform type: "+uniform.getVarType());
|
|
|
+ }
|
|
|
+ checkGLError();
|
|
|
+ }
|
|
|
+
|
|
|
+ protected void updateShaderUniforms(Shader shader){
|
|
|
+ ListMap<String, Uniform> uniforms = shader.getUniformMap();
|
|
|
+// for (Uniform uniform : shader.getUniforms()){
|
|
|
+ for (int i = 0; i < uniforms.size(); i++){
|
|
|
+ Uniform uniform = uniforms.getValue(i);
|
|
|
+ if (uniform.isUpdateNeeded())
|
|
|
+ updateUniform(shader, uniform);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+
|
|
|
+ protected void resetUniformLocations(Shader shader){
|
|
|
+ ListMap<String, Uniform> uniforms = shader.getUniformMap();
|
|
|
+// for (Uniform uniform : shader.getUniforms()){
|
|
|
+ for (int i = 0; i < uniforms.size(); i++){
|
|
|
+ Uniform uniform = uniforms.getValue(i);
|
|
|
+ uniform.reset(); // e.g check location again
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ /*
|
|
|
+ * (Non-javadoc)
|
|
|
+ * Only used for fixed-function. Ignored.
|
|
|
+ */
|
|
|
+ public void setLighting(LightList list){
|
|
|
+ }
|
|
|
+
|
|
|
+ public int convertShaderType(ShaderType type){
|
|
|
+ switch (type){
|
|
|
+ case Fragment:
|
|
|
+ return GLES20.GL_FRAGMENT_SHADER;
|
|
|
+ case Vertex:
|
|
|
+ return GLES20.GL_VERTEX_SHADER;
|
|
|
+// case Geometry:
|
|
|
+// return ARBGeometryShader4.GL_GEOMETRY_SHADER_ARB;
|
|
|
+ default:
|
|
|
+ throw new RuntimeException("Unrecognized shader type.");
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ public void updateShaderSourceData(ShaderSource source, String language){
|
|
|
+ int id = source.getId();
|
|
|
+ if (id == -1){
|
|
|
+ // create id
|
|
|
+ if (verboseLogging)
|
|
|
+ logger.info("GLES20.glCreateShader(" + source.getType() + ")");
|
|
|
+ id = GLES20.glCreateShader(convertShaderType(source.getType()));
|
|
|
+ checkGLError();
|
|
|
+ if (id <= 0)
|
|
|
+ throw new RendererException("Invalid ID received when trying to create shader.");
|
|
|
+
|
|
|
+ source.setId(id);
|
|
|
+ }
|
|
|
+
|
|
|
+ // upload shader source
|
|
|
+ // merge the defines and source code
|
|
|
+ byte[] versionData = new byte[]{};//"#version 140\n".getBytes();
|
|
|
+// versionData = "#define INSTANCING 1\n".getBytes();
|
|
|
+ byte[] definesCodeData = source.getDefines().getBytes();
|
|
|
+ byte[] sourceCodeData = source.getSource().getBytes();
|
|
|
+ ByteBuffer codeBuf = BufferUtils.createByteBuffer(versionData.length
|
|
|
+ + definesCodeData.length
|
|
|
+ + sourceCodeData.length);
|
|
|
+ codeBuf.put(versionData);
|
|
|
+ codeBuf.put(definesCodeData);
|
|
|
+ codeBuf.put(sourceCodeData);
|
|
|
+ codeBuf.flip();
|
|
|
+
|
|
|
+ if (verboseLogging)
|
|
|
+ logger.info("GLES20.glShaderSource("+ id + ")");
|
|
|
+
|
|
|
+ GLES20.glShaderSource(
|
|
|
+ id,
|
|
|
+ "precision mediump float;\n" +
|
|
|
+ source.getDefines() +
|
|
|
+ source.getSource()
|
|
|
+ );
|
|
|
+
|
|
|
+ checkGLError();
|
|
|
+
|
|
|
+ if (verboseLogging)
|
|
|
+ logger.info("GLES20.glCompileShader(" + id + ")");
|
|
|
+
|
|
|
+ GLES20.glCompileShader(id);
|
|
|
+
|
|
|
+ checkGLError();
|
|
|
+
|
|
|
+ if (verboseLogging)
|
|
|
+ logger.info("GLES20.glGetShaderiv(" + id + ", GLES20.GL_COMPILE_STATUS)");
|
|
|
+
|
|
|
+ GLES20.glGetShaderiv(id, GLES20.GL_COMPILE_STATUS, intBuf1);
|
|
|
+
|
|
|
+ checkGLError();
|
|
|
+
|
|
|
+ boolean compiledOK = intBuf1.get(0) == GLES20.GL_TRUE;
|
|
|
+ String infoLog = null;
|
|
|
+
|
|
|
+ if (VALIDATE_SHADER || !compiledOK){
|
|
|
+ // even if compile succeeded, check
|
|
|
+ // log for warnings
|
|
|
+ if (verboseLogging)
|
|
|
+ logger.info("GLES20.glGetShaderiv()");
|
|
|
+ GLES20.glGetShaderiv(id, GLES20.GL_INFO_LOG_LENGTH, intBuf1);
|
|
|
+ checkGLError();
|
|
|
+ int length = intBuf1.get(0);
|
|
|
+ if (length > 3){
|
|
|
+ // get infos
|
|
|
+ ByteBuffer logBuf = BufferUtils.createByteBuffer(length);
|
|
|
+ if (verboseLogging)
|
|
|
+ logger.info("GLES20.glGetShaderInfoLog(" + id + ")");
|
|
|
+ infoLog = GLES20.glGetShaderInfoLog(id);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ if (compiledOK){
|
|
|
+ if (infoLog != null){
|
|
|
+ logger.log(Level.INFO, "compile success: " + source.getName() + ", " + infoLog);
|
|
|
+ }else{
|
|
|
+ logger.log(Level.FINE, "compile success: " + source.getName());
|
|
|
+ }
|
|
|
+ }else{
|
|
|
+ if (infoLog != null){
|
|
|
+ logger.log(Level.WARNING, "compile error: " + source.getName() + ", " + infoLog);
|
|
|
+ }else{
|
|
|
+ logger.log(Level.WARNING, "compile error: " + source.getName());
|
|
|
+ }
|
|
|
+ logger.log(Level.WARNING, source.getDefines() + "\n" + source.getSource());
|
|
|
+ }
|
|
|
+
|
|
|
+ source.clearUpdateNeeded();
|
|
|
+ // only usable if compiled
|
|
|
+ source.setUsable(compiledOK);
|
|
|
+ if (!compiledOK){
|
|
|
+ // make sure to dispose id cause all program's
|
|
|
+ // shaders will be cleared later.
|
|
|
+ if (verboseLogging)
|
|
|
+ logger.info("GLES20.glDeleteShader(" + id + ")");
|
|
|
+ GLES20.glDeleteShader(id);
|
|
|
+ checkGLError();
|
|
|
+ }else{
|
|
|
+ // register for cleanup since the ID is usable
|
|
|
+ objManager.registerForCleanup(source);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ public void updateShaderData(Shader shader){
|
|
|
+ int id = shader.getId();
|
|
|
+ boolean needRegister = false;
|
|
|
+ if (id == -1){
|
|
|
+ // create program
|
|
|
+
|
|
|
+ if (verboseLogging)
|
|
|
+ logger.info("GLES20.glCreateProgram()");
|
|
|
+
|
|
|
+ id = GLES20.glCreateProgram();
|
|
|
+
|
|
|
+ if (id <= 0)
|
|
|
+ throw new RendererException("Invalid ID received when trying to create shader program.");
|
|
|
+
|
|
|
+ shader.setId(id);
|
|
|
+ needRegister = true;
|
|
|
+ }
|
|
|
+
|
|
|
+ for (ShaderSource source : shader.getSources()){
|
|
|
+ if (source.isUpdateNeeded()){
|
|
|
+ updateShaderSourceData(source, shader.getLanguage());
|
|
|
+ // shader has been compiled here
|
|
|
+ }
|
|
|
+
|
|
|
+ if (!source.isUsable()){
|
|
|
+ // it's useless.. just forget about everything..
|
|
|
+ shader.setUsable(false);
|
|
|
+ shader.clearUpdateNeeded();
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ if (verboseLogging)
|
|
|
+ logger.info("GLES20.glAttachShader(" + id + ", " + source.getId() + ")");
|
|
|
+
|
|
|
+ GLES20.glAttachShader(id, source.getId());
|
|
|
+ }
|
|
|
+
|
|
|
+ // link shaders to program
|
|
|
+ if (verboseLogging)
|
|
|
+ logger.info("GLES20.glLinkProgram(" + id + ")");
|
|
|
+
|
|
|
+ GLES20.glLinkProgram(id);
|
|
|
+
|
|
|
+
|
|
|
+ if (verboseLogging)
|
|
|
+ logger.info("GLES20.glGetProgramiv(" + id + ")");
|
|
|
+
|
|
|
+ GLES20.glGetProgramiv(id, GLES20.GL_LINK_STATUS, intBuf1);
|
|
|
+
|
|
|
+ boolean linkOK = intBuf1.get(0) == GLES20.GL_TRUE;
|
|
|
+ String infoLog = null;
|
|
|
+
|
|
|
+ if (VALIDATE_SHADER || !linkOK){
|
|
|
+ if (verboseLogging)
|
|
|
+ logger.info("GLES20.glGetProgramiv(" + id + ", GLES20.GL_INFO_LOG_LENGTH, buffer)");
|
|
|
+
|
|
|
+ GLES20.glGetProgramiv(id, GLES20.GL_INFO_LOG_LENGTH, intBuf1);
|
|
|
+
|
|
|
+ int length = intBuf1.get(0);
|
|
|
+ if (length > 3){
|
|
|
+ // get infos
|
|
|
+
|
|
|
+ if (verboseLogging)
|
|
|
+ logger.info("GLES20.glGetProgramInfoLog(" + id + ")");
|
|
|
+
|
|
|
+ infoLog = GLES20.glGetProgramInfoLog(id);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ if (linkOK){
|
|
|
+ if (infoLog != null){
|
|
|
+ logger.log(Level.INFO, "shader link success. \n{0}", infoLog);
|
|
|
+ }else{
|
|
|
+ logger.fine("shader link success");
|
|
|
+ }
|
|
|
+ }else{
|
|
|
+ if (infoLog != null){
|
|
|
+ logger.log(Level.WARNING, "shader link failure. \n{0}", infoLog);
|
|
|
+ }else{
|
|
|
+ logger.warning("shader link failure");
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ shader.clearUpdateNeeded();
|
|
|
+ if (!linkOK){
|
|
|
+ // failure.. forget about everything
|
|
|
+ shader.resetSources();
|
|
|
+ shader.setUsable(false);
|
|
|
+ deleteShader(shader);
|
|
|
+ }else{
|
|
|
+ shader.setUsable(true);
|
|
|
+ if (needRegister){
|
|
|
+ objManager.registerForCleanup(shader);
|
|
|
+ statistics.onNewShader();
|
|
|
+ }else{
|
|
|
+ // OpenGL spec: uniform locations may change after re-link
|
|
|
+ resetUniformLocations(shader);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ public void setShader(Shader shader){
|
|
|
+ if (verboseLogging)
|
|
|
+ logger.info("setShader(" + shader + ")");
|
|
|
+
|
|
|
+ if (shader == null){
|
|
|
+ if (context.boundShaderProgram > 0){
|
|
|
+
|
|
|
+ if (verboseLogging)
|
|
|
+ logger.info("GLES20.glUseProgram(0)");
|
|
|
+
|
|
|
+ GLES20.glUseProgram(0);
|
|
|
+
|
|
|
+ statistics.onShaderUse(null, true);
|
|
|
+ context.boundShaderProgram = 0;
|
|
|
+ boundShader = null;
|
|
|
+ }
|
|
|
+ } else {
|
|
|
+ if (shader.isUpdateNeeded())
|
|
|
+ updateShaderData(shader);
|
|
|
+
|
|
|
+ // NOTE: might want to check if any of the
|
|
|
+ // sources need an update?
|
|
|
+
|
|
|
+ if (!shader.isUsable()) {
|
|
|
+ logger.warning("shader is not usable.");
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ assert shader.getId() > 0;
|
|
|
+
|
|
|
+ updateShaderUniforms(shader);
|
|
|
+ if (context.boundShaderProgram != shader.getId()){
|
|
|
+ if (VALIDATE_SHADER){
|
|
|
+ // check if shader can be used
|
|
|
+ // with current state
|
|
|
+ if (verboseLogging)
|
|
|
+ logger.info("GLES20.glValidateProgram(" + shader.getId() + ")");
|
|
|
+
|
|
|
+ GLES20.glValidateProgram(shader.getId());
|
|
|
+
|
|
|
+ if (verboseLogging)
|
|
|
+ logger.info("GLES20.glGetProgramiv(" + shader.getId() + ", GLES20.GL_VALIDATE_STATUS, buffer)");
|
|
|
+
|
|
|
+ GLES20.glGetProgramiv(shader.getId(), GLES20.GL_VALIDATE_STATUS, intBuf1);
|
|
|
+
|
|
|
+ boolean validateOK = intBuf1.get(0) == GLES20.GL_TRUE;
|
|
|
+
|
|
|
+ if (validateOK){
|
|
|
+ logger.fine("shader validate success");
|
|
|
+ }else{
|
|
|
+ logger.warning("shader validate failure");
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ if (verboseLogging)
|
|
|
+ logger.info("GLES20.glUseProgram(" + shader.getId() + ")");
|
|
|
+
|
|
|
+ GLES20.glUseProgram(shader.getId());
|
|
|
+
|
|
|
+ statistics.onShaderUse(shader, true);
|
|
|
+ context.boundShaderProgram = shader.getId();
|
|
|
+ boundShader = shader;
|
|
|
+ }else{
|
|
|
+ statistics.onShaderUse(shader, false);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ public void deleteShaderSource(ShaderSource source){
|
|
|
+ if (source.getId() < 0){
|
|
|
+ logger.warning("Shader source is not uploaded to GPU, cannot delete.");
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ source.setUsable(false);
|
|
|
+ source.clearUpdateNeeded();
|
|
|
+
|
|
|
+ if (verboseLogging)
|
|
|
+ logger.info("GLES20.glDeleteShader(" + source.getId() + ")");
|
|
|
+
|
|
|
+ GLES20.glDeleteShader(source.getId());
|
|
|
+ source.resetObject();
|
|
|
+ }
|
|
|
+
|
|
|
+ public void deleteShader(Shader shader){
|
|
|
+ if (shader.getId() == -1){
|
|
|
+ logger.warning("Shader is not uploaded to GPU, cannot delete.");
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ for (ShaderSource source : shader.getSources()){
|
|
|
+ if (source.getId() != -1){
|
|
|
+
|
|
|
+ if (verboseLogging)
|
|
|
+ logger.info("GLES20.glDetachShader(" + shader.getId() + ", " + source.getId() + ")");
|
|
|
+
|
|
|
+ GLES20.glDetachShader(shader.getId(), source.getId());
|
|
|
+ // the next part is done by the GLObjectManager automatically
|
|
|
+// glDeleteShader(source.getId());
|
|
|
+ }
|
|
|
+ }
|
|
|
+ // kill all references so sources can be collected
|
|
|
+ // if needed.
|
|
|
+ shader.resetSources();
|
|
|
+
|
|
|
+ if (verboseLogging)
|
|
|
+ logger.info("GLES20.glDeleteProgram(" + shader.getId() + ")");
|
|
|
+
|
|
|
+ GLES20.glDeleteProgram(shader.getId());
|
|
|
+
|
|
|
+ statistics.onDeleteShader();
|
|
|
+ }
|
|
|
+
|
|
|
+ /*********************************************************************\
|
|
|
+ |* Framebuffers *|
|
|
|
+ \*********************************************************************/
|
|
|
+
|
|
|
+ public void copyFrameBuffer(FrameBuffer src, FrameBuffer dst){
|
|
|
+ logger.warning("copyFrameBuffer is not supported.");
|
|
|
+ }
|
|
|
+/*
|
|
|
+ public void copyFrameBuffer(FrameBuffer src, FrameBuffer dst){
|
|
|
+ if (GLContext.getCapabilities().GL_EXT_framebuffer_blit){
|
|
|
+ int srcW = 0;
|
|
|
+ int srcH = 0;
|
|
|
+ int dstW = 0;
|
|
|
+ int dstH = 0;
|
|
|
+ int prevFBO = context.boundFBO;
|
|
|
+
|
|
|
+ if (src != null && src.isUpdateNeeded())
|
|
|
+ updateFrameBuffer(src);
|
|
|
+
|
|
|
+ if (dst != null && dst.isUpdateNeeded())
|
|
|
+ updateFrameBuffer(dst);
|
|
|
+
|
|
|
+ if (src == null){
|
|
|
+ glBindFramebufferEXT(GL_READ_FRAMEBUFFER_EXT, 0);
|
|
|
+// srcW = viewWidth;
|
|
|
+// srcH = viewHeight;
|
|
|
+ }else{
|
|
|
+ glBindFramebufferEXT(GL_READ_FRAMEBUFFER_EXT, src.getId());
|
|
|
+ srcW = src.getWidth();
|
|
|
+ srcH = src.getHeight();
|
|
|
+ }
|
|
|
+ if (dst == null){
|
|
|
+ glBindFramebufferEXT(GL_DRAW_FRAMEBUFFER_EXT, 0);
|
|
|
+// dstW = viewWidth;
|
|
|
+// dstH = viewHeight;
|
|
|
+ }else{
|
|
|
+ glBindFramebufferEXT(GL_DRAW_FRAMEBUFFER_EXT, dst.getId());
|
|
|
+ dstW = dst.getWidth();
|
|
|
+ dstH = dst.getHeight();
|
|
|
+ }
|
|
|
+ glBlitFramebufferEXT(0, 0, srcW, srcH,
|
|
|
+ 0, 0, dstW, dstH,
|
|
|
+ GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT,
|
|
|
+ GL_NEAREST);
|
|
|
+
|
|
|
+ glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, prevFBO);
|
|
|
+ try {
|
|
|
+ checkFrameBufferError();
|
|
|
+ } catch (IllegalStateException ex){
|
|
|
+ logger.log(Level.SEVERE, "Source FBO:\n{0}", src);
|
|
|
+ logger.log(Level.SEVERE, "Dest FBO:\n{0}", dst);
|
|
|
+ throw ex;
|
|
|
+ }
|
|
|
+ }else{
|
|
|
+ throw new UnsupportedOperationException("EXT_framebuffer_blit required.");
|
|
|
+ // TODO: support non-blit copies?
|
|
|
+ }
|
|
|
+ }
|
|
|
+*/
|
|
|
+ private void checkFrameBufferError() {
|
|
|
+ logger.warning("checkFrameBufferError is not supported.");
|
|
|
+ }
|
|
|
+/*
|
|
|
+ private void checkFrameBufferError() {
|
|
|
+ int status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT);
|
|
|
+ switch (status) {
|
|
|
+ case GL_FRAMEBUFFER_COMPLETE_EXT:
|
|
|
+ break;
|
|
|
+ case GL_FRAMEBUFFER_UNSUPPORTED_EXT:
|
|
|
+ //Choose different formats
|
|
|
+ throw new IllegalStateException("Framebuffer object format is " +
|
|
|
+ "unsupported by the video hardware.");
|
|
|
+ case GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT:
|
|
|
+ throw new IllegalStateException("Framebuffer has erronous attachment.");
|
|
|
+ case GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT:
|
|
|
+ throw new IllegalStateException("Framebuffer is missing required attachment.");
|
|
|
+ case GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT:
|
|
|
+ throw new IllegalStateException("Framebuffer attachments must have same dimensions.");
|
|
|
+ case GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT:
|
|
|
+ throw new IllegalStateException("Framebuffer attachments must have same formats.");
|
|
|
+ case GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT:
|
|
|
+ throw new IllegalStateException("Incomplete draw buffer.");
|
|
|
+ case GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT:
|
|
|
+ throw new IllegalStateException("Incomplete read buffer.");
|
|
|
+ case GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_EXT:
|
|
|
+ throw new IllegalStateException("Incomplete multisample buffer.");
|
|
|
+ default:
|
|
|
+ //Programming error; will fail on all hardware
|
|
|
+ throw new IllegalStateException("Some video driver error " +
|
|
|
+ "or programming error occured. " +
|
|
|
+ "Framebuffer object status is invalid. ");
|
|
|
+ }
|
|
|
+ }
|
|
|
+*/
|
|
|
+ private void updateRenderBuffer(FrameBuffer fb, RenderBuffer rb){
|
|
|
+ logger.warning("updateRenderBuffer is not supported.");
|
|
|
+ }
|
|
|
+/*
|
|
|
+ private void updateRenderBuffer(FrameBuffer fb, RenderBuffer rb){
|
|
|
+ int id = rb.getId();
|
|
|
+ if (id == -1){
|
|
|
+ glGenRenderbuffersEXT(intBuf1);
|
|
|
+ id = intBuf1.get(0);
|
|
|
+ rb.setId(id);
|
|
|
+ }
|
|
|
+
|
|
|
+ if (context.boundRB != id){
|
|
|
+ glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, id);
|
|
|
+ context.boundRB = id;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (fb.getWidth() > maxRBSize || fb.getHeight() > maxRBSize)
|
|
|
+ throw new UnsupportedOperationException("Resolution "+fb.getWidth()+
|
|
|
+ ":"+fb.getHeight()+" is not supported.");
|
|
|
+
|
|
|
+ if (fb.getSamples() > 0 && GLContext.getCapabilities().GL_EXT_framebuffer_multisample){
|
|
|
+ int samples = fb.getSamples();
|
|
|
+ if (maxFBOSamples < samples){
|
|
|
+ samples = maxFBOSamples;
|
|
|
+ }
|
|
|
+ glRenderbufferStorageMultisampleEXT(GL_RENDERBUFFER_EXT,
|
|
|
+ samples,
|
|
|
+ TextureUtil.convertTextureFormat(rb.getFormat()),
|
|
|
+ fb.getWidth(),
|
|
|
+ fb.getHeight());
|
|
|
+ }else{
|
|
|
+ glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT,
|
|
|
+ TextureUtil.convertTextureFormat(rb.getFormat()),
|
|
|
+ fb.getWidth(),
|
|
|
+ fb.getHeight());
|
|
|
+ }
|
|
|
+ }
|
|
|
+*/
|
|
|
+ private int convertAttachmentSlot(int attachmentSlot){
|
|
|
+ logger.warning("convertAttachmentSlot is not supported.");
|
|
|
+ return -1;
|
|
|
+ }
|
|
|
+/*
|
|
|
+ private int convertAttachmentSlot(int attachmentSlot){
|
|
|
+ // can also add support for stencil here
|
|
|
+ if (attachmentSlot == -100){
|
|
|
+ return GL_DEPTH_ATTACHMENT_EXT;
|
|
|
+ }else if (attachmentSlot < 0 || attachmentSlot >= 16){
|
|
|
+ throw new UnsupportedOperationException("Invalid FBO attachment slot: "+attachmentSlot);
|
|
|
+ }
|
|
|
+
|
|
|
+ return GL_COLOR_ATTACHMENT0_EXT + attachmentSlot;
|
|
|
+ }
|
|
|
+*/
|
|
|
+
|
|
|
+ public void updateRenderTexture(FrameBuffer fb, RenderBuffer rb){
|
|
|
+ logger.warning("updateRenderTexture is not supported.");
|
|
|
+ }
|
|
|
+/*
|
|
|
+ public void updateRenderTexture(FrameBuffer fb, RenderBuffer rb){
|
|
|
+ Texture tex = rb.getTexture();
|
|
|
+ Image image = tex.getImage();
|
|
|
+ if (image.isUpdateNeeded())
|
|
|
+ updateTexImageData(image, tex.getType(), tex.getMinFilter().usesMipMapLevels());
|
|
|
+
|
|
|
+ glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT,
|
|
|
+ convertAttachmentSlot(rb.getSlot()),
|
|
|
+ convertTextureType(tex.getType()),
|
|
|
+ image.getId(),
|
|
|
+ 0);
|
|
|
+ }
|
|
|
+*/
|
|
|
+ public void updateFrameBufferAttachment(FrameBuffer fb, RenderBuffer rb){
|
|
|
+ logger.warning("updateFrameBufferAttachment is not supported.");
|
|
|
+ }
|
|
|
+/*
|
|
|
+ public void updateFrameBufferAttachment(FrameBuffer fb, RenderBuffer rb){
|
|
|
+ boolean needAttach;
|
|
|
+ if (rb.getTexture() == null){
|
|
|
+ // if it hasn't been created yet, then attach is required.
|
|
|
+ needAttach = rb.getId() == -1;
|
|
|
+ updateRenderBuffer(fb, rb);
|
|
|
+ }else{
|
|
|
+ needAttach = false;
|
|
|
+ updateRenderTexture(fb, rb);
|
|
|
+ }
|
|
|
+ if (needAttach){
|
|
|
+ glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT,
|
|
|
+ convertAttachmentSlot(rb.getSlot()),
|
|
|
+ GL_RENDERBUFFER_EXT,
|
|
|
+ rb.getId());
|
|
|
+ }
|
|
|
+ }
|
|
|
+*/
|
|
|
+ public void updateFrameBuffer(FrameBuffer fb) {
|
|
|
+ logger.warning("updateFrameBuffer is not supported.");
|
|
|
+ }
|
|
|
+/*
|
|
|
+ public void updateFrameBuffer(FrameBuffer fb) {
|
|
|
+ int id = fb.getId();
|
|
|
+ if (id == -1){
|
|
|
+ // create FBO
|
|
|
+ glGenFramebuffersEXT(intBuf1);
|
|
|
+ id = intBuf1.get(0);
|
|
|
+ fb.setId(id);
|
|
|
+ objManager.registerForCleanup(fb);
|
|
|
+
|
|
|
+ statistics.onNewFrameBuffer();
|
|
|
+ }
|
|
|
+
|
|
|
+ if (context.boundFBO != id){
|
|
|
+ glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, id);
|
|
|
+ // binding an FBO automatically sets draw buf to GL_COLOR_ATTACHMENT0
|
|
|
+ context.boundDrawBuf = 0;
|
|
|
+ context.boundFBO = id;
|
|
|
+ }
|
|
|
+
|
|
|
+ FrameBuffer.RenderBuffer depthBuf = fb.getDepthBuffer();
|
|
|
+ if (depthBuf != null){
|
|
|
+ updateFrameBufferAttachment(fb, depthBuf);
|
|
|
+ }
|
|
|
+
|
|
|
+ for (int i = 0; i < fb.getNumColorBuffers(); i++){
|
|
|
+ FrameBuffer.RenderBuffer colorBuf = fb.getColorBuffer(i);
|
|
|
+ updateFrameBufferAttachment(fb, colorBuf);
|
|
|
+ }
|
|
|
+
|
|
|
+ fb.clearUpdateNeeded();
|
|
|
+ }
|
|
|
+*/
|
|
|
+ public void setFrameBuffer(FrameBuffer fb) {
|
|
|
+ if (verboseLogging)
|
|
|
+ logger.warning("setFrameBuffer is not supported.");
|
|
|
+ }
|
|
|
+/*
|
|
|
+ public void setFrameBuffer(FrameBuffer fb) {
|
|
|
+ if (lastFb == fb)
|
|
|
+ return;
|
|
|
+
|
|
|
+ // generate mipmaps for last FB if needed
|
|
|
+ if (lastFb != null){
|
|
|
+ for (int i = 0; i < lastFb.getNumColorBuffers(); i++){
|
|
|
+ RenderBuffer rb = lastFb.getColorBuffer(i);
|
|
|
+ Texture tex = rb.getTexture();
|
|
|
+ if (tex != null
|
|
|
+ && tex.getMinFilter().usesMipMapLevels()){
|
|
|
+ setTexture(0, rb.getTexture());
|
|
|
+ glGenerateMipmapEXT(convertTextureType(tex.getType()));
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+
|
|
|
+ if (fb == null){
|
|
|
+ // unbind any fbos
|
|
|
+ if (context.boundFBO != 0){
|
|
|
+ glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
|
|
|
+ statistics.onFrameBufferUse(null, true);
|
|
|
+
|
|
|
+ context.boundFBO = 0;
|
|
|
+ }
|
|
|
+ // select back buffer
|
|
|
+ if (context.boundDrawBuf != -1){
|
|
|
+ glDrawBuffer(initialDrawBuf);
|
|
|
+ context.boundDrawBuf = -1;
|
|
|
+ }
|
|
|
+ if (context.boundReadBuf != -1){
|
|
|
+ glReadBuffer(initialReadBuf);
|
|
|
+ context.boundReadBuf = -1;
|
|
|
+ }
|
|
|
+
|
|
|
+ lastFb = null;
|
|
|
+ }else{
|
|
|
+ if (fb.isUpdateNeeded())
|
|
|
+ updateFrameBuffer(fb);
|
|
|
+
|
|
|
+ if (context.boundFBO != fb.getId()){
|
|
|
+ glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fb.getId());
|
|
|
+ statistics.onFrameBufferUse(fb, true);
|
|
|
+
|
|
|
+ // update viewport to reflect framebuffer's resolution
|
|
|
+ setViewPort(0, 0, fb.getWidth(), fb.getHeight());
|
|
|
+
|
|
|
+ context.boundFBO = fb.getId();
|
|
|
+ }else{
|
|
|
+ statistics.onFrameBufferUse(fb, false);
|
|
|
+ }
|
|
|
+ if (fb.getNumColorBuffers() == 0){
|
|
|
+ // make sure to select NONE as draw buf
|
|
|
+ // no color buffer attached. select NONE
|
|
|
+ if (context.boundDrawBuf != -2){
|
|
|
+ glDrawBuffer(GL_NONE);
|
|
|
+ context.boundDrawBuf = -2;
|
|
|
+ }
|
|
|
+ if (context.boundReadBuf != -2){
|
|
|
+ glReadBuffer(GL_NONE);
|
|
|
+ context.boundReadBuf = -2;
|
|
|
+ }
|
|
|
+ }else{
|
|
|
+ if (fb.isMultiTarget()){
|
|
|
+ if (fb.getNumColorBuffers() > maxMRTFBOAttachs)
|
|
|
+ throw new UnsupportedOperationException("Framebuffer has more"
|
|
|
+ + " targets than are supported"
|
|
|
+ + " on the system!");
|
|
|
+
|
|
|
+ if (context.boundDrawBuf != 100 + fb.getNumColorBuffers()){
|
|
|
+ intBuf16.clear();
|
|
|
+ for (int i = 0; i < fb.getNumColorBuffers(); i++)
|
|
|
+ intBuf16.put( GL_COLOR_ATTACHMENT0_EXT + i );
|
|
|
+
|
|
|
+ intBuf16.flip();
|
|
|
+ glDrawBuffers(intBuf16);
|
|
|
+ context.boundDrawBuf = 100 + fb.getNumColorBuffers();
|
|
|
+ }
|
|
|
+ }else{
|
|
|
+ RenderBuffer rb = fb.getColorBuffer(fb.getTargetIndex());
|
|
|
+ // select this draw buffer
|
|
|
+ if (context.boundDrawBuf != rb.getSlot()){
|
|
|
+ glDrawBuffer(GL_COLOR_ATTACHMENT0_EXT + rb.getSlot());
|
|
|
+ context.boundDrawBuf = rb.getSlot();
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ assert fb.getId() >= 0;
|
|
|
+ assert context.boundFBO == fb.getId();
|
|
|
+ lastFb = fb;
|
|
|
+ }
|
|
|
+
|
|
|
+ try {
|
|
|
+ checkFrameBufferError();
|
|
|
+ } catch (IllegalStateException ex){
|
|
|
+ logger.log(Level.SEVERE, "Problem FBO:\n{0}", fb);
|
|
|
+ throw ex;
|
|
|
+ }
|
|
|
+ }
|
|
|
+*/
|
|
|
+ public void readFrameBuffer(FrameBuffer fb, ByteBuffer byteBuf){
|
|
|
+ logger.warning("readFrameBuffer is not supported.");
|
|
|
+ }
|
|
|
+/*
|
|
|
+ public void readFrameBuffer(FrameBuffer fb, ByteBuffer byteBuf){
|
|
|
+ if (fb != null){
|
|
|
+ RenderBuffer rb = fb.getColorBuffer();
|
|
|
+ if (rb == null)
|
|
|
+ throw new IllegalArgumentException("Specified framebuffer" +
|
|
|
+ " does not have a colorbuffer");
|
|
|
+
|
|
|
+ setFrameBuffer(fb);
|
|
|
+ if (context.boundReadBuf != rb.getSlot()){
|
|
|
+ glReadBuffer(GL_COLOR_ATTACHMENT0_EXT + rb.getSlot());
|
|
|
+ context.boundReadBuf = rb.getSlot();
|
|
|
+ }
|
|
|
+ }else{
|
|
|
+ setFrameBuffer(null);
|
|
|
+ }
|
|
|
+
|
|
|
+ glReadPixels(vpX, vpY, vpW, vpH, GL_RGBA GL_BGRA, GL_UNSIGNED_BYTE, byteBuf);
|
|
|
+ }
|
|
|
+*/
|
|
|
+ private void deleteRenderBuffer(FrameBuffer fb, RenderBuffer rb){
|
|
|
+ logger.warning("deleteRenderBuffer is not supported.");
|
|
|
+ }
|
|
|
+/*
|
|
|
+ private void deleteRenderBuffer(FrameBuffer fb, RenderBuffer rb){
|
|
|
+ intBuf1.put(0, rb.getId());
|
|
|
+ glDeleteRenderbuffersEXT(intBuf1);
|
|
|
+ }
|
|
|
+*/
|
|
|
+ public void deleteFrameBuffer(FrameBuffer fb) {
|
|
|
+ logger.warning("deleteFrameBuffer is not supported.");
|
|
|
+ }
|
|
|
+/*
|
|
|
+ public void deleteFrameBuffer(FrameBuffer fb) {
|
|
|
+ if (fb.getId() != -1){
|
|
|
+ if (context.boundFBO == fb.getId()){
|
|
|
+ glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
|
|
|
+ context.boundFBO = 0;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (fb.getDepthBuffer() != null){
|
|
|
+ deleteRenderBuffer(fb, fb.getDepthBuffer());
|
|
|
+ }
|
|
|
+ if (fb.getColorBuffer() != null){
|
|
|
+ deleteRenderBuffer(fb, fb.getColorBuffer());
|
|
|
+ }
|
|
|
+
|
|
|
+ intBuf1.put(0, fb.getId());
|
|
|
+ glDeleteFramebuffersEXT(intBuf1);
|
|
|
+ fb.resetObject();
|
|
|
+
|
|
|
+ statistics.onDeleteFrameBuffer();
|
|
|
+ }
|
|
|
+ }
|
|
|
+*/
|
|
|
+
|
|
|
+ /*********************************************************************\
|
|
|
+ |* Textures *|
|
|
|
+ \*********************************************************************/
|
|
|
+ private int convertTextureType(Texture.Type type){
|
|
|
+ switch (type){
|
|
|
+ case TwoDimensional:
|
|
|
+ return GLES20.GL_TEXTURE_2D;
|
|
|
+ // case TwoDimensionalArray:
|
|
|
+ // return EXTTextureArray.GL_TEXTURE_2D_ARRAY_EXT;
|
|
|
+// case ThreeDimensional:
|
|
|
+ // return GLES20.GL_TEXTURE_3D;
|
|
|
+ case CubeMap:
|
|
|
+ return GLES20.GL_TEXTURE_CUBE_MAP;
|
|
|
+ default:
|
|
|
+ throw new UnsupportedOperationException("Unknown texture type: "+type);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ private int convertMagFilter(Texture.MagFilter filter){
|
|
|
+ switch (filter){
|
|
|
+ case Bilinear:
|
|
|
+ return GLES20.GL_LINEAR;
|
|
|
+ case Nearest:
|
|
|
+ return GLES20.GL_NEAREST;
|
|
|
+ default:
|
|
|
+ throw new UnsupportedOperationException("Unknown mag filter: "+filter);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ private int convertMinFilter(Texture.MinFilter filter){
|
|
|
+ switch (filter){
|
|
|
+ case Trilinear:
|
|
|
+ return GLES20.GL_LINEAR_MIPMAP_LINEAR;
|
|
|
+ case BilinearNearestMipMap:
|
|
|
+ return GLES20.GL_LINEAR_MIPMAP_NEAREST;
|
|
|
+ case NearestLinearMipMap:
|
|
|
+ return GLES20.GL_NEAREST_MIPMAP_LINEAR;
|
|
|
+ case NearestNearestMipMap:
|
|
|
+ return GLES20.GL_NEAREST_MIPMAP_NEAREST;
|
|
|
+ case BilinearNoMipMaps:
|
|
|
+ return GLES20.GL_LINEAR;
|
|
|
+ case NearestNoMipMaps:
|
|
|
+ return GLES20.GL_NEAREST;
|
|
|
+ default:
|
|
|
+ throw new UnsupportedOperationException("Unknown min filter: "+filter);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ private int convertWrapMode(Texture.WrapMode mode){
|
|
|
+ switch (mode){
|
|
|
+// case BorderClamp:
|
|
|
+// return GLES20.GL_CLAMP_TO_BORDER;
|
|
|
+// case Clamp:
|
|
|
+// return GLES20.GL_CLAMP;
|
|
|
+ case EdgeClamp:
|
|
|
+ return GLES20.GL_CLAMP_TO_EDGE;
|
|
|
+ case Repeat:
|
|
|
+ return GLES20.GL_REPEAT;
|
|
|
+ case MirroredRepeat:
|
|
|
+ return GLES20.GL_MIRRORED_REPEAT;
|
|
|
+ default:
|
|
|
+ throw new UnsupportedOperationException("Unknown wrap mode: "+mode);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ private void setupTextureParams(Texture tex){
|
|
|
+ int target = convertTextureType(tex.getType());
|
|
|
+
|
|
|
+ // filter things
|
|
|
+ int minFilter = convertMinFilter(tex.getMinFilter());
|
|
|
+ int magFilter = convertMagFilter(tex.getMagFilter());
|
|
|
+
|
|
|
+ if (verboseLogging)
|
|
|
+ logger.info("GLES20.glTexParameteri(" + target + ", GLES20.GL_TEXTURE_MIN_FILTER, " + minFilter + ")");
|
|
|
+
|
|
|
+ GLES20.glTexParameteri(target, GLES20.GL_TEXTURE_MIN_FILTER, minFilter);
|
|
|
+
|
|
|
+ if (verboseLogging)
|
|
|
+ logger.info("GLES20.glTexParameteri(" + target + ", GLES20.GL_TEXTURE_MAG_FILTER, " + magFilter + ")");
|
|
|
+
|
|
|
+ GLES20.glTexParameteri(target, GLES20.GL_TEXTURE_MAG_FILTER, magFilter);
|
|
|
+
|
|
|
+ if (tex.getAnisotropicFilter() > 1){
|
|
|
+/*
|
|
|
+ if (GLContext.getCapabilities().GL_EXT_texture_filter_anisotropic){
|
|
|
+ glTexParameterf(target,
|
|
|
+ EXTTextureFilterAnisotropic.GL_TEXTURE_MAX_ANISOTROPY_EXT,
|
|
|
+ tex.getAnisotropicFilter());
|
|
|
+ }
|
|
|
+*/
|
|
|
+ }
|
|
|
+ // repeat modes
|
|
|
+
|
|
|
+ switch (tex.getType()){
|
|
|
+ case ThreeDimensional:
|
|
|
+ case CubeMap: // cubemaps use 3D coords
|
|
|
+// GLES20.glTexParameteri(target, GLES20.GL_TEXTURE_WRAP_R, convertWrapMode(tex.getWrap(WrapAxis.R)));
|
|
|
+ case TwoDimensional:
|
|
|
+ case TwoDimensionalArray:
|
|
|
+
|
|
|
+ if (verboseLogging)
|
|
|
+ logger.info("GLES20.glTexParameteri(" + target + ", GLES20.GL_TEXTURE_WRAP_T, " + convertWrapMode(tex.getWrap(WrapAxis.T)));
|
|
|
+
|
|
|
+ GLES20.glTexParameteri(target, GLES20.GL_TEXTURE_WRAP_T, convertWrapMode(tex.getWrap(WrapAxis.T)));
|
|
|
+ // fall down here is intentional..
|
|
|
+// case OneDimensional:
|
|
|
+
|
|
|
+ if (verboseLogging)
|
|
|
+ logger.info("GLES20.glTexParameteri(" + target + ", GLES20.GL_TEXTURE_WRAP_S, " + convertWrapMode(tex.getWrap(WrapAxis.S)));
|
|
|
+
|
|
|
+ GLES20.glTexParameteri(target, GLES20.GL_TEXTURE_WRAP_S, convertWrapMode(tex.getWrap(WrapAxis.S)));
|
|
|
+ break;
|
|
|
+ default:
|
|
|
+ throw new UnsupportedOperationException("Unknown texture type: "+tex.getType());
|
|
|
+ }
|
|
|
+
|
|
|
+ // R to Texture compare mode
|
|
|
+/*
|
|
|
+ if (tex.getShadowCompareMode() != Texture.ShadowCompareMode.Off){
|
|
|
+ GLES20.glTexParameteri(target, GLES20.GL_TEXTURE_COMPARE_MODE, GLES20.GL_COMPARE_R_TO_TEXTURE);
|
|
|
+ GLES20.glTexParameteri(target, GLES20.GL_DEPTH_TEXTURE_MODE, GLES20.GL_INTENSITY);
|
|
|
+ if (tex.getShadowCompareMode() == Texture.ShadowCompareMode.GreaterOrEqual){
|
|
|
+ GLES20.glTexParameteri(target, GLES20.GL_TEXTURE_COMPARE_FUNC, GLES20.GL_GEQUAL);
|
|
|
+ }else{
|
|
|
+ GLES20.glTexParameteri(target, GLES20.GL_TEXTURE_COMPARE_FUNC, GLES20.GL_LEQUAL);
|
|
|
+ }
|
|
|
+ }
|
|
|
+*/
|
|
|
+ }
|
|
|
+
|
|
|
+ public void updateTexImageData(Image img, Texture.Type type, boolean mips){
|
|
|
+ int texId = img.getId();
|
|
|
+ if (texId == -1){
|
|
|
+ // create texture
|
|
|
+
|
|
|
+ if (verboseLogging)
|
|
|
+ logger.info("GLES20.glGenTexture(1, buffer)");
|
|
|
+
|
|
|
+ GLES20.glGenTextures(1, intBuf1);
|
|
|
+ texId = intBuf1.get(0);
|
|
|
+ img.setId(texId);
|
|
|
+ objManager.registerForCleanup(img);
|
|
|
+
|
|
|
+ statistics.onNewTexture();
|
|
|
+ }
|
|
|
+
|
|
|
+ // bind texture
|
|
|
+ int target = convertTextureType(type);
|
|
|
+ if (context.boundTextures[0] != img){
|
|
|
+ if (context.boundTextureUnit != 0){
|
|
|
+
|
|
|
+ if (verboseLogging)
|
|
|
+ logger.info("GLES20.glActiveTexture(GLES20.GL_TEXTURE0)");
|
|
|
+
|
|
|
+ GLES20.glActiveTexture(GLES20.GL_TEXTURE0);
|
|
|
+ context.boundTextureUnit = 0;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (verboseLogging)
|
|
|
+ logger.info("GLES20.glBindTexture(" + target + ", " + texId + ")");
|
|
|
+
|
|
|
+ GLES20.glBindTexture(target, texId);
|
|
|
+ context.boundTextures[0] = img;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (!img.hasMipmaps() && mips){
|
|
|
+ // No pregenerated mips available,
|
|
|
+ // generate from base level if required
|
|
|
+// if (!GLContext.getCapabilities().GL_EXT_framebuffer_multisample){
|
|
|
+
|
|
|
+ if (verboseLogging)
|
|
|
+ logger.info("GLES20.glTexParameteri(" + target + "GLES11.GL_GENERATE_MIMAP, GLES20.GL_TRUE)");
|
|
|
+
|
|
|
+ GLES20.glTexParameteri(target, GLES11.GL_GENERATE_MIPMAP, GLES20.GL_TRUE);
|
|
|
+// }
|
|
|
+ }else{
|
|
|
+// glTexParameteri(target, GL_TEXTURE_BASE_LEVEL, 0 );
|
|
|
+ if (img.getMipMapSizes() != null){
|
|
|
+// GLES20.glTexParameteri(target, GLES11.GL_TEXTURE_MAX_LEVEL, img.getMipMapSizes().length );
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+
|
|
|
+ if (target == GLES20.GL_TEXTURE_CUBE_MAP){
|
|
|
+ List<ByteBuffer> data = img.getData();
|
|
|
+ if (data.size() != 6){
|
|
|
+ logger.log(Level.WARNING, "Invalid texture: {0}\n"
|
|
|
+ + "Cubemap textures must contain 6 data units.", img);
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ for (int i = 0; i < 6; i++){
|
|
|
+ TextureUtil.uploadTexture(gl, img, GLES20.GL_TEXTURE_CUBE_MAP_POSITIVE_X + i, i, 0, tdc, true, powerOf2);
|
|
|
+ }
|
|
|
+ }/*else if (target == EXTTextureArray.GL_TEXTURE_2D_ARRAY_EXT){
|
|
|
+ List<ByteBuffer> data = img.getData();
|
|
|
+ // -1 index specifies prepare data for 2D Array
|
|
|
+ TextureUtil.uploadTexture(img, target, -1, 0, tdc);
|
|
|
+ for (int i = 0; i < data.size(); i++){
|
|
|
+ // upload each slice of 2D array in turn
|
|
|
+ // this time with the appropriate index
|
|
|
+ TextureUtil.uploadTexture(img, target, i, 0, tdc);
|
|
|
+ }
|
|
|
+ }*/else{
|
|
|
+ TextureUtil.uploadTexture(gl, img, target, 0, 0, tdc, true, powerOf2);
|
|
|
+
|
|
|
+ if (verboseLogging)
|
|
|
+ logger.info("GLES20.glTexParameteri(" + target + "GLES11.GL_GENERATE_MIMAP, GLES20.GL_TRUE)");
|
|
|
+
|
|
|
+ GLES20.glTexParameteri(target, GLES11.GL_GENERATE_MIPMAP, GLES20.GL_TRUE);
|
|
|
+ }
|
|
|
+
|
|
|
+// if (GLContext.getCapabilities().GL_EXT_framebuffer_multisample){
|
|
|
+// glGenerateMipmapEXT(target);
|
|
|
+// }
|
|
|
+
|
|
|
+ img.clearUpdateNeeded();
|
|
|
+ }
|
|
|
+
|
|
|
+ public void setTexture(int unit, Texture tex){
|
|
|
+ Image image = tex.getImage();
|
|
|
+ if (image.isUpdateNeeded()){
|
|
|
+ updateTexImageData(image, tex.getType(), tex.getMinFilter().usesMipMapLevels());
|
|
|
+ }
|
|
|
+
|
|
|
+ int texId = image.getId();
|
|
|
+ assert texId != -1;
|
|
|
+
|
|
|
+ if (texId == -1) {
|
|
|
+ logger.warning("error: texture image has -1 id");
|
|
|
+ }
|
|
|
+
|
|
|
+ Image[] textures = context.boundTextures;
|
|
|
+
|
|
|
+ int type = convertTextureType(tex.getType());
|
|
|
+ if (!context.textureIndexList.moveToNew(unit)){
|
|
|
+// if (context.boundTextureUnit != unit){
|
|
|
+// glActiveTexture(GL_TEXTURE0 + unit);
|
|
|
+// context.boundTextureUnit = unit;
|
|
|
+// }
|
|
|
+// glEnable(type);
|
|
|
+ }
|
|
|
+
|
|
|
+ if (textures[unit] != image){
|
|
|
+ if (context.boundTextureUnit != unit){
|
|
|
+ if (verboseLogging)
|
|
|
+ logger.info("GLES20.glActiveTexture(GLES20.GL_TEXTURE0 + " + unit + ")");
|
|
|
+ GLES20.glActiveTexture(GLES20.GL_TEXTURE0 + unit);
|
|
|
+ context.boundTextureUnit = unit;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (verboseLogging)
|
|
|
+ logger.info("GLES20.glBindTexture(" + type + ", " + texId + ")");
|
|
|
+
|
|
|
+ GLES20.glBindTexture(type, texId);
|
|
|
+ textures[unit] = image;
|
|
|
+
|
|
|
+ statistics.onTextureUse(tex.getImage(), true);
|
|
|
+ }else{
|
|
|
+ statistics.onTextureUse(tex.getImage(), false);
|
|
|
+ }
|
|
|
+
|
|
|
+ setupTextureParams(tex);
|
|
|
+ }
|
|
|
+
|
|
|
+ public void clearTextureUnits(){
|
|
|
+ IDList textureList = context.textureIndexList;
|
|
|
+ Image[] textures = context.boundTextures;
|
|
|
+ for (int i = 0; i < textureList.oldLen; i++){
|
|
|
+ int idx = textureList.oldList[i];
|
|
|
+// if (context.boundTextureUnit != idx){
|
|
|
+// glActiveTexture(GL_TEXTURE0 + idx);
|
|
|
+// context.boundTextureUnit = idx;
|
|
|
+// }
|
|
|
+// glDisable(convertTextureType(textures[idx].getType()));
|
|
|
+ textures[idx] = null;
|
|
|
+ }
|
|
|
+ context.textureIndexList.copyNewToOld();
|
|
|
+ }
|
|
|
+
|
|
|
+ public void deleteImage(Image image){
|
|
|
+ int texId = image.getId();
|
|
|
+ if (texId != -1){
|
|
|
+ intBuf1.put(0, texId);
|
|
|
+ intBuf1.position(0).limit(1);
|
|
|
+
|
|
|
+ if (verboseLogging)
|
|
|
+ logger.info("GLES20.glDeleteTexture(1, buffer)");
|
|
|
+
|
|
|
+ GLES20.glDeleteTextures(1, intBuf1);
|
|
|
+ image.resetObject();
|
|
|
+
|
|
|
+ statistics.onDeleteTexture();
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ /*********************************************************************\
|
|
|
+ |* Vertex Buffers and Attributes *|
|
|
|
+ \*********************************************************************/
|
|
|
+ private int convertUsage(Usage usage){
|
|
|
+ switch (usage){
|
|
|
+ case Static:
|
|
|
+ return GLES20.GL_STATIC_DRAW;
|
|
|
+ case Dynamic:
|
|
|
+ return GLES20.GL_DYNAMIC_DRAW;
|
|
|
+ case Stream:
|
|
|
+ return GLES20.GL_STREAM_DRAW;
|
|
|
+ default:
|
|
|
+ throw new RuntimeException("Unknown usage type.");
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ private int convertFormat(Format format){
|
|
|
+ switch (format){
|
|
|
+ case Byte:
|
|
|
+ return GLES20.GL_BYTE;
|
|
|
+ case UnsignedByte:
|
|
|
+ return GLES20.GL_UNSIGNED_BYTE;
|
|
|
+ case Short:
|
|
|
+ return GLES20.GL_SHORT;
|
|
|
+ case UnsignedShort:
|
|
|
+ return GLES20.GL_UNSIGNED_SHORT;
|
|
|
+ case Int:
|
|
|
+ return GLES20.GL_INT;
|
|
|
+ case UnsignedInt:
|
|
|
+ return GLES20.GL_UNSIGNED_INT;
|
|
|
+/*
|
|
|
+ case Half:
|
|
|
+ return NVHalfFloat.GL_HALF_FLOAT_NV;
|
|
|
+// return ARBHalfFloatVertex.GL_HALF_FLOAT;
|
|
|
+*/
|
|
|
+ case Float:
|
|
|
+ return GLES20.GL_FLOAT;
|
|
|
+// case Double:
|
|
|
+// return GLES20.GL_DOUBLE;
|
|
|
+ default:
|
|
|
+ throw new RuntimeException("Unknown buffer format.");
|
|
|
+
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ public void updateBufferData(VertexBuffer vb){
|
|
|
+
|
|
|
+ if (verboseLogging)
|
|
|
+ logger.info("updateBufferData(" + vb + ")");
|
|
|
+
|
|
|
+ int bufId = vb.getId();
|
|
|
+ boolean created = false;
|
|
|
+ if (bufId == -1){
|
|
|
+ // create buffer
|
|
|
+
|
|
|
+ if (verboseLogging)
|
|
|
+ logger.info("GLES20.glGenBuffers(" + 1 + ", buffer)");
|
|
|
+
|
|
|
+ GLES20.glGenBuffers(1, intBuf1);
|
|
|
+ bufId = intBuf1.get(0);
|
|
|
+ vb.setId(bufId);
|
|
|
+ objManager.registerForCleanup(vb);
|
|
|
+
|
|
|
+ created = true;
|
|
|
+ }
|
|
|
+
|
|
|
+ // bind buffer
|
|
|
+ int target;
|
|
|
+ if (vb.getBufferType() == VertexBuffer.Type.Index){
|
|
|
+ target = GLES20.GL_ELEMENT_ARRAY_BUFFER;
|
|
|
+
|
|
|
+ if (verboseLogging)
|
|
|
+ logger.info("vb.getBufferType() == VertexBuffer.Type.Index");
|
|
|
+
|
|
|
+ if (context.boundElementArrayVBO != bufId){
|
|
|
+
|
|
|
+ if (verboseLogging)
|
|
|
+ logger.info("GLES20.glBindBuffer(" + target + ", " + bufId + ")");
|
|
|
+
|
|
|
+ GLES20.glBindBuffer(target, bufId);
|
|
|
+ context.boundElementArrayVBO = bufId;
|
|
|
+ }
|
|
|
+ }else{
|
|
|
+ if (verboseLogging)
|
|
|
+ logger.info("vb.getBufferType() != VertexBuffer.Type.Index");
|
|
|
+
|
|
|
+ target = GLES20.GL_ARRAY_BUFFER;
|
|
|
+
|
|
|
+ if (context.boundArrayVBO != bufId){
|
|
|
+
|
|
|
+ if (verboseLogging)
|
|
|
+ logger.info("GLES20.glBindBuffer(" + target + ", " + bufId + ")");
|
|
|
+
|
|
|
+ GLES20.glBindBuffer(target, bufId);
|
|
|
+ context.boundArrayVBO = bufId;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ int usage = convertUsage(vb.getUsage());
|
|
|
+ vb.getData().clear();
|
|
|
+
|
|
|
+ if (created || vb.hasDataSizeChanged()){
|
|
|
+ // upload data based on format
|
|
|
+ int size = vb.getData().capacity() * vb.getFormat().getComponentSize();
|
|
|
+
|
|
|
+ switch (vb.getFormat()){
|
|
|
+ case Byte:
|
|
|
+ case UnsignedByte:
|
|
|
+
|
|
|
+ if (verboseLogging)
|
|
|
+ logger.info("GLES20.glBufferData(" + target + ", " + size + ", (data), " + usage + ")");
|
|
|
+
|
|
|
+ GLES20.glBufferData(target, size, (ByteBuffer) vb.getData(), usage);
|
|
|
+ break;
|
|
|
+ // case Half:
|
|
|
+ case Short:
|
|
|
+ case UnsignedShort:
|
|
|
+
|
|
|
+ if (verboseLogging)
|
|
|
+ logger.info("GLES20.glBufferData(" + target + ", " + size + ", (data), " + usage + ")");
|
|
|
+
|
|
|
+ GLES20.glBufferData(target, size, (ShortBuffer) vb.getData(), usage);
|
|
|
+ break;
|
|
|
+ case Int:
|
|
|
+ case UnsignedInt:
|
|
|
+
|
|
|
+ if (verboseLogging)
|
|
|
+ logger.info("GLES20.glBufferData(" + target + ", " + size + ", (data), " + usage + ")");
|
|
|
+
|
|
|
+ GLES20.glBufferData(target, size, (IntBuffer) vb.getData(), usage);
|
|
|
+ break;
|
|
|
+ case Float:
|
|
|
+ if (verboseLogging)
|
|
|
+ logger.info("GLES20.glBufferData(" + target + ", " + size + ", (data), " + usage + ")");
|
|
|
+
|
|
|
+ GLES20.glBufferData(target, size, (FloatBuffer) vb.getData(), usage);
|
|
|
+ break;
|
|
|
+ case Double:
|
|
|
+ if (verboseLogging)
|
|
|
+ logger.info("GLES20.glBufferData(" + target + ", " + size + ", (data), " + usage + ")");
|
|
|
+
|
|
|
+ GLES20.glBufferData(target, size, (DoubleBuffer) vb.getData(), usage);
|
|
|
+ break;
|
|
|
+ default:
|
|
|
+ throw new RuntimeException("Unknown buffer format.");
|
|
|
+ }
|
|
|
+ }else{
|
|
|
+ int size = vb.getData().capacity() * vb.getFormat().getComponentSize();
|
|
|
+
|
|
|
+ switch (vb.getFormat()){
|
|
|
+ case Byte:
|
|
|
+ case UnsignedByte:
|
|
|
+ if (verboseLogging)
|
|
|
+ logger.info("GLES20.glBufferSubData(" + target + ", 0, " + size + ", (data))");
|
|
|
+
|
|
|
+ GLES20.glBufferSubData(target, 0, size, (ByteBuffer) vb.getData());
|
|
|
+ break;
|
|
|
+ case Short:
|
|
|
+ case UnsignedShort:
|
|
|
+ if (verboseLogging)
|
|
|
+ logger.info("GLES20.glBufferSubData(" + target + ", 0, " + size + ", (data))");
|
|
|
+
|
|
|
+ GLES20.glBufferSubData(target, 0, size, (ShortBuffer) vb.getData());
|
|
|
+ break;
|
|
|
+ case Int:
|
|
|
+ case UnsignedInt:
|
|
|
+ if (verboseLogging)
|
|
|
+ logger.info("GLES20.glBufferSubData(" + target + ", 0, " + size + ", (data))");
|
|
|
+
|
|
|
+ GLES20.glBufferSubData(target, 0, size, (IntBuffer) vb.getData());
|
|
|
+ break;
|
|
|
+ case Float:
|
|
|
+ if (verboseLogging)
|
|
|
+ logger.info("GLES20.glBufferSubData(" + target + ", 0, " + size + ", (data))");
|
|
|
+
|
|
|
+ GLES20.glBufferSubData(target, 0, size, (FloatBuffer) vb.getData());
|
|
|
+ break;
|
|
|
+ case Double:
|
|
|
+ if (verboseLogging)
|
|
|
+ logger.info("GLES20.glBufferSubData(" + target + ", 0, " + size + ", (data))");
|
|
|
+
|
|
|
+ GLES20.glBufferSubData(target, 0, size, (DoubleBuffer) vb.getData());
|
|
|
+ break;
|
|
|
+ default:
|
|
|
+ throw new RuntimeException("Unknown buffer format.");
|
|
|
+ }
|
|
|
+ }
|
|
|
+// }else{
|
|
|
+// if (created || vb.hasDataSizeChanged()){
|
|
|
+// glBufferData(target, vb.getData().capacity() * vb.getFormat().getComponentSize(), usage);
|
|
|
+// }
|
|
|
+//
|
|
|
+// ByteBuffer buf = glMapBuffer(target,
|
|
|
+// GL_WRITE_ONLY,
|
|
|
+// vb.getMappedData());
|
|
|
+//
|
|
|
+// if (buf != vb.getMappedData()){
|
|
|
+// buf = buf.order(ByteOrder.nativeOrder());
|
|
|
+// vb.setMappedData(buf);
|
|
|
+// }
|
|
|
+//
|
|
|
+// buf.clear();
|
|
|
+//
|
|
|
+// switch (vb.getFormat()){
|
|
|
+// case Byte:
|
|
|
+// case UnsignedByte:
|
|
|
+// buf.put( (ByteBuffer) vb.getData() );
|
|
|
+// break;
|
|
|
+// case Short:
|
|
|
+// case UnsignedShort:
|
|
|
+// buf.asShortBuffer().put( (ShortBuffer) vb.getData() );
|
|
|
+// break;
|
|
|
+// case Int:
|
|
|
+// case UnsignedInt:
|
|
|
+// buf.asIntBuffer().put( (IntBuffer) vb.getData() );
|
|
|
+// break;
|
|
|
+// case Float:
|
|
|
+// buf.asFloatBuffer().put( (FloatBuffer) vb.getData() );
|
|
|
+// break;
|
|
|
+// case Double:
|
|
|
+// break;
|
|
|
+// default:
|
|
|
+// throw new RuntimeException("Unknown buffer format.");
|
|
|
+// }
|
|
|
+//
|
|
|
+// glUnmapBuffer(target);
|
|
|
+// }
|
|
|
+
|
|
|
+ vb.clearUpdateNeeded();
|
|
|
+ }
|
|
|
+
|
|
|
+ public void deleteBuffer(VertexBuffer vb) {
|
|
|
+ int bufId = vb.getId();
|
|
|
+ if (bufId != -1){
|
|
|
+ // delete buffer
|
|
|
+ intBuf1.put(0, bufId);
|
|
|
+ intBuf1.position(0).limit(1);
|
|
|
+ if (verboseLogging)
|
|
|
+ logger.info("GLES20.glDeleteBuffers(1, buffer)");
|
|
|
+
|
|
|
+ GLES20.glDeleteBuffers(1, intBuf1);
|
|
|
+ vb.resetObject();
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ public void clearVertexAttribs(){
|
|
|
+ IDList attribList = context.attribIndexList;
|
|
|
+ for (int i = 0; i < attribList.oldLen; i++){
|
|
|
+ int idx = attribList.oldList[i];
|
|
|
+
|
|
|
+ if (verboseLogging)
|
|
|
+ logger.info("GLES20.glDisableVertexAttribArray(" + idx + ")");
|
|
|
+
|
|
|
+ GLES20.glDisableVertexAttribArray(idx);
|
|
|
+ context.boundAttribs[idx] = null;
|
|
|
+ }
|
|
|
+ context.attribIndexList.copyNewToOld();
|
|
|
+ }
|
|
|
+
|
|
|
+ public void setVertexAttrib(VertexBuffer vb, VertexBuffer idb){
|
|
|
+ if (verboseLogging)
|
|
|
+ logger.info("setVertexAttrib(" + vb + ", " + idb + ")");
|
|
|
+
|
|
|
+ if (vb.getBufferType() == VertexBuffer.Type.Index)
|
|
|
+ throw new IllegalArgumentException("Index buffers not allowed to be set to vertex attrib");
|
|
|
+
|
|
|
+ if (vb.isUpdateNeeded() && idb == null)
|
|
|
+ updateBufferData(vb);
|
|
|
+
|
|
|
+ int programId = context.boundShaderProgram;
|
|
|
+ if (programId > 0){
|
|
|
+ Attribute attrib = boundShader.getAttribute(vb.getBufferType().name());
|
|
|
+ int loc = attrib.getLocation();
|
|
|
+ if (loc == -1) {
|
|
|
+
|
|
|
+ if (verboseLogging)
|
|
|
+ logger.warning("location is invalid for attrib: [" + vb.getBufferType().name() + "]");
|
|
|
+
|
|
|
+ return; // not defined
|
|
|
+ }
|
|
|
+
|
|
|
+ if (loc == -2){
|
|
|
+// stringBuf.setLength(0);
|
|
|
+// stringBuf.append("in").append(vb.getBufferType().name()).append('\0');
|
|
|
+// updateNameBuffer();
|
|
|
+
|
|
|
+ String attributeName = "in" + vb.getBufferType().name();
|
|
|
+
|
|
|
+ if (verboseLogging)
|
|
|
+ logger.info("GLES20.glGetAttribLocation(" + programId + ", " + attributeName + ")");
|
|
|
+
|
|
|
+ loc = GLES20.glGetAttribLocation(programId, attributeName);
|
|
|
+
|
|
|
+ // not really the name of it in the shader (inPosition\0) but
|
|
|
+ // the internal name of the enum (Position).
|
|
|
+ if (loc < 0){
|
|
|
+ attrib.setLocation(-1);
|
|
|
+
|
|
|
+ if (verboseLogging)
|
|
|
+ logger.warning("attribute is invalid in shader: [" + vb.getBufferType().name() + "]");
|
|
|
+
|
|
|
+ return; // not available in shader.
|
|
|
+ }else{
|
|
|
+ attrib.setLocation(loc);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ VertexBuffer[] attribs = context.boundAttribs;
|
|
|
+ if (!context.attribIndexList.moveToNew(loc)){
|
|
|
+ if (verboseLogging)
|
|
|
+ logger.info("GLES20.glEnableVertexAttribArray(" + loc + ")");
|
|
|
+
|
|
|
+ GLES20.glEnableVertexAttribArray(loc);
|
|
|
+ //System.out.println("Enabled ATTRIB IDX: "+loc);
|
|
|
+ }
|
|
|
+ if (attribs[loc] != vb){
|
|
|
+ // NOTE: Use id from interleaved buffer if specified
|
|
|
+ int bufId = idb != null ? idb.getId() : vb.getId();
|
|
|
+ assert bufId != -1;
|
|
|
+
|
|
|
+ if (bufId == -1) {
|
|
|
+ logger.warning("invalid buffer id");
|
|
|
+ }
|
|
|
+
|
|
|
+ if (context.boundArrayVBO != bufId){
|
|
|
+ if (verboseLogging)
|
|
|
+ logger.info("GLES20.glBindBuffer(" + GLES20.GL_ARRAY_BUFFER + ", " + bufId+ ")");
|
|
|
+ GLES20.glBindBuffer(GLES20.GL_ARRAY_BUFFER, bufId);
|
|
|
+ context.boundArrayVBO = bufId;
|
|
|
+ }
|
|
|
+
|
|
|
+ vb.getData().clear();
|
|
|
+
|
|
|
+ if (verboseLogging)
|
|
|
+ logger.info("GLES20.glVertexAttribPointer(" +
|
|
|
+ "location=" + loc + ", " +
|
|
|
+ "numComponents=" + vb.getNumComponents() + ", " +
|
|
|
+ "format=" + vb.getFormat() + ", " +
|
|
|
+ "isNormalized=" + vb.isNormalized() + ", " +
|
|
|
+ "stride=" + vb.getStride() + ", " +
|
|
|
+ "data.capacity=" + vb.getData().capacity() + ")"
|
|
|
+ );
|
|
|
+
|
|
|
+ GLES20.glVertexAttribPointer(loc,
|
|
|
+ vb.getNumComponents(),
|
|
|
+ convertFormat(vb.getFormat()),
|
|
|
+ vb.isNormalized(),
|
|
|
+ vb.getStride(),
|
|
|
+ vb.getData());
|
|
|
+
|
|
|
+ attribs[loc] = vb;
|
|
|
+ }
|
|
|
+ }else{
|
|
|
+ throw new IllegalStateException("Cannot render mesh without shader bound");
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ public void setVertexAttrib(VertexBuffer vb){
|
|
|
+ setVertexAttrib(vb, null);
|
|
|
+ }
|
|
|
+
|
|
|
+ public void drawTriangleArray(Mesh.Mode mode, int count, int vertCount){
|
|
|
+/* if (count > 1){
|
|
|
+ ARBDrawInstanced.glDrawArraysInstancedARB(convertElementMode(mode), 0,
|
|
|
+ vertCount, count);
|
|
|
+ }else{*/
|
|
|
+ if (verboseLogging)
|
|
|
+ logger.info("GLES20.glDrawArrays(" + vertCount + ")");
|
|
|
+
|
|
|
+ GLES20.glDrawArrays(convertElementMode(mode), 0, vertCount);
|
|
|
+/*
|
|
|
+ }*/
|
|
|
+ }
|
|
|
+
|
|
|
+ public void drawTriangleList(VertexBuffer indexBuf, Mesh mesh, int count){
|
|
|
+
|
|
|
+ if (verboseLogging)
|
|
|
+ logger.info("drawTriangleList(" + count + ")");
|
|
|
+
|
|
|
+ if (indexBuf.getBufferType() != VertexBuffer.Type.Index)
|
|
|
+ throw new IllegalArgumentException("Only index buffers are allowed as triangle lists.");
|
|
|
+
|
|
|
+ if (indexBuf.isUpdateNeeded()) {
|
|
|
+ if (verboseLogging)
|
|
|
+ logger.info("updateBufferData for indexBuf.");
|
|
|
+ updateBufferData(indexBuf);
|
|
|
+ }
|
|
|
+
|
|
|
+ int bufId = indexBuf.getId();
|
|
|
+ assert bufId != -1;
|
|
|
+
|
|
|
+ if (bufId == -1) {
|
|
|
+ logger.info("invalid buffer id!");
|
|
|
+ }
|
|
|
+
|
|
|
+ if (context.boundElementArrayVBO != bufId){
|
|
|
+ if (verboseLogging)
|
|
|
+ logger.info("GLES20.glBindBuffer(GLES20.GL_ELEMENT_ARRAY_BUFFER, " + bufId + ")");
|
|
|
+
|
|
|
+ GLES20.glBindBuffer(GLES20.GL_ELEMENT_ARRAY_BUFFER, bufId);
|
|
|
+ context.boundElementArrayVBO = bufId;
|
|
|
+ }
|
|
|
+
|
|
|
+ int vertCount = mesh.getVertexCount();
|
|
|
+ boolean useInstancing = count > 1 && caps.contains(Caps.MeshInstancing);
|
|
|
+
|
|
|
+ Buffer indexData = indexBuf.getData();
|
|
|
+
|
|
|
+ if (mesh.getMode() == Mode.Hybrid){
|
|
|
+ int[] modeStart = mesh.getModeStart();
|
|
|
+ int[] elementLengths = mesh.getElementLengths();
|
|
|
+
|
|
|
+ int elMode = convertElementMode(Mode.Triangles);
|
|
|
+ int fmt = convertFormat(indexBuf.getFormat());
|
|
|
+ int elSize = indexBuf.getFormat().getComponentSize();
|
|
|
+ int listStart = modeStart[0];
|
|
|
+ int stripStart = modeStart[1];
|
|
|
+ int fanStart = modeStart[2];
|
|
|
+ int curOffset = 0;
|
|
|
+ for (int i = 0; i < elementLengths.length; i++){
|
|
|
+ if (i == stripStart){
|
|
|
+ elMode = convertElementMode(Mode.TriangleStrip);
|
|
|
+ }else if (i == fanStart){
|
|
|
+ elMode = convertElementMode(Mode.TriangleStrip);
|
|
|
+ }
|
|
|
+ int elementLength = elementLengths[i];
|
|
|
+
|
|
|
+ if (useInstancing){
|
|
|
+ //ARBDrawInstanced.
|
|
|
+ throw new IllegalArgumentException("instancing is not supported.");
|
|
|
+/*
|
|
|
+ GLES20.glDrawElementsInstancedARB(elMode,
|
|
|
+ elementLength,
|
|
|
+ fmt,
|
|
|
+ curOffset,
|
|
|
+ count);
|
|
|
+*/
|
|
|
+ }else{
|
|
|
+ indexBuf.getData().position(curOffset);
|
|
|
+ if (verboseLogging)
|
|
|
+ logger.info("glDrawElements(): " + elementLength + ", " + curOffset);
|
|
|
+
|
|
|
+ GLES20.glDrawElements(elMode, elementLength, fmt, indexBuf.getData());
|
|
|
+/*
|
|
|
+ glDrawRangeElements(elMode,
|
|
|
+ 0,
|
|
|
+ vertCount,
|
|
|
+ elementLength,
|
|
|
+ fmt,
|
|
|
+ curOffset);
|
|
|
+*/
|
|
|
+ }
|
|
|
+
|
|
|
+ curOffset += elementLength * elSize;
|
|
|
+ }
|
|
|
+ }else{
|
|
|
+ if (useInstancing){
|
|
|
+ throw new IllegalArgumentException("instancing is not supported.");
|
|
|
+ //ARBDrawInstanced.
|
|
|
+/*
|
|
|
+ GLES20.glDrawElementsInstancedARB(convertElementMode(mesh.getMode()),
|
|
|
+ indexBuf.getData().capacity(),
|
|
|
+ convertFormat(indexBuf.getFormat()),
|
|
|
+ 0,
|
|
|
+ count);
|
|
|
+*/
|
|
|
+ }else{
|
|
|
+ indexData.clear();
|
|
|
+
|
|
|
+ if (verboseLogging)
|
|
|
+ logger.info("glDrawElements(), indexBuf.capacity (" + indexBuf.getData().capacity() + "), vertCount (" + vertCount + ")");
|
|
|
+
|
|
|
+ GLES11.glDrawElements(
|
|
|
+ convertElementMode(mesh.getMode()),
|
|
|
+ indexBuf.getData().capacity(),
|
|
|
+ convertFormat(indexBuf.getFormat()),
|
|
|
+ 0
|
|
|
+ );
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ /*********************************************************************\
|
|
|
+ |* Render Calls *|
|
|
|
+ \*********************************************************************/
|
|
|
+ public int convertElementMode(Mesh.Mode mode){
|
|
|
+ switch (mode){
|
|
|
+ case Points:
|
|
|
+ return GLES20.GL_POINTS;
|
|
|
+ case Lines:
|
|
|
+ return GLES20.GL_LINES;
|
|
|
+ case LineLoop:
|
|
|
+ return GLES20.GL_LINE_LOOP;
|
|
|
+ case LineStrip:
|
|
|
+ return GLES20.GL_LINE_STRIP;
|
|
|
+ case Triangles:
|
|
|
+ return GLES20.GL_TRIANGLES;
|
|
|
+ case TriangleFan:
|
|
|
+ return GLES20.GL_TRIANGLE_FAN;
|
|
|
+ case TriangleStrip:
|
|
|
+ return GLES20.GL_TRIANGLE_STRIP;
|
|
|
+ default:
|
|
|
+ throw new UnsupportedOperationException("Unrecognized mesh mode: "+mode);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ public void updateVertexArray(Mesh mesh){
|
|
|
+ logger.info("updateVertexArray(" + mesh + ")");
|
|
|
+ int id = mesh.getId();
|
|
|
+/*
|
|
|
+ if (id == -1){
|
|
|
+ IntBuffer temp = intBuf1;
|
|
|
+ // ARBVertexArrayObject.glGenVertexArrays(temp);
|
|
|
+ GLES20.glGenVertexArrays(temp);
|
|
|
+ id = temp.get(0);
|
|
|
+ mesh.setId(id);
|
|
|
+ }
|
|
|
+
|
|
|
+ if (context.boundVertexArray != id){
|
|
|
+ // ARBVertexArrayObject.glBindVertexArray(id);
|
|
|
+ GLES20.glBindVertexArray(id);
|
|
|
+ context.boundVertexArray = id;
|
|
|
+ }
|
|
|
+*/
|
|
|
+ VertexBuffer interleavedData = mesh.getBuffer(Type.InterleavedData);
|
|
|
+ if (interleavedData != null && interleavedData.isUpdateNeeded()){
|
|
|
+ updateBufferData(interleavedData);
|
|
|
+ }
|
|
|
+
|
|
|
+ IntMap<VertexBuffer> buffers = mesh.getBuffers();
|
|
|
+ for (Entry<VertexBuffer> entry : buffers){
|
|
|
+ VertexBuffer vb = entry.getValue();
|
|
|
+
|
|
|
+ if (vb.getBufferType() == Type.InterleavedData
|
|
|
+ || vb.getUsage() == Usage.CpuOnly // ignore cpu-only buffers
|
|
|
+ || vb.getBufferType() == Type.Index)
|
|
|
+ continue;
|
|
|
+
|
|
|
+ if (vb.getStride() == 0){
|
|
|
+ // not interleaved
|
|
|
+ setVertexAttrib(vb);
|
|
|
+ }else{
|
|
|
+ // interleaved
|
|
|
+ setVertexAttrib(vb, interleavedData);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+
|
|
|
+ /**
|
|
|
+ * renderMeshVertexArray renders a mesh using vertex arrays
|
|
|
+ * @param mesh
|
|
|
+ * @param lod
|
|
|
+ * @param count
|
|
|
+ */
|
|
|
+ private void renderMeshVertexArray(Mesh mesh, int lod, int count)
|
|
|
+ {
|
|
|
+ if (verboseLogging)
|
|
|
+ logger.info("renderMeshVertexArray");
|
|
|
+
|
|
|
+ IntMap<VertexBuffer> buffers = mesh.getBuffers();
|
|
|
+ for (Entry<VertexBuffer> entry : buffers){
|
|
|
+ VertexBuffer vb = entry.getValue();
|
|
|
+
|
|
|
+ if (vb.getBufferType() == Type.InterleavedData
|
|
|
+ || vb.getUsage() == Usage.CpuOnly // ignore cpu-only buffers
|
|
|
+ || vb.getBufferType() == Type.Index)
|
|
|
+ continue;
|
|
|
+
|
|
|
+ if (vb.getStride() == 0){
|
|
|
+ // not interleaved
|
|
|
+ setVertexAttrib_Array(vb);
|
|
|
+ }else{
|
|
|
+ // interleaved
|
|
|
+ VertexBuffer interleavedData = mesh.getBuffer(Type.InterleavedData);
|
|
|
+ setVertexAttrib_Array(vb, interleavedData);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ VertexBuffer indices = null;
|
|
|
+ if (mesh.getNumLodLevels() > 0)
|
|
|
+ {
|
|
|
+ indices = mesh.getLodLevel(lod);
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ indices = buffers.get(Type.Index.ordinal());
|
|
|
+ }
|
|
|
+ if (indices != null)
|
|
|
+ {
|
|
|
+ drawTriangleList_Array(indices, mesh, count);
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ if (verboseLogging)
|
|
|
+ logger.info("GLES20.glDrawArrays(" + mesh.getMode() + ", " + 0 + ", " + mesh.getVertexCount() + ")");
|
|
|
+
|
|
|
+ GLES20.glDrawArrays(convertElementMode(mesh.getMode()), 0, mesh.getVertexCount());
|
|
|
+ }
|
|
|
+ clearVertexAttribs();
|
|
|
+ clearTextureUnits();
|
|
|
+ }
|
|
|
+
|
|
|
+
|
|
|
+ private void renderMeshDefault(Mesh mesh, int lod, int count){
|
|
|
+ if (verboseLogging)
|
|
|
+ logger.info("renderMeshDefault(" + mesh + ", " + lod + ", " + count + ")");
|
|
|
+ VertexBuffer indices = null;
|
|
|
+
|
|
|
+ VertexBuffer interleavedData = mesh.getBuffer(Type.InterleavedData);
|
|
|
+ if (interleavedData != null && interleavedData.isUpdateNeeded()){
|
|
|
+ updateBufferData(interleavedData);
|
|
|
+ }
|
|
|
+
|
|
|
+ IntMap<VertexBuffer> buffers = mesh.getBuffers();
|
|
|
+ if (mesh.getNumLodLevels() > 0){
|
|
|
+ indices = mesh.getLodLevel(lod);
|
|
|
+ }else{
|
|
|
+ indices = buffers.get(Type.Index.ordinal());
|
|
|
+ }
|
|
|
+ for (Entry<VertexBuffer> entry : buffers){
|
|
|
+ VertexBuffer vb = entry.getValue();
|
|
|
+
|
|
|
+ if (vb.getBufferType() == Type.InterleavedData
|
|
|
+ || vb.getUsage() == Usage.CpuOnly // ignore cpu-only buffers
|
|
|
+ || vb.getBufferType() == Type.Index)
|
|
|
+ continue;
|
|
|
+
|
|
|
+ if (vb.getStride() == 0){
|
|
|
+ // not interleaved
|
|
|
+ setVertexAttrib(vb);
|
|
|
+ }else{
|
|
|
+ // interleaved
|
|
|
+ setVertexAttrib(vb, interleavedData);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ if (indices != null){
|
|
|
+ drawTriangleList(indices, mesh, count);
|
|
|
+ }else{
|
|
|
+// throw new UnsupportedOperationException("Cannot render without index buffer");
|
|
|
+ if (verboseLogging)
|
|
|
+ logger.info("GLES20.glDrawArrays(" + convertElementMode(mesh.getMode()) + ", 0, " + mesh.getVertexCount() + ")");
|
|
|
+
|
|
|
+ GLES20.glDrawArrays(convertElementMode(mesh.getMode()), 0, mesh.getVertexCount());
|
|
|
+ }
|
|
|
+ clearVertexAttribs();
|
|
|
+ clearTextureUnits();
|
|
|
+ }
|
|
|
+
|
|
|
+ public void renderMesh(Mesh mesh, int lod, int count) {
|
|
|
+ if (context.pointSize != mesh.getPointSize()){
|
|
|
+
|
|
|
+ if (verboseLogging)
|
|
|
+ logger.info("GLES10.glPointSize(" + mesh.getPointSize() + ")");
|
|
|
+
|
|
|
+ GLES10.glPointSize(mesh.getPointSize());
|
|
|
+ context.pointSize = mesh.getPointSize();
|
|
|
+ }
|
|
|
+ if (context.lineWidth != mesh.getLineWidth()){
|
|
|
+
|
|
|
+ if (verboseLogging)
|
|
|
+ logger.info("GLES20.glLineWidth(" + mesh.getLineWidth() + ")");
|
|
|
+
|
|
|
+ GLES20.glLineWidth(mesh.getLineWidth());
|
|
|
+ context.lineWidth = mesh.getLineWidth();
|
|
|
+ }
|
|
|
+
|
|
|
+ statistics.onMeshDrawn(mesh, lod);
|
|
|
+// if (GLContext.getCapabilities().GL_ARB_vertex_array_object){
|
|
|
+// renderMeshVertexArray(mesh, lod, count);
|
|
|
+// }else{
|
|
|
+
|
|
|
+ if (useVBO) {
|
|
|
+ if (verboseLogging)
|
|
|
+ logger.info("RENDERING A MESH USING VertexBufferObject");
|
|
|
+
|
|
|
+ renderMeshDefault(mesh, lod, count);
|
|
|
+ } else {
|
|
|
+ if (verboseLogging)
|
|
|
+ logger.info("RENDERING A MESH USING VertexArray");
|
|
|
+
|
|
|
+ renderMeshVertexArray(mesh, lod, count);
|
|
|
+ }
|
|
|
+
|
|
|
+// }
|
|
|
+ }
|
|
|
+
|
|
|
+ private void checkGLError() {
|
|
|
+ int error;
|
|
|
+ while ((error = GLES20.glGetError()) != GLES20.GL_NO_ERROR) {
|
|
|
+ logger.warning("glError " + error);
|
|
|
+ // throw new RuntimeException("glError " + error);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ private boolean log(String message) {
|
|
|
+ logger.info(message);
|
|
|
+ return true;
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * drawTriangleList_Array uses Vertex Array
|
|
|
+ * @param indexBuf
|
|
|
+ * @param mesh
|
|
|
+ * @param count
|
|
|
+ */
|
|
|
+ public void drawTriangleList_Array(VertexBuffer indexBuf, Mesh mesh, int count)
|
|
|
+ {
|
|
|
+ if (verboseLogging)
|
|
|
+ logger.info("drawTriangleList_Array(Count = " + count + ")");
|
|
|
+
|
|
|
+ if (indexBuf.getBufferType() != VertexBuffer.Type.Index)
|
|
|
+ throw new IllegalArgumentException("Only index buffers are allowed as triangle lists.");
|
|
|
+
|
|
|
+ boolean useInstancing = count > 1 && caps.contains(Caps.MeshInstancing);
|
|
|
+ if (useInstancing)
|
|
|
+ {
|
|
|
+ throw new IllegalArgumentException("Caps.MeshInstancing is not supported.");
|
|
|
+ }
|
|
|
+
|
|
|
+ int vertCount = mesh.getVertexCount();
|
|
|
+ Buffer indexData = indexBuf.getData();
|
|
|
+ indexData.clear();
|
|
|
+
|
|
|
+ if (mesh.getMode() == Mode.Hybrid)
|
|
|
+ {
|
|
|
+ int[] modeStart = mesh.getModeStart();
|
|
|
+ int[] elementLengths = mesh.getElementLengths();
|
|
|
+
|
|
|
+ int elMode = convertElementMode(Mode.Triangles);
|
|
|
+ int fmt = convertFormat(indexBuf.getFormat());
|
|
|
+ int elSize = indexBuf.getFormat().getComponentSize();
|
|
|
+ int listStart = modeStart[0];
|
|
|
+ int stripStart = modeStart[1];
|
|
|
+ int fanStart = modeStart[2];
|
|
|
+ int curOffset = 0;
|
|
|
+ for (int i = 0; i < elementLengths.length; i++)
|
|
|
+ {
|
|
|
+ if (i == stripStart)
|
|
|
+ {
|
|
|
+ elMode = convertElementMode(Mode.TriangleStrip);
|
|
|
+ }
|
|
|
+ else if (i == fanStart)
|
|
|
+ {
|
|
|
+ elMode = convertElementMode(Mode.TriangleStrip);
|
|
|
+ }
|
|
|
+ int elementLength = elementLengths[i];
|
|
|
+
|
|
|
+ indexBuf.getData().position(curOffset);
|
|
|
+ if (verboseLogging)
|
|
|
+ logger.info("glDrawElements(): " + elementLength + ", " + curOffset);
|
|
|
+
|
|
|
+ GLES20.glDrawElements(elMode, elementLength, fmt, indexBuf.getData());
|
|
|
+
|
|
|
+ curOffset += elementLength * elSize;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ else //if (mesh.getMode() == Mode.Hybrid)
|
|
|
+ {
|
|
|
+ if (verboseLogging)
|
|
|
+ logger.info("glDrawElements(), indexBuf.capacity (" + indexBuf.getData().capacity() + "), vertCount (" + vertCount + ")");
|
|
|
+
|
|
|
+ GLES20.glDrawElements(
|
|
|
+ convertElementMode(mesh.getMode()),
|
|
|
+ indexBuf.getData().capacity(),
|
|
|
+ convertFormat(indexBuf.getFormat()),
|
|
|
+ indexBuf.getData()
|
|
|
+ );
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * setVertexAttrib_Array uses Vertex Array
|
|
|
+ * @param vb
|
|
|
+ * @param idb
|
|
|
+ */
|
|
|
+ public void setVertexAttrib_Array(VertexBuffer vb, VertexBuffer idb)
|
|
|
+ {
|
|
|
+ if (verboseLogging)
|
|
|
+ logger.info("setVertexAttrib_Array(" + vb + ", " + idb + ")");
|
|
|
+
|
|
|
+ if (vb.getBufferType() == VertexBuffer.Type.Index)
|
|
|
+ throw new IllegalArgumentException("Index buffers not allowed to be set to vertex attrib");
|
|
|
+
|
|
|
+ // Get shader
|
|
|
+ int programId = context.boundShaderProgram;
|
|
|
+ if (programId > 0)
|
|
|
+ {
|
|
|
+ VertexBuffer[] attribs = context.boundAttribs;
|
|
|
+
|
|
|
+ Attribute attrib = boundShader.getAttribute(vb.getBufferType().name());
|
|
|
+ int loc = attrib.getLocation();
|
|
|
+ if (loc == -1)
|
|
|
+ {
|
|
|
+ //throw new IllegalArgumentException("Location is invalid for attrib: [" + vb.getBufferType().name() + "]");
|
|
|
+ if (verboseLogging)
|
|
|
+ logger.warning("attribute is invalid in shader: [" + vb.getBufferType().name() + "]");
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ else if (loc == -2)
|
|
|
+ {
|
|
|
+ String attributeName = "in" + vb.getBufferType().name();
|
|
|
+
|
|
|
+ if (verboseLogging)
|
|
|
+ logger.info("GLES20.glGetAttribLocation(" + programId + ", " + attributeName + ")");
|
|
|
+
|
|
|
+ loc = GLES20.glGetAttribLocation(programId, attributeName);
|
|
|
+ if (loc < 0)
|
|
|
+ {
|
|
|
+ attrib.setLocation(-1);
|
|
|
+ if (verboseLogging)
|
|
|
+ logger.warning("attribute is invalid in shader: [" + vb.getBufferType().name() + "]");
|
|
|
+ return; // not available in shader.
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ attrib.setLocation(loc);
|
|
|
+ }
|
|
|
+
|
|
|
+ } // if (loc == -2)
|
|
|
+
|
|
|
+ if ((attribs[loc] != vb) || vb.isUpdateNeeded())
|
|
|
+ {
|
|
|
+ // NOTE: Use data from interleaved buffer if specified
|
|
|
+ VertexBuffer avb = idb != null ? idb : vb;
|
|
|
+ avb.getData().clear();
|
|
|
+ avb.getData().position(vb.getOffset());
|
|
|
+
|
|
|
+ if (verboseLogging)
|
|
|
+ logger.info("GLES20.glVertexAttribPointer(" +
|
|
|
+ "location=" + loc + ", " +
|
|
|
+ "numComponents=" + vb.getNumComponents() + ", " +
|
|
|
+ "format=" + vb.getFormat() + ", " +
|
|
|
+ "isNormalized=" + vb.isNormalized() + ", " +
|
|
|
+ "stride=" + vb.getStride() + ", " +
|
|
|
+ "data.capacity=" + avb.getData().capacity() + ")"
|
|
|
+ );
|
|
|
+
|
|
|
+
|
|
|
+ // Upload attribute data
|
|
|
+ GLES20.glVertexAttribPointer(loc,
|
|
|
+ vb.getNumComponents(),
|
|
|
+ convertFormat(vb.getFormat()),
|
|
|
+ vb.isNormalized(),
|
|
|
+ vb.getStride(),
|
|
|
+ avb.getData());
|
|
|
+ checkGLError();
|
|
|
+
|
|
|
+ GLES20.glEnableVertexAttribArray(loc);
|
|
|
+
|
|
|
+ attribs[loc] = vb;
|
|
|
+ } // if (attribs[loc] != vb)
|
|
|
+ }
|
|
|
+ else
|
|
|
+ {
|
|
|
+ throw new IllegalStateException("Cannot render mesh without shader bound");
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ /**
|
|
|
+ * setVertexAttrib_Array uses Vertex Array
|
|
|
+ * @param vb
|
|
|
+ */
|
|
|
+ public void setVertexAttrib_Array(VertexBuffer vb)
|
|
|
+ {
|
|
|
+ setVertexAttrib_Array(vb, null);
|
|
|
+ }
|
|
|
+
|
|
|
+ public void setAlphaToCoverage(boolean value)
|
|
|
+ {
|
|
|
+ // TODO Auto-generated method stub
|
|
|
+ }
|
|
|
+}
|
nor..67
14 jaren geleden