<repo_name>PedroHas98/ProjetoMS-La-Casa-de-Papel-<file_sep>/La casa de Papel/Geometria.h
#ifndef GEOMETRIA_H_INCLUDED
#define GEOMETRIA_H_INCLUDED

void Cilindro (int rdiv, int hdiv, float alt, float raio);
void TQuadrado (GLfloat alt, GLfloat lar, GLfloat ang);

#endif // GEOMETRIA_H_INCLUDED
<file_sep>/La casa de Papel/Geometria.c
#include "../headers/Textura.h"
#include "../headers/Textura.h"

#include <GL/glut.h>
#include <GL/glu.h>
#include <stdlib.h>
#include <stdio.h>
#include <math.h>

void Cilindro (GLint rdiv, GLint hdiv, GLfloat alt, GLfloat raio)
{
    int i, j;

    GLfloat delta, theta, theta_;
    GLfloat alt_, delta_H;

    delta = (2*M_PI)/rdiv;
    delta_H = alt/hdiv;

    for(i = 0; i < rdiv; i++)
    {
        theta = i * delta;
        theta_ = theta + delta;

        glBegin(GL_LINE_LOOP);
            glVertex3f(0.0, alt, 0.0);
            glVertex3f(raio*cos(theta), alt, raio*sin(theta));
            glVertex3f(raio*cos(theta+delta), alt, raio*sin(theta+delta));
        glEnd();

        for (j = 0; j < hdiv; j++)
        {
            alt_ = j * delta_H;

            glBegin(GL_QUADS);

                	glTexCoord2f(theta/2*M_PI, (alt_)/alt);
                glVertex3f(raio*cos(theta), alt_, raio*sin(theta));

                	glTexCoord2f(theta/2*M_PI, (alt_+delta_H)/alt);
                glVertex3f(raio*cos(theta), alt_+delta_H, raio*sin(theta));

                	glTexCoord2f(theta_/2*M_PI, (alt_+delta_H)/alt);
                glVertex3f(raio*cos(theta_), alt_+delta_H, raio*sin(theta+delta));

                	glTexCoord2f(theta_/2*M_PI, (alt_)/alt);
                glVertex3f(raio*cos(theta_), alt_, raio*sin(theta+delta));

            glEnd();
        }

        glBegin(GL_LINE_LOOP);
            glVertex3f(0.0,0.0,0.0);
            glVertex3f(raio*cos(theta), 0.0, raio*sin(theta));
            glVertex3f(raio*cos(theta+delta), 0.0, raio*sin(theta+delta));
        glEnd();
    }
}


void TQuadrado (GLfloat lar, GLfloat alt, GLfloat ang)
{
	glRotatef(ang, 0, 1, 0);
	glBegin(GL_QUADS);
			glTexCoord2f(0.0, 0.0);
		glVertex3f(-lar/2.0, 0, 0);
			glTexCoord2f(0.0, 1.0);
		glVertex3f(-lar/2.0, alt, 0);
			glTexCoord2f(1.0, 1.0);
		glVertex3f(lar/2.0, alt, 0);
			glTexCoord2f(1.0, 0.0);
		glVertex3f(lar/2.0, 0, 0);
	glEnd();
}
<file_sep>/La casa de Papel/main.cpp
#include <GL/glut.h>
#include <GL/glu.h>
#include <stdlib.h>
#include <stdio.h>
#include <math.h>


#include "headers/LaCasa.h"
#include "headers/Textura.h"


#define WIDTH 1300
#define HEIGHT 720
#define FPS 16


float theta = 0.0;
GLuint texturas[20];
GLuint quadros[4];
static float posx = 0.0, posz = -30.0, posy = -3.0, angle = 0.0;
enum tMode {TRANSLATE = 0, SCALE} transformMode;

float springiness = 50;

void init(void);
void initTex(void);
void display(void);
void defineIlumination(void);
void keyboard(unsigned char key, int x, int y);
void keyboard2(int key, int moposx, int mouse_y);
void timer (int id);
void idle (void);
void initTex(void);
void mouseFunc(int button, int state, int x, int y);
void mouseMotionFunc(int x, int y);

int nWindowID;

// atributos de camera
float viewerPosition[3] = { 0.0, 0.0, -2.0 };
float viewerDirection[3] = { 0.0, 0.0, 0.0 };
float viewerUp[3] = { 0.0, 1.0, 0.0 };

// valores de rotação para a navegação
float navigationRotation[3]	= { 0.0, 0.0, 0.0 };

// parametros do contador de frames
char pixelstring[30];
int cframe = 0;
int time = 0;
int timebase = 0;

// parâmetros para navegação

// posição do mouse qauando pressionado
int mousePressedX = 0, mousePressedY = 0;
float lastXOffset = 0.0, lastYOffset = 0.0, lastZOffset = 0.0;
// estados do botão do mouse
int leftMouseButtonActive = 0, middleMouseButtonActive = 0, rightMouseButtonActive = 0;
// alterar estado
int shiftActive = 0, altActive = 0, ctrlActive = 0;



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

    glutInit(&argc, argv);
    glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
    glutInitWindowSize(WIDTH, HEIGHT);
    glutInitWindowPosition(100, 100);
    glutCreateWindow("Casa da Moeda");
    glutDisplayFunc(display);
    glutKeyboardFunc(keyboard);
    glutSpecialFunc(keyboard2);
    glutMouseFunc(mouseFunc);
	glutMotionFunc(mouseMotionFunc);
    glutIdleFunc(idle);
    init();
    glutMainLoop();

    return 0;

}

void init (void)
{

    transformMode = TRANSLATE;

    initTex();
    glClearColor(0.50980392156862745098039215686275,
				 0.77647058823529411764705882352941,
				 0.91372549019607843137254901960784, 1);
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    gluPerspective(45.0f, (float)WIDTH/(float)HEIGHT, 1.0f, 100.0f);
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
    glTranslatef(posx, posy, posz);
    glMatrixMode(GL_MODELVIEW);

	glEnable(GL_COLOR_MATERIAL);
	glEnable(GL_LIGHTING);
	glEnable(GL_LIGHT0);
	glEnable(GL_DEPTH_TEST);
	glShadeModel(GL_SMOOTH);

}

