cgcomplexstandardshaderexample.java

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

        gl.glLoadIdentity();
        gl.glRotated(xrotation, 1, 0, 0);
        gl.glRotated(yrotation, 0, 1, 0);
        gl.glRotated(zrotation, 0, 0, 1);

        CGprogram currentVertexProgram = null;
        CGprogram currentPixelProgram = null;
        CGparameter param = null;

        if ( (!quality.isBumpMapSet() || !NvidiaGpuActive) && 
             retextureNeeded ) {
            JoglRenderer.setDefaultTextureForFixedFunctionOpenGL(
                NvidiaGpuPixelProgramTexture);
            retextureNeeded = false;
        }

        enableTexture(gl, NvidiaGpuActive && quality.isBumpMapSet());

        if ( NvidiaGpuActive ) {
            //- Global per-frame shader activation ----------------------------
            JoglRenderer.enableNvidiaCgProfiles();
            JoglRenderer.setRenderingWithNvidiaGpu(true);
            if ( quality.isBumpMapSet() ) {
                currentVertexProgram = NvidiaGpuVertexProgramTextureBump;
                currentPixelProgram = NvidiaGpuPixelProgramTextureBump;
              }
              else {
                currentVertexProgram = NvidiaGpuVertexProgramTexture;
                currentPixelProgram = NvidiaGpuPixelProgramTexture;
            }
            JoglRenderer.bindNvidiaGpuShaders(
                currentVertexProgram, currentPixelProgram);

            //- Shader configuration from scene data --------------------------
            JoglRenderer.activateNvidiaGpuParameters(gl, quality,
                currentVertexProgram, currentPixelProgram);
            JoglCameraRenderer.activateNvidiaGpuParameters(gl, camera,
                currentVertexProgram, currentPixelProgram);
            JoglLightRenderer.activateNvidiaGpuParameters(gl, light,
                currentVertexProgram, currentPixelProgram);
            JoglMaterialRenderer.activateNvidiaGpuParameters(gl, material,
                currentVertexProgram, currentPixelProgram);
            JoglGeometryRenderer.activateNvidiaGpuParameters(gl, geometry,
                camera, currentVertexProgram, currentPixelProgram);

            //- Multiple texture management for pixel shaders -----------------
            param = CgGL.cgGetNamedParameter(currentPixelProgram, "textureMap");
            CgGL.cgGLEnableTextureParameter(param);
            if ( quality.isBumpMapSet() ) {
                param = CgGL.cgGetNamedParameter(currentPixelProgram, "normalMap");
                CgGL.cgGLEnableTextureParameter(param);
            }  
        }
        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);
            }
        }


        JoglGeometryRenderer.draw(gl, geometry, camera, quality);

        if ( NvidiaGpuActive ) {
            // Disable textures
            param = CgGL.cgGetNamedParameter(currentPixelProgram, "textureMap");
            CgGL.cgGLDisableTextureParameter(param);
            if ( quality.isBumpMapSet() ) {
                param = CgGL.cgGetNamedParameter(currentPixelProgram, "normalMap");
                CgGL.cgGLDisableTextureParameter(param);
            }
            JoglRenderer.disableNvidiaCgProfiles();

            // When using multiple textures... without this fixed function OpenGL
            // gets unconfigured is texture state! More should be researched on
            // this topic!
            if ( quality.isBumpMapSet() ) {
                retextureNeeded = true;
            }
            JoglRenderer.setRenderingWithNvidiaGpu(false);
        }

        gl.glLoadIdentity();
        JoglLightRenderer.draw(gl, light);
    }

    void enableTexture(GL gl, boolean withMap) {
        //-----------------------------------------------------------------
        gl.glEnable(gl.GL_TEXTURE_2D);
        textureMapList = JoglImageRenderer.activate(gl, textureMap);

        //- 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);

        //gl.glTexEnvf(gl.GL_TEXTURE_ENV,
        //   GL.GL_TEXTURE_ENV_MODE, gl.GL_DECAL);

        //-----------------------------------------------------------------
        if ( withMap ) {
            normalMapList = JoglImageRenderer.activate(gl, convertedNormalMap);
        }
    }

    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);

        //-----------------------------------------------------------------
        CgComplexStandardShaderExample instance = new CgComplexStandardShaderExample(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                                                                     =
//===========================================================================