PDA

View Full Version : Gl_ortho over a 3d scene



karinonava
11-21-2014, 11:57 AM
Hi thank you for stopping by the question I'm new to openGl and I'm trying to do a video Game , i want to put a ortho cam over a 3d scene so i can put the score and lives but when i put the ortho cam the 3d scene is ruined. ill attach my code under sorry for the mess but I'm new.


#include <stdlib.h>
#include <stdio.h>
#include <math.h>
#include "targa.h"
#include "glm.h"
#include <time.h>
#ifdef __APPLE__
#include <GLUT/glut.h>
#else
#include <GL/glut.h>
#endif
bool* teclaApretada = new bool[256];
int cont=0;


// angulo de la camara
float angle=0.0;
// direccion
float lx=0.0f,lz=-1.0f;
// posicion
float x=50.0f,z=-1.0f, y = 1.5f;
int i = 0;
GLubyte posColision = 0;
//balas
int numbala;
GLMmodel* balon;

int pantallaSelec = 1;

int vidaJugador = 5;

float deltaAngle = 0.0f;
GLubyte *data,*data2,*dataMapa,*data3;

struct bala{
float velocidad = 0.5;
float x, z;
float lx, lz;
bool active = false;
};

bool colocoEnemigos = false;

struct enemigo{
int vida;
float x, z;
float lx, lz;
bool vivo = true;
float angulo;
};



struct bala balas[99];
struct enemigo enemigos[10];



void dibujaBala(float lx, float lz, float x, float z);


void reshape(int w, int h) {
if(pantallaSelec == 0){
glViewport(0, 0, w, h); //actualizar la ventana
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(0, 2, 0, 2, -10, 10);

}else if(pantallaSelec == 1){
glViewport(0, 0, w, h);
if (h == 0)
h = 1;
float ratio = w * 1.0 / h;
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(45.0f, ratio, 0.1f, 100.0f);
glMatrixMode(GL_MODELVIEW);
}

}

void init(){

glEnable(GL_TEXTURE_2D);

GLint x,y,d;
//cargo en texture 1 pido
data=LoadTGA("./texturas/tierra.tga",&x,&y,&d);
glBindTexture(GL_TEXTURE_2D,1);
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
glTexImage2D(GL_TEXTURE_2D,0,GL_RGB,x,y,0, GL_RGB,GL_UNSIGNED_BYTE,data);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);

glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
delete data;
// fin cargo piso

//inicio cargo paredes
data2=LoadTGA("./texturas/pared.tga",&x,&y,&d);
glBindTexture(GL_TEXTURE_2D,2);
glPixelStorei(GL_UNPACK_ALIGNMENT, 2);
glTexImage2D(GL_TEXTURE_2D,0,GL_RGB,x,y,0, GL_RGB,GL_UNSIGNED_BYTE,data2);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
delete data2;

//fin cargo paredes

//inicio cargo menuPrincipal
data3=LoadTGA("./texturas/inicio.tga",&x,&y,&d);
glBindTexture(GL_TEXTURE_2D,3);
glPixelStorei(GL_UNPACK_ALIGNMENT, 3);
glTexImage2D(GL_TEXTURE_2D,0,GL_RGB,x,y,0, GL_RGB,GL_UNSIGNED_BYTE,data3);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
delete data3;

//fin cargo menuPrincipal

balon = glmReadOBJ("./objetos/test.obj");

dataMapa=LoadTGA("./texturas/laberinto.tga",&x,&y,&d);

GLubyte valor;
for( int idy=0 ; idy<y ;idy++ )
{
for( int idx=0 ; idx<y ;idx++ )
{
//int indice = idy*x*3 + idx*3 + 0;
valor = dataMapa[ idy*x*3 + idx*3 + 0 ];
//printf("%d:%d \n",indice,valor);
}
//printf("\n");
}

//delete dataMapa;


}

//------------------------------------------------

// Balas

//------------------------------------------------




