Luego de leerme todo y no encontrar la funcion, supuse que no existia, pero me parecio raro que no la tenga ... o sea ... es casí obvio que si vas a dar soporte a OpenGL deberias facilitar el juego de funciones basicas.

O sea ... deberia proponer que existan:

Código [Seleccionar] Expand

#define SDL_GL_MIPMAPS               0x0001
#define SDL_GL_MINFILTERLINEAR 0x0002
#define SDL_GL_MAXFILTERLINEAR 0x0004
#define SDL_GL_TODOLOOTRO       0xXXXX

bool SDL_GLGenTexture1d(SDL_Surface *s, int Caracteristicas, int &TexturaId);
bool SDL_GLGenTexture2d(SDL_Surface *s, int Caracteristicas, int &TexturaId);
bool SDL_GLGenTextureCubeMap(SDL_Surface *s[6], int Caracteristicas, int &TexturaId);
Pero supongo que es algo con la filosofia de OpenGL ...
Gracias a todos.
Saludos.

No entiendo... ¿no te sirvió el código que te puse antes?... a mi me funciona.

Saludos.

 Se me olvidaba, IMG_LoadPNG_RW(rwop); carga PNG, si quieres que cargue otro tipo de textura simplemente cambiale PNG por BMP, TGA, JPG o lo que necesites, si tienes dudas revisa la documentación.

 Hola Pogacha, cargar texturas con SDL es muy fácil, solo tienes que bajar una librería que se llama SDL_image ( http://www.libsdl.org/projects/SDL_image/ ), uncluir el .h y . lib en tu proyecto y después usar el siguiente código:


Estas variables deben ser globales (o privadas dentro de una clase si estás usando POO).

Código [Seleccionar] Expand


SDL_RWops *rwop;  //variable de SDL_imagen
SDL_Surface *image; //variable de SDL_imagen
GLuint texture; //identificador de textura de OpenGL


Después usas el siguiente código para saber si existe el archivo, considera que BUFF contiene el nombre del archivo:

Código [Seleccionar] Expand

rwop=SDL_RWFromFile(BUFF, "rb");
if(rwop) image=IMG_LoadPNG_RW(rwop);
else
{
  printf("No existe el archivo");
}


//Verificas que la textura se haya podido guardar bien y si es así, cargas en Memoria:

if(image)
{
 
   glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
   glGenTextures(1,&texture );
   glBindTexture(GL_TEXTURE_2D, texture);

/**************************************/
// Aquí verificas si tiene o no alpha channel
//
/**************************************/
   if(image->format->Amask)
   {
    gluBuild2DMipmaps(GL_TEXTURE_2D,
    GL_RGBA,image->w, image->h,
    GL_RGBA, GL_UNSIGNED_BYTE,image->pixels);
    }
    else
   {
   gluBuild2DMipmaps(GL_TEXTURE_2D,
   GL_RGB,image->w, image->h,
   GL_RGB, GL_UNSIGNED_BYTE,image->pixels);
  }

//Colocas el filtro correspondiente
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR_MIPMAP_LINEAR);


// Y finalmente creas la imágen en OpenGL.
if(image->format->Amask)
{
 glTexImage2D(GL_TEXTURE_2D,0,GL_RGBA,image->w,
 image->h,0,GL_RGBA,GL_UNSIGNED_BYTE,image->pixels);
}
else
{
 glTexImage2D(GL_TEXTURE_2D,0,GL_RGB,image->w,
 image->h,0,GL_RGB,GL_UNSIGNED_BYTE,image->pixels);
}

}

}

Después para usarla solo tienes que llamar a glBindTexture(GL_TEXTURE_2D, texture); antes de dibujar tu modelo y listo.


Saludos.

puedes hacer una optimizacion que notaras bastante, este codigo es mortal

Código [Seleccionar] Expand

