unsigned char r_worldleafvisible[32768];
// TODO: dynamic resize according to r_refdef.worldmodel->num_surfaces
unsigned char r_worldsurfacevisible[262144];
+// if true, the view is currently in a leaf without pvs data
+qboolean r_worldnovis;
/*
===============
*/
void R_BuildLightMap (const entity_render_t *ent, msurface_t *surface)
{
- int smax, tmax, i, j, size, size3, maps, l;
- unsigned int *bl, scale;
+ int smax, tmax, i, size, size3, maps, l;
+ int *bl, scale;
unsigned char *lightmap, *out, *stain;
- static unsigned int intblocklights[MAX_LIGHTMAP_SIZE*MAX_LIGHTMAP_SIZE*3]; // LordHavoc: *3 for colored lighting
+ model_t *model = ent->model;
+ static int intblocklights[MAX_LIGHTMAP_SIZE*MAX_LIGHTMAP_SIZE*3]; // LordHavoc: *3 for colored lighting
static unsigned char templight[MAX_LIGHTMAP_SIZE*MAX_LIGHTMAP_SIZE*4];
// update cached lighting info
// set to full bright if no light data
bl = intblocklights;
- if (!ent->model->brushq1.lightdata)
+ if (!model->brushq1.lightdata)
{
for (i = 0;i < size3;i++)
bl[i] = 255*256;
else
{
// clear to no light
- memset(bl, 0, size*3*sizeof(unsigned int));
+ memset(bl, 0, size3*sizeof(*bl));
// add all the lightmaps
if (lightmap)
- {
- bl = intblocklights;
for (maps = 0;maps < MAXLIGHTMAPS && surface->lightmapinfo->styles[maps] != 255;maps++, lightmap += size3)
for (scale = r_refdef.lightstylevalue[surface->lightmapinfo->styles[maps]], i = 0;i < size3;i++)
bl[i] += lightmap[i] * scale;
- }
}
stain = surface->lightmapinfo->stainsamples;
// scaling, and remaps the 0-65536 (2x overbright) to 0-256, it will
// be doubled during rendering to achieve 2x overbright
// (0 = 0.0, 128 = 1.0, 256 = 2.0)
- if (ent->model->brushq1.lightmaprgba)
+ if (model->brushq1.lightmaprgba)
{
- for (i = 0;i < tmax;i++)
+ for (i = 0;i < size;i++)
{
- for (j = 0;j < smax;j++)
- {
- l = (*bl++ * *stain++) >> 16;*out++ = min(l, 255);
- l = (*bl++ * *stain++) >> 16;*out++ = min(l, 255);
- l = (*bl++ * *stain++) >> 16;*out++ = min(l, 255);
- *out++ = 255;
- }
+ l = (*bl++ * *stain++) >> 16;*out++ = min(l, 255);
+ l = (*bl++ * *stain++) >> 16;*out++ = min(l, 255);
+ l = (*bl++ * *stain++) >> 16;*out++ = min(l, 255);
+ *out++ = 255;
}
}
else
{
- for (i = 0;i < tmax;i++)
+ for (i = 0;i < size;i++)
{
- for (j = 0;j < smax;j++)
- {
- l = (*bl++ * *stain++) >> 16;*out++ = min(l, 255);
- l = (*bl++ * *stain++) >> 16;*out++ = min(l, 255);
- l = (*bl++ * *stain++) >> 16;*out++ = min(l, 255);
- }
+ l = (*bl++ * *stain++) >> 16;*out++ = min(l, 255);
+ l = (*bl++ * *stain++) >> 16;*out++ = min(l, 255);
+ l = (*bl++ * *stain++) >> 16;*out++ = min(l, 255);
}
}
R_UpdateTexture(surface->lightmaptexture, templight, surface->lightmapinfo->lightmaporigin[0], surface->lightmapinfo->lightmaporigin[1], smax, tmax);
+
+ // update the surface's deluxemap if it has one
+ if (surface->deluxemaptexture != r_texture_blanknormalmap)
+ {
+ vec3_t n;
+ unsigned char *normalmap = surface->lightmapinfo->nmapsamples;
+ lightmap = surface->lightmapinfo->samples;
+ // clear to no normalmap
+ bl = intblocklights;
+ memset(bl, 0, size3*sizeof(*bl));
+ // add all the normalmaps
+ if (lightmap && normalmap)
+ {
+ for (maps = 0;maps < MAXLIGHTMAPS && surface->lightmapinfo->styles[maps] != 255;maps++, lightmap += size3, normalmap += size3)
+ {
+ for (scale = r_refdef.lightstylevalue[surface->lightmapinfo->styles[maps]], i = 0;i < size;i++)
+ {
+ // add the normalmap with weighting proportional to the style's lightmap intensity
+ l = (int)(VectorLength(lightmap + i*3) * scale);
+ bl[i*3+0] += ((int)normalmap[i*3+0] - 128) * l;
+ bl[i*3+1] += ((int)normalmap[i*3+1] - 128) * l;
+ bl[i*3+2] += ((int)normalmap[i*3+2] - 128) * l;
+ }
+ }
+ }
+ bl = intblocklights;
+ out = templight;
+ // we simply renormalize the weighted normals to get a valid deluxemap
+ if (model->brushq1.lightmaprgba)
+ {
+ for (i = 0;i < size;i++, bl += 3)
+ {
+ VectorCopy(bl, n);
+ VectorNormalize(n);
+ l = (int)(n[0] * 128 + 128);*out++ = bound(0, l, 255);
+ l = (int)(n[1] * 128 + 128);*out++ = bound(0, l, 255);
+ l = (int)(n[2] * 128 + 128);*out++ = bound(0, l, 255);
+ *out++ = 255;
+ }
+ }
+ else
+ {
+ for (i = 0;i < size;i++, bl += 3)
+ {
+ VectorCopy(bl, n);
+ VectorNormalize(n);
+ l = (int)(n[0] * 128 + 128);*out++ = bound(0, l, 255);
+ l = (int)(n[1] * 128 + 128);*out++ = bound(0, l, 255);
+ l = (int)(n[2] * 128 + 128);*out++ = bound(0, l, 255);
+ }
+ }
+ R_UpdateTexture(surface->deluxemaptexture, templight, surface->lightmapinfo->lightmaporigin[0], surface->lightmapinfo->lightmaporigin[1], smax, tmax);
+ }
}
void R_StainNode (mnode_t *node, model_t *model, const vec3_t origin, float radius, const float fcolor[8])
smax = (surface->lightmapinfo->extents[0] >> 4) + 1;
tmax = (surface->lightmapinfo->extents[1] >> 4) + 1;
- impacts = DotProduct (impact, surface->lightmapinfo->texinfo->vecs[0]) + surface->lightmapinfo->texinfo->vecs[0][3] - surface->lightmapinfo->texturemins[0];
- impactt = DotProduct (impact, surface->lightmapinfo->texinfo->vecs[1]) + surface->lightmapinfo->texinfo->vecs[1][3] - surface->lightmapinfo->texturemins[1];
+ impacts = (int)(DotProduct (impact, surface->lightmapinfo->texinfo->vecs[0]) + surface->lightmapinfo->texinfo->vecs[0][3] - surface->lightmapinfo->texturemins[0]);
+ impactt = (int)(DotProduct (impact, surface->lightmapinfo->texinfo->vecs[1]) + surface->lightmapinfo->texinfo->vecs[1][3] - surface->lightmapinfo->texturemins[1]);
s = bound(0, impacts, smax * 16) - impacts;
t = bound(0, impactt, tmax * 16) - impactt;
- i = s * s + t * t + dist2;
+ i = (int)(s * s + t * t + dist2);
if (i > maxdist)
continue;
}
}
-static void R_DrawCollisionBrush(colbrushf_t *brush)
-{
- int i;
- rmeshstate_t m;
- memset(&m, 0, sizeof(m));
- m.pointer_vertex = brush->points->v;
- R_Mesh_State(&m);
- i = (int)(((size_t)brush) / sizeof(colbrushf_t));
- GL_Color((i & 31) * (1.0f / 32.0f), ((i >> 5) & 31) * (1.0f / 32.0f), ((i >> 10) & 31) * (1.0f / 32.0f), 0.2f);
- GL_LockArrays(0, brush->numpoints);
- R_Mesh_Draw(0, brush->numpoints, brush->numtriangles, brush->elements);
- GL_LockArrays(0, 0);
-}
-
-static void R_DrawCollisionSurface(entity_render_t *ent, msurface_t *surface)
-{
- int i;
- rmeshstate_t m;
- if (!surface->num_collisiontriangles)
- return;
- memset(&m, 0, sizeof(m));
- m.pointer_vertex = surface->data_collisionvertex3f;
- R_Mesh_State(&m);
- i = (int)(((size_t)surface) / sizeof(msurface_t));
- GL_Color((i & 31) * (1.0f / 32.0f), ((i >> 5) & 31) * (1.0f / 32.0f), ((i >> 10) & 31) * (1.0f / 32.0f), 0.2f);
- GL_LockArrays(0, surface->num_collisionvertices);
- R_Mesh_Draw(0, surface->num_collisionvertices, surface->num_collisiontriangles, surface->data_collisionelement3i);
- GL_LockArrays(0, 0);
-}
-
void R_WorldVisibility(void)
{
int i, j, *mark;
memset(r_worldsurfacevisible, 0, model->num_surfaces);
memset(r_worldleafvisible, 0, model->brush.num_leafs);
+ r_worldnovis = false;
+
// if floating around in the void (no pvs data available, and no
// portals available), simply use all on-screen leafs.
if (!viewleaf || viewleaf->clusterindex < 0)
// no visibility method: (used when floating around in the void)
// simply cull each leaf to the frustum (view pyramid)
// similar to quake's RecursiveWorldNode but without cache misses
+ r_worldnovis = true;
for (j = 0, leaf = model->brush.data_leafs;j < model->brush.num_leafs;j++, leaf++)
{
// if leaf is in current pvs and on the screen, mark its surfaces
if (model == NULL)
return;
R_DrawSurfaces(ent, false);
- if (r_showcollisionbrushes.integer && model->brush.num_brushes)
- {
- int i;
- msurface_t *surface;
- q3mbrush_t *brush;
- R_Mesh_Matrix(&ent->matrix);
- GL_BlendFunc(GL_SRC_ALPHA, GL_ONE);
- GL_DepthMask(false);
- GL_DepthTest(!r_showdisabledepthtest.integer);
- qglPolygonOffset(r_polygonfactor + r_showcollisionbrushes_polygonfactor.value, r_polygonoffset + r_showcollisionbrushes_polygonoffset.value);
- for (i = 0, brush = model->brush.data_brushes + model->firstmodelbrush;i < model->nummodelbrushes;i++, brush++)
- if (brush->colbrushf && brush->colbrushf->numtriangles)
- R_DrawCollisionBrush(brush->colbrushf);
- for (i = 0, surface = model->data_surfaces + model->firstmodelsurface;i < model->nummodelsurfaces;i++, surface++)
- if (surface->num_collisiontriangles)
- R_DrawCollisionSurface(ent, surface);
- qglPolygonOffset(r_polygonfactor, r_polygonoffset);
- }
}
typedef struct r_q1bsp_getlightinfo_s
r_shadow_compilingrtlight->static_meshchain_shadow = Mod_ShadowMesh_Finish(r_main_mempool, r_shadow_compilingrtlight->static_meshchain_shadow, false, false);
}
-extern float *rsurface_vertex3f;
-extern float *rsurface_svector3f;
-extern float *rsurface_tvector3f;
-extern float *rsurface_normal3f;
-extern void RSurf_SetVertexPointer(const entity_render_t *ent, const texture_t *texture, const msurface_t *surface, const vec3_t modelorg, qboolean generatenormals, qboolean generatetangents);
-
void R_Q1BSP_DrawShadowVolume(entity_render_t *ent, vec3_t relativelightorigin, float lightradius, int numsurfaces, const int *surfacelist, const vec3_t lightmins, const vec3_t lightmaxs)
{
model_t *model = ent->model;
int surfacelistindex;
float projectdistance = lightradius + model->radius*2 + r_shadow_projectdistance.value;
vec3_t modelorg;
- texture_t *texture;
+ texture_t *texture, *currentexture = NULL;
// check the box in modelspace, it was already checked in worldspace
- if (!BoxesOverlap(ent->model->normalmins, ent->model->normalmaxs, lightmins, lightmaxs))
+ if (!BoxesOverlap(model->normalmins, model->normalmaxs, lightmins, lightmaxs))
return;
R_UpdateAllTextureInfo(ent);
if (model->brush.shadowmesh)
}
else
{
- projectdistance = lightradius + ent->model->radius*2;
+ projectdistance = lightradius + model->radius*2;
Matrix4x4_Transform(&ent->inversematrix, r_vieworigin, modelorg);
for (surfacelistindex = 0;surfacelistindex < numsurfaces;surfacelistindex++)
{
surface = model->data_surfaces + surfacelist[surfacelistindex];
- // FIXME: get current skin
- texture = surface->texture;//R_FetchAliasSkin(ent, surface->groupmesh);
+ texture = surface->texture->currentframe;
if (texture->currentmaterialflags & (MATERIALFLAG_NODRAW | MATERIALFLAG_TRANSPARENT) || !surface->num_triangles)
continue;
- RSurf_SetVertexPointer(ent, texture, surface, modelorg, false, false);
+ if (currentexture != texture)
+ {
+ currentexture = texture;
+ RSurf_PrepareForBatch(ent, texture, modelorg);
+ RSurf_SetPointersForPass(false, false);
+ }
+ if (rsurface_dynamicvertex)
+ RSurf_PrepareDynamicSurfaceVertices(surface);
// identify lit faces within the bounding box
- R_Shadow_PrepareShadowMark(surface->groupmesh->num_triangles);
- R_Shadow_MarkVolumeFromBox(surface->num_firsttriangle, surface->num_triangles, rsurface_vertex3f, surface->groupmesh->data_element3i, relativelightorigin, lightmins, lightmaxs, surface->mins, surface->maxs);
- R_Shadow_VolumeFromList(surface->groupmesh->num_vertices, surface->groupmesh->num_triangles, rsurface_vertex3f, surface->groupmesh->data_element3i, surface->groupmesh->data_neighbor3i, relativelightorigin, projectdistance, numshadowmark, shadowmarklist);
+ R_Shadow_PrepareShadowMark(model->surfmesh.num_triangles);
+ R_Shadow_MarkVolumeFromBox(surface->num_firsttriangle, surface->num_triangles, rsurface_vertex3f, model->surfmesh.data_element3i, relativelightorigin, lightmins, lightmaxs, surface->mins, surface->maxs);
+ R_Shadow_VolumeFromList(model->surfmesh.num_vertices, model->surfmesh.num_triangles, rsurface_vertex3f, model->surfmesh.data_element3i, model->surfmesh.data_neighbor3i, relativelightorigin, projectdistance, numshadowmark, shadowmarklist);
}
}
}
static void R_Q1BSP_DrawLight_TransparentBatch(const entity_render_t *ent, texture_t *texture, int batchnumsurfaces, msurface_t **batchsurfacelist)
{
int batchsurfaceindex;
+ model_t *model = ent->model;
msurface_t *batchsurface;
vec3_t tempcenter, center;
for (batchsurfaceindex = 0;batchsurfaceindex < batchnumsurfaces;batchsurfaceindex++)
tempcenter[1] = (batchsurface->mins[1] + batchsurface->maxs[1]) * 0.5f;
tempcenter[2] = (batchsurface->mins[2] + batchsurface->maxs[2]) * 0.5f;
Matrix4x4_Transform(&ent->matrix, tempcenter, center);
- R_MeshQueue_AddTransparent(texture->currentmaterialflags & MATERIALFLAG_NODEPTHTEST ? r_vieworigin : center, R_Q1BSP_DrawLight_TransparentCallback, ent, batchsurface - ent->model->data_surfaces, r_shadow_rtlight);
+ R_MeshQueue_AddTransparent(texture->currentmaterialflags & MATERIALFLAG_NODEPTHTEST ? r_vieworigin : center, R_Q1BSP_DrawLight_TransparentCallback, ent, batchsurface - model->data_surfaces, r_shadow_rtlight);
}
}