Pues para añadir dos motoreres LGPL a la lista pongo estos que tb estan muy bien:

NeoEngine
Multiplataforma, Bsp, Animaciones Esqueleticas, Sombras dinamicas, Carga de ms3d 3ds bsp y tb de los modelos del doom3 (ascii), Colisiones, sitemas de audio y red etc

http://neoengine.sourceforge.net/

Crystal Space
Todas las features de antes menos los modelos de doom3 con muchas mas.

http://crystal.sourceforge.net/drupal/


Ya solo te queda ver cual es el que mejor se adapta a tus caracteristicas. Tengo que decir que el NeoEngine es mas facil de usar y que el Crytal ofrece muchas mas posibilidades (pero si no las vas a usar...)

Suerte

 ¿Donde se compra tu libro?

:huh:  

 ya estoy colaborando enviandoselo a todos mis contactos. Es lo menos que puedo hacer.

Animo y ayudad.  (ole)  (ole)  (ole)  

 Sobre el tema de patentes. Noticia sacada de www.codepixel.com:

Ya que estamos de moda con las patentes, en estados unidos ya tenemos una que a muchos nos interesa: se ha patentado el metodo de renderizar sombras usando el stencil buffer. Toma ya! como nadie usa esa tecnica! Cachis, a ver quien patenta la interpolacion, que tanto ha costado desarrollar en los costosos laboratorios... Si no os lo creeis, aqui teneis un enlace a la patente. Enlace

Increible  <_<  :angry:   (grrr)  (asco)  (nooo)  

lo digo por el concepto en si mismo, no entiendo la utilidad de conectar un compilador con el motor de un juego.

Supongo k se referira a meterle unas "funciones" nativas al compilador para carga de mayas, camara, texturas, etc etc etc. No es nada nuevo, (DIV,DIV2,BLITZ,...)

Respecto a lo de las licencias creo k no tienes la del vc6 asi k por ahi no podrias hacerlo sin comprarlo y creo k tampoco tienes la del motor del quake2 para comercializar (por k solo esta libre bajo GPL, eso tengo entendido).

 A ver, el "SDK" para programar OpenGL te lo suele traer el propio compilador (GL/gl.h, etc). Y son el propio s.o. y los drivers los que implementan los dlls o equivalente en linux.
Microsoft solo implementa la version de OpenGL 1.1 (por qué sera??) y las capacidades de 1.4 y en  breve 1.5 se manejan mediante extensiones.
(Hablo de oidas) En linux directamente implementan la mayor version de OpenGL por lo que no te hara falta menejar estas extensiones (repito, lo digo solo de oidas).
Para programar bajo windows, pues solo te bajas algo que dicen que es un sdk , que en verdad solo es un conjunto de tres .h para manejar las extensiones (comunes/windows/linux).
Si estas empezando creo que seria mejor programar con las funciones de OGL 1.1 que es nativo en windows y dejarte de cosas mas complicadas, para eso mirate infinidad de ejemplos que hay por internet, en Enlaces o Links de la seccion General de Programacion tienes muchos enlaces posteados por mi de opengl.
Si necesitas mas informacion de como programar las extensiones o cualquier cosa postealo.

PD: Si, escribo con k, y qué?  :P

 Sacado de internet. Es para Borland C++ Builder pero creo k con unas conversiones te sevira. AnsiString por std::string etc etc

Código [Seleccionar] Expand

#include <winsock2.h>

// ...

void __fastcall TForm1::Button1Click(TObject *Sender)
{
     WORD wVersionRequested;
     WSADATA wsaData;
     char name[255];
     AnsiString ip;
     PHOSTENT hostinfo;
     wVersionRequested = MAKEWORD( 2, 0 );

     if ( WSAStartup( wVersionRequested, &wsaData ) == 0 )
     {

           if( gethostname ( name, sizeof(name)) == 0)
           {
               Label1->Caption = name;
                 if((hostinfo = gethostbyname(name)) != NULL)
                 {
                       ip = inet_ntoa (*(in_addr *)*hostinfo->h_addr_list);
                       Label2->Caption = ip;
                 }
           }
           WSACleanup( );
     }
}

 http://openglforums.com Foros sobre TODOS los aspectos de openGL

 Estaba probando el articulo de edevi #3 sobre objetos autocacheables (me parece muy buen codigo) y al compilar con Visual C++ me doy cuenta de que sales muchoooos warnings, algo asi de 155. Segui probando y probando y no se de que seran los warnings, solo que es por el std::map.No es algo que importe ya que el codigo funciona a la perfeccion. Pero queda un poco ofuscado (vampiro rulez  :D ) lo de los mensajes del VC++.
