yo veo el video bien, nose, sigues teniendo algun problema?

Vamos a ver. Lo que pretendo es que una luz sea direccional y apunte al centro, bien, la otra posicional, bien, y la última direccional pero que la dirección vaya cambiando y que ilumine también hacia las paredes pero no lo consigo.

Lo que hago es lo siguiente.

Declaro luzrdir como un vector de 3 elementos (lo he mirado y en este caso no hay cuarto parámetro, aunque por si acaso he probado con cuatro parámetros pero tampoco resulta),

Código [Seleccionar] Expand

GLfloat luzrdir[]={0,0,1};  // dirección de la luz roja

uso el mismo método para calcular la dirección que para calcular la posición y normalizo el vector por que creo que en algún sitio he leído que el vector debe estar normalizado  (también lo he hecho sin normalizar el vector y el resultado es el mismo), es decir,

   

Código [Seleccionar] Expand


luzrdir[0]=GLfloat(cos(tm *0.0005f)); // tm= tiempo transcurrido desde el inicio de la escena
luzrdir[1]=GLfloat(sin(tm *0.0005f));
luzrdir[2]=GLfloat(sin(tm *0.0005f));
NormalizarVector(luzrdir,luzrdir);

Nota: La funcion NormalizarVector aunque se vea rara funciona bien, no es el problema, lo he comprobado.

y después de las correspondientes rotaciones y translaciones y de dibujar la escena salvo las "luces",

Código [Seleccionar] Expand

glLightfv(GL_LIGHT0, GL_SPOT_DIRECTION,luzrdir);

también he probado antes de dibujar la escena pero haga lo que haga parece no tener ningún efecto sobre la dirección de la luz, siempre apunta al centro, y se me han acabado las ideas.

Se que las rotaciones y las traslaciones también afectan a las luces, quizás tenga algo que ver con eso, quizás si me planteo la escena de otra forma vea algún cambio.

De todas formas ya he empezado con otra cosa, llevo demasiado tiempo con esto, más adelante volveré con ello, aunque si tienes alguna idea lo probaré.

Gracias por tu interés.

  Lo que pretendía con la variable bbp es que si cambiaba el color de la ventana de opengl funcionara igualmente sin necesidad de modificar la función pero no, como he dicho antes solo funciona si configuro la pantalla con 16 bits de color y la ventan de opengl con 32 bits, es decir que solved lo que se dice solved no está aunque se puede apañar un video sabiendo esto  :D.

  Pero bueno, aunque todavía tengo dudas y no acabo de conseguir el efecto deseado (quizás sea mi método ) si he aprendido cosas sobre la iluminación y espero que las dudas que ahora tengo se vayan resolviendo con practica y pruebas. De moemnto doy el tema por zanjado.

Por si a alguien le puede servir de ayuda resumo lo que se ha dicho sobre el tema.

Propiedades de una luz:

Código [Seleccionar] Expand


glLightfv(GL_LIGHT0 + lightId, GL_POSITION , rawPosition);
glLightfv(GL_LIGHT0 + lightId, GL_AMBIENT  , m_properties.ambient);
glLightfv(GL_LIGHT0 + lightId, GL_DIFFUSE  , m_properties.diffuse);
glLightfv(GL_LIGHT0 + lightId, GL_SPECULAR , m_properties.specular);

glLightfv(GL_LIGHT0 + lightId, GL_EMISSION , m_properties.emission);
glLightf (GL_LIGHT0 + lightId, GL_SHININESS, m_properties.shininess);

glLightfv(GL_LIGHT0 + lightId, GL_SPOT_DIRECTION       , m_properties.spotDirection);
glLighti (GL_LIGHT0 + lightId, GL_SPOT_EXPONENT        , m_properties.spotExponent);
glLightf (GL_LIGHT0 + lightId, GL_SPOT_CUTOFF          , m_properties.spotCutOff);
glLightf (GL_LIGHT0 + lightId, GL_CONSTANT_ATTENUATION , m_properties.constantAttenuation);
glLightf (GL_LIGHT0 + lightId, GL_LINEAR_ATTENUATION   , m_properties.linearAttenuation);
glLightf (GL_LIGHT0 + lightId, GL_QUADRATIC_ATTENUATION, m_properties.quadraticAttenuation);


