joglrenderer.java

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

        if ( CgGL.cgGLIsProfileSupported(CgGL.CG_PROFILE_ARBVP1) ) {
            nvidiaGpuVertexProfile = CgGL.CG_PROFILE_ARBVP1;
        }
        else {
            if (CgGL.cgGLIsProfileSupported(CgGL.CG_PROFILE_VP30)) {
                nvidiaGpuVertexProfile = CgGL.CG_PROFILE_VP30;
            }
            else {
                if ( nvidiaCgErrorReported ) return false;
                nvidiaCgErrorReported = true;
                VSDK.reportMessage(null, VSDK.WARNING, 
                    "JoglRenderer.tryToEnableNvidiaCg",
                    "Neither arbvp1 or vp30 vertex profiles supported on " + 
                    "this system.\n" +
                    "CG vertex shader functionality disabled.\n" + 
                    "Furter error reporting on this issue disabled");
                nvidiaCgAvailable = false;
                return false;
            }
        }

        if ( CgGL.cgGLIsProfileSupported(CgGL.CG_PROFILE_ARBFP1) ) {
            nvidiaGpuPixelProfile = CgGL.CG_PROFILE_ARBFP1;
        }
        else {
            // try FP30
            if ( CgGL.cgGLIsProfileSupported(CgGL.CG_PROFILE_FP30) ) {
                nvidiaGpuPixelProfile = CgGL.CG_PROFILE_FP30;
            }
            else {
                if ( nvidiaCgErrorReported ) return false;
                nvidiaCgErrorReported = true;
                VSDK.reportMessage(null, VSDK.WARNING, 
                    "JoglRenderer.tryToEnableNvidiaCg",
                    "Neither arbfp1 or fp30 pixel profiles supported on " +
                    "this system.\n" + 
                    "CG pixel shader functionality disabled.\n" + 
                    "Furter error reporting on this issue disabled");
                nvidiaCgAvailable = false;
                return false;
            }
        }

        //-----------------------------------------------------------------
        // Warning: do not use this!
        //CgGL.cgGLSetManageTextureParameters(nvidiaGpuContext, true);
        nvidiaCgAvailable = true;
        return true;
    }

    public static void enableNvidiaCgProfiles()
    {
        if ( getNvidiaCgAvailability() ) {
            CgGL.cgGLEnableProfile(nvidiaGpuVertexProfile);
            CgGL.cgGLEnableProfile(nvidiaGpuPixelProfile);
        }
    }

    public static void disableNvidiaCgProfiles()
    {
        if ( getNvidiaCgAvailability() ) {
            CgGL.cgGLUnbindProgram(nvidiaGpuVertexProfile);
            CgGL.cgGLUnbindProgram(nvidiaGpuPixelProfile);
            CgGL.cgGLDisableProfile(nvidiaGpuVertexProfile);
            CgGL.cgGLDisableProfile(nvidiaGpuPixelProfile);
        }
    }

    public static CGprogram loadNvidiaGpuVertexShader(InputStream is)
    {
        if ( !getNvidiaCgAvailability() ) {
            return null;
        }
        CGprogram shader = null;
        try {
            shader = CgGL.cgCreateProgramFromStream(
                nvidiaGpuContext, CgGL.CG_SOURCE, is,
                nvidiaGpuVertexProfile, null, null);
            if ( !CgGL.cgIsProgramCompiled(shader) ) {
                CgGL.cgCompileProgram(shader);
            }
            CgGL.cgGLLoadProgram(shader);
        }
        catch ( Exception e ) {
            if ( nvidiaCgErrorReported ) return null;
            nvidiaCgErrorReported = true;
            VSDK.reportMessage(null, VSDK.WARNING, 
                "JoglRenderer.loadNvidiaGpuVertexShader",
                "Error loading an nvidia vertex shader.\n" + 
                "CG vertex shader functionality disabled.\n" + 
                "Furter error reporting on this issue disabled");
            nvidiaCgAvailable = false;
            return null;
        }
        return shader;
    }

    public static CGprogram loadNvidiaGpuPixelShader(InputStream is)
    {
        if ( !getNvidiaCgAvailability() ) {
            return null;
        }

        CGprogram shader;
        try {
            shader = CgGL.cgCreateProgramFromStream(
                nvidiaGpuContext, CgGL.CG_SOURCE, is,
                nvidiaGpuPixelProfile, null, null);
            if ( !CgGL.cgIsProgramCompiled(shader) ) {
                CgGL.cgCompileProgram(shader);
            }
            CgGL.cgGLLoadProgram(shader);
        }
        catch ( Exception e ) {
            if ( nvidiaCgErrorReported ) return null;
            nvidiaCgErrorReported = true;
            VSDK.reportMessage(null, VSDK.WARNING, 
                "JoglRenderer.loadNvidiaGpuPixelShader",
                "Error loading an nvidia pixel shader.\n" + 
                "CG pixel shader functionality disabled.\n" + 
                "Furter error reporting on this issue disabled");
            nvidiaCgAvailable = false;
            return null;
        }

        return shader;
    }

    public static boolean needCg(RendererConfiguration quality)
    {
        if ( quality.getShadingType() != quality.SHADING_TYPE_PHONG ||
             nvidiaCgErrorReported ) {
            return false;
        }
        return true;
    }

    public static void deactivateNvidiaGpuParameters(GL gl, RendererConfiguration quality)
    {
        if ( nvidiaCgErrorReported ) {
            return;
        }

        //-----------------------------------------------------------------
        if ( nvidiaCgAutomaticMode && needCg(quality) ) {
            // Disable textures
            CGparameter param = null;
            param = CgGL.cgGetNamedParameter(NvidiaGpuPixelProgramTexture, "textureMap");
            CgGL.cgGLDisableTextureParameter(param);
            param = CgGL.cgGetNamedParameter(NvidiaGpuPixelProgramTextureBump, "textureMap");
            CgGL.cgGLDisableTextureParameter(param);
            param = CgGL.cgGetNamedParameter(NvidiaGpuPixelProgramTexture, "normalMap");
            CgGL.cgGLDisableTextureParameter(param);
            param = CgGL.cgGetNamedParameter(NvidiaGpuPixelProgramTextureBump, "normalMap");
            CgGL.cgGLDisableTextureParameter(param);
            disableNvidiaCgProfiles();
            setRenderingWithNvidiaGpu(false);
            setDefaultTextureForFixedFunctionOpenGL(
                NvidiaGpuPixelProgramTexture);
        }
    }

    public static void activateNvidiaGpuParameters(GL gl,
        RendererConfiguration quality,
        CGprogram vertexShader, CGprogram pixelShader)
    {
        if ( nvidiaCgErrorReported ) {
            return;
        }

        //-----------------------------------------------------------------
        if ( nvidiaCgAutomaticMode && needCg(quality) ) {
            //- Global per-frame shader activation ----------------------------
            enableNvidiaCgProfiles();
            setRenderingWithNvidiaGpu(true);

            if ( quality.isBumpMapSet() ) {
                JoglRenderer.currentVertexShader = JoglRenderer.NvidiaGpuVertexProgramTextureBump;
                JoglRenderer.currentPixelShader = JoglRenderer.NvidiaGpuPixelProgramTextureBump;
              }
              else {
                JoglRenderer.currentVertexShader = JoglRenderer.NvidiaGpuVertexProgramTexture;
                JoglRenderer.currentPixelShader = JoglRenderer.NvidiaGpuPixelProgramTexture;
            }
            JoglRenderer.bindNvidiaGpuShaders(
                currentVertexShader, currentPixelShader);
            vertexShader = currentVertexShader;
            pixelShader = currentPixelShader;

            //- Multiple texture management for pixel shaders -----------------
            CGparameter param;
            param = CgGL.cgGetNamedParameter(JoglRenderer.currentPixelShader, "textureMap");
            CgGL.cgGLEnableTextureParameter(param);
            if ( quality.isBumpMapSet() ) {
                param = CgGL.cgGetNamedParameter(JoglRenderer.currentPixelShader, "normalMap");
                CgGL.cgGLEnableTextureParameter(param);
            }  

        }
        //-----------------------------------------------------------------
        double withTexture = 0.0;
        if ( quality.isTextureSet() ) withTexture = 1.0;
        CgGL.cgGLSetParameter1d(CgGL.cgGetNamedParameter(
            pixelShader, "withTexture"), withTexture);
    }

    /**
    When using Nvidia Gpu fragment shaders with multiple textures (samplers),
    there is a problem drawing objects with default fixed function OpenGL/
    JOGL, and is that the default texture for fixed function is changed.
    This method is not fair, but a desperate measure for returning
    fixed function OpenGL/JOGL to the default texture.
    Current implementation requires an standarized VitralSDK pixel shader
    NOT USING more than one texture.  It has been observed that just
    enabling and disabling such a shader, turns default OpenGL/JOGL default
    texture for fixed function pipeline to that texture associated with
    "textureMap" sampler in current shader.  Use this function in the
    initialization of shaders, and each time Nvidia GPU use is turned off.
    */
    public static void
    setDefaultTextureForFixedFunctionOpenGL(CGprogram pixelShader)
    {
        CGparameter param;

        JoglRenderer.enableNvidiaCgProfiles();
        CgGL.cgGLBindProgram(pixelShader);
        param = CgGL.cgGetNamedParameter(pixelShader, "textureMap");
        CgGL.cgGLEnableTextureParameter(param);
        JoglRenderer.disableNvidiaCgProfiles();
    }

}

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