public static void setupLighting() {
FloatBuffer lightPosition = BufferUtils.createFloatBuffer(4);
lightPosition.put(0.0f).put(0.0f).put(0.0f).put(0.0f).flip();
FloatBuffer whiteLight = BufferUtils.createFloatBuffer(4);
whiteLight.put(1.0f).put(1.0f).put(1.0f).put(1.0f).flip();
FloatBuffer lModelAmbient = BufferUtils.createFloatBuffer(4);
lModelAmbient.put(0.4f).put(0.4f).put(0.4f).put(1.0f).flip();
glShadeModel(GL_SMOOTH);
glMaterial(GL_FRONT, GL_SPECULAR, whiteLight);
glMaterialf(GL_FRONT, GL_SHININESS, 50.0f);
glLight(GL_LIGHT0, GL_POSITION, lightPosition);
glLight(GL_LIGHT0, GL_SPECULAR, whiteLight);
glLight(GL_LIGHT0, GL_DIFFUSE, whiteLight);
glLightModel(GL_LIGHT_MODEL_AMBIENT, lModelAmbient);
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
glEnable(GL_COLOR_MATERIAL);
glColorMaterial(GL_FRONT, GL_AMBIENT_AND_DIFFUSE);
}
public static void setupView(int width, int height) {
glPopAttrib();
glPushAttrib(GL_ENABLE_BIT);
glEnable(GL_TEXTURE_2D);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
setupLighting();
glClearDepth(1D);
glEnable(GL_DEPTH_TEST);
glEnable(GL_CULL_FACE);
glDepthFunc(GL_LEQUAL);
glViewport(0, 0, width, height);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(60F, (float) width / height, 0.1F, 1000F);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
}
@Override
public void render() {
int width = App.getScreenWidth();
int height = App.getScreenHeight();
glMatrixMode(GL_PROJECTION);
glPushMatrix();
glLoadIdentity();
gluOrtho2D(0, width, 0, height);
glScalef(1, -1, 1);
glTranslatef(0, -height, 0);
glMatrixMode(GL_MODELVIEW);
glDisable(GL_DEPTH_TEST);
// Draw background
glBegin(GL_QUADS);
{
if (backgroundColor != null) GeneralUtils.glColorShortcut(backgroundColor);
glVertex2f(0, 0);
glVertex2f(0, height);
glVertex2f(width, height);
glVertex2f(width, 0);
}
glEnd();
for (GuiButton b : buttons) {
b.render();
// System.out.println(b.isMouseOver());
}
// I don't want to set the same opengl settings for every button.
// We can reduce a least a tiny bit of overhead by doing it in one go
font.renderBegin();
for (GuiButton b : buttons) {
b.renderText();
}
font.renderEnd();
glMatrixMode(GL_PROJECTION);
glPopMatrix();
glMatrixMode(GL_MODELVIEW);
glEnable(GL_DEPTH_TEST);
}
public static int prepareSquare(int texId, float size) {
int list = glGenLists(1);
glNewList(list, GL_COMPILE);
glDisable(GL_CULL_FACE);
glBindTexture(GL_TEXTURE_2D, texId);
glTranslatef(-size / 2, -size / 2, 0);
// glRotatef(180.0f, 0.0f, 0.0f, 0.0f);
glBegin(GL_QUADS);
glTexCoord2f(0.0f, 0.0f);
glVertex2f(0.0f, 0.0f);
glTexCoord2f(1.0f, 0.0f);
glVertex2f(size, 0.0f);
glTexCoord2f(1.0f, 1.0f);
glVertex2f(size, size);
glTexCoord2f(0.0f, 1.0f);
glVertex2f(0.0f, size);
glEnd();
glEnable(GL_CULL_FACE);
glEndList();
return list;
}
@Override
public void init() throws IOException {
super.init();
screen.setTitle("MD2 Loader");
createGameActions();
glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(45.0f, 800 / 600, 1.0f, 2000.0f);
glMatrixMode(GL_MODELVIEW);
glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
// Here, we turn on a lighting and enable lighting. We don't need to
// set anything else for lighting because we will just take the defaults.
// We also want color, so we turn that on
// Habilita Z-Buffer
glEnable(GL_DEPTH_TEST);
glEnable(GL_LIGHT0); // Turn on a light with defaults set
glEnable(GL_LIGHTING); // Turn on lighting
glEnable(GL_COLOR_MATERIAL); // Allow color
// To make our model render somewhat faster, we do some front back culling.
// It seems that Quake2 orders their polygons clock-wise.
// Seleciona o modo de aplicação da textura
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, modo);
glEnable(GL_CULL_FACE); // Turn culling on
glCullFace(GL_FRONT);
glEnable(GL_TEXTURE_2D);
g_World.load(FILE_NAME);
// g_LoadMd2.importMD2(g_World, "modelsd2/model8/head.md2", "modelsd2/model8/head.png");
// g_LoadMd2.importMD2(g_World, "modelsd2/model8/throne.md2", "modelsd2/model8/throne.png");
}
protected void render() {
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // Clear The Screen And The Depth Buffer
glLoadIdentity();
camera.look();
// Each frame we calculate the new frustum. In reality you only need to
// calculate the frustum when we move the camera.
GameCore.gFrustum.calculateFrustum();
// Initialize the total node count that is being draw per frame
Octree.totalNodesDrawn = 0;
glPushMatrix();
// Here we draw the octree, starting with the root node and recursing down each node.
// This time, we pass in the root node and just the original world model. You could
// just store the world in the root node and not have to keep the original data around.
// This is up to you. I like this way better because it's easy, though it could be
// more error prone.
octree.drawOctree(octree, g_World);
glPopMatrix();
// Render the cubed nodes to visualize the octree (in wire frame mode)
if (g_bDisplayNodes) Octree.debug.drawBoundingBox();
glPushMatrix();
// If there was a collision, make the Orange ball Red.
if (octree.isObjectColliding()) {
glColor3f(1.0f, 0.0f, 0.0f);
} else {
glColor3f(1.0f, 0.5f, 0.0f); // Disable Lighting.
}
// Move the Ball into place.
glTranslatef(g_BallEntity.x, g_BallEntity.y, g_BallEntity.z);
glDisable(GL_LIGHTING);
// Draw the Ground Intersection Line.
glBegin(GL_LINES);
glColor3f(1, 1, 1);
glVertex3f(g_vGroundISector[0].x, g_vGroundISector[0].y, g_vGroundISector[0].z);
glVertex3f(g_vGroundISector[1].x, g_vGroundISector[1].y, g_vGroundISector[1].z);
glEnd();
// Draw the Forward Intersection Line.
glBegin(GL_LINES);
glColor3f(1, 1, 0);
glVertex3f(
g_vForwardISector[0].x * 10.0f, g_vForwardISector[0].y, g_vForwardISector[0].z * 10.0f);
glVertex3f(
g_vForwardISector[1].x * 10.0f, g_vForwardISector[1].y, g_vForwardISector[1].z * 10.0f);
glEnd();
// Re-enable lighting.
glEnable(GL_LIGHTING);
// System.out.println("x " + g_BallEntity.x + " y " + g_BallEntity.y);
// Draw it!
pObj.draw(g_BallEntity.fRadius, 20, 20);
glPopMatrix();
screen.setTitle(
"Triangles: "
+ Octree.maxTriangles
+ " -Total Draw: "
+ Octree.totalNodesDrawn
+ " -Subdivisions: "
+ Octree.maxSubdivisions
+ " -FPS: "
+ FPSCounter.get()
+ " -Node Collisions: "
+ Octree.numNodesCollided
+ " -Object Colliding? "
+ octree.isObjectColliding());
}
@Override
public void init() throws IOException {
super.init();
camera = new Camera(true);
camera.setPosition(-17f, 20f, 17f, 0, 0, 0, 0, 1, 0);
float df = 100.0f;
// Precalculate the Sine and Cosine Lookup Tables.
// Basically, loop through 360 Degrees and assign the Radian
// value to each array index (which represents the Degree).
for (int i = 0; i < 360; i++) {
g_fSinTable[i] = (float) Math.sin(AR_DegToRad(i));
g_fCosTable[i] = (float) Math.cos(AR_DegToRad(i));
}
pObj = new Sphere();
pObj.setOrientation(GLU_OUTSIDE);
Octree.debug = new BoundingBox();
// Turn lighting on initially
Octree.turnLighting = true;
// The current amount of end nodes in our tree (The nodes with vertices stored in them)
Octree.totalNodesCount = 0;
// This stores the amount of nodes that are in the frustum
Octree.totalNodesDrawn = 0;
// The maximum amount of triangles per node. If a node has equal or less
// than this, stop subdividing and store the face indices in that node
Octree.maxTriangles = 800;
// The maximum amount of subdivisions allowed (Levels of subdivision)
Octree.maxSubdivisions = 5;
// The number of Nodes we've checked for collision.
Octree.numNodesCollided = 0;
// Wheter the Object is Colliding with anything in the World or not.
octree.setObjectColliding(false);
// Wheter we test the whole world for collision or just the nodes we are in.
Octree.octreeCollisionDetection = true;
LoadWorld();
// for(int i=0; i < g_World.getNumOfMaterials(); i++)
// {
// System.out.println(g_World.getMaterials(i).getName() + " indice " + i);
// }
// for(int i=0; i < g_World.getNumOfObjects(); i++)
// {
// System.out.println(g_World.getObject(i).getName());
// System.out.println(g_World.getObject(i).getMaterialID());
// System.out.println(g_World.getPObject(i).getMaterialID());
// }
// System.out.println(g_World.getPMaterials(12).getColor()[0] + " " +
// g_World.getPMaterials(12).getColor()[1]
// + " " + g_World.getPMaterials(12).getColor()[2]);
// System.out.println(g_World.getPMaterials(g_World.getPObject(6).getMaterialID()));
inputManager = new InputManager();
createGameActions();
posLuz1F = Conversion.allocFloats(posLuz1);
// Define a cor de fundo da janela de visualização como preto
glClearColor(0, 0, 0, 1);
// Ajusta iluminação
glLight(GL_LIGHT0, GL_AMBIENT, Conversion.allocFloats(luzAmb1));
glLight(GL_LIGHT0, GL_DIFFUSE, Conversion.allocFloats(luzDif1));
glLight(GL_LIGHT0, GL_SPECULAR, Conversion.allocFloats(luzEsp1));
// Habilita todas as fontes de luz
glEnable(GL_LIGHT0);
glEnable(GL_LIGHTING);
// Agora posiciona demais fontes de luz
glLight(GL_LIGHT0, GL_POSITION, posLuz1F);
// Habilita Z-Buffer
glEnable(GL_DEPTH_TEST);
// Seleciona o modo de GL_COLOR_MATERIAL
// glColorMaterial(GL_FRONT, GL_DIFFUSE);
glEnable(GL_COLOR_MATERIAL);
glMaterial(GL_FRONT, GL_SPECULAR, Conversion.allocFloats(spec));
glMaterialf(GL_FRONT, GL_SHININESS, df);
}
