/**
* Causes this SurfaceObject to draw a representation of itself suitable for use during picking.
*
* @param dc the current DrawContext.
*/
protected void drawPickRepresentation(DrawContext dc)
{
// The pick representation is stored as a list of surface tiles. If the list is empty, then this surface object
// was not picked. This method might be called when the list is null or empty because of an upstream
// exception that prevented creation of the list.
if (this.pickTileBuilder == null || this.pickTileBuilder.getTileCount(dc) == 0)
{
return;
}
// Draw the pickable representation of this surface object created during preRendering.
GL2 gl = dc.getGL().getGL2(); // GL initialization checks for GL2 compatibility.
OGLStackHandler ogsh = new OGLStackHandler();
ogsh.pushAttrib(gl, GL2.GL_POLYGON_BIT); // For cull face enable, cull face, polygon mode.
try
{
gl.glEnable(GL.GL_CULL_FACE);
gl.glCullFace(GL.GL_BACK);
gl.glPolygonMode(GL2.GL_FRONT, GL2.GL_FILL);
dc.getGeographicSurfaceTileRenderer().renderTiles(dc, this.pickTileBuilder.getTiles(dc));
}
finally
{
ogsh.pop(gl);
// Clear the list of pick tiles to avoid retaining references to them in case we're never picked again.
this.pickTileBuilder.clearTiles(dc);
}
}
/**
* Draw a vertex buffer with texture coordinates in a given gl mode. Vertex buffers coming from the
* createShapeBuffer() methods support both <code>GL.GL_TRIANGLE_FAN</code> and <code>GL.LINE_STRIP</code>.
*
* @param dc the current DrawContext.
* @param mode the desired drawing GL mode.
* @param count the number of vertices to draw.
* @param verts the vertex buffer to draw.
* @param coords the buffer containing the shape texture coordinates.
*/
public static void drawBuffer(DrawContext dc, int mode, int count, DoubleBuffer verts, DoubleBuffer coords)
{
if (dc == null)
{
String message = Logging.getMessage("nullValue.DrawContextIsNull");
Logging.logger().severe(message);
throw new ArgumentException(message);
}
if (verts == null || coords == null)
{
String message = Logging.getMessage("nullValue.BufferIsNull");
Logging.logger().severe(message);
throw new ArgumentException(message);
}
GL2 gl = dc.getGL().getGL2(); // GL initialization checks for GL2 compatibility.
// Set up
gl.glPushClientAttrib(GL2.GL_CLIENT_VERTEX_ARRAY_BIT);
gl.glEnableClientState(GL2.GL_VERTEX_ARRAY);
gl.glEnableClientState(GL2.GL_TEXTURE_COORD_ARRAY);
gl.glVertexPointer(2, GL2.GL_DOUBLE, 0, verts);
gl.glTexCoordPointer(2, GL2.GL_DOUBLE, 0, coords);
// Draw
gl.glDrawArrays(mode, 0, count);
// Restore
gl.glPopClientAttrib();
}
/**
* Causes this <code>Sphere</code> to render itself using the <code>DrawContext</code> provided. <code>dc</code> may
* not be null.
*
* @param dc the <code>DrawContext</code> to be used
*
* @throws ArgumentException if <code>dc</code> is null
*/
public void render(DrawContext dc)
{
if (dc == null)
{
String msg = Logging.getMessage("nullValue.DrawContextIsNull");
Logging.logger().severe(msg);
throw new ArgumentException(msg);
}
GL2 gl = dc.getGL().getGL2(); // GL initialization checks for GL2 compatibility.
gl.glPushAttrib(GL2.GL_ENABLE_BIT | GL2.GL_CURRENT_BIT);
gl.glMatrixMode(GL2.GL_MODELVIEW);
gl.glPushMatrix();
gl.glTranslated(this.center.x, this.center.y, this.center.z);
GLUquadric quadric = dc.getGLU().gluNewQuadric();
dc.getGLU().gluQuadricDrawStyle(quadric, GLU.GLU_LINE);
dc.getGLU().gluSphere(quadric, this.radius, 10, 10);
gl.glPopMatrix();
dc.getGLU().gluDeleteQuadric(quadric);
gl.glPopAttrib();
}
public void pushModelviewIdentity(GL2 gl)
{
gl.MatrixMode(GL2.GL_MODELVIEW);
this.modelviewPushed = true;
gl.PushMatrix();
gl.LoadIdentity();
}
public void applyInternalTransform(DrawContext dc)
{
if (dc == null)
{
String message = Logging.getMessage("nullValue.DrawContextIsNull");
Logging.logger().severe(message);
throw new IllegalStateException(message);
}
Texture texture = this.getTexture(dc);
if (texture == null)
{
texture = this.requestTexture(dc);
}
if (texture == null)
{
return;
}
if (texture.getMustFlipVertically())
{
GL2 gl = dc.getGL().getGL2(); // GL initialization checks for GL2 compatibility.
gl.glMatrixMode(GL2.GL_TEXTURE);
gl.glLoadIdentity();
gl.glScaled(1, -1, 1);
gl.glTranslated(0, -1, 0);
}
}
/**
* Removes the model-view matrix on top of the matrix stack, and restores the original matrix.
*
* @param dc the current World Wind drawing context on which the original matrix will be restored.
*
* @throws ArgumentException if <code>dc</code> is null, or if the <code>Globe</code> or <code>GL</code>
* instances in <code>dc</code> are null.
*/
public void popReferenceCenter(DrawContext dc)
{
if (dc == null)
{
String message = Logging.getMessage("nullValue.DrawContextIsNull");
Logging.logger().severe(message);
throw new ArgumentException(message);
}
if (dc.getGL() == null)
{
String message = Logging.getMessage("nullValue.DrawingContextGLIsNull");
Logging.logger().severe(message);
throw new IllegalStateException(message);
}
GL2 gl = dc.getGL().getGL2(); // GL initialization checks for GL2 compatibility.
// Store the current matrix-mode state.
OGLStackHandler ogsh = new OGLStackHandler();
try
{
ogsh.pushAttrib(gl, GL2.GL_TRANSFORM_BIT);
gl.MatrixMode(GL2.GL_MODELVIEW);
// Pop the top model-view matrix.
gl.PopMatrix();
}
finally
{
ogsh.pop(gl);
}
}
public void applyInternalTransform(DrawContext dc)
{
if (dc == null)
{
String message = Logging.getMessage("nullValue.DrawContextIsNull");
Logging.logger().severe(message);
throw new IllegalStateException(message);
}
// Use the tile's texture if available.
Texture t = this.getTextureFromCache(dc);
if (t == null)
{
t = this.initializeTexture(dc, this.imageSource);
}
if (t != null)
{
if (t.getMustFlipVertically())
{
GL2 gl = dc.getGL().getGL2(); // GL initialization checks for GL2 compatibility.
gl.glMatrixMode(GL2.GL_TEXTURE);
gl.glLoadIdentity();
gl.glScaled(1, -1, 1);
gl.glTranslated(0, -1, 0);
}
}
}
public void endLighting(DrawContext dc)
{
GL2 gl = dc.getGL().getGL2(); // GL initialization checks for GL2 compatibility.
this.lightingStackHandler.pop(gl);
this.lightingStackHandler.clear();
}
/**
* Sets the GL color state to the specified {@link java.awt.Color}, and with the specified color mode. If
* <code>premultiplyColors</code> is true, this premultipies the Red, Green, and Blue color values by the Alpha
* value. Otherwise, this does not modify the Red, Green, and Blue color values.
*
* @param gl the GL context.
* @param color the Red, Green, Blue, and Alpha values to set.
* @param premultiplyColors true to premultiply the Red, Green and Blue color values by the Alpha value, false to
* leave the Red, Green, and Blue values unmodified.
*
* @throws ArgumentException if the GL is null, if the Color is null, if the opacity is less than 0, or if
* the opacity is greater than 1.
*/
public static void applyColor(GL2 gl, java.awt.Color color, bool premultiplyColors)
{
if (gl == null)
{
String message = Logging.getMessage("nullValue.GLIsNull");
Logging.logger().severe(message);
throw new ArgumentException(message);
}
if (color == null)
{
String message = Logging.getMessage("nullValue.ColorIsNull");
Logging.logger().severe(message);
throw new ArgumentException(message);
}
float[] compArray = new float[4];
color.getRGBComponents(compArray);
if (premultiplyColors)
{
compArray[0] *= compArray[3];
compArray[1] *= compArray[3];
compArray[2] *= compArray[3];
}
gl.glColor4fv(compArray, 0);
}
/**
* Sets the GL lighting state to a white light originating from the eye position and pointed in the specified
* direction, in model coordinates. The light direction is always relative to the current eye point and viewer
* direction. If the direction is null, this the light direction defaults to (0, 0, -1), which points directly along
* the forward vector form the eye point
*
* @param gl the GL context.
* @param light the GL light name to set.
* @param direction the light direction in model coordinates, may be null.
*
* @throws ArgumentException if the GL is null.
*/
public static void applyLightingDirectionalFromViewer(GL2 gl, int light, Vec4 direction)
{
if (gl == null)
{
String message = Logging.getMessage("nullValue.GLIsNull");
Logging.logger().severe(message);
throw new ArgumentException(message);
}
if (direction == null)
{
direction = DEFAULT_LIGHT_DIRECTION;
}
float[] ambient = { 1f, 1f, 1f, 0f };
float[] diffuse = { 1f, 1f, 1f, 0f };
float[] specular = { 1f, 1f, 1f, 0f };
float[] position = { (float)direction.x, (float)direction.y, (float)direction.z, 0.0f };
gl.glLightfv(light, GL2.GL_AMBIENT, ambient, 0);
gl.glLightfv(light, GL2.GL_DIFFUSE, diffuse, 0);
gl.glLightfv(light, GL2.GL_SPECULAR, specular, 0);
OGLStackHandler ogsh = new OGLStackHandler();
ogsh.pushModelviewIdentity(gl);
try
{
gl.glLightfv(light, GL2.GL_POSITION, position, 0);
}
finally
{
ogsh.pop(gl);
}
}
public void pop(GL2 gl)
{
if (this.attribsPushed)
{
gl.PopAttrib();
this.attribsPushed = false;
}
if (this.clientAttribsPushed)
{
gl.PopClientAttrib();
this.clientAttribsPushed = false;
}
if (this.modelviewPushed)
{
gl.MatrixMode(GL2.GL_MODELVIEW);
gl.PopMatrix();
this.modelviewPushed = false;
}
if (this.projectionPushed)
{
gl.MatrixMode(GL2.GL_PROJECTION);
gl.PopAttrib();
this.projectionPushed = false;
}
if (this.texturePushed)
{
gl.MatrixMode(GL2.GL_TEXTURE);
gl.PopMatrix();
this.texturePushed = false;
}
}
public void pushTextureIdentity(GL2 gl)
{
gl.MatrixMode(GL2.GL_TEXTURE);
this.texturePushed = true;
gl.PushMatrix();
gl.LoadIdentity();
}
public void pushProjectionIdentity(GL2 gl)
{
gl.MatrixMode(GL2.GL_PROJECTION);
this.projectionPushed = true;
gl.PushMatrix();
gl.LoadIdentity();
}
/**
* Flushes any buffered pixel values to the appropriate texure targets, then restores the GL state to its previous
* configuration before {@link #beginRendering(gov.nasa.worldwind.render.DrawContext, int, int, int, int)} was
* called. Finally, all texture targets associated with this OGLRenderToTextureSupport are unbound.
*
* @param dc the current DrawContext.
*
* @throws ArgumentException if the DrawContext is null.
*/
public void endRendering(DrawContext dc)
{
if (dc == null)
{
String message = Logging.getMessage("nullValue.DrawContextIsNull");
Logging.logger().severe(message);
throw new ArgumentException(message);
}
GL2 gl = dc.getGL().getGL2(); // GL initialization checks for GL2 compatibility.
this.flush(dc);
if (this.useFramebufferObject(dc))
{
if (this.colorTarget != null)
{
this.bindFramebufferColorAttachment(dc, null);
}
this.endFramebufferObjectRendering(dc);
}
this.stackHandler.pop(gl);
this.drawRegion = null;
this.colorTarget = null;
}
public Matrix pushReferenceCenter(DrawContext dc, Vec4 referenceCenter)
{
if (dc == null)
{
String message = Logging.getMessage("nullValue.DrawContextIsNull");
Logging.logger().severe(message);
throw new ArgumentException(message);
}
if (dc.getGL() == null)
{
String message = Logging.getMessage("nullValue.DrawingContextGLIsNull");
Logging.logger().severe(message);
throw new IllegalStateException(message);
}
if (referenceCenter == null)
{
String message = Logging.getMessage("nullValue.PointIsNull");
Logging.logger().severe(message);
throw new ArgumentException(message);
}
Matrix modelview = getModelviewMatrix();
// Compute a new model-view matrix with origin at referenceCenter.
Matrix matrix = null;
if (modelview != null)
{
matrix = modelview.multiply(Matrix.fromTranslation(referenceCenter));
}
GL2 gl = dc.getGL().getGL2(); // GL initialization checks for GL2 compatibility.
// Store the current matrix-mode state.
OGLStackHandler ogsh = new OGLStackHandler();
try
{
ogsh.pushAttrib(gl, GL2.GL_TRANSFORM_BIT);
gl.MatrixMode(GL2.GL_MODELVIEW);
// Push and load a new model-view matrix to the current OpenGL context held by 'dc'.
gl.PushMatrix();
if (matrix != null)
{
double[] matrixArray = new double[16];
matrix.toArray(matrixArray, 0, false);
gl.LoadMatrix(matrixArray);
}
}
finally
{
ogsh.pop(gl);
}
return(matrix);
}
public void endPicking(DrawContext dc)
{
GL2 gl = dc.getGL().getGL2(); // GL initialization checks for GL2 compatibility.
gl.glPopAttrib();
// Some nvidia Quadro cards have a bug in which the current color is not restored. Restore it to the
// default here.
gl.glColor3ub((byte)255, (byte)255, (byte)255);
}
/**
* Creates a new {@link javax.media.opengl.glu.GLUtessellatorCallback} that draws tessellated polygons as OpenGL
* primitives by calling glBegin, glEnd, and glVertex.
*
* @param gl the GL context to draw into.
*
* @return a new GLUtessellatorCallback for drawing tessellated polygons as OpenGL primtives.
*
* @throws ArgumentException if the GL is null.
*/
public static GLUtessellatorCallback createOGLDrawPrimitivesCallback(GL2 gl)
{
if (gl == null)
{
String message = Logging.getMessage("nullValue.GLIsNull");
Logging.logger().severe(message);
throw new ArgumentException(message);
}
return(new OGLDrawPrimitivesCallback(gl));
}
protected void drawOutline(DrawContext dc, Vec4 a, Vec4 b, Vec4 c, Vec4 d)
{
GL2 gl = dc.getGL().getGL2(); // GL initialization checks for GL2 compatibility.
gl.glBegin(GL2.GL_LINE_LOOP);
gl.glVertex3d(a.x, a.y, a.z);
gl.glVertex3d(b.x, b.y, b.z);
gl.glVertex3d(c.x, c.y, c.z);
gl.glVertex3d(d.x, d.y, d.z);
gl.glEnd();
}
protected void endDrawAnnotations(DrawContext dc, OGLStackHandler stackHandler)
{
GL2 gl = dc.getGL().getGL2(); // GL initialization checks for GL2 compatibility.
if (dc.isPickingMode())
{
this.pickSupport.endPicking(dc);
}
stackHandler.pop(gl);
}
public OGLDrawPrimitivesCallback(GL2 gl)
{
if (gl == null)
{
String message = Logging.getMessage("nullValue.GLIsNull");
Logging.logger().severe(message);
throw new ArgumentException(message);
}
this.gl = gl;
}
/**
* Detects the locations of the sector geometries in this list that intersect a specified screen point.
* <p/>
* Note: Prior to calling this method, {@link #beginRendering(gov.nasa.worldwind.render.DrawContext)} must be
* called.
*
* @param dc the current draw context.
* @param pickPoint the screen point to test.
*/
public void pick(DrawContext dc, java.awt.Point pickPoint)
{
if (dc == null)
{
String message = Logging.getMessage("nullValue.DrawContextIsNull");
Logging.logger().severe(message);
throw new IllegalStateException(message);
}
if (pickPoint == null)
{
return;
}
this.pickSupport.clearPickList();
this.pickSupport.beginPicking(dc);
GL2 gl = dc.getGL().getGL2(); // GL initialization checks for GL2 compatibility.
gl.glShadeModel(GL2.GL_FLAT);
try
{
// render each sector in unique color
this.beginRendering(dc);
foreach (SectorGeometry sector in this)
{
Color color = dc.getUniquePickColor();
gl.glColor3ub((byte)color.getRed(), (byte)color.getGreen(), (byte)color.getBlue());
sector.render(dc);
// lat/lon/elevation not used in this case
this.pickSupport.addPickableObject(color.getRGB(), sector, Position.ZERO, true);
}
PickedObject pickedSector = this.pickSupport.getTopObject(dc, pickPoint);
if (pickedSector == null || pickedSector.getObject() == null)
{
return; // no sector picked
}
this.beginSectorGeometryPicking(dc);
SectorGeometry sector = (SectorGeometry)pickedSector.getObject();
sector.pick(dc, pickPoint);
}
finally
{
this.endSectorGeometryPicking(dc);
this.endRendering(dc);
gl.glShadeModel(GL2.GL_SMOOTH); // restore to default explicitly to avoid more expensive pushAttrib
this.pickSupport.endPicking(dc);
this.pickSupport.clearPickList();
}
}
protected void apply(DrawContext dc)
{
GL2 gl = dc.getGL().getGL2(); // GL initialization checks for GL2 compatibility.
gl.glEnable(GL2.GL_LIGHTING);
applyStandardLightModel(gl);
applyStandardShadeModel(gl);
gl.glEnable(GL2.GL_LIGHT0);
applyStandardLightMaterial(gl, GL2.GL_LIGHT0, this.lightMaterial);
applyStandardLightDirection(gl, GL2.GL_LIGHT0, this.lightDirection);
}
public void beginLighting(DrawContext dc)
{
if (this.lightingStackHandler.isActive())
{
return; // lighting is already enabled
}
GL2 gl = dc.getGL().getGL2(); // GL initialization checks for GL2 compatibility.
this.lightingStackHandler.pushAttrib(gl, GL2.GL_LIGHTING_BIT);
this.apply(dc);
}
public void endDrawAnnotations(DrawContext dc)
{
if (dc == null)
{
String message = Logging.getMessage("nullValue.DrawContextIsNull");
Logging.logger().severe(message);
throw new ArgumentException(message);
}
GL2 gl = dc.getGL().getGL2(); // GL initialization checks for GL2 compatibility.
this.stackHandler.pop(gl);
}
protected void applyStandardLightModel(GL2 gl)
{
float[] modelAmbient = new float[4];
modelAmbient[0] = 1.0f;
modelAmbient[1] = 1.0f;
modelAmbient[2] = 1.0f;
modelAmbient[3] = 0.0f;
gl.glLightModelfv(GL2.GL_LIGHT_MODEL_AMBIENT, modelAmbient, 0);
gl.glLightModeli(GL2.GL_LIGHT_MODEL_LOCAL_VIEWER, GL2.GL_TRUE);
// gl.glLightModeli(GL2.GL_LIGHT_MODEL_TWO_SIDE, GL2.GL_FALSE);
gl.glLightModeli(GL2.GL_LIGHT_MODEL_TWO_SIDE, GL2.GL_TRUE);
}
//**************************************************************//
//******************** Diagnostic Support ********************//
//**************************************************************//
/**
* Causes this SurfaceObject to render its bounding sectors to the specified region in geographic coordinates. The
* specified viewport denotes the geographic region and its corresponding screen viewport.
* <p/>
* The bounding sectors are rendered as a 1 pixel wide green outline.
*
* @param dc the current DrawContext.
* @param sdc the context containing a geographic region and screen viewport corresponding to a surface tile.
*
* @see #getSectors(DrawContext)
*/
protected void drawBoundingSectors(DrawContext dc, SurfaceTileDrawContext sdc)
{
List <Sector> sectors = this.getSectors(dc);
if (sectors == null)
{
return;
}
GL2 gl = dc.getGL().getGL2(); // GL initialization checks for GL2 compatibility.
int attributeMask =
GL2.GL_COLOR_BUFFER_BIT // For alpha test enable, blend enable, alpha func, blend func.
| GL2.GL_CURRENT_BIT // For current color.
| GL2.GL_LINE_BIT; // For line smooth, line width.
OGLStackHandler ogsh = new OGLStackHandler();
ogsh.pushAttrib(gl, attributeMask);
ogsh.pushModelview(gl);
try
{
gl.glEnable(GL.GL_BLEND);
OGLUtil.applyBlending(gl, false);
gl.glDisable(GL.GL_LINE_SMOOTH);
gl.glLineWidth(1f);
gl.glColor4f(1f, 1f, 1f, 0.5f);
// Set the model-view matrix to transform from geographic coordinates to viewport coordinates.
Matrix matrix = sdc.getModelviewMatrix();
gl.glMultMatrixd(matrix.toArray(new double[16], 0, false), 0);
foreach (Sector s in sectors)
{
LatLon[] corners = s.getCorners();
gl.glBegin(GL2.GL_LINE_LOOP);
gl.glVertex2f((float)corners[0].getLongitude().degrees, (float)corners[0].getLatitude().degrees);
gl.glVertex2f((float)corners[1].getLongitude().degrees, (float)corners[1].getLatitude().degrees);
gl.glVertex2f((float)corners[2].getLongitude().degrees, (float)corners[2].getLatitude().degrees);
gl.glVertex2f((float)corners[3].getLongitude().degrees, (float)corners[3].getLatitude().degrees);
gl.glEnd();
}
}
finally
{
ogsh.pop(gl);
}
}
protected void finalizeFrame(DrawContext dc)
{
GL2 gl = dc.getGL().getGL2(); // GL initialization checks for GL2 compatibility.
gl.glMatrixMode(GL2.GL_MODELVIEW);
gl.glPopMatrix();
gl.glMatrixMode(GL2.GL_PROJECTION);
gl.glPopMatrix();
gl.glPopAttrib();
// checkGLErrors(dc);
}
protected void beginDrawAnnotations(DrawContext dc, OGLStackHandler stackHandler)
{
GL2 gl = dc.getGL().getGL2(); // GL initialization checks for GL2 compatibility.
int attributeMask = GL2.GL_COLOR_BUFFER_BIT // for alpha test func and ref, blend func
| GL2.GL_CURRENT_BIT // for current color
| GL2.GL_DEPTH_BUFFER_BIT // for depth test, depth mask, depth func
| GL2.GL_ENABLE_BIT // for enable/disable changes
| GL2.GL_HINT_BIT // for line smoothing hint
| GL2.GL_LINE_BIT // for line width, line stipple
| GL2.GL_TRANSFORM_BIT // for matrix mode
| GL2.GL_VIEWPORT_BIT; // for viewport, depth range
stackHandler.pushAttrib(gl, attributeMask);
// Load a parallel projection with dimensions (viewportWidth, viewportHeight)
stackHandler.pushProjectionIdentity(gl);
gl.glOrtho(0d, dc.getView().getViewport().width, 0d, dc.getView().getViewport().height, -1d, 1d);
// Push identity matrices on the texture and modelview matrix stacks. Leave the matrix mode as modelview.
stackHandler.pushTextureIdentity(gl);
stackHandler.pushModelviewIdentity(gl);
// Enable the alpha test.
gl.glEnable(GL2.GL_ALPHA_TEST);
gl.glAlphaFunc(GL2.GL_GREATER, 0.0f);
// Apply the depth buffer but don't change it.
if ((!dc.isDeepPickingEnabled()))
{
gl.glEnable(GL.GL_DEPTH_TEST);
}
gl.glDepthMask(false);
// Disable lighting and backface culling.
gl.glDisable(GL2.GL_LIGHTING);
gl.glDisable(GL.GL_CULL_FACE);
if (!dc.isPickingMode())
{
// Enable blending in premultiplied color mode.
gl.glEnable(GL.GL_BLEND);
OGLUtil.applyBlending(gl, true);
}
else
{
this.pickSupport.beginPicking(dc);
}
}
public void apply(GL2 gl, int face)
{
if (gl == null)
{
String msg = Logging.getMessage("nullValue.GLIsNull");
Logging.logger().severe(msg);
throw new ArgumentException(msg);
}
glMaterial(gl, face, GL2.GL_AMBIENT, this.ambient);
glMaterial(gl, face, GL2.GL_DIFFUSE, this.diffuse);
glMaterial(gl, face, GL2.GL_SPECULAR, this.specular);
glMaterial(gl, face, GL2.GL_EMISSION, this.emission);
gl.glMaterialf(face, GL2.GL_SHININESS, (float)this.shininess);
}
/**
* Implement no stereo ("Mono") while using a stereo device.
* <p/>
* Note that this method draws the image twice, once to each of the left and right eye buffers, even when stereo is
* not in effect. This is to prevent the stereo device from drawing blurred scenes.
*
* @param dc the current draw context.
*/
protected void doDrawStereoNone(DrawContext dc)
{
// If running on a stereo device but want to draw a normal image, both buffers must be filled or the
// display will be blurry.
GL2 gl = dc.getGL().getGL2(); // GL initialization checks for GL2 compatibility.
gl.glDrawBuffer(GL2.GL_BACK_LEFT);
gl.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT);
super.draw(dc);
gl.glDrawBuffer(GL2.GL_BACK_RIGHT);
gl.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT);
super.draw(dc);
}