Ahi está mi codigo para poner los estados de la luz. Deberias mirar el MSDN para saber que parametros por defecto tienen esos valores ya que si pones otro, puedes activar la luz direccional o un spot light.

Creo que es muy importante esto que comenta lemoniac, recuerdo efectos rarísimos e incomprensibles con las luces y ahora entiendo que se debían a que pasaba como parametro a GL_SPOT_DIRECTION un vector de 3 elementos.

Un poco tarde, pero comento algo interesante (y básico): las coordenadas homogéneas.

Como en gráficos utilizamos matrices de 4x4 también necesitaremos vectores de 4 elementos para poder multiplicar (4x1 ó 1x4), de la forma (x, y, z, w)

Para verlo en 3d hay que proyectarlo dividiendo cada elemento por la w.

Así a groso modo:
- cuando w es igual a 0, el vector equivale a (x, y, z)
- cuando es 1, es lo mismo que el punto (x, y, z)
- cuando es distinto, equivale al punto (x/w, y/w, z/w)

Así que cuando pones una luz acabada en 0, estás haciendo una luz direccional, y cuando es distinto, puntual.

Y estas son las funciones que he utilizado para capturar una imagen y asi montar un pequeño video con el virtualdub, recordad que solo funcionan bien si la ventana esta configurada a 32 bits y la pantalla a 16.

Código [Seleccionar] Expand


bool WriteTga(const char*img_name, int sw, int sh, int bpp,unsigned char*buf)
{
char tga_name[1024];
FILE *tga;

strcpy(tga_name, img_name);
strcat(tga_name, ".tga");

tga = fopen(tga_name, "w");
if (!tga)
{
return false;
}

putc(0,tga);
putc(0,tga);
putc(2,tga);
putc(0,tga); putc( 0,tga); //maporg
putc(0,tga); putc( 0,tga); //maplen
putc(0,tga);
putc(0,tga); putc( 0,tga); // xorigin
putc(0,tga); putc( 0,tga); // yorigin
putc(sw,tga); putc( sw>>8,tga); // sw
putc(sh,tga); putc( sh>>8,tga); // sh
putc(bpp*8,tga);

putc( 0,tga); // flag 0x20 means: inverted image.

fwrite(buf,sw*sh*bpp,1,tga);

fclose(tga);
return true;
}



bool SaveScreen(const char* filename)
{
int sw = ANCHO;
int sh = ALTO;
//int bpp = COLOR/8;
GLenum format = GL_BGRA_EXT ;
bool ret;

// Reservamos memoria para almacenar los datos de la imagen
unsigned char* pdata = new unsigned char[sw*sh*4];
//Leemos del buffer de la pantalla
glReadBuffer(GL_BACK);
//Leemos los pixeles que nos interesan
glReadPixels(0,0,ANCHO,ALTO,format,GL_UNSIGNED_BYTE,pdata);
//Guardamos los datos como un archivo tga
ret = WriteTga(filename,sw,sh,4,pdata);
//Liberamos memoria
delete [] pdata;
return ret;
}
.

Espero que esto pueda servir de ayuda sobre todo a quien como yo estén empezando en esto de la programación gráfica con opengl.

Gracias de nuevo por los consejos.

Un saludo.

...

Se me olvidaba, el vídeo  :).

http://www.youtube.com/watch?v=86gT7YlnVHU

Ahora que dices eso de R y B creo que el formato más comodo es ABGR o algo así, no es el tipico RGBA, para que la obtencion sea más rapida creo que se suele cambiar a ese formato más comodo.

