#include "polygon.h"
cvar_t r_mipskins = {CVAR_SAVE, "r_mipskins", "0", "mipmaps model skins so they render faster in the distance and do not display noise artifacts, can cause discoloration of skins if they contain undesirable border colors"};
-cvar_t mod_generatelightmaps_unitspersample = {CVAR_SAVE, "mod_generatelightmaps_unitspersample", "16", "lightmap resolution"};
+cvar_t mod_generatelightmaps_unitspersample = {CVAR_SAVE, "mod_generatelightmaps_unitspersample", "8", "lightmap resolution"};
cvar_t mod_generatelightmaps_borderpixels = {CVAR_SAVE, "mod_generatelightmaps_borderpixels", "2", "extra space around polygons to prevent sampling artifacts"};
cvar_t mod_generatelightmaps_texturesize = {CVAR_SAVE, "mod_generatelightmaps_texturesize", "1024", "size of lightmap textures"};
+cvar_t mod_generatelightmaps_lightmapsamples = {CVAR_SAVE, "mod_generatelightmaps_lightmapsamples", "16", "number of shadow tests done per lightmap pixel"};
+cvar_t mod_generatelightmaps_vertexsamples = {CVAR_SAVE, "mod_generatelightmaps_vertexsamples", "16", "number of shadow tests done per vertex"};
+cvar_t mod_generatelightmaps_gridsamples = {CVAR_SAVE, "mod_generatelightmaps_gridsamples", "64", "number of shadow tests done per lightgrid cell"};
+cvar_t mod_generatelightmaps_lightmapradius = {CVAR_SAVE, "mod_generatelightmaps_lightmapradius", "16", "sampling area around each lightmap pixel"};
+cvar_t mod_generatelightmaps_vertexradius = {CVAR_SAVE, "mod_generatelightmaps_vertexradius", "16", "sampling area around each vertex"};
+cvar_t mod_generatelightmaps_gridradius = {CVAR_SAVE, "mod_generatelightmaps_gridradius", "64", "sampling area around each lightgrid cell center"};
dp_model_t *loadmodel;
Cvar_RegisterVariable(&mod_generatelightmaps_unitspersample);
Cvar_RegisterVariable(&mod_generatelightmaps_borderpixels);
Cvar_RegisterVariable(&mod_generatelightmaps_texturesize);
+
+ Cvar_RegisterVariable(&mod_generatelightmaps_lightmapsamples);
+ Cvar_RegisterVariable(&mod_generatelightmaps_vertexsamples);
+ Cvar_RegisterVariable(&mod_generatelightmaps_gridsamples);
+ Cvar_RegisterVariable(&mod_generatelightmaps_lightmapradius);
+ Cvar_RegisterVariable(&mod_generatelightmaps_vertexradius);
+ Cvar_RegisterVariable(&mod_generatelightmaps_gridradius);
+
Cmd_AddCommand ("modellist", Mod_Print, "prints a list of loaded models");
Cmd_AddCommand ("modelprecache", Mod_Precache, "load a model");
Cmd_AddCommand ("modeldecompile", Mod_Decompile_f, "exports a model in several formats for editing purposes");
}
lightmaptriangle_t;
+typedef struct lightmaplight_s
+{
+ float origin[3];
+ float radius;
+ float iradius;
+ float radius2;
+ float color[3];
+ svbsp_t svbsp;
+}
+lightmaplight_t;
+
lightmaptriangle_t *mod_generatelightmaps_lightmaptriangles;
-extern void R_SampleRTLights(const float *pos, float *sample);
+#define MAX_LIGHTMAPSAMPLES 64
+static int mod_generatelightmaps_numoffsets[3];
+static float mod_generatelightmaps_offsets[3][MAX_LIGHTMAPSAMPLES][3];
+
+static int mod_generatelightmaps_numlights;
+static lightmaplight_t *mod_generatelightmaps_lightinfo;
+
+static void Mod_GenerateLightmaps_CreateLights_ComputeSVBSP_InsertSurfaces(const dp_model_t *model, svbsp_t *svbsp, const float *mins, const float *maxs)
+{
+ int surfaceindex;
+ int triangleindex;
+ const msurface_t *surface;
+ const float *vertex3f = model->surfmesh.data_vertex3f;
+ const int *element3i = model->surfmesh.data_element3i;
+ const int *e;
+ double v2[3][3];
+ for (surfaceindex = 0, surface = model->data_surfaces;surfaceindex < model->nummodelsurfaces;surfaceindex++, surface++)
+ {
+ if (!BoxesOverlap(surface->mins, surface->maxs, mins, maxs))
+ continue;
+ if (R_GetCurrentTexture(surface->texture)->currentmaterialflags & MATERIALFLAG_NOSHADOW)
+ continue;
+ for (triangleindex = 0, e = element3i + 3*surface->num_firsttriangle;triangleindex < surface->num_triangles;triangleindex++, e += 3)
+ {
+ VectorCopy(vertex3f + 3*e[0], v2[0]);
+ VectorCopy(vertex3f + 3*e[1], v2[1]);
+ VectorCopy(vertex3f + 3*e[2], v2[2]);
+ SVBSP_AddPolygon(svbsp, 3, v2[0], true, NULL, NULL, 0);
+ }
+ }
+}
-static void Mod_GenerateLightmaps_SamplePoint(const float *pos, float *sample)
+static void Mod_GenerateLightmaps_CreateLights_ComputeSVBSP(dp_model_t *model, lightmaplight_t *lightinfo)
+{
+ int maxnodes = 1<<14;
+ svbsp_node_t *nodes;
+ double origin[3];
+ float mins[3];
+ float maxs[3];
+ svbsp_t svbsp;
+ VectorSet(mins, lightinfo->origin[0] - lightinfo->radius, lightinfo->origin[1] - lightinfo->radius, lightinfo->origin[2] - lightinfo->radius);
+ VectorSet(maxs, lightinfo->origin[0] + lightinfo->radius, lightinfo->origin[1] + lightinfo->radius, lightinfo->origin[2] + lightinfo->radius);
+ VectorCopy(lightinfo->origin, origin);
+ nodes = Mem_Alloc(tempmempool, maxnodes * sizeof(*nodes));
+ for (;;)
+ {
+ SVBSP_Init(&svbsp, origin, maxnodes, nodes);
+ Mod_GenerateLightmaps_CreateLights_ComputeSVBSP_InsertSurfaces(model, &svbsp, mins, maxs);
+ if (svbsp.ranoutofnodes)
+ {
+ maxnodes *= 2;
+ if (maxnodes >= 1<<22)
+ {
+ Mem_Free(nodes);
+ return;
+ }
+ Mem_Free(nodes);
+ nodes = Mem_Alloc(tempmempool, maxnodes * sizeof(*nodes));
+ }
+ else
+ break;
+ }
+ if (svbsp.numnodes > 0)
+ {
+ svbsp.nodes = Mem_Alloc(tempmempool, svbsp.numnodes * sizeof(*nodes));
+ memcpy(svbsp.nodes, nodes, svbsp.numnodes * sizeof(*nodes));
+ lightinfo->svbsp = svbsp;
+ }
+ Mem_Free(nodes);
+}
+
+extern int R_Shadow_GetRTLightInfo(unsigned int lightindex, float *origin, float *radius, float *color);
+static void Mod_GenerateLightmaps_CreateLights(dp_model_t *model)
+{
+ int index;
+ int result;
+ lightmaplight_t *lightinfo;
+ float origin[3];
+ float radius;
+ float color[3];
+ mod_generatelightmaps_numlights = 0;
+ for (index = 0;;index++)
+ {
+ result = R_Shadow_GetRTLightInfo(index, origin, &radius, color);
+ if (result < 0)
+ break;
+ if (result > 0)
+ mod_generatelightmaps_numlights++;
+ }
+ if (mod_generatelightmaps_numlights > 0)
+ {
+ mod_generatelightmaps_lightinfo = Mem_Alloc(tempmempool, mod_generatelightmaps_numlights * sizeof(*mod_generatelightmaps_lightinfo));
+ lightinfo = mod_generatelightmaps_lightinfo;
+ for (index = 0;;index++)
+ {
+ result = R_Shadow_GetRTLightInfo(index, lightinfo->origin, &lightinfo->radius, lightinfo->color);
+ if (result < 0)
+ break;
+ if (result > 0)
+ lightinfo++;
+ }
+ }
+ for (index = 0, lightinfo = mod_generatelightmaps_lightinfo;index < mod_generatelightmaps_numlights;index++, lightinfo++)
+ {
+ lightinfo->iradius = 1.0f / lightinfo->radius;
+ lightinfo->radius2 = lightinfo->radius * lightinfo->radius;
+ // TODO: compute svbsp
+ Mod_GenerateLightmaps_CreateLights_ComputeSVBSP(model, lightinfo);
+ }
+}
+
+static void Mod_GenerateLightmaps_DestroyLights(dp_model_t *model)
{
int i;
+ if (mod_generatelightmaps_lightinfo)
+ {
+ for (i = 0;i < mod_generatelightmaps_numlights;i++)
+ if (mod_generatelightmaps_lightinfo[i].svbsp.nodes)
+ Mem_Free(mod_generatelightmaps_lightinfo[i].svbsp.nodes);
+ Mem_Free(mod_generatelightmaps_lightinfo);
+ }
+ mod_generatelightmaps_lightinfo = NULL;
+ mod_generatelightmaps_numlights = 0;
+}
+
+static qboolean Mod_GenerateLightmaps_SamplePoint_SVBSP(const svbsp_t *svbsp, const float *pos)
+{
+ const svbsp_node_t *node;
+ const svbsp_node_t *nodes = svbsp->nodes;
+ int num = 0;
+ while (num >= 0)
+ {
+ node = nodes + num;
+ num = node->children[DotProduct(node->plane, pos) < node->plane[3]];
+ }
+ return num == -1; // true if empty, false if solid (shadowed)
+}
+
+extern cvar_t r_shadow_lightattenuationdividebias;
+extern cvar_t r_shadow_lightattenuationlinearscale;
+static void Mod_GenerateLightmaps_SamplePoint(const float *pos, const float *normal, float *sample, int numoffsets, const float *offsets)
+{
+ int i;
+ float relativepoint[3];
+ float color[3];
+ float offsetpos[3];
+ float dist;
+ float dist2;
+ float intensity;
+ int offsetindex;
+ int hits;
+ int tests;
+ const lightmaplight_t *lightinfo;
+ trace_t trace;
for (i = 0;i < 5*3;i++)
sample[i] = 0.0f;
- R_SampleRTLights(pos, sample);
+ for (i = 0, lightinfo = mod_generatelightmaps_lightinfo;i < mod_generatelightmaps_numlights;i++, lightinfo++)
+ {
+ //R_SampleRTLights(pos, sample, numoffsets, offsets);
+ VectorSubtract(lightinfo->origin, pos, relativepoint);
+ // don't accept light from behind a surface, it causes bad shading
+ if (normal && DotProduct(relativepoint, normal) <= 0)
+ continue;
+ dist2 = VectorLength2(relativepoint);
+ if (dist2 >= lightinfo->radius2)
+ continue;
+ dist = sqrt(dist2) * lightinfo->iradius;
+ intensity = dist < 1 ? ((1.0f - dist) * r_shadow_lightattenuationlinearscale.value / (r_shadow_lightattenuationdividebias.value + dist*dist)) : 0;
+ if (intensity <= 0)
+ continue;
+ if (cl.worldmodel && cl.worldmodel->TraceLine && numoffsets > 0)
+ {
+ hits = 0;
+ tests = 1;
+ if (Mod_GenerateLightmaps_SamplePoint_SVBSP(&lightinfo->svbsp, pos))
+ hits++;
+ for (offsetindex = 1;offsetindex < numoffsets;offsetindex++)
+ {
+ VectorAdd(pos, offsets + 3*offsetindex, offsetpos);
+ if (!normal)
+ {
+ // for light grid we'd better check visibility of the offset point
+ cl.worldmodel->TraceLine(cl.worldmodel, NULL, NULL, &trace, pos, offsetpos, SUPERCONTENTS_VISBLOCKERMASK);
+ if (trace.fraction < 1)
+ VectorLerp(pos, trace.fraction, offsetpos, offsetpos);
+ }
+ tests++;
+ if (Mod_GenerateLightmaps_SamplePoint_SVBSP(&lightinfo->svbsp, offsetpos))
+ hits++;
+ }
+ if (!hits)
+ continue;
+ // scale intensity according to how many rays succeeded
+ // we know one test is valid, half of the rest will fail...
+ //if (normal && tests > 1)
+ // intensity *= (tests - 1.0f) / tests;
+ intensity *= (float)hits / tests;
+ }
+ // scale down intensity to add to both ambient and diffuse
+ //intensity *= 0.5f;
+ VectorNormalize(relativepoint);
+ VectorScale(lightinfo->color, intensity, color);
+ VectorMA(sample , 0.5f , color, sample );
+ VectorMA(sample + 3, relativepoint[0], color, sample + 3);
+ VectorMA(sample + 6, relativepoint[1], color, sample + 6);
+ VectorMA(sample + 9, relativepoint[2], color, sample + 9);
+ // calculate a weighted average light direction as well
+ intensity *= VectorLength(color);
+ VectorMA(sample + 12, intensity, relativepoint, sample + 12);
+ }
}
static void Mod_GenerateLightmaps_LightmapSample(const float *pos, const float *normal, unsigned char *lm_bgr, unsigned char *lm_dir)
float color[3];
float dir[3];
float f;
- Mod_GenerateLightmaps_SamplePoint(pos, sample);
+ Mod_GenerateLightmaps_SamplePoint(pos, normal, sample, mod_generatelightmaps_numoffsets[0], mod_generatelightmaps_offsets[0][0]);
//VectorSet(dir, sample[3] + sample[4] + sample[5], sample[6] + sample[7] + sample[8], sample[9] + sample[10] + sample[11]);
VectorCopy(sample + 12, dir);
VectorNormalize(dir);
- VectorAdd(dir, normal, dir);
- VectorNormalize(dir);
+ //VectorAdd(dir, normal, dir);
+ //VectorNormalize(dir);
f = DotProduct(dir, normal);
f = max(0, f) * 255.0f;
VectorScale(sample, f, color);
//VectorCopy(normal, dir);
- if (r_test.integer & 1) dir[0] *= -1.0f;
- if (r_test.integer & 2) dir[1] *= -1.0f;
- if (r_test.integer & 4) dir[2] *= -1.0f;
VectorSet(dir, (dir[0]+1.0f)*127.5f, (dir[1]+1.0f)*127.5f, (dir[2]+1.0f)*127.5f);
lm_bgr[0] = (unsigned char)bound(0.0f, color[2], 255.0f);
lm_bgr[1] = (unsigned char)bound(0.0f, color[1], 255.0f);
static void Mod_GenerateLightmaps_VertexSample(const float *pos, const float *normal, float *vertex_color)
{
float sample[5*3];
- Mod_GenerateLightmaps_SamplePoint(pos, sample);
+ Mod_GenerateLightmaps_SamplePoint(pos, normal, sample, mod_generatelightmaps_numoffsets[1], mod_generatelightmaps_offsets[1][0]);
VectorCopy(sample, vertex_color);
}
float ambient[3];
float diffuse[3];
float dir[3];
- Mod_GenerateLightmaps_SamplePoint(pos, sample);
+ Mod_GenerateLightmaps_SamplePoint(pos, NULL, sample, mod_generatelightmaps_numoffsets[2], mod_generatelightmaps_offsets[2][0]);
// calculate the direction we'll use to reduce the sample to a directional light source
VectorCopy(sample + 12, dir);
//VectorSet(dir, sample[3] + sample[4] + sample[5], sample[6] + sample[7] + sample[8], sample[9] + sample[10] + sample[11]);
VectorNormalize(dir);
- // scale the ambient from 0-2 to 0-255
- VectorScale(sample, 255.0f, ambient);
// extract the diffuse color along the chosen direction and scale it
- diffuse[0] = (dir[0]*sample[3] + dir[1]*sample[6] + dir[2]*sample[ 9] + sample[0]) * 255.0f;
- diffuse[1] = (dir[0]*sample[4] + dir[1]*sample[7] + dir[2]*sample[10] + sample[1]) * 255.0f;
- diffuse[2] = (dir[0]*sample[5] + dir[1]*sample[8] + dir[2]*sample[11] + sample[2]) * 255.0f;
+ diffuse[0] = (dir[0]*sample[3] + dir[1]*sample[6] + dir[2]*sample[ 9] + sample[ 0]) * 127.5f;
+ diffuse[1] = (dir[0]*sample[4] + dir[1]*sample[7] + dir[2]*sample[10] + sample[ 1]) * 127.5f;
+ diffuse[2] = (dir[0]*sample[5] + dir[1]*sample[8] + dir[2]*sample[11] + sample[ 2]) * 127.5f;
+ // scale the ambient from 0-2 to 0-255 and subtract some of diffuse
+ VectorScale(sample, 127.5f, ambient);
+ VectorMA(ambient, -0.333f, diffuse, ambient);
// encode to the grid format
s->ambientrgb[0] = (unsigned char)bound(0.0f, ambient[0], 255.0f);
s->ambientrgb[1] = (unsigned char)bound(0.0f, ambient[1], 255.0f);
s->diffusergb[0] = (unsigned char)bound(0.0f, diffuse[0], 255.0f);
s->diffusergb[1] = (unsigned char)bound(0.0f, diffuse[1], 255.0f);
s->diffusergb[2] = (unsigned char)bound(0.0f, diffuse[2], 255.0f);
- if (dir[2] >= 0.99f) {s->diffuseyaw = 0;s->diffusepitch = 0;}
- else if (dir[2] <= -0.99f) {s->diffuseyaw = 0;s->diffusepitch = 128;}
- else {s->diffuseyaw = (unsigned char)(acos(dir[2]) * (127.5f/M_PI));s->diffusepitch = (unsigned char)(atan2(dir[1], dir[0]) * (127.5f/M_PI));}
+ if (dir[2] >= 0.99f) {s->diffusepitch = 0;s->diffuseyaw = 0;}
+ else if (dir[2] <= -0.99f) {s->diffusepitch = 128;s->diffuseyaw = 0;}
+ else {s->diffusepitch = (unsigned char)(acos(dir[2]) * (127.5f/M_PI));s->diffuseyaw = (unsigned char)(atan2(dir[1], dir[0]) * (127.5f/M_PI));}
+}
+
+static void Mod_GenerateLightmaps_InitSampleOffsets(dp_model_t *model)
+{
+ float radius[3];
+ float temp[3];
+ int i, j;
+ memset(mod_generatelightmaps_offsets, 0, sizeof(mod_generatelightmaps_offsets));
+ mod_generatelightmaps_numoffsets[0] = min(MAX_LIGHTMAPSAMPLES, mod_generatelightmaps_lightmapsamples.integer);
+ mod_generatelightmaps_numoffsets[1] = min(MAX_LIGHTMAPSAMPLES, mod_generatelightmaps_vertexsamples.integer);
+ mod_generatelightmaps_numoffsets[2] = min(MAX_LIGHTMAPSAMPLES, mod_generatelightmaps_gridsamples.integer);
+ radius[0] = mod_generatelightmaps_lightmapradius.value;
+ radius[1] = mod_generatelightmaps_vertexradius.value;
+ radius[2] = mod_generatelightmaps_gridradius.value;
+ for (i = 0;i < 3;i++)
+ {
+ for (j = 1;j < mod_generatelightmaps_numoffsets[i];j++)
+ {
+ VectorRandom(temp);
+ VectorScale(temp, radius[i], mod_generatelightmaps_offsets[i][j]);
+ }
+ }
}
static void Mod_GenerateLightmaps_DestroyLightmaps(dp_model_t *model)
msurface_t *surface;
int surfaceindex;
int i;
+ int axis;
+ float normal[3];
const int *e;
lightmaptriangle_t *triangle;
// generate lightmap triangle structs
VectorCopy(model->surfmesh.data_vertex3f + 3*e[i*3+0], triangle->vertex[0]);
VectorCopy(model->surfmesh.data_vertex3f + 3*e[i*3+1], triangle->vertex[1]);
VectorCopy(model->surfmesh.data_vertex3f + 3*e[i*3+2], triangle->vertex[2]);
- }
- }
-}
-
-float lmaxis[3][3] = {{1, 0, 0}, {0, 1, 0}, {0, 0, 1}};
-
-static void Mod_GenerateLightmaps_ClassifyTriangles(dp_model_t *model)
-{
- msurface_t *surface;
- int surfaceindex;
- int i;
- int axis;
- float normal[3];
- const int *e;
- lightmaptriangle_t *triangle;
-
- for (surfaceindex = 0;surfaceindex < model->num_surfaces;surfaceindex++)
- {
- surface = model->data_surfaces + surfaceindex;
- e = model->surfmesh.data_element3i + surface->num_firsttriangle*3;
- for (i = 0;i < surface->num_triangles;i++)
- {
- triangle = &mod_generatelightmaps_lightmaptriangles[surface->num_firsttriangle+i];
// calculate bounds of triangle
triangle->mins[0] = min(triangle->vertex[0][0], min(triangle->vertex[1][0], triangle->vertex[2][0]));
triangle->mins[1] = min(triangle->vertex[0][1], min(triangle->vertex[1][1], triangle->vertex[2][1]));
}
}
+static void Mod_GenerateLightmaps_DestroyTriangleInformation(dp_model_t *model)
+{
+ if (mod_generatelightmaps_lightmaptriangles)
+ Mem_Free(mod_generatelightmaps_lightmaptriangles);
+ mod_generatelightmaps_lightmaptriangles = NULL;
+}
+
+float lmaxis[3][3] = {{1, 0, 0}, {0, 1, 0}, {0, 0, 1}};
+
static void Mod_GenerateLightmaps_CreateLightmaps(dp_model_t *model)
{
msurface_t *surface;
pixeloffset = ((triangle->lightmapindex * lm_texturesize + y + triangle->lmoffset[1]) * lm_texturesize + triangle->lmoffset[0]) * 4;
for (x = 0;x < triangle->lmsize[0];x++, pixeloffset += 4)
{
- samplecenter[axis1] = x*lmiscale[0] + triangle->lmbase[0];
- samplecenter[axis2] = y*lmiscale[1] + triangle->lmbase[1];
+ samplecenter[axis1] = (x+0.5f)*lmiscale[0] + triangle->lmbase[0];
+ samplecenter[axis2] = (y+0.5f)*lmiscale[1] + triangle->lmbase[1];
samplecenter[axis] = samplecenter[axis1]*slopex + samplecenter[axis2]*slopey + slopebase;
VectorMA(samplecenter, 0.125f, samplenormal, samplecenter);
Mod_GenerateLightmaps_LightmapSample(samplecenter, samplenormal, lightmappixels + pixeloffset, deluxemappixels + pixeloffset);
dp_model_t *oldloadmodel = loadmodel;
loadmodel = model;
+ Mod_GenerateLightmaps_InitSampleOffsets(model);
Mod_GenerateLightmaps_DestroyLightmaps(model);
Mod_GenerateLightmaps_UnweldTriangles(model);
Mod_GenerateLightmaps_CreateTriangleInformation(model);
- Mod_GenerateLightmaps_ClassifyTriangles(model);
+ Mod_GenerateLightmaps_CreateLights(model);
if(!mod_q3bsp_nolightmaps.integer)
Mod_GenerateLightmaps_CreateLightmaps(model);
Mod_GenerateLightmaps_UpdateVertexColors(model);
Mod_GenerateLightmaps_UpdateLightGrid(model);
-#if 0
- // stage 1:
- // first step is deleting the lightmaps
- for (surfaceindex = 0;surfaceindex < model->num_surfaces;surfaceindex++)
- {
- surface = model->data_surfaces + surfaceindex;
- surface->lightmap = NULL;
- surface->deluxemap = NULL;
- // add a sample for each vertex of surface
- for (i = 0, vertexindex = surface->num_firstvertex;i < surface->num_vertices;i++, vertexindex++)
- Mod_GenerateLightmaps_AddSample(model->surfmesh.data_vertex3f + 3*vertexindex, model->surfmesh.data_normal3f + 3*vertexindex, model->surfmesh.data_lightmapcolor4f + 4*vertexindex, NULL, NULL);
- // generate lightmaptriangle_t for each triangle of surface
- for (i = 0, triangleindex = surface->num_firstvertex;i < surface->num_triangles;i++, triangleindex++)
- {
- }
-#endif
-
- if (mod_generatelightmaps_lightmaptriangles)
- Mem_Free(mod_generatelightmaps_lightmaptriangles);
- mod_generatelightmaps_lightmaptriangles = NULL;
+ Mod_GenerateLightmaps_DestroyLights(model);
+ Mod_GenerateLightmaps_DestroyTriangleInformation(model);
loadmodel = oldloadmodel;
}