Buenas,

Cuando escribes más de 15 líneas en c pues te encuentras con estos problemas. En linux he encontrado mtrace que hace más o menos lo que necesito pero me gustaría un programa que detectase memory leaks para windows para mingw.

¿Conocéis alguno?

Muchas gracias.

Un saludo.

Buenas,

Tengo dudas y problemillas.

Código [Seleccionar] Expand


varying vec4 lightproj;
varying vec4 lightpos;

uniform mat4 LPM;  //ProjModelView de la luz
uniform mat4 CPOV;
uniform mat4 NORM;

uniform vec3 lpos;  //posicion de la luz

void main(void)
{
  gl_TexCoord[0] = gl_MultiTexCoord0;
  gl_TexCoord[1] = gl_MultiTexCoord1;

  lightproj      = LPM * gl_Vertex; //convertir el vertice a LPOV

  lightpos       = (vec4(lpos, 1) - gl_Vertex);  //para luego sacar la longitud
  gl_Position    = ftransform();

}


Este el el código de mi vertex shader para una implementación de shadow mapping que estoy haciendo.

EL shadow mapping funciona para el escenario que se renderiza sin tocar nada de la ModelView. Para los modelos antes de pintarlos hago un glTranslatef y un glRotatef y ahí está el problema, los modelos no reciben el sombreado.

El shadow map lo almaceno en una textura en un fbo, ahí si se almacena todo correctamente ya que los modelos si generan sombras pero como dije no las reciben.

Un tío en gamedev me dijo que el problema es que no aplicaba las transformaciones que hacía a los modelos (gltranslatef, glRotatef) al vector lightproj y que para solucionarlo lo multiplicasa por la Projmv, no lo entendí porque lo que entiendo es que ese vertice tengo que convertirlo al punto de vista de la luz y esa matriz no cambia.

Ya puesto alguien me podría aclarar que información guarda gl_Vertex, es decir está pasado por alguna matriz?.

Muchas gracias y un saludo.

Buenas,

Estoy intentando renderizar mi escena a una textura, este es el codigo de inicializacion:

Código [Seleccionar] Expand


       glGenTextures(1, &textura_fbo);
       glBindTexture(GL_TEXTURE_2D, textura_fbo);
       glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTE    R,GL_LINEAR);
       glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTE    R,GL_LINEAR);
       glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, w_size, h_size, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);

       glGenRenderbuffersEXT(1, &depthbuffer);
       glBindRenderbufferEXT(GL_RENDERBUFFER_EXT, depthbuffer);

       glGenFramebuffersEXT(1, &fbo);
       glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fbo);

        //definmos nuestro renderbuffer
       glRenderbufferStorageEXT(GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT, w_size, h_size);

        //añadimos el renderbuffer al frambuffer
       glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, depthbuffer);

       //añadimos una textura
       glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, textura_fbo, 0);
       //glBindTexture(GL_TEXTURE_2D, 0);
       //comprobamos si hay errores
       GLenum status = glCheckFramebufferStatusEXT(GL_FRAMEBUFFER_EXT);
       glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);


Me devuelve "FBO completed" asi que supuestamente esta bien montado.

Antes y despues de pintar el escenario lo activo y desactivo asi:

Código [Seleccionar] Expand


       glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, fbo);
       //glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT,GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, depthbuffer);
       //glFramebufferTexture2DEXT(GL_FRAMEBUFFER_EXT,GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, textura_fbo, 0);
       glPushAttrib(GL_VIEWPORT_BIT);
       glViewport(0, 0, w_size, h_size);

Código [Seleccionar] Expand


       glPopAttrib();
       glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, 0);

Y aqui es donde pinto la textura generada

Código [Seleccionar] Expand



       glBindTexture(GL_TEXTURE_2D, textura_fbo);

       // Set Flags
       glEnable(GL_TEXTURE_2D);
       glDisable(GL_DEPTH_TEST);

       glMatrixMode(GL_PROJECTION); // Select The Projection Matrix
       glPushMatrix(); // Store The Projection Matrix

       // Change to orthogonal projection to do a texture blitter to the screen
       glLoadIdentity(); // Reset The Projection Matrix
       glOrtho(0,1,0,1,-1,1); // Set Up An Ortho Screen

       glMatrixMode(GL_MODELVIEW); // Select The Modelview Matrix
       glPushMatrix(); // Store The Modelview Matrix
       glLoadIdentity(); // Reset The Modelview Matrix

       glBegin(GL_QUADS);
       glTexCoord2f(0.0f, 0.0f);
       glVertex3f(-1.0f, -1.0f, 0.0f);
       glTexCoord2f(1.0f, 0.0f);
       glVertex3f( 1.0f, -1.0f, 0.0f);
       glTexCoord2f(1.0f, 1.0f);
       glVertex3f( 1.0f,  1.0f, 0.0f);
       glTexCoord2f(0.0f, 1.0f);
       glVertex3f(-1.0f,  1.0f, 0.0f);

       glEnd();

       glMatrixMode(GL_PROJECTION); // Select The Projection Matrix
       glPopMatrix(); // Restore The Old Projection Matrix

       glMatrixMode(GL_MODELVIEW); // Select The Modelview Matrix
       glPopMatrix(); // Restore The Old Projection Matrix*/


