Hola, tengo un problema con visual c++. Normalmente uso Dev-c++ y no tengo ningun problema para compilar opengl y glut, tengo los archivos del linker bien puestos y va todo bien.
Pero prefiero programar en visual c++ porque me parece mejor compilador y el Dev-c a veces falla en la depuración.
Tengo este sencillo código:

Código [Seleccionar] Expand

#include <GL/glut.h>


int main (int argc, char **argv)
{
   glutInit (&argc, argv);
   return 0;
}



Al compilar con visual c++ 2008 todo bien pero a cuando pone "Vinculando..." (que es el linker) me da un error. (fatal error LNK1120: 1 externos sin resolver)

A ver si alguien sabe que librerias tengo que poner en el linker del proyecto para que vincule bien. Yo he puesto las mismas que pongo para el Dev-c:
glaux.lib
GLU32.LIB
glut32.lib
OPENGL32.LIB
gdi32.lib
winmm.lib

estan puestas en propiedades del proyecto/vinculador/entrada/dependencias adicionales.


Pero no funciona, tengo que tocar algun otro parametro en las propiedades del proyecto?? o falta alguna libreria ?? Esque ya probe de todo y no tengo ni idea de porque no vincula bien el visual c++.

Y otra pregunta: ¿alguien ha conseguido compilar los ejemplos de la sdk de opengl?? porque esos ejemplos no me los compila ni con dev-c ni con visual c++ claro.

Pues muchas gracias por toda la info, tendré que digerirla poco a poco.

y otra pregunta, la tecnica swap-last en que consiste? Intuyo que se coge el último objeto y se mete en el lugar donde se ha borrado el objeto, no?

Si ya se que soy principiante en c++...es mi primer código en c++ y con opengl.

Si tienes tiempo de contestarme gallo, ¿cual sería la forma correcta (sin matar la orientación a objetos) de hacer eso? Es decir, crear nuevos objetos disparo y borrarlos después según salen fuera de la pantalla.
Si puedes poner algun código de ejemplo te lo agradezco.

Pues estoy creando un jueguito con opengl y glut y el personaje principal que es la esfera roja tiene ke disparar a segun se mueve.
Los disparos los creo con new disparo, de la clase disparo, pero cuando llegan al limite de la pantalla llamo a borrar_disparo.
Sin embargo no se que ocurre que no se borra y vuelve a aparecer en el otro extremo de la pantalla.
A ver si alguien sabe porque pasa eso....

Código [Seleccionar] Expand

#include <GL/glut.h>
#include <time.h>
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <windows.h>
#include <iostream>

#define PI 3.141592
#define v_alto 10
#define v_ancho 10

#define radio_j 0.25
#define radio_d 0.1

using namespace std;

const int ancho = 800;
const int alto = 600;
int tecla_a,tecla_w,tecla_s,tecla_d;

class jugador;
class disparo;

disparo *dis[20];

void pintar_circulo (float radio);

class jugador
{
      public:
             jugador () {x = v_ancho * 0.5; y = v_alto * 0.5;}
             void mover(bool arriba,bool derecha,bool abajo,bool izquierda);
             void pintar ();
             void crear_disparo (float x,float y,int dir);
             void actualizar_disparos ();
             int num_d;
      private:
              float x,y;
               
}j;

class disparo
{
public:
      disparo (float x1,float y1,int direcion) : x(x1), y(y1) ,dir(direcion) {}
      void mover ();
      void pintar ();
      void borrar_disparo (disparo *d);
private:
         float x,y;
         int dir;
         
};

void jugador::mover (bool arriba,bool derecha,bool abajo,bool izquierda)
{
     float vel = 0.15f;
     if (arriba) {y += vel; crear_disparo (x,y,1);}
     if (abajo) {y -= vel; crear_disparo (x,y,3);}
     if (derecha) {x += vel; crear_disparo (x,y,2);}
     if (izquierda) {x -= vel; crear_disparo (x,y,4);}
     
     if (y < radio_j) y = radio_j;
     if (y > v_alto - radio_j) y = v_alto-radio_j;
     if (x < radio_j) x = radio_j;
     if (x > v_ancho - radio_j) x = v_ancho - radio_j;
     
     
}
void jugador::pintar ()
{

     glLoadIdentity ();
     glTranslatef (x,y,0);
     glColor3f (1,0,1);
     pintar_circulo (radio_j);
}
void jugador::crear_disparo (float x,float y,int dir)
{   
     if (num_d >= 2) return;
     dis[num_d] = new disparo(x,y,dir);
     num_d++; 
}
void jugador::actualizar_disparos ()
{
  for (int i = 0; i < num_d; i++)
  {
      disparo *d;
      d = dis[i];

      d->mover();
      d->pintar();

  }
}

void disparo::borrar_disparo (disparo *d)
{
     j.num_d--;
     delete d;
}

void disparo::mover()
{
     float vel = 0.1;
     if (dir == 1) y += vel;
     if (dir == 2) x += vel;
     if (dir == 3) y -= vel;
     if (dir == 4) x -= vel;
     
     if (y < -radio_d || y > v_alto + radio_d || x < -radio_d || x > v_ancho + radio_d){
           borrar_disparo (this);
     }
}

void disparo::pintar ()
{
     glLoadIdentity ();
     glTranslatef (x,y,0);
     glColor3f (1,0,0);
     pintar_circulo (radio_d);
}

