diff --git a/r_context.c b/r_context.c
index 1df68953..9e3f0307 100644
--- a/r_context.c
+++ b/r_context.c
@@ -387,27 +387,6 @@ qboolean VID_CubemapShot(const char *base, uint size, const float *vieworg, qboo
 	// cubemaps? in my softrender???
 }
 
-void R_DecalShoot(int textureIndex, int entityIndex, int modelIndex, vec3_t pos, int flags, float scale)
-{
-
-}
-
-void R_DecalRemoveAll(int texture)
-{
-
-}
-
-int R_CreateDecalList(decallist_t *pList)
-{
-	return 0;
-}
-
-void R_ClearAllDecals()
-{
-
-}
-
-
 void R_InitSkyClouds(mip_t *mt, texture_t *tx, qboolean custom_palette)
 {
 
@@ -448,16 +427,6 @@ void DrawSingleDecal(decal_t *pDecal, msurface_t *fa)
 
 }
 
-float *R_DecalSetupVerts(decal_t *pDecal, msurface_t *surf, int texture, int *outCount)
-{
-	return NULL;
-}
-
-void R_EntityRemoveDecals(model_t *mod)
-{
-
-}
-
 void GL_SelectTexture(int texture)
 {
 
diff --git a/r_decals.c b/r_decals.c
new file mode 100644
index 00000000..f3fd318d
--- /dev/null
+++ b/r_decals.c
@@ -0,0 +1,1296 @@
+/*
+gl_decals.c - decal paste and rendering
+Copyright (C) 2010 Uncle Mike
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+*/
+
+#include "r_local.h"
+//#include "cl_tent.h"
+
+#define DECAL_OVERLAP_DISTANCE	2
+#define DECAL_DISTANCE		4	// too big values produce more clipped polygons
+#define MAX_DECALCLIPVERT		32	// produced vertexes of fragmented decal
+#define DECAL_CACHEENTRY		256	// MUST BE POWER OF 2 or code below needs to change!
+#define DECAL_TRANSPARENT_THRESHOLD	230	// transparent decals draw with GL_MODULATE
+
+// empirically determined constants for minimizing overalpping decals
+#define MAX_OVERLAP_DECALS		6
+#define DECAL_OVERLAP_DIST		8
+#define MIN_DECAL_SCALE		0.01f
+#define MAX_DECAL_SCALE		16.0f
+
+// clip edges
+#define LEFT_EDGE			0
+#define RIGHT_EDGE			1
+#define TOP_EDGE			2
+#define BOTTOM_EDGE			3
+		
+// This structure contains the information used to create new decals
+typedef struct
+{
+	vec3_t		m_Position;	// world coordinates of the decal center
+	model_t		*m_pModel;	// the model the decal is going to be applied in
+	int		m_iTexture;	// The decal material
+	int		m_Size;		// Size of the decal (in world coords)
+	int		m_Flags;
+	int		m_Entity;		// Entity the decal is applied to.
+	float		m_scale;
+	int		m_decalWidth;
+	int		m_decalHeight;
+	vec3_t		m_Basis[3];
+} decalinfo_t;
+
+static float	g_DecalClipVerts[MAX_DECALCLIPVERT][VERTEXSIZE];
+static float	g_DecalClipVerts2[MAX_DECALCLIPVERT][VERTEXSIZE];
+
+decal_t	gDecalPool[MAX_RENDER_DECALS];
+static int	gDecalCount;
+
+void R_ClearDecals( void )
+{
+	memset( gDecalPool, 0, sizeof( gDecalPool ));
+	gDecalCount = 0;
+}
+
+// unlink pdecal from any surface it's attached to
+static void R_DecalUnlink( decal_t *pdecal )
+{
+	decal_t	*tmp;
+
+	if( pdecal->psurface )
+	{
+		if( pdecal->psurface->pdecals == pdecal )
+		{
+			pdecal->psurface->pdecals = pdecal->pnext;
+		}
+		else 
+		{
+			tmp = pdecal->psurface->pdecals;
+			if( !tmp ) gEngfuncs.Host_Error( "D_DecalUnlink: bad decal list\n" );
+
+			while( tmp->pnext ) 
+			{
+				if( tmp->pnext == pdecal ) 
+				{
+					tmp->pnext = pdecal->pnext;
+					break;
+				}
+				tmp = tmp->pnext;
+			}
+		}
+	}
+
+	if( pdecal->polys )
+		Mem_Free( pdecal->polys );
+
+	pdecal->psurface = NULL;
+	pdecal->polys = NULL;
+}
+
+// Just reuse next decal in list
+// A decal that spans multiple surfaces will use multiple decal_t pool entries,
+// as each surface needs it's own.
+static decal_t *R_DecalAlloc( decal_t *pdecal )
+{
+	int	limit = MAX_RENDER_DECALS;
+
+	if( r_decals->value < limit )
+		limit = r_decals->value;
+	
+	if( !limit ) return NULL;
+
+	if( !pdecal ) 
+	{
+		int	count = 0;
+
+		// check for the odd possiblity of infinte loop
+		do 
+		{
+			if( gDecalCount >= limit )
+				gDecalCount = 0;
+
+			pdecal = &gDecalPool[gDecalCount]; // reuse next decal
+			gDecalCount++;
+			count++;
+		} while( FBitSet( pdecal->flags, FDECAL_PERMANENT ) && count < limit );
+	}
+	
+	// if decal is already linked to a surface, unlink it.
+	R_DecalUnlink( pdecal );
+
+	return pdecal;	
+}
+
+//-----------------------------------------------------------------------------
+// find decal image and grab size from it
+//-----------------------------------------------------------------------------
+static void R_GetDecalDimensions( int texture, int *width, int *height )
+{
+	if( width ) *width = 1;	// to avoid divide by zero
+	if( height ) *height = 1;
+
+	R_GetTextureParms( width, height, texture );
+}
+
+//-----------------------------------------------------------------------------
+// compute the decal basis based on surface normal
+//-----------------------------------------------------------------------------
+void R_DecalComputeBasis( msurface_t *surf, int flags, vec3_t textureSpaceBasis[3] )
+{
+	vec3_t	surfaceNormal;
+
+	// setup normal
+	if( surf->flags & SURF_PLANEBACK )
+		VectorNegate( surf->plane->normal, surfaceNormal );
+	else VectorCopy( surf->plane->normal, surfaceNormal );
+
+	VectorNormalize2( surfaceNormal, textureSpaceBasis[2] );
+#if 0
+	if( FBitSet( flags, FDECAL_CUSTOM ))
+	{
+		vec3_t	pSAxis = { 1, 0, 0 };
+
+		// T = S cross N
+		CrossProduct( pSAxis, textureSpaceBasis[2], textureSpaceBasis[1] );
+
+		// Name sure they aren't parallel or antiparallel
+		// In that case, fall back to the normal algorithm.
+		if( DotProduct( textureSpaceBasis[1], textureSpaceBasis[1] ) > 1e-6 )
+		{
+			// S = N cross T
+			CrossProduct( textureSpaceBasis[2], textureSpaceBasis[1], textureSpaceBasis[0] );
+
+			VectorNormalizeFast( textureSpaceBasis[0] );
+			VectorNormalizeFast( textureSpaceBasis[1] );
+			return;
+		}
+		// Fall through to the standard algorithm for parallel or antiparallel
+	}
+#endif
+	VectorNormalize2( surf->texinfo->vecs[0], textureSpaceBasis[0] );
+	VectorNormalize2( surf->texinfo->vecs[1], textureSpaceBasis[1] );
+}
+
+void R_SetupDecalTextureSpaceBasis( decal_t *pDecal, msurface_t *surf, int texture, vec3_t textureSpaceBasis[3], float decalWorldScale[2] )
+{
+	int	width, height;
+
+	// Compute the non-scaled decal basis
+	R_DecalComputeBasis( surf, pDecal->flags, textureSpaceBasis );
+	R_GetDecalDimensions( texture, &width, &height );
+
+	// world width of decal = ptexture->width / pDecal->scale
+	// world height of decal = ptexture->height / pDecal->scale
+	// scale is inverse, scales world space to decal u/v space [0,1]
+	// OPTIMIZE: Get rid of these divides
+	decalWorldScale[0] = (float)pDecal->scale / width;
+	decalWorldScale[1] = (float)pDecal->scale / height;
+	
+	VectorScale( textureSpaceBasis[0], decalWorldScale[0], textureSpaceBasis[0] );
+	VectorScale( textureSpaceBasis[1], decalWorldScale[1], textureSpaceBasis[1] );
+}
+
+// Build the initial list of vertices from the surface verts into the global array, 'verts'.
+void R_SetupDecalVertsForMSurface( decal_t *pDecal, msurface_t *surf,	vec3_t textureSpaceBasis[3], float *verts )
+{
+	float	*v;
+	int	i;
+
+	if( !surf->polys )
+		return;
+	for( i = 0, v = surf->polys->verts[0]; i < surf->polys->numverts; i++, v += VERTEXSIZE, verts += VERTEXSIZE )
+	{
+		VectorCopy( v, verts ); // copy model space coordinates
+		verts[3] = DotProduct( verts, textureSpaceBasis[0] ) - pDecal->dx + 0.5f;
+		verts[4] = DotProduct( verts, textureSpaceBasis[1] ) - pDecal->dy + 0.5f;
+		verts[5] = verts[6] = 0.0f;
+	}
+}
+
+// Figure out where the decal maps onto the surface.
+void R_SetupDecalClip( decal_t *pDecal, msurface_t *surf, int texture, vec3_t textureSpaceBasis[3], float decalWorldScale[2] )
+{
+	R_SetupDecalTextureSpaceBasis( pDecal, surf, texture, textureSpaceBasis, decalWorldScale );
+
+	// Generate texture coordinates for each vertex in decal s,t space
+	// probably should pre-generate this, store it and use it for decal-decal collisions
+	// as in R_DecalsIntersect()
+	pDecal->dx = DotProduct( pDecal->position, textureSpaceBasis[0] );
+	pDecal->dy = DotProduct( pDecal->position, textureSpaceBasis[1] );
+}
+
+// Quick and dirty sutherland Hodgman clipper
+// Clip polygon to decal in texture space
+// JAY: This code is lame, change it later.  It does way too much work per frame
+// It can be made to recursively call the clipping code and only copy the vertex list once
+int R_ClipInside( float *vert, int edge )
+{
+	switch( edge )
+	{
+	case LEFT_EDGE:
+		if( vert[3] > 0.0f )
+			return 1;
+		return 0;
+	case RIGHT_EDGE:
+		if( vert[3] < 1.0f )
+			return 1;
+		return 0;
+	case TOP_EDGE:
+		if( vert[4] > 0.0f )
+			return 1;
+		return 0;
+	case BOTTOM_EDGE:
+		if( vert[4] < 1.0f )
+			return 1;
+		return 0;
+	}
+	return 0;
+}
+
+void R_ClipIntersect( float *one, float *two, float *out, int edge )
+{
+	float	t;
+
+	// t is the parameter of the line between one and two clipped to the edge
+	// or the fraction of the clipped point between one & two
+	// vert[0], vert[1], vert[2] is X, Y, Z
+	// vert[3] is u
+	// vert[4] is v
+	// vert[5] is lightmap u
+	// vert[6] is lightmap v
+
+	if( edge < TOP_EDGE )
+	{
+		if( edge == LEFT_EDGE )
+		{
+			// left
+			t = ((one[3] - 0.0f) / (one[3] - two[3]));
+			out[3] = out[5] = 0.0f;
+		}
+		else
+		{	
+			// right
+			t = ((one[3] - 1.0f) / (one[3] - two[3]));
+			out[3] = out[5] = 1.0f;
+		}
+
+		out[4] = one[4] + (two[4] - one[4]) * t;
+		out[6] = one[6] + (two[6] - one[6]) * t;
+	}
+	else
+	{
+		if( edge == TOP_EDGE )
+		{
+			// top
+			t = ((one[4] - 0.0f)  / (one[4] - two[4]));
+			out[4] = out[6] = 0.0f;
+		}
+		else
+		{	
+			// bottom
+			t = ((one[4] - 1.0f) / (one[4] - two[4]));
+			out[4] = out[6] = 1.0f;
+		}
+
+		out[3] = one[3] + (two[3] - one[3]) * t;
+		out[5] = one[5] + (two[4] - one[5]) * t;
+	}
+
+	VectorLerp( one, t, two, out );
+}
+
+static int SHClip( float *vert, int vertCount, float *out, int edge )
+{
+	int	j, outCount;
+	float	*s, *p;
+
+	outCount = 0;
+
+	s = &vert[(vertCount - 1) * VERTEXSIZE];
+
+	for( j = 0; j < vertCount; j++ )
+	{
+		p = &vert[j * VERTEXSIZE];
+
+		if( R_ClipInside( p, edge ))
+		{
+			if( R_ClipInside( s, edge ))
+			{
+				// Add a vertex and advance out to next vertex
+				memcpy( out, p, sizeof( float ) * VERTEXSIZE );
+				out += VERTEXSIZE;
+				outCount++;
+			}
+			else
+			{
+				R_ClipIntersect( s, p, out, edge );
+				out += VERTEXSIZE;
+				outCount++;
+
+				memcpy( out, p, sizeof( float ) * VERTEXSIZE );
+				out += VERTEXSIZE;
+				outCount++;
+			}
+		}
+		else
+		{
+			if( R_ClipInside( s, edge ))
+			{
+				R_ClipIntersect( p, s, out, edge );
+				out += VERTEXSIZE;
+				outCount++;
+			}
+		}
+
+		s = p;
+	}
+
+	return outCount;
+}
+
+float *R_DoDecalSHClip( float *pInVerts, decal_t *pDecal, int nStartVerts, int *pVertCount )
+{
+	float	*pOutVerts = g_DecalClipVerts[0];
+	int	outCount;
+
+	// clip the polygon to the decal texture space
+	outCount = SHClip( pInVerts, nStartVerts, g_DecalClipVerts2[0], LEFT_EDGE );
+	outCount = SHClip( g_DecalClipVerts2[0], outCount, g_DecalClipVerts[0], RIGHT_EDGE );
+	outCount = SHClip( g_DecalClipVerts[0], outCount, g_DecalClipVerts2[0], TOP_EDGE );
+	outCount = SHClip( g_DecalClipVerts2[0], outCount, pOutVerts, BOTTOM_EDGE );
+
+	if( pVertCount )
+		*pVertCount = outCount;
+
+	return pOutVerts;
+}
+
+//-----------------------------------------------------------------------------
+// Generate clipped vertex list for decal pdecal projected onto polygon psurf
+//-----------------------------------------------------------------------------
+float *R_DecalVertsClip( decal_t *pDecal, msurface_t *surf, int texture, int *pVertCount )
+{
+	float	decalWorldScale[2];
+	vec3_t	textureSpaceBasis[3]; 
+
+	// figure out where the decal maps onto the surface.
+	R_SetupDecalClip( pDecal, surf, texture, textureSpaceBasis, decalWorldScale );
+
+	// build the initial list of vertices from the surface verts.
+	R_SetupDecalVertsForMSurface( pDecal, surf, textureSpaceBasis, g_DecalClipVerts[0] );
+
+	if( !surf->polys )
+		return 0;
+	return R_DoDecalSHClip( g_DecalClipVerts[0], pDecal, surf->polys->numverts, pVertCount );
+}
+
+// Generate lighting coordinates at each vertex for decal vertices v[] on surface psurf
+static void R_DecalVertsLight( float *v, msurface_t *surf, int vertCount )
+{
+	float		s, t;
+	mtexinfo_t	*tex;
+	mextrasurf_t	*info = surf->info;
+	float		sample_size;
+	int		j;
+
+	sample_size = gEngfuncs.Mod_SampleSizeForFace( surf );
+	tex = surf->texinfo;
+
+	for( j = 0; j < vertCount; j++, v += VERTEXSIZE )
+	{
+		// lightmap texture coordinates
+		s = DotProduct( v, info->lmvecs[0] ) + info->lmvecs[0][3] - info->lightmapmins[0];
+		s += surf->light_s * sample_size;
+		s += sample_size * 0.5;
+		s /= BLOCK_SIZE * sample_size; //fa->texinfo->texture->width;
+
+		t = DotProduct( v, info->lmvecs[1] ) + info->lmvecs[1][3] - info->lightmapmins[1];
+		t += surf->light_t * sample_size;
+		t += sample_size * 0.5;
+		t /= BLOCK_SIZE * sample_size; //fa->texinfo->texture->height;
+
+		v[5] = s;
+		v[6] = t;
+	}
+}
+
+// Check for intersecting decals on this surface
+static decal_t *R_DecalIntersect( decalinfo_t *decalinfo, msurface_t *surf, int *pcount )
+{
+	int		texture;
+	decal_t		*plast, *pDecal;
+	vec3_t		decalExtents[2];
+	float		lastArea = 2;
+	int		mapSize[2];
+
+	plast = NULL;
+	*pcount = 0;
+
+	// (Same as R_SetupDecalClip).
+	texture = decalinfo->m_iTexture;
+	
+	// precalculate the extents of decalinfo's decal in world space.
+	R_GetDecalDimensions( texture, &mapSize[0], &mapSize[1] );
+	VectorScale( decalinfo->m_Basis[0], ((mapSize[0] / decalinfo->m_scale) * 0.5f), decalExtents[0] );
+	VectorScale( decalinfo->m_Basis[1], ((mapSize[1] / decalinfo->m_scale) * 0.5f), decalExtents[1] );
+
+	pDecal = surf->pdecals;
+
+	while( pDecal ) 
+	{
+		texture = pDecal->texture;
+
+		// Don't steal bigger decals and replace them with smaller decals
+		// Don't steal permanent decals
+		if( !FBitSet( pDecal->flags, FDECAL_PERMANENT ))
+		{
+			vec3_t	testBasis[3];
+			vec3_t	testPosition[2];
+			float	testWorldScale[2];
+			vec2_t	vDecalMin, vDecalMax;
+			vec2_t	vUnionMin, vUnionMax;
+
+			R_SetupDecalTextureSpaceBasis( pDecal, surf, texture, testBasis, testWorldScale );
+
+			VectorSubtract( decalinfo->m_Position, decalExtents[0], testPosition[0] );
+			VectorSubtract( decalinfo->m_Position, decalExtents[1], testPosition[1] );
+
+			// Here, we project the min and max extents of the decal that got passed in into
+			// this decal's (pDecal's) [0,0,1,1] clip space, just like we would if we were
+			// clipping a triangle into pDecal's clip space.
+			Vector2Set( vDecalMin,
+				DotProduct( testPosition[0], testBasis[0] ) - pDecal->dx + 0.5f,
+				DotProduct( testPosition[1], testBasis[1] ) - pDecal->dy + 0.5f );
+
+			VectorAdd( decalinfo->m_Position, decalExtents[0], testPosition[0] );
+			VectorAdd( decalinfo->m_Position, decalExtents[1], testPosition[1] );
+
+			Vector2Set( vDecalMax,
+				DotProduct( testPosition[0], testBasis[0] ) - pDecal->dx + 0.5f,
+				DotProduct( testPosition[1], testBasis[1] ) - pDecal->dy + 0.5f );	
+
+			// Now figure out the part of the projection that intersects pDecal's
+			// clip box [0,0,1,1].
+			Vector2Set( vUnionMin, max( vDecalMin[0], 0 ), max( vDecalMin[1], 0 ));
+			Vector2Set( vUnionMax, min( vDecalMax[0], 1 ), min( vDecalMax[1], 1 ));
+
+			if( vUnionMin[0] < 1 && vUnionMin[1] < 1 && vUnionMax[0] > 0 && vUnionMax[1] > 0 )
+			{
+				// Figure out how much of this intersects the (0,0) - (1,1) bbox.			
+				float	flArea = (vUnionMax[0] - vUnionMin[1]) * (vUnionMax[1] - vUnionMin[1]);
+
+				if( flArea > 0.6f )
+				{
+					*pcount += 1;
+
+					if( !plast || flArea <= lastArea ) 
+					{
+						plast = pDecal;
+						lastArea =  flArea;
+					}
+				}
+			}
+		}
+		pDecal = pDecal->pnext;
+	}
+	return plast;
+}
+
+/*
+====================
+R_DecalCreatePoly
+
+creates mesh for decal on first rendering
+====================
+*/
+glpoly_t *R_DecalCreatePoly( decalinfo_t *decalinfo, decal_t *pdecal, msurface_t *surf )
+{
+	int		lnumverts;
+	glpoly_t	*poly;
+	float		*v;
+	int		i;
+
+	return;
+	if( pdecal->polys )	// already created?
+		return pdecal->polys;
+
+	v = R_DecalSetupVerts( pdecal, surf, pdecal->texture, &lnumverts );
+	if( !lnumverts ) return NULL;	// probably this never happens
+
+	// allocate glpoly
+	// REFTODO: com_studiocache pool!
+	poly = Mem_Calloc( r_temppool, sizeof( glpoly_t ) + ( lnumverts - 4 ) * VERTEXSIZE * sizeof( float ));
+	poly->next = pdecal->polys;
+	poly->flags = surf->flags;
+	pdecal->polys = poly;
+	poly->numverts = lnumverts;
+
+	for( i = 0; i < lnumverts; i++, v += VERTEXSIZE )
+	{
+		VectorCopy( v, poly->verts[i] );
+		poly->verts[i][3] = v[3];
+		poly->verts[i][4] = v[4];
+		poly->verts[i][5] = v[5];
+		poly->verts[i][6] = v[6];
+	}
+
+	return poly;
+}
+
+// Add the decal to the surface's list of decals.
+static void R_AddDecalToSurface( decal_t *pdecal, msurface_t *surf, decalinfo_t *decalinfo )
+{
+	decal_t	*pold;
+
+	pdecal->pnext = NULL;
+	pold = surf->pdecals;
+
+	if( pold ) 
+	{
+		while( pold->pnext ) 
+			pold = pold->pnext;
+		pold->pnext = pdecal;
+	}
+	else
+	{
+		surf->pdecals = pdecal;
+	}
+
+	// force surface cache rebuild
+	surf->dlightframe = r_framecount + 1;
+
+	// tag surface
+	pdecal->psurface = surf;
+
+	// at this point decal are linked with surface
+	// and will be culled, drawing and sorting
+	// together with surface
+
+	// alloc clipped poly for decal
+	R_DecalCreatePoly( decalinfo, pdecal, surf );
+	//R_AddDecalVBO( pdecal, surf );
+}
+
+static void R_DecalCreate( decalinfo_t *decalinfo, msurface_t *surf, float x, float y )
+{
+	decal_t	*pdecal, *pold;
+	int	count, vertCount;
+
+	if( !surf ) return;	// ???
+	
+	pold = R_DecalIntersect( decalinfo, surf, &count );
+	if( count < MAX_OVERLAP_DECALS ) pold = NULL;
+
+	pdecal = R_DecalAlloc( pold );
+	if( !pdecal ) return; // r_decals == 0 ???
+
+	pdecal->flags = decalinfo->m_Flags;
+
+	VectorCopy( decalinfo->m_Position, pdecal->position );
+
+	pdecal->dx = x;
+	pdecal->dy = y;
+
+	// set scaling
+	pdecal->scale = decalinfo->m_scale;
+	pdecal->entityIndex = decalinfo->m_Entity;
+	pdecal->texture = decalinfo->m_iTexture;
+
+	// check to see if the decal actually intersects the surface
+	// if not, then remove the decal
+	R_DecalVertsClip( pdecal, surf, decalinfo->m_iTexture, &vertCount );
+	
+	if( !vertCount )
+	{
+		R_DecalUnlink( pdecal );
+		return;
+	}
+
+	// add to the surface's list
+	R_AddDecalToSurface( pdecal, surf, decalinfo );
+}
+
+void R_DecalSurface( msurface_t *surf, decalinfo_t *decalinfo )
+{
+	// get the texture associated with this surface
+	mtexinfo_t	*tex = surf->texinfo;
+	decal_t		*decal = surf->pdecals;
+	vec4_t		textureU, textureV;
+	float		s, t, w, h;
+	connstate_t state = ENGINE_GET_PARM( PARM_CONNSTATE );
+
+	// we in restore mode
+	if( state == ca_connected || state == ca_validate )
+	{
+		// NOTE: we may have the decal on this surface that come from another level.
+		// check duplicate with same position and texture
+		while( decal != NULL )
+		{
+			if( VectorCompare( decal->position, decalinfo->m_Position ) && decal->texture == decalinfo->m_iTexture )
+				return; // decal already exists, don't place it again
+			decal = decal->pnext;
+		}
+	}
+
+	Vector4Copy( tex->vecs[0], textureU );
+	Vector4Copy( tex->vecs[1], textureV );
+
+	// project decal center into the texture space of the surface
+	s = DotProduct( decalinfo->m_Position, textureU ) + textureU[3] - surf->texturemins[0];
+	t = DotProduct( decalinfo->m_Position, textureV ) + textureV[3] - surf->texturemins[1];
+
+	// Determine the decal basis (measured in world space)
+	// Note that the decal basis vectors 0 and 1 will always lie in the same
+	// plane as the texture space basis vectorstextureVecsTexelsPerWorldUnits.
+	R_DecalComputeBasis( surf, decalinfo->m_Flags, decalinfo->m_Basis );
+
+	// Compute an effective width and height (axis aligned) in the parent texture space
+	// How does this work? decalBasis[0] represents the u-direction (width)
+	// of the decal measured in world space, decalBasis[1] represents the 
+	// v-direction (height) measured in world space.
+	// textureVecsTexelsPerWorldUnits[0] represents the u direction of 
+	// the surface's texture space measured in world space (with the appropriate
+	// scale factor folded in), and textureVecsTexelsPerWorldUnits[1]
+	// represents the texture space v direction. We want to find the dimensions (w,h)
+	// of a square measured in texture space, axis aligned to that coordinate system.
+	// All we need to do is to find the components of the decal edge vectors
+	// (decalWidth * decalBasis[0], decalHeight * decalBasis[1])
+	// in texture coordinates:
+
+	w = fabs( decalinfo->m_decalWidth  * DotProduct( textureU, decalinfo->m_Basis[0] )) +
+	    fabs( decalinfo->m_decalHeight * DotProduct( textureU, decalinfo->m_Basis[1] ));
+	
+	h = fabs( decalinfo->m_decalWidth  * DotProduct( textureV, decalinfo->m_Basis[0] )) +
+	    fabs( decalinfo->m_decalHeight * DotProduct( textureV, decalinfo->m_Basis[1] ));
+
+	// move s,t to upper left corner
+	s -= ( w * 0.5f );
+	t -= ( h * 0.5f );
+
+	// Is this rect within the surface? -- tex width & height are unsigned
+	if( s <= -w || t <= -h || s > (surf->extents[0] + w) || t > (surf->extents[1] + h))
+	{
+		return; // nope
+	}
+
+	// stamp it
+	R_DecalCreate( decalinfo, surf, s, t );
+}
+
+//-----------------------------------------------------------------------------
+// iterate over all surfaces on a node, looking for surfaces to decal
+//-----------------------------------------------------------------------------
+static void R_DecalNodeSurfaces( model_t *model, mnode_t *node, decalinfo_t *decalinfo )
+{
+	// iterate over all surfaces in the node
+	msurface_t	*surf;
+	int		i;
+
+	surf = model->surfaces + node->firstsurface;
+
+	for( i = 0; i < node->numsurfaces; i++, surf++ ) 
+	{
+		// never apply decals on the water or sky surfaces
+		if( surf->flags & (SURF_DRAWTURB|SURF_DRAWSKY|SURF_CONVEYOR))
+			continue;
+
+		// we can implement alpha testing without stencil
+		//if( surf->flags & SURF_TRANSPARENT && !glState.stencilEnabled )
+			//continue;
+
+		R_DecalSurface( surf, decalinfo );
+	}
+}
+
+//-----------------------------------------------------------------------------
+// Recursive routine to find surface to apply a decal to.  World coordinates of 
+// the decal are passed in r_recalpos like the rest of the engine.  This should 
+// be called through R_DecalShoot()
+//-----------------------------------------------------------------------------
+static void R_DecalNode( model_t *model, mnode_t *node, decalinfo_t *decalinfo )
+{
+	mplane_t	*splitplane;
+	float	dist;
+	
+	Assert( node != NULL );
+
+	if( node->contents < 0 )
+	{
+		// hit a leaf
+		return;
+	}
+
+	splitplane = node->plane;
+	dist = DotProduct( decalinfo->m_Position, splitplane->normal ) - splitplane->dist;
+
+	// This is arbitrarily set to 10 right now. In an ideal world we'd have the 
+	// exact surface but we don't so, this tells me which planes are "sort of 
+	// close" to the gunshot -- the gunshot is actually 4 units in front of the 
+	// wall (see dlls\weapons.cpp). We also need to check to see if the decal 
+	// actually intersects the texture space of the surface, as this method tags
+	// parallel surfaces in the same node always.
+	// JAY: This still tags faces that aren't correct at edges because we don't 
+	// have a surface normal
+	if( dist > decalinfo->m_Size )
+	{
+		R_DecalNode( model, node->children[0], decalinfo );
+	}
+	else if( dist < -decalinfo->m_Size )
+	{
+		R_DecalNode( model, node->children[1], decalinfo );
+	}
+	else 
+	{
+		if( dist < DECAL_DISTANCE && dist > -DECAL_DISTANCE )
+			R_DecalNodeSurfaces( model, node, decalinfo );
+
+		R_DecalNode( model, node->children[0], decalinfo );
+		R_DecalNode( model, node->children[1], decalinfo );
+	}
+}
+
+// Shoots a decal onto the surface of the BSP.  position is the center of the decal in world coords
+void R_DecalShoot( int textureIndex, int entityIndex, int modelIndex, vec3_t pos, int flags, float scale )
+{
+	decalinfo_t	decalInfo;
+	cl_entity_t	*ent = NULL;
+	model_t		*model = NULL;
+	int		width, height;
+	hull_t		*hull;
+
+	if( textureIndex <= 0 || textureIndex >= MAX_TEXTURES )
+	{
+		gEngfuncs.Con_Printf( S_ERROR "Decal has invalid texture!\n" );
+		return;
+	}
+
+	if( entityIndex > 0 )
+	{
+		ent = gEngfuncs.GetEntityByIndex( entityIndex );
+
+		if( modelIndex > 0 ) model = gEngfuncs.pfnGetModelByIndex( modelIndex );
+		else if( ent != NULL ) model = gEngfuncs.pfnGetModelByIndex( ent->curstate.modelindex );
+		else return;
+	}
+	else if( modelIndex > 0 )
+		model = gEngfuncs.pfnGetModelByIndex( modelIndex );
+	else model = WORLDMODEL;
+
+	if( !model ) return;
+	
+	if( model->type != mod_brush )
+	{
+		gEngfuncs.Con_Printf( S_ERROR "Decals must hit mod_brush!\n" );
+		return;
+	}
+
+	decalInfo.m_pModel = model;
+	hull = &model->hulls[0];	// always use #0 hull
+
+	// NOTE: all the decals at 'first shoot' placed into local space of parent entity
+	// and won't transform again on a next restore, levelchange etc
+	if( ent && !FBitSet( flags, FDECAL_LOCAL_SPACE ))
+	{
+		vec3_t	pos_l;
+
+		// transform decal position in local bmodel space
+		if( !VectorIsNull( ent->angles ))
+		{
+			matrix4x4	matrix;
+
+			Matrix4x4_CreateFromEntity( matrix, ent->angles, ent->origin, 1.0f );
+			Matrix4x4_VectorITransform( matrix, pos, pos_l );
+		}
+		else
+		{
+			VectorSubtract( pos, ent->origin, pos_l );
+		}
+
+		VectorCopy( pos_l, decalInfo.m_Position );
+		// decal position moved into local space
+		SetBits( flags, FDECAL_LOCAL_SPACE );
+	}
+	else
+	{
+		// already in local space
+		VectorCopy( pos, decalInfo.m_Position );
+	}
+
+	// this decal must use landmark for correct transition
+	// because their model exist only in world-space
+	if( !FBitSet( model->flags, MODEL_HAS_ORIGIN ))
+		SetBits( flags, FDECAL_USE_LANDMARK );
+
+	// more state used by R_DecalNode()
+	decalInfo.m_iTexture = textureIndex;
+	decalInfo.m_Entity = entityIndex;
+	decalInfo.m_Flags = flags;
+
+	R_GetDecalDimensions( textureIndex, &width, &height );
+	decalInfo.m_Size = width >> 1;
+	if(( height >> 1 ) > decalInfo.m_Size )
+		decalInfo.m_Size = height >> 1;
+
+	decalInfo.m_scale = bound( MIN_DECAL_SCALE, scale, MAX_DECAL_SCALE );
+
+	// compute the decal dimensions in world space
+	decalInfo.m_decalWidth = width / decalInfo.m_scale;
+	decalInfo.m_decalHeight = height / decalInfo.m_scale;
+
+	R_DecalNode( model, &model->nodes[hull->firstclipnode], &decalInfo );
+}
+
+// Build the vertex list for a decal on a surface and clip it to the surface.
+// This is a template so it can work on world surfaces and dynamic displacement 
+// triangles the same way.
+float *R_DecalSetupVerts( decal_t *pDecal, msurface_t *surf, int texture, int *outCount )
+{
+	glpoly_t	*p = pDecal->polys;
+	int	i, count;
+	float	*v, *v2;
+
+	if( p )
+	{
+		v = g_DecalClipVerts[0];
+		count = p->numverts;
+		v2 = p->verts[0];
+
+		// if we have mesh so skip clipping and just copy vertexes out (perf)
+		for( i = 0; i < count; i++, v += VERTEXSIZE, v2 += VERTEXSIZE )
+		{
+			VectorCopy( v2, v );
+			v[3] = v2[3];
+			v[4] = v2[4];
+			v[5] = v2[5];
+			v[6] = v2[6];
+		}
+
+		// restore pointer
+		v = g_DecalClipVerts[0];
+	}
+	else
+	{
+		v = R_DecalVertsClip( pDecal, surf, texture, &count );
+		R_DecalVertsLight( v, surf, count );
+	}
+
+	if( outCount )
+		*outCount = count;
+
+	return v;
+}
+
+#if 0
+void DrawSingleDecal( decal_t *pDecal, msurface_t *fa )
+{
+	float	*v;
+	int	i, numVerts;
+
+	v = R_DecalSetupVerts( pDecal, fa, pDecal->texture, &numVerts );
+	if( !numVerts ) return;
+
+	GL_Bind( XASH_TEXTURE0, pDecal->texture );
+
+	pglBegin( GL_POLYGON );
+
+	for( i = 0; i < numVerts; i++, v += VERTEXSIZE )
+	{
+		pglTexCoord2f( v[3], v[4] );
+		pglVertex3fv( v );
+	}
+
+	pglEnd();
+}
+
+void DrawSurfaceDecals( msurface_t *fa, qboolean single, qboolean reverse )
+{	
+	decal_t		*p;
+	cl_entity_t	*e;
+
+	if( !fa->pdecals ) return;
+
+	e = RI.currententity;
+	Assert( e != NULL );
+
+	if( single )
+	{
+		if( e->curstate.rendermode == kRenderNormal || e->curstate.rendermode == kRenderTransAlpha )
+		{
+			pglDepthMask( GL_FALSE );
+			pglEnable( GL_BLEND );
+
+			if( e->curstate.rendermode == kRenderTransAlpha )
+				pglDisable( GL_ALPHA_TEST );
+		}
+
+		if( e->curstate.rendermode == kRenderTransColor )
+			pglEnable( GL_TEXTURE_2D );
+
+		if( e->curstate.rendermode == kRenderTransTexture || e->curstate.rendermode == kRenderTransAdd )
+			GL_Cull( GL_NONE );
+
+		if( gl_polyoffset->value )
+		{
+			pglEnable( GL_POLYGON_OFFSET_FILL );
+			pglPolygonOffset( -1.0f, -gl_polyoffset->value );
+		}
+	}
+
+	if( FBitSet( fa->flags, SURF_TRANSPARENT ) && glState.stencilEnabled )
+	{
+		mtexinfo_t	*tex = fa->texinfo;
+
+		for( p = fa->pdecals; p; p = p->pnext )
+		{
+			if( p->texture )
+			{
+				float *o, *v;
+				int i, numVerts;
+				o = R_DecalSetupVerts( p, fa, p->texture, &numVerts );
+
+				pglEnable( GL_STENCIL_TEST );
+				pglStencilFunc( GL_ALWAYS, 1, 0xFFFFFFFF );
+				pglColorMask( GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE );
+
+				pglStencilOp( GL_KEEP, GL_KEEP, GL_REPLACE );
+				pglBegin( GL_POLYGON );
+
+				for( i = 0, v = o; i < numVerts; i++, v += VERTEXSIZE )
+				{
+					v[5] = ( DotProduct( v, tex->vecs[0] ) + tex->vecs[0][3] ) / tex->texture->width;
+					v[6] = ( DotProduct( v, tex->vecs[1] ) + tex->vecs[1][3] ) / tex->texture->height;
+
+					pglTexCoord2f( v[5], v[6] );
+					pglVertex3fv( v );
+				}
+
+				pglEnd();
+				pglStencilOp( GL_KEEP, GL_KEEP, GL_DECR );
+
+				pglEnable( GL_ALPHA_TEST );
+				pglBegin( GL_POLYGON );
+
+				for( i = 0, v = o; i < numVerts; i++, v += VERTEXSIZE )
+				{
+					pglTexCoord2f( v[5], v[6] );
+					pglVertex3fv( v );
+				}
+
+				pglEnd();
+				pglDisable( GL_ALPHA_TEST );
+
+				pglColorMask( GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE );
+				pglStencilFunc( GL_EQUAL, 0, 0xFFFFFFFF );
+				pglStencilOp( GL_KEEP, GL_KEEP, GL_KEEP );
+			}
+		}
+	}
+
+	pglBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
+
+	if( reverse && e->curstate.rendermode == kRenderTransTexture )
+	{
+		decal_t	*list[1024];
+		int	i, count;
+
+		for( p = fa->pdecals, count = 0; p && count < 1024; p = p->pnext )
+			if( p->texture ) list[count++] = p;
+
+		for( i = count - 1; i >= 0; i-- )
+			DrawSingleDecal( list[i], fa );
+	}
+	else
+	{
+		for( p = fa->pdecals; p; p = p->pnext )
+		{
+			if( !p->texture ) continue;
+			DrawSingleDecal( p, fa );
+		}
+	}
+
+	if( FBitSet( fa->flags, SURF_TRANSPARENT ) && glState.stencilEnabled )
+		pglDisable( GL_STENCIL_TEST );
+
+	if( single )
+	{
+		if( e->curstate.rendermode == kRenderNormal || e->curstate.rendermode == kRenderTransAlpha )
+		{
+			pglDepthMask( GL_TRUE );
+			pglDisable( GL_BLEND );
+
+			if( e->curstate.rendermode == kRenderTransAlpha )
+				pglEnable( GL_ALPHA_TEST );
+		}
+
+		if( gl_polyoffset->value )
+			pglDisable( GL_POLYGON_OFFSET_FILL );
+
+		if( e->curstate.rendermode == kRenderTransTexture || e->curstate.rendermode == kRenderTransAdd )
+			GL_Cull( GL_FRONT );
+
+		if( e->curstate.rendermode == kRenderTransColor )
+			pglDisable( GL_TEXTURE_2D );
+
+		// restore blendfunc here
+		if( e->curstate.rendermode == kRenderTransAdd || e->curstate.rendermode == kRenderGlow )
+			pglBlendFunc( GL_SRC_ALPHA, GL_ONE );
+
+		pglTexEnvf( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE );
+	}
+}
+
+void DrawDecalsBatch( void )
+{	
+	cl_entity_t	*e;
+	int		i;
+
+	if( !tr.num_draw_decals )
+		return;
+
+	e = RI.currententity;
+	Assert( e != NULL );
+
+	if( e->curstate.rendermode != kRenderTransTexture )
+	{
+		pglEnable( GL_BLEND );
+		pglBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
+		pglDepthMask( GL_FALSE );
+	}
+
+	if( e->curstate.rendermode == kRenderTransTexture || e->curstate.rendermode == kRenderTransAdd )
+		GL_Cull( GL_NONE );
+
+	if( gl_polyoffset->value )
+	{
+		pglEnable( GL_POLYGON_OFFSET_FILL );
+		pglPolygonOffset( -1.0f, -gl_polyoffset->value );
+	}
+
+	for( i = 0; i < tr.num_draw_decals; i++ )
+	{
+		DrawSurfaceDecals( tr.draw_decals[i], false, false );
+	}
+
+	if( e->curstate.rendermode != kRenderTransTexture )
+	{
+		pglDepthMask( GL_TRUE );
+		pglDisable( GL_BLEND );
+		pglDisable( GL_ALPHA_TEST );
+	}
+
+	if( gl_polyoffset->value )
+		pglDisable( GL_POLYGON_OFFSET_FILL );
+
+	if( e->curstate.rendermode == kRenderTransTexture || e->curstate.rendermode == kRenderTransAdd )
+		GL_Cull( GL_FRONT );
+
+	tr.num_draw_decals = 0;
+}
+#endif
+/*
+=============================================================
+
+  DECALS SERIALIZATION
+
+=============================================================
+*/
+static qboolean R_DecalUnProject( decal_t *pdecal, decallist_t *entry )
+{
+	if( !pdecal || !( pdecal->psurface ))
+		return false;
+
+	VectorCopy( pdecal->position, entry->position );
+	entry->entityIndex = pdecal->entityIndex;
+
+	// Grab surface plane equation
+	if( pdecal->psurface->flags & SURF_PLANEBACK )
+		VectorNegate( pdecal->psurface->plane->normal, entry->impactPlaneNormal );
+	else VectorCopy( pdecal->psurface->plane->normal, entry->impactPlaneNormal );
+
+	return true;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+// Input  : *pList - 
+//			count - 
+// Output : static int
+//-----------------------------------------------------------------------------
+static int DecalListAdd( decallist_t *pList, int count )
+{
+	vec3_t		tmp;
+	decallist_t	*pdecal;
+	int		i;
+
+	pdecal = pList + count;
+
+	for( i = 0; i < count; i++ )
+	{
+		if( !Q_strcmp( pdecal->name, pList[i].name ) &&  pdecal->entityIndex == pList[i].entityIndex )
+		{
+			VectorSubtract( pdecal->position, pList[i].position, tmp );	// Merge
+
+			if( VectorLength( tmp ) < DECAL_OVERLAP_DISTANCE )
+				return count;
+		}
+	}
+
+	// this is a new decal
+	return count + 1;
+}
+
+static int DecalDepthCompare( const void *a, const void *b )
+{
+	const decallist_t	*elem1, *elem2;
+
+	elem1 = (const decallist_t *)a;
+	elem2 = (const decallist_t *)b;
+
+	if( elem1->depth > elem2->depth )
+		return 1;
+	if( elem1->depth < elem2->depth )
+		return -1;
+
+	return 0;
+}
+
+//-----------------------------------------------------------------------------
+// Purpose: Called by CSaveRestore::SaveClientState
+// Input  : *pList - 
+// Output : int
+//-----------------------------------------------------------------------------
+int R_CreateDecalList( decallist_t *pList )
+{
+	int	total = 0;
+	int	i, depth;
+
+	if( WORLDMODEL )
+	{
+		for( i = 0; i < MAX_RENDER_DECALS; i++ )
+		{
+			decal_t	*decal = &gDecalPool[i];
+			decal_t	*pdecals;
+			
+			// decal is in use and is not a custom decal
+			if( decal->psurface == NULL || FBitSet( decal->flags, FDECAL_DONTSAVE ))
+				 continue;
+
+			// compute depth
+			depth = 0;
+			pdecals = decal->psurface->pdecals;
+
+			while( pdecals && pdecals != decal )
+			{
+				depth++;
+				pdecals = pdecals->pnext;
+			}
+
+			pList[total].depth = depth;
+			pList[total].flags = decal->flags;
+			pList[total].scale = decal->scale;
+			
+			R_DecalUnProject( decal, &pList[total] );
+			COM_FileBase( R_GetTexture( decal->texture )->name, pList[total].name );
+
+			// check to see if the decal should be added
+			total = DecalListAdd( pList, total );
+		}
+
+		if( gEngfuncs.drawFuncs->R_CreateStudioDecalList )
+		{
+			total += gEngfuncs.drawFuncs->R_CreateStudioDecalList( pList, total );
+		}
+	}
+
+	// sort the decals lowest depth first, so they can be re-applied in order
+	qsort( pList, total, sizeof( decallist_t ), DecalDepthCompare );
+
+	return total;
+}
+
+/*
+===============
+R_DecalRemoveAll
+
+remove all decals with specified texture
+===============
+*/
+void R_DecalRemoveAll( int textureIndex )
+{
+	decal_t	*pdecal;
+	int	i;
+
+	if( textureIndex < 0 || textureIndex >= MAX_TEXTURES )
+		return; // out of bounds
+
+	for( i = 0; i < gDecalCount; i++ )
+	{
+		pdecal = &gDecalPool[i];
+
+		// don't remove permanent decals
+		if( !textureIndex && FBitSet( pdecal->flags, FDECAL_PERMANENT ))
+			continue;
+
+		if( !textureIndex || ( pdecal->texture == textureIndex ))
+			R_DecalUnlink( pdecal );
+	}
+}
+
+/*
+===============
+R_EntityRemoveDecals
+
+remove all decals from specified entity
+===============
+*/
+void R_EntityRemoveDecals( model_t *mod )
+{
+	msurface_t	*psurf;
+	decal_t		*p;
+	int		i;
+
+	if( !mod || mod->type != mod_brush )
+		return;
+
+	psurf = &mod->surfaces[mod->firstmodelsurface];
+	for( i = 0; i < mod->nummodelsurfaces; i++, psurf++ )
+	{
+		for( p = psurf->pdecals; p; p = p->pnext )
+			R_DecalUnlink( p );
+	}
+}
+
+/*
+===============
+R_ClearAllDecals
+
+remove all decals from anything
+used for full decals restart 
+===============
+*/
+void R_ClearAllDecals( void )
+{
+	decal_t	*pdecal;
+	int	i;
+
+	// because gDecalCount may be zeroed after recach the decal limit
+	for( i = 0; i < MAX_RENDER_DECALS; i++ )
+	{
+		pdecal = &gDecalPool[i];
+		R_DecalUnlink( pdecal );
+	}
+
+	if( gEngfuncs.drawFuncs->R_ClearStudioDecals )
+	{
+		gEngfuncs.drawFuncs->R_ClearStudioDecals();
+	}
+}
diff --git a/r_local.h b/r_local.h
index 56c74af5..5ed57284 100644
--- a/r_local.h
+++ b/r_local.h
@@ -406,18 +406,18 @@ int R_CullModel( cl_entity_t *e, const vec3_t absmin, const vec3_t absmax );
 qboolean R_CullBox( const vec3_t mins, const vec3_t maxs );
 qboolean R_CullSphere( const vec3_t centre, const float radius );
 //int R_CullSurface( msurface_t *surf, gl_frustum_t *frustum, uint clipflags );
-
+#endif
 //
 // gl_decals.c
 //
 void DrawSurfaceDecals( msurface_t *fa, qboolean single, qboolean reverse );
 float *R_DecalSetupVerts( decal_t *pDecal, msurface_t *surf, int texture, int *outCount );
-void DrawSingleDecal( decal_t *pDecal, msurface_t *fa );
+//void DrawSingleDecal( decal_t *pDecal, msurface_t *fa );
 void R_EntityRemoveDecals( model_t *mod );
-void DrawDecalsBatch( void );
+//void DrawDecalsBatch( void );
 void R_ClearDecals( void );
 
-
+#if 0
 
 //
 // gl_drawhulls.c
@@ -1223,6 +1223,8 @@ extern cvar_t   *sw_stipplealpha;
 extern cvar_t   *sw_surfcacheoverride;
 extern cvar_t *sw_waterwarp;
 extern cvar_t   *sw_texfilt;
+extern cvar_t	*r_decals;
+
 
 extern vec3_t modelorg;
 extern vec3_t r_origin;
diff --git a/r_main.c b/r_main.c
index d58186c2..08249aab 100644
--- a/r_main.c
+++ b/r_main.c
@@ -104,6 +104,8 @@ cvar_t	*vid_gamma;
 cvar_t	*sw_lockpvs;
 //PGM
 
+cvar_t	*r_decals;
+
 
 mleaf_t		*r_viewleaf;
 int	r_viewcluster, r_oldviewcluster;
@@ -1925,7 +1927,7 @@ qboolean R_Init()
 	sw_texfilt = gEngfuncs.Cvar_Get ("sw_texfilt", "0", 0, "texture dither");
 	//r_lefthand = ri.Cvar_Get( "hand", "0", FCVAR_USERINFO | FCVAR_ARCHIVE );
 //	r_speeds = ri.Cvar_Get ("r_speeds", "0", 0);
-
+	r_decals = gEngfuncs.pfnGetCvarPointer( "r_decals", 0 );
 	//r_drawworld = ri.Cvar_Get ("r_drawworld", "1", 0);
 	//r_dspeeds = ri.Cvar_Get ("r_dspeeds", "0", 0);
 //	r_lightlevel = ri.Cvar_Get ("r_lightlevel", "0", 0);
diff --git a/r_surf.c b/r_surf.c
index 784ca161..3d7fc918 100644
--- a/r_surf.c
+++ b/r_surf.c
@@ -147,9 +147,9 @@ void R_AddDynamicLights( msurface_t *surf )
 
 				if( dist < minlight )
 				{
-					printf("dlight %f\n", dist);
+					//printf("dlight %f\n", dist);
 					//*(void**)0 = 0;
-					bl[0] +=  ((int)((rad - dist) * 256) * 7.5) / 256;
+					bl[0] +=  ((int)((rad - dist) * 256) * 7.5);
 					//bl[1] += ((int)((rad - dist) * 256) * 2.5) / 256;
 					//bl[2] += ((int)((rad - dist) * 256) * 2.5) / 256;
 				}
@@ -237,7 +237,7 @@ static void R_BuildLightMap(  )
 				t = 0;
 			if( t > 65535 * 3 )
 				t = 65535 * 3;
-			t = t * 31 / 65535 / 3;//(255*256 - t) >> (8 - VID_CBITS);
+			t = t / 2048 / 3;//(255*256 - t) >> (8 - VID_CBITS);
 
 			//if (t < (1 << 6))
 				//t = (1 << 6);
@@ -961,6 +961,127 @@ int D_log2 (int num)
 }
 
 //=============================================================================
+void R_DecalComputeBasis( msurface_t *surf, int flags, vec3_t textureSpaceBasis[3] );
+void R_DrawSurfaceDecals()
+{
+	msurface_t *fa = r_drawsurf.surf;
+	decal_t *p;
+
+	for( p = fa->pdecals; p; p = p->pnext)
+	{
+			pixel_t	*dest, *source;
+			vec4_t		textureU, textureV;
+			image_t *tex = R_GetTexture( p->texture );
+			int s1 = 0,t1 = 0, s2 = tex->width, t2 = tex->height;
+			unsigned int				height;
+			unsigned int				f, fstep;
+			int				skip;
+			pixel_t *buffer;
+			qboolean transparent;
+			int x, y, u,v, sv, w, h;
+			vec3_t basis[3];
+
+			Vector4Copy( fa->texinfo->vecs[0], textureU );
+			Vector4Copy( fa->texinfo->vecs[1], textureV );
+
+			R_DecalComputeBasis( fa, 0, basis );
+
+			w = fabs( tex->width  * DotProduct( textureU, basis[0] )) +
+					fabs( tex->height * DotProduct( textureU, basis[1] ));
+			h = fabs( tex->width  * DotProduct( textureV, basis[0] )) +
+					fabs( tex->height * DotProduct( textureV, basis[1] ));
+
+			// project decal center into the texture space of the surface
+			x = DotProduct( p->position, textureU ) + textureU[3] - fa->texturemins[0] - w/2;
+			y = DotProduct( p->position, textureV ) + textureV[3] - fa->texturemins[1] - h/2;
+
+			x = x >> r_drawsurf.surfmip;
+			y = y >> r_drawsurf.surfmip;
+			w = w >> r_drawsurf.surfmip;
+			h = h >> r_drawsurf.surfmip;
+
+			if( x < 0 )
+			{
+				s1 += (-x)*(s2-s1) / w;
+				x = 0;
+			}
+			if( x + w > r_drawsurf.surfwidth )
+			{
+				s2 -= (x + w - r_drawsurf.surfwidth) * (s2 - s1)/ w ;
+				w = r_drawsurf.surfwidth - x;
+			}
+			if( y + h > r_drawsurf.surfheight )
+			{
+				t2 -= (y + h - r_drawsurf.surfheight) * (t2 - t1) / h;
+				h = r_drawsurf.surfheight - y;
+			}
+
+			if( !tex->pixels[0] || s1 >= s2 || t1 >= t2 )
+				continue;
+
+			if( tex->alpha_pixels )
+			{
+				buffer = tex->alpha_pixels;
+				transparent = true;
+			}
+			else
+				buffer = tex->pixels[0];
+
+			height = h;
+			if (y < 0)
+			{
+				skip = -y;
+				height += y;
+				y = 0;
+			}
+			else
+				skip = 0;
+
+			dest = ((pixel_t*)r_drawsurf.surfdat) + y * r_drawsurf.rowbytes + x;
+
+			for (v=0 ; v<height ; v++)
+			{
+				//int alpha1 = vid.alpha;
+				sv = (skip + v)*(t2-t1)/h + t1;
+				source = buffer + sv*tex->width + s1;
+
+				{
+					f = 0;
+					fstep = s2*0x10000/w;
+					if( w == s2 - s1 )
+						fstep = 0x10000;
+
+					for (u=0 ; u<w ; u++)
+					{
+						pixel_t src = source[f>>16];
+						int alpha = 7;
+						f += fstep;
+
+						if( transparent )
+						{
+							alpha &= src >> 16 - 3;
+							src = src << 3;
+						}
+
+						if( alpha <= 0 )
+							continue;
+
+						if( alpha < 7) // && (vid.rendermode == kRenderTransAlpha || vid.rendermode == kRenderTransTexture ) )
+						{
+							pixel_t screen = dest[u]; //  | 0xff & screen & src ;
+							dest[u] = vid.alphamap[( alpha << 16)|(src & 0xff00)|(screen>>8)] << 8 | (screen & 0xff) | ((src & 0xff) >> 3);
+
+						}
+						else
+							dest[u] = src;
+
+					}
+				}
+				dest += r_drawsurf.rowbytes;
+			}
+	}
+
+}
 
 /*
 ================
@@ -1054,6 +1175,7 @@ surfcache_t *D_CacheSurface (msurface_t *surface, int miplevel)
 	
 	// rasterize the surface into the cache
 	R_DrawSurface ();
+	R_DrawSurfaceDecals();
 
 	return cache;
 }