[Opengl/C++] Aiuto su semplice gioco

[Wall4c3]

Ciao a tutti!
Volevo dei consigli su come realizzare un semplice gioco in C++ e Opengl.
Volevo realizzare un gioco di macchine tipo il giocatore deve schivare (usando le frecce della tastiere ) le macchine che gli vengono incontro ( vedere immagine allegata anche se fa schifo rende l idea :D ).
Ovviamente utilizzando texture , etc..
Volevo alcuni consigli su come realizzare il movimento delle macchine, dello sfondo, come realizzare le macchine, ovvero se creare dei semplici rettangoli e poi applicare una texture sopra o creare degli oggetti 3d ( utilizzo Blender ) e poi importarli (in formato Ase)
Grazie :)

[Tommo]

Lunghezza stimata della risposta: 2 o 3 cento pagine :asd:
Quello che stai chiedendo non è difficilissimo, però hai chiesto _tutto_ :D

Prova a vederti prima qualche tutorial che spiega proprio queste semplici cose passo passo, tipo quelli NeHe anche se sono parecchio veci ormai.

Magari se sei proprio a digiuno, prova prima un motore già fatto tipo Ogre o una libreria più di alto livello come XNA (in C#) così ti fai un'idea di come devi astrarre le parti di alto livello, es: matrici world view e proj per gestire le posizioni, loading delle textures, delle meshes, mettere su i materiali + shaders ecc...

Considera che con OpenGL ti troverai per il 90% del tempo a scrivere roba di basso livello completamente estranea al "muovere 2 macchine"...
se stai imparando grafica 3d bene, ma altrimenti ti consiglio qualcosa di prefabbricato come sopra.
Ti aiuterà anche a capire "come ragionano i pro", per evitare di reinventare la ruota ma quadrata :asd:

[Wall4c3]

Grazie della risposta :)
allora diciamo che parecchie cose le conosco avendo seguito il corso Informatica Grafica all' università...ora devo sviluppare un piccolo progetto per l esame ( io avevo pensato a questo semplice giochino perchè non voglio perdere tanto tempo , se avete altre idee sono ben accette :) ) in C++ e Opengl (utilizzo anche glut) ( quindi non mi posso appoggiare ad altre soluzioni ).
Parto da questo template predefinito

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

GLint FPS = 30;

int spin_x = 0, old_x = 0;
int spin_y = 0, old_y = 0;

int fase = 0;


void menu(int op) {

switch(op) {
case 'Q':
case 'q':
exit(0);
}
}

/*
* invocata da GLUT quando un tasto viene premuto
*
* key - tasto premuto
* x, y - coordinate del cursore del mouse
*/
void keyboardDown(unsigned char key, int x, int y) {

switch(key) {
case 'Q':
case 'q':
case 27: // ESC
exit(0);
}
}

/*
* invocata da GLUT quando un tasto viene rilasciato
*
* key - tasto premuto
* x, y - coordinate del cursore del mouse
*/
void keyboardUp(unsigned char key, int x, int y) {}


void reshape(int width, int height)
{
GLfloat fieldOfView = 45.0f;
glViewport (0, 0, (GLsizei) width, (GLsizei) height);

glMatrixMode (GL_PROJECTION);
glLoadIdentity();
gluPerspective(fieldOfView, (GLfloat) width/(GLfloat) height, 0.1, 500.0);

glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
}


void mouseClick(int button, int state, int x, int y)
{
old_x = x;
old_y = y;

glutPostRedisplay();
}


void mouseMotion(int x, int y)
{
spin_x = x - old_x;
spin_y = y - old_y;

glutPostRedisplay();
}

/*
* disegna gli assi
*
* lenght - lunghezza degli assi
*/
void DrawAxes(float length)
{
glPushMatrix();
glScalef(length, length, length);

glLineWidth(2.f);
glBegin(GL_LINES);

// x red
glColor3f(1.f, 0.f, 0.f);
glVertex3f(0.f, 0.f, 0.f);
glVertex3f(1.f, 0.f, 0.f);

// y green
glColor3f(0.f, 1.f, 0.f);
glVertex3f(0.f, 0.f, 0.f);
glVertex3f(0.f, 1.f, 0.f);

// z blue
glColor3f(0.f, 0.f, 1.f);
glVertex3f(0.f, 0.f, 0.f);
glVertex3f(0.f, 0.f, 1.f);

glEnd();
glLineWidth(1.f);

glPopMatrix();
}

/*
* disegna la scena
*/
void draw()
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();

gluLookAt( 2, 2, 2,
0, 0, 0,
0, 1, 0);