void initTex (void)
{

    glEnable(GL_DEPTH_TEST);
    glEnable(GL_TEXTURE_2D);
	glEnable(GL_COLOR_MATERIAL);
	glPixelStorei(GL_UNPACK_ALIGNMENT, 1);

	glGenTextures(3, texturas);

	glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);

	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_MIN_FILTER, GL_LINEAR);
    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);

    texturas[0] = carregaBmp("textura/lacasateto.bmp");
    texturas[1] = carregaBmp("textura/mpar.bmp");
    texturas[2] = carregaBmp("textura/chaointerior.bmp");
    texturas[3] = carregaBmp("textura/asfalto.bmp");
    texturas[4] = carregaBmp("textura/porta.bmp");
    texturas[5] = carregaBmp("textura/janeladecima.bmp");
    texturas[6] = carregaBmp("textura/ceu.bmp");
	texturas[7] = carregaBmp("textura/janela.bmp");
    texturas[8] = carregaBmp("textura/Parede.bmp");
    texturas[9] = carregaBmp("textura/Topo.bmp");
	texturas[10] = carregaBmp("textura/quadro2.bmp");
	texturas[11] = carregaBmp("textura/escada.bmp");
    texturas[12] = carregaBmp("textura/textescada.bmp");
    texturas[13] = carregaBmp("textura/images1.bmp");
    texturas[14] = carregaBmp("textura/bancada.bmp");
    texturas[15] = carregaBmp("textura/quadronovo1.bmp");
    texturas[16] = carregaBmp("textura/quadron3.bmp");
    texturas[17] = carregaBmp("textura/lateralescada2.bmp");
    texturas[18] = carregaBmp("textura/paredesechao.bmp");
    texturas[19] = carregaBmp("textura/janelinha.bmp");
}

void timer (int id)
{

    theta += 0.1;
    glutPostRedisplay();
    glutTimerFunc(FPS, timer, 0);

}

void idle (void)
{
    theta = 0.1 * glutGet(GLUT_ELAPSED_TIME);
    glutSwapBuffers();
    glutPostRedisplay();

}

void display (void)
{
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
	glEnable(GL_DEPTH_TEST);
	glDepthFunc(GL_LESS);
    glMatrixMode(GL_MODELVIEW);

    glLoadIdentity();

    GLfloat	lightpos[4] = { 5.0, 15.0, 10.0, 1.0 };
	glLightfv(GL_LIGHT0, GL_POSITION, lightpos);

	glTranslatef(viewerPosition[0], viewerPosition[1], viewerPosition[2]);

	// adicionar rotação de navegação

	glRotatef(navigationRotation[0], 1.0f, 0.0f, 0.0f);
	glRotatef(navigationRotation[1], 0.0f, 1.0f, 0.0f);

    Cenario (texturas, posx, posz, theta);
    LaCasa(texturas, quadros, theta);

    theta += 0.000001;
    glutPostRedisplay();

    glFlush();

}

void keyboard (unsigned char key,int x, int y)
{

    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    gluPerspective(45.0f, (float)WIDTH/(float)HEIGHT, 1.0f, 100.0f);

    switch(key)
	{
        case 27:
          exit(0);
        break;
        case 't':
        case 'T':
            transformMode = TRANSLATE;
        break;
        case 'c':
        case 'C':
            transformMode = SCALE;
        break;
        case 'w':
        case 'W':
            posz += 0.5*cos(M_PI*angle/180.0);
            posx += 0.5*sin(M_PI*angle/180.0);
        break;
        case 's':
        case 'S':
            posz -= 0.5*cos(M_PI*angle/180.0);
            posx -= 0.5*sin(M_PI*angle/180.0);
        break;
        case 'q':
        case 'Q':
            posz += -0.5*sin(M_PI*angle/180.0);
            posx += 0.5*cos(M_PI*angle/180.0);
        break;
        case 'e':
        case 'E':
            posz -= -0.5*sin(M_PI*angle/180.0);
            posx -= 0.5*cos(M_PI*angle/180.0);
        break;
    	case 'r':
        case 'R':
            posy -= -0.5*sin(M_PI*angle/180.0);
            posy -= 0.5*cos(M_PI*angle/180.0);
		break;
		case 'f':
        case 'F':
            posy += -0.5*sin(M_PI*angle/180.0);
            posy += 0.5*cos(M_PI*angle/180.0);
		break;
        case 'a':
        case 'A':
            angle += 3;
        break;
        case 'd':
        case 'D':
            angle -= 3;
        break;

    }

    glRotatef(-angle, 0.0, 1.0, 0.0);
    glTranslatef(posx, posy, posz);

}

void keyboard2(int key, int moposx, int mouse_y)
{

    int x=0, y=0, z=0;

    switch(key){
        case GLUT_KEY_PAGE_UP:
            posz++;
        break;
        case GLUT_KEY_PAGE_DOWN:
            posz--;
        break;
    }

    glMatrixMode(GL_PROJECTION);
    switch(transformMode){
        case TRANSLATE:
            glTranslatef(x, y, z);
        break;
        case SCALE:
            glScalef(1.0+x/10.0, 1.0+y/10.0, 1.0+z/10.0);
        break;
    }
    glutPostRedisplay();

}


// mouse callback

void mouseFunc(int button, int state, int x, int y)
{

	// recuperar os modificadores

	switch (glutGetModifiers())
	{
		case GLUT_ACTIVE_SHIFT:
			shiftActive = 1;
			break;
		case GLUT_ACTIVE_ALT:
			altActive	= 1;
			break;
		case GLUT_ACTIVE_CTRL:
			ctrlActive	= 1;
			break;
		default:
			shiftActive = 0;
			altActive	= 0;
			ctrlActive	= 0;
			break;
	}

	// recuperar os botões do mouse

	if (button == GLUT_LEFT_BUTTON){
		if (state == GLUT_DOWN)
		{
			leftMouseButtonActive += 1;
		}
		else
			leftMouseButtonActive -= 1;
	}

	else if (button == GLUT_MIDDLE_BUTTON){
		if (state == GLUT_DOWN)
		{
			middleMouseButtonActive += 1;
			lastXOffset = 0.0;
			lastYOffset = 0.0;
		}
		else
			middleMouseButtonActive -= 1;
	}

	else if (button == GLUT_RIGHT_BUTTON){
		if (state == GLUT_DOWN)
		{
			rightMouseButtonActive += 1;
			lastZOffset = 0.0;
		}
		else
			rightMouseButtonActive -= 1;
	}

	mousePressedX = x;
	mousePressedY = y;

}

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