Yo no lo hice, pero la idea es tener un hilo que hace el volcado a disco y el correspondiente cambio de formato al que más te guste para escribir una TGA. Eso hace que el impacto en rendimiento sea menor.

  Ya funciona bien, ejem, bueno se como haver que no funcione mal  :D.

El formato es GL_BGRA o GL_BGRA_EXT aunque a mi solo me reconoce el segundo sera por que no uso GLUT, no se.

Hay algun fallo que no entiendo pero se como evitarlo.

...

  Línea que no se entendía bien.

int bpp = COLOR/8;

En la funcion que modifique comprobaba los parametros de la ventana mediante funciones, pero a parte de que la funcion usaba GLUT tampoco necesitaba comprbarlo por que la ventana la creo yo y controlo esos parametros. En esa linea lo unico que hago es convertir los bits que le paso a la función CreteGLWindow() en bytes para reservar memoria.

El error si iba por ahí aunque lo solucione cambiando la configuracion de pantalla. Para que funcione tiene que estar la pantalla a 16 bits
y la ventana a 32, solo funciona bien así  :-X Oo.

El caso es que ya tengo el video hecho, al final con el virtualdub, es muy fácil pero no lo entendia, he vuelto a prbar y di con la tecla. En otro momento lo subo.


  Gracias a todos por la ayuda y los consejos.

No se, supongo que tenéis razón pero además también es mas pesado, es que mi intención es hacer una intro de 64k con música y para eso hay que eliminar todo lo que no sea imprescindible. Más adelante quizás, aunque tampoco tengo muchas aspiraciones, simplemente me entro la curiosidad por saber como iba esto de opengl.

Un saludo.

Y tan raro, como que se ha solucionado solo, y no he cambiando nada, después de probar cambiando valores a ver si sonaba la flauta lo deje por imposible pero al día siguiente ya funcionaba, no se.

Aunque no esta bien del todo, mi intercambia los bytes R por el B, lo he solucionado, es fácil con un bucle, aunque imagino que cambiando algún parámetro sería mas correcto.

También he engañado al timer para que el futuro video valla a la misma velocidad que en el ejecutable y también guardo cada frame numerado, es decir, frame0001.tga,frame0002 ..., etc. Total tengo 1000 frames para un video de 30 segundos  pero con todos los programas que he probado no veo opción a que cada imagen sea un frame y no supero la velocidad de 1frame/5 segundos  ??? ¿Algún método o programa para hacerlo de forma simple? El último que he probado es el adobe premier 6.0 y me extraña que no tenga esa opción, supuestamente es un buen programa de edición de video.

 Pues me he puesto con lo de capturar una imagen.

He buscado información, he encontrado una función en un lado otra en otro ( creo entender las dos ) y  las he modificado para que funcionen con mi código. Justo antes de glClear();  guardo una imagen, arranco el programa y efectivamente se ha creado un TGA pero no sale como debería.




Las funciones que uso son estas.

Código [Seleccionar] Expand



bool WriteTga(const char*img_name, int sw, int sh, int bpp,unsigned char*buf)
{
char tga_name[1024];
FILE *tga;

strcpy(tga_name, img_name);
strcat(tga_name, ".tga");

tga = fopen(tga_name, "w");
if (!tga)
{
return false;
}

putc(0,tga);
putc(0,tga);
putc(2,tga);
putc(0,tga); putc( 0,tga); //maporg
putc(0,tga); putc( 0,tga); //maplen
putc(0,tga);
putc(0,tga); putc( 0,tga); // xorigin
putc(0,tga); putc( 0,tga); // yorigin
putc(sw,tga); putc( sw>>8,tga); // sw
putc(sh,tga); putc( sh>>8,tga); // sh
putc(32,tga);

putc( 0,tga); // flag 0x20 means: inverted image.

fwrite(buf,sw*sh*bpp,1,tga);

fclose(tga);
return true;
}