for( i = 0; i < m_pBuffers->m_dwNumVerts; i++ )
{
for( j = 0; j < m_pBuffers->m_dwNumFaces; j++ )
{

recorre solo las caras, calculas la normal de esa cara y se la metes a los tres vertices sumandola contra la anterior que habia y la divides entre dos, al final recorres una vez mas los vertices y normalizas ya si quieres, de una pasada por las caras haces todo el calculo, si quieres saber como calcular la normal correctamente pasate por mi web y descarga el codigo de c++ clase vector

saludos

Hay un detalle con ese algoritmo colega, ¿qué pasa si un vertice pertenece a más de una cara?, entonces el vertice quedará con la normal de la última cara a la que pertenezca mostrando datos de iluminación erroneos cuando se referencie en caras anteriores, la única solución para eliminar ese problema es con smooth de normales, sacar una normal promedio de todas las normales que tiene el vértice, lo que no es muy simple.
Si esto no se hace se van a ver efectos de iluminación bastante extraños sobre el modelo.

Saludos.

 Hola zupervaca, leí tu problema y en realidad no es ningún problema, si el valor que quieres enviar es uno solo puedes usar perfectamente GL_VERTEX_BUFFER_OBJECT y con eso te aseguras de que tu modelo siempre esté en la memoria AGP, solo tienes que enviar el cuarto parametro en el glVertexPointer diciendole que cada vertice tiene 4 parámetros y usarlo en el shader, nada mas.

Espero que te haya quedado más claro, si no, te puedo poner un ejemplo aquí.

los ejemplos que he encontrado usan el psize o renderizar triangulo a triangulo, ¿como lo haces tu?

saludos

Hola zupervaca, ¿puedes explicar con más detalle cuál es tu problema y si es posible colocar algún seudocódigo?.

Así va a ser más fácil ayudarte.

3.- Depende de si tienes o no desactivado Vsync, esto reduce el rendimiento por la sincronia con el monitor.

Si tiene activado el Vsync le tendria que ir a la frequencia del monitor, no?

Efectivamente colega, afortunadamente existe una extensión en OpenGL que permite desactivar el Vsync y así la aplicación da el máximo de FPS posible.

No conocia el tema de la extensión. Yo siempre lo hacia desactivandolo en las propiedades de la pantalla...  B)

La extensión es mucho mejor, así te aseguras que sin importar lo que el driver tenga configurado, siempre se va a desactivar Vsync.

Saludos.

si en la mayoria de ejemplos he visto que usan el PSIZEn, lo de las 2000fps es normal ya que tengo que renderizar triangulo a triangulo con fors (grrr) por culpa de esti rollo,

Creo que algo estás haciendo mal ahí, nunca he tenido que renderizar triángulo a triángulo con OpenGL, ni siquiera usando GLSL, todo lo contrario...

Quizás deberías revizas las especificaciones de OpenGL o algunos ejemplos para verificar.


Saludos.

lo del "super buffer" parece una coña :P (deberian llamarlos "super vaca"),
saludos y gracias

No lo es colega, si lees las especificaciones de GL_VERTEX_BUFFER_OBJECT hay una referencia bien superficial a la idea del super buffer que ya lleva pensada bastante tiempo.

3.- Depende de si tienes o no desactivado Vsync, esto reduce el rendimiento por la sincronia con el monitor.

Si tiene activado el Vsync le tendria que ir a la frequencia del monitor, no?

Efectivamente colega, afortunadamente existe una extensión en OpenGL que permite desactivar el Vsync y así la aplicación da el máximo de FPS posible.

 Otra cosa, ese asunto de los 2000 fps depende de varios factores:

1.- Depende de tu versión de drivers.
2.- Depende de tu tarjeta de video, si tienes una Nvidia, OpenGL correrá mejor que DirectX, si tienes una ATI viceversa.
3.- Depende de si tienes o no desactivado Vsync, esto reduce el rendimiento por la sincronia con el monitor.
4.- Depende de como tengas configurados tus drivers, recuerda que tienen opciones para OpenGL y Direct X.
5.- Depende si estás usando intensamente pixel o vertex shaders, Nvidia es mejor para los pshaders y Ati para los vshaders.

Saludos.

 Hola colegas, el problema que tiene zupervaca es muy común con OpenGL, sobre todo si quieres usar GL_VERTEX_BUFFER_OBJECT, la razón de esto es que esta extensión hasta donde tengo claro solo guarda en memoria los arreglos que corresponden a propiedades primitivas de los polígonos, como los vértices, las texturas, las UV, las normales y el color, si quieres agregar un arreglo más, ese se queda en ram de sistema y no de video, lo que merma es rendimiento. Pero esto va a cambiar con la nueva extensión que todavía no se termina que se llama "GL_SUPER_BUFFER" donde vas a poder enviar a memoria todo lo que quieras.

Para resolver tu problema colega hay varios trucos, por ejemplo, si no estás usando el color, o si todos los vertices son del mismo color, puedes usar ese arreglo para enviar el blending, lo mismo con las normales, he incluso, los vertices tienen una cuarta coordenada que puedes usar al igual que las coordenadas de texturas que nunca se usan, como la tercera y cuarta (uvzw me parece que es el orden).

Es muy común ven en códigos de ejemplo trucos como ese, ahora si quieres usar binormales y tangentes te recomiendo calcularlas en el mismo shader, no vale la pena desperdiciar ancho de banda en algo que puedes calcular en el mismo shader.

Ojalá te haya servido de algo este comentario.

 http://www.openglubb.info - Página en español dedicada a toda persona que quiera aprender OpenGL, como lema te responde cualquier duda antes de 24 horas. - Todo nivel.