glTranslatef(-3.f, -3.f, -3.f);
glRotatef(spin_y, 1.0, 0.0, 0.0);
glRotatef(spin_x, 0.0, 1.0, 0.0);


DrawAxes(2.0);


glColor3f( .4f, .4f, .4f );
glutSolidCube(2.f);

glFlush();
glutSwapBuffers();
}

/*
* invocata ogni volta che non ci sono eventi pendenti da processare
*/
void idle() { }

/*
* inizializza lo stato di OpenGL
*
* width, height - larghezza e altezza della finestra OpenGL
*/
void initGL(int width, int height)
{
// colore e tipo delle luci
GLfloat light_ambient_0[] = {0.65, 0.65, 0.65, 1.0};// colore ambiente della luce 0
GLfloat light_diffuse_0[] = {1.0, 1.0, 1.0, 1.0}; // colore diffusione della luce 0
GLfloat light_specular_0[] = {1.0, 1.0, 1.0, 1.0}; // colore speculare della luce 0
GLfloat light_position_0[] = {5.0, 5.0, 0.0, 0.0}; // posizione della luce 0

glLightfv (GL_LIGHT0, GL_AMBIENT, light_ambient_0);
glLightfv (GL_LIGHT0, GL_DIFFUSE, light_diffuse_0);
glLightfv (GL_LIGHT0, GL_SPECULAR, light_specular_0);
glLightfv (GL_LIGHT0, GL_POSITION, light_position_0);

glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);

glEnable(GL_COLOR_MATERIAL);
glColorMaterial(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE);

reshape(width, height);

glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
glClearDepth(1.0f);

glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LEQUAL);
}


void animation(int t)
{
switch (fase) {
case 0: // fase di pausa
break;
case 1: // prima fase di animazione
glutPostRedisplay();
break;
}
glutTimerFunc((int) 1000/FPS, animation, 0);

}

/*
* inizializza GLUT, registra le callback, entra nel main loop
*
* argc : numero di parametri di ingresso
* argv : vettore degli argomenti di ingresso
*
* nota: argc e argv aiutano a capire quali sono i parametri di ingresso passati da linea di comando
*/
int main(int argc, char** argv)
{
int width = 800;
int eight = 600;

glutInit(&argc, argv);

glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
glutInitWindowSize(width, eight);
glutInitWindowPosition(100, 100);
glutCreateWindow("Perspective's GLUT Template");

// registra le callback
glutKeyboardFunc(keyboardDown);
glutKeyboardUpFunc(keyboardUp);
glutMouseFunc(mouseClick);
glutMotionFunc(mouseMotion);
glutReshapeFunc(reshape);
glutDisplayFunc(draw);
glutIdleFunc(idle);
glutTimerFunc((int) 1000/FPS, animation, 0);
glutIgnoreKeyRepeat(false); // process keys held down

// crea un sottomenu
int subMenu = glutCreateMenu(menu);
glutAddMenuEntry("Do nothing", 0);
glutAddMenuEntry("Really Quit", 'q');

// crea il menu principale (apribile con click destro)
glutCreateMenu(menu);
glutAddSubMenu("Sub Menu", subMenu);
glutAddMenuEntry("Quit", 'q');
glutAttachMenu(GLUT_RIGHT_BUTTON);

// inizializza lo stato di OpenGL
initGL(width, eight);

// entra nel rendering loop
glutMainLoop();
return 0;
}

ovviamente non voglio la soluzione :) , ma solo dei consigli.
Grazie :)

[fero86]

il template predefinito che hai postato non so dove tu l'abbia pescato ma é preistorico, a parte le chiamate glu e glut contiene quasi esclusivamente funzioni deprecate :D

[Tommo]

Quanto ci butti che glielo ha dato il prof :asd:

Cmq con GL non ti posso aiutare, mai usata :D
Lo scheletro (apparte la vecchiezza) mi sembra adeguato, certo fare la stessa cosa in maniera più generica può impiegare dalle 10 alle 50 classi :asd:

[Wall4c3]

si è del prof :D
ok grazie lo stesso Tommo ;)

[fero86]

Wall4c3, di' al tuo prof di dare un'occhiata a questo file: http://www.opengl.org/registry/doc/glspec32.compatibility.20090803.pdf
le cose scritte in rosso sono deprecate. direi che é giunta l'ora di aggiornare il corso :asd:

un suggerimento costruttivo per lui: usare solo la roba scritta in questi due files:
http://www.opengl.org/registry/doc/glspec32.core.20090803.pdf
http://www.opengl.org/registry/doc/GLSLangSpec.1.50.09.pdf