Alguien sabe como corregir los warnings o por que pueden ser.
Saludos.

 Varias cosas aunque no lo pueda asegurar:

Segun el libro "Programacion en OpenGL" en el apartado de mezclas pone

Los argumento por defecto de glBlendFunc son GL_ONE y GL_ZERO

parece ser que no hace falta esto.

¿No deberia llamarse glEnable(GL_BLEND); antes de glBlendFunc?

Segun el mismo libro

GL_DST_ALPHA: El color de origen se multiplica por el valor alfa de destino. Microsoft OpenGL no lo soporta.

Lo que da que pensar en que version de OpenGL programas, la que viene por defecto en el win (1.1) o una actualizada (1.4) (crao k una actualizada por k si no no podrias usar dot3 en el otro topic)

¿Y poniendo el 2o glBlendFunc(GL_ONE,GL_DST_ALPHA); ?

¿El formato de pixel del contexto de dibujo es RGBA??

Si se me ocurre algo mas lo pongo. Suerte

 Pues si, estoy viendo que las virtuales es lo mejor. Como hariais vosotros por ejemplo un sistema de particulas en el k la fisica de estas pueda variar dentro de unas cuantas predefinidas, explosiones, agua,etc. Mi idea para eso era usar punteros a funciones miembro para poder cambiarlo en tiempo de ejecucion sin tener k poner los switch. De todos modos por ahora voy a poner una interfaz para los objetos k necesiten renderizarse con los metodos basicos.

 Vale, ok, ya esta todo!!!!  (ole)

bueno, se llama mediante:

(Mia.*(Mia.OnRender))();

kisiera volver a agradeceros todo  :D  :D  :D

PD: Los edit de los post caducan en nada

 Juan Mellado: He probado tu metodo y no da errores al compilar, pero si al llamar al puntero: "term does not evaluate to a function", he estado mirando por ahi lo de los punteros a miembros de clases y creo k deberia llamarse al puntero mediante
(Mia.*OnRender)(); pero no se puede  (nooo) , A ver si puedes sacarme de esta duda please, dejo el codigo:

Código [Seleccionar] Expand


class MyClass //: public IRender
{
public:
 void Render();
 void (MyClass::*OnRender) ();

 MyClass() {OnRender = &MyClass::Render;} // No da fallos si es solo MyClass::Render
            //pero como no se como va no toco
};

// Para llamar al puntero
MyClass Mia;
Mia.OnRender(); // Curioso error
// O si no com he visto googleando

(Mia.*OnRender)(); // Pero tampoco va


Lo que busque del google es:
http://www.lnf.infn.it/computing/doc/aixcx...ef/rnpt2mem.htm
http://www.clipx.net/ng/zc_ref/ng6a945.php

(nooo)  (nooo)  (nooo)

PD: Creia que iva a ser una pregunta tonta con su facil respuesta, pero veo que se ha saldio de 'principiantes'  ;)  

 Pensandolo voy a usar los dos metodos, es decir, derivas la clase de una clase base y usar puneros a funciones. El uso de punteros a funciones lo quiero para un renderizado mas rapido de los objetos, por ejemplo, si kiero usar sombras y luz pues apunto a esa funcion , si no apunto a otra, asi con lo basico. Y asi evito los if(g_bSombras), y poder cambiar el metodo Render en tiempo de ejecucion( que es para lo que lo kiero de verdad ). Lo de los metodos virtuales lo usare para renderizar varios objetos con diferente estructura y por lo tanto diferente forma de renderizarse. Incluire tambien punteros a funciones de otro tipo como IA, etc.

Gracias a todos por vuestra ayuda

 Pues mi idea (k no se si se podra llevar a cabo) es tener un formato de modelo k incluya animacion por frames, animacion por eskeleto, estatico, frustum culling etc, lo que queria hacer es lo siguiente:
Leo la informacion del archivo y si es un modelo estatico pues hace que OnRender apunte a una funcion k solo renderice un frame( ya k solo habra uno), si es de animacion, pues k interpole y renderize, si es un mapa k haga fustrum, para tener todo en un formato, no se si me explico.

Una idea k se me ha ocurrido para hacer esto es:

Código [Seleccionar] Expand


class MyClass
{
public:
   static void Render1(MyClass *Mia);
   static void Render2(MyClass *Mia);
   void (*OnRender)(MyClass*);
};


Lo malo es k para llamarla habra k pasarle la clase a la k se llama y en las funciones de render pues habra k estar poniendo Mia-> todo el tiempo. Pero no se me ocurre nada mejor para eso.
Auque ahora k me lo dices samsaga2 pues estaria bien usar virtuales pero no se donde lei k relentizaba el codigo  :blink: aunque no lo se a ciencia cierta.

PD: Por algo Carmack usa solo C, digo yo.