void disparar(){
for (int i = 0; i<100; i++) {
if(balas[i].active == false){
numbala = i;
break;
}
else{
numbala = 999;
}
}

if(numbala != 999){
balas[numbala].active = true;
balas[numbala].lx = lx;
balas[numbala].lz = lz;
balas[numbala].x = x;
balas[numbala].z = z;
printf("entre a disparar");
//dibujaBala(balas[numbala].lx,balas[numbala].lz,balas[numbala].x,balas[numbala].z);
}else{
printf("ya no tienes balas");
}
}

//------------------------------------------------

// Enemigos

//------------------------------------------------

void colocarEnemigos(){
srand (time(NULL));
for(int i = 0; i < 4; i++){
enemigos[i].vida = 5;
enemigos[i].x = rand() % 100 + 1;
enemigos[i].z = (rand() % 100 + 1)*-1;
enemigos[i].angulo = rand() % 90 + 1;
printf("posX: %f, posZ: %f, ang: %f\n",enemigos[i].x,enemigos[i].z,enemigos[i].angulo);

}
}



//------------------------------------------------

// moverse mouse y teclado

//------------------------------------------------


void Keyboard(unsigned char key, int r, int y){
if(pantallaSelec == 0){
switch (key) {
case 's':
pantallaSelec = 1;
//glLoadIdentity();
}
}else if(pantallaSelec == 1){
int indice;
GLubyte valors;

switch (key) {
case 'a' :
teclaApretada[key] = true;
break;
case 'd' :
indice = floor((z)*-1)*100*3 + floor(x+lx+3.14)*3 + 0;
valors = dataMapa[ indice];
if(valors != 255){
printf("pared");
}else{
teclaApretada[key] = true;
}
break;
case 'w' :
indice = floor((z+lz)*-1)*100*3 + floor(x+lx)*3 + 0;
valors = dataMapa[ indice];
if(valors != 255){
printf("pared");
}else{
teclaApretada[key] = true;
}
printf("valorx: %f valorFlorx: %f valorz:%f valor: %d indice: %d\n",x,floor(x),floor(z*-1),valors,indice);
break;
case 's' :
indice = floor((z-lz)*-1)*100*3 + floor(x-lx)*3 + 0;
valors = dataMapa[ indice];
if(valors != 255){
printf("pared");
}else{
teclaApretada[key] = true;
}

break;
case' ':
teclaApretada[key] = true;
disparar();
break;
}
}
}

void KeyboardUp(unsigned char key, int r, int y){
if(pantallaSelec == 0){
}else if(pantallaSelec == 1){
switch (key) {
case 'a':
teclaApretada[key] = false;
break;
case 'd':
teclaApretada[key] = false;
break;
case 'w':
teclaApretada[key] = false;
break;
case 's':
teclaApretada[key] = false;
break;
case' ':
teclaApretada[key] = false;
break;
}
}
}




void moverse(){
int indice;
GLubyte valors;
float velocidad = 0.1f;
if (teclaApretada['w']) {
indice = floor((z+lz)*-1)*100*3 + floor(x+lx)*3 + 0;
valors = dataMapa[ indice];
if(valors != 255){
printf("pared");
}else{
x += lx * velocidad;
z += lz * velocidad;
}
printf("valorx: %f valorFlorx: %f valorz:%f valor: %d indice: %d\n",x,floor(x),floor(z*-1),valors,indice);

}
if (teclaApretada['s']) {
indice = floor((z-lz)*-1)*100*3 + floor(x-lx)*3 + 0;
valors = dataMapa[ indice];
if(valors != 255){
printf("pared");
}else{
x -= lx * velocidad;
z -= lz * velocidad;
}
printf("valorx: %f valorFlorx: %f valorz:%f valor: %d indice: %d\n",x,floor(x),floor(z*-1),valors,indice);

}
if (teclaApretada['d']) {
//angle += 0.003f;
velocidad = .01;
indice = floor((z)*-1)*100*3 + floor(x+lx+3.14)*3 + 0;
valors = dataMapa[ indice];
if(valors != 255){
printf("pared");
}else{
x += (lx+3.14) * velocidad;
}

printf("angle:%f\n",angle);

}
if (teclaApretada['a']) {
velocidad = .01;
indice = floor((z)*-1)*100*3 + floor(x+lx-3.14)*3 + 0;
valors = dataMapa[ indice];
if(valors != 255){
printf("pared");
}else{
x += (lx-3.14) * velocidad;
}



//lx = sin(angle);
//lz = -cos(angle);
//printf("angle:%f\n",angle);
//printf("lx: %f\n lz:%f\n",lx,lz);
}

}

