aboutsummaryrefslogtreecommitdiffstats
path: root/demos/RonsDemos/dinoshade.java
diff options
context:
space:
mode:
Diffstat (limited to 'demos/RonsDemos/dinoshade.java')
-rwxr-xr-xdemos/RonsDemos/dinoshade.java1104
1 files changed, 1104 insertions, 0 deletions
diff --git a/demos/RonsDemos/dinoshade.java b/demos/RonsDemos/dinoshade.java
new file mode 100755
index 0000000..344fd00
--- /dev/null
+++ b/demos/RonsDemos/dinoshade.java
@@ -0,0 +1,1104 @@
+/**
+ * @(#) dinoshade.java
+ * @(#) author: Mark J. Kilgard (converted to Java by Ron Cemer)
+ */
+
+/* Copyright (c) Mark J. Kilgard, 1994, 1997. */
+
+/* This program is freely distributable without licensing fees
+ and is provided without guarantee or warrantee expressed or
+ implied. This program is -not- in the public domain. */
+
+/* Example for PC game developers to show how to *combine* texturing,
+ reflections, and projected shadows all in real-time with OpenGL.
+ Robust reflections use stenciling. Robust projected shadows
+ use both stenciling and polygon offset. PC game programmers
+ should realize that neither stenciling nor polygon offset are
+ supported by Direct3D, so these real-time rendering algorithms
+ are only really viable with OpenGL.
+
+ The program has modes for disabling the stenciling and polygon
+ offset uses. It is worth running this example with these features
+ toggled off so you can see the sort of artifacts that result.
+
+ Notice that the floor texturing, reflections, and shadowing
+ all co-exist properly. */
+
+/* When you run this program: Left mouse button controls the
+ view. Middle mouse button controls light position (left &
+ right rotates light around dino; up & down moves light
+ position up and down). Right mouse button pops up menu. */
+
+/* Check out the comments in the "redraw" routine to see how the
+ reflection blending and surface stenciling is done. You can
+ also see in "redraw" how the projected shadows are rendered,
+ including the use of stenciling and polygon offset. */
+
+import java.applet.*;
+import java.awt.*;
+import java.awt.event.*;
+import java.lang.*;
+import java.util.*;
+import java.io.*;
+import java.util.*;
+import gl4java.GLContext;
+import gl4java.awt.GLAnimCanvas;
+import gl4java.applet.SimpleGLAnimApplet1;
+
+public class dinoshade extends SimpleGLAnimApplet1
+{
+ static final float[][] bodyVerts =
+ {
+ { 0.0f, 3.0f, 0.0f},
+ { 1.0f, 1.0f, 0.0f},
+ { 5.0f, 1.0f, 0.0f},
+ { 8.0f, 4.0f, 0.0f},
+ { 10.0f, 4.0f, 0.0f},
+ { 11.0f, 5.0f, 0.0f},
+ { 11.0f, 11.5f, 0.0f},
+ { 13.0f, 12.0f, 0.0f},
+ { 13.0f, 13.0f, 0.0f},
+ { 10.0f, 13.5f, 0.0f},
+ { 13.0f, 14.0f, 0.0f},
+ { 13.0f, 15.0f, 0.0f},
+ { 11.0f, 16.0f, 0.0f},
+ { 8.0f, 16.0f, 0.0f},
+ { 7.0f, 15.0f, 0.0f},
+ { 7.0f, 13.0f, 0.0f},
+ { 8.0f, 12.0f, 0.0f},
+ { 7.0f, 11.0f, 0.0f},
+ { 6.0f, 6.0f, 0.0f},
+ { 4.0f, 3.0f, 0.0f},
+ { 3.0f, 2.0f, 0.0f},
+ { 1.0f, 2.0f, 0.0f},
+ };
+
+ static final int[][] bodyTris =
+ {
+ { 1, 0, 21 },
+ { 1, 21, 2 },
+ { 21, 20, 2 },
+ { 20, 19, 2 },
+ { 19, 3, 2 },
+ { 19, 18, 3 },
+ { 18, 4, 3 },
+ { 18, 5, 4 },
+ { 18, 6, 5 },
+ { 18, 17, 6 },
+ { 17, 16, 6 },
+ { 16, 7, 6 },
+ { 16, 8, 7 },
+ { 16, 15, 8 },
+ { 15, 9, 8 },
+ { 15, 14, 9 },
+ { 14, 13, 9 },
+ { 9, 13, 12 },
+ { 9, 12, 11 },
+ { 11, 10, 9 },
+ };
+
+ static final float[][] armVerts =
+ {
+ { 8.0f, 10.0f, 0.0f},
+ { 9.0f, 9.0f, 0.0f},
+ { 10.0f, 9.0f, 0.0f},
+ { 13.0f, 8.0f, 0.0f},
+ { 14.0f, 9.0f, 0.0f},
+ { 16.0f, 9.0f, 0.0f},
+ { 15.0f, 9.5f, 0.0f},
+ { 16.0f, 10.0f, 0.0f},
+ { 15.0f, 10.0f, 0.0f},
+ { 15.5f, 11.0f, 0.0f},
+ { 14.5f, 10.0f, 0.0f},
+ { 14.0f, 11.0f, 0.0f},
+ { 14.0f, 10.0f, 0.0f},
+ { 13.0f, 9.0f, 0.0f},
+ { 11.0f, 11.0f, 0.0f},
+ { 9.0f, 11.0f, 0.0f},
+ };
+
+ static final int[][] armTris =
+ {
+ { 0, 15, 1 },
+ { 15, 2, 1 },
+ { 15, 14, 2 },
+ { 14, 13, 2 },
+ { 13, 3, 2 },
+ { 13, 4, 3 },
+ { 13, 12, 4 },
+ { 12, 11, 10 },
+ { 12, 10, 4 },
+ { 10, 6, 4 },
+ { 6, 5, 4 },
+ { 8, 7, 6 },
+ { 10, 8, 6 },
+ { 10, 9, 8 },
+ };
+
+ static final float[][] legVerts =
+ {
+ { 8.0f, 6.0f, 0.0f},
+ { 8.0f, 4.0f, 0.0f},
+ { 9.0f, 3.0f, 0.0f},
+ { 9.0f, 2.0f, 0.0f},
+ { 8.0f, 1.0f, 0.0f},
+ { 8.0f, 0.5f, 0.0f},
+ { 9.0f, 0.0f, 0.0f},
+ { 12.0f, 0.0f, 0.0f},
+ { 10.0f, 1.0f, 0.0f},
+ { 10.0f, 2.0f, 0.0f},
+ { 12.0f, 4.0f, 0.0f},
+ { 11.0f, 6.0f, 0.0f},
+ { 10.0f, 7.0f, 0.0f},
+ { 9.0f, 7.0f, 0.0f},
+ };
+
+ static final int[][] legTris =
+ {
+ { 6, 5, 7 },
+ { 5, 8, 7 },
+ { 5, 4, 8 },
+ { 4, 3, 8 },
+ { 3, 9, 8 },
+ { 3, 2, 9 },
+ { 2, 10, 9 },
+ { 2, 1, 10 },
+ { 1, 0, 10 },
+ { 0, 11, 10 },
+ { 0, 12, 11 },
+ { 0, 13, 12 },
+ };
+
+ static final float[][] eyeVerts =
+ {
+ { 8.75f, 15.0f, 0.0f},
+ { 9.0f, 14.7f, 0.0f},
+ { 9.6f, 14.7f, 0.0f},
+ { 10.1f, 15.0f, 0.0f},
+ { 9.6f, 15.25f, 0.0f},
+ { 9.0f, 15.25f, 0.0f},
+ };
+
+ static final int[][] eyeTris =
+ {
+ { 1, 0, 2 },
+ { 0, 5, 2 },
+ { 5, 4, 2 },
+ { 4, 3, 2 },
+ };
+
+ static final float floorVertices[][] =
+ {
+ { -20.0f, 0.0f, 20.0f },
+ { 20.0f, 0.0f, 20.0f },
+ { 20.0f, 0.0f, -20.0f },
+ { -20.0f, 0.0f, -20.0f },
+ };
+
+
+ /* Initialize the applet */
+
+
+ public void init()
+ {
+ super.init();
+ Dimension d = getSize();
+ canvas = new dinoshadeCanvas(d.width, d.height);
+ add("Center", canvas);
+ }
+
+
+ public static void main( String args[] ) {
+ dinoshade applet =
+ new dinoshade();
+
+ Frame f = new Frame("dinoshade");
+
+ f.addWindowListener( new WindowAdapter()
+ {
+ public void windowClosed(WindowEvent e)
+ {
+ System.exit(0);
+ }
+ public void windowClosing(WindowEvent e)
+ {
+ windowClosed(e);
+ }
+ }
+ );
+
+ f.setLayout(new BorderLayout());
+ f.add("Center", applet);
+ applet.setSize(500,300);
+ applet.init();
+ applet.start();
+ Dimension ps = applet.getPreferredSize();
+ f.setBounds(-100,-100,99,99);
+ f.setVisible(true);
+ f.setVisible(false);
+ Insets i = f.getInsets();
+ f.setBounds(0,0,
+ ps.width+i.left+i.right,
+ ps.height+i.top+i.bottom);
+ f.setVisible(true);
+ }
+
+ /* Local GLAnimCanvas extension class */
+
+
+ private class dinoshadeCanvas extends GLAnimCanvas
+ implements MouseListener, MouseMotionListener, ActionListener
+ {
+ private static final double M_PI = 3.14159265;
+
+ // Menu options:
+ private static final String M_NONE = "-----------------------";
+ private static final String M_MOTION = "Toggle motion";
+ private static final String M_LIGHT = "Toggle light";
+ private static final String M_TEXTURE = "Toggle texture";
+ private static final String M_SHADOWS = "Toggle shadows";
+ private static final String M_REFLECTION = "Toggle reflection";
+ private static final String M_DINOSAUR = "Toggle dinosaur";
+ private static final String M_STENCIL_REFLECTION = "Toggle reflection stenciling";
+ private static final String M_STENCIL_SHADOW = "Toggle shadow stenciling";
+ private static final String M_OFFSET_SHADOW = "Toggle shadow offset";
+ private static final String M_POSITIONAL = "Positional light";
+ private static final String M_DIRECTIONAL = "Directional light";
+
+ private PopupMenu menu = null;
+ private boolean menu_showing = false;
+ private boolean save_suspended = false;
+
+ /* Variables controlling various rendering modes. */
+ private boolean stencilReflection = true, stencilShadow = true, offsetShadow = true;
+ private boolean renderShadow = true, renderDinosaur = true, renderReflection = true;
+ private boolean linearFiltering = false, useTexture = true;
+// private boolean useMipmaps = false;
+ private boolean lightSwitch = true;
+ private boolean directionalLight = true;
+
+ /* Time varying or user-controled variables. */
+ private float jump = 0.0f;
+ private float lightAngle = 0.0f, lightHeight = 20.0f;
+ private float angle = -150.0f; /* in degrees */
+ private float angle2 = 30.0f; /* in degrees */
+
+ private boolean moving = false;
+ private int startx, starty;
+ private boolean lightMoving = false;
+ private int lightStartX, lightStartY;
+
+ private final float bodyWidth = 3.0f;
+
+ private final float[] lightPosition = new float[4];
+ private final float lightColor[] = {0.8f, 1.0f, 0.8f, 1.0f}; /* green-tinted */
+ private final float skinColor[] = {0.1f, 1.0f, 0.1f, 1.0f};
+ private final float eyeColor[] = {1.0f, 0.2f, 0.2f, 1.0f};
+ private final int X = 0, Y = 1, Z = 2, W = 3;
+ private final int A = 0, B = 1, C = 2, D = 3;
+
+ /* Enumerants for refering to display lists. */
+ private static final int
+ BODY_SIDE = 1, BODY_EDGE = 2, BODY_WHOLE = 3,
+ ARM_SIDE = 4, ARM_EDGE = 5, ARM_WHOLE = 6,
+ LEG_SIDE = 7, LEG_EDGE = 8, LEG_WHOLE = 9,
+ EYE_SIDE = 10, EYE_EDGE = 11, EYE_WHOLE = 12;
+ private float floorPlane[] = new float[4];
+ private float floorShadow[] = new float[16];
+
+ public dinoshadeCanvas(int w, int h)
+ {
+ super(w, h);
+ GLContext.gljNativeDebug = false;
+ GLContext.gljClassDebug = false;
+ setAnimateFps(30.0);
+ }
+
+ public void preInit()
+ {
+ doubleBuffer = true;
+ stereoView = false;
+ stencilBits = 3;
+ }
+
+ public void init()
+ {
+ int [] res=new int[6];
+
+ gl.glGetIntegerv(GL_STENCIL_BITS,res);
+
+ System.out.println("init(): " + this + "\n\t" +
+ "Stencil bits are "+res[0] +"\n\t" +
+ "IsOwnCreatedWindow: "+createOwnWindow);
+
+ reshape(getSize().width, getSize().height);
+
+ makeDinosaur();
+
+ gl.glPolygonOffset(-2.0f, -1.0f);
+
+ gl.glEnable(GL_CULL_FACE);
+ gl.glEnable(GL_DEPTH_TEST);
+ gl.glEnable(GL_TEXTURE_2D);
+ gl.glLineWidth(3.0f);
+
+ gl.glMatrixMode(GL_PROJECTION);
+ glu.gluPerspective
+ ( /* field of view in degree */ 40.0f,
+ /* aspect ratio */ 1.0f,
+ /* Z near */ 20.0f,
+ /* Z far */ 100.0f);
+ gl.glMatrixMode(GL_MODELVIEW);
+ glu.gluLookAt
+ (0.0f, 8.0f, 60.0f, /* eye is at (0,8,60) */
+ 0.0f, 8.0f, 0.0f, /* center is at (0,8,0) */
+ 0.0f, 1.0f, 0.0f); /* up is in postivie Y direction */
+
+ gl.glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, 1);
+ gl.glLightfv(GL_LIGHT0, GL_DIFFUSE, lightColor);
+ gl.glLightf(GL_LIGHT0, GL_CONSTANT_ATTENUATION, 0.1f);
+ gl.glLightf(GL_LIGHT0, GL_LINEAR_ATTENUATION, 0.05f);
+ gl.glEnable(GL_LIGHT0);
+ gl.glEnable(GL_LIGHTING);
+
+ makeFloorTexture();
+
+ /* Setup floor plane for projected shadow calculations. */
+ findPlane
+ (floorPlane,
+ floorVertices[1],
+ floorVertices[2],
+ floorVertices[3]);
+
+ glj.gljCheckGL();
+
+ menu = new PopupMenu("Options");
+ menu.add(M_MOTION);
+ menu.add(M_NONE);
+ menu.add(M_LIGHT);
+ menu.add(M_TEXTURE);
+ menu.add(M_SHADOWS);
+ menu.add(M_REFLECTION);
+ menu.add(M_DINOSAUR);
+ menu.add(M_NONE);
+ menu.add(M_STENCIL_REFLECTION);
+ menu.add(M_STENCIL_SHADOW);
+ menu.add(M_OFFSET_SHADOW);
+ menu.add(M_NONE);
+ menu.add(M_POSITIONAL);
+ menu.add(M_DIRECTIONAL);
+ menu.addActionListener(this);
+ add(menu);
+
+ addMouseListener(this);
+ addMouseMotionListener(this);
+ }
+
+ public void doCleanup()
+ {
+ removeMouseListener(this);
+ removeMouseMotionListener(this);
+ menu.removeActionListener(this);
+ }
+
+ public void reshape(int width, int height)
+ {
+ gl.glViewport(0,0,width,height);
+ }
+
+ public void display()
+ {
+ if (glj.gljMakeCurrent() == false) return;
+
+ if (!isSuspended())
+ {
+ long ltime =
+ System.currentTimeMillis() % 3142L; //approximate 2*PI*500
+ float time = (float)(((double)ltime)/500.0);
+ jump = 4.0f * (float)Math.abs(Math.sin(time)*0.5);
+ if (!lightMoving) lightAngle += 0.0f;
+ }
+
+ /* Clear; default stencil clears to zero. */
+ if ((stencilReflection && renderReflection) || (stencilShadow && renderShadow))
+ gl.glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
+ else
+ /* Avoid clearing stencil when not using it. */
+ gl.glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+
+ /* Reposition the light source. */
+ lightPosition[0] = 12*(float)Math.cos(lightAngle);
+ lightPosition[1] = lightHeight;
+ lightPosition[2] = 12*(float)Math.sin(lightAngle);
+ if (directionalLight)
+ lightPosition[3] = 0.0f;
+ else
+ lightPosition[3] = 1.0f;
+
+ shadowMatrix(floorShadow, floorPlane, lightPosition);
+
+ gl.glPushMatrix();
+
+ /* Perform scene rotations based on user mouse input. */
+ gl.glRotatef(angle2, 1.0f, 0.0f, 0.0f);
+ gl.glRotatef(angle, 0.0f, 1.0f, 0.0f);
+
+ /* Tell GL new light source position. */
+ gl.glLightfv(GL_LIGHT0, GL_POSITION, lightPosition);
+
+ if (renderReflection)
+ {
+ if (stencilReflection)
+ {
+ /* We can eliminate the visual "artifact" of seeing the "flipped"
+ dinosaur underneath the floor by using stencil. The idea is
+ draw the floor without color or depth update but so that
+ a stencil value of one is where the floor will be. Later when
+ rendering the dinosaur reflection, we will only update pixels
+ with a stencil value of 1 to make sure the reflection only
+ lives on the floor, not below the floor. */
+
+ /* Don't update color or depth. */
+ gl.glDisable(GL_DEPTH_TEST);
+ gl.glColorMask(false, false, false, false);
+
+ /* Draw 1 into the stencil buffer. */
+ gl.glEnable(GL_STENCIL_TEST);
+ gl.glStencilOp(GL_REPLACE, GL_REPLACE, GL_REPLACE);
+ gl.glStencilFunc(GL_ALWAYS, 1, 0xffffffff);
+
+ /* Now render floor; floor pixels just get their stencil set to 1. */
+ drawFloor();
+
+ /* Re-enable update of color and depth. */
+ gl.glColorMask(true, true, true, true);
+ gl.glEnable(GL_DEPTH_TEST);
+
+ /* Now, only render where stencil is set to 1. */
+ gl.glStencilFunc(GL_EQUAL, 1, 0xffffffff); /* draw if ==1 */
+ gl.glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);
+ }
+
+ gl.glPushMatrix();
+
+ /* The critical reflection step: Reflect dinosaur through the floor
+ (the Y=0 plane) to make a relection. */
+
+ gl.glScalef(1.0f, -1.0f, 1.0f);
+
+ /* Reflect the light position. */
+ gl.glLightfv(GL_LIGHT0, GL_POSITION, lightPosition);
+
+ /* To avoid our normals getting reversed and hence botched lighting
+ on the reflection, turn on normalize. */
+ gl.glEnable(GL_NORMALIZE);
+ gl.glCullFace(GL_FRONT);
+
+ /* Draw the reflected dinosaur. */
+ drawDinosaur();
+
+ /* Disable noramlize again and re-enable back face culling. */
+ gl.glDisable(GL_NORMALIZE);
+ gl.glCullFace(GL_BACK);
+
+ gl.glPopMatrix();
+
+ /* Switch back to the unreflected light position. */
+ gl.glLightfv(GL_LIGHT0, GL_POSITION, lightPosition);
+
+ if (stencilReflection) gl.glDisable(GL_STENCIL_TEST);
+ }
+
+ /* Back face culling will get used to only draw either the top or the
+ bottom floor. This let's us get a floor with two distinct
+ appearances. The top floor surface is reflective and kind of red.
+ The bottom floor surface is not reflective and blue. */
+
+ /* Draw "bottom" of floor in blue. */
+ gl.glFrontFace(GL_CW); /* Switch face orientation. */
+ gl.glColor4f(0.1f, 0.1f, 0.7f, 1.0f);
+ drawFloor();
+ gl.glFrontFace(GL_CCW);
+
+ if (renderShadow)
+ {
+ if (stencilShadow)
+ {
+ /* Draw the floor with stencil value 3. This helps us only
+ draw the shadow once per floor pixel (and only on the
+ floor pixels). */
+ gl.glEnable(GL_STENCIL_TEST);
+ gl.glStencilFunc(GL_ALWAYS, 3, 0xffffffff);
+ gl.glStencilOp(GL_KEEP, GL_KEEP, GL_REPLACE);
+ }
+ }
+
+ /* Draw "top" of floor. Use blending to blend in reflection. */
+ gl.glEnable(GL_BLEND);
+ gl.glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+ gl.glColor4f(0.7f, 0.0f, 0.0f, 0.3f);
+ gl.glColor4f(1.0f, 1.0f, 1.0f, 0.3f);
+ drawFloor();
+ gl.glDisable(GL_BLEND);
+
+ /* Draw "actual" dinosaur, not its reflection. */
+ if (renderDinosaur) drawDinosaur();
+
+ if (renderShadow)
+ {
+ /* Render the projected shadow. */
+ if (stencilShadow)
+ {
+ /* Now, only render where stencil is set above 2 (ie, 3 where
+ the top floor is). Update stencil with 2 where the shadow
+ gets drawn so we don't redraw (and accidently reblend) the
+ shadow). */
+ gl.glStencilFunc(GL_LESS, 2, 0xffffffff); /* draw if ==1 */
+ gl.glStencilOp(GL_REPLACE, GL_REPLACE, GL_REPLACE);
+ }
+ /* To eliminate depth buffer artifacts, we use polygon offset
+ to raise the depth of the projected shadow slightly so
+ that it does not depth buffer alias with the floor. */
+ if (offsetShadow) gl.glEnable(GL_POLYGON_OFFSET_FILL);
+
+ /* Render 50% black shadow color on top of whatever the
+ floor appareance is. */
+ gl.glEnable(GL_BLEND);
+ gl.glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+ gl.glDisable(GL_LIGHTING); /* Force the 50% black. */
+ gl.glColor4f(0.0f, 0.0f, 0.0f, 0.5f);
+
+ gl.glPushMatrix();
+ /* Project the shadow. */
+ gl.glMultMatrixf(floorShadow);
+ drawDinosaur();
+ gl.glPopMatrix();
+
+ gl.glDisable(GL_BLEND);
+ gl.glEnable(GL_LIGHTING);
+
+ if (offsetShadow) gl.glDisable(GL_POLYGON_OFFSET_FILL);
+ if (stencilShadow) gl.glDisable(GL_STENCIL_TEST);
+ }
+
+ gl.glPushMatrix();
+ gl.glDisable(GL_LIGHTING);
+ gl.glColor3f(1.0f, 1.0f, 0.0f);
+ if (directionalLight)
+ {
+ /* Draw an arrowhead. */
+ gl.glDisable(GL_CULL_FACE);
+ gl.glTranslatef(lightPosition[0], lightPosition[1], lightPosition[2]);
+ gl.glRotatef(lightAngle * (float)(-180.0 / M_PI), 0, 1, 0);
+ gl.glRotatef((float)Math.atan(lightHeight/12) * (float)(180.0 / M_PI), 0, 0, 1);
+ gl.glBegin(GL_TRIANGLE_FAN);
+ gl.glVertex3f(0, 0, 0);
+ gl.glVertex3f(2, 1, 1);
+ gl.glVertex3f(2, -1, 1);
+ gl.glVertex3f(2, -1, -1);
+ gl.glVertex3f(2, 1, -1);
+ gl.glVertex3f(2, 1, 1);
+ gl.glEnd();
+ /* Draw a white line from light direction. */
+ gl.glColor3f(1.0f, 1.0f, 1.0f);
+ gl.glBegin(GL_LINES);
+ gl.glVertex3f(0, 0, 0);
+ gl.glVertex3f(5, 0, 0);
+ gl.glEnd();
+ gl.glEnable(GL_CULL_FACE);
+ }
+ else
+ {
+ /* Draw a yellow ball at the light source. */
+ gl.glTranslatef(lightPosition[0], lightPosition[1], lightPosition[2]);
+ int qobj = glu.gluNewQuadric();
+ glu.gluQuadricOrientation(qobj,GLU_OUTSIDE);
+ glu.gluQuadricNormals(qobj,GLU_SMOOTH);
+ glu.gluQuadricTexture(qobj,false);
+ glu.gluSphere(qobj,1.0f,5,5);
+ glu.gluDeleteQuadric(qobj);
+ }
+ gl.glEnable(GL_LIGHTING);
+ gl.glPopMatrix();
+
+ gl.glPopMatrix();
+
+ glj.gljSwap();
+ glj.gljCheckGL();
+ glj.gljFree();
+
+ // if (!isSuspended()) repaint(); // Animate at full speed.
+ }
+
+ private void makeDinosaur()
+ {
+ extrudeSolidFromPolygon
+ (bodyVerts,
+ bodyTris,
+ bodyWidth,
+ BODY_SIDE,
+ BODY_EDGE,
+ BODY_WHOLE);
+ extrudeSolidFromPolygon
+ (armVerts,
+ armTris,
+ bodyWidth/4,
+ ARM_SIDE,
+ ARM_EDGE,
+ ARM_WHOLE);
+ extrudeSolidFromPolygon
+ (legVerts,
+ legTris,
+ bodyWidth/2,
+ LEG_SIDE,
+ LEG_EDGE,
+ LEG_WHOLE);
+ extrudeSolidFromPolygon
+ (eyeVerts,
+ eyeTris,
+ bodyWidth+0.2f,
+ EYE_SIDE,
+ EYE_EDGE,
+ EYE_WHOLE);
+ }
+
+ private void drawDinosaur()
+ {
+ gl.glPushMatrix();
+ /* Translate the dinosaur to be at (0,8,0). */
+ gl.glTranslatef(-8, 0, -bodyWidth / 2);
+ gl.glTranslatef(0.0f, jump, 0.0f);
+ gl.glMaterialfv(GL_FRONT, GL_DIFFUSE, skinColor);
+ gl.glCallList(BODY_WHOLE);
+ gl.glTranslatef(0.0f, 0.0f, bodyWidth);
+ gl.glCallList(ARM_WHOLE);
+ gl.glCallList(LEG_WHOLE);
+ gl.glTranslatef(0.0f, 0.0f, -bodyWidth - bodyWidth / 4);
+ gl.glCallList(ARM_WHOLE);
+ gl.glTranslatef(0.0f, 0.0f, -bodyWidth / 4);
+ gl.glCallList(LEG_WHOLE);
+ gl.glTranslatef(0.0f, 0.0f, bodyWidth / 2 - 0.1f);
+ gl.glMaterialfv(GL_FRONT, GL_DIFFUSE, eyeColor);
+ gl.glCallList(EYE_WHOLE);
+ gl.glPopMatrix();
+ }
+
+ private void makeFloorTexture()
+ {
+ /* Nice floor texture tiling pattern. */
+ String circles[] =
+ {
+ "....xxxx........",
+ "..xxxxxxxx......",
+ ".xxxxxxxxxx.....",
+ ".xxx....xxx.....",
+ "xxx......xxx....",
+ "xxx......xxx....",
+ "xxx......xxx....",
+ "xxx......xxx....",
+ ".xxx....xxx.....",
+ ".xxxxxxxxxx.....",
+ "..xxxxxxxx......",
+ "....xxxx........",
+ "................",
+ "................",
+ "................",
+ "................"
+ };
+ byte floorTexture[] = new byte[16*16*3];
+
+ /* Setup RGB image for the texture. */
+ int idx = 0;
+ for (int t = 0; t < 16; t++)
+ {
+ for (int s = 0; s < 16; s++)
+ {
+ if (circles[t].charAt(s) == 'x')
+ {
+ /* Nice blue. */
+ floorTexture[idx++] = (byte)0x1f;
+ floorTexture[idx++] = (byte)0x1f;
+ floorTexture[idx++] = (byte)0x8f;
+ }
+ else
+ {
+ /* Light gray. */
+ floorTexture[idx++] = (byte)0xca;
+ floorTexture[idx++] = (byte)0xca;
+ floorTexture[idx++] = (byte)0xca;
+ }
+ }
+ }
+
+ gl.glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
+
+// if (useMipmaps)
+// {
+// gl.glTexParameteri
+// (GL_TEXTURE_2D,
+// GL_TEXTURE_MIN_FILTER,
+// GL_LINEAR_MIPMAP_LINEAR);
+// glu.gluBuild2DMipmaps
+// (GL_TEXTURE_2D,3,16,16,GL_RGB,GL_UNSIGNED_BYTE,floorTexture);
+// }
+// else
+ {
+ if (linearFiltering)
+ {
+ gl.glTexParameteri
+ (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+ gl.glTexParameteri
+ (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+ }
+ else
+ {
+ gl.glTexParameteri
+ (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+ gl.glTexParameteri
+ (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+ }
+ gl.glTexImage2D
+ (GL_TEXTURE_2D,0,3,16,16,0,GL_RGB,GL_UNSIGNED_BYTE,floorTexture);
+ }
+ }
+
+ /* Draw a floor (possibly textured). */
+ private void drawFloor()
+ {
+ gl.glDisable(GL_LIGHTING);
+ if (useTexture) gl.glEnable(GL_TEXTURE_2D);
+ gl.glBegin(GL_QUADS);
+ gl.glTexCoord2f(0.0f, 0.0f);
+ gl.glVertex3fv(floorVertices[0]);
+ gl.glTexCoord2f(0.0f, 16.0f);
+ gl.glVertex3fv(floorVertices[1]);
+ gl.glTexCoord2f(16.0f, 16.0f);
+ gl.glVertex3fv(floorVertices[2]);
+ gl.glTexCoord2f(16.0f, 0.0f);
+ gl.glVertex3fv(floorVertices[3]);
+ gl.glEnd();
+ if (useTexture) gl.glDisable(GL_TEXTURE_2D);
+ gl.glEnable(GL_LIGHTING);
+ }
+
+ /* create a matrix that will project the desired shadow */
+ void shadowMatrix(float shadowMat[], float groundplane[], float lightpos[])
+ {
+ float dot;
+
+ /* find dot product between light position vector
+ and ground plane normal */
+ dot =
+ groundplane[0] * lightpos[0] +
+ groundplane[1] * lightpos[1] +
+ groundplane[2] * lightpos[2] +
+ groundplane[3] * lightpos[3];
+
+ shadowMat[0] = dot - lightpos[0] * groundplane[0];
+ shadowMat[4] = -lightpos[0] * groundplane[1];
+ shadowMat[8] = -lightpos[0] * groundplane[2];
+ shadowMat[12] = -lightpos[0] * groundplane[3];
+
+ shadowMat[1] = -lightpos[1] * groundplane[0];
+ shadowMat[5] = dot - lightpos[1] * groundplane[1];
+ shadowMat[9] = -lightpos[1] * groundplane[2];
+ shadowMat[13] = -lightpos[1] * groundplane[3];
+
+ shadowMat[2] = -lightpos[2] * groundplane[0];
+ shadowMat[6] = -lightpos[2] * groundplane[1];
+ shadowMat[10] = dot - lightpos[2] * groundplane[2];
+ shadowMat[14] = -lightpos[2] * groundplane[3];
+
+ shadowMat[3] = -lightpos[3] * groundplane[0];
+ shadowMat[7] = -lightpos[3] * groundplane[1];
+ shadowMat[11] = -lightpos[3] * groundplane[2];
+ shadowMat[15] = dot - lightpos[3] * groundplane[3];
+ }
+
+ /* find the plane equation given 3 points */
+ void findPlane(float plane[], float v0[], float v1[], float v2[])
+ {
+ float vec0[] = new float[3], vec1[] = new float[3];
+
+ /* need 2 vectors to find cross product */
+ vec0[X] = v1[X] - v0[X];
+ vec0[Y] = v1[Y] - v0[Y];
+ vec0[Z] = v1[Z] - v0[Z];
+
+ vec1[X] = v2[X] - v0[X];
+ vec1[Y] = v2[Y] - v0[Y];
+ vec1[Z] = v2[Z] - v0[Z];
+
+ /* find cross product to get A, B, and C of plane equation */
+ plane[A] = vec0[Y] * vec1[Z] - vec0[Z] * vec1[Y];
+ plane[B] = -(vec0[X] * vec1[Z] - vec0[Z] * vec1[X]);
+ plane[C] = vec0[X] * vec1[Y] - vec0[Y] * vec1[X];
+ plane[D] = -(plane[A]*v0[X] + plane[B]*v0[Y] + plane[C]*v0[Z]);
+ }
+
+ /* Mark Kilgard's tessellation code from the "dino" demos.
+ Bug fixes and re-write without GLU tesselator
+ by Ronald B. Cemer */
+ private void extrudeSolidFromPolygon
+ (float data[][],
+ int outlineTriIndices[][],
+ float thickness,
+ int side,
+ int edge,
+ int whole)
+ {
+ double dx, dy, len;
+ int i, j0, j1, j2;
+ int min, max, range;
+ float x0, y0, x1, y1;
+ int count = data.length;
+ int tricount = outlineTriIndices.length;
+
+ gl.glNewList(side, GL_COMPILE);
+ gl.glShadeModel(GL_SMOOTH);
+ gl.glBegin(GL_TRIANGLES);
+ for (i = 0; i < tricount; i++)
+ {
+/* *+*+* Note that we use the triangle indices in reverse order here
+ because they are specified in reverse order in the arrays. */
+ j0 = outlineTriIndices[i][2];
+ j1 = outlineTriIndices[i][1];
+ j2 = outlineTriIndices[i][0];
+ gl.glVertex3f(data[j0][0],data[j0][1],0.0f);
+ gl.glVertex3f(data[j1][0],data[j1][1],0.0f);
+ gl.glVertex3f(data[j2][0],data[j2][1],0.0f);
+ }
+ gl.glEnd();
+ gl.glEndList();
+
+ gl.glNewList(edge, GL_COMPILE);
+ gl.glShadeModel(GL_FLAT); /* flat shade keeps angular hands
+ from being "smoothed" */
+ for (min = max = 0; min < count; min = max)
+ {
+ for (max = min+1; max < count; max++)
+ if (data[max][2] != 0.0f) break;
+ range = max-min;
+ gl.glBegin(GL_QUAD_STRIP);
+ for (i = min; i <= max; i++)
+ {
+ j0 = i;
+ j1 = i+1;
+ if (j0 >= max) j0 -= range;
+ if (j1 >= max) j1 -= range;
+ x0 = data[j0][0];
+ y0 = data[j0][1];
+ x1 = data[j1][0];
+ y1 = data[j1][1];
+ gl.glVertex3f(x0, y0, 0.0f);
+ gl.glVertex3f(x0, y0, thickness);
+ // Normals
+ dx = y1 - y0;
+ dy = x0 - x1;
+ len = Math.sqrt(dx * dx + dy * dy);
+ gl.glNormal3f((float)(dx / len), (float)(dy / len), 0.0f);
+ }
+ gl.glEnd();
+ }
+ gl.glEndList();
+
+ gl.glNewList(whole, GL_COMPILE);
+ gl.glFrontFace(GL_CW);
+
+ gl.glCallList(edge);
+
+ gl.glNormal3f(0.0f, 0.0f, -1.0f);
+ gl.glCallList(side);
+ gl.glPushMatrix();
+ gl.glTranslatef(0.0f, 0.0f, thickness);
+ gl.glFrontFace(GL_CCW);
+ gl.glNormal3f(0.0f, 0.0f, 1.0f);
+ gl.glCallList(side);
+ gl.glPopMatrix();
+
+ gl.glEndList();
+ }
+
+ // Methods required for the implementation of MouseListener
+ public void mouseEntered(MouseEvent evt)
+ {
+ }
+
+ public void mouseExited(MouseEvent evt)
+ {
+ }
+
+ public void mousePressed(MouseEvent evt)
+ {
+ // Left button moves view.
+ // Both buttons moves light.
+ // Right button pops up menu.
+ if (!menu_showing)
+ {
+ if ((evt.getModifiers() & evt.BUTTON3_MASK) == 0)
+ {
+ moving = true;
+ startx = evt.getX();
+ starty = evt.getY();
+ }
+ else if (moving)
+ {
+ moving = false;
+ lightMoving = true;
+ lightStartX = evt.getX();
+ lightStartY = evt.getY();
+ }
+ else
+ {
+ // Must be right mouse button.
+ menu_showing = true;
+ save_suspended = isSuspended();
+ if (!save_suspended)
+ {
+ setSuspended(true);
+ repaint(100);
+ try
+ {
+ Thread.currentThread().sleep(200);
+ }
+ catch (Exception e)
+ { }
+ }
+ menu.show(this,evt.getX(),evt.getY());
+ }
+ }
+ else
+ {
+ menu_showing = false;
+ setSuspended(save_suspended);
+ }
+ }
+
+ public void mouseReleased(MouseEvent evt)
+ {
+ lightMoving = false;
+ if ((evt.getModifiers() & evt.BUTTON3_MASK) == 0)
+ {
+ // Must be left button.
+ moving = false;
+ }
+ }
+
+ public void mouseClicked(MouseEvent evt)
+ {
+ }
+
+ // Methods required for the implementation of MouseMotionListener
+ public void mouseDragged(MouseEvent evt)
+ {
+ int x = evt.getX(), y = evt.getY();
+ if (moving)
+ {
+ angle += (x - startx);
+ while (angle < 0.0f) angle += 360.0f;
+ while (angle >= 360.0f) angle -= 360.0f;
+ angle2 += (y - starty);
+ if (angle2 < -180.0f)
+ angle2 = -180.0f;
+ else if (angle2 > 180.0f)
+ angle2 = 180.0f;
+ startx = x;
+ starty = y;
+ if (isSuspended()) repaint();
+ }
+ else if (lightMoving)
+ {
+ lightAngle += (lightStartX - x)/40.0f;
+ while (lightAngle < 0.0f) lightAngle += 360.0f;
+ while (lightAngle >= 360.0f) lightAngle -= 360.0f;
+ lightHeight += (lightStartY - y)/20.0f;
+ lightStartX = x;
+ lightStartY = y;
+ if (isSuspended()) repaint();
+ }
+ }
+
+ public void mouseMoved(MouseEvent evt)
+ {
+ }
+
+ // Method required for the implementation of ActionListener
+ public void actionPerformed(ActionEvent evt)
+ {
+ if (glj.gljMakeCurrent() == false) return;
+ boolean dorepaint = false;
+ String c = evt.getActionCommand();
+
+ if (c.equals(M_MOTION))
+ {
+ if (menu_showing)
+ save_suspended = !save_suspended;
+ else
+ setSuspended(!isSuspended());
+ dorepaint = true;
+ }
+ else if (c.equals(M_LIGHT))
+ {
+ lightSwitch = !lightSwitch;
+ if (lightSwitch)
+ gl.glEnable(GL_LIGHT0);
+ else
+ gl.glDisable(GL_LIGHT0);
+ dorepaint = true;
+ }
+ else if (c.equals(M_TEXTURE))
+ {
+ useTexture = !useTexture;
+ dorepaint = true;
+ }
+ else if (c.equals(M_SHADOWS))
+ {
+ renderShadow = !renderShadow;
+ dorepaint = true;
+ }
+ else if (c.equals(M_REFLECTION))
+ {
+ renderReflection = !renderReflection;
+ dorepaint = true;
+ }
+ else if (c.equals(M_DINOSAUR))
+ {
+ renderDinosaur = !renderDinosaur;
+ dorepaint = true;
+ }
+ else if (c.equals(M_STENCIL_REFLECTION))
+ {
+ stencilReflection = !stencilReflection;
+ dorepaint = true;
+ }
+ else if (c.equals(M_STENCIL_SHADOW))
+ {
+ stencilShadow = !stencilShadow;
+ dorepaint = true;
+ }
+ else if (c.equals(M_OFFSET_SHADOW))
+ {
+ offsetShadow = !offsetShadow;
+ dorepaint = true;
+ }
+ else if (c.equals(M_POSITIONAL))
+ {
+ directionalLight = false;
+ dorepaint = true;
+ }
+ else if (c.equals(M_DIRECTIONAL))
+ {
+ directionalLight = true;
+ dorepaint = true;
+ }
+
+ glj.gljFree();
+ if (menu_showing)
+ {
+ menu_showing = false;
+ setSuspended(save_suspended);
+ }
+ if ( (isSuspended()) && (dorepaint) ) repaint();
+ }
+ }
+}
generated by cgit v1.2.3 (git 2.39.1) at 2024-11-28 22:53:34 +0000