void mouseMotionFunc(int x, int y)
{

	float xOffset = 0.0, yOffset = 0.0, zOffset = 0.0;

	// navegação

	if (leftMouseButtonActive)
	{

		navigationRotation[0] += ((mousePressedY - y) * 180.0f) / 2000.0f;
		navigationRotation[1] += ((mousePressedX - x) * 180.0f) / 2000.0f;

		mousePressedY = y;
		mousePressedX = x;
	}

	// panning
	else if (middleMouseButtonActive)
	{

		xOffset = (mousePressedX + x);
		if (!lastXOffset == 0.0) {
			viewerPosition[0]	-= (xOffset - lastXOffset) / 32.0;
			viewerDirection[0]	-= (xOffset - lastXOffset) / 32.0;
		}
		lastXOffset = xOffset;

		yOffset = (mousePressedY + y);
		if (!lastYOffset == 0.0) {
			viewerPosition[1]	+= (yOffset - lastYOffset) / 32.0;
			viewerDirection[1]	+= (yOffset - lastYOffset) / 32.0;
		}
		lastYOffset = yOffset;

	}

	// profundidade do movimento

	else if (rightMouseButtonActive)
	{
		zOffset = (mousePressedX + x);
		if (!lastZOffset == 0.0)
		{
			viewerPosition[2] -= (zOffset - lastZOffset) / 30.0;
			viewerDirection[2] -= (zOffset - lastZOffset) / 30.0;
		}
		lastZOffset = zOffset;
	}
}
<file_sep>/La casa de Papel/LaCasa.c
#include "../headers/LaCasa.h"
#include "../headers/Textura.h"
#include "../headers/Geometria.h"

#include <GL/glut.h>
#include <GL/glu.h>
#include <stdlib.h>
#include <stdio.h>
#include <math.h>

GLint pb[6][4] = {

    {0,1,2,3}, {3,2,6,7},{7,6,5,4},
    {4,5,1,0}, {5,6,2,1},{7,4,0,3}

};
GLfloat v[8][3];
static void define (float l, float c, float a)
{
	v[0][0] = v[1][0] = v[2][0] = v[3][0] = -l/2.0;
    v[4][0] = v[5][0] = v[6][0] = v[7][0] = l/2.0;
    v[0][1] = v[1][1] = v[4][1] = v[5][1] = 0;
    v[2][1] = v[3][1] = v[6][1] = v[7][1] = a;
    v[0][2] = v[3][2] = v[4][2] = v[7][2] = c/2.0;
    v[1][2] = v[2][2] = v[5][2] = v[6][2] = -c/2.0;

}

GLint faces[6][4] = {
 {0, 1, 2, 3}, {3, 2, 6, 7}, {7, 6, 5, 4},
 {4, 5, 1, 0}, {5, 6, 2, 1}, {7, 4, 0, 3}
};

GLfloat v1[8][3] = {
{-2.5, -1.5, 9}, {-2.5, -1.5, -9},
{-2.5, 1.5, -9}, {-2.5, 1.5, 9},
{2.5, -1.5, 9}, {2.5, -1.5, -9},
{2.5, 0.0, -9}, {2.5, 0.0, 9}
};

GLfloat v3[8][3] = {
{-0.5, -0.5, 1}, {-0.5, -0.5, -1},
{-0.5, 0.5, -1}, {-0.5, 0.5, 1},
{0.5, -0.5, 1}, {0.5, -0.5, -1},
{0.5, 0.0, -1}, {0.5, 0.0, 1}
};

void drawCube(int fatorr)
{
 int i;
 glPushMatrix();
  glColor3f(255,193,37);
 glTranslatef(-6.4, 1.0, 6.5);
 glRotatef(180, 180, 1.0, 0.0);
 for (i = 0; i < 6; i++) {
   glBegin(GL_QUADS);
   glTexCoord2f(0.0, 0.0);
   glVertex3fv(&v1[faces[i][0]][0]);

   glTexCoord2f(0.0, fatorr * 1.0);
   glVertex3fv(&v1[faces[i][1]][0]);

   glTexCoord2f(fatorr * 1.0, fatorr *  1.0);
   glVertex3fv(&v1[faces[i][2]][0]);

   glTexCoord2f(fatorr * 1.0, 0.0);
   glVertex3fv(&v1[faces[i][3]][0]);
   glEnd();
 }
 glPopMatrix();
}

void drawCube2(int fatorr)
{
 int i;
 glPushMatrix();
 glTranslatef(6.4, 1.0, 6.5);
 glRotatef(-180, 0, 0, 0);
 for (i = 0; i < 6; i++) {
   glBegin(GL_QUADS);
   glTexCoord2f(0.0, 0.0);
   glVertex3fv(&v1[faces[i][0]][0]);

   glTexCoord2f(0.0, fatorr * 1.0);
   glVertex3fv(&v1[faces[i][1]][0]);

   glTexCoord2f(fatorr * 1.0, fatorr *  1.0);
   glVertex3fv(&v1[faces[i][2]][0]);

   glTexCoord2f(fatorr * 1.0, 0.0);
   glVertex3fv(&v1[faces[i][3]][0]);
   glEnd();
 }
 glPopMatrix();
}