void mouseMove(int x, int y) {

//update deltaAngle
deltaAngle = (x-721)*(.00436/*157/35950*/);
//update camera's direction
lx = sin(angle + deltaAngle);
lz = -cos(angle + deltaAngle);
}


void dibujaParedes(float xInicial, float zInicial, float xFinal, float zFinal){
glBegin(GL_QUADS);
glTexCoord2f(0,1);
glVertex3f(xInicial, 4, zInicial);//arriba izq
glTexCoord2f(0,0);
glVertex3f(xInicial, 0, zInicial);//abajo izq
glTexCoord2f(1,0);
glVertex3f(xFinal, 0, zFinal);//abajo der
glTexCoord2f(1,1);
glVertex3f(xFinal, 4, zFinal);//arriba der
glEnd();

}

void dibujaPiso(){
glBegin(GL_QUADS);
glTexCoord2f(0,0);
glVertex3f(0, 0.0f, 0);
glTexCoord2f(1,0);
glVertex3f(100.0f, 0.0f, 0);
glTexCoord2f(1,1);
glVertex3f(100.0f, 0.0f, -100.0f);
glTexCoord2f(0,1);
glVertex3f(0.0f, 0.0f, -100.0f);
}



//------------------------------------------------

// dibuja la pantalla de inicio

//------------------------------------------------
void principal(){

glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glLoadIdentity();

//glColor3f(1, 0, 0);

glBindTexture(GL_TEXTURE_2D,3);

glBegin(GL_QUADS);
glTexCoord2f(1, 1);
glVertex2f(-2, -2);
glTexCoord2f(0, 0);
glVertex2f(-2, 2);
glTexCoord2f(1, 0);
glVertex2f(2, 2);
glTexCoord2f(0, 1);
glVertex2f(2, -2);
glEnd();
//glutSolidCube(1.0);

}

void ataqueEnemigo(){
for (int i = 0; i < 3; i++) {
if (enemigos[i].vivo == true) {
float resX = enemigos[i].x - x;
float resZ = enemigos[i].z - z;
if(resX < .2 && resZ < .2 && resX > .1 && resZ < .1){
vidaJugador--;
x = x-1;
z = z- 1;
printf("me pego");
}
}
}
if(vidaJugador == 0){
printf("jugador Muerto");
}
}

void balasEnemigo(){
for (int i = 0 ; i < 99; i++) {
if(balas[i].active == true){
for (int j = 0; j < 3; j++) {
if (enemigos[j].vivo == true) {
float resX = enemigos[j].x - balas[i].x;
float resZ = enemigos[j].z - balas[i].z;
if(resX < .2 && resZ < .2 && resX > .1 && resZ < .1){
enemigos[j].vida--;
balas[i].active = false;
printf("le pegue\n");
if(enemigos[j].vida == 0){
enemigos[j].vivo = false;
}
}
}
}
}
}
}





//------------------------------------------------

// dibuja el juego

//------------------------------------------------

