diff options
Diffstat (limited to 'src/classes')
31 files changed, 1330 insertions, 242 deletions
diff --git a/src/classes/com/sun/javafx/newt/GLWindow.java b/src/classes/com/sun/javafx/newt/GLWindow.java index c8c707e98..23f959799 100644 --- a/src/classes/com/sun/javafx/newt/GLWindow.java +++ b/src/classes/com/sun/javafx/newt/GLWindow.java @@ -338,22 +338,24 @@ public class GLWindow extends Window implements GLAutoDrawable { return factory; } + public void setContext(GLContext newCtx) { + context = newCtx; + } + public GLContext getContext() { return context; } public GL getGL() { - GLContext ctx = getContext(); - if (ctx == null) { + if (context == null) { return null; } - return ctx.getGL(); + return context.getGL(); } public void setGL(GL gl) { - GLContext ctx = getContext(); - if (ctx != null) { - ctx.setGL(gl); + if (context != null) { + context.setGL(gl); } } diff --git a/src/classes/com/sun/opengl/impl/GLArrayHandler.java b/src/classes/com/sun/opengl/impl/GLArrayHandler.java index bba190835..d34e04b10 100644 --- a/src/classes/com/sun/opengl/impl/GLArrayHandler.java +++ b/src/classes/com/sun/opengl/impl/GLArrayHandler.java @@ -2,6 +2,7 @@ package com.sun.opengl.impl; import javax.media.opengl.*; +import javax.media.opengl.sub.*; public interface GLArrayHandler { diff --git a/src/classes/com/sun/opengl/impl/GLContextImpl.java b/src/classes/com/sun/opengl/impl/GLContextImpl.java index 02cbd6581..d00afde4d 100644 --- a/src/classes/com/sun/opengl/impl/GLContextImpl.java +++ b/src/classes/com/sun/opengl/impl/GLContextImpl.java @@ -48,7 +48,7 @@ import com.sun.gluegen.runtime.opengl.*; public abstract class GLContextImpl extends GLContext { protected GLContextLock lock = new GLContextLock(); - protected static final boolean DEBUG = Debug.debug("GLContextImpl"); + protected static final boolean DEBUG = Debug.debug("GLContext"); protected static final boolean VERBOSE = Debug.verbose(); protected static final boolean NO_FREE = Debug.isPropertyDefined("jogl.GLContext.nofree"); // NOTE: default sense of GLContext optimization disabled in JSR-231 @@ -223,6 +223,12 @@ public abstract class GLContextImpl extends GLContext { } public void setGL(GL gl) { + if(DEBUG) { + String sgl1 = (null!=this.gl)?this.gl.getClass().toString()+", "+this.gl.toString():new String("<null>"); + String sgl2 = (null!=gl)?gl.getClass().toString()+", "+gl.toString():new String("<null>"); + Exception e = new Exception("setGL: "+Thread.currentThread()+", "+sgl1+" -> "+sgl2); + e.printStackTrace(); + } this.gl = gl; } diff --git a/src/classes/com/sun/opengl/impl/GLFixedArrayHandler.java b/src/classes/com/sun/opengl/impl/GLFixedArrayHandler.java index 868385447..b9e2ca613 100644 --- a/src/classes/com/sun/opengl/impl/GLFixedArrayHandler.java +++ b/src/classes/com/sun/opengl/impl/GLFixedArrayHandler.java @@ -2,6 +2,8 @@ package com.sun.opengl.impl; import javax.media.opengl.*; +import javax.media.opengl.sub.*; +import javax.media.opengl.sub.fixed.*; import java.nio.*; public class GLFixedArrayHandler implements GLArrayHandler { @@ -11,18 +13,18 @@ public class GLFixedArrayHandler implements GLArrayHandler { this.ad = ad; } - protected final void passArrayPointer(GL gl) { + protected final void passArrayPointer(GLPointerIf gl) { switch(ad.getIndex()) { - case GL.GL_VERTEX_ARRAY: + case GLPointerIf.GL_VERTEX_ARRAY: gl.glVertexPointer(ad); break; - case GL.GL_NORMAL_ARRAY: + case GLPointerIf.GL_NORMAL_ARRAY: gl.glNormalPointer(ad); break; - case GL.GL_COLOR_ARRAY: + case GLPointerIf.GL_COLOR_ARRAY: gl.glColorPointer(ad); break; - case GL.GL_TEXTURE_COORD_ARRAY: + case GLPointerIf.GL_TEXTURE_COORD_ARRAY: gl.glTexCoordPointer(ad); break; default: @@ -31,8 +33,9 @@ public class GLFixedArrayHandler implements GLArrayHandler { } public void enableBuffer(GL gl, boolean enable) { + GLPointerIf glp = GLFixedFuncUtil.getGLFixedFuncIf(gl); if(enable) { - gl.glEnableClientState(ad.getIndex()); + glp.glEnableClientState(ad.getIndex()); Buffer buffer = ad.getBuffer(); @@ -46,16 +49,16 @@ public class GLFixedArrayHandler implements GLArrayHandler { } ad.setBufferWritten(true); } - passArrayPointer(gl); + passArrayPointer(glp); } else if(null!=buffer) { - passArrayPointer(gl); + passArrayPointer(glp); ad.setBufferWritten(true); } } else { if(ad.isVBO()) { gl.glBindBuffer(GL.GL_ARRAY_BUFFER, 0); } - gl.glDisableClientState(ad.getIndex()); + glp.glDisableClientState(ad.getIndex()); } } } diff --git a/src/classes/com/sun/opengl/impl/GLPbufferImpl.java b/src/classes/com/sun/opengl/impl/GLPbufferImpl.java index 74fc0fe1a..14c218c45 100644 --- a/src/classes/com/sun/opengl/impl/GLPbufferImpl.java +++ b/src/classes/com/sun/opengl/impl/GLPbufferImpl.java @@ -112,6 +112,10 @@ public class GLPbufferImpl implements GLPbuffer { drawableHelper.removeGLEventListener(listener); } + public void setContext(GLContext ctx) { + context=(GLContextImpl)ctx; + } + public GLContext getContext() { return context; } diff --git a/src/classes/com/sun/opengl/impl/GLReflection.java b/src/classes/com/sun/opengl/impl/GLReflection.java index 256a9b9af..8c89c50dd 100644 --- a/src/classes/com/sun/opengl/impl/GLReflection.java +++ b/src/classes/com/sun/opengl/impl/GLReflection.java @@ -45,7 +45,7 @@ public final class GLReflection { try { Class clazz = Class.forName(clazzName); return null!=clazz; - } catch (Exception e) { } + } catch (Throwable e) { } return false; } @@ -64,7 +64,10 @@ public final class GLReflection { throw new GLUnsupportedException("Constructor: '" + clazzName + "("+cstrArgTypes+")' not found"); } return factory; - } catch (Exception e) { + } catch (Throwable e) { + if (Debug.debug("GLReflection")) { + e.printStackTrace(); + } throw new GLUnsupportedException(e); } } diff --git a/src/classes/com/sun/opengl/impl/ProjectFloat.java b/src/classes/com/sun/opengl/impl/ProjectFloat.java index 309a6bdaf..61c1bd8a1 100755 --- a/src/classes/com/sun/opengl/impl/ProjectFloat.java +++ b/src/classes/com/sun/opengl/impl/ProjectFloat.java @@ -118,6 +118,7 @@ import java.nio.*; import javax.media.opengl.*; import javax.media.opengl.util.*; +import javax.media.opengl.sub.fixed.GLMatrixIf; /** * ProjectFloat.java @@ -538,7 +539,7 @@ public class ProjectFloat { * @param bottom * @param top */ - public void gluOrtho2D(GL gl, float left, float right, float bottom, float top) { + public void gluOrtho2D(GLMatrixIf gl, float left, float right, float bottom, float top) { gl.glOrthof(left, right, bottom, top, -1, 1); } @@ -550,7 +551,7 @@ public class ProjectFloat { * @param zNear * @param zFar */ - public void gluPerspective(GL gl, float fovy, float aspect, float zNear, float zFar) { + public void gluPerspective(GLMatrixIf gl, float fovy, float aspect, float zNear, float zFar) { float sine, cotangent, deltaZ; float radians = fovy / 2 * (float) Math.PI / 180; @@ -588,7 +589,7 @@ public class ProjectFloat { * @param upy * @param upz */ - public void gluLookAt(GL gl, + public void gluLookAt(GLMatrixIf gl, float eyex, float eyey, float eyez, @@ -1001,7 +1002,7 @@ public class ProjectFloat { * @param deltaY * @param viewport */ - public void gluPickMatrix(GL gl, + public void gluPickMatrix(GLMatrixIf gl, float x, float y, float deltaX, @@ -1029,7 +1030,7 @@ public class ProjectFloat { * @param viewport * @param viewport_offset */ - public void gluPickMatrix(GL gl, + public void gluPickMatrix(GLMatrixIf gl, float x, float y, float deltaX, diff --git a/src/classes/com/sun/opengl/impl/glsl/GLSLArrayHandler.java b/src/classes/com/sun/opengl/impl/glsl/GLSLArrayHandler.java index d74298a7c..3edfe43d5 100644 --- a/src/classes/com/sun/opengl/impl/glsl/GLSLArrayHandler.java +++ b/src/classes/com/sun/opengl/impl/glsl/GLSLArrayHandler.java @@ -4,6 +4,7 @@ package com.sun.opengl.impl.glsl; import com.sun.opengl.impl.*; import javax.media.opengl.*; +import javax.media.opengl.sub.*; import com.sun.opengl.util.glsl.ShaderState; import java.nio.*; @@ -19,6 +20,9 @@ public class GLSLArrayHandler implements GLArrayHandler { } public void enableBuffer(GL gl, boolean enable) { + if(!gl.isGL2ES2()) { + throw new GLException("GLSLArrayHandler expects a GL2ES2 implementation"); + } GL2ES2 glsl = gl.getGL2ES2(); ShaderState st = ShaderState.getCurrent(); if(null==st) { @@ -33,10 +37,10 @@ public class GLSLArrayHandler implements GLArrayHandler { if(ad.isVBO()) { // always bind and refresh the VBO mgr, // in case more than one gl*Pointer objects are in use - gl.glBindBuffer(GL.GL_ARRAY_BUFFER, ad.getVBOName()); + glsl.glBindBuffer(GL.GL_ARRAY_BUFFER, ad.getVBOName()); if(!ad.isBufferWritten()) { if(null!=buffer) { - gl.glBufferData(GL.GL_ARRAY_BUFFER, buffer.limit() * ad.getComponentSize(), buffer, ad.getBufferUsage()); + glsl.glBufferData(GL.GL_ARRAY_BUFFER, buffer.limit() * ad.getComponentSize(), buffer, ad.getBufferUsage()); } ad.setBufferWritten(true); } @@ -47,7 +51,7 @@ public class GLSLArrayHandler implements GLArrayHandler { } } else { if(ad.isVBO()) { - gl.glBindBuffer(GL.GL_ARRAY_BUFFER, 0); + glsl.glBindBuffer(GL.GL_ARRAY_BUFFER, 0); } st.glDisableVertexAttribArray(glsl, ad.getName()); } diff --git a/src/classes/com/sun/opengl/impl/glsl/fixed/FixedFuncPipeline.java b/src/classes/com/sun/opengl/impl/glsl/fixed/FixedFuncPipeline.java index 7cd3d7bbb..c5b85924d 100644 --- a/src/classes/com/sun/opengl/impl/glsl/fixed/FixedFuncPipeline.java +++ b/src/classes/com/sun/opengl/impl/glsl/fixed/FixedFuncPipeline.java @@ -3,6 +3,7 @@ package com.sun.opengl.impl.glsl.fixed; import javax.media.opengl.*; import javax.media.opengl.util.*; +import javax.media.opengl.sub.fixed.*; import com.sun.opengl.util.glsl.*; import java.nio.*; @@ -11,7 +12,16 @@ public class FixedFuncPipeline { public static final int MAX_LIGHTS = 8; public FixedFuncPipeline(GL2ES2 gl, PMVMatrix pmvMatrix) { - init(gl, pmvMatrix); + init(gl, pmvMatrix, FixedFuncPipeline.class, shaderSrcRootDef, shaderBinRootDef, + vertexColorFileDef, vertexColorLightFileDef, fragmentColorFileDef, fragmentColorTextureFileDef); + } + public FixedFuncPipeline(GL2ES2 gl, PMVMatrix pmvMatrix, Class shaderRootClass, String shaderSrcRoot, String shaderBinRoot, + String vertexColorFile, + String vertexColorLightFile, + String fragmentColorFile, + String fragmentColorTextureFile) { + init(gl, pmvMatrix, shaderRootClass, shaderSrcRoot, shaderBinRoot, + vertexColorFile, vertexColorLightFile, fragmentColorFile, fragmentColorTextureFile); } public boolean verbose() { return verbose; } @@ -33,11 +43,11 @@ public class FixedFuncPipeline { public String getArrayIndexName(int glArrayIndex) { String name = GLContext.getPredefinedArrayIndexName(glArrayIndex); switch(glArrayIndex) { - case GL.GL_VERTEX_ARRAY: - case GL.GL_NORMAL_ARRAY: - case GL.GL_COLOR_ARRAY: + case GLPointerIf.GL_VERTEX_ARRAY: + case GLPointerIf.GL_NORMAL_ARRAY: + case GLPointerIf.GL_COLOR_ARRAY: break; - case GL.GL_TEXTURE_COORD_ARRAY: + case GLPointerIf.GL_TEXTURE_COORD_ARRAY: name = name + activeTextureUnit; } return name; @@ -105,38 +115,38 @@ public class FixedFuncPipeline { public void glLightfv(GL2ES2 gl, int light, int pname, java.nio.FloatBuffer params) { shaderState.glUseProgram(gl, true); - light -=GL.GL_LIGHT0; + light -=GLLightingIf.GL_LIGHT0; if(0 <= light && light < MAX_LIGHTS) { GLUniformData ud = null; switch(pname) { - case GL.GL_AMBIENT: + case GLLightingIf.GL_AMBIENT: ud = shaderState.getUniform(mgl_LightSource+"["+light+"].ambient"); break; - case GL.GL_DIFFUSE: + case GLLightingIf.GL_DIFFUSE: ud = shaderState.getUniform(mgl_LightSource+"["+light+"].diffuse"); break; - case GL.GL_SPECULAR: + case GLLightingIf.GL_SPECULAR: ud = shaderState.getUniform(mgl_LightSource+"["+light+"].specular"); break; - case GL.GL_POSITION: + case GLLightingIf.GL_POSITION: ud = shaderState.getUniform(mgl_LightSource+"["+light+"].position"); break; - case GL.GL_SPOT_DIRECTION: + case GLLightingIf.GL_SPOT_DIRECTION: ud = shaderState.getUniform(mgl_LightSource+"["+light+"].spotDirection"); break; - case GL.GL_SPOT_EXPONENT: + case GLLightingIf.GL_SPOT_EXPONENT: ud = shaderState.getUniform(mgl_LightSource+"["+light+"].spotExponent"); break; - case GL.GL_SPOT_CUTOFF: + case GLLightingIf.GL_SPOT_CUTOFF: ud = shaderState.getUniform(mgl_LightSource+"["+light+"].spotCutoff"); break; - case GL.GL_CONSTANT_ATTENUATION: + case GLLightingIf.GL_CONSTANT_ATTENUATION: ud = shaderState.getUniform(mgl_LightSource+"["+light+"].constantAttenuation"); break; - case GL.GL_LINEAR_ATTENUATION: + case GLLightingIf.GL_LINEAR_ATTENUATION: ud = shaderState.getUniform(mgl_LightSource+"["+light+"].linearAttenuation"); break; - case GL.GL_QUADRATIC_ATTENUATION: + case GLLightingIf.GL_QUADRATIC_ATTENUATION: ud = shaderState.getUniform(mgl_LightSource+"["+light+"].quadraticAttenuation"); break; default: @@ -171,22 +181,22 @@ public class FixedFuncPipeline { GLUniformData ud = null; switch(pname) { - case GL.GL_AMBIENT: + case GLLightingIf.GL_AMBIENT: ud = shaderState.getUniform(mgl_FrontMaterial+".ambient"); break; - case GL.GL_AMBIENT_AND_DIFFUSE: - glMaterialfv(gl, face, GL.GL_AMBIENT, params); + case GLLightingIf.GL_AMBIENT_AND_DIFFUSE: + glMaterialfv(gl, face, GLLightingIf.GL_AMBIENT, params); // fall through intended .. - case GL.GL_DIFFUSE: + case GLLightingIf.GL_DIFFUSE: ud = shaderState.getUniform(mgl_FrontMaterial+".diffuse"); break; - case GL.GL_SPECULAR: + case GLLightingIf.GL_SPECULAR: ud = shaderState.getUniform(mgl_FrontMaterial+".specular"); break; - case GL.GL_EMISSION: + case GLLightingIf.GL_EMISSION: ud = shaderState.getUniform(mgl_FrontMaterial+".emission"); break; - case GL.GL_SHININESS: + case GLLightingIf.GL_SHININESS: ud = shaderState.getUniform(mgl_FrontMaterial+".shininess"); break; default: @@ -231,30 +241,36 @@ public class FixedFuncPipeline { } } - public void glEnable(GL2ES2 gl, int cap, boolean enable) { + /** + * @return false if digested in regard to GL2ES2 spec, + * eg this call must not be passed to an underlying ES2 implementation. + * true if this call shall be passed to an underlying GL2ES2/ES2 implementation as well. + */ + public boolean glEnable(GL2ES2 gl, int cap, boolean enable) { switch(cap) { case GL.GL_TEXTURE_2D: textureEnabled=enable; - return; - case GL.GL_LIGHTING: + return true; + case GLLightingIf.GL_LIGHTING: lightingEnabled=enable; - return; + return false; case GL.GL_CULL_FACE: cullFace=Math.abs(cullFace); if(!enable) { cullFace*=-1; } - return; + return true; } - int light = cap - GL.GL_LIGHT0; + int light = cap - GLLightingIf.GL_LIGHT0; if(0 <= light && light < MAX_LIGHTS) { if ( (lightsEnabled.get(light)==1) != enable ) { lightsEnabled.put(light, enable?1:0); lightsEnabledDirty = true; - return; + return false; } } + return true; // pass it on .. } public void glCullFace(GL2ES2 gl, int faceName) { @@ -355,7 +371,12 @@ public class FixedFuncPipeline { "]"; } - protected void init(GL2ES2 gl, PMVMatrix pmvMatrix) { + protected void init(GL2ES2 gl, PMVMatrix pmvMatrix, Class shaderRootClass, String shaderSrcRoot, String shaderBinRoot, + String vertexColorFile, + String vertexColorLightFile, + String fragmentColorFile, + String fragmentColorTextureFile) + { if(null==pmvMatrix) { throw new GLException("PMVMatrix is null"); } @@ -364,16 +385,16 @@ public class FixedFuncPipeline { this.shaderState.setVerbose(verbose); ShaderCode vertexColor, vertexColorLight, fragmentColor, fragmentColorTexture; - vertexColor = ShaderCode.create( gl, gl.GL_VERTEX_SHADER, 1, FixedFuncPipeline.class, + vertexColor = ShaderCode.create( gl, gl.GL_VERTEX_SHADER, 1, shaderRootClass, shaderSrcRoot, shaderBinRoot, vertexColorFile); - vertexColorLight = ShaderCode.create( gl, gl.GL_VERTEX_SHADER, 1, FixedFuncPipeline.class, + vertexColorLight = ShaderCode.create( gl, gl.GL_VERTEX_SHADER, 1, shaderRootClass, shaderSrcRoot, shaderBinRoot, vertexColorLightFile); - fragmentColor = ShaderCode.create( gl, gl.GL_FRAGMENT_SHADER, 1, FixedFuncPipeline.class, + fragmentColor = ShaderCode.create( gl, gl.GL_FRAGMENT_SHADER, 1, shaderRootClass, shaderSrcRoot, shaderBinRoot, fragmentColorFile); - fragmentColorTexture = ShaderCode.create( gl, gl.GL_FRAGMENT_SHADER, 1, FixedFuncPipeline.class, + fragmentColorTexture = ShaderCode.create( gl, gl.GL_FRAGMENT_SHADER, 1, shaderRootClass, shaderSrcRoot, shaderBinRoot, fragmentColorTextureFile); shaderProgramColor = new ShaderProgram(); @@ -502,11 +523,11 @@ public class FixedFuncPipeline { public static final FloatBuffer defMatEmission= BufferUtil.newFloatBuffer(new float[] { 0f, 0f, 0f, 1f}); public static final float defMatShininess = 0f; - protected static final String vertexColorFile = "FixedFuncColor"; - protected static final String vertexColorLightFile = "FixedFuncColorLight"; - protected static final String fragmentColorFile = "FixedFuncColor"; - protected static final String fragmentColorTextureFile = "FixedFuncColorTexture"; - protected static final String shaderSrcRoot = "shader" ; - protected static final String shaderBinRoot = "shader/bin" ; + protected static final String vertexColorFileDef = "FixedFuncColor"; + protected static final String vertexColorLightFileDef = "FixedFuncColorLight"; + protected static final String fragmentColorFileDef = "FixedFuncColor"; + protected static final String fragmentColorTextureFileDef = "FixedFuncColorTexture"; + protected static final String shaderSrcRootDef = "shader" ; + protected static final String shaderBinRootDef = "shader/bin" ; } diff --git a/src/classes/com/sun/opengl/impl/glu/GLUquadricImpl.java b/src/classes/com/sun/opengl/impl/glu/GLUquadricImpl.java index e8d039d1e..218f904b3 100644 --- a/src/classes/com/sun/opengl/impl/glu/GLUquadricImpl.java +++ b/src/classes/com/sun/opengl/impl/glu/GLUquadricImpl.java @@ -117,6 +117,7 @@ package com.sun.opengl.impl.glu; import javax.media.opengl.util.ImmModeSink; import javax.media.opengl.*; +import javax.media.opengl.sub.*; import javax.media.opengl.glu.*; import java.nio.*; @@ -1110,7 +1111,7 @@ public class GLUquadricImpl implements GLUquadric { if(immModeSinkEnabled) { immModeSink.glBegin(mode); } else { - ((GL2)gl).glBegin(mode); + gl.getGL2().glBegin(mode); } } @@ -1118,7 +1119,7 @@ public class GLUquadricImpl implements GLUquadric { if(immModeSinkEnabled) { immModeSink.glEnd(gl, immModeSinkImmediate); } else { - ((GL2)gl).glEnd(); + gl.getGL2().glEnd(); } } @@ -1126,7 +1127,7 @@ public class GLUquadricImpl implements GLUquadric { if(immModeSinkEnabled) { immModeSink.glVertex2f(x, y); } else { - ((GL2)gl).glVertex2f(x, y); + gl.getGL2().glVertex2f(x, y); } } @@ -1134,7 +1135,7 @@ public class GLUquadricImpl implements GLUquadric { if(immModeSinkEnabled) { immModeSink.glVertex3f(x, y, z); } else { - ((GL2)gl).glVertex3f(x, y, z); + gl.getGL2().glVertex3f(x, y, z); } } @@ -1145,7 +1146,7 @@ public class GLUquadricImpl implements GLUquadric { if(immModeSinkEnabled) { immModeSink.glNormal3s(a, b, c); } else { - ((GL2)gl).glNormal3s(a, b, c); + gl.getGL2().glNormal3s(a, b, c); } } @@ -1156,7 +1157,7 @@ public class GLUquadricImpl implements GLUquadric { if(immModeSinkEnabled) { immModeSink.glNormal3b(a, b, c); } else { - ((GL2)gl).glNormal3b(a, b, c); + gl.getGL2().glNormal3b(a, b, c); } } @@ -1166,7 +1167,7 @@ public class GLUquadricImpl implements GLUquadric { if(immModeSinkEnabled) { immModeSink.glNormal3f(x,y,z); } else { - ((GL2)gl).glNormal3f(x,y,z); + gl.getGL2().glNormal3f(x,y,z); } break; case GL.GL_SHORT: @@ -1182,7 +1183,7 @@ public class GLUquadricImpl implements GLUquadric { if(immModeSinkEnabled) { immModeSink.glTexCoord2f(x, y); } else { - ((GL2)gl).glTexCoord2f(x, y); + gl.getGL2().glTexCoord2f(x, y); } } diff --git a/src/classes/com/sun/opengl/impl/x11/glx/X11GLXDrawableFactory.java b/src/classes/com/sun/opengl/impl/x11/glx/X11GLXDrawableFactory.java index d99b237e5..9ee93793a 100644 --- a/src/classes/com/sun/opengl/impl/x11/glx/X11GLXDrawableFactory.java +++ b/src/classes/com/sun/opengl/impl/x11/glx/X11GLXDrawableFactory.java @@ -278,11 +278,11 @@ public class X11GLXDrawableFactory extends GLDrawableFactoryImpl { int[] res = new int[MAX_ATTRIBS]; int idx = 0; if (pbuffer) { - res[idx++] = GLXExt.GLX_DRAWABLE_TYPE; - res[idx++] = GLXExt.GLX_PBUFFER_BIT; + res[idx++] = GLX.GLX_DRAWABLE_TYPE; + res[idx++] = GLX.GLX_PBUFFER_BIT; - res[idx++] = GLXExt.GLX_RENDER_TYPE; - res[idx++] = GLXExt.GLX_RGBA_BIT; + res[idx++] = GLX.GLX_RENDER_TYPE; + res[idx++] = GLX.GLX_RGBA_BIT; } else { res[idx++] = GLX.GLX_RGBA; } @@ -334,9 +334,9 @@ public class X11GLXDrawableFactory extends GLDrawableFactoryImpl { res[idx++] = caps.getAccumAlphaBits(); } if (isMultisampleAvailable && caps.getSampleBuffers()) { - res[idx++] = GLXExt.GLX_SAMPLE_BUFFERS; + res[idx++] = GLX.GLX_SAMPLE_BUFFERS; res[idx++] = GL.GL_TRUE; - res[idx++] = GLXExt.GLX_SAMPLES; + res[idx++] = GLX.GLX_SAMPLES; res[idx++] = caps.getNumSamples(); } if (pbuffer) { @@ -411,11 +411,11 @@ public class X11GLXDrawableFactory extends GLDrawableFactoryImpl { caps.setAccumAlphaBits(ivalues[i]); break; - case GLXExt.GLX_SAMPLE_BUFFERS: + case GLX.GLX_SAMPLE_BUFFERS: caps.setSampleBuffers(ivalues[i] != GL.GL_FALSE); break; - case GLXExt.GLX_SAMPLES: + case GLX.GLX_SAMPLES: caps.setNumSamples(ivalues[i]); break; diff --git a/src/classes/com/sun/opengl/impl/x11/glx/X11OnscreenGLXDrawable.java b/src/classes/com/sun/opengl/impl/x11/glx/X11OnscreenGLXDrawable.java index 23835f21b..ac228b68a 100644 --- a/src/classes/com/sun/opengl/impl/x11/glx/X11OnscreenGLXDrawable.java +++ b/src/classes/com/sun/opengl/impl/x11/glx/X11OnscreenGLXDrawable.java @@ -81,4 +81,14 @@ public class X11OnscreenGLXDrawable extends X11GLXDrawable { protected void setChosenGLCapabilities(GLCapabilities caps) { super.setChosenGLCapabilities(caps); } + + public void setRealized(boolean realized) { + if (realized) { + X11GLXDrawableFactory factory = (X11GLXDrawableFactory) getFactory(); + NativeWindow window = getNativeWindow(); + setChosenGLCapabilities(factory.lookupCapabilitiesByScreenAndVisualID(window.getScreenIndex(), + window.getVisualID())); + } + super.setRealized(realized); + } } diff --git a/src/classes/com/sun/opengl/impl/x11/glx/X11PbufferGLXContext.java b/src/classes/com/sun/opengl/impl/x11/glx/X11PbufferGLXContext.java index 377d92f98..a32ee99d7 100644 --- a/src/classes/com/sun/opengl/impl/x11/glx/X11PbufferGLXContext.java +++ b/src/classes/com/sun/opengl/impl/x11/glx/X11PbufferGLXContext.java @@ -83,7 +83,7 @@ public class X11PbufferGLXContext extends X11GLXContext { } } context = GLX.glXCreateNewContext(drawable.getNativeWindow().getDisplayHandle(), - drawable.getFBConfig(), GLXExt.GLX_RGBA_TYPE, share, true); + drawable.getFBConfig(), GLX.GLX_RGBA_TYPE, share, true); if (context == 0) { throw new GLException("pbuffer creation error: glXCreateNewContext() failed"); } diff --git a/src/classes/com/sun/opengl/impl/x11/glx/X11PbufferGLXDrawable.java b/src/classes/com/sun/opengl/impl/x11/glx/X11PbufferGLXDrawable.java index 390ca96a4..d720fe7e8 100644 --- a/src/classes/com/sun/opengl/impl/x11/glx/X11PbufferGLXDrawable.java +++ b/src/classes/com/sun/opengl/impl/x11/glx/X11PbufferGLXDrawable.java @@ -149,9 +149,9 @@ public class X11PbufferGLXDrawable extends X11GLXDrawable { // Create the p-buffer. int niattribs = 0; - iattributes[niattribs++] = GLXExt.GLX_PBUFFER_WIDTH; + iattributes[niattribs++] = GLX.GLX_PBUFFER_WIDTH; iattributes[niattribs++] = nw.getWidth(); - iattributes[niattribs++] = GLXExt.GLX_PBUFFER_HEIGHT; + iattributes[niattribs++] = GLX.GLX_PBUFFER_HEIGHT; iattributes[niattribs++] = nw.getHeight(); iattributes[niattribs++] = 0; @@ -167,8 +167,8 @@ public class X11PbufferGLXDrawable extends X11GLXDrawable { this.fbConfig = fbConfig; // Pick innocent query values if multisampling or floating point buffers not available - int sbAttrib = X11Util.isMultisampleAvailable() ? GLXExt.GLX_SAMPLE_BUFFERS: GLX.GLX_RED_SIZE; - int samplesAttrib = X11Util.isMultisampleAvailable() ? GLXExt.GLX_SAMPLES: GLX.GLX_RED_SIZE; + int sbAttrib = X11Util.isMultisampleAvailable() ? GLX.GLX_SAMPLE_BUFFERS: GLX.GLX_RED_SIZE; + int samplesAttrib = X11Util.isMultisampleAvailable() ? GLX.GLX_SAMPLES: GLX.GLX_RED_SIZE; int floatNV = capabilities.getPbufferFloatingPointBuffers() ? GLXExt.GLX_FLOAT_COMPONENTS_NV : GLX.GLX_RED_SIZE; // Query the fbconfig to determine its GLCapabilities @@ -196,9 +196,9 @@ public class X11PbufferGLXDrawable extends X11GLXDrawable { // Determine the actual width and height we were able to create. int[] tmp = new int[1]; - GLX.glXQueryDrawable(display, drawable, GLXExt.GLX_WIDTH, tmp, 0); + GLX.glXQueryDrawable(display, drawable, GLX.GLX_WIDTH, tmp, 0); int width = tmp[0]; - GLX.glXQueryDrawable(display, drawable, GLXExt.GLX_HEIGHT, tmp, 0); + GLX.glXQueryDrawable(display, drawable, GLX.GLX_HEIGHT, tmp, 0); int height = tmp[0]; nw.setSize(width, height); diff --git a/src/classes/com/sun/opengl/util/glsl/ShaderCode.java b/src/classes/com/sun/opengl/util/glsl/ShaderCode.java index 8addf339c..288ef760b 100644 --- a/src/classes/com/sun/opengl/util/glsl/ShaderCode.java +++ b/src/classes/com/sun/opengl/util/glsl/ShaderCode.java @@ -51,7 +51,9 @@ public class ShaderCode { id = getNextID(); } - public static ShaderCode create(int type, int number, Class context, String[] sourceFiles) { + public static ShaderCode create(GL2ES2 gl, int type, int number, Class context, String[] sourceFiles) { + if(!gl.glShaderCompilerAvailable()) return null; + String[][] shaderSources = null; if(null!=sourceFiles) { shaderSources = new String[sourceFiles.length][1]; @@ -112,7 +114,7 @@ public class ShaderCode { String srcPath[] = new String[1]; srcFileName = srcRoot + '/' + basename + "." + getFileSuffix(false, type); srcPath[0] = srcFileName; - res = create(type, number, context, srcPath); + res = create(gl, type, number, context, srcPath); if(null!=res) { return res; } @@ -134,6 +136,61 @@ public class ShaderCode { return res; } + public static boolean createAndLoadShader(GL2ES2 gl, IntBuffer shader, int shaderType, + int binFormat, java.nio.Buffer bin, + PrintStream verboseOut) + { + int err = gl.glGetError(); // flush previous errors .. + if(err!=GL.GL_NO_ERROR && null!=verboseOut) { + verboseOut.println("createAndLoadShader: Pre GL Error: 0x"+Integer.toHexString(err)); + } + + gl.glCreateShader(shaderType, shader); + err = gl.glGetError(); + if(err!=GL.GL_NO_ERROR) { + throw new GLException("createAndLoadShader: CreateShader failed, GL Error: 0x"+Integer.toHexString(err)); + } + + + gl.glShaderBinary(shader, binFormat, bin); + + err = gl.glGetError(); + if(err!=GL.GL_NO_ERROR && null!=verboseOut) { + verboseOut.println("createAndLoadShader: ShaderBinary failed, GL Error: 0x"+Integer.toHexString(err)); + } + return err == GL.GL_NO_ERROR; + } + + public static boolean createAndCompileShader(GL2ES2 gl, IntBuffer shader, int shaderType, + java.lang.String[][] sources, + PrintStream verboseOut) + { + int err = gl.glGetError(); // flush previous errors .. + if(err!=GL.GL_NO_ERROR && null!=verboseOut) { + verboseOut.println("createAndCompileShader: Pre GL Error: 0x"+Integer.toHexString(err)); + } + + gl.glCreateShader(shaderType, shader); + err = gl.glGetError(); + if(err!=GL.GL_NO_ERROR) { + throw new GLException("createAndCompileShader: CreateShader failed, GL Error: 0x"+Integer.toHexString(err)); + } + + gl.glShaderSource(shader, sources); + err = gl.glGetError(); + if(err!=GL.GL_NO_ERROR) { + throw new GLException("createAndCompileShader: ShaderSource failed, GL Error: 0x"+Integer.toHexString(err)); + } + + gl.glCompileShader(shader); + err = gl.glGetError(); + if(err!=GL.GL_NO_ERROR && null!=verboseOut) { + verboseOut.println("createAndCompileShader: CompileShader failed, GL Error: 0x"+Integer.toHexString(err)); + } + + return gl.glIsShaderStatusValid(shader, gl.GL_COMPILE_STATUS, verboseOut) && err == GL.GL_NO_ERROR; + } + /** * returns the uniq shader id as an integer * @see #key() @@ -176,11 +233,11 @@ public class ShaderCode { // Create & Compile the vertex/fragment shader objects if(null!=shaderSource) { - valid=gl.glCreateCompileShader(shader, shaderType, - shaderSource, verboseOut); + valid=createAndCompileShader(gl, shader, shaderType, + shaderSource, verboseOut); } else if(null!=shaderBinary) { - valid=gl.glCreateLoadShader(shader, shaderType, - shaderBinaryFormat, shaderBinary, verboseOut); + valid=createAndLoadShader(gl, shader, shaderType, + shaderBinaryFormat, shaderBinary, verboseOut); } else { throw new GLException("no code (source or binary)"); } diff --git a/src/classes/com/sun/opengl/util/glsl/fixed/FixedFuncHook.java b/src/classes/com/sun/opengl/util/glsl/fixed/FixedFuncHook.java new file mode 100755 index 000000000..d4b3be046 --- /dev/null +++ b/src/classes/com/sun/opengl/util/glsl/fixed/FixedFuncHook.java @@ -0,0 +1,333 @@ +/* + * Copyright 2009 Sun Microsystems, Inc. All Rights Reserved. + */ + +package com.sun.opengl.util.glsl.fixed; + +import javax.media.opengl.*; +import javax.media.opengl.sub.*; +import javax.media.opengl.sub.fixed.*; +import javax.media.opengl.util.*; +import javax.media.opengl.glu.*; +import com.sun.gluegen.runtime.BufferFactory; +import com.sun.opengl.util.glsl.*; +import com.sun.opengl.impl.glsl.fixed.*; +import java.nio.*; + +public class FixedFuncHook implements GLFixedFuncHookIf { + public static final int MAX_TEXTURE_UNITS = 8; + + protected FixedFuncPipeline fixedFunction=null; + protected PMVMatrix pmvMatrix=null; + protected GL2ES2 gl=null; + + public FixedFuncHook (GL2ES2 gl) { + this(gl, null); + } + + public FixedFuncHook (GL2ES2 gl, PMVMatrix matrix) { + this.gl = gl; + pmvMatrix = (null!=matrix)?matrix:new PMVMatrix(); + + fixedFunction = new FixedFuncPipeline(gl, pmvMatrix); + } + + public FixedFuncHook(GL2ES2 gl, PMVMatrix matrix, + Class shaderRootClass, String shaderSrcRoot, String shaderBinRoot, + String vertexColorFile, + String vertexColorLightFile, + String fragmentColorFile, + String fragmentColorTextureFile) { + this.gl = gl; + pmvMatrix = matrix; + + fixedFunction = new FixedFuncPipeline(gl, pmvMatrix, + shaderRootClass, shaderSrcRoot, shaderBinRoot, + vertexColorFile, vertexColorLightFile, fragmentColorFile, fragmentColorTextureFile); + } + + public void dispose() { + fixedFunction.release(gl); + fixedFunction = null; + } + + public PMVMatrix getMatrix() { return pmvMatrix; } + + // + // FixedFuncHookIf - hooks + // + public void glDrawArrays(int mode, int first, int count) { + fixedFunction.validate(gl); + gl.glDrawArrays(mode, first, count); + } + public void glDrawElements(int mode, int count, int type, java.nio.Buffer indices) { + fixedFunction.validate(gl); + gl.glDrawElements(mode, count, type, indices); + } + public void glDrawElements(int mode, int count, int type, long indices_buffer_offset) { + fixedFunction.validate(gl); + gl.glDrawElements(mode, count, type, indices_buffer_offset); + } + + public void glActiveTexture(int texture) { + fixedFunction.glActiveTexture(gl, texture); + gl.glActiveTexture(texture); + } + public void glEnable(int cap) { + if(fixedFunction.glEnable(gl, cap, true)) { + gl.glEnable(cap); + } + } + public void glDisable(int cap) { + if(fixedFunction.glEnable(gl, cap, false)) { + gl.glDisable(cap); + } + } + public void glCullFace(int faceName) { + fixedFunction.glCullFace(gl, faceName); + gl.glCullFace(faceName); + } + + public void glGetFloatv(int pname, java.nio.FloatBuffer params) { + if(pmvMatrix.isMatrixGetName(pname)) { + pmvMatrix.glGetFloatv(pname, params); + return; + } + gl.glGetFloatv(pname, params); + } + public void glGetFloatv(int pname, float[] params, int params_offset) { + if(pmvMatrix.isMatrixGetName(pname)) { + pmvMatrix.glGetFloatv(pname, params, params_offset); + return; + } + gl.glGetFloatv(pname, params, params_offset); + } + public void glGetIntegerv(int pname, IntBuffer params) { + if(pmvMatrix.isMatrixGetName(pname)) { + pmvMatrix.glGetIntegerv(pname, params); + return; + } + gl.glGetIntegerv(pname, params); + } + public void glGetIntegerv(int pname, int[] params, int params_offset) { + if(pmvMatrix.isMatrixGetName(pname)) { + pmvMatrix.glGetIntegerv(pname, params, params_offset); + return; + } + gl.glGetIntegerv(pname, params, params_offset); + } + + // + // MatrixIf + // + public int glGetMatrixMode() { + return pmvMatrix.glGetMatrixMode(); + } + public void glMatrixMode(int mode) { + pmvMatrix.glMatrixMode(mode); + } + public void glLoadMatrixf(java.nio.FloatBuffer m) { + pmvMatrix.glLoadMatrixf(m); + } + public void glLoadMatrixf(float[] m, int m_offset) { + glLoadMatrixf(BufferUtil.newFloatBuffer(m, m_offset)); + } + public void glPopMatrix() { + pmvMatrix.glPopMatrix(); + } + public void glPushMatrix() { + pmvMatrix.glPushMatrix(); + } + public void glLoadIdentity() { + pmvMatrix.glLoadIdentity(); + } + public void glMultMatrixf(java.nio.FloatBuffer m) { + pmvMatrix.glMultMatrixf(m); + } + public void glMultMatrixf(float[] m, int m_offset) { + glMultMatrixf(BufferUtil.newFloatBuffer(m, m_offset)); + } + public void glTranslatef(float x, float y, float z) { + pmvMatrix.glTranslatef(x, y, z); + } + public void glRotatef(float angdeg, float x, float y, float z) { + pmvMatrix.glRotatef(angdeg, x, y, z); + } + public void glScalef(float x, float y, float z) { + pmvMatrix.glScalef(x, y, z); + } + public void glOrthof(float left, float right, float bottom, float top, float zNear, float zFar) { + pmvMatrix.glOrthof(left, right, bottom, top, zNear, zFar); + } + public void glFrustumf(float left, float right, float bottom, float top, float zNear, float zFar) { + pmvMatrix.glFrustumf(left, right, bottom, top, zNear, zFar); + } + + // + // LightingIf + // + public void glColor4f(float red, float green, float blue, float alpha) { + fixedFunction.glColor4fv(gl, BufferUtil.newFloatBuffer(new float[] { red, green, blue, alpha })); + } + + public void glLightfv(int light, int pname, java.nio.FloatBuffer params) { + fixedFunction.glLightfv(gl, light, pname, params); + } + public void glLightfv(int light, int pname, float[] params, int params_offset) { + glLightfv(light, pname, BufferUtil.newFloatBuffer(params, params_offset)); + } + public void glMaterialfv(int face, int pname, java.nio.FloatBuffer params) { + fixedFunction.glMaterialfv(gl, face, pname, params); + } + public void glMaterialfv(int face, int pname, float[] params, int params_offset) { + glMaterialfv(face, pname, BufferUtil.newFloatBuffer(params, params_offset)); + } + public void glMaterialf(int face, int pname, float param) { + glMaterialfv(face, pname, BufferUtil.newFloatBuffer(new float[] { param })); + } + public void glShadeModel(int mode) { + fixedFunction.glShadeModel(gl, mode); + } + + // + // PointerIf + // + public void glEnableClientState(int glArrayIndex) { + fixedFunction.glEnableClientState(gl, glArrayIndex); + } + public void glDisableClientState(int glArrayIndex) { + fixedFunction.glDisableClientState(gl, glArrayIndex); + } + + public void glVertexPointer(GLArrayData array) { + if(array.isVBO()) { + if(!gl.glIsVBOArrayEnabled()) { + throw new GLException("VBO array is not enabled: "+array); + } + } else { + if(gl.glIsVBOArrayEnabled()) { + throw new GLException("VBO array is not disabled: "+array); + } + BufferFactory.rangeCheck(array.getBuffer(), 1); + if (!BufferFactory.isDirect(array.getBuffer())) { + throw new GLException("Argument \"pointer\" was not a direct buffer"); } + } + fixedFunction.glVertexPointer(gl, array); + } + + public void glVertexPointer(int size, int type, int stride, java.nio.Buffer pointer) { + glVertexPointer(GLArrayDataWrapper.createFixed(GL_VERTEX_ARRAY, size, type, false, stride, pointer, 0, 0)); + } + public void glVertexPointer(int size, int type, int stride, long pointer_buffer_offset) { + int vboName = gl.glGetBoundBuffer(GL.GL_ARRAY_BUFFER); + if(vboName==0) { + throw new GLException("no GL_ARRAY_BUFFER VBO bound"); + } + glVertexPointer(GLArrayDataWrapper.createFixed(GL_VERTEX_ARRAY, size, type, false, + stride, null, vboName, pointer_buffer_offset)); + } + + public void glColorPointer(GLArrayData array) { + if(array.isVBO()) { + if(!gl.glIsVBOArrayEnabled()) { + throw new GLException("VBO array is not enabled: "+array); + } + } else { + if(gl.glIsVBOArrayEnabled()) { + throw new GLException("VBO array is not disabled: "+array); + } + BufferFactory.rangeCheck(array.getBuffer(), 1); + if (!BufferFactory.isDirect(array.getBuffer())) { + throw new GLException("Argument \"pointer\" was not a direct buffer"); } + } + fixedFunction.glColorPointer(gl, array); + } + public void glColorPointer(int size, int type, int stride, java.nio.Buffer pointer) { + glColorPointer(GLArrayDataWrapper.createFixed(GL_COLOR_ARRAY, size, type, false, + stride, pointer, 0, 0)); + } + public void glColorPointer(int size, int type, int stride, long pointer_buffer_offset) { + int vboName = gl.glGetBoundBuffer(GL.GL_ARRAY_BUFFER); + if(vboName==0) { + throw new GLException("no GL_ARRAY_BUFFER VBO bound"); + } + glColorPointer(GLArrayDataWrapper.createFixed(GL_COLOR_ARRAY, size, type, false, + stride, null, vboName, pointer_buffer_offset)); + } + + public void glNormalPointer(GLArrayData array) { + if(array.getComponentNumber()!=3) { + throw new GLException("Only 3 components per normal allowed"); + } + if(array.isVBO()) { + if(!gl.glIsVBOArrayEnabled()) { + throw new GLException("VBO array is not enabled: "+array); + } + } else { + if(gl.glIsVBOArrayEnabled()) { + throw new GLException("VBO array is not disabled: "+array); + } + BufferFactory.rangeCheck(array.getBuffer(), 1); + if (!BufferFactory.isDirect(array.getBuffer())) { + throw new GLException("Argument \"pointer\" was not a direct buffer"); } + } + fixedFunction.glNormalPointer(gl, array); + } + public void glNormalPointer(int type, int stride, java.nio.Buffer pointer) { + glNormalPointer(GLArrayDataWrapper.createFixed(GL_NORMAL_ARRAY, 3, type, false, + stride, pointer, 0, 0)); + } + public void glNormalPointer(int type, int stride, long pointer_buffer_offset) { + int vboName = gl.glGetBoundBuffer(GL.GL_ARRAY_BUFFER); + if(vboName==0) { + throw new GLException("no GL_ARRAY_BUFFER VBO bound"); + } + glNormalPointer(GLArrayDataWrapper.createFixed(GL_NORMAL_ARRAY, 3, type, false, + stride, null, vboName, pointer_buffer_offset)); + } + + public void glTexCoordPointer(GLArrayData array) { + if(array.isVBO()) { + if(!gl.glIsVBOArrayEnabled()) { + throw new GLException("VBO array is not enabled: "+array); + } + } else { + if(gl.glIsVBOArrayEnabled()) { + throw new GLException("VBO array is not disabled: "+array); + } + BufferFactory.rangeCheck(array.getBuffer(), 1); + if (!BufferFactory.isDirect(array.getBuffer())) { + throw new GLException("Argument \"pointer\" was not a direct buffer"); } + } + fixedFunction.glTexCoordPointer(gl, array); + } + public void glTexCoordPointer(int size, int type, int stride, java.nio.Buffer pointer) { + glTexCoordPointer( + GLArrayDataWrapper.createFixed(GL_TEXTURE_COORD_ARRAY, size, type, false, stride, pointer, 0,0)); + } + public void glTexCoordPointer(int size, int type, int stride, long pointer_buffer_offset) { + int vboName = gl.glGetBoundBuffer(GL.GL_ARRAY_BUFFER); + if(vboName==0) { + throw new GLException("no GL_ARRAY_BUFFER VBO bound"); + } + glTexCoordPointer( + GLArrayDataWrapper.createFixed(GL_TEXTURE_COORD_ARRAY, size, type, false, + stride, null, vboName, pointer_buffer_offset) ); + } + + public final String toString() { + StringBuffer buf = new StringBuffer(); + buf.append(getClass().getName()+" ("); + if(null!=pmvMatrix) { + buf.append(", matrixDirty: "+pmvMatrix.isDirty()); + } + buf.append("\n\t, FixedFunction: "+fixedFunction); + buf.append(gl); + buf.append(" )"); + + return buf.toString(); + } + +} + + diff --git a/src/classes/javax/media/opengl/GLAutoDrawable.java b/src/classes/javax/media/opengl/GLAutoDrawable.java index d4aff9107..743cbc143 100644 --- a/src/classes/javax/media/opengl/GLAutoDrawable.java +++ b/src/classes/javax/media/opengl/GLAutoDrawable.java @@ -56,9 +56,15 @@ public interface GLAutoDrawable extends GLDrawable { /** * Returns the context associated with this drawable. The returned * context will be synchronized. + * Don't rely on it's identity, the context may change. */ public GLContext getContext(); + /** + * Associate a new context to this drawable. + */ + public void setContext(GLContext context); + /** Adds a {@link GLEventListener} to this drawable. If multiple listeners are added to a given drawable, they are notified of events in an arbitrary order. */ diff --git a/src/classes/javax/media/opengl/GLContext.java b/src/classes/javax/media/opengl/GLContext.java index ae9c11786..57569af2a 100644 --- a/src/classes/javax/media/opengl/GLContext.java +++ b/src/classes/javax/media/opengl/GLContext.java @@ -39,6 +39,10 @@ package javax.media.opengl; +import com.sun.opengl.impl.Debug; +import javax.media.opengl.sub.fixed.*; +import java.util.HashMap; + /** Abstraction for an OpenGL rendering context. In order to perform OpenGL rendering, a context must be "made current" on the current thread. OpenGL rendering semantics specify that only one context @@ -53,6 +57,8 @@ package javax.media.opengl; refer to a given context. */ public abstract class GLContext { + protected static final boolean DEBUG = Debug.debug("GLContext"); + /** Indicates that the context was not made current during the last call to {@link #makeCurrent makeCurrent}. */ public static final int CONTEXT_NOT_CURRENT = 0; /** Indicates that the context was made current during the last call to {@link #makeCurrent makeCurrent}. */ @@ -62,6 +68,8 @@ public abstract class GLContext { private static ThreadLocal currentContext = new ThreadLocal(); + private HashMap/*<int, Object>*/ attachedObjects = new HashMap(); + /** * Returns the GLDrawable to which this context may be used to * draw. @@ -158,6 +166,11 @@ public abstract class GLContext { * new GLContext implementations; not for use by end users. */ protected static void setCurrent(GLContext cur) { + if(DEBUG) { + Exception e = new Exception("setCurrent: "+Thread.currentThread()+", "+currentContext.get()+" -> "+cur); + e.printStackTrace(); + } + currentContext.set(cur); } @@ -188,6 +201,21 @@ public abstract class GLContext { */ public abstract void setGL(GL gl); + /** + * Returns the attached user object for the given name to this GLContext/GL. + */ + public Object getAttachedObject(int name) { + return attachedObjects.get(new Integer(name)); + } + + /** + * Sets the attached user object for the given name to this GLContext/GL. + * Returns the previous set object or null. + */ + public Object putAttachedObject(int name, Object obj) { + return attachedObjects.put(new Integer(name), obj); + } + public final String toString() { return "GLContext: "+getClass().getName()+ "(GL: "+getGL().getClass().getName()+","+ @@ -207,28 +235,28 @@ public abstract class GLContext { * Useful for uniq mapping of canonical array index names as listed. * * @see #mgl_Vertex - * @see javax.media.opengl.GL#GL_VERTEX_ARRAY + * @see javax.media.opengl.sub.fixed.GLPointerIf#GL_VERTEX_ARRAY * @see #mgl_Normal - * @see javax.media.opengl.GL#GL_NORMAL_ARRAY + * @see javax.media.opengl.sub.fixed.GLPointerIf#GL_NORMAL_ARRAY * @see #mgl_Color - * @see javax.media.opengl.GL#GL_COLOR_ARRAY + * @see javax.media.opengl.sub.fixed.GLPointerIf#GL_COLOR_ARRAY * @see #mgl_MultiTexCoord - * @see javax.media.opengl.GL#GL_TEXTURE_COORD_ARRAY - * @see javax.media.opengl.GL#glEnableClientState - * @see javax.media.opengl.GL#glVertexPointer - * @see javax.media.opengl.GL#glColorPointer - * @see javax.media.opengl.GL#glNormalPointer - * @see javax.media.opengl.GL#glTexCoordPointer + * @see javax.media.opengl.sub.fixed.GLPointerIf#GL_TEXTURE_COORD_ARRAY + * @see javax.media.opengl.sub.fixed.GLPointerIf#glEnableClientState + * @see javax.media.opengl.sub.fixed.GLPointerIf#glVertexPointer + * @see javax.media.opengl.sub.fixed.GLPointerIf#glColorPointer + * @see javax.media.opengl.sub.fixed.GLPointerIf#glNormalPointer + * @see javax.media.opengl.sub.fixed.GLPointerIf#glTexCoordPointer */ public static String getPredefinedArrayIndexName(int glArrayIndex) { switch(glArrayIndex) { - case GL.GL_VERTEX_ARRAY: + case GLPointerIf.GL_VERTEX_ARRAY: return mgl_Vertex; - case GL.GL_NORMAL_ARRAY: + case GLPointerIf.GL_NORMAL_ARRAY: return mgl_Normal; - case GL.GL_COLOR_ARRAY: + case GLPointerIf.GL_COLOR_ARRAY: return mgl_Color; - case GL.GL_TEXTURE_COORD_ARRAY: + case GLPointerIf.GL_TEXTURE_COORD_ARRAY: return mgl_MultiTexCoord; } return null; diff --git a/src/classes/javax/media/opengl/GLProfile.java b/src/classes/javax/media/opengl/GLProfile.java index 0d1c73d07..a6a51862a 100644 --- a/src/classes/javax/media/opengl/GLProfile.java +++ b/src/classes/javax/media/opengl/GLProfile.java @@ -36,6 +36,7 @@ package javax.media.opengl; +import javax.media.opengl.sub.fixed.*; import java.lang.reflect.*; import java.security.*; import com.sun.opengl.impl.*; @@ -299,8 +300,8 @@ public class GLProfile { return false; } switch(index) { - case GL.GL_VERTEX_ARRAY: - case GL.GL_TEXTURE_COORD_ARRAY: + case GLPointerIf.GL_VERTEX_ARRAY: + case GLPointerIf.GL_TEXTURE_COORD_ARRAY: switch(type) { case GL.GL_BYTE: case GL.GL_SHORT: @@ -326,7 +327,7 @@ public class GLProfile { return false; } break; - case GL.GL_NORMAL_ARRAY: + case GLPointerIf.GL_NORMAL_ARRAY: switch(type) { case GL.GL_BYTE: case GL.GL_SHORT: @@ -350,7 +351,7 @@ public class GLProfile { return false; } break; - case GL.GL_COLOR_ARRAY: + case GLPointerIf.GL_COLOR_ARRAY: switch(type) { case GL.GL_UNSIGNED_BYTE: case GL.GL_FIXED: @@ -437,7 +438,7 @@ public class GLProfile { } } else { switch(index) { - case GL.GL_VERTEX_ARRAY: + case GLPointerIf.GL_VERTEX_ARRAY: switch(type) { case GL.GL_SHORT: case GL.GL_FLOAT: @@ -463,7 +464,7 @@ public class GLProfile { return false; } break; - case GL.GL_NORMAL_ARRAY: + case GLPointerIf.GL_NORMAL_ARRAY: switch(type) { case GL.GL_BYTE: case GL.GL_SHORT: @@ -488,7 +489,7 @@ public class GLProfile { return false; } break; - case GL.GL_COLOR_ARRAY: + case GLPointerIf.GL_COLOR_ARRAY: switch(type) { case GL.GL_UNSIGNED_BYTE: case GL.GL_BYTE: @@ -517,7 +518,7 @@ public class GLProfile { return false; } break; - case GL.GL_TEXTURE_COORD_ARRAY: + case GLPointerIf.GL_TEXTURE_COORD_ARRAY: switch(type) { case GL.GL_SHORT: case GL.GL_FLOAT: diff --git a/src/classes/javax/media/opengl/NativeWindowFactory.java b/src/classes/javax/media/opengl/NativeWindowFactory.java index 18ce61974..b80e239ea 100644 --- a/src/classes/javax/media/opengl/NativeWindowFactory.java +++ b/src/classes/javax/media/opengl/NativeWindowFactory.java @@ -85,8 +85,7 @@ public abstract class NativeWindowFactory { Constructor factoryConstructor = GLReflection.getConstructor("com.sun.opengl.impl.x11.glx.awt.X11AWTGLXNativeWindowFactory", new Class[] {}); factory = (NativeWindowFactory) factoryConstructor.newInstance(null); - } catch (Exception e) { - } + } catch (Exception e) { } } registerFactory(componentClass, factory); defaultFactory = factory; diff --git a/src/classes/javax/media/opengl/awt/GLCanvas.java b/src/classes/javax/media/opengl/awt/GLCanvas.java index bce58be0f..e0d997dc5 100644 --- a/src/classes/javax/media/opengl/awt/GLCanvas.java +++ b/src/classes/javax/media/opengl/awt/GLCanvas.java @@ -373,6 +373,10 @@ public class GLCanvas extends Canvas implements AWTGLAutoDrawable { drawableHelper.removeGLEventListener(listener); } + public void setContext(GLContext ctx) { + context=(GLContextImpl)ctx; + } + public GLContext getContext() { return context; } diff --git a/src/classes/javax/media/opengl/awt/GLJPanel.java b/src/classes/javax/media/opengl/awt/GLJPanel.java index d5f44ff21..37f1dfa7b 100644 --- a/src/classes/javax/media/opengl/awt/GLJPanel.java +++ b/src/classes/javax/media/opengl/awt/GLJPanel.java @@ -324,6 +324,13 @@ public class GLJPanel extends JPanel implements AWTGLAutoDrawable { public void setRealized(boolean realized) { } + public void setContext(GLContext ctx) { + if (backend == null) { + return; + } + backend.setContext(ctx); + } + public GLContext getContext() { if (backend == null) { return null; @@ -565,6 +572,9 @@ public class GLJPanel extends JPanel implements AWTGLAutoDrawable { // this GLJPanel public GLContext createContext(GLContext shareWith); + // Called to set the current backend's GLContext + public void setContext(GLContext ctx); + // Called to get the current backend's GLContext public GLContext getContext(); @@ -797,6 +807,10 @@ public class GLJPanel extends JPanel implements AWTGLAutoDrawable { return offscreenDrawable.createContext(shareWith); } + public void setContext(GLContext ctx) { + offscreenContext=(GLContextImpl)ctx; + } + public GLContext getContext() { return offscreenContext; } @@ -873,6 +887,13 @@ public class GLJPanel extends JPanel implements AWTGLAutoDrawable { return pbuffer.createContext(shareWith); } + public void setContext(GLContext ctx) { + if (pbuffer == null && Beans.isDesignTime()) { + return; + } + pbuffer.setContext(ctx); + } + public GLContext getContext() { // Workaround for crashes in NetBeans GUI builder if (pbuffer == null && Beans.isDesignTime()) { @@ -1040,6 +1061,10 @@ public class GLJPanel extends JPanel implements AWTGLAutoDrawable { throw new GLException("Not yet implemented"); } + public void setContext(GLContext ctx) { + joglContext=ctx; + } + public GLContext getContext() { return joglContext; } diff --git a/src/classes/javax/media/opengl/sub/GLObject.java b/src/classes/javax/media/opengl/sub/GLObject.java new file mode 100644 index 000000000..1426f75d1 --- /dev/null +++ b/src/classes/javax/media/opengl/sub/GLObject.java @@ -0,0 +1,75 @@ +/* + * Copyright 2009 Sun Microsystems, Inc. All Rights Reserved. + */ + +package javax.media.opengl.sub; + +import java.nio.*; + +import javax.media.opengl.*; + +/** + * GLObject specifies the GL profile related implementations + * and it's composition with GLContext, which is a lifetime one. + */ +public interface GLObject { + + public boolean isGL(); + + public boolean isGL2(); + + public boolean isGLES1(); + + public boolean isGLES2(); + + public boolean isGLES(); + + public boolean isGL2ES1(); + + public boolean isGL2ES2(); + + /** + * @return This object cast to GL + * @throws GLException is this GLObject is not a GL implementation + */ + public GL getGL() throws GLException; + + /** + * @return This object cast to GL2 + * @throws GLException is this GLObject is not a GL2 implementation + */ + public GL2 getGL2() throws GLException; + + /** + * @return This object cast to GLES1 + * @throws GLException is this GLObject is not a GLES1 implementation + */ + public GLES1 getGLES1() throws GLException; + + /** + * @return This object cast to GLES2 + * @throws GLException is this GLObject is not a GLES2 implementation + */ + public GLES2 getGLES2() throws GLException; + + /** + * @return This object cast to GL2ES1 + * @throws GLException is this GLObject is not a GL2ES1 implementation + */ + public GL2ES1 getGL2ES1() throws GLException; + + /** + * @return This object cast to GL2ES2 + * @throws GLException is this GLObject is not a GL2ES2 implementation + */ + public GL2ES2 getGL2ES2() throws GLException; + + public String toString(); + + /** + * @return This GL object's bound GLContext + */ + public GLContext getContext(); + +} + diff --git a/src/classes/javax/media/opengl/sub/fixed/GLFixedFuncHookIf.java b/src/classes/javax/media/opengl/sub/fixed/GLFixedFuncHookIf.java new file mode 100644 index 000000000..05e0f2ca7 --- /dev/null +++ b/src/classes/javax/media/opengl/sub/fixed/GLFixedFuncHookIf.java @@ -0,0 +1,33 @@ +/* + * Copyright 2009 Sun Microsystems, Inc. All Rights Reserved. + */ + +package javax.media.opengl.sub.fixed; + +import java.nio.*; + +import javax.media.opengl.*; +import javax.media.opengl.sub.*; + +/** + * Fixed function implementation hook interface<p> + * + * An implementation shall implement the below interface methods + * and pipeline the call to the underlying GL impl. if necessary. <p> + * + * An implementation must implement all extended interface methods. <p> + */ +public interface GLFixedFuncHookIf extends GLLightingIf, GLMatrixIf, GLPointerIf { + public void glDrawArrays(int mode, int first, int count) ; + public void glDrawElements(int mode, int count, int type, java.nio.Buffer indices) ; + public void glDrawElements(int mode, int count, int type, long indices_buffer_offset) ; + public void glActiveTexture(int texture) ; + public void glEnable(int cap) ; + public void glDisable(int cap) ; + public void glCullFace(int faceName) ; + public void glGetFloatv(int pname, java.nio.FloatBuffer params) ; + public void glGetFloatv(int pname, float[] params, int params_offset) ; + public void glGetIntegerv(int pname, IntBuffer params) ; + public void glGetIntegerv(int pname, int[] params, int params_offset) ; +} + diff --git a/src/classes/javax/media/opengl/sub/fixed/GLFixedFuncIf.java b/src/classes/javax/media/opengl/sub/fixed/GLFixedFuncIf.java new file mode 100644 index 000000000..cc3e299e8 --- /dev/null +++ b/src/classes/javax/media/opengl/sub/fixed/GLFixedFuncIf.java @@ -0,0 +1,18 @@ +/* + * Copyright 2009 Sun Microsystems, Inc. All Rights Reserved. + */ + +package javax.media.opengl.sub.fixed; + +import java.nio.*; + +import javax.media.opengl.*; +import javax.media.opengl.sub.*; + +/** + * GL Fixed function module interface + * + */ +public interface GLFixedFuncIf extends GL, GLFixedFuncHookIf, GLLightingIf, GLMatrixIf, GLPointerIf { +} + diff --git a/src/classes/javax/media/opengl/sub/fixed/GLFixedFuncUtil.java b/src/classes/javax/media/opengl/sub/fixed/GLFixedFuncUtil.java new file mode 100644 index 000000000..4c0d1b87f --- /dev/null +++ b/src/classes/javax/media/opengl/sub/fixed/GLFixedFuncUtil.java @@ -0,0 +1,50 @@ +/* + * Copyright 2009 Sun Microsystems, Inc. All Rights Reserved. + */ + +package javax.media.opengl.sub.fixed; + +import javax.media.opengl.*; +import javax.media.opengl.sub.*; + +/** + * Contains values to handle the fixed implementation. + */ +public class GLFixedFuncUtil { + + /** + * @return The current GLContext's GL object cast as GLFixedFuncIf + * @throws GLException is this GL Object is not a GLFixedFuncIf implementation, + * or no GLContext is current + */ + public static final GLFixedFuncIf getCurrentGLFixedFuncIf() throws GLException { + GLContext curContext = GLContext.getCurrent(); + if (curContext == null) { + throw new GLException("No OpenGL context current on this thread"); + } + GL gl = curContext.getGL(); + if(gl instanceof GLFixedFuncIf) { + return (GLFixedFuncIf) gl; + } + throw new GLException("Not a GLFixedFuncIf implementation"); + } + + /** + * @return true if GL object is a GLFixedFuncIf + */ + public static final boolean isGLFixedFuncIf(GL gl) { + return (gl instanceof GLFixedFuncIf) ; + } + + /** + * @return The object cast as GLFixedFuncIf + * @throws GLException is this GL Object is not a GLFixedFuncIf implementation + */ + public static final GLFixedFuncIf getGLFixedFuncIf(GL gl) { + if(gl instanceof GLFixedFuncIf) { + return (GLFixedFuncIf) gl; + } + throw new GLException("Not a GLFixedFuncIf implementation"); + } +} + diff --git a/src/classes/javax/media/opengl/sub/fixed/GLLightingIf.java b/src/classes/javax/media/opengl/sub/fixed/GLLightingIf.java new file mode 100644 index 000000000..1f3aa9ab7 --- /dev/null +++ b/src/classes/javax/media/opengl/sub/fixed/GLLightingIf.java @@ -0,0 +1,50 @@ +/* + * Copyright 2009 Sun Microsystems, Inc. All Rights Reserved. + */ + +package javax.media.opengl.sub.fixed; + +import java.nio.*; + +import javax.media.opengl.*; +import javax.media.opengl.sub.*; + +public interface GLLightingIf { + public static final int GL_LIGHT0 = 0x4000; + public static final int GL_LIGHT1 = 0x4001; + public static final int GL_LIGHT2 = 0x4002; + public static final int GL_LIGHT3 = 0x4003; + public static final int GL_LIGHT4 = 0x4004; + public static final int GL_LIGHT5 = 0x4005; + public static final int GL_LIGHT6 = 0x4006; + public static final int GL_LIGHT7 = 0x4007; + public static final int GL_LIGHTING = 0xB50; + public static final int GL_AMBIENT = 0x1200; + public static final int GL_DIFFUSE = 0x1201; + public static final int GL_SPECULAR = 0x1202; + public static final int GL_POSITION = 0x1203; + public static final int GL_SPOT_DIRECTION = 0x1204; + public static final int GL_SPOT_EXPONENT = 0x1205; + public static final int GL_SPOT_CUTOFF = 0x1206; + public static final int GL_CONSTANT_ATTENUATION = 0x1207; + public static final int GL_LINEAR_ATTENUATION = 0x1208; + public static final int GL_QUADRATIC_ATTENUATION = 0x1209; + public static final int GL_EMISSION = 0x1600; + public static final int GL_SHININESS = 0x1601; + public static final int GL_AMBIENT_AND_DIFFUSE = 0x1602; + public static final int GL_COLOR_MATERIAL = 0xB57; + public static final int GL_NORMALIZE = 0xBA1; + + public static final int GL_FLAT = 0x1D00; + public static final int GL_SMOOTH = 0x1D01; + + public void glLightfv(int light, int pname, java.nio.FloatBuffer params); + public void glLightfv(int light, int pname, float[] params, int params_offset); + public void glMaterialf(int face, int pname, float param); + public void glMaterialfv(int face, int pname, java.nio.FloatBuffer params); + public void glMaterialfv(int face, int pname, float[] params, int params_offset); + public void glColor4f(float red, float green, float blue, float alpha); + public void glShadeModel(int mode); + +} + diff --git a/src/classes/javax/media/opengl/sub/fixed/GLMatrixIf.java b/src/classes/javax/media/opengl/sub/fixed/GLMatrixIf.java new file mode 100644 index 000000000..834731b98 --- /dev/null +++ b/src/classes/javax/media/opengl/sub/fixed/GLMatrixIf.java @@ -0,0 +1,77 @@ +/* + * Copyright 2009 Sun Microsystems, Inc. All Rights Reserved. + */ + +package javax.media.opengl.sub.fixed; + +import java.nio.*; + +import javax.media.opengl.*; +import javax.media.opengl.sub.*; + +public interface GLMatrixIf { + + public static final int GL_MATRIX_MODE = 0x0BA0; + public static final int GL_MODELVIEW = 0x1700; + public static final int GL_PROJECTION = 0x1701; + // public static final int GL_TEXTURE = 0x1702; // Use GL.GL_TEXTURE due to ambiguous GL usage + public static final int GL_MODELVIEW_MATRIX = 0x0BA6; + public static final int GL_PROJECTION_MATRIX = 0x0BA7; + public static final int GL_TEXTURE_MATRIX = 0x0BA8; + + /** + * glGetFloatv + * @param pname GL_MODELVIEW_MATRIX, GL_PROJECTION_MATRIX or GL_TEXTURE_MATRIX + * @param params the FloatBuffer's position remains unchanged, + * which is the same behavior than the native JOGL GL impl + */ + public void glGetFloatv(int pname, java.nio.FloatBuffer params); + public void glGetFloatv(int pname, float[] params, int params_offset); + /** + * glGetIntegerv + * @param pname GL_MATRIX_MODE + * @param params the FloatBuffer's position remains unchanged + * which is the same behavior than the native JOGL GL impl + */ + public void glGetIntegerv(int pname, IntBuffer params); + public void glGetIntegerv(int pname, int[] params, int params_offset); + + /** + * sets the current matrix + * @param pname GL_MODELVIEW, GL_PROJECTION or GL.GL_TEXTURE + */ + public void glMatrixMode(int mode) ; + + public void glPushMatrix(); + public void glPopMatrix(); + + public void glLoadIdentity() ; + + /** + * glLoadMatrixf + * @param params the FloatBuffer's position remains unchanged, + * which is the same behavior than the native JOGL GL impl + */ + public void glLoadMatrixf(java.nio.FloatBuffer m) ; + public void glLoadMatrixf(float[] m, int m_offset); + + /** + * glMultMatrixf + * @param params the FloatBuffer's position remains unchanged, + * which is the same behavior than the native JOGL GL impl + */ + public void glMultMatrixf(java.nio.FloatBuffer m) ; + public void glMultMatrixf(float[] m, int m_offset); + + public void glTranslatef(float x, float y, float z) ; + + public void glRotatef(float angle, float x, float y, float z); + + public void glScalef(float x, float y, float z) ; + + public void glOrthof(float left, float right, float bottom, float top, float zNear, float zFar) ; + + public void glFrustumf(float left, float right, float bottom, float top, float zNear, float zFar); + +} + diff --git a/src/classes/javax/media/opengl/sub/fixed/GLPointerIf.java b/src/classes/javax/media/opengl/sub/fixed/GLPointerIf.java new file mode 100644 index 000000000..2f4cda1aa --- /dev/null +++ b/src/classes/javax/media/opengl/sub/fixed/GLPointerIf.java @@ -0,0 +1,39 @@ +/* + * Copyright 2009 Sun Microsystems, Inc. All Rights Reserved. + */ + +package javax.media.opengl.sub.fixed; + +import java.nio.*; + +import javax.media.opengl.*; +import javax.media.opengl.sub.*; + +public interface GLPointerIf { + public static final int GL_VERTEX_ARRAY = 0x8074; + public static final int GL_NORMAL_ARRAY = 0x8075; + public static final int GL_COLOR_ARRAY = 0x8076; + public static final int GL_TEXTURE_COORD_ARRAY = 0x8078; + + public void glEnableClientState(int arrayName); + public void glDisableClientState(int arrayName); + + public void glVertexPointer(GLArrayData array); + public void glVertexPointer(int size, int type, int stride, java.nio.Buffer pointer); + public void glVertexPointer(int size, int type, int stride, long pointer_buffer_offset); + + public void glColorPointer(GLArrayData array); + public void glColorPointer(int size, int type, int stride, java.nio.Buffer pointer); + public void glColorPointer(int size, int type, int stride, long pointer_buffer_offset); + public void glColor4f(float red, float green, float blue, float alpha); + + public void glNormalPointer(GLArrayData array); + public void glNormalPointer(int type, int stride, java.nio.Buffer pointer); + public void glNormalPointer(int type, int stride, long pointer_buffer_offset); + + public void glTexCoordPointer(GLArrayData array); + public void glTexCoordPointer(int size, int type, int stride, java.nio.Buffer pointer); + public void glTexCoordPointer(int size, int type, int stride, long pointer_buffer_offset); + +} + diff --git a/src/classes/javax/media/opengl/util/ImmModeSink.java b/src/classes/javax/media/opengl/util/ImmModeSink.java index 526f38dab..9ab899d69 100644 --- a/src/classes/javax/media/opengl/util/ImmModeSink.java +++ b/src/classes/javax/media/opengl/util/ImmModeSink.java @@ -2,6 +2,8 @@ package javax.media.opengl.util; import javax.media.opengl.*; +import javax.media.opengl.sub.*; +import javax.media.opengl.sub.fixed.*; import com.sun.opengl.impl.GLReflection; import java.nio.*; import java.util.Iterator; @@ -332,8 +334,13 @@ public class ImmModeSink { enableBuffer(gl, true); if (buffer!=null) { + GLFixedFuncIf glf = GLFixedFuncUtil.getGLFixedFuncIf(gl); + if(null==glf) { + throw new GLException("ImmModeSink.draw: No GLFixedFuncIf available"); + } + if(null==indices) { - gl.glDrawArrays(mode, 0, count); + glf.glDrawArrays(mode, 0, count); } else { Class clazz = indices.getClass(); int type=-1; @@ -345,7 +352,7 @@ public class ImmModeSink { if(0>type) { throw new GLException("Given Buffer Class not supported: "+clazz+", should be ubyte or ushort:\n\t"+this); } - gl.glDrawElements(mode, indices.remaining(), type, indices); + glf.glDrawElements(mode, indices.remaining(), type, indices); // GL2: gl.glDrawRangeElements(mode, 0, indices.remaining()-1, indices.remaining(), type, indices); } } @@ -643,11 +650,12 @@ public class ImmModeSink { this.bufferWritten=false; } - public void seal(GL gl, boolean seal) + public void seal(GL glObj, boolean seal) { seal(seal); if(sealedGL==seal) return; sealedGL = seal; + GL gl = glObj.getGL(); if(seal) { if(vboUsage && vboName==0) { int[] tmp = new int[1]; @@ -695,6 +703,11 @@ public class ImmModeSink { } public void enableBufferFixed(GL gl, boolean enable) { + GLFixedFuncIf glf = GLFixedFuncUtil.getGLFixedFuncIf(gl); + if(null==glf) { + throw new GLException("ImmModeSink.enableBufferFixed: No GLFixedFuncIf available"); + } + if(enable) { gl.glBindBuffer(GL.GL_ARRAY_BUFFER, vboName); @@ -704,35 +717,35 @@ public class ImmModeSink { } if(vComps>0) { - gl.glEnableClientState(gl.GL_VERTEX_ARRAY); - gl.glVertexPointer(vArrayData); + glf.glEnableClientState(glf.GL_VERTEX_ARRAY); + glf.glVertexPointer(vArrayData); } if(cComps>0) { - gl.glEnableClientState(gl.GL_COLOR_ARRAY); - gl.glColorPointer(cArrayData); + glf.glEnableClientState(glf.GL_COLOR_ARRAY); + glf.glColorPointer(cArrayData); } if(nComps>0) { - gl.glEnableClientState(gl.GL_NORMAL_ARRAY); - gl.glNormalPointer(nArrayData); + glf.glEnableClientState(glf.GL_NORMAL_ARRAY); + glf.glNormalPointer(nArrayData); } if(tComps>0) { - gl.glEnableClientState(gl.GL_TEXTURE_COORD_ARRAY); - gl.glTexCoordPointer(tArrayData); + glf.glEnableClientState(glf.GL_TEXTURE_COORD_ARRAY); + glf.glTexCoordPointer(tArrayData); } gl.glBindBuffer(GL.GL_ARRAY_BUFFER, 0); } else { if(vComps>0) { - gl.glDisableClientState(gl.GL_VERTEX_ARRAY); + glf.glDisableClientState(glf.GL_VERTEX_ARRAY); } if(cComps>0) { - gl.glDisableClientState(gl.GL_COLOR_ARRAY); + glf.glDisableClientState(glf.GL_COLOR_ARRAY); } if(nComps>0) { - gl.glDisableClientState(gl.GL_NORMAL_ARRAY); + glf.glDisableClientState(glf.GL_NORMAL_ARRAY); } if(tComps>0) { - gl.glDisableClientState(gl.GL_TEXTURE_COORD_ARRAY); + glf.glDisableClientState(glf.GL_TEXTURE_COORD_ARRAY); } } } @@ -745,10 +758,10 @@ public class ImmModeSink { } if(enable) { - gl.glBindBuffer(GL.GL_ARRAY_BUFFER, vboName); + glsl.glBindBuffer(GL.GL_ARRAY_BUFFER, vboName); if(!bufferWritten) { - gl.glBufferData(GL.GL_ARRAY_BUFFER, buffer.limit(), buffer, GL.GL_STATIC_DRAW); + glsl.glBufferData(GL.GL_ARRAY_BUFFER, buffer.limit(), buffer, GL.GL_STATIC_DRAW); bufferWritten=true; } @@ -769,7 +782,7 @@ public class ImmModeSink { st.glVertexAttribPointer(glsl, tArrayData); } - gl.glBindBuffer(GL.GL_ARRAY_BUFFER, 0); + glsl.glBindBuffer(GL.GL_ARRAY_BUFFER, 0); } else { if(vComps>0) { st.glDisableVertexAttribArray(glsl, vArrayData.getName()); @@ -853,25 +866,25 @@ public class ImmModeSink { buffer.flip(); if(vComps>0) { - vArrayData = GLArrayDataWrapper.createFixed(GL.GL_VERTEX_ARRAY, vComps, vDataType, false, + vArrayData = GLArrayDataWrapper.createFixed(GLPointerIf.GL_VERTEX_ARRAY, vComps, vDataType, false, 0, vertexArray, 0, vOffset); } else { vArrayData = null; } if(cComps>0) { - cArrayData = GLArrayDataWrapper.createFixed(GL.GL_COLOR_ARRAY, cComps, cDataType, false, + cArrayData = GLArrayDataWrapper.createFixed(GLPointerIf.GL_COLOR_ARRAY, cComps, cDataType, false, 0, colorArray, 0, cOffset); } else { cArrayData = null; } if(nComps>0) { - nArrayData = GLArrayDataWrapper.createFixed(GL.GL_NORMAL_ARRAY, nComps, nDataType, false, + nArrayData = GLArrayDataWrapper.createFixed(GLPointerIf.GL_NORMAL_ARRAY, nComps, nDataType, false, 0, normalArray, 0, nOffset); } else { nArrayData = null; } if(tComps>0) { - tArrayData = GLArrayDataWrapper.createFixed(GL.GL_TEXTURE_COORD_ARRAY, tComps, tDataType, false, + tArrayData = GLArrayDataWrapper.createFixed(GLPointerIf.GL_TEXTURE_COORD_ARRAY, tComps, tDataType, false, 0, textCoordArray, 0, tOffset); } else { tArrayData = null; diff --git a/src/classes/javax/media/opengl/util/PMVMatrix.java b/src/classes/javax/media/opengl/util/PMVMatrix.java index 37472dfe6..5a69b920c 100755 --- a/src/classes/javax/media/opengl/util/PMVMatrix.java +++ b/src/classes/javax/media/opengl/util/PMVMatrix.java @@ -1,13 +1,19 @@ +/* + * Copyright 2009 Sun Microsystems, Inc. All Rights Reserved. + */ -package javax.media.opengl.util; +package javax.media.opengl.util; + +import com.sun.opengl.impl.ProjectFloat; -import javax.media.opengl.*; -import com.sun.opengl.impl.ProjectFloat; import java.nio.*; import java.util.ArrayList; import java.util.List; -public class PMVMatrix { +import javax.media.opengl.*; +import javax.media.opengl.sub.fixed.GLMatrixIf; + +public class PMVMatrix implements GLMatrixIf { public PMVMatrix() { projectFloat = new ProjectFloat(); @@ -16,14 +22,24 @@ public class PMVMatrix { projectFloat.gluMakeIdentityf(matrixIdent); matrixIdent.rewind(); - matrixPMvMviT = BufferUtil.newFloatBuffer(4*16); // grouping P + Mv + Mvi + MviT - matrixPMvMvi = slice(matrixPMvMviT, 0*16, 3*16); // grouping P + Mv + Mvi - matrixPMv = slice(matrixPMvMviT, 0*16, 2*16); // grouping P + Mv - matrixP = slice(matrixPMvMviT, 0*16, 1*16); - matrixMv = slice(matrixPMvMviT, 1*16, 1*16); - matrixMvi = slice(matrixPMvMviT, 2*16, 1*16); - matrixMvit = slice(matrixPMvMviT, 3*16, 1*16); - matrixPMvMviT.rewind(); + // T Texture + // P Projection + // Mv ModelView + // Mvi Modelview-Inverse + // Mvit Modelview-Inverse-Transpose + // Pmv P * Mv + matrixTPMvMvitPmv = BufferUtil.newFloatBuffer(6*16); // grouping T + P + Mv + Mvi + Mvit + Pmv + matrixPMvMvitPmv = slice(matrixTPMvMvitPmv, 1*16, 5*16); // grouping P + Mv + Mvi + Mvit + Pmv + matrixT = slice(matrixTPMvMvitPmv, 0*16, 1*16); // T + matrixPMvMvit = slice(matrixTPMvMvitPmv, 1*16, 4*16); // grouping P + Mv + Mvi + Mvit + matrixPMvMvi = slice(matrixTPMvMvitPmv, 1*16, 3*16); // grouping P + Mv + Mvi + matrixPMv = slice(matrixTPMvMvitPmv, 1*16, 2*16); // grouping P + Mv + matrixP = slice(matrixTPMvMvitPmv, 1*16, 1*16); // P + matrixMv = slice(matrixTPMvMvitPmv, 2*16, 1*16); // Mv + matrixMvi = slice(matrixTPMvMvitPmv, 3*16, 1*16); // Mvi + matrixMvit = slice(matrixTPMvMvitPmv, 4*16, 1*16); // Mvit + matrixPmv = slice(matrixTPMvMvitPmv, 5*16, 1*16); // Pmv + matrixTPMvMvitPmv.rewind(); matrixMvit3 = BufferUtil.newFloatBuffer(3*3); @@ -52,11 +68,13 @@ public class PMVMatrix { matrixMvStack= new ArrayList(); // default values and mode - glMatrixMode(GL.GL_PROJECTION); + glMatrixMode(GL_PROJECTION); glLoadIdentity(); - glMatrixMode(GL.GL_MODELVIEW); + glMatrixMode(GL_MODELVIEW); glLoadIdentity(); - modified = true; + glMatrixMode(GL.GL_TEXTURE); + glLoadIdentity(); + setDirty(); } private static FloatBuffer slice(FloatBuffer buf, int pos, int len) { @@ -65,36 +83,121 @@ public class PMVMatrix { return buf.slice(); } - public boolean isDirty() { - return modified; + public static final boolean isMatrixModeName(final int matrixModeName) { + switch(matrixModeName) { + case GL_MODELVIEW_MATRIX: + case GL_PROJECTION_MATRIX: + case GL_TEXTURE_MATRIX: + return true; + } + return false; } - public boolean update() { - boolean res = modified; - if(res) { - setMviMvit(); - modified=false; + public static final int matrixModeName2MatrixGetName(final int matrixModeName) { + switch(matrixModeName) { + case GL_MODELVIEW: + return GL_MODELVIEW_MATRIX; + case GL_PROJECTION: + return GL_PROJECTION_MATRIX; + case GL.GL_TEXTURE: + return GL_TEXTURE_MATRIX; + default: + throw new GLUnsupportedException("unsupported matrixName: "+matrixModeName); } - return res; } - public final int glGetMatrixMode() { - return matrixMode; + public static final boolean isMatrixGetName(final int matrixGetName) { + switch(matrixGetName) { + case GL_MATRIX_MODE: + case GL_MODELVIEW_MATRIX: + case GL_PROJECTION_MATRIX: + case GL_TEXTURE_MATRIX: + return true; + } + return false; + } + + public static final int matrixGetName2MatrixModeName(final int matrixGetName) { + switch(matrixGetName) { + case GL_MODELVIEW_MATRIX: + return GL_MODELVIEW; + case GL_PROJECTION_MATRIX: + return GL_PROJECTION; + case GL_TEXTURE_MATRIX: + return GL.GL_TEXTURE; + default: + throw new GLUnsupportedException("unsupported matrixGetName: "+matrixGetName); + } + } + + public void setDirty() { + modified = DIRTY_MODELVIEW | DIRTY_PROJECTION | DIRTY_TEXTURE ; + matrixMode = GL_MODELVIEW; + } + + public int getDirtyBits() { + return modified; } - public void glMatrixMode(int matrixName) { + public boolean isDirty(final int matrixName) { + boolean res; switch(matrixName) { - case GL.GL_MODELVIEW: - case GL.GL_PROJECTION: + case GL_MODELVIEW: + res = (modified&DIRTY_MODELVIEW)!=0 ; + break; + case GL_PROJECTION: + res = (modified&DIRTY_PROJECTION)!=0 ; + break; + case GL.GL_TEXTURE: + res = (modified&DIRTY_TEXTURE)!=0 ; break; default: throw new GLUnsupportedException("unsupported matrixName: "+matrixName); } - matrixMode = matrixName; + return res; } - public final FloatBuffer glGetPMvMviTMatrixf() { - return matrixPMvMviT; + public boolean isDirty() { + return modified!=0; + } + + public boolean update() { + // if(0==modified) return false; + + // int res = modified; + int res = DIRTY_MODELVIEW | DIRTY_PROJECTION ; + if( (res&DIRTY_MODELVIEW)!=0 ) { + setMviMvit(); + } + if( (res&DIRTY_MODELVIEW)!=0 || (res&DIRTY_PROJECTION)!=0 ) { + glMultMatrixf(matrixP, matrixMv, matrixPmv); + } + modified=0; + return res!=0; + } + + public final int glGetMatrixMode() { + return matrixMode; + } + + public final FloatBuffer glGetTMatrixf() { + return matrixT; + } + + public final FloatBuffer glGetPMatrixf() { + return matrixP; + } + + public final FloatBuffer glGetMvMatrixf() { + return matrixMv; + } + + public final FloatBuffer glGetPMvMvitPmvMatrixf() { + return matrixPMvMvitPmv; + } + + public final FloatBuffer glGetPMvMvitMatrixf() { + return matrixPMvMvit; } public final FloatBuffer glGetPMvMviMatrixf() { @@ -109,118 +212,256 @@ public class PMVMatrix { return matrixMvi; } + public final FloatBuffer glGetPmvMatrixf() { + return matrixPmv; + } + public final FloatBuffer glGetNormalMatrixf() { return matrixMvit3; } + /* + * @return the current matrix + */ public final FloatBuffer glGetMatrixf() { return glGetMatrixf(matrixMode); } - public final FloatBuffer glGetMatrixf(int matrixName) { - if(matrixName==GL.GL_MODELVIEW) { + /** + * @param pname GL_MODELVIEW, GL_PROJECTION or GL.GL_TEXTURE + * @return the given matrix + */ + public final FloatBuffer glGetMatrixf(final int matrixName) { + if(matrixName==GL_MODELVIEW) { return matrixMv; - } else if(matrixName==GL.GL_PROJECTION) { + } else if(matrixName==GL_PROJECTION) { return matrixP; + } else if(matrixName==GL.GL_TEXTURE) { + return matrixT; + } else { + throw new GLUnsupportedException("unsupported matrixName: "+matrixName); } - return null; } - public void glLoadMatrixf(float[] values, int offset) { + public final void gluPerspective(final float fovy, final float aspect, final float zNear, final float zFar) { + float top=(float)Math.tan(fovy*((float)Math.PI)/360.0f)*zNear; + float bottom=-1.0f*top; + float left=aspect*bottom; + float right=aspect*top; + glFrustumf(left, right, bottom, top, zNear, zFar); + } + + public static final void glMultMatrixf(final FloatBuffer a, final FloatBuffer b, FloatBuffer p) { + for (int i = 0; i < 4; i++) { + final float ai0=a.get(i+0*4), ai1=a.get(i+1*4), ai2=a.get(i+2*4), ai3=a.get(i+3*4); + p.put(i+0*4 , ai0 * b.get(0+0*4) + ai1 * b.get(1+0*4) + ai2 * b.get(2+0*4) + ai3 * b.get(3+0*4) ); + p.put(i+1*4 , ai0 * b.get(0+1*4) + ai1 * b.get(1+1*4) + ai2 * b.get(2+1*4) + ai3 * b.get(3+1*4) ); + p.put(i+2*4 , ai0 * b.get(0+2*4) + ai1 * b.get(1+2*4) + ai2 * b.get(2+2*4) + ai3 * b.get(3+2*4) ); + p.put(i+3*4 , ai0 * b.get(0+3*4) + ai1 * b.get(1+3*4) + ai2 * b.get(2+3*4) + ai3 * b.get(3+3*4) ); + } + } + public static final void glMultMatrixf(final FloatBuffer a, final float[] b, int b_off, FloatBuffer p) { + for (int i = 0; i < 4; i++) { + final float ai0=a.get(i+0*4), ai1=a.get(i+1*4), ai2=a.get(i+2*4), ai3=a.get(i+3*4); + p.put(i+0*4 , ai0 * b[b_off+0+0*4] + ai1 * b[b_off+1+0*4] + ai2 * b[b_off+2+0*4] + ai3 * b[b_off+3+0*4] ); + p.put(i+1*4 , ai0 * b[b_off+0+1*4] + ai1 * b[b_off+1+1*4] + ai2 * b[b_off+2+1*4] + ai3 * b[b_off+3+1*4] ); + p.put(i+2*4 , ai0 * b[b_off+0+2*4] + ai1 * b[b_off+1+2*4] + ai2 * b[b_off+2+2*4] + ai3 * b[b_off+3+2*4] ); + p.put(i+3*4 , ai0 * b[b_off+0+3*4] + ai1 * b[b_off+1+3*4] + ai2 * b[b_off+2+3*4] + ai3 * b[b_off+3+3*4] ); + } + } + + // + // MatrixIf + // + + public void glMatrixMode(final int matrixName) { + switch(matrixName) { + case GL_MODELVIEW: + case GL_PROJECTION: + case GL.GL_TEXTURE: + break; + default: + throw new GLUnsupportedException("unsupported matrixName: "+matrixName); + } + matrixMode = matrixName; + } + + public void glGetFloatv(int matrixGetName, FloatBuffer params) { + int pos = params.position(); + if(matrixGetName==GL_MATRIX_MODE) { + params.put((float)matrixMode); + } else { + FloatBuffer matrix = glGetMatrixf(matrixGetName2MatrixModeName(matrixGetName)); + params.put(matrix); + matrix.rewind(); + } + params.position(pos); + } + public void glGetFloatv(int matrixGetName, float[] params, int params_offset) { + if(matrixGetName==GL_MATRIX_MODE) { + params[params_offset]=(float)matrixMode; + } else { + FloatBuffer matrix = glGetMatrixf(matrixGetName2MatrixModeName(matrixGetName)); + matrix.get(params, params_offset, 16); + matrix.rewind(); + } + } + public void glGetIntegerv(int pname, IntBuffer params) { + int pos = params.position(); + if(pname==GL_MATRIX_MODE) { + params.put(matrixMode); + } else { + throw new GLUnsupportedException("unsupported pname: "+pname); + } + params.position(pos); + } + public void glGetIntegerv(int pname, int[] params, int params_offset) { + if(pname==GL_MATRIX_MODE) { + params[params_offset]=matrixMode; + } else { + throw new GLUnsupportedException("unsupported pname: "+pname); + } + } + + public final void glLoadMatrixf(final float[] values, final int offset) { int len = values.length-offset; - if(matrixMode==GL.GL_MODELVIEW) { + if(matrixMode==GL_MODELVIEW) { matrixMv.clear(); matrixMv.put(values, offset, len); matrixMv.rewind(); - } else if(matrixMode==GL.GL_PROJECTION) { + modified |= DIRTY_MODELVIEW ; + } else if(matrixMode==GL_PROJECTION) { matrixP.clear(); matrixP.put(values, offset, len); matrixP.rewind(); + modified |= DIRTY_PROJECTION ; + } else if(matrixMode==GL.GL_TEXTURE) { + matrixT.clear(); + matrixT.put(values, offset, len); + matrixT.rewind(); + modified |= DIRTY_TEXTURE ; } - modified = true; } - public void glLoadMatrixf(java.nio.FloatBuffer m) { + public final void glLoadMatrixf(java.nio.FloatBuffer m) { int spos = m.position(); - if(matrixMode==GL.GL_MODELVIEW) { + if(matrixMode==GL_MODELVIEW) { matrixMv.clear(); matrixMv.put(m); matrixMv.rewind(); - } else if(matrixMode==GL.GL_PROJECTION) { + modified |= DIRTY_MODELVIEW ; + } else if(matrixMode==GL_PROJECTION) { matrixP.clear(); matrixP.put(m); matrixP.rewind(); + modified |= DIRTY_PROJECTION ; + } else if(matrixMode==GL.GL_TEXTURE) { + matrixT.clear(); + matrixT.put(m); + matrixT.rewind(); + modified |= DIRTY_TEXTURE ; } m.position(spos); - modified = true; } - public void glPopMatrix() { + public final void glPopMatrix() { float[] stackEntry=null; - if(matrixMode==GL.GL_MODELVIEW) { + if(matrixMode==GL_MODELVIEW) { stackEntry = (float[])matrixMvStack.remove(0); - } else if(matrixMode==GL.GL_PROJECTION) { + } else if(matrixMode==GL_PROJECTION) { stackEntry = (float[])matrixPStack.remove(0); + } else if(matrixMode==GL.GL_TEXTURE) { + stackEntry = (float[])matrixTStack.remove(0); } glLoadMatrixf(stackEntry, 0); } - public void glPushMatrix() { + public final void glPushMatrix() { float[] stackEntry = new float[1*16]; - if(matrixMode==GL.GL_MODELVIEW) { + if(matrixMode==GL_MODELVIEW) { matrixMv.get(stackEntry); matrixMv.rewind(); matrixMvStack.add(0, stackEntry); - } else if(matrixMode==GL.GL_PROJECTION) { + } else if(matrixMode==GL_PROJECTION) { matrixP.get(stackEntry); matrixP.rewind(); matrixPStack.add(0, stackEntry); + } else if(matrixMode==GL.GL_TEXTURE) { + matrixT.get(stackEntry); + matrixT.rewind(); + matrixTStack.add(0, stackEntry); } } - public void glLoadIdentity() { - if(matrixMode==GL.GL_MODELVIEW) { + public final void glLoadIdentity() { + if(matrixMode==GL_MODELVIEW) { matrixMv.clear(); matrixMv.put(matrixIdent); matrixMv.rewind(); matrixIdent.rewind(); - } else if(matrixMode==GL.GL_PROJECTION) { + modified |= DIRTY_MODELVIEW ; + } else if(matrixMode==GL_PROJECTION) { matrixP.clear(); matrixP.put(matrixIdent); matrixP.rewind(); matrixIdent.rewind(); + modified |= DIRTY_PROJECTION ; + } else if(matrixMode==GL.GL_TEXTURE) { + matrixT.clear(); + matrixT.put(matrixIdent); + matrixT.rewind(); + matrixIdent.rewind(); + modified |= DIRTY_TEXTURE ; } - modified = true; - } - - public void glMultMatrixf(FloatBuffer a, FloatBuffer b, FloatBuffer p) { - for (int i = 0; i < 4; i++) { - final float ai0=a.get(i+0*4), ai1=a.get(i+1*4), ai2=a.get(i+2*4), ai3=a.get(i+3*4); - p.put(i+0*4 , ai0 * b.get(0+0*4) + ai1 * b.get(1+0*4) + ai2 * b.get(2+0*4) + ai3 * b.get(3+0*4) ); - p.put(i+1*4 , ai0 * b.get(0+1*4) + ai1 * b.get(1+1*4) + ai2 * b.get(2+1*4) + ai3 * b.get(3+1*4) ); - p.put(i+2*4 , ai0 * b.get(0+2*4) + ai1 * b.get(1+2*4) + ai2 * b.get(2+2*4) + ai3 * b.get(3+2*4) ); - p.put(i+3*4 , ai0 * b.get(0+3*4) + ai1 * b.get(1+3*4) + ai2 * b.get(2+3*4) + ai3 * b.get(3+3*4) ); - } - // or .. projectFloat.gluMultMatricesf(b, a, p); } - public void glMultMatrixf(FloatBuffer m) { - if(matrixMode==GL.GL_MODELVIEW) { + public final void glMultMatrixf(final FloatBuffer m) { + if(matrixMode==GL_MODELVIEW) { glMultMatrixf(matrixMv, m, matrixMult); matrixMv.clear(); matrixMv.put(matrixMult); matrixMv.rewind(); - } else if(matrixMode==GL.GL_PROJECTION) { + modified |= DIRTY_MODELVIEW ; + } else if(matrixMode==GL_PROJECTION) { glMultMatrixf(matrixP, m, matrixMult); matrixP.clear(); matrixP.put(matrixMult); matrixP.rewind(); + modified |= DIRTY_PROJECTION ; + } else if(matrixMode==GL.GL_TEXTURE) { + glMultMatrixf(matrixT, m, matrixMult); + matrixT.clear(); + matrixT.put(matrixMult); + matrixT.rewind(); + modified |= DIRTY_TEXTURE ; } matrixMult.rewind(); - modified = true; } - public void glTranslatef(float x, float y, float z) { + public void glMultMatrixf(float[] m, int m_offset) { + if(matrixMode==GL_MODELVIEW) { + glMultMatrixf(matrixMv, m, m_offset, matrixMult); + matrixMv.clear(); + matrixMv.put(matrixMult); + matrixMv.rewind(); + modified |= DIRTY_MODELVIEW ; + } else if(matrixMode==GL_PROJECTION) { + glMultMatrixf(matrixP, m, m_offset, matrixMult); + matrixP.clear(); + matrixP.put(matrixMult); + matrixP.rewind(); + modified |= DIRTY_PROJECTION ; + } else if(matrixMode==GL.GL_TEXTURE) { + glMultMatrixf(matrixT, m, m_offset, matrixMult); + matrixT.clear(); + matrixT.put(matrixMult); + matrixT.rewind(); + modified |= DIRTY_TEXTURE ; + } + matrixMult.rewind(); + } + + public final void glTranslatef(final float x, final float y, final float z) { // Translation matrix: // 1 0 0 x // 0 1 0 y @@ -232,7 +473,7 @@ public class PMVMatrix { glMultMatrixf(matrixTrans); } - public void glRotatef(float angdeg, float x, float y, float z) { + public final void glRotatef(final float angdeg, float x, float y, float z) { float angrad = angdeg * (float) Math.PI / 180; float c = (float)Math.cos(angrad); float ic= 1.0f - c; @@ -253,19 +494,6 @@ public class PMVMatrix { float ys = y*s; float yz = y*z; float zs = z*s; - if(false) { - matrixRot.put(0+4*0, x*x*ic+c); - matrixRot.put(0+4*1, xy*ic+zs); - matrixRot.put(0+4*2, xz*ic-ys); - - matrixRot.put(1+4*0, xy*ic+zs); - matrixRot.put(1+4*1, y*y*ic+c); - matrixRot.put(1+4*2, yz*ic-xs); - - matrixRot.put(2+4*0, xz*ic-ys); - matrixRot.put(2+4*1, yz*ic+xs); - matrixRot.put(2+4*2, z*z*ic+c); - } else { matrixRot.put(0*4+0, x*x*ic+c); matrixRot.put(0*4+1, xy*ic+zs); matrixRot.put(0*4+2, xz*ic-ys); @@ -277,12 +505,11 @@ public class PMVMatrix { matrixRot.put(2*4+0, xz*ic+ys); matrixRot.put(2*4+1, yz*ic-xs); matrixRot.put(2*4+2, z*z*ic+c); - } glMultMatrixf(matrixRot); } - public void glScalef(float x, float y, float z) { + public final void glScalef(final float x, final float y, final float z) { // Scale matrix: // x 0 0 0 // 0 y 0 0 @@ -295,7 +522,7 @@ public class PMVMatrix { glMultMatrixf(matrixScale); } - public void glOrthof(float left, float right, float bottom, float top, float zNear, float zFar) { + public final void glOrthof(final float left, final float right, final float bottom, final float top, final float zNear, final float zFar) { // Ortho matrix: // 2/dx 0 0 tx // 0 2/dy 0 ty @@ -318,7 +545,7 @@ public class PMVMatrix { glMultMatrixf(matrixOrtho); } - public void glFrustumf(float left, float right, float bottom, float top, float zNear, float zFar) { + public final void glFrustumf(final float left, final float right, final float bottom, final float top, final float zNear, final float zFar) { if(zNear<=0.0f||zFar<0.0f) { throw new GLException("GL_INVALID_VALUE: zNear and zFar must be positive, and zNear>0"); } @@ -352,15 +579,11 @@ public class PMVMatrix { glMultMatrixf(matrixFrustum); } - public void gluPerspective(float fovy, float aspect, float zNear, float zFar) { - float top=(float)Math.tan(fovy*((float)Math.PI)/360.0f)*zNear; - float bottom=-1.0f*top; - float left=aspect*bottom; - float right=aspect*top; - glFrustumf(left, right, bottom, top, zNear, zFar); - } + // + // private + // - private void setMviMvit() { + private final void setMviMvit() { if(!projectFloat.gluInvertMatrixf(matrixMv, matrixMvi)) { throw new GLException("Invalid source Mv matrix, can't compute inverse"); } @@ -381,15 +604,16 @@ public class PMVMatrix { } protected FloatBuffer matrixIdent; - protected FloatBuffer matrixPMvMviT, matrixPMvMvi, matrixPMv, matrixP, matrixMv, matrixMvi, matrixMvit; + protected FloatBuffer matrixTPMvMvitPmv, matrixPMvMvit, matrixPMvMvitPmv, matrixPMvMvi, matrixPMv, matrixP, matrixT, matrixMv, matrixMvi, matrixMvit, matrixPmv; protected FloatBuffer matrixMvit3; protected FloatBuffer matrixMult, matrixTrans, matrixRot, matrixScale, matrixOrtho, matrixFrustum; protected float[] vec3f; - protected List/*FloatBuffer*/ matrixPStack, matrixMvStack; - protected int matrixMode = GL.GL_MODELVIEW; - protected boolean modified = false; + protected List/*FloatBuffer*/ matrixTStack, matrixPStack, matrixMvStack; + protected int matrixMode = GL_MODELVIEW; + protected int modified = 0; protected ProjectFloat projectFloat; + public static final int DIRTY_MODELVIEW = 1 << 0; + public static final int DIRTY_PROJECTION = 1 << 1; + public static final int DIRTY_TEXTURE = 1 << 2; } - - |