Hola,
tengo una duda sobre como configurar un entorno para programar en linux. Vaya por delante que estoy acostumbrado al entorno de Visual Studio en C++ y al hecho de añadir librerias en el proyecto.

Para linux, me estoy basando en CMake, pero hay algunas cosas que creo que no he comprendido bien. Primero: donde van las librerias? Esta claro que la forma mas comoda es usando apt-get, pero esas librerias quedan en los local y shares de tu linux. Entonces, como se distribuyen despues los programas?

Tengo mucho mas claro el concepto windows, donde todas las libs van a un folder, donde linkas estatico para que vaya al codigo directamente o dinamico, y entonces distribuyes las dlls. Eso se puede hacer en linux? Yo estuve probando con lua + luabind. Linko bien con luabind pero despues me dice que necesita lua. Y lua parece que solo le sirve si esta en /usr/local/...

Alguien me puede dar algun consejo de como montar un entorno de programacion? Cual es el ciclo de trabajo?

Muchas gracias.

Hola, acabo de leer en algunos mensajes sobre motores basados en arboles.  En general, que yo sepa, es la tecnica habitual, es decir, es scene tree. Pero me preguntaba si hay alguna otra tecnica habitual para representar escenas ademas de ponerlas de manera jerarquica. Alguien conoce algun motor que use otras tecnicas?

Hola a todos,
me estoy leyendo un libro de opengl donde hablan del OpenGL 3.x. Lo que viene a decir el libro es que el inmediate mode, esta deprecated. Ok hasta aqui. El caso es que creo el contexto tal como dice el libro, y parece que va bien y dibuja bien, pero no hay ni rastro de mensajes en el compilador que adviertan que las funciones estan deprecated.

No deberia lanzarme algun warning el compilador?

Gracias

Hola a todos:

me estoy leyendo un tutorial de nehe sobre rotaciones. Esta aqui. Es un ariculo de camara basada en quaternions. El caso es que tengo dudas en la funcion setPerspective. Me explico: cuando lo resuelve con quaternions lo hace asi:

Código (cpp) [Seleccionar] Expand


void glCamera::SetPrespective()
{
GLfloat Matrix[16];
glQuaternion q;

// Make the Quaternions that will represent our rotations
m_qPitch.CreateFromAxisAngle(1.0f, 0.0f, 0.0f, m_PitchDegrees);
m_qHeading.CreateFromAxisAngle(0.0f, 1.0f, 0.0f, m_HeadingDegrees);

// Combine the pitch and heading rotations and store the results in q
q = m_qPitch * m_qHeading;
q.CreateMatrix(Matrix);

// Let OpenGL set our new prespective on the world!
glMultMatrixf(Matrix);

// Create a matrix from the pitch Quaternion and get the j vector
// for our direction.
m_qPitch.CreateMatrix(Matrix);
m_DirectionVector.j = Matrix[9];

// Combine the heading and pitch rotations and make a matrix to get
// the i and j vectors for our direction.
q = m_qHeading * m_qPitch;
q.CreateMatrix(Matrix);
m_DirectionVector.i = Matrix[8];
m_DirectionVector.k = Matrix[10];

// Scale the direction by our speed.
m_DirectionVector *= m_ForwardVelocity;

// Increment our position by the vector
m_Position.x += m_DirectionVector.i;
m_Position.y += m_DirectionVector.j;
m_Position.z += m_DirectionVector.k;

// Translate to our new position.
glTranslatef(-m_Position.x, -m_Position.y, m_Position.z);
}

Aqui lo que no entiendo es por que primero multiplica qPitch x qHeading, despues lo sube a la pila de matrices, y despues vuelve a multiplicarlos pero al reves qHeading x qPitch para sacarles el vector de direccion. El escritor del articulo también lo hace con matrices:

Código (cpp) [Seleccionar] Expand


