cgsimpleunrestrictedshaderexample.java

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

//===========================================================================

// VITRAL recomendation: Use explicit class imports (not .*) in hello world 
// type programs so the user/programmer can be exposed to all the complexity 
// involved. This will help him to dominate the involved libraries.

// Java base classes
import java.io.IOException;
import java.io.FileInputStream;
import java.io.File;

// Java GUI classes
import java.awt.event.MouseEvent;
import java.awt.event.MouseWheelEvent;
import java.awt.event.KeyEvent;
import java.awt.event.MouseListener;
import java.awt.event.MouseWheelListener;
import java.awt.event.MouseMotionListener;
import java.awt.event.KeyListener;
import javax.swing.JFrame;

// JOGL classes
import javax.media.opengl.GL;
import javax.media.opengl.GLAutoDrawable;
import javax.media.opengl.GLCanvas;
import javax.media.opengl.GLEventListener;
import com.sun.opengl.cg.CgGL;
import com.sun.opengl.cg.CGcontext;
import com.sun.opengl.cg.CGprogram;
import com.sun.opengl.util.Animator;

// VitralSDK classes
import vsdk.toolkit.common.ColorRgb;
import vsdk.toolkit.common.Vector3D;
import vsdk.toolkit.common.Matrix4x4;
import vsdk.toolkit.common.RendererConfiguration;
import vsdk.toolkit.media.RGBImage;
import vsdk.toolkit.environment.Camera;
import vsdk.toolkit.environment.Material;
import vsdk.toolkit.environment.Light;
import vsdk.toolkit.environment.geometry.Geometry;
import vsdk.toolkit.environment.geometry.Sphere;
import vsdk.toolkit.io.PersistenceElement;
import vsdk.toolkit.io.image.ImagePersistence;
import vsdk.toolkit.gui.CameraController;
import vsdk.toolkit.gui.CameraControllerAquynza;
import vsdk.toolkit.gui.RendererConfigurationController;
import vsdk.toolkit.render.jogl.JoglCameraRenderer;
import vsdk.toolkit.render.jogl.JoglGeometryRenderer;
import vsdk.toolkit.render.jogl.JoglImageRenderer;
import vsdk.toolkit.render.jogl.JoglLightRenderer;
import vsdk.toolkit.render.jogl.JoglMaterialRenderer;
import vsdk.toolkit.render.jogl.JoglMatrixRenderer;
import vsdk.toolkit.render.jogl.JoglRenderer;

