Exchanged SURF_NOLIGHTMAP and SURF_HINT

Added more surface params

code/qcommon/qfiles.h

@@ -555,9 +555,9 @@ typedef struct cTerraPatch_s {
 } cTerraPatch_t;
 
 typedef struct cStaticModel_s {
-	char model[ 128 ];
-	float origin[ 3 ];
-	float angles[ 3 ];
+	char model[128];
+	vec3_t origin;
+	vec3_t angles;
 	float scale;
 	int firstVertexData;
 	int numVertexData;

code/qcommon/surfaceflags.h

@@ -87,7 +87,7 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 #define	SURF_NOMARKS			0x20	// don't leave missile marks
 #define	SURF_CASTSHADOW			0x40
 #define	SURF_NODRAW				0x80	// don't generate a drawsurface at all
-#define SURF_HINT				0x100	// make a primary bsp splitter
+#define SURF_NOLIGHTMAP			0x100	// surface doesn't need a lightmap
 #define	SURF_ALPHASHADOW		0x200	// do per-pixel light shadow casting in q3map
 #define	SURF_NOSTEPS			0x400	// no footstep sounds
 #define	SURF_NONSOLID			0x800	// don't collide against curves with this set
@@ -109,7 +109,7 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 #define SURF_CARPET				0x8000000	// carpet effects
 #define SURF_BACKSIDE			0x10000000	// su44: backside
 #define SURF_NODLIGHT			0x20000000	// don't dlight even if solid (solid lava, skies)
-#define	SURF_NOLIGHTMAP			0x40000000	// surface doesn't need a lightmap
+#define	SURF_HINT				0x40000000	// make a primary bsp splitter
 #define SURF_UNKNOWN3			0x80000000	// IneQuation: WTF?
 
 #define	SURF_FLESH				0x40	// make flesh sounds and effects

code/renderer/qgl.h

@@ -92,6 +92,25 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 
 #define GL_COMBINE                          0x8570
 #define GL_COMBINE4_NV                      0x8503
+#define GL_COMBINE_RGB                      0x8571
+#define GL_COMBINE_ALPHA                    0x8572
+
+#define GL_SOURCE0_RGB                      0x8580
+#define GL_SOURCE1_RGB                      0x8581
+#define GL_SOURCE2_RGB                      0x8582
+#define GL_SOURCE3_RGB                      0x8583
+#define GL_SOURCE0_ALPHA                    0x8588
+#define GL_SOURCE1_ALPHA                    0x8589
+#define GL_SOURCE2_ALPHA                    0x858A
+#define GL_SOURCE3_ALPHA                    0x858B
+#define GL_OPERAND0_RGB                     0x8590
+#define GL_OPERAND1_RGB                     0x8591
+#define GL_OPERAND2_RGB                     0x8592
+#define GL_OPERAND3_RGB                     0x8593
+#define GL_OPERAND0_ALPHA                   0x8598
+#define GL_OPERAND1_ALPHA                   0x8599
+#define GL_OPERAND2_ALPHA                   0x859A
+#define GL_OPERAND3_ALPHA                   0x859B
 
 // NOTE: some Linux platforms would need those prototypes
 #if defined(MACOS_X)

code/renderer/tr_backend.c

@@ -34,6 +34,16 @@ static float	s_flipMatrix[16] = {
 	0, 0, 0, 1
 };
 
+void GL_SetFogColor(const vec4_t fColor) {
+	glState.fFogColor[0] = fColor[0];
+	glState.fFogColor[1] = fColor[1];
+	glState.fFogColor[2] = fColor[2];
+	glState.fFogColor[3] = fColor[3];
+
+	if (!(glState.glStateBits & GLS_FOG_COLOR)) {
+		qglFogfv(GL_FOG_COLOR, glState.fFogColor);
+	}
+}
 
 /*
 ** GL_Bind
@@ -206,7 +216,7 @@ void GL_TexEnv( int env )
 */
 void GL_State( unsigned long stateBits )
 {
-	unsigned long diff = stateBits ^ glState.glStateBits;
+	unsigned long diff = glState.glStateBits ^ (glState.externalSetState | stateBits);
 
 	if ( !diff )
 	{
@@ -358,6 +368,35 @@ void GL_State( unsigned long stateBits )
 		}
 	}
 
+	if ((diff & GLS_MULTITEXTURE_ENV) || (diff & GLS_MULTITEXTURE))
+	{
+		if (stateBits & GLS_MULTITEXTURE_ENV)
+		{
+			GL_TexEnv(GL_COMBINE4_NV);
+		}
+		else if (stateBits & GLS_MULTITEXTURE)
+		{
+			if (glState.cntTexEnvExt != GLS_MULTITEXTURE)
+			{
+				qglTexEnvf(GL_TEXTURE_ENV, GL_COMBINE_RGB, 34165.0);
+				qglTexEnvf(GL_TEXTURE_ENV, GL_COMBINE_ALPHA, 8448.0);
+				qglTexEnvf(GL_TEXTURE_ENV, GL_SOURCE0_RGB, 0x47057700);
+				qglTexEnvf(GL_TEXTURE_ENV, GL_OPERAND0_RGB, 0x44400000);
+				qglTexEnvf(GL_TEXTURE_ENV, GL_SOURCE1_RGB, 5890.0);
+				qglTexEnvf(GL_TEXTURE_ENV, GL_OPERAND1_RGB, 0x44400000);
+				qglTexEnvf(GL_TEXTURE_ENV, GL_SOURCE2_RGB, 0x47057700);
+				qglTexEnvf(GL_TEXTURE_ENV, GL_OPERAND2_RGB, 770.0);
+				glState.cntTexEnvExt = GLS_MULTITEXTURE;
+			}
+
+			GL_TexEnv(GL_COMBINE);
+		}
+		else
+		{
+			GL_TexEnv(GL_MODULATE);
+		}
+	}
+
 	//
 	// alpha test
 	//
@@ -386,7 +425,109 @@ void GL_State( unsigned long stateBits )
 		}
 	}
 
-	glState.glStateBits = stateBits;
+
+
+	if (diff & GLS_CLAMP_EDGE)
+	{
+		float clampValue;
+
+		if (r_forceClampToEdge->value)
+		{
+			if (stateBits & GLS_CLAMP_EDGE) {
+				clampValue = 33071.0;
+			}
+			else {
+				clampValue = 10497.0;
+			}
+		}
+		else
+		{
+			if (stateBits & GLS_CLAMP_EDGE) {
+				clampValue = 10496.0;
+			}
+			else {
+				clampValue = 10497.0;
+			}
+		}
+
+		if (qglActiveTextureARB)
+		{
+			int currenttmu = glState.currenttmu;
+
+			GL_SelectTexture(0);
+			qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, clampValue);
+			qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, clampValue);
+
+			GL_SelectTexture(1);
+			qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, clampValue);
+			qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, clampValue);
+
+			GL_SelectTexture(currenttmu);
+		}
+		else
+		{
+			GL_SelectTexture(0);
+			qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, clampValue);
+			qglTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, clampValue);
+		}
+	}
+
+	if (diff & GLS_FOG)
+	{
+		if (glState.externalSetState & GLS_FOG)
+		{
+			qglEnable(GL_FOG);
+
+			if (stateBits & GLS_FOG_BLACK)
+			{
+				vec4_t fBlackFogColor = { 0, 0, 0, 1 };
+				qglFogfv(GL_FOG_COLOR, fBlackFogColor);
+			}
+			else if (stateBits & GLS_FOG_WHITE)
+			{
+				vec4_t fWhiteFogColor = { 1, 1, 1, 1 };
+				qglFogfv(GL_FOG_COLOR, fWhiteFogColor);
+			}
+			else
+			{
+				//
+				// Use the global fog
+				qglFogfv(GL_FOG_COLOR, glState.fFogColor);
+			}
+		}
+		else
+		{
+			qglDisable(GL_FOG);
+		}
+	}
+	else if (glState.externalSetState & GLS_FOG)
+	{
+		if (diff & GLS_FOG_ENABLED)
+		{
+			if (stateBits & GLS_FOG_ENABLED) {
+				qglEnable(GL_FOG);
+			}
+			else {
+				qglDisable(GL_FOG);
+			}
+		}
+
+		if (diff & GLS_FOG_COLOR)
+		{
+			if (stateBits & GLS_FOG_BLACK)
+			{
+				vec4_t fBlackFogColor = { 0, 0, 0, 1 };
+				qglFogfv(GL_FOG_COLOR, fBlackFogColor);
+			}
+			else if (stateBits & GLS_FOG_WHITE)
+			{
+				vec4_t fWhiteFogColor = { 1, 1, 1, 1 };
+				qglFogfv(GL_FOG_COLOR, fWhiteFogColor);
+			}
+		}
+	}
+
+	glState.glStateBits = stateBits | glState.externalSetState;
 }
 
 
