Half-Life 2 BSP Lightmaps

Estoy escribiendo un visor BSP para un proyecto universitario. Hasta ahora tengo la geometría principal cargada correctamente y el PVS funciona.

Ahora estoy tratando de aplicar los mapas de luz, pero parece que no puedo calcular correctamente las coordenadas de textura para los mapas de luz.

De acuerdo a aquí: http://developer.valvesoftware.com/wiki/The_Source_Engine_BSP_File_Format

struct texinfo_t
{
    float textureVecs[2][4];  // [s/t][xyz offset]
    float lightmapVecs[2][4]; // [s/t][xyz offset] - length is in units of texels/area
    int flags;                // miptex flags overrides
    int texdata;               // Pointer to texture name, size, etc.
}

El primer conjunto de flotadores son, en esencia, dos vectores que representan cómo se orienta y se escala la textura cuando se representa en la geometría mundial. Los dos vectores, syt, son el mapeo de las direcciones de izquierda a derecha y de abajo hacia arriba en el espacio de coordenadas de píxeles de textura, en el mundo. Cada vector tiene un componente x, y y z, más un desplazamiento que es el "desplazamiento" de la textura en esa dirección en relación con el mundo. La longitud de los vectores representa la escala de la textura en cada dirección.

Las coordenadas 2D (u, v) de un píxel de textura (o texel) se asignan a las coordenadas mundiales (x, y, z) de un punto en una cara de la siguiente manera:

u = tv0,0 * x + tv0,1 * y + tv0,2 * z + tv0,3

v = tv1,0 * x + tv1,1 * y + tv1,2 * z + tv1,3

(es decir. El producto escalar de los vectores con el vértice más el desplazamiento en esa dirección. Donde tvA, B es textureVecs [A] [B].

Además, después de calcular (u, v), para convertirlos en coordenadas de textura que enviaría a su tarjeta gráfica, divida u y v entre el ancho y el alto de la textura, respectivamente.

Entonces estoy haciendo el cálculo de la siguiente manera. Tome el producto de punto del vértice y el vector de mapa de luz (lightmapVecs [0] [0], lightmapVecs 0 , lightmapVecs [0] [2]) agregue el desplazamiento (lightmapVecs [0] [3]), reste los minutos y divida El resultado por el ancho / alto.

float s = Vector3f.dot(v, new Vector3f(lightmapVecs[0][0], lightmapVecs[0][1], lightmapVecs[0][2])) + lightmapVecs[0][3] - f.LightmapTextureMinsInLuxels[0];
float t = Vector3f.dot(v, new Vector3f(lightmapVecs[1][0], lightmapVecs[1][1], lightmapVecs[1][2])) + lightmapVecs[1][3] - f.LightmapTextureMinsInLuxels[1];
s /= (f.LightmapTextureSizeInLuxels[0] + 1);
t /= (f.LightmapTextureSizeInLuxels[1] + 1);

Sin embargo, termina luciendo así:

Aquí hay un ejemplo de cálculo de la textura coord 't' para un vértice.

vertex = 352.0, -144.00027, -224.0
lightmap vector = -4, 0, 0
lightmap offset = 0
lightmap mins = 9
lightmap height = 14

Entonces el producto punto es -1408

(-1408 + 0 - 9) / 14

t = -101.21

Esto parece estar muy lejos.

Finalmente me di cuenta, estaba leyendo los datos incorrectamente. Todo el código anterior es correcto.

Debería normalizar los vectores antes de calcular el producto escalar.