#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");
int element[2];
}
edgehashentry_t;
- edgehashentry_t *edgehash[TRIANGLEEDGEHASH], *edgehashentries, edgehashentriesbuffer[TRIANGLEEDGEHASH*3], *hash;
+ static edgehashentry_t *edgehash[TRIANGLEEDGEHASH];
+ edgehashentry_t *edgehashentries, *hash;
+ if (!numtriangles)
+ return;
memset(edgehash, 0, sizeof(edgehash));
- edgehashentries = edgehashentriesbuffer;
// if there are too many triangles for the stack array, allocate larger buffer
- if (numtriangles > TRIANGLEEDGEHASH)
- edgehashentries = (edgehashentry_t *)Mem_Alloc(tempmempool, numtriangles * 3 * sizeof(edgehashentry_t));
+ edgehashentries = (edgehashentry_t *)Mem_Alloc(tempmempool, numtriangles * 3 * sizeof(edgehashentry_t));
// find neighboring triangles
for (i = 0, e = elements, n = neighbors;i < numtriangles;i++, e += 3, n += 3)
{
CL_KeepaliveMessage(false);
}
// free the allocated buffer
- if (edgehashentries != edgehashentriesbuffer)
- Mem_Free(edgehashentries);
+ Mem_Free(edgehashentries);
}
#else
// very slow but simple way
static void Mod_ShadowMesh_CreateVBOs(shadowmesh_t *mesh)
{
- if (!gl_support_arb_vertex_buffer_object)
+ if (!vid.support.arb_vertex_buffer_object)
return;
// element buffer is easy because it's just one array
texflagsmask &= ~TEXF_COMPRESS;
texture->specularscalemod = 1; // unless later loaded from the shader
texture->specularpowermod = 1; // unless later loaded from the shader
+ // WHEN ADDING DEFAULTS HERE, REMEMBER TO SYNC TO SHADER LOADING ABOVE
+ // HERE, AND Q1BSP LOADING
+ // JUST GREP FOR "specularscalemod = 1".
if (shader)
{
{
if (fallback)
{
- qboolean has_alpha;
- if ((texture->skinframes[0] = R_SkinFrame_LoadExternal_CheckAlpha(texture->name, defaulttexflags, false, &has_alpha)))
+ if ((texture->skinframes[0] = R_SkinFrame_LoadExternal(texture->name, defaulttexflags, false)))
{
- if(has_alpha && (defaulttexflags & TEXF_ALPHA))
+ if(texture->skinframes[0]->hasalpha)
texture->basematerialflags |= MATERIALFLAG_ALPHA | MATERIALFLAG_BLENDED | MATERIALFLAG_NOSHADOW;
}
else
}
}
- if (!gl_support_arb_vertex_buffer_object)
+ if (!vid.support.arb_vertex_buffer_object)
return;
// element buffer is easy because it's just one array
state->width = width;
state->height = height;
state->currentY = 0;
- state->rows = Mem_Alloc(tempmempool, state->height * sizeof(*state->rows));
+ state->rows = Mem_Alloc(loadmodel->mempool, state->height * sizeof(*state->rows));
for (y = 0;y < state->height;y++)
{
state->rows[y].currentX = 0;
// 2D modelspace to lightmap coordinate scale
float lmscale[2];
float vertex[3][3];
+ float mins[3];
+ float maxs[3];
}
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;
-static void Mod_GenerateLightmaps_Sample(const float *pos, const float *normal, float *vertex_color, unsigned char *lm_bgr, unsigned char *lm_dir)
+#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)
{
-
-/*
- if (mod_generatelightmaps_maxsamples <= mod_generatelightmaps_numsamples)
- {
- lightmapsample_t *oldsamples = mod_generatelightmaps_samples;
- mod_generatelightmaps_maxsamples = max(65536, mod_generatelightmaps_maxsamples * 2);
-
-
- }
- sample = &mod_generatelightmaps_samples[mod_generatelightmaps_numsamples++];
- memset(sample, 0, sizeof(*sample));
- sample->pos[0] = pos[0];
- sample->pos[1] = pos[1];
- sample->pos[2] = pos[2];
- sample->normal[0] = normal[0];
- sample->normal[1] = normal[1];
- sample->normal[2] = normal[2];
- sample->vertex_color = vertex_color;
- sample->lm_bgr = lm_bgr;
- sample->lm_dir = lm_dir;
- */
+ 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_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;
+ 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 sample[5*3];
+ float color[3];
+ float dir[3];
+ float f;
+ 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);
+ f = DotProduct(dir, normal);
+ f = max(0, f) * 255.0f;
+ VectorScale(sample, f, color);
+ //VectorCopy(normal, dir);
+ 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);
+ lm_bgr[2] = (unsigned char)bound(0.0f, color[0], 255.0f);
+ lm_bgr[3] = 255;
+ lm_dir[0] = (unsigned char)dir[2];
+ lm_dir[1] = (unsigned char)dir[1];
+ lm_dir[2] = (unsigned char)dir[0];
+ lm_dir[3] = 255;
+}
+
+static void Mod_GenerateLightmaps_VertexSample(const float *pos, const float *normal, float *vertex_color)
+{
+ float sample[5*3];
+ Mod_GenerateLightmaps_SamplePoint(pos, normal, sample, mod_generatelightmaps_numoffsets[1], mod_generatelightmaps_offsets[1][0]);
+ VectorCopy(sample, vertex_color);
+}
+
+static void Mod_GenerateLightmaps_GridSample(const float *pos, q3dlightgrid_t *s)
+{
+ float sample[5*3];
+ float ambient[3];
+ float diffuse[3];
+ float dir[3];
+ 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);
+ // 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]) * 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->ambientrgb[2] = (unsigned char)bound(0.0f, ambient[2], 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->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]);
- }
- }
-}
-
-#if 0
-float lmprojection[3][3][3] =
-{
- {{0, 1, 0}, {0, 0, 1}, {1, 0, 0}},
- {{1, 0, 0}, {0, 0, 1}, {0, 1, 0}},
- {{1, 0, 0}, {0, 1, 0}, {0, 0, 1}},
-};
-#endif
-
-static void Mod_GenerateLightmaps_ClassifyTriangles(dp_model_t *model)
-{
- msurface_t *surface;
- int surfaceindex;
- int i;
- int axis;
- float mins[3];
- float maxs[3];
- float aabbsize[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
- mins[0] = min(triangle->vertex[0][0], min(triangle->vertex[1][0], triangle->vertex[2][0]));
- mins[1] = min(triangle->vertex[0][1], min(triangle->vertex[1][1], triangle->vertex[2][1]));
- mins[2] = min(triangle->vertex[0][2], min(triangle->vertex[1][2], triangle->vertex[2][2]));
- maxs[0] = max(triangle->vertex[0][0], max(triangle->vertex[1][0], triangle->vertex[2][0]));
- maxs[1] = max(triangle->vertex[0][1], max(triangle->vertex[1][1], triangle->vertex[2][1]));
- maxs[2] = max(triangle->vertex[0][2], max(triangle->vertex[1][2], triangle->vertex[2][2]));
- // pick an axial projection based on the shortest dimension of the
- // axially aligned bounding box, this is almost equivalent to
- // calculating a triangle normal and classifying its primary axis.
- //
- // one difference is that this method can pick a workable
- // projection axis even for a degenerate triangle whose only shape
- // is a line (where the chosen projection will always map the line
- // to non-zero coordinates in texture space)
- VectorSubtract(maxs, mins, aabbsize);
+ 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]));
+ triangle->mins[2] = min(triangle->vertex[0][2], min(triangle->vertex[1][2], triangle->vertex[2][2]));
+ triangle->maxs[0] = max(triangle->vertex[0][0], max(triangle->vertex[1][0], triangle->vertex[2][0]));
+ triangle->maxs[1] = max(triangle->vertex[0][1], max(triangle->vertex[1][1], triangle->vertex[2][1]));
+ triangle->maxs[2] = max(triangle->vertex[0][2], max(triangle->vertex[1][2], triangle->vertex[2][2]));
+ // pick an axial projection based on the triangle normal
+ TriangleNormal(triangle->vertex[0], triangle->vertex[1], triangle->vertex[2], normal);
axis = 0;
- if (aabbsize[1] < aabbsize[axis])
+ if (fabs(normal[1]) > fabs(normal[axis]))
axis = 1;
- if (aabbsize[2] < aabbsize[axis])
+ if (fabs(normal[2]) > fabs(normal[axis]))
axis = 2;
triangle->axis = axis;
}
}
}
-static void Mod_GenerateLightmaps_AllocateLightmaps(dp_model_t *model)
+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;
int surfaceindex;
int k;
int x;
int y;
+ int axis;
+ int axis1;
+ int axis2;
int retry;
int pixeloffset;
- int row_numpoints;
- int column_numpoints;
- float f;
- float row_plane[3];
- float column_plane[3];
float trianglenormal[3];
- float clipbuf[5][8][3];
float samplecenter[3];
float samplenormal[3];
- float mins[3];
+ float temp[3];
+ float lmiscale[2];
+ float slopex;
+ float slopey;
+ float slopebase;
float lmscalepixels;
float lmmins;
float lmmaxs;
model->texturepool = R_AllocTexturePool();
lm_basescalepixels = 1.0f / max(0.0001f, mod_generatelightmaps_unitspersample.value);
lm_borderpixels = mod_generatelightmaps_borderpixels.integer;
- lm_texturesize = bound(lm_borderpixels*2+1, 64, gl_max_texture_size);
+ lm_texturesize = bound(lm_borderpixels*2+1, 64, (int)vid.maxtexturesize_2d);
lm_maxpixels = lm_texturesize-(lm_borderpixels*2+1);
Mod_AllocLightmap_Init(&lmstate, lm_texturesize, lm_texturesize);
lightmapnumber = 0;
{
if (j == triangle->axis)
continue;
- lmmins = floor(mins[j]*lmscalepixels)-lm_borderpixels;
- lmmaxs = floor(mins[j]*lmscalepixels)+lm_borderpixels;
+ lmmins = floor(triangle->mins[j]*lmscalepixels)-lm_borderpixels;
+ lmmaxs = floor(triangle->maxs[j]*lmscalepixels)+lm_borderpixels;
triangle->lmsize[k] = (int)(lmmaxs-lmmins);
triangle->lmbase[k] = lmmins/lmscalepixels;
triangle->lmscale[k] = lmscalepixels;
break;
// if we haven't maxed out the lightmap size yet, we retry the
// entire surface batch...
- if (lm_texturesize * 2 <= min(mod_generatelightmaps_texturesize.integer, gl_max_texture_size))
+ if (lm_texturesize * 2 <= min(mod_generatelightmaps_texturesize.integer, (int)vid.maxtexturesize_2d))
{
lm_texturesize *= 2;
surfaceindex = -1;
Mod_AllocLightmap_Reset(&lmstate);
}
}
+ lightmapnumber++;
Mod_AllocLightmap_Free(&lmstate);
// now together lightmap textures
+ model->brushq3.deluxemapping_modelspace = true;
+ model->brushq3.deluxemapping = true;
model->brushq3.num_mergedlightmaps = lightmapnumber;
model->brushq3.data_lightmaps = Mem_Alloc(model->mempool, model->brushq3.num_mergedlightmaps * sizeof(rtexture_t *));
model->brushq3.data_deluxemaps = Mem_Alloc(model->mempool, model->brushq3.num_mergedlightmaps * sizeof(rtexture_t *));
lightmappixels = Mem_Alloc(tempmempool, model->brushq3.num_mergedlightmaps * lm_texturesize * lm_texturesize * 4);
deluxemappixels = Mem_Alloc(tempmempool, model->brushq3.num_mergedlightmaps * lm_texturesize * lm_texturesize * 4);
- lightmapnumber = 0;
for (surfaceindex = 0;surfaceindex < model->num_surfaces;surfaceindex++)
{
surface = model->data_surfaces + surfaceindex;
for (i = 0;i < surface->num_triangles;i++)
{
triangle = &mod_generatelightmaps_lightmaptriangles[surface->num_firsttriangle+i];
- VectorClear(row_plane);
- VectorClear(column_plane);
- row_plane[triangle->axis] = 1.0f;
- column_plane[!triangle->axis] = 1.0f;
+ TriangleNormal(triangle->vertex[0], triangle->vertex[1], triangle->vertex[2], trianglenormal);
+ VectorNormalize(trianglenormal);
+ VectorCopy(trianglenormal, samplenormal); // FIXME: this is supposed to be interpolated per pixel from vertices
+ axis = triangle->axis;
+ axis1 = axis == 0 ? 1 : 0;
+ axis2 = axis == 2 ? 1 : 2;
+ lmiscale[0] = 1.0f / triangle->lmscale[0];
+ lmiscale[1] = 1.0f / triangle->lmscale[1];
+ if (trianglenormal[axis] < 0)
+ VectorNegate(trianglenormal, trianglenormal);
+ CrossProduct(lmaxis[axis2], trianglenormal, temp);slopex = temp[axis] / temp[axis1];
+ CrossProduct(lmaxis[axis1], trianglenormal, temp);slopey = temp[axis] / temp[axis2];
+ slopebase = triangle->vertex[0][axis] - triangle->vertex[0][axis1]*slopex - triangle->vertex[0][axis2]*slopey;
+ for (j = 0;j < 3;j++)
+ {
+ float *t2f = model->surfmesh.data_texcoordlightmap2f + e[i*3+j]*2;
+ t2f[0] = ((triangle->vertex[j][axis1] - triangle->lmbase[0]) * triangle->lmscale[0] + triangle->lmoffset[0]) / lm_texturesize;
+ t2f[1] = ((triangle->vertex[j][axis2] - triangle->lmbase[1]) * triangle->lmscale[1] + triangle->lmoffset[1]) / lm_texturesize;
+#if 0
+ samplecenter[axis1] = (t2f[0]*lm_texturesize-triangle->lmoffset[0])*lmiscale[0] + triangle->lmbase[0];
+ samplecenter[axis2] = (t2f[1]*lm_texturesize-triangle->lmoffset[1])*lmiscale[1] + triangle->lmbase[1];
+ samplecenter[axis] = samplecenter[axis1]*slopex + samplecenter[axis2]*slopey + slopebase;
+ Con_Printf("%f:%f %f:%f %f:%f = %f %f\n", triangle->vertex[j][axis1], samplecenter[axis1], triangle->vertex[j][axis2], samplecenter[axis2], triangle->vertex[j][axis], samplecenter[axis], t2f[0], t2f[1]);
+#endif
+ }
+
#if 0
switch (axis)
{
Matrix4x4_FromVectors(&backmatrix, forward, left, up, origin);
#endif
#define LM_DIST_EPSILON (1.0f / 32.0f)
- TriangleNormal(triangle->vertex[0], triangle->vertex[1], triangle->vertex[2], trianglenormal);
- VectorNormalize(trianglenormal);
- PolygonF_QuadForPlane(clipbuf[0][0], trianglenormal[0], trianglenormal[1], trianglenormal[2], DotProduct(trianglenormal, triangle->vertex[0]), model->radius * 2);
- VectorCopy(trianglenormal, samplenormal); // FIXME!
for (y = 0;y < triangle->lmsize[1];y++)
{
- row_numpoints = PolygonF_Clip(4 , clipbuf[0][0], row_plane[0], row_plane[1], row_plane[2], triangle->lmbase[1] + y / triangle->lmscale[1] , LM_DIST_EPSILON, 8, clipbuf[1][0]);
- if (!row_numpoints)
- continue;
- row_numpoints = PolygonF_Clip(row_numpoints, clipbuf[1][0], -row_plane[0], -row_plane[1], -row_plane[2], -(triangle->lmbase[1] + (y+1) / triangle->lmscale[1]), LM_DIST_EPSILON, 8, clipbuf[2][0]);
- if (!row_numpoints)
- continue;
- pixeloffset = triangle->lightmapindex * lm_texturesize * lm_texturesize * 4 + (y+triangle->lmoffset[1]) * lm_texturesize * 4 + triangle->lmoffset[0] * 4;
+ 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)
{
- column_numpoints = PolygonF_Clip(row_numpoints , clipbuf[2][0], column_plane[0], column_plane[1], column_plane[2], triangle->lmbase[0] + x / triangle->lmscale[0] , LM_DIST_EPSILON, 8, clipbuf[3][0]);
- if (!column_numpoints)
- continue;
- column_numpoints = PolygonF_Clip(column_numpoints, clipbuf[3][0], -column_plane[0], -column_plane[1], -column_plane[2], -(triangle->lmbase[0] + (x+1) / triangle->lmscale[0]), LM_DIST_EPSILON, 8, clipbuf[4][0]);
- if (!column_numpoints)
- continue;
- // we now have a polygon fragment in clipbuf[4], we can
- // sample its center or subdivide it further for
- // antialiasing
- VectorClear(samplecenter);
- for (j = 0;j < column_numpoints;j++)
- VectorAdd(samplecenter, clipbuf[4][j], samplecenter);
- f = 1.0f / column_numpoints;
- VectorScale(samplecenter, f, samplecenter);
- VectorMA(samplecenter, 0.125f, trianglenormal, samplecenter);
- Mod_GenerateLightmaps_Sample(samplecenter, samplenormal, NULL, lightmappixels + pixeloffset, deluxemappixels + pixeloffset);
+ 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);
}
}
}
for (lightmapindex = 0;lightmapindex < model->brushq3.num_mergedlightmaps;lightmapindex++)
{
- model->brushq3.data_lightmaps[lightmapindex] = R_LoadTexture2D(model->texturepool, va("lightmap%i", lightmapnumber), lm_texturesize, lm_texturesize, NULL, TEXTYPE_BGRA, TEXF_FORCELINEAR | TEXF_PRECACHE, NULL);
- model->brushq3.data_deluxemaps[lightmapindex] = R_LoadTexture2D(model->texturepool, va("deluxemap%i", lightmapnumber), lm_texturesize, lm_texturesize, NULL, TEXTYPE_BGRA, TEXF_FORCELINEAR | TEXF_PRECACHE, NULL);
+ model->brushq3.data_lightmaps[lightmapindex] = R_LoadTexture2D(model->texturepool, va("lightmap%i", lightmapindex), lm_texturesize, lm_texturesize, lightmappixels + lightmapindex * lm_texturesize * lm_texturesize * 4, TEXTYPE_BGRA, TEXF_FORCELINEAR | TEXF_PRECACHE, NULL);
+ model->brushq3.data_deluxemaps[lightmapindex] = R_LoadTexture2D(model->texturepool, va("deluxemap%i", lightmapindex), lm_texturesize, lm_texturesize, deluxemappixels + lightmapindex * lm_texturesize * lm_texturesize * 4, TEXTYPE_BGRA, TEXF_FORCELINEAR | TEXF_PRECACHE, NULL);
}
if (lightmappixels)
e = model->surfmesh.data_element3i + surface->num_firsttriangle*3;
if (!surface->num_triangles)
continue;
- if (model->brushq3.num_mergedlightmaps)
- {
- lightmapindex = mod_generatelightmaps_lightmaptriangles[surface->num_firsttriangle].lightmapindex;
- surface->lightmaptexture = model->brushq3.data_lightmaps[lightmapindex];
- surface->deluxemaptexture = model->brushq3.data_deluxemaps[lightmapindex];
- }
- else
+ lightmapindex = mod_generatelightmaps_lightmaptriangles[surface->num_firsttriangle].lightmapindex;
+ surface->lightmaptexture = model->brushq3.data_lightmaps[lightmapindex];
+ surface->deluxemaptexture = model->brushq3.data_deluxemaps[lightmapindex];
+ }
+}
+
+static void Mod_GenerateLightmaps_UpdateVertexColors(dp_model_t *model)
+{
+ int i;
+ for (i = 0;i < model->surfmesh.num_vertices;i++)
+ Mod_GenerateLightmaps_VertexSample(model->surfmesh.data_vertex3f + 3*i, model->surfmesh.data_normal3f + 3*i, model->surfmesh.data_lightmapcolor4f + 4*i);
+}
+
+static void Mod_GenerateLightmaps_UpdateLightGrid(dp_model_t *model)
+{
+ int x;
+ int y;
+ int z;
+ int index = 0;
+ float pos[3];
+ for (z = 0;z < model->brushq3.num_lightgrid_isize[2];z++)
+ {
+ pos[2] = (model->brushq3.num_lightgrid_imins[2] + z + 0.5f) * model->brushq3.num_lightgrid_cellsize[2];
+ for (y = 0;y < model->brushq3.num_lightgrid_isize[1];y++)
{
- surface->lightmaptexture = NULL;
- surface->deluxemaptexture = NULL;
+ pos[1] = (model->brushq3.num_lightgrid_imins[1] + y + 0.5f) * model->brushq3.num_lightgrid_cellsize[1];
+ for (x = 0;x < model->brushq3.num_lightgrid_isize[0];x++, index++)
+ {
+ pos[0] = (model->brushq3.num_lightgrid_imins[0] + x + 0.5f) * model->brushq3.num_lightgrid_cellsize[0];
+ Mod_GenerateLightmaps_GridSample(pos, model->brushq3.data_lightgrid + index);
+ }
}
}
}
+extern cvar_t mod_q3bsp_nolightmaps;
static void Mod_GenerateLightmaps(dp_model_t *model)
{
//lightmaptriangle_t *lightmaptriangles = Mem_Alloc(model->mempool, model->surfmesh.num_triangles * sizeof(lightmaptriangle_t));
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_AllocateLightmaps(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_CreateLights(model);
+ if(!mod_q3bsp_nolightmaps.integer)
+ Mod_GenerateLightmaps_CreateLightmaps(model);
+ Mod_GenerateLightmaps_UpdateVertexColors(model);
+ Mod_GenerateLightmaps_UpdateLightGrid(model);
+ Mod_GenerateLightmaps_DestroyLights(model);
+ Mod_GenerateLightmaps_DestroyTriangleInformation(model);
loadmodel = oldloadmodel;
}
projects / xonotic / darkplaces.git / blobdiff