Ah thats more like what i'm after!
Would all this happen in the render loop? I'm not too experienced with lwjgl unfortunately, although i do understand the basics.. The below code is my renderer class (with quite a lot taken out) which is based on someone elses basic renderer. Do this look right (roughly) for each object in the render loop:
GL11.glScissor(x, y, width, height);
glEnable(GL_SCISSOR);
GL11.glViewport(...);
GL11.glClear(GL11.GL_COLOR_BUFFER_BIT | GL11.GL_DEPTH_BUFFER_BIT);
GL11.glDisable(GL_SCISSOR);
GL11.glMatrixMode(GL_MODELVIEW);
GL11.glLoadIdentity();
GL11.glRotatef(rotateModelY, 0, 1, 0); // around vertical axis
GL11.glRotatef(rotateModelX, 1, 0, 0); // around horizontal axis
GL11.glPushMatrix();
renderMesh(object1,0);
GL11.glPopMatrix();
THANKS AGAIN!
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
RENDERER CODE:
public class GLRenderer{
private String WINDOW_TITLE = "OBJModel";
private DisplayMode displayMode; //Display perspectives and aspect ratios
public GL_Mesh obj; //Single OBJ Object
private String modelLocation;
private float z = 0.0f; // Depth Into The Screen
private float rotateModelX = 0;
private float rotateModelY = 0;
private boolean normalsOn = true;
private int cursorX, cursorY;
// camera position and rotation (see handleNavigationKeys())
float[] cameraPos = new float[] {0,0,100};
float cameraRotation = 0f;
final float piover180 = 0.0174532925f;// A constant used in navigation
// for mouse drag
Vector3D mousePrevPos = null;
boolean mouseIsDown = false;
Vector3D mousePoint = new Vector3D(.1f,0,100);
// Arrays to hold matrices for projectVerts() operation.
// For memory efficiency, instantiate these once and reuse.
// see getModelviewMatrixA(), getMatrixAsArray() and mesh.projectVerts().
public static float[][] modelViewMatrix = new float[4][4];
public static float[][] projectionMatrix = new float[4][4];
public static int[] viewport = new int[4];
// color of overall scene lighting
float ambient[] = { 0f, 0f, 0f, 1f };
// color of light source
float lightDiffuse[] = { .9f, .9f, .6f, 1f }; // direct light
float lightSpecular[] = { .9f, .9f, .6f, 1f }; // highlight
float lightAmbient[] = { .5f, .0f, .0f, 1f }; // scattered light
// light position: if last value is 0, then this describes light direction.
// If 1, then light position.
float lightPosition[] = { -100f, 100f, 100, 0f };
// color of material
float mtlDiffuse[] = { .6f, 0f, 0f, 1f }; // red
float mtlAmbient[] = { .2f, 0f, 0f, 1f }; // dark red
float mtlSpecular[] = { .8f, .8f, .8f, 1f }; // almost white: very reflective
float mtlShininess = 100f; // 0=no shine, 127=max shine
private boolean done = false;
private boolean norm = false;
private boolean tetra = false;
private boolean renderAnchors = false;
private boolean objLoaded = false;
private Tetrahedron tet;
public int[] anchors;
private GL_Vertex modelCenter;
private boolean wireframe;
public GLRenderer(GL_Mesh mesh){
this.obj = mesh;
objLoaded = true;
}
public GLRenderer(String filename){
this.modelLocation = filename;
run();
}
public void run() {
try {
init();
while (!done) {
if(!norm){
MainLoop();
render();
Display.update();}
}
cleanup();
}
catch (Exception e) {
e.printStackTrace();
System.exit(0);
}
}
public void init() throws Exception {
createWindow();
initGL();
if(!objLoaded){
Importer importOBJ = new Importer();
obj = importOBJ.importOBJ(modelLocation);}
// Get the current projection and viewport matrices
// for use in projectVerts(). Modelview matrix will change
// every frame, so we'll get that in render().
projectionMatrix = getProjectionMatrixA();
viewport = getViewportA();
}
public void initGL() {
Display.setVSyncEnabled(false); //Seriously slows down FPS
// Select the Projection Matrix (controls perspective)
GL11.glMatrixMode(GL11.GL_PROJECTION);
GL11.glLoadIdentity(); // Reset The Projection Matrix
// Define perspective
GLU.gluPerspective(
30.0f, // Field Of View
(float)displayMode.getWidth() / (float)displayMode.getHeight(), // aspect ratio
0.01f, // near Z clipping plane
1000.0f); // far Z clipping plane
// Select The Modelview Matrix (controls model orientation)
GL11.glMatrixMode(GL11.GL_MODELVIEW);
GL11.glLoadIdentity(); // Reset The Modelview Matrix
// make sure OpenGL correctly layers objects
GL11.glEnable(GL11.GL_DEPTH_TEST);
// OpenGL won't draw backward facing triangles ("back faces")
GL11.glEnable(GL11.GL_CULL_FACE);
// turn lighting on (does not create a light)
GL11.glEnable(GL11.GL_LIGHTING);
// Create a light
// diffuse is the color of direct light from this light source
// specular is the hightlight color
// ambient is the color of scattered light from this source
// position is where the light is, or it's direction
setLight( GL11.GL_LIGHT1, lightDiffuse, lightAmbient, lightSpecular, lightPosition );
// no overall scene lighting
setAmbientLight(ambient);
GL11.glShadeModel(GL11.GL_SMOOTH);
// set the background color
GL11.glClearColor(.08f, .08f, .1f, 1);
GL11.glLineWidth(1);
}
public void createWindow() throws Exception {
Display.setFullscreen(false);
// get all possible display resolutions
DisplayMode d[] = Display.getAvailableDisplayModes();
// find a resolution we like
for (int i = 0; i < d.length; i++) {
if (d.getWidth() == 800
&& d.getHeight() == 600
&& d.getBitsPerPixel() == 32) {
displayMode = d;
break;
}
}
// set the display to the resolution we picked
Display.setDisplayMode(displayMode);
Display.setTitle(WINDOW_TITLE);
// create the window
// specify Pixel Format:
// 0 -- default bits per pixel for alpha values
// 24 -- 24 bits per pixel for depth buffer
// 0 -- default bits per pixel for stencil buffer
// NOTE:
// we specify 24 bits per pixel instead of the default
// 8 bits because this scene is deep
// (zdepth is .01 - 1000 in the gluPerspective() command)
// and 8 bit values only hold 0-255 (rounding
// errors cause close objects to overlap instead of
// correctly layering.
Display.create(new PixelFormat(0,24,0));
}
public void MainLoop() {
if(Keyboard.isKeyDown(Keyboard.KEY_ESCAPE)) {
done = true;
}
// Has Window been closed
if(Display.isCloseRequested()) {
done = true;
}
// Handle key press events (down/up)
handleKeyPressEvents();
// Handle arrow keys (press and hold)
handleNavigationKeys();
handleMouseEvents();
//cleanup();
}
public void render() {
// Clear screen and depth buffer
GL11.glClear(GL11.GL_COLOR_BUFFER_BIT | GL11.GL_DEPTH_BUFFER_BIT);
// reset the coordinate system to center of screen
GL11.glLoadIdentity();
GL11.glPushMatrix();
{
// Place the 'camera'
GLU.gluLookAt( // camera position
cameraPos[0], cameraPos[1], cameraPos[2],
// look at a point directly in front of camera
cameraPos[0]- (float) Math.sin(cameraRotation* piover180), cameraPos[1],
cameraPos[2]- (float) Math.cos(cameraRotation* piover180),
// which way is up
0f, 1f, 0f);
// alternative
// shift and rotate entire scene (opposite to "camera" position)
//GL11.glRotatef((360.0f-cameraRotation), 0, 1f, 0); // first
// rotate around y axis
//GL11.glTranslatef( -cameraPos[0], -cameraPos[1], -cameraPos[2]);
// // then move forward on x,z axis (staying on ground, so no Y
// motion)
// set the light position (have to do this each render() since
// we're moving the scene around with navigation, have to update
// light position. Light pos is transformed just like a vertex).
//setLightPos(GL11.GL_LIGHT1, lightPosition[0], lightPosition[1], lightPosition[2]);
// draw white sphere at light position
GL11.glDisable(GL11.GL_LIGHTING);
GL11.glColor4f(1, 1, .9f, 1);
GL11.glPushMatrix();
{
//GL11.glTranslatef(lightPosition[0], lightPosition[1], lightPosition[2]);
//renderSphere();
}
GL11.glPopMatrix();
GL11.glEnable(GL11.GL_LIGHTING);
GL11.glPushMatrix();
{
// rotate model (based on mouse drag)
GL11.glRotatef(rotateModelY, 0, 1, 0); // around vertical axis
GL11.glRotatef(rotateModelX, 1, 0, 0); // around horizontal axis
renderMesh(obj,0);
if(tetra){
drawTetrahedron();
}
if(renderAnchors){
highlightFixPoints();
}
//pps+=polycount;
}
GL11.glPopMatrix();
}
GL11.glPopMatrix();
}
public void renderMesh(GL_Mesh o, int textureHandle)
{
GL_Triangle t;
GL11.glBindTexture(GL11.GL_TEXTURE_2D,textureHandle);
GL11.glBegin(GL11.GL_TRIANGLES);
for (int j = 0; j < o.triangles.length; j++) { // draw all triangles in object
t = o.triangles[j];
GL11.glTexCoord2f(t.uvw1.x, t.uvw1.y);
GL11.glNormal3f(t.norm1.x, t.norm1.y, t.norm1.z);
GL11.glVertex3f( (float)t.p1.pos.x, (float)t.p1.pos.y, (float)t.p1.pos.z);
GL11.glTexCoord2f(t.uvw2.x, t.uvw2.y);
GL11.glNormal3f(t.norm2.x, t.norm2.y, t.norm2.z);
GL11.glVertex3f( (float)t.p2.pos.x, (float)t.p2.pos.y, (float)t.p2.pos.z);
GL11.glTexCoord2f(t.uvw3.x, t.uvw3.y);
GL11.glNormal3f(t.norm3.x, t.norm3.y, t.norm3.z);
GL11.glVertex3f( (float)t.p3.pos.x, (float)t.p3.pos.y, (float)t.p3.pos.z);
}
GL11.glEnd();
}
public void cleanup() {
Display.destroy();
}
public void screenDepth(){
GL11.glTranslatef(0.0f,0.0f,z); // Translate Into/Out Of The Screen By z
}
/**
* Detect changes in key state, ie. a key is pressed or released, and
* call keydown() and keyup() functions. These are non-repeating events
* (keydown will be called only when the key is first pressed).
*/
public void handleKeyPressEvents()
{
while ( Keyboard.next() ) {
if (Keyboard.getEventKeyState()) {
keyDown(Keyboard.getEventKey());
}
else {
keyUp(Keyboard.getEventKey());
}
}
}
/**
* Key event functions (keyDown() and keyUp() are are called by mainloop()).
* @param keycode
*/
public void keyDown(int keycode) {
// Normals off/on
if (keycode == Keyboard.KEY_N) {
normalsOn = !normalsOn;
}
}
public void keyUp(int keycode) {
}
public void handleNavigationKeys()
{
// Turn left
if (Keyboard.isKeyDown(Keyboard.KEY_LEFT)) {
cameraRotation += 1.0f;
}
// Turn right
if (Keyboard.isKeyDown(Keyboard.KEY_RIGHT)) {
cameraRotation -= 1.0f;
}
// move forward in current direction
if (Keyboard.isKeyDown(Keyboard.KEY_UP)) {
cameraPos[0] -= (float) Math.sin(cameraRotation * piover180) * 1f;
cameraPos[2] -= (float) Math.cos(cameraRotation * piover180) * 1f;
}
// move backward in current direction
if (Keyboard.isKeyDown(Keyboard.KEY_DOWN)) {
cameraPos[0] += (float) Math.sin(cameraRotation * piover180) * 1f;
cameraPos[2] += (float) Math.cos(cameraRotation * piover180) * 1f;
}
// move camera down
if (Keyboard.isKeyDown(Keyboard.KEY_PRIOR)) {
cameraPos[1] += .3f;
}
// move camera up
if (Keyboard.isKeyDown(Keyboard.KEY_NEXT)) {
cameraPos[1] -= .3f;
}
if (Keyboard.isKeyDown(Keyboard.KEY_W)) {
setWireframeOn();
}
if (Keyboard.isKeyDown(Keyboard.KEY_E)) {
setWireframeOff();
}
if (Keyboard.isKeyDown(Keyboard.KEY_T)) {
testCenter();
}
if (Keyboard.isKeyDown(Keyboard.KEY_N)) {
normalise();
}
}
//----------------------------------------------------------------
// Wireframe
//----------------------------------------------------------------
public void setWireframeOff() {
GL11.glPolygonMode(GL11.GL_FRONT_AND_BACK, GL11.GL_FILL);
GL11.glEnable(GL11.GL_CULL_FACE);
wireframe = false;
}
/** enter wireframe mode */
public void setWireframeOn() {
GL11.glPolygonMode(GL11.GL_FRONT_AND_BACK, GL11.GL_LINE);
GL11.glDisable(GL11.GL_CULL_FACE);
wireframe = true;
}
}
