cgsimpleunrestrictedshaderexample.java

基于java的3d开发库。对坐java3d的朋友有很大的帮助。

            CgGL.cgGLSetMatrixParameterdr(
                CgGL.cgGetNamedParameter(currentVertexProgram,
                    "modelViewGlobal"), matrixarray, 0);
            CgGL.cgGLSetParameter3dv(
                CgGL.cgGetNamedParameter(currentVertexProgram,
                    "cameraPositionGlobal"), vectorarray, 0);
            }

            //- Shader configuration from light data --------------------------
            // (This should be managed by JoglLightRenderer)
            {
            Vector3D lp = light.getPosition();
            double lpos[] = {lp.x, lp.y, lp.z};
            double lightColor[] = {1.0, 1.0, 1.0};

            CgGL.cgGLSetParameter3dv(CgGL.cgGetNamedParameter(
                currentVertexProgram, "lightPositionGlobal"), lpos, 0);
            CgGL.cgGLSetParameter3dv(CgGL.cgGetNamedParameter(
                currentPixelProgram, "lightColor"), lightColor, 0);
            }

            //- Shader configuration from material data -----------------------
            // (This should be managed by JoglMaterialRenderer)
            {
            double Ka[] = material.getAmbient().exportToDoubleArrayVect();
            double Kd[] = material.getDiffuse().exportToDoubleArrayVect();
            double Ks[] = material.getSpecular().exportToDoubleArrayVect();
            CgGL.cgGLSetParameter3dv(CgGL.cgGetNamedParameter(
                currentVertexProgram, "ambientColor"), Ka, 0);
            CgGL.cgGLSetParameter3dv(CgGL.cgGetNamedParameter(
                currentVertexProgram, "diffuseColor"), Kd, 0);
            CgGL.cgGLSetParameter3dv(CgGL.cgGetNamedParameter(
                currentVertexProgram, "specularColor"), Ks, 0);
            CgGL.cgGLSetParameter1d(CgGL.cgGetNamedParameter(
                currentPixelProgram, "phongExponent"), material.getPhongExponent());
            }

            //- Shader configuration from current object ----------------------
            // (This should be managed by JoglGeometryRenderer)
            {
            Matrix4x4 MProjection;
            Matrix4x4 MModelviewGlobal;
            Matrix4x4 MModelviewLocal, MModelviewLocalIT, MCombined;
            double matrixarray[];

            MProjection = camera.calculateViewVolumeMatrix();
            MModelviewGlobal = camera.calculateTransformationMatrix();
            MModelviewLocal = MModelviewGlobal.multiply(
                JoglMatrixRenderer.importJOGL(gl, gl.GL_MODELVIEW_MATRIX));
            MCombined = MProjection.multiply(MModelviewLocal);
            MModelviewLocalIT = MModelviewLocal.inverse();
            MModelviewLocalIT.transpose();

            matrixarray = MCombined.exportToDoubleArrayRowOrder();
            CgGL.cgGLSetMatrixParameterdr(CgGL.cgGetNamedParameter(
                currentVertexProgram, "modelViewProjectionLocal"),
                matrixarray, 0);

            matrixarray = MModelviewLocal.exportToDoubleArrayRowOrder();
            CgGL.cgGLSetMatrixParameterdr(CgGL.cgGetNamedParameter(
                currentVertexProgram, "modelViewLocal"),
                matrixarray, 0);

            matrixarray = MModelviewLocalIT.exportToDoubleArrayRowOrder();
            CgGL.cgGLSetMatrixParameterdr(CgGL.cgGetNamedParameter(
                currentVertexProgram, "modelViewLocalIT"),
                matrixarray, 0);
            }
        }
        else {
            JoglLightRenderer.activate(gl, light);
            JoglMaterialRenderer.activate(gl, material);
            if ( quality.isTextureSet() ) {
                gl.glEnable(gl.GL_TEXTURE_2D);
            }
            else {
                gl.glDisable(gl.GL_TEXTURE_2D);
            }
        }

        // And go ahead and draw the scene geometry
        enableTexture(gl);
        JoglGeometryRenderer.draw(gl, geometry, camera, quality);

        if ( NvidiaGpuActive ) {
            JoglRenderer.disableNvidiaCgProfiles();
        }
        gl.glLoadIdentity();
        JoglLightRenderer.draw(gl, light);
    }

    void enableTexture(GL gl) {
        int glList;

        //- Basic OpenGL texture state setup ------------------------------
        gl.glTexParameteri(GL.GL_TEXTURE_2D,
           GL.GL_GENERATE_MIPMAP_SGIS, GL.GL_TRUE);
        gl.glTexParameteri(GL.GL_TEXTURE_2D,
           GL.GL_TEXTURE_MIN_FILTER, GL.GL_LINEAR_MIPMAP_LINEAR);
        gl.glTexParameteri(GL.GL_TEXTURE_2D,
           GL.GL_TEXTURE_MAG_FILTER, GL.GL_LINEAR);
        gl.glTexParameteri(GL.GL_TEXTURE_2D,
           GL.GL_TEXTURE_WRAP_S, GL.GL_CLAMP_TO_EDGE);
        gl.glTexParameteri(GL.GL_TEXTURE_2D,
           GL.GL_TEXTURE_WRAP_T, GL.GL_CLAMP_TO_EDGE);

        glList = JoglImageRenderer.activate(gl, textureMap);
    }

    public void
    displayChanged(GLAutoDrawable drawable,
        boolean modeChanged, boolean deviceChanged) {
        // nothing
    }

    public void reshape(GLAutoDrawable drawable,
        int x, int y, int width, int height) {
        GL gl = drawable.getGL();
        
        gl.glViewport(x, y, width, height); 
        camera.updateViewportResize(width, height);
        needPaint = 1;
    }

    public void mouseEntered(MouseEvent e) {
        canvas.requestFocusInWindow();
    }

    public void mouseExited(MouseEvent e) {
        //System.out.println("Mouse exited");
    }

    public void mousePressed(MouseEvent e) {
        if ( cameraController.processMousePressedEventAwt(e) ) {
            needPaint = 1;
            canvas.repaint();
        }
    }

    public void mouseReleased(MouseEvent e) {
        if ( cameraController.processMouseReleasedEventAwt(e) ) {
            needPaint = 1;
            canvas.repaint();
        }
    }

    public void mouseClicked(MouseEvent e) {
        if ( cameraController.processMouseClickedEventAwt(e) ) {
            needPaint = 1;
            canvas.repaint();
        }
    }

    public void mouseMoved(MouseEvent e) {
        if ( cameraController.processMouseMovedEventAwt(e) ) {
            needPaint = 1;
            canvas.repaint();
        }
    }

    public void mouseDragged(MouseEvent e) {
        if ( cameraController.processMouseDraggedEventAwt(e) ) {
            needPaint = 1;
            canvas.repaint();
        }
    }

    /**
    WARNING: It is not working... check pending
    */
    public void mouseWheelMoved(MouseWheelEvent e) {
        System.out.println(".");
        if ( cameraController.processMouseWheelEventAwt(e) ) {
            needPaint = 1;
            canvas.repaint();
        }
    }

    public void keyPressed(KeyEvent e) {
        if ( e.getKeyCode() == KeyEvent.VK_ESCAPE ) {
            System.exit(0);
        }
        if ( cameraController.processKeyPressedEventAwt(e) ) {
            needPaint = 1;
            canvas.repaint();
        }
        if ( qualityController.processKeyPressedEventAwt(e) ) {
            System.out.println(quality);
            needPaint = 1;
            canvas.repaint();
        }

        int unicode_id = e.getKeyChar();
        if ( unicode_id != e.CHAR_UNDEFINED ) {
          Vector3D lightPosition = light.getPosition();
          switch ( unicode_id ) {
            case '1': xrotation -= 1.0; break;
            case '2': xrotation += 1.0; break;
            case '3': yrotation -= 1.0; break;
            case '4': yrotation += 1.0; break;
            case '5': zrotation -= 1.0; break;
            case '6': zrotation += 1.0; break;
            case 'h': lightPosition.x -= 0.1; break;
            case 'k': lightPosition.x += 0.1; break;
            case 'u': lightPosition.z += 0.1; break;
            case 'j': lightPosition.z -= 0.1; break;
            case '9': lightPosition.y -= 0.1; break;
            case '0': lightPosition.y += 0.1; break;
            case 'g':
              if ( NvidiaGpuAvailable ) {
                  NvidiaGpuActive = !NvidiaGpuActive;
              }
              else {
                  NvidiaGpuActive = false;
                  System.out.println("Nvidia Cg not available. Turning on GPU support not available!");
              }
              break;
            case 'r': withRotationAnimation = !withRotationAnimation; break;
            case ' ': withLightAnimation = !withLightAnimation; break;
          }
          light.setPosition(lightPosition);
          needPaint = 1;
          canvas.repaint();
        }
    }

    public void keyReleased(KeyEvent e) {
        if ( cameraController.processKeyReleasedEventAwt(e) ) {
            needPaint = 1;
            canvas.repaint();
        }
    }

    /**
    Do NOT call your controller from the `keyTyped` method, or the controller
    will be invoked twice for each key. Call it only from the `keyPressed` and
    `keyReleased` method
    */
    public void keyTyped(KeyEvent e) {
        ;
    }

    public static void main(String[] argv) {
        //-----------------------------------------------------------------
        JoglRenderer.verifyOpenGLAvailability();
        JoglRenderer.verifyNvidiaCgAvailability();
        JoglRenderer.setNvidiaCgAutomaticMode(false);

        //-----------------------------------------------------------------
        CgSimpleUnrestrictedShaderExample instance = new CgSimpleUnrestrictedShaderExample(false);

        JFrame frame = new JFrame("Vitral SDK / Nvidia Cg demo");
        canvas = new GLCanvas();
        canvas.addGLEventListener(instance);
        canvas.addMouseListener(instance);
        canvas.addMouseMotionListener(instance);
        canvas.addKeyListener(instance);
        canvas.addGLEventListener(instance);
        Animator animator = new Animator(canvas);

        frame.add(canvas);
        frame.setSize(1150, 1150);
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setVisible(true);
        canvas.requestFocusInWindow();
        animator.start();
    }
}

//===========================================================================
//= EOF                                                                     =
//===========================================================================