java left logo
java middle logo
java right logo
 

Home arrow Other API Tips arrow JOGL arrow Multiple viewports - NeHe Tutorial JOGL Port
 
 
Main Menu
Home
Java Tutorials
Book Reviews
Java SE Tips
Java ME Tips
Java EE Tips
Other API Tips
Java Applications
Java Libraries
Java Games
Java Network
Java Forums
Java Blog




Most Visited Tips
Java SE Tips
Java ME Tips
Java EE Tips
Other API Tips
Java Applications
Java Libraries
Java Games
Book Reviews
Top Rated Tips
Java SE Tips
Java ME Tips
Java EE Tips
Other API Tips
Java Applications
Java Libraries
Java Games
Book Reviews


Statistics
Registered Users: 4092
Java SE Tips: 614
Java ME Tips: 202
Java EE Tips: 183
Other API Tips: 779
Java Applications: 298
Java Libraries: 209
Java Games: 16
Book Reviews:
 
 
 
Multiple viewports - NeHe Tutorial JOGL Port E-mail
User Rating: / 8
PoorBest 

This example shows how to display multiple views on a single screen.

This is the Java port of the one of the NeHe OpenGL tutorials.

You can get complete IntelliJ IDEA project structure (all source, resources, build script, ) by downloading the source distribution from here.

The original post of the programmer who ported the examples can be found here.


Image

package demos.nehe.lesson42;

import demos.common.GLDisplay;

/**
 @author Pepijn Van Eeckhoudt
 */
public class Lesson42 {
    public static void main(String[] args) {
        GLDisplay neheGLDisplay = GLDisplay.createGLDisplay("Lesson 42: Multiple viewports");
        Renderer renderer = new Renderer();
        InputHandler inputHandler = new InputHandler(renderer, neheGLDisplay);
        neheGLDisplay.addGLEventListener(renderer);
        neheGLDisplay.addKeyListener(inputHandler);
        neheGLDisplay.start();
    }
}


package demos.nehe.lesson42;

import demos.common.GLDisplay;

import javax.swing.*;
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;

class InputHandler extends KeyAdapter {
    private Renderer renderer;

    public InputHandler(Renderer renderer, GLDisplay glDisplay) {
        this.renderer = renderer;
        glDisplay.registerKeyStrokeForHelp(
                KeyStroke.getKeyStroke(KeyEvent.VK_SPACE, 0)"Reset maze texture");
    }

    public void keyReleased(KeyEvent e) {
        switch (e.getKeyCode()) {
            case KeyEvent.VK_SPACE:
                renderer.resetMaze();
        }
    }
}


package demos.nehe.lesson42;

import com.sun.opengl.util.BufferUtil;

import javax.media.opengl.*;
import javax.media.opengl.glu.GLUquadric;
import javax.media.opengl.glu.GLU;

import java.nio.ByteBuffer;

class Renderer implements GLEventListener {
    private static final int MAZE_WIDTH = 128// Maze Width  (Must Be A Power Of 2)
    private static final int MAZE_HEIGHT = 128// Maze Height (Must Be A Power Of 2)

    private int mx,my;      // General Loops (Used For Seeking)
    private ByteBuffer tex_data = BufferUtil.newByteBuffer(MAZE_WIDTH * MAZE_HEIGHT * 3);
    private byte[] r = new byte[4];  // Random Colors (4 Red, 4 Green, 4 Blue)
    private byte[] g = new byte[4];
    private byte[] b = new byte[4];
    private GLU glu = new GLU();
    private GLUquadric quadric;
    private float xrot, yrot, zrot;  // Use For Rotation Of Objects

    private long previousTime = System.currentTimeMillis();

    private boolean resetMaze = false;

    public void resetMaze() {
        resetMaze = true;
    }