void game(){
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glMatrixMode(GL_MODELVIEW);


// Reset transformations
glLoadIdentity();
// Set the camera
gluLookAt( x, 1.0f, z,
x+lx, 1.0f, z+lz,
0.0f, 1.0f, 0.0f);
moverse();




glBindTexture(GL_TEXTURE_2D,1);
dibujaPiso();



glEnd();

//------------------------------------------------

// pared Perimetral

//------------------------------------------------

glBindTexture(GL_TEXTURE_2D,2);


dibujaParedes(0, 0, 100, 0);
dibujaParedes(0, 0, 0, -100);
dibujaParedes(100, 0, 100, -100);
dibujaParedes(0, -100, 100, -100);


if(colocoEnemigos == false){
colocarEnemigos();
colocoEnemigos = true;
}

for(int i = 0; i< 99; i++){
int indice;
GLubyte valors;
//glLoadIdentity();
if(balas[i].active == true){
//printf("entre a dibujar");
glColor3f(190, 190, 190);
glPushMatrix();
printf("posxbala: %f, pos zbala %f\n",balas[i].x,balas[i].z);
glTranslatef(balas[i].x, 0, balas[i].z);
glutSolidSphere(1, 50, 50);
balas[i].x += balas[i].lx * balas[i].velocidad;
balas[i].z += balas[i].lz * balas[i].velocidad;
indice = floor((balas[i].z+balas[i].lz)*-1)*100*3 + floor(balas[i].x+balas[i].lx)*3 + 0;
valors = dataMapa[ indice];
if(valors != 255){
balas[i].active = false;
printf("pared");
}

glPopMatrix();
}

}

for (int i = 0; i < 3 ; i++) {
int indice;
GLubyte valors;
if (enemigos[i].vivo == true) {
glPushMatrix();
glTranslatef(enemigos[i].x, 0, enemigos[i].z);
glmDraw(balon, GLM_TEXTURE | GLM_SMOOTH | GLM_MATERIAL);
//glutSolidCube(1.2);
//enemigos[i].x += sin(enemigos[i].angulo)*.01;
//enemigos[i].z += -cos(enemigos[i].angulo)*.01;
indice = floor((enemigos[i].z+-cos(enemigos[i].angulo)*.1))*100*3 + floor(balas[i].x+sin(enemigos[i].angulo)*.1)*3 + 0;
valors = dataMapa[ indice];
if(valors != 255){
//enemigos[i].vivo = false;
int angu = rand() % 90 + 1;
glRotatef(180, 0, 1, 0);
enemigos[i].angulo = 3.14;
//printf("pared");
}
glPopMatrix();
}
}

//checa las colisiones con los enemigos

balasEnemigo();
ataqueEnemigo();

/* glMatrixMode(GL_PROJECTION);
glPushMatrix();
glLoadIdentity();
glOrtho(-2, 2, -2, 2, -10, 10);
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
glLoadIdentity();
*/

}

void score(){
glMatrixMode(GL_PROJECTION);
glPushMatrix();
glOrtho(-2, 2, -2, 2, -10, 10);
glMatrixMode(GL_MODELVIEW);
glPushMatrix();

glBegin(GL_QUADS);
glColor3f(1.0, 0,0);
glTexCoord2f(1.0,1.0);
glVertex3f(-1.0, 2.0, 0);
glTexCoord2f(0.0,1.0);
glVertex3f(-2.0, 2.0, 0);
glTexCoord2f(0.0,0.0);
glVertex3f(-2.0, 1.5, 0);
glTexCoord2f(1.0,0.0);
glVertex3f(-1.0, 1.5, 0);
glEnd();


}


void Display(void) {
/*if(pantallaSelec == 0){
glLoadIdentity();
glPushMatrix();
principal();
glPopMatrix();
}else if(pantallaSelec == 1){*/
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glMatrixMode(GL_MODELVIEW);
game();
glPushMatrix();
glPopMatrix();
glLoadIdentity();
//}
glutSwapBuffers();
}





int main(int argc, char **argv) {

// init GLUT and create window
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_DEPTH | GLUT_DOUBLE | GLUT_RGBA);
glutInitWindowPosition(100,100);
glutInitWindowSize(1440,800);
glutCreateWindow("shooter");
init();




// register callbacks
glutDisplayFunc(Display);
glutReshapeFunc(reshape);
glutIdleFunc(Display);

// here are the new entries
glutKeyboardFunc(Keyboard);
glutKeyboardUpFunc(KeyboardUp);
glutPassiveMotionFunc(mouseMove);
init();
// enter GLUT event processing cycle

glutMainLoop();

return 1;
}