diff options
Diffstat (limited to 'demos/HodglimsNeHe/Lesson9.java')
| -rw-r--r-- | demos/HodglimsNeHe/Lesson9.java | 451 |
1 files changed, 451 insertions, 0 deletions
diff --git a/demos/HodglimsNeHe/Lesson9.java b/demos/HodglimsNeHe/Lesson9.java new file mode 100644 index 0000000..4c4a92d --- /dev/null +++ b/demos/HodglimsNeHe/Lesson9.java @@ -0,0 +1,451 @@ +/**
+ * Lesson9.java
+ *
+ * Author: Darren Hodges
+ * Date: 21/12/1999
+ *
+ * Port of the NeHe OpenGL Tutorial (Lesson 9: "Moving Bitmaps In 3D Space")
+ * to Java using the GL4Java interface to OpenGL.
+ *
+ */
+
+
+import java.applet.*;
+import java.awt.*;
+import java.awt.event.*;
+
+//GL4Java classes
+import gl4java.GLContext;
+import gl4java.awt.GLAnimCanvas;
+import gl4java.utils.textures.*;
+
+
+public class Lesson9 extends Applet
+{
+ //Our rendering canvas
+ //We are using GLAnimCanvas because we want the canvas
+ //to be constantly redrawn
+ renderCanvas canvas = null;
+
+
+ /**
+ * void init()
+ *
+ * Initialise the applet.
+ */
+ public void init()
+ {
+ //We will use BorderLayout to layout the applet components
+ setLayout(new BorderLayout());
+
+ //Create our canvas and add it to the center of the applet
+ canvas = new renderCanvas(getSize().width, getSize().height);
+ canvas.requestFocus();
+ add("Center", canvas);
+ }
+
+
+ /**
+ * void start()
+ *
+ * Start the applet.
+ */
+ public void start()
+ {
+ //Start animating the canvas
+ canvas.start();
+ }
+
+
+ /**
+ * void stop()
+ *
+ * Stop the applet.
+ */
+ public void stop()
+ {
+ //Stop animating the canvas
+ canvas.stop();
+ }
+
+
+ /**
+ * void destroy()
+ *
+ * Destroy the applet.
+ */
+ public void destroy()
+ {
+ //Stop animating the canvas
+ canvas.stop();
+ //Destroy the canvas
+ canvas.destroy();
+ }
+
+
+
+ private class renderCanvas extends GLAnimCanvas
+ implements KeyListener, MouseListener
+ {
+ boolean twinkle = true; //Twinkling stars
+ boolean tp = false; //T Pressed?
+ final int NUM = 50; //NUMber of stars to draw
+
+ Star[] star = new Star[NUM]; //Array of stars
+
+ float zoom = -15.0f; //Viewing Distance Away From Stars
+ float tilt = 90.0f; //Tilt The View
+ float spin = 0.0f; //Spin Twinkling Stars
+
+ int loop = 0; //General loop Variable
+
+ int[] texture = new int[1]; //Storage For One Texture
+
+
+ /**
+ * renderCanvas(int w, int h)
+ *
+ * Constructor.
+ */
+ public renderCanvas(int w, int h)
+ {
+ super(w, h);
+
+ //Registers this canvas to process keyboard events
+ addKeyListener(this);
+ addMouseListener(this);
+ }
+
+
+ /**
+ * void preInit()
+ *
+ * Called just BEFORE the GL-Context is created.
+ */
+ public void preInit()
+ {
+ //We want double buffering
+ doubleBuffer = true;
+ //But we dont want stereo view
+ stereoView = false;
+ }
+
+
+ /**
+ * void LoadGLTextures()
+ *
+ * Load textures.
+ */
+ public void LoadGLTextures()
+ {
+ PngTextureLoader texLoader = new PngTextureLoader(gl, glu);
+ texLoader.readTexture(getCodeBase(), "data/star.png");
+
+ if(texLoader.isOk())
+ {
+ //Create Texture
+ gl.glGenTextures(1, texture);
+ gl.glBindTexture(GL_TEXTURE_2D, texture[0]);
+
+ gl.glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+ gl.glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+
+ gl.glTexImage2D(GL_TEXTURE_2D,
+ 0,
+ 3,
+ texLoader.getImageWidth(),
+ texLoader.getImageHeight(),
+ 0,
+ GL_RGB,
+ GL_UNSIGNED_BYTE,
+ texLoader.getTexture());
+ }
+ }
+
+
+ /**
+ * void init()
+ *
+ * Called just AFTER the GL-Context is created.
+ */
+ public void init()
+ {
+ //Load The Texture(s)
+ LoadGLTextures();
+ //Enable Texture Mapping
+ gl.glEnable(GL_TEXTURE_2D);
+
+ //This Will Clear The Background Color To Black
+ gl.glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
+
+ //Enables Clearing Of The Depth Buffer
+ gl.glClearDepth(1.0);
+
+ //Enables Smooth Color Shading
+ gl.glShadeModel(GL_SMOOTH);
+
+ //Select The Projection Matrix
+ gl.glMatrixMode(GL_PROJECTION);
+
+ //Reset The Projection Matrix
+ gl.glLoadIdentity();
+
+ //Calculate The Aspect Ratio Of The Window
+ glu.gluPerspective(45.0f, (float)getSize().width / (float)getSize().height, 0.1f, 100.0f);
+ //Select The Modelview Matrix
+ gl.glMatrixMode(GL_MODELVIEW);
+
+ //Set The Blending Function For Translucency
+ gl.glBlendFunc(GL_SRC_ALPHA, GL_ONE);
+ //Enable Blending
+ gl.glEnable(GL_BLEND);
+
+ //Create A Loop That Goes Through All The Stars
+ for(loop = 0; loop < NUM; loop++)
+ {
+ star[loop] = new Star();
+ star[loop].angle = 0.0f; //Start All The Stars At Angle Zero
+ star[loop].dist = ((float)(loop) / NUM) * 5.0f; //Calculate Distance From The Center
+ star[loop].r = (byte)(256 * Math.random()); //Give star[loop] A Random Red Intensity
+ star[loop].g = (byte)(256 * Math.random()); //Give star[loop] A Random Green Intensity
+ star[loop].b = (byte)(256 * Math.random()); //Give star[loop] A Random Blue Intensity
+ }
+ }
+
+
+ /**
+ * void destroy()
+ *
+ * Destroy the canvas.
+ */
+ public void destroy()
+ {
+ //Destroy the GLContext
+ cvsDispose();
+ }
+
+
+ /**
+ * void reshape(int width, int height)
+ *
+ * Called after the first paint command.
+ */
+ public void reshape(int width, int height)
+ {
+ //Reset The Current Viewport And Perspective Transformation
+ gl.glViewport(0, 0, width, height);
+
+ //Select The Projection Matrix
+ gl.glMatrixMode(GL_PROJECTION);
+ //Reset The Projection Matrix
+ gl.glLoadIdentity();
+ //Calculate The Aspect Ratio Of The Window
+ glu.gluPerspective(45.0f, (float)getSize().width / (float)getSize().height, 0.1f, 100.0f);
+ //Select The Modelview Matrix
+ gl.glMatrixMode(GL_MODELVIEW);
+ }
+
+
+ /**
+ * void display()
+ *
+ * Draw to the canvas.
+ */
+ public void display()
+ {
+ //Ensure GL is initialised correctly
+ if (glj.gljMakeCurrent(true) == false)
+ return;
+
+ //Clear The Screen And The Depth Buffer
+ gl.glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+
+ //Select Our Texture
+ gl.glBindTexture(GL_TEXTURE_2D, texture[0]);
+
+ //Loop Through All The Stars
+ for(loop = 0; loop < NUM; loop++)
+ {
+ gl.glLoadIdentity(); //Reset The View Before We Draw Each Star
+ gl.glTranslatef(0.0f, 0.0f, zoom); //Zoom Into The Screen (Using The Value In 'zoom')
+ gl.glRotatef(tilt, 1.0f, 0.0f, 0.0f); //Tilt The View (Using The Value In 'tilt')
+ gl.glRotatef(star[loop].angle, 0.0f, 1.0f, 0.0f); //Rotate To The Current Stars Angle
+ gl.glTranslatef(star[loop].dist, 0.0f, 0.0f); //Move Forward On The X Plane
+ gl.glRotatef(-star[loop].angle, 0.0f, 1.0f, 0.0f); //Cancel The Current Stars Angle
+ gl.glRotatef(-tilt, 1.0f, 0.0f, 0.0f); //Cancel The Screen Tilt
+
+ //Twinkling Stars Enabled
+ if(twinkle)
+ {
+ //Assign A Color Using Bytes
+ gl.glColor4ub(star[(NUM - loop) - 1].r, star[(NUM - loop) - 1].g, star[(NUM - loop) - 1].b, (byte)255);
+ gl.glBegin(GL_QUADS); //Begin Drawing The Textured Quad
+ gl.glTexCoord2f(0.0f, 0.0f); gl.glVertex3f(-1.0f, -1.0f, 0.0f);
+ gl.glTexCoord2f(1.0f, 0.0f); gl.glVertex3f(1.0f, -1.0f, 0.0f);
+ gl.glTexCoord2f(1.0f, 1.0f); gl.glVertex3f(1.0f, 1.0f, 0.0f);
+ gl.glTexCoord2f(0.0f, 1.0f); gl.glVertex3f(-1.0f, 1.0f, 0.0f);
+ gl.glEnd(); //Done Drawing The Textured Quad
+ }
+
+ gl. glRotatef(spin,0.0f,0.0f,1.0f); //Rotate The Star On The Z Axis
+ //Assign A Color Using Bytes
+ gl.glColor4ub(star[loop].r, star[loop].g, star[loop].b, (byte)255);
+ gl.glBegin(GL_QUADS); //Begin Drawing The Textured Quad
+ gl.glTexCoord2f(0.0f, 0.0f); gl.glVertex3f(-1.0f, -1.0f, 0.0f);
+ gl.glTexCoord2f(1.0f, 0.0f); gl.glVertex3f(1.0f,-1.0f, 0.0f);
+ gl.glTexCoord2f(1.0f, 1.0f); gl.glVertex3f(1.0f, 1.0f, 0.0f);
+ gl.glTexCoord2f(0.0f, 1.0f); gl.glVertex3f(-1.0f, 1.0f, 0.0f);
+ gl.glEnd(); //Done Drawing The Textured Quad
+
+ spin += 0.01f; //Used To Spin The Stars
+ star[loop].angle += (float)(loop / (float)NUM); //Changes The Angle Of A Star
+ star[loop].dist -= 0.01f; //Changes The Distance Of A Star
+
+ //Is The Star In The Middle Yet?
+ if(star[loop].dist < 0.0f)
+ {
+ star[loop].dist += 5.0f; //Move The Star 5 Units From The Center
+ star[loop].r = (byte)(256 * Math.random()); //Give It A New Red Value
+ star[loop].g = (byte)(256 * Math.random()); //Give It A New Green Value
+ star[loop].b = (byte)(256 * Math.random()); //Give It A New Blue Value
+ }
+ }
+
+ //Swap buffers
+ glj.gljSwap();
+ }
+
+
+ /**
+ * void keyTyped(KeyEvent e)
+ *
+ * Invoked when a key has been typed. This event occurs when a key press is followed by a key release.
+ */
+ public void keyTyped(KeyEvent e)
+ {
+ }
+
+
+ /**
+ * void keyPressed(KeyEvent e)
+ *
+ * Invoked when a key has been pressed.
+ */
+ public void keyPressed(KeyEvent e)
+ {
+ switch(e.getKeyCode())
+ {
+ //Switch ON/OFF twinkle when T is pressed
+ case KeyEvent.VK_T:
+ {
+ if(!tp)
+ {
+ tp = true;
+ //Toggle twinkle
+ twinkle = !twinkle;
+ }
+
+ break;
+ }
+
+ //Tilt screen up when user presses UP
+ case KeyEvent.VK_UP:
+ {
+ //Tilt The Screen Up
+ tilt -= 0.5f;
+ break;
+ }
+
+ //Tilt screen down when user presses DOWN
+ case KeyEvent.VK_DOWN:
+ {
+ //Tilt The Screen Down
+ tilt += 0.5f;
+ break;
+ }
+
+ //Zoom out when user presses PG_UP
+ case KeyEvent.VK_PAGE_UP:
+ {
+ //Zoom out
+ zoom -= 0.2f;
+ break;
+ }
+
+ //Zoom in when user presses PG_DOWN
+ case KeyEvent.VK_PAGE_DOWN:
+ {
+ //Zoom in
+ zoom += 0.2f;
+ break;
+ }
+ }
+ }
+
+
+ /**
+ * void keyReleased(KeyEvent e)
+ *
+ * Invoked when a key has been released.
+ */
+ public void keyReleased(KeyEvent e)
+ {
+ switch(e.getKeyCode())
+ {
+ //Key has been released
+ case KeyEvent.VK_T:
+ {
+ tp = false;
+ break;
+ }
+ }
+ }
+
+ // Methods required for the implementation of MouseListener
+ public void mouseEntered( MouseEvent evt )
+ {
+ Component comp = evt.getComponent();
+ if( comp.equals(this ) )
+ {
+ requestFocus();
+ }
+ }
+
+ public void mouseExited( MouseEvent evt )
+ { }
+ public void mousePressed( MouseEvent evt )
+ { }
+ public void mouseReleased( MouseEvent evt )
+ { }
+ public void mouseClicked( MouseEvent evt )
+ {
+ Component comp = evt.getComponent();
+ if( comp.equals(this ) )
+ {
+ requestFocus();
+ }
+ }
+
+ }
+
+
+
+ public class Star
+ {
+ byte r, g, b; //Stars colour
+ float dist; //Stars distance from center
+ float angle; //Stars current angle
+
+
+ /**
+ * Star()
+ *
+ * Constructor.
+ */
+ public Star()
+ {
+ r = g = b = 0;
+ dist = angle = 0.0f;
+ }
+ }
+}
|