void glfwTest::onMouseButton(GLFWwindow* window, int button, int action, int mods)
{
double xd, yd;
if ((button == GLFW_MOUSE_BUTTON_1) && (action == GLFW_PRESS))
{
mCamera.SetMouseLButtonStat(true);
glfwGetCursorPos(window, &xd, &yd);
mCamera.initMousePosition(xd, yd);
}
else if ((button == GLFW_MOUSE_BUTTON_1) && (action == GLFW_RELEASE))
{
mCamera.SetMouseLButtonStat(false);
}
if ((button == GLFW_MOUSE_BUTTON_2) && (action == GLFW_PRESS))
{
mCamera.SetMouseRButtonStat(true);
glfwGetCursorPos(window, &xd, &yd);
mCamera.initMousePosition(xd, yd);
}
else if ((button == GLFW_MOUSE_BUTTON_2) && (action == GLFW_RELEASE))
{
mCamera.SetMouseRButtonStat(false);
}
}
void glfwTest::onMouseMove(GLFWwindow* window, double xd, double yd)
{
double x = xd;
double y = yd;
if (mCamera.IsMouseLButtonDown())
{
glfwGetCursorPos(window, &xd, &yd);
mCamera.SetCurMousePosition(xd, yd);
mCamera.computeQuat();
mCamera.setMmworldQuat();
}
if (mCamera.IsMouseRButtonDown())
{
glfwGetCursorPos(window, &xd, &yd);
mCamera.SetCurMousePosition(xd, yd);
mCamera.computeTran();
mCamera.setMmworldTran();
}
}
void glfwTest::UpdateScene()
{
static const GLfloat black[] = { 0.0f, 0.0f, 0.0f, 1.0f };
static const GLfloat one = 1.0f;
glViewport(0, 0, mWidth, mHeight);
glClearBufferfv(GL_COLOR, 0, black);
glClearBufferfv(GL_DEPTH, 0, &one);
glUseProgram(program);
/*
vec3 pos = vec3(0.0f, 0.0f, 5.0f);
vec3 target = vec3(0.0f);
vec3 up = vec3(0.0f, 1.0f, 0.0f);
mat4 Projection = perspective(45.0f, (float)mWidth/mHeight, 0.1f, 100.f);
mat4 View = lookAt(pos, target, up);
mat4 Model = scale(mat4(1.0f), vec3(0.5f));
mat4 MVP = Projection * View * Model;*/
mat4 MVP = mCamera.getMVP();
glUniformMatrix4fv(mvp_matrix, 1, GL_FALSE, glm::value_ptr(MVP));
}
int main(int argc, char** argv) {
// Initialize SDL and open a window
SDLWindowManager windowManager(WINDOW_WIDTH, WINDOW_HEIGHT, "GLImac");
float currentTime;
float lastTime;
int nbFrames = 0;
//Création des variables clavier et souris SDL
int key_z = 0,
key_s = 0,
key_q = 0,
key_d = 0,
key_v = 0,
click = 0;
bool freefly = false;
// Initialize glew for OpenGL3+ support
GLenum glewInitError = glewInit();
if(GLEW_OK != glewInitError) {
std::cerr << glewGetErrorString(glewInitError) << std::endl;
return EXIT_FAILURE;
}
std::cout << "OpenGL Version : " << glGetString(GL_VERSION) << std::endl;
std::cout << "GLEW Version : " << glewGetString(GLEW_VERSION) << std::endl;
//--------------------------------------------------------------------------------------------------
//-------------CONSTRUCTION CUBE ET INJECTION DANS UN TABLEAU DE VERTICES-------------------------
//--------------------------------------------------------------------------------------------------
GLfloat taille = 1;
GLfloat cube_vertices[] = {
// front
-taille, -taille, taille,
taille, -taille, taille,
taille, taille, taille,
-taille, taille, taille,
// back
-taille, -taille, -taille,
taille, -taille, -taille,
taille, taille, -taille,
-taille, taille, -taille,
};
GLfloat cube_colors[] = {
// front colors
1.0, 0.0, 0.0,
0.0, 1.0, 0.0,
0.0, 0.0, 1.0,
1.0, 1.0, 1.0,
// back colors
1.0, 0.0, 0.0,
0.0, 1.0, 0.0,
0.0, 0.0, 1.0,
1.0, 1.0, 1.0,
};
uint32_t cube_elements[] = {
// front
0, 1, 2,
2, 3, 0,
// top
3, 2, 6,
6, 7, 3,
// back
7, 6, 5,
5, 4, 7,
// bottom
4, 5, 1,
1, 0, 4,
// left
4, 0, 3,
3, 7, 4,
// right
1, 5, 6,
6, 2, 1,
};
//--------------------------------------------------------------------------------------------------
//---------------------------------CONSTRUCTION CAMERA----------------------------------------------
//--------------------------------------------------------------------------------------------------
TrackballCamera trackballCamera;
FreeflyCamera freeflyCamera;
//--------------------------------------------------------------------------------------------------
//-------------------------------CHARGEMENT DES SHADERS---------------------------------------------
//--------------------------------------------------------------------------------------------------
FilePath applicationPath(argv[0]);
MyProgram program(applicationPath);
//--------------------------------------------------------------------------------------------------
//--------------------------CREATION DES VARIABLES UNIFORMES----------------------------------------
//--------------------------------------------------------------------------------------------------
glEnable(GL_DEPTH_TEST);
glm::mat4 ProjMatrix,
MVMatrix,
MVPMatrix;
ProjMatrix = glm::perspective(glm::radians(50.f), (float)WINDOW_WIDTH/WINDOW_HEIGHT, 0.1f, 1000.f);
MVMatrix = glm::translate(glm::mat4(), glm::vec3(0., 0., -5.));
MVPMatrix = ProjMatrix * MVMatrix;
glUniformMatrix4fv(program.uMVMatrix, 1, GL_FALSE, glm::value_ptr(MVMatrix));
glUniformMatrix4fv(program.uMVPMatrix, 1, GL_FALSE, glm::value_ptr(MVPMatrix));
glUniformMatrix4fv(program.uPMatrix, 1, GL_FALSE, glm::value_ptr(ProjMatrix));
//--------------------------------------------------------------------------------------------------
//-----------------------------CHARGEMENT DU VBO ET DU VAO------------------------------------------
//--------------------------------------------------------------------------------------------------
GLuint vbo_cube_vertices,
vbo_cube_colors;
glGenBuffers(1, &vbo_cube_vertices);
glGenBuffers(1, &vbo_cube_colors);
glBindBuffer(GL_ARRAY_BUFFER, vbo_cube_vertices);
glBufferData(GL_ARRAY_BUFFER, 24 * sizeof(GLfloat), cube_vertices, GL_STATIC_DRAW);
glBindBuffer(GL_ARRAY_BUFFER, 0);
glBindBuffer(GL_ARRAY_BUFFER, vbo_cube_colors);
glBufferData(GL_ARRAY_BUFFER, 24 * sizeof(GLfloat), cube_colors, GL_STATIC_DRAW);
glBindBuffer(GL_ARRAY_BUFFER, 0);
GLuint ibo_cube_elements;
glGenBuffers(1, &ibo_cube_elements);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ibo_cube_elements);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, 36 * sizeof(uint32_t), cube_elements, GL_STATIC_DRAW);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
GLuint vao;
glGenVertexArrays(1, &vao);
glBindVertexArray(vao);
// => On bind l'IBO sur GL_ELEMENT_ARRAY_BUFFER; puisqu'un VAO est actuellement bindé,
// cela a pour effet d'enregistrer l'IBO dans le VAO
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ibo_cube_elements);
const GLuint VERTEX_ATTR_POSITION = 0;
const GLuint VERTEX_ATTR_COLOR = 1;
glEnableVertexAttribArray(VERTEX_ATTR_POSITION);
glEnableVertexAttribArray(VERTEX_ATTR_COLOR);
glBindBuffer(GL_ARRAY_BUFFER, vbo_cube_vertices);
glVertexAttribPointer(VERTEX_ATTR_POSITION, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(GL_FLOAT), 0);
glBindBuffer(GL_ARRAY_BUFFER, 0);
glBindBuffer(GL_ARRAY_BUFFER, vbo_cube_colors);
glVertexAttribPointer(VERTEX_ATTR_COLOR, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(GL_FLOAT), 0);
glBindBuffer(GL_ARRAY_BUFFER, 0);
/*
-param1 : index de l'attribut à spécifier
-param2 : le nombre de composante de l'attribut (=nombre de cases dans le tableau pour définir un attribut)
-param3 : le type de chaque composante
-param4 : mystere pour le moment
-param5 : le nombre de cases à sauter avant de passer à la composante suivante de l'attribut
-param6 : offset de la première instance de l'attribut
*/
glBindVertexArray(0);
//--------------------------------------------------------------------------------------------------
//----------------------------------APPLICATION LOOP------------------------------------------------
//--------------------------------------------------------------------------------------------------
bool done = false;
while(!done) {
// Event loop:
SDL_Event e;
while(windowManager.pollEvent(e)) {
if(e.type == SDL_QUIT) {
done = true; // Leave the loop after this iteration
}
if(e.type == SDL_KEYDOWN){
if(e.key.keysym.sym == SDLK_ESCAPE){
done = true;
}
if(e.key.keysym.sym == SDLK_z){
key_z = 1;
}
if(e.key.keysym.sym == SDLK_s){
key_s = 1;
}
if(e.key.keysym.sym == SDLK_q){
key_q = 1;
}
if(e.key.keysym.sym == SDLK_d){
key_d = 1;
}
if(e.key.keysym.sym == SDLK_p){
TAILLE++;
std::cout << "TAILLE = " << TAILLE << std::endl;
}
if(e.key.keysym.sym == SDLK_m){
TAILLE--;
if(TAILLE <= 0) TAILLE = 1;
std::cout << "TAILLE = " << TAILLE << std::endl;
}
if(e.key.keysym.sym == SDLK_v){
if(freefly == true){
freefly = false;
}
else{
freefly = true;
}
}
}
if(e.type == SDL_KEYUP){
if(e.key.keysym.sym == SDLK_z){
key_z = 0;
}
if(e.key.keysym.sym == SDLK_s){
key_s = 0;
}
if(e.key.keysym.sym == SDLK_q){
key_q = 0;
}
if(e.key.keysym.sym == SDLK_d){
key_d = 0;
}
}
if(e.type == SDL_MOUSEBUTTONDOWN){
click = 1;
}
if(e.type == SDL_MOUSEBUTTONUP){
click = 0;
}
if(e.type == SDL_MOUSEMOTION){
if(e.motion.xrel != 0 && click == 1){
//std::cout << e.motion.xrel << std::endl;
trackballCamera.rotateLeft(e.motion.xrel/2.);
freeflyCamera.rotateLeft(-e.motion.xrel/2.);
}
if(e.motion.yrel != 0 && click == 1){
//std::cout << e.motion.xrel << std::endl;
trackballCamera.rotateUp(e.motion.yrel/2.);
freeflyCamera.rotateUp(-e.motion.yrel/2.);
}
}
}
if(key_z && !key_s){
trackballCamera.moveFront(-0.1);
freeflyCamera.moveFront(0.1);
}
if(key_s && !key_z){
trackballCamera.moveFront(0.1);
freeflyCamera.moveFront(-0.1);
}
if(key_q && !key_d){
freeflyCamera.moveLeft(0.1);
}
if(key_d && !key_q){
freeflyCamera.moveLeft(-0.1);
}
//--------------------------------------------------------------------------------------------------
//-----------------------------------RENDERING CODE-------------------------------------------------
//--------------------------------------------------------------------------------------------------
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glBindVertexArray(vao);
//DESSIN DE LA TERRE
program.m_Program.use();
for(int i = 0; i<TAILLE; ++i){
for(int j=0; j<TAILLE; ++j){
//CONSTRUCTION MATRICE V
MVMatrix = freefly? freeflyCamera.getViewMatrix() : trackballCamera.getViewMatrix();
//CONSTRUCTION MATRICE MV
MVMatrix = glm::translate(MVMatrix, glm::vec3(2*i, 0, 2*j));
MVMatrix = glm::rotate(MVMatrix, (float)(M_PI * i), glm::vec3(0, 0, 1));
MVMatrix = glm::rotate(MVMatrix, (float)(M_PI * j), glm::vec3(0, 0, 1));
//CONSTRUCTION MATRICE MVP
MVPMatrix = ProjMatrix * MVMatrix;
//ENVOI DES NOUVELLES VALEURS AUX UNIFORMS
glUniformMatrix4fv(program.uMVMatrix, 1, GL_FALSE, glm::value_ptr(MVMatrix));
glUniformMatrix4fv(program.uMVPMatrix, 1, GL_FALSE, glm::value_ptr(MVPMatrix));
glUniformMatrix4fv(program.uPMatrix, 1, GL_FALSE, glm::value_ptr(ProjMatrix));
//DESSIN
glDrawElements(GL_TRIANGLES, 36, GL_UNSIGNED_INT, 0);
}
}
glBindVertexArray(0);
// Update the display
windowManager.swapBuffers();
// Measure speed
++nbFrames;
currentTime = windowManager.getTime();
//std::cout << nbFrames / windowManager.getTime() << std::endl;
float ellapsedTime = currentTime - lastTime;
if(ellapsedTime >= 1){
float res = ellapsedTime / nbFrames;
if(res > 0.04){
std::cout << "Warning ! : ";
}
std::cout << res << " sec" << std::endl;
std::cout << 1 / res << " fps" << std::endl;
nbFrames = 0;
lastTime = windowManager.getTime();
}
}
glDeleteBuffers(1, &vbo_cube_vertices);
glDeleteBuffers(1, &vbo_cube_colors);
glDeleteBuffers(1, &ibo_cube_elements);
glDeleteVertexArrays(1, &vao);
return EXIT_SUCCESS;
}
int Game::playTrack(Track& track){
bool raceFinished = false;
unsigned int timeElapsed = 0;
//Interface
Program prog2D;
prog2D = loadProgram("../shaders/tex2D.vs.glsl", "../shaders/tex2D.fs.glsl");
prog2D.use();
//Carre qui affiche les pouvoirs
Object2D powerquad;
powerquad.setVertices(0.7, 0.9, -0.9, -0.64);
powerquad.build();
//Carre qui affiche la position
Object2D positionQuad;
positionQuad.setVertices(-0.9,-0.7,0.64,0.9);
positionQuad.build();
//Surfaces pour afficher le classement final (à optimiser)
Object2D positionQuad1;
positionQuad1.setVertices(-0.2,-0.1,0.8,0.9);
positionQuad1.build();
Object2D positionQuad2;
positionQuad2.setVertices(-0.2,-0.1,0.6,0.7);
positionQuad2.build();
Object2D positionQuad3;
positionQuad3.setVertices(-0.2,-0.1,0.4,0.5);
positionQuad3.build();
Object2D positionQuad4;
positionQuad4.setVertices(-0.2,-0.1,0.2,0.3);
positionQuad4.build();
Object2D positionQuad5;
positionQuad5.setVertices(-0.2,-0.1,0.0,0.1);
positionQuad5.build();
Object2D positionQuad6;
positionQuad6.setVertices(-0.2,-0.1,-0.2,-0.1);
positionQuad6.build();
Object2D positionQuad7;
positionQuad7.setVertices(-0.2,-0.1,-0.4,-0.3);
positionQuad7.build();
Object2D positionQuad8;
positionQuad8.setVertices(-0.2,-0.1,-0.6,-0.5);
positionQuad8.build();
Object2D persoQuad1;
persoQuad1.setVertices(0.1,0.2,0.8,0.9);
persoQuad1.build();
Object2D persoQuad2;
persoQuad2.setVertices(0.1,0.2,0.6,0.7);
persoQuad2.build();
Object2D persoQuad3;
persoQuad3.setVertices(0.1,0.2,0.4,0.5);
persoQuad3.build();
Object2D persoQuad4;
persoQuad4.setVertices(0.1,0.2,0.2,0.3);
persoQuad4.build();
Object2D persoQuad5;
persoQuad5.setVertices(0.1,0.2,0.0,0.1);
persoQuad5.build();
Object2D persoQuad6;
persoQuad6.setVertices(0.1,0.2,-0.2,-0.1);
persoQuad6.build();
Object2D persoQuad7;
persoQuad7.setVertices(0.1,0.2,-0.4,-0.3);
persoQuad7.build();
Object2D persoQuad8;
persoQuad8.setVertices(0.1,0.2,-0.6,-0.5);
persoQuad8.build();
GLint locVarTexture;
locVarTexture= glGetUniformLocation(prog2D.getGLId(), "uTexture");
GLuint* texturepower=PowerTexture();
GLuint* textureRank=RankTexture();
GLuint* texturePerso=PersoTexture();
Program prog;
prog = loadProgram("../shaders/3D.vs.glsl","../shaders/tex3D.fs.glsl");
prog.use();
GLuint uMVPMatrix=glGetUniformLocation(prog.getGLId(),"uMVPMatrix");
GLuint uMVMatrix=glGetUniformLocation(prog.getGLId(),"uMVMatrix");
GLuint uNormalMatrix=glGetUniformLocation(prog.getGLId(),"uNormalMatrix");
GLuint uTex=glGetUniformLocation(prog.getGLId(),"uTexture");
GLuint uKd=glGetUniformLocation(prog.getGLId(),"uKd");
GLuint uKs=glGetUniformLocation(prog.getGLId(),"uKs");
GLuint uShininess=glGetUniformLocation(prog.getGLId(),"uShininess");
GLuint uLightDir_vs=glGetUniformLocation(prog.getGLId(),"uLightDir_vs");
GLuint uLightIntensity=glGetUniformLocation(prog.getGLId(),"uLightIntensity");
glEnable(GL_DEPTH_TEST);
glm::mat4 ViewMatrix;
TrackballCamera camera;
// Les power qu'on peut ramasser, a enlever car ils seront inclus dans powObject
PowerObject boost(BOOST,10000);
PowerObject atk_back(ATK_BACK,10000);
PowerObject trap(TRAP,10000);
PowerObject shield(SHIELD, 10000);
PowerObject atk_all(ATK_ALL, 10000);
PowerObject atk_front(ATK_FRONT, 10000);
//Ciel
Object3D sky;
sky.sphere(1,32,16);
sky.setScale(glm::vec3(80,80,80));
sky.setHitbox(glm::vec3(0));
sky.build();
sky.LoadTexture("../textures/sky.jpg");
PowerObject *obj=NULL;
bool done=false;
bool ready=false;
int sortie=0;
std::cout << "Lecture du fichier Map" << std::endl;
//Lecture du fichier Map
track.insertElt();
//Nodes
unsigned int rank = 8;
//On donne le prochain noeud pour que les IA s'y dirigent
for (std::vector<Kart*>::iterator it = Karts.begin() ; it != Karts.end(); ++it){
(*it)->setNodeTo(track.getNodeStart()->next);
(*it)->setRank(rank);
rank--;
}
Node* currentNode = track.getNodeStart();
Object3D* node;
// while(1){
// node = new Object3D();
// node->sphere(1,32,16);
// node->setScale(glm::vec3(1,1,1));
// node->setHitbox(glm::vec3(0));
// node->setPosition(currentNode->getPosition());
// node->build();
// if(currentNode==track.getNodeStart())
// node->LoadTexture("../textures/Maison.jpg");
// else
// node->LoadTexture("../textures/CCTex.jpg");
// track.push_back(*node);
// currentNode = currentNode->next;
// if(currentNode==track.getNodeStart())
// break;
// }
placementKart(track.getNodeStart());
//Rotation pour la caméra
std::queue<std::pair<float,Uint32>> anglefile;
anglefile.push(std::pair<float,Uint32>(Karts[0]->getAngle(),0));
glUniform3f(uKd, 1, 1, 1);
glUniform3f(uKs, 1, 1, 1);
glUniform1f(uShininess, 2);
glUniform3f(uLightIntensity, 1, 1, 1);
timeElapsed=0;
while(!done) {
Uint32 tStart = SDL_GetTicks();
if(timeElapsed >= FPS && timeElapsed < 2*FPS)
std::cout << "3 ..." << std::endl;
if(timeElapsed >= 2*FPS && timeElapsed < 3*FPS)
std::cout << "2 ..." << std::endl;
if(timeElapsed >= 3*FPS && timeElapsed < 4*FPS)
std::cout << "1 ..." << std::endl;
if(timeElapsed >= 4*FPS && timeElapsed < 5*FPS){
std::cout << "PINAAAAAAAAAAGE !!!" << std::endl;
ready=true;
}
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
prog2D.use();
//affichage des pouvoirs
powerquad.initDraw();
if (Players[0]->getPower()==NULL){
powerquad.bindTex(texturepower[6]);
}
else{
switch(Players[0]->getPower()->getType()){
case BOOST:
powerquad.bindTex(texturepower[0]);
break;
case ATK_FRONT:
powerquad.bindTex(texturepower[1]);
break;
case ATK_BACK:
powerquad.bindTex(texturepower[2]);
break;
case ATK_ALL:
powerquad.bindTex(texturepower[3]);
break;
case SHIELD:
powerquad.bindTex(texturepower[4]);
break;
case TRAP:
powerquad.bindTex(texturepower[5]);
break;
}
}
powerquad.Draw(locVarTexture);
//Gestion du classement
if( !raceFinished ){
ranking(Karts);
positionQuad.initDraw();
positionQuad.bindTex(textureRank[Karts[0]->getRank()-1]);
positionQuad.Draw(locVarTexture);
}
else{
getFinalRanking(Players);
positionQuad1.initDraw();
positionQuad1.bindTex(textureRank[0]);
positionQuad1.Draw(locVarTexture);
positionQuad2.initDraw();
positionQuad2.bindTex(textureRank[1]);
positionQuad2.Draw(locVarTexture);
positionQuad3.initDraw();
positionQuad3.bindTex(textureRank[2]);
positionQuad3.Draw(locVarTexture);
positionQuad4.initDraw();
positionQuad4.bindTex(textureRank[3]);
positionQuad4.Draw(locVarTexture);
positionQuad5.initDraw();
positionQuad5.bindTex(textureRank[4]);
positionQuad5.Draw(locVarTexture);
positionQuad6.initDraw();
positionQuad6.bindTex(textureRank[5]);
positionQuad6.Draw(locVarTexture);
positionQuad7.initDraw();
positionQuad7.bindTex(textureRank[6]);
positionQuad7.Draw(locVarTexture);
positionQuad8.initDraw();
positionQuad8.bindTex(textureRank[7]);
positionQuad8.Draw(locVarTexture);
persoQuad1.initDraw();
persoQuad1.bindTex(texturePerso[getIdPersoByRank(Players, 1)]);
persoQuad1.Draw(locVarTexture);
persoQuad2.initDraw();
persoQuad2.bindTex(texturePerso[getIdPersoByRank(Players, 2)]);
persoQuad2.Draw(locVarTexture);
persoQuad3.initDraw();
persoQuad3.bindTex(texturePerso[getIdPersoByRank(Players, 3)]);
persoQuad3.Draw(locVarTexture);
persoQuad4.initDraw();
persoQuad4.bindTex(texturePerso[getIdPersoByRank(Players, 4)]);
persoQuad4.Draw(locVarTexture);
persoQuad5.initDraw();
persoQuad5.bindTex(texturePerso[getIdPersoByRank(Players, 5)]);
persoQuad5.Draw(locVarTexture);
persoQuad6.initDraw();
persoQuad6.bindTex(texturePerso[getIdPersoByRank(Players, 6)]);
persoQuad6.Draw(locVarTexture);
persoQuad7.initDraw();
persoQuad7.bindTex(texturePerso[getIdPersoByRank(Players, 7)]);
persoQuad7.Draw(locVarTexture);
persoQuad8.initDraw();
persoQuad8.bindTex(texturePerso[getIdPersoByRank(Players, 8)]);
persoQuad8.Draw(locVarTexture);
}
prog.use();
//Decalage camera
if(tStart-anglefile.front().second>330){
if(anglefile.size()>1)
anglefile.pop();
}
//Camera
ViewMatrix=camera.getViewMatrix(Karts[0]->getPosition(), anglefile.front().first,Karts[0]->back);
glUniform3fv(uLightDir_vs, 1, glm::value_ptr(glm::rotate(ViewMatrix,Karts[0]->getAngle()+90, glm::vec3(0,1,0))));
//Kart (boucle sur tous les karts)
for (int id=0;id<8;++id){
if((id!=0 && ready) || raceFinished ){
//Deplacement IA
int sortie=Karts[id]->moveIA(track.getMapObjects(),track.getPowObjects(), Karts,Players[id]->getPower(),
Players[id]->getCharacter().getHero(), Players[id]->getCharacter().isPowerReady(tStart));
if(sortie==1)
Players[id]->usePower(Karts,id,tStart,track.getMapObjects());
else if(sortie==2)
Players[id]->getCharacter().useSuperPower(tStart,*Karts[id],track.getMapObjects());
}else{
Karts[id]->crossANode();
}
Karts[id]->getVAO().bind(); //Bind du VAO
Karts[id]->TransfoMatrix(ViewMatrix,Karts[id]->getPosition()); //Transformations (View, Translation, anglerotation,scale)
Karts[id]->MatrixToShader(uMVMatrix, uMVPMatrix, uNormalMatrix, WINDOW_WIDTH, WINDOW_HEIGHT); //Envoi des matrices au shader
Karts[id]->Draw(uTex); //Draw de l'objet
//Pouvoirs Classiques
if(Players[id]->getPower()){
if(Players[id]->getPower()->isLaunched() && Players[id]->getPower()->withKart()){
Players[id]->getPower()->getVAO().bind(); //Bind du VAO
Players[id]->getPower()->TransfoMatrix(ViewMatrix, Players[id]->getKart().getPosition()); //Transformations (View, Translation, anglerotation,scale)
Players[id]->getPower()->MatrixToShader(uMVMatrix, uMVPMatrix, uNormalMatrix, WINDOW_WIDTH, WINDOW_HEIGHT); //Envoi des matrices au shader
Players[id]->getPower()->Draw(uTex); //Draw de l'objet
}
if(Players[id]->getPower()->isLaunched() && Players[id]->getPower()->isPerimed(tStart)){
Players[id]->stopPower(Karts,id);
}
}
//Pouvoirs Speciaux
if(Players[id]->getCharacter().isLaunched()){
if(Players[id]->getCharacter().isPerimed(tStart)){
Players[id]->getCharacter().useSuperPowerBack(Players[id]->getKart());
Players[id]->getCharacter().hitSuperPowerBack(Karts);
}
else {
Players[id]->getCharacter().continuousHitSuperPower(Karts,Players[id]->getKart());
}
}
}
//Dessin des objets de la map
for(int id=0;id<track.getMapObjects().size();++id){
if(track.getMapObjects()[id]->isVisible()){
track.getMapObjects()[id]->getVAO().bind();
track.getMapObjects()[id]->movePower();
track.getMapObjects()[id]->TransfoMatrix(ViewMatrix, track.getMapObjects()[id]->getPosition());
track.getMapObjects()[id]->MatrixToShader(uMVMatrix, uMVPMatrix, uNormalMatrix, WINDOW_WIDTH, WINDOW_HEIGHT);
track.getMapObjects()[id]->Draw(uTex);
}
if(track.getMapObjects()[id]->tooFar()){
delete(track.getMapObjects()[id]);
track.getMapObjects().erase(track.getMapObjects().begin()+id);
id--;
}
else if(track.getMapObjects()[id]->isPerimed(tStart)){
track.getMapObjects()[id]->hitKartBack(Karts);
delete(track.getMapObjects()[id]);
track.getMapObjects().erase(track.getMapObjects().begin()+id);
id--;
}
}
//Dessin des pouvoirs de la map
for (std::vector<PowerObject*>::iterator it = track.getPowObjects().begin() ; it != track.getPowObjects().end(); ++it){
if((*it)->isVisible()){
(*it)->getVAO().bind();
(*it)->rotateObj();
(*it)->TransfoMatrix(ViewMatrix, (*it)->getPosition());
(*it)->MatrixToShader(uMVMatrix, uMVPMatrix, uNormalMatrix, WINDOW_WIDTH, WINDOW_HEIGHT);
(*it)->Draw(uTex);
}
if((*it)->isPerimed(tStart)){
(*it)->visible=true;
}
}
//Gestion des collisions
for (int idkart=0;idkart<8;++idkart){ // Boucle sur tous les karts
//Collision avec les autres objets de la map
for (std::vector<Object3D*>::iterator it_mapObjects = track.getMapObjects().begin() ; it_mapObjects != track.getMapObjects().end(); ++it_mapObjects){ // Boucle sur tous les objets de la map
if(Karts[idkart]->isInCollision( **it_mapObjects )){
if(((*it_mapObjects)->hitKart(*Karts[idkart],idkart, tStart))==0){
Karts[idkart]->avoidCollision( **it_mapObjects );
Karts[idkart]->move(-1); // Fais ralentir le kart quand il est en collision
}
}
}
//Collision avec les pouvoirs ramassables de la map
for (std::vector<PowerObject*>::iterator it_powObjects = track.getPowObjects().begin() ; it_powObjects != track.getPowObjects().end(); ++it_powObjects){ // Boucle sur tous les objets de la map
if(Karts[idkart]->isInCollision( **it_powObjects )){
Players[idkart]->pickPower(**it_powObjects,tStart);
(*it_powObjects)->visible=false;
}
}
//Collision avec les autres Karts
//>>>>>>>>>>>>>>>>>>>>> Boucle sur le reste des karts, permet d'éviter de tester 2 fois la même collision (kart1/kart2 et kart2/kart1 par exemple)
for (int idotherkart = idkart+1 ; idotherkart <8; ++idotherkart){ // Boucle sur le reste des karts
if(Karts[idkart]->intouchable || Karts[idotherkart]->intouchable)
continue;
if(Karts[idkart]->isInCollision( *Karts[idotherkart] )){
Karts[idkart]->avoidCollision( *Karts[idotherkart] );
Karts[idkart]->move(-1); // Fais ralentir le kart quand il est en collision
Players[idkart]->getCharacter().hitSuperPower(tStart, Karts, idotherkart, *Karts[idkart]); //Pouvoir spécial kart1 sur kart2
Players[idotherkart]->getCharacter().hitSuperPower(tStart, Karts, idkart, *Karts[idotherkart]); //Pouvoir spécial kart2 sur kart1
}
}
//Collision avec les bords de la map
Karts[idkart]->collisionWithMap(track.getLargeur(), track.getLongueur());
}
/* for(int i=0; i<8; ++i){
finalRankQuad[i].initDraw();
finalRankQuad[i].bindTex(textureRank[i]);
finalRankQuad[i].Draw(locVarTexture);
}
*/
//getFinalRanking(Players, textSurfaces, font);
// showRankSurfaces(rankSurfaces, screen, positionSurfaces);
// std::cout << "Votre classement : " << Karts[0]->getRank() << std::endl;
//std::cout << "NbNodesPassed : " << Karts[0]->getNbNodesPassed() << std::endl;
if((float)Karts[0]->getNbNodesPassed()/track.getNbNodes() == track.getNbLaps() ){
raceFinished = true;
}
//Sky
sky.getVAO().bind();
sky.setAngle(tStart*0.001f);
sky.TransfoMatrix(ViewMatrix,Karts[0]->getPosition());
sky.MatrixToShader(uMVMatrix, uMVPMatrix, uNormalMatrix, WINDOW_WIDTH, WINDOW_HEIGHT);
sky.Draw(uTex);
VAO::debind();
SDL_Event e;
while(SDL_PollEvent(&e)) {
switch(e.type) {
case SDL_QUIT:
done = true;
sortie=-1;
break;
case SDL_KEYDOWN:
switch(e.key.keysym.sym){
case 'n':
std::cout << "You pick an Attack_Front" << std::endl;
Players[0]->pickPower(atk_front,tStart);
obj=Players[0]->getPower();
break;
case 'b':
std::cout << "You pick a Boost" << std::endl;
Players[0]->pickPower(boost,tStart);
break;
case 'v':
std::cout << "You pick an Attack_back" << std::endl;
Players[0]->pickPower(atk_back,tStart);
obj=Players[0]->getPower();
break;
case 'c':
std::cout << "You pick a Trap" << std::endl;
Players[0]->pickPower(trap,tStart);
obj=Players[0]->getPower();
break;
case 'x':
std::cout << "You pick a Shield" << std::endl;
Players[0]->pickPower(shield,tStart);
break;
case 'z':
std::cout << "You pick an Attack_All" << std::endl;
Players[0]->pickPower(atk_all,tStart);
break;
case 'm':
std::cout << "You have been hit" << std::endl;
if(obj)
obj->hitKart(*Karts[0], 0, tStart);
break;
case SDLK_SPACE:
if(ready)
Players[0]->usePower(Karts,0,tStart,track.getMapObjects());
break;
case SDLK_ESCAPE:
sortie=0;
done=true;
break;
case 'p':
sortie = redirectionPause();
if(sortie==-1)
done = true;
std::cout << sortie << std::endl;
break;
case 'q':
if(ready){
if(!Players[0]->getCharacter().isPowerReady(tStart))
break;
switch(Players[0]->getCharacter().getHero()){
case JOHN :
son = Mix_LoadWAV("../sounds/John.wav");
Mix_VolumeChunk(son, MIX_MAX_VOLUME);
Mix_PlayChannel(-1, son, 0);
break;
case KLAUS :
son = Mix_LoadWAV("../sounds/Klaus.wav");
Mix_VolumeChunk(son, MIX_MAX_VOLUME);
Mix_PlayChannel(-1, son, 0);
break;
case DOUG :
son = Mix_LoadWAV("../sounds/Doug.wav");
Mix_VolumeChunk(son, MIX_MAX_VOLUME);
Mix_PlayChannel(-1, son, 0);
break;
case CANADA :
son = Mix_LoadWAV("../sounds/Captain.wav");
Mix_VolumeChunk(son, MIX_MAX_VOLUME);
Mix_PlayChannel(-1, son, 0);
break;
case BURT :
son = Mix_LoadWAV("../sounds/Burt.wav");
Mix_VolumeChunk(son, MIX_MAX_VOLUME);
Mix_PlayChannel(-1, son, 0);
break;
case MCKORMACK :
son = Mix_LoadWAV("../sounds/Mac.wav");
Mix_VolumeChunk(son, MIX_MAX_VOLUME);
Mix_PlayChannel(-1, son, 0);
break;
case STEVE :
son = Mix_LoadWAV("../sounds/Steve.wav");
Mix_VolumeChunk(son, MIX_MAX_VOLUME);
Mix_PlayChannel(-1, son, 0);
break;
case STAN :
son = Mix_LoadWAV("../sounds/Stan.wav");
Mix_VolumeChunk(son, MIX_MAX_VOLUME);
Mix_PlayChannel(-1, son, 0);
break;
case JENNIFER :
son = Mix_LoadWAV("../sounds/Jennifer.wav");
Mix_VolumeChunk(son, MIX_MAX_VOLUME);
Mix_PlayChannel(-1, son, 0);
break;
}
Players[0]->getCharacter().useSuperPower(tStart,*Karts[0],track.getMapObjects());
}
break;
}
break;
default:
break;
}
}
Uint8 *keystate = SDL_GetKeyState(NULL);
if(ready && !raceFinished){
if ( keystate[SDLK_UP] ) Karts[0]->move(1);
if ( keystate[SDLK_DOWN] ) Karts[0]->move(-1);
if (!keystate[SDLK_UP] && !keystate[SDLK_UP]) Karts[0]->move(0);
if ( keystate[SDLK_LEFT] ){ Karts[0]->rotate(1); anglefile.push(std::pair<float,Uint32>(Karts[0]->getAngle(),tStart));}
if ( keystate[SDLK_RIGHT] ){ Karts[0]->rotate(-1); anglefile.push(std::pair<float,Uint32>(Karts[0]->getAngle(),tStart));}
}
// Mise à jour de la fenêtre (synchronisation implicite avec OpenGL)
SDL_GL_SwapBuffers();
Uint32 tEnd = SDL_GetTicks();
Uint32 d = tEnd - tStart;
if(d < FRAME_DURATION) {
SDL_Delay(FRAME_DURATION - d);
}
timeElapsed++;
}
std::cout << "Nettoyage" << std::endl;
CleanObjects(track);
return sortie;
}
