j3dcore: flatten the directory structure a bit

Signed-off-by: Harvey Harrison <[email protected]>

1 files changed, 429 insertions, 0 deletions

diff --git a/src/javax/media/j3d/GLSLShaderProgramRetained.java b/src/javax/media/j3d/GLSLShaderProgramRetained.java
new file mode 100644
index 0000000..d1c7614
--- /dev/null
+++ b/src/javax/media/j3d/GLSLShaderProgramRetained.java
@@ -0,0 +1,429 @@
+/*
+ * Copyright 2005-2008 Sun Microsystems, Inc.  All Rights Reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Sun designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Sun in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
+ * CA 95054 USA or visit www.sun.com if you need additional information or
+ * have any questions.
+ *
+ */
+
+package javax.media.j3d;
+
+/**
+ * The GLSLShaderProgram object is a concrete implementation of a
+ * ShaderProgram node component for the OpenGL GLSL shading language.
+ */
+
+class GLSLShaderProgramRetained extends ShaderProgramRetained {
+
+    /**
+     * Constructs a GLSL shader program node component.
+     */
+    GLSLShaderProgramRetained() {
+    }
+
+    @Override
+    synchronized void createMirrorObject() {
+	// System.err.println("GLSLShaderProgramRetained : createMirrorObject");
+        // This method should only call by setLive().
+	if (mirror == null) {
+            GLSLShaderProgramRetained  mirrorGLSLSP = new GLSLShaderProgramRetained();
+            mirror = mirrorGLSLSP;
+	    mirror.source = source;
+	}
+	initMirrorObject();
+    }
+
+    // ShaderAttributeValue methods
+
+    @Override
+    ShaderError setUniform1i(Context ctx,
+            ShaderProgramId shaderProgramId,
+            ShaderAttrLoc uniformLocation,
+            int value) {
+
+        return Pipeline.getPipeline().setGLSLUniform1i(ctx,
+                shaderProgramId,
+                uniformLocation,
+                value);
+    }
+
+    @Override
+    ShaderError setUniform1f(Context ctx,
+            ShaderProgramId shaderProgramId,
+            ShaderAttrLoc uniformLocation,
+            float value) {
+
+        return Pipeline.getPipeline().setGLSLUniform1f(ctx,
+                shaderProgramId,
+                uniformLocation,
+                value);
+    }
+
+    @Override
+    ShaderError setUniform2i(Context ctx,
+            ShaderProgramId shaderProgramId,
+            ShaderAttrLoc uniformLocation,
+            int[] value) {
+
+        return Pipeline.getPipeline().setGLSLUniform2i(ctx,
+                shaderProgramId,
+                uniformLocation,
+                value);
+    }
+
+    @Override
+    ShaderError setUniform2f(Context ctx,
+            ShaderProgramId shaderProgramId,
+            ShaderAttrLoc uniformLocation,
+            float[] value) {
+
+        return Pipeline.getPipeline().setGLSLUniform2f(ctx,
+                shaderProgramId,
+                uniformLocation,
+                value);
+    }
+
+    @Override
+    ShaderError setUniform3i(Context ctx,
+            ShaderProgramId shaderProgramId,
+            ShaderAttrLoc uniformLocation,
+            int[] value) {
+
+        return Pipeline.getPipeline().setGLSLUniform3i(ctx,
+                shaderProgramId,
+                uniformLocation,
+                value);
+    }
+
+    @Override
+    ShaderError setUniform3f(Context ctx,
+            ShaderProgramId shaderProgramId,
+            ShaderAttrLoc uniformLocation,
+            float[] value) {
+
+        return Pipeline.getPipeline().setGLSLUniform3f(ctx,
+                shaderProgramId,
+                uniformLocation,
+                value);
+    }
+
+    @Override
+    ShaderError setUniform4i(Context ctx,
+            ShaderProgramId shaderProgramId,
+            ShaderAttrLoc uniformLocation,
+            int[] value) {
+
+        return Pipeline.getPipeline().setGLSLUniform4i(ctx,
+                shaderProgramId,
+                uniformLocation,
+                value);
+    }
+
+    @Override
+    ShaderError setUniform4f(Context ctx,
+            ShaderProgramId shaderProgramId,
+            ShaderAttrLoc uniformLocation,
+            float[] value) {
+
+        return Pipeline.getPipeline().setGLSLUniform4f(ctx,
+                shaderProgramId,
+                uniformLocation,
+                value);
+    }
+
+    @Override
+    ShaderError setUniformMatrix3f(Context ctx,
+            ShaderProgramId shaderProgramId,
+            ShaderAttrLoc uniformLocation,
+            float[] value) {
+
+        return Pipeline.getPipeline().setGLSLUniformMatrix3f(ctx,
+                shaderProgramId,
+                uniformLocation,
+                value);
+    }
+
+    @Override
+    ShaderError setUniformMatrix4f(Context ctx,
+            ShaderProgramId shaderProgramId,
+            ShaderAttrLoc uniformLocation,
+            float[] value) {
+
+        return Pipeline.getPipeline().setGLSLUniformMatrix4f(ctx,
+                shaderProgramId,
+                uniformLocation,
+                value);
+    }
+
+    // ShaderAttributeArray methods
+
+    @Override
+    ShaderError setUniform1iArray(Context ctx,
+            ShaderProgramId shaderProgramId,
+            ShaderAttrLoc uniformLocation,
+            int numElements,
+            int[] value) {
+
+        return Pipeline.getPipeline().setGLSLUniform1iArray(ctx,
+                shaderProgramId,
+                uniformLocation,
+                numElements,
+                value);
+    }
+
+    @Override
+    ShaderError setUniform1fArray(Context ctx,
+            ShaderProgramId shaderProgramId,
+            ShaderAttrLoc uniformLocation,
+            int numElements,
+            float[] value) {
+
+        return Pipeline.getPipeline().setGLSLUniform1fArray(ctx,
+                shaderProgramId,
+                uniformLocation,
+                numElements,
+                value);
+    }
+
+    @Override
+    ShaderError setUniform2iArray(Context ctx,
+            ShaderProgramId shaderProgramId,
+            ShaderAttrLoc uniformLocation,
+            int numElements,
+            int[] value) {
+
+        return Pipeline.getPipeline().setGLSLUniform2iArray(ctx,
+                shaderProgramId,
+                uniformLocation,
+                numElements,
+                value);
+    }
+
+    @Override
+    ShaderError setUniform2fArray(Context ctx,
+            ShaderProgramId shaderProgramId,
+            ShaderAttrLoc uniformLocation,
+            int numElements,
+            float[] value) {
+
+        return Pipeline.getPipeline().setGLSLUniform2fArray(ctx,
+                shaderProgramId,
+                uniformLocation,
+                numElements,
+                value);
+    }
+
+    @Override
+    ShaderError setUniform3iArray(Context ctx,
+            ShaderProgramId shaderProgramId,
+            ShaderAttrLoc uniformLocation,
+            int numElements,
+            int[] value) {
+
+        return Pipeline.getPipeline().setGLSLUniform3iArray(ctx,
+                shaderProgramId,
+                uniformLocation,
+                numElements,
+                value);
+    }
+
+    @Override
+    ShaderError setUniform3fArray(Context ctx,
+            ShaderProgramId shaderProgramId,
+            ShaderAttrLoc uniformLocation,
+            int numElements,
+            float[] value) {
+
+        return Pipeline.getPipeline().setGLSLUniform3fArray(ctx,
+                shaderProgramId,
+                uniformLocation,
+                numElements,
+                value);
+    }
+
+    @Override
+    ShaderError setUniform4iArray(Context ctx,
+            ShaderProgramId shaderProgramId,
+            ShaderAttrLoc uniformLocation,
+            int numElements,
+            int[] value) {
+
+        return Pipeline.getPipeline().setGLSLUniform4iArray(ctx,
+                shaderProgramId,
+                uniformLocation,
+                numElements,
+                value);
+    }
+
+    @Override
+    ShaderError setUniform4fArray(Context ctx,
+            ShaderProgramId shaderProgramId,
+            ShaderAttrLoc uniformLocation,
+            int numElements,
+            float[] value) {
+
+        return Pipeline.getPipeline().setGLSLUniform4fArray(ctx,
+                shaderProgramId,
+                uniformLocation,
+                numElements,
+                value);
+    }
+
+    @Override
+    ShaderError setUniformMatrix3fArray(Context ctx,
+            ShaderProgramId shaderProgramId,
+            ShaderAttrLoc uniformLocation,
+            int numElements,
+            float[] value) {
+
+        return Pipeline.getPipeline().setGLSLUniformMatrix3fArray(ctx,
+                shaderProgramId,
+                uniformLocation,
+                numElements,
+                value);
+    }
+
+    @Override
+    ShaderError setUniformMatrix4fArray(Context ctx,
+            ShaderProgramId shaderProgramId,
+            ShaderAttrLoc uniformLocation,
+            int numElements,
+            float[] value) {
+
+        return Pipeline.getPipeline().setGLSLUniformMatrix4fArray(ctx,
+                shaderProgramId,
+                uniformLocation,
+                numElements,
+                value);
+    }
+
+    /**
+     * Method to return a flag indicating whether this
+     * ShaderProgram is supported on the specified Canvas.
+     */
+    @Override
+    boolean isSupported(Canvas3D cv) {
+        return cv.shadingLanguageGLSL;
+    }
+
+    /**
+     * Method to create the native shader.
+     */
+    @Override
+    ShaderError createShader(Context ctx, ShaderRetained shader, ShaderId[] shaderIdArr) {
+	  return Pipeline.getPipeline().createGLSLShader(ctx, shader.shaderType, shaderIdArr);
+    }
+
+    /**
+     * Method to destroy the native shader.
+     */
+    @Override
+    ShaderError destroyShader(Context ctx, ShaderId shaderId) {
+	return Pipeline.getPipeline().destroyGLSLShader(ctx, shaderId);
+    }
+
+    /**
+     * Method to compile the native shader.
+     */
+    @Override
+    ShaderError compileShader(Context ctx, ShaderId shaderId, String source) {
+        return Pipeline.getPipeline().compileGLSLShader(ctx, shaderId, source );
+    }
+
+    /**
+     * Method to create the native shader program.
+     */
+    @Override
+    ShaderError createShaderProgram(Context ctx, ShaderProgramId[] shaderProgramIdArr) {
+	    return Pipeline.getPipeline().createGLSLShaderProgram(ctx, shaderProgramIdArr);
+    }
+
+    /**
+     * Method to destroy the native shader program.
+     */
+    @Override
+    ShaderError destroyShaderProgram(Context ctx, ShaderProgramId shaderProgramId) {
+        return Pipeline.getPipeline().destroyGLSLShaderProgram(ctx, shaderProgramId);
+    }
+
+    /**
+     * Method to link the native shader program.
+     */
+    @Override
+    ShaderError linkShaderProgram(Context ctx, ShaderProgramId shaderProgramId, ShaderId[] shaderIds) {
+        return Pipeline.getPipeline().linkGLSLShaderProgram(ctx, shaderProgramId, shaderIds);
+    }
+
+    @Override
+    ShaderError bindVertexAttrName(Context ctx, ShaderProgramId shaderProgramId, String attrName, int attrIndex) {
+        return Pipeline.getPipeline().bindGLSLVertexAttrName(ctx, shaderProgramId, attrName, attrIndex);
+    }
+
+    @Override
+    void lookupVertexAttrNames(Context ctx, ShaderProgramId shaderProgramId, String[] attrNames, boolean[] errArr) {
+        // This method is a no-op for GLSL
+    }
+
+    @Override
+    void lookupShaderAttrNames(Context ctx, ShaderProgramId shaderProgramId,
+            String[] attrNames, AttrNameInfo[] attrNameInfoArr) {
+
+        int numAttrNames = attrNames.length;
+
+        ShaderAttrLoc[] locArr = new ShaderAttrLoc[numAttrNames];
+        int[] typeArr = new int[numAttrNames];
+        int[] sizeArr = new int[numAttrNames]; // currently unused
+        boolean[] isArrayArr = new boolean[numAttrNames];
+
+        Pipeline.getPipeline().lookupGLSLShaderAttrNames(ctx, shaderProgramId,
+                numAttrNames, attrNames, locArr, typeArr, sizeArr, isArrayArr);
+
+        for (int i = 0; i < numAttrNames; i++) {
+            attrNameInfoArr[i] = new AttrNameInfo();
+            attrNameInfoArr[i].setLocation(locArr[i]);
+            attrNameInfoArr[i].setArray(isArrayArr[i]);
+            attrNameInfoArr[i].setType(typeArr[i]);
+//            System.err.println(attrNames[i] +
+//                    " : loc = " + locArr[i] +
+//                    ", type = " + typeArr[i] +
+//                    ", isArray = " + isArrayArr[i] +
+//                    ", size = " + sizeArr[i]);
+        }
+    }
+
+    /**
+     * Method to enable the native shader program.
+     */
+    @Override
+    ShaderError enableShaderProgram(Context ctx, ShaderProgramId shaderProgramId) {
+	return Pipeline.getPipeline().useGLSLShaderProgram(ctx, shaderProgramId);
+    }
+
+    /**
+     * Method to disable the native shader program.
+     */
+    @Override
+    ShaderError disableShaderProgram(Context ctx) {
+	return Pipeline.getPipeline().useGLSLShaderProgram(ctx, null);
+    }
+
+
+}