/**
This program constitutes a template for VitralSDK based applications which
make use of Nvidia Cg shaders. Note that current code does not use standard
VitralSDK material handling, but all shader management is standalone and
contained here.  Use this program as a base for custom developed programs
and shaders.
*/
public class CgSimpleUnrestrictedShaderExample
    implements GLEventListener, MouseListener, MouseMotionListener,
               MouseWheelListener, KeyListener
{
    //- GUI ----------------------------------------------------------------
    private static GLCanvas canvas;
    private CameraController cameraController;
    private RendererConfigurationController qualityController;

    //- GPU control --------------------------------------------------------
    private boolean NvidiaGpuActive = true;
    private boolean NvidiaGpuAvailable = true;
    private CGprogram NvidiaGpuVertexProgramTexture;
    private CGprogram NvidiaGpuPixelProgramTexture;

    //- Animation & state control ------------------------------------------
    private boolean firstTimer = true;
    private int needPaint = 3;
    private boolean retextureNeeded = false;
    private boolean withRotationAnimation = false;
    private boolean withLightAnimation = false;
    private double lightAngle = 0;

    //- Scene elements -----------------------------------------------------
    private Camera camera;                   // 1. Camera
    private Light light;                     // 2. Light
    private Material material;               // 3. Surface properties
    private RGBImage textureMap;
    private RendererConfiguration quality;
    private double xrotation;                // 4. Geometrical transformations
    private double yrotation;
    private double zrotation;
    private Geometry geometry;                   // 5. Geometry

    //----------------------------------------------------------------------

    public CgSimpleUnrestrictedShaderExample(boolean appletMode) {
        if ( !appletMode ) init();
    }

    public void init() {
        //- Print users' manual -------------------------------------------
        System.out.println(
        "Key controls:\n"+
        "  - Camera: <cursor arrows>, x/X, y/Y, z/Z, s/S, a/A, f/F, n/N, i\n"+
        "  - Rendering quality: g, <function keys>\n"+
        "  - Animation control: <space>, r\n"+
        "  - Light control: 0, 9, h, k, j, u\n"+
        "  - Rotation control: 1, 2, 3, 4, 5, 6\n"+
        "  - Exit: <escape>\n"+
        "Mouse controls:\n"+
        "  - Drag+button1: camera orientation\n"+
        "  - Drag+button2: camera panning\n"+
        "  - Drag+button3: camera advance & roll\n"
        );
        System.out.print("Initializing... ");

        //- Initialize scene elements--------------------------------------
        // 1: Camera
        camera = new Camera();
        camera.setPosition(new Vector3D(0, -4, 0));
        Matrix4x4 R = new Matrix4x4();
        R.eulerAnglesRotation(Math.toRadians(90.0), 0, 0);
        camera.setRotation(R);
        camera.setFov(30.0);

        // 2: Lights
        light = new Light(Light.POINT, new Vector3D(0, -4, 0), new ColorRgb(1, 1, 1));

        // 3.1. Object attribute -> material propierties
        material = new Material();
        material.setAmbient(new ColorRgb(0, 0, 0));
        material.setDiffuse(new ColorRgb(1, 1, 1));
        material.setSpecular(new ColorRgb(1, 1, 1));
        material.setPhongExponent(40);

        // 3.2. Object attribute -> texture map
        String imageFilename = null;
        try {
            //-------------------------------------------------------
            imageFilename = "../../../etc/textures/miniearth.png";
            textureMap = ImagePersistence.importRGB(new File(imageFilename));
        }
        catch (Exception e) {
            System.err.println("Error: could not read the image file \"" + imageFilename + "\".");
            System.err.println("Check you have access to that file from current working directory.");
            System.err.println(e);
            System.exit(0);
        }

        // 3.3. Object attribute -> how it will render
        quality = new RendererConfiguration();

        // 4. Object attribute -> geometrical transformations
        xrotation = 0;
        yrotation = 0;
        zrotation = 0;

        // 5. Object attribute -> geometry
        geometry = new Sphere(1.0);

        //- Initialize GUI helpers ----------------------------------------
        cameraController = new CameraControllerAquynza(camera);
        qualityController = new RendererConfigurationController(quality);

        //-----------------------------------------------------------------
        System.gc();
        System.out.println("Ok!");
    }

    public void createCgElements() {
        if ( !JoglRenderer.tryToEnableNvidiaCg() ) {
            System.out.println("Nvidia Cg not available. Turning off GPU support!");
            NvidiaGpuActive = false;
            NvidiaGpuAvailable = false;
            return;
        }
        try {
            //-----------------------------------------------------------------
            NvidiaGpuVertexProgramTexture =
              JoglRenderer.loadNvidiaGpuVertexShader(
                new FileInputStream("./etc/PhongTextureVertexShader.cg"));
            NvidiaGpuPixelProgramTexture =
              JoglRenderer.loadNvidiaGpuPixelShader(
                new FileInputStream("./etc/PhongTexturePixelShader.cg"));
        }
        catch ( Exception e ) {
            System.err.println("Error loading shaders!");
            System.exit(1);
        }
    }

    public void init(GLAutoDrawable drawable) {
        // Not used in VitralSDK style applications... check 'firstTimer'
    }

    public void display(GLAutoDrawable drawable) {
        GL gl = drawable.getGL();

        if ( withRotationAnimation ) {
            zrotation += 0.5*2;
            needPaint = 1;
        }

        if ( withLightAnimation ) {
            Vector3D lightPosition = new Vector3D(1, -3, 1);
            Vector3D axis = new Vector3D(0, -1, 0);
            Matrix4x4 R = new Matrix4x4();
            lightAngle += Math.toRadians(1.0*2);
            R.axisRotation(lightAngle, axis);
            lightPosition = R.multiply(lightPosition);
            light.setPosition(lightPosition);
            needPaint = 1;
        }

        if ( needPaint <= 0 ) {
            return;
        }
        needPaint--;

        if ( firstTimer ) {
            firstTimer = false;
            createCgElements();
        }

        //-----------------------------------------------------------------
        gl.glEnable(GL.GL_DEPTH_TEST);
        gl.glClearColor(0, 0, 0, 1.0f);
        gl.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT);

        //-----------------------------------------------------------------
        JoglCameraRenderer.activate(gl, camera);

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

        if ( NvidiaGpuActive ) {
            //- Global per-frame shader activation ----------------------------
            JoglRenderer.enableNvidiaCgProfiles();
            CGprogram currentVertexProgram; // Use this variables to choose
            CGprogram currentPixelProgram;  // between various shaders...
            currentVertexProgram = NvidiaGpuVertexProgramTexture;
            currentPixelProgram = NvidiaGpuPixelProgramTexture;

            CgGL.cgGLBindProgram(currentVertexProgram);
            CgGL.cgGLBindProgram(currentPixelProgram);

            //- Shader configuration for special features ---------------------
            // (This should be managed by JoglRenderer, usually with the help
            // of RendererConfiguration)
            {
            double withTexture = 0.0;
            if ( quality.isTextureSet() ) withTexture = 1.0;
            CgGL.cgGLSetParameter1d(CgGL.cgGetNamedParameter(
                currentPixelProgram, "withTexture"), withTexture);
            }

            //- Shader configuration from camera data -------------------------
            // (This should be managed by JoglCameraRenderer)
            {
            Matrix4x4 MProjection;
            Matrix4x4 MModelviewGlobal;
            Vector3D cp = camera.getPosition();
            double matrixarray[];
            double vectorarray[] = {cp.x, cp.y, cp.z};

            MProjection = camera.calculateViewVolumeMatrix();
            MModelviewGlobal = camera.calculateTransformationMatrix();
            matrixarray = MModelviewGlobal.exportToDoubleArrayRowOrder();