X-Git-Url: http://de.git.xonotic.org/?a=blobdiff_plain;f=gl_rsurf.c;h=a31b6df9ca82b6dcc43adb4ff7b9f4570f9f9a31;hb=eacd06327dd5ac3be3800d102e5b56a1efd051b0;hp=27f6d6db4c2774aea025b5c3712e4d4e41e64689;hpb=5bc6231f75923291e67a4b88bedd1dd013d62e91;p=xonotic%2Fdarkplaces.git diff --git a/gl_rsurf.c b/gl_rsurf.c index 27f6d6db..a31b6df9 100644 --- a/gl_rsurf.c +++ b/gl_rsurf.c @@ -25,23 +25,21 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. #define MAX_LIGHTMAP_SIZE 256 -cvar_t r_ambient = {0, "r_ambient", "0"}; -cvar_t r_drawportals = {0, "r_drawportals", "0"}; -cvar_t r_testvis = {0, "r_testvis", "0"}; -cvar_t r_detailtextures = {CVAR_SAVE, "r_detailtextures", "1"}; -cvar_t r_surfaceworldnode = {0, "r_surfaceworldnode", "0"}; -cvar_t r_drawcollisionbrushes_polygonfactor = {0, "r_drawcollisionbrushes_polygonfactor", "-1"}; -cvar_t r_drawcollisionbrushes_polygonoffset = {0, "r_drawcollisionbrushes_polygonoffset", "0"}; -cvar_t r_q3bsp_renderskydepth = {0, "r_q3bsp_renderskydepth", "0"}; +cvar_t r_ambient = {0, "r_ambient", "0", "brighter world cheat (not allowed in multiplayer), value is 0-128"}; +cvar_t r_drawportals = {0, "r_drawportals", "0", "shows portals (separating polygons) in world interior in quake1 maps"}; +cvar_t r_lockpvs = {0, "r_lockpvs", "0", "disables pvs switching, allows you to walk around and inspect what is visible from a given location in the map (anything not visible from your current location will not be drawn)"}; +cvar_t r_lockvisibility = {0, "r_lockvisibility", "0", "disables visibility updates, allows you to walk around and inspect what is visible from a given viewpoint in the map (anything offscreen at the moment this is enabled will not be drawn)"}; +cvar_t r_useportalculling = {0, "r_useportalculling", "1", "use advanced portal culling visibility method to improve performance over just Potentially Visible Set, provides an even more significant speed improvement in unvised maps"}; +cvar_t r_q3bsp_renderskydepth = {0, "r_q3bsp_renderskydepth", "0", "draws sky depth masking in q3 maps (as in q1 maps), this means for example that sky polygons can hide other things"}; // flag arrays used for visibility checking on world model // (all other entities have no per-surface/per-leaf visibility checks) // TODO: dynamic resize according to r_refdef.worldmodel->brush.num_clusters -qbyte r_pvsbits[(32768+7)>>3]; +unsigned char r_pvsbits[(32768+7)>>3]; // TODO: dynamic resize according to r_refdef.worldmodel->brush.num_leafs -qbyte r_worldleafvisible[32768]; +unsigned char r_worldleafvisible[32768]; // TODO: dynamic resize according to r_refdef.worldmodel->num_surfaces -qbyte r_worldsurfacevisible[262144]; +unsigned char r_worldsurfacevisible[262144]; /* =============== @@ -54,9 +52,9 @@ void R_BuildLightMap (const entity_render_t *ent, msurface_t *surface) { int smax, tmax, i, j, size, size3, maps, stride, l; unsigned int *bl, scale; - qbyte *lightmap, *out, *stain; + unsigned char *lightmap, *out, *stain; static unsigned int intblocklights[MAX_LIGHTMAP_SIZE*MAX_LIGHTMAP_SIZE*3]; // LordHavoc: *3 for colored lighting - static qbyte templight[MAX_LIGHTMAP_SIZE*MAX_LIGHTMAP_SIZE*4]; + static unsigned char templight[MAX_LIGHTMAP_SIZE*MAX_LIGHTMAP_SIZE*4]; // update cached lighting info surface->cached_dlight = 0; @@ -84,7 +82,7 @@ void R_BuildLightMap (const entity_render_t *ent, msurface_t *surface) { bl = intblocklights; for (maps = 0;maps < MAXLIGHTMAPS && surface->lightmapinfo->styles[maps] != 255;maps++, lightmap += size3) - for (scale = d_lightstylevalue[surface->lightmapinfo->styles[maps]], i = 0;i < size3;i++) + for (scale = r_refdef.lightstylevalue[surface->lightmapinfo->styles[maps]], i = 0;i < size3;i++) bl[i] += lightmap[i] * scale; } } @@ -132,7 +130,7 @@ void R_StainNode (mnode_t *node, model_t *model, const vec3_t origin, float radi float ndist, a, ratio, maxdist, maxdist2, maxdist3, invradius, sdtable[256], td, dist2; msurface_t *surface, *endsurface; int i, s, t, smax, tmax, smax3, impacts, impactt, stained; - qbyte *bl; + unsigned char *bl; vec3_t impact; maxdist = radius * radius; @@ -210,9 +208,9 @@ loc0: { if (a > 1) a = 1; - bl[0] = (qbyte) ((float) bl[0] + a * ((fcolor[0] + ratio * fcolor[4]) - (float) bl[0])); - bl[1] = (qbyte) ((float) bl[1] + a * ((fcolor[1] + ratio * fcolor[5]) - (float) bl[1])); - bl[2] = (qbyte) ((float) bl[2] + a * ((fcolor[2] + ratio * fcolor[6]) - (float) bl[2])); + bl[0] = (unsigned char) ((float) bl[0] + a * ((fcolor[0] + ratio * fcolor[4]) - (float) bl[0])); + bl[1] = (unsigned char) ((float) bl[1] + a * ((fcolor[1] + ratio * fcolor[5]) - (float) bl[1])); + bl[2] = (unsigned char) ((float) bl[2] + a * ((fcolor[2] + ratio * fcolor[6]) - (float) bl[2])); stained = true; } } @@ -276,7 +274,6 @@ void R_Stain (const vec3_t origin, float radius, int cr1, int cg1, int cb1, int model = ent->model; if (model && model->name[0] == '*') { - Mod_CheckLoaded(model); if (model->brush.data_nodes) { Matrix4x4_Transform(&ent->inversematrix, origin, org); @@ -295,22 +292,22 @@ void R_Stain (const vec3_t origin, float radius, int cr1, int cg1, int cb1, int ============================================================= */ -static void R_DrawPortal_Callback(const void *calldata1, int calldata2) +static void R_DrawPortal_Callback(const entity_render_t *ent, int surfacenumber, const rtlight_t *rtlight) { + const mportal_t *portal = (mportal_t *)ent; int i; float *v; rmeshstate_t m; - const mportal_t *portal = calldata1; GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); GL_DepthMask(false); GL_DepthTest(true); - R_Mesh_Matrix(&r_identitymatrix); + R_Mesh_Matrix(&identitymatrix); memset(&m, 0, sizeof(m)); m.pointer_vertex = varray_vertex3f; R_Mesh_State(&m); - i = calldata2; + i = surfacenumber; GL_Color(((i & 0x0007) >> 0) * (1.0f / 7.0f), ((i & 0x0038) >> 3) * (1.0f / 7.0f), ((i & 0x01C0) >> 6) * (1.0f / 7.0f), @@ -331,7 +328,7 @@ static void R_DrawPortal_Callback(const void *calldata1, int calldata2) // LordHavoc: this is just a nice debugging tool, very slow static void R_DrawPortals(void) { - int i, leafnum;//, portalnum; + int i, leafnum; mportal_t *portal; float center[3], f; model_t *model = r_refdef.worldmodel; @@ -352,8 +349,7 @@ static void R_DrawPortals(void) VectorAdd(center, portal->points[i].position, center); f = ixtable[portal->numpoints]; VectorScale(center, f, center); - //R_MeshQueue_AddTransparent(center, R_DrawPortal_Callback, portal, portalnum); - R_MeshQueue_AddTransparent(center, R_DrawPortal_Callback, portal, leafnum); + R_MeshQueue_AddTransparent(center, R_DrawPortal_Callback, (entity_render_t *)portal, leafnum, r_shadow_rtlight); } } } @@ -403,66 +399,97 @@ void R_WorldVisibility(void) // if possible find the leaf the view origin is in viewleaf = model->brush.PointInLeaf ? model->brush.PointInLeaf(model, r_vieworigin) : NULL; // if possible fetch the visible cluster bits - if (model->brush.FatPVS) + if (!r_lockpvs.integer && model->brush.FatPVS) model->brush.FatPVS(model, r_vieworigin, 2, r_pvsbits, sizeof(r_pvsbits)); - // clear the visible surface and leaf flags arrays - memset(r_worldsurfacevisible, 0, model->num_surfaces); - memset(r_worldleafvisible, 0, model->brush.num_leafs); - - // if the user prefers surfaceworldnode (testing?) or the viewleaf could - // not be found, or the viewleaf is not part of the visible world - // (floating around in the void), use the pvs method - if (r_surfaceworldnode.integer || !viewleaf || viewleaf->clusterindex < 0) + if (!r_lockvisibility.integer) { - // pvs method: - // similar to quake's RecursiveWorldNode but without cache misses - for (j = 0, leaf = model->brush.data_leafs;j < model->brush.num_leafs;j++, leaf++) + // clear the visible surface and leaf flags arrays + memset(r_worldsurfacevisible, 0, model->num_surfaces); + memset(r_worldleafvisible, 0, model->brush.num_leafs); + + // 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 + 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 (!R_CullBox(leaf->mins, leaf->maxs)) + { + renderstats.world_leafs++; + r_worldleafvisible[j] = true; + if (leaf->numleafsurfaces) + for (i = 0, mark = leaf->firstleafsurface;i < leaf->numleafsurfaces;i++, mark++) + r_worldsurfacevisible[*mark] = true; + } + } + } + // if the user prefers to disable portal culling (testing?), simply + // use all on-screen leafs that are in the pvs. + else if (!r_useportalculling.integer) + { + // pvs method: + // simply check if each leaf is in the Potentially Visible Set, + // and cull to frustum (view pyramid) + // similar to quake's RecursiveWorldNode but without cache misses + 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 (CHECKPVSBIT(r_pvsbits, leaf->clusterindex) && !R_CullBox(leaf->mins, leaf->maxs)) + { + renderstats.world_leafs++; + r_worldleafvisible[j] = true; + if (leaf->numleafsurfaces) + for (i = 0, mark = leaf->firstleafsurface;i < leaf->numleafsurfaces;i++, mark++) + r_worldsurfacevisible[*mark] = true; + } + } + } + // otherwise use a recursive portal flow, culling each portal to + // frustum and checking if the leaf the portal leads to is in the pvs + else { - // if leaf is in current pvs and on the screen, mark its surfaces - if (CHECKPVSBIT(r_pvsbits, leaf->clusterindex) && !R_CullBox(leaf->mins, leaf->maxs)) + int leafstackpos; + mportal_t *p; + mleaf_t *leafstack[8192]; + // simple-frustum portal method: + // follows portals leading outward from viewleaf, does not venture + // offscreen or into leafs that are not visible, faster than + // Quake's RecursiveWorldNode and vastly better in unvised maps, + // often culls some surfaces that pvs alone would miss + // (such as a room in pvs that is hidden behind a wall, but the + // passage leading to the room is off-screen) + leafstack[0] = viewleaf; + leafstackpos = 1; + while (leafstackpos) { - c_leafs++; - r_worldleafvisible[j] = true; + renderstats.world_leafs++; + leaf = leafstack[--leafstackpos]; + r_worldleafvisible[leaf - model->brush.data_leafs] = true; + // mark any surfaces bounding this leaf if (leaf->numleafsurfaces) for (i = 0, mark = leaf->firstleafsurface;i < leaf->numleafsurfaces;i++, mark++) r_worldsurfacevisible[*mark] = true; + // follow portals into other leafs + // the checks are: + // if viewer is behind portal (portal faces outward into the scene) + // and the portal polygon's bounding box is on the screen + // and the leaf has not been visited yet + // and the leaf is visible in the pvs + // (the first two checks won't cause as many cache misses as the leaf checks) + for (p = leaf->portals;p;p = p->next) + { + renderstats.world_portals++; + if (DotProduct(r_vieworigin, p->plane.normal) < (p->plane.dist + 1) && !R_CullBox(p->mins, p->maxs) && !r_worldleafvisible[p->past - model->brush.data_leafs] && CHECKPVSBIT(r_pvsbits, p->past->clusterindex)) + leafstack[leafstackpos++] = p->past; + } } } } - else - { - int leafstackpos; - mportal_t *p; - mleaf_t *leafstack[8192]; - // portal method: - // follows portals leading outward from viewleaf, does not venture - // offscreen or into leafs that are not visible, faster than Quake's - // RecursiveWorldNode and vastly better in unvised maps, often culls a - // lot of surface that pvs alone would miss - leafstack[0] = viewleaf; - leafstackpos = 1; - while (leafstackpos) - { - c_leafs++; - leaf = leafstack[--leafstackpos]; - r_worldleafvisible[leaf - model->brush.data_leafs] = true; - // mark any surfaces bounding this leaf - if (leaf->numleafsurfaces) - for (i = 0, mark = leaf->firstleafsurface;i < leaf->numleafsurfaces;i++, mark++) - r_worldsurfacevisible[*mark] = true; - // follow portals into other leafs - // the checks are: - // if viewer is behind portal (portal faces outward into the scene) - // and the portal polygon's bounding box is on the screen - // and the leaf has not been visited yet - // and the leaf is visible in the pvs - // (the first two checks won't cause as many cache misses as the leaf checks) - for (p = leaf->portals;p;p = p->next) - if (DotProduct(r_vieworigin, p->plane.normal) < (p->plane.dist + 1) && !R_CullBox(p->mins, p->maxs) && !r_worldleafvisible[p->past - model->brush.data_leafs] && CHECKPVSBIT(r_pvsbits, p->past->clusterindex)) - leafstack[leafstackpos++] = p->past; - } - } if (r_drawportals.integer) R_DrawPortals(); @@ -472,28 +499,25 @@ void R_Q1BSP_DrawSky(entity_render_t *ent) { if (ent->model == NULL) return; - if (r_drawcollisionbrushes.integer < 2) - R_DrawSurfaces(ent, true); + R_DrawSurfaces(ent, true); } void R_Q1BSP_Draw(entity_render_t *ent) { - if (ent->model == NULL) + model_t *model = ent->model; + if (model == NULL) return; - c_bmodels++; - if (r_drawcollisionbrushes.integer < 2) - R_DrawSurfaces(ent, false); - if (r_drawcollisionbrushes.integer >= 1 && ent->model->brush.num_brushes) + R_DrawSurfaces(ent, false); + if (r_showcollisionbrushes.integer && model->brush.num_brushes && !r_showtrispass) { int i; - model_t *model = ent->model; msurface_t *surface; q3mbrush_t *brush; R_Mesh_Matrix(&ent->matrix); GL_BlendFunc(GL_SRC_ALPHA, GL_ONE); GL_DepthMask(false); - GL_DepthTest(true); - qglPolygonOffset(r_drawcollisionbrushes_polygonfactor.value, r_drawcollisionbrushes_polygonoffset.value); + GL_DepthTest(!r_showdisabledepthtest.integer); + qglPolygonOffset(r_showcollisionbrushes_polygonfactor.value, 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); @@ -510,16 +534,16 @@ typedef struct r_q1bsp_getlightinfo_s vec3_t relativelightorigin; float lightradius; int *outleaflist; - qbyte *outleafpvs; + unsigned char *outleafpvs; int outnumleafs; int *outsurfacelist; - qbyte *outsurfacepvs; + unsigned char *outsurfacepvs; int outnumsurfaces; vec3_t outmins; vec3_t outmaxs; vec3_t lightmins; vec3_t lightmaxs; - const qbyte *pvs; + const unsigned char *pvs; } r_q1bsp_getlightinfo_t; @@ -529,18 +553,24 @@ void R_Q1BSP_RecursiveGetLightInfo(r_q1bsp_getlightinfo_t *info, mnode_t *node) mleaf_t *leaf; for (;;) { - if (!BoxesOverlap(info->lightmins, info->lightmaxs, node->mins, node->maxs)) - return; - if (!node->plane) + mplane_t *plane = node->plane; + //if (!BoxesOverlap(info->lightmins, info->lightmaxs, node->mins, node->maxs)) + // return; + if (!plane) break; - sides = BoxOnPlaneSide(info->lightmins, info->lightmaxs, node->plane) - 1; - if (sides == 2) + if (plane->type < 3) + sides = ((info->lightmaxs[plane->type] >= plane->dist) | ((info->lightmins[plane->type] < plane->dist) << 1)); + else + sides = BoxOnPlaneSide(info->lightmins, info->lightmaxs, plane); + if (sides == 3) { R_Q1BSP_RecursiveGetLightInfo(info, node->children[0]); node = node->children[1]; } + else if (sides == 0) + return; // ERROR: NAN bounding box! else - node = node->children[sides]; + node = node->children[sides - 1]; } leaf = (mleaf_t *)node; if (info->pvs == NULL || CHECKPVSBIT(info->pvs, leaf->clusterindex)) @@ -570,7 +600,6 @@ void R_Q1BSP_RecursiveGetLightInfo(r_q1bsp_getlightinfo_t *info, mnode_t *node) { msurface_t *surface = info->model->data_surfaces + surfaceindex; if (BoxesOverlap(info->lightmins, info->lightmaxs, surface->mins, surface->maxs)) - if ((surface->texture->currentmaterialflags & (MATERIALFLAG_WALL | MATERIALFLAG_NODRAW | MATERIALFLAG_TRANSPARENT)) == MATERIALFLAG_WALL) { int triangleindex, t; const int *e; @@ -594,7 +623,7 @@ void R_Q1BSP_RecursiveGetLightInfo(r_q1bsp_getlightinfo_t *info, mnode_t *node) } } -void R_Q1BSP_GetLightInfo(entity_render_t *ent, vec3_t relativelightorigin, float lightradius, vec3_t outmins, vec3_t outmaxs, int *outleaflist, qbyte *outleafpvs, int *outnumleafspointer, int *outsurfacelist, qbyte *outsurfacepvs, int *outnumsurfacespointer) +void R_Q1BSP_GetLightInfo(entity_render_t *ent, vec3_t relativelightorigin, float lightradius, vec3_t outmins, vec3_t outmaxs, int *outleaflist, unsigned char *outleafpvs, int *outnumleafspointer, int *outsurfacelist, unsigned char *outsurfacepvs, int *outnumsurfacespointer) { r_q1bsp_getlightinfo_t info; VectorCopy(relativelightorigin, info.relativelightorigin); @@ -657,11 +686,34 @@ void R_Q1BSP_GetLightInfo(entity_render_t *ent, vec3_t relativelightorigin, floa *outnumsurfacespointer = info.outnumsurfaces; } +void R_Q1BSP_CompileShadowVolume(entity_render_t *ent, vec3_t relativelightorigin, float lightradius, int numsurfaces, const int *surfacelist) +{ + model_t *model = ent->model; + msurface_t *surface; + int surfacelistindex; + float projectdistance = lightradius + model->radius*2 + r_shadow_projectdistance.value; + texture_t *texture; + r_shadow_compilingrtlight->static_meshchain_shadow = Mod_ShadowMesh_Begin(r_shadow_mempool, 32768, 32768, NULL, NULL, NULL, false, false, true); + R_Shadow_PrepareShadowMark(model->brush.shadowmesh->numtriangles); + for (surfacelistindex = 0;surfacelistindex < numsurfaces;surfacelistindex++) + { + surface = model->data_surfaces + surfacelist[surfacelistindex]; + texture = surface->texture; + if ((texture->basematerialflags & (MATERIALFLAG_NODRAW | MATERIALFLAG_TRANSPARENT | MATERIALFLAG_WALL)) != MATERIALFLAG_WALL) + continue; + if ((texture->textureflags & (Q3TEXTUREFLAG_TWOSIDED | Q3TEXTUREFLAG_AUTOSPRITE | Q3TEXTUREFLAG_AUTOSPRITE2)) || (ent->flags & RENDER_NOCULLFACE)) + continue; + R_Shadow_MarkVolumeFromBox(surface->num_firstshadowmeshtriangle, surface->num_triangles, model->brush.shadowmesh->vertex3f, model->brush.shadowmesh->element3i, relativelightorigin, r_shadow_compilingrtlight->cullmins, r_shadow_compilingrtlight->cullmaxs, surface->mins, surface->maxs); + } + R_Shadow_VolumeFromList(model->brush.shadowmesh->numverts, model->brush.shadowmesh->numtriangles, model->brush.shadowmesh->vertex3f, model->brush.shadowmesh->element3i, model->brush.shadowmesh->neighbor3i, relativelightorigin, lightradius + model->radius + projectdistance, numshadowmark, shadowmarklist); + r_shadow_compilingrtlight->static_meshchain_shadow = Mod_ShadowMesh_Finish(r_shadow_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); +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) { @@ -674,38 +726,19 @@ void R_Q1BSP_DrawShadowVolume(entity_render_t *ent, vec3_t relativelightorigin, // check the box in modelspace, it was already checked in worldspace if (!BoxesOverlap(ent->model->normalmins, ent->model->normalmaxs, lightmins, lightmaxs)) return; - if (r_drawcollisionbrushes.integer >= 2) - return; - if (!r_shadow_compilingrtlight) - R_UpdateAllTextureInfo(ent); + R_UpdateAllTextureInfo(ent); if (model->brush.shadowmesh) { R_Shadow_PrepareShadowMark(model->brush.shadowmesh->numtriangles); - if (r_shadow_compilingrtlight) - { - for (surfacelistindex = 0;surfacelistindex < numsurfaces;surfacelistindex++) - { - surface = model->data_surfaces + surfacelist[surfacelistindex]; - texture = surface->texture; - if ((texture->basematerialflags & (MATERIALFLAG_NODRAW | MATERIALFLAG_TRANSPARENT | MATERIALFLAG_WALL)) != MATERIALFLAG_WALL) - continue; - if (texture->textureflags & (Q3TEXTUREFLAG_TWOSIDED | Q3TEXTUREFLAG_AUTOSPRITE | Q3TEXTUREFLAG_AUTOSPRITE2)) - continue; - R_Shadow_MarkVolumeFromBox(surface->num_firstshadowmeshtriangle, surface->num_triangles, model->brush.shadowmesh->vertex3f, model->brush.shadowmesh->element3i, relativelightorigin, lightmins, lightmaxs, surface->mins, surface->maxs); - } - } - else + for (surfacelistindex = 0;surfacelistindex < numsurfaces;surfacelistindex++) { - for (surfacelistindex = 0;surfacelistindex < numsurfaces;surfacelistindex++) - { - surface = model->data_surfaces + surfacelist[surfacelistindex]; - texture = surface->texture->currentframe; - if ((texture->currentmaterialflags & (MATERIALFLAG_NODRAW | MATERIALFLAG_TRANSPARENT | MATERIALFLAG_WALL)) != MATERIALFLAG_WALL) - continue; - if (texture->textureflags & (Q3TEXTUREFLAG_TWOSIDED | Q3TEXTUREFLAG_AUTOSPRITE | Q3TEXTUREFLAG_AUTOSPRITE2)) - continue; - R_Shadow_MarkVolumeFromBox(surface->num_firstshadowmeshtriangle, surface->num_triangles, model->brush.shadowmesh->vertex3f, model->brush.shadowmesh->element3i, relativelightorigin, lightmins, lightmaxs, surface->mins, surface->maxs); - } + surface = model->data_surfaces + surfacelist[surfacelistindex]; + texture = surface->texture->currentframe; + if ((texture->currentmaterialflags & (MATERIALFLAG_NODRAW | MATERIALFLAG_TRANSPARENT | MATERIALFLAG_WALL)) != MATERIALFLAG_WALL) + continue; + if ((texture->textureflags & (Q3TEXTUREFLAG_TWOSIDED | Q3TEXTUREFLAG_AUTOSPRITE | Q3TEXTUREFLAG_AUTOSPRITE2)) || (ent->flags & RENDER_NOCULLFACE)) + continue; + R_Shadow_MarkVolumeFromBox(surface->num_firstshadowmeshtriangle, surface->num_triangles, model->brush.shadowmesh->vertex3f, model->brush.shadowmesh->element3i, relativelightorigin, lightmins, lightmaxs, surface->mins, surface->maxs); } R_Shadow_VolumeFromList(model->brush.shadowmesh->numverts, model->brush.shadowmesh->numtriangles, model->brush.shadowmesh->vertex3f, model->brush.shadowmesh->element3i, model->brush.shadowmesh->neighbor3i, relativelightorigin, lightradius + model->radius + projectdistance, numshadowmark, shadowmarklist); } @@ -720,7 +753,7 @@ void R_Q1BSP_DrawShadowVolume(entity_render_t *ent, vec3_t relativelightorigin, texture = surface->texture;//R_FetchAliasSkin(ent, surface->groupmesh); if (texture->currentmaterialflags & (MATERIALFLAG_NODRAW | MATERIALFLAG_TRANSPARENT) || !surface->num_triangles) continue; - RSurf_SetVertexPointer(ent, texture, surface, modelorg); + RSurf_SetVertexPointer(ent, texture, surface, modelorg, false, false); // 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); @@ -729,99 +762,157 @@ void R_Q1BSP_DrawShadowVolume(entity_render_t *ent, vec3_t relativelightorigin, } } -void R_Q1BSP_DrawLight(entity_render_t *ent, float *lightcolor, int numsurfaces, const int *surfacelist) +static void R_Q1BSP_DrawLight_TransparentCallback(const entity_render_t *ent, int surfacenumber, const rtlight_t *rtlight) +{ + msurface_t *surface = ent->model->data_surfaces + surfacenumber; + texture_t *texture = surface->texture; + R_UpdateTextureInfo(ent, texture); + texture = texture->currentframe; + R_Shadow_RenderMode_Begin(); + R_Shadow_RenderMode_ActiveLight((rtlight_t *)rtlight); + R_Shadow_RenderMode_Lighting(false, true); + R_Shadow_SetupEntityLight(ent); + R_Shadow_RenderSurfacesLighting(ent, texture, 1, &surface); + R_Shadow_RenderMode_End(); +} + +static void R_Q1BSP_DrawLight_TransparentBatch(const entity_render_t *ent, texture_t *texture, int batchnumsurfaces, msurface_t **batchsurfacelist) +{ + int batchsurfaceindex; + msurface_t *batchsurface; + vec3_t tempcenter, center; + for (batchsurfaceindex = 0;batchsurfaceindex < batchnumsurfaces;batchsurfaceindex++) + { + batchsurface = batchsurfacelist[batchsurfaceindex]; + tempcenter[0] = (batchsurface->mins[0] + batchsurface->maxs[0]) * 0.5f; + 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); + } +} + +#define RSURF_MAX_BATCHSURFACES 1024 + +void R_Q1BSP_DrawLight(entity_render_t *ent, int numsurfaces, const int *surfacelist) { model_t *model = ent->model; msurface_t *surface; texture_t *texture; - int surfacelistindex; + int surfacelistindex, batchnumsurfaces; + msurface_t *batchsurfacelist[RSURF_MAX_BATCHSURFACES]; vec3_t modelorg; - if (r_drawcollisionbrushes.integer >= 2) - return; - if (r_shadow_compilingrtlight) + texture_t *tex; + qboolean skip; + R_UpdateAllTextureInfo(ent); + Matrix4x4_Transform(&ent->inversematrix, r_vieworigin, modelorg); + tex = NULL; + texture = NULL; + skip = false; + batchnumsurfaces = 0; + for (surfacelistindex = 0;surfacelistindex < numsurfaces;surfacelistindex++) { - // if compiling an rtlight, capture the meshes - int tri; - int *e; - float *lightmins, *lightmaxs, *v[3], *vertex3f; - for (surfacelistindex = 0;surfacelistindex < numsurfaces;surfacelistindex++) + if ((ent == r_refdef.worldentity && !r_worldsurfacevisible[surfacelist[surfacelistindex]])) + continue; + surface = model->data_surfaces + surfacelist[surfacelistindex]; + renderstats.lights_lighttriangles += surface->num_triangles; + if (tex != surface->texture) { - surface = model->data_surfaces + surfacelist[surfacelistindex]; - texture = surface->texture; - if ((texture->basematerialflags & (MATERIALFLAG_WALL | MATERIALFLAG_TRANSPARENT)) != MATERIALFLAG_WALL || !surface->num_triangles) + if (batchnumsurfaces > 0) + { + if (texture->currentmaterialflags & MATERIALFLAG_TRANSPARENT) + R_Q1BSP_DrawLight_TransparentBatch(ent, texture, batchnumsurfaces, batchsurfacelist); + else + R_Shadow_RenderSurfacesLighting(ent, texture, batchnumsurfaces, batchsurfacelist); + batchnumsurfaces = 0; + } + tex = surface->texture; + texture = surface->texture->currentframe; + skip = (texture->currentmaterialflags & MATERIALFLAG_SKY) != 0; + if (skip) continue; - e = surface->groupmesh->data_element3i + 3 * surface->num_firsttriangle; - vertex3f = surface->groupmesh->data_vertex3f; - lightmins = r_shadow_compilingrtlight->cullmins; - lightmaxs = r_shadow_compilingrtlight->cullmaxs; - for (tri = 0;tri < surface->num_triangles;tri++, e += 3) + } + if (!skip && surface->num_triangles) + { + if (batchnumsurfaces == RSURF_MAX_BATCHSURFACES) { - v[0] = vertex3f + e[0] * 3; - v[1] = vertex3f + e[1] * 3; - v[2] = vertex3f + e[2] * 3; - if (PointInfrontOfTriangle(r_shadow_compilingrtlight->shadoworigin, 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]))) - Mod_ShadowMesh_AddMesh(r_shadow_mempool, r_shadow_compilingrtlight->static_meshchain_light, surface->texture->skin.base, surface->texture->skin.gloss, surface->texture->skin.nmap, surface->groupmesh->data_vertex3f, surface->groupmesh->data_svector3f, surface->groupmesh->data_tvector3f, surface->groupmesh->data_normal3f, surface->groupmesh->data_texcoordtexture2f, 1, e); + if (texture->currentmaterialflags & MATERIALFLAG_TRANSPARENT) + R_Q1BSP_DrawLight_TransparentBatch(ent, texture, batchnumsurfaces, batchsurfacelist); + else + R_Shadow_RenderSurfacesLighting(ent, texture, batchnumsurfaces, batchsurfacelist); + batchnumsurfaces = 0; } + batchsurfacelist[batchnumsurfaces++] = surface; } } - else + if (batchnumsurfaces > 0) { - R_UpdateAllTextureInfo(ent); - Matrix4x4_Transform(&ent->inversematrix, r_vieworigin, modelorg); - for (surfacelistindex = 0;surfacelistindex < numsurfaces;surfacelistindex++) + if (texture->currentmaterialflags & MATERIALFLAG_TRANSPARENT) + R_Q1BSP_DrawLight_TransparentBatch(ent, texture, batchnumsurfaces, batchsurfacelist); + else + R_Shadow_RenderSurfacesLighting(ent, texture, batchnumsurfaces, batchsurfacelist); + batchnumsurfaces = 0; + } + qglEnable(GL_CULL_FACE); +} + +//Made by [515] +void R_ReplaceWorldTexture (void) +{ + model_t *m; + texture_t *t; + int i; + const char *r, *newt; + m = r_refdef.worldmodel; + + if(Cmd_Argc() < 2) + { + Con_Print("r_replacemaptexture - replaces texture\n"); + Con_Print("r_replacemaptexture - switch back to default texture\n"); + return; + } + if(!cl.islocalgame || !cl.worldmodel) + { + Con_Print("This command works only in singleplayer\n"); + return; + } + r = Cmd_Argv(1); + newt = Cmd_Argv(2); + if(!newt[0]) + newt = r; + for(i=0,t=m->data_textures;inum_textures;i++,t++) + { + if(t->width && !strcasecmp(t->name, r)) { - if (ent == r_refdef.worldentity && !r_worldsurfacevisible[surfacelist[surfacelistindex]]) - continue; - surface = model->data_surfaces + surfacelist[surfacelistindex]; - texture = surface->texture->currentframe; - // FIXME: transparent surfaces need to be lit later - if ((texture->currentmaterialflags & (MATERIALFLAG_WALL | MATERIALFLAG_TRANSPARENT)) != MATERIALFLAG_WALL || !surface->num_triangles) - continue; - if (texture->textureflags & Q3TEXTUREFLAG_TWOSIDED) - qglDisable(GL_CULL_FACE); - RSurf_SetVertexPointer(ent, texture, surface, modelorg); - if (!rsurface_svector3f) + if(Mod_LoadSkinFrame(&t->skin, (char*)newt, TEXF_MIPMAP | TEXF_ALPHA | TEXF_PRECACHE | TEXF_PICMIP, false, r_fullbrights.integer)) { - rsurface_svector3f = varray_svector3f; - rsurface_tvector3f = varray_tvector3f; - rsurface_normal3f = varray_normal3f; - Mod_BuildTextureVectorsAndNormals(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, rsurface_vertex3f, surface->groupmesh->data_texcoordtexture2f, surface->groupmesh->data_element3i + surface->num_firsttriangle * 3, rsurface_svector3f, rsurface_tvector3f, rsurface_normal3f); + Con_Printf("%s replaced with %s\n", r, newt); + return; } - if (ent->colormap >= 0) + else { - vec3_t lightcolorpants, lightcolorshirt; - // 128-224 are backwards ranges - int b = (ent->colormap & 0xF) << 4;b += (b >= 128 && b < 224) ? 4 : 12; - if (texture->skin.pants && b < 224) - { - qbyte *bcolor = (qbyte *) (&palette_complete[b]); - lightcolorpants[0] = lightcolor[0] * bcolor[0] * (1.0f / 255.0f); - lightcolorpants[1] = lightcolor[1] * bcolor[1] * (1.0f / 255.0f); - lightcolorpants[2] = lightcolor[2] * bcolor[2] * (1.0f / 255.0f); - } - else - VectorClear(lightcolorpants); - // 128-224 are backwards ranges - b = (ent->colormap & 0xF0);b += (b >= 128 && b < 224) ? 4 : 12; - if (texture->skin.shirt && b < 224) - { - qbyte *bcolor = (qbyte *) (&palette_complete[b]); - lightcolorshirt[0] = lightcolor[0] * bcolor[0] * (1.0f / 255.0f); - lightcolorshirt[1] = lightcolor[1] * bcolor[1] * (1.0f / 255.0f); - lightcolorshirt[2] = lightcolor[2] * bcolor[2] * (1.0f / 255.0f); - } - else - VectorClear(lightcolorshirt); - R_Shadow_RenderLighting(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, (surface->groupmesh->data_element3i + 3 * surface->num_firsttriangle), rsurface_vertex3f, rsurface_svector3f, rsurface_tvector3f, rsurface_normal3f, surface->groupmesh->data_texcoordtexture2f, lightcolor, lightcolorpants, lightcolorshirt, texture->skin.base, texture->skin.pants, texture->skin.shirt, texture->skin.nmap, texture->skin.gloss); + Con_Printf("%s was not found\n", newt); + Mod_LoadSkinFrame(&t->skin, (char*)r, TEXF_MIPMAP | TEXF_ALPHA | TEXF_PRECACHE | TEXF_PICMIP, false, r_fullbrights.integer);//back to default + return; } - else - R_Shadow_RenderLighting(surface->num_firstvertex, surface->num_vertices, surface->num_triangles, (surface->groupmesh->data_element3i + 3 * surface->num_firsttriangle), rsurface_vertex3f, rsurface_svector3f, rsurface_tvector3f, rsurface_normal3f, surface->groupmesh->data_texcoordtexture2f, lightcolor, vec3_origin, vec3_origin, texture->skin.merged ? texture->skin.merged : texture->skin.base, NULL, NULL, texture->skin.nmap, texture->skin.gloss); - if (texture->textureflags & Q3TEXTUREFLAG_TWOSIDED) - qglEnable(GL_CULL_FACE); } } } +//Made by [515] +void R_ListWorldTextures (void) +{ + model_t *m; + texture_t *t; + int i; + m = r_refdef.worldmodel; + + Con_Print("Worldmodel textures :\n"); + for(i=0,t=m->data_textures;inum_textures;i++,t++) + if(t->skin.base != r_texture_notexture) + Con_Printf("%s\n", t->name); +} + #if 0 static void gl_surf_start(void) { @@ -841,13 +932,14 @@ void GL_Surf_Init(void) Cvar_RegisterVariable(&r_ambient); Cvar_RegisterVariable(&r_drawportals); - Cvar_RegisterVariable(&r_testvis); - Cvar_RegisterVariable(&r_detailtextures); - Cvar_RegisterVariable(&r_surfaceworldnode); - Cvar_RegisterVariable(&r_drawcollisionbrushes_polygonfactor); - Cvar_RegisterVariable(&r_drawcollisionbrushes_polygonoffset); + Cvar_RegisterVariable(&r_lockpvs); + Cvar_RegisterVariable(&r_lockvisibility); + Cvar_RegisterVariable(&r_useportalculling); Cvar_RegisterVariable(&r_q3bsp_renderskydepth); + Cmd_AddCommand ("r_replacemaptexture", R_ReplaceWorldTexture, "override a map texture for testing purposes"); // By [515] + Cmd_AddCommand ("r_listmaptextures", R_ListWorldTextures, "list all textures used by the current map"); // By [515] + //R_RegisterModule("GL_Surf", gl_surf_start, gl_surf_shutdown, gl_surf_newmap); }