void glCamera::SetPrespective()
{
GLfloat Matrix[16];

glRotatef(m_HeadingDegrees, 0.0f, 1.0f, 0.0f);
glRotatef(m_PitchDegrees, 1.0f, 0.0f, 0.0f);

glGetFloatv(GL_MODELVIEW_MATRIX, Matrix);

m_DirectionVector.i = Matrix[8];
m_DirectionVector.k = Matrix[10];

glLoadIdentity();

glRotatef(m_PitchDegrees, 1.0f, 0.0f, 0.0f);

glGetFloatv(GL_MODELVIEW_MATRIX, Matrix);
m_DirectionVector.j = Matrix[9];

glRotatef(m_HeadingDegrees, 0.0f, 1.0f, 0.0f);

// Scale the direction by our speed.
m_DirectionVector *= m_ForwardVelocity;

// Increment our position by the vector
m_Position.x += m_DirectionVector.i;
m_Position.y += m_DirectionVector.j;
m_Position.z += m_DirectionVector.k;

// Translate to our new position.
glTranslatef(-m_Position.x, -m_Position.y, m_Position.z);
}


Pero tampoco lo entiendo. Primero aplica las rotaciones, despues recupera la matriz modelview para recuperar un vector de direccion y despues cargar la identidad y volver a rotar y volver a recuperar la modelview y recuperar la direccion de j. Por que necesita hacer esto? No seria mejor recuperar la matriz una sola vez? Por que lo hace dos veces? Por que primero rota por heading y por pitch y despues solo por pitch?

A ver si me podeis pasar algo de info para niños de dos años. Entiendo las rotaciones basicas pero no logro ver por que hace esto.

Ayer, como no tengo dinero para un plugin que haga refactor, intente cambiar el nombre de unos namespaces de unas clases para ganar coherencia. El problema no es que no compile sino que no me reconoce el nuevo namespace. El intellisense me sugiere el antiguo namespace junto con el nuevo. El tooltip cuando pongo el cursor encima me dice que el la clase es de tipo

Código [Seleccionar] Expand

namespace::Clase *namespace2::variable

He hecho un limpiar proyecto, he reiniciado hasta la maquina, pero parece que VC++ guarda algun tipo de cache o algo asi. Alguien me puede dar una pista para empezar a tirar del hilo?

Muchas gracias

Hola a todos, me estoy iniciando en el tema de la programacion grafica y tengo bastantes dudas sobre la iluminacion.
Cargo un modelo 3D desde un archivo (uso Assimp, para importar archivos 3D). He comprobado que  los poligonos se pintan en sentido contrario a las agujas del reloj, y tambien he comprobado que las normales se calculan bien:
http://picasaweb.google.com/lh/photo/WIwiaasKZkHLHVvn20Afaw?feat=directlink

Este es el codigo de init()

Código [Seleccionar] Expand


int InitGL(GLvoid) // All Setup For OpenGL Goes Here
{
glClearDepth(1.0);
glClearColor(0.1f, 0.3f, 0.3f, 0.0f);

glDepthFunc(GL_LEQUAL);
glEnable(GL_DEPTH_TEST);
glShadeModel(GL_SMOOTH);
glCullFace(GL_FRONT);
glEnable(GL_CULL_FACE);

glEnable(GL_LIGHTING);
GLfloat ambientLight[] = {.30f,.30f,.30f,1.0f};
GLfloat difusseLigth[] = {.70f,.70f,0.70f,1.0f};
GLfloat specularLight[] = {1.0f,1.0f,1.0f,1.0f};


glLightModelfv(GL_LIGHT_MODEL_AMBIENT,ambientLight);
GLfloat lightPos[] = {4,-6,-4};
glLightfv(GL_LIGHT0,GL_POSITION,lightPos);
glLightfv(GL_LIGHT0,GL_AMBIENT,ambientLight);
glLightfv(GL_LIGHT0,GL_SPECULAR,specularLight);
glLightfv(GL_LIGHT0,GL_DIFFUSE,difusseLigth);
glEnable(GL_LIGHT0);

glColorMaterial(GL_FRONT, GL_AMBIENT_AND_DIFFUSE);
glEnable(GL_COLOR_MATERIAL);
glFrontFace(GL_CCW);

std::cout << gluErrorString(glGetError());
return TRUE;
}