void Bancada1(int fatorr)
{
 int i;
 glPushMatrix();
 glRotatef(-180, 0, 0, 0);
 for (i = 0; i < 6; i++) {
   glBegin(GL_QUADS);
   glTexCoord2f(0.0, 0.0);
   glVertex3fv(&v3[faces[i][0]][0]);
	glTexCoord2f(0.0, fatorr * 1.0);
   glVertex3fv(&v3[faces[i][1]][0]);
	glTexCoord2f(fatorr * 1.0, fatorr *  1.0);
   glVertex3fv(&v3[faces[i][2]][0]);
	glTexCoord2f(fatorr * 1.0, 0.0);
   glVertex3fv(&v3[faces[i][3]][0]);
   glEnd();

 }
 glPopMatrix();
}

void Bancada2(int fatorr)
{
 int i;
 glPushMatrix();
 glRotatef(-180, 180, 0, 0);
 for (i = 0; i < 6; i++) {
   glBegin(GL_QUADS);
   glTexCoord2f(0.0, 0.0);
   glVertex3fv(&v3[faces[i][0]][0]);
	glTexCoord2f(0.0, fatorr * 1.0);
   glVertex3fv(&v3[faces[i][1]][0]);
	glTexCoord2f(fatorr * 1.0, fatorr *  1.0);
   glVertex3fv(&v3[faces[i][2]][0]);
	glTexCoord2f(fatorr * 1.0, 0.0);
   glVertex3fv(&v3[faces[i][3]][0]);
   glEnd();
 }
 glPopMatrix();
}

void Base (float largura, float comprimento, float altura, int fatorr)
{
   int i;
   define(largura, comprimento, altura);
   	   for(i = 0; i < 6; i++){
        glBegin(GL_QUADS);
   			glTexCoord2f(0.0, 0.0);
            glVertex3fv(&v[pb[i][0]][0]);
   			glTexCoord2f(0.0, fatorr * 1.0);
            glVertex3fv(&v[pb[i][1]][0]);
   			glTexCoord2f(fatorr * 1.0, fatorr *  1.0);
            glVertex3fv(&v[pb[i][2]][0]);
   			glTexCoord2f(fatorr * 1.0, 0.0);
            glVertex3fv(&v[pb[i][3]][0]);
        glEnd();
    }
}