    private void updateTex(int dmx, int dmy)  // Update Pixel dmx, dmy On The Texture
    {
        // Set Red Pixel To Full Bright
        tex_data.put(((dmx + (MAZE_WIDTH * dmy)) 3)(byte255);                
        // Set Green Pixel To Full Bright
        tex_data.put(((dmx + (MAZE_WIDTH * dmy)) 3)(byte255);                
        // Set Blue Pixel To Full Bright
        tex_data.put(((dmx + (MAZE_WIDTH * dmy)) 3)(byte255);  
    }

    private void reset()  // Reset The Maze, Colors, Start Point, Etc
    {
        tex_data.clear();
        while(tex_data.hasRemaining()) {
            tex_data.put((byte)0);
        }
        tex_data.flip();

        for (int loop = 0; loop < 4; loop++)  // Loop So We Can Assign 4 Random Colors
        {
            // Pick A Random Red Color (Bright)
            r[loop(byte) ((int) (Math.random() * Integer.MAX_VALUE128 128);
            // Pick A Random Green Color (Bright)
            g[loop(byte) ((int) (Math.random() * Integer.MAX_VALUE128 128);
            // Pick A Random Blue Color (Bright)
            b[loop(byte) ((int) (Math.random() * Integer.MAX_VALUE128 128);
        }

        setRandomMazePosition();
    }

    private void setRandomMazePosition() {
        // Pick A New Random X Position
        mx = (intMath.round(Math.random() ((MAZE_WIDTH - 12)) 2
        // Pick A New Random Y Position
        my = (intMath.round(Math.random() ((MAZE_HEIGHT - 12)) 2
    }

    public void init(GLAutoDrawable drawable) {
        GL gl = drawable.getGL();

        reset();    // Call Reset To Build Our Initial Texture, Etc.

        // Start Of User Initialization
        gl.glTexParameteri(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_WRAP_S, GL.GL_CLAMP);
        gl.glTexParameteri(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_WRAP_T, GL.GL_CLAMP);
        gl.glTexParameterf(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_MAG_FILTER, GL.GL_LINEAR);
        gl.glTexParameteri(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_MIN_FILTER, GL.GL_LINEAR);
        gl.glTexImage2D(GL.GL_TEXTURE_2D, 0, GL.GL_RGB, MAZE_WIDTH, MAZE_HEIGHT, 0
                GL.GL_RGB, GL.GL_UNSIGNED_BYTE, tex_data);

        gl.glClearColor(0.0f0.0f0.0f0.0f)// Black Background
        gl.glClearDepth(1.0f);      // Depth Buffer Setup

        gl.glDepthFunc(GL.GL_LEQUAL);    // The Type Of Depth Testing
        gl.glEnable(GL.GL_DEPTH_TEST);    // Enable Depth Testing

        // Enable Color Material (Allows Us To Tint Textures)
        gl.glEnable(GL.GL_COLOR_MATERIAL);

        gl.glEnable(GL.GL_TEXTURE_2D);  // Enable Texture Mapping

        quadric = glu.gluNewQuadric();  // Create A Pointer To The Quadric Object
        glu.gluQuadricNormals(quadric, GLU.GLU_SMOOTH)// Create Smooth Normals
        glu.gluQuadricTexture(quadric, true)// Create Texture Coords

        gl.glEnable(GL.GL_LIGHT0);    // Enable Light0 (Default GL Light)
    }

    private void update(float milliseconds)  // Perform Motion Updates Here
    {
        int dir;        // Will Hold Current Direction

        xrot += milliseconds * 0.02f// Increase Rotation On The X-Axis
        yrot += milliseconds * 0.03f// Increase Rotation On The Y-Axis
        zrot += milliseconds * 0.015f// Increase Rotation On The Z-Axis

        // Check To Make Sure We Are Not Trapped (Nowhere Else To Move)
        if ((mx > (MAZE_WIDTH - 4|| (tex_data.get((((mx + 2
                (MAZE_WIDTH * my)) 3)) != 0)) &&
                (mx < || (tex_data.get((((mx - 2(MAZE_WIDTH * my)) 3)) != 0)) 
                && (my > (MAZE_HEIGHT - 4|| 
                (tex_data.get(((mx + (MAZE_WIDTH * (my + 2))) 3)) != 0)) &&
                (my < || (tex_data.get(((mx + (MAZE_WIDTH * (my - 2))) 3)) != 0))
        ) {
            do          // If We Are Trapped
            {
                setRandomMazePosition();
            // Keep Picking A Random Position Until We Find
            while (tex_data.get(((mx + (MAZE_WIDTH * my)) 3)) == 0);            
        // One That Has Already Been Tagged (Safe Starting Point)
        }                                  

        dir = (intMath.round(Math.random() 3f);

        // If The Direction Is 0 (Right) And We Are Not At The Far Right
        if ((dir == 0&& (mx <= (MAZE_WIDTH - 4)))                  
        {
            // And If The Room To The Right Has Not Already Been Visited
            if (tex_data.get((((mx + 2(MAZE_WIDTH * my)) 3)) == 0)            
            {
                // Update The Texture To Show Path Cut Out Between Rooms
                updateTex(mx + 1, my);  
                mx += 2;  // Move To The Right (Room To The Right)
            }
        }

        // If The Direction Is 1 (Down) And We Are Not At The Bottom
        if ((dir == 1&& (my <= (MAZE_HEIGHT - 4)))  
        {
            // And If The Room Below Has Not Already Been Visited
            if (tex_data.get(((mx + (MAZE_WIDTH * (my + 2))) 3)) == 0)
            {
                // Update The Texture To Show Path Cut Out Between Rooms
                updateTex(mx, my + 1);  
                my += 2;  // Move Down (Room Below)
            }
        }

        // If The Direction Is 2 (Left) And We Are Not At The Far Left
        if ((dir == 2&& (mx >= 2))                      
        {
            // And If The Room To The Left Has Not Already Been Visited
            if (tex_data.get((((mx - 2(MAZE_WIDTH * my)) 3)) == 0)
            {
                // Update The Texture To Show Path Cut Out Between Rooms
                updateTex(mx - 1, my);  
                mx -= 2;    // Move To The Left (Room To The Left)
            }
        }

        // If The Direction Is 3 (Up) And We Are Not At The Top
        if ((dir == 3&& (my >= 2))  
        {
            // And If The Room Above Has Not Already Been Visited
            if (tex_data.get(((mx + (MAZE_WIDTH * (my - 2))) 3)) == 0)  
            {
                // Update The Texture To Show Path Cut Out Between Rooms
                updateTex(mx, my - 1);  
                my -= 2;    // Move Up (Room Above)
            }
        }

        updateTex(mx, my);  // Update Current Room
    }

    public void display(GLAutoDrawable drawable) {
        if (resetMaze) {
            reset();
            resetMaze = false;
        }

        long currentTime = System.currentTimeMillis();
        update(currentTime - previousTime);
        previousTime = currentTime;

        GL gl = drawable.getGL();

        int windowWidth = drawable.getWidth();
        int windowHeight = drawable.getHeight();

        // Update Our Texture... This Is The Key To The Programs Speed... 
        // Much Faster Than Rebuilding The Texture Each Time
        gl.glTexSubImage2D(GL.GL_TEXTURE_2D, 000, MAZE_WIDTH, MAZE_HEIGHT, 
                GL.GL_RGB, GL.GL_UNSIGNED_BYTE, tex_data);

        gl.glClear(GL.GL_COLOR_BUFFER_BIT);  // Clear Screen

        for (int loop = 0; loop < 4; loop++)  // Loop To Draw Our 4 Views
        {
            gl.glColor3ub(r[loop], g[loop], b[loop]);  // Assign Color To Current View

            if (loop == 0)  // If We Are Drawing The First Scene
            {
                // Set The Viewport To The Top Left.  It Will Take Up Half The Screen 
                // Width And Height
                gl.glViewport(0, windowHeight / 2, windowWidth / 2, windowHeight / 2);
                gl.glMatrixMode(GL.GL_PROJECTION)// Select The Projection Matrix
                gl.glLoadIdentity();  // Reset The Projection Matrix
                // Set Up Ortho Mode To Fit 1/4 The Screen (Size Of A Viewport)
                glu.gluOrtho2D(0, windowWidth / 2, windowHeight / 20);
            }

            if (loop == 1// If We Are Drawing The Second Scene
            {
                // Set The Viewport To The Top Right.  It Will Take Up Half The 
                // Screen Width And Height
                gl.glViewport(windowWidth / 2, windowHeight / 2, windowWidth / 2
                        windowHeight / 2);
                gl.glMatrixMode(GL.GL_PROJECTION)// Select The Projection Matrix
                gl.glLoadIdentity();  // Reset The Projection Matrix
                // Set Up Perspective Mode To Fit 1/4 The Screen (Size Of A Viewport)
                glu.gluPerspective(45.0(float) (MAZE_WIDTH
                        (float) (MAZE_HEIGHT)0.1f500.0);
            }

            if (loop == 2// If We Are Drawing The Third Scene
            {
                // Set The Viewport To The Bottom Right.  It Will Take Up 
                // Half The Screen Width And Height
                gl.glViewport(windowWidth / 20, windowWidth / 2, windowHeight / 2);
                gl.glMatrixMode(GL.GL_PROJECTION)// Select The Projection Matrix
                gl.glLoadIdentity();  // Reset The Projection Matrix
                // Set Up Perspective Mode To Fit 1/4 The Screen (Size Of A Viewport)
                glu.gluPerspective(45.0(float) (MAZE_WIDTH
                        (float) (MAZE_HEIGHT)0.1f500.0);
            }

            if (loop == 3// If We Are Drawing The Fourth Scene
            {
                // Set The Viewport To The Bottom Left.  It Will Take Up Half 
                // The Screen Width And Height
                gl.glViewport(00, windowWidth / 2, windowHeight / 2);
                gl.glMatrixMode(GL.GL_PROJECTION)// Select The Projection Matrix
                gl.glLoadIdentity();  // Reset The Projection Matrix
                // Set Up Perspective Mode To Fit 1/4 The Screen (Size Of A Viewport)
                glu.gluPerspective(45.0(float) (MAZE_WIDTH
                        (float) (MAZE_HEIGHT)0.1f500.0);
            }

            gl.glMatrixMode(GL.GL_MODELVIEW)// Select The Modelview Matrix
            gl.glLoadIdentity();  // Reset The Modelview Matrix

            gl.glClear(GL.GL_DEPTH_BUFFER_BIT);  // Clear Depth Buffer

            // Are We Drawing The First Image?  (Original Texture... Ortho)
            if (loop == 0)  
            {
                gl.glBegin(GL.GL_QUADS);// Begin Drawing A Singl.gle Quad
                // We Fill The Entire 1/4 Section With A Singl.gle Textured Quad.
                gl.glTexCoord2f(1.0f0.0f);
                gl.glVertex2i(windowWidth / 20);
                gl.glTexCoord2f(0.0f0.0f);
                gl.glVertex2i(00);
                gl.glTexCoord2f(0.0f1.0f);
                gl.glVertex2i(0, windowHeight / 2);
                gl.glTexCoord2f(1.0f1.0f);
                gl.glVertex2i(windowWidth / 2, windowHeight / 2);
                gl.glEnd();    // Done Drawing The Textured Quad
            }

            // Are We Drawing The Second Image?  
      // (3D Texture Mapped Sphere... Perspective)
            if (loop == 1)    
            {
                gl.glTranslatef(0.0f0.0f, -14.0f)// Move 14 Units Into The Screen

                gl.glRotatef(xrot, 1.0f0.0f0.0f)// Rotate By xrot On The X-Axis
                gl.glRotatef(yrot, 0.0f1.0f0.0f)// Rotate By yrot On The Y-Axis
                gl.glRotatef(zrot, 0.0f0.0f1.0f)// Rotate By zrot On The Z-Axis

                gl.glEnable(GL.GL_LIGHTING);  // Enable Lighting
                glu.gluSphere(quadric, 4.0f3232)// Draw A Sphere
                gl.glDisable(GL.GL_LIGHTING);  // Disable Lighting
            }

            // Are We Drawing The Third Image?  (Texture At An Angl.gle... Perspective)
            if (loop == 2)
            {
                gl.glTranslatef(0.0f0.0f, -2.0f)// Move 2 Units Into The Screen
                // Tilt The Quad Below Back 45 Degrees.
                gl.glRotatef(-45.0f1.0f0.0f0.0f);  
                // Rotate By zrot/1.5 On The Z-Axis
                gl.glRotatef(zrot / 1.5f0.0f0.0f1.0f)

                gl.glBegin(GL.GL_QUADS);  // Begin Drawing A Singl.gle Quad
                gl.glTexCoord2f(1.0f1.0f);
                gl.glVertex3f(1.0f1.0f0.0f);
                gl.glTexCoord2f(0.0f1.0f);
                gl.glVertex3f(-1.0f1.0f0.0f);
                gl.glTexCoord2f(0.0f0.0f);
                gl.glVertex3f(-1.0f, -1.0f0.0f);
                gl.glTexCoord2f(1.0f0.0f);
                gl.glVertex3f(1.0f, -1.0f0.0f);
                gl.glEnd()// Done Drawing The Textured Quad
            }

            // Are We Drawing The Fourth Image?  
      // (3D Texture Mapped Cylinder... Perspective)
            if (loop == 3
            {
                gl.glTranslatef(0.0f0.0f, -7.0f)// Move 7 Units Into The Screen
                // Rotate By -xrot/2 On The X-Axis
                gl.glRotatef(-xrot / 21.0f0.0f0.0f)
                // Rotate By -yrot/2 On The Y-Axis
                gl.glRotatef(-yrot / 20.0f1.0f0.0f)
                // Rotate By -zrot/2 On The Z-Axis
                gl.glRotatef(-zrot / 20.0f0.0f1.0f);              

                gl.glEnable(GL.GL_LIGHTING)// Enable Lighting
                // Translate -2 On The Z-Axis (To Rotate Cylinder Around The 
                // Center, Not An End)
                gl.glTranslatef(0.0f0.0f, -2.0f)
                glu.gluCylinder(quadric, 1.5f1.5f4.0f3216)// Draw A Cylinder
                gl.glDisable(GL.GL_LIGHTING)// Disable Lighting
            }
        }

        gl.glFlush();    // Flush The GL.GL Rendering Pipeline
    }

    public void reshape(GLAutoDrawable drawable,
                        int xstart,
                        int ystart,
                        int width,
                        int height) {
        GL gl = drawable.getGL();

        height = (height == 0: height;

        gl.glViewport(00, width, height);
        gl.glMatrixMode(GL.GL_PROJECTION);
        gl.glLoadIdentity();

        glu.gluPerspective(45(floatwidth / height, 11000);
        gl.glMatrixMode(GL.GL_MODELVIEW);
        gl.glLoadIdentity();
    }

    public void displayChanged(GLAutoDrawable drawable,
                               boolean modeChanged,
                               boolean deviceChanged) {
    }
}

 Related Tips

 
< Prev   Next >

Page 1 of 0 ( 0 comments )

You can share your information about this topic using the form below!

Please do not post your questions with this form! Thanks.


Name (required)


E-Mail (required)

Your email will not be displayed on the site - only to our administrator
Homepage(optional)



Comment Enable HTML code : Yes No



 
       
         
     
 
 
 
   
 
 
java bottom left
java bottom middle
java bottom right
RSS 0.91 FeedRSS 1.0 FeedRSS 2.0 FeedATOM FeedOPML Feed

Home - About Us - Privacy Policy
Copyright 2005 - 2008 www.java-tips.org
Java is a trademark of Sun Microsystems, Inc.