[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 ).
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
Quello che stai chiedendo non è difficilissimo, però hai chiesto _tutto_

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

[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

[Tommo]

Quanto ci butti che glielo ha dato il prof

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

[Wall4c3]

si è del prof
ok grazie lo stesso Tommo

[fero86]

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

un suggerimento costruttivo per lui: usare solo la roba scritta in questi due files:
http://www.opengl.org/registry/doc/g...e.20090803.pdf
http://www.opengl.org/registry/doc/G...ec.1.50.09.pdf