Y este el de dibujado (que no me parece que tenga nada de especial)

Código [Seleccionar] Expand


glBegin(GL_TRIANGLES);
for(unsigned int j=0; j < mesh->mNumFaces; j++)
{
int vert1 = mesh->mFaces[j].mIndices[0];
int vert2 = mesh->mFaces[j].mIndices[1];
int vert3 = mesh->mFaces[j].mIndices[2];

glNormal3f(mesh->mNormals[vert1].x,mesh->mNormals[vert1].y,mesh->mNormals[vert1].z);
glVertex3f(mesh->mVertices[vert1].x,mesh->mVertices[vert1].y,mesh->mVertices[vert1].z);
glNormal3f(mesh->mNormals[vert2].x,mesh->mNormals[vert2].y,mesh->mNormals[vert2].z);
glVertex3f(mesh->mVertices[vert2].x,mesh->mVertices[vert2].y,mesh->mVertices[vert2].z);
glNormal3f(mesh->mNormals[vert3].x,mesh->mNormals[vert3].y,mesh->mNormals[vert3].z);
glVertex3f(mesh->mVertices[vert3].x,mesh->mVertices[vert3].y,mesh->mVertices[vert3].z);
}
glEnd();

               //dibujar normales
glColor3f(1,1,1);
glBegin(GL_LINES);
for(unsigned int j=0; j < mesh->mNumFaces; j++)
{
int vert1 = mesh->mFaces[j].mIndices[0];
int vert2 = mesh->mFaces[j].mIndices[1];
int vert3 = mesh->mFaces[j].mIndices[2];

glVertex3f(mesh->mVertices[vert1].x,mesh->mVertices[vert1].y,mesh->mVertices[vert1].z);
glVertex3f( mesh->mVertices[vert1].x +mesh->mNormals[vert1].x
,mesh->mVertices[vert1].y + mesh->mNormals[vert1].y
,mesh->mVertices[vert1].z + mesh->mNormals[vert1].z);


glVertex3f(mesh->mVertices[vert2].x,mesh->mVertices[vert2].y,mesh->mVertices[vert2].z);
glVertex3f( mesh->mNormals[vert2].x + mesh->mVertices[vert2].x
,mesh->mNormals[vert2].y + mesh->mVertices[vert2].y
,mesh->mNormals[vert2].z + mesh->mVertices[vert2].z);

glVertex3f(mesh->mVertices[vert3].x,mesh->mVertices[vert3].y,mesh->mVertices[vert3].z);
glVertex3f( mesh->mNormals[vert3].x + mesh->mVertices[vert3].x
,mesh->mNormals[vert3].y + mesh->mVertices[vert3].y
,mesh->mNormals[vert3].z + mesh->mVertices[vert3].z);
}
glEnd();


Lo que me resulta mas raro de todo es que cuando cambio la posicion de la luz, y en vez de

Código [Seleccionar] Expand


GLfloat lightPos[] = {4,-6,-4};

Le pongo

Código [Seleccionar] Expand


GLfloat lightPos[] = {4,-7,-4};

O mas de -7, entonces me hace esto (desactivo el pintado de normales para que se vea mejor:

http://picasaweb.google.com/lh/photo/XPBMFshWCaeOOSBTuofNAw?feat=directlink

Aunque no se ve mucho, se ve que es el interior del cubo lo que esta mostrando y no es exterior. No entiendo por que, puesto que eso seria un problema de test de profundidad pero me aparece cuando vario la luz.

Por favor, si pudierais darme una pista os lo agradeceria :)