bool SaveScreen(const char* filename)
{
int sw = ANCHO;
int sh = ALTO;
int bpp = COLOR/8;
GLenum format = GL_RGBA ;
bool ret;

// Reservamos memoria para almacenar los datos de la imagen
unsigned char* pdata = new unsigned char[sw*sh*bpp];
//Leemos del buffer de la pantalla
glReadBuffer(GL_BACK);
//Leemos los pixeles que nos interesan
glReadPixels(0,0,ANCHO,ALTO,format,GL_UNSIGNED_BYTE,pdata);
//Guardamos los datos como un archivo tga
ret = WriteTga(filename,sw,sh,bpp,pdata);
//Liberamos memoria
delete [] pdata;
return ret;
}

  y simplemente antes de glClear();

Código [Seleccionar] Expand

if (frame==1)
{
SaveScreen("imagentga");
}


Te aconsejo que te pases a usar los tutoriales de nehe pero con el código que usa

GLUT + OPENGL

así y de primeras, tienes un código portable entre windows y linux.

o liarte con SDL ?=)

Aparte de la portabilidad ¿Cual es la diferencia? Es que tampoco tengo intención de programar bajo linux.

Ufff   ???, lo he mirado por encima y de momento creo que voy a seguir con los tutoriales de NEHE  :-X que me resultan mas sencillos  de entender, aunque me lo apunto para más adelante. El libro  me parece muy buena idea, además me gusta tener determinadas cosas en papel.

Lo del capturador de frames si que lo intentaré por que los programas que he probado van muuuy lentos, gracias por la información.

Un saludo.

 Gracias a los dos por los consejos.

No conocía lo del cuarto parámetro de la posición de la luz, que raro que no lo haya visto en ningún tutorial, y si, algo cambia aunque no acabo de entender del todo lo que pasa. Si es 0 la cosa queda como estaba, es decir da la sensación de que las luces son direccionales y apuntan al centro, y si es 1 no se si convierte en omni o es que la luz es más intensa, además tengo la duda de que el cubo exterior se ilumine correctamente cuando es 1, con el valor 0 la iluminación me parece mas coherente, quizás sea sensación mía.
Por otro lado no consigo cambiar la dirección de la luz o quizás si y por la forma de iluminar lo objetos del centro da la sensación de que apunta hacia ellos aunque no sea así, no estoy seguro.

La verdad es que es un poco comedura de tarro.

Lo que me comentas, Prompt, sobre tener cuidado con lo que activo pues más o menos ya me estaba dando cuenta solo, pero mis cabreos me pille por no entender como funcionaba, ahora lo veo mas claro.

Lo de las propiedades de la luz y del material también tengo por ahí un tutorial, creo entenderlo pero es fácil que se escape algo, son demasiados parámetros de repente.

Quizás debería hacer caso a Tamat y ponerme con los shaders, pero me dan miedo ¿Algún sitio para empezar a leer algo sobre el tema?

De todas formas tened en cuenta que acabo de empezar, creo que hay muchas cosas antes de eso ¿no?   además necesito cambiar de tercio.

Un saludo y gracias a los dos de nuevo, me vereís por aqui de vez en cuando, esto engancha la ostia, lastima que no tenga más tiempo libre.


PD: ¿Como es eso del capturador de frames?
He probado algún programa para hacer un video como dices, pero mi programa bajaba o 15 fps, no había caído en capturar los frames.

 Hola.

Llevo unos meses con esto de Opengl y aunque no lo llevo mal todavía estoy entendiendo como funciona todo.

Ahora mismo estoy con las luces y tengo bastantes dudas.

He conseguido meter varias luces simultaneas y emular una especie de bombillas de colores que se mueven pero tengo varios problemas.

Las luces siempre apuntan hacia el centro. He intentado cambiar la dirección de la luz pero no lo consigo, era lo que quería en principio y parece ser que por defecto apuntan al centro, pero ahora no puedo cambiar la dirección.