Al renderizar la textura aparece la pantalla completamente negra. Si comento esta lina al inicializar
glFramebufferRenderbufferEXT(GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, depthbuffer);
puedo ver la textura pero sin depth testing.

Estoy jodido.

Alguien me muede echar una mano.

Muchas gracias y un saludo.

Buenas,

Alquien sabe cual es la mejor manera(taxi, bus, tren) para llegar desde el aeropuerto al sitio dónde se celebra el ART?

Gracias y un saludo.

Buenas,

Aquí dejo un link con un video con la última versión que he enviado hoy al artfutura dónde explica en qué consite el gameplay del juego.

Espero que os guste.


http://stage6.divx.com/user/misscelan/video/1766481/EL-ocaso-de-sara

Un saludo.

Buenas,

Pues después de dos años de desarrollo por fin tengo... algo así como el 15 % de
mi juego, que es lo que he mandado como demo al artfutura de este año.

El juego está desarrolado con openGL + SDL + openAL y Newton para algunas partes
de la física, que serán totales cuando me desaga de toda la mierda que cree cuando
me dió por intentar crear también desde 0 el engine de física. Todo ello en c para gcc.

Ahora mismo está testeado en windows y linux y supongo que sería fácil portarlo a
mac.

La historia del juego no os la contaré aquí para aburriros. La temática será variada,
los escenarios del juego tratan sobre sentimientos humanos y "supuestamente" cada escenario
se centrará en hacerte "sentir" algo referente a su temática. Los colores del juego también tienen
su porqué.

Bueno sin más os dejo unas imágenes y un video, espero que os guste.

Un saludo.











Video en Youtube

Hola,

Tengo un vector dirección (vDir) al que le he aplicado unos cambios. Tengo un punto de origen (vStart) y un punto final (vEnd).

Después de calcular unos cambios para vDir, vEnd lo calculo así

Código [Seleccionar] Expand

vEnd.x = vStart.x + Radio * vDir.x;
vEnd.y = vStart.y + Radio * vDir.y;
vEnd.z = vStart.z + Radio * vDir.z;

Ahora lo que quería conseguir es rotar vDir sobre el eje Y unos determinador grados y volver a calcular vEnd.

La rotación sobre el eje Y la hago así:

Código [Seleccionar] Expand

vDir.x  =  (vDir.z * cos(ang_rad)) - (vDir.x * sin(ang_rad));//y
vDir.z  =  (vDir.x * cos(ang_rad)) + (vDir.z * sin(ang_rad));

El caso es que así parece que las cosas no funcionan, sin embargo si hago esto funciona perfectamente:

Código [Seleccionar] Expand

vEnd.x = Radio * vDir.x;
vEnd.y = Radio * vDir.y;
vEnd.z = Radio * vDir.z;

glPushMatrix();
   glTranslatef(vStart.x, vStart..y, vStart..z);
   glRotatef(angle, 0.0, 1.0, 0.0);
   glBegin(GL_LINES);
        glVertex3f(0, 0, 0);
        glVertex3f(vEnd.x, vEnd.y, vEnd.z);
  glEnd();
glPopMatrix();

Aquí realmente roto el punto final no el vector pero rotando vEnd directamente por código tampoco lo consigo.

Alguien me puede echar una mano.

Gracias y un saludo

Hola,

Alguien sabe porque puedo seguir viendo texturas con este frag shader activado durante toda la aplicación?

Código [Seleccionar] Expand

uniform sampler2DShadow ShadowMap;
varying vec4 ProjShadow;

void main (void)
{
   vec3 color = vec3(1.0, 1.0, 1.0);
   color *= shadow2DProj(ShadowMap, ProjShadow).r;
   gl_FragColor = vec4(color, 0.0);
}

Buenas,

Estoy intentando implementar shadow mapping con extensiones arb en mi aplicación y la cosa no funciona.

