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();
}
public void fire() throws IllegalActionException {
if (_debugging) {
_debug("Called fire()");
}
GL gl = ((GRODirector) getDirector()).getGL();
gl.glBegin(GL.GL_QUADS);
gl.glColor3f(0.3f, 0.7f, 0.3f);
gl.glVertex3f(-1.0f, 0.0f, 1.0f);
gl.glVertex3f(1.0f, 0.0f, 1.0f);
gl.glVertex3f(1.0f, 0.0f, -1.0f);
gl.glVertex3f(-1.0f, 0.0f, -1.0f);
gl.glEnd();
}
public void display(GL gl, float time, int screenWidth, int screenHeight) {
// TODO: most of this only needs to be done once per frame, not per button.
if (!visible) {
return;
}
gl.glMatrixMode(GL.GL_MODELVIEW);
gl.glPushMatrix();
if (flipx) {
gl.glTranslatef(1.0f, 0.0f, 0.0f);
gl.glScalef(-1.0f, 1.0f, 1.0f);
}
if (flipy) {
gl.glTranslatef(0.0f, 1.0f, 0.0f);
gl.glScalef(1.0f, -1.0f, 1.0f);
}
gl.glScalef(1.0f / screenWidth, 1.0f / screenHeight, 1.0f);
if (isSelected() || (mDown && mOver)) {
gl.glColor3f(0.6f, 0.6f, 0.8f);
} else {
gl.glColor3f(0.8f, 0.8f, 0.8f);
}
gl.glActiveTexture(GL.GL_TEXTURE0);
marble.enable();
marble.bind();
gl.glMatrixMode(GL.GL_TEXTURE);
gl.glPushMatrix();
gl.glLoadIdentity();
gl.glBegin(GL.GL_POLYGON);
for (int n = 0; n < buttonShape.npoints; n++) {
gl.glTexCoord2f(n / 2, (n + n / 2 + 1) % 2);
gl.glVertex3f(buttonShape.xpoints[n], buttonShape.ypoints[n], -0.5f);
}
gl.glEnd();
tex.enable();
tex.bind();
gl.glTexParameteri(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_MIN_FILTER, GL.GL_LINEAR);
gl.glBegin(GL.GL_POLYGON);
for (int n = 0; n < buttonShape.npoints; n++) {
gl.glTexCoord2f(n / 2, (n + n / 2 + 1) % 2);
gl.glVertex3f(buttonShape.xpoints[n], buttonShape.ypoints[n], -1.0f);
}
gl.glEnd();
gl.glPopMatrix();
gl.glMatrixMode(GL.GL_MODELVIEW);
gl.glPopMatrix();
}
/**
* 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();
}
}
public void draw(GL gl) {
if (visible) {
// Seta a cor da peça
if (color != null) {
float r = color.getR();
float g = color.getG();
float b = color.getB();
float a = color.getAlpha();
gl.glColor4f(r, g, b, a);
} else {
gl.glColor3d(Math.random(), Math.random(), Math.random());
}
// desenha a peça
gl.glBegin(drawType);
for (Vetor3f v : points) {
gl.glVertex3f(v.getX(), v.getY(), v.getZ());
}
gl.glEnd();
}
}
/** Here we actually draw the scene. */
public void display(GLAutoDrawable drawable) {
super.display(drawable);
System.out.println("GLScene - display");
GL gl = drawable.getGL();
try {
// Update velocities and positions of all text
float deltaT = 0.1f;
Point2f tmp = new Point2f();
for (Iterator<TextInfo> iter = textInfo.iterator(); iter.hasNext(); ) {
TextInfo info = (TextInfo) iter.next();
// Randomize things a little bit at run time
if (random.nextInt(1000) == 0) {
info.angularVelocity = INIT_ANG_VEL_MAG * (randomAngle() - 180);
info.velocity = randomVelocity(INIT_VEL_MAG, INIT_VEL_MAG);
}
// Now update angles and positions
info.angle += info.angularVelocity * deltaT;
tmp.set(info.velocity);
tmp.scale(deltaT);
info.position.add(tmp);
// Update color
info.curTime += deltaT;
if (info.curTime > 2 * Math.PI) {
info.curTime -= 2 * Math.PI;
}
int rgb =
Color.HSBtoRGB(info.h, (float) (0.5 * (1 + Math.sin(info.curTime)) * info.s), info.v);
info.r = ((rgb >> 16) & 0xFF) / 255.0f;
info.g = ((rgb >> 8) & 0xFF) / 255.0f;
info.b = (rgb & 0xFF) / 255.0f;
// Wrap angles and positions
if (info.angle < 0) {
info.angle += 360;
} else if (info.angle > 360) {
info.angle -= 360;
}
// Use maxTextWidth to avoid popping in/out at edges
// Would be better to do oriented bounding rectangle computation
if (info.position.x < -maxTextWidth) {
info.position.x = info.position.x + glComposite.getCanvas().getWidth() + 2 * maxTextWidth;
} else if (info.position.x > glComposite.getCanvas().getWidth() + maxTextWidth) {
info.position.x = info.position.x - glComposite.getCanvas().getWidth() - 2 * maxTextWidth;
}
if (info.position.y < -maxTextWidth) {
info.position.y =
info.position.y + glComposite.getCanvas().getHeight() + 2 * maxTextWidth;
} else if (info.position.y > glComposite.getCanvas().getHeight() + maxTextWidth) {
info.position.y =
info.position.y - glComposite.getCanvas().getHeight() - 2 * maxTextWidth;
}
}
gl.glClear(GL.GL_COLOR_BUFFER_BIT);
gl.glMatrixMode(GL.GL_PROJECTION);
gl.glLoadIdentity();
glComposite
.getGLU()
.gluOrtho2D(
0, glComposite.getCanvas().getWidth(), 0, glComposite.getCanvas().getHeight());
gl.glMatrixMode(GL.GL_MODELVIEW);
gl.glLoadIdentity();
// Draw the background texture
backgroundTexture.enable();
backgroundTexture.bind();
TextureCoords coords = backgroundTexture.getImageTexCoords();
int w = glComposite.getCanvas().getWidth();
int h = glComposite.getCanvas().getHeight();
float fw = w / 100.0f;
float fh = h / 100.0f;
gl.glTexEnvi(GL.GL_TEXTURE_ENV, GL.GL_TEXTURE_ENV_MODE, GL.GL_REPLACE);
gl.glBegin(GL.GL_QUADS);
gl.glTexCoord2f(fw * coords.left(), fh * coords.bottom());
gl.glVertex3f(0, 0, 0);
gl.glTexCoord2f(fw * coords.right(), fh * coords.bottom());
gl.glVertex3f(w, 0, 0);
gl.glTexCoord2f(fw * coords.right(), fh * coords.top());
gl.glVertex3f(w, h, 0);
gl.glTexCoord2f(fw * coords.left(), fh * coords.top());
gl.glVertex3f(0, h, 0);
gl.glEnd();
backgroundTexture.disable();
// Render all text
renderer.beginRendering(w, h);
// Note we're doing some slightly fancy stuff to position the text.
// We tell the text renderer to render the text at the origin, and
// manipulate the modelview matrix to put the text where we want.
gl.glMatrixMode(GL.GL_MODELVIEW);
// First render drop shadows
renderer.setColor(0, 0, 0, 0.5f);
for (Iterator<TextInfo> iter = textInfo.iterator(); iter.hasNext(); ) {
TextInfo info = (TextInfo) iter.next();
gl.glLoadIdentity();
gl.glTranslatef(
info.position.x + dropShadowDistance, info.position.y - dropShadowDistance, 0);
gl.glRotatef(info.angle, 0, 0, 1);
renderer.draw(info.text, 0, 0);
renderer.flush();
}
// Now render the actual text
for (Iterator<TextInfo> iter = textInfo.iterator(); iter.hasNext(); ) {
TextInfo info = (TextInfo) iter.next();
gl.glLoadIdentity();
gl.glTranslatef(info.position.x, info.position.y, 0);
gl.glRotatef(info.angle, 0, 0, 1);
renderer.setColor(info.r, info.g, info.b, 1);
renderer.draw(info.text, 0, 0);
renderer.flush();
}
renderer.endRendering();
} catch (Exception e) {
e.printStackTrace();
}
}
public void display(GLAutoDrawable drawable) {
GL gl = drawable.getGL();
gl.glClear(GL.GL_COLOR_BUFFER_BIT);
gl.glClear(GL.GL_DEPTH_BUFFER_BIT);
gl.glLoadIdentity();
gl.glTranslatef(0.0f, 0.0f, -5.0f);
// Front Of House
gl.glBegin(GL.GL_QUADS);
gl.glColor3f(1.0f, 0.0f, 0.0f);
gl.glVertex3f(-1.0f, 1.0f, 0.0f);
gl.glVertex3f(1.0f, 1.0f, 0.0f);
gl.glVertex3f(1.0f, -1.0f, 0.0f);
gl.glVertex3f(-1.0f, -1.0f, 0.0f);
gl.glEnd();
// Front Left Window
gl.glBegin(GL.GL_QUADS);
gl.glColor3f(0.5f, 0.0f, 0.0f);
gl.glVertex3f(-0.75f, 0.25f, 0.0f);
gl.glVertex3f(-0.25f, 0.25f, 0.0f);
gl.glVertex3f(-0.25f, 0.75f, 0.0f);
gl.glVertex3f(-0.75f, 0.75f, 0.0f);
gl.glEnd();
// Front Right Window
gl.glBegin(GL.GL_QUADS);
gl.glColor3f(0.5f, 0.0f, 0.0f);
gl.glVertex3f(0.75f, 0.25f, 0.0f);
gl.glVertex3f(0.25f, 0.25f, 0.0f);
gl.glVertex3f(0.25f, 0.75f, 0.0f);
gl.glVertex3f(0.75f, 0.75f, 0.0f);
gl.glEnd();
// Door
gl.glBegin(GL.GL_QUADS);
gl.glColor3f(0.0f, 1.0f, 0.0f);
gl.glVertex3f(-0.25f, -1.0f, 0.0f);
gl.glVertex3f(0.25f, -1.0f, 0.0f);
gl.glVertex3f(0.25f, -0.25f, 0.0f);
gl.glVertex3f(-0.25f, -0.25f, 0.0f);
gl.glEnd();
// Right Side of house
gl.glBegin(GL.GL_QUADS);
gl.glColor3f(1.0f, 0.0f, 0.0f);
gl.glVertex3f(1.0f, -1.0f, 0.0f);
gl.glVertex3f(2.0f, -1.0f, -1.0f);
gl.glVertex3f(2.0f, 1.0f, -1.0f);
gl.glVertex3f(1.0f, 1.0f, 0.0f);
gl.glEnd();
// Right Side of roof
gl.glBegin(GL.GL_QUADS);
gl.glColor3f(1.0f, 0.0f, 0.0f);
gl.glVertex3f(1.0f, 1.0f, 0.0f);
gl.glVertex3f(2.0f, 1.0f, -1.0f);
gl.glVertex3f(1.0f, 1.75f, -1.0f);
gl.glVertex3f(0.0f, 2.0f, -1.0f);
gl.glEnd();
// Roof
gl.glBegin(GL.GL_TRIANGLES);
gl.glColor3f(1.0f, 0.0f, 0.0f);
gl.glVertex3f(-1.0f, 1.0f, 0.0f);
gl.glVertex3f(0.0f, 2.0f, -1.0f);
gl.glVertex3f(1.0f, 1.0f, 0.0f);
gl.glEnd();
// Front Side Of House Outline
gl.glBegin(GL.GL_LINE_STRIP);
gl.glColor3f(0.0f, 0.0f, 1.0f);
gl.glVertex3f(-1.0f, 1.0f, 0.0f);
gl.glVertex3f(1.0f, 1.0f, 0.0f);
gl.glVertex3f(1.0f, -1.0f, 0.0f);
gl.glVertex3f(-1.0f, -1.0f, 0.0f);
gl.glEnd();
// Right Side of house outline
gl.glBegin(GL.GL_LINE_STRIP);
gl.glColor3f(0.0f, 0.0f, 1.0f);
gl.glVertex3f(1.0f, -1.0f, 0.0f);
gl.glVertex3f(2.0f, -1.0f, -1.0f);
gl.glVertex3f(2.0f, 1.0f, -1.0f);
gl.glVertex3f(1.0f, 1.0f, 0.0f);
gl.glEnd();
// Roof Outline
gl.glBegin(GL.GL_LINE_STRIP);
gl.glColor3f(0.0f, 0.0f, 1.0f);
gl.glVertex3f(-1.0f, 1.0f, 0.0f);
gl.glVertex3f(0.0f, 2.0f, -1.0f);
gl.glVertex3f(1.0f, 1.0f, 0.0f);
gl.glEnd();
// Right Side of roof Outline
gl.glBegin(GL.GL_LINE_STRIP);
gl.glColor3f(0.0f, 0.0f, 1.0f);
gl.glVertex3f(1.0f, 1.0f, 0.0f);
gl.glVertex3f(2.0f, 1.0f, -1.0f);
gl.glVertex3f(1.0f, 1.75f, -1.0f);
gl.glVertex3f(0.0f, 2.0f, -1.0f);
gl.glEnd();
}
public void display(GLAutoDrawable gLDrawable) {
key = Input.keysPressed();
double dt = (System.currentTimeMillis() - dt_timer) / 1000.0;
dt_timer = System.currentTimeMillis();
// Start 3d Rendering
GL gl = gLDrawable.getGL();
gl.glBlendFunc(GL.GL_SRC_ALPHA, GL.GL_ONE_MINUS_SRC_ALPHA);
gl.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT);
gl.glLoadIdentity();
GLU glu = new GLU();
// Code to adjust camera
if (input.getKey(KeyEvent.VK_UP)) z -= .5 * dt;
if (input.getKey(KeyEvent.VK_DOWN)) z += .5 * dt;
if (input.getKey(KeyEvent.VK_LEFT)) y -= .5 * dt;
if (input.getKey(KeyEvent.VK_RIGHT)) y += .5 * dt;
if (input.getKey(KeyEvent.VK_SPACE)) System.out.println(y + " " + z);
glu.gluLookAt(0, y, z, 0, 0, -3, 0, 1, 0);
// orangeNote.drawBar(gLDrawable, zTest);
// redNote.draw(gLDrawable, -3f, -4f, zTest);
// yellowNote.draw(gLDrawable, -1.5f, -4f, zTest);
// blueNote.draw(gLDrawable, 0f, -4f, zTest);
// greenNote.draw(gLDrawable, 1.5f, -4f, zTest);
zTest += 0.005f;
if (zTest > -2f) zTest = -10f;
gl.glPushMatrix();
gl.glEnable(GL.GL_BLEND);
// gl.glRotatef(70,1,-2,1);
gl.glBegin(GL.GL_QUADS);
// Draw the Board
// x goes basically from -1 to 1(camera changed tho)
// y stays same
// board length is -z
gl.glColor4f(40 / 256f, 100 / 256f, 150 / 256f, 1f); // R,G,B,A
gl.glVertex3f(-3f, -4f, 0f); // x,y,z
gl.glColor4f(40 / 256f, 100 / 256f, 150 / 256f, 1f);
gl.glVertex3f(3f, -4f, 0f);
gl.glColor4f(60 / 256f, 150 / 256f, 200 / 256f, 0f);
gl.glVertex3f(3f, -4f, -10f);
gl.glColor4f(60 / 256f, 150 / 256f, 200 / 256f, 0f);
gl.glVertex3f(-3f, -4f, -10f);
// All y values on top of the Board must have at least
// 0.0001f added for some reason
// Bottom bar - Orange
gl.glColor4f(255 / 256f, 165 / 256f, 0 / 256f, 1f);
gl.glVertex3f(-3f, -4f + .0001f, -2.15f); // close left
gl.glVertex3f(3f, -4f + .0001f, -2.15f); // close right
gl.glVertex3f(3f, -4f + .0001f, -2.85f); // far right
gl.glVertex3f(-3f, -4f + .0001f, -2.85f); // far left
// RedNote
gl.glColor4f(1f, 0f, 0f, 1f);
gl.glVertex3f(-3f, -4f + .001f, -2.25f);
gl.glVertex3f(-1.5f, -4f + .001f, -2.25f);
gl.glVertex3f(-1.5f, -4f + .001f, -2.75f);
gl.glVertex3f(-3f, -4f + .001f, -2.75f);
// YellowNote
gl.glColor4f(1f, 1f, 0f, 1f);
gl.glVertex3f(-1.5f, -4f + .001f, -2.25f);
gl.glVertex3f(0f, -4f + .001f, -2.25f);
gl.glVertex3f(0f, -4f + .001f, -2.75f);
gl.glVertex3f(-1.5f, -4f + .001f, -2.75f);
// BlueNote
gl.glColor4f(0f, 0f, 1f, 1f);
gl.glVertex3f(0f, -4f + .001f, -2.25f);
gl.glVertex3f(1.5f, -4f + .001f, -2.25f);
gl.glVertex3f(1.5f, -4f + .001f, -2.75f);
gl.glVertex3f(0f, -4f + .001f, -2.75f);
// GreenNote
gl.glColor4f(0f, 1f, 0f, 1f);
gl.glVertex3f(1.5f, -4f + .001f, -2.25f);
gl.glVertex3f(3f, -4f + .001f, -2.25f);
gl.glVertex3f(3f, -4f + .001f, -2.75f);
gl.glVertex3f(1.5f, -4f + .001f, -2.75f);
// End Bottom Bar
this.renderNotes(gLDrawable, dt);
/////////////////////////////////////
gl.glEnd();
gl.glDisable(GL.GL_BLEND);
gl.glPopMatrix();
try {
Thread.sleep(1);
} catch (Exception e) {
}
}
/**
* Render the geometry now.
*
* @param gl The GL context to render with
*/
public void render(GL gl) {
gl.glBegin(GL.GL_LINES);
gl.glColor3f(0, 0, 1);
gl.glVertex3f(minBounds[0], minBounds[1], minBounds[2]);
gl.glVertex3f(minBounds[0], minBounds[1], maxBounds[2]);
gl.glVertex3f(minBounds[0], minBounds[1], minBounds[2]);
gl.glVertex3f(minBounds[0], maxBounds[1], minBounds[2]);
gl.glVertex3f(minBounds[0], minBounds[1], minBounds[2]);
gl.glVertex3f(maxBounds[0], minBounds[1], minBounds[2]);
gl.glVertex3f(maxBounds[0], maxBounds[1], maxBounds[2]);
gl.glVertex3f(maxBounds[0], maxBounds[1], minBounds[2]);
gl.glVertex3f(maxBounds[0], maxBounds[1], maxBounds[2]);
gl.glVertex3f(maxBounds[0], minBounds[1], maxBounds[2]);
gl.glVertex3f(maxBounds[0], maxBounds[1], maxBounds[2]);
gl.glVertex3f(minBounds[0], maxBounds[1], maxBounds[2]);
gl.glVertex3f(minBounds[0], minBounds[1], maxBounds[2]);
gl.glVertex3f(minBounds[0], maxBounds[1], maxBounds[2]);
gl.glVertex3f(minBounds[0], minBounds[1], maxBounds[2]);
gl.glVertex3f(maxBounds[0], minBounds[1], maxBounds[2]);
gl.glVertex3f(minBounds[0], maxBounds[1], maxBounds[2]);
gl.glVertex3f(minBounds[0], maxBounds[1], minBounds[2]);
gl.glVertex3f(maxBounds[0], maxBounds[1], minBounds[2]);
gl.glVertex3f(minBounds[0], maxBounds[1], minBounds[2]);
gl.glVertex3f(maxBounds[0], maxBounds[1], minBounds[2]);
gl.glVertex3f(maxBounds[0], minBounds[1], minBounds[2]);
gl.glVertex3f(maxBounds[0], minBounds[1], minBounds[2]);
gl.glVertex3f(maxBounds[0], minBounds[1], maxBounds[2]);
gl.glEnd();
if (showParent) {
gl.glPopMatrix();
gl.glBegin(GL.GL_LINES);
gl.glColor3f(1, 0, 1);
gl.glVertex3f(minBox[0], minBox[1], minBox[2]);
gl.glVertex3f(minBox[0], minBox[1], maxBox[2]);
gl.glVertex3f(minBox[0], minBox[1], minBox[2]);
gl.glVertex3f(minBox[0], maxBox[1], minBox[2]);
gl.glVertex3f(minBox[0], minBox[1], minBox[2]);
gl.glVertex3f(maxBox[0], minBox[1], minBox[2]);
gl.glVertex3f(maxBox[0], maxBox[1], maxBox[2]);
gl.glVertex3f(maxBox[0], maxBox[1], minBox[2]);
gl.glVertex3f(maxBox[0], maxBox[1], maxBox[2]);
gl.glVertex3f(maxBox[0], minBox[1], maxBox[2]);
gl.glVertex3f(maxBox[0], maxBox[1], maxBox[2]);
gl.glVertex3f(minBox[0], maxBox[1], maxBox[2]);
gl.glVertex3f(minBox[0], minBox[1], maxBox[2]);
gl.glVertex3f(minBox[0], maxBox[1], maxBox[2]);
gl.glVertex3f(minBox[0], minBox[1], maxBox[2]);
gl.glVertex3f(maxBox[0], minBox[1], maxBox[2]);
gl.glVertex3f(minBox[0], maxBox[1], maxBox[2]);
gl.glVertex3f(minBox[0], maxBox[1], minBox[2]);
gl.glVertex3f(maxBox[0], maxBox[1], minBox[2]);
gl.glVertex3f(minBox[0], maxBox[1], minBox[2]);
gl.glVertex3f(maxBox[0], maxBox[1], minBox[2]);
gl.glVertex3f(maxBox[0], minBox[1], minBox[2]);
gl.glVertex3f(maxBox[0], minBox[1], minBox[2]);
gl.glVertex3f(maxBox[0], minBox[1], maxBox[2]);
gl.glEnd();
// Push it back down again as the next call after this will pop it
gl.glPushMatrix();
}
}
private void drawVertex(GL gl, Coordinates point) {
gl.glVertex3f(point.getLongitude(), point.getLatitude(), 0);
}
public void prerenderToTexture(GL gl) {
int texSize = 256;
final int[] tmp = new int[1];
gl.glGenTextures(1, tmp, 0);
textureID = tmp[0];
gl.glBindTexture(GL_TEXTURE_2D, textureID);
gl.glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
gl.glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
gl.glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
gl.glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
gl.glTexImage2D(
GL_TEXTURE_2D, 0, GL_RGBA, texSize, texSize, 0, GL_BGRA, GL_UNSIGNED_BYTE, null);
final int[] fbo = new int[1];
gl.glGenFramebuffersEXT(1, IntBuffer.wrap(fbo));
gl.glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fbo[0]);
gl.glFramebufferTexture2DEXT(
GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, textureID, 0);
gl.glDrawBuffers(1, IntBuffer.wrap(new int[] {GL_COLOR_ATTACHMENT0_EXT}));
final int[] rba = new int[1];
gl.glGenRenderbuffersEXT(1, IntBuffer.wrap(rba));
gl.glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, rba[0]);
gl.glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT, texSize, texSize);
gl.glFramebufferRenderbufferEXT(
GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, rba[0]);
gl.glPushMatrix();
gl.glLoadIdentity();
gl.glPushAttrib(GL_VIEWPORT_BIT);
gl.glViewport(0, 0, texSize, texSize);
gl.glMatrixMode(GL.GL_PROJECTION);
gl.glPushMatrix();
gl.glLoadIdentity();
gl.glOrtho(0, texSize, 0, texSize, 0, 10);
gl.glMatrixMode(GL.GL_MODELVIEW);
Set<MapElement> map = State.getInstance().getMapInfo().queryElements(detailLevel, bounds, true);
gl.glDisable(GL_TEXTURE_2D);
gl.glColor3f(1, 1, 1);
for (MapElement element : map) {
if (element instanceof Street) {
drawLine(
gl,
((Street) element).getDrawingSize() / (float) Projection.getZoomFactor(detailLevel),
((Street) element).getNodes());
}
}
gl.glColor3f(0.3f, 0.3f, 0.3f);
for (MapElement element : map) {
if ((element instanceof Area) && (((Area) element).getWayInfo().isBuilding())) {
gl.glBegin(GL_POLYGON);
for (Node node : ((Area) element).getNodes()) {
Coordinates pos = getLocalCoordinates(node.getPos());
gl.glVertex3f(pos.getLongitude(), pos.getLatitude(), 0f);
}
gl.glEnd();
}
}
gl.glEnable(GL_TEXTURE_2D);
gl.glMatrixMode(GL.GL_PROJECTION);
gl.glPopMatrix();
gl.glMatrixMode(GL.GL_MODELVIEW);
gl.glPopAttrib();
gl.glPopMatrix();
gl.glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);
gl.glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, 0);
gl.glDeleteFramebuffersEXT(1, fbo, 0);
gl.glDeleteRenderbuffersEXT(1, rba, 0);
}