void reshape (int width,int height)
{
     glViewport (0,0,width,height);
     glMatrixMode (GL_PROJECTION);
     glLoadIdentity();
     
   
    glOrtho (0, v_ancho, 0, v_alto, 0, 10);
     
     glMatrixMode (GL_MODELVIEW);

}



void pintar_escena()
{
     glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
     glLoadIdentity();
     //glTranslatef (0,0,-5);
     j.mover(tecla_w,tecla_d,tecla_s,tecla_a);
     j.pintar();
     j.actualizar_disparos ();
     glFlush();
     glutSwapBuffers();

}

void init ()
{   

     glClearColor (0,0,0,0);
     glEnable(GL_DEPTH_TEST);
}
     
void idle ()
{
     pintar_escena();
     
     
}   
     
void teclas_down (unsigned char key, int x, int y)
{
    if (key == 'w' || key == 'W') tecla_w = 1;
    if (key == 'a' || key == 'A') tecla_a = 1;
    if (key == 's' || key == 'S') tecla_s = 1;
    if (key == 'd' || key == 'D') tecla_d = 1;
}

void teclas_up (unsigned char key, int x, int y)
{
    if (key == 'w' || key == 'W') tecla_w = 0;
    if (key == 'a' || key == 'A') tecla_a = 0;
    if (key == 's' || key == 'S') tecla_s = 0;
    if (key == 'd' || key == 'D') tecla_d = 0;
}


int main (int argc, char **argv)
{
    glutInit (&argc,argv);
    glutInitDisplayMode (GLUT_DOUBLE | GLUT_RGB);
    glutInitWindowPosition (100,100);
    init();
    glutInitWindowSize (ancho,alto);
    glutCreateWindow ("Cubo 1");
   
    glutDisplayFunc (pintar_escena);
    glutReshapeFunc (reshape);
    glutIdleFunc (idle);
    glutKeyboardFunc (teclas_down);
    glutKeyboardUpFunc(teclas_up);
    glutMainLoop();
    return 0;
}             

void pintar_circulo (float radio)
{
     glBegin (GL_TRIANGLE_FAN);
             glVertex2f (0,0);
             for (float ang = 0; ang <= PI*2; ang += PI/8) glVertex2f (radio * cosf(ang),radio * sinf(ang));
     glEnd();
}


Gracias por los aportes ¡

Ahí está la ventaja de usar la clase "vector" como ya te ha mostrado Gallo. Solo un apunte, cada vez más se recomienda evitar el uso de los operadores new y delete siempre que sea posible, la librería STL hace un buen uso de la memoria. Por ejemplo puedes declarar un vector que no sea de punteros, crear los objetos y al eliminarlos con un "clear()" se llama a los destructores automáticamente.

Código [Seleccionar] Expand


std::vector<Bola> gridBolas;
gridBolas.resize(2); //crear dos objetos de Bola
gridBolas.clear(); //eliminar los objetos


Es mucho pedir un ejemplo de una clase por ejemplo "class bola" y luego el uso de vector para crear objetos y el uso de for para recorrerlos y para borrarlos usando STL...
perdonar si son muy noobs las preguntas...

Gracias de nuevo, y tienes razón, me faltan muchos conceptos de c++, vengo de programar con basic y era tan sencillo....
Bueno, resumiendo lo preguntado, necesito crear un array para cada tipo de objeto dinamico que contenga mi juego, sería una buena opcion no?

pd: en basic creaba objetos ilimitados sin estar contenidos dentro de ningun array y luego los recorria mediante for a.bola = each bola

pd2: si quisieras ponerme un ejemplo sencillo de creación de objetos de una clase mediante STL y su recorrido en un for, te lo agradeceria enormemente.

Muchas gracias por la ayuda, pero me preguntaba como se podría crear por ejemplo un emisor de particulas tal y como lo hacía con blit3d (en lenguaje basic).

Veo que en c++ es necesario guardar los objetos nuevos creados en un array para poder recorrerlos luego.
Pero, ¿ no hay ninguna forma de crear objetos de una clase "class bola" y luego recorrer esos objetos mediante un bucle for ?
Porque si entendí bien, siempre se necesita un array declarado como global en el programa para que las funciones puedan acceder a todos los objetos creados dentro del array, no?

Si por ejemplo tengo un juego donde hay varias naves, que disparan varias bolas, que a su vez cada bola emite particulas; tendría que crear 3 arrays globales al inicio del programa ?? uno para cada tipo de objetos multiples a crear, por ejemplo:

class nave {};
class bola {};
class particula {};

nave naves[];
bola bolas[];
particula particulas[]

si ahora quiero crear objetos de esas clases, la pregunta es ¿tengo que crearlos siempre dentro de un array para poder acceder a ellos mediante un bucle for ?? o hay otra manera mas sencilla ?
Porque si no siempre tengo un numero fijo de objetos a crear definido por el array y no puedo crear cuantos yo quiera como hacia con basic.

Hola a todos, soy nuevo en el foro y tengo una dudilla de c++.
¿como se pueden recorrer mediante un bucle todos los objetos de una clase creados con new?

Necesito tener muchos objetos de la clase "bola" y poder recorrerlos para gestionarlos.

pd: soy noob total en c++, gracias por vuestra ayuda.