/*
* Copyright 1997-2008 Sun Microsystems, Inc. All Rights Reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Sun designates this
* particular file as subject to the "Classpath" exception as provided
* by Sun in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
* CA 95054 USA or visit www.sun.com if you need additional information or
* have any questions.
*
*/
package javax.media.j3d;
import java.awt.AWTEvent;
import java.awt.Canvas;
import java.awt.Container;
import java.awt.Dimension;
import java.awt.Frame;
import java.awt.Graphics;
import java.awt.GraphicsConfiguration;
import java.awt.GraphicsDevice;
import java.awt.GraphicsEnvironment;
import java.awt.IllegalComponentStateException;
import java.awt.Point;
import java.awt.Window;
import java.awt.image.BufferedImage;
import java.util.ArrayList;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.Map;
import javax.vecmath.Color3f;
import javax.vecmath.Point2d;
import javax.vecmath.Point3d;
import javax.vecmath.Vector4d;
/**
* The Canvas3D class provides a drawing canvas for 3D rendering. It
* is used either for on-screen rendering or off-screen rendering.
* Canvas3D is an extension of the AWT Canvas class that users may
* further subclass to implement additional functionality.
* <p>
* The Canvas3D object extends the Canvas object to include
* 3D-related information such as the size of the canvas in pixels,
* the Canvas3D's location, also in pixels, within a Screen3D object,
* and whether or not the canvas has stereo enabled.
* <p>
* Because all Canvas3D objects contain a
* reference to a Screen3D object and because Screen3D objects define
* the size of a pixel in physical units, Java 3D can convert a Canvas3D
* size in pixels to a physical world size in meters. It can also
* determine the Canvas3D's position and orientation in the
* physical world.
* <p>
* <b>On-screen Rendering vs. Off-screen Rendering</b>
* <p>
* The Canvas3D class is used either for on-screen rendering or
* off-screen rendering.
* On-screen Canvas3Ds are added to AWT or Swing Container objects
* like any other canvas. Java 3D automatically and continuously
* renders to all on-screen canvases that are attached to an active
* View object. On-screen Canvas3Ds can be either single or double
* buffered and they can be either stereo or monoscopic.
* <p>
* Off-screen Canvas3Ds must not be added to any Container. Java 3D
* renders to off-screen canvases in response to the
* <code>renderOffScreenBuffer</code> method. Off-screen Canvas3Ds
* are single buffered. However, on many systems, the actual
* rendering is done to an off-screen hardware buffer or to a 3D
* library-specific buffer and only copied to the off-screen buffer of
* the Canvas when the rendering is complete, at "buffer swap" time.
* Off-screen Canvas3Ds are monoscopic.
* <p>
* The setOffScreenBuffer method sets the off-screen buffer for this
* Canvas3D. The specified image is written into by the Java 3D renderer.
* The size of the specified ImageComponent determines the size, in
* pixels, of this Canvas3D - the size inherited from Component is
* ignored. Note that the size, physical width, and physical height of the
* associated Screen3D must be set
* explicitly prior to rendering. Failure to do so will result in an
* exception.
* <p>
* The getOffScreenBuffer method retrieves the off-screen
* buffer for this Canvas3D.
* <p>
* The renderOffScreenBuffer method schedules the rendering of a frame
* into this Canvas3D's off-screen buffer. The rendering is done from
* the point of view of the View object to which this Canvas3D has been
* added. No rendering is performed if this Canvas3D object has not been
* added to an active View. This method does not wait for the rendering
* to actually happen. An application that wishes to know when the
* rendering is complete must either subclass Canvas3D and
* override the postSwap method, or call waitForOffScreenRendering.
* <p>
* The setOfScreenLocation methods set the location of this off-screen
* Canvas3D. The location is the upper-left corner of the Canvas3D
* relative to the upper-left corner of the corresponding off-screen
* Screen3D. The function of these methods is similar to that of
* Component.setLocation for on-screen Canvas3D objects. The default
* location is (0,0).
* <p>
* <b>Accessing and Modifying an Eye's Image Plate Position</b>
* <p>
* A Canvas3D object provides sophisticated applications with access
* to the eye's position information in head-tracked, room-mounted
* runtime environments. It also allows applications to manipulate
* the position of an eye relative to an image plate in non-head-tracked
* runtime environments.
* <p>
* The setLeftManualEyeInImagePlate and setRightManualEyeInImagePlate
* methods set the position of the manual left and right eyes in image
* plate coordinates. These values determine eye placement when a head
* tracker is not in use and the application is directly controlling the
* eye position in image plate coordinates. In head-tracked mode or
* when the windowEyepointPolicy is RELATIVE_TO_FIELD_OF_VIEW or
* RELATIVE_TO_COEXISTENCE, this
* value is ignored. When the windowEyepointPolicy is RELATIVE_TO_WINDOW,
* only the Z value is used.
* <p>
* The getLeftEyeInImagePlate, getRightEyeInImagePlate, and
* getCenterEyeInImagePlate methods retrieve the actual position of the
* left eye, right eye, and center eye in image plate coordinates and
* copy that value into the object provided. The center eye is the
* fictional eye half-way between the left and right eye. These three
* values are a function of the windowEyepointPolicy, the tracking
* enable flag, and the manual left, right, and center eye positions.
* <p>
* <b>Monoscopic View Policy</b>
* <p>
* The setMonoscopicViewPolicy and getMonoscopicViewPolicy methods
* set and retrieve the policy regarding how Java 3D generates monoscopic
* view. If the policy is set to View.LEFT_EYE_VIEW, the view generated
* corresponds to the view as seen from the left eye. If set to
* View.RIGHT_EYE_VIEW, the view generated corresponds to the view as
* seen from the right eye. If set to View.CYCLOPEAN_EYE_VIEW, the view
* generated corresponds to the view as seen from the "center eye," the
* fictional eye half-way between the left and right eye. The default
* monoscopic view policy is View.CYCLOPEAN_EYE_VIEW.
* <p>
* <b>Immediate Mode Rendering</b>
* <p>
* Pure immediate-mode rendering provides for those applications and
* applets that do not want Java 3D to do any automatic rendering of
* the scene graph. Such applications may not even wish to build a
* scene graph to represent their graphical data. However, they use
* Java 3D's attribute objects to set graphics state and Java 3D's
* geometric objects to render geometry.
* <p>
* A pure immediate mode application must create a minimal set of
* Java 3D objects before rendering. In addition to a Canvas3D object,
* the application must create a View object, with its associated
* PhysicalBody and PhysicalEnvironment objects, and the following
* scene graph elements: a VirtualUniverse object, a high-resolution
* Locale object, a BranchGroup node object, a TransformGroup node
* object with associated transform, and a ViewPlatform
* leaf node object that defines the position and orientation within
* the virtual universe that generates the view.
* <p>
* In immediate mode, all rendering is done completely under user
* control. It is necessary for the user to clear the 3D canvas,
* render all geometry, and swap the buffers. Additionally,
* rendering the right and left eye for stereo viewing becomes the
* sole responsibility of the application. In pure immediate mode,
* the user must stop the Java 3D renderer, via the
* Canvas3D object <code>stopRenderer</code> method, prior to adding the
* Canvas3D object to an active View object (that is, one that is
* attached to a live ViewPlatform object).
* <p>
* Other Canvas3D methods related to immediate mode rendering are:
* <p>
* <ul>
* <code>getGraphicsContext3D</code> retrieves the immediate-mode
* 3D graphics context associated with this Canvas3D. It creates a
* new graphics context if one does not already exist.
* <p>
* <code>getGraphics2D</code> retrieves the
* 2D graphics object associated with this Canvas3D. It creates a
* new 2D graphics object if one does not already exist.
* <p>
* <code>swap</code> synchronizes and swaps buffers on a
* double-buffered canvas for this Canvas3D object. This method
* should only be called if the Java 3D renderer has been stopped.
* In the normal case, the renderer automatically swaps
* the buffer.
* </ul>
*
* <p>
* <b>Mixed Mode Rendering</b>
* <p>
* Mixing immediate mode and retained or compiled-retained mode
* requires more structure than pure immediate mode. In mixed mode,
* the Java 3D renderer is running continuously, rendering the scene
* graph into the canvas.
*
* <p>
* Canvas3D methods related to mixed mode rendering are:
*
* <p>
* <ul>
* <code>preRender</code> called by the Java 3D rendering loop after
* clearing the canvas and before any rendering has been done for
* this frame.
* <p>
* <code>postRender</code> called by the Java 3D rendering loop after
* completing all rendering to the canvas for this frame and before
* the buffer swap.
* <p>
* <code>postSwap</code> called by the Java 3D rendering loop after
* completing all rendering to the canvas, and all other canvases
* associated with this view, for this frame following the
* buffer swap.
* <p>
* <code>renderField</code> called by the Java 3D rendering loop
* during the execution of the rendering loop. It is called once
* for each field (i.e., once per frame on a mono system or once
* each for the right eye and left eye on a two-pass stereo system.
* </ul>
* <p>
* The above callback methods are called by the Java 3D rendering system
* and should <i>not</i> be called by an application directly.
*
* <p>
* The basic Java 3D <i>stereo</i> rendering loop,
* executed for each Canvas3D, is as follows:
* <ul><pre>
* clear canvas (both eyes)
* call preRender() // user-supplied method
* set left eye view
* render opaque scene graph objects
* call renderField(FIELD_LEFT) // user-supplied method
* render transparent scene graph objects
* set right eye view
* render opaque scene graph objects again
* call renderField(FIELD_RIGHT) // user-supplied method
* render transparent scene graph objects again
* call postRender() // user-supplied method
* synchronize and swap buffers
* call postSwap() // user-supplied method
* </pre></ul>
* <p>
* The basic Java 3D <i>monoscopic</i> rendering loop is as follows:
* <ul><pre>
* clear canvas
* call preRender() // user-supplied method
* set view
* render opaque scene graph objects
* call renderField(FIELD_ALL) // user-supplied method
* render transparent scene graph objects
* call postRender() // user-supplied method
* synchronize and swap buffers
* call postSwap() // user-supplied method
* </pre></ul>
* <p>
* In both cases, the entire loop, beginning with clearing the canvas
* and ending with swapping the buffers, defines a frame. The application
* is given the opportunity to render immediate-mode geometry at any of
* the clearly identified spots in the rendering loop. A user specifies
* his or her own rendering methods by extending the Canvas3D class and
* overriding the preRender, postRender, postSwap, and/or renderField
* methods.
* Updates to live Geometry, Texture, and ImageComponent objects
* in the scene graph are not allowed from any of these callback
* methods.
*
* <p>
* <b>Serialization</b>
* <p>
* Canvas3D does <i>not</i> support serialization. An attempt to
* serialize a Canvas3D object will result in an
* UnsupportedOperationException being thrown.
*
* <p>
* <b>Additional Information</b>
* <p>
* For more information, see the
* <a href="doc-files/intro.html">Introduction to the Java 3D API</a> and
* <a href="doc-files/ViewModel.html">View Model</a>
* documents.
*
* @see Screen3D
* @see View
* @see GraphicsContext3D
*/
public class Canvas3D extends Canvas {
/**
* Specifies the left field of a field-sequential stereo rendering loop.
* A left field always precedes a right field.
*/
public static final int FIELD_LEFT = 0;
/**
* Specifies the right field of a field-sequential stereo rendering loop.
* A right field always follows a left field.
*/
public static final int FIELD_RIGHT = 1;
/**
* Specifies a single-field rendering loop.
*/
public static final int FIELD_ALL = 2;
//
// The following constants are bit masks to specify which of the node
// components are dirty and need updates.
//
// Values for the geometryType field.
static final int POLYGONATTRS_DIRTY = 0x01;
static final int LINEATTRS_DIRTY = 0x02;
static final int POINTATTRS_DIRTY = 0x04;
static final int MATERIAL_DIRTY = 0x08;
static final int TRANSPARENCYATTRS_DIRTY = 0x10;
static final int COLORINGATTRS_DIRTY = 0x20;
// Values for lightbin, env set, texture, texture setting etc.
static final int LIGHTBIN_DIRTY = 0x40;
static final int LIGHTENABLES_DIRTY = 0x80;
static final int AMBIENTLIGHT_DIRTY = 0x100;
static final int ATTRIBUTEBIN_DIRTY = 0x200;
static final int TEXTUREBIN_DIRTY = 0x400;
static final int TEXTUREATTRIBUTES_DIRTY = 0x800;
static final int RENDERMOLECULE_DIRTY = 0x1000;
static final int FOG_DIRTY = 0x2000;
static final int MODELCLIP_DIRTY = 0x4000;
static final int VIEW_MATRIX_DIRTY = 0x8000;
// static final int SHADER_DIRTY = 0x10000; Not ready for this yet -- JADA
//
// Flag that indicates whether this Canvas3D is an off-screen Canvas3D
//
boolean offScreen = false;
//
// Issue 131: Flag that indicates whether this Canvas3D is a manually
// rendered Canvas3D (versus an automatically rendered Canvas3D).
//
// NOTE: manualRendering only applies to off-screen Canvas3Ds at this time.
// We have no plans to ever change this, but if we do, it might be necessary
// to determine which, if any, of the uses of "manualRendering" should be
// changed to "manualRendering&&offScreen"
//
boolean manualRendering = false;
// user specified offScreen Canvas location
Point offScreenCanvasLoc;
// user specified offScreen Canvas dimension
Dimension offScreenCanvasSize;
//
// Flag that indicates whether off-screen rendering is in progress or not
//
volatile boolean offScreenRendering = false;
//
// Flag that indicates we are waiting for an off-screen buffer to be
// created or destroyed by the Renderer.
//
volatile boolean offScreenBufferPending = false;
//
// ImageComponent used for off-screen rendering
//
ImageComponent2D offScreenBuffer = null;
// flag that indicates whether this canvas will use shared context
boolean useSharedCtx = true;
//
// Read-only flag that indicates whether stereo is supported for this
// canvas. This is always false for off-screen canvases.
//
boolean stereoAvailable;
//
// Flag to enable stereo rendering, if allowed by the
// stereoAvailable flag.
//
boolean stereoEnable = true;
//
// This flag is set when stereo mode is both enabled and
// available. Code that looks at stereo mode should use this
// flag.
//
boolean useStereo;
// Indicate whether it is left or right stereo pass currently
boolean rightStereoPass = false;
//
// Specifies how Java 3D generates monoscopic view
// (LEFT_EYE_VIEW, RIGHT_EYE_VIEW, or CYCLOPEAN_EYE_VIEW).
//
int monoscopicViewPolicy = View.CYCLOPEAN_EYE_VIEW;
// User requested stencil size
int requestedStencilSize;
// Actual stencil size return for this canvas
int actualStencilSize;
// True if stencil buffer is available for user
boolean userStencilAvailable;
// True if stencil buffer is available for system ( decal )
boolean systemStencilAvailable;
//
// Read-only flag that indicates whether double buffering is supported
// for this canvas. This is always false for off-screen canvases.
//
boolean doubleBufferAvailable;
//
// Flag to enable double buffered rendering, if allowed by the
// doubleBufferAvailable flag.
//
boolean doubleBufferEnable = true;
//
// This flag is set when doubleBuffering is both enabled and
// available Code that enables or disables double buffering should
// use this flag.
//
boolean useDoubleBuffer;
//
// Read-only flag that indicates whether scene antialiasing
// is supported for this canvas.
//
boolean sceneAntialiasingAvailable;
boolean sceneAntialiasingMultiSamplesAvailable;
// Use to see whether antialiasing is already set
private boolean antialiasingSet = false;
//
// Read-only flag that indicates the size of the texture color
// table for this canvas. A value of 0 indicates that the texture
// color table is not supported.
//
int textureColorTableSize;
// number of active/enabled texture unit
int numActiveTexUnit = 0;
// index iof last enabled texture unit
int lastActiveTexUnit = -1;
// True if shadingLanguage is supported, otherwise false.
boolean shadingLanguageGLSL = false;
// Query properties
J3dQueryProps queryProps;
// Flag indicating a fatal rendering error of some sort
private boolean fatalError = false;
//
// The positions of the manual left and right eyes in image-plate
// coordinates.
// By default, we will use the center of the screen for X and Y values
// (X values are adjusted for default eye separation), and
// 0.4572 meters (18 inches) for the Z value.
// These match defaults elsewhere in the system.
//
Point3d leftManualEyeInImagePlate = new Point3d(0.142, 0.135, 0.4572);
Point3d rightManualEyeInImagePlate = new Point3d(0.208, 0.135, 0.4572);
//
// View that is attached to this Canvas3D.
//
View view = null;
// View waiting to be set
View pendingView;
//
// View cache for this canvas and its associated view.
//
CanvasViewCache canvasViewCache = null;
// Issue 109: View cache for this canvas, for computing view frustum planes
CanvasViewCache canvasViewCacheFrustum = null;
// Since multiple renderAtomListInfo, share the same vecBounds
// we want to do the intersection test only once per renderAtom
// this flag is set to true after the first intersect and set to
// false during checkForCompaction in renderBin
boolean raIsVisible = false;
RenderAtom ra = null;
// Stereo related field has changed.
static final int STEREO_DIRTY = 0x01;
// MonoscopicViewPolicy field has changed.
static final int MONOSCOPIC_VIEW_POLICY_DIRTY = 0x02;
// Left/right eye in image plate field has changed.
static final int EYE_IN_IMAGE_PLATE_DIRTY = 0x04;
// Canvas has moved/resized.
static final int MOVED_OR_RESIZED_DIRTY = 0x08;
// Canvas Background changed (this may affect doInfinite flag)
static final int BACKGROUND_DIRTY = 0x10;
// Canvas Background Image changed
static final int BACKGROUND_IMAGE_DIRTY = 0x20;
// Mask that indicates this Canvas view dependence info. has changed,
// and CanvasViewCache may need to recompute the final view matries.
static final int VIEW_INFO_DIRTY = (STEREO_DIRTY |
MONOSCOPIC_VIEW_POLICY_DIRTY |
EYE_IN_IMAGE_PLATE_DIRTY |
MOVED_OR_RESIZED_DIRTY |
BACKGROUND_DIRTY |
BACKGROUND_IMAGE_DIRTY);
// Issue 163: Array of dirty bits is used because the Renderer and
// RenderBin run asynchronously. Now that they each have a separate
// instance of CanvasViewCache (due to the fix for Issue 109), they
// need separate dirty bits. Array element 0 is used for the Renderer and
// element 1 is used for the RenderBin.
static final int RENDERER_DIRTY_IDX = 0;
static final int RENDER_BIN_DIRTY_IDX = 1;
int[] cvDirtyMask = new int[2];
// This boolean informs the J3DGraphics2DImpl that the window is resized
boolean resizeGraphics2D = true;
//
// This boolean allows an application to start and stop the render
// loop on this canvas.
//
volatile boolean isRunning = true;
// This is used by MasterControl only. MC relay on this in a
// single loop to set renderer thread. During this time,
// the isRunningStatus can't change by user thread.
volatile boolean isRunningStatus = true;
// This is true when the canvas is ready to be rendered into
boolean active = false;
// This is true when the canvas is visible
boolean visible = false;
// This is true if context need to recreate
boolean ctxReset = true;
// The Screen3D that corresponds to this Canvas3D
Screen3D screen = null;
// Flag to indicate that image is render completely
// so swap is valid.
boolean imageReady = false;
// The 3D Graphics context used for immediate mode rendering
// into this canvas.
GraphicsContext3D graphicsContext3D = null;
boolean waiting = false;
boolean swapDone = false;
GraphicsConfiguration graphicsConfiguration;
// The Java 3D Graphics2D object used for Java2D/AWT rendering
// into this Canvas3D
J3DGraphics2DImpl graphics2D = null;
// Lock used to synchronize the creation of the 2D and 3D
// graphics context objects
Object gfxCreationLock = new Object();
// The source of the currently loaded localToVWorld for this Canvas3D
// (used to only update the model matrix when it changes)
// Transform3D localToVWorldSrc = null;
// The current vworldToEc Transform
Transform3D vworldToEc = new Transform3D();
// The view transform (VPC to EC) for the current eye.
// NOTE that this is *read-only*
Transform3D vpcToEc;
// Opaque object representing the underlying drawable (window). This
// is defined by the Pipeline.
Drawable drawable = null;
// graphicsConfigTable is a static hashtable which allows getBestConfiguration()
// in NativeConfigTemplate3D to map a GraphicsConfiguration to the pointer
// to the actual GLXFBConfig that glXChooseFBConfig() returns. The Canvas3D
// doesn't exist at the time getBestConfiguration() is called, and
// X11GraphicsConfig neither maintains this pointer nor provides a public
// constructor to allow Java 3D to extend it.
static Hashtable<GraphicsConfiguration,GraphicsConfigInfo> graphicsConfigTable =
new Hashtable<GraphicsConfiguration,GraphicsConfigInfo>();
// The native graphics version, vendor, and renderer information
String nativeGraphicsVersion = "<UNKNOWN>";
String nativeGraphicsVendor = "<UNKNOWN>";
String nativeGraphicsRenderer = "<UNKNOWN>";
boolean firstPaintCalled = false;
// This reflects whether or not this canvas has seen an addNotify. It is
// forced to true for off-screen canvases
boolean added = false;
// Flag indicating whether addNotify has been called (so we don't process it twice).
private boolean addNotifyCalled = false;
// This is the id for the underlying graphics context structure.
Context ctx = null;
// since the ctx id can be the same as the previous one,
// we need to keep a time stamp to differentiate the contexts with the
// same id
volatile long ctxTimeStamp = 0;
// The current context setting for local eye lighting
boolean ctxEyeLightingEnable = false;
// This AppearanceRetained Object refelects the current state of this
// canvas. It is used to optimize setting of attributes at render time.
AppearanceRetained currentAppear = new AppearanceRetained();
// This MaterialRetained Object refelects the current state of this canvas.
// It is used to optimize setting of attributes at render time.
MaterialRetained currentMaterial = new MaterialRetained();
/**
* The object used for View Frustum Culling
*/
CachedFrustum viewFrustum = new CachedFrustum();
/**
* The RenderBin bundle references used to decide what the underlying
* context contains.
*/
LightBin lightBin = null;
EnvironmentSet environmentSet = null;
AttributeBin attributeBin = null;
ShaderBin shaderBin = null;
RenderMolecule renderMolecule = null;
PolygonAttributesRetained polygonAttributes = null;
LineAttributesRetained lineAttributes = null;
PointAttributesRetained pointAttributes = null;
MaterialRetained material = null;
boolean enableLighting = false;
TransparencyAttributesRetained transparency = null;
ColoringAttributesRetained coloringAttributes = null;
Transform3D modelMatrix = null;
Transform3D projTrans = null;
TextureBin textureBin = null;
/**
* cached RenderBin states for lazy native states update
*/
LightRetained lights[] = null;
int frameCount[] = null;
long enableMask = -1;
FogRetained fog = null;
ModelClipRetained modelClip = null;
Color3f sceneAmbient = new Color3f();
TextureUnitStateRetained[] texUnitState = null;
/**
* These cached values are only used in Pure Immediate and Mixed Mode rendering
*/
TextureRetained texture = null;
TextureAttributesRetained texAttrs = null;
TexCoordGenerationRetained texCoordGeneration = null;
RenderingAttributesRetained renderingAttrs = null;
AppearanceRetained appearance = null;
ShaderProgramRetained shaderProgram = null;
// only used in Mixed Mode rendering
Object appHandle = null;
/**
* Dirty bit to determine if the NodeComponent needs to be re-sent
* down to the underlying API
*/
int canvasDirty = 0xffff;
// True when either one of dirtyRenderMoleculeList,
// dirtyDlistPerRinfoList, dirtyRenderAtomList size > 0
boolean dirtyDisplayList = false;
ArrayList<RenderMolecule> dirtyRenderMoleculeList = new ArrayList<RenderMolecule>();
ArrayList<RenderAtomListInfo> dirtyRenderAtomList = new ArrayList<RenderAtomListInfo>();
// List of (Rm, rInfo) pair of individual dlists that need to be rebuilt
ArrayList<Object[]> dirtyDlistPerRinfoList = new ArrayList<Object[]>();
ArrayList<Integer> displayListResourceFreeList = new ArrayList<Integer>();
ArrayList<Integer> textureIdResourceFreeList = new ArrayList<Integer>();
// an unique bit to identify this canvas
int canvasBit = 0;
// an unique number to identify this canvas : ( canvasBit = 1 << canvasId)
int canvasId = 0;
// Indicates whether the canvasId has been allocated
private boolean canvasIdAlloc = false;
// Avoid using this as lock, it cause deadlock
Object cvLock = new Object();
Object evaluateLock = new Object();
Object dirtyMaskLock = new Object();
// For D3D, instead of using the same variable in Renderer,
// each canvas has to build its own displayList.
boolean needToRebuildDisplayList = false;
// Read-only flag that indicates whether the following texture features
// are supported for this canvas.
static final int TEXTURE_3D = 0x0001;
static final int TEXTURE_COLOR_TABLE = 0x0002;
static final int TEXTURE_MULTI_TEXTURE = 0x0004;
static final int TEXTURE_COMBINE = 0x0008;
static final int TEXTURE_COMBINE_DOT3 = 0x0010;
static final int TEXTURE_COMBINE_SUBTRACT = 0x0020;
static final int TEXTURE_REGISTER_COMBINERS = 0x0040;
static final int TEXTURE_CUBE_MAP = 0x0080;
static final int TEXTURE_SHARPEN = 0x0100;
static final int TEXTURE_DETAIL = 0x0200;
static final int TEXTURE_FILTER4 = 0x0400;
static final int TEXTURE_ANISOTROPIC_FILTER = 0x0800;
static final int TEXTURE_LOD_RANGE = 0x1000;
static final int TEXTURE_LOD_OFFSET = 0x2000;
// Use by D3D to indicate using one pass Blend mode
// if Texture interpolation mode is support.
static final int TEXTURE_LERP = 0x4000;
static final int TEXTURE_NON_POWER_OF_TWO = 0x8000;
static final int TEXTURE_AUTO_MIPMAP_GENERATION = 0x10000;
int textureExtendedFeatures = 0;
// Extensions supported by the underlying canvas
//
// NOTE: we should remove EXT_BGR and EXT_ABGR when the imaging code is
// rewritten
// killed global alpha
//static final int SUN_GLOBAL_ALPHA = 0x1;
static final int EXT_ABGR = 0x2;
static final int EXT_BGR = 0x4;
static final int MULTISAMPLE = 0x8;
// The following 10 variables are set by the native
// createNewContext()/createQueryContext() methods
// Supported Extensions
int extensionsSupported = 0;
// Anisotropic Filter degree
float anisotropicDegreeMax = 1.0f;
// Texture Boundary Width Max
int textureBoundaryWidthMax = 0;
boolean multiTexAccelerated = false;
// Max number of texture coordinate sets
int maxTexCoordSets = 1;
// Max number of fixed-function texture units
int maxTextureUnits = 1;
// Max number of fragment shader texture units
int maxTextureImageUnits = 0;
// Max number of vertex shader texture units
int maxVertexTextureImageUnits = 0;
// Max number of combined shader texture units
int maxCombinedTextureImageUnits = 0;
// Max number of vertex attrs (not counting coord, etc.)
int maxVertexAttrs = 0;
// End of variables set by createNewContext()/createQueryContext()
// The total available number of texture units used by either the
// fixed-function or programmable shader pipeline.
// This is computed as: max(maxTextureUnits, maxTextureImageUnits)
int maxAvailableTextureUnits;
// Texture Width, Height Max
int textureWidthMax = 0;
int textureHeightMax = 0;
// Texture3D Width, Heigh, Depth Max
int texture3DWidthMax = -1;
int texture3DHeightMax = -1;
int texture3DDepthMax = -1;
// Cached position & size for CanvasViewCache.
// We don't want to call canvas.getxx method in Renderer
// since it will cause deadlock as removeNotify() need to get
// component lock of Canvas also and need to wait Renderer to
// finish before continue. So we invoke the method now in
// CanvasViewEventCatcher.
Point newPosition = new Point();
Dimension newSize = new Dimension();
// Remember OGL context resources to free
// before context is destroy.
// It is used when sharedCtx = false;
ArrayList<TextureRetained> textureIDResourceTable = new ArrayList<TextureRetained>(5);
// The following variables are used by the lazy download of
// states code to keep track of the set of current to be update bins
static final int LIGHTBIN_BIT = 0x0;
static final int ENVIRONMENTSET_BIT = 0x1;
static final int ATTRIBUTEBIN_BIT = 0x2;
static final int TEXTUREBIN_BIT = 0x3;
static final int RENDERMOLECULE_BIT = 0x4;
static final int TRANSPARENCY_BIT = 0x5;
static final int SHADERBIN_BIT = 0x6;
// bitmask to specify if the corresponding "bin" needs to be updated
int stateUpdateMask = 0;
// the set of current "bins" that is to be updated, the stateUpdateMask
// specifies if each bin in this set is updated or not.
Object curStateToUpdate[] = new Object[7];
/**
* The list of lights that are currently being represented in the native
* graphics context.
*/
LightRetained[] currentLights = null;
/**
* Flag to override RenderAttributes.depthBufferWriteEnable
*/
boolean depthBufferWriteEnableOverride = false;
/**
* Flag to override RenderAttributes.depthBufferEnable
*/
boolean depthBufferEnableOverride = false;
// current state of depthBufferWriteEnable
boolean depthBufferWriteEnable = true;
boolean vfPlanesValid = false;
// The event catcher for this canvas.
EventCatcher eventCatcher;
// The view event catcher for this canvas.
private CanvasViewEventCatcher canvasViewEventCatcher;
// The top-level parent window for this canvas.
private Window windowParent;
// Issue 458 - list of all parent containers for this canvas
// (includes top-level parent window)
private LinkedList<Container> containerParentList = new LinkedList<Container>();
// flag that indicates if light has changed
boolean lightChanged = false;
// resource control object
DrawingSurfaceObject drawingSurfaceObject;
// true if context is valid for rendering
boolean validCtx = false;
// true if canvas is valid for rendering
boolean validCanvas = false;
// true if ctx changed between render and swap. In this case
// cv.canvasDirty flag will not reset in Renderer.
// This case happen when GraphicsContext3D invoked doClear()
// and canvas removeNotify() called while Renderer is running
boolean ctxChanged = false;
// Default graphics configuration
private static GraphicsConfiguration defaultGcfg = null;
// Returns default graphics configuration if user passes null
// into the Canvas3D constructor
private static synchronized GraphicsConfiguration defaultGraphicsConfiguration() {
if (defaultGcfg == null) {
GraphicsConfigTemplate3D template = new GraphicsConfigTemplate3D();
defaultGcfg = GraphicsEnvironment.getLocalGraphicsEnvironment().
getDefaultScreenDevice().getBestConfiguration(template);
}
return defaultGcfg;
}
// Returns true if this is a valid graphics configuration, obtained
// via a GraphicsConfigTemplate3D.
private static boolean isValidConfig(GraphicsConfiguration gconfig) {
// If this is a valid GraphicsConfiguration object, then it will
// be in the graphicsConfigTable
return graphicsConfigTable.containsKey(gconfig);
}
// Checks the given graphics configuration, and throws an exception if
// the config is null or invalid.
private static synchronized GraphicsConfiguration
checkForValidGraphicsConfig(GraphicsConfiguration gconfig, boolean offScreen) {
// Issue 266 - for backwards compatibility with legacy applications,
// we will accept a null GraphicsConfiguration for an on-screen Canvas3D
// only if the "allowNullGraphicsConfig" system property is set to true.
if (!offScreen && VirtualUniverse.mc.allowNullGraphicsConfig) {
if (gconfig == null) {
// Print out warning if Canvas3D is called with a
// null GraphicsConfiguration
System.err.println(J3dI18N.getString("Canvas3D7"));
System.err.println(" " + J3dI18N.getString("Canvas3D18"));
// Use a default graphics config
gconfig = defaultGraphicsConfiguration();
}
}
// Validate input graphics config
if (gconfig == null) {
throw new NullPointerException(J3dI18N.getString("Canvas3D19"));
} else if (!isValidConfig(gconfig)) {
throw new IllegalArgumentException(J3dI18N.getString("Canvas3D17"));
}
return gconfig;
}
// Return the actual graphics config that will be used to construct
// the AWT Canvas. This is permitted to be non-unique or null.
private static GraphicsConfiguration getGraphicsConfig(GraphicsConfiguration gconfig) {
return Pipeline.getPipeline().getGraphicsConfig(gconfig);
}
/**
* Constructs and initializes a new Canvas3D object that Java 3D
* can render into. The following Canvas3D attributes are initialized
* to default values as shown:
* <ul>
* left manual eye in image plate : (0.142, 0.135, 0.4572)<br>
* right manual eye in image plate : (0.208, 0.135, 0.4572)<br>
* stereo enable : true<br>
* double buffer enable : true<br>
* monoscopic view policy : View.CYCLOPEAN_EYE_VIEW<br>
* off-screen mode : false<br>
* off-screen buffer : null<br>
* off-screen location : (0,0)<br>
* </ul>
*
* @param graphicsConfiguration a valid GraphicsConfiguration object that
* will be used to create the canvas. This object should not be null and
* should be created using a GraphicsConfigTemplate3D or the
* getPreferredConfiguration() method of the SimpleUniverse utility. For
* backward compatibility with earlier versions of Java 3D, a null or
* default GraphicsConfiguration will still work when used to create a
* Canvas3D on the default screen, but an error message will be printed.
* A NullPointerException or IllegalArgumentException will be thrown in a
* subsequent release.
*
* @exception IllegalArgumentException if the specified
* GraphicsConfiguration does not support 3D rendering
*/
public Canvas3D(GraphicsConfiguration graphicsConfiguration) {
this(null, checkForValidGraphicsConfig(graphicsConfiguration, false), false);
}
/**
* Constructs and initializes a new Canvas3D object that Java 3D
* can render into.
*
* @param graphicsConfiguration a valid GraphicsConfiguration object
* that will be used to create the canvas. This must be created either
* with a GraphicsConfigTemplate3D or by using the
* getPreferredConfiguration() method of the SimpleUniverse utility.
*
* @param offScreen a flag that indicates whether this canvas is
* an off-screen 3D rendering canvas. Note that if offScreen
* is set to true, this Canvas3D object cannot be used for normal
* rendering; it should not be added to any Container object.
*
* @exception NullPointerException if the GraphicsConfiguration
* is null.
*
* @exception IllegalArgumentException if the specified
* GraphicsConfiguration does not support 3D rendering
*
* @since Java 3D 1.2
*/
public Canvas3D(GraphicsConfiguration graphicsConfiguration, boolean offScreen) {
this(null, checkForValidGraphicsConfig(graphicsConfiguration, offScreen), offScreen);
}
// Private constructor only called by the two public constructors after
// they have validated the graphics config (and possibly constructed a new
// default config).
// The graphics config must be valid, unique, and non-null.
private Canvas3D(Object dummyObj1,
GraphicsConfiguration graphicsConfiguration,
boolean offScreen) {
this(dummyObj1,
graphicsConfiguration,
getGraphicsConfig(graphicsConfiguration),
offScreen);
}
// Private constructor only called by the previous private constructor.
// The graphicsConfiguration parameter is used by Canvas3D to lookup the
// graphics device and graphics template. The graphicsConfiguration2
// parameter is generated by the Pipeline from graphicsConfiguration and
// is only used to initialize the java.awt.Canvas.
private Canvas3D(Object dummyObj1,
GraphicsConfiguration graphicsConfiguration,
GraphicsConfiguration graphicsConfiguration2,
boolean offScreen) {
super(graphicsConfiguration2);
this.offScreen = offScreen;
this.graphicsConfiguration = graphicsConfiguration;
// Issue 131: Set the autoOffScreen variable based on whether this
// canvas3d implements the AutoOffScreenCanvas3D tagging interface.
// Eventually, we may replace this with an actual API.
boolean autoOffScreenCanvas3D = false;
if (this instanceof AutoOffScreenCanvas3D) {
autoOffScreenCanvas3D = true;
}
// Throw an illegal argument exception if an on-screen canvas is tagged
// as an auto-off-screen canvas
if (autoOffScreenCanvas3D && !offScreen) {
throw new IllegalArgumentException(J3dI18N.getString("Canvas3D25"));
}
// Issue 163 : Set dirty bits for both Renderer and RenderBin
cvDirtyMask[0] = VIEW_INFO_DIRTY;
cvDirtyMask[1] = VIEW_INFO_DIRTY;
GraphicsConfigInfo gcInfo = graphicsConfigTable.get(graphicsConfiguration);
requestedStencilSize = gcInfo.getGraphicsConfigTemplate3D().getStencilSize();
if (offScreen) {
// Issue 131: set manual rendering flag based on whether this is
// an auto-off-screen Canvas3D.
manualRendering = !autoOffScreenCanvas3D;
screen = new Screen3D(graphicsConfiguration, offScreen);
// QUESTION: keep a list of off-screen Screen3D objects?
// Does this list need to be grouped by GraphicsDevice?
synchronized(dirtyMaskLock) {
cvDirtyMask[0] |= MOVED_OR_RESIZED_DIRTY;
cvDirtyMask[1] |= MOVED_OR_RESIZED_DIRTY;
}
// this canvas will not receive the paint callback,
// so we need to set the necessary flags here
firstPaintCalled = true;
if (manualRendering) {
// since this canvas will not receive the addNotify
// callback from AWT, set the added flag here for
// evaluateActive to work correctly
added = true;
}
evaluateActive();
// create the rendererStructure object
//rendererStructure = new RendererStructure();
offScreenCanvasLoc = new Point(0, 0);
offScreenCanvasSize = new Dimension(0, 0);
this.setLocation(offScreenCanvasLoc);
this.setSize(offScreenCanvasSize);
newSize = offScreenCanvasSize;
newPosition = offScreenCanvasLoc;
// Issue 131: create event catchers for auto-offScreen
if (!manualRendering) {
eventCatcher = new EventCatcher(this);
canvasViewEventCatcher = new CanvasViewEventCatcher(this);
}
} else {
GraphicsDevice graphicsDevice;
graphicsDevice = graphicsConfiguration.getDevice();
eventCatcher = new EventCatcher(this);
canvasViewEventCatcher = new CanvasViewEventCatcher(this);
synchronized(VirtualUniverse.mc.deviceScreenMap) {
screen = VirtualUniverse.mc.deviceScreenMap.get(graphicsDevice);
if (screen == null) {
screen = new Screen3D(graphicsConfiguration, offScreen);
VirtualUniverse.mc.deviceScreenMap.put(graphicsDevice, screen);
}
}
}
lights = new LightRetained[VirtualUniverse.mc.maxLights];
frameCount = new int[VirtualUniverse.mc.maxLights];
for (int i=0; i<frameCount.length;i++) {
frameCount[i] = -1;
}
// Construct the drawing surface object for this Canvas3D
drawingSurfaceObject =
Pipeline.getPipeline().createDrawingSurfaceObject(this);
// Get double buffer, stereo available, scene antialiasing
// flags from graphics config
GraphicsConfigTemplate3D.getGraphicsConfigFeatures(this);
useDoubleBuffer = doubleBufferEnable && doubleBufferAvailable;
useStereo = stereoEnable && stereoAvailable;
useSharedCtx = VirtualUniverse.mc.isSharedCtx;
// Issue 131: assert that only an off-screen canvas can be demand-driven
assert (!offScreen && manualRendering) == false;
// Assert that offScreen is *not* stereo
assert (offScreen && useStereo) == false;
}
/**
* This method overrides AWT's handleEvent class...
*/
void sendEventToBehaviorScheduler(AWTEvent evt) {
ViewPlatform vp;
if ((view != null) && ((vp = view.getViewPlatform()) != null)) {
VirtualUniverse univ =
((ViewPlatformRetained)(vp.retained)).universe;
if (univ != null) {
univ.behaviorStructure.handleAWTEvent(evt);
}
}
}
/**
* Method to return whether or not the Canvas3D is recursively visible;
* that is, whether the Canas3D is currently visible on the screen. Note
* that we don't directly use isShowing() because that won't work for an
* auto-offScreen Canvas3D.
*/
private boolean isRecursivelyVisible() {
Container parent = getParent();
return isVisible() && parent != null && parent.isShowing();
}
/**
* Method to return whether the top-level Window parent is iconified
*/
private boolean isIconified() {
if (windowParent instanceof Frame) {
return (((Frame)windowParent).getExtendedState() & Frame.ICONIFIED) != 0;
}
return false;
}
// Issue 458 - evaluate this Canvas3D's visibility whenever we get a
// Window or Component Event that could change it.
void evaluateVisiblilty() {
boolean nowVisible = isRecursivelyVisible() && !isIconified();
// Only need to reevaluate and repaint if visibility has changed
if (this.visible != nowVisible) {
this.visible = nowVisible;
evaluateActive();
if (nowVisible) {
if (view != null) {
view.repaint();
}
}
}
}
/**
* This version looks for the view and notifies it.
*/
void redraw() {
if ((view != null) && active && isRunning) {
view.repaint();
}
}
/**
* Canvas3D uses the paint callback to track when it is possible to
* render into the canvas. Subclasses of Canvas3D that override this
* method need to call super.paint() in their paint method for Java 3D
* to function properly.
* @param g the graphics context
*/
@Override
public void paint(Graphics g) {
if (!firstPaintCalled && added && validCanvas &&
validGraphicsMode()) {
try {
newSize = getSize();
newPosition = getLocationOnScreen();
} catch (IllegalComponentStateException e) {
return;
}
synchronized (drawingSurfaceObject) {
drawingSurfaceObject.getDrawingSurfaceObjectInfo();
}
firstPaintCalled = true;
visible = true;
evaluateActive();
}
redraw();
}
// When this canvas is added to a frame, this notification gets called. We
// can get drawing surface information at this time. Note: we cannot get
// the X11 window id yet, unless it is a reset condition.
/**
* Canvas3D uses the addNotify callback to track when it is added
* to a container. Subclasses of Canvas3D that override this
* method need to call super.addNotify() in their addNotify() method for Java 3D
* to function properly.
*/
@Override
public void addNotify() {
// Return immediately if addNotify called twice with no removeNotify
if (addNotifyCalled) {
return;
}
addNotifyCalled = true;
// Issue 131: This method is now being called by JCanvas3D for its
// off-screen Canvas3D, so we need to handle off-screen properly here.
// Do nothing for manually-rendered off-screen canvases
if (manualRendering) {
return;
}
Renderer rdr = null;
if (isRunning && (screen != null)) {
// If there is other Canvas3D in the same screen
// rendering, stop it before JDK create new Canvas
rdr = screen.renderer;
if (rdr != null) {
VirtualUniverse.mc.postRequest(MasterControl.STOP_RENDERER, rdr);
while (!rdr.userStop) {
MasterControl.threadYield();
}
}
}
// Issue 131: Don't call super for off-screen Canvas3D
if (!offScreen) {
super.addNotify();
}
screen.addUser(this);
// Issue 458 - Add the eventCatcher as a component listener for each
// parent container in the window hierarchy
assert containerParentList.isEmpty();
windowParent = null;
Container container = this.getParent();
while (container != null) {
if (container instanceof Window) {
windowParent = (Window)container;
}
container.addComponentListener(eventCatcher);
container.addComponentListener(canvasViewEventCatcher);
containerParentList.add(container);
container = container.getParent();
}
this.addComponentListener(eventCatcher);
this.addComponentListener(canvasViewEventCatcher);
if (windowParent != null) {
windowParent.addWindowListener(eventCatcher);
}
synchronized(dirtyMaskLock) {
cvDirtyMask[0] |= MOVED_OR_RESIZED_DIRTY;
cvDirtyMask[1] |= MOVED_OR_RESIZED_DIRTY;
}
allocateCanvasId();
validCanvas = true;
added = true;
// Since we won't get a paint call for off-screen canvases, we need
// to set the first paint and visible flags here. We also need to
// call evaluateActive for the same reason.
if (offScreen) {
firstPaintCalled = true;
visible = true;
evaluateActive();
}
// In case the same canvas is removed and add back,
// we have to change isRunningStatus back to true;
if (isRunning && !fatalError) {
isRunningStatus = true;
}
ctxTimeStamp = 0;
if ((view != null) && (view.universe != null)) {
view.universe.checkForEnableEvents();
}
if (rdr != null) {
// Issue 84: Send a message to MC to restart renderer
// Note that this also obviates the need for the earlier fix to
// issue 131 which called redraw() for auto-off-screen Canvas3Ds
// (and this is a more robust fix)
VirtualUniverse.mc.postRequest(MasterControl.START_RENDERER, rdr);
while (rdr.userStop) {
MasterControl.threadYield();
}
}
}
// When this canvas is removed a frame, this notification gets called. We
// need to release the native context at this time. The underlying window
// is about to go away.
/**
* Canvas3D uses the removeNotify callback to track when it is removed
* from a container. Subclasses of Canvas3D that override this
* method need to call super.removeNotify() in their removeNotify()
* method for Java 3D to function properly.
*/
@Override
public void removeNotify() {
// Return immediately if addNotify not called first
if (!addNotifyCalled) {
return;
}
addNotifyCalled = false;
// Do nothing for manually-rendered off-screen canvases
if (manualRendering) {
return;
}
Renderer rdr = null;
if (isRunning && (screen != null)) {
// If there is other Canvas3D in the same screen
// rendering, stop it before JDK create new Canvas
rdr = screen.renderer;
if (rdr != null) {
VirtualUniverse.mc.postRequest(MasterControl.STOP_RENDERER, rdr);
while (!rdr.userStop) {
MasterControl.threadYield();
}
}
}
// Note that although renderer userStop is true,
// MasterControl can still schedule renderer to run through
// runMonotor(RUN_RENDERER_CLEANUP) which skip userStop
// thread checking.
// For non-offscreen rendering the following call will
// block waiting until all resources is free before
// continue
synchronized (drawingSurfaceObject) {
validCtx = false;
validCanvas = false;
}
removeCtx();
Pipeline.getPipeline().freeDrawingSurface(this, drawingSurfaceObject);
// Clear first paint and visible flags
firstPaintCalled = false;
visible = false;
screen.removeUser(this);
evaluateActive();
freeCanvasId();
ra = null;
graphicsContext3D = null;
ctx = null;
// must be after removeCtx() because
// it will free graphics2D textureID
graphics2D = null;
super.removeNotify();
// Release and clear.
for (Container container : containerParentList) {
container.removeComponentListener(eventCatcher);
container.removeComponentListener(canvasViewEventCatcher);
}
containerParentList.clear();
this.removeComponentListener(eventCatcher);
this.removeComponentListener(canvasViewEventCatcher);
if (eventCatcher != null) {
this.removeFocusListener(eventCatcher);
this.removeKeyListener(eventCatcher);
this.removeMouseListener(eventCatcher);
this.removeMouseMotionListener(eventCatcher);
this.removeMouseWheelListener(eventCatcher);
eventCatcher.reset();
}
if (windowParent != null) {
windowParent.removeWindowListener(eventCatcher);
windowParent.requestFocus();
}
added = false;
if (rdr != null) {
// Issue 84: Send a message to MC to restart renderer
VirtualUniverse.mc.postRequest(MasterControl.START_RENDERER, rdr);
while (rdr.userStop) {
MasterControl.threadYield();
}
}
// Fix for issue 102 removing strong reference and avoiding memory leak
// due retention of parent container
this.windowParent = null;
}
void allocateCanvasId() {
if (!canvasIdAlloc) {
canvasId = VirtualUniverse.mc.getCanvasId();
canvasBit = 1 << canvasId;
canvasIdAlloc = true;
}
}
void freeCanvasId() {
if (canvasIdAlloc) {
VirtualUniverse.mc.freeCanvasId(canvasId);
canvasBit = 0;
canvasId = 0;
canvasIdAlloc = false;
}
}
// This decides if the canvas is active
void evaluateActive() {
// Note that no need to check for isRunning, we want
// view register in order to create scheduler in pure immedite mode
// Also we can't use this as lock, otherwise there is a
// deadlock where updateViewCache get a lock of this and
// get a lock of this component. But Container
// remove will get a lock of this component follows by evaluateActive.
synchronized (evaluateLock) {
if ((visible || manualRendering) && firstPaintCalled) {
if (!active) {
active = true;
if (pendingView != null) {
pendingView.evaluateActive();
}
} else {
if ((pendingView != null) &&
!pendingView.activeStatus) {
pendingView.evaluateActive();
}
}
} else {
if (active) {
active = false;
if (view != null) {
view.evaluateActive();
}
}
}
}
if ((view != null) && (!active)) {
VirtualUniverse u = view.universe;
if ((u != null) && !u.isSceneGraphLock) {
u.waitForMC();
}
}
}
void setFrustumPlanes(Vector4d[] planes) {
if(VirtualUniverse.mc.viewFrustumCulling) {
/* System.err.println("Canvas3D.setFrustumPlanes()"); */
viewFrustum.set(planes);
}
}
/**
* Retrieve the Screen3D object that this Canvas3D is attached to.
* If this Canvas3D is an off-screen buffer, a new Screen3D object
* is created corresponding to the off-screen buffer.
* @return the 3D screen object that this Canvas3D is attached to
*/
public Screen3D getScreen3D() {
return screen;
}
/**
* Get the immediate mode 3D graphics context associated with
* this Canvas3D. A new graphics context object is created if one does
* not already exist.
* @return a GraphicsContext3D object that can be used for immediate
* mode rendering to this Canvas3D.
*/
public GraphicsContext3D getGraphicsContext3D() {
synchronized(gfxCreationLock) {
if (graphicsContext3D == null)
graphicsContext3D = new GraphicsContext3D(this);
}
return graphicsContext3D;
}
/**
* Get the 2D graphics object associated with
* this Canvas3D. A new 2D graphics object is created if one does
* not already exist.
*
* @return a Graphics2D object that can be used for Java 2D
* rendering into this Canvas3D.
*
* @since Java 3D 1.2
*/
public J3DGraphics2D getGraphics2D() {
synchronized(gfxCreationLock) {
if (graphics2D == null)
graphics2D = new J3DGraphics2DImpl(this);
}
return graphics2D;
}
/**
* This routine is called by the Java 3D rendering loop after clearing
* the canvas and before any rendering has been done for this frame.
* Applications that wish to perform operations in the rendering loop,
* prior to any actual rendering may override this function.
*
* <p>
* Updates to live Geometry, Texture, and ImageComponent objects
* in the scene graph are not allowed from this method.
*
* <p>
* NOTE: Applications should <i>not</i> call this method.
*/
public void preRender() {
// Do nothing; the user overrides this to cause some action
}
/**
* This routine is called by the Java 3D rendering loop after completing
* all rendering to the canvas for this frame and before the buffer swap.
* Applications that wish to perform operations in the rendering loop,
* following any actual rendering may override this function.
*
* <p>
* Updates to live Geometry, Texture, and ImageComponent objects
* in the scene graph are not allowed from this method.
*
* <p>
* NOTE: Applications should <i>not</i> call this method.
*/
public void postRender() {
// Do nothing; the user overrides this to cause some action
}
/**
* This routine is called by the Java 3D rendering loop after completing
* all rendering to the canvas, and all other canvases associated with
* this view, for this frame following the buffer swap.
* Applications that wish to perform operations at the very
* end of the rendering loop may override this function.
* In off-screen mode, all rendering is copied to the off-screen
* buffer before this method is called.
*
* <p>
* Updates to live Geometry, Texture, and ImageComponent objects
* in the scene graph are not allowed from this method.
*
* <p>
* NOTE: Applications should <i>not</i> call this method.
*/
public void postSwap() {
// Do nothing; the user overrides this to cause some action
}
/**
* This routine is called by the Java 3D rendering loop during the
* execution of the rendering loop. It is called once for each
* field (i.e., once per frame on
* a mono system or once each for the right eye and left eye on a
* two-pass stereo system. This is intended for use by applications that
* want to mix retained/compiled-retained mode rendering with some
* immediate mode rendering. Applications that wish to perform
* operations during the rendering loop, may override this
* function.
*
* <p>
* Updates to live Geometry, Texture, and ImageComponent objects
* in the scene graph are not allowed from this method.
*
* <p>
* NOTE: Applications should <i>not</i> call this method.
* <p>
*
* @param fieldDesc field description, one of: FIELD_LEFT, FIELD_RIGHT or
* FIELD_ALL. Applications that wish to work correctly in stereo mode
* should render the same image for both FIELD_LEFT and FIELD_RIGHT calls.
* If Java 3D calls the renderer with FIELD_ALL then the immediate mode
* rendering only needs to be done once.
*/
public void renderField(int fieldDesc) {
// Do nothing; the user overrides this to cause some action
}
/**
* Stop the Java 3D renderer on this Canvas3D object. If the
* Java 3D renderer is currently running, the rendering will be
* synchronized before being stopped. No further rendering will be done
* to this canvas by Java 3D until the renderer is started again.
* In pure immediate mode this method should be called prior to adding
* this canvas to an active View object.
*
* @exception IllegalStateException if this Canvas3D is in
* off-screen mode.
*/
public final void stopRenderer() {
// Issue 131: renderer can't be stopped only if it is an offscreen,
// manual canvas. Otherwise, it has to be seen as an onscreen canvas.
if (manualRendering)
throw new IllegalStateException(J3dI18N.getString("Canvas3D14"));
if (isRunning) {
VirtualUniverse.mc.postRequest(MasterControl.STOP_RENDERER, this);
isRunning = false;
}
}
/**
* Start the Java 3D renderer on this Canvas3D object. If the
* Java 3D renderer is not currently running, any rendering to other
* Canvas3D objects sharing the same View will be synchronized before this
* Canvas3D's renderer is (re)started. When a Canvas3D is created, it is
* initially marked as being started. This means that as soon as the
* Canvas3D is added to an active View object, the rendering loop will
* render the scene graph to the canvas.
*/
public final void startRenderer() {
// Issue 260 : ignore attempt to start renderer if fatal error
if (fatalError) {
return;
}
if (!isRunning) {
VirtualUniverse.mc.postRequest(MasterControl.START_RENDERER, this);
isRunning = true;
redraw();
}
}
/**
* Retrieves the state of the renderer for this Canvas3D object.
* @return the state of the renderer
*
* @since Java 3D 1.2
*/
public final boolean isRendererRunning() {
return isRunning;
}
// Returns the state of the fatal error flag
boolean isFatalError() {
return fatalError;
}
// Sets the fatal error flag to true; stop the renderer for this canvas
void setFatalError() {
fatalError = true;
if (isRunning) {
isRunning = false;
if (!manualRendering) {
VirtualUniverse.mc.postRequest(MasterControl.STOP_RENDERER, this);
}
}
}
/**
* Retrieves a flag indicating whether this Canvas3D is an
* off-screen canvas.
*
* @return <code>true</code> if this Canvas3D is an off-screen canvas;
* <code>false</code> if this is an on-screen canvas.
*
* @since Java 3D 1.2
*/
public boolean isOffScreen() {
return offScreen;
}
/**
* Sets the off-screen buffer for this Canvas3D. The specified
* image is written into by the Java 3D renderer. The size of the
* specified ImageComponent determines the size, in pixels, of
* this Canvas3D--the size inherited from Component is ignored.
* <p>
* NOTE: the size, physical width, and physical height of the associated
* Screen3D must be set explicitly prior to rendering.
* Failure to do so will result in an exception.
* <p>
*
* @param buffer the image component that will be rendered into by
* subsequent calls to renderOffScreenBuffer. The image component must not
* be part of a live scene graph, nor may it subsequently be made part of a
* live scene graph while being used as an off-screen buffer; an
* IllegalSharingException is thrown in such cases. The buffer may be null,
* indicating that the previous off-screen buffer is released without a new
* buffer being set.
*
* @exception IllegalStateException if this Canvas3D is not in
* off-screen mode.
*
* @exception RestrictedAccessException if an off-screen rendering
* is in process for this Canvas3D.
*
* @exception IllegalSharingException if the specified ImageComponent2D
* is part of a live scene graph
*
* @exception IllegalSharingException if the specified ImageComponent2D is
* being used by an immediate mode context, or by another Canvas3D as
* an off-screen buffer.
*
* @exception IllegalArgumentException if the image class of the specified
* ImageComponent2D is <i>not</i> ImageClass.BUFFERED_IMAGE.
*
* @exception IllegalArgumentException if the specified
* ImageComponent2D is in by-reference mode and its
* RenderedImage is null.
*
* @exception IllegalArgumentException if the ImageComponent2D format
* is <i>not</i> a 3-component format (e.g., FORMAT_RGB)
* or a 4-component format (e.g., FORMAT_RGBA).
*
* @see #renderOffScreenBuffer
* @see Screen3D#setSize(int, int)
* @see Screen3D#setSize(Dimension)
* @see Screen3D#setPhysicalScreenWidth
* @see Screen3D#setPhysicalScreenHeight
*
* @since Java 3D 1.2
*/
public void setOffScreenBuffer(ImageComponent2D buffer) {
int width, height;
boolean freeCanvasId = false;
if (!offScreen)
throw new IllegalStateException(J3dI18N.getString("Canvas3D1"));
if (offScreenRendering)
throw new RestrictedAccessException(J3dI18N.getString("Canvas3D2"));
// Check that offScreenBufferPending is not already set
J3dDebug.doAssert(!offScreenBufferPending, "!offScreenBufferPending");
if (offScreenBuffer != null && offScreenBuffer != buffer) {
ImageComponent2DRetained i2dRetained =
(ImageComponent2DRetained)offScreenBuffer.retained;
i2dRetained.setUsedByOffScreen(false);
}
if (buffer != null) {
ImageComponent2DRetained bufferRetained =
(ImageComponent2DRetained)buffer.retained;
if (bufferRetained.byReference &&
!(bufferRetained.getRefImage(0) instanceof BufferedImage)) {
throw new IllegalArgumentException(J3dI18N.getString("Canvas3D15"));
}
if (bufferRetained.getNumberOfComponents() < 3 ) {
throw new IllegalArgumentException(J3dI18N.getString("Canvas3D16"));
}
if (buffer.isLive()) {
throw new IllegalSharingException(J3dI18N.getString("Canvas3D26"));
}
if (bufferRetained.getInImmCtx()) {
throw new IllegalSharingException(J3dI18N.getString("Canvas3D27"));
}
if (buffer != offScreenBuffer && bufferRetained.getUsedByOffScreen()) {
throw new IllegalSharingException(J3dI18N.getString("Canvas3D28"));
}
bufferRetained.setUsedByOffScreen(true);
width = bufferRetained.width;
height = bufferRetained.height;
// Issues 347, 348 - assign a canvasId for off-screen Canvas3D
if (manualRendering) {
sendAllocateCanvasId();
}
}
else {
width = height = 0;
// Issues 347, 348 - release canvasId for off-screen Canvas3D
if (manualRendering) {
freeCanvasId = true;
}
}
if ((offScreenCanvasSize.width != width) ||
(offScreenCanvasSize.height != height)) {
if (drawable != null) {
// Fix for Issue 18 and Issue 175
// Will do destroyOffScreenBuffer in the Renderer thread.
sendDestroyCtxAndOffScreenBuffer();
drawable = null;
}
// Issue 396. Since context is invalid here, we should set it to null.
ctx = null;
// set the canvas dimension according to the buffer dimension
offScreenCanvasSize.setSize(width, height);
this.setSize(offScreenCanvasSize);
if (width > 0 && height > 0) {
sendCreateOffScreenBuffer();
}
}
else if (ctx != null) {
removeCtx();
}
if (freeCanvasId) {
sendFreeCanvasId();
}
offScreenBuffer = buffer;
synchronized(dirtyMaskLock) {
cvDirtyMask[0] |= MOVED_OR_RESIZED_DIRTY;
cvDirtyMask[1] |= MOVED_OR_RESIZED_DIRTY;
}
}
/**
* Retrieves the off-screen buffer for this Canvas3D.
*
* @return the current off-screen buffer for this Canvas3D.
*
* @exception IllegalStateException if this Canvas3D is not in
* off-screen mode.
*
* @since Java 3D 1.2
*/
public ImageComponent2D getOffScreenBuffer() {
if (!offScreen)
throw new IllegalStateException(J3dI18N.getString("Canvas3D1"));
return (offScreenBuffer);
}
/**
* Schedules the rendering of a frame into this Canvas3D's
* off-screen buffer. The rendering is done from the point of
* view of the View object to which this Canvas3D has been added.
* No rendering is performed if this Canvas3D object has not been
* added to an active View. This method does not wait for the rendering
* to actually happen. An application that wishes to know when
* the rendering is complete must either subclass Canvas3D and
* override the <code>postSwap</code> method, or call
* <code>waitForOffScreenRendering</code>.
*
* @exception NullPointerException if the off-screen buffer is null.
* @exception IllegalStateException if this Canvas3D is not in
* off-screen mode, or if either the width or the height of
* the associated Screen3D's size is <= 0, or if the associated
* Screen3D's physical width or height is <= 0.
* @exception RestrictedAccessException if an off-screen rendering
* is already in process for this Canvas3D or if the Java 3D renderer
* is stopped.
*
* @see #setOffScreenBuffer
* @see Screen3D#setSize(int, int)
* @see Screen3D#setSize(Dimension)
* @see Screen3D#setPhysicalScreenWidth
* @see Screen3D#setPhysicalScreenHeight
* @see #waitForOffScreenRendering
* @see #postSwap
*
* @since Java 3D 1.2
*/
public void renderOffScreenBuffer() {
if (!offScreen)
throw new IllegalStateException(J3dI18N.getString("Canvas3D1"));
// Issue 131: Cannot manually render to an automatic canvas.
if (!manualRendering)
throw new IllegalStateException(J3dI18N.getString("Canvas3D24"));
// Issue 260 : Cannot render if we already have a fatal error
if (fatalError) {
throw new IllegalRenderingStateException(J3dI18N.getString("Canvas3D30"));
}
if (offScreenBuffer == null)
throw new NullPointerException(J3dI18N.getString("Canvas3D10"));
Dimension screenSize = screen.getSize();
if (screenSize.width <= 0)
throw new IllegalStateException(J3dI18N.getString("Canvas3D8"));
if (screenSize.height <= 0)
throw new IllegalStateException(J3dI18N.getString("Canvas3D9"));
if (screen.getPhysicalScreenWidth() <= 0.0)
throw new IllegalStateException(J3dI18N.getString("Canvas3D12"));
if (screen.getPhysicalScreenHeight() <= 0.0)
throw new IllegalStateException(J3dI18N.getString("Canvas3D13"));
if (offScreenRendering)
throw new RestrictedAccessException(J3dI18N.getString("Canvas3D2"));
if (!isRunning)
throw new RestrictedAccessException(J3dI18N.getString("Canvas3D11"));
// Fix to issue 66
if ((!active) || (pendingView == null)) {
/* No rendering is performed if this Canvas3D object has not been
added to an active View. */
return;
}
// Issue 131: moved code that determines off-screen boundary to separate
// method that is called from the renderer
offScreenRendering = true;
// Fix to issue 66.
/* This is an attempt to do the following check in one atomic operation :
((view != null) && (view.inCanvasCallback)) */
boolean inCanvasCallback = false;
try {
inCanvasCallback = view.inCanvasCallback;
} catch (NullPointerException npe) {
/* Do nothing here */
}
if (inCanvasCallback) {
// Here we assume that view is stable if inCanvasCallback
// is true. This assumption is valid among all j3d threads as
// all access to view is synchronized by MasterControl.
// Issue : user threads access to view isn't synchronize hence
// is model will break.
if (screen.renderer == null) {
// It is possible that screen.renderer = null when this View
// is shared by another onScreen Canvas and this callback
// is from that Canvas. In this case it need one more
// round before the renderer.
screen.renderer = Screen3D.deviceRendererMap.get(screen.graphicsDevice);
// screen.renderer may equal to null when multiple
// screen is used and this Canvas3D is in different
// screen sharing the same View not yet initialize.
}
// if called from render call back, send a message directly to
// the renderer message queue, and call renderer doWork
// to do the offscreen rendering now
if (Thread.currentThread() == screen.renderer) {
J3dMessage createMessage = new J3dMessage();
createMessage.threads = J3dThread.RENDER_THREAD;
createMessage.type = J3dMessage.RENDER_OFFSCREEN;
createMessage.universe = this.view.universe;
createMessage.view = this.view;
createMessage.args[0] = this;
screen.renderer.rendererStructure.addMessage(createMessage);
// modify the args to reflect offScreen rendering
screen.renderer.args = new Object[4];
screen.renderer.args[0] = new Integer(Renderer.REQUESTRENDER);
screen.renderer.args[1] = this;
screen.renderer.args[2] = view;
// This extra argument 3 is needed in MasterControl to
// test whether offscreen Rendering is used or not
screen.renderer.args[3] = null;
// call renderer doWork directly since we are already in
// the renderer thread
screen.renderer.doWork(0);
} else {
// XXXX:
// Now we are in trouble, this will cause deadlock if
// waitForOffScreenRendering() is invoked
J3dMessage createMessage = new J3dMessage();
createMessage.threads = J3dThread.RENDER_THREAD;
createMessage.type = J3dMessage.RENDER_OFFSCREEN;
createMessage.universe = this.view.universe;
createMessage.view = this.view;
createMessage.args[0] = this;
screen.renderer.rendererStructure.addMessage(createMessage);
VirtualUniverse.mc.setWorkForRequestRenderer();
}
} else if (Thread.currentThread() instanceof BehaviorScheduler) {
// If called from behavior scheduler, send a message directly to
// the renderer message queue.
// Note that we didn't use
// currentThread() == view.universe.behaviorScheduler
// since the caller may be another universe Behavior
// scheduler.
J3dMessage createMessage = new J3dMessage();
createMessage.threads = J3dThread.RENDER_THREAD;
createMessage.type = J3dMessage.RENDER_OFFSCREEN;
createMessage.universe = this.view.universe;
createMessage.view = this.view;
createMessage.args[0] = this;
screen.renderer.rendererStructure.addMessage(createMessage);
VirtualUniverse.mc.setWorkForRequestRenderer();
} else {
// send a message to renderBin
// Fix for issue 66 : Since view might not been set yet,
// we have to use pendingView instead.
J3dMessage createMessage = new J3dMessage();
createMessage.threads = J3dThread.UPDATE_RENDER;
createMessage.type = J3dMessage.RENDER_OFFSCREEN;
createMessage.universe = this.pendingView.universe;
createMessage.view = this.pendingView;
createMessage.args[0] = this;
createMessage.args[1] = offScreenBuffer;
VirtualUniverse.mc.processMessage(createMessage);
}
}
/**
* Waits for this Canvas3D's off-screen rendering to be done.
* This method will wait until the <code>postSwap</code> method of this
* off-screen Canvas3D has completed. If this Canvas3D has not
* been added to an active view or if the renderer is stopped for this
* Canvas3D, then this method will return
* immediately. This method must not be called from a render
* callback method of an off-screen Canvas3D.
*
* @exception IllegalStateException if this Canvas3D is not in
* off-screen mode, or if this method is called from a render
* callback method of an off-screen Canvas3D.
*
* @see #renderOffScreenBuffer
* @see #postSwap
*
* @since Java 3D 1.2
*/
public void waitForOffScreenRendering() {
if (!offScreen) {
throw new IllegalStateException(J3dI18N.getString("Canvas3D1"));
}
if (Thread.currentThread() instanceof Renderer) {
throw new IllegalStateException(J3dI18N.getString("Canvas3D31"));
}
while (offScreenRendering) {
MasterControl.threadYield();
}
}
/**
* Sets the location of this off-screen Canvas3D. The location is
* the upper-left corner of the Canvas3D relative to the
* upper-left corner of the corresponding off-screen Screen3D.
* The function of this method is similar to that of
* <code>Component.setLocation</code> for on-screen Canvas3D
* objects. The default location is (0,0).
*
* @param x the <i>x</i> coordinate of the upper-left corner of
* the new location.
* @param y the <i>y</i> coordinate of the upper-left corner of
* the new location.
*
* @exception IllegalStateException if this Canvas3D is not in
* off-screen mode.
*
* @since Java 3D 1.2
*/
public void setOffScreenLocation(int x, int y) {
if (!offScreen)
throw new IllegalStateException(J3dI18N.getString("Canvas3D1"));
synchronized(cvLock) {
offScreenCanvasLoc.setLocation(x, y);
}
}
/**
* Sets the location of this off-screen Canvas3D. The location is
* the upper-left corner of the Canvas3D relative to the
* upper-left corner of the corresponding off-screen Screen3D.
* The function of this method is similar to that of
* <code>Component.setLocation</code> for on-screen Canvas3D
* objects. The default location is (0,0).
*
* @param p the point defining the upper-left corner of the new
* location.
*
* @exception IllegalStateException if this Canvas3D is not in
* off-screen mode.
*
* @since Java 3D 1.2
*/
public void setOffScreenLocation(Point p) {
if (!offScreen)
throw new IllegalStateException(J3dI18N.getString("Canvas3D1"));
synchronized(cvLock) {
offScreenCanvasLoc.setLocation(p);
}
}
/**
* Retrieves the location of this off-screen Canvas3D. The
* location is the upper-left corner of the Canvas3D relative to
* the upper-left corner of the corresponding off-screen Screen3D.
* The function of this method is similar to that of
* <code>Component.getLocation</code> for on-screen Canvas3D
* objects.
*
* @return a new point representing the upper-left corner of the
* location of this off-screen Canvas3D.
*
* @exception IllegalStateException if this Canvas3D is not in
* off-screen mode.
*
* @since Java 3D 1.2
*/
public Point getOffScreenLocation() {
if (!offScreen)
throw new IllegalStateException(J3dI18N.getString("Canvas3D1"));
return (new Point(offScreenCanvasLoc));
}
/**
* Retrieves the location of this off-screen Canvas3D and stores
* it in the specified Point object. The location is the
* upper-left corner of the Canvas3D relative to the upper-left
* corner of the corresponding off-screen Screen3D. The function
* of this method is similar to that of
* <code>Component.getLocation</code> for on-screen Canvas3D
* objects. This version of <code>getOffScreenLocation</code> is
* useful if the caller wants to avoid allocating a new Point
* object on the heap.
*
* @param rv Point object into which the upper-left corner of the
* location of this off-screen Canvas3D is copied.
* If <code>rv</code> is null, a new Point is allocated.
*
* @return <code>rv</code>
*
* @exception IllegalStateException if this Canvas3D is not in
* off-screen mode.
*
* @since Java 3D 1.2
*/
public Point getOffScreenLocation(Point rv) {
if (!offScreen)
throw new IllegalStateException(J3dI18N.getString("Canvas3D1"));
if (rv == null)
return (new Point(offScreenCanvasLoc));
else {
rv.setLocation(offScreenCanvasLoc);
return rv;
}
}
void endOffScreenRendering() {
ImageComponent2DRetained icRetained = (ImageComponent2DRetained)offScreenBuffer.retained;
boolean isByRef = icRetained.isByReference();
ImageComponentRetained.ImageData imageData = icRetained.getImageData(false);
if(!isByRef) {
// If icRetained has a null image ( BufferedImage)
if (imageData == null) {
assert (!isByRef);
icRetained.createBlankImageData();
imageData = icRetained.getImageData(false);
}
// Check for possible format conversion in imageData
else {
// Format convert imageData if format is unsupported.
icRetained.evaluateExtensions(this);
}
// read the image from the offscreen buffer
readOffScreenBuffer(ctx, icRetained.getImageFormatTypeIntValue(false),
icRetained.getImageDataTypeIntValue(), imageData.get(),
offScreenCanvasSize.width, offScreenCanvasSize.height);
} else {
icRetained.geomLock.getLock();
// Create a copy of format converted image in imageData if format is unsupported.
icRetained.evaluateExtensions(this);
// read the image from the offscreen buffer
readOffScreenBuffer(ctx, icRetained.getImageFormatTypeIntValue(false),
icRetained.getImageDataTypeIntValue(), imageData.get(),
offScreenCanvasSize.width, offScreenCanvasSize.height);
// For byRef, we might have to copy buffer back into
// the user's referenced ImageComponent2D
if(!imageData.isDataByRef()) {
if(icRetained.isImageTypeSupported()) {
icRetained.copyToRefImage(0);
} else {
// This method only handle RGBA conversion.
icRetained.copyToRefImageWithFormatConversion(0);
}
}
icRetained.geomLock.unLock();
}
}
/**
* Synchronize and swap buffers on a double buffered canvas for
* this Canvas3D object. This method should only be called if the
* Java 3D renderer has been stopped. In the normal case, the renderer
* automatically swaps the buffer.
* This method calls the <code>flush(true)</code> methods of the
* associated 2D and 3D graphics contexts, if they have been allocated.
*
* @exception RestrictedAccessException if the Java 3D renderer is
* running.
* @exception IllegalStateException if this Canvas3D is in
* off-screen mode.
*
* @see #stopRenderer
* @see GraphicsContext3D#flush
* @see J3DGraphics2D#flush
*/
public void swap() {
if (offScreen)
throw new IllegalStateException(J3dI18N.getString("Canvas3D14"));
if (isRunning)
throw new RestrictedAccessException(J3dI18N.getString("Canvas3D0"));
if (!firstPaintCalled) {
return;
}
if (view != null && graphicsContext3D != null) {
if ((view.universe != null) &&
(Thread.currentThread() == view.universe.behaviorScheduler)) {
graphicsContext3D.sendRenderMessage(false, GraphicsContext3D.SWAP, null, null);
} else {
graphicsContext3D.sendRenderMessage(true, GraphicsContext3D.SWAP, null, null);
}
graphicsContext3D.runMonitor(J3dThread.WAIT);
}
}
void doSwap() {
if (firstPaintCalled && useDoubleBuffer) {
try {
if (validCtx && (ctx != null) && (view != null)) {
synchronized (drawingSurfaceObject) {
if (validCtx) {
if (!drawingSurfaceObject.renderLock()) {
graphicsContext3D.runMonitor(J3dThread.NOTIFY);
return;
}
this.syncRender(ctx, true);
swapBuffers(ctx, drawable);
drawingSurfaceObject.unLock();
}
}
}
} catch (NullPointerException ne) {
drawingSurfaceObject.unLock();
}
}
// Increment the elapsedFrame for the behavior structure
// to trigger any interpolators
view.universe.behaviorStructure.incElapsedFrames();
graphicsContext3D.runMonitor(J3dThread.NOTIFY);
}
/**
* Wrapper for native createNewContext method.
*/
Context createNewContext(Context shareCtx, boolean isSharedCtx) {
Context retVal = createNewContext(
this.drawable,
shareCtx, isSharedCtx,
this.offScreen);
// compute the max available texture units
maxAvailableTextureUnits = Math.max(maxTextureUnits, maxTextureImageUnits);
// reset 'antialiasingSet' if new context is created for an already existing Canvas3D,
// e.g. resizing offscreen Canvas3D
antialiasingSet = false;
return retVal;
}
/**
* Make the context associated with the specified canvas current.
*/
final void makeCtxCurrent() {
makeCtxCurrent(ctx, drawable);
}
/**
* Make the specified context current.
*/
final void makeCtxCurrent(Context ctx) {
makeCtxCurrent(ctx, drawable);
}
final void makeCtxCurrent(Context ctx, Drawable drawable) {
if (ctx != screen.renderer.currentCtx || drawable != screen.renderer.currentDrawable) {
if (!drawingSurfaceObject.isLocked()) {
drawingSurfaceObject.renderLock();
useCtx(ctx, drawable);
drawingSurfaceObject.unLock();
} else {
useCtx(ctx, drawable);
}
screen.renderer.currentCtx = ctx;
screen.renderer.currentDrawable = drawable;
}
}
// Give the pipeline a chance to release the context; the Pipeline may
// or may not ignore this call.
void releaseCtx() {
if (screen.renderer.currentCtx != null) {
boolean needLock = !drawingSurfaceObject.isLocked();
if (needLock) {
drawingSurfaceObject.renderLock();
}
if (releaseCtx(screen.renderer.currentCtx)) {
screen.renderer.currentCtx = null;
screen.renderer.currentDrawable = null;
}
if (needLock) {
drawingSurfaceObject.unLock();
}
}
}
/**
* Sets the position of the manual left eye in image-plate
* coordinates. This value determines eye placement when a head
* tracker is not in use and the application is directly controlling
* the eye position in image-plate coordinates.
* In head-tracked mode or when the windowEyePointPolicy is
* RELATIVE_TO_FIELD_OF_VIEW or RELATIVE_TO_COEXISTENCE, this value
* is ignored. When the
* windowEyepointPolicy is RELATIVE_TO_WINDOW only the Z value is
* used.
* @param position the new manual left eye position
*/
public void setLeftManualEyeInImagePlate(Point3d position) {
this.leftManualEyeInImagePlate.set(position);
synchronized(dirtyMaskLock) {
cvDirtyMask[0] |= EYE_IN_IMAGE_PLATE_DIRTY;
cvDirtyMask[1] |= EYE_IN_IMAGE_PLATE_DIRTY;
}
redraw();
}
/**
* Sets the position of the manual right eye in image-plate
* coordinates. This value determines eye placement when a head
* tracker is not in use and the application is directly controlling
* the eye position in image-plate coordinates.
* In head-tracked mode or when the windowEyePointPolicy is
* RELATIVE_TO_FIELD_OF_VIEW or RELATIVE_TO_COEXISTENCE, this value
* is ignored. When the
* windowEyepointPolicy is RELATIVE_TO_WINDOW only the Z value is
* used.
* @param position the new manual right eye position
*/
public void setRightManualEyeInImagePlate(Point3d position) {
this.rightManualEyeInImagePlate.set(position);
synchronized(dirtyMaskLock) {
cvDirtyMask[0] |= EYE_IN_IMAGE_PLATE_DIRTY;
cvDirtyMask[1] |= EYE_IN_IMAGE_PLATE_DIRTY;
}
redraw();
}
/**
* Retrieves the position of the user-specified, manual left eye
* in image-plate
* coordinates and copies that value into the object provided.
* @param position the object that will receive the position
*/
public void getLeftManualEyeInImagePlate(Point3d position) {
position.set(this.leftManualEyeInImagePlate);
}
/**
* Retrieves the position of the user-specified, manual right eye
* in image-plate
* coordinates and copies that value into the object provided.
* @param position the object that will receive the position
*/
public void getRightManualEyeInImagePlate(Point3d position) {
position.set(this.rightManualEyeInImagePlate);
}
/**
* Retrieves the actual position of the left eye
* in image-plate
* coordinates and copies that value into the object provided.
* This value is a function of the windowEyepointPolicy, the tracking
* enable flag, and the manual left eye position.
* @param position the object that will receive the position
*/
public void getLeftEyeInImagePlate(Point3d position) {
if (canvasViewCache != null) {
synchronized(canvasViewCache) {
position.set(canvasViewCache.getLeftEyeInImagePlate());
}
}
else {
position.set(leftManualEyeInImagePlate);
}
}
/**
* Retrieves the actual position of the right eye
* in image-plate
* coordinates and copies that value into the object provided.
* This value is a function of the windowEyepointPolicy, the tracking
* enable flag, and the manual right eye position.
* @param position the object that will receive the position
*/
public void getRightEyeInImagePlate(Point3d position) {
if (canvasViewCache != null) {
synchronized(canvasViewCache) {
position.set(canvasViewCache.getRightEyeInImagePlate());
}
}
else {
position.set(rightManualEyeInImagePlate);
}
}
/**
* Retrieves the actual position of the center eye
* in image-plate
* coordinates and copies that value into the object provided.
* The center eye is the fictional eye half-way between the left and
* right eye.
* This value is a function of the windowEyepointPolicy, the tracking
* enable flag, and the manual right and left eye positions.
* @param position the object that will receive the position
* @see #setMonoscopicViewPolicy
*/
// XXXX: This might not make sense for field-sequential HMD.
public void getCenterEyeInImagePlate(Point3d position) {
if (canvasViewCache != null) {
synchronized(canvasViewCache) {
position.set(canvasViewCache.getCenterEyeInImagePlate());
}
}
else {
Point3d cenEye = new Point3d();
cenEye.add(leftManualEyeInImagePlate, rightManualEyeInImagePlate);
cenEye.scale(0.5);
position.set(cenEye);
}
}
/**
* Retrieves the current ImagePlate coordinates to Virtual World
* coordinates transform and places it into the specified object.
* @param t the Transform3D object that will receive the
* transform
*/
// TODO: Document -- This will return the transform of left plate.
public void getImagePlateToVworld(Transform3D t) {
if (canvasViewCache != null) {
synchronized(canvasViewCache) {
t.set(canvasViewCache.getImagePlateToVworld());
}
}
else {
t.setIdentity();
}
}
/**
* Computes the position of the specified AWT pixel value
* in image-plate
* coordinates and copies that value into the object provided.
* @param x the X coordinate of the pixel relative to the upper-left
* hand corner of the window.
* @param y the Y coordinate of the pixel relative to the upper-left
* hand corner of the window.
* @param imagePlatePoint the object that will receive the position in
* physical image plate coordinates (relative to the lower-left
* corner of the screen).
*/
// TODO: Document -- This transform the pixel location to the left image plate.
public void getPixelLocationInImagePlate(int x, int y,
Point3d imagePlatePoint) {
if (canvasViewCache != null) {
synchronized(canvasViewCache) {
imagePlatePoint.x =
canvasViewCache.getWindowXInImagePlate((double)x);
imagePlatePoint.y =
canvasViewCache.getWindowYInImagePlate((double)y);
imagePlatePoint.z = 0.0;
}
} else {
imagePlatePoint.set(0.0, 0.0, 0.0);
}
}
void getPixelLocationInImagePlate(double x, double y, double z,
Point3d imagePlatePoint) {
if (canvasViewCache != null) {
synchronized(canvasViewCache) {
canvasViewCache.getPixelLocationInImagePlate(
x, y, z, imagePlatePoint);
}
} else {
imagePlatePoint.set(0.0, 0.0, 0.0);
}
}
/**
* Computes the position of the specified AWT pixel value
* in image-plate
* coordinates and copies that value into the object provided.
* @param pixelLocation the coordinates of the pixel relative to
* the upper-left hand corner of the window.
* @param imagePlatePoint the object that will receive the position in
* physical image plate coordinates (relative to the lower-left
* corner of the screen).
*
* @since Java 3D 1.2
*/
// TODO: Document -- This transform the pixel location to the left image plate.
public void getPixelLocationInImagePlate(Point2d pixelLocation,
Point3d imagePlatePoint) {
if (canvasViewCache != null) {
synchronized(canvasViewCache) {
imagePlatePoint.x =
canvasViewCache.getWindowXInImagePlate(pixelLocation.x);
imagePlatePoint.y =
canvasViewCache.getWindowYInImagePlate(pixelLocation.y);
imagePlatePoint.z = 0.0;
}
}
else {
imagePlatePoint.set(0.0, 0.0, 0.0);
}
}
/**
* Projects the specified point from image plate coordinates
* into AWT pixel coordinates. The AWT pixel coordinates are
* copied into the object provided.
* @param imagePlatePoint the position in
* physical image plate coordinates (relative to the lower-left
* corner of the screen).
* @param pixelLocation the object that will receive the coordinates
* of the pixel relative to the upper-left hand corner of the window.
*
* @since Java 3D 1.2
*/
// TODO: Document -- This transform the pixel location from the left image plate.
public void getPixelLocationFromImagePlate(Point3d imagePlatePoint,
Point2d pixelLocation) {
if (canvasViewCache != null) {
synchronized(canvasViewCache) {
canvasViewCache.getPixelLocationFromImagePlate(
imagePlatePoint, pixelLocation);
}
}
else {
pixelLocation.set(0.0, 0.0);
}
}
/**
* Copies the current Vworld projection transform for each eye
* into the specified Transform3D objects. This transform takes
* points in virtual world coordinates and projects them into
* clipping coordinates, which are in the range [-1,1] in
* <i>X</i>, <i>Y</i>, and <i>Z</i> after clipping and perspective
* division.
* In monoscopic mode, the same projection transform will be
* copied into both the right and left eye Transform3D objects.
*
* @param leftProjection the Transform3D object that will receive
* a copy of the current projection transform for the left eye.
*
* @param rightProjection the Transform3D object that will receive
* a copy of the current projection transform for the right eye.
*
* @since Java 3D 1.3
*/
public void getVworldProjection(Transform3D leftProjection,
Transform3D rightProjection) {
if (canvasViewCache != null) {
ViewPlatformRetained viewPlatformRetained =
(ViewPlatformRetained)view.getViewPlatform().retained;
synchronized(canvasViewCache) {
leftProjection.mul(canvasViewCache.getLeftProjection(),
canvasViewCache.getLeftVpcToEc());
leftProjection.mul(viewPlatformRetained.getVworldToVpc());
// caluclate right eye if in stereo, otherwise
// this is the same as the left eye.
if (useStereo) {
rightProjection.mul(canvasViewCache.getRightProjection(),
canvasViewCache.getRightVpcToEc());
rightProjection.mul(viewPlatformRetained.getVworldToVpc());
}
else {
rightProjection.set(leftProjection);
}
}
}
else {
leftProjection.setIdentity();
rightProjection.setIdentity();
}
}
/**
* Copies the inverse of the current Vworld projection transform
* for each eye into the specified Transform3D objects. This
* transform takes points in clipping coordinates, which are in
* the range [-1,1] in <i>X</i>, <i>Y</i>, and <i>Z</i> after
* clipping and perspective division, and transforms them into
* virtual world coordinates.
* In monoscopic mode, the same inverse projection transform will
* be copied into both the right and left eye Transform3D objects.
*
* @param leftInverseProjection the Transform3D object that will
* receive a copy of the current inverse projection transform for
* the left eye.
* @param rightInverseProjection the Transform3D object that will
* receive a copy of the current inverse projection transform for
* the right eye.
*
* @since Java 3D 1.3
*/
public void getInverseVworldProjection(Transform3D leftInverseProjection,
Transform3D rightInverseProjection) {
if (canvasViewCache != null) {
synchronized(canvasViewCache) {
leftInverseProjection.set(
canvasViewCache.getLeftCcToVworld());
// caluclate right eye if in stereo, otherwise
// this is the same as the left eye.
if (useStereo) {
rightInverseProjection.set(
canvasViewCache.getRightCcToVworld());
}
else {
rightInverseProjection.set(leftInverseProjection);
}
}
}
else {
leftInverseProjection.setIdentity();
rightInverseProjection.setIdentity();
}
}
/**
* Retrieves the physical width of this canvas window in meters.
* @return the physical window width in meters.
*/
public double getPhysicalWidth() {
double width = 0.0;
if (canvasViewCache != null) {
synchronized(canvasViewCache) {
width = canvasViewCache.getPhysicalWindowWidth();
}
}
return width;
}
/**
* Retrieves the physical height of this canvas window in meters.
* @return the physical window height in meters.
*/
public double getPhysicalHeight() {
double height = 0.0;
if (canvasViewCache != null) {
synchronized(canvasViewCache) {
height = canvasViewCache.getPhysicalWindowHeight();
}
}
return height;
}
/**
* Retrieves the current Virtual World coordinates to ImagePlate
* coordinates transform and places it into the specified object.
* @param t the Transform3D object that will receive the
* transform
*/
// TODO: Document -- This will return the transform of left plate.
public void getVworldToImagePlate(Transform3D t) {
if (canvasViewCache != null) {
synchronized(canvasViewCache) {
t.set(canvasViewCache.getVworldToImagePlate());
}
}
else {
t.setIdentity();
}
}
void getLastVworldToImagePlate(Transform3D t) {
if (canvasViewCache != null) {
synchronized(canvasViewCache) {
t.set(canvasViewCache.getLastVworldToImagePlate());
}
}
else {
t.setIdentity();
}
}
/**
* Sets view that points to this Canvas3D.
* @param view view object that points to this Canvas3D
*/
void setView(View view) {
pendingView = view;
// We can't set View directly here in user thread since
// other threads may using canvas.view
// e.g. In Renderer, we use canvas3d.view.inCallBack
// before and after postSwap(), if view change in between
// than view.inCallBack may never reset to false.
VirtualUniverse.mc.postRequest(MasterControl.SET_VIEW, this);
evaluateActive();
}
void computeViewCache() {
synchronized(cvLock) {
if (view == null) {
canvasViewCache = null;
canvasViewCacheFrustum = null;
} else {
canvasViewCache = new CanvasViewCache(this,
screen.screenViewCache,
view.viewCache);
// Issue 109 : construct a separate canvasViewCache for
// computing view frustum
canvasViewCacheFrustum = new CanvasViewCache(this,
screen.screenViewCache,
view.viewCache);
synchronized (dirtyMaskLock) {
cvDirtyMask[0] = VIEW_INFO_DIRTY;
cvDirtyMask[1] = VIEW_INFO_DIRTY;
}
}
}
}
/**
* Gets view that points to this Canvas3D.
* @return view object that points to this Canvas3D
*/
public View getView() {
return pendingView;
}
/**
* Returns a status flag indicating whether or not stereo
* is available.
* This is equivalent to:
* <ul>
* <code>
* ((Boolean)queryProperties().
* get("stereoAvailable")).
* booleanValue()
* </code>
* </ul>
*
* @return a flag indicating whether stereo is available
*/
public boolean getStereoAvailable() {
return ((Boolean)queryProperties().get("stereoAvailable")).
booleanValue();
}
/**
* Turns stereo on or off. Note that this attribute is used
* only when stereo is available. Enabling stereo on a Canvas3D
* that does not support stereo has no effect.
* @param flag enables or disables the display of stereo
*
* @see #queryProperties
*/
public void setStereoEnable(boolean flag) {
stereoEnable = flag;
useStereo = stereoEnable && stereoAvailable;
synchronized(dirtyMaskLock) {
cvDirtyMask[0] |= STEREO_DIRTY;
cvDirtyMask[1] |= STEREO_DIRTY;
}
redraw();
}
/**
* Returns a status flag indicating whether or not stereo
* is enabled.
* @return a flag indicating whether stereo is enabled
*/
public boolean getStereoEnable() {
return this.stereoEnable;
}
/**
* Specifies how Java 3D generates monoscopic view. If set to
* View.LEFT_EYE_VIEW, the view generated corresponds to the view as
* seen from the left eye. If set to View.RIGHT_EYE_VIEW, the view
* generated corresponds to the view as seen from the right
* eye. If set to View.CYCLOPEAN_EYE_VIEW, the view generated
* corresponds to the view as seen from the 'center eye', the
* fictional eye half-way between the left and right eye. The
* default monoscopic view policy is View.CYCLOPEAN_EYE_VIEW.
* <p>
* NOTE: for backward compatibility with Java 3D 1.1, if this
* attribute is set to its default value of
* View.CYCLOPEAN_EYE_VIEW, the monoscopic view policy in the
* View object will be used. An application should not use both
* the deprecated View method and this Canvas3D method at the same
* time.
* @param policy one of View.LEFT_EYE_VIEW, View.RIGHT_EYE_VIEW, or
* View.CYCLOPEAN_EYE_VIEW.
*
* @exception IllegalStateException if the specified
* policy is CYCLOPEAN_EYE_VIEW, the canvas is a stereo canvas,
* and the viewPolicy for the associated view is HMD_VIEW
*
* @since Java 3D 1.2
*/
public void setMonoscopicViewPolicy(int policy) {
if((view !=null) && (view.viewPolicy == View.HMD_VIEW) &&
(monoscopicViewPolicy == View.CYCLOPEAN_EYE_VIEW) &&
(!useStereo)) {
throw new
IllegalStateException(J3dI18N.getString("View31"));
}
monoscopicViewPolicy = policy;
synchronized(dirtyMaskLock) {
cvDirtyMask[0] |= MONOSCOPIC_VIEW_POLICY_DIRTY;
cvDirtyMask[1] |= MONOSCOPIC_VIEW_POLICY_DIRTY;
}
redraw();
}
/**
* Returns policy on how Java 3D generates monoscopic view.
* @return policy one of View.LEFT_EYE_VIEW, View.RIGHT_EYE_VIEW or
* View.CYCLOPEAN_EYE_VIEW.
*
* @since Java 3D 1.2
*/
public int getMonoscopicViewPolicy() {
return this.monoscopicViewPolicy;
}
/**
* Returns a status flag indicating whether or not double
* buffering is available.
* This is equivalent to:
* <ul>
* <code>
* ((Boolean)queryProperties().
* get("doubleBufferAvailable")).
* booleanValue()
* </code>
* </ul>
*
* @return a flag indicating whether double buffering is available.
*/
public boolean getDoubleBufferAvailable() {
return ((Boolean)queryProperties().get("doubleBufferAvailable")).
booleanValue();
}
/**
* Turns double buffering on or off. If double buffering
* is off, all drawing is to the front buffer and no buffer swap
* is done between frames. It should be stressed that running
* Java 3D with double buffering disabled is not recommended.
* Enabling double buffering on a Canvas3D
* that does not support double buffering has no effect.
*
* @param flag enables or disables double buffering.
*
* @see #queryProperties
*/
public void setDoubleBufferEnable(boolean flag) {
doubleBufferEnable = flag;
useDoubleBuffer = doubleBufferEnable && doubleBufferAvailable;
if (Thread.currentThread() == screen.renderer) {
setRenderMode(ctx, FIELD_ALL, useDoubleBuffer);
}
redraw();
}
/**
* Returns a status flag indicating whether or not double
* buffering is enabled.
* @return a flag indicating if double buffering is enabled.
*/
public boolean getDoubleBufferEnable() {
return doubleBufferEnable;
}
/**
* Returns a status flag indicating whether or not scene
* antialiasing is available.
* This is equivalent to:
* <ul>
* <code>
* ((Boolean)queryProperties().
* get("sceneAntialiasingAvailable")).
* booleanValue()
* </code>
* </ul>
*
* @return a flag indicating whether scene antialiasing is available.
*/
public boolean getSceneAntialiasingAvailable() {
return ((Boolean)queryProperties().get("sceneAntialiasingAvailable")).
booleanValue();
}
/**
* Returns a flag indicating whether or not the specified shading
* language is supported. A ShaderError will be generated if an
* unsupported shading language is used.
*
* @param shadingLanguage the shading language being queried, one of:
* <code>Shader.SHADING_LANGUAGE_GLSL</code> or
* <code>Shader.SHADING_LANGUAGE_CG</code>.
*
* @return true if the specified shading language is supported,
* false otherwise.
*
* @since Java 3D 1.4
*/
public boolean isShadingLanguageSupported(int shadingLanguage) {
// Call queryProperties to ensure that the shading language flags are valid
queryProperties();
if (shadingLanguage == Shader.SHADING_LANGUAGE_GLSL)
return shadingLanguageGLSL;
return false;
}
/**
* Returns a read-only Map object containing key-value pairs that define
* various properties for this Canvas3D. All of the keys are
* String objects. The values are key-specific, but most will be
* Boolean, Integer, Float, Double, or String objects.
*
* <p>
* The currently defined keys are:
*
* <p>
* <ul>
* <table BORDER=1 CELLSPACING=1 CELLPADDING=1>
* <tr>
* <td><b>Key (String)</b></td>
* <td><b>Value Type</b></td>
* </tr>
* <tr>
* <td><code>shadingLanguageCg</code></td>
* <td>Boolean</td>
* </tr>
* <tr>
* <td><code>shadingLanguageGLSL</code></td>
* <td>Boolean</td>
* </tr>
* <tr>
* <td><code>doubleBufferAvailable</code></td>
* <td>Boolean</td>
* </tr>
* <tr>
* <td><code>stereoAvailable</code></td>
* <td>Boolean</td>
* </tr>
* <tr>
* <td><code>sceneAntialiasingAvailable</code></td>
* <td>Boolean</td>
* </tr>
* <tr>
* <td><code>sceneAntialiasingNumPasses</code></td>
* <td>Integer</td>
* </tr>
* <tr>
* <td><code>stencilSize</code></td>
* <td>Integer</td>
* </tr>
* <tr>
* <td><code>texture3DAvailable</code></td>
* <td>Boolean</td>
* </tr>
* <tr>
* <td><code>textureColorTableSize</code></td>
* <td>Integer</td>
* </tr>
* <tr>
* <td><code>textureLodRangeAvailable</code></td>
* <td>Boolean</td>
* </tr>
* <tr>
* <td><code>textureLodOffsetAvailable</code></td>
* <td>Boolean</td>
* </tr>
* <tr>
* <td><code>textureWidthMax</code></td>
* <td>Integer</td>
* </tr>
* <tr>
* <td><code>textureHeightMax</code></td>
* <td>Integer</td>
* </tr>
* <tr>
* <td><code>textureBoundaryWidthMax</code></td>
* <td>Integer</td>
* </tr>
* <tr>
* <td><code>textureEnvCombineAvailable</code></td>
* <td>Boolean</td>
* </tr>
* <tr>
* <td><code>textureCombineDot3Available</code></td>
* <td>Boolean</td>
* </tr>
* <tr>
* <td><code>textureCombineSubtractAvailable</code></td>
* <td>Boolean</td>
* </tr>
* <tr>
* <td><code>textureCoordSetsMax</code></td>
* <td>Integer</td>
* </tr>
* <tr>
* <td><code>textureUnitStateMax</code></td>
* <td>Integer</td>
* </tr>
* <tr>
* <td><code>textureImageUnitsMax</code></td>
* <td>Integer</td>
* </tr>
* <tr>
* <td><code>textureImageUnitsVertexMax</code></td>
* <td>Integer</td>
* </tr>
* <tr>
* <td><code>textureImageUnitsCombinedMax</code></td>
* <td>Integer</td>
* </tr>
* <tr>
* <td><code>textureCubeMapAvailable</code></td>
* <td>Boolean</td>
* </tr>
* <tr>
* <td><code>textureDetailAvailable</code></td>
* <td>Boolean</td>
* </tr>
* <tr>
* <td><code>textureSharpenAvailable</code></td>
* <td>Boolean</td>
* </tr>
* <tr>
* <td><code>textureFilter4Available</code></td>
* <td>Boolean</td>
* </tr>
* <tr>
* <td><code>textureAnisotropicFilterDegreeMax</code></td>
* <td>Float</td>
* </tr>
* <tr>
* <td><code>textureNonPowerOfTwoAvailable</code></td>
* <td>Boolean</td>
* </tr>
* <tr>
* <td><code>vertexAttrsMax</code></td>
* <td>Integer</td>
* </tr>
* <tr>
* <td><code>compressedGeometry.majorVersionNumber</code></td>
* <td>Integer</td>
* </tr>
* <tr>
* <td><code>compressedGeometry.minorVersionNumber</code></td>
* <td>Integer</td>
* </tr>
* <tr>
* <td><code>compressedGeometry.minorMinorVersionNumber</code></td>
* <td>Integer</td>
* </tr>
* <tr>
* <td><code>native.version</code></td>
* <td>String</td>
* </tr>
* </table>
* </ul>
*
* <p>
* The descriptions of the values returned for each key are as follows:
*
* <p>
* <ul>
* <li>
* <code>shadingLanguageCg</code>
* <ul>
* A Boolean indicating whether or not Cg shading Language
* is available for this Canvas3D.
* </ul>
* </li>
*
* <li>
* <code>shadingLanguageGLSL</code>
* <ul>
* A Boolean indicating whether or not GLSL shading Language
* is available for this Canvas3D.
* </ul>
* </li>
*
* <li>
* <code>doubleBufferAvailable</code>
* <ul>
* A Boolean indicating whether or not double buffering
* is available for this Canvas3D. This is equivalent to
* the getDoubleBufferAvailable method. If this flag is false,
* the Canvas3D will be rendered in single buffer mode; requests
* to enable double buffering will be ignored.
* </ul>
* </li>
*
* <li>
* <code>stereoAvailable</code>
* <ul>
* A Boolean indicating whether or not stereo
* is available for this Canvas3D. This is equivalent to
* the getStereoAvailable method. If this flag is false,
* the Canvas3D will be rendered in monoscopic mode; requests
* to enable stereo will be ignored.
* </ul>
* </li>
*
* <li>
* <code>sceneAntialiasingAvailable</code>
* <ul>
* A Boolean indicating whether or not scene antialiasing
* is available for this Canvas3D. This is equivalent to
* the getSceneAntialiasingAvailable method. If this flag is false,
* requests to enable scene antialiasing will be ignored.
* </ul>
* </li>
*
* <li>
* <code>sceneAntialiasingNumPasses</code>
* <ul>
* An Integer indicating the number of passes scene antialiasing
* requires to render a single frame for this Canvas3D.
* If this value is zero, scene antialiasing is not supported.
* If this value is one, multisampling antialiasing is used.
* Otherwise, the number indicates the number of rendering passes
* needed.
* </ul>
* </li>
*
* <li>
* <code>stencilSize</code>
* <ul>
* An Integer indicating the number of stencil bits that are available
* for this Canvas3D.
* </ul>
* </li>
*
* <li>
* <code>texture3DAvailable</code>
* <ul>
* A Boolean indicating whether or not 3D Texture mapping
* is available for this Canvas3D. If this flag is false,
* 3D texture mapping is either not supported by the underlying
* rendering layer or is otherwise unavailable for this
* particular Canvas3D. All use of 3D texture mapping will be
* ignored in this case.
* </ul>
* </li>
*
* <li>
* <code>textureColorTableSize</code>
* <ul>
* An Integer indicating the maximum size of the texture color
* table for this Canvas3D. If the size is 0, the texture
* color table is either not supported by the underlying rendering
* layer or is otherwise unavailable for this particular
* Canvas3D. An attempt to use a texture color table larger than
* textureColorTableSize will be ignored; no color lookup will be
* performed.
* </ul>
* </li>
*
* <li>
* <code>textureLodRangeAvailable</code>
* <ul>
* A Boolean indicating whether or not setting only a subset of mipmap
* levels and setting a range of texture LOD are available for this
* Canvas3D.
* If it indicates false, setting a subset of mipmap levels and
* setting a texture LOD range are not supported by the underlying
* rendering layer, and an attempt to set base level, or maximum level,
* or minimum LOD, or maximum LOD will be ignored. In this case,
* images for all mipmap levels must be defined for the texture to be
* valid.
* </ul>
* </li>
*
* <li>
* <code>textureLodOffsetAvailable</code>
* <ul>
* A Boolean indicating whether or not setting texture LOD offset is
* available for this Canvas3D. If it indicates false, setting
* texture LOD offset is not supported by the underlying rendering
* layer, and an attempt to set the texture LOD offset will be ignored.
* </ul>
* </li>
*
* <li>
* <code>textureWidthMax</code>
* <ul>
* An Integer indicating the maximum texture width supported by
* this Canvas3D. If the width of a texture exceeds the maximum texture
* width for a Canvas3D, then the texture will be effectively disabled
* for that Canvas3D.
* </ul>
* </li>
*
* <li>
* <code>textureHeightMax</code>
* <ul>
* An Integer indicating the maximum texture height supported by
* this Canvas3D. If the height of a texture exceeds the maximum texture
* height for a Canvas3D, then the texture will be effectively disabled
* for that Canvas3D.
* </ul>
* </li>
*
* <li>
* <code>textureBoundaryWidthMax</code>
* <ul>
* An Integer indicating the maximum texture boundary width
* supported by the underlying rendering layer for this Canvas3D. If
* the maximum supported texture boundary width is 0, then texture
* boundary is not supported by the underlying rendering layer.
* An attempt to specify a texture boundary width > the
* textureBoundaryWidthMax will effectively disable the texture.
* </ul>
* </li>
*
* <li>
* <code>textureEnvCombineAvailable</code>
* <ul>
* A Boolean indicating whether or not texture environment combine
* operation is supported for this Canvas3D. If it indicates false,
* then texture environment combine is not supported by the
* underlying rendering layer, and an attempt to specify COMBINE
* as the texture mode will be ignored. The texture mode in effect
* will be REPLACE.
* </ul>
* </li>
*
* <li>
* <code>textureCombineDot3Available</code>
* <ul>
* A Boolean indicating whether or not texture combine mode
* COMBINE_DOT3 is
* supported for this Canvas3D. If it indicates false, then
* texture combine mode COMBINE_DOT3 is not supported by
* the underlying rendering layer, and an attempt to specify
* COMBINE_DOT3 as the texture combine mode will be ignored.
* The texture combine mode in effect will be COMBINE_REPLACE.
* </ul>
* </li>
*
* <li>
* <code>textureCombineSubtractAvailable</code>
* <ul>
* A Boolean indicating whether or not texture combine mode
* COMBINE_SUBTRACT is
* supported for this Canvas3D. If it indicates false, then
* texture combine mode COMBINE_SUBTRACT is not supported by
* the underlying rendering layer, and an attempt to specify
* COMBINE_SUBTRACT as the texture combine mode will be ignored.
* The texture combine mode in effect will be COMBINE_REPLACE.
* </ul>
* </li>
*
* <li>
* <code>textureCoordSetsMax</code>
* <ul>
* An Integer indicating the maximum number of texture coordinate sets
* supported by the underlying rendering layer.
* </ul>
* </li>
*
* <li>
* <code>textureUnitStateMax</code>
* <ul>
* An Integer indicating the maximum number of fixed-function texture units
* supported by the underlying rendering layer. If the number of
* application-sepcified texture unit states exceeds the maximum number
* for a Canvas3D, and the fixed-function rendering pipeline is used, then
* the texture will be effectively disabled for that Canvas3D.
* </ul>
* </li>
*
* <li>
* <code>textureImageUnitsMax</code>
* <ul>
* An Integer indicating the maximum number of texture image units
* that can be accessed by the fragment shader when programmable shaders
* are used.
* </ul>
* </li>
*
* <li>
* <code>textureImageUnitsVertexMax</code>
* <ul>
* An Integer indicating the maximum number of texture image units
* that can be accessed by the vertex shader when programmable shaders
* are used.
* </ul>
* </li>
*
* <li>
* <code>textureImageUnitsCombinedMax</code>
* <ul>
* An Integer indicating the combined maximum number of texture image units
* that can be accessed by the vertex shader and the fragment shader when
* programmable shaders are used.
* </ul>
* </li>
*
* <li>
* <code>textureCubeMapAvailable</code>
* <ul>
* A Boolean indicating whether or not texture cube map is supported
* for this Canvas3D. If it indicates false, then texture cube map
* is not supported by the underlying rendering layer, and an attempt
* to specify NORMAL_MAP or REFLECTION_MAP as the texture generation
* mode will be ignored. The texture generation mode in effect will
* be SPHERE_MAP.
* </ul>
* </li>
*
* <li>
* <code>textureDetailAvailable</code>
* <ul>
* A Boolean indicating whether or not detail texture is supported
* for this Canvas3D. If it indicates false, then detail texture is
* not supported by the underlying rendering layer, and an attempt
* to specify LINEAR_DETAIL, LINEAR_DETAIL_ALPHA or
* LINEAR_DETAIL_RGB as the texture magnification filter mode will
* be ignored. The texture magnification filter mode in effect will
* be BASE_LEVEL_LINEAR.
* As of Java 3D 1.5, this property is always false.
* </ul>
* </li>
*
* <li>
* <code>textureSharpenAvailable</code>
* <ul>
* A Boolean indicating whether or not sharpen texture is supported
* for this Canvas3D. If it indicates false, then sharpen texture
* is not supported by the underlying rendering layer, and an attempt
* to specify LINEAR_SHARPEN, LINEAR_SHARPEN_ALPHA or
* LINEAR_SHARPEN_RGB as the texture magnification filter mode
* will be ignored. The texture magnification filter mode in effect
* will be BASE_LEVEL_LINEAR.
* </ul>
* </li>
*
* <li>
* <code>textureFilter4Available</code>
* <ul>
* A Boolean indicating whether or not filter4 is supported for this
* Canvas3D. If it indicates flase, then filter4 is not supported
* by the underlying rendering layer, and an attempt to specify
* FILTER_4 as the texture minification filter mode or texture
* magnification filter mode will be ignored. The texture filter mode
* in effect will be BASE_LEVEL_LINEAR.
* </ul>
* </li>
*
* <li>
* <code>textureAnisotropicFilterDegreeMax</code>
* <ul>
* A Float indicating the maximum degree of anisotropic filter
* available for this Canvas3D. If it indicates 1.0, setting
* anisotropic filter is not supported by the underlying rendering
* layer, and an attempt to set anisotropic filter degree will be ignored.
* </ul>
* </li>
* <li>
* <code>textureNonPowerOfTwoAvailable</code>
* <ul>
* A Boolean indicating whether or not texture dimensions that are
* not powers of two are supported for
* for this Canvas3D. If it indicates false, then textures with
* non power of two sizes will be ignored. Set the property
* j3d.textureEnforcePowerOfTwo to revert to the pre-1.5 behavior
* of throwing exceptions for non power of two textures.
* </ul>
* </li>
*
* <li>
* <code>vertexAttrsMax</code>
* <ul>
* An Integer indicating the maximum number of vertex attributes
* supported by the underlying rendering layer. This is in addition to
* the vertex coordinate (position), color, normal, and so forth.
* </ul>
* </li>
*
* <li>
* <code>compressedGeometry.majorVersionNumber</code><br>
* <code>compressedGeometry.minorVersionNumber</code><br>
* <code>compressedGeometry.minorMinorVersionNumber</code>
* <ul>
* Integers indicating the major, minor, and minor-minor
* version numbers, respectively, of the version of compressed
* geometry supported by this version of Java 3D.
* </ul>
* </li>
*
* <li>
* <code>native.version</code>
* <ul>
* A String indicating the version number of the native graphics
* library. The format of this string is defined by the native
* library.
* </ul>
* </li>
* </ul>
*
* @return the properties of this Canavs3D
*
* @since Java 3D 1.2
*/
public final Map queryProperties() {
if (queryProps == null) {
boolean createDummyCtx = false;
synchronized (VirtualUniverse.mc.contextCreationLock) {
if (ctx == null) {
createDummyCtx = true;
}
}
if (createDummyCtx) {
GraphicsConfigTemplate3D.setQueryProps(this);
}
//create query Properties
createQueryProps();
}
if (fatalError) {
throw new IllegalStateException(J3dI18N.getString("Canvas3D29"));
}
return queryProps;
}
void createQueryContext() {
// create a dummy context to query for support of certain
// extensions, the context will destroy immediately
// inside the native code after setting the various
// fields in this object
createQueryContext(drawable, offScreen, 1, 1);
// compute the max available texture units
maxAvailableTextureUnits = Math.max(maxTextureUnits, maxTextureImageUnits);
}
/**
* Creates the query properties for this Canvas.
*/
private void createQueryProps() {
// Create lists of keys and values
ArrayList<String> keys = new ArrayList<String>();
ArrayList<Object> values = new ArrayList<Object>();
int pass = 0;
// properties not associated with graphics context
keys.add("doubleBufferAvailable");
values.add(new Boolean(doubleBufferAvailable));
keys.add("stereoAvailable");
values.add(new Boolean(stereoAvailable));
keys.add("sceneAntialiasingAvailable");
values.add(new Boolean(sceneAntialiasingAvailable));
keys.add("sceneAntialiasingNumPasses");
if (sceneAntialiasingAvailable) {
pass = (sceneAntialiasingMultiSamplesAvailable ?
1: Renderer.NUM_ACCUMULATION_SAMPLES);
}
values.add(new Integer(pass));
keys.add("stencilSize");
// Return the actual stencil size if the user owns it, otherwise
// return 0
if (userStencilAvailable) {
values.add(new Integer(actualStencilSize));
} else {
values.add(new Integer(0));
}
keys.add("compressedGeometry.majorVersionNumber");
values.add(new Integer(GeometryDecompressor.majorVersionNumber));
keys.add("compressedGeometry.minorVersionNumber");
values.add(new Integer(GeometryDecompressor.minorVersionNumber));
keys.add("compressedGeometry.minorMinorVersionNumber");
values.add(new Integer(GeometryDecompressor.minorMinorVersionNumber));
// Properties associated with graphics context
keys.add("texture3DAvailable");
values.add(new Boolean((textureExtendedFeatures & TEXTURE_3D) != 0));
keys.add("textureColorTableSize");
values.add(new Integer(textureColorTableSize));
keys.add("textureEnvCombineAvailable");
values.add(new Boolean(
(textureExtendedFeatures & TEXTURE_COMBINE) != 0));
keys.add("textureCombineDot3Available");
values.add(new Boolean(
(textureExtendedFeatures & TEXTURE_COMBINE_DOT3) != 0));
keys.add("textureCombineSubtractAvailable");
values.add(new Boolean(
(textureExtendedFeatures & TEXTURE_COMBINE_SUBTRACT) != 0));
keys.add("textureCubeMapAvailable");
values.add(new Boolean(
(textureExtendedFeatures & TEXTURE_CUBE_MAP) != 0));
keys.add("textureSharpenAvailable");
values.add(new Boolean(
(textureExtendedFeatures & TEXTURE_SHARPEN) != 0));
keys.add("textureDetailAvailable");
values.add(new Boolean(
(textureExtendedFeatures & TEXTURE_DETAIL) != 0));
keys.add("textureFilter4Available");
values.add(new Boolean(
(textureExtendedFeatures & TEXTURE_FILTER4) != 0));
keys.add("textureAnisotropicFilterDegreeMax");
values.add(new Float(anisotropicDegreeMax));
keys.add("textureWidthMax");
values.add(new Integer(textureWidthMax));
keys.add("textureHeightMax");
values.add(new Integer(textureHeightMax));
keys.add("texture3DWidthMax");
values.add(new Integer(texture3DWidthMax));
keys.add("texture3DHeightMax");
values.add(new Integer(texture3DHeightMax));
keys.add("texture3DDepthMax");
values.add(new Integer(texture3DDepthMax));
keys.add("textureBoundaryWidthMax");
values.add(new Integer(textureBoundaryWidthMax));
keys.add("textureLodRangeAvailable");
values.add(new Boolean(
(textureExtendedFeatures & TEXTURE_LOD_RANGE) != 0));
keys.add("textureLodOffsetAvailable");
values.add(new Boolean(
(textureExtendedFeatures & TEXTURE_LOD_OFFSET) != 0));
keys.add("textureNonPowerOfTwoAvailable");
values.add(new Boolean(
(textureExtendedFeatures & TEXTURE_NON_POWER_OF_TWO) != 0));
keys.add("textureAutoMipMapGenerationAvailable");
values.add(new Boolean(
(textureExtendedFeatures & TEXTURE_AUTO_MIPMAP_GENERATION) != 0));
keys.add("textureCoordSetsMax");
values.add(new Integer(maxTexCoordSets));
keys.add("textureUnitStateMax");
values.add(new Integer(maxTextureUnits));
keys.add("textureImageUnitsMax");
values.add(new Integer(maxTextureImageUnits));
keys.add("textureImageUnitsVertexMax");
values.add(new Integer(maxVertexTextureImageUnits));
keys.add("textureImageUnitsCombinedMax");
values.add(new Integer(maxCombinedTextureImageUnits));
keys.add("vertexAttrsMax");
values.add(new Integer(maxVertexAttrs));
keys.add("shadingLanguageGLSL");
values.add(new Boolean(shadingLanguageGLSL));
keys.add("native.version");
values.add(nativeGraphicsVersion);
keys.add("native.vendor");
values.add(nativeGraphicsVendor);
keys.add("native.renderer");
values.add(nativeGraphicsRenderer);
// Now Create read-only properties object
queryProps = new J3dQueryProps(keys, values);
}
/**
* Update the view cache associated with this canvas.
*/
void updateViewCache(boolean flag, CanvasViewCache cvc,
BoundingBox frustumBBox, boolean doInfinite) {
assert cvc == null;
synchronized(cvLock) {
if (firstPaintCalled && (canvasViewCache != null)) {
assert canvasViewCacheFrustum != null;
// Issue 109 : choose the appropriate cvCache
if (frustumBBox != null) {
canvasViewCacheFrustum.snapshot(true);
canvasViewCacheFrustum.computeDerivedData(flag, null,
frustumBBox, doInfinite);
} else {
canvasViewCache.snapshot(false);
canvasViewCache.computeDerivedData(flag, null,
null, doInfinite);
}
}
}
}
/**
* Set depthBufferWriteEnableOverride flag
*/
void setDepthBufferWriteEnableOverride(boolean flag) {
depthBufferWriteEnableOverride = flag;
}
/**
* Set depthBufferEnableOverride flag
*/
void setDepthBufferEnableOverride(boolean flag) {
depthBufferEnableOverride = flag;
}
// Static initializer for Canvas3D class
static {
VirtualUniverse.loadLibraries();
}
void resetTexture(Context ctx, int texUnitIndex) {
// D3D also need to reset texture attributes
this.resetTextureNative(ctx, texUnitIndex);
if (texUnitIndex < 0) {
texUnitIndex = 0;
}
texUnitState[texUnitIndex].mirror = null;
texUnitState[texUnitIndex].texture = null;
}
// reset all attributes so that everything e.g. display list,
// texture will recreate again in the next frame
void resetRendering() {
reset();
synchronized (dirtyMaskLock) {
cvDirtyMask[0] |= VIEW_INFO_DIRTY;
cvDirtyMask[1] |= VIEW_INFO_DIRTY;
}
}
void reset() {
int i;
currentAppear = new AppearanceRetained();
currentMaterial = new MaterialRetained();
viewFrustum = new CachedFrustum();
canvasDirty = 0xffff;
lightBin = null;
environmentSet = null;
attributeBin = null;
shaderBin = null;
textureBin = null;
renderMolecule = null;
polygonAttributes = null;
lineAttributes = null;
pointAttributes = null;
material = null;
enableLighting = false;
transparency = null;
coloringAttributes = null;
shaderProgram = null;
texture = null;
texAttrs = null;
if (texUnitState != null) {
TextureUnitStateRetained tus;
for (i=0; i < texUnitState.length; i++) {
tus = texUnitState[i];
if (tus != null) {
tus.texAttrs = null;
tus.texGen = null;
}
}
}
texCoordGeneration = null;
renderingAttrs = null;
appearance = null;
appHandle = null;
dirtyRenderMoleculeList.clear();
displayListResourceFreeList.clear();
dirtyDlistPerRinfoList.clear();
textureIdResourceFreeList.clear();
lightChanged = true;
modelMatrix = null;
modelClip = null;
fog = null;
sceneAmbient = new Color3f();
for (i=0; i< frameCount.length;i++) {
frameCount[i] = -1;
}
for (i=0; i < lights.length; i++) {
lights[i] = null;
}
if (currentLights != null) {
for (i=0; i < currentLights.length; i++) {
currentLights[i] = null;
}
}
enableMask = -1;
stateUpdateMask = 0;
depthBufferWriteEnableOverride = false;
depthBufferEnableOverride = false;
depthBufferWriteEnable = true;
vfPlanesValid = false;
lightChanged = false;
for (i=0; i < curStateToUpdate.length; i++) {
curStateToUpdate[i] = null;
}
// Issue 362 - need to reset display lists and ctxTimeStamp in this
// method, so that display lists will be recreated when canvas is
// removed from a view and then added back into a view with another
// canvas
needToRebuildDisplayList = true;
ctxTimeStamp = VirtualUniverse.mc.getContextTimeStamp();
}
void resetImmediateRendering() {
canvasDirty = 0xffff;
ra = null;
setSceneAmbient(ctx, 0.0f, 0.0f, 0.0f);
disableFog(ctx);
resetRenderingAttributes(ctx, false, false);
resetTexture(ctx, -1);
resetTexCoordGeneration(ctx);
resetTextureAttributes(ctx);
texUnitState[0].texAttrs = null;
texUnitState[0].texGen = null;
resetPolygonAttributes(ctx);
resetLineAttributes(ctx);
resetPointAttributes(ctx);
resetTransparency(ctx,
RenderMolecule.SURFACE,
PolygonAttributes.POLYGON_FILL,
false, false);
resetColoringAttributes(ctx,
1.0f, 1.0f,
1.0f, 1.0f, false);
updateMaterial(ctx, 1.0f, 1.0f, 1.0f, 1.0f);
resetRendering();
makeCtxCurrent();
synchronized (dirtyMaskLock) {
cvDirtyMask[0] |= VIEW_INFO_DIRTY;
cvDirtyMask[1] |= VIEW_INFO_DIRTY;
}
needToRebuildDisplayList = true;
ctxTimeStamp = VirtualUniverse.mc.getContextTimeStamp();
}
@Override
public Point getLocationOnScreen() {
try {
return super.getLocationOnScreen();
}
catch (IllegalComponentStateException e) {}
return new Point();
}
void setProjectionMatrix(Context ctx, Transform3D projTrans) {
this.projTrans = projTrans;
setProjectionMatrix(ctx, projTrans.mat);
}
void setModelViewMatrix(Context ctx, double[] viewMatrix, Transform3D mTrans) {
setModelViewMatrix(ctx, viewMatrix, mTrans.mat);
if (!useStereo) {
this.modelMatrix = mTrans;
} else {
// TODO : This seems wrong to do only for the right eye.
// A possible approach is to invalidate the cache at begin of
// each eye.
if (rightStereoPass) {
// Only set cache in right stereo pass, otherwise
// if the left stereo pass set the cache value,
// setModelViewMatrix() in right stereo pass will not
// perform in RenderMolecules.
this.modelMatrix = mTrans;
}
}
}
void setDepthBufferWriteEnable(boolean mode) {
depthBufferWriteEnable = mode;
setDepthBufferWriteEnable(ctx, mode);
}
void setNumActiveTexUnit(int n) {
numActiveTexUnit = n;
}
int getNumActiveTexUnit() {
return numActiveTexUnit;
}
void setLastActiveTexUnit(int n) {
lastActiveTexUnit = n;
}
int getLastActiveTexUnit() {
return lastActiveTexUnit;
}
// Create the texture state array
void createTexUnitState() {
texUnitState = new TextureUnitStateRetained[maxAvailableTextureUnits];
for (int t = 0; t < maxAvailableTextureUnits; t++) {
texUnitState[t] = new TextureUnitStateRetained();
texUnitState[t].texture = null;
texUnitState[t].mirror = null;
}
}
/**
* Enable separate specular color if it is not overriden by the
* property j3d.disableSeparateSpecular.
*/
void enableSeparateSpecularColor() {
boolean enable = !VirtualUniverse.mc.disableSeparateSpecularColor;
updateSeparateSpecularColorEnable(ctx, enable);
}
// Send a createOffScreenBuffer message to Renderer (via
// MasterControl) and wait for it to be done
private void sendCreateOffScreenBuffer() {
// Wait for the buffer to be created unless called from
// a Behavior or from a Rendering thread
if (!(Thread.currentThread() instanceof BehaviorScheduler) &&
!(Thread.currentThread() instanceof Renderer)) {
offScreenBufferPending = true;
}
// Send message to Renderer thread to perform createOffScreenBuffer.
VirtualUniverse.mc.sendCreateOffScreenBuffer(this);
// Wait for off-screen buffer to be created
while (offScreenBufferPending) {
// Issue 364: create master control thread if needed
VirtualUniverse.mc.createMasterControlThread();
MasterControl.threadYield();
}
}
// Send a destroyOffScreenBuffer message to Renderer (via
// MasterControl) and wait for it to be done
private void sendDestroyCtxAndOffScreenBuffer() {
// Wait for the buffer to be destroyed unless called from
// a Behavior or from a Rendering thread
Thread currentThread = Thread.currentThread();
if (!(currentThread instanceof BehaviorScheduler) &&
!(currentThread instanceof Renderer)) {
offScreenBufferPending = true;
}
// Fix for Issue 18 and Issue 175
// Send message to Renderer thread to perform remove Ctx and destroyOffScreenBuffer.
VirtualUniverse.mc.sendDestroyCtxAndOffScreenBuffer(this);
// Wait for ctx and off-screen buffer to be destroyed
while (offScreenBufferPending) {
// Issue 364: create master control thread if needed
VirtualUniverse.mc.createMasterControlThread();
MasterControl.threadYield();
}
}
// Send a allocateCanvasId message to Renderer (via MasterControl) without
// waiting for it to be done
private void sendAllocateCanvasId() {
// Send message to Renderer thread to allocate a canvasId
VirtualUniverse.mc.sendAllocateCanvasId(this);
}
// Send a freeCanvasId message to Renderer (via MasterControl) without
// waiting for it to be done
private void sendFreeCanvasId() {
// Send message to Renderer thread to free the canvasId
VirtualUniverse.mc.sendFreeCanvasId(this);
}
private void removeCtx() {
if ((screen != null) &&
(screen.renderer != null) &&
(ctx != null)) {
VirtualUniverse.mc.postRequest(MasterControl.FREE_CONTEXT,
new Object[]{this,
Long.valueOf(0L),
drawable,
ctx});
// Fix for Issue 19
// Wait for the context to be freed unless called from
// a Behavior or from a Rendering thread
Thread currentThread = Thread.currentThread();
if (!(currentThread instanceof BehaviorScheduler) &&
!(currentThread instanceof Renderer)) {
while (ctxTimeStamp != 0) {
MasterControl.threadYield();
}
}
ctx = null;
}
}
/**
* Serialization of Canvas3D objects is not supported.
*
* @exception UnsupportedOperationException this method is not supported
*
* @since Java 3D 1.3
*/
private void writeObject(java.io.ObjectOutputStream out)
throws java.io.IOException {
throw new UnsupportedOperationException(J3dI18N.getString("Canvas3D20"));
}
/**
* Serialization of Canvas3D objects is not supported.
*
* @exception UnsupportedOperationException this method is not supported
*
* @since Java 3D 1.3
*/
private void readObject(java.io.ObjectInputStream in)
throws java.io.IOException, ClassNotFoundException {
throw new UnsupportedOperationException(J3dI18N.getString("Canvas3D20"));
}
// mark that the current bin specified by the bit is already updated
void setStateIsUpdated(int bit) {
stateUpdateMask &= ~(1 << bit);
}
// mark that the bin specified by the bit needs to be updated
void setStateToUpdate(int bit, Object bin) {
stateUpdateMask |= 1 << bit;
curStateToUpdate[bit] = bin;
}
// update LightBin, EnvironmentSet, AttributeBin & ShaderBin if neccessary
// according to the stateUpdateMask
static int ENV_STATE_MASK = (1 << LIGHTBIN_BIT) |
(1 << ENVIRONMENTSET_BIT) |
(1 << ATTRIBUTEBIN_BIT) |
(1 << SHADERBIN_BIT);
void updateEnvState() {
if ((stateUpdateMask & ENV_STATE_MASK) == 0)
return;
if ((stateUpdateMask & (1 << LIGHTBIN_BIT)) != 0) {
((LightBin)curStateToUpdate[LIGHTBIN_BIT]).updateAttributes(this);
}
if ((stateUpdateMask & (1 << ENVIRONMENTSET_BIT)) != 0) {
((EnvironmentSet)
curStateToUpdate[ENVIRONMENTSET_BIT]).updateAttributes(this);
}
if ((stateUpdateMask & (1 << ATTRIBUTEBIN_BIT)) != 0) {
((AttributeBin)
curStateToUpdate[ATTRIBUTEBIN_BIT]).updateAttributes(this);
}
if ((stateUpdateMask & (1 << SHADERBIN_BIT)) != 0) {
((ShaderBin)
curStateToUpdate[SHADERBIN_BIT]).updateAttributes(this);
}
// reset the state update mask for those environment state bits
stateUpdateMask &= ~ENV_STATE_MASK;
}
/**
* update state if neccessary according to the stateUpdatedMask
*/
void updateState( int dirtyBits) {
if (stateUpdateMask == 0)
return;
updateEnvState();
if ((stateUpdateMask & (1 << TEXTUREBIN_BIT)) != 0) {
((TextureBin)
curStateToUpdate[TEXTUREBIN_BIT]).updateAttributes(this);
}
if ((stateUpdateMask & (1 << RENDERMOLECULE_BIT)) != 0) {
((RenderMolecule)
curStateToUpdate[RENDERMOLECULE_BIT]).updateAttributes(this,
dirtyBits);
}
if ((stateUpdateMask & (1 << TRANSPARENCY_BIT)) != 0) {
((RenderMolecule)curStateToUpdate[RENDERMOLECULE_BIT]).updateTransparencyAttributes(this);
stateUpdateMask &= ~(1 << TRANSPARENCY_BIT);
}
// reset state update mask
stateUpdateMask = 0;
}
// This method updates this Texture2D for raster.
// Note : No multi-texture is not used.
void updateTextureForRaster(Texture2DRetained texture) {
// Setup texture and texture attributes for texture unit 0.
Pipeline.getPipeline().updateTextureUnitState(ctx, 0, true);
setLastActiveTexUnit(0);
setNumActiveTexUnit(1);
texture.updateNative(this);
resetTexCoordGeneration(ctx);
resetTextureAttributes(ctx);
for(int i=1; i < maxTextureUnits; i++) {
resetTexture(ctx, i);
}
// set the active texture unit back to 0
activeTextureUnit(ctx, 0);
// Force the next textureBin to reload.
canvasDirty |= Canvas3D.TEXTUREBIN_DIRTY | Canvas3D.TEXTUREATTRIBUTES_DIRTY;
}
void restoreTextureBin() {
// Need to check TextureBin's shaderBin for null
// TextureBin can get clear() if there isn't any RM under it.
if((textureBin != null) && (textureBin.shaderBin != null)) {
textureBin.updateAttributes(this);
}
}
void textureFill(RasterRetained raster, Point2d winCoord,
float mapZ, float alpha) {
int winWidth = canvasViewCache.getCanvasWidth();
int winHeight = canvasViewCache.getCanvasHeight();
int rasterImageWidth = raster.image.width;
int rasterImageHeight = raster.image.height;
float texMinU = 0, texMinV = 0, texMaxU = 0, texMaxV = 0;
float mapMinX = 0, mapMinY = 0, mapMaxX = 0, mapMaxY = 0;
Point rasterSrcOffset = new Point();
raster.getSrcOffset(rasterSrcOffset);
Dimension rasterSize = new Dimension();
raster.getSize(rasterSize);
// System.err.println("rasterImageWidth " + rasterImageWidth + " rasterImageHeight " + rasterImageHeight);
// System.err.println("rasterSrcOffset " + rasterSrcOffset + " rasterSize " + rasterSize);
int rasterMinX = rasterSrcOffset.x;
int rasterMaxX = rasterSrcOffset.x + rasterSize.width;
int rasterMinY = rasterSrcOffset.y;
int rasterMaxY = rasterSrcOffset.y + rasterSize.height;
if ((rasterMinX >= rasterImageWidth) || (rasterMinY >= rasterImageHeight) ||
(rasterMaxX <= 0) || (rasterMaxY <= 0)) {
return;
}
if (rasterMinX < 0) {
rasterMinX = 0;
}
if (rasterMinY < 0) {
rasterMinY = 0;
}
if (rasterMaxX > rasterImageWidth) {
rasterMaxX = rasterImageWidth;
}
if (rasterMaxY > rasterImageHeight) {
rasterMaxY = rasterImageHeight;
}
texMinU = (float) rasterMinX / (float) rasterImageWidth;
texMaxU = (float) rasterMaxX / (float) rasterImageWidth;
mapMinX = (float) winCoord.x / (float) winWidth;
mapMaxX = (float) (winCoord.x + (rasterMaxX - rasterMinX)) / (float) winWidth;
if (raster.image.isYUp()) {
texMinV = (float) rasterMinY / (float) rasterImageHeight;
texMaxV = (float) rasterMaxY / (float) rasterImageHeight;
} else {
// System.err.println("In yUp is false case");
texMinV = 1.0f - (float) rasterMaxY / (float) rasterImageHeight;
texMaxV = 1.0f - (float) rasterMinY / (float) rasterImageHeight;
}
mapMinY = 1.0f - ((float) (winCoord.y + (rasterMaxY - rasterMinY)) / (float) winHeight);
mapMaxY = 1.0f - ((float) winCoord.y / (float) winHeight);
textureFillRaster(ctx, texMinU, texMaxU, texMinV, texMaxV,
mapMinX, mapMaxX, mapMinY, mapMaxY, mapZ, alpha, raster.image.useBilinearFilter());
}
void textureFill(BackgroundRetained bg, int winWidth, int winHeight) {
final int maxX = bg.image.width;
final int maxY = bg.image.height;
// System.err.println("maxX " + maxX + " maxY " + maxY);
float xzoom = (float)winWidth / maxX;
float yzoom = (float)winHeight / maxY;
float zoom = 0;
float texMinU = 0, texMinV = 0, texMaxU = 0, texMaxV = 0, adjustV = 0;
float mapMinX = 0, mapMinY = 0, mapMaxX = 0, mapMaxY = 0;
float halfWidth = 0, halfHeight = 0;
switch (bg.imageScaleMode) {
case Background.SCALE_NONE:
texMinU = 0.0f;
texMinV = 0.0f;
texMaxU = 1.0f;
texMaxV = 1.0f;
halfWidth = (float)winWidth/2.0f;
halfHeight = (float)winHeight/2.0f;
mapMinX = (float) ((0 - halfWidth)/halfWidth);
mapMinY = (float) ((0 - halfHeight)/halfHeight);
mapMaxX = (float) ((maxX - halfWidth)/halfWidth);
mapMaxY = (float) ((maxY - halfHeight)/halfHeight);
adjustV = ((float)winHeight - (float)maxY)/halfHeight;
mapMinY += adjustV;
mapMaxY += adjustV;
break;
case Background.SCALE_FIT_MIN:
zoom = Math.min(xzoom, yzoom);
texMinU = 0.0f;
texMinV = 0.0f;
texMaxU = 1.0f;
texMaxV = 1.0f;
mapMinX = -1.0f;
mapMaxY = 1.0f;
if (xzoom < yzoom) {
mapMaxX = 1.0f;
mapMinY = -1.0f + 2.0f * ( 1.0f - zoom * (float)maxY/(float) winHeight );
} else {
mapMaxX = -1.0f + zoom * (float)maxX/winWidth * 2;
mapMinY = -1.0f;
}
break;
case Background.SCALE_FIT_MAX:
zoom = Math.max(xzoom, yzoom);
mapMinX = -1.0f;
mapMinY = -1.0f;
mapMaxX = 1.0f;
mapMaxY = 1.0f;
if (xzoom < yzoom) {
texMinU = 0.0f;
texMinV = 0.0f;
texMaxU = (float)winWidth/maxX/zoom;
texMaxV = 1.0f;
} else {
texMinU = 0.0f;
texMinV = 1.0f - (float)winHeight/maxY/zoom;
texMaxU = 1.0f;
texMaxV = 1.0f;
}
break;
case Background.SCALE_FIT_ALL:
texMinU = 0.0f;
texMinV = 0.0f;
texMaxU = 1.0f;
texMaxV = 1.0f;
mapMinX = -1.0f;
mapMinY = -1.0f;
mapMaxX = 1.0f;
mapMaxY = 1.0f;
break;
case Background.SCALE_REPEAT:
texMinU = 0.0f;
texMinV = - yzoom;
texMaxU = xzoom;
texMaxV = 0.0f;
mapMinX = -1.0f;
mapMinY = -1.0f;
mapMaxX = 1.0f;
mapMaxY = 1.0f;
break;
case Background.SCALE_NONE_CENTER:
// TODO : Why is there a zoom ?
if(xzoom >= 1.0f){
texMinU = 0.0f;
texMaxU = 1.0f;
mapMinX = -(float)maxX/winWidth;
mapMaxX = (float)maxX/winWidth;
} else {
texMinU = 0.5f - (float)winWidth/maxX/2;
texMaxU = 0.5f + (float)winWidth/maxX/2;
mapMinX = -1.0f;
mapMaxX = 1.0f;
}
if (yzoom >= 1.0f) {
texMinV = 0.0f;
texMaxV = 1.0f;
mapMinY = -(float)maxY/winHeight;
mapMaxY = (float)maxY/winHeight;
} else {
texMinV = 0.5f - (float)winHeight/maxY/2;
texMaxV = 0.5f + (float)winHeight/maxY/2;
mapMinY = -1.0f;
mapMaxY = 1.0f;
}
break;
}
// System.err.println("Java 3D : mapMinX " + mapMinX + " mapMinY " + mapMinY +
// " mapMaxX " + mapMaxX + " mapMaxY " + mapMaxY);
textureFillBackground(ctx, texMinU, texMaxU, texMinV, texMaxV,
mapMinX, mapMaxX, mapMinY, mapMaxY, bg.image.useBilinearFilter());
}
void clear(BackgroundRetained bg, int winWidth, int winHeight) {
// Issue 239 - clear stencil if requested and available
// Note that this is a partial solution, since we eventually want an API
// to control this.
boolean clearStencil = VirtualUniverse.mc.stencilClear &&
userStencilAvailable;
clear(ctx, bg.color.x, bg.color.y, bg.color.z, clearStencil);
// TODO : This is a bug on not mirror bg. Will fix this as a bug after 1.5 beta.
// For now, as a workaround, we will check bg.image and bg.image.imageData not null.
if((bg.image != null) && (bg.image.imageData != null)) {
// setup Texture pipe.
updateTextureForRaster(bg.texture);
textureFill(bg, winWidth, winHeight);
// Restore texture pipe.
restoreTextureBin();
}
}
/**
* obj is either TextureRetained or DetailTextureImage
* if obj is DetailTextureImage then we just clear
* the resourceCreationMask of all the formats
* no matter it is create or not since we don't
* remember the format information for simplicity.
* We don't need to check duplicate value of id in the
* table since this procedure is invoke only when id
* of texture is -1 one time only.
* This is always call from Renderer thread.
*/
void addTextureResource(int id, TextureRetained obj) {
if (id <= 0) {
return;
}
if (useSharedCtx) {
screen.renderer.addTextureResource(id, obj);
} else {
// This will replace the previous key if exists
if (textureIDResourceTable.size() <= id) {
for (int i=textureIDResourceTable.size();
i < id; i++) {
textureIDResourceTable.add(null);
}
textureIDResourceTable.add(obj);
} else {
textureIDResourceTable.set(id, obj);
}
}
}
// handle free resource in the FreeList
void freeResourcesInFreeList(Context ctx) {
Iterator<Integer> it;
int val;
// free resource for those canvases that
// don't use shared ctx
if (displayListResourceFreeList.size() > 0) {
for (it = displayListResourceFreeList.iterator(); it.hasNext();) {
val = it.next().intValue();
if (val <= 0) {
continue;
}
Canvas3D.freeDisplayList(ctx, val);
}
displayListResourceFreeList.clear();
}
if (textureIdResourceFreeList.size() > 0) {
for (it = textureIdResourceFreeList.iterator(); it.hasNext();) {
val = it.next().intValue();
if (val <= 0) {
continue;
}
if (val >= textureIDResourceTable.size()) {
System.err.println("Error in freeResourcesInFreeList : ResourceIDTableSize = " +
textureIDResourceTable.size() +
" val = " + val);
} else {
TextureRetained tex = textureIDResourceTable.get(val);
if (tex != null) {
synchronized (tex.resourceLock) {
tex.resourceCreationMask &= ~canvasBit;
if (tex.resourceCreationMask == 0) {
tex.freeTextureId(val);
}
}
}
textureIDResourceTable.set(val, null);
}
Canvas3D.freeTexture(ctx, val);
}
textureIdResourceFreeList.clear();
}
}
void freeContextResources(Renderer rdr, boolean freeBackground,
Context ctx) {
TextureRetained tex;
// Just return if we don't have a valid renderer or context
if (rdr == null || ctx == null) {
return;
}
if (freeBackground) {
// Dispose of Graphics2D Texture
if (graphics2D != null) {
graphics2D.dispose();
}
}
for (int id = textureIDResourceTable.size()-1; id >= 0; id--) {
tex = textureIDResourceTable.get(id);
if (tex == null) {
continue;
}
// Issue 403 : this assertion doesn't hold in some cases
// TODO KCR : determine why this is the case
// assert id == ((TextureRetained)obj).objectId;
Canvas3D.freeTexture(ctx, id);
synchronized (tex.resourceLock) {
tex.resourceCreationMask &= ~canvasBit;
if (tex.resourceCreationMask == 0) {
tex.freeTextureId(id);
}
}
}
textureIDResourceTable.clear();
freeAllDisplayListResources(ctx);
}
void freeAllDisplayListResources(Context ctx) {
if ((view != null) && (view.renderBin != null)) {
view.renderBin.freeAllDisplayListResources(this, ctx);
if (useSharedCtx) {
// We need to rebuild all other Canvas3D resource
// shared by this Canvas3D. Since we didn't
// remember resource in Renderer but RenderBin only.
if ((screen != null) && (screen.renderer != null)) {
screen.renderer.needToRebuildDisplayList = true;
}
}
}
}
// *****************************************************************
// Wrappers for native methods go below here
// *****************************************************************
// This is the native method for creating the underlying graphics context.
private Context createNewContext(Drawable drawable,
Context shareCtx, boolean isSharedCtx,
boolean offScreen) {
return Pipeline.getPipeline().createNewContext(this, drawable,
shareCtx, isSharedCtx,
offScreen);
}
private void createQueryContext(Drawable drawable,
boolean offScreen, int width, int height) {
Pipeline.getPipeline().createQueryContext(this, drawable,
offScreen, width, height);
}
// This is the native for creating offscreen buffer
Drawable createOffScreenBuffer(Context ctx, int width, int height) {
return Pipeline.getPipeline().createOffScreenBuffer(this,
ctx, width, height);
}
void destroyOffScreenBuffer(Context ctx, Drawable drawable) {
assert drawable != null;
Pipeline.getPipeline().destroyOffScreenBuffer(this, ctx, drawable);
}
// This is the native for reading the image from the offscreen buffer
private void readOffScreenBuffer(Context ctx, int format, int type, Object data, int width, int height) {
Pipeline.getPipeline().readOffScreenBuffer(this, ctx, format, type, data, width, height);
}
// The native method for swapBuffers
void swapBuffers(Context ctx, Drawable drawable) {
Pipeline.getPipeline().swapBuffers(this, ctx, drawable);
}
// -----------------------------------------------------------------------------
// native method for setting Material when no material is present
void updateMaterial(Context ctx, float r, float g, float b, float a) {
Pipeline.getPipeline().updateMaterialColor(ctx, r, g, b, a);
}
static void destroyContext(Drawable drawable, Context ctx) {
Pipeline.getPipeline().destroyContext(drawable, ctx);
}
// This is the native method for doing accumulation.
void accum(Context ctx, float value) {
Pipeline.getPipeline().accum(ctx, value);
}
// This is the native method for doing accumulation return.
void accumReturn(Context ctx) {
Pipeline.getPipeline().accumReturn(ctx);
}
// This is the native method for clearing the accumulation buffer.
void clearAccum(Context ctx) {
Pipeline.getPipeline().clearAccum(ctx);
}
// This is the native method for getting the number of lights the underlying
// native library can support.
int getNumCtxLights(Context ctx) {
return Pipeline.getPipeline().getNumCtxLights(ctx);
}
// Native method for decal 1st child setup
boolean decal1stChildSetup(Context ctx) {
return Pipeline.getPipeline().decal1stChildSetup(ctx);
}
// Native method for decal nth child setup
void decalNthChildSetup(Context ctx) {
Pipeline.getPipeline().decalNthChildSetup(ctx);
}
// Native method for decal reset
void decalReset(Context ctx, boolean depthBufferEnable) {
Pipeline.getPipeline().decalReset(ctx, depthBufferEnable);
}
// Native method for decal reset
void ctxUpdateEyeLightingEnable(Context ctx, boolean localEyeLightingEnable) {
Pipeline.getPipeline().ctxUpdateEyeLightingEnable(ctx, localEyeLightingEnable);
}
// The following three methods are used in multi-pass case
// native method for setting blend color
void setBlendColor(Context ctx, float red, float green,
float blue, float alpha) {
Pipeline.getPipeline().setBlendColor(ctx, red, green,
blue, alpha);
}
// native method for setting blend func
void setBlendFunc(Context ctx, int src, int dst) {
Pipeline.getPipeline().setBlendFunc(ctx, src, dst);
}
// native method for setting fog enable flag
void setFogEnableFlag(Context ctx, boolean enableFlag) {
Pipeline.getPipeline().setFogEnableFlag(ctx, enableFlag);
}
boolean isAntialiasingSet() {
return antialiasingSet;
}
// Setup the full scene antialising in D3D and ogl when GL_ARB_multisamle supported
void setFullSceneAntialiasing(Context ctx, boolean enable) {
Pipeline.getPipeline().setFullSceneAntialiasing(ctx, enable);
antialiasingSet = enable;
}
// Native method to update separate specular color control
void updateSeparateSpecularColorEnable(Context ctx, boolean control) {
Pipeline.getPipeline().updateSeparateSpecularColorEnable(ctx, control);
}
// True under Solaris,
// False under windows when display mode <= 8 bit
private boolean validGraphicsMode() {
return Pipeline.getPipeline().validGraphicsMode();
}
// native method for setting light enables
void setLightEnables(Context ctx, long enableMask, int maxLights) {
Pipeline.getPipeline().setLightEnables(ctx, enableMask, maxLights);
}
// native method for setting scene ambient
void setSceneAmbient(Context ctx, float red, float green, float blue) {
Pipeline.getPipeline().setSceneAmbient(ctx, red, green, blue);
}
// native method for disabling fog
void disableFog(Context ctx) {
Pipeline.getPipeline().disableFog(ctx);
}
// native method for disabling modelClip
void disableModelClip(Context ctx) {
Pipeline.getPipeline().disableModelClip(ctx);
}
// native method for setting default RenderingAttributes
void resetRenderingAttributes(Context ctx,
boolean depthBufferWriteEnableOverride,
boolean depthBufferEnableOverride) {
Pipeline.getPipeline().resetRenderingAttributes(ctx,
depthBufferWriteEnableOverride,
depthBufferEnableOverride);
}
// native method for setting default texture
void resetTextureNative(Context ctx, int texUnitIndex) {
Pipeline.getPipeline().resetTextureNative(ctx, texUnitIndex);
}
// native method for activating a particular texture unit
void activeTextureUnit(Context ctx, int texUnitIndex) {
Pipeline.getPipeline().activeTextureUnit(ctx, texUnitIndex);
}
// native method for setting default TexCoordGeneration
void resetTexCoordGeneration(Context ctx) {
Pipeline.getPipeline().resetTexCoordGeneration(ctx);
}
// native method for setting default TextureAttributes
void resetTextureAttributes(Context ctx) {
Pipeline.getPipeline().resetTextureAttributes(ctx);
}
// native method for setting default PolygonAttributes
void resetPolygonAttributes(Context ctx) {
Pipeline.getPipeline().resetPolygonAttributes(ctx);
}
// native method for setting default LineAttributes
void resetLineAttributes(Context ctx) {
Pipeline.getPipeline().resetLineAttributes(ctx);
}
// native method for setting default PointAttributes
void resetPointAttributes(Context ctx) {
Pipeline.getPipeline().resetPointAttributes(ctx);
}
// native method for setting default TransparencyAttributes
void resetTransparency(Context ctx, int geometryType,
int polygonMode, boolean lineAA,
boolean pointAA) {
Pipeline.getPipeline().resetTransparency(ctx, geometryType,
polygonMode, lineAA,
pointAA);
}
// native method for setting default ColoringAttributes
void resetColoringAttributes(Context ctx,
float r, float g,
float b, float a,
boolean enableLight) {
Pipeline.getPipeline().resetColoringAttributes(ctx,
r, g,
b, a,
enableLight);
}
/**
* This native method makes sure that the rendering for this canvas
* gets done now.
*/
void syncRender(Context ctx, boolean wait) {
Pipeline.getPipeline().syncRender(ctx, wait);
}
// The native method that sets this ctx to be the current one
static boolean useCtx(Context ctx, Drawable drawable) {
return Pipeline.getPipeline().useCtx(ctx, drawable);
}
// Give the Pipeline a chance to release the context. The return
// value indicates whether the context was released.
private boolean releaseCtx(Context ctx) {
return Pipeline.getPipeline().releaseCtx(ctx);
}
void clear(Context ctx, float r, float g, float b, boolean clearStencil) {
Pipeline.getPipeline().clear(ctx, r, g, b, clearStencil);
}
void textureFillBackground(Context ctx, float texMinU, float texMaxU, float texMinV, float texMaxV,
float mapMinX, float mapMaxX, float mapMinY, float mapMaxY, boolean useBiliearFilter) {
Pipeline.getPipeline().textureFillBackground(ctx, texMinU, texMaxU, texMinV, texMaxV,
mapMinX, mapMaxX, mapMinY, mapMaxY, useBiliearFilter);
}
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) {
Pipeline.getPipeline().textureFillRaster(ctx, texMinU, texMaxU, texMinV, texMaxV,
mapMinX, mapMaxX, mapMinY, mapMaxY, mapZ, alpha, useBiliearFilter);
}
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) {
Pipeline.getPipeline().executeRasterDepth(ctx, posX, posY, posZ,
srcOffsetX, srcOffsetY, rasterWidth, rasterHeight, depthWidth, depthHeight, depthType, depthData);
}
// The native method for setting the ModelView matrix.
void setModelViewMatrix(Context ctx, double[] viewMatrix, double[] modelMatrix) {
Pipeline.getPipeline().setModelViewMatrix(ctx, viewMatrix, modelMatrix);
}
// The native method for setting the Projection matrix.
void setProjectionMatrix(Context ctx, double[] projMatrix) {
Pipeline.getPipeline().setProjectionMatrix(ctx, projMatrix);
}
// The native method for setting the Viewport.
void setViewport(Context ctx, int x, int y, int width, int height) {
Pipeline.getPipeline().resizeOffscreenLayer(this, width, height);
Pipeline.getPipeline().setViewport(ctx, x, y, width, height);
}
// used for display Lists
void newDisplayList(Context ctx, int displayListId) {
Pipeline.getPipeline().newDisplayList(ctx, displayListId);
}
void endDisplayList(Context ctx) {
Pipeline.getPipeline().endDisplayList(ctx);
}
void callDisplayList(Context ctx, int id, boolean isNonUniformScale) {
Pipeline.getPipeline().callDisplayList(ctx, id, isNonUniformScale);
}
static void freeDisplayList(Context ctx, int id) {
Pipeline.getPipeline().freeDisplayList(ctx, id);
}
static void freeTexture(Context ctx, int id) {
Pipeline.getPipeline().freeTexture(ctx, id);
}
static int generateTexID(Context ctx) {
return Pipeline.getPipeline().generateTexID(ctx);
}
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) {
Pipeline.getPipeline().texturemapping(ctx,
px, py,
xmin, ymin, xmax, ymax,
texWidth, texHeight,
rasWidth,
format, objectId,
image,
winWidth, winHeight);
}
boolean initTexturemapping(Context ctx, int texWidth,
int texHeight, int objectId) {
return Pipeline.getPipeline().initTexturemapping(ctx, texWidth,
texHeight, 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.
void setRenderMode(Context ctx, int mode, boolean doubleBuffer) {
Pipeline.getPipeline().setRenderMode(ctx, mode, doubleBuffer);
}
// Set glDepthMask.
void setDepthBufferWriteEnable(Context ctx, boolean mode) {
Pipeline.getPipeline().setDepthBufferWriteEnable(ctx, mode);
}
// Methods to get actual capabilities from Canvas3D
boolean hasDoubleBuffer() {
return Pipeline.getPipeline().hasDoubleBuffer(this);
}
boolean hasStereo() {
return Pipeline.getPipeline().hasStereo(this);
}
int getStencilSize() {
return Pipeline.getPipeline().getStencilSize(this);
}
boolean hasSceneAntialiasingMultisample() {
return Pipeline.getPipeline().hasSceneAntialiasingMultisample(this);
}
boolean hasSceneAntialiasingAccum() {
return Pipeline.getPipeline().hasSceneAntialiasingAccum(this);
}
}