@@ -454,23 +595,33 @@ void RB_BeginDrawingView (void) {
 	//
 	SetViewportAndScissor();
 
+	R_UploadDlights();
+
 	// ensures that depth writes are enabled for the depth clear
 	GL_State( GLS_DEFAULT );
 	// clear relevant buffers
 	clearBits = GL_DEPTH_BUFFER_BIT;
 
-	if ( r_measureOverdraw->integer || r_shadows->integer == 2 )
+	if ( r_measureOverdraw->integer || r_shadows->integer == 3 )
 	{
 		clearBits |= GL_STENCIL_BUFFER_BIT;
 	}
-	if ( r_fastsky->integer && !( backEnd.refdef.rdflags & RDF_NOWORLDMODEL ) )
+
+	if (!( backEnd.refdef.rdflags & RDF_NOWORLDMODEL))
 	{
-		clearBits |= GL_COLOR_BUFFER_BIT;	// FIXME: only if sky shaders have been used
-#ifdef _DEBUG
-		qglClearColor( 0.8f, 0.7f, 0.4f, 1.0f );	// FIXME: get color of sky
-#else
-		qglClearColor( 0.0f, 0.0f, 0.0f, 1.0f );	// FIXME: get color of sky
-#endif
+		if (backEnd.viewParms.farplane_distance && tr.skyRendered && tr.portalRendered)
+		{
+			clearBits |= GL_COLOR_BUFFER_BIT;
+			qglClearColor(glState.fFogColor[0], glState.fFogColor[1], glState.fFogColor[2], glState.fFogColor[3]);
+		}
+		else
+		{
+			if (r_fastsky->integer)
+			{
+				clearBits |= GL_COLOR_BUFFER_BIT;
+				qglClearColor(0.5, 0.5, 1.0, 1.0);
+			}
+		}
 	}
 	qglClear( clearBits );
 
@@ -973,6 +1124,10 @@ const void *RB_StretchPic ( const void *data ) {
 	return (const void *)(cmd + 1);
 }
 
+void RB_SetupFog() {
+	// FIXME: unimplemented
+}
+
 
 /*
 =============

code/renderer/tr_bsp.c

@@ -2087,17 +2087,16 @@ void R_LoadStaticModelData(gamelump_t* lump) {
     }
 
     s_worldData.numStaticModelData = lump->length / (sizeof(byte) * 3);
-    s_worldData.staticModelData = ri.Hunk_Alloc(s_worldData.numStaticModelData * (sizeof(byte) * 4));
+    s_worldData.staticModelData = (byte*)ri.Hunk_Alloc(s_worldData.numStaticModelData * sizeof(color4ub_t));
 
     pSrcColors = lump->buffer;
     pDstColors = s_worldData.staticModelData;
 
-    for (i = 0; i < lump->length; i += 3)
-    {
-        pDstColors[0] = pSrcColors[0];
-        pDstColors[1] = pSrcColors[1];
-        pDstColors[2] = pSrcColors[2];
-        pDstColors[3] = -1;
+    for (i = 0; i < lump->length; i += sizeof(byte) * 3)
+    { 
+		// Colors are stored as integers
+		*(unsigned int*)pDstColors = LittleLong(*(unsigned int*)pSrcColors);
+        pDstColors[3] = 0xFF;
 
         pSrcColors += sizeof(byte) * 3;
         pDstColors += sizeof(byte) * 4;
@@ -2111,11 +2110,15 @@ R_CopyStaticModel
 */
 void R_CopyStaticModel(cStaticModel_t* pSM, cStaticModelUnpacked_t* pUnpackedSM) {
     pUnpackedSM->visCount = 0;
-    VectorCopy(pSM->angles, pUnpackedSM->angles);
-    VectorCopy(pSM->origin, pUnpackedSM->origin);
-    pUnpackedSM->scale = pSM->scale;
-    pUnpackedSM->firstVertexData = pSM->firstVertexData * 4 / 3;
-    pUnpackedSM->numVertexData = pSM->numVertexData;
+	pUnpackedSM->angles[0] = LittleFloat(pSM->angles[0]);
+	pUnpackedSM->angles[1] = LittleFloat(pSM->angles[1]);
+	pUnpackedSM->angles[2] = LittleFloat(pSM->angles[2]);
+	pUnpackedSM->origin[0] = LittleFloat(pSM->origin[0]);
+	pUnpackedSM->origin[1] = LittleFloat(pSM->origin[1]);
+	pUnpackedSM->origin[2] = LittleFloat(pSM->origin[2]);
+    pUnpackedSM->scale = LittleFloat(pSM->scale);
+    pUnpackedSM->firstVertexData = LittleLong(pSM->firstVertexData) * sizeof(color4ub_t) / (sizeof(byte) * 3);
+    pUnpackedSM->numVertexData = LittleLong(pSM->numVertexData);
     memcpy(pUnpackedSM->model, pSM->model, sizeof(pUnpackedSM->model));
 }
 

code/renderer/tr_image.c

@@ -2057,61 +2057,6 @@ static void R_CreateDlightImage( void ) {
 	tr.dlightImage = R_CreateImage("*dlight", (byte *)data, DLIGHT_SIZE, DLIGHT_SIZE, 0, 1, qfalse, qfalse, qfalse, qfalse, GL_CLAMP, GL_CLAMP);
 }
 
-
-/*
-=================
-R_InitFogTable
-=================
-*/
-void R_InitFogTable( void ) {
-	int		i;
-	float	d;
-	float	exp;
-	
-	exp = 0.5;
-
-	for ( i = 0 ; i < FOG_TABLE_SIZE ; i++ ) {
-		d = pow ( (float)i/(FOG_TABLE_SIZE-1), exp );
-
-		tr.fogTable[i] = d;
-	}
-}
-
-/*
-================
-R_FogFactor
-
-Returns a 0.0 to 1.0 fog density value
-This is called for each texel of the fog texture on startup
-and for each vertex of transparent shaders in fog dynamically
-================
-*/
-float	R_FogFactor( float s, float t ) {
-	float	d;
-
-	s -= 1.0/512;
-	if ( s < 0 ) {
-		return 0;
-	}
-	if ( t < 1.0/32 ) {
-		return 0;
-	}
-	if ( t < 31.0/32 ) {
-		s *= (t - 1.0f/32.0f) / (30.0f/32.0f);
-	}
-
-	// we need to leave a lot of clamp range
-	s *= 8;
-
-	if ( s > 1.0 ) {
-		s = 1.0;
-	}
-
-	d = tr.fogTable[ (int)(s * (FOG_TABLE_SIZE-1)) ];
-
-	return d;
-}
-
 /*
 ==================
 R_CreateDefaultImage

code/renderer/tr_init.c

@@ -841,6 +841,13 @@ void GL_SetDefaultState( void )
 	qglEnable( GL_SCISSOR_TEST );
 	qglDisable( GL_CULL_FACE );
 	qglDisable( GL_BLEND );
+
+	qglFogi(GL_FOG_MODE, GL_LINEAR);
+
+	glState.fFogColor[0] = 0.0;
+	glState.fFogColor[1] = 0.0;
+	glState.fFogColor[2] = 0.0;
+	glState.fFogColor[3] = 1.0;
 }
 
 const char* RE_GetGraphicsInfo() {
@@ -1201,7 +1208,18 @@ void R_Register( void )
 }
 
 void R_InitExtensions() {
-	// FIXME: unimplemented
+	// FIXME: qglTextureEnvCombineExists
+	glState.cntTexEnvExt = 0;
+	glState.cntnvblendmode = 0;
+
+	qglTexEnvf(GL_TEXTURE_ENV, GL_COMBINE_RGB, 34165.0);
+	qglTexEnvf(GL_TEXTURE_ENV, GL_COMBINE_ALPHA, 8448.0);
+	qglTexEnvf(GL_TEXTURE_ENV, GL_SOURCE0_RGB, 0x47057700);
+	qglTexEnvf(GL_TEXTURE_ENV, GL_OPERAND0_RGB, 0x44400000);
+	qglTexEnvf(GL_TEXTURE_ENV, GL_SOURCE1_RGB, 5890.0);
+	qglTexEnvf(GL_TEXTURE_ENV, GL_OPERAND1_RGB, 0x44400000);
+	qglTexEnvf(GL_TEXTURE_ENV, GL_SOURCE2_RGB, 0x47057700);
+	qglTexEnvf(GL_TEXTURE_ENV, GL_OPERAND2_RGB, 770.0);
 }
 
 /*
@@ -1228,6 +1246,11 @@ void R_Init( void ) {
 	}
 	Com_Memset( tess.constantColor255, 255, sizeof( tess.constantColor255 ) );
 
+	tr.worldEntity.e.shaderRGBA[0] = -1;
+	tr.worldEntity.e.shaderRGBA[1] = 0;
+	tr.worldEntity.e.shaderRGBA[2] = -1;
+	tr.worldEntity.e.shaderRGBA[3] = -1;
+
 	//
 	// init function tables
 	//
@@ -1255,10 +1278,16 @@ void R_Init( void ) {
 		}
 	}
 
-	R_InitFogTable();
+	tr.rendererhandle = ri.Milliseconds();
+
+	if (!tr.rendererhandle) {
+		tr.rendererhandle = -1;
+	}
 
 	R_NoiseInit();
 
+	R_Sky_Init();
+
 	R_Register();
 
 	max_polys = r_maxpolys->integer;
@@ -1304,6 +1333,11 @@ void R_Init( void ) {
 
 	R_ModelInit();
 
+	R_LevelMarksInit();
+
+	tr.pFontDebugStrings = R_LoadFont("verdana-14");
+	g_bInfoworldtris = qfalse;
+
 	err = qglGetError();
 	if ( err != GL_NO_ERROR )
 		ri.Printf (PRINT_ALL, "glGetError() = 0x%x\n", err);

code/renderer/tr_light.c

@@ -29,6 +29,23 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 #define	DLIGHT_MINIMUM_RADIUS	16		
 // never calculate a range less than this to prevent huge light numbers
 
+typedef struct {
+  dlight_t *dl;
+  float power;
+  vec3_t origin;
+} incidentLight_t;
+
+typedef struct {
+  int dlightMap;
+  int allocated[128];
+  byte lightmap_buffer[65536];
+  byte* srcBase;
+  byte* dstBase;
+  incidentLight_t lights[32];
+  int numLights;
+} dlightInfo_t;
+
+dlightInfo_t dli;
 
 /*
 ===============
@@ -413,3 +430,78 @@ int R_LightForPoint( vec3_t point, vec3_t ambientLight, vec3_t directedLight, ve
 
 	return qtrue;
 }
+
+void R_ClearRealDlights() {
+	memset(dli.allocated, 0, sizeof(dli.allocated));
+	dli.dlightMap = 0;
+}
+
+void R_UploadDlights() {
+	int i, h;
+
+	if (!tr.pc.c_dlightSurfaces) {
+		return;
+	}
+
+	h = 0;
+	for (i = 0; i < 128; ++i)
+	{
+		if (h < dli.allocated[i]) {
+			h = dli.allocated[i];
+		}
+	}
+
+	if (h)
+	{
+		if (h > 128) {
+			ri.Error(ERR_DROP, "R_UploadDlights: bad allocated height");
+		}
+
+		GL_Bind(tr.dlightImages[dli.dlightMap]);
+		qglTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 128, h, GL_RGBA, GL_UNSIGNED_BYTE, dli.lightmap_buffer);
+
+		tr.pc.c_dlightMaps++;
+		memset(dli.allocated, 0, sizeof(dli.allocated));
+	}
+}
+
+qboolean R_AllocLMBlock(int w, int h, int* x, int* y) {
+	int i, j;
+	int best, best2;
+
+	for (;;)
+	{
+		best = 128;
+		for (i = 0; i < 128 - w; i++)
+		{
+			best2 = 0;
+
+			for (j = 0; j < w && dli.allocated[i] < best; j++)
+			{
+				if (best2 < dli.allocated[i]) {
+					best2 = dli.allocated[i];
+				}
+			}
+
+			if (j == w)
+			{
+				*x = i;
+				*y = best2;
+				best = best2;
+			}
+		}
+
+		if (h + best <= 128) {
+			break;
+		}
+
+		if (dli.dlightMap == 14) {
+			return qfalse;
+		}
+
+		R_UploadDlights();
+		dli.dlightMap++;
+	}
+
+	return qtrue;
+}

code/renderer/tr_local.h

@@ -613,21 +613,29 @@ typedef struct {
 	int			num_entities;
 	trRefEntity_t	*entities;
 
+    int			num_sprites;
+    refSprite_t	*sprites;
+
 	int			num_dlights;
 	struct dlight_s	*dlights;
 
+	int			numTerMarks;
+	struct srfMarkFragment_s *terMarks;
+
 	int			numPolys;
 	struct srfPoly_s	*polys;
 
 	int			numDrawSurfs;
 	struct drawSurf_s	*drawSurfs;
 
-    int numSpriteSurfs;
-    struct drawSurf_s* spriteSurfs;
-    int numStaticModels;
-    struct cStaticModelUnpacked_s* staticModels;
-    int numStaticModelData;
-    unsigned char* staticModelData;
+	int			numSpriteSurfs;
+	struct drawSurf_s	*spriteSurfs;
+
+    int			numStaticModels;
+    struct cStaticModelUnpacked_s *staticModels;
+
+    int			numStaticModelData;
+    unsigned char		*staticModelData;
     qboolean sky_portal;
     float sky_alpha;
     vec3_t sky_origin;
@@ -683,7 +691,7 @@ typedef struct {
 	int			viewportX, viewportY, viewportWidth, viewportHeight;
 	float		fovX, fovY;
 	float		projectionMatrix[16];
-	cplane_t	frustum[4];
+	cplane_t	frustum[5];
 	vec3_t		visBounds[2];
 	float		zFar;
 	depthfog_t	fog;
@@ -1024,6 +1032,7 @@ typedef struct {
 	int			numShaders;
 	dshader_t	*shaders;
 
+	int			numBmodels;
 	bmodel_t	*bmodels;
 
 	int			numplanes;
@@ -1156,6 +1165,8 @@ typedef struct {
 	int		c_leafs;
 	int		c_dlightSurfaces;
 	int		c_dlightSurfacesCulled;
+	int		c_dlightMaps;
+	int		c_dlightTexels;
 } frontEndCounters_t;
 
 #define	FOG_TABLE_SIZE		256
@@ -1180,7 +1191,7 @@ typedef struct {
 
 
 typedef struct {
-	int		c_surfaces, c_shaders, c_vertexes, c_indexes, c_totalIndexes;
+	int		c_surfaces, c_shaders, c_vertexes, c_indexes, c_totalIndexes, c_characterlights;
 	float	c_overDraw;
 	
 	int		c_dlightVertexes;
@@ -1252,6 +1263,7 @@ typedef struct {
 	image_t					*flareImage;
 	image_t					*whiteImage;			// full of 0xff
 	image_t					*identityLightImage;	// full of tr.identityLightByte
+	image_t					*dlightImages[15];
 
 	shader_t				*defaultShader;
 	shader_t				*shadowShader;
@@ -1281,6 +1293,9 @@ typedef struct {
 
 	orientationr_t			ori;				// for current entity
 
+	portalsky_t				portalsky;
+	qboolean				skyRendered;
+	qboolean				portalRendered;
 	trRefdef_t				refdef;
 
 	int						viewCluster;
@@ -1316,7 +1331,6 @@ typedef struct {
 	float					triangleTable[FUNCTABLE_SIZE];
 	float					sawToothTable[FUNCTABLE_SIZE];
 	float					inverseSawToothTable[FUNCTABLE_SIZE];
-	float					fogTable[FOG_TABLE_SIZE];
 
     spherel_t sSunLight;
     spherel_t sLights[1532];
@@ -1560,6 +1574,8 @@ void R_DebugCircle(const vec3_t org, float radius, float r, float g, float b, fl
 void R_DebugLine(const vec3_t start, const vec3_t end, float r, float g, float b, float alpha);
 void R_RenderView( viewParms_t *parms );
 
+qboolean SurfIsOffscreen(const srfSurfaceFace_t* surface, shader_t* shader, int entityNum);
+
 void R_AddMD3Surfaces( trRefEntity_t *e );
 void R_AddNullModelSurfaces( trRefEntity_t *e );
 void R_AddBeamSurfaces( trRefEntity_t *e );
@@ -1576,18 +1592,24 @@ void R_AddDrawSurf(surfaceType_t* surface, shader_t* shader, int dlightMap);
 #define	CULL_IN		0		// completely unclipped
 #define	CULL_CLIP	1		// clipped by one or more planes
 #define	CULL_OUT	2		// completely outside the clipping planes
-void R_LocalNormalToWorld (vec3_t local, vec3_t world);
-void R_LocalPointToWorld (vec3_t local, vec3_t world);
+void R_LocalNormalToWorld (const vec3_t local, vec3_t world);
+void R_LocalPointToWorld (const vec3_t local, vec3_t world);
+int R_CullLocalBoxOffset(const vec3_t offset, vec3_t bounds[2]);
 int R_CullLocalBox (vec3_t bounds[2]);
 int R_CullPointAndRadius( vec3_t origin, float radius );
 int R_CullLocalPointAndRadius( vec3_t origin, float radius );
+int R_DistanceCullLocalPointAndRadius(float fDist, const vec3_t pt, float radius);
+int R_DistanceCullPointAndRadius(float fDist, const vec3_t pt, float radius);
 
 void R_RotateForEntity( const trRefEntity_t *ent, const viewParms_t *viewParms, orientationr_t *ori );
 void R_RotateForStaticModel(cStaticModelUnpacked_t* SM, const viewParms_t* viewParms, orientationr_t* ori );
+void R_RotateForViewer(void);
+void R_SetupFrustum(void);
 
 /*
 ** GL wrapper/helper functions
 */
+void	GL_SetFogColor(const vec4_t fColor);
 void	GL_Bind( image_t *image );
 void	GL_SetDefaultState (void);
 void	GL_SelectTexture( int unit );
@@ -1619,12 +1641,19 @@ void	GL_Cull( int cullType );
 #define		GLS_DSTBLEND_BITS					0x000000f0
 
 #define GLS_DEPTHMASK_TRUE						0x00000100
+#define GLS_POLYMODE_LINE						0x00000200
 #define GLS_DEPTHTEST_DISABLE					0x00000400
+#define GLS_DEPTHFUNC_EQUAL						0x00000800
 
-#define GLS_POLYMODE_LINE						0x00001000
+#define GLS_CLAMP_EDGE							0x00001000
+#define GLS_MULTITEXTURE						0x00002000
 #define GLS_MULTITEXTURE_ENV					0x00004000
+#define GLS_FOG									0x00008000
 
-#define GLS_DEPTHFUNC_EQUAL						0x00020000
+#define GLS_FOG_ENABLED							0x00010000
+#define GLS_FOG_BLACK							0x00020000
+#define GLS_FOG_WHITE							0x00040000
+#define GLS_FOG_COLOR							(GLS_FOG_BLACK | GLS_FOG_WHITE)
 
 #define GLS_ATEST_GT_0							0x10000000
 #define GLS_ATEST_LT_80							0x20000000
@@ -1688,8 +1717,6 @@ void	R_SkinList_f( void );
 const void *RB_TakeScreenshotCmd( const void *data );
 void	R_ScreenShot_f( void );
 
-void	R_InitFogTable( void );
-float	R_FogFactor( float s, float t );
 void	R_InitImages( void );
 void	R_DeleteTextures( void );
 int		R_SumOfUsedImages( void );
@@ -1815,6 +1842,7 @@ extern terrainVert_t* g_pVert;
 
 void R_AddBrushModelSurfaces( trRefEntity_t *e );
 void R_GetInlineModelBounds(int iIndex, vec3_t vMins, vec3_t vMaxs);
+mnode_t* R_PointInLeaf(const vec3_t p);
 int R_DlightTerrain(cTerraPatchUnpacked_t* surf, int dlightBits);
 int R_CheckDlightTerrain(cTerraPatchUnpacked_t* surf, int dlightBits);
 void R_AddWorldSurfaces( void );
@@ -1857,6 +1885,7 @@ void RB_Grid_SetupStaticModel();
 void RB_Light_Fullbright(const color4ub_t colors);
 void R_Sphere_InitLights();
 int R_GatherLightSources(const vec3_t vPos, vec3_t* pvLightPos, vec3_t* pvLightIntensity, int iMaxLights);
+void R_UploadDlights();
 
 
 /*
@@ -1868,6 +1897,7 @@ SHADOWS
 */
 
 void RB_ShadowTessEnd( void );
+void RB_ComputeShadowVolume();
 void RB_ShadowFinish( void );
 void RB_ProjectionShadowDeform( void );
 
@@ -1972,6 +2002,7 @@ void R_LevelMarksLoad(const char* szBSPName);
 void R_LevelMarksInit();
 void R_LevelMarksFree();
 void R_UpdateLevelMarksSystem();
+void R_AddPermanentMarkFragmentSurfaces(void** pFirstMarkFragment, int iNumMarkFragment);
 
 /*
 =============================================================
@@ -2060,6 +2091,7 @@ float R_CalcLod(const vec3_t origin, float radius);
 
 extern int g_nStaticSurfaces;
 extern qboolean g_bInfostaticmodels;
+extern qboolean g_bInfoworldtris;
 
 /*
 =============================================================
@@ -2106,9 +2138,6 @@ void	RB_CalcRotateTexCoords( float rotSpeed, float *dstTexCoords );
 void	RB_CalcScaleTexCoords( const float scale[2], float *dstTexCoords );
 void	RB_CalcTurbulentTexCoords( const waveForm_t *wf, float *dstTexCoords );
 void	RB_CalcTransformTexCoords( const texModInfo_t *tmi, float *dstTexCoords );
-void	RB_CalcModulateColorsByFog( unsigned char *dstColors );
-void	RB_CalcModulateAlphasByFog( unsigned char *dstColors );
-void	RB_CalcModulateRGBAsByFog( unsigned char *dstColors );
 void	RB_CalcWaveAlpha( const waveForm_t *wf, unsigned char *dstColors );
 void	RB_CalcWaveColor(const waveForm_t* wf, unsigned char* dstColors, unsigned char* constantColor);
 void	RB_CalcAlphaFromEntity( unsigned char *dstColors );

code/renderer/tr_main.c

@@ -49,7 +49,7 @@ R_CullLocalBox
 Returns CULL_IN, CULL_CLIP, or CULL_OUT
 =================
 */
-int R_CullLocalBox (vec3_t bounds[2]) {
+int R_CullLocalBoxOffset(const vec3_t offset, vec3_t bounds[2]) {
 	int		i, j;
 	vec3_t	transformed[8];
 	float	dists[8];
@@ -69,6 +69,7 @@ int R_CullLocalBox (vec3_t bounds[2]) {
 		v[2] = bounds[(i>>2)&1][2];
 
 		VectorCopy( tr.ori.origin, transformed[i] );
+		VectorAdd(transformed[i], offset, transformed[i]);
 		VectorMA( transformed[i], v[0], tr.ori.axis[0], transformed[i] );
 		VectorMA( transformed[i], v[1], tr.ori.axis[1], transformed[i] );
 		VectorMA( transformed[i], v[2], tr.ori.axis[2], transformed[i] );
@@ -76,7 +77,7 @@ int R_CullLocalBox (vec3_t bounds[2]) {
 
 	// check against frustum planes
 	anyBack = 0;
-	for (i = 0 ; i < 4 ; i++) {
+	for (i = 0 ; i < tr.viewParms.fog.extrafrustums + 4 ; i++) {
 		frust = &tr.viewParms.frustum[i];
 
 		front = back = 0;
@@ -105,6 +106,10 @@ int R_CullLocalBox (vec3_t bounds[2]) {
 	return CULL_CLIP;		// partially clipped
 }
 
+int R_CullLocalBox(vec3_t bounds[2]) {
+	return R_CullLocalBoxOffset(vec3_origin, bounds);
+}
+
 /*
 ** R_CullLocalPointAndRadius
 */
@@ -155,6 +160,35 @@ int R_CullPointAndRadius( vec3_t pt, float radius )
 	return CULL_IN;		// completely inside frustum
 }
 
+int R_DistanceCullLocalPointAndRadius(float fDist, const vec3_t pt, float radius) {
+	vec3_t transformed;
+
+	R_LocalPointToWorld(pt, transformed);
+
+	return R_DistanceCullPointAndRadius(fDist, transformed, radius);
+}
+
+int R_DistanceCullPointAndRadius(float fDist, const vec3_t pt, float radius) {
+	if (!r_nocull->integer)
+	{
+		vec3_t vDelta;
+		float fLengthSquared;
+		float fTotalDistSquared;
+
+		VectorSubtract(pt, tr.viewParms.ori.origin, vDelta);
+		fLengthSquared = VectorLengthSquared(vDelta);
+		fTotalDistSquared = (fDist + radius) * (fDist + radius);
+
+		if ((fDist + radius) * (fDist + radius) < vDelta[2] + fLengthSquared) {
+			return CULL_OUT;
+		} else if ((fDist - radius) * (fDist - radius) > vDelta[2] + fLengthSquared) {
+			return CULL_IN;
+		}
+	}
+
+	return CULL_CLIP;
+	// FIXME: unimplemented
+}
 
 /*
 =================
@@ -162,7 +196,7 @@ R_LocalNormalToWorld
 
 =================
 */
-void R_LocalNormalToWorld (vec3_t local, vec3_t world) {
+void R_LocalNormalToWorld (const vec3_t local, vec3_t world) {
 	world[0] = local[0] * tr.ori.axis[0][0] + local[1] * tr.ori.axis[1][0] + local[2] * tr.ori.axis[2][0];
 	world[1] = local[0] * tr.ori.axis[0][1] + local[1] * tr.ori.axis[1][1] + local[2] * tr.ori.axis[2][1];
 	world[2] = local[0] * tr.ori.axis[0][2] + local[1] * tr.ori.axis[1][2] + local[2] * tr.ori.axis[2][2];
@@ -174,7 +208,7 @@ R_LocalPointToWorld
 
 =================
 */
-void R_LocalPointToWorld (vec3_t local, vec3_t world) {
+void R_LocalPointToWorld (const vec3_t local, vec3_t world) {
 	world[0] = local[0] * tr.ori.axis[0][0] + local[1] * tr.ori.axis[1][0] + local[2] * tr.ori.axis[2][0] + tr.ori.origin[0];
 	world[1] = local[0] * tr.ori.axis[0][1] + local[1] * tr.ori.axis[1][1] + local[2] * tr.ori.axis[2][1] + tr.ori.origin[1];
 	world[2] = local[0] * tr.ori.axis[0][2] + local[1] * tr.ori.axis[1][2] + local[2] * tr.ori.axis[2][2] + tr.ori.origin[2];
@@ -581,6 +615,70 @@ void R_SetupFrustum (void) {
 		tr.viewParms.frustum[i].dist = DotProduct (tr.viewParms.ori.origin, tr.viewParms.frustum[i].normal);
 		SetPlaneSignbits( &tr.viewParms.frustum[i] );
 	}
+
+	if (tr.portalsky.inUse) {
+		tr.viewParms.farplane_distance = 0.0;
+	}
+	else if (r_farplane->integer)
+	{
+		tr.viewParms.farplane_distance = r_farplane->value;
+
+		sscanf(
+			r_farplane_color->string,
+			"%f %f %f",
+			&tr.viewParms.farplane_color[0],
+			&tr.viewParms.farplane_color[1],
+			&tr.viewParms.farplane_color[2]);
+
+		tr.viewParms.farplane_cull = !r_farplane_nocull->integer;
+	}
+
+	if (tr.viewParms.farplane_distance)
+	{
+		vec3_t farPoint;
+		float realPlaneLen;
+		float tmp;
+		vec4_t fogColor;
+
+		tr.viewParms.fog.len = tr.viewParms.farplane_distance;
+		tr.viewParms.fog.oolen = 1.0 / tr.viewParms.farplane_distance;
+
+		farPoint[0] = tr.viewParms.ori.origin[0] + tr.viewParms.ori.axis[0][0] * tr.viewParms.farplane_distance;
+		farPoint[1] = tr.viewParms.ori.origin[1] + tr.viewParms.ori.axis[0][1] * tr.viewParms.farplane_distance;
+		farPoint[2] = tr.viewParms.ori.origin[2] + tr.viewParms.ori.axis[0][2] * tr.viewParms.farplane_distance;
+
+		VectorNegate(tr.viewParms.ori.axis[0], tr.viewParms.frustum[4].normal);
+		tr.viewParms.frustum[4].type = PLANE_NON_AXIAL;
+		tr.viewParms.frustum[4].dist = DotProduct(farPoint, tr.viewParms.frustum[4].normal);
+		SetPlaneSignbits(&tr.viewParms.frustum[4]);
+
+		tr.viewParms.fog.enabled = r_farplane_nofog->integer == 0;
+		tr.viewParms.fog.extrafrustums = tr.viewParms.farplane_cull;
+
+		if (!r_farplane_nofog->integer)
+		{
+			qglFogf(GL_FOG_END, tr.viewParms.farplane_distance);
+
+			fogColor[0] = tr.viewParms.farplane_color[0] * tr.identityLight;
+			fogColor[1] = tr.viewParms.farplane_color[1] * tr.identityLight;
+			fogColor[2] = tr.viewParms.farplane_color[2] * tr.identityLight;
+			fogColor[3] = 1.0;
+
+			GL_SetFogColor(fogColor);
+			glState.externalSetState |= GLS_FOG;
+		}
+		else
+		{
+			glState.externalSetState &= ~GLS_FOG;
+		}
+	}
+	else
+	{
+		tr.viewParms.fog.enabled = 0;
+		tr.viewParms.fog.extrafrustums = 0;
+
+		glState.externalSetState &= ~GLS_FOG;
+	}
 }
 
 
@@ -837,27 +935,26 @@ static qboolean IsMirror( const drawSurf_t *drawSurf, int entityNum )
 **
 ** Determines if a surface is completely offscreen.
 */
-static qboolean SurfIsOffscreen( const drawSurf_t *drawSurf, vec4_t clipDest[128] ) {
+qboolean SurfIsOffscreen(const srfSurfaceFace_t* surface, shader_t* shader, int entityNum) {
 	float shortest = 100000000;
-	int entityNum;
 	int numTriangles;
-	shader_t *shader;
-	int dlighted;
-	qboolean bStaticModel;
+	qboolean doRange;
+	orientationr_t surfOr;
+	unsigned int* indices;
 	vec4_t clip, eye;
 	int i;
 	unsigned int pointOr = 0;
 	unsigned int pointAnd = (unsigned int)~0;
-
+	
 	if ( glConfig.smpActive ) {		// FIXME!  we can't do RB_BeginSurface/RB_EndSurface stuff with smp!
 		return qfalse;
 	}
 
-	R_RotateForViewer();
-
-	R_DecomposeSort( drawSurf->sort, &entityNum, &shader, &dlighted, &bStaticModel );
-	RB_BeginSurface( shader );
-	rb_surfaceTable[ *drawSurf->surface ]( drawSurf->surface );
+	if (entityNum == ENTITYNUM_WORLD) {
+		surfOr = tr.viewParms.world;
+	} else {
+		R_RotateForEntity(&tr.refdef.entities[entityNum], &tr.viewParms, &surfOr);
+	}
 
 	assert( tess.numVertexes < 128 );
 
@@ -920,21 +1017,27 @@ static qboolean SurfIsOffscreen( const drawSurf_t *drawSurf, vec4_t clipDest[128
 		return qtrue;
 	}
 
-	// mirrors can early out at this point, since we don't do a fade over distance
-	// with them (although we could)
-	if ( IsMirror( drawSurf, entityNum ) )
+	if (shader->fDistRange > 0.0)
 	{
-		return qfalse;
-	}
-
-	if ( shortest > (tess.shader->portalRange*tess.shader->portalRange) )
-	{
-		return qtrue;
+		if (shortest > (tess.shader->portalRange * tess.shader->portalRange))
+		{
+			return qtrue;
+		}
 	}
 
 	return qfalse;
 }
 
+static qboolean DrawSurfIsOffscreen(drawSurf_t* drawSurf) {
+	int entityNum;
+	shader_t* shader;
+	int dlighted;
+	qboolean bStaticModel;
+
+	R_DecomposeSort(drawSurf->sort, &entityNum, &shader, &dlighted, &bStaticModel);
+	return SurfIsOffscreen((srfSurfaceFace_t*)drawSurf->surface, shader, entityNum);
+}
+
 /*
 ========================
 R_MirrorViewBySurface
@@ -943,7 +1046,6 @@ Returns qtrue if another view has been rendered
 ========================
 */
 qboolean R_MirrorViewBySurface (drawSurf_t *drawSurf, int entityNum) {
-	vec4_t			clipDest[128];
 	viewParms_t		newParms;
 	viewParms_t		oldParms;
 	orientation_t	surface, camera;
@@ -959,7 +1061,7 @@ qboolean R_MirrorViewBySurface (drawSurf_t *drawSurf, int entityNum) {
 	}
 
 	// trivially reject portal/mirror
-	if ( SurfIsOffscreen( drawSurf, clipDest ) ) {
+	if (DrawSurfIsOffscreen( drawSurf ) ) {
 		return qfalse;
 	}
 
@@ -1602,6 +1704,8 @@ void R_RenderView (viewParms_t *parms) {
 
 	R_SetupFrustum ();
 
+	R_Sky_Reset();
+
 	R_GenerateDrawSurfs();
 
 	R_SortDrawSurfs( tr.refdef.drawSurfs + firstDrawSurf, tr.refdef.numDrawSurfs - firstDrawSurf );

code/renderer/tr_marks.c

@@ -158,8 +158,7 @@ void R_BoxSurfaces_r(mnode_t *node, vec3_t mins, vec3_t maxs, surfaceType_t **li
 		//
 		surf = *mark;
 		// check if the surface has NOIMPACT or NOMARKS set
-		if ( ( surf->shader->surfaceFlags & ( SURF_NOIMPACT | SURF_NOMARKS ) )
-			|| ( surf->shader->contentFlags & CONTENTS_FOG ) ) {
+		if ( ( surf->shader->surfaceFlags & ( SURF_NOIMPACT | SURF_NOMARKS ) ) ) {
 			surf->viewCount = tr.viewCount;
 		}
 		// extra check for surfaces to avoid list overflows
@@ -244,6 +243,38 @@ void R_AddMarkFragments(int numClipPoints, vec3_t clipPoints[2][MAX_VERTS_ON_POL
 	(*returnedFragments)++;
 }
 
+void R_AddMarkFragmentsToTerrain(
+	cTerraPatchUnpacked_t* pTerPatch,
+	int numPlanes,
+	vec3_t* normals,
+	float* dists,
+	int maxPoints,
+	const vec3_t pointBuffer,
+	markFragment_t* fragmentBuffer,
+	int* returnedPoints,
+	int* returnedFragments
+)
+{
+	// FIXME: unimplemented
+}
+
+void R_TessellateMarkFragments(
+	int* pReturnedPoints,
+	int* pReturnedFragments,
+	int numsurfaces, surfaceType_t** surfaces,
+	const vec3_t projectionDir, int numPlanes,
+	vec3_t* normals,
+	float* dists,
+	int maxPoints,
+	const vec3_t pointBuffer,
+	int maxFragments,
+	markFragment_t* fragmentBuffer,
+	float fRadiusSquared
+)
+{
+	// FIXME: unimplemented
+}
+
 /*
 =================
 R_MarkFragments
@@ -441,6 +472,11 @@ int R_MarkFragments( int numPoints, const vec3_t *points, const vec3_t projectio
 	return returnedFragments;
 }
 
+void R_BoxSurfacesForBModel_r(bmodel_t* pBmodel, const vec3_t mins, const vec3_t maxs, surfaceType_t** list, int listsize, int* listlength, const vec3_t dir)
+{
+	// FIXME: unimplemented
+}
+
 int R_MarkFragmentsForInlineModel(clipHandle_t bmodel, const vec3_t angles, const vec3_t origin, int numPoints,
 	const vec3_t* points, const vec3_t projection, int maxPoints, vec3_t pointBuffer,
 	int maxFragments, markFragment_t* fragmentBuffer, float radiusSquared)

code/renderer/tr_marks_permanent.c

@@ -24,22 +24,325 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 
 #include "tr_local.h"
 
+typedef struct lmEditPoly_s {
+	srfMarkFragment_t surf;
+	shader_t* shader;
+	int viewCount;
+	polyVert_t verts[8];
+	mnode_t* pLeafs[8];
+	int iNumLeafs;
+} lmEditPoly_t;
+
+typedef struct lmEditMarkDef_s {
+	struct lmEditMarkDef_s* pNextMark;
+	struct lmEditMarkDef_s* pPrevMark;
+	shader_t* markShader;
+	vec3_t vPos;
+	vec3_t vProjection;
+	float fRadius;
+	float fHeightScale;
+	float fWidthScale;
+	float fRotation;
+	float color[4];
+	qboolean bDoLighting;
+	lmEditPoly_t* pMarkEditPolys;
+	int iNumEditPolys;
+	vec3_t vPathCorners[4];
+} lmEditMarkDef_t;
+
+typedef struct lmPoly_s {
+	srfMarkFragment_t surf;
+	shader_t* shader;
+	int viewCount;
+} lmPoly_t;
+
+typedef struct {
+	qboolean bLevelMarksLoaded;
+	char szDCLFilename[MAX_QPATH];
+	lmPoly_t* pMarkFragments;
+	qboolean bAutoApplySettings;
+	lmEditPoly_t* pFreeEditPolys;
+	lmEditMarkDef_t activeMarkDefs;
+	lmEditMarkDef_t* pFreeMarkDefs;
+	lmEditMarkDef_t* pCurrentMark;
+	qboolean bPathLayingMode;
+	treadMark_t treadMark;
+	lmEditMarkDef_t* pTreadMarkStartDecal;
+	lmEditMarkDef_t* pTreadMarkEndDecal;
+} lmGlobals_t;
+
+typedef struct {
+  int ident;
+  int version;
+  int checksum;
+  int iNumDecals;
+  int iNumFragments;
+} dclHeader_t;
+
+typedef struct {
+  char shader[MAX_RES_NAME];
+  vec3_t vPos;
+  vec3_t vProjection;
+  float fRadius;
+  float fHeightScale;
+  float fWidthScale;
+  float fRotation;
+  float color[4];
+  qboolean bDoLighting;
+} dclSavedMarkDef_t;
+
+typedef struct {
+  char shader[MAX_RES_NAME];
+  int fogIndex;
+  int iIndex;
+  int iNumVerts;
+} dclSavedMarkPoly_t;
+
+cvar_t* dcl_editmode;
+cvar_t* dcl_showcurrent;
+cvar_t* dcl_autogetinfo;
+cvar_t* dcl_shiftstep;
+cvar_t* dcl_shader;
+cvar_t* dcl_radius;
+cvar_t* dcl_heightscale;
+cvar_t* dcl_widthscale;
+cvar_t* dcl_rotation;
+cvar_t* dcl_r;
+cvar_t* dcl_g;
+cvar_t* dcl_b;
+cvar_t* dcl_alpha;
+cvar_t* dcl_dolighting;
+cvar_t* dcl_doworld;
+cvar_t* dcl_doterrain;
+cvar_t* dcl_dobmodels;
+cvar_t* dcl_dostring;
+cvar_t* dcl_pathmode;
+cvar_t* dcl_maxsegment;
+cvar_t* dcl_minsegment;
+cvar_t* dcl_maxoffset;
+cvar_t* dcl_texturescale;
+lmGlobals_t lm;
+vec3_t vec_upwards;
+
+void DCLC_Save(void)
+{
+	// FIXME: unimplemented
+}
+
 void R_LevelMarksLoad(const char* szBSPName)
 {
     // FIXME: unimplemented
 }
 
+void R_RemoveEditPolyFromPointerList(lmEditPoly_t* pPoly, void** pFragmentList, int* piNumFragments)
+{
+	// FIXME: unimplemented
+}
+
+void R_FreeMarkFragments(lmEditMarkDef_t* pMark)
+{
+	// FIXME: unimplemented
+}
+
+void R_InitMarkDef(lmEditMarkDef_t* pMark)
+{
+	// FIXME: unimplemented
+}
+
+lmEditMarkDef_t* R_AllocateMarkDef(void)
+{
+	// FIXME: unimplemented
+	return NULL;
+}
+
+lmEditPoly_t* R_AllocateEditPoly(void)
+{
+	// FIXME: unimplemented
+	return NULL;
+}
+
+qboolean R_AddEditPolyToPointerList(lmEditPoly_t* pPoly, void*** pFragmentList, int* piNumFragments)
+{
+	// FIXME: unimplemented
+	return qfalse;
+}
+
+lmEditMarkDef_t* R_ApplyLevelDecal(const vec3_t vPos, const vec3_t vDir, qboolean bUseCurrent, qboolean bUseCurrentSettings, int iPathIndex)
+{
+	// FIXME: unimplemented
+	return NULL;
+}
+
+void DCLC_Make(void)
+{
+	// FIXME: unimplemented
+}
+
+void DCLC_Reapply(void)
+{
+	// FIXME: unimplemented
+}
+
+void DCLC_Delete(void)
+{
+	// FIXME: unimplemented
+}
+
+void DCLC_SelectNext(void)
+{
+	// FIXME: unimplemented
+}
+
+void DCLC_SelectPrev(void)
+{
+	// FIXME: unimplemented
+}
+
+void DCLC_SelectCh(void)
+{
+	// FIXME: unimplemented
+}
+
+void DCLC_SelectChNxt(void)
+{
+	// FIXME: unimplemented
+}
+
+void DCLC_GetInfo(void)
+{
+	// FIXME: unimplemented
+}
+
+void DCLC_ShiftUp(void)
+{
+	// FIXME: unimplemented
+}
+
+void DCLC_ShiftDown(void)
+{
+	// FIXME: unimplemented
+}
+
+void DCLC_ShiftLeft(void)
+{
+	// FIXME: unimplemented
+}
+
+void DCLC_ShiftRight(void)
+{
+	// FIXME: unimplemented
+}
+
+void DCLC_RandomRoll(void)
+{
+	// FIXME: unimplemented
+}
+
 void R_LevelMarksInit()
 {
-    // FIXME: unimplemented
+	memset(&lm, 0, sizeof(lm));
+
+	dcl_editmode = ri.Cvar_Get("dcl_editmode", "0", CVAR_LATCH);
+	dcl_showcurrent = ri.Cvar_Get("dcl_showcurrent", "1", 0);
+	dcl_autogetinfo = ri.Cvar_Get("dcl_autogetinfo", "1", 0);
+	dcl_shiftstep = ri.Cvar_Get("dcl_shiftstep", "4", 0);
+	dcl_shader = ri.Cvar_Get("dcl_shader", "blastmark", 0);
+	dcl_radius = ri.Cvar_Get("dcl_radius", "16", 0);
+	dcl_heightscale = ri.Cvar_Get("dcl_heightscale", "1", 0);
+	dcl_widthscale = ri.Cvar_Get("dcl_widthscale", "1", 0);
+	dcl_rotation = ri.Cvar_Get("dcl_rotation", "0", 0);
+	dcl_r = ri.Cvar_Get("dcl_r", "1", 0);
+	dcl_g = ri.Cvar_Get("dcl_g", "1", 0);
+	dcl_b = ri.Cvar_Get("dcl_b", "1", 0);
+	dcl_alpha = ri.Cvar_Get("dcl_alpha", "1", 0);
+	dcl_dolighting = ri.Cvar_Get("dcl_dolighting", "1", 0);
+	dcl_doworld = ri.Cvar_Get("dcl_doworld", "1", 0);
+	dcl_doterrain = ri.Cvar_Get("dcl_doterrain", "1", 0);
+	dcl_dobmodels = ri.Cvar_Get("dcl_dobmodels", "1", 0);
+	dcl_dostring = ri.Cvar_Get("dcl_dostring", "apply to all", 0);
+	dcl_pathmode = ri.Cvar_Get("dcl_pathmode", "0", 0);
+	dcl_maxsegment = ri.Cvar_Get("dcl_maxsegment", "512", 0);
+	dcl_minsegment = ri.Cvar_Get("dcl_minsegment", "24", 0);
+	dcl_maxoffset = ri.Cvar_Get("dcl_maxoffset", "10", 0);
+	dcl_texturescale = ri.Cvar_Get("dcl_texturescale", "32", 0);
+
+	if (dcl_editmode->integer)
+	{
+		ri.Cmd_AddCommand("dclc_make", DCLC_Make);
+		ri.Cmd_AddCommand("dclc_reapply", DCLC_Reapply);
+		ri.Cmd_AddCommand("dclc_delete", DCLC_Delete);
+		ri.Cmd_AddCommand("dclc_selectnext", DCLC_SelectNext);
+		ri.Cmd_AddCommand("dclc_selectprev", DCLC_SelectPrev);
+		ri.Cmd_AddCommand("dclc_selectch", DCLC_SelectCh);
+		ri.Cmd_AddCommand("dclc_selectchnxt", DCLC_SelectChNxt);
+		ri.Cmd_AddCommand("dclc_getinfo", DCLC_GetInfo);
+		ri.Cmd_AddCommand("dclc_shiftup", DCLC_ShiftUp);
+		ri.Cmd_AddCommand("dclc_shiftdown", DCLC_ShiftDown);
+		ri.Cmd_AddCommand("dclc_shiftleft", DCLC_ShiftLeft);
+		ri.Cmd_AddCommand("dclc_shiftright", DCLC_ShiftRight);
+		ri.Cmd_AddCommand("dclc_randomroll", DCLC_RandomRoll);
+		ri.Cmd_AddCommand("dclc_save", DCLC_Save);
+
+		lm.activeMarkDefs.pNextMark = &lm.activeMarkDefs;
+		lm.activeMarkDefs.pPrevMark = &lm.activeMarkDefs;
+	}
 }
 
 void R_LevelMarksFree()
 {
-    // FIXME: unimplemented
+	int i;
+
+	if (!dcl_editmode->integer) {
+		return;
+	}
+
+	ri.Cmd_RemoveCommand("dclc_make");
+	ri.Cmd_RemoveCommand("dclc_reapply");
+	ri.Cmd_RemoveCommand("dclc_delete");
+	ri.Cmd_RemoveCommand("dclc_selectnext");
+	ri.Cmd_RemoveCommand("dclc_selectprev");
+	ri.Cmd_RemoveCommand("dclc_selectch");
+	ri.Cmd_RemoveCommand("dclc_selectchnxt");
+	ri.Cmd_RemoveCommand("dclc_getinfo");
+	ri.Cmd_RemoveCommand("dclc_shiftup");
+	ri.Cmd_RemoveCommand("dclc_shiftdown");
+	ri.Cmd_RemoveCommand("dclc_shiftleft");
+	ri.Cmd_RemoveCommand("dclc_shiftright");
+	ri.Cmd_RemoveCommand("dclc_randomroll");
+	ri.Cmd_RemoveCommand("dclc_save");
+
+	for (i = 0; i < tr.world->numBmodels; i++)
+	{
+		bmodel_t* pBmodel = &tr.world->bmodels[i];
+		if (pBmodel->iNumMarkFragment && pBmodel->pFirstMarkFragment)
+		{
+			ri.Free(pBmodel->pFirstMarkFragment);
+			pBmodel->pFirstMarkFragment = NULL;
+			pBmodel->iNumMarkFragment = 0;
+		}
+	}
+
+	for (i = tr.world->numDecisionNodes; i < tr.world->numnodes; i++)
+	{
+		mnode_t* pLeaf = &tr.world->nodes[i];
+
+		if (pLeaf->iNumMarkFragment)
+		{
+			if (pLeaf->pFirstMarkFragment)
+			{
+				ri.Free(pLeaf->pFirstMarkFragment);
+				pLeaf->pFirstMarkFragment = NULL;
+				pLeaf->iNumMarkFragment = 0;
+			}
+		}
+	}
 }
 
 void R_UpdateLevelMarksSystem()
 {
     // FIXME: unimplemented
 }
+
+void R_AddPermanentMarkFragmentSurfaces(void** pFirstMarkFragment, int iNumMarkFragment) {
+	// FIXME: unimplemented
+}

code/renderer/tr_model.cpp

@@ -28,6 +28,8 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 
 #define	LL(x) x=LittleLong(x)
 
+qboolean g_bInfoworldtris;
+
 /*
 ** R_GetModelByHandle
 */

code/renderer/tr_scene.c

@@ -32,6 +32,12 @@ int			r_firstSceneDlight;
 int			r_numentities;
 int			r_firstSceneEntity;
 
+int			r_numsprites;
+int			r_firstSceneSprite;
+
+int			r_numtermarks;
+int			r_firstSceneTerMark;
+
 int			r_numpolys;
 int			r_firstScenePoly;
 
@@ -63,6 +69,12 @@ void R_ToggleSmpFrame( void ) {
 	r_numentities = 0;
 	r_firstSceneEntity = 0;
 
+	r_numsprites = 0;
+	r_firstSceneSprite = 0;
+
+	r_numtermarks = 0;
+	r_firstSceneTerMark = 0;
+
 	r_numpolys = 0;
 	r_firstScenePoly = 0;
 
@@ -79,6 +91,8 @@ RE_ClearScene
 void RE_ClearScene( void ) {
 	r_firstSceneDlight = r_numdlights;
 	r_firstSceneEntity = r_numentities;
+	r_firstSceneSprite = r_numsprites;
+	r_firstSceneTerMark = r_numtermarks;
 	r_firstScenePoly = r_numpolys;
 }
 
@@ -387,6 +401,14 @@ void RE_RenderScene( const refdef_t *fd ) {
 		}
 	}
 
+	// copy the sky data
+	tr.refdef.sky_alpha = fd->sky_alpha;
+	tr.refdef.sky_portal = fd->sky_portal;
+
+	VectorCopy(fd->sky_origin, tr.refdef.sky_origin);
+	VectorCopy(fd->sky_axis[0], tr.refdef.sky_axis[0]);
+	VectorCopy(fd->sky_axis[1], tr.refdef.sky_axis[1]);
+	VectorCopy(fd->sky_axis[2], tr.refdef.sky_axis[2]);
 
 	// derived info
 
@@ -398,12 +420,20 @@ void RE_RenderScene( const refdef_t *fd ) {
 	tr.refdef.num_entities = r_numentities - r_firstSceneEntity;
 	tr.refdef.entities = &backEndData[tr.smpFrame]->entities[r_firstSceneEntity];
 
+	tr.refdef.num_sprites = r_numsprites - r_firstSceneSprite;
+	tr.refdef.sprites = &backEndData[tr.smpFrame]->sprites[r_firstSceneSprite];
+
 	tr.refdef.num_dlights = r_numdlights - r_firstSceneDlight;
 	tr.refdef.dlights = &backEndData[tr.smpFrame]->dlights[r_firstSceneDlight];
 
+	tr.refdef.numTerMarks = r_numtermarks - r_firstSceneTerMark;
+	tr.refdef.terMarks = &backEndData[tr.smpFrame]->terMarks[r_firstSceneTerMark];
+
 	tr.refdef.numPolys = r_numpolys - r_firstScenePoly;
 	tr.refdef.polys = &backEndData[tr.smpFrame]->polys[r_firstScenePoly];
 
+	backEndData[tr.smpFrame]->staticModelData = tr.refdef.staticModelData;
+
 	// turn off dynamic lighting globally by clearing all the
 	// dlights if it needs to be disabled or if vertex lighting is enabled
 	if (r_vertexLight->integer == 1 ) {
@@ -424,6 +454,8 @@ void RE_RenderScene( const refdef_t *fd ) {
 	// The refdef takes 0-at-the-top y coordinates, so
 	// convert to GL's 0-at-the-bottom space
 	//
+	tr.skyRendered = qfalse;
+	tr.portalRendered = qfalse;
 	Com_Memset( &parms, 0, sizeof( parms ) );
 	parms.viewportX = tr.refdef.x;
 	parms.viewportY = glConfig.vidHeight - ( tr.refdef.y + tr.refdef.height );
@@ -441,12 +473,22 @@ void RE_RenderScene( const refdef_t *fd ) {
 
 	VectorCopy( fd->vieworg, parms.pvsOrigin );
 
+	// copy the farplane data
+	parms.farplane_distance = fd->farplane_distance;
+	parms.farplane_color[0] = fd->farplane_color[0];
+	parms.farplane_color[1] = fd->farplane_color[1];
+	parms.farplane_color[2] = fd->farplane_color[2];
+	parms.farplane_cull = fd->farplane_cull;
+
+	R_ClearRealDlights();
 	R_RenderView( &parms );
 
 	// the next scene rendered in this frame will tack on after this one
 	r_firstSceneDrawSurf = tr.refdef.numDrawSurfs;
 	r_firstSceneEntity = r_numentities;
+	r_firstSceneSprite = r_numsprites;
 	r_firstSceneDlight = r_numdlights;
+	r_firstSceneTerMark = r_numtermarks;
 	r_firstScenePoly = r_numpolys;
 
 	tr.frontEndMsec += ri.Milliseconds() - startTime;

code/renderer/tr_shade.c

@@ -361,23 +361,23 @@ static void DrawMultitextured( shaderCommands_t *input, int stage ) {
 
 		if (pStage->multitextureEnv == GL_ADD)
 		{
-			qglTexEnvf(8960, 34161, 260.0);
-			qglTexEnvf(8960, 34176, 33984.0);
-			qglTexEnvf(8960, 34192, 1145044992);
-			qglTexEnvf(8960, 34177, 0);
-			qglTexEnvf(8960, 34193, 1145061376);
-			qglTexEnvf(8960, 34178, 33985.0);
-			qglTexEnvf(8960, 34194, 1145044992);
-			qglTexEnvf(8960, 34179, 0);
-			qglTexEnvf(8960, 34195, 1145061376);
+			qglTexEnvf(GL_TEXTURE_ENV, GL_COMBINE_RGB, 260.0);
+			qglTexEnvf(GL_TEXTURE_ENV, GL_SOURCE0_RGB, 33984.0);
+			qglTexEnvf(GL_TEXTURE_ENV, GL_OPERAND0_RGB, 0x44400000);
+			qglTexEnvf(GL_TEXTURE_ENV, GL_SOURCE1_RGB, 0);
+			qglTexEnvf(GL_TEXTURE_ENV, GL_OPERAND1_RGB, 33985.0);
+			qglTexEnvf(GL_TEXTURE_ENV, GL_SOURCE2_RGB, 0x44400000);
+			qglTexEnvf(GL_TEXTURE_ENV, GL_OPERAND2_RGB, 0x44400000);
+			qglTexEnvf(GL_TEXTURE_ENV, GL_SOURCE3_RGB, 0);
+			qglTexEnvf(GL_TEXTURE_ENV, GL_OPERAND3_RGB, 0x44404000);
 		}
 		else if (pStage->multitextureEnv == GL_MODULATE)
 		{
-			qglTexEnvf(8960, 34161, 8448.0);
-			qglTexEnvf(8960, 34176, 33984.0);
-			qglTexEnvf(8960, 34192, 1145044992);
-			qglTexEnvf(8960, 34177, 33985.0);
-			qglTexEnvf(8960, 34193, 1145044992);
+			qglTexEnvf(GL_TEXTURE_ENV, GL_COMBINE_RGB, GL_MODULATE);
+			qglTexEnvf(GL_TEXTURE_ENV, GL_SOURCE0_RGB, 33984.0);
+			qglTexEnvf(GL_TEXTURE_ENV, GL_OPERAND0_RGB, 0x44400000);
+			qglTexEnvf(GL_TEXTURE_ENV, GL_SOURCE1_RGB, 33985.0);
+			qglTexEnvf(GL_TEXTURE_ENV, GL_OPERAND1_RGB, 0x44400000);
 		}
 		else
 		{
@@ -398,13 +398,13 @@ static void DrawMultitextured( shaderCommands_t *input, int stage ) {
 		glState.cntTexEnvExt = GLS_MULTITEXTURE_ENV;
 
 		GL_TexEnv(GL_COMBINE);
-		qglTexEnvf(GL_TEXTURE_ENV, 34161, 34165.0);
-		qglTexEnvf(GL_TEXTURE_ENV, 34176, 0x47057700);
-		qglTexEnvf(GL_TEXTURE_ENV, 34192, 0x44400000);
-		qglTexEnvf(GL_TEXTURE_ENV, 34177, 34168.0);
-		qglTexEnvf(GL_TEXTURE_ENV, 34193, 0x44400000);
-		qglTexEnvf(GL_TEXTURE_ENV, 34178, 0x47057700);
-		qglTexEnvf(GL_TEXTURE_ENV, 34194, 770.0);
+		qglTexEnvf(GL_TEXTURE_ENV, GL_COMBINE_RGB, 34165);
+		qglTexEnvf(GL_TEXTURE_ENV, GL_SOURCE0_RGB, 0x47057700);
+		qglTexEnvf(GL_TEXTURE_ENV, GL_OPERAND0_RGB, 0x44400000);
+		qglTexEnvf(GL_TEXTURE_ENV, GL_SOURCE1_RGB, 34168);
+		qglTexEnvf(GL_TEXTURE_ENV, GL_OPERAND1_RGB, 0x44400000);
+		qglTexEnvf(GL_TEXTURE_ENV, GL_SOURCE2_RGB, 0x47057700);
+		qglTexEnvf(GL_TEXTURE_ENV, GL_OPERAND2_RGB, 0x44407700000);
 	} else {
 		GL_TexEnv( pStage->multitextureEnv );
 	}
@@ -1094,54 +1094,64 @@ static void RB_IterateStagesGeneric( shaderCommands_t *input )
 {
 	int stage;
 
-	for ( stage = 0; stage < MAX_SHADER_STAGES; stage++ )
+	for (stage = 0; stage < MAX_SHADER_STAGES; stage++)
 	{
-		shaderStage_t *pStage = tess.xstages[stage];
+		shaderStage_t* pStage = tess.xstages[stage];
 
-		if ( !pStage )
+		if (!pStage)
 		{
 			break;
 		}
 
-		ComputeColors( pStage );
-		ComputeTexCoords( pStage );
+		if (pStage->alphaGen == AGEN_SKYALPHA && tr.refdef.sky_alpha < 0.01) {
+			continue;
+		}
+		else if (pStage->alphaGen == AGEN_ONE_MINUS_SKYALPHA && tr.refdef.sky_alpha > 0.99) {
+			continue;
+		}
 
-		if ( !setArraysOnce )
+		ComputeTexCoords(pStage);
+		ComputeColors(pStage);
+
+		if (!setArraysOnce)
 		{
-			qglEnableClientState( GL_COLOR_ARRAY );
-			qglColorPointer( 4, GL_UNSIGNED_BYTE, 0, input->svars.colors );
+			qglEnableClientState(GL_COLOR_ARRAY);
+			qglColorPointer(4, GL_UNSIGNED_BYTE, 0, input->svars.colors);
 		}
 
 		//
 		// do multitexture
 		//
-		if ( pStage->bundle[1].image[0] != 0 )
+		if (pStage->bundle[1].image[0] != 0)
 		{
-			DrawMultitextured( input, stage );
+			DrawMultitextured(input, stage);
 		}
 		else
 		{
 			if (backEnd.in2D) {
 				GL_State(pStage->stateBits | GLS_DEPTHTEST_DISABLE);
-			} else {
+			}
+			else {
 				GL_State(pStage->stateBits);
 			}
 
-			if ( !setArraysOnce )
+			if (!setArraysOnce)
 			{
-				qglTexCoordPointer( 2, GL_FLOAT, 0, input->svars.texcoords[0] );
+				qglTexCoordPointer(2, GL_FLOAT, 0, input->svars.texcoords[0]);
 			}
 
 			//
 			// set state
 			//
-			if ( pStage->bundle[0].vertexLightmap && r_vertexLight->integer && r_lightmap->integer )
+			if (pStage->bundle[0].vertexLightmap && r_vertexLight->integer && r_lightmap->integer)
 			{
-				GL_Bind( tr.whiteImage );
-			} else {
+				GL_Bind(tr.whiteImage);
+			}
+			else {
 				if (input->dlightMap && tess.xstages[stage]->bundle[0].isLightmap) {
 					GL_Bind(&tr.identityLightImage[input->dlightMap]);
-				} else {
+				}
+				else {
 					R_BindAnimatedImage(&pStage->bundle[0]);
 				}
 			}
@@ -1149,10 +1159,10 @@ static void RB_IterateStagesGeneric( shaderCommands_t *input )
 			//
 			// draw
 			//
-			R_DrawElements( input->numIndexes, input->indexes );
+			R_DrawElements(input->numIndexes, input->indexes);
 		}
 		// allow skipping out to show just lightmaps during development
-		if ( r_lightmap->integer && ( pStage->bundle[0].isLightmap || pStage->bundle[1].isLightmap || pStage->bundle[0].vertexLightmap ) )
+		if (r_lightmap->integer && (pStage->bundle[0].isLightmap || pStage->bundle[1].isLightmap || pStage->bundle[0].vertexLightmap))
 		{
 			break;
 		}
@@ -1465,7 +1475,6 @@ void RB_EndSurface( void ) {
 	if (input->numIndexes == 0) {
 		return;
 	}
-
 	if (input->indexes[SHADER_MAX_INDEXES-1] != 0) {
 		ri.Error (ERR_DROP, "RB_EndSurface() - SHADER_MAX_INDEXES hit");
 	}	
@@ -1473,8 +1482,12 @@ void RB_EndSurface( void ) {
 		ri.Error (ERR_DROP, "RB_EndSurface() - SHADER_MAX_VERTEXES hit");
 	}
 
+	if (tess.xyz[SHADER_MAX_VERTEXES - 1][0] && r_shadows->integer != 3) {
+		tess.xyz[SHADER_MAX_VERTEXES - 1][0] = 0;
+	}
+
 	if ( tess.shader == tr.shadowShader ) {
-		RB_ShadowTessEnd();
+		RB_ComputeShadowVolume();
 		return;
 	}
 
@@ -1496,15 +1509,19 @@ void RB_EndSurface( void ) {
 	//
 	tess.currentStageIteratorFunc();
 
-	//
-	// draw debugging stuff
-	//
-	if ( r_showtris->integer ) {
-		DrawTris (input);
-	}
-	if ( r_shownormals->integer ) {
-		DrawNormals (input);
+	if (!(tr.refdef.rdflags & RDF_NOWORLDMODEL) && !backEnd.in2D)
+	{
+		//
+		// draw debugging stuff
+		//
+		if (r_showtris->integer && developer->integer) {
+			DrawTris(input);
+		}
+		if (r_shownormals->integer && developer->integer) {
+			DrawNormals(input);
+		}
 	}
+
 	// clear shader so we can tell we don't have any unclosed surfaces
 	tess.numIndexes = 0;
 

code/renderer/tr_shade_calc.c

@@ -792,65 +792,6 @@ void RB_CalcWaveAlpha( const waveForm_t *wf, unsigned char *dstColors )
 	}
 }
 
-/*
-** RB_CalcModulateColorsByFog
-*/
-void RB_CalcModulateColorsByFog( unsigned char *colors ) {
-	int		i;
-	float	texCoords[SHADER_MAX_VERTEXES][2];
-
-	// calculate texcoords so we can derive density
-	// this is not wasted, because it would only have
-	// been previously called if the surface was opaque
-	RB_CalcFogTexCoords( texCoords[0] );
-
-	for ( i = 0; i < tess.numVertexes; i++, colors += 4 ) {
-		float f = 1.0 - R_FogFactor( texCoords[i][0], texCoords[i][1] );
-		colors[0] *= f;
-		colors[1] *= f;
-		colors[2] *= f;
-	}
-}
-
-/*
-** RB_CalcModulateAlphasByFog
-*/
-void RB_CalcModulateAlphasByFog( unsigned char *colors ) {
-	int		i;
-	float	texCoords[SHADER_MAX_VERTEXES][2];
-
-	// calculate texcoords so we can derive density
-	// this is not wasted, because it would only have
-	// been previously called if the surface was opaque
-	RB_CalcFogTexCoords( texCoords[0] );
-
-	for ( i = 0; i < tess.numVertexes; i++, colors += 4 ) {
-		float f = 1.0 - R_FogFactor( texCoords[i][0], texCoords[i][1] );
-		colors[3] *= f;
-	}
-}
-
-/*
-** RB_CalcModulateRGBAsByFog
-*/
-void RB_CalcModulateRGBAsByFog( unsigned char *colors ) {
-	int		i;
-	float	texCoords[SHADER_MAX_VERTEXES][2];
-
-	// calculate texcoords so we can derive density
-	// this is not wasted, because it would only have
-	// been previously called if the surface was opaque
-	RB_CalcFogTexCoords( texCoords[0] );
-
-	for ( i = 0; i < tess.numVertexes; i++, colors += 4 ) {
-		float f = 1.0 - R_FogFactor( texCoords[i][0], texCoords[i][1] );
-		colors[0] *= f;
-		colors[1] *= f;
-		colors[2] *= f;
-		colors[3] *= f;
-	}
-}
-
 
 /*
 ====================================================================

code/renderer/tr_shader.c

@@ -641,6 +641,8 @@ static qboolean ParseStage( shaderStage_t *stage, char **text )
 	int depthMaskBits = GLS_DEPTHMASK_TRUE, blendSrcBits = 0, blendDstBits = 0, atestBits = 0, depthFuncBits = 0;
 	qboolean depthMaskExplicit = qfalse;
 	int cntBundle = 0;
+	int depthTestBits = 0;
+	int fogBits = 0;
 
 	stage->active = qtrue;
 	stage->noMipMaps = shader_noMipMaps;
@@ -660,6 +662,24 @@ static qboolean ParseStage( shaderStage_t *stage, char **text )
 		{
 			break;
 		}
+		// no picmip adjustment
+		else if ( !Q_stricmp( token, "nomipmaps" ) )
+		{
+			stage->noMipMaps = qtrue;
+			continue;
+		}
+		// no picmip adjustment
+		else if ( !Q_stricmp( token, "nopicmip" ) )
+		{
+			stage->noPicMip = qtrue;
+			continue;
+		}
+		// no picmip adjustment
+		else if ( !Q_stricmp( token, "nofog" ) )
+		{
+			fogBits = GLS_FOG;
+			continue;
+		}
 		//
 		// map <name>
 		//
@@ -778,11 +798,11 @@ static qboolean ParseStage( shaderStage_t *stage, char **text )
 
 			if ( !Q_stricmp( token, "lequal" ) )
 			{
-				depthFuncBits = 0;
+				depthTestBits = 0;
 			}
 			else if ( !Q_stricmp( token, "equal" ) )
 			{
-				depthFuncBits = GLS_DEPTHFUNC_EQUAL;
+				depthTestBits = GLS_DEPTHFUNC_EQUAL;
 			}
 			else
 			{
@@ -1286,7 +1306,9 @@ static qboolean ParseStage( shaderStage_t *stage, char **text )
 	stage->stateBits = depthMaskBits | 
 		               blendSrcBits | blendDstBits | 
 					   atestBits | 
-					   depthFuncBits;
+					   depthFuncBits |
+					   depthTestBits |
+					   fogBits;
 
 	return qtrue;
 }
@@ -1611,8 +1633,11 @@ infoParm_t	infoParms[] = {
 	{"lava",		1,	0,	CONTENTS_LAVA },		// very damaging
 	{"playerclip",	1,	0,	CONTENTS_PLAYERCLIP },
 	{"monsterclip",	1,	0,	CONTENTS_MONSTERCLIP },
+	{"fence",		1,	0,	CONTENTS_FENCE },
+	{"weaponclip",	1,	0,	CONTENTS_WEAPONCLIP },
+	{"vehicleclip",	1,	0,	CONTENTS_VEHICLECLIP },
 	{"nodrop",		1,	0,	CONTENTS_NODROP },		// don't drop items or leave bodies (death fog, lava, etc)
-	{"nonsolid",	1,	SURF_NONSOLID,	0},						// clears the solid flag
+	{"nonsolid",	1,	SURF_NONSOLID,	0 },		// clears the solid flag
 
 	// utility relevant attributes
 	{"origin",		1,	0,	CONTENTS_ORIGIN },		// center of rotating brushes
@@ -1620,14 +1645,9 @@ infoParm_t	infoParms[] = {
 	{"detail",		0,	0,	CONTENTS_DETAIL },		// don't include in structural bsp
 	{"structural",	0,	0,	CONTENTS_STRUCTURAL },	// force into structural bsp even if trnas
 	{"areaportal",	1,	0,	CONTENTS_AREAPORTAL },	// divides areas
-	{"clusterportal", 1,0,  CONTENTS_CLUSTERPORTAL },	// for bots
-	{"donotenter",  1,  0,  CONTENTS_DONOTENTER },		// for bots
-
 	{"fog",			1,	0,	CONTENTS_FOG},			// carves surfaces entering
-	{"sky",			0,	SURF_SKY,		0 },		// emit light from an environment map
-	{"lightfilter",	0,	SURF_LIGHTFILTER, 0 },		// filter light going through it
-	{"alphashadow",	0,	SURF_ALPHASHADOW, 0 },		// test light on a per-pixel basis
-	{"hint",		0,	SURF_HINT,		0 },		// use as a primary splitter
+	{"sky",			0,	SURF_SKY,			0 },	// emit light from an environment map
+	{"alphashadow",	1,	SURF_ALPHASHADOW,	0 },	// carves surfaces entering
 
 	// server attributes
 	{"slick",		0,	SURF_SLICK,		0 },
@@ -1635,16 +1655,29 @@ infoParm_t	infoParms[] = {
 	{"nomarks",		0,	SURF_NOMARKS,	0 },		// don't make impact marks, but still explode
 	{"ladder",		0,	SURF_LADDER,	0 },
 	{"nodamage",	0,	SURF_NODAMAGE,	0 },
-	{"metalsteps",	0,	SURF_METALSTEPS,0 },
-	{"flesh",		0,	SURF_FLESH,		0 },
 	{"nosteps",		0,	SURF_NOSTEPS,	0 },
+	{"paper",		0,	SURF_PAPER,		0 },
+	{"wood",		0,	SURF_WOOD,		0 },
+	{"metal",		0,	SURF_METAL,		0 },
+	{"rock",		0,	SURF_ROCK,		0 },
+	{"dirt",		0,	SURF_DIRT,		0 },
+	{"grill",		0,	SURF_GRILL,		0 },
+	{"grass",		0,	SURF_GRASS,		0 },
+	{"mud",			0,	SURF_MUD,		0 },
+	{"puddle",		0,	SURF_PUDDLE,	0 },
+	{"glass",		0,	SURF_GLASS,		0 },
+	{"gravel",		0,	SURF_GRAVEL,	0 },
+	{"sand",		0,	SURF_SAND,		0 },
+	{"foliage",		0,	SURF_FOLIAGE,	0 },
+	{"snow",		0,	SURF_SNOW,		0 },
+	{"carpet",		0,	SURF_CARPET,	0 },
 
 	// drawsurf attributes
-	{"nodraw",		0,	SURF_NODRAW,	0 },	// don't generate a drawsurface (or a lightmap)
-	{"pointlight",	0,	SURF_POINTLIGHT, 0 },	// sample lighting at vertexes
-	{"nolightmap",	0,	SURF_NOLIGHTMAP,0 },	// don't generate a lightmap
-	{"nodlight",	0,	SURF_NODLIGHT, 0 },		// don't ever add dynamic lights
-	{"dust",		0,	SURF_DUST, 0}			// leave a dust trail when walking on this surface
+	{"nodraw",		0,	SURF_NODRAW,		0 },	// don't generate a drawsurface (or a lightmap)
+	{"castshadow",	0,	SURF_CASTSHADOW,	0 },	// sample lighting at vertexes
+	{"nolightmap",	0,	SURF_NOLIGHTMAP,	0 },	// don't generate a lightmap
+	{"nodlight",	0,	SURF_NODLIGHT,		0 },	// don't ever add dynamic lights
+	{"hint",		0,	SURF_HINT,		0}			// leave a dust trail when walking on this surface
 };
 
 
@@ -2309,12 +2342,6 @@ static shader_t *GeneratePermanentShader( void ) {
 	newShader->next = currentShader->shader;
 	currentShader->shader = newShader;
 
-	if ( shader.sort <= SS_OPAQUE ) {
-		newShader->fogPass = FP_EQUAL;
-	} else if ( shader.contentFlags & CONTENTS_FOG ) {
-		newShader->fogPass = FP_LE;
-	}
-
 	tr.shaders[ tr.numShaders ] = newShader;
 	newShader->index = tr.numShaders;
 	
@@ -2332,8 +2359,10 @@ static shader_t *GeneratePermanentShader( void ) {
 
 		for ( b = 0 ; b < NUM_TEXTURE_BUNDLES ; b++ ) {
 			size = newShader->unfoggedStages[i]->bundle[b].numTexMods * sizeof( texModInfo_t );
-			newShader->unfoggedStages[i]->bundle[b].texMods = ri.Hunk_Alloc( size );
-			Com_Memcpy( newShader->unfoggedStages[i]->bundle[b].texMods, unfoggedStages[i].bundle[b].texMods, size );
+			if (size) {
+				newShader->unfoggedStages[i]->bundle[b].texMods = ri.Hunk_Alloc(size);
+				Com_Memcpy(newShader->unfoggedStages[i]->bundle[b].texMods, unfoggedStages[i].bundle[b].texMods, size);
+			}
 		}
 	}
 
@@ -2443,9 +2472,9 @@ from the current global working shader
 */
 static shader_t *FinishShader( void ) {
 	int stage;
+	int i;
 	int bundle;
-	qboolean		hasLightmapStage;
-	qboolean		vertexLightmap;
+	qboolean hasLightmapStage;
 
 	if (!currentShader) {
 		currentShader = FindShaderText(shader.name);
@@ -2459,11 +2488,13 @@ static shader_t *FinishShader( void ) {
     }
 
 	hasLightmapStage = qfalse;
-	vertexLightmap = qfalse;
 
 	//
 	// set sky stuff appropriate
 	//
+	if ( shader.isPortalSky ) {
+		shader.sort = SS_PORTALSKY;
+	}
 	if ( shader.isSky ) {
 		shader.sort = SS_ENVIRONMENT;
 	}
@@ -2475,13 +2506,15 @@ static shader_t *FinishShader( void ) {
 		shader.sort = SS_DECAL;
 	}
 
+	shader.needsLGrid = qfalse;
+	shader.needsLSpherical = qfalse;
+
 	//
 	// set appropriate stage information
 	//
-	for ( stage = 0; stage < MAX_SHADER_STAGES; stage++ ) {
-		shaderStage_t *pStage = &unfoggedStages[stage];
-
-    // check for a missing texture
+	stage = 0;
+	for (shaderStage_t* pStage = &unfoggedStages[0]; pStage->active; pStage++, stage++) {
+		// check for a missing texture
 		if ( !pStage->bundle[0].image[0] ) {
 			ri.Printf( PRINT_WARNING, "Shader %s has a stage with no image\n", shader.name );
 			pStage->active = qfalse;
@@ -2511,19 +2544,13 @@ static shader_t *FinishShader( void ) {
 			}
 		}
 
-		// not a true lightmap but we want to leave existing 
-		// behaviour in place and not print out a warning
-		//if (pStage->rgbGen == CGEN_VERTEX) {
-		//  vertexLightmap = qtrue;
-		//}
-
 		if (pStage->multitextureEnv && pStage->bundle[0].isLightmap) {
 			//
 			// exchange bundle
 			//
-			textureBundle_t tmp = pStage->bundle[0];
+			textureBundle_t tmpBundle = pStage->bundle[0];
 			pStage->bundle[0] = pStage->bundle[1];
-			pStage->bundle[1] = tmp;
+			pStage->bundle[1] = tmpBundle;
 		}
 
 		//
@@ -2555,23 +2582,70 @@ static shader_t *FinishShader( void ) {
 	//
 	// if we are in r_vertexLight mode, never use a lightmap texture
 	//
-	if ( stage > 1 && r_vertexLight->integer ) {
-		VertexLightingCollapse();
-		stage = 1;
-		hasLightmapStage = qfalse;
+	if (stage > 1)
+	{
+		if (r_vertexLight->integer) {
+			VertexLightingCollapse();
+			stage = 1;
+			hasLightmapStage = qfalse;
+		}
+
+		//
+		// look for multitexture potential
+		//
+		if (qglActiveTextureARB) {
+			CollapseMultitexture(&stage);
+		};
 	}
 
-	//
-	// look for multitexture potential
-	//
-	if (stage > 1 && qglActiveTextureARB) {
-		CollapseMultitexture(&stage);
-	};
+	for (i = 0; i < stage; i++) {
+		int blendSrcBits, blendDstBits;
 
-	// FIXME: fog shader
+		shaderStage_t* pStage = &unfoggedStages[i];
+		if (pStage->stateBits & (GLS_SRCBLEND_BITS | GLS_DSTBLEND_BITS))
+		{
+			blendSrcBits = pStage->stateBits & GLS_SRCBLEND_BITS;
+			blendDstBits = pStage->stateBits & GLS_DSTBLEND_BITS;
+			if (blendSrcBits == GLS_SRCBLEND_ONE && blendDstBits == GLS_DSTBLEND_ONE
+				|| blendSrcBits == GLS_SRCBLEND_ZERO && blendDstBits == GLS_DSTBLEND_ONE_MINUS_SRC_COLOR
+				|| blendSrcBits == GLS_SRCBLEND_SRC_ALPHA && blendDstBits == GLS_DSTBLEND_ONE
+				|| blendSrcBits == GLS_SRCBLEND_DST_COLOR && blendDstBits == GLS_DSTBLEND_ONE
+				|| blendSrcBits == GLS_SRCBLEND_ONE_MINUS_DST_COLOR && blendDstBits == GLS_DSTBLEND_ONE)
+			{
+				pStage->stateBits |= GLS_FOG_ENABLED | GLS_FOG_BLACK;
+			}
+			else if (blendSrcBits == GLS_SRCBLEND_DST_COLOR && blendDstBits == GLS_DSTBLEND_ZERO
+					|| blendSrcBits == GLS_SRCBLEND_ZERO && blendDstBits == GLS_DSTBLEND_SRC_COLOR)
+			{
+				pStage->stateBits |= GLS_FOG_ENABLED | GLS_FOG_WHITE;
+			}
+			else if (blendSrcBits == GLS_SRCBLEND_SRC_ALPHA && blendDstBits == GLS_DSTBLEND_ONE_MINUS_SRC_ALPHA
+					|| blendSrcBits == GLS_SRCBLEND_ONE_MINUS_SRC_ALPHA && blendDstBits == GLS_DSTBLEND_SRC_ALPHA
+					|| blendSrcBits == GLS_SRCBLEND_SRC_ALPHA && blendDstBits == GLS_DSTBLEND_ONE)
+			{
+				pStage->stateBits |= GLS_FOG_ENABLED;
+			}
+			else {
+				ri.Printf(PRINT_WARNING, "Shader '%s' stage# %i is unfoggable\n", shader.name, i + 1);
+			}
+
+			if (shader.sort == SS_BAD)
+			{
+				if (pStage->stateBits & GLS_DEPTHMASK_TRUE) {
+					shader.sort = SS_SEE_THROUGH;
+				}
+				else {
+					shader.sort = SS_BLEND0;
+				}
+			}
+		}
+		else {
+			pStage->stateBits |= GLS_FOG_ENABLED;
+		}
+	}
 
 	// fogonly shaders don't have any normal passes
-	if (stage == 0) {
+	if (shader.sort == SS_BAD) {
 		shader.sort = SS_OPAQUE;
 	}
 
@@ -2586,9 +2660,11 @@ static shader_t *FinishShader( void ) {
 	shader.numUnfoggedPasses = 0;
 	for (stage = 0; stage < MAX_SHADER_STAGES; stage++) {
 		shaderStage_t* pStage = &unfoggedStages[stage];
-		if (pStage->active) {
-			shader.numUnfoggedPasses++;
+		if (!pStage->active) {
+			break;
 		}
+
+		shader.numUnfoggedPasses++;
 	}
 
 	// determine which stage iterator function is appropriate

code/renderer/tr_shadows.c

@@ -45,19 +45,6 @@ static	edgeDef_t	edgeDefs[SHADER_MAX_VERTEXES][MAX_EDGE_DEFS];
 static	int			numEdgeDefs[SHADER_MAX_VERTEXES];
 static	int			facing[SHADER_MAX_INDEXES/3];
 
-void R_AddEdgeDef( int i1, int i2, int facing ) {
-	int		c;
-
-	c = numEdgeDefs[ i1 ];
-	if ( c == MAX_EDGE_DEFS ) {
-		return;		// overflow
-	}
-	edgeDefs[ i1 ][ c ].i2 = i2;
-	edgeDefs[ i1 ][ c ].facing = facing;
-
-	numEdgeDefs[ i1 ]++;
-}
-
 void R_RenderShadowEdges( void ) {
 	int		i;
 
@@ -139,6 +126,19 @@ void R_RenderShadowEdges( void ) {
 #endif
 }
 
+void R_AddEdgeDef(int i1, int i2, int facing) {
+	int		c;
+
+	c = numEdgeDefs[i1];
+	if (c == MAX_EDGE_DEFS) {
+		return;		// overflow
+	}
+	edgeDefs[i1][c].i2 = i2;
+	edgeDefs[i1][c].facing = facing;
+
+	numEdgeDefs[i1]++;
+}
+
 /*
 =================
 RB_ShadowTessEnd
@@ -248,6 +248,9 @@ void RB_ShadowTessEnd( void ) {
 	qglColorMask( GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE );
 }
 
+void RB_ComputeShadowVolume() {
+	// FIXME: unimplemented
+}
 
 /*
 =================

code/renderer/tr_sky_portal.cpp

@@ -26,15 +26,129 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 
 void R_Sky_Init()
 {
-    // FIXME: unimplemented
+	tr.portalsky.inUse = qfalse;
+	tr.portalsky.numSurfs = 0;
 }
 
 void R_Sky_Reset()
 {
-    // FIXME: unimplemented
+    if (tr.portalsky.inUse) {
+        return;
+    }
+
+	tr.portalsky.mins[0] = 8192.0;
+	tr.portalsky.mins[1] = 8192.0;
+	tr.portalsky.mins[2] = 8192.0;
+	tr.portalsky.maxs[0] = -8192.0;
+	tr.portalsky.maxs[1] = -8192.0;
+	tr.portalsky.maxs[2] = -8192.0;
+	tr.portalsky.cntNode = 0;
+	tr.portalsky.numSurfs = 0;
 }
 
 void R_Sky_AddSurf(msurface_t* surf)
 {
-    // FIXME: unimplemented
+	if (tr.portalsky.inUse)
+	{
+		static int last_sky_warning = 0;
+
+		if (tr.refdef.time - 1000 > last_sky_warning)
+		{
+			ri.Printf(3, "WARNING: sky being drawn in a sky portal!  Bad!  Bad!\n");
+			last_sky_warning = tr.refdef.time;
+		}
+
+		return;
+	}
+
+	if (tr.portalsky.numSurfs < 32) {
+		tr.portalsky.skySurfs[tr.portalsky.numSurfs++] = surf;
+	}
+
+	if (tr.portalsky.cntNode)
+	{
+		int i;
+
+		for (i = 0; i < 3; i++) {
+			if (tr.portalsky.mins[i] >= tr.portalsky.cntNode->mins[i]) {
+				tr.portalsky.mins[i] = tr.portalsky.cntNode->mins[i];
+			}
+
+			if (tr.portalsky.maxs[i] >= tr.portalsky.cntNode->maxs[i]) {
+				tr.portalsky.maxs[i] = tr.portalsky.cntNode->maxs[i];
+			}
+		}
+	}
 }
+
+void R_Sky_Render() {
+    int i;
+    viewParms_t newParms, oldParms;
+    mnode_t* leaf;
+
+    if (!tr.portalsky.numSurfs) {
+        return;
+    }
+
+    if (!tr.refdef.sky_portal) {
+        return;
+    }
+
+    if (tr.skyRendered) {
+        // already rendered
+        return;
+    }
+
+	if (tr.portalsky.inUse)
+	{
+		ri.Printf(PRINT_WARNING, "WARNING: Recursive skies found!  Make that not happen!\n");
+		return;
+	}
+
+    for (i = 0; i < tr.portalsky.numSurfs; i++) {
+        if (!SurfIsOffscreen((const srfSurfaceFace_t*)tr.portalsky.skySurfs[i]->data, tr.portalsky.skySurfs[i]->shader, ENTITYNUM_WORLD)) {
+            break;
+        }
+    }
+
+    if (i == tr.portalsky.numSurfs) {
+        return;
+    }
+
+    tr.skyRendered = qtrue;
+    oldParms = tr.viewParms;
+    newParms = tr.viewParms;
+
+	if (r_skyportal->integer)
+	{
+		if (sscanf(r_skyportal_origin->string, "%f %f %f", &newParms.ori.origin[0], &newParms.ori.origin[1], &newParms.ori.origin[2]) != 3)
+		{
+			ri.Printf(PRINT_WARNING, "WARNING: Invalid sky portal origin: %s\n", r_skyportal_origin->string);
+			return;
+		}
+	}
+	else
+	{
+        VectorCopy(tr.refdef.sky_origin, newParms.ori.origin);
+		MatrixMultiply(newParms.ori.axis, tr.refdef.sky_axis, newParms.ori.axis);
+	}
+
+    tr.portalsky.inUse = qtrue;
+    VectorCopy(newParms.ori.origin, newParms.pvsOrigin);
+
+    leaf = R_PointInLeaf(newParms.pvsOrigin);
+    if (leaf) {
+        R_RenderView(&newParms);
+    }
+
+    tr.viewParms = oldParms;
+
+	tr.portalsky.inUse = qfalse;
+	tr.portalsky.numSurfs = 0;
+	R_RotateForViewer();
+	R_SetupFrustum();
+}
+
+void R_Sky_ChangeFrustum() {
+	// FIXME: unimplemented
+}

code/renderer/tr_staticmodels.cpp

@@ -56,14 +56,11 @@ void R_InitStaticModels(void) {
             g = (int)((float)tr.world->staticModelData[i * 4 + 1] * tr.overbrightMult);
             b = (int)((float)tr.world->staticModelData[i * 4 + 2] * tr.overbrightMult);
 
-            if ((r | g | b) & 0xFFFFFF00)
+            if (r > 0xFF || g > 0xFF || b > 0xFF)
             {
                 float t;
-                unsigned long long rgb;
 
-                rgb = (g + (~((unsigned long long)(r - g) >> 32) & (r - g)) - b);
-
-                t = 255.0 / (float)(b + (~(rgb & 0x00000000FFFFFFFF) & rgb));
+                t = 255.0 / (float)max(r, max(g, b));
 
                 r = (int)((float)r * t);
                 g = (int)((float)g * t);
@@ -326,6 +323,7 @@ void R_AddStaticModelSurfaces(void) {
             {
                 skelHeaderGame_t* skelmodel = TIKI_GetSkel(tiki->mesh[mesh]);
                 skelSurfaceGame_t* surface;
+                staticSurface_t* s_surface;
                 shader_t* shader;
 
                 if (!skelmodel) {
@@ -336,7 +334,7 @@ void R_AddStaticModelSurfaces(void) {
                 // draw all surfaces
                 //
                 surface = skelmodel->pSurfaces;
-                for (j = 0; j < skelmodel->numSurfaces; j++, surface = surface->pNext, dsurf++)
+                for (j = 0; j < skelmodel->numSurfaces; j++, ofsStaticData += surface->numVerts, surface = surface->pNext, dsurf++)
                 {
                     if (g_nStaticSurfaces >= MAX_STATIC_MODELS_SURFS)
                     {
@@ -344,18 +342,44 @@ void R_AddStaticModelSurfaces(void) {
                         continue;
                     }
 
-                    g_staticSurfaces[g_nStaticSurfaces].ident = SF_TIKI_STATIC;
-                    g_staticSurfaces[g_nStaticSurfaces].ofsStaticData = ofsStaticData;
-                    g_staticSurfaces[g_nStaticSurfaces].surface = surface;
-                    g_staticSurfaces[g_nStaticSurfaces].meshNum = mesh;
+                    s_surface = &g_staticSurfaces[g_nStaticSurfaces++];
+					s_surface->ident = SF_TIKI_STATIC;
+					s_surface->ofsStaticData = ofsStaticData;
+					s_surface->surface = surface;
+					s_surface->meshNum = mesh;
 
                     shader = tr.shaders[dsurf->hShader[0]];
 
-                    SM->bRendered = qtrue;
-                    R_AddDrawSurf((surfaceType_t*)&g_staticSurfaces[g_nStaticSurfaces], shader, 0);
+                    if (shader->numUnfoggedPasses == 1)
+                    {
+                        if (shader->unfoggedStages[0]->alphaGen == AGEN_DIST_FADE)
+                        {
+                            if (R_DistanceCullPointAndRadius(shader->fDistNear + shader->fDistRange, tiki_worldorigin, SM->cull_radius) == CULL_OUT) {
+                                continue;
+                            }
+						}
+						else if (shader->unfoggedStages[0]->alphaGen == AGEN_ONE_MINUS_DIST_FADE)
+						{
+							if (R_DistanceCullPointAndRadius(shader->fDistNear, tiki_worldorigin, SM->cull_radius) == CULL_IN) {
+								continue;
+							}
+						}
+                    }
 
-                    g_nStaticSurfaces++;
-                    ofsStaticData += surface->numVerts;
+                    SM->bRendered = qtrue;
+                    R_AddDrawSurf((surfaceType_t*)s_surface, shader, 0);
+
+                    if (r_showstaticlod->integer) {
+                        //
+                        // FIXME: draw debug lods
+                        //
+                    }
+
+                    if (r_showstaticbboxes->integer) {
+                        //
+                        // FIXME: draw debug bbox
+                        //
+                    }
                 }
             }
         }
@@ -456,15 +480,18 @@ void RB_StaticMesh(staticSurface_t* staticSurf) {
     }
 
     if (backEndData[backEnd.smpFrame]->staticModelData) {
-        color4ub_t* in = (color4ub_t*)&backEndData[backEnd.smpFrame]->staticModelData[backEnd.currentStaticModel->firstVertexData + staticSurf->ofsStaticData];
-        color4ub_t* out = &tess.vertexColors[baseVertex];
+        const size_t offset = backEnd.currentStaticModel->firstVertexData + staticSurf->ofsStaticData * sizeof(color4ub_t);
+		assert(offset < tr.world->numStaticModelData * sizeof(color4ub_t));
+		assert(offset + render_count * sizeof(color4ub_t) <= tr.world->numStaticModelData * sizeof(color4ub_t));
 
-        for (i = 0; i < render_count; i++, in++, out++)
+        const color4ub_t* in = (const color4ub_t*)&backEndData[backEnd.smpFrame]->staticModelData[offset];
+
+        for (i = 0; i < render_count; i++)
         {
-            (*out)[0] = (*in)[0];
-            (*out)[1] = (*in)[1];
-            (*out)[2] = (*in)[2];
-            (*out)[3] = (*in)[3];
+			tess.vertexColors[baseVertex + i][0] = in[i][0];
+			tess.vertexColors[baseVertex + i][1] = in[i][1];
+			tess.vertexColors[baseVertex + i][2] = in[i][2];
+			tess.vertexColors[baseVertex + i][3] = in[i][3];
         }
     }
     else {

code/renderer/tr_world.c

@@ -407,46 +407,56 @@ static void R_RecursiveWorldNode( mnode_t *node, int planeBits, int dlightBits )
 		if ( !r_nocull->integer ) {
 			int		r;
 
-			if ( planeBits & 1 ) {
+			if (planeBits & 1) {
 				r = BoxOnPlaneSide(node->mins, node->maxs, &tr.viewParms.frustum[0]);
 				if (r == 2) {
 					return;						// culled
 				}
-				if ( r == 1 ) {
+				if (r == 1) {
 					planeBits &= ~1;			// all descendants will also be in front
 				}
 			}
 
-			if ( planeBits & 2 ) {
+			if (planeBits & 2) {
 				r = BoxOnPlaneSide(node->mins, node->maxs, &tr.viewParms.frustum[1]);
 				if (r == 2) {
 					return;						// culled
 				}
-				if ( r == 1 ) {
+				if (r == 1) {
 					planeBits &= ~2;			// all descendants will also be in front
 				}
 			}
 
-			if ( planeBits & 4 ) {
+			if (planeBits & 4) {
 				r = BoxOnPlaneSide(node->mins, node->maxs, &tr.viewParms.frustum[2]);
 				if (r == 2) {
 					return;						// culled
 				}
-				if ( r == 1 ) {
+				if (r == 1) {
 					planeBits &= ~4;			// all descendants will also be in front
 				}
 			}
 
-			if ( planeBits & 8 ) {
+			if (planeBits & 8) {
 				r = BoxOnPlaneSide(node->mins, node->maxs, &tr.viewParms.frustum[3]);
 				if (r == 2) {
 					return;						// culled
 				}
-				if ( r == 1 ) {
+				if (r == 1) {
 					planeBits &= ~8;			// all descendants will also be in front
 				}
 			}
 
+			if (planeBits & 16) {
+				r = BoxOnPlaneSide(node->mins, node->maxs, &tr.viewParms.frustum[4]);
+				if (r == 2) {
+					return;						// culled
+				}
+				if (r == 1) {
+					planeBits &= ~16;			// all descendants will also be in front
+				}
+			}
+
 		}
 
 		if ( node->contents != -1 ) {
@@ -488,6 +498,8 @@ static void R_RecursiveWorldNode( mnode_t *node, int planeBits, int dlightBits )
 			tr.viewParms.visBounds[1][2] = node->maxs[2];
 		}
 
+		tr.portalsky.cntNode = node;
+
 		if (r_drawbrushes->integer) {
 			// add the individual surfaces
 			mark = node->firstmarksurface;
@@ -509,8 +521,20 @@ static void R_RecursiveWorldNode( mnode_t *node, int planeBits, int dlightBits )
 				R_MarkTerrainPatch(tr.world->visTerraPatches[node->firstTerraPatch + i]);
 			}
 		}
-		// FIXME: static decals
-		// FIXME: static models
+
+		if (r_drawstaticdecals->integer) {
+			if (node->pFirstMarkFragment) {
+				R_AddPermanentMarkFragmentSurfaces(node->pFirstMarkFragment, node->iNumMarkFragment);
+			}
+		}
+
+		if (r_drawstaticmodels->integer) {
+			int i;
+
+			for (i = 0; i < node->numStaticModels; i++) {
+				tr.world->visStaticModels[node->firstStaticModel + i]->visCount = tr.visCount;
+			}
+		}
 	}
 
 }
@@ -521,7 +545,7 @@ static void R_RecursiveWorldNode( mnode_t *node, int planeBits, int dlightBits )
 R_PointInLeaf
 ===============
 */
-static mnode_t *R_PointInLeaf( const vec3_t p ) {
+mnode_t *R_PointInLeaf( const vec3_t p ) {
 	mnode_t		*node;
 	float		d;
 	cplane_t	*plane;
@@ -692,7 +716,7 @@ void R_AddWorldSurfaces (void) {
 		tr.refdef.num_dlights = 32;
 	}
 	R_TransformDlights(tr.refdef.num_dlights, tr.refdef.dlights, &tr.viewParms.world);
-	R_RecursiveWorldNode(tr.world->nodes, 15, (1 << tr.refdef.num_dlights) - 1);
+	R_RecursiveWorldNode(tr.world->nodes, tr.viewParms.fog.extrafrustums ? 31 : 15, (1 << tr.refdef.num_dlights) - 1);
 
 	if (r_drawterrain->integer) {
 		R_AddTerrainSurfaces();