/**
* DrawNeutral function.
*
* This function draws the stick figure depending on the
* transforming stage of the player or draws a diamond if the
* player is not tracked.
*
* @param player is the ID of the player.
*
*/
void NeutralModel :: drawNeutral (XnUserID player)
{
// UserGenerator.
UserGenerator userGen;
// Color of the stick figure.
XnFloat color[3];
// Material properties.
GLfloat mat_specular[] = { 0.3, 0.3, 0.3, 0.3 };
GLfloat mat_shininess[] = { 10.0 };
// Center of mass.
XnPoint3D com;
// Player's stage.
int stage;
float ax;
Vector3D a;
Vector3D b;
Vector3D c;
Vector3D u;
Vector3D v;
Vector3D w;
GLuint mode;
// Select the players color according his ID.
color[0] = Colors[player % nColors][0];
color[1] = Colors[player % nColors][1];
color[2] = Colors[player % nColors][2];
// Set the material for the stick figure.
GLfloat materialColor[] = {color[0], color[1], color[2], 1.0f};
glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, materialColor);
glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular);
glMaterialfv(GL_FRONT, GL_SHININESS, mat_shininess);
userGen = nm_UserDetector -> retUserGenerator();
SkeletonCapability skelCap = userGen.GetSkeletonCap();
mode = GLM_SMOOTH | GLM_MATERIAL;
a = Vector3D(joint[LSHOULDER]);
b = Vector3D(joint[RSHOULDER]);
c = Vector3D(joint[RHIP]);
u = b - a;
v = c - a;
w = u.cross(v);
w.y = 0.0;
w.normalize();
ax = 57.2957795 * acos(w.z);
if (w.x <= 0.0) {
ax = -ax;
}
// Init the drawing process.
// Draws a stick figure if player is been tracked.
if (skelCap.IsTracking(player)) {
// Get player's stage.
stage = nm_UserDetector -> retStage(player);
loadJoints(player, skelCap);
// Drawing legs.
if ((stage >= 0) && (stage < 4)) {
// Left leg.
glPushMatrix();
orientMatrix(joint[RHIP],joint[RKNEE]);
glTranslatef( 0.0, 0.0, 50.0);
glScalef(250.0, 250.0, 250.0);
glRotatef(90, -1.0, 0.0, 0.0);
glRotatef(ax, 0.0,-1.0, 0.0);
glmDraw(zamusModelParts.thigh, mode);
glPopMatrix();
glPushMatrix();
orientMatrix(joint[RKNEE],joint[RFOOT]);
glTranslatef( 0.0, 0.0, 50.0);
glScalef(100.0, 100.0, 100.0);
glRotatef(90, -1.0, 0.0, 0.0);
glRotatef(ax, 0.0,-1.0, 0.0);
glmDraw(zamusModelParts.leg, mode);
glPopMatrix();
// Right leg.
glPushMatrix();
orientMatrix(joint[LHIP], joint[LKNEE]);
glTranslatef( 0.0, 0.0, 50.0);
glScalef(-250.0, 250.0, 250.0);
glRotatef(90, -1.0, 0.0, 0.0);
glRotatef(-ax, 0.0,-1.0, 0.0);
glmDraw(zamusModelParts.thigh, mode);
glPopMatrix();
glPushMatrix();
orientMatrix(joint[LKNEE], joint[LFOOT]);
glTranslatef( 0.0, 0.0, 50.0);
glScalef(-100.0, 100.0, 100.0);
glRotatef(90, -1.0, 0.0, 0.0);
glRotatef(-ax, 0.0,-1.0, 0.0);
glmDraw(zamusModelParts.leg, mode);
glPopMatrix();
// Foots.
glPushMatrix();
glTranslatef( joint[LFOOT].X, joint[LFOOT].Y, joint[LFOOT].Z);
glScalef(40.0,-40.0,-40.0);
glRotatef(ax, 0.0,-1.0, 0.0);
glTranslatef(0.0,-0.25, 0.5);
glmDraw(zamusModelParts.foot, mode);
glPopMatrix();
glPushMatrix();
glTranslatef( joint[RFOOT].X, joint[RFOOT].Y, joint[RFOOT].Z);
glScalef(-40.0,-40.0,-40.0);
glRotatef(-ax, 0.0,-1.0, 0.0);
glTranslatef(0.0,-0.25, 0.5);
glmDraw(zamusModelParts.foot, mode);
glPopMatrix();
}
else {
drawLimp(joint[LKNEE],joint[LFOOT]);
drawLimp(joint[RKNEE],joint[RFOOT]);
drawLimp(joint[LHIP],joint[LKNEE]);
drawLimp(joint[RHIP],joint[RKNEE]);
}
// Draw torso.
if ((stage > 0) && (stage < 4)) {
glPushMatrix();
orientMatrix(joint[NECK],joint[TORSO]);
glScalef(400.0, 400.0, 400.0);
glRotatef(90, -1.0, 0.0, 0.0);
glRotatef(ax, 0.0,-1.0, 0.0);
glTranslatef(0.0, -0.1, 0.0);
glmDraw(zamusModelParts.chest, mode);
glPopMatrix();
}
else {
drawTorso();
}
// Drawing arms.
if (stage == 2) {
// Shoulders
glPushMatrix();
glTranslatef(joint[LSHOULDER].X,
joint[LSHOULDER].Y,
joint[LSHOULDER].Z);
glRotatef(-ax, 0.0,-2.0, 0.0);
glTranslatef(-30.0,-40.0, 0.0);
glScalef(500.0,-500.0, 500.0);
glmDraw(zamusModelParts.shoulder, mode);
glPopMatrix();
glPushMatrix();
glTranslatef(joint[RSHOULDER].X,
joint[RSHOULDER].Y,
joint[RSHOULDER].Z);
glRotatef(-ax, 0.0,-1.0, 0.0);
glTranslatef( 30.0,-40.0, 0.0);
glScalef(500.0,-500.0, 500.0);
glmDraw(zamusModelParts.shoulder, mode);
glPopMatrix();
// LeftArm
glPushMatrix();
orientMatrix(joint[RSHOULDER], joint[RELBOW]);
glTranslatef( 0.0, 0.0, 50.0);
glScalef(500.0, 500.0, 500.0);
glRotatef(90, -1.0, 0.0, 0.0);
glRotatef(ax, 0.0,-1.0, 0.0);
glmDraw(zamusModelParts.arm, mode);
glPopMatrix();
glPushMatrix();
orientMatrix(joint[RELBOW], joint[RHAND]);
glTranslatef( 0.0, 0.0, 60.0);
glScalef(250.0, 250.0, 250.0);
glRotatef(90, -1.0, 0.0, 0.0);
glRotatef(-ax, 0.0,-1.0, 0.0);
glmDraw(zamusModelParts.forearm, mode);
glPopMatrix();
glPushMatrix();
orientMatrix(joint[LSHOULDER], joint[LELBOW]);
glTranslatef( 0.0, 0.0, 50.0);
glScalef(500.0, 500.0, 500.0);
glRotatef(90, -1.0, 0.0, 0.0);
glRotatef(ax, 0.0,-1.0, 0.0);
glmDraw(zamusModelParts.arm, mode);
glPopMatrix();
glPushMatrix();
orientMatrix(joint[LELBOW],joint[LHAND]);
glTranslatef( 0.0, 0.0, 80.0);
glScalef(300.0, 300.0, 300.0);
glRotatef(90, -1.0, 0.0, 0.0);
glRotatef(-ax, 0.0,-1.0, 0.0);
glmDraw(zamusModelParts.cannon, mode);
glPopMatrix();
}
else if ((stage == 4) || (stage == 5)) {
glPushMatrix();
glTranslatef(joint[LSHOULDER].X,
joint[LSHOULDER].Y,
joint[LSHOULDER].Z);
glRotatef(-ax, 0.0,-2.0, 0.0);
glScalef(500.0,-500.0, 500.0);
glmDraw(linqModelParts.shoulder, mode);
glPopMatrix();
glPushMatrix();
orientMatrix(joint[LSHOULDER],joint[LELBOW]);
glTranslatef( 0.0, 0.0, 50.0);
glScalef(-180.0, 180.0, 180.0);
glRotatef(90, -1.0, 0.0, 0.0);
glRotatef(-ax, 0.0,-1.0, 0.0);
glmDraw(linqModelParts.thigh, mode);
glPopMatrix();
glPushMatrix();
orientMatrix(joint[LELBOW],joint[LHAND]);
glTranslatef( 0.0, 0.0, 50.0);
glScalef(-80.0, 80.0, 80.0);
glRotatef(90, -1.0, 0.0, 0.0);
glRotatef(-ax, 0.0,-1.0, 0.0);
glmDraw(linqModelParts.leg, mode);
glPopMatrix();
}
else {
drawLimp(joint[LSHOULDER],joint[LELBOW]);
drawLimp(joint[LELBOW],joint[LHAND]);
}
if (stage == 5) {
glPushMatrix();
glTranslatef(joint[RSHOULDER].X,
joint[RSHOULDER].Y,
joint[RSHOULDER].Z);
glRotatef(-ax, 0.0,-1.0, 0.0);
glScalef(500.0,-500.0, 500.0);
glmDraw(linqModelParts.shoulder, mode);
glPopMatrix();
glPushMatrix();
orientMatrix(joint[RSHOULDER],joint[RELBOW]);
glTranslatef( 0.0, 0.0, 50.0);
glScalef(350.0, 350.0, 350.0);
glRotatef(90, -1.0, 0.0, 0.0);
glRotatef(ax, 0.0,-1.0, 0.0);
glmDraw(linqModelParts.arm, mode);
glPopMatrix();
glPushMatrix();
orientMatrix(joint[RELBOW],joint[RHAND]);
glTranslatef( 0.0, 0.0, 60.0);
glScalef(250.0, 250.0, 250.0);
glRotatef(90, -1.0, 0.0, 0.0);
glRotatef(-ax, 0.0,-1.0, 0.0);
glmDraw(linqModelParts.forearm, mode);
glPopMatrix();
}
else {
drawLimp(joint[RSHOULDER],joint[RELBOW]);
drawLimp(joint[RELBOW],joint[RHAND]);
}
// Draw head.
drawHead();
}
// Draws a diamond in the player's center of mass.
else {
userGen.GetCoM(player, com);
nm_DepthGenerator.ConvertRealWorldToProjective(1, &com, &com);
glPushMatrix();
glTranslatef(com.X, com.Y, com.Z);
glutSolidSphere(60.0, 4, 2);
glPopMatrix();
}
}
void MapObject::draw(float size, bool mapDependency) {
if (model != nullptr) {
glmDraw(model, GLM_COLOR | GLM_SMOOTH, 0);
}
}
void
display(void)
{
static char s[256], t[32];
static char* p;
static int frames = 0;
glClearColor(1.0, 1.0, 1.0, 1.0);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glBindFramebuffer(GL_FRAMEBUFFER, 0);
//glBindFramebuffer(GL_FRAMEBUFFER, shadowBuffer);
glUseProgram(shadowShaderID);
// Render to our framebuffer
glViewport(0,0,windowW,windowH); // Render on the whole framebuffer, complete from the lower left corner to the upper right
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
glTranslatef(pan_x, pan_y, 0.0);
gltbMatrix();
#if 0 /* glmDraw() performance test */
if (material_mode == 0) {
if (facet_normal)
glmDraw(model, GLM_FLAT);
else
glmDraw(model, GLM_SMOOTH);
} else if (material_mode == 1) {
if (facet_normal)
glmDraw(model, GLM_FLAT | GLM_COLOR);
else
glmDraw(model, GLM_SMOOTH | GLM_COLOR);
} else if (material_mode == 2) {
if (facet_normal)
glmDraw(model, GLM_FLAT | GLM_MATERIAL);
else
glmDraw(model, GLM_SMOOTH | GLM_MATERIAL);
}
#else
glCallList(model_list);
#endif
drawTexToScreen();
glDisable(GL_LIGHTING);
if (bounding_box) {
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glEnable(GL_BLEND);
glEnable(GL_CULL_FACE);
glColor4f(1.0, 0.0, 0.0, 0.25);
glutSolidCube(2.0);
glDisable(GL_BLEND);
}
glPopMatrix();
if (stats) {
/* XXX - this could be done a _whole lot_ faster... */
int height = glutGet(GLUT_WINDOW_HEIGHT);
glColor3ub(0, 0, 0);
sprintf(s, "%s\n%d vertices\n%d triangles\n%d normals\n"
"%d texcoords\n%d groups\n%d materials",
model->pathname, model->numvertices, model->numtriangles,
model->numnormals, model->numtexcoords, model->numgroups,
model->nummaterials);
shadowtext(5, height-(5+18*1), s);
}
/* spit out frame rate. */
frames++;
if (frames > NUM_FRAMES) {
sprintf(t, "%g fps", frames/elapsed());
frames = 0;
}
if (performance) {
shadowtext(5, 5, t);
}
//glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glutSwapBuffers();
glEnable(GL_LIGHTING);
}
/* DRAW POLICE
* funzione che disegna le navette nemiche caricate come obj
* model modello del nemico caricato
* pos posizione del nemico
* direcion (r1) orientazione (versore direzione di movimento)
*
*/
GLvoid drawPolice(GLMmodel* model, Point3 pos, Point3 r1){
// vettore temporaneo: ci serve per definire una terna di assi ortogonali tra loro di cui uno di essi e' r3
Point3 temp;
temp.x=1;
temp.y=1;
temp.z=1;
// CI TROVIAMO LA TERNA DI ASSI ORTOGONALI TRA LORO: r1,r2,r3
// normalizziamo r1, anche se dovrebbe essere gia' stato normalizzato
r1=Normalize(r1);
// il prodotto esterno del vettore 'r1' per un qualsiasi vettore 'temp', mi fornisce il vettore 'r2' ortogonale a r1
Point3 r2=Normalize(Cross(r1, temp));
// ci troviamo il versore r3, ortogonale a 'r2' e quindi anche a 'r1'
Point3 r3=Normalize(Cross(r1,r2));
// ci creiamo un vettore che definisce la matrice (4x4) di rototraslazione che dobbiamo applicare
/* MATRICE DI ROTO-TRASLAZIONE
Mappatura indici del vettore sulla matrice:
0 1 2 3
4 5 6 7
8 9 10 11
12 13 14 15
POSIZIONI:
0:2 coordinate di r1 (prime tre posizioni della prima riga)
4:6 coordinate di r2 (prime tre posizioni della seconda riga)
8:10 coordinate di r3 (prime tre posizioni della terza riga)
12:14 coordinate della posizione (prime tre posizioni della quarta riga)
3,7,11 impostate a 0 (prime tre posizioni dell'ultima colonna)
15 impostata a 1
*/
GLfloat r[16];
r[0]=r1.x;
r[1]=r1.y;
r[2]=r1.z;
r[4]=r2.x;
r[5]=r2.y;
r[6]=r2.z;
r[8]=r3.x;
r[9]=r3.y;
r[10]=r3.z;
r[3]=0;
r[7]=0;
r[11]=0;
r[12]=pos.x;
r[13]=pos.y;
r[14]=pos.z;
r[15]=1;
glPushMatrix();
glMultMatrixf(r);
//printf("diff=%f\n", (glutGet(GLUT_ELAPSED_TIME)-anglePolice)*0.032); fflush(stdout);
// se non sono nel freeze
if(!freezeShip)
anglePolice += 0.896000;
glRotatef(anglePolice, 1, 0, 0);
//ROTAZIONE perche' stia dritto:
//glRotatef(-135, 1, 0, 0);
glmDraw(model, GLM_SMOOTH | GLM_MATERIAL);
//glmDraw(model, GLM_SMOOTH|GLM_TEXTURE|GLM_MATERIAL);
glPopMatrix();
}
void Inicializa(){
char str[40+1];
OB_ovni.ponto.x = 0.0;
OB_ovni.ponto.y = 0.0;
OB_ovni.ponto.z = 0.0;
OB_nave.ponto.x = 0.0;
OB_nave.ponto.y = -17.5;
OB_nave.ponto.z = 3.0;
for(i=0;i<QTD_MISSEL_NAVE;i++){
OB_missel1[i].ponto.x = OB_nave.ponto.x;
OB_missel1[i].ponto.y = OB_nave.ponto.y + trans_missel_nave;
OB_missel1[i].ponto.z = 0;
OB_missel1[i].habilitado = false;
OB_missel1[i].dispara_missel_esfera = false;
}
for(i=0;i<QTD_MISSEL_OVNI;i++){
OB_missel2[i].ponto.x = 0.0;
OB_missel2[i].ponto.y = 0.0;
OB_missel2[i].ponto.z = 0.0;
OB_missel2[i].habilitado = false;
OB_missel2[i].dispara_missel_esfera = false;
}
//imagem = CarregaJPG("490020730_5d1ef91b20_o.jpg");
//importarBlenderWrl("nave_pronta3.wrl",&SA_faces,&points);
sprintf(textpontos,"%s","Pontos: 0");
//printf("Inicializa 1\n");
/*aviao = CarregaObjeto("nave_pronta_gabriel2.obj", true);
if(aviao == NULL){
printf("ERRO teste.obj\n");
}else{
printf("Nave Importado\n");
}*/
GLM_background = glmReadOBJ("fundo.obj");
GLM_background_list = glGenLists(1);
glNewList(GLM_background_list, GL_COMPILE);
glmDraw(GLM_background, GLM_NONE|GLM_SMOOTH|GLM_TEXTURE|GLM_COLOR);
glEndList();
GLM_aviao = glmReadOBJ("nave_pronta_gabriel2.obj");
GLM_aviao_list = glGenLists(1);
glNewList(GLM_aviao_list, GL_COMPILE);
glmDraw(GLM_aviao, GLM_SMOOTH|GLM_TEXTURE|GLM_COLOR);
glEndList();
GLM_aviao2 = glmReadOBJ("nave_pronta_gabriel2.obj");
GLM_aviao_list2 = glGenLists(1);
glNewList(GLM_aviao_list2, GL_COMPILE);
glmDraw(GLM_aviao2, GLM_SMOOTH);
glEndList();
GLM_missel = glmReadOBJ("missel.obj");
GLM_missel_list = glGenLists(1);
glNewList(GLM_missel_list, GL_COMPILE);
glmDraw(GLM_missel, GLM_NONE|GLM_SMOOTH|GLM_TEXTURE|GLM_COLOR);
glEndList();
GLM_missel2 = glmReadOBJ("missel2.obj");
GLM_missel_list2 = glGenLists(1);
glNewList(GLM_missel_list2, GL_COMPILE);
glmDraw(GLM_missel2, GLM_NONE|GLM_SMOOTH|GLM_TEXTURE|GLM_COLOR);
glEndList();
/*missel=glGenLists(1);
glNewList(missel,GL_COMPILE);
importarBlenderWrl("missel.wrl",&SA_faces,&points);
glEndList();
DestroiRegFaces(&SA_faces);
DestroiRegPoints(&points);*/
/*ovni = CarregaObjeto("ovni.obj", true);
if(ovni == NULL){
printf("ERRO ovni.obj\n");
}else{
printf("Ovni Importado\n");
}*/
GLM_ovni = glmReadOBJ("ovni.obj");
GLM_ovni_list = glGenLists(1);
glNewList(GLM_ovni_list, GL_COMPILE);
glmDraw(GLM_ovni, GLM_NONE|GLM_SMOOTH|GLM_TEXTURE|GLM_MATERIAL);
glEndList();
/*background = CarregaObjeto("background.obj", false);
if(background == NULL){
printf("ERRO background.obj\n");
}else{
printf("background Importado\n");
}*/
CriaDisplayList(NULL);
iluminacao();
InitEsferas(esfera);
}
void Wheel::draw(float timeElapsed, float speed) {
//glPushMatrix();
//assuming the current position where to make the wheel
//since it is always drawn with the car, so we can have the angle to turn the wheel from the time elapsed and Velocity
int i;
float angleRotated = (10*speed*timeElapsed*180)/(M_PI*rad); //making the circle in XY plane
angle += angleRotated;
if(angle > 360) {
angle = angle-360;
}
if(angle < 0) {
angle += 360;
}
// printf(">>angle = %f\n", timeElapsed);
glPushMatrix();
glColor3f(1,1,1);
glRotatef(angle,1,0,0);
int mode = GLM_NONE; /* reset mode */
mode = mode | GLM_SMOOTH;
mode = mode | GLM_2_SIDED;
mode = mode | GLM_MATERIAL;
mode = mode | GLM_TEXTURE;
// glTranslatef(0,20,0);
glPushMatrix();
glmUnitize(wheel_model);
glScalef(18, 18,18);
if (wheel_model) {
glEnable(GL_TEXTURE_2D);
glmDraw(wheel_model, mode);
glDisable(GL_TEXTURE_2D);
}
glPopMatrix();
/*
glBindTexture(GL_TEXTURE_2D, _wheel);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_BORDER);
glBegin(GL_POLYGON);
for(i=0; i<360; ++i) {
glTexCoord2f((cos((i)*M_PI/180)+1)/2, (sin((i)*M_PI/180)+1)/2);
glVertex2f(rad*cos((i)*M_PI/180), rad*sin((i)*M_PI/180));
}
glEnd();*/
glPopMatrix();
//glRotatef(angleRotated,0,0,1);
//glPopMatrix();
}
/* DRAW ENEMY
* funzione che disegna le navette nemiche caricate come obj
* model modello del nemico caricato
* pos posizione del nemico
* direcion (r3) orientazione (versore direzione di movimento)
*
*/
GLvoid drawEnemy(GLMmodel* model, Point3 pos, Point3 r3){
// vettore temporaneo: ci serve per definire una terna di assi ortogonali tra loro di cui uno di essi e' r3
Point3 temp;
temp.x=1;
temp.y=1;
temp.z=1;
// CI TROVIAMO LA TERNA DI ASSI ORTOGONALI TRA LORO: r1,r2,r3
// normalizziamo r3, anche se dovrebbe essere gia' stato normalizzato
r3=Normalize(r3);
// il prodotto esterno del vettore 'r3' per un qualsiasi vettore 'temp', mi fornisce il vettore 'r1' ortogonale a r3
Point3 r1=Normalize(Cross(r3, temp));
// ci troviamo il versore r2, ortogonale a 'r1' e quindi anche a 'r3'
Point3 r2=Normalize(Cross(r3,r1));
// ci creiamo un vettore che definisce la matrice (4x4) di rototraslazione che dobbiamo applicare
/* MATRICE DI ROTO-TRASLAZIONE
Mappatura indici del vettore sulla matrice:
0 1 2 3
4 5 6 7
8 9 10 11
12 13 14 15
POSIZIONI:
0:2 coordinate di r1 (prime tre posizioni della prima riga)
4:6 coordinate di r2 (prime tre posizioni della seconda riga)
8:10 coordinate di r3 (prime tre posizioni della terza riga)
12:14 coordinate della posizione (prime tre posizioni della quarta riga)
3,7,11 impostate a 0 (prime tre posizioni dell'ultima colonna)
15 impostata a 1
*/
GLfloat r[16];
r[0]=r1.x;
r[1]=r1.y;
r[2]=r1.z;
r[4]=r2.x;
r[5]=r2.y;
r[6]=r2.z;
r[8]=r3.x;
r[9]=r3.y;
r[10]=r3.z;
r[3]=0;
r[7]=0;
r[11]=0;
r[12]=pos.x;
r[13]=pos.y;
r[14]=pos.z;
r[15]=1;
/*glDisable(GL_LIGHTING);
glPushAttrib(GL_ALL_ATTRIB_BITS);
glPushMatrix();
glEnable(GL_LIGHT0);
glEnable(GL_LIGHT1);
glEnable(GL_LIGHT2);
glEnable(GL_COLOR_MATERIAL); // abilita il materiale
glColorMaterial(GL_FRONT, GL_EMISSION); // tipo di materiale
*/
glPushMatrix();
// applichiamo la roto-traslazione
glMultMatrixf(r);
if(!freezeShip)
angleEnemy += 0.896000;
glRotatef(angleEnemy, 0, 0, 1);
glmDraw(model, GLM_SMOOTH | GLM_MATERIAL);
//glmDraw(model, GLM_SMOOTH|GLM_TEXTURE|GLM_MATERIAL);
glPopMatrix();
/*
glDisable(GL_COLOR_MATERIAL); // disabilita il materiale
glDisable(GL_LIGHT2);
glDisable(GL_LIGHT1);
glDisable(GL_LIGHT0);
glPopMatrix();
glPopAttrib();
//glEnable(GL_LIGHTING);}
*/
}
void LoadSelectionModels()
{
//Setup Teapot
SelectTeapot = glmReadOBJ( "./models/teapot.obj" );
glmUnitize( SelectTeapot );
glmFacetNormals( SelectTeapot );
glmVertexNormals( SelectTeapot, 180 );
TeapotList = glGenLists(1);
glNewList(TeapotList,GL_COMPILE);
glmDraw( SelectTeapot, GLM_SMOOTH );
glEndList();
//Setup Triceratops
SelectTriceratops = new HalfEdgeModel( "./models/triceratops.hem", TYPE_HEM_FILE );
if (!SelectTriceratops->IsValid()) printf( "triceratops.hem not loaded!\n" );
TriceratopsList = SelectTriceratops->CreateOpenGLDisplayList(USE_TRIANGLES | WITH_NORMALS);
//Setup Door
SelectDoor = glmReadOBJ( "./models/selection/door.obj" );
glmUnitize( SelectDoor );
glmFacetNormals( SelectDoor );
glmVertexNormals( SelectDoor, 180 );
DoorList = glGenLists(1);
glNewList(DoorList,GL_COMPILE);
glmDraw( SelectDoor, GLM_SMOOTH );
glEndList();
//Setup Fridge
SelectFridge = glmReadOBJ( "./models/selection/fridge1.obj" );
glmUnitize( SelectFridge );
glmFacetNormals( SelectFridge );
glmVertexNormals( SelectFridge, 180 );
FridgeList = glGenLists(1);
glNewList(FridgeList,GL_COMPILE);
glmDraw( SelectFridge, GLM_SMOOTH );
glEndList();
//Setup SinkStand
SelectSinkStand = glmReadOBJ( "./models/selection/sinkstand.obj" );
glmUnitize( SelectSinkStand );
glmFacetNormals( SelectSinkStand );
glmVertexNormals( SelectSinkStand, 180 );
SinkStandList = glGenLists(1);
glNewList(SinkStandList,GL_COMPILE);
glmDraw( SelectSinkStand, GLM_SMOOTH );
glEndList();
//Setup Sink
SelectSink = glmReadOBJ( "./models/selection/sink.obj" );
glmUnitize( SelectSink );
glmFacetNormals( SelectSink );
glmVertexNormals( SelectSink, 180 );
SinkList = glGenLists(1);
glNewList(SinkList,GL_COMPILE);
glmDraw( SelectSink, GLM_FLAT);
glEndList();
//Setup Table
SelectTable = glmReadOBJ( "./models/selection/table1.obj" );
glmUnitize( SelectTable );
glmFacetNormals( SelectTable );
glmVertexNormals( SelectTable, 180 );
TableList = glGenLists(1);
glNewList(TableList,GL_COMPILE);
glmDraw( SelectTable, GLM_SMOOTH );
glEndList();
//Setup Chair
SelectChair = glmReadOBJ( "./models/selection/chair1.obj" );
glmUnitize( SelectChair );
glmFacetNormals( SelectChair );
glmVertexNormals( SelectChair, 180 );
ChairList = glGenLists(1);
glNewList(ChairList,GL_COMPILE);
glmDraw( SelectChair, GLM_SMOOTH );
glEndList();
//Setup Sideboard
SelectSideboard = glmReadOBJ( "./models/selection/sideboard.obj" );
glmUnitize( SelectSideboard );
glmFacetNormals( SelectSideboard );
glmVertexNormals( SelectSideboard, 180 );
SideboardList = glGenLists(1);
glNewList(SideboardList,GL_COMPILE);
glmDraw( SelectSideboard, GLM_FLAT );
glEndList();
//Setup Microwave
SelectMicrowave = glmReadOBJ( "./models/selection/microwave.obj" );
glmUnitize( SelectMicrowave );
glmFacetNormals( SelectMicrowave );
glmVertexNormals( SelectMicrowave, 180 );
MicrowaveList = glGenLists(1);
glNewList(MicrowaveList,GL_COMPILE);
glmDraw( SelectMicrowave, GLM_SMOOTH );
glEndList();
//Setup Cabinet
SelectCabinet = glmReadOBJ( "./models/selection/cabinet.obj" );
glmUnitize( SelectCabinet );
glmFacetNormals( SelectCabinet );
glmVertexNormals( SelectCabinet, 180 );
CabinetList = glGenLists(1);
glNewList(CabinetList,GL_COMPILE);
glmDraw( SelectCabinet, GLM_SMOOTH );
glEndList();
}
void Player::forceRender() {
glPushMatrix();
GLfloat emission[] = { 0.5f, 0.5f, 0.5f, 1.f };
glMaterialfv(GL_FRONT_AND_BACK, GL_EMISSION, emission);
glColor3f(1.f, 1.f, 1.f);
glTranslatef((GLfloat) (std::abs(current.x)), -current.y*2, (GLfloat) (std::abs(current.z)));
glRotatef(-current.roty, 0.f, 1.f, 0.f);
glScalef(0.5f, 0.5f, 0.5f);
//glTranslatef(-0.5f, 0.0f, -0.5f);
glmDraw(playerModel, GLM_SMOOTH | GLM_MATERIAL | GLM_TEXTURE);
GLfloat noEmission[] = { 0.f, 0.f, 0.f, 1.f };
glMaterialfv(GL_FRONT_AND_BACK, GL_EMISSION, noEmission);
glPopMatrix();
/*glPushMatrix();
glScalef(1.0f, 0.5f, 1.0f);
glTranslatef((GLfloat) (std::abs(current.x)), -current.y*2, (GLfloat) (std::abs(current.z)));
glRotatef(-current.roty, 0.f, 1.f, 0.f);
glTranslatef(-0.5f, 0.0f, -0.5f);
glBegin(GL_QUADS);
glColor3f (1.0f,0.0f,0.0f);
glTexCoord2f( 1.f, 0.f);
glVertex3f ( 0.f, 0.f, 0.f);
glTexCoord2f( 1.f, 1.f);
glVertex3f ( 0.f, 0.f, 1.f);
glTexCoord2f( 0.f, 1.f);
glVertex3f ( 0.f,-1.f, 1.f);
glTexCoord2f( 0.f, 0.f);
glVertex3f ( 0.f,-1.f, 0.f);
glTexCoord2f( 1.f, 1.f);
glVertex3f ( 1.f, 0.f, 1.f);
glTexCoord2f( 1.f, 0.f);
glVertex3f ( 1.f, 0.f, 0.f);
glTexCoord2f( 0.f, 0.f);
glVertex3f ( 1.f,-1.f, 0.f);
glTexCoord2f( 0.f, 1.f);
glVertex3f ( 1.f,-1.f, 1.f);
glTexCoord2f( 1.f, 1.f);
glVertex3f ( 1.f, 0.f, 1.f);
glTexCoord2f( 0.f, 1.f);
glVertex3f ( 0.f, 0.f, 1.f);
glTexCoord2f( 0.f, 0.f);
glVertex3f ( 0.f,-1.f, 1.f);
glTexCoord2f( 1.f, 0.f);
glVertex3f ( 1.f,-1.f, 1.f);
glTexCoord2f( 0.f, 1.f);
glVertex3f ( 0.f, 0.f, 0.f);
glTexCoord2f( 1.f, 1.f);
glVertex3f ( 1.f, 0.f, 0.f);
glTexCoord2f( 1.f, 0.f);
glVertex3f ( 1.f,-1.f, 0.f);
glTexCoord2f( 0.f, 0.f);
glVertex3f ( 0.f,-1.f, 0.f);
glVertex3f ( 0.f, 0.f, 0.f);
glVertex3f ( 1.f, 0.f, 0.f);
glVertex3f ( 1.f, 0.f, 1.f);
glVertex3f ( 0.f, 0.f, 1.f);
glEnd();
glPopMatrix();*/
}
void ObjModel::draw()
{
glmDraw(objModel, GLM_SMOOTH);
}
void display(void)
{
static char s[256], t[32];
static char* p;
static int frames = 0;
glClearColor(1.0, 1.0, 1.0, 1.0);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glPushMatrix();
glTranslatef(pan_x, pan_y, 0.0);
gltbMatrix();
if(!start) {
#if 0 // glmDraw() performance test
if (material_mode == 0) {
if (facet_normal)
glmDraw(model, GLM_FLAT);
else
glmDraw(model, GLM_SMOOTH);
} else if (material_mode == 1) {
if (facet_normal)
glmDraw(model, GLM_FLAT | GLM_COLOR);
else
glmDraw(model, GLM_SMOOTH | GLM_COLOR);
} else if (material_mode == 2) {
if (facet_normal)
glmDraw(model, GLM_FLAT | GLM_MATERIAL);
else
glmDraw(model, GLM_SMOOTH | GLM_MATERIAL);
}
#else
glCallList(model_list);
#endif
glDisable(GL_LIGHTING);
if (bounding_box) {
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glEnable(GL_BLEND);
glEnable(GL_CULL_FACE);
glColor4f(1.0, 0.0, 0.0, 0.25);
glutSolidCube(2.0);
glDisable(GL_BLEND);
}
} else {
//glDisable(GL_LIGHTING);
newDrawMechanism();
glEnable(GL_LIGHTING);
}
glPopMatrix();
if (stats) {
/* XXX - this could be done a _whole lot_ faster... */
int height = glutGet(GLUT_WINDOW_HEIGHT);
glColor3ub(0, 0, 0);
sprintf(s, "%s\n%d vertices\n%d triangles\n%d normals\n"
"%d texcoords\n%d groups\n%d materials",
model->pathname, model->numvertices, model->numtriangles,
model->numnormals, model->numtexcoords, model->numgroups,
model->nummaterials);
shadowtext(5, height-(5+18*1), s);
}
/* spit out frame rate. */
frames++;
if (frames > NUM_FRAMES) {
sprintf(t, "%g fps", frames/elapsed());
frames = 0;
}
if (performance) {
shadowtext(5, 5, t);
}
glutSwapBuffers();
glEnable(GL_LIGHTING);
}
void ofxGLM::draw() {
//cout << render_mode << "," << GLM_TEXTURE << endl;
glmDraw(model, render_mode);
}
