+static int mod_generatelightmaps_numlights;
+static lightmaplight_t *mod_generatelightmaps_lightinfo;
+
+extern cvar_t r_shadow_lightattenuationdividebias;
+extern cvar_t r_shadow_lightattenuationlinearscale;
+
+static void Mod_GenerateLightmaps_LightPoint(dp_model_t *model, const vec3_t pos, vec3_t ambient, vec3_t diffuse, vec3_t lightdir)
+{
+ int i;
+ int index;
+ int result;
+ float relativepoint[3];
+ float color[3];
+ float dir[3];
+ float dist;
+ float dist2;
+ float intensity;
+ float sample[5*3];
+ float lightorigin[3];
+ float lightradius;
+ float lightradius2;
+ float lightiradius;
+ float lightcolor[3];
+ trace_t trace;
+ for (i = 0;i < 5*3;i++)
+ sample[i] = 0.0f;
+ for (index = 0;;index++)
+ {
+ result = R_Shadow_GetRTLightInfo(index, lightorigin, &lightradius, lightcolor);
+ if (result < 0)
+ break;
+ if (result == 0)
+ continue;
+ lightradius2 = lightradius * lightradius;
+ VectorSubtract(lightorigin, pos, relativepoint);
+ dist2 = VectorLength2(relativepoint);
+ if (dist2 >= lightradius2)
+ continue;
+ lightiradius = 1.0f / lightradius;
+ dist = sqrt(dist2) * lightiradius;
+ intensity = (1.0f - dist) * r_shadow_lightattenuationlinearscale.value / (r_shadow_lightattenuationdividebias.value + dist*dist);
+ if (intensity <= 0.0f)
+ continue;
+ if (model && model->TraceLine)
+ {
+ model->TraceLine(model, NULL, NULL, &trace, pos, lightorigin, SUPERCONTENTS_VISBLOCKERMASK);
+ if (trace.fraction < 1)
+ continue;
+ }
+ // scale down intensity to add to both ambient and diffuse
+ //intensity *= 0.5f;
+ VectorNormalize(relativepoint);
+ VectorScale(lightcolor, 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);
+ }
+ // 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);
+ // 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]);
+ diffuse[1] = (dir[0]*sample[4] + dir[1]*sample[7] + dir[2]*sample[10] + sample[ 1]);
+ diffuse[2] = (dir[0]*sample[5] + dir[1]*sample[8] + dir[2]*sample[11] + sample[ 2]);
+ // subtract some of diffuse from ambient
+ VectorMA(sample, -0.333f, diffuse, ambient);
+ // store the normalized lightdir
+ VectorCopy(dir, lightdir);
+}
+
+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;
+ float 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 (surface->texture->basematerialflags & 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_CreateLights_ComputeSVBSP(dp_model_t *model, lightmaplight_t *lightinfo)
+{
+ int maxnodes = 1<<14;
+ svbsp_node_t *nodes;
+ float 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 = (svbsp_node_t *)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 *= 16;
+ if (maxnodes > 1<<22)
+ {
+ Mem_Free(nodes);
+ return;
+ }
+ Mem_Free(nodes);
+ nodes = (svbsp_node_t *)Mem_Alloc(tempmempool, maxnodes * sizeof(*nodes));
+ }
+ else
+ break;
+ }
+ if (svbsp.numnodes > 0)
+ {
+ svbsp.nodes = (svbsp_node_t *)Mem_Alloc(tempmempool, svbsp.numnodes * sizeof(*nodes));
+ memcpy(svbsp.nodes, nodes, svbsp.numnodes * sizeof(*nodes));
+ lightinfo->svbsp = svbsp;
+ }
+ Mem_Free(nodes);
+}
+
+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 = (lightmaplight_t *)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)
+}