He leído en algún tutoríal que las luces pueden convertirse en direcionales pero a mi me ocurre lo contrario, siempre son direccionales ¿Como puedo hacer para que iluminen en todas direcciones? He probado con distintos valores con glLightf(GL_LIGHTx,   GL_SPOT_CUTOFF,valor) pero lo único que consigo son errores en la iluminación.

También tengo problemas al usar glColor3f(). Cuando uso glColor3f(), por ejemplo para el texto, desactivo las iluminación y después vuelvo a activarla pero el color que haya usado en glColor3f() influye en la iluminación. Lo que hago después de usar glColor3f() es establecer el color a blanco, así es como consigo los mejores resultados pero el problema es que cuando cambio los valores de glLightf (GL_LIGHTx, GL_SHININESS,   valor) estes no tienen efecto si el color establecido con glColor3f() es blanco, con lo cual deduzco que algo no estoy haciendo bien ¿Es normal eso?

  En principio a ver si me podéis ayudar con esto, gracias de antemano.

Me gustaría enseñaros mis progresos ¿A donde puedo subir un ejecutable?


Añado el código de la función InitGl() por si olvido algo

Código [Seleccionar] Expand


GLfloat Model_Ambient[]={0.05f,0.05f,0.05f,1.0f};

GLfloat L0_Diffuse []={0.6f,0.0f,0.0f,1.0f}; //Luz roja
GLfloat L1_Diffuse []={0.0f,0.6f,0.0f,1.0f}; // Luz verde
GLfloat L2_Diffuse []={0.0f,0.0f,0.6f,1.0f}; // Luz azul

glBlendFunc(GL_SRC_ALPHA,GL_ONE);
glShadeModel(GL_SMOOTH);
glClearColor(0.0f, 0.0f, 0.0f, 0.5f);
glClearDepth(1.0f);
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LEQUAL);
glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);

glLightModelfv(GL_LIGHT_MODEL_AMBIENT,Model_Ambient) ;

glLightfv(GL_LIGHT0, GL_DIFFUSE, L0_Diffuse );
glLightfv(GL_LIGHT0, GL_SPECULAR,L0_Diffuse );
glLightf (GL_LIGHT0, GL_SHININESS, 50);

glLightfv(GL_LIGHT1, GL_DIFFUSE, L1_Diffuse );
glLightfv(GL_LIGHT1, GL_SPECULAR,L1_Diffuse );
glLightf (GL_LIGHT1, GL_SHININESS, 50);

glLightfv(GL_LIGHT2, GL_DIFFUSE, L2_Diffuse );
glLightfv(GL_LIGHT2, GL_SPECULAR,L2_Diffuse );
glLightf (GL_LIGHT2, GL_SHININESS, 50);

return TRUE;

y la fución donde créo la escena

Código [Seleccionar] Expand

