| /* | |
| * 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.lwjgl; | |
| import com.jme3.light.LightList; | |
| import com.jme3.material.RenderState; | |
| import com.jme3.material.RenderState.StencilOperation; | |
| import com.jme3.material.RenderState.TestFunction; | |
| import com.jme3.math.*; | |
| import com.jme3.renderer.*; | |
| import com.jme3.scene.Mesh; | |
| import com.jme3.scene.Mesh.Mode; | |
| 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.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 com.jme3.util.NativeObjectManager; | |
| import com.jme3.util.SafeArrayList; | |
| import java.nio.*; | |
| import java.util.EnumSet; | |
| import java.util.List; | |
| import java.util.logging.Level; | |
| import java.util.logging.Logger; | |
| import jme3tools.converters.MipMapGenerator; | |
| import static org.lwjgl.opengl.ARBTextureMultisample.*; | |
| import static org.lwjgl.opengl.EXTFramebufferBlit.*; | |
| import static org.lwjgl.opengl.EXTFramebufferMultisample.*; | |
| import static org.lwjgl.opengl.EXTFramebufferObject.*; | |
| 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 org.lwjgl.opengl.*; | |
| //import static org.lwjgl.opengl.ARBDrawInstanced.*; | |
| public class LwjglRenderer implements Renderer { | |
| private static final Logger logger = Logger.getLogger(LwjglRenderer.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 NativeObjectManager objManager = new NativeObjectManager(); | |
| 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 int maxColorTexSamples; | |
| private int maxDepthTexSamples; | |
| private boolean tdc; | |
| private FrameBuffer lastFb = null; | |
| private FrameBuffer mainFbOverride = null; | |
| private final Statistics statistics = new Statistics(); | |
| private int vpX, vpY, vpW, vpH; | |
| private int clipX, clipY, clipW, clipH; | |
| public LwjglRenderer() { | |
| } | |
| 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; | |
| } | |
| @SuppressWarnings("fallthrough") | |
| public void initialize() { | |
| 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); | |
| if (ctxCaps.OpenGL31) { | |
| caps.add(Caps.OpenGL31); | |
| if (ctxCaps.OpenGL32) { | |
| caps.add(Caps.OpenGL32); | |
| } | |
| } | |
| } | |
| } | |
| } | |
| String versionStr = null; | |
| if (ctxCaps.OpenGL20) { | |
| versionStr = glGetString(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 = glGetInteger(GL_DRAW_BUFFER); | |
| initialReadBuf = glGetInteger(GL_READ_BUFFER); | |
| // XXX: This has to be GL_BACK for canvas on Mac | |
| // Since initialDrawBuf is GL_FRONT for pbuffer, gotta | |
| // change this value later on ... | |
| // initialDrawBuf = GL_BACK; | |
| // initialReadBuf = GL_BACK; | |
| int spaceIdx = versionStr.indexOf(" "); | |
| if (spaceIdx >= 1) { | |
| versionStr = versionStr.substring(0, spaceIdx); | |
| } | |
| 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.log(Level.WARNING, "Force-adding GLSL100 support, since OpenGL2 is supported."); | |
| caps.add(Caps.GLSL100); | |
| } | |
| glGetInteger(GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS, intBuf16); | |
| vertexTextureUnits = intBuf16.get(0); | |
| logger.log(Level.FINER, "VTF Units: {0}", vertexTextureUnits); | |
| if (vertexTextureUnits > 0) { | |
| caps.add(Caps.VertexTextureFetch); | |
| } | |
| glGetInteger(GL_MAX_TEXTURE_IMAGE_UNITS, intBuf16); | |
| fragTextureUnits = intBuf16.get(0); | |
| logger.log(Level.FINER, "Texture Units: {0}", fragTextureUnits); | |
| glGetInteger(GL_MAX_VERTEX_UNIFORM_COMPONENTS, intBuf16); | |
| vertexUniforms = intBuf16.get(0); | |
| logger.log(Level.FINER, "Vertex Uniforms: {0}", vertexUniforms); | |
| glGetInteger(GL_MAX_FRAGMENT_UNIFORM_COMPONENTS, intBuf16); | |
| fragUniforms = intBuf16.get(0); | |
| logger.log(Level.FINER, "Fragment Uniforms: {0}", fragUniforms); | |
| glGetInteger(GL_MAX_VERTEX_ATTRIBS, intBuf16); | |
| vertexAttribs = intBuf16.get(0); | |
| logger.log(Level.FINER, "Vertex Attributes: {0}", vertexAttribs); | |
| glGetInteger(GL_SUBPIXEL_BITS, intBuf16); | |
| int subpixelBits = intBuf16.get(0); | |
| logger.log(Level.FINER, "Subpixel Bits: {0}", subpixelBits); | |
| glGetInteger(GL_MAX_ELEMENTS_VERTICES, intBuf16); | |
| maxVertCount = intBuf16.get(0); | |
| logger.log(Level.FINER, "Preferred Batch Vertex Count: {0}", maxVertCount); | |
| glGetInteger(GL_MAX_ELEMENTS_INDICES, intBuf16); | |
| maxTriCount = intBuf16.get(0); | |
| logger.log(Level.FINER, "Preferred Batch Index Count: {0}", maxTriCount); | |
| glGetInteger(GL_MAX_TEXTURE_SIZE, intBuf16); | |
| maxTexSize = intBuf16.get(0); | |
| logger.log(Level.FINER, "Maximum Texture Resolution: {0}", maxTexSize); | |
| glGetInteger(GL_MAX_CUBE_MAP_TEXTURE_SIZE, intBuf16); | |
| maxCubeTexSize = intBuf16.get(0); | |
| logger.log(Level.FINER, "Maximum CubeMap Resolution: {0}", 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); | |
| } | |
| if (ctxCaps.GL_ARB_texture_non_power_of_two) { | |
| caps.add(Caps.NonPowerOfTwoTextures); | |
| } else { | |
| logger.log(Level.WARNING, "Your graphics card does not " | |
| + "support non-power-of-2 textures. " | |
| + "Some features might not work."); | |
| } | |
| 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_texture_multisample) { | |
| caps.add(Caps.TextureMultisample); | |
| glGetInteger(GL_MAX_COLOR_TEXTURE_SAMPLES, intBuf16); | |
| maxColorTexSamples = intBuf16.get(0); | |
| logger.log(Level.FINER, "Texture Multisample Color Samples: {0}", maxColorTexSamples); | |
| glGetInteger(GL_MAX_DEPTH_TEXTURE_SAMPLES, intBuf16); | |
| maxDepthTexSamples = intBuf16.get(0); | |
| logger.log(Level.FINER, "Texture Multisample Depth Samples: {0}", maxDepthTexSamples); | |
| } | |
| 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); | |
| } | |
| } | |
| logger.log(Level.INFO, "Caps: {0}", caps); | |
| } | |
| public void invalidateState() { | |
| context.reset(); | |
| boundShader = null; | |
| lastFb = null; | |
| initialDrawBuf = glGetInteger(GL_DRAW_BUFFER); | |
| initialReadBuf = glGetInteger(GL_READ_BUFFER); | |
| } | |
| public void resetGLObjects() { | |
| logger.log(Level.INFO, "Reseting objects and invalidating state"); | |
| objManager.resetObjects(); | |
| statistics.clearMemory(); | |
| invalidateState(); | |
| } | |
| public void cleanup() { | |
| logger.log(Level.INFO, "Deleting objects and invalidating state"); | |
| objManager.deleteAllObjects(this); | |
| statistics.clearMemory(); | |
| invalidateState(); | |
| } | |
| 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) { | |
| glDepthRange(start, end); | |
| } | |
| public void clearBuffers(boolean color, boolean depth, boolean stencil) { | |
| int bits = 0; | |
| if (color) { | |
| //See explanations of the depth below, we must enable color write to be able to clear the color buffer | |
| if (context.colorWriteEnabled == false) { | |
| glColorMask(true, true, true, true); | |
| context.colorWriteEnabled = true; | |
| } | |
| bits = GL_COLOR_BUFFER_BIT; | |
| } | |
| if (depth) { | |
| //glClear(GL_DEPTH_BUFFER_BIT) seems to not work when glDepthMask is false | |
| //here s some link on openl board | |
| //http://www.opengl.org/discussion_boards/ubbthreads.php?ubb=showflat&Number=257223 | |
| //if depth clear is requested, we enable the depthMask | |
| if (context.depthWriteEnabled == false) { | |
| glDepthMask(true); | |
| context.depthWriteEnabled = true; | |
| } | |
| bits |= GL_DEPTH_BUFFER_BIT; | |
| } | |
| if (stencil) { | |
| bits |= GL_STENCIL_BUFFER_BIT; | |
| } | |
| if (bits != 0) { | |
| glClear(bits); | |
| } | |
| } | |
| public void setBackgroundColor(ColorRGBA color) { | |
| glClearColor(color.r, color.g, color.b, color.a); | |
| } | |
| public void setAlphaToCoverage(boolean value) { | |
| if (value) { | |
| glEnable(ARBMultisample.GL_SAMPLE_ALPHA_TO_COVERAGE_ARB); | |
| } else { | |
| glDisable(ARBMultisample.GL_SAMPLE_ALPHA_TO_COVERAGE_ARB); | |
| } | |
| } | |
| public void applyRenderState(RenderState state) { | |
| if (state.isWireframe() && !context.wireframe) { | |
| glPolygonMode(GL_FRONT_AND_BACK, GL_LINE); | |
| context.wireframe = true; | |
| } else if (!state.isWireframe() && context.wireframe) { | |
| glPolygonMode(GL_FRONT_AND_BACK, GL_FILL); | |
| context.wireframe = false; | |
| } | |
| if (state.isDepthTest() && !context.depthTestEnabled) { | |
| glEnable(GL_DEPTH_TEST); | |
| glDepthFunc(GL_LEQUAL); | |
| context.depthTestEnabled = true; | |
| } else if (!state.isDepthTest() && context.depthTestEnabled) { | |
| glDisable(GL_DEPTH_TEST); | |
| context.depthTestEnabled = false; | |
| } | |
| if (state.isAlphaTest() && !context.alphaTestEnabled) { | |
| glEnable(GL_ALPHA_TEST); | |
| glAlphaFunc(GL_GREATER, state.getAlphaFallOff()); | |
| context.alphaTestEnabled = true; | |
| } else if (!state.isAlphaTest() && context.alphaTestEnabled) { | |
| glDisable(GL_ALPHA_TEST); | |
| context.alphaTestEnabled = false; | |
| } | |
| if (state.isDepthWrite() && !context.depthWriteEnabled) { | |
| glDepthMask(true); | |
| context.depthWriteEnabled = true; | |
| } else if (!state.isDepthWrite() && context.depthWriteEnabled) { | |
| glDepthMask(false); | |
| context.depthWriteEnabled = false; | |
| } | |
| if (state.isColorWrite() && !context.colorWriteEnabled) { | |
| glColorMask(true, true, true, true); | |
| context.colorWriteEnabled = true; | |
| } else if (!state.isColorWrite() && context.colorWriteEnabled) { | |
| glColorMask(false, false, false, false); | |
| context.colorWriteEnabled = false; | |
| } | |
| if (state.isPointSprite() && !context.pointSprite) { | |
| // Only enable/disable sprite | |
| if (context.boundTextures[0] != null){ | |
| if (context.boundTextureUnit != 0){ | |
| glActiveTexture(GL_TEXTURE0); | |
| context.boundTextureUnit = 0; | |
| } | |
| glEnable(GL_POINT_SPRITE); | |
| glEnable(GL_VERTEX_PROGRAM_POINT_SIZE); | |
| } | |
| context.pointSprite = true; | |
| } else if (!state.isPointSprite() && context.pointSprite) { | |
| if (context.boundTextures[0] != null){ | |
| if (context.boundTextureUnit != 0){ | |
| glActiveTexture(GL_TEXTURE0); | |
| context.boundTextureUnit = 0; | |
| } | |
| glDisable(GL_POINT_SPRITE); | |
| glDisable(GL_VERTEX_PROGRAM_POINT_SIZE); | |
| context.pointSprite = false; | |
| } | |
| } | |
| if (state.isPolyOffset()) { | |
| if (!context.polyOffsetEnabled) { | |
| glEnable(GL_POLYGON_OFFSET_FILL); | |
| glPolygonOffset(state.getPolyOffsetFactor(), | |
| state.getPolyOffsetUnits()); | |
| context.polyOffsetEnabled = true; | |
| context.polyOffsetFactor = state.getPolyOffsetFactor(); | |
| context.polyOffsetUnits = state.getPolyOffsetUnits(); | |
| } else { | |
| if (state.getPolyOffsetFactor() != context.polyOffsetFactor | |
| || state.getPolyOffsetUnits() != context.polyOffsetUnits) { | |
| glPolygonOffset(state.getPolyOffsetFactor(), | |
| state.getPolyOffsetUnits()); | |
| context.polyOffsetFactor = state.getPolyOffsetFactor(); | |
| context.polyOffsetUnits = state.getPolyOffsetUnits(); | |
| } | |
| } | |
| } else { | |
| if (context.polyOffsetEnabled) { | |
| glDisable(GL_POLYGON_OFFSET_FILL); | |
| context.polyOffsetEnabled = false; | |
| context.polyOffsetFactor = 0; | |
| context.polyOffsetUnits = 0; | |
| } | |
| } | |
| if (state.getFaceCullMode() != context.cullMode) { | |
| if (state.getFaceCullMode() == RenderState.FaceCullMode.Off) { | |
| glDisable(GL_CULL_FACE); | |
| } else { | |
| glEnable(GL_CULL_FACE); | |
| } | |
| switch (state.getFaceCullMode()) { | |
| case Off: | |
| break; | |
| case Back: | |
| glCullFace(GL_BACK); | |
| break; | |
| case Front: | |
| glCullFace(GL_FRONT); | |
| break; | |
| case FrontAndBack: | |
| glCullFace(GL_FRONT_AND_BACK); | |
| break; | |
| default: | |
| throw new UnsupportedOperationException("Unrecognized face cull mode: " | |
| + state.getFaceCullMode()); | |
| } | |
| context.cullMode = state.getFaceCullMode(); | |
| } | |
| if (state.getBlendMode() != context.blendMode) { | |
| if (state.getBlendMode() == RenderState.BlendMode.Off) { | |
| glDisable(GL_BLEND); | |
| } else { | |
| glEnable(GL_BLEND); | |
| switch (state.getBlendMode()) { | |
| case Off: | |
| break; | |
| case Additive: | |
| glBlendFunc(GL_ONE, GL_ONE); | |
| break; | |
| case AlphaAdditive: | |
| glBlendFunc(GL_SRC_ALPHA, GL_ONE); | |
| break; | |
| case Color: | |
| glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_COLOR); | |
| break; | |
| case Alpha: | |
| glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); | |
| break; | |
| case PremultAlpha: | |
| glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA); | |
| break; | |
| case Modulate: | |
| glBlendFunc(GL_DST_COLOR, GL_ZERO); | |
| break; | |
| case ModulateX2: | |
| glBlendFunc(GL_DST_COLOR, GL_SRC_COLOR); | |
| break; | |
| default: | |
| throw new UnsupportedOperationException("Unrecognized blend mode: " | |
| + state.getBlendMode()); | |
| } | |
| } | |
| context.blendMode = state.getBlendMode(); | |
| } | |
| if (context.stencilTest != state.isStencilTest() | |
| || context.frontStencilStencilFailOperation != state.getFrontStencilStencilFailOperation() | |
| || context.frontStencilDepthFailOperation != state.getFrontStencilDepthFailOperation() | |
| || context.frontStencilDepthPassOperation != state.getFrontStencilDepthPassOperation() | |
| || context.backStencilStencilFailOperation != state.getBackStencilStencilFailOperation() | |
| || context.backStencilDepthFailOperation != state.getBackStencilDepthFailOperation() | |
| || context.backStencilDepthPassOperation != state.getBackStencilDepthPassOperation() | |
| || context.frontStencilFunction != state.getFrontStencilFunction() | |
| || context.backStencilFunction != state.getBackStencilFunction()) { | |
| context.frontStencilStencilFailOperation = state.getFrontStencilStencilFailOperation(); //terrible looking, I know | |
| context.frontStencilDepthFailOperation = state.getFrontStencilDepthFailOperation(); | |
| context.frontStencilDepthPassOperation = state.getFrontStencilDepthPassOperation(); | |
| context.backStencilStencilFailOperation = state.getBackStencilStencilFailOperation(); | |
| context.backStencilDepthFailOperation = state.getBackStencilDepthFailOperation(); | |
| context.backStencilDepthPassOperation = state.getBackStencilDepthPassOperation(); | |
| context.frontStencilFunction = state.getFrontStencilFunction(); | |
| context.backStencilFunction = state.getBackStencilFunction(); | |
| if (state.isStencilTest()) { | |
| glEnable(GL_STENCIL_TEST); | |
| glStencilOpSeparate(GL_FRONT, | |
| convertStencilOperation(state.getFrontStencilStencilFailOperation()), | |
| convertStencilOperation(state.getFrontStencilDepthFailOperation()), | |
| convertStencilOperation(state.getFrontStencilDepthPassOperation())); | |
| glStencilOpSeparate(GL_BACK, | |
| convertStencilOperation(state.getBackStencilStencilFailOperation()), | |
| convertStencilOperation(state.getBackStencilDepthFailOperation()), | |
| convertStencilOperation(state.getBackStencilDepthPassOperation())); | |
| glStencilFuncSeparate(GL_FRONT, | |
| convertTestFunction(state.getFrontStencilFunction()), | |
| 0, Integer.MAX_VALUE); | |
| glStencilFuncSeparate(GL_BACK, | |
| convertTestFunction(state.getBackStencilFunction()), | |
| 0, Integer.MAX_VALUE); | |
| } else { | |
| glDisable(GL_STENCIL_TEST); | |
| } | |
| } | |
| } | |
| private int convertStencilOperation(StencilOperation stencilOp) { | |
| switch (stencilOp) { | |
| case Keep: | |
| return GL_KEEP; | |
| case Zero: | |
| return GL_ZERO; | |
| case Replace: | |
| return GL_REPLACE; | |
| case Increment: | |
| return GL_INCR; | |
| case IncrementWrap: | |
| return GL_INCR_WRAP; | |
| case Decrement: | |
| return GL_DECR; | |
| case DecrementWrap: | |
| return GL_DECR_WRAP; | |
| case Invert: | |
| return GL_INVERT; | |
| default: | |
| throw new UnsupportedOperationException("Unrecognized stencil operation: " + stencilOp); | |
| } | |
| } | |
| private int convertTestFunction(TestFunction testFunc) { | |
| switch (testFunc) { | |
| case Never: | |
| return GL_NEVER; | |
| case Less: | |
| return GL_LESS; | |
| case LessOrEqual: | |
| return GL_LEQUAL; | |
| case Greater: | |
| return GL_GREATER; | |
| case GreaterOrEqual: | |
| return GL_GEQUAL; | |
| case Equal: | |
| return GL_EQUAL; | |
| case NotEqual: | |
| return GL_NOTEQUAL; | |
| case Always: | |
| return GL_ALWAYS; | |
| default: | |
| throw new UnsupportedOperationException("Unrecognized test function: " + testFunc); | |
| } | |
| } | |
| /*********************************************************************\ | |
| |* Camera and World transforms *| | |
| \*********************************************************************/ | |
| public void setViewPort(int x, int y, int w, int h) { | |
| if (x != vpX || vpY != y || vpW != w || vpH != h) { | |
| glViewport(x, y, w, h); | |
| vpX = x; | |
| vpY = y; | |
| vpW = w; | |
| vpH = h; | |
| } | |
| } | |
| public void setClipRect(int x, int y, int width, int height) { | |
| if (!context.clipRectEnabled) { | |
| glEnable(GL_SCISSOR_TEST); | |
| context.clipRectEnabled = true; | |
| } | |
| if (clipX != x || clipY != y || clipW != width || clipH != height) { | |
| glScissor(x, y, width, height); | |
| clipX = x; | |
| clipY = y; | |
| clipW = width; | |
| clipH = height; | |
| } | |
| } | |
| public void clearClipRect() { | |
| if (context.clipRectEnabled) { | |
| glDisable(GL_SCISSOR_TEST); | |
| 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(); | |
| int loc = glGetUniformLocation(shader.getId(), nameBuf); | |
| if (loc < 0) { | |
| uniform.setLocation(-1); | |
| // uniform is not declared in shader | |
| logger.log(Level.INFO, "Uniform {0} is not declared in shader {1}.", new Object[]{uniform.getName(), shader.getSources()}); | |
| } else { | |
| uniform.setLocation(loc); | |
| } | |
| } | |
| protected void bindProgram(Shader shader){ | |
| int shaderId = shader.getId(); | |
| if (context.boundShaderProgram != shaderId) { | |
| glUseProgram(shaderId); | |
| statistics.onShaderUse(shader, true); | |
| boundShader = shader; | |
| context.boundShaderProgram = shaderId; | |
| } else { | |
| statistics.onShaderUse(shader, false); | |
| } | |
| } | |
| protected void updateUniform(Shader shader, Uniform uniform) { | |
| int shaderId = shader.getId(); | |
| assert uniform.getName() != null; | |
| assert shader.getId() > 0; | |
| bindProgram(shader); | |
| int loc = uniform.getLocation(); | |
| if (loc == -1) { | |
| return; | |
| } | |
| if (loc == -2) { | |
| // get uniform location | |
| updateUniformLocation(shader, uniform); | |
| if (uniform.getLocation() == -1) { | |
| // not declared, ignore | |
| uniform.clearUpdateNeeded(); | |
| return; | |
| } | |
| loc = uniform.getLocation(); | |
| } | |
| if (uniform.getVarType() == null) { | |
| return; // value not set yet.. | |
| } | |
| statistics.onUniformSet(); | |
| uniform.clearUpdateNeeded(); | |
| FloatBuffer fb; | |
| switch (uniform.getVarType()) { | |
| case Float: | |
| Float f = (Float) uniform.getValue(); | |
| glUniform1f(loc, f.floatValue()); | |
| break; | |
| case Vector2: | |
| Vector2f v2 = (Vector2f) uniform.getValue(); | |
| glUniform2f(loc, v2.getX(), v2.getY()); | |
| break; | |
| case Vector3: | |
| Vector3f v3 = (Vector3f) uniform.getValue(); | |
| glUniform3f(loc, v3.getX(), v3.getY(), v3.getZ()); | |
| break; | |
| case Vector4: | |
| Object val = uniform.getValue(); | |
| if (val instanceof ColorRGBA) { | |
| ColorRGBA c = (ColorRGBA) val; | |
| glUniform4f(loc, c.r, c.g, c.b, c.a); | |
| } else if (val instanceof Vector4f) { | |
| Vector4f c = (Vector4f) val; | |
| glUniform4f(loc, c.x, c.y, c.z, c.w); | |
| } else { | |
| Quaternion c = (Quaternion) uniform.getValue(); | |
| glUniform4f(loc, c.getX(), c.getY(), c.getZ(), c.getW()); | |
| } | |
| break; | |
| case Boolean: | |
| Boolean b = (Boolean) uniform.getValue(); | |
| glUniform1i(loc, b.booleanValue() ? GL_TRUE : GL_FALSE); | |
| break; | |
| case Matrix3: | |
| fb = (FloatBuffer) uniform.getValue(); | |
| assert fb.remaining() == 9; | |
| glUniformMatrix3(loc, false, fb); | |
| break; | |
| case Matrix4: | |
| fb = (FloatBuffer) uniform.getValue(); | |
| assert fb.remaining() == 16; | |
| glUniformMatrix4(loc, false, fb); | |
| break; | |
| case FloatArray: | |
| fb = (FloatBuffer) uniform.getValue(); | |
| glUniform1(loc, fb); | |
| break; | |
| case Vector2Array: | |
| fb = (FloatBuffer) uniform.getValue(); | |
| glUniform2(loc, fb); | |
| break; | |
| case Vector3Array: | |
| fb = (FloatBuffer) uniform.getValue(); | |
| glUniform3(loc, fb); | |
| break; | |
| case Vector4Array: | |
| fb = (FloatBuffer) uniform.getValue(); | |
| glUniform4(loc, fb); | |
| break; | |
| case Matrix4Array: | |
| fb = (FloatBuffer) uniform.getValue(); | |
| glUniformMatrix4(loc, false, fb); | |
| break; | |
| case Int: | |
| Integer i = (Integer) uniform.getValue(); | |
| glUniform1i(loc, i.intValue()); | |
| break; | |
| default: | |
| throw new UnsupportedOperationException("Unsupported uniform type: " + uniform.getVarType()); | |
| } | |
| } | |
| 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 GL_FRAGMENT_SHADER; | |
| case Vertex: | |
| return GL_VERTEX_SHADER; | |
| // case Geometry: | |
| // return ARBGeometryShader4.GL_GEOMETRY_SHADER_ARB; | |
| default: | |
| throw new UnsupportedOperationException("Unrecognized shader type."); | |
| } | |
| } | |
| public void updateShaderSourceData(ShaderSource source, String language) { | |
| int id = source.getId(); | |
| if (id == -1) { | |
| // create id | |
| id = glCreateShader(convertShaderType(source.getType())); | |
| if (id <= 0) { | |
| throw new RendererException("Invalid ID received when trying to create shader."); | |
| } | |
| source.setId(id); | |
| }else{ | |
| throw new RendererException("Cannot recompile shader source"); | |
| } | |
| // upload shader source | |
| // merge the defines and source code | |
| stringBuf.setLength(0); | |
| if (language.startsWith("GLSL")) { | |
| int version = Integer.parseInt(language.substring(4)); | |
| if (version > 100) { | |
| stringBuf.append("#version "); | |
| stringBuf.append(language.substring(4)); | |
| if (version >= 150) { | |
| stringBuf.append(" core"); | |
| } | |
| stringBuf.append("\n"); | |
| } | |
| } | |
| updateNameBuffer(); | |
| byte[] definesCodeData = source.getDefines().getBytes(); | |
| byte[] sourceCodeData = source.getSource().getBytes(); | |
| ByteBuffer codeBuf = BufferUtils.createByteBuffer(nameBuf.limit() | |
| + definesCodeData.length | |
| + sourceCodeData.length); | |
| codeBuf.put(nameBuf); | |
| codeBuf.put(definesCodeData); | |
| codeBuf.put(sourceCodeData); | |
| codeBuf.flip(); | |
| glShaderSource(id, codeBuf); | |
| glCompileShader(id); | |
| glGetShader(id, GL_COMPILE_STATUS, intBuf1); | |
| boolean compiledOK = intBuf1.get(0) == GL_TRUE; | |
| String infoLog = null; | |
| if (VALIDATE_SHADER || !compiledOK) { | |
| // even if compile succeeded, check | |
| // log for warnings | |
| glGetShader(id, GL_INFO_LOG_LENGTH, intBuf1); | |
| int length = intBuf1.get(0); | |
| if (length > 3) { | |
| // get infos | |
| ByteBuffer logBuf = BufferUtils.createByteBuffer(length); | |
| glGetShaderInfoLog(id, null, logBuf); | |
| byte[] logBytes = new byte[length]; | |
| logBuf.get(logBytes, 0, length); | |
| // convert to string, etc | |
| infoLog = new String(logBytes); | |
| } | |
| } | |
| if (compiledOK) { | |
| if (infoLog != null) { | |
| logger.log(Level.INFO, "{0} compile success\n{1}", | |
| new Object[]{source.getName(), infoLog}); | |
| } else { | |
| logger.log(Level.FINE, "{0} compile success", source.getName()); | |
| } | |
| } else { | |
| logger.log(Level.WARNING, "Bad compile of:\n{0}{1}", | |
| new Object[]{source.getDefines(), source.getSource()}); | |
| if (infoLog != null) { | |
| throw new RendererException("compile error in:" + source + " error:" + infoLog); | |
| } else { | |
| throw new RendererException("compile error in:" + source + " error: <not provided>"); | |
| } | |
| } | |
| 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. | |
| glDeleteShader(id); | |
| } else { | |
| // register for cleanup since the ID is usable | |
| // NOTE: From now on cleanup is handled | |
| // by the parent shader object so no need | |
| // to register. | |
| //objManager.registerForCleanup(source); | |
| } | |
| } | |
| public void updateShaderData(Shader shader) { | |
| int id = shader.getId(); | |
| boolean needRegister = false; | |
| if (id == -1) { | |
| // create program | |
| id = glCreateProgram(); | |
| if (id == 0) { | |
| throw new RendererException("Invalid ID (" + 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; | |
| } | |
| glAttachShader(id, source.getId()); | |
| } | |
| if (caps.contains(Caps.OpenGL30)) { | |
| // Check if GLSL version is 1.5 for shader | |
| GL30.glBindFragDataLocation(id, 0, "outFragColor"); | |
| } | |
| // link shaders to program | |
| glLinkProgram(id); | |
| glGetProgram(id, GL_LINK_STATUS, intBuf1); | |
| boolean linkOK = intBuf1.get(0) == GL_TRUE; | |
| String infoLog = null; | |
| if (VALIDATE_SHADER || !linkOK) { | |
| glGetProgram(id, GL_INFO_LOG_LENGTH, intBuf1); | |
| int length = intBuf1.get(0); | |
| if (length > 3) { | |
| // get infos | |
| ByteBuffer logBuf = BufferUtils.createByteBuffer(length); | |
| glGetProgramInfoLog(id, null, logBuf); | |
| // convert to string, etc | |
| byte[] logBytes = new byte[length]; | |
| logBuf.get(logBytes, 0, length); | |
| infoLog = new String(logBytes); | |
| } | |
| } | |
| 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) { | |
| throw new RendererException("Shader link failure, shader:" + shader + " info:" + infoLog); | |
| } else { | |
| throw new RendererException("Shader link failure, shader:" + shader + " info: <not provided>"); | |
| } | |
| } | |
| 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 (shader == null) { | |
| throw new IllegalArgumentException("shader cannot be null"); | |
| // if (context.boundShaderProgram > 0) { | |
| // 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()) { | |
| return; | |
| } | |
| assert shader.getId() > 0; | |
| updateShaderUniforms(shader); | |
| bindProgram(shader); | |
| } | |
| } | |
| 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(); | |
| 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) { | |
| glDetachShader(shader.getId(), source.getId()); | |
| deleteShaderSource(source); | |
| } | |
| } | |
| // kill all references so sources can be collected | |
| // if needed. | |
| shader.resetSources(); | |
| glDeleteProgram(shader.getId()); | |
| statistics.onDeleteShader(); | |
| } | |
| /*********************************************************************\ | |
| |* Framebuffers *| | |
| \*********************************************************************/ | |
| public void copyFrameBuffer(FrameBuffer src, FrameBuffer dst) { | |
| copyFrameBuffer(src, dst, true); | |
| } | |
| public void copyFrameBuffer(FrameBuffer src, FrameBuffer dst, boolean copyDepth) { | |
| 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(); | |
| } | |
| int mask = GL_COLOR_BUFFER_BIT; | |
| if (copyDepth) { | |
| mask |= GL_DEPTH_BUFFER_BIT; | |
| } | |
| glBlitFramebufferEXT(0, 0, srcW, srcH, | |
| 0, 0, dstW, dstH, mask, | |
| 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 RendererException("EXT_framebuffer_blit required."); | |
| // TODO: support non-blit copies? | |
| } | |
| } | |
| private String getTargetBufferName(int buffer){ | |
| switch (buffer){ | |
| case GL_NONE: return "NONE"; | |
| case GL_FRONT: return "GL_FRONT"; | |
| case GL_BACK: return "GL_BACK"; | |
| default: | |
| if ( buffer >= GL_COLOR_ATTACHMENT0_EXT | |
| && buffer <= GL_COLOR_ATTACHMENT15_EXT){ | |
| return "GL_COLOR_ATTACHMENT" + | |
| (buffer - GL_COLOR_ATTACHMENT0_EXT); | |
| }else{ | |
| return "UNKNOWN? " + buffer; | |
| } | |
| } | |
| } | |
| private void printRealRenderBufferInfo(FrameBuffer fb, RenderBuffer rb, String name){ | |
| System.out.println("== Renderbuffer " + name + " =="); | |
| System.out.println("RB ID: " + rb.getId()); | |
| System.out.println("Is proper? " + glIsRenderbufferEXT(rb.getId())); | |
| int attachment = convertAttachmentSlot(rb.getSlot()); | |
| int type = glGetFramebufferAttachmentParameterEXT(GL_DRAW_FRAMEBUFFER_EXT, | |
| attachment, | |
| GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE_EXT); | |
| int rbName = glGetFramebufferAttachmentParameterEXT(GL_DRAW_FRAMEBUFFER_EXT, | |
| attachment, | |
| GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_EXT); | |
| switch (type){ | |
| case GL_NONE: | |
| System.out.println("Type: None"); | |
| return; // note: return from method as other queries will be invalid | |
| case GL_TEXTURE: | |
| System.out.println("Type: Texture"); | |
| break; | |
| case GL_RENDERBUFFER_EXT: | |
| System.out.println("Type: Buffer"); | |
| System.out.println("RB ID: " + rbName); | |
| break; | |
| } | |
| } | |
| private void printRealFrameBufferInfo(FrameBuffer fb) { | |
| boolean doubleBuffer = glGetBoolean(GL_DOUBLEBUFFER); | |
| String drawBuf = getTargetBufferName(glGetInteger(GL_DRAW_BUFFER)); | |
| String readBuf = getTargetBufferName(glGetInteger(GL_READ_BUFFER)); | |
| int fbId = fb.getId(); | |
| int curDrawBinding = glGetInteger(ARBFramebufferObject.GL_DRAW_FRAMEBUFFER_BINDING); | |
| int curReadBinding = glGetInteger(ARBFramebufferObject.GL_READ_FRAMEBUFFER_BINDING); | |
| System.out.println("=== OpenGL FBO State ==="); | |
| System.out.println("Context doublebuffered? " + doubleBuffer); | |
| System.out.println("FBO ID: " + fbId); | |
| System.out.println("Is proper? " + glIsFramebufferEXT(fbId)); | |
| System.out.println("Is bound to draw? " + (fbId == curDrawBinding)); | |
| System.out.println("Is bound to read? " + (fbId == curReadBinding)); | |
| System.out.println("Draw buffer: " + drawBuf); | |
| System.out.println("Read buffer: " + readBuf); | |
| if (context.boundFBO != fbId){ | |
| glBindFramebufferEXT(GL_DRAW_FRAMEBUFFER_EXT, fbId); | |
| context.boundFBO = fbId; | |
| } | |
| if (fb.getDepthBuffer() != null){ | |
| printRealRenderBufferInfo(fb, fb.getDepthBuffer(), "Depth"); | |
| } | |
| for (int i = 0; i < fb.getNumColorBuffers(); i++){ | |
| printRealRenderBufferInfo(fb, fb.getColorBuffer(i), "Color" + i); | |
| } | |
| } | |
| 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 doesn't have any renderbuffers attached."); | |
| 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) { | |
| 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 RendererException("Resolution " + fb.getWidth() | |
| + ":" + fb.getHeight() + " is not supported."); | |
| } | |
| TextureUtil.checkFormatSupported(rb.getFormat()); | |
| if (fb.getSamples() > 1 && 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) { | |
| // 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) { | |
| Texture tex = rb.getTexture(); | |
| Image image = tex.getImage(); | |
| if (image.isUpdateNeeded()) { | |
| updateTexImageData(image, tex.getType(), tex.getMinFilter().usesMipMapLevels(), 0); | |
| // NOTE: For depth textures, sets nearest/no-mips mode | |
| // Required to fix "framebuffer unsupported" | |
| // for old NVIDIA drivers! | |
| setupTextureParams(tex); | |
| } | |
| glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, | |
| convertAttachmentSlot(rb.getSlot()), | |
| convertTextureType(tex.getType(), image.getMultiSamples()), | |
| image.getId(), | |
| 0); | |
| } | |
| 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) { | |
| 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 Vector2f[] getFrameBufferSamplePositions(FrameBuffer fb) { | |
| if (fb.getSamples() <= 1) { | |
| throw new IllegalArgumentException("Framebuffer must be multisampled"); | |
| } | |
| setFrameBuffer(fb); | |
| Vector2f[] samplePositions = new Vector2f[fb.getSamples()]; | |
| FloatBuffer samplePos = BufferUtils.createFloatBuffer(2); | |
| for (int i = 0; i < samplePositions.length; i++) { | |
| glGetMultisample(GL_SAMPLE_POSITION, i, samplePos); | |
| samplePos.clear(); | |
| samplePositions[i] = new Vector2f(samplePos.get(0) - 0.5f, | |
| samplePos.get(1) - 0.5f); | |
| } | |
| return samplePositions; | |
| } | |
| public void setMainFrameBufferOverride(FrameBuffer fb){ | |
| mainFbOverride = fb; | |
| } | |
| public void setFrameBuffer(FrameBuffer fb) { | |
| if (fb == null && mainFbOverride != null){ | |
| fb = mainFbOverride; | |
| } | |
| if (lastFb == fb) { | |
| if (fb == null || !fb.isUpdateNeeded()){ | |
| 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()); | |
| int textureType = convertTextureType(tex.getType(), tex.getImage().getMultiSamples()); | |
| glEnable(textureType); | |
| glGenerateMipmapEXT(textureType); | |
| glDisable(textureType); | |
| } | |
| } | |
| } | |
| 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.getNumColorBuffers() == 0 && fb.getDepthBuffer() == null){ | |
| throw new IllegalArgumentException("The framebuffer: " + fb + | |
| "\nDoesn't have any color/depth buffers"); | |
| } | |
| 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 RendererException("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, "=== jMonkeyEngine FBO State ===\n{0}", fb); | |
| printRealFrameBufferInfo(fb); | |
| throw ex; | |
| } | |
| } | |
| } | |
| 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) { | |
| intBuf1.put(0, rb.getId()); | |
| glDeleteRenderbuffersEXT(intBuf1); | |
| } | |
| 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, int samples) { | |
| switch (type) { | |
| case TwoDimensional: | |
| if (samples > 1) { | |
| return ARBTextureMultisample.GL_TEXTURE_2D_MULTISAMPLE; | |
| } else { | |
| return GL_TEXTURE_2D; | |
| } | |
| case TwoDimensionalArray: | |
| if (samples > 1) { | |
| return ARBTextureMultisample.GL_TEXTURE_2D_MULTISAMPLE_ARRAY; | |
| } else { | |
| return EXTTextureArray.GL_TEXTURE_2D_ARRAY_EXT; | |
| } | |
| case ThreeDimensional: | |
| return GL_TEXTURE_3D; | |
| case CubeMap: | |
| return GL_TEXTURE_CUBE_MAP; | |
| default: | |
| throw new UnsupportedOperationException("Unknown texture type: " + type); | |
| } | |
| } | |
| private int convertMagFilter(Texture.MagFilter filter) { | |
| switch (filter) { | |
| case Bilinear: | |
| return GL_LINEAR; | |
| case Nearest: | |
| return GL_NEAREST; | |
| default: | |
| throw new UnsupportedOperationException("Unknown mag filter: " + filter); | |
| } | |
| } | |
| private int convertMinFilter(Texture.MinFilter filter) { | |
| switch (filter) { | |
| case Trilinear: | |
| return GL_LINEAR_MIPMAP_LINEAR; | |
| case BilinearNearestMipMap: | |
| return GL_LINEAR_MIPMAP_NEAREST; | |
| case NearestLinearMipMap: | |
| return GL_NEAREST_MIPMAP_LINEAR; | |
| case NearestNearestMipMap: | |
| return GL_NEAREST_MIPMAP_NEAREST; | |
| case BilinearNoMipMaps: | |
| return GL_LINEAR; | |
| case NearestNoMipMaps: | |
| return GL_NEAREST; | |
| default: | |
| throw new UnsupportedOperationException("Unknown min filter: " + filter); | |
| } | |
| } | |
| private int convertWrapMode(Texture.WrapMode mode) { | |
| switch (mode) { | |
| case BorderClamp: | |
| return GL_CLAMP_TO_BORDER; | |
| case Clamp: | |
| return GL_CLAMP; | |
| case EdgeClamp: | |
| return GL_CLAMP_TO_EDGE; | |
| case Repeat: | |
| return GL_REPEAT; | |
| case MirroredRepeat: | |
| return GL_MIRRORED_REPEAT; | |
| default: | |
| throw new UnsupportedOperationException("Unknown wrap mode: " + mode); | |
| } | |
| } | |
| @SuppressWarnings("fallthrough") | |
| private void setupTextureParams(Texture tex) { | |
| Image image = tex.getImage(); | |
| int target = convertTextureType(tex.getType(), image != null ? image.getMultiSamples() : 1); | |
| // filter things | |
| int minFilter = convertMinFilter(tex.getMinFilter()); | |
| int magFilter = convertMagFilter(tex.getMagFilter()); | |
| glTexParameteri(target, GL_TEXTURE_MIN_FILTER, minFilter); | |
| glTexParameteri(target, 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()); | |
| } | |
| } | |
| if (context.pointSprite) { | |
| return; // Attempt to fix glTexParameter crash for some ATI GPUs | |
| } | |
| // repeat modes | |
| switch (tex.getType()) { | |
| case ThreeDimensional: | |
| case CubeMap: // cubemaps use 3D coords | |
| glTexParameteri(target, GL_TEXTURE_WRAP_R, convertWrapMode(tex.getWrap(WrapAxis.R))); | |
| case TwoDimensional: | |
| case TwoDimensionalArray: | |
| glTexParameteri(target, GL_TEXTURE_WRAP_T, convertWrapMode(tex.getWrap(WrapAxis.T))); | |
| // fall down here is intentional.. | |
| // case OneDimensional: | |
| glTexParameteri(target, 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) { | |
| glTexParameteri(target, GL_TEXTURE_COMPARE_MODE, GL_COMPARE_R_TO_TEXTURE); | |
| glTexParameteri(target, GL_DEPTH_TEXTURE_MODE, GL_INTENSITY); | |
| if (tex.getShadowCompareMode() == Texture.ShadowCompareMode.GreaterOrEqual) { | |
| glTexParameteri(target, GL_TEXTURE_COMPARE_FUNC, GL_GEQUAL); | |
| } else { | |
| glTexParameteri(target, GL_TEXTURE_COMPARE_FUNC, GL_LEQUAL); | |
| } | |
| } | |
| } | |
| public void updateTexImageData(Image img, Texture.Type type, boolean mips, int unit) { | |
| int texId = img.getId(); | |
| if (texId == -1) { | |
| // create texture | |
| glGenTextures(intBuf1); | |
| texId = intBuf1.get(0); | |
| img.setId(texId); | |
| objManager.registerForCleanup(img); | |
| statistics.onNewTexture(); | |
| } | |
| // bind texture | |
| int target = convertTextureType(type, img.getMultiSamples()); | |
| if (context.boundTextureUnit != unit) { | |
| glActiveTexture(GL_TEXTURE0 + unit); | |
| context.boundTextureUnit = unit; | |
| } | |
| if (context.boundTextures[unit] != img) { | |
| glBindTexture(target, texId); | |
| context.boundTextures[unit] = img; | |
| statistics.onTextureUse(img, true); | |
| } | |
| if (!img.hasMipmaps() && mips) { | |
| // No pregenerated mips available, | |
| // generate from base level if required | |
| if (!GLContext.getCapabilities().OpenGL30) { | |
| glTexParameteri(target, GL_GENERATE_MIPMAP, GL_TRUE); | |
| } | |
| } else { | |
| // glTexParameteri(target, GL_TEXTURE_BASE_LEVEL, 0 ); | |
| if (img.getMipMapSizes() != null) { | |
| glTexParameteri(target, GL_TEXTURE_MAX_LEVEL, img.getMipMapSizes().length); | |
| } | |
| } | |
| int imageSamples = img.getMultiSamples(); | |
| if (imageSamples > 1) { | |
| if (img.getFormat().isDepthFormat()) { | |
| img.setMultiSamples(Math.min(maxDepthTexSamples, imageSamples)); | |
| } else { | |
| img.setMultiSamples(Math.min(maxColorTexSamples, imageSamples)); | |
| } | |
| } | |
| // Yes, some OpenGL2 cards (GeForce 5) still dont support NPOT. | |
| if (!GLContext.getCapabilities().GL_ARB_texture_non_power_of_two) { | |
| if (img.getWidth() != 0 && img.getHeight() != 0) { | |
| if (!FastMath.isPowerOfTwo(img.getWidth()) | |
| || !FastMath.isPowerOfTwo(img.getHeight())) { | |
| if (img.getData(0) == null) { | |
| throw new RendererException("non-power-of-2 framebuffer textures are not supported by the video hardware"); | |
| } else { | |
| MipMapGenerator.resizeToPowerOf2(img); | |
| } | |
| } | |
| } | |
| } | |
| // Check if graphics card doesn't support multisample textures | |
| if (!GLContext.getCapabilities().GL_ARB_texture_multisample) { | |
| if (img.getMultiSamples() > 1) { | |
| throw new RendererException("Multisample textures not supported by graphics hardware"); | |
| } | |
| } | |
| if (target == 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(img, GL_TEXTURE_CUBE_MAP_POSITIVE_X + i, i, 0, tdc); | |
| } | |
| } 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(img, target, 0, 0, tdc); | |
| } | |
| if (img.getMultiSamples() != imageSamples) { | |
| img.setMultiSamples(imageSamples); | |
| } | |
| if (GLContext.getCapabilities().OpenGL30) { | |
| if (!img.hasMipmaps() && mips && img.getData() != null) { | |
| // XXX: Required for ATI | |
| glEnable(target); | |
| glGenerateMipmapEXT(target); | |
| glDisable(target); | |
| } | |
| } | |
| img.clearUpdateNeeded(); | |
| } | |
| public void setTexture(int unit, Texture tex) { | |
| Image image = tex.getImage(); | |
| if (image.isUpdateNeeded()) { | |
| updateTexImageData(image, tex.getType(), tex.getMinFilter().usesMipMapLevels(), unit); | |
| } | |
| int texId = image.getId(); | |
| assert texId != -1; | |
| Image[] textures = context.boundTextures; | |
| int type = convertTextureType(tex.getType(), image.getMultiSamples()); | |
| // if (!context.textureIndexList.moveToNew(unit)) { | |
| // if (context.boundTextureUnit != unit){ | |
| // glActiveTexture(GL_TEXTURE0 + unit); | |
| // context.boundTextureUnit = unit; | |
| // } | |
| // glEnable(type); | |
| // } | |
| if (context.boundTextureUnit != unit) { | |
| glActiveTexture(GL_TEXTURE0 + unit); | |
| context.boundTextureUnit = unit; | |
| } | |
| if (textures[unit] != image) { | |
| glBindTexture(type, texId); | |
| textures[unit] = image; | |
| statistics.onTextureUse(image, true); | |
| } else { | |
| statistics.onTextureUse(image, 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); | |
| glDeleteTextures(intBuf1); | |
| image.resetObject(); | |
| statistics.onDeleteTexture(); | |
| } | |
| } | |
| /*********************************************************************\ | |
| |* Vertex Buffers and Attributes *| | |
| \*********************************************************************/ | |
| private int convertUsage(Usage usage) { | |
| switch (usage) { | |
| case Static: | |
| return GL_STATIC_DRAW; | |
| case Dynamic: | |
| return GL_DYNAMIC_DRAW; | |
| case Stream: | |
| return GL_STREAM_DRAW; | |
| default: | |
| throw new UnsupportedOperationException("Unknown usage type."); | |
| } | |
| } | |
| private int convertFormat(Format format) { | |
| switch (format) { | |
| case Byte: | |
| return GL_BYTE; | |
| case UnsignedByte: | |
| return GL_UNSIGNED_BYTE; | |
| case Short: | |
| return GL_SHORT; | |
| case UnsignedShort: | |
| return GL_UNSIGNED_SHORT; | |
| case Int: | |
| return GL_INT; | |
| case UnsignedInt: | |
| return GL_UNSIGNED_INT; | |
| case Half: | |
| return NVHalfFloat.GL_HALF_FLOAT_NV; | |
| // return ARBHalfFloatVertex.GL_HALF_FLOAT; | |
| case Float: | |
| return GL_FLOAT; | |
| case Double: | |
| return GL_DOUBLE; | |
| default: | |
| throw new UnsupportedOperationException("Unknown buffer format."); | |
| } | |
| } | |
| public void updateBufferData(VertexBuffer vb) { | |
| int bufId = vb.getId(); | |
| boolean created = false; | |
| if (bufId == -1) { | |
| // create buffer | |
| glGenBuffers(intBuf1); | |
| bufId = intBuf1.get(0); | |
| vb.setId(bufId); | |
| objManager.registerForCleanup(vb); | |
| //statistics.onNewVertexBuffer(); | |
| created = true; | |
| } | |
| // bind buffer | |
| int target; | |
| if (vb.getBufferType() == VertexBuffer.Type.Index) { | |
| target = GL_ELEMENT_ARRAY_BUFFER; | |
| if (context.boundElementArrayVBO != bufId) { | |
| glBindBuffer(target, bufId); | |
| context.boundElementArrayVBO = bufId; | |
| //statistics.onVertexBufferUse(vb, true); | |
| }else{ | |
| //statistics.onVertexBufferUse(vb, false); | |
| } | |
| } else { | |
| target = GL_ARRAY_BUFFER; | |
| if (context.boundArrayVBO != bufId) { | |
| glBindBuffer(target, bufId); | |
| context.boundArrayVBO = bufId; | |
| //statistics.onVertexBufferUse(vb, true); | |
| }else{ | |
| //statistics.onVertexBufferUse(vb, false); | |
| } | |
| } | |
| int usage = convertUsage(vb.getUsage()); | |
| vb.getData().rewind(); | |
| if (created || vb.hasDataSizeChanged()) { | |
| // upload data based on format | |
| switch (vb.getFormat()) { | |
| case Byte: | |
| case UnsignedByte: | |
| glBufferData(target, (ByteBuffer) vb.getData(), usage); | |
| break; | |
| // case Half: | |
| case Short: | |
| case UnsignedShort: | |
| glBufferData(target, (ShortBuffer) vb.getData(), usage); | |
| break; | |
| case Int: | |
| case UnsignedInt: | |
| glBufferData(target, (IntBuffer) vb.getData(), usage); | |
| break; | |
| case Float: | |
| glBufferData(target, (FloatBuffer) vb.getData(), usage); | |
| break; | |
| case Double: | |
| glBufferData(target, (DoubleBuffer) vb.getData(), usage); | |
| break; | |
| default: | |
| throw new UnsupportedOperationException("Unknown buffer format."); | |
| } | |
| } else { | |
| switch (vb.getFormat()) { | |
| case Byte: | |
| case UnsignedByte: | |
| glBufferSubData(target, 0, (ByteBuffer) vb.getData()); | |
| break; | |
| case Short: | |
| case UnsignedShort: | |
| glBufferSubData(target, 0, (ShortBuffer) vb.getData()); | |
| break; | |
| case Int: | |
| case UnsignedInt: | |
| glBufferSubData(target, 0, (IntBuffer) vb.getData()); | |
| break; | |
| case Float: | |
| glBufferSubData(target, 0, (FloatBuffer) vb.getData()); | |
| break; | |
| case Double: | |
| glBufferSubData(target, 0, (DoubleBuffer) vb.getData()); | |
| break; | |
| default: | |
| throw new UnsupportedOperationException("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); | |
| glDeleteBuffers(intBuf1); | |
| vb.resetObject(); | |
| //statistics.onDeleteVertexBuffer(); | |
| } | |
| } | |
| public void clearVertexAttribs() { | |
| IDList attribList = context.attribIndexList; | |
| for (int i = 0; i < attribList.oldLen; i++) { | |
| int idx = attribList.oldList[i]; | |
| glDisableVertexAttribArray(idx); | |
| context.boundAttribs[idx] = null; | |
| } | |
| context.attribIndexList.copyNewToOld(); | |
| } | |
| public void setVertexAttrib(VertexBuffer vb, VertexBuffer idb) { | |
| if (vb.getBufferType() == VertexBuffer.Type.Index) { | |
| throw new IllegalArgumentException("Index buffers not allowed to be set to vertex attrib"); | |
| } | |
| int programId = context.boundShaderProgram; | |
| if (programId > 0) { | |
| Attribute attrib = boundShader.getAttribute(vb.getBufferType()); | |
| int loc = attrib.getLocation(); | |
| if (loc == -1) { | |
| return; // not defined | |
| } | |
| if (loc == -2) { | |
| stringBuf.setLength(0); | |
| stringBuf.append("in").append(vb.getBufferType().name()).append('\0'); | |
| updateNameBuffer(); | |
| loc = glGetAttribLocation(programId, nameBuf); | |
| // 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); | |
| return; // not available in shader. | |
| } else { | |
| attrib.setLocation(loc); | |
| } | |
| } | |
| if (vb.isUpdateNeeded() && idb == null) { | |
| updateBufferData(vb); | |
| } | |
| VertexBuffer[] attribs = context.boundAttribs; | |
| if (!context.attribIndexList.moveToNew(loc)) { | |
| 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 (context.boundArrayVBO != bufId) { | |
| glBindBuffer(GL_ARRAY_BUFFER, bufId); | |
| context.boundArrayVBO = bufId; | |
| //statistics.onVertexBufferUse(vb, true); | |
| }else{ | |
| //statistics.onVertexBufferUse(vb, false); | |
| } | |
| glVertexAttribPointer(loc, | |
| vb.getNumComponents(), | |
| convertFormat(vb.getFormat()), | |
| vb.isNormalized(), | |
| vb.getStride(), | |
| vb.getOffset()); | |
| 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 { | |
| glDrawArrays(convertElementMode(mode), 0, vertCount); | |
| } | |
| } | |
| public void drawTriangleList(VertexBuffer indexBuf, Mesh mesh, int count) { | |
| if (indexBuf.getBufferType() != VertexBuffer.Type.Index) { | |
| throw new IllegalArgumentException("Only index buffers are allowed as triangle lists."); | |
| } | |
| if (indexBuf.isUpdateNeeded()) { | |
| updateBufferData(indexBuf); | |
| } | |
| int bufId = indexBuf.getId(); | |
| assert bufId != -1; | |
| if (context.boundElementArrayVBO != bufId) { | |
| glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, bufId); | |
| context.boundElementArrayVBO = bufId; | |
| //statistics.onVertexBufferUse(indexBuf, true); | |
| }else{ | |
| //statistics.onVertexBufferUse(indexBuf, true); | |
| } | |
| int vertCount = mesh.getVertexCount(); | |
| boolean useInstancing = count > 1 && caps.contains(Caps.MeshInstancing); | |
| 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.glDrawElementsInstancedARB(elMode, | |
| elementLength, | |
| fmt, | |
| curOffset, | |
| count); | |
| } else { | |
| glDrawRangeElements(elMode, | |
| 0, | |
| vertCount, | |
| elementLength, | |
| fmt, | |
| curOffset); | |
| } | |
| curOffset += elementLength * elSize; | |
| } | |
| } else { | |
| if (useInstancing) { | |
| ARBDrawInstanced.glDrawElementsInstancedARB(convertElementMode(mesh.getMode()), | |
| indexBuf.getData().limit(), | |
| convertFormat(indexBuf.getFormat()), | |
| 0, | |
| count); | |
| } else { | |
| glDrawRangeElements(convertElementMode(mesh.getMode()), | |
| 0, | |
| vertCount, | |
| indexBuf.getData().limit(), | |
| convertFormat(indexBuf.getFormat()), | |
| 0); | |
| } | |
| } | |
| } | |
| /*********************************************************************\ | |
| |* Render Calls *| | |
| \*********************************************************************/ | |
| public int convertElementMode(Mesh.Mode mode) { | |
| switch (mode) { | |
| case Points: | |
| return GL_POINTS; | |
| case Lines: | |
| return GL_LINES; | |
| case LineLoop: | |
| return GL_LINE_LOOP; | |
| case LineStrip: | |
| return GL_LINE_STRIP; | |
| case Triangles: | |
| return GL_TRIANGLES; | |
| case TriangleFan: | |
| return GL_TRIANGLE_FAN; | |
| case TriangleStrip: | |
| return GL_TRIANGLE_STRIP; | |
| default: | |
| throw new UnsupportedOperationException("Unrecognized mesh mode: " + mode); | |
| } | |
| } | |
| public void updateVertexArray(Mesh mesh) { | |
| int id = mesh.getId(); | |
| if (id == -1) { | |
| IntBuffer temp = intBuf1; | |
| ARBVertexArrayObject.glGenVertexArrays(temp); | |
| id = temp.get(0); | |
| mesh.setId(id); | |
| } | |
| if (context.boundVertexArray != id) { | |
| ARBVertexArrayObject.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); | |
| } | |
| } | |
| } | |
| private void renderMeshVertexArray(Mesh mesh, int lod, int count) { | |
| if (mesh.getId() == -1){ | |
| updateVertexArray(mesh); | |
| }else{ | |
| // TODO: Check if it was updated | |
| } | |
| if (context.boundVertexArray != mesh.getId()) { | |
| ARBVertexArrayObject.glBindVertexArray(mesh.getId()); | |
| context.boundVertexArray = mesh.getId(); | |
| } | |
| // IntMap<VertexBuffer> buffers = mesh.getBuffers(); | |
| VertexBuffer indices = null; | |
| if (mesh.getNumLodLevels() > 0) { | |
| indices = mesh.getLodLevel(lod); | |
| } else { | |
| indices = mesh.getBuffer(Type.Index); | |
| } | |
| if (indices != null) { | |
| drawTriangleList(indices, mesh, count); | |
| } else { | |
| drawTriangleArray(mesh.getMode(), count, mesh.getVertexCount()); | |
| } | |
| clearVertexAttribs(); | |
| clearTextureUnits(); | |
| } | |
| private void renderMeshDefault(Mesh mesh, int lod, int count) { | |
| VertexBuffer indices = null; | |
| VertexBuffer interleavedData = mesh.getBuffer(Type.InterleavedData); | |
| if (interleavedData != null && interleavedData.isUpdateNeeded()) { | |
| updateBufferData(interleavedData); | |
| } | |
| // IntMap<VertexBuffer> buffers = mesh.getBuffers(); | |
| SafeArrayList<VertexBuffer> buffersList = mesh.getBufferList(); | |
| if (mesh.getNumLodLevels() > 0) { | |
| indices = mesh.getLodLevel(lod); | |
| } else { | |
| indices = mesh.getBuffer(Type.Index); | |
| } | |
| // for (Entry<VertexBuffer> entry : buffers) { | |
| // VertexBuffer vb = entry.getValue(); | |
| for (VertexBuffer vb : mesh.getBufferList().getArray()){ | |
| 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 { | |
| drawTriangleArray(mesh.getMode(), count, mesh.getVertexCount()); | |
| } | |
| clearVertexAttribs(); | |
| clearTextureUnits(); | |
| } | |
| public void renderMesh(Mesh mesh, int lod, int count) { | |
| if (mesh.getVertexCount() == 0) { | |
| return; | |
| } | |
| if (context.pointSprite && mesh.getMode() != Mode.Points){ | |
| // XXX: Hack, disable point sprite mode if mesh not in point mode | |
| if (context.boundTextures[0] != null){ | |
| if (context.boundTextureUnit != 0){ | |
| glActiveTexture(GL_TEXTURE0); | |
| context.boundTextureUnit = 0; | |
| } | |
| glDisable(GL_POINT_SPRITE); | |
| glDisable(GL_VERTEX_PROGRAM_POINT_SIZE); | |
| context.pointSprite = false; | |
| } | |
| } | |
| if (context.pointSize != mesh.getPointSize()) { | |
| glPointSize(mesh.getPointSize()); | |
| context.pointSize = mesh.getPointSize(); | |
| } | |
| if (context.lineWidth != mesh.getLineWidth()) { | |
| glLineWidth(mesh.getLineWidth()); | |
| context.lineWidth = mesh.getLineWidth(); | |
| } | |
| statistics.onMeshDrawn(mesh, lod); | |
| // if (GLContext.getCapabilities().GL_ARB_vertex_array_object){ | |
| // renderMeshVertexArray(mesh, lod, count); | |
| // }else{ | |
| renderMeshDefault(mesh, lod, count); | |
| // } | |
| } | |
| } |