private static void clearEnabledAttributes(final ShaderObjectsStateRecord record, final GL gl) { // go through and disable any enabled attributes if (!record.enabledAttributes.isEmpty()) { for (int i = 0, maxI = record.enabledAttributes.size(); i < maxI; i++) { final ShaderVariable var = record.enabledAttributes.get(i); if (var.getSize() == 1) { if (gl.isGL2()) { gl.getGL2().glDisableVertexAttribArrayARB(var.variableID); } else { if (gl.isGL2ES2()) { gl.getGL2ES2().glDisableVertexAttribArray(var.variableID); } } } else { for (int j = 0, maxJ = var.getSize(); j < maxJ; j++) { if (gl.isGL2()) { gl.getGL2().glDisableVertexAttribArrayARB(var.variableID + j); } else { if (gl.isGL2ES2()) { gl.getGL2ES2().glDisableVertexAttribArray(var.variableID + j); } } } } } record.enabledAttributes.clear(); } }
/** Applies fixed function bindings from the context to OpenGL */ private void applyFixedFuncBindings(boolean forLighting) { GL gl = GLContext.getCurrentGL(); if (forLighting) { gl.getGL2().glMaterialf(GL.GL_FRONT_AND_BACK, GLLightingFunc.GL_SHININESS, context.shininess); setMaterialColor(GLLightingFunc.GL_AMBIENT, context.ambient, ColorRGBA.DarkGray); setMaterialColor(GLLightingFunc.GL_DIFFUSE, context.diffuse, ColorRGBA.White); setMaterialColor(GLLightingFunc.GL_SPECULAR, context.specular, ColorRGBA.Black); if (context.useVertexColor) { gl.glEnable(GLLightingFunc.GL_COLOR_MATERIAL); } else { gl.glDisable(GLLightingFunc.GL_COLOR_MATERIAL); } } else { // Ignore other values as they have no effect when // GL_LIGHTING is disabled. ColorRGBA color = context.color; if (color != null) { gl.getGL2().glColor4f(color.r, color.g, color.b, color.a); } else { gl.getGL2().glColor4f(1, 1, 1, 1); } } if (context.alphaTestFallOff > 0f) { gl.glEnable(GL2ES1.GL_ALPHA_TEST); gl.getGL2ES1().glAlphaFunc(GL.GL_GREATER, context.alphaTestFallOff); } else { gl.glDisable(GL2ES1.GL_ALPHA_TEST); } }
public void drawGL2(GL gl) { gl.getGL2().glPointSize(width); gl.getGL2().glBegin(GL2.GL_POINTS); if (points != null) { synchronized (points) { for (LightPoint p : points) { gl.getGL2().glColor4f(p.rgb.r, p.rgb.g, p.rgb.b, p.rgb.a); GlVertexExecutor.Vertex(gl, new Coord3d(p.xyz.x, p.xyz.y, p.xyz.z), transformers); } } } gl.getGL2().glEnd(); }
private static void checkLinkError(final int programId) { final GL gl = GLContext.getCurrentGL(); final JoglRenderContext context = (JoglRenderContext) ContextManager.getCurrentContext(); final IntBuffer compiled = context.getDirectNioBuffersSet().getSingleIntBuffer(); compiled.clear(); if (gl.isGL2()) { gl.getGL2().glGetObjectParameterivARB(programId, GL2ES2.GL_LINK_STATUS, compiled); } else { if (gl.isGL2ES2()) { gl.getGL2ES2().glGetProgramiv(programId, GL2ES2.GL_LINK_STATUS, compiled); } } if (compiled.get(0) == GL.GL_FALSE) { if (gl.isGL2()) { gl.getGL2().glGetObjectParameterivARB(programId, GL2ES2.GL_INFO_LOG_LENGTH, compiled); } else { if (gl.isGL2ES2()) { gl.getGL2ES2().glGetProgramiv(programId, GL2ES2.GL_INFO_LOG_LENGTH, compiled); } } final int length = compiled.get(0); String out = null; if (length > 0) { final ByteBuffer infoLogBuf = context.getDirectNioBuffersSet().getInfoLogBuffer(); final ByteBuffer infoLog; if (length <= infoLogBuf.capacity()) { infoLog = infoLogBuf; infoLogBuf.rewind().limit(length); } else { infoLog = BufferUtils.createByteBuffer(length); } if (gl.isGL2()) { gl.getGL2().glGetInfoLogARB(programId, infoLog.limit(), compiled, infoLog); } else { if (gl.isGL2ES2()) { gl.getGL2ES2().glGetProgramInfoLog(programId, infoLog.limit(), compiled, infoLog); } } final byte[] infoBytes = new byte[length]; infoLog.get(infoBytes); out = new String(infoBytes); } logger.severe(out); // throw new Ardor3dException("Error linking GLSL shader: " + out); } }
private void drawElements(int mode, int format, Buffer data) { GL gl = GLContext.getCurrentGL(); switch (format) { case GL.GL_UNSIGNED_BYTE: gl.getGL2().glDrawElements(mode, data.limit(), format, (ByteBuffer) data); break; case GL.GL_UNSIGNED_SHORT: gl.getGL2().glDrawElements(mode, data.limit(), format, (ShortBuffer) data); break; case GL.GL_UNSIGNED_INT: gl.getGL2().glDrawElements(mode, data.limit(), format, (IntBuffer) data); break; default: throw new UnsupportedOperationException(); } }
/** * Check for program errors. If an error is detected, program exits. * * @param compilerState the compiler state for a given shader * @param id shader's id */ private static void checkProgramError( final int compilerState, final int id, final String shaderName) { final GL gl = GLContext.getCurrentGL(); if (compilerState == GL.GL_FALSE) { final JoglRenderContext context = (JoglRenderContext) ContextManager.getCurrentContext(); final IntBuffer iVal = context.getDirectNioBuffersSet().getSingleIntBuffer(); iVal.clear(); if (gl.isGL2()) { gl.getGL2().glGetObjectParameterivARB(id, GL2.GL_OBJECT_INFO_LOG_LENGTH_ARB, iVal); } else { if (gl.isGL2ES2()) { gl.getGL2ES2().glGetProgramiv(id, GL2ES2.GL_INFO_LOG_LENGTH, iVal); } } final int length = iVal.get(0); String out = null; if (length > 0) { final ByteBuffer infoLogBuf = context.getDirectNioBuffersSet().getInfoLogBuffer(); final ByteBuffer infoLog; if (length <= infoLogBuf.capacity()) { infoLog = infoLogBuf; infoLogBuf.rewind().limit(length); } else { infoLog = BufferUtils.createByteBuffer(length); } if (gl.isGL2()) { gl.getGL2().glGetInfoLogARB(id, infoLog.limit(), iVal, infoLog); } else { if (gl.isGL2ES2()) { gl.getGL2ES2().glGetProgramInfoLog(id, infoLog.limit(), iVal, infoLog); } } final byte[] infoBytes = new byte[length]; infoLog.get(infoBytes); out = new String(infoBytes); } logger.severe(out); final String nameString = shaderName.equals("") ? "" : " [ " + shaderName + " ]"; throw new Ardor3dException("Error compiling GLSL shader " + nameString + ": " + out); } }
private void setMaterialColor(int type, ColorRGBA color, ColorRGBA defaultColor) { GL gl = GLContext.getCurrentGL(); if (color != null) { fb16.put(color.r).put(color.g).put(color.b).put(color.a).flip(); } else { fb16.put(defaultColor.r).put(defaultColor.g).put(defaultColor.b).put(defaultColor.a).flip(); } gl.getGL2().glMaterialfv(GL.GL_FRONT_AND_BACK, type, fb16); }
public void update(GL glGeneric) { if (!init) return; GL2 gl = glGeneric.getGL2(); contentManager.update(gl); ui.update(gl, elapsedMS); world.update(gl, elapsedMS, ui); drawings.update(); }
public void clearVertexAttribs() { for (int i = 0; i < 16; i++) { VertexBuffer vb = context.boundAttribs[i]; if (vb != null) { int arrayType = convertArrayType(vb.getBufferType()); GL gl = GLContext.getCurrentGL(); gl.getGL2().glDisableClientState(arrayType); context.boundAttribs[vb.getBufferType().ordinal()] = null; } } }
public void renderMesh(Mesh mesh, int lod, int count, VertexBuffer[] instanceData) { if (mesh.getVertexCount() == 0) { return; } GL gl = GLContext.getCurrentGL(); if (context.pointSize != mesh.getPointSize()) { gl.getGL2().glPointSize(mesh.getPointSize()); context.pointSize = mesh.getPointSize(); } if (context.lineWidth != mesh.getLineWidth()) { gl.getGL2().glLineWidth(mesh.getLineWidth()); context.lineWidth = mesh.getLineWidth(); } boolean dynamic = false; if (mesh.getBuffer(Type.InterleavedData) != null) { throw new UnsupportedOperationException("Interleaved meshes are not supported"); } if (mesh.getNumLodLevels() == 0) { for (VertexBuffer vb : mesh.getBufferList().getArray()) { if (vb.getUsage() != VertexBuffer.Usage.Static) { dynamic = true; break; } } } else { dynamic = true; } statistics.onMeshDrawn(mesh, lod); // if (!dynamic) { // dealing with a static object, generate display list // renderMeshDisplayList(mesh); // } else { renderMeshDefault(mesh, lod, count); // } }
/** Removes the tessellation evaluation shader */ private static void removeTessEvalShader(final GLSLShaderObjectsState state) { final GL gl = GLContext.getCurrentGL(); if (state._tessellationEvaluationShaderID != -1) { if (gl.isGL2()) { gl.getGL2().glDetachObjectARB(state._programID, state._tessellationEvaluationShaderID); gl.getGL2().glDeleteObjectARB(state._tessellationEvaluationShaderID); } else { if (gl.isGL2ES2()) { gl.getGL2ES2().glDetachShader(state._programID, state._tessellationEvaluationShaderID); gl.getGL2ES2().glDeleteShader(state._tessellationEvaluationShaderID); } } } }
private long getBufferSizeImpl(int target, int buffer, GL caller) { // See whether we know the size of this buffer object; at this // point we almost certainly should if the application is // written correctly long sz = bufferSizeMap.get(buffer); if (0 > sz) { // For robustness, try to query this value from the GL as we used to // FIXME: both functions return 'int' types, which is not suitable, // since buffer lenght is 64bit ? int[] tmp = new int[1]; if (0 == target) { // DirectState .. if (caller.isFunctionAvailable("glGetNamedBufferParameterivEXT")) { caller.getGL2().glGetNamedBufferParameterivEXT(buffer, GL.GL_BUFFER_SIZE, tmp, 0); } else { throw new GLException( "Error: getDirectStateBufferSize called with unknown state and GL function 'glGetNamedBufferParameterivEXT' n/a to query size"); } } else { caller.glGetBufferParameteriv(target, GL.GL_BUFFER_SIZE, tmp, 0); } if (tmp[0] == 0) { // Assume something is wrong rather than silently going along throw new GLException( "Error: buffer size returned by " + ((0 == target) ? "glGetNamedBufferParameterivEXT" : "glGetBufferParameteriv") + " was zero; probably application error"); } // Assume we just don't know what's happening sz = (long) tmp[0]; bufferSizeMap.put(buffer, sz); if (DEBUG) { System.err.println( "GLBufferSizeTracker.getBufferSize(): made slow query to cache size " + sz + " for buffer " + buffer); } } return sz; }
public void initialize() { GL gl = GLContext.getCurrentGL(); if (gl.isExtensionAvailable("GL_VERSION_1_2")) { gl12 = true; } // workaround, always assume we support GLSL100 // some cards just don't report this correctly caps.add(Caps.GLSL100); // Default values for certain GL state. gl.getGL2ES1().glShadeModel(GLLightingFunc.GL_SMOOTH); gl.getGL2().glColorMaterial(GL.GL_FRONT_AND_BACK, GLLightingFunc.GL_DIFFUSE); gl.glHint(GL2ES1.GL_PERSPECTIVE_CORRECTION_HINT, GL.GL_NICEST); // Enable rescaling/normaling of normal vectors. // Fixes lighting issues with scaled models. if (gl12) { gl.glEnable(GL2ES1.GL_RESCALE_NORMAL); } else { gl.glEnable(GLLightingFunc.GL_NORMALIZE); } if (gl.isExtensionAvailable("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."); } gl.glGetIntegerv(GL2ES1.GL_MAX_LIGHTS, ib1); maxLights = ib1.get(0); gl.glGetIntegerv(GL.GL_MAX_TEXTURE_SIZE, ib1); maxTexSize = ib1.get(0); }
@Override protected void render(GL g) { GL2 gl = g.getGL2(); gl.glColor3f(.5f, .5f, .5f); // =======================================\\ // Retained Mode \\ // =======================================\\ gl.glEnableClientState(GL2.GL_VERTEX_ARRAY); gl.glVertexPointer(3, GL2.GL_FLOAT, 0, vertexBuffer); if (normal) { gl.glEnableClientState(GL2.GL_NORMAL_ARRAY); gl.glNormalPointer(GL2.GL_FLOAT, 0, normalBuffer); } if (texture) { gl.glEnableClientState(GL2.GL_TEXTURE_COORD_ARRAY); gl.glTexCoordPointer(2, GL2.GL_FLOAT, 0, textureBuffer); } else gl.glPolygonMode(GL2.GL_FRONT_AND_BACK, GL2.GL_LINE); for (IntBuffer face : faces) { if (face.capacity() == 3) gl.glDrawElements(GL2.GL_TRIANGLES, face.capacity(), GL2.GL_UNSIGNED_INT, face); else if (face.capacity() == 4) gl.glDrawElements(GL2.GL_QUADS, face.capacity(), GL2.GL_UNSIGNED_INT, face); else gl.glDrawElements(GL2.GL_POLYGON, face.capacity(), GL2.GL_UNSIGNED_INT, face); } gl.glDisableClientState(GL2.GL_VERTEX_ARRAY); if (normal) gl.glDisableClientState(GL2.GL_NORMAL_ARRAY); if (texture) gl.glDisableClientState(GL2.GL_TEXTURE_COORD_ARRAY); if (drawBox) bbox.draw(gl); }
@Override public void setGLContext(GL context) { gl = context.getGL2(); }
/** ******************************************************************* */ public void draw(GL gl, GLU glu, Camera cam) { doTransform(gl, glu, cam); applyMaterial(gl); // TODO: shall we avoid calling this @ each draw? Coord3d norm = Normal.compute(points.get(0).xyz, points.get(1).xyz, points.get(2).xyz); // Draw content of polygon if (gl.isGL2()) { if (facestatus) { gl.getGL2().glPolygonMode(GL2.GL_FRONT_AND_BACK, GL2.GL_FILL); if (wfstatus) { gl.getGL2().glEnable(GL2.GL_POLYGON_OFFSET_FILL); gl.getGL2().glPolygonOffset(1.0f, 1.0f); } gl.getGL2().glBegin(GL2.GL_POLYGON); for (Point p : points) { if (mapper != null) { Color c = mapper.getColor(p.xyz); // TODO: should store // result in the // point color gl.getGL2().glColor4f(c.r, c.g, c.b, c.a); } else gl.getGL2().glColor4f(p.rgb.r, p.rgb.g, p.rgb.b, p.rgb.a); gl.getGL2().glVertex3f(p.xyz.x, p.xyz.y, p.xyz.z); gl.getGL2().glNormal3f(norm.x, norm.y, norm.z); } gl.getGL2().glEnd(); if (wfstatus) gl.glDisable(GL2.GL_POLYGON_OFFSET_FILL); } // Draw edge of polygon if (wfstatus) { gl.getGL2().glPolygonMode(GL2.GL_FRONT_AND_BACK, GL2.GL_LINE); gl.glEnable(GL2.GL_POLYGON_OFFSET_FILL); gl.glPolygonOffset(1.0f, 1.0f); gl.getGL2().glColor4f(wfcolor.r, wfcolor.g, wfcolor.b, 1); // wfcolor.a); gl.glLineWidth(wfwidth); gl.getGL2().glBegin(GL2.GL_POLYGON); for (Point p : points) { gl.getGL2().glVertex3f(p.xyz.x, p.xyz.y, p.xyz.z); gl.getGL2().glNormal3f(norm.x, norm.y, norm.z); } gl.getGL2().glEnd(); gl.glDisable(GL2.GL_POLYGON_OFFSET_FILL); } } else { if (facestatus) { GLES2CompatUtils.glPolygonMode(GL2.GL_FRONT_AND_BACK, GL2.GL_FILL); if (wfstatus) { gl.glEnable(GL2.GL_POLYGON_OFFSET_FILL); gl.glPolygonOffset(1.0f, 1.0f); } GLES2CompatUtils.glBegin(GL2.GL_POLYGON); for (Point p : points) { if (mapper != null) { Color c = mapper.getColor(p.xyz); // TODO: should store // result in the // point color GLES2CompatUtils.glColor4f(c.r, c.g, c.b, c.a); } else GLES2CompatUtils.glColor4f(p.rgb.r, p.rgb.g, p.rgb.b, p.rgb.a); GLES2CompatUtils.glVertex3f(p.xyz.x, p.xyz.y, p.xyz.z); GLES2CompatUtils.glNormal3f(norm.x, norm.y, norm.z); } GLES2CompatUtils.glEnd(); if (wfstatus) gl.glDisable(GL2.GL_POLYGON_OFFSET_FILL); } // Draw edge of polygon if (wfstatus) { GLES2CompatUtils.glPolygonMode(GL2.GL_FRONT_AND_BACK, GL2.GL_LINE); gl.glEnable(GL2.GL_POLYGON_OFFSET_FILL); gl.glPolygonOffset(1.0f, 1.0f); GLES2CompatUtils.glColor4f(wfcolor.r, wfcolor.g, wfcolor.b, 1); // wfcolor.a); gl.glLineWidth(wfwidth); GLES2CompatUtils.glBegin(GL2.GL_POLYGON); for (Point p : points) { GLES2CompatUtils.glVertex3f(p.xyz.x, p.xyz.y, p.xyz.z); GLES2CompatUtils.glNormal3f(norm.x, norm.y, norm.z); } GLES2CompatUtils.glEnd(); gl.glDisable(GL2.GL_POLYGON_OFFSET_FILL); } } /* * // Drawbarycenter Point b = new Point(getBarycentre(), Color.BLUE); * b.setWidth(5); b.draw(gl,glu,cam); */ }
public void setVertexAttrib(VertexBuffer vb, VertexBuffer idb) { if (vb.getBufferType() == VertexBuffer.Type.Color && !context.useVertexColor) { // Ignore vertex color buffer if vertex color is disabled. return; } int arrayType = convertArrayType(vb.getBufferType()); if (arrayType == -1) { return; // unsupported } GL gl = GLContext.getCurrentGL(); gl.getGL2GL3().glEnableClientState(arrayType); context.boundAttribs[vb.getBufferType().ordinal()] = vb; if (vb.getBufferType() == Type.Normal) { // normalize if requested if (vb.isNormalized() && !context.normalizeEnabled) { gl.glEnable(GLLightingFunc.GL_NORMALIZE); context.normalizeEnabled = true; } else if (!vb.isNormalized() && context.normalizeEnabled) { gl.glDisable(GLLightingFunc.GL_NORMALIZE); context.normalizeEnabled = false; } } // NOTE: Use data from interleaved buffer if specified Buffer data = idb != null ? idb.getData() : vb.getData(); int comps = vb.getNumComponents(); int type = convertVertexFormat(vb.getFormat()); data.rewind(); switch (vb.getBufferType()) { case Position: if (!(data instanceof FloatBuffer)) { throw new UnsupportedOperationException(); } gl.getGL2().glVertexPointer(comps, type, vb.getStride(), (FloatBuffer) data); break; case Normal: if (!(data instanceof FloatBuffer)) { throw new UnsupportedOperationException(); } gl.getGL2().glNormalPointer(type, vb.getStride(), (FloatBuffer) data); break; case Color: if (data instanceof FloatBuffer) { gl.getGL2().glColorPointer(comps, type, vb.getStride(), (FloatBuffer) data); } else if (data instanceof ByteBuffer) { gl.getGL2().glColorPointer(comps, type, vb.getStride(), (ByteBuffer) data); } else { throw new UnsupportedOperationException(); } break; case TexCoord: if (!(data instanceof FloatBuffer)) { throw new UnsupportedOperationException(); } gl.getGL2().glTexCoordPointer(comps, type, vb.getStride(), (FloatBuffer) data); break; default: // Ignore, this is an unsupported attribute for OpenGL1. break; } }
protected static void sendToGL( final GLSLShaderObjectsState state, final ContextCapabilities caps) { final GL gl = GLContext.getCurrentGL(); if (state.getVertexShader() == null && state.getFragmentShader() == null) { logger.warning("Could not find shader resources!" + "(both inputbuffers are null)"); state._needSendShader = false; return; } if (state._programID == -1) { if (gl.isGL2()) { state._programID = gl.getGL2().glCreateProgramObjectARB(); } else { if (gl.isGL2ES2()) { state._programID = gl.getGL2ES2().glCreateProgram(); } } } if (state.getVertexShader() != null) { if (state._vertexShaderID != -1) { removeVertShader(state); } if (gl.isGL2()) { state._vertexShaderID = gl.getGL2().glCreateShaderObjectARB(GL2ES2.GL_VERTEX_SHADER); } else { if (gl.isGL2ES2()) { state._vertexShaderID = gl.getGL2ES2().glCreateShader(GL2ES2.GL_VERTEX_SHADER); } } // Create the sources final byte array[] = new byte[state.getVertexShader().limit()]; state.getVertexShader().rewind(); state.getVertexShader().get(array); if (gl.isGL2()) { gl.getGL2() .glShaderSourceARB( state._vertexShaderID, 1, new String[] {new String(array)}, new int[] {array.length}, 0); } else { if (gl.isGL2ES2()) { gl.getGL2ES2() .glShaderSource( state._vertexShaderID, 1, new String[] {new String(array)}, new int[] {array.length}, 0); } } // Compile the vertex shader final JoglRenderContext context = (JoglRenderContext) ContextManager.getCurrentContext(); final IntBuffer compiled = context.getDirectNioBuffersSet().getSingleIntBuffer(); compiled.clear(); if (gl.isGL2()) { gl.getGL2().glCompileShaderARB(state._vertexShaderID); gl.getGL2() .glGetObjectParameterivARB( state._vertexShaderID, GL2.GL_OBJECT_COMPILE_STATUS_ARB, compiled); } else { if (gl.isGL2ES2()) { gl.getGL2ES2().glCompileShader(state._vertexShaderID); gl.getGL2ES2().glGetShaderiv(state._vertexShaderID, GL2ES2.GL_COMPILE_STATUS, compiled); } } checkProgramError(compiled.get(0), state._vertexShaderID, state._vertexShaderName); // Attach the program if (gl.isGL2()) { gl.getGL2().glAttachObjectARB(state._programID, state._vertexShaderID); } else { if (gl.isGL2ES2()) { gl.getGL2ES2().glAttachShader(state._programID, state._vertexShaderID); } } } else if (state._vertexShaderID != -1) { removeVertShader(state); state._vertexShaderID = -1; } if (state.getFragmentShader() != null) { if (state._fragmentShaderID != -1) { removeFragShader(state); } if (gl.isGL2()) { state._fragmentShaderID = gl.getGL2().glCreateShaderObjectARB(GL2ES2.GL_FRAGMENT_SHADER); } else { if (gl.isGL2ES2()) { state._fragmentShaderID = gl.getGL2ES2().glCreateShader(GL2ES2.GL_FRAGMENT_SHADER); } } // Create the sources final byte array[] = new byte[state.getFragmentShader().limit()]; state.getFragmentShader().rewind(); state.getFragmentShader().get(array); if (gl.isGL2()) { gl.getGL2() .glShaderSourceARB( state._fragmentShaderID, 1, new String[] {new String(array)}, new int[] {array.length}, 0); } else { if (gl.isGL2ES2()) { gl.getGL2ES2() .glShaderSource( state._fragmentShaderID, 1, new String[] {new String(array)}, new int[] {array.length}, 0); } } // Compile the fragment shader final JoglRenderContext context = (JoglRenderContext) ContextManager.getCurrentContext(); final IntBuffer compiled = context.getDirectNioBuffersSet().getSingleIntBuffer(); compiled.clear(); if (gl.isGL2()) { gl.getGL2().glCompileShaderARB(state._fragmentShaderID); gl.getGL2() .glGetObjectParameterivARB( state._fragmentShaderID, GL2.GL_OBJECT_COMPILE_STATUS_ARB, compiled); } else { if (gl.isGL2ES2()) { gl.getGL2ES2().glCompileShader(state._fragmentShaderID); gl.getGL2ES2().glGetShaderiv(state._fragmentShaderID, GL2ES2.GL_COMPILE_STATUS, compiled); } } checkProgramError(compiled.get(0), state._fragmentShaderID, state._vertexShaderName); // Attach the program if (gl.isGL2()) { gl.getGL2().glAttachObjectARB(state._programID, state._fragmentShaderID); } else { if (gl.isGL2ES2()) { gl.getGL2ES2().glAttachShader(state._programID, state._fragmentShaderID); } } } else if (state._fragmentShaderID != -1) { removeFragShader(state); state._fragmentShaderID = -1; } if (caps.isGeometryShader4Supported()) { if (state.getGeometryShader() != null) { if (state._geometryShaderID != -1) { removeGeomShader(state); } if (gl.isGL2()) { state._geometryShaderID = gl.getGL2().glCreateShaderObjectARB(GL3.GL_GEOMETRY_SHADER); } else { if (gl.isGL2ES2()) { state._geometryShaderID = gl.getGL2ES2().glCreateShader(GL3.GL_GEOMETRY_SHADER); } } // Create the sources final byte array[] = new byte[state.getGeometryShader().limit()]; state.getGeometryShader().rewind(); state.getGeometryShader().get(array); if (gl.isGL2()) { gl.getGL2() .glShaderSourceARB( state._geometryShaderID, 1, new String[] {new String(array)}, new int[] {array.length}, 0); } else { if (gl.isGL2ES2()) { gl.getGL2ES2() .glShaderSource( state._geometryShaderID, 1, new String[] {new String(array)}, new int[] {array.length}, 0); } } // Compile the geometry shader final JoglRenderContext context = (JoglRenderContext) ContextManager.getCurrentContext(); final IntBuffer compiled = context.getDirectNioBuffersSet().getSingleIntBuffer(); compiled.clear(); if (gl.isGL2()) { gl.getGL2().glCompileShaderARB(state._geometryShaderID); gl.getGL2() .glGetObjectParameterivARB( state._geometryShaderID, GL2.GL_OBJECT_COMPILE_STATUS_ARB, compiled); } else { if (gl.isGL2ES2()) { gl.getGL2ES2().glCompileShader(state._geometryShaderID); gl.getGL2ES2() .glGetShaderiv(state._geometryShaderID, GL2ES2.GL_COMPILE_STATUS, compiled); } } checkProgramError(compiled.get(0), state._geometryShaderID, state._geometryShaderName); // Attach the program if (gl.isGL2()) { gl.getGL2().glAttachObjectARB(state._programID, state._geometryShaderID); } else { if (gl.isGL2ES2()) { gl.getGL2ES2().glAttachShader(state._programID, state._geometryShaderID); } } } else if (state._geometryShaderID != -1) { removeGeomShader(state); state._geometryShaderID = -1; } } if (caps.isTessellationShadersSupported()) { if (state.getTessellationControlShader() != null) { if (state._tessellationControlShaderID != -1) { removeTessControlShader(state); } if (gl.isGL2()) { state._tessellationControlShaderID = gl.getGL2().glCreateShaderObjectARB(GL4.GL_TESS_CONTROL_SHADER); } else { if (gl.isGL2ES2()) { state._tessellationControlShaderID = gl.getGL2ES2().glCreateShader(GL4.GL_TESS_CONTROL_SHADER); } } // Create the sources final byte array[] = new byte[state.getTessellationControlShader().limit()]; state.getTessellationControlShader().rewind(); state.getTessellationControlShader().get(array); if (gl.isGL2()) { gl.getGL2() .glShaderSourceARB( state._tessellationControlShaderID, 1, new String[] {new String(array)}, new int[] {array.length}, 0); } else { if (gl.isGL2ES2()) { gl.getGL2ES2() .glShaderSource( state._tessellationControlShaderID, 1, new String[] {new String(array)}, new int[] {array.length}, 0); } } // Compile the tessellation control shader final JoglRenderContext context = (JoglRenderContext) ContextManager.getCurrentContext(); final IntBuffer compiled = context.getDirectNioBuffersSet().getSingleIntBuffer(); compiled.clear(); if (gl.isGL2()) { gl.getGL2().glCompileShaderARB(state._tessellationControlShaderID); gl.getGL2() .glGetObjectParameterivARB( state._tessellationControlShaderID, GL2.GL_OBJECT_COMPILE_STATUS_ARB, compiled); } else { if (gl.isGL2ES2()) { gl.getGL2ES2().glCompileShader(state._tessellationControlShaderID); gl.getGL2ES2() .glGetShaderiv( state._tessellationControlShaderID, GL2ES2.GL_COMPILE_STATUS, compiled); } } checkProgramError( compiled.get(0), state._tessellationControlShaderID, state._tessellationControlShaderName); // Attach the program if (gl.isGL2()) { gl.getGL2().glAttachObjectARB(state._programID, state._tessellationControlShaderID); } else { if (gl.isGL2ES2()) { gl.getGL2ES2().glAttachShader(state._programID, state._tessellationControlShaderID); } } } else if (state._tessellationControlShaderID != -1) { removeTessControlShader(state); state._tessellationControlShaderID = -1; } if (state.getTessellationEvaluationShader() != null) { if (state._tessellationEvaluationShaderID != -1) { removeTessEvalShader(state); } if (gl.isGL2()) { state._tessellationEvaluationShaderID = gl.getGL2().glCreateShaderObjectARB(GL4.GL_TESS_CONTROL_SHADER); } else { if (gl.isGL2ES2()) { state._tessellationEvaluationShaderID = gl.getGL2ES2().glCreateShader(GL4.GL_TESS_CONTROL_SHADER); } } // Create the sources final byte array[] = new byte[state.getTessellationEvaluationShader().limit()]; state.getTessellationEvaluationShader().rewind(); state.getTessellationEvaluationShader().get(array); if (gl.isGL2()) { gl.getGL2() .glShaderSourceARB( state._tessellationEvaluationShaderID, 1, new String[] {new String(array)}, new int[] {array.length}, 0); } else { if (gl.isGL2ES2()) { gl.getGL2ES2() .glShaderSource( state._tessellationEvaluationShaderID, 1, new String[] {new String(array)}, new int[] {array.length}, 0); } } // Compile the tessellation control shader final JoglRenderContext context = (JoglRenderContext) ContextManager.getCurrentContext(); final IntBuffer compiled = context.getDirectNioBuffersSet().getSingleIntBuffer(); compiled.clear(); if (gl.isGL2()) { gl.getGL2().glCompileShaderARB(state._tessellationEvaluationShaderID); gl.getGL2() .glGetObjectParameterivARB( state._tessellationEvaluationShaderID, GL2.GL_OBJECT_COMPILE_STATUS_ARB, compiled); } else { if (gl.isGL2ES2()) { gl.getGL2ES2().glCompileShader(state._tessellationEvaluationShaderID); gl.getGL2ES2() .glGetShaderiv( state._tessellationEvaluationShaderID, GL2ES2.GL_COMPILE_STATUS, compiled); } } checkProgramError( compiled.get(0), state._tessellationEvaluationShaderID, state._tessellationEvaluationShaderName); // Attach the program if (gl.isGL2()) { gl.getGL2().glAttachObjectARB(state._programID, state._tessellationEvaluationShaderID); } else { if (gl.isGL2ES2()) { gl.getGL2ES2().glAttachShader(state._programID, state._tessellationEvaluationShaderID); } } } else if (state._tessellationEvaluationShaderID != -1) { removeTessEvalShader(state); state._tessellationEvaluationShaderID = -1; } } if (gl.isGL2()) { gl.getGL2().glLinkProgramARB(state._programID); } else { if (gl.isGL2ES2()) { gl.getGL2ES2().glLinkProgram(state._programID); } } checkLinkError(state._programID); state.setNeedsRefresh(true); state._needSendShader = false; }
public void setLighting(LightList list) { GL gl = GLContext.getCurrentGL(); // XXX: This is abuse of setLighting() to // apply fixed function bindings // and do other book keeping. if (list == null || list.size() == 0) { gl.glDisable(GLLightingFunc.GL_LIGHTING); applyFixedFuncBindings(false); setModelView(worldMatrix, viewMatrix); return; } // Number of lights set previously int numLightsSetPrev = lightList.size(); // If more than maxLights are defined, they will be ignored. // The GL1 renderer is not permitted to crash due to a // GL1 limitation. It must render anything that the GL2 renderer // can render (even incorrectly). lightList.clear(); materialAmbientColor.set(0, 0, 0, 0); for (int i = 0; i < list.size(); i++) { Light l = list.get(i); if (l.getType() == Light.Type.Ambient) { // Gather materialAmbientColor.addLocal(l.getColor()); } else { // Add to list lightList.add(l); // Once maximum lights reached, exit loop. if (lightList.size() >= maxLights) { break; } } } applyFixedFuncBindings(true); gl.glEnable(GLLightingFunc.GL_LIGHTING); fb16.clear(); fb16.put(materialAmbientColor.r) .put(materialAmbientColor.g) .put(materialAmbientColor.b) .put(1) .flip(); gl.getGL2ES1().glLightModelfv(GL2ES1.GL_LIGHT_MODEL_AMBIENT, fb16); if (context.matrixMode != GLMatrixFunc.GL_MODELVIEW) { gl.getGL2ES1().glMatrixMode(GLMatrixFunc.GL_MODELVIEW); context.matrixMode = GLMatrixFunc.GL_MODELVIEW; } // Lights are already in world space, so just convert // them to view space. gl.getGL2ES1().glLoadMatrixf(storeMatrix(viewMatrix, fb16)); for (int i = 0; i < lightList.size(); i++) { int glLightIndex = GLLightingFunc.GL_LIGHT0 + i; Light light = lightList.get(i); Light.Type lightType = light.getType(); ColorRGBA col = light.getColor(); Vector3f pos; // Enable the light gl.glEnable(glLightIndex); // OGL spec states default value for light ambient is black switch (lightType) { case Directional: DirectionalLight dLight = (DirectionalLight) light; fb16.clear(); fb16.put(col.r).put(col.g).put(col.b).put(col.a).flip(); gl.getGL2ES1().glLightfv(glLightIndex, GLLightingFunc.GL_DIFFUSE, fb16); gl.getGL2ES1().glLightfv(glLightIndex, GLLightingFunc.GL_SPECULAR, fb16); pos = tempVec.set(dLight.getDirection()).negateLocal().normalizeLocal(); fb16.clear(); fb16.put(pos.x).put(pos.y).put(pos.z).put(0.0f).flip(); gl.getGL2ES1().glLightfv(glLightIndex, GLLightingFunc.GL_POSITION, fb16); gl.getGL2ES1().glLightf(glLightIndex, GLLightingFunc.GL_SPOT_CUTOFF, 180); break; case Point: PointLight pLight = (PointLight) light; fb16.clear(); fb16.put(col.r).put(col.g).put(col.b).put(col.a).flip(); gl.getGL2ES1().glLightfv(glLightIndex, GLLightingFunc.GL_DIFFUSE, fb16); gl.getGL2ES1().glLightfv(glLightIndex, GLLightingFunc.GL_SPECULAR, fb16); pos = pLight.getPosition(); fb16.clear(); fb16.put(pos.x).put(pos.y).put(pos.z).put(1.0f).flip(); gl.getGL2ES1().glLightfv(glLightIndex, GLLightingFunc.GL_POSITION, fb16); gl.getGL2ES1().glLightf(glLightIndex, GLLightingFunc.GL_SPOT_CUTOFF, 180); if (pLight.getRadius() > 0) { // Note: this doesn't follow the same attenuation model // as the one used in the lighting shader. gl.getGL2ES1().glLightf(glLightIndex, GLLightingFunc.GL_CONSTANT_ATTENUATION, 1); gl.getGL2ES1() .glLightf( glLightIndex, GLLightingFunc.GL_LINEAR_ATTENUATION, pLight.getInvRadius() * 2); gl.getGL2ES1() .glLightf( glLightIndex, GLLightingFunc.GL_QUADRATIC_ATTENUATION, pLight.getInvRadius() * pLight.getInvRadius()); } else { gl.getGL2ES1().glLightf(glLightIndex, GLLightingFunc.GL_CONSTANT_ATTENUATION, 1); gl.getGL2ES1().glLightf(glLightIndex, GLLightingFunc.GL_LINEAR_ATTENUATION, 0); gl.getGL2ES1().glLightf(glLightIndex, GLLightingFunc.GL_QUADRATIC_ATTENUATION, 0); } break; case Spot: SpotLight sLight = (SpotLight) light; fb16.clear(); fb16.put(col.r).put(col.g).put(col.b).put(col.a).flip(); gl.getGL2ES1().glLightfv(glLightIndex, GLLightingFunc.GL_DIFFUSE, fb16); gl.getGL2ES1().glLightfv(glLightIndex, GLLightingFunc.GL_SPECULAR, fb16); pos = sLight.getPosition(); fb16.clear(); fb16.put(pos.x).put(pos.y).put(pos.z).put(1.0f).flip(); gl.getGL2().glLightfv(glLightIndex, GLLightingFunc.GL_POSITION, fb16); Vector3f dir = sLight.getDirection(); fb16.clear(); fb16.put(dir.x).put(dir.y).put(dir.z).put(1.0f).flip(); gl.getGL2ES1().glLightfv(glLightIndex, GLLightingFunc.GL_SPOT_DIRECTION, fb16); float outerAngleRad = sLight.getSpotOuterAngle(); float innerAngleRad = sLight.getSpotInnerAngle(); float spotCut = outerAngleRad * FastMath.RAD_TO_DEG; float spotExpo = 0.0f; if (outerAngleRad > 0) { spotExpo = (1.0f - (innerAngleRad / outerAngleRad)) * 128.0f; } gl.getGL2ES1().glLightf(glLightIndex, GLLightingFunc.GL_SPOT_CUTOFF, spotCut); gl.getGL2ES1().glLightf(glLightIndex, GLLightingFunc.GL_SPOT_EXPONENT, spotExpo); if (sLight.getSpotRange() > 0) { gl.getGL2ES1() .glLightf( glLightIndex, GLLightingFunc.GL_LINEAR_ATTENUATION, sLight.getInvSpotRange()); } else { gl.getGL2ES1().glLightf(glLightIndex, GLLightingFunc.GL_LINEAR_ATTENUATION, 0); } break; default: throw new UnsupportedOperationException("Unrecognized light type: " + lightType); } } // Disable lights after the index for (int i = lightList.size(); i < numLightsSetPrev; i++) { gl.glDisable(GLLightingFunc.GL_LIGHT0 + i); } // This will set view matrix as well. setModelView(worldMatrix, viewMatrix); }