cvar_t r_drawcollisionbrushes_polygonoffset = {0, "r_drawcollisionbrushes_polygonoffset", "0"};
cvar_t gl_lightmaps = {0, "gl_lightmaps", "0"};
+/*
+// FIXME: these arrays are huge!
+int r_q1bsp_maxmarkleafs;
+int r_q1bsp_nummarkleafs;
+mleaf_t *r_q1bsp_maxleaflist[65536];
+int r_q1bsp_maxmarksurfaces;
+int r_q1bsp_nummarksurfaces;
+msurface_t *r_q1bsp_maxsurfacelist[65536];
+
+// FIXME: these arrays are huge!
+int r_q3bsp_maxmarkleafs;
+int r_q3bsp_nummarkleafs;
+q3mleaf_t *r_q3bsp_maxleaflist[65536];
+int r_q3bsp_maxmarksurfaces;
+int r_q3bsp_nummarksurfaces;
+q3mface_t *r_q3bsp_maxsurfacelist[65536];
+*/
+
static int dlightdivtable[32768];
static int R_IntAddDynamicLights (const matrix4x4_t *matrix, msurface_t *surf)
int sdtable[256], lnum, td, maxdist, maxdist2, maxdist3, i, s, t, smax, tmax, smax3, red, green, blue, lit, dist2, impacts, impactt, subtract, k;
unsigned int *bl;
float dist, impact[3], local[3];
+ dlight_t *light;
lit = false;
tmax = (surf->extents[1] >> 4) + 1;
smax3 = smax * 3;
- for (lnum = 0; lnum < r_numdlights; lnum++)
+ for (lnum = 0, light = r_dlight;lnum < r_numdlights;lnum++, light++)
{
if (!(surf->dlightbits[lnum >> 5] & (1 << (lnum & 31))))
continue; // not lit by this light
- Matrix4x4_Transform(matrix, r_dlight[lnum].origin, local);
+ Matrix4x4_Transform(matrix, light->origin, local);
dist = DotProduct (local, surf->plane->normal) - surf->plane->dist;
// for comparisons to minimum acceptable light
// compensate for LIGHTOFFSET
- maxdist = (int) r_dlight[lnum].cullradius2 + LIGHTOFFSET;
+ maxdist = (int) light->rtlight.lightmap_cullradius2 + LIGHTOFFSET;
dist2 = dist * dist;
dist2 += LIGHTOFFSET;
maxdist3 = maxdist - dist2;
// convert to 8.8 blocklights format
- red = r_dlight[lnum].light[0] * (1.0f / 128.0f);
- green = r_dlight[lnum].light[1] * (1.0f / 128.0f);
- blue = r_dlight[lnum].light[2] * (1.0f / 128.0f);
- subtract = (int) (r_dlight[lnum].subtract * 4194304.0f);
+ red = light->rtlight.lightmap_light[0] * (1.0f / 128.0f);
+ green = light->rtlight.lightmap_light[1] * (1.0f / 128.0f);
+ blue = light->rtlight.lightmap_light[2] * (1.0f / 128.0f);
+ subtract = (int) (light->rtlight.lightmap_subtract * 4194304.0f);
bl = intblocklights;
i = impactt;
{
int lnum, s, t, smax, tmax, smax3, lit, impacts, impactt;
float sdtable[256], *bl, k, dist, dist2, maxdist, maxdist2, maxdist3, td1, td, red, green, blue, impact[3], local[3], subtract;
+ dlight_t *light;
lit = false;
tmax = (surf->extents[1] >> 4) + 1;
smax3 = smax * 3;
- for (lnum = 0; lnum < r_numdlights; lnum++)
+ for (lnum = 0, light = r_dlight;lnum < r_numdlights;lnum++, light++)
{
if (!(surf->dlightbits[lnum >> 5] & (1 << (lnum & 31))))
continue; // not lit by this light
- Matrix4x4_Transform(matrix, r_dlight[lnum].origin, local);
+ Matrix4x4_Transform(matrix, light->origin, local);
dist = DotProduct (local, surf->plane->normal) - surf->plane->dist;
// for comparisons to minimum acceptable light
// compensate for LIGHTOFFSET
- maxdist = (int) r_dlight[lnum].cullradius2 + LIGHTOFFSET;
+ maxdist = (int) light->rtlight.lightmap_cullradius2 + LIGHTOFFSET;
dist2 = dist * dist;
dist2 += LIGHTOFFSET;
maxdist3 = maxdist - dist2;
// convert to 8.8 blocklights format
- red = r_dlight[lnum].light[0];
- green = r_dlight[lnum].light[1];
- blue = r_dlight[lnum].light[2];
- subtract = r_dlight[lnum].subtract * 32768.0f;
+ red = light->rtlight.lightmap_light[0];
+ green = light->rtlight.lightmap_light[1];
+ blue = light->rtlight.lightmap_light[2];
+ subtract = light->rtlight.lightmap_subtract * 32768.0f;
bl = floatblocklights;
td1 = impactt;
const float *v;
float *c;
int i, l, lit = false;
- const rdlight_t *rd;
+ const dlight_t *light;
vec3_t lightorigin;
for (l = 0;l < r_numdlights;l++)
{
if (dlightbits[l >> 5] & (1 << (l & 31)))
{
- rd = &r_dlight[l];
- Matrix4x4_Transform(matrix, rd->origin, lightorigin);
+ light = &r_dlight[l];
+ Matrix4x4_Transform(matrix, light->origin, lightorigin);
for (i = 0, v = vert, c = color;i < numverts;i++, v += 3, c += 4)
{
f = VectorDistance2(v, lightorigin) + LIGHTOFFSET;
- if (f < rd->cullradius2)
+ if (f < light->rtlight.lightmap_cullradius2)
{
- f = ((1.0f / f) - rd->subtract) * scale;
- VectorMA(c, f, rd->light, c);
+ f = ((1.0f / f) - light->rtlight.lightmap_subtract) * scale;
+ VectorMA(c, f, light->rtlight.lightmap_light, c);
lit = true;
}
}
static void R_PortalWorldNode(entity_render_t *ent, mleaf_t *viewleaf)
{
- int c, leafstackpos, *mark, *surfacevisframes, bitnum;
+ int c, leafstackpos, *mark, *surfacevisframes;
#if WORLDNODECULLBACKFACES
int n;
msurface_t *surf;
{
leaf->worldnodeframe = r_framecount;
// FIXME: R_CullBox is absolute, should be done relative
- bitnum = (leaf - ent->model->brushq1.leafs) - 1;
- if ((r_pvsbits[bitnum >> 3] & (1 << (bitnum & 7))) && !R_CullBox(leaf->mins, leaf->maxs))
+ if (CHECKPVSBIT(r_pvsbits, leaf->clusterindex) && !R_CullBox(leaf->mins, leaf->maxs))
leafstack[leafstackpos++] = leaf;
}
}
if (viewleaf)
{
surfacepvsframes = model->brushq1.surfacepvsframes;
- for (j = 0;j < model->brushq1.visleafs;j++)
+ for (j = 0, leaf = model->brushq1.data_leafs;j < model->brushq1.num_leafs;j++, leaf++)
{
- if (r_pvsbits[j >> 3] & (1 << (j & 7)))
+ if (CHECKPVSBIT(r_pvsbits, leaf->clusterindex))
{
- leaf = model->brushq1.leafs + j + 1;
leaf->pvsframe = model->brushq1.pvsframecount;
leaf->pvschain = model->brushq1.pvsleafchain;
model->brushq1.pvsleafchain = leaf;
{
if (ent->model == NULL)
return;
- if (!ent->model->brushq1.numleafs)
+ if (!ent->model->brushq1.num_leafs)
{
if (ent->model->DrawSky)
ent->model->DrawSky(ent);
void R_Model_Brush_DrawShadowVolume (entity_render_t *ent, vec3_t relativelightorigin, float lightradius)
{
+#if 0
int i;
msurface_t *surf;
float projectdistance, f, temp[3], lightradius2;
R_Mesh_Matrix(&ent->matrix);
lightradius2 = lightradius * lightradius;
R_UpdateTextureInfo(ent);
- projectdistance = 1000000000.0f;//lightradius + ent->model->radius;
+ projectdistance = lightradius + ent->model->radius;//projectdistance = 1000000000.0f;//lightradius + ent->model->radius;
+ //projectdistance = 1000000000.0f;//lightradius + ent->model->radius;
for (i = 0, surf = ent->model->brushq1.surfaces + ent->model->brushq1.firstmodelsurface;i < ent->model->brushq1.nummodelsurfaces;i++, surf++)
{
if (surf->texinfo->texture->rendertype == SURFRENDER_OPAQUE && surf->flags & SURF_SHADOWCAST)
temp[1] = bound(surf->poly_mins[1], relativelightorigin[1], surf->poly_maxs[1]) - relativelightorigin[1];
temp[2] = bound(surf->poly_mins[2], relativelightorigin[2], surf->poly_maxs[2]) - relativelightorigin[2];
if (DotProduct(temp, temp) < lightradius2)
- R_Shadow_Volume(surf->mesh.num_vertices, surf->mesh.num_triangles, surf->mesh.data_vertex3f, surf->mesh.data_element3i, surf->mesh.data_neighbor3i, relativelightorigin, lightradius, projectdistance);
+ R_Shadow_VolumeFromSphere(surf->mesh.num_vertices, surf->mesh.num_triangles, surf->mesh.data_vertex3f, surf->mesh.data_element3i, surf->mesh.data_neighbor3i, relativelightorigin, projectdistance, lightradius);
+ }
+ }
+ }
+#else
+ int t, leafnum, marksurfnum, trianglenum;
+ const int *e;
+ msurface_t *surf;
+ mleaf_t *leaf;
+ const qbyte *pvs;
+ float projectdistance;
+ const float *v[3];
+ vec3_t lightmins, lightmaxs;
+ if (ent->model == NULL)
+ return;
+ R_Mesh_Matrix(&ent->matrix);
+ R_UpdateTextureInfo(ent);
+ projectdistance = lightradius + ent->model->radius;//projectdistance = 1000000000.0f;//lightradius + ent->model->radius;
+ lightmins[0] = relativelightorigin[0] - lightradius;
+ lightmins[1] = relativelightorigin[1] - lightradius;
+ lightmins[2] = relativelightorigin[2] - lightradius;
+ lightmaxs[0] = relativelightorigin[0] + lightradius;
+ lightmaxs[1] = relativelightorigin[1] + lightradius;
+ lightmaxs[2] = relativelightorigin[2] + lightradius;
+ /*
+ R_Shadow_PrepareShadowMark(ent->model->brush.shadowmesh->numtriangles);
+ maxmarksurfaces = sizeof(surfacelist) / sizeof(surfacelist[0]);
+ ent->model->brushq1.GetVisible(ent->model, relativelightorigin, lightmins, lightmaxs, 0, NULL, NULL, maxmarkleafs, markleaf, &nummarkleafs);
+ for (marksurfacenum = 0;marksurfacenum < nummarksurfaces;marksurfacenum++)
+ {
+ surf = marksurface[marksurfacenum];
+ if (surf->shadowmark != shadowmarkcount)
+ {
+ surf->shadowmark = shadowmarkcount;
+ if (BoxesOverlap(lightmins, lightmaxs, surf->poly_mins, surf->poly_maxs) && surf->texinfo->texture->rendertype == SURFRENDER_OPAQUE && (surf->flags & SURF_SHADOWCAST))
+ {
+ for (trianglenum = 0, t = surf->num_firstshadowmeshtriangle, e = ent->model->brush.shadowmesh->element3i + t * 3;trianglenum < surf->mesh.num_triangles;trianglenum++, t++, e += 3)
+ {
+ v[0] = ent->model->brush.shadowmesh->vertex3f + e[0] * 3;
+ v[1] = ent->model->brush.shadowmesh->vertex3f + e[1] * 3;
+ v[2] = ent->model->brush.shadowmesh->vertex3f + e[2] * 3;
+ if (PointInfrontOfTriangle(relativelightorigin, v[0], v[1], v[2]) && lightmaxs[0] > min(v[0][0], min(v[1][0], v[2][0])) && lightmins[0] < max(v[0][0], max(v[1][0], v[2][0])) && lightmaxs[1] > min(v[0][1], min(v[1][1], v[2][1])) && lightmins[1] < max(v[0][1], max(v[1][1], v[2][1])) && lightmaxs[2] > min(v[0][2], min(v[1][2], v[2][2])) && lightmins[2] < max(v[0][2], max(v[1][2], v[2][2])))
+ shadowmarklist[numshadowmark++] = t;
+ }
+ }
+ }
+ }
+ */
+ R_Shadow_PrepareShadowMark(ent->model->brush.shadowmesh->numtriangles);
+ if (ent->model->brush.GetPVS && (pvs = ent->model->brush.GetPVS(ent->model, relativelightorigin)))
+ {
+ pvs = ent->model->brush.GetPVS(ent->model, relativelightorigin);
+ // FIXME: use BSP recursion in q1bsp as dlights are often small
+ for (leafnum = 0, leaf = ent->model->brushq1.data_leafs;leafnum < ent->model->brushq1.num_leafs;leafnum++, leaf++)
+ {
+ if (BoxesOverlap(lightmins, lightmaxs, leaf->mins, leaf->maxs) && CHECKPVSBIT(pvs, leaf->clusterindex))
+ {
+ for (marksurfnum = 0;marksurfnum < leaf->nummarksurfaces;marksurfnum++)
+ {
+ surf = ent->model->brushq1.surfaces + leaf->firstmarksurface[marksurfnum];
+ if (surf->shadowmark != shadowmarkcount)
+ {
+ surf->shadowmark = shadowmarkcount;
+ if (BoxesOverlap(lightmins, lightmaxs, surf->poly_mins, surf->poly_maxs) && surf->texinfo->texture->rendertype == SURFRENDER_OPAQUE && (surf->flags & SURF_SHADOWCAST))
+ {
+ for (trianglenum = 0, t = surf->num_firstshadowmeshtriangle, e = ent->model->brush.shadowmesh->element3i + t * 3;trianglenum < surf->mesh.num_triangles;trianglenum++, t++, e += 3)
+ {
+ v[0] = ent->model->brush.shadowmesh->vertex3f + e[0] * 3;
+ v[1] = ent->model->brush.shadowmesh->vertex3f + e[1] * 3;
+ v[2] = ent->model->brush.shadowmesh->vertex3f + e[2] * 3;
+ if (PointInfrontOfTriangle(relativelightorigin, v[0], v[1], v[2]) && lightmaxs[0] > min(v[0][0], min(v[1][0], v[2][0])) && lightmins[0] < max(v[0][0], max(v[1][0], v[2][0])) && lightmaxs[1] > min(v[0][1], min(v[1][1], v[2][1])) && lightmins[1] < max(v[0][1], max(v[1][1], v[2][1])) && lightmaxs[2] > min(v[0][2], min(v[1][2], v[2][2])) && lightmins[2] < max(v[0][2], max(v[1][2], v[2][2])))
+ shadowmarklist[numshadowmark++] = t;
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ else
+ {
+ for (marksurfnum = 0, surf = ent->model->brushq1.surfaces + ent->model->brushq1.firstmodelsurface;marksurfnum < ent->model->brushq1.nummodelsurfaces;marksurfnum++, surf++)
+ {
+ if (BoxesOverlap(lightmins, lightmaxs, surf->poly_mins, surf->poly_maxs) && surf->texinfo->texture->rendertype == SURFRENDER_OPAQUE && (surf->flags & SURF_SHADOWCAST))
+ {
+ for (trianglenum = 0, t = surf->num_firstshadowmeshtriangle, e = ent->model->brush.shadowmesh->element3i + t * 3;trianglenum < surf->mesh.num_triangles;trianglenum++, t++, e += 3)
+ {
+ v[0] = ent->model->brush.shadowmesh->vertex3f + e[0] * 3;
+ v[1] = ent->model->brush.shadowmesh->vertex3f + e[1] * 3;
+ v[2] = ent->model->brush.shadowmesh->vertex3f + e[2] * 3;
+ if (PointInfrontOfTriangle(relativelightorigin, v[0], v[1], v[2]) && lightmaxs[0] > min(v[0][0], min(v[1][0], v[2][0])) && lightmins[0] < max(v[0][0], max(v[1][0], v[2][0])) && lightmaxs[1] > min(v[0][1], min(v[1][1], v[2][1])) && lightmins[1] < max(v[0][1], max(v[1][1], v[2][1])) && lightmaxs[2] > min(v[0][2], min(v[1][2], v[2][2])) && lightmins[2] < max(v[0][2], max(v[1][2], v[2][2])))
+ shadowmarklist[numshadowmark++] = t;
+ }
}
}
}
+ R_Shadow_VolumeFromList(ent->model->brush.shadowmesh->numverts, ent->model->brush.shadowmesh->numtriangles, ent->model->brush.shadowmesh->vertex3f, ent->model->brush.shadowmesh->element3i, ent->model->brush.shadowmesh->neighbor3i, relativelightorigin, projectdistance, numshadowmark, shadowmarklist);
+#endif
}
-void R_Model_Brush_DrawLight(entity_render_t *ent, vec3_t relativelightorigin, vec3_t relativeeyeorigin, float lightradius, float *lightcolor, const matrix4x4_t *matrix_modeltofilter, const matrix4x4_t *matrix_modeltoattenuationxyz, const matrix4x4_t *matrix_modeltoattenuationz, rtexture_t *lightcubemap)
+void R_Model_Brush_DrawLight(entity_render_t *ent, vec3_t relativelightorigin, vec3_t relativeeyeorigin, float lightradius, float *lightcolor, const matrix4x4_t *matrix_modeltolight, const matrix4x4_t *matrix_modeltoattenuationxyz, const matrix4x4_t *matrix_modeltoattenuationz, rtexture_t *lightcubemap)
{
- int surfnum;
+ int leafnum, marksurfnum;
msurface_t *surf;
+ mleaf_t *leaf;
+ const qbyte *pvs;
texture_t *t;
- float f, lightmins[3], lightmaxs[3];
+ float lightmins[3], lightmaxs[3];
if (ent->model == NULL)
return;
R_Mesh_Matrix(&ent->matrix);
lightmaxs[1] = relativelightorigin[1] + lightradius;
lightmaxs[2] = relativelightorigin[2] + lightradius;
R_UpdateTextureInfo(ent);
- for (surfnum = 0, surf = ent->model->brushq1.surfaces + ent->model->brushq1.firstmodelsurface;surfnum < ent->model->brushq1.nummodelsurfaces;surfnum++, surf++)
+ shadowmarkcount++;
+ if (ent->model->brush.GetPVS && (pvs = ent->model->brush.GetPVS(ent->model, relativelightorigin)))
{
- if ((ent != &cl_entities[0].render || surf->visframe == r_framecount) && BoxesOverlap(surf->poly_mins, surf->poly_maxs, lightmins, lightmaxs))
+ pvs = ent->model->brush.GetPVS(ent->model, relativelightorigin);
+ for (leafnum = 0, leaf = ent->model->brushq1.data_leafs;leafnum < ent->model->brushq1.num_leafs;leafnum++, leaf++)
{
- f = PlaneDiff(relativelightorigin, surf->plane);
- if (surf->flags & SURF_PLANEBACK)
- f = -f;
- if (f >= -0.1 && f < lightradius)
+ if (BoxesOverlap(lightmins, lightmaxs, leaf->mins, leaf->maxs) && CHECKPVSBIT(pvs, leaf->clusterindex))
+ {
+ for (marksurfnum = 0;marksurfnum < leaf->nummarksurfaces;marksurfnum++)
+ {
+ surf = ent->model->brushq1.surfaces + leaf->firstmarksurface[marksurfnum];
+ if (surf->shadowmark != shadowmarkcount)
+ {
+ surf->shadowmark = shadowmarkcount;
+ if (BoxesOverlap(lightmins, lightmaxs, surf->poly_mins, surf->poly_maxs) && (ent != &cl_entities[0].render || surf->visframe == r_framecount))
+ {
+ t = surf->texinfo->texture->currentframe;
+ if (t->rendertype == SURFRENDER_OPAQUE && t->flags & SURF_SHADOWLIGHT)
+ {
+ R_Shadow_DiffuseLighting(surf->mesh.num_vertices, surf->mesh.num_triangles, surf->mesh.data_element3i, surf->mesh.data_vertex3f, surf->mesh.data_svector3f, surf->mesh.data_tvector3f, surf->mesh.data_normal3f, surf->mesh.data_texcoordtexture2f, relativelightorigin, lightcolor, matrix_modeltolight, matrix_modeltoattenuationxyz, matrix_modeltoattenuationz, t->skin.base, t->skin.nmap, lightcubemap);
+ R_Shadow_SpecularLighting(surf->mesh.num_vertices, surf->mesh.num_triangles, surf->mesh.data_element3i, surf->mesh.data_vertex3f, surf->mesh.data_svector3f, surf->mesh.data_tvector3f, surf->mesh.data_normal3f, surf->mesh.data_texcoordtexture2f, relativelightorigin, relativeeyeorigin, lightcolor, matrix_modeltolight, matrix_modeltoattenuationxyz, matrix_modeltoattenuationz, t->skin.gloss, t->skin.nmap, lightcubemap);
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ else
+ {
+ for (marksurfnum = 0, surf = ent->model->brushq1.surfaces + ent->model->brushq1.firstmodelsurface;marksurfnum < ent->model->brushq1.nummodelsurfaces;marksurfnum++, surf++)
+ {
+ if (BoxesOverlap(lightmins, lightmaxs, surf->poly_mins, surf->poly_maxs) && (ent != &cl_entities[0].render || surf->visframe == r_framecount))
{
t = surf->texinfo->texture->currentframe;
if (t->rendertype == SURFRENDER_OPAQUE && t->flags & SURF_SHADOWLIGHT)
{
- R_Shadow_DiffuseLighting(surf->mesh.num_vertices, surf->mesh.num_triangles, surf->mesh.data_element3i, surf->mesh.data_vertex3f, surf->mesh.data_svector3f, surf->mesh.data_tvector3f, surf->mesh.data_normal3f, surf->mesh.data_texcoordtexture2f, relativelightorigin, lightradius, lightcolor, matrix_modeltofilter, matrix_modeltoattenuationxyz, matrix_modeltoattenuationz, t->skin.base, t->skin.nmap, lightcubemap);
- R_Shadow_SpecularLighting(surf->mesh.num_vertices, surf->mesh.num_triangles, surf->mesh.data_element3i, surf->mesh.data_vertex3f, surf->mesh.data_svector3f, surf->mesh.data_tvector3f, surf->mesh.data_normal3f, surf->mesh.data_texcoordtexture2f, relativelightorigin, relativeeyeorigin, lightradius, lightcolor, matrix_modeltofilter, matrix_modeltoattenuationxyz, matrix_modeltoattenuationz, t->skin.gloss, t->skin.nmap, lightcubemap);
+ R_Shadow_DiffuseLighting(surf->mesh.num_vertices, surf->mesh.num_triangles, surf->mesh.data_element3i, surf->mesh.data_vertex3f, surf->mesh.data_svector3f, surf->mesh.data_tvector3f, surf->mesh.data_normal3f, surf->mesh.data_texcoordtexture2f, relativelightorigin, lightcolor, matrix_modeltolight, matrix_modeltoattenuationxyz, matrix_modeltoattenuationz, t->skin.base, t->skin.nmap, lightcubemap);
+ R_Shadow_SpecularLighting(surf->mesh.num_vertices, surf->mesh.num_triangles, surf->mesh.data_element3i, surf->mesh.data_vertex3f, surf->mesh.data_svector3f, surf->mesh.data_tvector3f, surf->mesh.data_normal3f, surf->mesh.data_texcoordtexture2f, relativelightorigin, relativeeyeorigin, lightcolor, matrix_modeltolight, matrix_modeltoattenuationxyz, matrix_modeltoattenuationz, t->skin.gloss, t->skin.nmap, lightcubemap);
}
}
}
node = node->children[1];
}
leaf = (q3mleaf_t *)node;
- if (pvs[leaf->clusterindex >> 3] & (1 << (leaf->clusterindex & 7)))
+ if (CHECKPVSBIT(pvs, leaf->clusterindex))
{
c_leafs++;
for (i = 0;i < leaf->numleaffaces;i++)
q3mleaf_t *leaf;
for (j = 0, leaf = ent->model->brushq3.data_leafs;j < ent->model->brushq3.num_leafs;j++, leaf++)
{
- if (pvs[leaf->clusterindex >> 3] & (1 << (leaf->clusterindex & 7)))
+ if (CHECKPVSBIT(pvs, leaf->clusterindex))
{
c_leafs++;
for (i = 0;i < leaf->numleaffaces;i++)
if (r_drawcollisionbrushes.integer < 2)
{
Matrix4x4_Transform(&ent->inversematrix, r_vieworigin, modelorg);
- if (ent == &cl_entities[0].render && model->brushq3.num_pvsclusters && !r_novis.integer && (pvs = model->brush.GetPVS(model, modelorg)))
+ if (ent == &cl_entities[0].render && model->brush.num_pvsclusters && !r_novis.integer && (pvs = model->brush.GetPVS(model, modelorg)))
{
if (r_q3bsp_framecount != r_framecount)
{
if (r_drawcollisionbrushes.integer < 2)
{
Matrix4x4_Transform(&ent->inversematrix, r_vieworigin, modelorg);
- if (ent == &cl_entities[0].render && model->brushq3.num_pvsclusters && !r_novis.integer && (pvs = model->brush.GetPVS(model, modelorg)))
+ if (ent == &cl_entities[0].render && model->brush.num_pvsclusters && !r_novis.integer && (pvs = model->brush.GetPVS(model, modelorg)))
{
if (r_q3bsp_framecount != r_framecount)
{
void R_Q3BSP_DrawShadowVolume(entity_render_t *ent, vec3_t relativelightorigin, float lightradius)
{
+#if 0
int i;
q3mface_t *face;
vec3_t modelorg, lightmins, lightmaxs;
model_t *model;
float projectdistance;
- projectdistance = 1000000000.0f;//lightradius + ent->model->radius;
+ projectdistance = lightradius + ent->model->radius;//projectdistance = 1000000000.0f;//lightradius + ent->model->radius;
if (r_drawcollisionbrushes.integer < 2)
{
model = ent->model;
lightmaxs[0] = relativelightorigin[0] + lightradius;
lightmaxs[1] = relativelightorigin[1] + lightradius;
lightmaxs[2] = relativelightorigin[2] + lightradius;
- //if (ent == &cl_entities[0].render && model->brushq3.num_pvsclusters && !r_novis.integer && (pvs = model->brush.GetPVS(model, modelorg)))
+ //if (ent == &cl_entities[0].render && model->brush.num_pvsclusters && !r_novis.integer && (pvs = model->brush.GetPVS(model, modelorg)))
// R_Q3BSP_RecursiveWorldNode(ent, model->brushq3.data_nodes, modelorg, pvs, ++markframe);
//else
for (i = 0, face = model->brushq3.data_thismodel->firstface;i < model->brushq3.data_thismodel->numfaces;i++, face++)
if (BoxesOverlap(lightmins, lightmaxs, face->mins, face->maxs))
- R_Shadow_Volume(face->num_vertices, face->num_triangles, face->data_vertex3f, face->data_element3i, face->data_neighbor3i, relativelightorigin, lightradius, projectdistance);
+ R_Shadow_VolumeFromSphere(face->num_vertices, face->num_triangles, face->data_vertex3f, face->data_element3i, face->data_neighbor3i, relativelightorigin, projectdistance, lightradius);
+ }
+#else
+ int j, t, leafnum, marksurfnum;
+ const int *e;
+ const qbyte *pvs;
+ const float *v[3];
+ q3mface_t *face;
+ q3mleaf_t *leaf;
+ vec3_t modelorg, lightmins, lightmaxs;
+ model_t *model;
+ float projectdistance;
+ projectdistance = lightradius + ent->model->radius;//projectdistance = 1000000000.0f;//lightradius + ent->model->radius;
+ if (r_drawcollisionbrushes.integer < 2)
+ {
+ model = ent->model;
+ R_Mesh_Matrix(&ent->matrix);
+ Matrix4x4_Transform(&ent->inversematrix, r_vieworigin, modelorg);
+ lightmins[0] = relativelightorigin[0] - lightradius;
+ lightmins[1] = relativelightorigin[1] - lightradius;
+ lightmins[2] = relativelightorigin[2] - lightradius;
+ lightmaxs[0] = relativelightorigin[0] + lightradius;
+ lightmaxs[1] = relativelightorigin[1] + lightradius;
+ lightmaxs[2] = relativelightorigin[2] + lightradius;
+ R_Shadow_PrepareShadowMark(model->brush.shadowmesh->numtriangles);
+ if (ent->model->brush.GetPVS && (pvs = ent->model->brush.GetPVS(ent->model, relativelightorigin)))
+ {
+ for (leafnum = 0, leaf = ent->model->brushq3.data_leafs;leafnum < ent->model->brushq3.num_leafs;leafnum++, leaf++)
+ {
+ if (BoxesOverlap(lightmins, lightmaxs, leaf->mins, leaf->maxs) && CHECKPVSBIT(pvs, leaf->clusterindex))
+ {
+ for (marksurfnum = 0;marksurfnum < leaf->numleaffaces;marksurfnum++)
+ {
+ face = leaf->firstleafface[marksurfnum];
+ if (face->shadowmark != shadowmarkcount)
+ {
+ face->shadowmark = shadowmarkcount;
+ if (BoxesOverlap(lightmins, lightmaxs, face->mins, face->maxs))
+ {
+ for (j = 0, t = face->num_firstshadowmeshtriangle, e = model->brush.shadowmesh->element3i + t * 3;j < face->num_triangles;j++, t++, e += 3)
+ {
+ v[0] = model->brush.shadowmesh->vertex3f + e[0] * 3;
+ v[1] = model->brush.shadowmesh->vertex3f + e[1] * 3;
+ v[2] = model->brush.shadowmesh->vertex3f + e[2] * 3;
+ if (PointInfrontOfTriangle(relativelightorigin, v[0], v[1], v[2]) && lightmaxs[0] > min(v[0][0], min(v[1][0], v[2][0])) && lightmins[0] < max(v[0][0], max(v[1][0], v[2][0])) && lightmaxs[1] > min(v[0][1], min(v[1][1], v[2][1])) && lightmins[1] < max(v[0][1], max(v[1][1], v[2][1])) && lightmaxs[2] > min(v[0][2], min(v[1][2], v[2][2])) && lightmins[2] < max(v[0][2], max(v[1][2], v[2][2])))
+ shadowmarklist[numshadowmark++] = t;
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ else
+ {
+ for (marksurfnum = 0, face = model->brushq3.data_thismodel->firstface;marksurfnum < model->brushq3.data_thismodel->numfaces;marksurfnum++, face++)
+ {
+ if (BoxesOverlap(lightmins, lightmaxs, face->mins, face->maxs))
+ {
+ for (j = 0, t = face->num_firstshadowmeshtriangle, e = model->brush.shadowmesh->element3i + t * 3;j < face->num_triangles;j++, t++, e += 3)
+ {
+ v[0] = model->brush.shadowmesh->vertex3f + e[0] * 3;
+ v[1] = model->brush.shadowmesh->vertex3f + e[1] * 3;
+ v[2] = model->brush.shadowmesh->vertex3f + e[2] * 3;
+ if (PointInfrontOfTriangle(relativelightorigin, v[0], v[1], v[2]) && lightmaxs[0] > min(v[0][0], min(v[1][0], v[2][0])) && lightmins[0] < max(v[0][0], max(v[1][0], v[2][0])) && lightmaxs[1] > min(v[0][1], min(v[1][1], v[2][1])) && lightmins[1] < max(v[0][1], max(v[1][1], v[2][1])) && lightmaxs[2] > min(v[0][2], min(v[1][2], v[2][2])) && lightmins[2] < max(v[0][2], max(v[1][2], v[2][2])))
+ shadowmarklist[numshadowmark++] = t;
+ }
+ }
+ }
+ }
+ R_Shadow_VolumeFromList(model->brush.shadowmesh->numverts, model->brush.shadowmesh->numtriangles, model->brush.shadowmesh->vertex3f, model->brush.shadowmesh->element3i, model->brush.shadowmesh->neighbor3i, relativelightorigin, projectdistance, numshadowmark, shadowmarklist);
}
+#endif
}
-void R_Q3BSP_DrawFaceLight(entity_render_t *ent, q3mface_t *face, vec3_t relativelightorigin, vec3_t relativeeyeorigin, float lightradius, float *lightcolor, const matrix4x4_t *matrix_modeltofilter, const matrix4x4_t *matrix_modeltoattenuationxyz, const matrix4x4_t *matrix_modeltoattenuationz, rtexture_t *lightcubemap)
+void R_Q3BSP_DrawFaceLight(entity_render_t *ent, q3mface_t *face, vec3_t relativelightorigin, vec3_t relativeeyeorigin, float lightradius, float *lightcolor, const matrix4x4_t *matrix_modeltolight, const matrix4x4_t *matrix_modeltoattenuationxyz, const matrix4x4_t *matrix_modeltoattenuationz, rtexture_t *lightcubemap)
{
if ((face->texture->surfaceflags & Q3SURFACEFLAG_NODRAW) || !face->num_triangles)
return;
- R_Shadow_DiffuseLighting(face->num_vertices, face->num_triangles, face->data_element3i, face->data_vertex3f, face->data_svector3f, face->data_tvector3f, face->data_normal3f, face->data_texcoordtexture2f, relativelightorigin, lightradius, lightcolor, matrix_modeltofilter, matrix_modeltoattenuationxyz, matrix_modeltoattenuationz, face->texture->skin.base, face->texture->skin.nmap, lightcubemap);
- R_Shadow_SpecularLighting(face->num_vertices, face->num_triangles, face->data_element3i, face->data_vertex3f, face->data_svector3f, face->data_tvector3f, face->data_normal3f, face->data_texcoordtexture2f, relativelightorigin, relativeeyeorigin, lightradius, lightcolor, matrix_modeltofilter, matrix_modeltoattenuationxyz, matrix_modeltoattenuationz, face->texture->skin.gloss, face->texture->skin.nmap, lightcubemap);
+ R_Shadow_DiffuseLighting(face->num_vertices, face->num_triangles, face->data_element3i, face->data_vertex3f, face->data_svector3f, face->data_tvector3f, face->data_normal3f, face->data_texcoordtexture2f, relativelightorigin, lightcolor, matrix_modeltolight, matrix_modeltoattenuationxyz, matrix_modeltoattenuationz, face->texture->skin.base, face->texture->skin.nmap, lightcubemap);
+ R_Shadow_SpecularLighting(face->num_vertices, face->num_triangles, face->data_element3i, face->data_vertex3f, face->data_svector3f, face->data_tvector3f, face->data_normal3f, face->data_texcoordtexture2f, relativelightorigin, relativeeyeorigin, lightcolor, matrix_modeltolight, matrix_modeltoattenuationxyz, matrix_modeltoattenuationz, face->texture->skin.gloss, face->texture->skin.nmap, lightcubemap);
}
-void R_Q3BSP_DrawLight(entity_render_t *ent, vec3_t relativelightorigin, vec3_t relativeeyeorigin, float lightradius, float *lightcolor, const matrix4x4_t *matrix_modeltofilter, const matrix4x4_t *matrix_modeltoattenuationxyz, const matrix4x4_t *matrix_modeltoattenuationz, rtexture_t *lightcubemap)
+void R_Q3BSP_DrawLight(entity_render_t *ent, vec3_t relativelightorigin, vec3_t relativeeyeorigin, float lightradius, float *lightcolor, const matrix4x4_t *matrix_modeltolight, const matrix4x4_t *matrix_modeltoattenuationxyz, const matrix4x4_t *matrix_modeltoattenuationz, rtexture_t *lightcubemap)
{
- int i;
+ int leafnum, marksurfnum;
+ const qbyte *pvs;
q3mface_t *face;
+ q3mleaf_t *leaf;
vec3_t modelorg, lightmins, lightmaxs;
model_t *model;
//qbyte *pvs;
lightmaxs[0] = relativelightorigin[0] + lightradius;
lightmaxs[1] = relativelightorigin[1] + lightradius;
lightmaxs[2] = relativelightorigin[2] + lightradius;
- //if (ent == &cl_entities[0].render && model->brushq3.num_pvsclusters && !r_novis.integer && (pvs = model->brush.GetPVS(model, modelorg)))
- // R_Q3BSP_RecursiveWorldNode(ent, model->brushq3.data_nodes, modelorg, pvs, ++markframe);
- //else
- for (i = 0, face = model->brushq3.data_thismodel->firstface;i < model->brushq3.data_thismodel->numfaces;i++, face++)
- if ((ent != &cl_entities[0].render || face->visframe == r_framecount) && BoxesOverlap(lightmins, lightmaxs, face->mins, face->maxs))
- R_Q3BSP_DrawFaceLight(ent, face, relativelightorigin, relativeeyeorigin, lightradius, lightcolor, matrix_modeltofilter, matrix_modeltoattenuationxyz, matrix_modeltoattenuationz, lightcubemap);
+
+ if (ent->model->brush.GetPVS && (pvs = ent->model->brush.GetPVS(ent->model, relativelightorigin)))
+ {
+ pvs = ent->model->brush.GetPVS(ent->model, relativelightorigin);
+ for (leafnum = 0, leaf = ent->model->brushq3.data_leafs;leafnum < ent->model->brushq3.num_leafs;leafnum++, leaf++)
+ {
+ if (BoxesOverlap(lightmins, lightmaxs, leaf->mins, leaf->maxs) && CHECKPVSBIT(pvs, leaf->clusterindex))
+ {
+ for (marksurfnum = 0;marksurfnum < leaf->numleaffaces;marksurfnum++)
+ {
+ face = leaf->firstleafface[marksurfnum];
+ if (face->shadowmark != shadowmarkcount)
+ {
+ face->shadowmark = shadowmarkcount;
+ if (BoxesOverlap(lightmins, lightmaxs, face->mins, face->maxs) && (ent != &cl_entities[0].render || face->visframe == r_framecount))
+ R_Q3BSP_DrawFaceLight(ent, face, relativelightorigin, relativeeyeorigin, lightradius, lightcolor, matrix_modeltolight, matrix_modeltoattenuationxyz, matrix_modeltoattenuationz, lightcubemap);
+ }
+ }
+ }
+ }
+ }
+ else
+ {
+ for (marksurfnum = 0, face = model->brushq3.data_thismodel->firstface;marksurfnum < model->brushq3.data_thismodel->numfaces;marksurfnum++, face++)
+ if (BoxesOverlap(lightmins, lightmaxs, face->mins, face->maxs) && (ent != &cl_entities[0].render || face->visframe == r_framecount))
+ R_Q3BSP_DrawFaceLight(ent, face, relativelightorigin, relativeeyeorigin, lightradius, lightcolor, matrix_modeltolight, matrix_modeltoattenuationxyz, matrix_modeltoattenuationz, lightcubemap);
+ }
}
}
projects / xonotic / darkplaces.git / blobdiff