La teoría no sé si la tengo muy clara. Por lo que entiendo primero se debe hacer es colocarte en el lugar de luz y guardar el buffer de profundidad en una textura, después te desplazas al lugar donde está la cámara, tranformas los puntos actuales para poder compararlos con el buffer guardado y así poder distinguer cuales deberían estar en sombra o no.

La parte de generar el shadow map la tengo funcionando, pero ahí tengo mi primera duda, vi que en algunos ejemplos para poder debugear sacaban la textura por pantalla, yo lo hice y veo la imagen desde el punto de vista de luz, pero yo pensaba que los datos guardados en el buffer de profundidad era algo ilegible como poder sacarlo en una textura por pantalla.

La segunda parte por los ejemplos que tengo no me entero de nada.
Utilizan un  método para generar las coordenadas de la textura automáticamente.

Código [Seleccionar] Expand


float mRowTextures1[4] = {1.0f,0.0f,0.0f,0.0f};
   float mRowTextures2[4] = {0.0f,1.0f,0.0f,0.0f};
   float mRowTextures3[4] = {0.0f,0.0f,1.0f,0.0f};
   float mRowTextures4[4] = {0.0f,0.0f,0.0f,1.0f};
.
   glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR);
   glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR);
   glTexGeni(GL_R, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR);
   glTexGeni(GL_Q, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR);
   glTexGenfv(GL_S, GL_EYE_PLANE, mRowTextures1);
   glTexGenfv(GL_T, GL_EYE_PLANE, mRowTextures2);
   glTexGenfv(GL_R, GL_EYE_PLANE, mRowTextures3);
   glTexGenfv(GL_Q, GL_EYE_PLANE, mRowTextures4);
   glEnable(GL_TEXTURE_GEN_S);
   glEnable(GL_TEXTURE_GEN_T);
   glEnable(GL_TEXTURE_GEN_R);
   glEnable(GL_TEXTURE_GEN_Q);

   glMatrixMode( GL_TEXTURE );
   glLoadIdentity();
   glTranslatef( 0.5f, 0.5f, 0.5f );                      // Offset
   glScalef( 0.5f, 0.5f, 0.5f );                          // Bias
   glMultMatrixf( mLightView.m );


La última parte entiendo que es para convertir los puntos para poder compararlos con el depth buffer y lo del offset y bias para evitar algunos problemas que se puedan dar.

Pero la primera parte no la entiendo, todo el tema de generación de las coordenadas, qué hace cada comando que sale ahí?

Bueno, si me solucionáis esto volveré con más.

Muchas gracias.

Un saludo.

Hola,

Recientemente he adquirido esta tarjeta gráfica, antes poseía una Ati Radeon 9200.

El aplicación que estaba desarrollando se ejecutaba sin problemas en la Ati pero al poner la nueva tarjeta me da problemas en esta parte.

Código [Seleccionar] Expand


glGenTextures(1, textura_temp);

   glPixelStorei (GL_UNPACK_ALIGNMENT, 1);

   glBindTexture(GL_TEXTURE_2D, *textura_temp);

   GLint internalFormat = canales;

   if (conf_get_ext(EXT_ARB_COMP)) /*compruebo si tengo la extensión*/
   {
       internalFormat = GL_COMPRESSED_RGB_ARB;

       if (canales == FT_ALPHA)
       {
          internalFormat = GL_COMPRESSED_RGBA_ARB;
       }
   }
   
   gluBuild2DMipmaps(GL_TEXTURE_2D, internalFormat, ancho,
                     alto, tipo, GL_UNSIGNED_BYTE, datos);


Exactamente casca en el gluBuild, pero no para todas las texturas. En el backtrace sale esta línea:

Código [Seleccionar] Expand

nvoglnt!DrvValidateVersion() (??:??)

En la textura donde se rompe no veo nada raro, es un jpg de tamaño 256x256.

La tarjeta posee la extensión y entra dentro del if, si lo comento (el if) algunas texturas se muestran mal pero la aplicación se ejecuta.

Alguien que me pueda echar una mano.

Muchas gracias y un saludo.

Hola,

Dentro del procedimiento donde inicio SDL quería llamar a otro procediento para cargar unas imágenes.

Código [Seleccionar] Expand



