Pues nada que estaba haciendo un generador de lightmap cutrecillo para intros 64k y me he encontrado algunos problemas. El mas importante es que en los filos de algunos poligonos salen unos bordes un tanto desagradables :P mirad en
http://usuarios.tripod.es/andromeda_studios/asynkro el fichero lightmaptest.zip (No pongo la url completa xq tripod le ha dao por redireccionarte a la index para q veas la web entera :S )
Total probad solamente los 3 ultimos porque los primeros no vienen al caso. Una cosa que pense a la hora de descartar poligonos cuando se testean es ver si entre el poligono actual y el que estamos testeando hay veritces en comun, de esta manear nunca podria cortar el rayo no? :P Es que no se me ocurre otro metodo para evitar eso. Lord trancos algun consejo? O:) jejej
Thanks
dónde has encontrado información sobre generación de lightmaps?
CitarTotal probad solamente los 3 ultimos porque los primeros no vienen al caso.
No me salen los lm. prob. pq no tengo multitextura ^_^; (banshee rulez)
CitarUna cosa que pense a la hora de descartar poligonos cuando se testean es ver si entre el poligono actual y el que estamos testeando hay veritces en comun, de esta manear nunca podria cortar el rayo no?
Si q podria darse el caso; q un poligono comparta vertices con otro no impide q pueda hacerle sombra.
CitarEs que no se me ocurre otro metodo para evitar eso.
Si he entendido bien lo que te pasa;... mis poligonos tb tienen zonas oscuras en las juntas,... pero esto no es ningun problema... me gusta como queda... ^_^
Con el filtrado y tal no queda mal...
De hecho recuerdo haber visto problemas semejantes en juegos comerciales; ahora mismo no me acuerdo q juego era, pero en un FPS de la segunda guerra mundial, recuerdo estar dentro de una habitacion la luz que habia en el pasillo era visible en el suelo que habia cerca de las paredes de la habitacion (como si la luz pasara por debajo de la pared)....
Para reducir estos efectos el filtrado de los lightmaps hace maravillas y ademas tb cuando trazo los rayos de la luz hasta los poligonos, uso una distancia a modo de distancia de seguridad.
// check intersection
if (triIntersectRayEx(_light, _dir, P_Vec(a), @e0, @e1,
_dist, _u, _v)) then
begin
if (_dist > 0) and (_dist < _distance - g_Collision_Dist) then
g_Collision_Dist es la distancia de seguridad.
_dist es a que distancia se produce la colision con el triangulo. (<0 no colisiona)
_distance es la distancia que hay desde la luz hasta el punto para el cual quiero el lightmap.
La distancia de seguridad basicamente elimina el problema cuando hay poco angulo, pero en las esquinas de una habitacion no suele salvar el problema (a no ser que se use una distancia grande)
Colson;
Lord Trancos:
Pues si efectivamente los tres ultimos utilizan multitextura (Sorry en esa version no hago chequeo de extensiones jeje) Ya te pasare una captura para que veas a que me refiero. Por cierto no he comprendido muy bien para que usas la distancia esa de seguridad que sentido tiene? :)
Colson:
Pues solo encontre un tutorial asi simplecillo en una google, busca "olygone lightmap tutorial". No he encontrado ninguno de como generar las sombras, la mayoria que hay y el codigo q he encontradono tiene sombras vamos pero es bastante faci meterlas con un poco de idea de matematicas.
Yo lo que hice para solucionar eso (aunque ahora mismo no se si se llegó a solucionar, creo que sí, ya que hace mucho tiempo que me puse a trastear con los lightmaps) fue, a la hora de calcular las coordenadas de textura del lightmap, calcular el centro de masas del polígono y entonces expandir las coordenadas del lightmap tomando como pivote el centro de masas...
Es algo así:
#define LIGHTMAP_SIZE 32
#define SCALE (1.0f - 1.0f / float(LIGHTMAP_SIZE))
void CMap::CalcFaceST(face_t *face, D3DXVECTOR2 *mins, D3DXVECTOR2 *maxs)
{
int i;
D3DXVECTOR2 stMins, stMaxs, stDelta;
D3DXVECTOR3 massCenter(0, 0, 0);
// Nos preparamos para calcular el centro de masas
for(i = 0; i < face->vertexNum; i++)
{
massCenter.x += face->vertices[i].vertex.x;
massCenter.y += face->vertices[i].vertex.y;
massCenter.z += face->vertices[i].vertex.z;
}
// Calculamos el centro de masas
massCenter.x /= face->vertexNum;
massCenter.y /= face->vertexNum;
massCenter.z /= face->vertexNum;
// Calculamos las coordenadas S y T en world space
for(i = 0; i < face->vertexNum; i++)
{
// Tenemos que saber en qué plano descansa nuestra face
// para saber qué componentes debemos usar para asignar
// las coordenadas S y T del lightmap
switch(face->plane.type)
{
case PLANE_YZ:
face->vertices[i].lmap_s = (face->vertices[i].vertex.z - massCenter.z) * SCALE + massCenter.z;
face->vertices[i].lmap_t = (face->vertices[i].vertex.y - massCenter.y) * SCALE + massCenter.y;
break;
case PLANE_XZ:
face->vertices[i].lmap_s = (face->vertices[i].vertex.x - massCenter.x) * SCALE + massCenter.x;
face->vertices[i].lmap_t = (face->vertices[i].vertex.z - massCenter.z) * SCALE + massCenter.z;
break;
case PLANE_XY:
face->vertices[i].lmap_s = (face->vertices[i].vertex.x - massCenter.x) * SCALE + massCenter.x;
face->vertices[i].lmap_t = (face->vertices[i].vertex.y - massCenter.y) * SCALE + massCenter.y;
break;
default:
break;
}
}
// Ahora tenemos que hallar las extensiones de la face
stMins.x = face->vertices[0].lmap_s;
stMins.y = face->vertices[0].lmap_t;
stMaxs.x = face->vertices[0].lmap_s;
stMaxs.y = face->vertices[0].lmap_t;
for(i = 0; i < face->vertexNum; i++)
{
// Mínimos
if(face->vertices[i].lmap_s < stMins.x)
stMins.x = face->vertices[i].lmap_s;
if(face->vertices[i].lmap_t < stMins.y)
stMins.y = face->vertices[i].lmap_t;
// Máximos
if(face->vertices[i].lmap_s > stMaxs.x)
stMaxs.x = face->vertices[i].lmap_s;
if(face->vertices[i].lmap_t > stMaxs.y)
stMaxs.y = face->vertices[i].lmap_t;
}
// Calculamos la distancia entre el máximo y el mínimo
// para una posterior normalización de las coordendas del
// lightmap (0.0 <-> 1.0)
stDelta.x = stMaxs.x - stMins.x;
stDelta.y = stMaxs.y - stMins.y;
// Normalizamos las coordenadas del lightmap
for(i = 0; i < face->vertexNum; i++)
{
face->vertices[i].lmap_s -= stMins.x;
face->vertices[i].lmap_t -= stMins.y;
face->vertices[i].lmap_s /= stDelta.x;
face->vertices[i].lmap_t /= stDelta.y;
}
// Asignamos el máximo y el mínimo
*mins = stMins;
*maxs = stMaxs;
}
Saludos
CitarLord Trancos:
Pues si efectivamente los tres ultimos utilizan multitextura (Sorry en esa version no hago chequeo de extensiones jeje) Ya te pasare una captura para que veas a que me refiero. Por cierto no he comprendido muy bien para que usas la distancia esa de seguridad que sentido tiene? :)
bufff... ^_^ pueeee.... es para q si el de delante frena de golpe no te lo comas.... xDDDDDD
Ahorap en serio; es para evitar colisiones con poligonos que haya cerca del poligono que se esta lightmapeando
Sin distancia
* |
. |
. |
. |
.|
-------
Con distancia
* |
. |
. |
. |
|
-------
Las rallas son poligonos, el asterisco es una luz, y los puntitos es un rayo de luz. La distancia de seguridad impide que el rayo de luz "llegue" y colisione y asi las esquinas no se oscurecen con una sombra (o al menos se oscurecen menos),
El ejemplo tb es aplicable a dos poligonos en el mismo plano que (por ejemplo) forman una pared.
Ok Muchas gracias B3RS3RK3R y Lord Trancos, estoy deseando llegar a mi casa para probarlo jejeje a ver que tal. Ya os contare :)
berserker :
face_t exactamente q es ? si es solo una cara de un poligono no entiendo muy bien todo el codigo. No seria mas logico para un grupo de caras ? creo q hay algo q no tengo claro xDD
saludos