public void display(GLAutoDrawable drawable) {
GL2 gl = drawable.getGL().getGL2();
// Clear the drawing area
gl.glClear(GL2.GL_COLOR_BUFFER_BIT | GL2.GL_DEPTH_BUFFER_BIT);
// Reset the current matrix to the "identity"
gl.glLoadIdentity();
// Move the "drawing cursor" around
gl.glTranslatef(-1.5f, 0.0f, -6.0f);
// Drawing Using Triangles
gl.glBegin(GL2.GL_TRIANGLES);
gl.glColor3f(1.0f, 0.0f, 0.0f); // Set the current drawing color to red
gl.glVertex3f(0.0f, 1.0f, 0.0f); // Top
gl.glColor3f(0.0f, 1.0f, 0.0f); // Set the current drawing color to green
gl.glVertex3f(-1.0f, -1.0f, 0.0f); // Bottom Left
gl.glColor3f(0.0f, 0.0f, 1.0f); // Set the current drawing color to blue
gl.glVertex3f(1.0f, -1.0f, 0.0f); // Bottom Right
// Finished Drawing The Triangle
gl.glEnd();
// Move the "drawing cursor" to another position
gl.glTranslatef(3.0f, 0.0f, 0.0f);
// Draw A Quad
gl.glBegin(GL2.GL_QUADS);
gl.glColor3f(0.5f, 0.5f, 1.0f); // Set the current drawing color to light blue
gl.glVertex3f(-1.0f, 1.0f, 0.0f); // Top Left
gl.glVertex3f(1.0f, 1.0f, 0.0f); // Top Right
gl.glVertex3f(1.0f, -1.0f, 0.0f); // Bottom Right
gl.glVertex3f(-1.0f, -1.0f, 0.0f); // Bottom Left
// Done Drawing The Quad
gl.glEnd();
}
@Override
public void draw(GL2 gl, Object obj) {
if (!(Force.class.isAssignableFrom(obj.getClass()))) return;
Force force = (Force) obj;
gl.glLineWidth(2.5f);
gl.glColor3f(1.0f, 0f, 0f);
gl.glBegin(GL.GL_LINES);
gl.glVertex3d(
force.getPointApplication().getX(),
force.getPointApplication().getY(),
force.getPointApplication().getZ());
Vector3D finalPoint = force.getPointApplication().add(force.getForce());
gl.glVertex3d(finalPoint.getX(), finalPoint.getY(), finalPoint.getZ());
gl.glEnd();
gl.glTranslated(
force.getPointApplication().getX(),
force.getPointApplication().getY(),
force.getPointApplication().getZ());
gl.glColor3f(1.0f, 0.0f, 0.0f);
GLU glu = new GLU();
GLUquadric q = glu.gluNewQuadric();
glu.gluQuadricDrawStyle(q, GLU.GLU_FILL);
glu.gluSphere(q, Force.originRadius, 5, 5);
glu.gluDeleteQuadric(q);
}
public void render2d(GL2 g) {
for (Entry<EntityData, TileEntity> e : entities.entrySet()) {
EntityData key = e.getKey();
TileEntity entity = e.getValue();
g.glPushMatrix();
switch (key.getType()) {
case VBORDER:
g.glRotatef(90, 0, 0, 1);
BorderData vBorder = (BorderData) entity;
if (Globals.upCamera) {
vBorder.render(g, this);
}
g.glColor3f(1, 1, 1);
break;
case HBORDER:
BorderData hBorder = (BorderData) entity;
if (Globals.upCamera) {
hBorder.render(g, this);
}
g.glColor3f(1, 1, 1);
break;
}
g.glPopMatrix();
g.glColor3f(1, 1, 1);
}
}
public static void drawAxis(GL2 gl, float size) {
gl.glColor3f(1, 0, 0);
drawLine(gl, new Vector3f(0, 0, 0), new Vector3f(size, 0.0f, 0.0f));
gl.glColor3f(0.0f, 1.0f, 0.0f);
drawLine(gl, new Vector3f(0, 0, 0), new Vector3f(0.0f, size, 0.0f));
gl.glColor3f(0.0f, 0.0f, 1.0f);
drawLine(gl, new Vector3f(0, 0, 0), new Vector3f(0.0f, 0.0f, size));
}
@Override
public void render(GL2 gl, float trajectory) {
// flat = true;
gl.glPushMatrix();
{
gl.glTranslatef(c.x, c.y, c.z);
gl.glRotatef(trajectory, 0, -1, 0);
gl.glRotatef((flat) ? -90 : 0, 1, 0, 0);
gl.glRotatef(rotation, 0, 0, 1);
Vec3 scale = new Vec3(0.75f, 2.0f, 0);
if (miniature) scale = scale.multiply(0.5f);
scale = scale.multiply(0.8f);
gl.glScalef(scale.x, scale.y, scale.z);
gl.glTranslatef(0, 0.2f, 0);
gl.glDepthMask(false);
gl.glDisable(GL_LIGHTING);
gl.glEnable(GL_BLEND);
gl.glEnable(GL_TEXTURE_2D);
gl.glBlendFunc(GL2.GL_SRC_ALPHA, GL2.GL_ONE);
whiteSpark.bind(gl);
gl.glColor3f(colors[color][0], colors[color][1], colors[color][2]);
gl.glBegin(GL_QUADS);
{
gl.glTexCoord2f(1.0f, 1.0f);
gl.glVertex3f(-0.5f, -0.5f, 0.0f);
gl.glTexCoord2f(1.0f, 0.0f);
gl.glVertex3f(-0.5f, 0.5f, 0.0f);
gl.glTexCoord2f(0.0f, 0.0f);
gl.glVertex3f(0.5f, 0.5f, 0.0f);
gl.glTexCoord2f(0.0f, 1.0f);
gl.glVertex3f(0.5f, -0.5f, 0.0f);
}
gl.glEnd();
gl.glDisable(GL_BLEND);
gl.glEnable(GL_LIGHTING);
gl.glDepthMask(true);
gl.glColor3f(1, 1, 1);
}
gl.glPopMatrix();
}
@Override
public void draw(GL2 gl) {
// Arbres triangles
gl.glBegin(GL_TRIANGLES);
gl.glColor3f(30.0f / 256.0f, 109.0f / 256.0f, 54.0f / 256.0f);
gl.glVertex3f(0.0f, hauteurArbre, 0.0f);
gl.glVertex3f(-largeurArbre, 0.0f, 0.0f);
gl.glVertex3f(largeurArbre, 0.0f, 0.0f);
gl.glColor3f(47.0f / 256.0f, 135.0f / 256.0f, 74.0f / 256.0f);
gl.glVertex3f(0.0f, hauteurArbre, 0.0f);
gl.glVertex3f(0.0f, 0.0f, -largeurArbre);
gl.glVertex3f(0.0f, 0.0f, largeurArbre);
gl.glEnd();
}
@Override
public void display(GLAutoDrawable gLDrawable) {
final GL2 gl = gLDrawable.getGL().getGL2();
gl.glClear(GL.GL_COLOR_BUFFER_BIT);
gl.glClear(GL.GL_DEPTH_BUFFER_BIT);
gl.glLoadIdentity();
gl.glTranslatef(0.0f, 0.0f, -5.0f);
// rotate about the three axes
gl.glRotatef(rotateT, 1.0f, 0.0f, 0.0f);
gl.glRotatef(rotateT, 0.0f, 1.0f, 0.0f);
gl.glRotatef(rotateT, 0.0f, 0.0f, 1.0f);
// Draw A Quad
gl.glBegin(GL2.GL_QUADS);
gl.glColor3f(0.0f, 1.0f, 1.0f); // set the color of the quad
gl.glVertex3f(-1.0f, 1.0f, 0.0f); // Top Left
gl.glVertex3f(1.0f, 1.0f, 0.0f); // Top Right
gl.glVertex3f(1.0f, -1.0f, 0.0f); // Bottom Right
gl.glVertex3f(-1.0f, -1.0f, 0.0f); // Bottom Left
// Done Drawing The Quad
gl.glEnd();
// increasing rotation for the next iteration
rotateT += 0.2f;
}
@SuppressWarnings("unused")
private static void drawBox(GL2 gl) {
gl.glDisable(GLLightingFunc.GL_LIGHTING);
gl.glDisable(GL.GL_TEXTURE_2D);
gl.glColor3f(1.0f, 1.0f, 1.0f);
gl.glBegin(GL.GL_LINE_STRIP);
gl.glVertex3f(-0.5f, -0.5f, 0.5f);
gl.glVertex3f(0.5f, -0.5f, 0.5f);
gl.glVertex3f(0.5f, 0.5f, 0.5f);
gl.glVertex3f(-0.5f, 0.5f, 0.5f);
gl.glVertex3f(-0.5f, -0.5f, 0.5f);
gl.glVertex3f(-0.5f, -0.5f, -0.5f);
gl.glVertex3f(0.5f, -0.5f, -0.5f);
gl.glVertex3f(0.5f, 0.5f, -0.5f);
gl.glVertex3f(-0.5f, 0.5f, -0.5f);
gl.glVertex3f(-0.5f, -0.5f, -0.5f);
gl.glEnd();
gl.glBegin(GL.GL_LINE_STRIP);
gl.glVertex3f(-0.5f, 0.5f, 0.5f);
gl.glVertex3f(-0.5f, 0.5f, -0.5f);
gl.glEnd();
gl.glBegin(GL.GL_LINE_STRIP);
gl.glVertex3f(0.5f, 0.5f, 0.5f);
gl.glVertex3f(0.5f, 0.5f, -0.5f);
gl.glEnd();
gl.glBegin(GL.GL_LINE_STRIP);
gl.glVertex3f(0.5f, -0.5f, 0.5f);
gl.glVertex3f(0.5f, -0.5f, -0.5f);
gl.glEnd();
gl.glEnable(GL.GL_TEXTURE_2D);
gl.glEnable(GLLightingFunc.GL_LIGHTING);
gl.glEnable(GLLightingFunc.GL_LIGHT0);
}
public void setup() {
// OPENGL SPECIFIC INITIALIZATION (OPTIONAL)
GL2 gl = getGL2();
gl.glEnable(GL2.GL_CULL_FACE);
float light_model_ambient[] = {0.3f, 0.3f, 0.3f, 1.0f};
float light0_diffuse[] = {0.9f, 0.9f, 0.9f, 0.9f};
float light0_direction[] = {0.0f, -0.4f, 1.0f, 0.0f};
gl.glEnable(GL2.GL_NORMALIZE);
gl.glShadeModel(GL2.GL_SMOOTH);
gl.glLightModeli(GL2.GL_LIGHT_MODEL_LOCAL_VIEWER, GL2.GL_FALSE);
gl.glLightModeli(GL2.GL_LIGHT_MODEL_TWO_SIDE, GL2.GL_FALSE);
gl.glLightModelfv(GL2.GL_LIGHT_MODEL_AMBIENT, light_model_ambient, 0);
gl.glLightfv(GL2.GL_LIGHT0, GL2.GL_DIFFUSE, light0_diffuse, 0);
gl.glLightfv(GL2.GL_LIGHT0, GL2.GL_POSITION, light0_direction, 0);
gl.glEnable(GL2.GL_LIGHT0);
gl.glEnable(GL2.GL_COLOR_MATERIAL);
gl.glEnable(GL2.GL_LIGHTING);
gl.glColor3f(0.9f, 0.9f, 0.9f);
gl.glBlendFunc(GL2.GL_SRC_ALPHA, GL2.GL_ONE_MINUS_SRC_ALPHA);
background(0, 0, 0);
video_frame = new VideoFrame();
}
public void draw() {
GL2 gl = getGL2();
pushMatrix();
translate(0, 0, -2);
rotate(view_rotx, 1.0, 0.0, 0.0);
rotate(view_roty, 0.0, 1.0, 0.0);
rotate(view_rotz, 0.0, 0.0, 1.0);
translate(0, 0, 2);
if (app != null) {
if (is_playing) {
map_previous = map;
map =
new DepthMap(
app.w,
app.h,
DepthMap.fromRawDepthFile(
new File(app.filename), app.frame_now - 1, app.w, app.h, false));
map.maskZ(app.z_threshold.getValue() / 100f);
// map.maskRect(130,40,100,100);//head
// map.maskRect(50,140,130,100);//arms
map.setUVuniform();
if (app.frame_now < app.frames) {
app.frame_now += 1;
app.time_domain.setValue(app.frame_now);
} else {
app.play_button.setText("Play");
stop();
}
}
}
if (map != null) {
if (app.show_diff.isSelected() && map != null && map_previous != null) {
// map.drawNormals(gl);
// gl.glClear(GL2.GL_DEPTH);
// gl.glEnable(GL2.GL_BLEND);
computeColorMap();
gl.glDisable(GL2.GL_LIGHTING);
gl.glEnable(GL2.GL_TEXTURE_2D);
gl.glColor4f(1f, 1f, 1f, 0.75f);
video_frame.use(gl);
map.drawTextureNormals(gl);
gl.glDisable(GL2.GL_TEXTURE_2D);
gl.glEnable(GL2.GL_LIGHTING);
gl.glDisable(GL2.GL_BLEND);
} else {
gl.glColor3f(0.9f, 0.9f, 0.9f);
map.drawNormals(gl);
}
}
popMatrix();
}
private void drawStar(GL2 gl, GLAutoDrawable drawable, Float x, Float y, Float z) {
// Pushing to matrix stack
gl.glPushMatrix();
// STAR
// Moves the figure in the (x, y, z)-axis
gl.glTranslatef(x, y, z);
// BEGIN Star
gl.glBegin(GL_LINE_LOOP);
// Pushing to attribute stack
gl.glPushAttrib(GL_ALL_ATTRIB_BITS);
// Set color to GREEN
gl.glColor3f(0.0f, 1.0f, 0.0f);
// Draw the sides
gl.glVertex3f(0.0f, 1.0f, 0.0f);
gl.glVertex3f(0.2f, 0.2f, 0.0f);
gl.glVertex3f(1.0f, 0.0f, 0.0f);
gl.glVertex3f(0.2f, -0.2f, 0.0f);
gl.glVertex3f(0.0f, -1.0f, 0.0f);
gl.glVertex3f(-0.2f, -0.2f, 0.0f);
gl.glVertex3f(-1.0f, 0.0f, 0.0f);
gl.glVertex3f(-0.2f, 0.2f, 0.0f);
// END Star
gl.glEnd();
// Popping state
gl.glPopAttrib();
gl.glPopMatrix();
}
private void drawSquare(GL2 gl, GLAutoDrawable drawable, Float x, Float y, Float z) {
// Pushing to matrix stack
gl.glPushMatrix();
// SQUARE
// Moves the figure in the (x, y, z)-axis
gl.glTranslatef(x, y, z);
// Makes so that square is filled in
gl.glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
// BEGIN Square
gl.glBegin(GL_QUADS);
// Pushing to attribute stack
gl.glPushAttrib(GL_ALL_ATTRIB_BITS);
// Set color to BLUE
gl.glColor3f(0.0f, 0.0f, 1.0f);
// The Quad
gl.glVertex3f(1.0f, 1.0f, 1.0f);
gl.glVertex3f(-1.0f, 1.0f, 1.0f);
gl.glVertex3f(-1.0f, -1.0f, 1.0f);
gl.glVertex3f(1.0f, -1.0f, 1.0f);
// END Square
gl.glEnd();
// Popping state
gl.glPopAttrib();
gl.glPopMatrix();
}
public void display(GLAutoDrawable drawable) {
GL2 gl = drawable.getGL().getGL2();
//
double eqn[] = {0.0, 1.0, 0.0, 0.0};
double eqn2[] = {1.0, 0.0, 0.0, 0.0};
gl.glClear(GL.GL_COLOR_BUFFER_BIT);
gl.glColor3f(1.0f, 1.0f, 1.0f);
gl.glPushMatrix();
gl.glTranslatef(0.0f, 0.0f, -5.0f);
/* clip lower half -- y < 0 */
gl.glClipPlane(GL2.GL_CLIP_PLANE0, eqn, 0);
gl.glEnable(GL2.GL_CLIP_PLANE0);
/* clip left half -- x < 0 */
gl.glClipPlane(GL2.GL_CLIP_PLANE1, eqn2, 0);
gl.glEnable(GL2.GL_CLIP_PLANE1);
gl.glRotatef(90.0f, 1.0f, 0.0f, 0.0f);
glut.glutWireSphere(1.0, 20, 16);
gl.glPopMatrix();
gl.glFlush();
}
private void compile(GL2 gl) {
startList = 12;
gl.glNewList(startList, GL2.GL_COMPILE);
gl.glColor3f(1f, 1f, 1f);
glut.glutSolidCube(0.6f);
gl.glEndList();
}
private void renderGround(GL2 g) {
if ((Globals.upCamera && Globals.floor >= 0 && Globals.floor < 3) || !Globals.upCamera) {
if (Globals.upCamera && Globals.floor >= 0 && Globals.floor < 3) {
switch (Globals.floor) {
case 0:
g.glColor3f(1, 1, 1);
break;
case 1:
g.glColor3f(0.6f, 0.6f, 0.6f);
break;
case 2:
g.glColor3f(0.25f, 0.25f, 0.25f);
break;
}
}
ground.render(g, this);
}
}
@Override
public void display(GLAutoDrawable drawable) {
GL2 gl = drawable.getGL().getGL2();
GLUT glut = new GLUT();
// limpa o buer
gl.glClear(GL2.GL_COLOR_BUFFER_BIT | GL2.GL_DEPTH_BUFFER_BIT);
// de ne que a matrix é a de modelo
gl.glMatrixMode(GL2.GL_MODELVIEW);
gl.glLoadIdentity();
gl.glScalef(delta, delta, delta); // faça a escala de todos objetos
gl.glPushMatrix(); // armazena a matriz corrente
gl.glTranslatef(-3, 0, 0);
gl.glRotatef(beta, 0, 1, 0);
gl.glRotatef(alpha, 1, 0, 0);
gl.glColor3f(1, 1, 0);
glut.glutWireSphere(1, 20, 20);
// desenha um piso sob a esfera
gl.glTranslatef(0, -1, 0);
gl.glScalef(4, 0.1f, 4);
gl.glColor3f(0, 0, 1);
glut.glutSolidCube(1.0f);
gl.glPopMatrix(); // restaura a matriz anterior
gl.glPushMatrix(); // armazena a matriz corrente
gl.glTranslatef(3, 0, 0);
gl.glRotatef(beta, 0, 1, 0);
gl.glRotatef(alpha, 1, 0, 0);
gl.glColor3f(1, 0, 0);
glut.glutWireSphere(1, 20, 20);
// desenha um piso sob a esfera
gl.glTranslatef(0, -1, 0);
gl.glScalef(4, 0.1f, 4);
gl.glColor3f(0, 1, 0);
glut.glutSolidCube(1.0f);
gl.glPopMatrix(); // restaura a matriz anterior
// força o desenho das primitivas
gl.glFlush();
}
/**
* This method is a temporary helper method for draving the light for debuging purposes. Except it
* to decome deprecated in the future.
*/
public void renderLight(GL2 gl) {
gl.glDisable(GLLightingFunc.GL_LIGHTING);
ShaderProgram.unuseCurrent(gl);
switch (type) {
case Directional:
gl.glBegin(GL2.GL_LINES);
gl.glColor3f(0.0f, 0.0f, 0.0f);
gl.glVertex3f(0.0f, 0.0f, 0.0f);
gl.glColor3f(1.0f, 1.0f, 1.0f);
gl.glVertex3f(position.x, position.y, position.z);
gl.glEnd();
break;
case Point:
gl.glBegin(GL2.GL_POINTS);
gl.glColor3f(1.0f, 1.0f, 1.0f);
gl.glVertex3f(position.x, position.y, position.z);
gl.glEnd();
break;
case Spot:
Vector3f p = position, d = new Vector3f();
d.set(direction);
d.scale(4);
gl.glBegin(GL2.GL_LINES);
gl.glColor3f(1.0f, 1.0f, 1.0f);
gl.glVertex3f(p.x, p.y, p.z);
gl.glColor3f(0.2f, 0.2f, 0.2f);
gl.glVertex3f(p.x + d.x, p.y + d.y, p.z + d.z);
/* Spot wireframe
d.normalize();
//d.
d.cross(d, new Vector3f(0.0f, 1.0f, 0.0f));
gl.glColor3f(1.0f, 1.0f, 1.0f);
gl.glVertex3f(p.x, p.y, p.z);
gl.glColor3f(0.4f, 0.2f, 0.2f);
gl.glVertex3f(p.x+d.x, p.y+d.y, p.z+d.z);
*/
gl.glEnd();
}
gl.glEnable(GLLightingFunc.GL_LIGHTING);
}
/*
* The three rectangles are drawn. In selection mode, each rectangle is
* given the same name. Note that each rectangle is drawn with a different z
* value.
*/
private void drawRects(GL2 gl, int mode) {
if (mode == GL2.GL_SELECT) gl.glLoadName(1);
gl.glBegin(GL2.GL_QUADS);
gl.glColor3f(1.0f, 1.0f, 0.0f);
gl.glVertex3i(2, 0, 0);
gl.glVertex3i(2, 6, 0);
gl.glVertex3i(6, 6, 0);
gl.glVertex3i(6, 0, 0);
gl.glColor3f(0.0f, 1.0f, 1.0f);
gl.glVertex3i(3, 2, -1);
gl.glVertex3i(3, 8, -1);
gl.glVertex3i(8, 8, -1);
gl.glVertex3i(8, 2, -1);
gl.glColor3f(1.0f, 0.0f, 1.0f);
gl.glVertex3i(0, 2, -2);
gl.glVertex3i(0, 7, -2);
gl.glVertex3i(5, 7, -2);
gl.glVertex3i(5, 2, -2);
gl.glEnd();
}
// Support Methods
private void drawPyramid(GL2 gl, GLAutoDrawable drawable, Float x, Float y, Float z) {
// Pushing to matrix stack
gl.glPushMatrix();
// PYRAMID
// Moves the figure in the (x, y, z)-axis
gl.glTranslatef(x, y, z);
// Rotates the pyramid, just for "fun"
gl.glRotatef(-55.0f, 0.0f, 1.0f, 0.0f);
// Makes only the outlines
gl.glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
// BEGIN Pyramid
gl.glBegin(GL_TRIANGLES);
// Pushing current color to stack
gl.glPushAttrib(GL_ALL_ATTRIB_BITS);
// Set color to RED
gl.glColor3f(1.0f, 0.0f, 0.0f);
// Front triangle
gl.glVertex3f(0.0f, 1.0f, 0.0f);
gl.glVertex3f(-1.0f, -1.0f, 1.0f);
gl.glVertex3f(1.0f, -1.0f, 1.0f);
// Right triangle
gl.glVertex3f(0.0f, 1.0f, 0.0f);
gl.glVertex3f(1.0f, -1.0f, 1.0f);
gl.glVertex3f(1.0f, -1.0f, -1.0f);
// Left triangle
gl.glVertex3f(0.0f, 1.0f, 0.0f);
gl.glVertex3f(-1.0f, -1.0f, -1.0f);
gl.glVertex3f(-1.0f, -1.0f, 1.0f);
// Back triangle
gl.glVertex3f(0.0f, 1.0f, 0.0f);
gl.glVertex3f(1.0f, -1.0f, -1.0f);
gl.glVertex3f(-1.0f, -1.0f, -1.0f);
// END Pyramid
gl.glEnd();
// Popping state
gl.glPopAttrib();
gl.glPopMatrix();
}
/**
* Find in the goor container focused element and draw tooltip for it
*
* @param drawable OpenGL drawing context
*/
public void drawTooltip(GLAutoDrawable drawable) { // TODO move it to separate class
GL2 gl = (GL2) drawable.getGL();
for (Element element : getRoot()) {
if (element.isFocused()) {
MyColor color = PropertiesHolder.getInstance().getColorSchema().getVerticesTooltips();
gl.glColor3f(color.getRed(), color.getGreen(), color.getBlue());
Point2D p = element.getPosition();
gl.glRasterPos2d(p.getX(), p.getY());
glut().glutBitmapString(GLUT.BITMAP_8_BY_13, element.getTooltip());
}
}
}
@Override
public void draw(IBNAView view, ICoordinateMapper cm, GL2 gl, Rectangle clip, IResources r) {
if (Boolean.TRUE.equals(t.get(IHasSelected.SELECTED_KEY))) {
List<Point> localPoints = BNAUtils.worldToLocal(cm, t.getPoints());
gl.glLineWidth(1f);
gl.glColor3f(1f, 1f, 1f);
gl.glBegin(GL2.GL_LINE_STRIP);
for (Point p : localPoints) {
gl.glVertex2f(p.x + 0.5f, p.y + 0.5f);
}
gl.glEnd();
gl.glColor3f(0f, 0f, 0f);
gl.glLineStipple(1, (short) (0x0f0f0f0f >> t.getRotatingOffset() % 8));
gl.glBegin(GL2.GL_LINE_STRIP);
for (Point p : localPoints) {
gl.glVertex2f(p.x + 0.5f, p.y + 0.5f);
}
gl.glEnd();
}
}
public void draw(GL2 gl, GLU glu) {
gl.glColor3f(1f, 0f, .25f);
// Lamp Stem, cylindrical, a little smaller at the top.
gl.glPushMatrix();
gl.glRotatef(-90f, 1f, 0f, 0f); // stand upright (Y)
glu.gluCylinder(quadric, 1., 1, 3., 10, 1);
gl.glPopMatrix();
// Table Top
gl.glPushMatrix();
gl.glTranslated(0, 3, 0);
gl.glRotatef(-90f, 100f, 0f, 0f); // stand upright (Y)
glu.gluDisk(quadric, 0, 4., 15, 5); // also to be flipped
gl.glPopMatrix();
}
/*
* The nine squares are drawn. In selection mode, each square is given two
* names: one for the row and the other for the column on the grid. The
* color of each square is determined by its position on the grid, and the
* value in the board[][] array.
*/
private void drawSquares(GL2 gl, int mode) {
int i, j;
for (i = 0; i < 3; i++) {
if (mode == GL2.GL_SELECT) {
gl.glLoadName(i);
}
for (j = 0; j < 3; j++) {
if (mode == GL2.GL_SELECT) {
gl.glPushName(j);
}
gl.glColor3f((float) i / 3.0f, (float) j / 3.0f, (float) board[i][j] / 3.0f);
gl.glRecti(i, j, i + 1, j + 1);
if (mode == GL2.GL_SELECT) {
gl.glPopName();
}
}
}
}
public void displayOctree(GL2 gl, GLU glu) {
gl.glDisable(GL2.GL_CULL_FACE);
gl.glPolygonMode(GL2.GL_FRONT_AND_BACK, GL2.GL_LINE);
for (Octant o : leaves) {
if (o != null && o.visible) {
gl.glColor3f(1, 0.5f, 0.5f);
o.displayOctant(gl);
o.displayOctantInfo(gl, glu);
}
}
if (!vizController.getVizConfig().isWireFrame()) {
gl.glPolygonMode(GL2.GL_FRONT_AND_BACK, GL2.GL_FILL);
}
if (vizController.getVizModel().isCulling()) {
gl.glEnable(GL2.GL_CULL_FACE);
gl.glCullFace(GL2.GL_BACK);
}
}
@Override
protected void _render(GL2 gl, GLU glu, GLUT glut) {
gl.glScalef(.3f, .3f, 1);
gl.glBegin(GL2.GL_QUADS);
for (int i = 12; i >= 1; i--) {
gl.glColor3f(1 - (i / 12f), 1 - (i / 12f), 1 - (i / 12f));
gl.glVertex3f(-i, -i, 0);
gl.glVertex3f(i, -i, 0);
gl.glVertex3f(i, i, 0);
gl.glVertex3f(-i, i, 0);
}
gl.glEnd();
}
@Override
public void init(GLAutoDrawable glAutoDrawable) {
gl = glAutoDrawable.getGL().getGL2();
glu = new GLU();
glut = new GLUT();
gl.glClearColor(0.549f, 0.675f, 0.227f, 0.0f);
gl.glMatrixMode(GL2.GL_PROJECTION);
gl.glLoadIdentity();
glu.gluOrtho2D(left, right, bottom, top);
gl.glViewport((int) bottom, (int) left, (int) top, (int) right);
gl.glMatrixMode(GL2.GL_MODELVIEW);
gl.glColor3f(.357f, .184f, .478f);
maxFrames = 50 * ifsFiles.size() + 1000;
base = gl.glGenLists(maxFrames);
currentDrawList = base;
ifsfile = "CS371/assignments/assignment02/tri.ifs";
loadifs();
}
@Override
public void draw(GL2 gl) {
gl.glTranslatef(x, y, z);
// ----- Render the Color Cube -----
gl.glBegin(GL_QUADS); // of the color cube
gl.glColor3f(red, green, blue);
gl.glVertex3f(-demiWidth, -demiWidth, -demiWidth);
gl.glVertex3f(+demiWidth, -demiWidth, -demiWidth);
gl.glVertex3f(+demiWidth, +demiWidth, -demiWidth);
gl.glVertex3f(-demiWidth, +demiWidth, -demiWidth);
gl.glVertex3f(-demiWidth, -demiWidth, -demiWidth);
gl.glVertex3f(-demiWidth, -demiWidth, +demiWidth);
gl.glVertex3f(-demiWidth, +demiWidth, +demiWidth);
gl.glVertex3f(-demiWidth, +demiWidth, -demiWidth);
gl.glVertex3f(-demiWidth, -demiWidth, +demiWidth);
gl.glVertex3f(-demiWidth, +demiWidth, +demiWidth);
gl.glVertex3f(+demiWidth, +demiWidth, +demiWidth);
gl.glVertex3f(+demiWidth, -demiWidth, +demiWidth);
gl.glVertex3f(+demiWidth, -demiWidth, -demiWidth);
gl.glVertex3f(+demiWidth, +demiWidth, -demiWidth);
gl.glVertex3f(+demiWidth, +demiWidth, +demiWidth);
gl.glVertex3f(+demiWidth, -demiWidth, +demiWidth);
gl.glVertex3f(+demiWidth, -demiWidth, -demiWidth);
gl.glVertex3f(-demiWidth, -demiWidth, -demiWidth);
gl.glVertex3f(-demiWidth, -demiWidth, +demiWidth);
gl.glVertex3f(+demiWidth, -demiWidth, +demiWidth);
gl.glVertex3f(-demiWidth, +demiWidth, +demiWidth);
gl.glVertex3f(+demiWidth, +demiWidth, +demiWidth);
gl.glVertex3f(+demiWidth, +demiWidth, -demiWidth);
gl.glVertex3f(-demiWidth, +demiWidth, -demiWidth);
gl.glEnd(); // of the color cube
gl.glTranslatef(-x, -y, -z);
}
/*
* display() draws a triangle at an angle.
*/
public void display(GLAutoDrawable drawable) {
GL2 gl = drawable.getGL().getGL2();
//
gl.glClear(GL.GL_COLOR_BUFFER_BIT);
if (key != null)
switch (key.getKeyChar()) {
case 'c':
gl.glFogi(GL2.GL_FOG_COORDINATE_SOURCE, GL2.GL_FRAGMENT_DEPTH);
break;
case 'C':
gl.glFogi(GL2.GL_FOG_COORDINATE_SOURCE, GL2.GL_FOG_COORDINATE);
break;
case 'b':
gl.glMatrixMode(GL2.GL_MODELVIEW);
gl.glTranslatef(0.0f, 0.0f, -0.25f);
break;
case 'f':
gl.glMatrixMode(GL2.GL_MODELVIEW);
gl.glTranslatef(0.0f, 0.0f, 0.25f);
break;
default:
break;
}
gl.glColor3f(1.0f, 0.75f, 0.0f);
gl.glBegin(GL2.GL_TRIANGLES);
gl.glFogCoordf(f1);
gl.glVertex3f(2.0f, -2.0f, 0.0f);
gl.glFogCoordf(f2);
gl.glVertex3f(-2.0f, 0.0f, -5.0f);
gl.glFogCoordf(f3);
gl.glVertex3f(0.0f, 2.0f, -10.0f);
gl.glEnd();
gl.glFlush();
}
@Override
protected void render(GL g) {
GL2 gl = g.getGL2();
gl.glColor3f(.5f, .5f, .5f);
// =======================================\\
// Retained Mode \\
// =======================================\\
gl.glEnableClientState(GL2.GL_VERTEX_ARRAY);
gl.glVertexPointer(3, GL2.GL_FLOAT, 0, vertexBuffer);
if (normal) {
gl.glEnableClientState(GL2.GL_NORMAL_ARRAY);
gl.glNormalPointer(GL2.GL_FLOAT, 0, normalBuffer);
}
if (texture) {
gl.glEnableClientState(GL2.GL_TEXTURE_COORD_ARRAY);
gl.glTexCoordPointer(2, GL2.GL_FLOAT, 0, textureBuffer);
} else gl.glPolygonMode(GL2.GL_FRONT_AND_BACK, GL2.GL_LINE);
for (IntBuffer face : faces) {
if (face.capacity() == 3)
gl.glDrawElements(GL2.GL_TRIANGLES, face.capacity(), GL2.GL_UNSIGNED_INT, face);
else if (face.capacity() == 4)
gl.glDrawElements(GL2.GL_QUADS, face.capacity(), GL2.GL_UNSIGNED_INT, face);
else gl.glDrawElements(GL2.GL_POLYGON, face.capacity(), GL2.GL_UNSIGNED_INT, face);
}
gl.glDisableClientState(GL2.GL_VERTEX_ARRAY);
if (normal) gl.glDisableClientState(GL2.GL_NORMAL_ARRAY);
if (texture) gl.glDisableClientState(GL2.GL_TEXTURE_COORD_ARRAY);
if (drawBox) bbox.draw(gl);
}
/*
* Sends a quadrilateral to the OpenGL pipeline. Mimics the other quad
* function.
*/
public static void quad(
Vector3f v0, Vector3f v1, Vector3f v2, Vector3f v3, Vector3f n, Color3f c, GLAutoDrawable d) {
GL2 gl = d.getGL().getGL2();
gl.glBegin(GL2.GL_QUADS);
gl.glColor3f(c.x, c.y, c.z);
gl.glNormal3f(n.x, n.y, n.z);
gl.glTexCoord2f(t0.x, t0.y);
gl.glVertex3f(v0.x, v0.y, v0.z);
gl.glTexCoord2f(t1.x, t1.y);
gl.glVertex3f(v1.x, v1.y, v1.z);
gl.glTexCoord2f(t2.x, t2.y);
gl.glVertex3f(v2.x, v2.y, v2.z);
gl.glTexCoord2f(t3.x, t3.y);
gl.glVertex3f(v3.x, v3.y, v3.z);
gl.glEnd();
}