void cargar_menu()
{
 SDL_Surface *screen = NULL;  //fix liberar las imagenes

 screen = iniciar_sdl();


 if (screen == NULL)
 {
   printf("Error: %s\n", SDL_GetError());
 }

 map_load_pic("gui/main2.jpg");


El procedimiento es map_load_pic. Bueno pues ese procedimiento todavía está vacío, no hace absolutamente nada y si no lo comento. SDL deja de recogerme el input de teclado (pero no el de ratón). ¿??¿

El procedimiento tiene que estar ahí por que lo siguiente ya es el bucle del juego.

Utilizo codeblocks con gcc y SDL + OpenGL.

Hago todo esto porque quería cargar unas imágenes estáticas antes del juego y para ahorrarme problemas con las diferentes resoluciones quería cargarlo en una textura y fuera.

Soluciones al error? un método mejor y más bonito de poder usar imágenes estáticas sin tener en cuenta la resolución de la ventana del juego?

Muchas gracias.

Un saludo.

Hola,

Parto de un bezier patch con 9 puntos de control 3x3. Dependiendo de diversos factores los subdivido(de momento no he puesto límite).

Pero tengo dudas a la hora de renderizarlo ¿vosotros qué métodos usáis?. Directamente los puntos de control que sería lo más rápido aunque no exacto, concantenando curvas bezier o splines, otros?

Muchas gracias.

Un saludo.

La iluminación de objetos dinámicos por lo que he visto en el quake 3 está basada en unas rejillas precalculadas.

Esta reijja contiene información sobre la luz dentro de ella. Pero sólo de una.

Qué pasa si esa rejilla es el punto de encuentro de dos luces una roja por la izquierda y una verde por la derecha, la luz de esa rejilla sería una marrón por delante?.

Muchas gracias.

Un saludo

Bueno, sigo con la carga de los jodidos mapas del quake 3.

Ahora mismo estoy con la carga de objectos dinámicos: puertas, péndulos, plataformas, etc...

Esta es la información de la estructura de los objectos:

typedef struct
{
   tvector3f min;          //
   tvector3f max;          // mínimo y máximo para el bounding box
   int faceIndex;          // índice al vector de caras
   int numOfFaces;         // número de caras
   int brushIndex;         // índice al vector de planos de colisión
   int numOfBrushes;       // número de planos de colisión
}tBSPModel;

Esta es la estructura de los planos

typedef struct
{
   tvector3f vNormal;    
   float d;              
}tBSPPlane;

Mi modelo principal está contenido dentro de una BBox por lo que la colisión entre el personaje principal y los objectos dinámicos mediante BBoxes no es muy difícil.

El problema es que el BBox es sencillo para detectar la colisión, pero mi personaje se queda pegado al objecto. Para poder deslizarme (hacer sliding, o como se diga) con el objecto necesito el plano de colisión, no quiero ni pensar como extraer el plano de colisión con las BBox además si en la estructura viene información sobre los planos de colisión será para usarlos no?.

Ya tengo hecho el procedimiento de colisión usando los brushes(planos de colisión) el problema es que está hecho para objectos estáticos, para los dinámicos supongo que necesitaría recalcular la información de los planos (por si el objecto rota, se traslada, etc..)

Y ahí está mi duda, la normal es un simple vector, rotarlo y trasladarlo no debería ser muy difícil, lo que no sé es qué hacer con la componente d cuando mueva el objeto,  ¿calculo la distancia de la normal a 0,0,0?

Todo esto son suposiciones pero es la única manera que encuentro de solventar esto.

Alguien que me eche una manita.

Muchas gracias.

 Buenas,

Ya había tenido alguna vez problemas con llamadas a malloc en otras partes del código, pero al final tras reorganizarlo un poco acabó tirando.

Pero ahora mismo no hay manera, una llamada a malloc en el procedimiento de renderizar los modelos y casca. No quiero reorganizarlo, parchearlo, enguarrar más el código (basante está ya) para que funcione. Me gustaría arreglar el problema con los malloc definitivamente. Un cara a cara.

He descartado que sea el malloc esclusivamente del procedimiento de renderizado de modelos. Por lo que parece que tengo la memoria jodida de alguna llamada a malloc anterior ¿?. Tengo más o menos unas 70 llamadas a malloc en todo el programa. ¿Cuál es la mejor solución para encontrarlo? ¿Puede ser de otra cosa?

Muchas gracias.

Un saludo.

 Muchos conocerán este tutorial sobre colisiones es bsp http://www.devmaster.net/articles/quake3collision/ .

Bueno es caso es que lo tenía implementado añadiéndole el slide al colisionar. Yo creía que funcionaba de maravilla el caso es que añadí las colisiones para los disparos usando el mismo algoritmo. Lo que hacía era trazar una línea de longitud x desde la cámara en adelante y resulta que sólo me funcionaba la línea de disparo cuando no había colisión.

Repase el algoritmo y resulta que la fracción del vector de vuelta siempre que colisiona es 0. Me funcionaba de maravilla para el movimiento porque no avanzaba mucho cada iteración por eso se acercaba mucho a la pared y si aumentaba el desplazamiento mucho la cámara se quedaba parada un rato largo antes de la colisión.

Tenía ejemplos por ahí basados en los tutoriales de gametutorials sobre colisiones en bsp y parece que tenían el mismo problema. La distancia a la colisión era proporcional al avance por iteración. Cuando supuestamente ese algoritmo te devolvía una fracción de lo que podías avanzar hasta quedarte a EPSILON de la pared. Siendo EPSILON = a una mierda (no me acuerdo ahora pero era algo como 0.032 o algo así).

Al final le he hecho unas ñapas y parece que funciona pero el caso es que me he quedado con la duda de si son imaginaciones mías, si la he cagado al implementarlo o si realmente pasa.

Alguien con este algoritmo implementado me pueda arrojar luz?.

Muchas gracias.

Un saludo.

 Tengo un Pentium III a 750 portatil con una Ati Rage moblity con 8 mb.

Me gustaría poder usar ese ordenador para hacer alguna tontería pero es que con esa tarjeta no puedo hacer nada.

He pensado en comprarle una tarjetita algo mejor algo como una Ati Radeon Mobility 9200 o algo así. Pero es que a penas encuentro sitios donde vendan gráficas para portatil y donde los encuentro son las de última generación que no me interesan (ahora mismo).

Conoces algún sitio en Madrid primera o segunda mano?
alguno fiable por internet?

Muchas gracias.

 
Cargo mis modelos del mikshape (debería cambiar de programa pero ya lo haré en un momento que no esté metido hasta el cuello).

Ahora estoy pensando en como podría saber en que momento colisiona un objeto con mi modelo (por ejemplo un disparo).

Calcular la trayectoria del disparo y comprobar si colisiona con cada plano del modelo como que no. Supongo que la solución está creando "bounding boxes" o como se diga el plural para cada parte del cuerpo (cabeza, tronco, brazo, etc...).

El problemas es que con milkshape no veo una forma limpia de hacer esto. Lo único que se me ocurre es crear el mismo modelo con los BB y el mismo esqueleto asociado, luego a la hora de cargarlo únicamente cargo los vértices de las BB y lo incluyo con los procedimientos donde creaba las animaciones del antiguo para que que adopte las mimas posiciones al animarse y luego comprobar las colisiones sólo con esto que serán mu pocos planos a comprobar.

Pero me suena un poco chapuza...

Muchas gracias.

Un saludo.

 Buenas.

Tengo un array con los vertices de un modelo "md_vertices[num_vert]" y otro array ordenado con los indices a los vértices "md_vertices_index[num_vert]". Debe ser renderizado formando triángulos.

Mi pregunta es como podría pasar todo esto directamente a renderizar (sin usar glBegin-glEnd).

Se me ocurre crear una copia de "md_vertices" y reorganizarla según "md_vertices_index"y luego mandarlo con glDrawArrays(GL_TRIANGLES, 0 , num_vert). Pero trendría que reorganizar ese array en tiempo de renderizado y no creo que sea la opción más elegante.

¿Existe algún comando parecido a glDrawArrays al que le pueda pasar el array de vertices y el de los indices y el se encargue de mandarlo todo de golpe?

Si se os ocurren más cosas son bienvenidas.

Muchas gracias.

Un saludo.

 Tengo una Ati Radeon 9200.

Jugando al doom3, puse prácticamente todas las pijadas gráficas (incluyendo sus super efectos de luz) una resolución de 640 x 480 y la cosa iba a 15 fps. Bueno, era previsible, mi tarjeta es una reliquia.

Me entro curiosidad por mirar cosas sobre iluminación en tiempo real con sombras.

Intenté buscar ejemplos de algo chulo que funcionase en mi 9200. Lo único que encontré fue en la página de Paul's Projects.
Allí encontré una demo de shadow map que funcionaba en mi tarjeta. La demo consiste en unas croquetas girando encima de un donuts sin texturizar. Puse las opciones del tamaño del shadow map a 256 y la precisión a la única que podía, 8 bits.

El resultado fue unas sombras con más dientes que el collar de un canibal y
funcionando a 15 fps.

Supongo que lo que haga Carmack es algo alcanzable exclusivamente por él. Pero me gustaría creer que se puede hacer algo mejor con mi radeon que unas croquetas y un donuts con unas sombras horribles a 15 fps.

En fin, me gustaría saber si existen maneras más rápidas de hacer shadow map con mi tarjeta o si existen otros métodos de iluminación mucho más convenientes para mi tarjeta.

Muchas gracias.