void LaCasa (GLuint* t, GLuint* m, float rot){

    int i;
    int dim = 24;
    int altpp = 7; //Altura pilar
    float niv = 0;
    float salto = .3;

	// Escadas
	glBindTexture(GL_TEXTURE_2D, t[11]);
    for (i = 0; i < 10; i++){
        glTranslatef(0, .2, -0.8);
        	glPushMatrix();
			Base(dim-niv+2, dim-niv+8.5, .4, 5);
        glPopMatrix();
        niv += salto;
    };
	//Meio da Casa
glBindTexture(GL_TEXTURE_2D, t[18]);


//----------------------------------------
    // Paredes laterais
    //parede maior
	glPushMatrix();
        glTranslatef(-8, salto, -1.5);
        Base(.3, 27, altpp+5, 1);
    glPopMatrix();

//parede
    glPushMatrix();
        glTranslatef(8, salto, -1.5);
        Base(.3, 27, altpp+5, 1);
    glPopMatrix();
   glBindTexture(GL_TEXTURE_2D, t[14]);
//lado esquerdo
   //paredinha divisoria
    glPushMatrix();
        glTranslatef(-7.9, salto+6, -1.5);
        Base(.2, 27, .3, 1);
    glPopMatrix();
       //paredinha divisoria
    glPushMatrix();
        glTranslatef(-7.9, salto+5, -1.5);
        Base(.2, 27, .3, 1);
    glPopMatrix();

    //paredinha divisoria
    glPushMatrix();
        glTranslatef(7.9, salto+6, -1.5);
        Base(.2, 27, .3, 1);
    glPopMatrix();
       //paredinha divisoria
    glPushMatrix();
        glTranslatef(7.9, salto+5, -1.5);
        Base(.2, 27, .3, 1);
    glPopMatrix();
//lado direito
	  glPushMatrix();
        glTranslatef(-7.9, salto, -14.6);
        Base(.2, .3, 6, 1);
    glPopMatrix();
      glPushMatrix();
        glTranslatef(-7.9, salto, -5.6);
        Base(.2, .3, 6, 1);
    glPopMatrix();
      glPushMatrix();
        glTranslatef(-7.9, salto, 3);
        Base(.2, .3, 6, 1);
    glPopMatrix();
      glPushMatrix();
        glTranslatef(-7.9, salto, 11.5);
        Base(.2, .3, 6, 1);
    glPopMatrix();


  glPushMatrix();
        glTranslatef(7.9, salto, -14.6);
        Base(.2, .3, 6, 1);
    glPopMatrix();
      glPushMatrix();
        glTranslatef(7.9, salto, -5.6);
        Base(.2, .3, 6, 1);
    glPopMatrix();
      glPushMatrix();
        glTranslatef(7.9, salto, 3);
        Base(.2, .3, 6, 1);
    glPopMatrix();
      glPushMatrix();
        glTranslatef(7.9, salto, 11.5);
        Base(.2, .3, 6, 1);
    glPopMatrix();
//-----------------------------------------
  	glBindTexture(GL_TEXTURE_2D, t[8]);
   // Paredes traseira
    glPushMatrix();
        glTranslatef(0, salto-3, -16.1);
        Base(20, 2, altpp+8, 10);
    glPopMatrix();
//parede da frente

    glPushMatrix();
        glTranslatef(0, salto, 11.8);
        Base(20, .5, altpp+5, 10);
    glPopMatrix();
//----------------------------------
//INICIO DA CRIA픈O DO TOPO
    // Topo central

    glPushMatrix();
     glBindTexture(GL_TEXTURE_2D, t[1]);
        glTranslatef(0, salto+9, 12.2);
        Base(10, 0.2, 2.5, 1);
    glBindTexture(GL_TEXTURE_2D, t[9]);
        glTranslatef(0, salto, 0.2);
        TQuadrado(2,2,0);
    glPopMatrix();

//FIM DA CRIA플O DO TOPO
//------------------------------------------
//INICIO DA CRIA플O DE TODAS AS PORTAS
    // Porta central
    glBindTexture(GL_TEXTURE_2D, t[4]);
    glPushMatrix();
        glTranslatef(0, salto, 12.2);
        Base(2, .2, 3.4, 1);
    glPopMatrix();
    glPushMatrix();
        glTranslatef(0, salto, 11.3);
        Base(2, .2, 3.4, 1);
    glPopMatrix();

	//Porta Direita
	glPushMatrix();
        glTranslatef(6, salto, 12.2);
        Base(2, .2, 3.4, 1);
    glPopMatrix();


	// Porta Esquerda

    glPushMatrix();
        glTranslatef(-6, salto, 12.2);
        Base(2, .2, 3.4, 1);
    glPopMatrix();

//FIM DA CRIA플O DAS PORTAS
//------------------------------------------

//------------------------------------------
//JANELAS MEIO LATERAL DIREITA
         glBindTexture(GL_TEXTURE_2D, t[7]);
    glPushMatrix();
        glTranslatef(12, salto+5, 11.2);
        Base(1.6, .2, 3, 1);
    glPopMatrix();
        glPushMatrix();
        glTranslatef(15, salto+5, 11.2);
        Base(1.6, .2, 3, 1);
    glPopMatrix();
        glPushMatrix();
        glTranslatef(18, salto+5, 11.2);
        Base(1.6, .2, 3, 1);
    glPopMatrix();
        glPushMatrix();
        glTranslatef(21, salto+5, 11.2);
        Base(1.6, .2, 3, 1);
    glPopMatrix();
        glPushMatrix();
        glTranslatef(24, salto+5, 11.2);
        Base(1.6, .2, 3, 1);
    glPopMatrix();
        glPushMatrix();
        glTranslatef(27, salto+5, 11.2);
        Base(1.6, .2, 3, 1);
    glPopMatrix();

//FIM DA PRIMEIRA FILEIRA DE JANELAS
//------------------------------------------------


//------------------------------------------
//JANELAS MEIO LATERAL ESQUERDA
         glBindTexture(GL_TEXTURE_2D, t[7]);
    glPushMatrix();
        glTranslatef(-12, salto+5, 11.2);
        Base(1.6, .2, 3, 1);
    glPopMatrix();
        glPushMatrix();
        glTranslatef(-15, salto+5, 11.2);
        Base(1.6, .2, 3, 1);
    glPopMatrix();
        glPushMatrix();
        glTranslatef(-18, salto+5, 11.2);
        Base(1.6, .2, 3, 1);
    glPopMatrix();
        glPushMatrix();
        glTranslatef(-21, salto+5, 11.2);
        Base(1.6, .2, 3, 1);
    glPopMatrix();
        glPushMatrix();
        glTranslatef(-24, salto+5, 11.2);
        Base(1.6, .2, 3, 1);
    glPopMatrix();
        glPushMatrix();
        glTranslatef(-27, salto+5, 11.2);
        Base(1.6, .2, 3, 1);
    glPopMatrix();

//FIM DA PRIMEIRA FILEIRA DE JANELAS
//------------------------------------------------

//------------------------------------------------
//CRIA플O DA SEGUNDA FILEIRA DE JANELAS
     glBindTexture(GL_TEXTURE_2D, t[5]);
    glPushMatrix();
        glTranslatef(12, salto+1, 11.2);
        Base(1.6, .2, 2.5, 1);
    glPopMatrix();
        glPushMatrix();
        glTranslatef(15, salto+1, 11.2);
        Base(1.6, .2, 2.5, 1);
    glPopMatrix();
        glPushMatrix();
        glTranslatef(18, salto+1, 11.2);
        Base(1.6, .2, 2.5, 1);
    glPopMatrix();
        glPushMatrix();
        glTranslatef(21, salto+1, 11.2);
        Base(1.6, .2, 2.5, 1);
    glPopMatrix();
        glPushMatrix();
        glTranslatef(24, salto+1, 11.2);
        Base(1.6, .2, 2.5, 1);
    glPopMatrix();
        glPushMatrix();
        glTranslatef(27, salto+1, 11.2);
        Base(1.6, .2, 2.5, 1);
    glPopMatrix();

//------------------------------------------------
//------------------------------------------------
//CRIA플O DA SEGUNDA <NAME> <NAME>
     glBindTexture(GL_TEXTURE_2D, t[5]);
    glPushMatrix();
        glTranslatef(-12, salto+1, 11.2);
        Base(1.6, .2, 2.5, 1);
    glPopMatrix();
        glPushMatrix();
        glTranslatef(-15, salto+1, 11.2);
        Base(1.6, .2, 2.5, 1);
    glPopMatrix();
        glPushMatrix();
        glTranslatef(-18, salto+1, 11.2);
        Base(1.6, .2, 2.5, 1);
    glPopMatrix();
        glPushMatrix();
        glTranslatef(-21, salto+1, 11.2);
        Base(1.6, .2, 2.5, 1);
    glPopMatrix();
        glPushMatrix();
        glTranslatef(-24, salto+1, 11.2);
        Base(1.6, .2, 2.5, 1);
    glPopMatrix();
        glPushMatrix();
        glTranslatef(-27, salto+1, 11.2);
        Base(1.6, .2, 2.5, 1);
    glPopMatrix();

//------------------------------------------
//------------------------------------------
//J<NAME>

	glBindTexture(GL_TEXTURE_2D, t[5]);
    glPushMatrix();
        glTranslatef(15, salto-2, 11.2);
        Base(1.6, .2, 1.6, 1);
    glPopMatrix();

        glPushMatrix();
        glTranslatef(18, salto-2, 11.2);
        Base(1.6, .2, 1.6, 1);
    glPopMatrix();

        glPushMatrix();
        glTranslatef(21, salto-2, 11.2);
        Base(1.6, .2, 1.6, 1);
    glPopMatrix();

        glPushMatrix();
        glTranslatef(24, salto-2, 11.2);
        Base(1.6, .2, 1.6, 1);
    glPopMatrix();

        glPushMatrix();
        glTranslatef(27, salto-2, 11.2);
        Base(1.6, .2, 1.6, 1);
    glPopMatrix();

//------------------------------------------
//------------------------------------------
//<NAME>

	glBindTexture(GL_TEXTURE_2D, t[5]);
    glPushMatrix();
        glTranslatef(-15, salto-2, 11.2);
        Base(1.6, .2, 1.6, 1);
    glPopMatrix();

        glPushMatrix();
        glTranslatef(-18, salto-2, 11.2);
        Base(1.6, .2, 1.6, 1);
    glPopMatrix();

        glPushMatrix();
        glTranslatef(-21, salto-2, 11.2);
        Base(1.6, .2, 1.6, 1);
    glPopMatrix();

        glPushMatrix();
        glTranslatef(-24, salto-2, 11.2);
        Base(1.6, .2, 1.6, 1);
    glPopMatrix();

        glPushMatrix();
        glTranslatef(-27, salto-2, 11.2);
        Base(1.6, .2, 1.6, 1);
    glPopMatrix();
//------------------------------------------
    //JANELAS PARTE DE CIMA


	glBindTexture(GL_TEXTURE_2D, t[5]);
	   glPushMatrix();
        glTranslatef(12, salto+9, 11.2);
        Base(1.6, .2, 1.6, 1);
    glPopMatrix();

    glPushMatrix();
        glTranslatef(15, salto+9, 11.2);
        Base(1.6, .2, 1.6, 1);
    glPopMatrix();

        glPushMatrix();
        glTranslatef(18, salto+9, 11.2);
        Base(1.6, .2, 1.6, 1);
    glPopMatrix();

        glPushMatrix();
        glTranslatef(21, salto+9, 11.2);
        Base(1.6, .2, 1.6, 1);
    glPopMatrix();

        glPushMatrix();
        glTranslatef(24, salto+9, 11.2);
        Base(1.6, .2, 1.6, 1);
    glPopMatrix();

        glPushMatrix();
        glTranslatef(27, salto+9, 11.2);
        Base(1.6, .2, 1.6, 1);
    glPopMatrix();


//------------------------------------
// JANELAS SUPERIORES PARTE DE CIMA DAS PORTAS
    glBindTexture(GL_TEXTURE_2D, t[5]);
    glPushMatrix();
        glTranslatef(-6, salto+4, 12.2);
        Base(1.6, .2, 1.6, 1);
    glPopMatrix();
    //segundajanelaporta
      glPushMatrix();
        glTranslatef(0, salto+4, 12.2);
        Base(1.6, .2, 1.6, 1);
    glPopMatrix();
    ///terceirajanelaporta3
      glPushMatrix();
        glTranslatef(6, salto+4, 12.2);
        Base(1.6, .2, 1.6, 1);
    glPopMatrix();

//-------------------------------------------------
//<NAME> PARTE CENTRAL

glBindTexture(GL_TEXTURE_2D, t[5]);
	 glPushMatrix();
        glTranslatef(-12, salto+9, 11.2);
        Base(1.6, .2, 1.6, 1);
    glPopMatrix();
	 glPushMatrix();
        glTranslatef(-15, salto+9, 11.2);
        Base(1.6, .2, 1.6, 1);
    glPopMatrix();
	 glPushMatrix();
        glTranslatef(-18, salto+9, 11.2);
        Base(1.6, .2, 1.6, 1);
    glPopMatrix();
    glPushMatrix();
        glTranslatef(-21, salto+9, 11.2);
        Base(1.6, .2, 1.6, 1);
    glPopMatrix();
    glPushMatrix();
        glTranslatef(-24, salto+9, 11.2);
        Base(1.6, .2, 1.6, 1);
    glPopMatrix();

	glPushMatrix();
        glTranslatef(-27, salto+9, 11.2);
        Base(1.6, .2, 1.6, 1);
    glPopMatrix();

//---------------------------------------------------------
//---------------------------------------------------------
    // PILARES
    glBindTexture(GL_TEXTURE_2D, t[0]);
    float tr = -8;
    for (i = 0; i < 4; i++){
        if(i==0){
			glPushMatrix();
            	glTranslatef(tr-0.8, salto, 14);
            	Cilindro(20, 20, altpp, .4);
            glPopMatrix();

            glPushMatrix();
            	glTranslatef(tr+0.2, salto, 14);
            	Cilindro(20, 20, altpp, .4);
            glPopMatrix();
		}

		if(i==1){
			glPushMatrix();
            	glTranslatef(tr+2.0, salto, 14);
            	Cilindro(20, 20, altpp, .4);
            glPopMatrix();

            glPushMatrix();
            	glTranslatef(tr+1.0, salto, 14);
            	Cilindro(20, 20, altpp, .4);
            glPopMatrix();
		}

		if(i==2){
			glPushMatrix();
            	glTranslatef(tr+6.0, salto, 14);
            	Cilindro(20, 20, altpp, .4);
            glPopMatrix();

            glPushMatrix();
            	glTranslatef(tr+5.0, salto, 14);
            	Cilindro(20, 20, altpp, .4);
            glPopMatrix();
		}

		if(i==3){
			glPushMatrix();
            	glTranslatef(tr+8.0, salto, 14);
            	Cilindro(20, 20, altpp, .4);
            glPopMatrix();

            glPushMatrix();
            	glTranslatef(tr+7.0, salto, 14);
            	Cilindro(20, 20, altpp, .4);
            glPopMatrix();
		}

        tr += 3;
    }

    tr = -10.5;

//-------------------------------------------------
 //TETO ACIMA DOS PILARES
   glBindTexture(GL_TEXTURE_2D, t[1]);
    glPushMatrix();
        glTranslatef(0, salto+altpp, 13);
        Base(21, 3.5, 1, 4);
    glPopMatrix();

//---------------------------------------------------
//PREDIO LATERAL DIREITA
//--------------------------------------------
 	glBindTexture(GL_TEXTURE_2D, t[8]);
    // Paredes laterais
    //predio direito
    glPushMatrix();
        glTranslatef(28.5, salto-3, 0.0);
        Base(.3, 22.5, 15, 10);
    glPopMatrix();


//-------------------------------------------
//Paredes frontal e traseira do Predio direito
//parede traseira
    glPushMatrix();
        glTranslatef(19, salto-3, -11);
        Base(19, 12.1, altpp+8, 10);
    glPopMatrix();
//parede frontal
    glPushMatrix();
        glTranslatef(19, salto-3, 11.1);
        Base(19, .3, altpp+8, 10);
    glPopMatrix();
//--------------------------------------------

//------------------------------------
//lado esquerdo
   glPushMatrix();
        glTranslatef(-19, salto-3, -11);
        Base(19, 12.1, altpp+8, 10);
    glPopMatrix();
	//parede frontal
    glPushMatrix();
        glTranslatef(-19, salto-3, 11.1);
        Base(19, .3, altpp+8, 10);
    glPopMatrix();
  glPushMatrix();
        glTranslatef(-28.5, salto-3, 0.0);
        Base(.3, 22.5, 15, 10);
    glPopMatrix();

//-----------------------------------------------------------
//PILAR ESCADA, 1 PILAR ESQUERDO
 glBindTexture(GL_TEXTURE_2D, t[17]);
 	 glPushMatrix();
        glTranslatef(-2.3, salto-1, 1.5);
        Base(.5,.7, 3.2, 10);
     glPopMatrix();
//----------------------------------
//PAREDE ENTRE OS PILARES 1 E 2 LADO ESQUERDO
  	 glPushMatrix();
  	 glRotatef(25, 25, 0, 0);
        glTranslatef(-2.3, salto+0.1, -2.2);
        Base(.3,5.2, 2.2, 10);
     glPopMatrix();
//--------------------------------------------
//PILAR DIREITO, 1 PILAR
 	 glPushMatrix();
        glTranslatef(2.3, salto-1, 1.5);
        Base(.5,.7, 3.2, 10);
     glPopMatrix();
//------------------------------------------
//PAREDE ENTRE OS PILARES 1 E 2 DIREITO
   	 glPushMatrix();
  	 glRotatef(25, 25, 0, 0);
        glTranslatef(2.3, salto+0.1, -2.2);
        Base(.3,5.2, 2.2, 10);
     glPopMatrix();
//-----------------------------------------------------------
//PILAR ESCADA, 2 PILAR ESQUERDO
    glPushMatrix();
        glTranslatef(-2.3, salto+1, -3.5);
        Base(.5,.5, 3.5, 10);
    glPopMatrix();
//--------------------------------------------
//PILAR DIREITO, 2 PILAR
    glPushMatrix();
        glTranslatef(2.3, salto+1, -3.5);
        Base(.5,.5, 3.5, 10);
    glPopMatrix();
//-----------------------------------------------------------
//PILAR ESCADA, 3 PILAR ESQUERDO
 glPushMatrix();
        glTranslatef(-2.3, salto+4, -8.5);
        Base(.5,1, 3, 10);
    glPopMatrix();
//----------------------------------
//PAREDE ENTRE OS PILARES 2 E 3 LADO ESQUERDO
  	 glPushMatrix();
  	 glRotatef(30, 30, 0, 0);
        glTranslatef(-2.3, salto-0.5, -8);
        Base(.3,5.3, 2.2, 10);
     glPopMatrix();
//--------------------------------------------
//PILAR DIREITO, 3 PILAR
 glPushMatrix();
        glTranslatef(2.3, salto+4, -8.5);
        Base(.5,1, 3, 10);
    glPopMatrix();
//------------------------------------------
//PAREDE ENTRE OS PILARES 2 E 3 DIREITO
   	 glPushMatrix();
  	 glRotatef(30, 30, 0, 0);
        glTranslatef(2.3, salto-0.5, -8);
        Base(.3,5.3, 2.2, 10);
     glPopMatrix();
//-----------------------------------------------------------
//PILAR ESCADA, 4 PILAR ESQUERDO
 glPushMatrix();
        glTranslatef(-2.3, salto+6, -15);
        Base(.5,.7, 3, 10);
    glPopMatrix();
//PAREDE ENTRE OS PILARES 3 E 4 LADO ESQUERDO
  	 glPushMatrix();
  	 glRotatef(20, 20, 0, 0);
        glTranslatef(-2.3, salto+1, -14);
        Base(.3,6.2, 2.2, 10);
     glPopMatrix();
//--------------------------------------------

//PILAR DIREITO, 4 PILAR
 glPushMatrix();
        glTranslatef(2.3, salto+6, -15);
        Base(.5,.7, 3, 10);
    glPopMatrix();
//------------------------------------------
//PAREDE ENTRE OS PILARES 3 E 4 DIREITO
   	 glPushMatrix();
  	 glRotatef(20, 20, 0, 0);
        glTranslatef(2.3, salto+1, -14);
        Base(.3,6.2, 2.2, 10);
     glPopMatrix();
//--------------------------------------------

//--------------------------------------------------------
// ESCADA INTERIOR
	glBindTexture(GL_TEXTURE_2D, t[12]);
    for (i = 0; i < 14; i++){
        glTranslatef(0, 0.5, -1);
  		glPushMatrix();
			Base(4, 6, 0.5, 1);
        glPopMatrix();
        niv += salto;
    };
glBindTexture(GL_TEXTURE_2D, t[14]);
//	tetoInterior();
//--------------------------------------------------------------
//teto todo
// Base do teto lado direito
    glBindTexture(GL_TEXTURE_2D, t[1]);
    glPushMatrix();
        glTranslatef(0, salto+4.9,12.45);
        Base(57, 28, .3, 4);
    glPopMatrix();

//termina

 //QUADRO LADO ESQUERDO
   glBindTexture(GL_TEXTURE_2D, t[10]);
  glPushMatrix();
        glTranslatef(7.8, salto-4.5, 23);
	    Quadro(2, 2, t, m, 0, 1);
    glPopMatrix();

     glBindTexture(GL_TEXTURE_2D, t[13]);
  glPushMatrix();
        glTranslatef(7.8, salto-4.5, 20);
	    Quadro(2, 2, t, m, 0, 1);
    glPopMatrix();

 //QUADRO LADO DIREITO
glBindTexture(GL_TEXTURE_2D, t[15]);
  glPushMatrix();
        glTranslatef(-7.7, salto-4.5, 23);
	    Quadro(2, 2, t, m, 0, -1);
    glPopMatrix();

     glBindTexture(GL_TEXTURE_2D, t[16]);
  glPushMatrix();
        glTranslatef(-7.7, salto-4.5, 20);
	    Quadro(2, 2, t, m, 0, -1);
    glPopMatrix();

    //-----------------------------------
glBindTexture(GL_TEXTURE_2D, t[18]);
	  drawCube(1);
	  drawCube2(1);
//BANCADAS ABAIXO DOS QUADROS
	glBindTexture(GL_TEXTURE_2D, t[14]);
	glPushMatrix();
		glTranslatef(6.4,-5,23);
		Bancada1(1);
	glPopMatrix();
	glPushMatrix();
		glTranslatef(6.4,-5,20);
		Bancada1(1);
	glPopMatrix();
	glPushMatrix();
		glTranslatef(-6.4,-5,23);
		Bancada2(1);
	glPopMatrix();
	glPushMatrix();
		glTranslatef(-6.4,-5,20);
		Bancada2(1);
	glPopMatrix();
//-------------------------------------------------------
// janela taseira central
    glBindTexture(GL_TEXTURE_2D, t[19]);
    glPushMatrix();
        glTranslatef(0, salto-10, -1.1);
        Base(4, .2, 15, 7);
    glPopMatrix();

//Janela traseira Direita
glPushMatrix();
        glTranslatef(5, salto-9, -1.1);
        Base(4, .2, 11, 7);
    glPopMatrix();

// Janela traseira Esquerda

    glPushMatrix();
        glTranslatef(-5, salto-9, -1.1);
        Base(4, .2, 11, 7);
    glPopMatrix();

}
void Cenario (GLuint* t, float x, float z, float rot)
{
	float p = 2*sin((3.14*rot)/180.0);
	glBindTexture(GL_TEXTURE_2D, t[3]);
	glPushMatrix();
		glTranslatef(0, -0.1, 0);
		Base(300, 300, 0.1, 15);
	glPopMatrix();
	glPushMatrix();
	glBindTexture(GL_TEXTURE_2D, t[6]);
		glTranslatef(0+p, 30, 0);
		Base(300, 300, 0.1, 1);
	glPopMatrix();

}
void Quadro (float lar, float alt, GLuint* t, GLuint* m, int n, int inv)
{
	glPushMatrix();
		glRotatef((float) inv * 90, 0, 1, 0);
        Base(lar+0.2, .1, alt+0.2, 1);
		glBindTexture(GL_TEXTURE_2D, m[n]);
		glTranslatef(0, .1, .1);
        TQuadrado(lar, alt, 0);
    glPopMatrix();

}