int Escena1(GLvoid)
{

GLenum tm=TIMER_GetScnTime();


if (escena1)
{
glDisable(GL_LIGHT0);
glDisable(GL_LIGHT1);
glDisable(GL_LIGHT2);
       // en el main() cambia el valor de nluces al pulsar espacio.
if (nluces & 1)
{
glEnable(GL_LIGHT0);
}
if (nluces & 2)
{
glEnable(GL_LIGHT1);
}
if (nluces & 4)
{
glEnable(GL_LIGHT2);
}

escena1=false;
}
camarapos[0]=GLfloat(cos((tm) *0.0004f)*15.0f);
camarapos[1]=GLfloat(cos((tm) *0.0004f)*5.0f);
camarapos[2]=GLfloat(sin((tm) *0.0005f)*15.0f);
NormalizarVector (camarapos,camaranormal);

luzrpos[0]=GLfloat(cos(tm *0.0005f)*6.0f);
luzrpos[1]=GLfloat(sin(tm *0.0006f)*4.0f);
luzrpos[2]=GLfloat(cos(tm *0.00065f)*6.0f);
NormalizarVector (luzrpos,luzrnormal);

luzgpos[0]=GLfloat(cos(tm *-0.00065f)*7.0f);
luzgpos[1]=GLfloat(cos(tm *0.0005f)*4.5f);
luzgpos[2]=GLfloat(sin(tm *0.0005f)*7.0f);
NormalizarVector (luzgpos,luzgnormal);

luzbpos[0]=GLfloat(cos(tm *0.0006f)*8.0f);
luzbpos[1]=GLfloat(sin(tm *-0.0005f)*5.0f);
luzbpos[2]=GLfloat(sin(tm *-0.00065f)*8.0f);
NormalizarVector (luzbpos,luzbnormal);

camara.posx=camaranormal[0]*9+camarapos[0];
camara.posy=camaranormal[1]*4+camarapos[1];
camara.posz=camaranormal[2]*9+camarapos[2];

camara.calcular(); 

glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glLoadIdentity();
glPushMatrix();


glRotatef(camara.rotx,1.0f,0,0);
glRotatef(360-camara.roty,0,1.0f,0.0f);
glTranslatef(-camara.posx, -camara.posy, -camara.posz );


glLightfv(GL_LIGHT0,GL_POSITION, luzrpos); // Luz 0 , luz roja
glLightfv(GL_LIGHT1,GL_POSITION, luzgpos); // Luz 1 , luz verde
glLightfv(GL_LIGHT2,GL_POSITION, luzbpos); // Luz 1 , luz azul

        glCallList(list); // dibujamos escena

glDisable(GL_LIGHTING);         //desastivamos luz para dibujar luces de color puro, sin efectos de luz

if (nluces & 1)
{
glPushMatrix();
glTranslatef(luzrpos[0],luzrpos[1],luzrpos[2]);    // dibujamos luz roja
glColor3f(0.1f,0.0f,0.0f);
glCallList(list+2);                                                   
glColor3f(1.0f,0.0f,0.0f);
glTranslatef(luzrnormal[0]*-0.2f, luzrnormal[1]*-0.2f,luzrnormal[2]*-0.2f );
glCallList(list+1);
glPopMatrix();
}
if (nluces & 2)
{
glPushMatrix();
glTranslatef(luzgpos[0],luzgpos[1],luzgpos[2]);    // dibujamos luz roja
glColor3f(0.0f,0.1f,0.0f);
glCallList(list+4);
glColor3f(0.0f,1.0f,0.0f);
glTranslatef(luzgnormal[0]*-0.2f, luzgnormal[1]*-0.2f,luzgnormal[2]*-0.2f );
glCallList(list+3);
glPopMatrix();
}
if (nluces & 4)
{
glPushMatrix();
glTranslatef(luzbpos[0],luzbpos[1],luzbpos[2]);    // dibujamos luz roja
glColor3f(0.0f,0.0f,0.1f);
glCallList(list+6);
glColor3f(0.0f,0.0f,1.0f);
glTranslatef(luzbnormal[0]*-0.2f, luzbnormal[1]*-0.2f,luzbnormal[2]*-0.2f );
glCallList(list+5);
glPopMatrix();
}

glColor3fv(objeto3d.color3f);

glPopMatrix();

glFlush();
frame++;

        return TRUE;
}

Cualquier consejo sobre el código será bien recibido, mis conocimientos de C son muy básicos.

Voy a colgar unas imágenes para ilustrar lo que he hecho.

Un saludo.








Edito, he cambiado unas líneas que no estaban muy profesionales, no recordaba como se hacían operaciones lógicas  :-[, llevo años sin programar.

 Yuuuuupi  :) soy feliz.

Muchas gracias, llevo varios dias intentando de diferentes formas apartar las funciones de gestion de ventana a un fichero independiente y entre que no tengo mucha idea de c++ y que no entiendo muy bien como funciona el visual studio me estaba empezando a desesperar con los errores.

