How do I set up JOGL 2.0-rc5?
Posted by Pixelapp on Feb 01, 2012; 1:24am
URL: https://forum.jogamp.org/How-do-I-set-up-JOGL-2-0-rc5-tp3705345.html
I was developing with JOGL 2.0-rc3, but yesterday I switched to JOGL 2.0-rc5 and the code below doesn't work anymore.
Any ideas on how to fix this?
The main problem is that Eclipse doesn't recognize what I'm missing. When I set up the project I make sure to include all the jars under the /jogl-2.0-b45-20111219-windows-i586/jar folder, however I do not include the jars in /jogl-2.0-b45-20111219-windows-i586/jar/atomic because this is how I always do it.
I would have looked into the JOGL userguide but remember guys/gals that it hasn't been updated for a while since JOGL development moves so fast.
package pixelapp.texturedpolygon;
import java.awt.GraphicsDevice;
import java.awt.GraphicsEnvironment;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.nio.FloatBuffer;
import javax.media.opengl.GL;
import javax.media.opengl.GL2;
import javax.media.opengl.GLAutoDrawable;
import javax.media.opengl.GLCapabilities;
import javax.media.opengl.GLEventListener;
import javax.media.opengl.GLProfile;
import javax.media.opengl.awt.GLCanvas;
import javax.swing.JFrame;
import com.jogamp.opengl.util.FPSAnimator;
import com.jogamp.opengl.util.texture.Texture;
import com.jogamp.opengl.util.texture.TextureCoords;
import com.jogamp.opengl.util.texture.TextureIO;
/**
* @author Main
*
*/
public class TexturedPolygon implements GLEventListener
{
private Texture tex;
private String file = "platform.png";
private String folder = "pixelapp/texturedpolygon/images/";
private JFrame myFrame; // Create JFrame object.
private ClassLoader cl;
// To calculate textures
private final int SQUARE_VERT = 4;
private float one = 1;
private int cubeAcc = 0;
private final int ZERO = 0;
private int acc = ZERO; // Accumulator
// Display
private int NUM_CUBES_DISPLAY = 1;
private final int MAX_NUM_CUBES_DISPLAY = 1;
private FloatBuffer[] mVertexBufferDisplay = new FloatBuffer[MAX_NUM_CUBES_DISPLAY];
private FloatBuffer[] mColorBufferDisplay = new FloatBuffer[MAX_NUM_CUBES_DISPLAY];
private ByteBuffer[] mIndexBufferDisplay = new ByteBuffer[MAX_NUM_CUBES_DISPLAY];
private FloatBuffer[] mTexBufferDisplay = new FloatBuffer[MAX_NUM_CUBES_DISPLAY];
private ByteBuffer[] vbbDisplay = new ByteBuffer[MAX_NUM_CUBES_DISPLAY];
private ByteBuffer[] cbbDisplay = new ByteBuffer[MAX_NUM_CUBES_DISPLAY];
private ByteBuffer[] tbbDisplay = new ByteBuffer[MAX_NUM_CUBES_DISPLAY];
private float[] cubeFillerVDisplay = {
0.587655f,1.284244f,0.138390f,
0.587655f,0.149090f,0.140718f,
1.722811f,0.150490f,0.140715f,
1.722811f,1.282844f,0.138393f,
0.523544f,1.271740f,0.138393f,
0.523544f,0.139385f,0.140715f,
-0.611612f,0.137985f,0.140718f,
-0.611612f,1.273139f,0.138390f,
-0.622717f,2.439094f,0.138390f,
-0.622717f,1.303940f,0.140718f,
0.512440f,1.305340f,0.140715f,
0.512440f,2.437694f,0.138393f,
-0.742349f,1.249531f,0.138393f,
-0.742349f,0.117177f,0.140715f,
-1.877506f,0.115777f,0.140718f,
-1.877506f,1.250931f,0.138390f,
-0.622717f,0.018350f,0.138390f,
-0.622717f,-1.116804f,0.140718f,
0.512440f,-1.115404f,0.140716f,
0.512440f,0.016951f,0.138393f,
0.490231f,-1.226734f,0.138393f,
0.490231f,-2.359088f,0.140716f,
-0.644925f,-2.360488f,0.140719f,
-0.644925f,-1.225334f,0.138390f,
};
private float[] cubeFillerCDisplay = {
one, one, one, one,
one, one, one, one,
one, one, one, one,
one, one, one, one,
one, one, one, one,
one, one, one, one,
one, one, one, one,
one, one, one, one,
one, one, one, one,
one, one, one, one,
one, one, one, one,
one, one, one, one,
one, one, one, one,
one, one, one, one,
one, one, one, one,
one, one, one, one,
one, one, one, one,
one, one, one, one,
one, one, one, one,
one, one, one, one,
one, one, one, one,
one, one, one, one,
one, one, one, one,
one, one, one, one,
};
private byte[] cubeFillerIDisplay = {
2 - 1,3 - 1,4 - 1,
4 - 1,1 - 1,2 - 1,
7 - 1,5 - 1,8 - 1,
7 - 1,6 - 1,5 - 1,
10 - 1,11 - 1,12 - 1,
10 - 1,12 - 1,9 - 1,
15 - 1,13 - 1,16 - 1,
15 - 1,14 - 1,13 - 1,
18 - 1,19 - 1,20 - 1,
18 - 1,20 - 1,17 - 1,
23 - 1,21 - 1,24 - 1,
23 - 1,22 - 1,21 - 1,
};
public TexturedPolygon()
{
// Set the title of the Frame.
myFrame = new JFrame("TexturedPolygon");
// Close program on Finish.
myFrame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
// Eliminates the windows frames look.
myFrame.setUndecorated(true);
GLProfile glp = GLProfile.getDefault();
GLCapabilities caps = new GLCapabilities(glp);
GLCanvas miCanvas = new GLCanvas(caps);
// Indicate Canvas to detect the events of OpenGL in this Class.
miCanvas.addGLEventListener(this);
// Insert Canvas in the Frame.
myFrame.add(miCanvas);
// Size of the window
myFrame.setSize(600, 600);
// Make visible the object of most weight
myFrame.setVisible(true);
// Renders continuously JOGL2.
FPSAnimator animator = new FPSAnimator(miCanvas, 30);
animator.add(miCanvas);
animator.start();
// Get current classloader
cl = this.getClass().getClassLoader();
/**
Full Screen Mode
*/
GraphicsEnvironment env = GraphicsEnvironment.
getLocalGraphicsEnvironment();
GraphicsDevice device = env.getDefaultScreenDevice();
device.setFullScreenWindow(myFrame);
// Display
// Buffers to be passed to gl*Pointer() functions
// must be direct, i.e., they must be placed on the
// native heap where the garbage collector cannot
// move them.
//
// Buffers with multi-byte datatypes (e.g., short, int, float)
// must have their byte order set to native order
for (cubeAcc = ZERO; cubeAcc < NUM_CUBES_DISPLAY; cubeAcc++) {
vbbDisplay[cubeAcc] = ByteBuffer
.allocateDirect(cubeFillerVDisplay.length * 4);
vbbDisplay[cubeAcc].order(ByteOrder.nativeOrder());
mVertexBufferDisplay[cubeAcc] = vbbDisplay[cubeAcc].asFloatBuffer();
mVertexBufferDisplay[cubeAcc].put(cubeFillerVDisplay);
mVertexBufferDisplay[cubeAcc].position(0);
}
for (cubeAcc = ZERO; cubeAcc < NUM_CUBES_DISPLAY; cubeAcc++) {
cbbDisplay[cubeAcc] = ByteBuffer
.allocateDirect(cubeFillerCDisplay.length * 4);
cbbDisplay[cubeAcc].order(ByteOrder.nativeOrder());
mColorBufferDisplay[cubeAcc] = cbbDisplay[cubeAcc].asFloatBuffer();
mColorBufferDisplay[cubeAcc].put(cubeFillerCDisplay);
mColorBufferDisplay[cubeAcc].position(0);
}
for (cubeAcc = ZERO; cubeAcc < NUM_CUBES_DISPLAY; cubeAcc++) {
mIndexBufferDisplay[cubeAcc] = ByteBuffer
.allocateDirect(cubeFillerIDisplay.length);
mIndexBufferDisplay[cubeAcc].put(cubeFillerIDisplay);
mIndexBufferDisplay[cubeAcc].position(0);
}
for (cubeAcc = ZERO; cubeAcc < NUM_CUBES_DISPLAY; cubeAcc++) {
tbbDisplay[cubeAcc] = ByteBuffer.allocateDirect(cubeFillerVDisplay.length * 2 * 4);
tbbDisplay[cubeAcc].order(ByteOrder.nativeOrder());
mTexBufferDisplay[cubeAcc] = tbbDisplay[cubeAcc].asFloatBuffer();
}
}
/** Called by the drawable immediately after the OpenGL context is
* initialized for the first time. Can be used to perform one-time OpenGL
* initialization such as setup of lights and display lists.
* @param gLDrawable The GLAutoDrawable object.
*/
public void init(GLAutoDrawable drawable)
{
GL2 gl = drawable.getGL().getGL2(); // Initialize the variable GL
// >>
gl.glClearDepth(1.0f); // Set depth's clear-value to farthest
gl.glEnable(GL2.GL_DEPTH_TEST); // Enables depth-buffer for hidden
// surface removal
gl.glDepthFunc(GL2.GL_LEQUAL); // The type of depth testing to do
gl.glHint(GL2.GL_PERSPECTIVE_CORRECTION_HINT, GL2.GL_NICEST); // nice perspective view, avoid texture distortion.
gl.glShadeModel(GL2.GL_SMOOTH); // Enable smooth shading of color
gl.glDisable(GL2.GL_DITHER); // Disable dithering for better performance
// sky color background
gl.glClearColor(0.17f, 0.65f, 0.92f, 0.0f);
loadTexture(file, gl); // for the billboard
}
private void loadTexture(String fnm, GL2 gl)
{
String fileName = folder + fnm;
tex = null;
try {
tex = TextureIO.newTexture( cl.getResource(fileName), false, null);
tex.setTexParameteri(gl, GL2.GL_TEXTURE_MAG_FILTER, GL2.GL_NEAREST);
tex.setTexParameteri(gl, GL.GL_TEXTURE_MIN_FILTER, GL.GL_NEAREST);
}
catch(Exception e)
{ System.out.println("Error loading texture " + fileName); }
} // end of loadTexture()
public void display(GLAutoDrawable drawable)
{
GL2 gl = drawable.getGL().getGL2(); // Initialize the variable GL
/*
* By default, OpenGL enables features that improve quality but reduce
* performance. One might want to tweak that especially on software
* renderer.
*/
gl.glDisable(GL2.GL_DITHER);
// >>
gl.glTexEnvf(GL2.GL_TEXTURE_ENV, GL2.GL_TEXTURE_ENV_MODE, GL2.GL_MODULATE);
/*
* Usually, the first thing one might want to do is to clear the screen.
* The most efficient way of doing this is to use glClear().
*/
gl.glClear(GL2.GL_COLOR_BUFFER_BIT | GL2.GL_DEPTH_BUFFER_BIT);
/*
* Now we're ready to draw some 3D objects
*/
gl.glMatrixMode(GL2.GL_MODELVIEW);
gl.glLoadIdentity();
gl.glTranslatef(0, 0, -5.2f);
gl.glEnableClientState(GL2.GL_VERTEX_ARRAY);
gl.glEnableClientState(GL2.GL_COLOR_ARRAY);
gl.glEnableClientState(GL2.GL_TEXTURE_COORD_ARRAY);
TextureCoords tc = tex.getImageTexCoords();
// Display
mTexBufferDisplay[0].put(0); // x or s
mTexBufferDisplay[0].put(1); // y or t
mTexBufferDisplay[0].put(1); // x or s
mTexBufferDisplay[0].put(1); // y or t
mTexBufferDisplay[0].put(1); // x or s
mTexBufferDisplay[0].put(0); // y or t
mTexBufferDisplay[0].put(0); // x or s
mTexBufferDisplay[0].put(0); // y or t
mTexBufferDisplay[0].put(0); // x or s
mTexBufferDisplay[0].put(1); // y or t
mTexBufferDisplay[0].put(1); // x or s
mTexBufferDisplay[0].put(1); // y or t
mTexBufferDisplay[0].put(1); // x or s
mTexBufferDisplay[0].put(0); // y or t
mTexBufferDisplay[0].put(0); // x or s
mTexBufferDisplay[0].put(0); // y or t
mTexBufferDisplay[0].put(0); // x or s
mTexBufferDisplay[0].put(1); // y or t
mTexBufferDisplay[0].put(1); // x or s
mTexBufferDisplay[0].put(1); // y or t
mTexBufferDisplay[0].put(1); // x or s
mTexBufferDisplay[0].put(0); // y or t
mTexBufferDisplay[0].put(0); // x or s
mTexBufferDisplay[0].put(0); // y or t
mTexBufferDisplay[0].put(0); // x or s
mTexBufferDisplay[0].put(1); // y or t
mTexBufferDisplay[0].put(1); // x or s
mTexBufferDisplay[0].put(1); // y or t
mTexBufferDisplay[0].put(1); // x or s
mTexBufferDisplay[0].put(0); // y or t
mTexBufferDisplay[0].put(0); // x or s
mTexBufferDisplay[0].put(0); // y or t
mTexBufferDisplay[0].put(0); // x or s
mTexBufferDisplay[0].put(1); // y or t
mTexBufferDisplay[0].put(1); // x or s
mTexBufferDisplay[0].put(1); // y or t
mTexBufferDisplay[0].put(1); // x or s
mTexBufferDisplay[0].put(0); // y or t
mTexBufferDisplay[0].put(0); // x or s
mTexBufferDisplay[0].put(0); // y or t
mTexBufferDisplay[0].put(0); // x or s
mTexBufferDisplay[0].put(1); // y or t
mTexBufferDisplay[0].put(1); // x or s
mTexBufferDisplay[0].put(1); // y or t
mTexBufferDisplay[0].put(1); // x or s
mTexBufferDisplay[0].put(0); // y or t
mTexBufferDisplay[0].put(0); // x or s
mTexBufferDisplay[0].put(0); // y or t
mTexBufferDisplay[0].position(0);
gl.glActiveTexture(GL2.GL_TEXTURE0);
gl.glEnable(GL2.GL_TEXTURE_2D);
// do not draw the transparent parts of the texture
gl.glEnable(GL2.GL_BLEND);
gl.glBlendFunc(GL2.GL_SRC_ALPHA, GL2.GL_ONE_MINUS_SRC_ALPHA);
// don't show source alpha parts in the destination
// determine which areas of the polygon are to be rendered
gl.glEnable(GL2.GL_ALPHA_TEST);
gl.glAlphaFunc(GL2.GL_GREATER, 0); // only render if alpha > 0
// Display
for (acc = ZERO; acc < NUM_CUBES_DISPLAY; acc++)
{
tex.bind(gl);
tex.setTexParameterf(gl, GL2.GL_TEXTURE_WRAP_S,
GL2.GL_CLAMP_TO_EDGE);
tex.setTexParameterf(gl, GL2.GL_TEXTURE_WRAP_T,
GL2.GL_CLAMP_TO_EDGE);
gl.glPushMatrix();
gl.glVertexPointer(3, GL2.GL_FLOAT, 0, mVertexBufferDisplay[acc]);
gl.glEnable(GL2.GL_TEXTURE_2D);
gl.glColorPointer(4, GL2.GL_FLOAT, 0, mColorBufferDisplay[acc]);
gl.glTexCoordPointer(2, GL2.GL_FLOAT, 0, mTexBufferDisplay[acc]);
gl.glDrawElements(GL2.GL_TRIANGLES, cubeFillerIDisplay.length,
GL2.GL_UNSIGNED_BYTE, mIndexBufferDisplay[acc]);
gl.glPopMatrix();
}
}
public void reshape(GLAutoDrawable drawable, int x, int y, int width,
int height)
{
GL2 gl = drawable.getGL().getGL2(); // Initialize the variable GL
if (height == 0) {
height = 1; // to avoid division by 0 in aspect ratio below
}
float ratio = (float) width / height;
gl.glViewport(0, 0, width, height);
/*
* Set our projection matrix. This doesn't have to be done each time we
* draw, but usually a new projection needs to be set when the viewport
* is resized.
*/
gl.glMatrixMode(GL2.GL_PROJECTION);
gl.glLoadIdentity();
gl.glFrustum(-ratio, ratio, -1, 1, 1, 236);
}
public static void main(String[] args)
{
new TexturedPolygon();
}
public void dispose(GLAutoDrawable drawable)
{
}
}