<file_sep>/La casa de Papel/LaCasa.h
#ifndef LACASA_H_INCLUDED
#define LACASA_H_INCLUDED

#include <GL/glut.h>
#include <GL/glu.h>

void Base (float largura, float comprimento, float altura, int fatorr);

void LaCasa (GLuint* t, GLuint* m, float rot);

void Cenario (GLuint* t, float x, float z, float rot);

void Quadro (float lar, float alt, GLuint* t, GLuint* m, int n, int inv);

#endif // LACASA_H_INCLUDED
<file_sep>/README.md
#  Modelagem Casa da Moeda

###  1. Proposta para projeto;
◆ Inspiração para a cena.

● Com o grande sucesso da série la casa de papel foi desenvolvido um projeto que simula onde ocorreu o assalto da primeira temporada da série, a Casa da Moeda da Espanha.

###  2. Cenas apresentadas;

◆ Apresentação das cenas que foram modeladas.

● As cenas foram modeladas pensando e totalmente espelhada na Casa da Moeda da Espanha, que é mostrada na série.

###  3. Execução da cena;

◆ Apresentação da cena em tempo real.

● Foi feito uso de câmera virtual, o observador pode se mover por todos os lugares da cena.

### 4. Principais Funções.

◆ La Casa; 

● Inicialização e montagem da cena:  Essa função é a responsável por executar o projeto, todas as funções de chamada no projeto, para desenhar, são feitos nela.

