/** paint the portal using gl. */ public void paint(GL gl, GLDrawable glc) { if (fill != null) { setColor(gl, fill); gl.glDisable(GL.GL_TEXTURE_2D); } gl.glLineWidth(lineWidth()); gl.glBegin(GL.GL_LINES); // draw each wall for (int i = 0; i < pts2d.size(); i++) { Point2D p = (Point2D) (pts2d.get(i)); gl.glVertex2d(p.x, p.y); } gl.glEnd(); if (pts2d.size() == 4) { /* Connect mid point of the two line segments with dotted line*/ gl.glLineStipple(1, (short) 0x0F0F); gl.glEnable(GL.GL_LINE_STIPPLE); gl.glLineWidth(1); gl.glBegin(GL.GL_LINES); Point2D mid = pts2d.get(0).interp(pts2d.get(1), 0.5); gl.glVertex2d(mid.x, mid.y); mid = pts2d.get(2).interp(pts2d.get(3), 0.5); gl.glVertex2d(mid.x, mid.y); gl.glEnd(); gl.glDisable(GL.GL_LINE_STIPPLE); } }
private void renderPin(GL gl, Coordinates position, float[] color, float size) { float height = heightmap.getHeight(projection.getGeoCoordinates(position)); gl.glPushMatrix(); double[] model = new double[16]; gl.glGetDoublev(GL_MODELVIEW_MATRIX, model, 0); double zoomH = 0.1 / Math.sqrt((model[0] * model[0]) + (model[1] * model[1]) + (model[2] * model[2])); double zoomZ = 0.1 / Math.sqrt((model[8] * model[8]) + (model[9] * model[9]) + (model[10] * model[10])); gl.glTranslatef(position.getLongitude(), position.getLatitude(), height); gl.glScaled(zoomH * size, zoomH * size, zoomZ * size); gl.glDisable(GL_TEXTURE_2D); gl.glRotatef(20, 0.3f, 1, 0); GLU glu = new GLU(); GLUquadric quadric = glu.gluNewQuadric(); // glu.gluQuadricNormals(quadric, GLU.GLU_FLAT); gl.glColor3f(0.5f, 0.5f, 0.5f); gl.glEnable(GL_LIGHTING); glu.gluCylinder(quadric, 0.03, 0.03, 0.6f, 5, 1); gl.glTranslatef(0, 0, 0.6f); gl.glColor3f(color[0], color[1], color[2]); gl.glColorMaterial(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE); glu.gluSphere(quadric, 0.12, 8, 8); // glu.gluCylinder(quadric, 0.2, 0.1, 0.5, 8, 1); gl.glDisable(GL_LIGHTING); glu.gluDeleteQuadric(quadric); gl.glPopMatrix(); }
/** Applies fixed function bindings from the context to OpenGL */ private void applyFixedFuncBindings(boolean forLighting) { GL gl = GLContext.getCurrentGL(); if (forLighting) { gl.getGL2().glMaterialf(GL.GL_FRONT_AND_BACK, GLLightingFunc.GL_SHININESS, context.shininess); setMaterialColor(GLLightingFunc.GL_AMBIENT, context.ambient, ColorRGBA.DarkGray); setMaterialColor(GLLightingFunc.GL_DIFFUSE, context.diffuse, ColorRGBA.White); setMaterialColor(GLLightingFunc.GL_SPECULAR, context.specular, ColorRGBA.Black); if (context.useVertexColor) { gl.glEnable(GLLightingFunc.GL_COLOR_MATERIAL); } else { gl.glDisable(GLLightingFunc.GL_COLOR_MATERIAL); } } else { // Ignore other values as they have no effect when // GL_LIGHTING is disabled. ColorRGBA color = context.color; if (color != null) { gl.getGL2().glColor4f(color.r, color.g, color.b, color.a); } else { gl.getGL2().glColor4f(1, 1, 1, 1); } } if (context.alphaTestFallOff > 0f) { gl.glEnable(GL2ES1.GL_ALPHA_TEST); gl.getGL2ES1().glAlphaFunc(GL.GL_GREATER, context.alphaTestFallOff); } else { gl.glDisable(GL2ES1.GL_ALPHA_TEST); } }
public void desenhar(GL gl, GLUT glut) { gl.glShadeModel(GL.GL_FLAT); gl.glNormal3f(0.0f, 0.0f, 1.0f); gl.glColor3f(1f, 1f, 1f); float corWhite[] = {1.0f, 1.0f, 1.0f, 1.0f}; // base setTexture(Util.loadImage("texture/textureBrick.png")); getTexture().enable(); getTexture().bind(); gl.glMaterialfv(GL.GL_FRONT, GL.GL_AMBIENT_AND_DIFFUSE, corWhite, 0); gl.glEnable(GL.GL_LIGHTING); gl.glPushMatrix(); gl.glTranslatef(0f, -dif, 0f); gl.glScalef(getxEscala(), getyEscala(), getzEscala()); glut.glutSolidCube(1f); gl.glPopMatrix(); // esquerda setTexture(Util.loadImage("texture/tijolos/medio2.png")); getTexture().enable(); getTexture().bind(); gl.glPushMatrix(); gl.glTranslatef(-(getxEscala() / 2), (getAltura() / 2) - dif, 0f); gl.glScalef(0.1f, getAltura(), getzEscala()); glut.glutSolidCube(1f); gl.glPopMatrix(); gl.glDisable(GL.GL_LIGHTING); // direita setTexture(Util.loadImage("texture/tijolos/medio2.png")); getTexture().enable(); getTexture().bind(); gl.glPushMatrix(); gl.glTranslatef(getxEscala() / 2, (getAltura() / 2) - dif, 0f); gl.glScalef(0.1f, getAltura(), getzEscala()); glut.glutSolidCube(1f); gl.glPopMatrix(); gl.glDisable(GL.GL_LIGHTING); // fundo setTexture(Util.loadImage("texture/tijolos/fraco.png")); getTexture().enable(); getTexture().bind(); gl.glPushMatrix(); gl.glTranslatef(0f, (getAltura() / 2) - dif, -(getzEscala() / 2)); gl.glScalef(getxEscala(), getAltura(), 0.1f); glut.glutSolidCube(1f); gl.glPopMatrix(); gl.glDisable(GL.GL_LIGHTING); }
/** * Establish the OpenGL state needed to draw text. * * @param dc the current draw context. */ protected void beginDrawing(DrawContext dc) { GL gl = dc.getGL(); int attrMask = GL.GL_DEPTH_BUFFER_BIT // for depth test, depth mask and depth func | GL.GL_TRANSFORM_BIT // for modelview and perspective | GL.GL_VIEWPORT_BIT // for depth range | GL.GL_CURRENT_BIT // for current color | GL.GL_COLOR_BUFFER_BIT // for alpha test func and ref, and blend | GL.GL_DEPTH_BUFFER_BIT // for depth func | GL.GL_ENABLE_BIT; // for enable/disable changes this.BEogsh.pushAttrib(gl, attrMask); if (!dc.isPickingMode()) { gl.glEnable(GL.GL_BLEND); OGLUtil.applyBlending(gl, false); } // Do not depth buffer the label. (Labels beyond the horizon are culled above.) gl.glDisable(GL.GL_DEPTH_TEST); gl.glDepthMask(false); // The image is drawn using a parallel projection. this.BEogsh.pushProjectionIdentity(gl); gl.glOrtho( 0d, dc.getView().getViewport().width, 0d, dc.getView().getViewport().height, -1d, 1d); this.BEogsh.pushModelviewIdentity(gl); }
public void updateSelectedOctant(GL gl, GLU glu, float[] mousePosition, float[] pickRectangle) { // Start Picking mode int capacity = 1 * 4 * visibleLeaves.size(); // Each object take in maximium : 4 * name stack depth IntBuffer hitsBuffer = BufferUtil.newIntBuffer(capacity); gl.glSelectBuffer(hitsBuffer.capacity(), hitsBuffer); gl.glRenderMode(GL.GL_SELECT); gl.glDisable(GL.GL_CULL_FACE); // Disable flags gl.glInitNames(); gl.glPushName(0); gl.glMatrixMode(GL.GL_PROJECTION); gl.glPushMatrix(); gl.glLoadIdentity(); glu.gluPickMatrix( mousePosition[0], mousePosition[1], pickRectangle[0], pickRectangle[1], drawable.getViewport()); gl.glMultMatrixd(drawable.getProjectionMatrix()); gl.glMatrixMode(GL.GL_MODELVIEW); // Draw the nodes' cube int the select buffer int hitName = 1; for (int i = 0; i < visibleLeaves.size(); i++) { Octant node = visibleLeaves.get(i); gl.glLoadName(hitName); node.displayOctant(gl); hitName++; } // Restoring the original projection matrix gl.glMatrixMode(GL.GL_PROJECTION); gl.glPopMatrix(); gl.glMatrixMode(GL.GL_MODELVIEW); gl.glFlush(); // Returning to normal rendering mode int nbRecords = gl.glRenderMode(GL.GL_RENDER); if (vizController.getVizModel().isCulling()) { gl.glEnable(GL.GL_CULL_FACE); gl.glCullFace(GL.GL_BACK); } // Clean previous selection selectedLeaves.clear(); // Get the hits and put the node under selection in the selectionArray for (int i = 0; i < nbRecords; i++) { int hit = hitsBuffer.get(i * 4 + 3) - 1; // -1 Because of the glPushName(0) Octant nodeHit = visibleLeaves.get(hit); selectedLeaves.add(nodeHit); } }
@Override public void display(GLContext context) { initializeNewMembers(context, true); validateLayout(context); validateListenerShapes(context); Rectangle b = getBounds(); if (b.width == 0 || b.height == 0) return; GL gl = context.getGL(); try { gl.glEnable(GL.GL_SCISSOR_TEST); // TODO: scissor so as not to overrun the parent viewport // TODO: reconcile viewport with GLGlimpseListener viewport call gl.glViewport(b.x, b.y, b.width, b.height); gl.glScissor(b.x, b.y, b.width, b.height); for (Member m : members) { if (m.callback != null) m.callback.preDisplay(m.listener, context, isHovered()); m.listener.display(context); if (m.callback != null) m.callback.postDisplay(m.listener, context, isHovered()); } } finally { gl.glDisable(GL.GL_SCISSOR_TEST); } }
public void render3D(GL gl, GLDrawable glc) { if (pts2d.size() < 4) return; if (fill != null || texture != null) { if (texture == null) { setColor(gl, fill); gl.glDisable(GL.GL_TEXTURE_2D); } else { setColor(gl, Color.white); Texture gltexture = texture.getTexture(glc); gltexture.enable(); gl.glTexParameteri(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_WRAP_S, GL.GL_REPEAT); gl.glTexParameteri(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_WRAP_T, GL.GL_REPEAT); gl.glTexEnvf(GL.GL_TEXTURE_ENV, GL.GL_TEXTURE_ENV_MODE, GL.GL_MODULATE); gl.glTexParameteri(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_MAG_FILTER, GL.GL_NEAREST); gl.glTexParameteri(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_MIN_FILTER, GL.GL_NEAREST); gltexture.bind(); } gl.glPushMatrix(); // get 4 control points of portal Point2D p0 = pts2d.get(0); Point2D p1 = pts2d.get(1); Point2D p2 = pts2d.get(2); Point2D p3 = pts2d.get(3); // render 1st side of portal with height extra[0] renderOneside(p0, p1, gl, extra[0]); // render 1st side of portal with height extra[1] renderOneside(p2, p3, gl, extra[1]); gl.glPopMatrix(); } }
public void renderBox(GL gl) { gl.glDisable(GL_TEXTURE_2D); int c1 = Math.abs(this.hashCode()) % 256; int c2 = Math.abs(getImage().hashCode()) % 256; gl.glColor4f(c1 / 256f, c2 / 256f, ((c1 + c2) * 34) % 256 / 256f, 0.3f); gl.glPushMatrix(); gl.glTranslatef(bounds.getLeft(), bounds.getTop(), minHeight); gl.glScalef(bounds.getWidth(), bounds.getHeight(), maxHeight - minHeight); gl.glBegin(GL_QUADS); gl.glVertex3f(0, 0, 0); gl.glVertex3f(0, 1, 0); gl.glVertex3f(1, 1, 0); gl.glVertex3f(1, 0, 0); gl.glVertex3f(0, 0, 1); gl.glVertex3f(0, 1, 1); gl.glVertex3f(1, 1, 1); gl.glVertex3f(1, 0, 1); gl.glEnd(); gl.glColor4f(1, 1, 0, 0.2f); gl.glBegin(GL_QUAD_STRIP); gl.glVertex3f(0, 0, 0); gl.glVertex3f(0, 0, 1); gl.glVertex3f(0, 1, 0); gl.glVertex3f(0, 1, 1); gl.glVertex3f(1, 1, 0); gl.glVertex3f(1, 1, 1); gl.glVertex3f(1, 0, 0); gl.glVertex3f(1, 0, 1); gl.glVertex3f(0, 0, 0); gl.glVertex3f(0, 0, 1); gl.glEnd(); gl.glPopMatrix(); }
private void clearTextureUnits() { Image[] textures = context.boundTextures; if (textures[0] != null) { GL gl = GLContext.getCurrentGL(); gl.glDisable(GL.GL_TEXTURE_2D); textures[0] = null; } }
void glow() { final PGraphicsOpenGL pgl = (PGraphicsOpenGL) g; final GL openGL = pgl.beginGL(); openGL.glDisable(GL.GL_DEPTH_TEST); openGL.glEnable(GL.GL_BLEND); openGL.glBlendFunc(GL.GL_SRC_ALPHA, GL.GL_ONE); pgl.endGL(); }
/** * Renders the tile to the given context, in the process building all needed resources. * * @param gl */ public void render(GL gl) { projection = ProjectionFactory.getCurrentProjection(); heightmap = State.getInstance().getLoadedHeightmap(); // BUILD TEXTURES IF NECESSARY if (!gl.glIsTexture(textureID)) { textureID = createTexture(gl, getImage(), false); // prerenderToTexture(gl); } if (!gl.glIsTexture(grainTextureID)) { createGrainTexture(gl); } // RENDER TILE FROM DISPLAY LIST, OR ELSE BUILD DISPLAY LIST if (gl.glIsList(displaylistID)) { gl.glCallList(displaylistID); } else { displaylistID = gl.glGenLists(1); gl.glNewList(displaylistID, GL_COMPILE_AND_EXECUTE); gl.glActiveTexture(GL_TEXTURE0); gl.glEnable(GL_TEXTURE_2D); gl.glBindTexture(GL_TEXTURE_2D, grainTextureID); gl.glActiveTexture(GL_TEXTURE1); gl.glEnable(GL_TEXTURE_2D); gl.glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL); gl.glBindTexture(GL_TEXTURE_2D, textureID); gl.glColor3f(1, 1, 1); float[] color = new float[3]; float hRes = HEIGHT_RESOLUTION - 1; float stepSize = bounds.getWidth() / hRes; Coordinates pos = new Coordinates(); for (int x = 0; x < hRes; x++) { gl.glBegin(GL_TRIANGLE_STRIP); for (int y = 0; y <= hRes; y++) { for (int i = 0; i < 2; i++) { pos.setLatitude(bounds.getTop() + y * stepSize); pos.setLongitude(bounds.getLeft() + (x + i) * stepSize); gl.glMultiTexCoord2f( GL_TEXTURE0, (x + i) / (float) GRAIN_RESOLUTION, y / (float) GRAIN_RESOLUTION); gl.glMultiTexCoord2f(GL_TEXTURE1, (x + i) / hRes, y / hRes); float height = heights[x + HEIGHT_BORDER + i][y + HEIGHT_BORDER]; getHeightColor(color, height); float shade = getShade(x + i, y, stepSize); gl.glColor3f(color[0] * shade, color[1] * shade, color[2] * shade); gl.glVertex3f(pos.getLongitude(), pos.getLatitude(), height); } } gl.glEnd(); } gl.glDisable(GL_TEXTURE_2D); gl.glActiveTexture(GL_TEXTURE0); renderPOIs(gl); gl.glEndList(); } }
private void enableFog(boolean enable, FogStateRecord record) { final GL gl = GLU.getCurrentGL(); if (record.isValid()) { if (enable && !record.enabled) { gl.glEnable(GL.GL_FOG); record.enabled = true; } else if (!enable && record.enabled) { gl.glDisable(GL.GL_FOG); record.enabled = false; } } else { if (enable) { gl.glEnable(GL.GL_FOG); } else { gl.glDisable(GL.GL_FOG); } record.enabled = enable; } }
public void clearClipRect() { GL gl = GLContext.getCurrentGL(); if (context.clipRectEnabled) { gl.glDisable(GL.GL_SCISSOR_TEST); context.clipRectEnabled = false; clipX = 0; clipY = 0; clipW = 0; clipH = 0; } }
void texsel(int id) { if (id != sh.curtex) { HavenPanel.texmiss++; if (id == -1) { gl.glDisable(GL.GL_TEXTURE_2D); } else { gl.glEnable(GL.GL_TEXTURE_2D); gl.glBindTexture(GL.GL_TEXTURE_2D, id); } sh.curtex = id; } else { HavenPanel.texhit++; } }
public void updateVisibleOctant(GL gl) { // Limits refreshLimits(); // Switch to OpenGL select mode int capacity = 1 * 4 * leaves.getCount(); // Each object take in maximium : 4 * name stack depth IntBuffer hitsBuffer = BufferUtil.newIntBuffer(capacity); gl.glSelectBuffer(hitsBuffer.capacity(), hitsBuffer); gl.glRenderMode(GL.GL_SELECT); gl.glInitNames(); gl.glPushName(0); gl.glDisable(GL.GL_CULL_FACE); // Disable flags // Draw the nodes cube in the select buffer for (Octant n : leaves) { n .resetUpdatePositionFlag(); // Profit from the loop to do this, because this method is // always after updating position gl.glLoadName(n.getNumber()); n.displayOctant(gl); } int nbRecords = gl.glRenderMode(GL.GL_RENDER); if (vizController.getVizModel().isCulling()) { gl.glEnable(GL.GL_CULL_FACE); gl.glCullFace(GL.GL_BACK); } visibleLeaves.clear(); // Get the hits and add the nodes' objects to the array int depth = Integer.MAX_VALUE; int minDepth = -1; for (int i = 0; i < nbRecords; i++) { int hit = hitsBuffer.get(i * 4 + 3); // -1 Because of the glPushName(0) int minZ = hitsBuffer.get(i * 4 + 1); if (minZ < depth) { depth = minZ; minDepth = hit; } Octant nodeHit = leaves.getItem(hit); visibleLeaves.add(nodeHit); } if (minDepth != -1) { Octant closestOctant = leaves.getItem(minDepth); Vec3f pos = new Vec3f(closestOctant.getPosX(), closestOctant.getPosY(), closestOctant.getPosZ()); limits.setClosestPoint(pos); } // System.out.println(minDepth); }
public void draw() { if (!isTiling) { psys.update(srcImage.getPixels(), dstImage.getPixels()); } tiler.pre(); background(0); srcImage.draw(); // dstImage.draw(); // lights. if (isLightingEnabled) { gl.glEnable(GL.GL_LIGHTING); gl.glEnable(GL.GL_LIGHT1); } else { gl.glDisable(GL.GL_LIGHTING); gl.glDisable(GL.GL_LIGHT1); } // START DRAW. pgl.beginGL(); gl.glPushMatrix(); gl.glTranslatef(sceneCenterX, sceneCenterY, sceneCenterZ); drawSomething(); gl.glPopMatrix(); pgl.endGL(); tiler.post(); if (!tiler.checkStatus() && isTiling) { isTiling = false; } if (isRecording) save("export/image" + frameCount + ".png"); }
private void display(GL gl, GLU glu, final JoglFrameBufferObject theFBO) { final int w = theFBO.getPixelWidth(); final int h = theFBO.getPixelHeight(); /* bind position data */ gl.glEnableClientState(GL.GL_VERTEX_ARRAY); gl.glBindBuffer(GL.GL_ARRAY_BUFFER, _myVBO); gl.glVertexPointer(4, GL.GL_FLOAT, 0, 0); /* bind point size data */ _myShaderManager.enable(_myPointSpriteShader); final int myPointSizeAttrib = gl.glGetAttribLocation(_myPointSpriteShader.getOpenGLID(), "vertexAttribute"); gl.glEnableVertexAttribArray(myPointSizeAttrib); gl.glBindBuffer(GL.GL_ARRAY_BUFFER, _myIBO); gl.glVertexAttribPointer(myPointSizeAttrib, 3, GL.GL_FLOAT, false, 0, 0); gl.glEnable(GL.GL_VERTEX_PROGRAM_POINT_SIZE_ARB); /* --- */ final JoglFrameBufferObject READ_FBO = _myFBO; _myShaderManager.setUniform( _myPointSpriteShader, "textureVelocity", READ_FBO.additional_texture(BufferInfo.SECONDARY).getTextureUnit() - GL.GL_TEXTURE0); _myShaderManager.setUniform(_myPointSpriteShader, "velocityThreshold", velocity_threshold); _myShaderManager.setUniform(_myPointSpriteShader, "sizeThreshold", size_threshold); _myShaderManager.setUniform(_myPointSpriteShader, "pointSize", point_size); _myShaderManager.setUniform(_myPointSpriteShader, "flowdirection", flow_direction); _myShaderManager.setUniform(_myPointSpriteShader, "collisionratio", collision_ratio); gl.glActiveTexture(READ_FBO.additional_texture(BufferInfo.SECONDARY).getTextureUnit()); gl.glBindTexture( READ_FBO.additional_texture(BufferInfo.SECONDARY).getTextureTarget(), READ_FBO.additional_texture(BufferInfo.SECONDARY).getTextureID()); JoglUtil.printGLError(gl, glu, "binding texture", true); gl.glDrawArrays(GL.GL_POINTS, 0, w * h); gl.glBindBuffer(GL.GL_ARRAY_BUFFER, 0); gl.glDisableClientState(GL.GL_VERTEX_ARRAY); gl.glDisableVertexAttribArray(myPointSizeAttrib); _myShaderManager.disable(); gl.glDisable(GL.GL_VERTEX_PROGRAM_POINT_SIZE_ARB); gl.glBindTexture(READ_FBO.additional_texture(BufferInfo.SECONDARY).getTextureTarget(), 0); JoglUtil.printGLError(gl, glu, "display()", true); }
public void displayOctree(GL gl, GLU glu) { gl.glDisable(GL.GL_CULL_FACE); gl.glPolygonMode(GL.GL_FRONT_AND_BACK, GL.GL_LINE); for (Octant o : visibleLeaves) { gl.glColor3f(1, 0.5f, 0.5f); o.displayOctant(gl); o.displayOctantInfo(gl, glu); } if (!vizController.getVizConfig().isWireFrame()) { gl.glPolygonMode(GL.GL_FRONT_AND_BACK, GL.GL_FILL); } if (vizController.getVizModel().isCulling()) { gl.glEnable(GL.GL_CULL_FACE); gl.glCullFace(GL.GL_BACK); } }
/** The scene's implementation of the init method. */ public void init(GLAutoDrawable drawable) { super.init(drawable); System.out.println("FlyingTextScene - init"); final GL gl = drawable.getGL(); // Create the text renderer renderer = new TextRenderer(new Font("Palatino Linotype", Font.TRUETYPE_FONT, 72), true); // Create the background texture BufferedImage bgImage = new BufferedImage(2, 2, BufferedImage.TYPE_BYTE_GRAY); Graphics2D g = bgImage.createGraphics(); g.setColor(new Color(0.3f, 0.3f, 0.3f)); g.fillRect(0, 0, 2, 2); g.setColor(new Color(0.7f, 0.7f, 0.7f)); g.fillRect(0, 0, 1, 1); g.fillRect(1, 1, 1, 1); g.dispose(); backgroundTexture = TextureIO.newTexture(bgImage, false); backgroundTexture.bind(); backgroundTexture.setTexParameteri(GL.GL_TEXTURE_MIN_FILTER, GL.GL_NEAREST); backgroundTexture.setTexParameteri(GL.GL_TEXTURE_MAG_FILTER, GL.GL_NEAREST); backgroundTexture.setTexParameteri(GL.GL_TEXTURE_WRAP_S, GL.GL_REPEAT); backgroundTexture.setTexParameteri(GL.GL_TEXTURE_WRAP_T, GL.GL_REPEAT); width = glComposite.getCanvas().getWidth(); height = glComposite.getCanvas().getHeight(); // Compute maximum width of text we're going to draw to avoid // popping in/out at edges maxTextWidth = (int) renderer.getBounds("Java 2D").getWidth(); maxTextWidth = Math.max(maxTextWidth, (int) renderer.getBounds("OpenGL").getWidth()); // Create random text textInfo.clear(); for (int i = 0; i < NUM_STRINGS; i++) { textInfo.add(randomTextInfo()); } // Set up properties; note we don't need the depth buffer in this demo gl.glDisable(GL.GL_DEPTH_TEST); glComposite.initAnimator(drawable, 100); }
public void beginPicking(DrawContext dc) { javax.media.opengl.GL gl = dc.getGL(); gl.glPushAttrib(GL.GL_ENABLE_BIT | GL.GL_CURRENT_BIT); gl.glDisable(GL.GL_DITHER); gl.glDisable(GL.GL_LIGHTING); gl.glDisable(GL.GL_FOG); gl.glDisable(GL.GL_BLEND); gl.glDisable(GL.GL_TEXTURE_2D); if (dc.isDeepPickingEnabled()) gl.glDisable(GL.GL_DEPTH_TEST); }
private void initOpenGL() { pgl = (PGraphicsOpenGL) g; gl = pgl.gl; gl.setSwapInterval(1); gl.glShadeModel(GL.GL_SMOOTH); // Enable Smooth Shading gl.glClearColor(0.0f, 0.0f, 0.0f, 0.5f); // Black Background gl.glClearDepth(1.0f); // Depth Buffer Setup gl.glEnable(GL.GL_DEPTH_TEST); // Enables Depth Testing gl.glDepthFunc(GL.GL_LEQUAL); // The Type Of Depth Testing To Do gl.glHint( GL.GL_PERSPECTIVE_CORRECTION_HINT, GL.GL_NICEST); // Really Nice Perspective Calculations gl.glDisable(GL.GL_TEXTURE_2D); // Set up lighting gl.glLightfv(GL.GL_LIGHT1, GL.GL_AMBIENT, lightAmbient, 0); gl.glLightfv(GL.GL_LIGHT1, GL.GL_DIFFUSE, lightDiffuse, 0); // gl.glLightfv( GL.GL_LIGHT1, GL.GL_SPECULAR, lightSpecular, 0 ); gl.glLightfv(GL.GL_LIGHT1, GL.GL_POSITION, lightPosition, 0); gl.glEnable(GL.GL_LIGHTING); gl.glEnable(GL.GL_LIGHT1); }
protected void drawIcon(DrawContext dc) { if (this.getIconFilePath() == null) return; GL gl = dc.getGL(); OGLStackHandler ogsh = new OGLStackHandler(); try { // Initialize texture if necessary Texture iconTexture = dc.getTextureCache().getTexture(this.getIconFilePath()); if (iconTexture == null) { this.initializeTexture(dc); iconTexture = dc.getTextureCache().getTexture(this.getIconFilePath()); if (iconTexture == null) { String msg = Logging.getMessage("generic.ImageReadFailed"); Logging.logger().finer(msg); return; } } gl.glDisable(GL.GL_DEPTH_TEST); double width = this.getScaledIconWidth(); double height = this.getScaledIconHeight(); // Load a parallel projection with xy dimensions (viewportWidth, viewportHeight) // into the GL projection matrix. java.awt.Rectangle viewport = dc.getView().getViewport(); ogsh.pushProjectionIdentity(gl); double maxwh = width > height ? width : height; gl.glOrtho(0d, viewport.width, 0d, viewport.height, -0.6 * maxwh, 0.6 * maxwh); // Translate and scale ogsh.pushModelviewIdentity(gl); double scale = this.computeScale(viewport); Vec4 locationSW = this.computeLocation(viewport, scale); gl.glTranslated(locationSW.x(), locationSW.y(), locationSW.z()); // Scale to 0..1 space gl.glScaled(scale, scale, 1); gl.glScaled(width, height, 1d); if (!dc.isPickingMode()) { gl.glEnable(GL.GL_BLEND); gl.glBlendFunc(GL.GL_SRC_ALPHA, GL.GL_ONE_MINUS_SRC_ALPHA); // Draw background color behind the map gl.glColor4ub( (byte) this.backColor.getRed(), (byte) this.backColor.getGreen(), (byte) this.backColor.getBlue(), (byte) (this.backColor.getAlpha() * this.getOpacity())); dc.drawUnitQuad(); // Draw world map icon gl.glColor4d(1d, 1d, 1d, this.getOpacity()); gl.glEnable(GL.GL_TEXTURE_2D); iconTexture.bind(); TextureCoords texCoords = iconTexture.getImageTexCoords(); dc.drawUnitQuad(texCoords); gl.glBindTexture(GL.GL_TEXTURE_2D, 0); gl.glDisable(GL.GL_TEXTURE_2D); // Draw crosshair for current location gl.glLoadIdentity(); gl.glTranslated(locationSW.x(), locationSW.y(), locationSW.z()); // Scale to width x height space gl.glScaled(scale, scale, 1); // Set color float[] colorRGB = this.color.getRGBColorComponents(null); gl.glColor4d(colorRGB[0], colorRGB[1], colorRGB[2], this.getOpacity()); // Draw crosshair Position groundPos = this.computeGroundPosition(dc, dc.getView()); if (groundPos != null) { int x = (int) (width * (groundPos.getLongitude().degrees + 180) / 360); int y = (int) (height * (groundPos.getLatitude().degrees + 90) / 180); int w = 10; // cross branch length // Draw gl.glBegin(GL.GL_LINE_STRIP); gl.glVertex3d(x - w, y, 0); gl.glVertex3d(x + w + 1, y, 0); gl.glEnd(); gl.glBegin(GL.GL_LINE_STRIP); gl.glVertex3d(x, y - w, 0); gl.glVertex3d(x, y + w + 1, 0); gl.glEnd(); } // Draw view footprint in map icon space if (this.showFootprint) { this.footPrintPositions = this.computeViewFootPrint(dc, 32); if (this.footPrintPositions != null) { gl.glBegin(GL.GL_LINE_STRIP); LatLon p1 = this.footPrintPositions.get(0); for (LatLon p2 : this.footPrintPositions) { int x = (int) (width * (p2.getLongitude().degrees + 180) / 360); int y = (int) (height * (p2.getLatitude().degrees + 90) / 180); // Draw if (LatLon.locationsCrossDateline(p1, p2)) { int y1 = (int) (height * (p1.getLatitude().degrees + 90) / 180); gl.glVertex3d(x < width / 2 ? width : 0, (y1 + y) / 2, 0); gl.glEnd(); gl.glBegin(GL.GL_LINE_STRIP); gl.glVertex3d(x < width / 2 ? 0 : width, (y1 + y) / 2, 0); } gl.glVertex3d(x, y, 0); p1 = p2; } gl.glEnd(); } } // Draw 1px border around and inside the map gl.glBegin(GL.GL_LINE_STRIP); gl.glVertex3d(0, 0, 0); gl.glVertex3d(width, 0, 0); gl.glVertex3d(width, height - 1, 0); gl.glVertex3d(0, height - 1, 0); gl.glVertex3d(0, 0, 0); gl.glEnd(); } else { // Picking this.pickSupport.clearPickList(); this.pickSupport.beginPicking(dc); // Where in the world are we picking ? Position pickPosition = computePickPosition( dc, locationSW, new Dimension((int) (width * scale), (int) (height * scale))); Color color = dc.getUniquePickColor(); int colorCode = color.getRGB(); this.pickSupport.addPickableObject(colorCode, this, pickPosition, false); gl.glColor3ub((byte) color.getRed(), (byte) color.getGreen(), (byte) color.getBlue()); dc.drawUnitQuad(); this.pickSupport.endPicking(dc); this.pickSupport.resolvePick(dc, dc.getPickPoint(), this); } } finally { dc.restoreDefaultDepthTesting(); dc.restoreDefaultCurrentColor(); if (dc.isPickingMode()) dc.restoreDefaultBlending(); ogsh.pop(gl); } }
public void disableAlpha() { gl.glDisable(GL.GL_ALPHA); gl.glDisable(GL.GL_BLEND); }
public void disableTexture() { currentTexture = null; gl.glDisable(GL.GL_TEXTURE_2D); }
public void display(GLCanvas canvas) { GL gl = canvas.getGL(); // // render the simulation // try { sim.update(); } catch (Exception e) { Log.println("[Editor] exception in simulation update/calculate paths: " + e.getMessage()); e.printStackTrace(); } renderer.render(sim, canvas); // // render the grid // gl.glColor4f(0.4f, 0.4f, 0.4f, 0.4f); gl.glEnable(GL.GL_BLEND); gl.glBegin(GL.GL_LINES); for (int x = 0; x < 100; x++) { gl.glVertex2f( -50 * Constants.PLANET_MAX_SIZE * 4 + x * Constants.PLANET_MAX_SIZE * 4, -50 * Constants.PLANET_MAX_SIZE * 4); gl.glVertex2f( -50 * Constants.PLANET_MAX_SIZE * 4 + x * Constants.PLANET_MAX_SIZE * 4, 50 * Constants.PLANET_MAX_SIZE * 4); } for (int x = 0; x < 100; x++) { gl.glVertex2f( -50 * Constants.PLANET_MAX_SIZE * 4, -50 * Constants.PLANET_MAX_SIZE * 4 + x * Constants.PLANET_MAX_SIZE * 4); gl.glVertex2f( +50 * Constants.PLANET_MAX_SIZE * 4, -50 * Constants.PLANET_MAX_SIZE * 4 + x * Constants.PLANET_MAX_SIZE * 4); } gl.glDisable(GL.GL_BLEND); gl.glEnd(); // // render rectangle selection // if (drag_start != null && drag_end != null && selected_planets.size() == 0) { gl.glLineWidth(2); gl.glColor4f(1, 1, 1, 1); Widget.renderOutlinedQuad( drag_start.x, drag_start.y, drag_end.x - drag_start.x, -(drag_end.y - drag_start.y)); gl.glLineWidth(1); } // // render reference system // gl.glColor3f(1, 1, 1); gl.glBegin(GL.GL_LINES); gl.glColor3f(1, 0, 0); gl.glVertex2f(Constants.PLANET_MAX_SIZE * 50, 0); gl.glVertex2f(-Constants.PLANET_MAX_SIZE * 50, 0); gl.glColor3f(0, 1, 0); gl.glVertex2f(0, Constants.PLANET_MAX_SIZE * 50); gl.glVertex2f(0, -Constants.PLANET_MAX_SIZE * 50); gl.glEnd(); try { Thread.sleep(5); } catch (InterruptedException e) { } // // check mouse over planet // if (sim.getPlanet( renderer.getCamera().getScreenToWorldX(mouse_pos.x), renderer.getCamera().getScreenToWorldY(mouse_pos.y)) != null && !this.wasGuiIntersected(mouse_pos.x, mouse_pos.y) && drag_start != null) for (WorldAlignementContainer cont : conts) cont.setVisible(false); else for (WorldAlignementContainer cont : conts) cont.setVisible(true); }
public static void apply(final JoglRenderer renderer, final VertexProgramState state) { final GL gl = GLU.getCurrentGL(); final RenderContext context = ContextManager.getCurrentContext(); final ContextCapabilities caps = context.getCapabilities(); if (caps.isVertexProgramSupported()) { // ask for the current state record final VertexProgramStateRecord record = (VertexProgramStateRecord) context.getStateRecord(StateType.VertexProgram); context.setCurrentState(StateType.VertexProgram, state); if (!record.isValid() || record.getReference() != state) { record.setReference(state); if (state.isEnabled()) { // Vertex program not yet loaded if (state._getProgramID() == -1) { if (state.getProgramAsBuffer() != null) { final int id = create(state.getProgramAsBuffer()); state._setProgramID(id); } else { return; } } gl.glEnable(GL.GL_VERTEX_PROGRAM_ARB); gl.glBindProgramARB(GL.GL_VERTEX_PROGRAM_ARB, state._getProgramID()); // load environmental parameters... for (int i = 0; i < VertexProgramState._getEnvParameters().length; i++) { if (VertexProgramState._getEnvParameters()[i] != null) { gl.glProgramEnvParameter4fARB( GL.GL_VERTEX_PROGRAM_ARB, i, VertexProgramState._getEnvParameters()[i][0], VertexProgramState._getEnvParameters()[i][1], VertexProgramState._getEnvParameters()[i][2], VertexProgramState._getEnvParameters()[i][3]); } } // load local parameters... if (state.isUsingParameters()) { // no parameters are used for (int i = 0; i < state._getParameters().length; i++) { if (state._getParameters()[i] != null) { gl.glProgramLocalParameter4fARB( GL.GL_VERTEX_PROGRAM_ARB, i, state._getParameters()[i][0], state._getParameters()[i][1], state._getParameters()[i][2], state._getParameters()[i][3]); } } } } else { gl.glDisable(GL.GL_VERTEX_PROGRAM_ARB); } } if (!record.isValid()) { record.validate(); } } }
public void display(GLAutoDrawable glDrawable) { GL gl = glDrawable.getGL(); // Store old matrices gl.glMatrixMode(GL.GL_MODELVIEW); gl.glPushMatrix(); gl.glLoadIdentity(); gl.glMatrixMode(GL.GL_PROJECTION); gl.glPushMatrix(); gl.glLoadIdentity(); gl.glViewport(0, 0, glDrawable.getWidth(), glDrawable.getHeight()); // Store enabled state and disable lighting, texture mapping and the depth buffer gl.glPushAttrib(GL.GL_ENABLE_BIT); gl.glDisable(GL.GL_BLEND); gl.glDisable(GL.GL_LIGHTING); gl.glDisable(GL.GL_TEXTURE_2D); gl.glDisable(GL.GL_DEPTH_TEST); // Retrieve the current viewport and switch to orthographic mode IntBuffer viewPort = BufferUtil.newIntBuffer(4); gl.glGetIntegerv(GL.GL_VIEWPORT, viewPort); glu.gluOrtho2D(0, viewPort.get(2), viewPort.get(3), 0); // Render the text gl.glColor3f(1, 1, 1); int x = OFFSET; int maxx = 0; int y = OFFSET + CHAR_HEIGHT; if (keyboardEntries.size() > 0) { gl.glRasterPos2i(x, y); glut.glutBitmapString(GLUT.BITMAP_HELVETICA_12, KEYBOARD_CONTROLS); maxx = Math.max( maxx, OFFSET + glut.glutBitmapLength(GLUT.BITMAP_HELVETICA_12, KEYBOARD_CONTROLS)); y += OFFSET; x += INDENT; for (int i = 0; i < keyboardEntries.size(); i++) { gl.glRasterPos2f(x, y); String text = (String) keyboardEntries.get(i); glut.glutBitmapString(GLUT.BITMAP_HELVETICA_12, text); maxx = Math.max(maxx, OFFSET + glut.glutBitmapLength(GLUT.BITMAP_HELVETICA_12, text)); y += OFFSET; } } if (mouseEntries.size() > 0) { x = maxx + OFFSET; y = OFFSET + CHAR_HEIGHT; gl.glRasterPos2i(x, y); glut.glutBitmapString(GLUT.BITMAP_HELVETICA_12, MOUSE_CONTROLS); y += OFFSET; x += INDENT; for (int i = 0; i < mouseEntries.size(); i++) { gl.glRasterPos2f(x, y); glut.glutBitmapString(GLUT.BITMAP_HELVETICA_12, (String) mouseEntries.get(i)); y += OFFSET; } } // Restore enabled state gl.glPopAttrib(); // Restore old matrices gl.glPopMatrix(); gl.glMatrixMode(GL.GL_MODELVIEW); gl.glPopMatrix(); }
@Override public void render(final DrawContext dc) { // _lastDC = dc; runFrameWorkers(); final GTexture texture = getTexture(); if ((texture == null) || !texture.hasGLTexture()) { return; } final GL gl = dc.getGL(); gl.glPushAttrib( GL.GL_DEPTH_BUFFER_BIT | GL.GL_COLOR_BUFFER_BIT | GL.GL_ENABLE_BIT | GL.GL_TEXTURE_BIT | GL.GL_TRANSFORM_BIT | GL.GL_VIEWPORT_BIT | GL.GL_CURRENT_BIT); gl.glEnable(GL.GL_BLEND); gl.glBlendFunc(GL.GL_SRC_ALPHA, GL.GL_ONE_MINUS_SRC_ALPHA); gl.glDisable(GL.GL_DEPTH_TEST); // Load a parallel projection with xy dimensions (viewportWidth, viewportHeight) // into the GL projection matrix. final Rectangle viewport = dc.getView().getViewport(); gl.glMatrixMode(GL.GL_PROJECTION); gl.glPushMatrix(); gl.glLoadIdentity(); final double maxwh = Math.max(_textureWidth, _textureHeight); gl.glOrtho(0d, viewport.width, 0d, viewport.height, -0.6 * maxwh, 0.6 * maxwh); gl.glMatrixMode(GL.GL_MODELVIEW); gl.glPushMatrix(); gl.glLoadIdentity(); // Translate and scale final float scale = computeScale(viewport); final Vec4 locationSW = computeLocation(viewport, scale); gl.glTranslated(locationSW.x(), locationSW.y(), locationSW.z()); // Scale to 0..1 space gl.glScalef(scale, scale, 1f); gl.glScaled(_textureWidth, _textureHeight, 1d); _lastScreenBounds = calculateScreenBounds(viewport, locationSW, scale); texture.enable(); texture.bind(); gl.glTexEnvf(GL.GL_TEXTURE_ENV, GL.GL_TEXTURE_ENV_MODE, GL.GL_MODULATE); gl.glColor4f(1, 1, 1, calculateOpacity()); dc.drawUnitQuad(texture.getImageTexCoords()); texture.disable(); gl.glMatrixMode(GL.GL_PROJECTION); gl.glPopMatrix(); gl.glMatrixMode(GL.GL_MODELVIEW); gl.glPopMatrix(); gl.glPopAttrib(); }
public void setLighting(LightList list) { GL gl = GLContext.getCurrentGL(); // XXX: This is abuse of setLighting() to // apply fixed function bindings // and do other book keeping. if (list == null || list.size() == 0) { gl.glDisable(GLLightingFunc.GL_LIGHTING); applyFixedFuncBindings(false); setModelView(worldMatrix, viewMatrix); return; } // Number of lights set previously int numLightsSetPrev = lightList.size(); // If more than maxLights are defined, they will be ignored. // The GL1 renderer is not permitted to crash due to a // GL1 limitation. It must render anything that the GL2 renderer // can render (even incorrectly). lightList.clear(); materialAmbientColor.set(0, 0, 0, 0); for (int i = 0; i < list.size(); i++) { Light l = list.get(i); if (l.getType() == Light.Type.Ambient) { // Gather materialAmbientColor.addLocal(l.getColor()); } else { // Add to list lightList.add(l); // Once maximum lights reached, exit loop. if (lightList.size() >= maxLights) { break; } } } applyFixedFuncBindings(true); gl.glEnable(GLLightingFunc.GL_LIGHTING); fb16.clear(); fb16.put(materialAmbientColor.r) .put(materialAmbientColor.g) .put(materialAmbientColor.b) .put(1) .flip(); gl.getGL2ES1().glLightModelfv(GL2ES1.GL_LIGHT_MODEL_AMBIENT, fb16); if (context.matrixMode != GLMatrixFunc.GL_MODELVIEW) { gl.getGL2ES1().glMatrixMode(GLMatrixFunc.GL_MODELVIEW); context.matrixMode = GLMatrixFunc.GL_MODELVIEW; } // Lights are already in world space, so just convert // them to view space. gl.getGL2ES1().glLoadMatrixf(storeMatrix(viewMatrix, fb16)); for (int i = 0; i < lightList.size(); i++) { int glLightIndex = GLLightingFunc.GL_LIGHT0 + i; Light light = lightList.get(i); Light.Type lightType = light.getType(); ColorRGBA col = light.getColor(); Vector3f pos; // Enable the light gl.glEnable(glLightIndex); // OGL spec states default value for light ambient is black switch (lightType) { case Directional: DirectionalLight dLight = (DirectionalLight) light; fb16.clear(); fb16.put(col.r).put(col.g).put(col.b).put(col.a).flip(); gl.getGL2ES1().glLightfv(glLightIndex, GLLightingFunc.GL_DIFFUSE, fb16); gl.getGL2ES1().glLightfv(glLightIndex, GLLightingFunc.GL_SPECULAR, fb16); pos = tempVec.set(dLight.getDirection()).negateLocal().normalizeLocal(); fb16.clear(); fb16.put(pos.x).put(pos.y).put(pos.z).put(0.0f).flip(); gl.getGL2ES1().glLightfv(glLightIndex, GLLightingFunc.GL_POSITION, fb16); gl.getGL2ES1().glLightf(glLightIndex, GLLightingFunc.GL_SPOT_CUTOFF, 180); break; case Point: PointLight pLight = (PointLight) light; fb16.clear(); fb16.put(col.r).put(col.g).put(col.b).put(col.a).flip(); gl.getGL2ES1().glLightfv(glLightIndex, GLLightingFunc.GL_DIFFUSE, fb16); gl.getGL2ES1().glLightfv(glLightIndex, GLLightingFunc.GL_SPECULAR, fb16); pos = pLight.getPosition(); fb16.clear(); fb16.put(pos.x).put(pos.y).put(pos.z).put(1.0f).flip(); gl.getGL2ES1().glLightfv(glLightIndex, GLLightingFunc.GL_POSITION, fb16); gl.getGL2ES1().glLightf(glLightIndex, GLLightingFunc.GL_SPOT_CUTOFF, 180); if (pLight.getRadius() > 0) { // Note: this doesn't follow the same attenuation model // as the one used in the lighting shader. gl.getGL2ES1().glLightf(glLightIndex, GLLightingFunc.GL_CONSTANT_ATTENUATION, 1); gl.getGL2ES1() .glLightf( glLightIndex, GLLightingFunc.GL_LINEAR_ATTENUATION, pLight.getInvRadius() * 2); gl.getGL2ES1() .glLightf( glLightIndex, GLLightingFunc.GL_QUADRATIC_ATTENUATION, pLight.getInvRadius() * pLight.getInvRadius()); } else { gl.getGL2ES1().glLightf(glLightIndex, GLLightingFunc.GL_CONSTANT_ATTENUATION, 1); gl.getGL2ES1().glLightf(glLightIndex, GLLightingFunc.GL_LINEAR_ATTENUATION, 0); gl.getGL2ES1().glLightf(glLightIndex, GLLightingFunc.GL_QUADRATIC_ATTENUATION, 0); } break; case Spot: SpotLight sLight = (SpotLight) light; fb16.clear(); fb16.put(col.r).put(col.g).put(col.b).put(col.a).flip(); gl.getGL2ES1().glLightfv(glLightIndex, GLLightingFunc.GL_DIFFUSE, fb16); gl.getGL2ES1().glLightfv(glLightIndex, GLLightingFunc.GL_SPECULAR, fb16); pos = sLight.getPosition(); fb16.clear(); fb16.put(pos.x).put(pos.y).put(pos.z).put(1.0f).flip(); gl.getGL2().glLightfv(glLightIndex, GLLightingFunc.GL_POSITION, fb16); Vector3f dir = sLight.getDirection(); fb16.clear(); fb16.put(dir.x).put(dir.y).put(dir.z).put(1.0f).flip(); gl.getGL2ES1().glLightfv(glLightIndex, GLLightingFunc.GL_SPOT_DIRECTION, fb16); float outerAngleRad = sLight.getSpotOuterAngle(); float innerAngleRad = sLight.getSpotInnerAngle(); float spotCut = outerAngleRad * FastMath.RAD_TO_DEG; float spotExpo = 0.0f; if (outerAngleRad > 0) { spotExpo = (1.0f - (innerAngleRad / outerAngleRad)) * 128.0f; } gl.getGL2ES1().glLightf(glLightIndex, GLLightingFunc.GL_SPOT_CUTOFF, spotCut); gl.getGL2ES1().glLightf(glLightIndex, GLLightingFunc.GL_SPOT_EXPONENT, spotExpo); if (sLight.getSpotRange() > 0) { gl.getGL2ES1() .glLightf( glLightIndex, GLLightingFunc.GL_LINEAR_ATTENUATION, sLight.getInvSpotRange()); } else { gl.getGL2ES1().glLightf(glLightIndex, GLLightingFunc.GL_LINEAR_ATTENUATION, 0); } break; default: throw new UnsupportedOperationException("Unrecognized light type: " + lightType); } } // Disable lights after the index for (int i = lightList.size(); i < numLightsSetPrev; i++) { gl.glDisable(GLLightingFunc.GL_LIGHT0 + i); } // This will set view matrix as well. setModelView(worldMatrix, viewMatrix); }