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); } }
//**************************************************************// //******************** 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); } }
/** * Configures the GL attached to the specified DrawContext for rendering a 2D model to a texture. The modelview * matrix is set to the identity, the projection matrix is set to an orthographic projection aligned with the * specified draw rectangle (x, y, width, height), the viewport and scissor boxes are set to the specified draw * rectangle, and the depth test and depth write flags are disabled. Because the viewport and scissor boxes are set * to the draw rectangle, only the texels intersecting the specified drawing rectangle (x, y, width, height) are * affected by GL commands. Once rendering is complete, this should always be followed with a call to {@link * #endRendering(gov.nasa.worldwind.render.DrawContext)}. * * @param dc the current DrawContext. * @param x the x-coordinate of the draw region's lower left corner. * @param y the y-coordinate of the draw region's lower left corner. * @param width the draw region width. * @param height the draw region height. * * @throws ArgumentException if the DrawContext is null. */ public void beginRendering(DrawContext dc, int x, int y, int width, int height) { 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.drawRegion = new java.awt.Rectangle(x, y, width, height); // Note: there is no attribute bit for framebuffer objects. The default framebuffer object state (object ID 0 // is bound as the current fbo) is restored in endRendering(). this.stackHandler.pushAttrib(gl, GL2.GL_COLOR_BUFFER_BIT // For clear color. | GL2.GL_DEPTH_BUFFER_BIT // For depth test and depth mask. | GL2.GL_SCISSOR_BIT // For scissor test and scissor box. | GL2.GL_TRANSFORM_BIT // For matrix mode. | GL2.GL_VIEWPORT_BIT); // For viewport state. this.stackHandler.pushTextureIdentity(gl); this.stackHandler.pushProjectionIdentity(gl); gl.glOrtho(x, x + width, y, y + height, -1, 1); this.stackHandler.pushModelviewIdentity(gl); // Disable the depth test and writing to the depth buffer. This provides consistent render to texture behavior // regardless of whether we are using copy-to-texture or framebuffer objects. For copy-to-texture, the depth // test and depth writing are explicitly disabled. For fbos there is no depth buffer components, so the depth // dest is implicitly disabled. gl.glDisable(GL.GL_DEPTH_TEST); gl.glDepthMask(false); // Enable the scissor test and set both the scissor box and the viewport to the specified region. This enables // the caller to set up rendering to a subset of the texture. Note that the scissor box defines the region // affected by a call to glClear(). gl.glEnable(GL.GL_SCISSOR_TEST); gl.glScissor(x, y, width, height); gl.glViewport(x, y, width, height); if (this.useFramebufferObject(dc)) { this.beginFramebufferObjectRendering(dc); } }
public void beginPicking(DrawContext dc) { GL2 gl = dc.getGL().getGL2(); // GL initialization checks for GL2 compatibility. gl.glPushAttrib(GL2.GL_ENABLE_BIT | GL2.GL_CURRENT_BIT); gl.glDisable(GL.GL_DITHER); gl.glDisable(GL2.GL_LIGHTING); gl.glDisable(GL2.GL_FOG); gl.glDisable(GL.GL_BLEND); gl.glDisable(GL.GL_TEXTURE_2D); if (dc.isDeepPickingEnabled()) { gl.glDisable(GL.GL_DEPTH_TEST); } }
protected bool generateTexture(DrawContext dc, int width, int height) { GL2 gl = dc.getGL().getGL2(); // GL initialization checks for GL2 compatibility. OGLStackHandler ogsh = new OGLStackHandler(); Matrix geoToCartesian = this.computeGeographicToCartesianTransform(this.sector); try { ogsh.pushAttrib(gl, GL2.GL_COLOR_BUFFER_BIT | GL2.GL_ENABLE_BIT | GL2.GL_TRANSFORM_BIT | GL2.GL_VIEWPORT_BIT); // Fill the frame buffer with transparent black. gl.glClearColor(0f, 0f, 0f, 0f); gl.glClear(GL.GL_COLOR_BUFFER_BIT); gl.glDisable(GL.GL_BLEND); gl.glDisable(GL.GL_CULL_FACE); gl.glDisable(GL.GL_DEPTH_TEST); // Setup a viewport with the dimensions of the texture, and a projection matrix of dimension 2.0 (along // each axis) centered at the origin. Using a projection matrix with these dimensions ensures that incoming // vertices are rasterized without any rounding error. ogsh.pushProjectionIdentity(gl); gl.glViewport(0, 0, width, height); gl.glOrtho(-1d, 1d, -1d, 1d, -1d, 1d); ogsh.pushModelviewIdentity(gl); ogsh.pushTextureIdentity(gl); if (this.sourceTexture != null) { try { gl.glEnable(GL.GL_TEXTURE_2D); if (!this.sourceTexture.bind(dc)) { return(false); } this.sourceTexture.applyInternalTransform(dc); // Setup the texture to replace the fragment color at each pixel. gl.glTexEnvf(GL2.GL_TEXTURE_ENV, GL2.GL_TEXTURE_ENV_MODE, GL2.GL_REPLACE); int tessellationDensity = this.getTessellationDensity(); this.drawQuad(dc, geoToCartesian, tessellationDensity, tessellationDensity); } finally { gl.glTexEnvf(GL2.GL_TEXTURE_ENV, GL2.GL_TEXTURE_ENV_MODE, OGLUtil.DEFAULT_TEX_ENV_MODE); gl.glBindTexture(GL.GL_TEXTURE_2D, 0); } } } finally { ogsh.pop(gl); } return(true); }