◆ Base;

● É a função que tem com princípio desenhar os elementos quadrados:  Função que desenha quase todos elementos da casa, foi feito uso dessa função mais genérica para que seja possível criar qualquer tipo de quadro com ela, o que busca minimizar a repetição de código.

◆ Cenário;

● Modelagem do asfalto que a Casa da Moeda da Espanha fica sobre.

◆ Movimentações do Mouse;

● Responsável por verificar a posição e movimenta a câmera virtual: Funções de click foram implementadas para o mouse em todas as direções, então para girar e visualizar é só clicar e arrastar.

◆ Movimentações do Observador;
O que outras pessoas estão dizendo
● Funções de movimentação do observador na cena corresponde às teclas:

Q: movimentação para o lado esquerdo;

W:movimentação para frente;

E:movimentação para o lado direito;

A:Giro para o lado esquerdo;

S: Movimentação para trás;

D: Giro para o lado direito;

R:Para subir na cena;

 F: Para descer na cena;
 
# Como reproduzir

Existem duas maneiras de reproduzir o arquivo, a primeira e mais simples, consiste apenas em abrir o arquivo executável “La casa de Papel.exe”. Daí a cena já será exibida e o usuário já pode interagir com o cenário.

A segunda forma se torna um pouco mais complexa pelo fato de que o usuário precisa configurar um ambiente para executar o arquivo direto do código fonte. Neste link é possível ver um tutorial ensinando a preparar o ambiente “https://www.youtube.com/watch?v=YlvBcafLfhs”. Depois do ambiente ser preparado e está totalmente preparado basta abrir o projeto e executar. 

Obs.: Como o projeto faz o uso de texturas, lembre de sempre que mudar o diretorio do projeto o caminho para as imagens também precisam ser mudadas, caso opte por executar o rojeto direto no dódigo fonte.
