// used for dlight push checking and other things
int r_framecount;
+// used for visibility checking
+qbyte r_pvsbits[(MAX_MAP_LEAFS+7)>>3];
+
mplane_t frustum[4];
matrix4x4_t r_identitymatrix;
cvar_t r_drawentities = {0, "r_drawentities","1"};
cvar_t r_drawviewmodel = {0, "r_drawviewmodel","1"};
-cvar_t r_shadows = {CVAR_SAVE, "r_shadows", "0"};
cvar_t r_shadow_staticworldlights = {0, "r_shadow_staticworldlights", "1"};
cvar_t r_speeds = {0, "r_speeds","0"};
cvar_t r_fullbright = {0, "r_fullbright","0"};
cvar_t r_dynamic = {CVAR_SAVE, "r_dynamic","1"};
cvar_t r_fullbrights = {CVAR_SAVE, "r_fullbrights", "1"};
cvar_t r_shadow_cull = {0, "r_shadow_cull", "1"};
+cvar_t r_drawcollisionbrushes = {0, "r_drawcollisionbrushes", "0"};
cvar_t gl_fogenable = {0, "gl_fogenable", "0"};
cvar_t gl_fogdensity = {0, "gl_fogdensity", "0.25"};
cvar_t r_lerpsprites = {CVAR_SAVE, "r_lerpsprites", "1"};
cvar_t r_lerpmodels = {CVAR_SAVE, "r_lerpmodels", "1"};
cvar_t r_waterscroll = {CVAR_SAVE, "r_waterscroll", "1"};
-
+cvar_t r_watershader = {CVAR_SAVE, "r_watershader", "1"};
void R_ModulateColors(float *in, float *out, int verts, float r, float g, float b)
return;
}
}
- if (cl.worldmodel->entities)
- CL_ParseEntityLump(cl.worldmodel->entities);
+ if (cl.worldmodel->brush.entities)
+ CL_ParseEntityLump(cl.worldmodel->brush.entities);
}
}
Matrix4x4_CreateIdentity(&r_identitymatrix);
// FIXME: move this to client?
FOG_registercvars();
- Cmd_AddCommand ("timerefresh", R_TimeRefresh_f);
- Cvar_RegisterVariable (&r_drawentities);
- Cvar_RegisterVariable (&r_drawviewmodel);
- Cvar_RegisterVariable (&r_shadows);
- Cvar_RegisterVariable (&r_shadow_staticworldlights);
- Cvar_RegisterVariable (&r_speeds);
- Cvar_RegisterVariable (&r_fullbrights);
- Cvar_RegisterVariable (&r_wateralpha);
- Cvar_RegisterVariable (&r_dynamic);
- Cvar_RegisterVariable (&r_fullbright);
- Cvar_RegisterVariable (&r_textureunits);
- Cvar_RegisterVariable (&r_shadow_cull);
- Cvar_RegisterVariable (&r_lerpsprites);
- Cvar_RegisterVariable (&r_lerpmodels);
- Cvar_RegisterVariable (&r_waterscroll);
+ Cmd_AddCommand("timerefresh", R_TimeRefresh_f);
+ Cvar_RegisterVariable(&r_drawentities);
+ Cvar_RegisterVariable(&r_drawviewmodel);
+ Cvar_RegisterVariable(&r_shadow_staticworldlights);
+ Cvar_RegisterVariable(&r_speeds);
+ Cvar_RegisterVariable(&r_fullbrights);
+ Cvar_RegisterVariable(&r_wateralpha);
+ Cvar_RegisterVariable(&r_dynamic);
+ Cvar_RegisterVariable(&r_fullbright);
+ Cvar_RegisterVariable(&r_textureunits);
+ Cvar_RegisterVariable(&r_shadow_cull);
+ Cvar_RegisterVariable(&r_lerpsprites);
+ Cvar_RegisterVariable(&r_lerpmodels);
+ Cvar_RegisterVariable(&r_waterscroll);
+ Cvar_RegisterVariable(&r_watershader);
+ Cvar_RegisterVariable(&r_drawcollisionbrushes);
if (gamemode == GAME_NEHAHRA || gamemode == GAME_NEXUIZ)
Cvar_SetValue("r_fullbrights", 0);
R_RegisterModule("GL_Main", gl_main_start, gl_main_shutdown, gl_main_newmap);
extern void ui_init(void);
extern void gl_backend_init(void);
extern void Sbar_Init(void);
+extern void R_LightningBeams_Init(void);
void Render_Init(void)
{
R_Explosion_Init();
ui_init();
Sbar_Init();
+ R_LightningBeams_Init();
}
/*
return false;
}
-int PVS_CullBox(const vec3_t mins, const vec3_t maxs)
-{
- int stackpos, sides;
- mnode_t *node, *stack[4096];
- if (cl.worldmodel == NULL)
- return false;
- stackpos = 0;
- stack[stackpos++] = cl.worldmodel->nodes;
- while (stackpos)
- {
- node = stack[--stackpos];
- if (node->contents < 0)
- {
- if (((mleaf_t *)node)->pvsframe == cl.worldmodel->pvsframecount)
- return false;
- }
- else
- {
- sides = BoxOnPlaneSide(mins, maxs, node->plane);
- if (sides & 2 && stackpos < 4096)
- stack[stackpos++] = node->children[1];
- if (sides & 1 && stackpos < 4096)
- stack[stackpos++] = node->children[0];
- }
- }
- return true;
-}
-
-int VIS_CullBox(const vec3_t mins, const vec3_t maxs)
-{
- int stackpos, sides;
- mnode_t *node, *stack[4096];
- if (R_CullBox(mins, maxs))
- return true;
- if (cl.worldmodel == NULL)
- return false;
- stackpos = 0;
- stack[stackpos++] = cl.worldmodel->nodes;
- while (stackpos)
- {
- node = stack[--stackpos];
- if (node->contents < 0)
- {
- if (((mleaf_t *)node)->visframe == r_framecount)
- return false;
- }
- else
- {
- sides = BoxOnPlaneSide(mins, maxs, node->plane);
- if (sides & 2 && stackpos < 4096)
- stack[stackpos++] = node->children[1];
- if (sides & 1 && stackpos < 4096)
- stack[stackpos++] = node->children[0];
- }
- }
- return true;
-}
-
-int R_CullSphere(const vec3_t origin, vec_t radius)
-{
- return (DotProduct(frustum[0].normal, origin) + radius < frustum[0].dist
- || DotProduct(frustum[1].normal, origin) + radius < frustum[1].dist
- || DotProduct(frustum[2].normal, origin) + radius < frustum[2].dist
- || DotProduct(frustum[3].normal, origin) + radius < frustum[3].dist);
-}
-
-int PVS_CullSphere(const vec3_t origin, vec_t radius)
-{
- int stackpos;
- mnode_t *node, *stack[4096];
- float dist;
- if (cl.worldmodel == NULL)
- return false;
- stackpos = 0;
- stack[stackpos++] = cl.worldmodel->nodes;
- while (stackpos)
- {
- node = stack[--stackpos];
- if (node->contents < 0)
- {
- if (((mleaf_t *)node)->pvsframe == cl.worldmodel->pvsframecount)
- return false;
- }
- else
- {
- dist = PlaneDiff(origin, node->plane);
- if (dist <= radius)
- stack[stackpos++] = node->children[1];
- if (dist >= -radius)
- stack[stackpos++] = node->children[0];
- }
- }
- return true;
-}
-
-int VIS_CullSphere(const vec3_t origin, vec_t radius)
-{
- int stackpos;
- mnode_t *node, *stack[4096];
- float dist;
- if (R_CullSphere(origin, radius))
- return true;
- if (cl.worldmodel == NULL)
- return false;
- stackpos = 0;
- stack[stackpos++] = cl.worldmodel->nodes;
- while (stackpos)
- {
- node = stack[--stackpos];
- if (node->contents < 0)
- {
- if (((mleaf_t *)node)->visframe == r_framecount)
- return false;
- }
- else
- {
- dist = PlaneDiff(origin, node->plane);
- if (dist <= radius)
- stack[stackpos++] = node->children[1];
- if (dist >= -radius)
- stack[stackpos++] = node->children[0];
- }
- }
- return true;
-}
-
+#define VIS_CullBox(mins,maxs) (R_CullBox((mins), (maxs)) || (cl.worldmodel && cl.worldmodel->brush.BoxTouchingPVS && !cl.worldmodel->brush.BoxTouchingPVS(cl.worldmodel, r_pvsbits, (mins), (maxs))))
//==================================================================================
R_LerpAnimation(ent);
R_UpdateEntLights(ent);
if ((chase_active.integer || !(ent->flags & RENDER_EXTERIORMODEL))
- && !VIS_CullSphere(ent->origin, (ent->model != NULL ? ent->model->radius : 16) * ent->scale)
&& !VIS_CullBox(ent->mins, ent->maxs))
{
ent->visframe = r_framecount;
*/
void R_DrawNoModel(entity_render_t *ent);
-void R_DrawModels ()
+void R_DrawModels(void)
{
int i;
entity_render_t *ent;
}
}
-void R_DrawFakeShadows (void)
-{
- int i;
- entity_render_t *ent;
-
- ent = &cl_entities[0].render;
- if (ent->model && ent->model->DrawFakeShadow)
- ent->model->DrawFakeShadow(ent);
-
- if (!r_drawentities.integer)
- return;
- for (i = 0;i < r_refdef.numentities;i++)
- {
- ent = r_refdef.entities[i];
- if ((ent->flags & RENDER_SHADOW) && ent->model && ent->model->DrawFakeShadow)
- ent->model->DrawFakeShadow(ent);
- }
-}
-
#include "r_shadow.h"
int shadowframecount = 0;
-int Light_CullBox(const vec3_t mins, const vec3_t maxs)
-{
- int stackpos, sides;
- mnode_t *node, *stack[4096];
- if (cl.worldmodel == NULL)
- return false;
- stackpos = 0;
- stack[stackpos++] = cl.worldmodel->nodes;
- while (stackpos)
- {
- node = stack[--stackpos];
- if (node->contents < 0)
- {
- if (((mleaf_t *)node)->worldnodeframe == shadowframecount)
- return false;
- }
- else
- {
- sides = BoxOnPlaneSide(mins, maxs, node->plane);
- if (sides & 2 && stackpos < 4096)
- stack[stackpos++] = node->children[1];
- if (sides & 1 && stackpos < 4096)
- stack[stackpos++] = node->children[0];
- }
- }
- return true;
-}
-
-int LightAndVis_CullBox(const vec3_t mins, const vec3_t maxs)
-{
- int stackpos, sides;
- mnode_t *node, *stack[4096];
- if (R_CullBox(mins, maxs))
- return true;
- if (cl.worldmodel == NULL)
- return false;
- stackpos = 0;
- stack[stackpos++] = cl.worldmodel->nodes;
- while (stackpos)
- {
- node = stack[--stackpos];
- if (node->contents < 0)
- {
- if (((mleaf_t *)node)->visframe == r_framecount && ((mleaf_t *)node)->worldnodeframe == shadowframecount)
- return false;
- }
- else
- {
- sides = BoxOnPlaneSide(mins, maxs, node->plane);
- if (sides & 2 && stackpos < 4096)
- stack[stackpos++] = node->children[1];
- if (sides & 1 && stackpos < 4096)
- stack[stackpos++] = node->children[0];
- }
- }
- return true;
-}
-
-int LightAndVis_CullPointCloud(int numpoints, const float *points)
-{
- int i;
- const float *p;
- int stackpos, sides;
- mnode_t *node, *stack[4096];
- //if (R_CullBox(mins, maxs))
- // return true;
- if (cl.worldmodel == NULL)
- return false;
- stackpos = 0;
- stack[stackpos++] = cl.worldmodel->nodes;
- while (stackpos)
- {
- node = stack[--stackpos];
- if (node->contents < 0)
- {
- if (((mleaf_t *)node)->visframe == r_framecount && ((mleaf_t *)node)->worldnodeframe == shadowframecount)
- return false;
- }
- else
- {
- sides = 0;
- for (i = 0, p = points;i < numpoints && sides != 3;i++, p += 3)
- {
- if (DotProduct(p, node->plane->normal) < node->plane->dist)
- sides |= 1;
- else
- sides |= 2;
- }
- if (sides & 2 && stackpos < 4096)
- stack[stackpos++] = node->children[1];
- if (sides & 1 && stackpos < 4096)
- stack[stackpos++] = node->children[0];
- }
- }
- return true;
-}
-
-
void R_TestAndDrawShadowVolume(entity_render_t *ent, vec3_t lightorigin, float cullradius, float lightradius, vec3_t lightmins, vec3_t lightmaxs, vec3_t clipmins, vec3_t clipmaxs, int lightmarked)
{
vec3_t relativelightorigin;
- #if 0
- int i;
- vec3_t temp;
- float dist, projectdistance;
- float points[16][3];
- #endif
// rough checks
- if (!(ent->flags & RENDER_SHADOW) || ent->model == NULL || ent->model->DrawShadowVolume == NULL)
- return;
- if (r_shadow_cull.integer)
+ if ((ent->flags & RENDER_SHADOW) && ent->model && ent->model->DrawShadowVolume && !(r_shadow_cull.integer && (ent->maxs[0] < lightmins[0] || ent->mins[0] > lightmaxs[0] || ent->maxs[1] < lightmins[1] || ent->mins[1] > lightmaxs[1] || ent->maxs[2] < lightmins[2] || ent->mins[2] > lightmaxs[2])))
{
- if (ent->maxs[0] < lightmins[0] || ent->mins[0] > lightmaxs[0]
- || ent->maxs[1] < lightmins[1] || ent->mins[1] > lightmaxs[1]
- || ent->maxs[2] < lightmins[2] || ent->mins[2] > lightmaxs[2]
- || (lightmarked && Light_CullBox(ent->mins, ent->maxs)))
- return;
+ Matrix4x4_Transform(&ent->inversematrix, lightorigin, relativelightorigin);
+ ent->model->DrawShadowVolume (ent, relativelightorigin, lightradius);
}
- #if 0
- if (r_shadow_cull.integer)
- {
- projectdistance = cullradius;
- // calculate projected bounding box and decide if it is on-screen
- for (i = 0;i < 8;i++)
- {
- temp[0] = i & 1 ? ent->model->normalmaxs[0] : ent->model->normalmins[0];
- temp[1] = i & 2 ? ent->model->normalmaxs[1] : ent->model->normalmins[1];
- temp[2] = i & 4 ? ent->model->normalmaxs[2] : ent->model->normalmins[2];
- Matrix4x4_Transform(&ent->matrix, temp, points[i]);
- VectorSubtract(points[i], lightorigin, temp);
- dist = projectdistance / sqrt(DotProduct(temp, temp));
- VectorMA(lightorigin, dist, temp, points[i+8]);
- }
- if (LightAndVis_CullPointCloud(16, points[0]))
- return;
- /*
- for (i = 0;i < 8;i++)
- {
- p2[0] = i & 1 ? ent->model->normalmaxs[0] : ent->model->normalmins[0];
- p2[1] = i & 2 ? ent->model->normalmaxs[1] : ent->model->normalmins[1];
- p2[2] = i & 4 ? ent->model->normalmaxs[2] : ent->model->normalmins[2];
- Matrix4x4_Transform(&ent->matrix, p2, p);
- VectorSubtract(p, lightorigin, temp);
- dist = projectdistance / sqrt(DotProduct(temp, temp));
- VectorMA(p, dist, temp, p2);
- if (i)
- {
- if (mins[0] > p[0]) mins[0] = p[0];if (maxs[0] < p[0]) maxs[0] = p[0];
- if (mins[1] > p[1]) mins[1] = p[1];if (maxs[1] < p[1]) maxs[1] = p[1];
- if (mins[2] > p[2]) mins[2] = p[2];if (maxs[2] < p[2]) maxs[2] = p[2];
- }
- else
- {
- VectorCopy(p, mins);
- VectorCopy(p, maxs);
- }
- if (mins[0] > p2[0]) mins[0] = p2[0];if (maxs[0] < p2[0]) maxs[0] = p2[0];
- if (mins[1] > p2[1]) mins[1] = p2[1];if (maxs[1] < p2[1]) maxs[1] = p2[1];
- if (mins[2] > p2[2]) mins[2] = p2[2];if (maxs[2] < p2[2]) maxs[2] = p2[2];
- }
- if (mins[0] >= clipmaxs[0] || maxs[0] <= clipmins[0]
- || mins[1] >= clipmaxs[1] || maxs[1] <= clipmins[1]
- || mins[2] >= clipmaxs[2] || maxs[2] <= clipmins[2]
- || LightAndVis_CullBox(mins, maxs))
- return;
- */
- }
- #endif
- Matrix4x4_Transform(&ent->inversematrix, lightorigin, relativelightorigin);
- ent->model->DrawShadowVolume (ent, relativelightorigin, lightradius);
}
void R_Shadow_DrawWorldLightShadowVolume(matrix4x4_t *matrix, worldlight_t *light);
extern void R_Model_Brush_DrawLightForSurfaceList(entity_render_t *ent, vec3_t relativelightorigin, vec3_t relativeeyeorigin, float lightradius, float *lightcolor, msurface_t **surflist, int numsurfaces, const matrix4x4_t *matrix_modeltofilter, const matrix4x4_t *matrix_modeltoattenuationxyz, const matrix4x4_t *matrix_modeltoattenuationz);
-void R_ShadowVolumeLighting (int visiblevolumes)
+void R_ShadowVolumeLighting(int visiblevolumes)
{
int i;
entity_render_t *ent;
worldlight_t *wl;
rdlight_t *rd;
rmeshstate_t m;
- mleaf_t *leaf;
matrix4x4_t matrix;
matrix4x4_t matrix_worldtofilter, matrix_worldtoattenuationxyz, matrix_worldtoattenuationz;
matrix4x4_t matrix_modeltofilter, matrix_modeltoattenuationxyz, matrix_modeltoattenuationz;
GL_DepthMask(false);
GL_DepthTest(r_shadow_visiblevolumes.integer < 2);
qglDisable(GL_CULL_FACE);
- GL_Color(0.0 * r_colorscale, 0.0125 * r_colorscale, 0.1 * r_colorscale, 1);
+ GL_Color(0.0, 0.0125, 0.1, 1);
}
else
R_Shadow_Stage_Begin();
{
if (d_lightstylevalue[wl->style] <= 0)
continue;
- if (R_CullBox(wl->mins, wl->maxs))
- //if (R_CullSphere(wl->origin, cullradius))
+ if (VIS_CullBox(wl->mins, wl->maxs))
continue;
- //if (R_CullBox(wl->mins, wl->maxs) || R_CullSphere(wl->origin, lightradius))
- // continue;
- //if (VIS_CullBox(wl->mins, wl->maxs) || VIS_CullSphere(wl->origin, lightradius))
- // continue;
if (r_shadow_debuglight.integer >= 0 && lnum != r_shadow_debuglight.integer)
continue;
+ if (R_Shadow_ScissorForBBox(wl->mins, wl->maxs))
+ continue;
cullradius = wl->cullradius;
lightradius = wl->lightradius;
-
- if (cl.worldmodel != NULL)
- {
- for (i = 0;i < wl->numleafs;i++)
- if (wl->leafs[i]->visframe == r_framecount)
- break;
- if (i == wl->numleafs)
- continue;
- leaf = wl->leafs[i++];
- VectorCopy(leaf->mins, clipmins);
- VectorCopy(leaf->maxs, clipmaxs);
- for (;i < wl->numleafs;i++)
- {
- leaf = wl->leafs[i];
- if (leaf->visframe == r_framecount)
- {
- if (clipmins[0] > leaf->mins[0]) clipmins[0] = leaf->mins[0];
- if (clipmaxs[0] < leaf->maxs[0]) clipmaxs[0] = leaf->maxs[0];
- if (clipmins[1] > leaf->mins[1]) clipmins[1] = leaf->mins[1];
- if (clipmaxs[1] < leaf->maxs[1]) clipmaxs[1] = leaf->maxs[1];
- if (clipmins[2] > leaf->mins[2]) clipmins[2] = leaf->mins[2];
- if (clipmaxs[2] < leaf->maxs[2]) clipmaxs[2] = leaf->maxs[2];
- }
- }
- if (clipmins[0] < wl->mins[0]) clipmins[0] = wl->mins[0];
- if (clipmaxs[0] > wl->maxs[0]) clipmaxs[0] = wl->maxs[0];
- if (clipmins[1] < wl->mins[1]) clipmins[1] = wl->mins[1];
- if (clipmaxs[1] > wl->maxs[1]) clipmaxs[1] = wl->maxs[1];
- if (clipmins[2] < wl->mins[2]) clipmins[2] = wl->mins[2];
- if (clipmaxs[2] > wl->maxs[2]) clipmaxs[2] = wl->maxs[2];
- }
- else
- {
- VectorCopy(wl->mins, clipmins);
- VectorCopy(wl->maxs, clipmaxs);
- }
-
- //if (R_Shadow_ScissorForBBoxAndSphere(clipmins, clipmaxs, wl->origin, wl->cullradius))
- if (R_CullBox(clipmins, clipmaxs) || R_Shadow_ScissorForBBox(clipmins, clipmaxs))
- continue;
-
- // mark the leafs we care about so only things in those leafs will matter
- if (cl.worldmodel != NULL)
- for (i = 0;i < wl->numleafs;i++)
- wl->leafs[i]->worldnodeframe = shadowframecount;
+ VectorCopy(wl->mins, clipmins);
+ VectorCopy(wl->maxs, clipmaxs);
f = d_lightstylevalue[wl->style] * (1.0f / 256.0f);
VectorScale(wl->light, f, lightcolor);
static void R_SetupFrame (void)
{
// don't allow cheats in multiplayer
- if (cl.maxclients > 1)
+ if (!cl.islocalgame)
{
if (r_fullbright.integer != 0)
Cvar_Set ("r_fullbright", "0");
R_BuildLightList();
R_TimeReport("setup");
+ if (cl.worldmodel && cl.worldmodel->brush.FatPVS)
+ cl.worldmodel->brush.FatPVS(cl.worldmodel, r_origin, 2, r_pvsbits, sizeof(r_pvsbits));
+
R_WorldVisibility(world);
R_TimeReport("worldvis");
if (!intimerefresh && !r_speeds.integer)
S_ExtraUpdate ();
- R_DrawModels(r_shadow_realtime_world.integer);
+ R_DrawModels();
R_TimeReport("models");
- if (r_shadows.integer == 1 && !r_shadow_realtime_world.integer)
- {
- R_DrawFakeShadows();
- R_TimeReport("fakeshadow");
- }
-
if (r_shadow_realtime_world.integer || r_shadow_realtime_dlight.integer)
{
R_ShadowVolumeLighting(false);
vertex3f[18] = mins[0];vertex3f[19] = maxs[1];vertex3f[20] = maxs[2];
vertex3f[21] = maxs[0];vertex3f[22] = maxs[1];vertex3f[23] = maxs[2];
GL_ColorPointer(color);
- R_FillColors(color, 8, cr * r_colorscale, cg * r_colorscale, cb * r_colorscale, ca);
+ R_FillColors(color, 8, cr, cg, cb, ca);
if (fogenabled)
{
for (i = 0, v = vertex, c = color;i < 8;i++, v += 4, c += 4)
VectorSubtract(v, r_origin, diff);
f2 = exp(fogdensity/DotProduct(diff, diff));
f1 = 1 - f2;
- f2 *= r_colorscale;
c[0] = c[0] * f1 + fogcolor[0] * f2;
c[1] = c[1] * f1 + fogcolor[1] * f2;
c[2] = c[2] * f1 + fogcolor[2] * f2;
f1 = 1 - f2;
for (i = 0, c = color4f;i < 6;i++, c += 4)
{
- c[0] = (c[0] * f1 + fogcolor[0] * f2) * r_colorscale;
- c[1] = (c[1] * f1 + fogcolor[1] * f2) * r_colorscale;
- c[2] = (c[2] * f1 + fogcolor[2] * f2) * r_colorscale;
+ c[0] = (c[0] * f1 + fogcolor[0] * f2);
+ c[1] = (c[1] * f1 + fogcolor[1] * f2);
+ c[2] = (c[2] * f1 + fogcolor[2] * f2);
c[3] *= ent->alpha;
}
}
- else if (r_colorscale != 1 || ent->alpha != 1)
+ else if (ent->alpha != 1)
{
memcpy(color4f, nomodelcolor4f, sizeof(float[6*4]));
GL_ColorPointer(color4f);
for (i = 0, c = color4f;i < 6;i++, c += 4)
- {
- c[0] *= r_colorscale;
- c[1] *= r_colorscale;
- c[2] *= r_colorscale;
c[3] *= ent->alpha;
- }
}
else
GL_ColorPointer(nomodelcolor4f);
}
R_Mesh_Matrix(&r_identitymatrix);
- GL_Color(cr * r_colorscale, cg * r_colorscale, cb * r_colorscale, ca);
+ GL_Color(cr, cg, cb, ca);
GL_VertexPointer(varray_vertex3f);
GL_BlendFunc(blendfunc1, blendfunc2);
GL_DepthMask(false);
projects / xonotic / darkplaces.git / blobdiff