La verdad no entiendo  bien lo que me has dicho ni las funciones de gestion de ventana pero funciona, y lo mas importante he conseguido crear mi primera clase, aunque sea copiada me vale pare entender como funcionan, y ahora puedo centrarme en opengl y en ordenar mejor mis proyectos que es lo que quería.

Un saludo y gracias de nuevo.

Hola a todos, soy nuevo en el foro, buscando informacion sobre programacion grafica he llegado hasta aqui, a ver si podeis ayudarme.

Estoy empezando con opengl con los tutoriales de NEHE y aunque mis conocimeintos de C son básicos no tengo problemas para entender las lecciones de nehe.

El problema es que el codigo empieza a ser damasiado largo para un solo fichero.

Empiezo a buscar informacion sobre clases y una vez que creo tenerlo todo mas o menos claro empiezo a crear una clase con las funciones que gestionan la ventana de opengl.

He creado el fichero "nehewiondow.h" que queda asi.

#ifndef _NEHEWINDOW_H_
#define _NEHEWINDOW_H_

class nehewindow
{
private:
   HDC         hDC;      // Private GDI Device Context
   HGLRC      hRC;      // Permanent Rendering Context
   HWND      hWnd;      // Holds Our Window Handle
   HINSTANCE   hInstance;      // Holds The Instance Of The Application

   bool   keys[256];         // Array Used For The Keyboard Routine
   bool   active;      // Window Active Flag Set To TRUE By Default
   bool   fullscreen;   // Fullscreen Flag Set To Fullscreen Mode By Default

   GLfloat LightAmbient[4];
   GLfloat LightDiffuse[4];
   GLfloat LightPosition[4];

public:
   //contructor
   nehewiondow(void);
   // SetThings
   void sethDC(HDC a);
   void sethRC(HGLRC a);
   void sethWnd(HWND a);
   void sethInstance(HINSTANCE a);

   void setkeys(unsigned int i, bool a);
   void setactive(bool a);
   void setfullscreen(bool a);

   // GetThings
   HDC gethDC(void);
   HGLRC gethRC(void);
   HWND gethWnd(void);
   HINSTANCE gethInstance(void);

   bool getkeys(unsigned int a);
   bool getactive(void);
   bool getfullscreen(void);
   //
   LRESULT   CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM);   // Declaration For WndProc
   GLvoid ReSizeGLScene(GLsizei width, GLsizei height);
   int InitGL(GLvoid);
   GLvoid KillGLWindow(GLvoid)   ;
   BOOL CreateGLWindow(char* title, int width, int height, int bits, bool fullscreenflag);

};

#endif

y despues he ido copiando las funciones al fichero "nehewindow.cpp".
Todo iba bien hasta que llegue a (copio solo a cabecera y el lugar del error para no hacer demasiado largo esto)

BOOL nehewindow::CreateGLWindow(char* title, int width, int height, int bits, bool fullscreenflag)
{
      .
      .
      .
   wc.lpfnWndProc      = (WNDPROC) WndProc;               // WndProc Handles Messages
         .
      .
      .
   
}
aqui me da el error

error C2440: 'type cast' : cannot convert from '' to 'long (__stdcall *)(struct HWND__ *,unsigned int,unsigned int,long)'
        None of the functions with this name in scope match the target type

Esa misma linea en la funcion que esta en el fichero del main no da errores  :-X.

He partido de la leccion 8 de nehe ( http://nehe.gamedev.net/data/lessons/lesson.asp?lesson=08 ) ahí esta todo el código, he copiado las funciones tal cual, si es necesario el resto del fichero "nehewindow.cpp" me lo decis aunque es un poco largo y como he dicho las funciones estan copiadas tal cual de la lecion 8 de nehe por lo que se supone que estan bien.

Gracias de antemano.