pipeline.java

JAVA3D矩陈的相关类

    abstract void updateTexture3DSubImage(Context ctx,
            int level,
            int xoffset, int yoffset, int zoffset,
            int textureFormat, int imageFormat,
            int imgXoffset, int imgYoffset, int imgZoffset,
            int tilew, int tileh,
            int width, int height, int depth,
            int imageDataType, Object imageData, boolean useAutoMipMap);

    abstract void updateTexture3DLodRange(Context ctx,
            int baseLevel, int maximumLevel,
            float minimumLod, float maximumLod);

    abstract void updateTexture3DLodOffset(Context ctx,
            float lodOffsetX, float lodOffsetY,
            float lodOffsetZ);

    abstract void updateTexture3DBoundary(Context ctx,
            int boundaryModeS, int boundaryModeT,
            int boundaryModeR, float boundaryRed,
            float boundaryGreen, float boundaryBlue,
            float boundaryAlpha);

    abstract void updateTexture3DFilterModes(Context ctx,
            int minFilter, int magFilter);

    abstract void updateTexture3DSharpenFunc(Context ctx,
            int numSharpenTextureFuncPts,
            float[] sharpenTextureFuncPts);

    abstract void updateTexture3DFilter4Func(Context ctx,
            int numFilter4FuncPts,
            float[] filter4FuncPts);

    abstract void updateTexture3DAnisotropicFilter(Context ctx, float degree);


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

    //
    // TextureCubeMapRetained methods
    //

    abstract void bindTextureCubeMap(Context ctx, int objectId, boolean enable);

    abstract void updateTextureCubeMapImage(Context ctx,
            int face, int numLevels, int level,
            int textureFormat, int imageFormat,
            int width, int height,
            int boundaryWidth,
            int imageDataType, Object imageData, boolean useAutoMipMap);
    
    abstract void updateTextureCubeMapSubImage(Context ctx,
            int face, int level, int xoffset, int yoffset,
            int textureFormat, int imageFormat,
            int imgXOffset, int imgYOffset,
            int tilew, int width, int height,
            int imageDataType, Object imageData, boolean useAutoMipMap);
    
    abstract void updateTextureCubeMapLodRange(Context ctx,
            int baseLevel, int maximumLevel,
            float minimumLod, float maximumLod);

    abstract void updateTextureCubeMapLodOffset(Context ctx,
            float lodOffsetX, float lodOffsetY,
            float lodOffsetZ);

    abstract void updateTextureCubeMapBoundary(Context ctx,
            int boundaryModeS, int boundaryModeT,
            float boundaryRed, float boundaryGreen,
            float boundaryBlue, float boundaryAlpha);

    abstract void updateTextureCubeMapFilterModes(Context ctx,
            int minFilter, int magFilter);

    abstract void updateTextureCubeMapSharpenFunc(Context ctx,
            int numSharpenTextureFuncPts,
            float[] sharpenTextureFuncPts);

    abstract void updateTextureCubeMapFilter4Func(Context ctx,
            int numFilter4FuncPts,
            float[] filter4FuncPts);

    abstract void updateTextureCubeMapAnisotropicFilter(Context ctx, float degree);

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

    //
    // MasterControl methods
    //

    // Method to return the AWT object
    abstract long getAWT();

    // Method to initialize the native J3D library
    abstract boolean initializeJ3D(boolean disableXinerama);

    // Maximum lights supported by the native API 
    abstract int getMaximumLights();


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

    //
    // Canvas3D methods - native wrappers
    //

    // This is the native method for creating the underlying graphics context.
    abstract Context createNewContext(Canvas3D cv, long display, Drawable drawable,
            long fbConfig, Context shareCtx, boolean isSharedCtx,
            boolean offScreen,
            boolean glslLibraryAvailable,
            boolean cgLibraryAvailable);

    abstract void createQueryContext(Canvas3D cv, long display, Drawable drawable,
            long fbConfig, boolean offScreen, int width, int height,
            boolean glslLibraryAvailable,
            boolean cgLibraryAvailable);

    // This is the native for creating offscreen buffer
    abstract Drawable createOffScreenBuffer(Canvas3D cv, Context ctx, long display, long fbConfig, int width, int height);

    abstract void destroyOffScreenBuffer(Canvas3D cv, Context ctx, long display, long fbConfig, Drawable drawable);

    // This is the native for reading the image from the offscreen buffer
    abstract void readOffScreenBuffer(Canvas3D cv, Context ctx, int format, int type, Object data, int width, int height);

    // The native method for swapBuffers
    abstract int swapBuffers(Canvas3D cv, Context ctx, long dpy, Drawable drawable);

    // notify D3D that Canvas is resize
    abstract int resizeD3DCanvas(Canvas3D cv, Context ctx);

    // notify D3D to toggle between FullScreen and window mode
    abstract int toggleFullScreenMode(Canvas3D cv, Context ctx);

    // native method for setting Material when no material is present
    abstract void updateMaterialColor(Context ctx, float r, float g, float b, float a);

    abstract void destroyContext(long display, Drawable drawable, Context ctx);

    // This is the native method for doing accumulation.
    abstract void accum(Context ctx, float value);

    // This is the native method for doing accumulation return.
    abstract void accumReturn(Context ctx);

    // This is the native method for clearing the accumulation buffer.
    abstract void clearAccum(Context ctx);

    // This is the native method for getting the number of lights the underlying
    // native library can support.
    abstract int getNumCtxLights(Context ctx);

    // Native method for decal 1st child setup
    abstract boolean decal1stChildSetup(Context ctx);

    // Native method for decal nth child setup
    abstract void decalNthChildSetup(Context ctx);

    // Native method for decal reset
    abstract void decalReset(Context ctx, boolean depthBufferEnable);

    // Native method for decal reset
    abstract void ctxUpdateEyeLightingEnable(Context ctx, boolean localEyeLightingEnable);

    // The following three methods are used in multi-pass case

    // native method for setting blend color
    abstract void setBlendColor(Context ctx, float red, float green,
            float blue, float alpha);

    // native method for setting blend func
    abstract void setBlendFunc(Context ctx, int src, int dst);

    // native method for setting fog enable flag
    abstract void setFogEnableFlag(Context ctx, boolean enableFlag);

    // Setup the full scene antialising in D3D and ogl when GL_ARB_multisamle supported
    abstract void setFullSceneAntialiasing(Context ctx, boolean enable);

    abstract void setGlobalAlpha(Context ctx, float alpha);

    // Native method to update separate specular color control
    abstract void updateSeparateSpecularColorEnable(Context ctx, boolean control);

    // Initialization for D3D when scene begin
    abstract void beginScene(Context ctx);
    abstract void endScene(Context ctx);

    // True under Solaris,
    // False under windows when display mode <= 8 bit
    abstract boolean validGraphicsMode();

    // native method for setting light enables
    abstract void setLightEnables(Context ctx, long enableMask, int maxLights);

    // native method for setting scene ambient
    abstract void setSceneAmbient(Context ctx, float red, float green, float blue);

    // native method for disabling fog
    abstract void disableFog(Context ctx);

    // native method for disabling modelClip
    abstract void disableModelClip(Context ctx);

    // native method for setting default RenderingAttributes
    abstract void resetRenderingAttributes(Context ctx,
            boolean depthBufferWriteEnableOverride,
            boolean depthBufferEnableOverride);

    // native method for setting default texture
    abstract void resetTextureNative(Context ctx, int texUnitIndex);

    // native method for activating a particular texture unit
    abstract void activeTextureUnit(Context ctx, int texUnitIndex);

    // native method for setting default TexCoordGeneration
    abstract void resetTexCoordGeneration(Context ctx);

    // native method for setting default TextureAttributes
    abstract void resetTextureAttributes(Context ctx);

    // native method for setting default PolygonAttributes
    abstract void resetPolygonAttributes(Context ctx);

    // native method for setting default LineAttributes
    abstract void resetLineAttributes(Context ctx);

    // native method for setting default PointAttributes
    abstract void resetPointAttributes(Context ctx);

    // native method for setting default TransparencyAttributes
    abstract void resetTransparency(Context ctx, int geometryType,
            int polygonMode, boolean lineAA,
            boolean pointAA);

    // native method for setting default ColoringAttributes
    abstract void resetColoringAttributes(Context ctx,
            float r, float g,
            float b, float a,
            boolean enableLight);

    /**
     *  This native method makes sure that the rendering for this canvas
     *  gets done now.
     */
    abstract void syncRender(Context ctx, boolean wait);

    // The native method that sets this ctx to be the current one
    abstract boolean useCtx(Context ctx, long display, Drawable drawable);

    // Optionally release the context. A pipeline may override this and
    // returns true if the context was released.
    boolean releaseCtx(Context ctx, long dpy) {
        return false;
    }
    
    abstract void clear(Context ctx, float r, float g, float b, boolean clearStencil);
    
    abstract void textureFillBackground(Context ctx, float texMinU, float texMaxU, float texMinV, float texMaxV,
            float mapMinX, float mapMaxX, float mapMinY, float mapMaxY, boolean useBiliearFilter);
    
    abstract void textureFillRaster(Context ctx, float texMinU, float texMaxU, float texMinV, float texMaxV,
            float mapMinX, float mapMaxX, float mapMinY, float mapMaxY, float mapZ, float alpha, boolean useBiliearFilter);

    abstract void executeRasterDepth(Context ctx, float posX, float posY, float posZ, 
            int srcOffsetX, int srcOffsetY, int rasterWidth, int rasterHeight, int depthWidth, int depthHeight, 
            int depthType, Object depthData); 
    
        // The native method for setting the ModelView matrix.
    abstract void setModelViewMatrix(Context ctx, double[] viewMatrix, double[] modelMatrix);

    // The native method for setting the Projection matrix.
    abstract void setProjectionMatrix(Context ctx, double[] projMatrix);

    // The native method for setting the Viewport.
    abstract void setViewport(Context ctx, int x, int y, int width, int height);

    // used for display Lists
    abstract void newDisplayList(Context ctx, int displayListId);
    abstract void endDisplayList(Context ctx);
    abstract void callDisplayList(Context ctx, int id, boolean isNonUniformScale);

    abstract void freeDisplayList(Context ctx, int id);
    abstract void freeTexture(Context ctx, int id);

    abstract void texturemapping(Context ctx,
            int px, int py,
            int xmin, int ymin, int xmax, int ymax,
            int texWidth, int texHeight,
            int rasWidth,
            int format, int objectId,
            byte[] image,
            int winWidth, int winHeight);

    abstract boolean initTexturemapping(Context ctx, int texWidth,
            int texHeight, int objectId);


    // Set internal render mode to one of FIELD_ALL, FIELD_LEFT or
    // FIELD_RIGHT.  Note that it is up to the caller to ensure that
    // stereo is available before setting the mode to FIELD_LEFT or
    // FIELD_RIGHT.  The boolean isTRUE for double buffered mode, FALSE
    // foe single buffering.
    abstract void setRenderMode(Context ctx, int mode, boolean doubleBuffer);

    // Set glDepthMask.
    abstract void setDepthBufferWriteEnable(Context ctx, boolean mode);


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

    //
    // Canvas3D / GraphicsConfigTemplate3D methods - logic dealing with
    // native graphics configuration or drawing surface
    //

    // Return a graphics config based on the one passed in. Note that we can
    // assert that the input config is non-null and was created from a
    // GraphicsConfigTemplate3D.
    // This method must return a valid GraphicsConfig, or else it must throw
    // an exception if one cannot be returned.
    abstract GraphicsConfiguration getGraphicsConfig(GraphicsConfiguration gconfig);

    // Get the native FBconfig pointer
    abstract long getFbConfig(GraphicsConfigInfo gcInfo);

    // Get best graphics config from pipeline
    abstract GraphicsConfiguration getBestConfiguration(GraphicsConfigTemplate3D gct,
            GraphicsConfiguration[] gc);

    // Determine whether specified graphics config is supported by pipeline
    abstract boolean isGraphicsConfigSupported(GraphicsConfigTemplate3D gct,
            GraphicsConfiguration gc);

    // Methods to get actual capabilities from Canvas3D
    abstract boolean hasDoubleBuffer(Canvas3D cv);
    abstract boolean hasStereo(Canvas3D cv);
    abstract int getStencilSize(Canvas3D cv);
    abstract boolean hasSceneAntialiasingMultisample(Canvas3D cv);
    abstract boolean hasSceneAntialiasingAccum(Canvas3D cv);
    
    // Methods to get native WS display and screen
    abstract long getDisplay();
    abstract int getScreen(GraphicsDevice graphicsDevice);


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

    //
    // DrawingSurfaceObject methods
    //

    // Method to construct a new DrawingSurfaceObject
    abstract DrawingSurfaceObject createDrawingSurfaceObject(Canvas3D cv);

    // Method to free the drawing surface object
    abstract void freeDrawingSurface(Canvas3D cv, DrawingSurfaceObject drawingSurfaceObject);

    // Method to free the native drawing surface object
    abstract void freeDrawingSurfaceNative(Object o);

}