ref: common: wscript: fix psvita build

engine/client/cl_frame.c

@@ -981,15 +981,8 @@ qboolean CL_AddVisibleEntity( cl_entity_t *ent, int entityType )
 	if( !draw_player )
 		return false;
 
-	if( entityType == ET_BEAM )
-	{
-		ref.dllFuncs.CL_AddCustomBeam( ent );
-		return true;
-	}
-	else if( !ref.dllFuncs.R_AddEntity( ent, entityType ))
-	{
+	if( !ref.dllFuncs.R_AddEntity( ent, entityType ))
 		return false;
-	}
 
 	// because pTemp->entity.curstate.effects
 	// is already occupied by FTENT_FLICKER

engine/client/cl_game.c

@@ -374,13 +374,13 @@ static void SPR_DrawGeneric( int frame, float x, float y, float width, float hei
 		int	w, h;
 
 		// assume we get sizes from image
-		ref.dllFuncs.R_GetSpriteParms( &w, &h, NULL, frame, clgame.ds.pSprite );
+		R_GetSpriteParms( &w, &h, NULL, frame, clgame.ds.pSprite );
 
 		width = w;
 		height = h;
 	}
 
-	texnum = ref.dllFuncs.R_GetSpriteTexture( clgame.ds.pSprite, frame );
+	texnum = R_GetSpriteTexture( clgame.ds.pSprite, frame );
 
 	if( prc )
 	{
@@ -1424,7 +1424,7 @@ int EXPORT pfnSPR_Frames( HSPRITE hPic )
 {
 	int	numFrames = 0;
 
-	ref.dllFuncs.R_GetSpriteParms( NULL, NULL, &numFrames, 0, CL_GetSpritePointer( hPic ));
+	R_GetSpriteParms( NULL, NULL, &numFrames, 0, CL_GetSpritePointer( hPic ));
 
 	return numFrames;
 }
@@ -1439,7 +1439,7 @@ static int GAME_EXPORT pfnSPR_Height( HSPRITE hPic, int frame )
 {
 	int	sprHeight = 0;
 
-	ref.dllFuncs.R_GetSpriteParms( NULL, &sprHeight, NULL, frame, CL_GetSpritePointer( hPic ));
+	R_GetSpriteParms( NULL, &sprHeight, NULL, frame, CL_GetSpritePointer( hPic ));
 
 	return sprHeight;
 }
@@ -1454,7 +1454,7 @@ static int GAME_EXPORT pfnSPR_Width( HSPRITE hPic, int frame )
 {
 	int	sprWidth = 0;
 
-	ref.dllFuncs.R_GetSpriteParms( &sprWidth, NULL, NULL, frame, CL_GetSpritePointer( hPic ));
+	R_GetSpriteParms( &sprWidth, NULL, NULL, frame, CL_GetSpritePointer( hPic ));
 
 	return sprWidth;
 }
@@ -3324,7 +3324,7 @@ int TriSpriteTexture( model_t *pSpriteModel, int frame )
 {
 	int	gl_texturenum;
 
-	if(( gl_texturenum = ref.dllFuncs.R_GetSpriteTexture( pSpriteModel, frame )) <= 0 )
+	if(( gl_texturenum = R_GetSpriteTexture( pSpriteModel, frame )) <= 0 )
 		return 0;
 
 	ref.dllFuncs.GL_Bind( XASH_TEXTURE0, gl_texturenum );

engine/client/cl_sprite.c

@@ -0,0 +1,360 @@
+/*
+cl_sprite.c - sprite loading
+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 "common.h"
+#include "client.h"
+#include "sprite.h"
+#include "ref_common.h"
+
+static char  sprite_name[MAX_QPATH];
+static char  group_suffix[8];
+static uint  r_texFlags = 0;
+static int   sprite_version;
+
+/*
+================
+R_GetSpriteFrame
+
+assume pModel is valid
+================
+*/
+mspriteframe_t *R_GetSpriteFrame( const model_t *pModel, int frame, float yaw )
+{
+	msprite_t      *psprite;
+	mspritegroup_t *pspritegroup;
+	mspriteframe_t *pspriteframe = NULL;
+	float          *pintervals, fullinterval;
+	int             i, numframes;
+	float           targettime;
+
+	if( !pModel )
+		return NULL;
+
+	psprite = pModel->cache.data;
+
+	if( frame < 0 )
+	{
+		frame = 0;
+	}
+	else if( frame >= psprite->numframes )
+	{
+		if( frame > psprite->numframes )
+			Con_Printf( S_WARN "%s: no such frame %d (%s)\n", __func__, frame, pModel->name );
+		frame = psprite->numframes - 1;
+	}
+
+	if( psprite->frames[frame].type == SPR_SINGLE )
+	{
+		pspriteframe = psprite->frames[frame].frameptr;
+	}
+	else if( psprite->frames[frame].type == SPR_GROUP )
+	{
+		pspritegroup = (mspritegroup_t *)psprite->frames[frame].frameptr;
+		pintervals = pspritegroup->intervals;
+		numframes = pspritegroup->numframes;
+		fullinterval = pintervals[numframes - 1];
+
+		// when loading in Mod_LoadSpriteGroup, we guaranteed all interval values
+		// are positive, so we don't have to worry about division by zero
+		targettime = cl.time - ((int)( cl.time / fullinterval )) * fullinterval;
+
+		for( i = 0; i < ( numframes - 1 ); i++ )
+		{
+			if( pintervals[i] > targettime )
+				break;
+		}
+		pspriteframe = pspritegroup->frames[i];
+	}
+	else if( psprite->frames[frame].type == FRAME_ANGLED )
+	{
+		int angleframe = (int)( Q_rint(( refState.viewangles[1] - yaw + 45.0f ) / 360 * 8 ) - 4 ) & 7;
+
+		// e.g. doom-style sprite monsters
+		pspritegroup = (mspritegroup_t *)psprite->frames[frame].frameptr;
+		pspriteframe = pspritegroup->frames[angleframe];
+	}
+
+	return pspriteframe;
+}
+
+void R_GetSpriteParms( int *frameWidth, int *frameHeight, int *numFrames, int currentFrame, const model_t *pSprite )
+{
+	mspriteframe_t *pFrame;
+
+	if( !pSprite || pSprite->type != mod_sprite )
+		return;
+
+	pFrame = R_GetSpriteFrame( pSprite, currentFrame, 0.0f );
+
+	if( frameWidth )
+		*frameWidth = pFrame->width;
+	if( frameHeight )
+		*frameHeight = pFrame->height;
+	if( numFrames )
+		*numFrames = pSprite->numframes;
+}
+
+int R_GetSpriteTexture( const model_t *m_pSpriteModel, int frame )
+{
+	if( !m_pSpriteModel || m_pSpriteModel->type != mod_sprite || !m_pSpriteModel->cache.data )
+		return 0;
+
+	return R_GetSpriteFrame( m_pSpriteModel, frame, 0.0f )->gl_texturenum;
+}
+
+static void Mod_SpriteTextureReplacementReport( const char *modelname, int gl_texturenum, const char *foundpath )
+{
+	if( host_allow_materials.value != 2.0f )
+		return;
+
+	if( gl_texturenum > 0 )
+		Con_Printf( "Looking for %s tex replacement..." S_GREEN "OK (%s)\n", modelname, foundpath );
+	else if( gl_texturenum < 0 )
+		Con_Printf( "Looking for %s tex replacement..." S_YELLOW "MISS (%s)\n", modelname, foundpath );
+	else
+		Con_Printf( "Looking for %s tex replacement..." S_RED "FAIL (%s)\n", modelname, foundpath );
+}
+
+static qboolean Mod_SpriteSearchForTextureReplacement( char *out, size_t size, const char *modelname, const char *fmt, ... )
+{
+	va_list ap;
+	int ret;
+
+	va_start( ap, fmt );
+	ret = Q_vsnprintf( out, size, fmt, ap );
+	va_end( ap );
+
+	if( ret < 0 )
+	{
+		Mod_SpriteTextureReplacementReport( modelname, -1, "overflow" );
+		return false;
+	}
+
+	if( FS_FileExists( out, false ))
+		return true;
+
+	Mod_SpriteTextureReplacementReport( modelname, -1, out );
+	return false;
+}
+
+static const byte *Mod_SpriteLoadFrame( model_t *mod, const void *pin, mspriteframe_t **ppframe, int num )
+{
+	dspriteframe_t pinframe;
+	mspriteframe_t *pspriteframe;
+	int gl_texturenum = 0;
+	char texname[128];
+	int bytes = 1;
+
+	memcpy( &pinframe, pin, sizeof( dspriteframe_t ));
+
+	if( sprite_version == SPRITE_VERSION_32 )
+		bytes = 4;
+
+	// build unique frame name
+	if( FBitSet( mod->flags, MODEL_CLIENT )) // it's a HUD sprite
+	{
+		Q_snprintf( texname, sizeof( texname ), "#HUD/%s(%s:%i%i).spr", sprite_name, group_suffix, num / 10, num % 10 );
+		gl_texturenum = ref.dllFuncs.GL_LoadTexture( texname, pin, pinframe.width * pinframe.height * bytes, r_texFlags );
+	}
+	else
+	{
+		// partial HD-textures support
+		if( Mod_AllowMaterials( ))
+		{
+			if( Mod_SpriteSearchForTextureReplacement( texname, sizeof( texname ), sprite_name, "materials/%s/%s%i%i.tga", sprite_name, group_suffix, num / 10, num % 10 ))
+			{
+				gl_texturenum = ref.dllFuncs.GL_LoadTexture( texname, NULL, 0, r_texFlags );
+				Mod_SpriteTextureReplacementReport( sprite_name, gl_texturenum, texname );
+			}
+		}
+
+		if( gl_texturenum == 0 )
+		{
+			Q_snprintf( texname, sizeof( texname ), "#%s(%s:%i%i).spr", sprite_name, group_suffix, num / 10, num % 10 );
+			gl_texturenum = ref.dllFuncs.GL_LoadTexture( texname, pin, pinframe.width * pinframe.height * bytes, r_texFlags );
+		}
+	}
+
+	// setup frame description
+	pspriteframe = Mem_Malloc( mod->mempool, sizeof( mspriteframe_t ));
+	pspriteframe->width = pinframe.width;
+	pspriteframe->height = pinframe.height;
+	pspriteframe->up = pinframe.origin[1];
+	pspriteframe->left = pinframe.origin[0];
+	pspriteframe->down = pinframe.origin[1] - pinframe.height;
+	pspriteframe->right = pinframe.width + pinframe.origin[0];
+	pspriteframe->gl_texturenum = gl_texturenum;
+	*ppframe = pspriteframe;
+
+	return (const byte *)pin + sizeof( dspriteframe_t ) + pinframe.width * pinframe.height * bytes;
+}
+
+static const byte *Mod_SpriteLoadGroup( model_t *mod, const void *pin, mspriteframe_t **ppframe, int framenum )
+{
+	const dspritegroup_t    *pingroup;
+	mspritegroup_t          *pspritegroup;
+	const dspriteinterval_t *pin_intervals;
+	float      *poutintervals;
+	int         i, groupsize, numframes;
+	const void *ptemp;
+
+	pingroup = (const dspritegroup_t *)pin;
+	numframes = pingroup->numframes;
+
+	groupsize = sizeof( mspritegroup_t ) + ( numframes - 1 ) * sizeof( pspritegroup->frames[0] );
+	pspritegroup = Mem_Calloc( mod->mempool, groupsize );
+	pspritegroup->numframes = numframes;
+
+	*ppframe = (mspriteframe_t *)pspritegroup;
+	pin_intervals = (const dspriteinterval_t *)( pingroup + 1 );
+	poutintervals = Mem_Calloc( mod->mempool, numframes * sizeof( float ));
+	pspritegroup->intervals = poutintervals;
+
+	for( i = 0; i < numframes; i++ )
+	{
+		*poutintervals = pin_intervals->interval;
+		if( *poutintervals <= 0.0f )
+			*poutintervals = 1.0f; // set error value
+		poutintervals++;
+		pin_intervals++;
+	}
+
+	ptemp = (const void *)pin_intervals;
+	for( i = 0; i < numframes; i++ )
+	{
+		ptemp = Mod_SpriteLoadFrame( mod, ptemp, &pspritegroup->frames[i], framenum * 10 + i );
+	}
+
+	return ptemp;
+}
+
+void Mod_SpriteLoadTextures( model_t *mod, const void *buffer )
+{
+	const dsprite_t *pin = buffer;
+	const short     *numi = NULL;
+	const byte      *pframetype;
+	msprite_t       *psprite = mod->cache.data;
+	int i;
+
+	if( pin->version == SPRITE_VERSION_Q1 || pin->version == SPRITE_VERSION_32 )
+		numi = NULL;
+	else if( pin->version == SPRITE_VERSION_HL )
+		numi = (const short *)((const byte *)buffer + sizeof( dsprite_hl_t ));
+
+	r_texFlags = mod->numtexinfo;
+	sprite_version = pin->version;
+	Q_strncpy( sprite_name, mod->name, sizeof( sprite_name ));
+	COM_StripExtension( sprite_name );
+
+	if( numi == NULL )
+	{
+		rgbdata_t *pal;
+
+		pal = FS_LoadImage( "#id.pal", (byte *)&i, 768 );
+		pframetype = (const byte *)buffer + sizeof( dsprite_q1_t );
+		FS_FreeImage( pal );
+	}
+	else if( *numi <= 256 )
+	{
+		const byte *src = (const byte *)( numi + 1 );
+		rgbdata_t  *pal;
+		size_t      pal_bytes = *numi * 3;
+
+		// install palette
+		switch( psprite->texFormat )
+		{
+		case SPR_INDEXALPHA:
+			pal = FS_LoadImage( "#gradient.pal", src, pal_bytes );
+			break;
+		case SPR_ALPHTEST:
+			pal = FS_LoadImage( "#masked.pal", src, pal_bytes );
+			break;
+		default:
+			pal = FS_LoadImage( "#texgamma.pal", src, pal_bytes );
+			break;
+		}
+
+		pframetype = (const byte *)( src + pal_bytes );
+		FS_FreeImage( pal );
+	}
+	else
+	{
+		Con_DPrintf( S_ERROR "%s has wrong number of palette colors %i (should be less or equal than 256)\n", mod->name, *numi );
+		return;
+	}
+
+	if( mod->numframes < 1 )
+		return;
+
+	for( i = 0; i < mod->numframes; i++ )
+	{
+		frametype_t  frametype;
+		dframetype_t dframetype;
+
+		memcpy( &dframetype, pframetype, sizeof( dframetype ));
+		frametype = dframetype.type;
+		psprite->frames[i].type = (spriteframetype_t)frametype;
+
+		switch( frametype )
+		{
+		case FRAME_SINGLE:
+			Q_strncpy( group_suffix, "frame", sizeof( group_suffix ));
+			pframetype = Mod_SpriteLoadFrame( mod, pframetype + sizeof( dframetype_t ), &psprite->frames[i].frameptr, i );
+			break;
+		case FRAME_GROUP:
+			Q_strncpy( group_suffix, "group", sizeof( group_suffix ));
+			pframetype = Mod_SpriteLoadGroup( mod, pframetype + sizeof( dframetype_t ), &psprite->frames[i].frameptr, i );
+			break;
+		case FRAME_ANGLED:
+			Q_strncpy( group_suffix, "angle", sizeof( group_suffix ));
+			pframetype = Mod_SpriteLoadGroup( mod, pframetype + sizeof( dframetype_t ), &psprite->frames[i].frameptr, i );
+			break;
+		}
+		if( pframetype == NULL )
+			break;
+	}
+}
+
+void Mod_SpriteUnloadTextures( void *data )
+{
+	msprite_t *psprite = data;
+	int i;
+
+	if( !data )
+		return;
+
+	// release all textures
+	for( i = 0; i < psprite->numframes; i++ )
+	{
+		if( !psprite->frames[i].frameptr )
+			continue;
+
+		if( psprite->frames[i].type == SPR_SINGLE )
+		{
+			ref.dllFuncs.GL_FreeTexture( psprite->frames[i].frameptr->gl_texturenum );
+		}
+		else
+		{
+			mspritegroup_t *pspritegroup = (mspritegroup_t *)psprite->frames[i].frameptr;
+			int j;
+
+			for( j = 0; j < pspritegroup->numframes; j++ )
+			{
+				if( pspritegroup->frames[j] )
+					ref.dllFuncs.GL_FreeTexture( pspritegroup->frames[j]->gl_texturenum );
+			}
+		}
+	}
+}

engine/client/client.h

@@ -972,6 +972,13 @@ void SCR_DrawPos( void );
 void SCR_DrawEnts( void );
 void SCR_DrawUserCmd( void );
 
+//
+// cl_sprite.c
+//
+mspriteframe_t *R_GetSpriteFrame( const model_t *pModel, int frame, float yaw );
+void R_GetSpriteParms( int *frameWidth, int *frameHeight, int *numFrames, int currentFrame, const model_t *pSprite );
+int R_GetSpriteTexture( const model_t *m_pSpriteModel, int frame );
+
 //
 // cl_netgraph.c
 //

engine/client/ref_common.c

@@ -465,6 +465,7 @@ static const ref_api_t gEngfuncs =
 	&g_fsapi,
 
 	R_GetWindowHandle,
+	R_GetSpriteFrame,
 };
 
 static void R_UnloadProgs( void )

engine/common/mod_local.h

@@ -197,6 +197,8 @@ void Mod_ClearStudioCache( void );
 // mod_sprite.c
 //
 void Mod_LoadSpriteModel( model_t *mod, const void *buffer, size_t buffersize, qboolean *loaded );
-#endif
+void Mod_SpriteLoadTextures( model_t *mod, const void *buffer );
+void Mod_SpriteUnloadTextures( void *data );
 
+#endif
 #endif//MOD_LOCAL_H

engine/common/mod_sprite.c

@@ -17,9 +17,6 @@ GNU General Public License for more details.
 #include "common.h"
 #include "sprite.h"
 #include "studio.h"
-#if !XASH_DEDICATED
-#include "ref_common.h"
-#endif // XASH_DEDICATED
 #include "mod_local.h"
 
 
@@ -147,4 +144,8 @@ void Mod_LoadSpriteModel( model_t *mod, const void *buffer, size_t buffersize, q
 		psprite->numframes = 0;
 		return;
 	}
+
+#if !XASH_DEDICATED
+	Mod_SpriteLoadTextures( mod, buffer );
+#endif
 }

engine/common/model.c

@@ -88,6 +88,22 @@ static void Mod_Modellist_f( void )
 	Con_Printf( "\n" );
 }
 
+static void Mod_UnloadRenderData( model_t *mod )
+{
+#if !XASH_DEDICATED
+	switch( mod->type )
+	{
+	case mod_sprite:
+		Mod_SpriteUnloadTextures( mod->cache.data );
+		break;
+	default:
+		break;
+	}
+
+	ref.dllFuncs.Mod_ProcessRenderData( mod, false, NULL, 0 );
+#endif
+}
+
 /*
 ================
 Mod_FreeUserData
@@ -107,12 +123,10 @@ static void Mod_FreeUserData( model_t *mod )
 			svgame.physFuncs.Mod_ProcessUserData( mod, false, NULL );
 		}
 	}
-#if !XASH_DEDICATED
 	else
 	{
-		ref.dllFuncs.Mod_ProcessRenderData( mod, false, NULL, 0 );
+		Mod_UnloadRenderData( mod );
 	}
-#endif
 }
 
 /*

engine/ref_api.h

@@ -19,11 +19,11 @@ GNU General Public License for more details.
 #include <stdarg.h>
 #include "com_image.h"
 #include "vgui_api.h"
+#include "const.h"
+#include "com_model.h"
+#include "cl_entity.h"
 #include "render_api.h"
 #include "triangleapi.h"
-#include "const.h"
-#include "cl_entity.h"
-#include "com_model.h"
 #include "studio.h"
 #include "r_efx.h"
 #include "filesystem.h"
@@ -62,7 +62,9 @@ GNU General Public License for more details.
 // 11. Added size argument to Mod_ProcessRenderData
 // 12. Added Image_CalcImageSize
 // 13. Removed ignore_flags argument from GetCvarPointer
-#define REF_API_VERSION 13
+// 14. Removed reserved functions, they are leftover from RenderAPI
+//     Removed CL_AddCustomBeam, it's now handled through R_AddEntity
+#define REF_API_VERSION 14
 
 #define TF_SKY		(TF_SKYSIDE|TF_NOMIPMAP|TF_ALLOW_NEAREST)
 #define TF_FONT		(TF_NOMIPMAP|TF_CLAMP|TF_ALLOW_NEAREST)
@@ -499,6 +501,9 @@ typedef struct ref_api_s
 
 	// for abstracting the engine's rendering
 	ref_window_type_t (*R_GetWindowHandle)( void **handle, ref_window_type_t type );
+
+	// sprites
+	struct mspriteframe_s *(*R_GetSpriteFrame)( const struct model_s *pModel, int frame, float yaw );
 } ref_api_t;
 
 struct mip_s;
@@ -533,7 +538,6 @@ typedef struct ref_interface_s
 	void (*GL_SetRenderMode)( int renderMode );
 
 	qboolean (*R_AddEntity)( struct cl_entity_s *clent, int type );
-	void (*CL_AddCustomBeam)( cl_entity_t *pEnvBeam );
 	void (*R_ProcessEntData)( qboolean allocate, cl_entity_t *entities, unsigned int max_entities );
 	void (*R_Flush)( unsigned int flush_flags );
 
@@ -577,9 +581,6 @@ typedef struct ref_interface_s
 	void (*GL_SubdivideSurface)( model_t *mod, msurface_t *fa );
 	void (*CL_RunLightStyles)( lightstyle_t *ls );
 
-	// sprites
-	void (*R_GetSpriteParms)( int *frameWidth, int *frameHeight, int *numFrames, int currentFrame, const model_t *pSprite );
-	int (*R_GetSpriteTexture)( const model_t *m_pSpriteModel, int frame );
 
 	// model management
 	// flags ignored for everything except spritemodels
@@ -632,8 +633,6 @@ typedef struct ref_interface_s
 	void		(*GL_TextureTarget)( unsigned int target ); // change texture unit mode without bind texture
 	void		(*GL_TexCoordArrayMode)( unsigned int texmode );
 	void		(*GL_UpdateTexSize)( int texnum, int width, int height, int depth ); // recalc statistics
-	void		(*GL_Reserved0)( void );	// for potential interface expansion without broken compatibility
-	void		(*GL_Reserved1)( void );
 
 	// Misc renderer functions
 	void		(*GL_DrawParticles)( const struct ref_viewpass_s *rvp, qboolean trans_pass, float frametime );

ref/common/ref_common.h

@@ -0,0 +1,91 @@
+/*
+ref_common.h - shared renderer code
+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.
+*/
+
+#ifndef REF_COMMON_H
+#define REF_COMMON_H
+
+#include "xash3d_mathlib.h"
+#include "ref_api.h"
+
+//
+// ref_context.c
+//
+extern ref_api_t      gEngfuncs;
+extern ref_globals_t *gpGlobals;
+extern ref_client_t  *gp_cl;
+extern ref_host_t    *gp_host;
+extern const ref_interface_t gReffuncs;
+
+DECLARE_ENGINE_SHARED_CVAR_LIST()
+
+#define Assert( x ) if( !( x )) gEngfuncs.Host_Error( "assert failed at %s:%i\n", __FILE__, __LINE__ )
+
+#define ENGINE_GET_PARM_ (*gEngfuncs.EngineGetParm)
+#define ENGINE_GET_PARM( parm ) ENGINE_GET_PARM_( (parm), 0 )
+
+extern uint16_t rtable[MOD_FRAMES][MOD_FRAMES];
+void GL_InitRandomTable( void );
+
+void _Mem_Free( void *data, const char *filename, int fileline );
+void *_Mem_Alloc( poolhandle_t poolptr, size_t size, qboolean clear, const char *filename, int fileline )
+	ALLOC_CHECK( 2 ) MALLOC_LIKE( _Mem_Free, 1 ) WARN_UNUSED_RESULT;
+void *_Mem_Realloc( poolhandle_t poolptr, void *memptr, size_t size, qboolean clear, const char *filename, int fileline )
+	ALLOC_CHECK( 3 ) WARN_UNUSED_RESULT;
+
+#define Mem_Malloc( pool, size )       _Mem_Alloc( pool, size, false, __FILE__, __LINE__ )
+#define Mem_Calloc( pool, size )       _Mem_Alloc( pool, size, true, __FILE__, __LINE__ )
+#define Mem_Realloc( pool, ptr, size ) _Mem_Realloc( pool, ptr, size, true, __FILE__, __LINE__ )
+#define Mem_Free( mem )                _Mem_Free( mem, __FILE__, __LINE__ )
+#define Mem_AllocPool( name )          gEngfuncs._Mem_AllocPool( name, __FILE__, __LINE__ )
+#define Mem_FreePool( pool )           gEngfuncs._Mem_FreePool( pool, __FILE__, __LINE__ )
+#define Mem_EmptyPool( pool )          gEngfuncs._Mem_EmptyPool( pool, __FILE__, __LINE__ )
+
+extern dlight_t *gp_dlights;
+extern int g_lightstylevalue[MAX_LIGHTSTYLES];
+extern poolhandle_t r_temppool;
+
+//
+// ref_common cvars
+//
+extern convar_t r_dlight_virtual_radius;
+extern convar_t r_lighting_extended;
+
+//
+// ref_math.c
+//
+void Matrix4x4_Concat( matrix4x4 out, const matrix4x4 in1, const matrix4x4 in2 );
+void Matrix4x4_ConcatTranslate( matrix4x4 out, float x, float y, float z );
+void Matrix4x4_ConcatRotate( matrix4x4 out, float angle, float x, float y, float z );
+void Matrix4x4_CreateProjection( matrix4x4 out, float xMax, float xMin, float yMax, float yMin, float zNear, float zFar );
+void Matrix4x4_CreateOrtho( matrix4x4 m, float xLeft, float xRight, float yBottom, float yTop, float zNear, float zFar );
+void Matrix4x4_CreateModelview( matrix4x4 out );
+void Matrix4x4_ToArrayFloatGL( const matrix4x4 in, float out[16] );
+
+//
+// ref_light.c
+//
+void CL_RunLightStyles( lightstyle_t *ls );
+void R_PushDlightsForBmodel( model_t *model, int framecount, const matrix4x4 object_matrix );
+int R_PushDlights( model_t *model, int framecount );
+colorVec R_LightVec( const vec3_t start, const vec3_t end, vec3_t lspot, vec3_t lvec );
+colorVec R_LightPoint( const vec3_t p0 );
+void R_UpdateSurfaceCachedLight( msurface_t *surf );
+
+//
+// ref_image.c
+//
+byte *GL_ResampleTexture( const byte *source, int in_w, int in_h, int out_w, int out_h, qboolean isNormalMap );
+
+#endif // REF_COMMON_H

ref/common/ref_context.c

@@ -0,0 +1,81 @@
+/*
+ref_context.c - shared renderer context
+Copyright (C) 2018 a1batross
+
+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 "ref_common.h"
+#include "com_strings.h"
+
+DEFINE_ENGINE_SHARED_CVAR_LIST()
+
+ref_api_t      gEngfuncs;
+ref_globals_t *gpGlobals;
+ref_client_t  *gp_cl;
+ref_host_t    *gp_host;
+uint16_t       rtable[MOD_FRAMES][MOD_FRAMES];
+dlight_t      *gp_dlights;
+int            g_lightstylevalue[MAX_LIGHTSTYLES];
+poolhandle_t   r_temppool;
+
+void _Mem_Free( void *data, const char *filename, int fileline )
+{
+	gEngfuncs._Mem_Free( data, filename, fileline );
+}
+
+void *_Mem_Alloc( poolhandle_t poolptr, size_t size, qboolean clear, const char *filename, int fileline )
+{
+	return gEngfuncs._Mem_Alloc( poolptr, size, clear, filename, fileline );
+}
+
+void *_Mem_Realloc( poolhandle_t poolptr, void *memptr, size_t size, qboolean clear, const char *filename, int fileline )
+{
+	return gEngfuncs._Mem_Realloc( poolptr, memptr, size, clear, filename, fileline );
+}
+
+void GL_InitRandomTable( void )
+{
+	int tu, tv;
+
+	for( tu = 0; tu < MOD_FRAMES; tu++ )
+	{
+		for( tv = 0; tv < MOD_FRAMES; tv++ )
+		{
+			rtable[tu][tv] = gEngfuncs.COM_RandomLong( 0, 0x7FFF );
+		}
+	}
+
+	gEngfuncs.COM_SetRandomSeed( 0 );
+}
+
+int EXPORT GetRefAPI( int version, ref_interface_t *funcs, ref_api_t *engfuncs, ref_globals_t *globals );
+int EXPORT GetRefAPI( int version, ref_interface_t *funcs, ref_api_t *engfuncs, ref_globals_t *globals )
+{
+	if( version != REF_API_VERSION )
+		return 0;
+
+	// fill in our callbacks
+	*funcs = gReffuncs;
+	gEngfuncs = *engfuncs;
+	gpGlobals = globals;
+
+	gp_cl = (ref_client_t *)ENGINE_GET_PARM( PARM_GET_CLIENT_PTR );
+	gp_host = (ref_host_t *)ENGINE_GET_PARM( PARM_GET_HOST_PTR );
+	gp_dlights = (dlight_t *)ENGINE_GET_PARM( PARM_GET_DLIGHTS_PTR );
+
+	RETRIEVE_ENGINE_SHARED_CVAR_LIST();
+
+	gEngfuncs.Cvar_RegisterVariable( &r_dlight_virtual_radius );
+	gEngfuncs.Cvar_RegisterVariable( &r_lighting_extended );
+
+	return REF_API_VERSION;
+}

ref/common/ref_image.c

@@ -0,0 +1,108 @@
+/*
+ref_image.c - shared image code
+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 "ref_common.h"
+#include "xash3d_mathlib.h"
+
+/*
+================
+GL_ResampleTexture
+
+Assume input buffer is RGBA
+=================
+*/
+byte *GL_ResampleTexture( const byte *source, int inWidth, int inHeight, int outWidth, int outHeight, qboolean isNormalMap )
+{
+	uint		frac, fracStep;
+	uint		*in = (uint *)source;
+	uint		p1[0x1000], p2[0x1000];
+	byte		*pix1, *pix2, *pix3, *pix4;
+	uint		*out, *inRow1, *inRow2;
+	static byte	*scaledImage = NULL;	// pointer to a scaled image
+	vec3_t		normal;
+	int		i, x, y;
+
+	if( !source ) return NULL;
+
+	scaledImage = Mem_Realloc( r_temppool, scaledImage, outWidth * outHeight * 4 );
+	fracStep = inWidth * 0x10000 / outWidth;
+	out = (uint *)scaledImage;
+
+	frac = fracStep >> 2;
+	for( i = 0; i < outWidth; i++ )
+	{
+		p1[i] = 4 * (frac >> 16);
+		frac += fracStep;
+	}
+
+	frac = (fracStep >> 2) * 3;
+	for( i = 0; i < outWidth; i++ )
+	{
+		p2[i] = 4 * (frac >> 16);
+		frac += fracStep;
+	}
+
+	if( isNormalMap )
+	{
+		for( y = 0; y < outHeight; y++, out += outWidth )
+		{
+			inRow1 = in + inWidth * (int)(((float)y + 0.25f) * inHeight / outHeight);
+			inRow2 = in + inWidth * (int)(((float)y + 0.75f) * inHeight / outHeight);
+
+			for( x = 0; x < outWidth; x++ )
+			{
+				pix1 = (byte *)inRow1 + p1[x];
+				pix2 = (byte *)inRow1 + p2[x];
+				pix3 = (byte *)inRow2 + p1[x];
+				pix4 = (byte *)inRow2 + p2[x];
+
+				normal[0] = MAKE_SIGNED( pix1[0] ) + MAKE_SIGNED( pix2[0] ) + MAKE_SIGNED( pix3[0] ) + MAKE_SIGNED( pix4[0] );
+				normal[1] = MAKE_SIGNED( pix1[1] ) + MAKE_SIGNED( pix2[1] ) + MAKE_SIGNED( pix3[1] ) + MAKE_SIGNED( pix4[1] );
+				normal[2] = MAKE_SIGNED( pix1[2] ) + MAKE_SIGNED( pix2[2] ) + MAKE_SIGNED( pix3[2] ) + MAKE_SIGNED( pix4[2] );
+
+				if( !VectorNormalizeLength( normal ))
+					VectorSet( normal, 0.5f, 0.5f, 1.0f );
+
+				((byte *)(out+x))[0] = 128 + (byte)(127.0f * normal[0]);
+				((byte *)(out+x))[1] = 128 + (byte)(127.0f * normal[1]);
+				((byte *)(out+x))[2] = 128 + (byte)(127.0f * normal[2]);
+				((byte *)(out+x))[3] = 255;
+			}
+		}
+	}
+	else
+	{
+		for( y = 0; y < outHeight; y++, out += outWidth )
+		{
+			inRow1 = in + inWidth * (int)(((float)y + 0.25f) * inHeight / outHeight);
+			inRow2 = in + inWidth * (int)(((float)y + 0.75f) * inHeight / outHeight);
+
+			for( x = 0; x < outWidth; x++ )
+			{
+				pix1 = (byte *)inRow1 + p1[x];
+				pix2 = (byte *)inRow1 + p2[x];
+				pix3 = (byte *)inRow2 + p1[x];
+				pix4 = (byte *)inRow2 + p2[x];
+
+				((byte *)(out+x))[0] = (pix1[0] + pix2[0] + pix3[0] + pix4[0]) >> 2;
+				((byte *)(out+x))[1] = (pix1[1] + pix2[1] + pix3[1] + pix4[1]) >> 2;
+				((byte *)(out+x))[2] = (pix1[2] + pix2[2] + pix3[2] + pix4[2]) >> 2;
+				((byte *)(out+x))[3] = (pix1[3] + pix2[3] + pix3[3] + pix4[3]) >> 2;
+			}
+		}
+	}
+
+	return scaledImage;
+}

ref/common/ref_light.c

@@ -1,5 +1,5 @@
 /*
-gl_rlight.c - dynamic and static lights
+ref_light.c - shared light code
 Copyright (C) 2010 Uncle Mike
 
 This program is free software: you can redistribute it and/or modify
@@ -13,19 +13,13 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 */
 
-#include "gl_local.h"
-#include "pm_local.h"
-#include "studio.h"
+#include "ref_common.h"
 #include "xash3d_mathlib.h"
-#include "ref_params.h"
+#include "pm_local.h"
 
-/*
-=============================================================================
+CVAR_DEFINE_AUTO( r_dlight_virtual_radius, "3", FCVAR_GLCONFIG, "increase dlight radius virtually by this amount" );
+CVAR_DEFINE_AUTO( r_lighting_extended, "1", FCVAR_GLCONFIG, "allow to get lighting from world and bmodels" );
 
-DYNAMIC LIGHTS
-
-=============================================================================
-*/
 /*
 ==================
 CL_RunLightStyles
@@ -34,16 +28,17 @@ CL_RunLightStyles
 */
 void CL_RunLightStyles( lightstyle_t *ls )
 {
+	const model_t *world = gp_cl->models[1];
 	int i;
-	float frametime = (gp_cl->time - gp_cl->oldtime);
+	float frametime = gp_cl->time - gp_cl->oldtime;
 
-	if( !WORLDMODEL )
+	if( !world )
 		return;
 
-	if( !WORLDMODEL->lightdata )
+	if( r_fullbright->value || !world->lightdata )
 	{
 		for( i = 0; i < MAX_LIGHTSTYLES; i++ )
-			tr.lightstylevalue[i] = 256 * 256;
+			g_lightstylevalue[i] = 256 * 256;
 		return;
 	}
 
@@ -59,13 +54,13 @@ void CL_RunLightStyles( lightstyle_t *ls )
 
 		if( !ls[i].length )
 		{
-			tr.lightstylevalue[i] = 256;
+			g_lightstylevalue[i] = 256;
 			continue;
 		}
 		else if( ls[i].length == 1 )
 		{
 			// single length style so don't bother interpolating
-			tr.lightstylevalue[i] = ( ls[i].map[0] ) * 22;
+			g_lightstylevalue[i] = ls[i].map[0] * 22;
 			continue;
 		}
 
@@ -73,7 +68,7 @@ void CL_RunLightStyles( lightstyle_t *ls )
 
 		if( !ls[i].interp || !cl_lightstyle_lerping->value )
 		{
-			tr.lightstylevalue[i] = ls[i].map[flight%ls[i].length] * 22;
+			g_lightstylevalue[i] = ls[i].map[flight % ls[i].length] * 22;
 			continue;
 		}
 
@@ -90,7 +85,7 @@ void CL_RunLightStyles( lightstyle_t *ls )
 		k = ls[i].map[clight % ls[i].length];
 		l += (float)( k * 22.0f ) * lerpfrac;
 
-		tr.lightstylevalue[i] = (int)l;
+		g_lightstylevalue[i] = (int)l;
 	}
 }
 
@@ -99,44 +94,39 @@ void CL_RunLightStyles( lightstyle_t *ls )
 R_MarkLights
 =============
 */
-void R_MarkLights( const dlight_t *light, int bit, const mnode_t *node )
+static void R_MarkLights( const dlight_t *light, int bit, const mnode_t *node, model_t *model, int dlightframecount )
 {
 	const float virtual_radius = light->radius * Q_max( 1.0f, r_dlight_virtual_radius.value );
 	const float maxdist = light->radius * light->radius;
-	float dist;
-	int i;
-	int firstsurface, numsurfaces;
-
 start:
-
 	if( !node || node->contents < 0 )
 		return;
 
-	dist = PlaneDiff( light->origin, node->plane );
+	float dist = PlaneDiff( light->origin, node->plane );
 
 	if( dist > virtual_radius )
 	{
-		node = node_child( node, 0, RI.currentmodel );
+		node = node_child( node, 0, model );
 		goto start;
 	}
 
 	if( dist < -virtual_radius )
 	{
-		node = node_child( node, 1, RI.currentmodel );
+		node = node_child( node, 1, model );
 		goto start;
 	}
 
 	const float dist_sq = dist * dist;
 
 	// mark the polygons
-	firstsurface = node_firstsurface( node, RI.currentmodel );
-	numsurfaces = node_numsurfaces( node, RI.currentmodel );
+	int firstsurface = node_firstsurface( node, model );
+	int numsurfaces = node_numsurfaces( node, model );
 
-	for( i = 0; i < numsurfaces && dist_sq < maxdist; i++ )
+	for( int i = 0; i < numsurfaces && dist_sq < maxdist; i++ )
 	{
 		vec3_t impact;
 		float s, t, l;
-		msurface_t *surf = &RI.currentmodel->surfaces[firstsurface + i];
+		msurface_t *surf = &model->surfaces[firstsurface + i];
 		const mextrasurf_t *info = surf->info;
 
 		if( surf->plane->type < 3 )
@@ -162,16 +152,17 @@ start:
 		if( s * s + t * t + dist_sq >= maxdist )
 			continue;
 
-		if( surf->dlightframe != tr.dlightframecount )
+		if( surf->dlightframe != dlightframecount )
 		{
 			surf->dlightbits = bit;
-			surf->dlightframe = tr.dlightframecount;
+			surf->dlightframe = dlightframecount;
 		}
 		else surf->dlightbits |= bit;
 	}
 
-	R_MarkLights( light, bit, node_child( node, 0, RI.currentmodel ));
-	R_MarkLights( light, bit, node_child( node, 1, RI.currentmodel ));
+	R_MarkLights( light, bit, node_child( node, 0, model ), model, dlightframecount );
+	node = node_child( node, 1, model );
+	goto start;
 }
 
 /*
@@ -179,31 +170,40 @@ start:
 R_PushDlights
 =============
 */
-void R_PushDlights( void )
+int R_PushDlights( model_t *model, int framecount )
 {
-	int	i;
+	if( !model )
+		return framecount;
 
-	tr.dlightframecount = tr.framecount;
-
-	RI.currententity = CL_GetEntityByIndex( 0 );
-
-	// no world -- no dlights
-	if( !RI.currententity )
-		return;
-
-	RI.currentmodel = RI.currententity->model;
-
-	for( i = 0; i < MAX_DLIGHTS; i++ )
+	for( int i = 0; i < MAX_DLIGHTS; i++ )
 	{
-		dlight_t *l = &tr.dlights[i];
+		const dlight_t *l = &gp_dlights[i];
 
 		if( l->die < gp_cl->time || !l->radius )
 			continue;
 
-		if( GL_FrustumCullSphere( &RI.frustum, l->origin, l->radius, 15 ))
+		R_MarkLights( l, 1 << i, model->nodes, model, framecount );
+	}
+
+	return framecount;
+}
+
+void R_PushDlightsForBmodel( model_t *model, int framecount, const matrix4x4 object_matrix )
+{
+	for( int i = 0; i < MAX_DLIGHTS; i++ )
+	{
+		dlight_t *l = &gp_dlights[i];
+
+		if( l->die < gp_cl->time || !l->radius )
 			continue;
 
-		R_MarkLights( l, 1<<i, RI.currentmodel->nodes );
+		vec3_t oldorigin;
+		VectorCopy( l->origin, oldorigin );
+
+		Matrix4x4_VectorITransform( object_matrix, oldorigin, l->origin );
+		R_MarkLights( l, 1 << i, model->nodes + model->hulls[0].firstclipnode, model, framecount );
+
+		VectorCopy( oldorigin, l->origin );
 	}
 }
 
@@ -225,18 +225,7 @@ R_RecursiveLightPoint
 */
 static qboolean R_RecursiveLightPoint( model_t *model, mnode_t *node, float p1f, float p2f, colorVec *cv, const vec3_t start, const vec3_t end )
 {
-	float		front, back, frac, midf;
-	int		i, map, side, size;
-	float		ds, dt, s, t;
-	int		sample_size;
-	color24		*lm, *dm;
-	mextrasurf_t	*info;
-	msurface_t	*surf;
-	mtexinfo_t	*tex;
-	matrix3x4		tbn;
-	vec3_t		mid;
-	int firstsurface, numsurfaces;
-
+start:
 	// didn't hit anything
 	if( !node || node->contents < 0 )
 	{
@@ -244,21 +233,23 @@ static qboolean R_RecursiveLightPoint( model_t *model, mnode_t *node, float p1f,
 		return false;
 	}
 
-	firstsurface = node_firstsurface( node, model );
-	numsurfaces = node_numsurfaces( node, model );
-
 	// calculate mid point
-	front = PlaneDiff( start, node->plane );
-	back = PlaneDiff( end, node->plane );
+	float front = PlaneDiff( start, node->plane );
+	float back = PlaneDiff( end, node->plane );
 
-	side = front < 0;
+	int side = front < 0;
 	if(( back < 0 ) == side )
-		return R_RecursiveLightPoint( model, node_child( node, side, model ), p1f, p2f, cv, start, end );
+	{
+		node = node_child( node, side, model );
+		goto start;
+	}
 
-	frac = front / ( front - back );
+	float frac = front / ( front - back );
 
+	vec3_t mid;
 	VectorLerp( start, frac, end, mid );
-	midf = p1f + ( p2f - p1f ) * frac;
+
+	float midf = p1f + ( p2f - p1f ) * frac;
 
 	// co down front side
 	if( R_RecursiveLightPoint( model, node_child( node, side, model ), p1f, midf, cv, start, mid ))
@@ -271,27 +262,27 @@ static qboolean R_RecursiveLightPoint( model_t *model, mnode_t *node, float p1f,
 	}
 
 	// check for impact on this node
-	surf = model->surfaces + firstsurface;
+	int firstsurface = node_firstsurface( node, model );
+	int numsurfaces = node_numsurfaces( node, model );
+
 	VectorCopy( mid, g_trace_lightspot );
 
-	for( i = 0; i < numsurfaces; i++, surf++ )
+	for( int i = 0; i < numsurfaces; i++ )
 	{
-		int	smax, tmax;
-
-		tex = surf->texinfo;
-		info = surf->info;
+		const msurface_t *surf = &model->surfaces[firstsurface + i];
+		const mextrasurf_t *info = surf->info;
 
 		if( FBitSet( surf->flags, SURF_DRAWTILED ))
 			continue;	// no lightmaps
 
-		s = DotProduct( mid, info->lmvecs[0] ) + info->lmvecs[0][3];
-		t = DotProduct( mid, info->lmvecs[1] ) + info->lmvecs[1][3];
+		float s = DotProduct( mid, info->lmvecs[0] ) + info->lmvecs[0][3];
+		float t = DotProduct( mid, info->lmvecs[1] ) + info->lmvecs[1][3];
 
 		if( s < info->lightmapmins[0] || t < info->lightmapmins[1] )
 			continue;
 
-		ds = s - info->lightmapmins[0];
-		dt = t - info->lightmapmins[1];
+		float ds = s - info->lightmapmins[0];
+		float dt = t - info->lightmapmins[1];
 
 		if ( ds > info->lightextents[0] || dt > info->lightextents[1] )
 			continue;
@@ -301,21 +292,25 @@ static qboolean R_RecursiveLightPoint( model_t *model, mnode_t *node, float p1f,
 		if( !surf->samples )
 			return true;
 
-		sample_size = gEngfuncs.Mod_SampleSizeForFace( surf );
-		smax = (info->lightextents[0] / sample_size) + 1;
-		tmax = (info->lightextents[1] / sample_size) + 1;
+		int sample_size = gEngfuncs.Mod_SampleSizeForFace( surf );
+		int smax = (info->lightextents[0] / sample_size) + 1;
+		int tmax = (info->lightextents[1] / sample_size) + 1;
+
 		ds /= sample_size;
 		dt /= sample_size;
 
-		lm = surf->samples + Q_rint( dt ) * smax + Q_rint( ds );
 		g_trace_fraction = midf;
-		size = smax * tmax;
-		dm = NULL;
+
+		const color24 *lm = surf->samples + Q_rint( dt ) * smax + Q_rint( ds );
+		const color24 *dm = NULL;
+		matrix3x4 tbn;
 
 		if( surf->info->deluxemap )
 		{
 			vec3_t	faceNormal;
 
+			dm = surf->info->deluxemap + Q_rint( dt ) * smax + Q_rint( ds );
+
 			if( FBitSet( surf->flags, SURF_PLANEBACK ))
 				VectorNegate( surf->plane->normal, faceNormal );
 			else VectorCopy( surf->plane->normal, faceNormal );
@@ -333,12 +328,13 @@ static qboolean R_RecursiveLightPoint( model_t *model, mnode_t *node, float p1f,
 			VectorNormalize( tbn[0] );
 			VectorNormalize( tbn[1] );
 			VectorNormalize( tbn[2] );
-			dm = surf->info->deluxemap + Q_rint( dt ) * smax + Q_rint( ds );
 		}
 
-		for( map = 0; map < MAXLIGHTMAPS && surf->styles[map] != 255; map++ )
+		int size = smax * tmax;
+
+		for( int map = 0; map < MAXLIGHTMAPS && surf->styles[map] != 255; map++ )
 		{
-			uint	scale = tr.lightstylevalue[surf->styles[map]];
+			uint	scale = g_lightstylevalue[surf->styles[map]];
 
 			cv->r += lm->r * scale;
 			cv->g += lm->g * scale;
@@ -368,83 +364,75 @@ static qboolean R_RecursiveLightPoint( model_t *model, mnode_t *node, float p1f,
 
 /*
 =================
-R_LightVec
+R_LightVecInternal
 
 check bspmodels to get light from
 =================
 */
 static colorVec R_LightVecInternal( const vec3_t start, const vec3_t end, vec3_t lspot, vec3_t lvec )
 {
-	float	last_fraction;
-	int	i, maxEnts = 1;
-	colorVec	light, cv;
+	if( lspot )
+		VectorClear( lspot );
 
-	if( lspot ) VectorClear( lspot );
-	if( lvec ) VectorClear( lvec );
+	if( lvec )
+		VectorClear( lvec );
 
-	if( WORLDMODEL && WORLDMODEL->lightdata )
+	if( !gp_cl->models[1] || !gp_cl->models[1]->lightdata )
+		return (colorVec){ 255, 255, 255, 0 };
+
+	float last_fraction = 1.0f;
+	int max_ents = r_lighting_extended.value ? MAX_PHYSENTS : 1; // get light from bmodels too
+	colorVec light = { 0 };
+
+	// check all the bsp-models
+	for( int i = 0; i < max_ents; i++ )
 	{
-		light.r = light.g = light.b = light.a = 0;
-		last_fraction = 1.0f;
+		const physent_t *pe = gEngfuncs.EV_GetPhysent( i );
 
-		// get light from bmodels too
-		if( r_lighting_extended.value )
-			maxEnts = MAX_PHYSENTS;
+		if( !pe )
+			break;
 
-		// check all the bsp-models
-		for( i = 0; i < maxEnts; i++ )
+		if( !pe->model || pe->model->type != mod_brush )
+			continue; // skip non-bsp models
+
+		mnode_t *pnodes = &pe->model->nodes[pe->model->hulls[0].firstclipnode];
+		vec3_t offset, start_l, end_l;
+
+		VectorSubtract( pe->model->hulls[0].clip_mins, vec3_origin, offset );
+		VectorAdd( offset, pe->origin, offset );
+		VectorSubtract( start, offset, start_l );
+		VectorSubtract( end, offset, end_l );
+
+		// rotate start and end into the models frame of reference
+		if( !VectorIsNull( pe->angles ))
 		{
-			physent_t	*pe = gEngfuncs.EV_GetPhysent( i );
-			vec3_t	offset, start_l, end_l;
-			mnode_t	*pnodes;
-			matrix4x4	matrix;
-
-			if( !pe )
-				break;
-
-			if( !pe->model || pe->model->type != mod_brush )
-				continue; // skip non-bsp models
-
-			pnodes = &pe->model->nodes[pe->model->hulls[0].firstclipnode];
-			VectorSubtract( pe->model->hulls[0].clip_mins, vec3_origin, offset );
-			VectorAdd( offset, pe->origin, offset );
-			VectorSubtract( start, offset, start_l );
-			VectorSubtract( end, offset, end_l );
-
-			// rotate start and end into the models frame of reference
-			if( !VectorIsNull( pe->angles ))
-			{
-				Matrix4x4_CreateFromEntity( matrix, pe->angles, offset, 1.0f );
-				Matrix4x4_VectorITransform( matrix, start, start_l );
-				Matrix4x4_VectorITransform( matrix, end, end_l );
-			}
-
-			VectorClear( g_trace_lightspot );
-			VectorClear( g_trace_lightvec );
-			g_trace_fraction = 1.0f;
-
-			if( !R_RecursiveLightPoint( pe->model, pnodes, 0.0f, 1.0f, &cv, start_l, end_l ))
-				continue;	// didn't hit anything
-
-			if( g_trace_fraction < last_fraction )
-			{
-				if( lspot ) VectorCopy( g_trace_lightspot, lspot );
-				if( lvec ) VectorNormalize2( g_trace_lightvec, lvec );
-
-				light.r = Q_min(( cv.r >> 8 ), 255 );
-				light.g = Q_min(( cv.g >> 8 ), 255 );
-				light.b = Q_min(( cv.b >> 8 ), 255 );
-				last_fraction = g_trace_fraction;
-
-				if(( light.r + light.g + light.b ) != 0 )
-					break; // we get light now
-			}
+			matrix4x4 matrix;
+			Matrix4x4_CreateFromEntity( matrix, pe->angles, offset, 1.0f );
+			Matrix4x4_VectorITransform( matrix, start, start_l );
+			Matrix4x4_VectorITransform( matrix, end, end_l );
+		}
+
+		VectorClear( g_trace_lightspot );
+		VectorClear( g_trace_lightvec );
+		g_trace_fraction = 1.0f;
+
+		colorVec cv;
+		if( !R_RecursiveLightPoint( pe->model, pnodes, 0.0f, 1.0f, &cv, start_l, end_l ))
+			continue;	// didn't hit anything
+
+		if( g_trace_fraction < last_fraction )
+		{
+			if( lspot ) VectorCopy( g_trace_lightspot, lspot );
+			if( lvec ) VectorNormalize2( g_trace_lightvec, lvec );
+
+			light.r = Q_min(( cv.r >> 8 ), 255 );
+			light.g = Q_min(( cv.g >> 8 ), 255 );
+			light.b = Q_min(( cv.b >> 8 ), 255 );
+			last_fraction = g_trace_fraction;
+
+			if(( light.r + light.g + light.b ) != 0 )
+				break; // we get light now
 		}
-	}
-	else
-	{
-		light.r = light.g = light.b = 255;
-		light.a = 0;
 	}
 
 	return light;
@@ -459,7 +447,7 @@ check bspmodels to get light from
 */
 colorVec R_LightVec( const vec3_t start, const vec3_t end, vec3_t lspot, vec3_t lvec )
 {
-	colorVec	light = R_LightVecInternal( start, end, lspot, lvec );
+	colorVec light = R_LightVecInternal( start, end, lspot, lvec );
 
 	if( r_lighting_extended.value && lspot != NULL && lvec != NULL )
 	{
@@ -480,9 +468,20 @@ light from floor
 */
 colorVec R_LightPoint( const vec3_t p0 )
 {
-	vec3_t	p1;
+	vec3_t p1;
 
 	VectorSet( p1, p0[0], p0[1], p0[2] - 2048.0f );
 
 	return R_LightVec( p0, p1, NULL, NULL );
 }
+
+/*
+================
+R_SetCacheState
+================
+*/
+void R_UpdateSurfaceCachedLight( msurface_t *surf )
+{
+	for( int i = 0; i < MAXLIGHTMAPS && surf->styles[i] != 255; i++ )
+		surf->cached_light[i] = g_lightstylevalue[surf->styles[i]];
+}

ref/common/ref_math.c

@@ -1,5 +1,5 @@
 /*
-gl_rmath.c - renderer mathlib
+ref_math.c - renderer mathlib
 Copyright (C) 2010 Uncle Mike
 
 This program is free software: you can redistribute it and/or modify
@@ -13,8 +13,7 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 */
 
-#include "r_local.h"
-#include "xash3d_mathlib.h"
+#include "ref_common.h"
 
 /*
 ========================================================================
@@ -99,7 +98,27 @@ void Matrix4x4_CreateModelview( matrix4x4 out )
 	out[1][2] = 1.0f;
 }
 
-void Matrix4x4_CreateTranslate( matrix4x4 out, float x, float y, float z )
+void Matrix4x4_ToArrayFloatGL( const matrix4x4 in, float out[16] )
+{
+	out[ 0] = in[0][0];
+	out[ 1] = in[1][0];
+	out[ 2] = in[2][0];
+	out[ 3] = in[3][0];
+	out[ 4] = in[0][1];
+	out[ 5] = in[1][1];
+	out[ 6] = in[2][1];
+	out[ 7] = in[3][1];
+	out[ 8] = in[0][2];
+	out[ 9] = in[1][2];
+	out[10] = in[2][2];
+	out[11] = in[3][2];
+	out[12] = in[0][3];
+	out[13] = in[1][3];
+	out[14] = in[2][3];
+	out[15] = in[3][3];
+}
+
+static void Matrix4x4_CreateTranslate( matrix4x4 out, float x, float y, float z )
 {
 	out[0][0] = 1.0f;
 	out[0][1] = 0.0f;
@@ -119,7 +138,7 @@ void Matrix4x4_CreateTranslate( matrix4x4 out, float x, float y, float z )
 	out[3][3] = 1.0f;
 }
 
-void Matrix4x4_CreateRotate( matrix4x4 out, float angle, float x, float y, float z )
+static void Matrix4x4_CreateRotate( matrix4x4 out, float angle, float x, float y, float z )
 {
 	float len, c, s;
 

ref/common/wscript

@@ -0,0 +1,27 @@
+#! /usr/bin/env python
+# encoding: utf-8
+
+def options(opt):
+	pass
+
+def configure(conf):
+	pass
+
+def build(bld):
+	use = ['engine_includes', 'sdk_includes', 'werror']
+
+	# FIXME: figure out why psvita needs it and how can we avoid it
+	if bld.env.DEST_OS == 'psvita':
+		bld.env.CFLAGS_cstlib.remove('-fno-PIC')
+		bld.env.CFLAGS += ['-fPIC']
+	else:
+		use += ['public']
+
+	bld.stlib(source = bld.path.ant_glob('*.c'),
+		target = 'ref_common',
+		includes = '.',
+		export_includes = '.',
+		defines = 'REF_DLL=1',
+		use = use,
+		subsystem = bld.env.MSVC_SUBSYSTEM
+	)

ref/gl/gl_alias.c

@@ -684,7 +684,7 @@ static void R_AliasDynamicLight( cl_entity_t *ent, alight_t *plight )
 
 	for( lnum = 0; lnum < MAX_DLIGHTS; lnum++ )
 	{
-		const dlight_t *dl = &tr.dlights[lnum];
+		const dlight_t *dl = &gp_dlights[lnum];
 
 		if( dl->die < g_alias.time || !r_dynamic->value )
 			continue;

ref/gl/gl_beams.c

@@ -151,28 +151,6 @@ qboolean R_BeamCull( const vec3_t start, const vec3_t end, qboolean pvsOnly )
 	return true;
 }
 
-/*
-================
-CL_AddCustomBeam
-
-Add the beam that encoded as custom entity
-================
-*/
-void CL_AddCustomBeam( cl_entity_t *pEnvBeam )
-{
-	if( tr.draw_list->num_beam_entities >= MAX_VISIBLE_PACKET )
-	{
-		gEngfuncs.Con_Printf( S_ERROR "Too many beams %d!\n", tr.draw_list->num_beam_entities );
-		return;
-	}
-
-	if( pEnvBeam )
-	{
-		tr.draw_list->beam_entities[tr.draw_list->num_beam_entities] = pEnvBeam;
-		tr.draw_list->num_beam_entities++;
-	}
-}
-
 
 /*
 ==============================================================

ref/gl/gl_context.c

@@ -22,20 +22,7 @@ GNU General Public License for more details.
 #include "gl4es/include/gl4esinit.h"
 #endif
 
-ref_api_t      gEngfuncs;
-ref_globals_t *gpGlobals;
-ref_client_t  *gp_cl;
-ref_host_t    *gp_host;
 
-void _Mem_Free( void *data, const char *filename, int fileline )
-{
-	gEngfuncs._Mem_Free( data, filename, fileline );
-}
-
-void *_Mem_Alloc( poolhandle_t poolptr, size_t size, qboolean clear, const char *filename, int fileline )
-{
-	return gEngfuncs._Mem_Alloc( poolptr, size, clear, filename, fileline );
-}
 
 static void R_ClearScreen( void )
 {
@@ -132,7 +119,6 @@ static void Mod_UnloadTextures( model_t *mod )
 		Mod_BrushUnloadTextures( mod );
 		break;
 	case mod_sprite:
-		Mod_SpriteUnloadTextures( mod->cache.data );
 		break;
 	default:
 		Assert( 0 );
@@ -159,7 +145,7 @@ static qboolean Mod_ProcessRenderData( model_t *mod, qboolean create, const byte
 		loaded = true;
 		break;
 	case mod_sprite:
-		Mod_LoadSpriteModel( mod, buf, &loaded, mod->numtexinfo );
+		loaded = true;
 		break;
 	case mod_alias:
 		Mod_LoadAliasModel( mod, buf, &loaded );
@@ -228,7 +214,7 @@ static int GL_RefGetParm( int parm, int arg )
 		return glState.activeTMU;
 	case PARM_LIGHTSTYLEVALUE:
 		arg = bound( 0, arg, MAX_LIGHTSTYLES - 1 );
-		return tr.lightstylevalue[arg];
+		return g_lightstylevalue[arg];
 	case PARM_MAX_IMAGE_UNITS:
 		return GL_MaxTextureUnits();
 	case PARM_REBUILD_GAMMA:
@@ -427,7 +413,7 @@ static const char *R_GetConfigName( void )
 	return "opengl";
 }
 
-static const ref_interface_t gReffuncs =
+const ref_interface_t gReffuncs =
 {
 	R_Init,
 	R_Shutdown,
@@ -452,7 +438,6 @@ static const ref_interface_t gReffuncs =
 	GL_SetRenderMode,
 
 	R_AddEntity,
-	CL_AddCustomBeam,
 	R_ProcessEntData,
 	R_Flush,
 
@@ -487,8 +472,6 @@ static const ref_interface_t gReffuncs =
 	GL_SubdivideSurface,
 	CL_RunLightStyles,
 
-	R_GetSpriteParms,
-	R_GetSpriteTexture,
 
 	Mod_ProcessRenderData,
 	Mod_StudioLoadTextures,
@@ -531,8 +514,6 @@ static const ref_interface_t gReffuncs =
 	GL_TextureTarget,
 	GL_SetTexCoordArrayMode,
 	GL_UpdateTexSize,
-	NULL,
-	NULL,
 
 	CL_DrawParticlesExternal,
 	R_LightVec,
@@ -564,19 +545,3 @@ static const ref_interface_t gReffuncs =
 	VGUI_UploadTextureBlock,
 };
 
-int EXPORT GetRefAPI( int version, ref_interface_t *funcs, ref_api_t *engfuncs, ref_globals_t *globals );
-int EXPORT GetRefAPI( int version, ref_interface_t *funcs, ref_api_t *engfuncs, ref_globals_t *globals )
-{
-	if( version != REF_API_VERSION )
-		return 0;
-
-	// fill in our callbacks
-	*funcs = gReffuncs;
-	gEngfuncs = *engfuncs;
-	gpGlobals = globals;
-
-	gp_cl = (ref_client_t *)ENGINE_GET_PARM( PARM_GET_CLIENT_PTR );
-	gp_host = (ref_host_t *)ENGINE_GET_PARM( PARM_GET_HOST_PTR );
-
-	return REF_API_VERSION;
-}

ref/gl/gl_draw.c

@@ -29,34 +29,6 @@ void R_GetTextureParms( int *w, int *h, int texnum )
 	if( h ) *h = glt->srcHeight;
 }
 
-/*
-=============
-R_GetSpriteParms
-
-same as GetImageParms but used
-for sprite models
-=============
-*/
-void R_GetSpriteParms( int *frameWidth, int *frameHeight, int *numFrames, int currentFrame, const model_t *pSprite )
-{
-	mspriteframe_t	*pFrame;
-
-	if( !pSprite || pSprite->type != mod_sprite ) return; // bad model ?
-	pFrame = R_GetSpriteFrame( pSprite, currentFrame, 0.0f );
-
-	if( frameWidth ) *frameWidth = pFrame->width;
-	if( frameHeight ) *frameHeight = pFrame->height;
-	if( numFrames ) *numFrames = pSprite->numframes;
-}
-
-int R_GetSpriteTexture( const model_t *m_pSpriteModel, int frame )
-{
-	if( !m_pSpriteModel || m_pSpriteModel->type != mod_sprite || !m_pSpriteModel->cache.data )
-		return 0;
-
-	return R_GetSpriteFrame( m_pSpriteModel, frame, 0.0f )->gl_texturenum;
-}
-
 /*
 =============
 R_DrawStretchPic

ref/gl/gl_image.c

@@ -691,97 +691,6 @@ static void GL_SetTextureFormat( gl_texture_t *tex, pixformat_t format, int chan
 	}
 }
 
-/*
-=================
-GL_ResampleTexture
-
-Assume input buffer is RGBA
-=================
-*/
-byte *GL_ResampleTexture( const byte *source, int inWidth, int inHeight, int outWidth, int outHeight, qboolean isNormalMap )
-{
-	uint		frac, fracStep;
-	uint		*in = (uint *)source;
-	uint		p1[0x1000], p2[0x1000];
-	byte		*pix1, *pix2, *pix3, *pix4;
-	uint		*out, *inRow1, *inRow2;
-	static byte	*scaledImage = NULL;	// pointer to a scaled image
-	vec3_t		normal;
-	int		i, x, y;
-
-	if( !source ) return NULL;
-
-	scaledImage = Mem_Realloc( r_temppool, scaledImage, outWidth * outHeight * 4 );
-	fracStep = inWidth * 0x10000 / outWidth;
-	out = (uint *)scaledImage;
-
-	frac = fracStep >> 2;
-	for( i = 0; i < outWidth; i++ )
-	{
-		p1[i] = 4 * (frac >> 16);
-		frac += fracStep;
-	}
-
-	frac = (fracStep >> 2) * 3;
-	for( i = 0; i < outWidth; i++ )
-	{
-		p2[i] = 4 * (frac >> 16);
-		frac += fracStep;
-	}
-
-	if( isNormalMap )
-	{
-		for( y = 0; y < outHeight; y++, out += outWidth )
-		{
-			inRow1 = in + inWidth * (int)(((float)y + 0.25f) * inHeight / outHeight);
-			inRow2 = in + inWidth * (int)(((float)y + 0.75f) * inHeight / outHeight);
-
-			for( x = 0; x < outWidth; x++ )
-			{
-				pix1 = (byte *)inRow1 + p1[x];
-				pix2 = (byte *)inRow1 + p2[x];
-				pix3 = (byte *)inRow2 + p1[x];
-				pix4 = (byte *)inRow2 + p2[x];
-
-				normal[0] = MAKE_SIGNED( pix1[0] ) + MAKE_SIGNED( pix2[0] ) + MAKE_SIGNED( pix3[0] ) + MAKE_SIGNED( pix4[0] );
-				normal[1] = MAKE_SIGNED( pix1[1] ) + MAKE_SIGNED( pix2[1] ) + MAKE_SIGNED( pix3[1] ) + MAKE_SIGNED( pix4[1] );
-				normal[2] = MAKE_SIGNED( pix1[2] ) + MAKE_SIGNED( pix2[2] ) + MAKE_SIGNED( pix3[2] ) + MAKE_SIGNED( pix4[2] );
-
-				if( !VectorNormalizeLength( normal ))
-					VectorSet( normal, 0.5f, 0.5f, 1.0f );
-
-				((byte *)(out+x))[0] = 128 + (byte)(127.0f * normal[0]);
-				((byte *)(out+x))[1] = 128 + (byte)(127.0f * normal[1]);
-				((byte *)(out+x))[2] = 128 + (byte)(127.0f * normal[2]);
-				((byte *)(out+x))[3] = 255;
-			}
-		}
-	}
-	else
-	{
-		for( y = 0; y < outHeight; y++, out += outWidth )
-		{
-			inRow1 = in + inWidth * (int)(((float)y + 0.25f) * inHeight / outHeight);
-			inRow2 = in + inWidth * (int)(((float)y + 0.75f) * inHeight / outHeight);
-
-			for( x = 0; x < outWidth; x++ )
-			{
-				pix1 = (byte *)inRow1 + p1[x];
-				pix2 = (byte *)inRow1 + p2[x];
-				pix3 = (byte *)inRow2 + p1[x];
-				pix4 = (byte *)inRow2 + p2[x];
-
-				((byte *)(out+x))[0] = (pix1[0] + pix2[0] + pix3[0] + pix4[0]) >> 2;
-				((byte *)(out+x))[1] = (pix1[1] + pix2[1] + pix3[1] + pix4[1]) >> 2;
-				((byte *)(out+x))[2] = (pix1[2] + pix2[2] + pix3[2] + pix4[2]) >> 2;
-				((byte *)(out+x))[3] = (pix1[3] + pix2[3] + pix3[3] + pix4[3]) >> 2;
-			}
-		}
-	}
-
-	return scaledImage;
-}
-
 /*
 =================
 GL_BoxFilter3x3

ref/gl/gl_local.h

@@ -15,17 +15,12 @@ GNU General Public License for more details.
 
 #ifndef GL_LOCAL_H
 #define GL_LOCAL_H
+#include "ref_common.h"
 #include "port.h"
 #include "xash3d_types.h"
 #include "cvardef.h"
-#include "const.h"
-#include "com_model.h"
-#include "cl_entity.h"
-#include "render_api.h"
 #include "protocol.h"
 #include "gl_frustum.h"
-#include "ref_api.h"
-#include "xash3d_mathlib.h"
 #include "ref_params.h"
 #include "enginefeatures.h"
 #include "com_strings.h"
@@ -52,7 +47,6 @@ void VGL_ShimEndFrame( void );
 #endif
 #endif
 
-#define Assert(x) if(!( x )) gEngfuncs.Host_Error( "assert failed at %s:%i\n", __FILE__, __LINE__ )
 
 #include <stdio.h>
 
@@ -60,7 +54,6 @@ void VGL_ShimEndFrame( void );
 #define LM_SAMPLE_SIZE             16
 
 
-extern poolhandle_t r_temppool;
 
 #define BLOCK_SIZE		tr.block_size	// lightmap blocksize
 #define BLOCK_SIZE_DEFAULT	128		// for keep backward compatibility
@@ -239,7 +232,6 @@ typedef struct
 	qboolean		fFlipViewModel;
 
 	byte		visbytes[(MAX_MAP_LEAFS+7)/8];	// member custom PVS
-	int		lightstylevalue[MAX_LIGHTSTYLES];	// value 0 - 65536
 	int		block_size;			// lightmap blocksize
 
 	double		frametime;	// special frametime for multipass rendering (will set to 0 on a nextview)
@@ -255,7 +247,6 @@ typedef struct
 	movevars_t *movevars;
 	color24 *palette;
 	cl_entity_t *viewent;
-	dlight_t *dlights;
 	dlight_t *elights;
 	byte *texgammatable;
 	uint *lightgammatable;
@@ -359,7 +350,6 @@ gl_texture_t *R_GetTexture( unsigned int texnum );
 int GL_LoadTexture( const char *name, const byte *buf, size_t size, int flags );
 int GL_LoadTextureArray( const char **names, int flags );
 int GL_LoadTextureFromBuffer( const char *name, rgbdata_t *pic, texFlags_t flags, qboolean update );
-byte *GL_ResampleTexture( const byte *source, int in_w, int in_h, int out_w, int out_h, qboolean isNormalMap );
 int GL_CreateTexture( const char *name, int width, int height, const void *buffer, texFlags_t flags );
 int GL_CreateTextureArray( const char *name, int width, int height, int depth, const void *buffer, texFlags_t flags );
 void GL_ProcessTexture( int texnum, float gamma, int topColor, int bottomColor );
@@ -377,16 +367,6 @@ qboolean R_SearchForTextureReplacement( char *out, size_t size, const char *mode
 void R_TextureReplacementReport( const char *modelname, int gl_texturenum, const char *foundpath );
 void R_ShowTextures( void );
 
-//
-// gl_rlight.c
-//
-void CL_RunLightStyles( lightstyle_t *ls );
-void R_PushDlights( void );
-void R_GetLightSpot( vec3_t lightspot );
-void R_MarkLights( const dlight_t *light, int bit, const mnode_t *node );
-colorVec R_LightVec( const vec3_t start, const vec3_t end, vec3_t lightspot, vec3_t lightvec );
-colorVec R_LightPoint( const vec3_t p0 );
-
 //
 // gl_rmain.c
 //
@@ -407,17 +387,6 @@ void R_PopScene( void );
 void R_DrawFog( void );
 int CL_FxBlend( cl_entity_t *e );
 
-//
-// gl_rmath.c
-//
-void Matrix4x4_ToArrayFloatGL( const matrix4x4 in, float out[16] );
-void Matrix4x4_Concat( matrix4x4 out, const matrix4x4 in1, const matrix4x4 in2 );
-void Matrix4x4_ConcatTranslate( matrix4x4 out, float x, float y, float z );
-void Matrix4x4_ConcatRotate( matrix4x4 out, float angle, float x, float y, float z );
-void Matrix4x4_CreateProjection(matrix4x4 out, float xMax, float xMin, float yMax, float yMin, float zNear, float zFar);
-void Matrix4x4_CreateOrtho(matrix4x4 m, float xLeft, float xRight, float yBottom, float yTop, float zNear, float zFar);
-void Matrix4x4_CreateModelview( matrix4x4 out );
-
 //
 // gl_rmisc.c
 //
@@ -434,7 +403,6 @@ void GL_SubdivideSurface( model_t *mod, msurface_t *fa );
 void GL_SetupFogColorForSurfaces( void );
 void R_DrawAlphaTextureChains( void );
 void GL_RebuildLightmaps( void );
-void GL_InitRandomTable( void );
 void GL_BuildLightmaps( void );
 void GL_ResetFogColor( void );
 void R_GenerateVBO( void );
@@ -456,9 +424,6 @@ void CL_DrawTracers( double frametime, particle_t *cl_active_tracers );
 //
 // gl_sprite.c
 //
-void R_SpriteInit( void );
-void Mod_LoadSpriteModel( model_t *mod, const void *buffer, qboolean *loaded, uint texFlags );
-mspriteframe_t *R_GetSpriteFrame( const model_t *pModel, int frame, float yaw );
 void R_DrawSpriteModel( cl_entity_t *e );
 
 //
@@ -517,7 +482,6 @@ void R_RenderFrame( const struct ref_viewpass_s *vp );
 void R_EndFrame( void );
 void R_ClearScene( void );
 void R_GetTextureParms( int *w, int *h, int texnum );
-void R_GetSpriteParms( int *frameWidth, int *frameHeight, int *numFrames, int curFrame, const struct model_s *pSprite );
 void R_DrawStretchRaw( float x, float y, float w, float h, int cols, int rows, const byte *data, qboolean dirty );
 void R_DrawStretchPic( float x, float y, float w, float h, float s1, float t1, float s2, float t2, int texnum );
 qboolean R_SpeedsMessage( char *out, size_t size );
@@ -525,20 +489,17 @@ qboolean R_CullBox( const vec3_t mins, const vec3_t maxs );
 int R_WorldToScreen( const vec3_t point, vec3_t screen );
 void R_ScreenToWorld( const vec3_t screen, vec3_t point );
 qboolean R_AddEntity( struct cl_entity_s *pRefEntity, int entityType );
-void Mod_SpriteUnloadTextures( void *data );
 void Mod_UnloadAliasModel( struct model_s *mod );
 void Mod_AliasUnloadTextures( void *data );
 void GL_SetRenderMode( int mode );
 void R_RunViewmodelEvents( void );
 void R_DrawViewModel( void );
-int R_GetSpriteTexture( const struct model_s *m_pSpriteModel, int frame );
 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 );
 void R_ClearAllDecals( void );
 byte *Mod_GetCurrentVis( void );
 void Mod_SetOrthoBounds( const float *mins, const float *maxs );
-void CL_AddCustomBeam( cl_entity_t *pEnvBeam );
 
 //
 // gl_opengl.c
@@ -698,13 +659,6 @@ extern glconfig_t		glConfig;
 extern glstate_t		glState;
 // move to engine
 extern glwstate_t		glw_state;
-extern ref_api_t      gEngfuncs;
-extern ref_globals_t *gpGlobals;
-extern ref_client_t  *gp_cl;
-extern ref_host_t    *gp_host;
-
-#define ENGINE_GET_PARM_ (*gEngfuncs.EngineGetParm)
-#define ENGINE_GET_PARM( parm ) ENGINE_GET_PARM_( ( parm ), 0 )
 
 //
 // helper funcs
@@ -794,7 +748,6 @@ extern convar_t	gl_stencilbits;
 extern convar_t	gl_overbright;
 extern convar_t gl_fog;
 
-extern convar_t	r_lighting_extended;
 extern convar_t	r_lighting_ambient;
 extern convar_t	r_studio_lambert;
 extern convar_t	r_detailtextures;
@@ -814,28 +767,16 @@ extern convar_t r_ripple;
 extern convar_t r_ripple_updatetime;
 extern convar_t r_ripple_spawntime;
 extern convar_t r_large_lightmaps;
-extern convar_t r_dlight_virtual_radius;
 
 //
 // engine shared convars
 //
-DECLARE_ENGINE_SHARED_CVAR_LIST()
 
 //
 // engine callbacks
 //
 #include "crtlib.h"
 
-void _Mem_Free( void *data, const char *filename, int fileline );
-void *_Mem_Alloc( poolhandle_t poolptr, size_t size, qboolean clear, const char *filename, int fileline )
-	ALLOC_CHECK( 2 ) MALLOC_LIKE( _Mem_Free, 1 ) WARN_UNUSED_RESULT;
 
-#define Mem_Malloc( pool, size ) _Mem_Alloc( pool, size, false, __FILE__, __LINE__ )
-#define Mem_Calloc( pool, size ) _Mem_Alloc( pool, size, true, __FILE__, __LINE__ )
-#define Mem_Realloc( pool, ptr, size ) gEngfuncs._Mem_Realloc( pool, ptr, size, true, __FILE__, __LINE__ )
-#define Mem_Free( mem ) _Mem_Free( mem, __FILE__, __LINE__ )
-#define Mem_AllocPool( name ) gEngfuncs._Mem_AllocPool( name, __FILE__, __LINE__ )
-#define Mem_FreePool( pool ) gEngfuncs._Mem_FreePool( pool, __FILE__, __LINE__ )
-#define Mem_EmptyPool( pool ) gEngfuncs._Mem_EmptyPool( pool, __FILE__, __LINE__ )
 
 #endif // GL_LOCAL_H

ref/gl/gl_opengl.c

@@ -22,7 +22,6 @@ CVAR_DEFINE_AUTO( gl_msaa, "1", FCVAR_GLCONFIG, "enable or disable multisample a
 CVAR_DEFINE_AUTO( gl_stencilbits, "8", FCVAR_GLCONFIG|FCVAR_READ_ONLY, "pixelformat stencil bits (0 - auto)" );
 CVAR_DEFINE_AUTO( gl_overbright, "1", FCVAR_GLCONFIG, "overbrights" );
 CVAR_DEFINE_AUTO( gl_fog, "1", FCVAR_GLCONFIG, "allow for rendering fog using built-in OpenGL fog implementation" );
-CVAR_DEFINE_AUTO( r_lighting_extended, "1", FCVAR_GLCONFIG, "allow to get lighting from world and bmodels" );
 CVAR_DEFINE_AUTO( r_lighting_ambient, "0.3", FCVAR_GLCONFIG, "map ambient lighting scale" );
 CVAR_DEFINE_AUTO( r_detailtextures, "1", FCVAR_GLCONFIG, "enable detail textures support" );
 CVAR_DEFINE_AUTO( r_novis, "0", 0, "ignore vis information (perfomance test)" );
@@ -39,11 +38,7 @@ CVAR_DEFINE_AUTO( r_ripple, "0", FCVAR_GLCONFIG, "enable software-like water tex
 CVAR_DEFINE_AUTO( r_ripple_updatetime, "0.05", FCVAR_GLCONFIG, "how fast ripple simulation is" );
 CVAR_DEFINE_AUTO( r_ripple_spawntime, "0.1", FCVAR_GLCONFIG, "how fast new ripples spawn" );
 CVAR_DEFINE_AUTO( r_large_lightmaps, "0", FCVAR_GLCONFIG|FCVAR_LATCH, "enable larger lightmap atlas textures (might break custom renderer mods)" );
-CVAR_DEFINE_AUTO( r_dlight_virtual_radius, "3", FCVAR_GLCONFIG, "increase dlight radius virtually by this amount, should help against ugly cut off dlights on highly scaled textures" );
 
-DEFINE_ENGINE_SHARED_CVAR_LIST()
-
-poolhandle_t r_temppool;
 
 gl_globals_t	tr;
 glconfig_t	glConfig;
@@ -1141,9 +1136,6 @@ GL_InitCommands
 */
 static void GL_InitCommands( void )
 {
-	RETRIEVE_ENGINE_SHARED_CVAR_LIST();
-
-	gEngfuncs.Cvar_RegisterVariable( &r_lighting_extended );
 	gEngfuncs.Cvar_RegisterVariable( &r_lighting_ambient );
 	gEngfuncs.Cvar_RegisterVariable( &r_novis );
 	gEngfuncs.Cvar_RegisterVariable( &r_nocull );
@@ -1162,7 +1154,6 @@ static void GL_InitCommands( void )
 	gEngfuncs.Cvar_RegisterVariable( &r_vbo_overbrightmode );
 	gEngfuncs.Cvar_RegisterVariable( &r_vbo_detail );
 	gEngfuncs.Cvar_RegisterVariable( &r_large_lightmaps );
-	gEngfuncs.Cvar_RegisterVariable( &r_dlight_virtual_radius );
 
 	gEngfuncs.Cvar_RegisterVariable( &gl_extensions );
 	gEngfuncs.Cvar_RegisterVariable( &gl_texture_nearest );
@@ -1276,13 +1267,11 @@ qboolean R_Init( void )
 	tr.lightgammatable = (uint *)ENGINE_GET_PARM( PARM_GET_LIGHTGAMMATABLE_PTR );
 	tr.screengammatable = (uint *)ENGINE_GET_PARM( PARM_GET_SCREENGAMMATABLE_PTR );
 	tr.lineargammatable = (uint *)ENGINE_GET_PARM( PARM_GET_LINEARGAMMATABLE_PTR );
-	tr.dlights = (dlight_t *)ENGINE_GET_PARM( PARM_GET_DLIGHTS_PTR );
 	tr.elights = (dlight_t *)ENGINE_GET_PARM( PARM_GET_ELIGHTS_PTR );
 
 	GL_SetDefaults();
 	R_CheckVBO();
 	R_InitImages();
-	R_SpriteInit();
 	R_StudioInit();
 	R_AliasInit();
 	R_ClearDecals();

ref/gl/gl_rmain.c

@@ -243,9 +243,6 @@ qboolean R_AddEntity( struct cl_entity_s *clent, int type )
 	if( !r_drawentities->value )
 		return false; // not allow to drawing
 
-	if( !clent || !clent->model )
-		return false; // if set to invisible, skip
-
 	if( FBitSet( clent->curstate.effects, EF_NODRAW ))
 		return false; // done
 
@@ -260,10 +257,22 @@ qboolean R_AddEntity( struct cl_entity_s *clent, int type )
 	case ET_TEMPENTITY:
 		r_stats.c_active_tents_count++;
 		break;
-	default: break;
 	}
 
-	if( R_OpaqueEntity( clent ))
+	if( type == ET_BEAM )
+	{
+		if( tr.draw_list->num_beam_entities >= MAX_VISIBLE_PACKET )
+		{
+			gEngfuncs.Con_Printf( S_ERROR "Too many beams %d!\n", tr.draw_list->num_beam_entities );
+			return false;
+		}
+
+		tr.draw_list->beam_entities[tr.draw_list->num_beam_entities] = clent;
+		tr.draw_list->num_beam_entities++;
+
+		return true;
+	}
+	else if( R_OpaqueEntity( clent ))
 	{
 		// opaque
 		if( tr.draw_list->num_solid_entities >= MAX_VISIBLE_PACKET )
@@ -989,7 +998,7 @@ void R_RenderScene( void )
 	// begin a new frame
 	tr.framecount++;
 
-	R_PushDlights();
+	tr.dlightframecount = R_PushDlights( WORLDMODEL, tr.framecount );
 
 	R_SetupFrustum();
 	R_SetupFrame();

ref/gl/gl_rmath.c

@@ -1,189 +0,0 @@
-/*
-gl_rmath.c - renderer mathlib
-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 "gl_local.h"
-#include "xash3d_mathlib.h"
-
-/*
-========================================================================
-
-	       Matrix4x4 operations (private to renderer)
-
-========================================================================
-*/
-void Matrix4x4_Concat( matrix4x4 out, const matrix4x4 in1, const matrix4x4 in2 )
-{
-	out[0][0] = in1[0][0] * in2[0][0] + in1[0][1] * in2[1][0] + in1[0][2] * in2[2][0] + in1[0][3] * in2[3][0];
-	out[0][1] = in1[0][0] * in2[0][1] + in1[0][1] * in2[1][1] + in1[0][2] * in2[2][1] + in1[0][3] * in2[3][1];
-	out[0][2] = in1[0][0] * in2[0][2] + in1[0][1] * in2[1][2] + in1[0][2] * in2[2][2] + in1[0][3] * in2[3][2];
-	out[0][3] = in1[0][0] * in2[0][3] + in1[0][1] * in2[1][3] + in1[0][2] * in2[2][3] + in1[0][3] * in2[3][3];
-	out[1][0] = in1[1][0] * in2[0][0] + in1[1][1] * in2[1][0] + in1[1][2] * in2[2][0] + in1[1][3] * in2[3][0];
-	out[1][1] = in1[1][0] * in2[0][1] + in1[1][1] * in2[1][1] + in1[1][2] * in2[2][1] + in1[1][3] * in2[3][1];
-	out[1][2] = in1[1][0] * in2[0][2] + in1[1][1] * in2[1][2] + in1[1][2] * in2[2][2] + in1[1][3] * in2[3][2];
-	out[1][3] = in1[1][0] * in2[0][3] + in1[1][1] * in2[1][3] + in1[1][2] * in2[2][3] + in1[1][3] * in2[3][3];
-	out[2][0] = in1[2][0] * in2[0][0] + in1[2][1] * in2[1][0] + in1[2][2] * in2[2][0] + in1[2][3] * in2[3][0];
-	out[2][1] = in1[2][0] * in2[0][1] + in1[2][1] * in2[1][1] + in1[2][2] * in2[2][1] + in1[2][3] * in2[3][1];
-	out[2][2] = in1[2][0] * in2[0][2] + in1[2][1] * in2[1][2] + in1[2][2] * in2[2][2] + in1[2][3] * in2[3][2];
-	out[2][3] = in1[2][0] * in2[0][3] + in1[2][1] * in2[1][3] + in1[2][2] * in2[2][3] + in1[2][3] * in2[3][3];
-	out[3][0] = in1[3][0] * in2[0][0] + in1[3][1] * in2[1][0] + in1[3][2] * in2[2][0] + in1[3][3] * in2[3][0];
-	out[3][1] = in1[3][0] * in2[0][1] + in1[3][1] * in2[1][1] + in1[3][2] * in2[2][1] + in1[3][3] * in2[3][1];
-	out[3][2] = in1[3][0] * in2[0][2] + in1[3][1] * in2[1][2] + in1[3][2] * in2[2][2] + in1[3][3] * in2[3][2];
-	out[3][3] = in1[3][0] * in2[0][3] + in1[3][1] * in2[1][3] + in1[3][2] * in2[2][3] + in1[3][3] * in2[3][3];
-}
-
-/*
-================
-Matrix4x4_CreateProjection
-
-NOTE: produce quake style world orientation
-================
-*/
-void Matrix4x4_CreateProjection( matrix4x4 out, float xMax, float xMin, float yMax, float yMin, float zNear, float zFar )
-{
-	out[0][0] = ( 2.0f * zNear ) / ( xMax - xMin );
-	out[1][1] = ( 2.0f * zNear ) / ( yMax - yMin );
-	out[2][2] = -( zFar + zNear ) / ( zFar - zNear );
-	out[3][3] = out[0][1] = out[1][0] = out[3][0] = out[0][3] = out[3][1] = out[1][3] = 0.0f;
-
-	out[2][0] = 0.0f;
-	out[2][1] = 0.0f;
-	out[0][2] = ( xMax + xMin ) / ( xMax - xMin );
-	out[1][2] = ( yMax + yMin ) / ( yMax - yMin );
-	out[3][2] = -1.0f;
-	out[2][3] = -( 2.0f * zFar * zNear ) / ( zFar - zNear );
-}
-
-void Matrix4x4_CreateOrtho( matrix4x4 out, float xLeft, float xRight, float yBottom, float yTop, float zNear, float zFar )
-{
-	out[0][0] = 2.0f / (xRight - xLeft);
-	out[1][1] = 2.0f / (yTop - yBottom);
-	out[2][2] = -2.0f / (zFar - zNear);
-	out[3][3] = 1.0f;
-	out[0][1] = out[0][2] = out[1][0] = out[1][2] = out[3][0] = out[3][1] = out[3][2] = 0.0f;
-
-	out[2][0] = 0.0f;
-	out[2][1] = 0.0f;
-	out[0][3] = -(xRight + xLeft) / (xRight - xLeft);
-	out[1][3] = -(yTop + yBottom) / (yTop - yBottom);
-	out[2][3] = -(zFar + zNear) / (zFar - zNear);
-}
-
-/*
-================
-Matrix4x4_CreateModelview
-
-NOTE: produce quake style world orientation
-================
-*/
-void Matrix4x4_CreateModelview( matrix4x4 out )
-{
-	out[0][0] = out[1][1] = out[2][2] = 0.0f;
-	out[3][0] = out[0][3] = 0.0f;
-	out[3][1] = out[1][3] = 0.0f;
-	out[3][2] = out[2][3] = 0.0f;
-	out[3][3] = 1.0f;
-	out[1][0] = out[0][2] = out[2][1] = 0.0f;
-	out[2][0] = out[0][1] = -1.0f;
-	out[1][2] = 1.0f;
-}
-
-void Matrix4x4_ToArrayFloatGL( const matrix4x4 in, float out[16] )
-{
-	out[ 0] = in[0][0];
-	out[ 1] = in[1][0];
-	out[ 2] = in[2][0];
-	out[ 3] = in[3][0];
-	out[ 4] = in[0][1];
-	out[ 5] = in[1][1];
-	out[ 6] = in[2][1];
-	out[ 7] = in[3][1];
-	out[ 8] = in[0][2];
-	out[ 9] = in[1][2];
-	out[10] = in[2][2];
-	out[11] = in[3][2];
-	out[12] = in[0][3];
-	out[13] = in[1][3];
-	out[14] = in[2][3];
-	out[15] = in[3][3];
-}
-
-static void Matrix4x4_CreateTranslate( matrix4x4 out, float x, float y, float z )
-{
-	out[0][0] = 1.0f;
-	out[0][1] = 0.0f;
-	out[0][2] = 0.0f;
-	out[0][3] = x;
-	out[1][0] = 0.0f;
-	out[1][1] = 1.0f;
-	out[1][2] = 0.0f;
-	out[1][3] = y;
-	out[2][0] = 0.0f;
-	out[2][1] = 0.0f;
-	out[2][2] = 1.0f;
-	out[2][3] = z;
-	out[3][0] = 0.0f;
-	out[3][1] = 0.0f;
-	out[3][2] = 0.0f;
-	out[3][3] = 1.0f;
-}
-
-static void Matrix4x4_CreateRotate( matrix4x4 out, float angle, float x, float y, float z )
-{
-	float	len, c, s;
-
-	len = x * x + y * y + z * z;
-	if( len != 0.0f ) len = 1.0f / sqrt( len );
-	x *= len;
-	y *= len;
-	z *= len;
-
-	angle *= (-M_PI_F / 180.0f);
-	SinCos( angle, &s, &c );
-
-	out[0][0]=x * x + c * (1 - x * x);
-	out[0][1]=x * y * (1 - c) + z * s;
-	out[0][2]=z * x * (1 - c) - y * s;
-	out[0][3]=0.0f;
-	out[1][0]=x * y * (1 - c) - z * s;
-	out[1][1]=y * y + c * (1 - y * y);
-	out[1][2]=y * z * (1 - c) + x * s;
-	out[1][3]=0.0f;
-	out[2][0]=z * x * (1 - c) + y * s;
-	out[2][1]=y * z * (1 - c) - x * s;
-	out[2][2]=z * z + c * (1 - z * z);
-	out[2][3]=0.0f;
-	out[3][0]=0.0f;
-	out[3][1]=0.0f;
-	out[3][2]=0.0f;
-	out[3][3]=1.0f;
-}
-
-void Matrix4x4_ConcatTranslate( matrix4x4 out, float x, float y, float z )
-{
-	matrix4x4 base, temp;
-
-	Matrix4x4_Copy( base, out );
-	Matrix4x4_CreateTranslate( temp, x, y, z );
-	Matrix4x4_Concat( out, base, temp );
-}
-
-void Matrix4x4_ConcatRotate( matrix4x4 out, float angle, float x, float y, float z )
-{
-	matrix4x4 base, temp;
-
-	Matrix4x4_Copy( base, out );
-	Matrix4x4_CreateRotate( temp, angle, x, y, z );
-	Matrix4x4_Concat( out, base, temp );
-}

ref/gl/gl_rsurf.c

@@ -40,7 +40,6 @@ static vec2_t		world_orthohalf;
 static uint		r_blocklights[BLOCK_SIZE_MAX*BLOCK_SIZE_MAX*3];
 static mextrasurf_t		*fullbright_surfaces[MAX_TEXTURES];
 static mextrasurf_t		*detail_surfaces[MAX_TEXTURES];
-static int		rtable[MOD_FRAMES][MOD_FRAMES];
 
 typedef struct
 {
@@ -576,7 +575,7 @@ static void R_AddDynamicLights( const msurface_t *surf )
 		if( !FBitSet( surf->dlightbits, BIT( lnum )))
 			continue;	// not lit by this light
 
-		dl = &tr.dlights[lnum];
+		dl = &gp_dlights[lnum];
 
 		// transform light origin to local bmodel space
 		if( !tr.modelviewIdentity )
@@ -638,21 +637,6 @@ static void R_AddDynamicLights( const msurface_t *surf )
 	}
 }
 
-/*
-================
-R_SetCacheState
-================
-*/
-static void R_SetCacheState( msurface_t *surf )
-{
-	int	maps;
-
-	for( maps = 0; maps < MAXLIGHTMAPS && surf->styles[maps] != 255; maps++ )
-	{
-		surf->cached_light[maps] = tr.lightstylevalue[surf->styles[maps]];
-	}
-}
-
 /*
 =============================================================================
 
@@ -783,7 +767,7 @@ static void R_BuildLightMap( const msurface_t *surf, byte *dest, int stride, qbo
 		if( surf->styles[map] >= 255 )
 			break;
 
-		scale = tr.lightstylevalue[surf->styles[map]];
+		scale = g_lightstylevalue[surf->styles[map]];
 
 		for( i = 0; i < size; i++ )
 		{
@@ -960,7 +944,7 @@ EmitWaterPolys
 Does a water warp on the pre-fragmented glpoly_t chain
 =============
 */
-void EmitWaterPolys( msurface_t *warp, qboolean reverse, qboolean ripples )
+static void EmitWaterPolys( msurface_t *warp, qboolean reverse, qboolean ripples )
 {
 	float	*v, nv, waveHeight;
 	float	s, t, os, ot;
@@ -1398,7 +1382,7 @@ static qboolean R_CheckLightMap( msurface_t *fa )
 	// check for light styles
 	for( maps = 0; maps < MAXLIGHTMAPS && fa->styles[maps] != 255; maps++ )
 	{
-		if( tr.lightstylevalue[fa->styles[maps]] == fa->cached_light[maps] )
+		if( g_lightstylevalue[fa->styles[maps]] == fa->cached_light[maps] )
 			continue;
 
 		const int style = fa->styles[maps];
@@ -1423,7 +1407,7 @@ static qboolean R_CheckLightMap( msurface_t *fa )
 			//Host_MapDesignError( "%s: bad surface extents: %d %d", __func__, fa->extents[0], fa->extents[1] );
 		}
 
-		R_SetCacheState( fa );
+		R_UpdateSurfaceCachedLight( fa );
 
 #if XASH_WES
 		GL_Bind( XASH_TEXTURE1, tr.lightmapTextures[fa->lightmaptexturenum] );
@@ -1858,20 +1842,7 @@ void R_DrawBrushModel( cl_entity_t *e )
 	e->visframe = tr.realframecount; // visible
 
 	// calculate dynamic lighting for bmodel
-	for( int k = 0; k < MAX_DLIGHTS; k++ )
-	{
-		dlight_t *l = &tr.dlights[k];
-		vec3_t origin_l, oldorigin;
-
-		if( l->die < gp_cl->time || !l->radius )
-			continue;
-
-		VectorCopy( l->origin, oldorigin ); // save lightorigin
-		Matrix4x4_VectorITransform( RI.objectMatrix, l->origin, origin_l );
-		VectorCopy( origin_l, l->origin ); // move light in bmodel space
-		R_MarkLights( l, 1<<k, clmodel->nodes + clmodel->hulls[0].firstclipnode );
-		VectorCopy( oldorigin, l->origin ); // restore lightorigin
-	}
+	R_PushDlightsForBmodel( clmodel, tr.dlightframecount, RI.objectMatrix );
 
 	// setup the rendermode
 	R_SetRenderMode( e );
@@ -3872,7 +3843,7 @@ static void GL_CreateSurfaceLightmap( msurface_t *surf, model_t *loadmodel )
 	base = gl_lms.lightmap_buffer;
 	base += ( surf->light_t * BLOCK_SIZE + surf->light_s ) * 4;
 
-	R_SetCacheState( surf );
+	R_UpdateSurfaceCachedLight( surf );
 	R_BuildLightMap( surf, base, BLOCK_SIZE * 4, false );
 }
 
@@ -4008,17 +3979,3 @@ void GL_BuildLightmaps( void )
 	}
 }
 
-void GL_InitRandomTable( void )
-{
-	int	tu, tv;
-
-	for( tu = 0; tu < MOD_FRAMES; tu++ )
-	{
-		for( tv = 0; tv < MOD_FRAMES; tv++ )
-		{
-			rtable[tu][tv] = gEngfuncs.COM_RandomLong( 0, 0x7FFF );
-		}
-	}
-
-	gEngfuncs.COM_SetRandomSeed( 0 );
-}

ref/gl/gl_sprite.c

@@ -21,329 +21,8 @@ GNU General Public License for more details.
 
 #define GLARE_FALLOFF	19000.0f
 
-static char  sprite_name[MAX_QPATH];
-static char  group_suffix[8];
-static uint  r_texFlags = 0;
-static int   sprite_version;
 static float sprite_radius;
 
-/*
-====================
-R_SpriteInit
-
-====================
-*/
-void R_SpriteInit( void )
-{
-}
-
-/*
-====================
-R_SpriteLoadFrame
-
-upload a single frame
-====================
-*/
-static const byte *R_SpriteLoadFrame( model_t *mod, const void *pin, mspriteframe_t **ppframe, int num )
-{
-	dspriteframe_t	pinframe;
-	mspriteframe_t	*pspriteframe;
-	int		gl_texturenum = 0;
-	char		texname[128];
-	int		bytes = 1;
-
-	memcpy( &pinframe, pin, sizeof( dspriteframe_t ));
-
-	if( sprite_version == SPRITE_VERSION_32 )
-		bytes = 4;
-
-	// build uinque frame name
-	if( FBitSet( mod->flags, MODEL_CLIENT )) // it's a HUD sprite
-	{
-		Q_snprintf( texname, sizeof( texname ), "#HUD/%s(%s:%i%i).spr", sprite_name, group_suffix, num / 10, num % 10 );
-		gl_texturenum = GL_LoadTexture( texname, pin, pinframe.width * pinframe.height * bytes, r_texFlags );
-	}
-	else
-	{
-		// partial HD-textures support
-		if( Mod_AllowMaterials( ))
-		{
-			if( R_SearchForTextureReplacement( texname, sizeof( texname ), sprite_name, "materials/%s/%s%i%i.tga", sprite_name, group_suffix, num / 10, num % 10 ))
-			{
-				gl_texturenum = GL_LoadTexture( texname, NULL, 0, r_texFlags );
-				R_TextureReplacementReport( sprite_name, gl_texturenum, texname );
-			}
-		}
-
-		if( gl_texturenum == 0 )
-		{
-			Q_snprintf( texname, sizeof( texname ), "#%s(%s:%i%i).spr", sprite_name, group_suffix, num / 10, num % 10 );
-			gl_texturenum = GL_LoadTexture( texname, pin, pinframe.width * pinframe.height * bytes, r_texFlags );
-		}
-	}
-
-	// setup frame description
-	pspriteframe = Mem_Malloc( mod->mempool, sizeof( mspriteframe_t ));
-	pspriteframe->width = pinframe.width;
-	pspriteframe->height = pinframe.height;
-	pspriteframe->up = pinframe.origin[1];
-	pspriteframe->left = pinframe.origin[0];
-	pspriteframe->down = pinframe.origin[1] - pinframe.height;
-	pspriteframe->right = pinframe.width + pinframe.origin[0];
-	pspriteframe->gl_texturenum = gl_texturenum;
-	*ppframe = pspriteframe;
-
-	return (( const byte* )pin + sizeof( dspriteframe_t ) + pinframe.width * pinframe.height * bytes );
-}
-
-/*
-====================
-R_SpriteLoadGroup
-
-upload a group frames
-====================
-*/
-static const byte *R_SpriteLoadGroup( model_t *mod, const void *pin, mspriteframe_t **ppframe, int framenum )
-{
-	const dspritegroup_t	*pingroup;
-	mspritegroup_t	*pspritegroup;
-	const dspriteinterval_t	*pin_intervals;
-	float		*poutintervals;
-	int		i, groupsize, numframes;
-	const void		*ptemp;
-
-	pingroup = (const dspritegroup_t *)pin;
-	numframes = pingroup->numframes;
-
-	groupsize = sizeof( mspritegroup_t ) + (numframes - 1) * sizeof( pspritegroup->frames[0] );
-	pspritegroup = Mem_Calloc( mod->mempool, groupsize );
-	pspritegroup->numframes = numframes;
-
-	*ppframe = (mspriteframe_t *)pspritegroup;
-	pin_intervals = (const dspriteinterval_t *)(pingroup + 1);
-	poutintervals = Mem_Calloc( mod->mempool, numframes * sizeof( float ));
-	pspritegroup->intervals = poutintervals;
-
-	for( i = 0; i < numframes; i++ )
-	{
-		*poutintervals = pin_intervals->interval;
-		if( *poutintervals <= 0.0f )
-			*poutintervals = 1.0f; // set error value
-		poutintervals++;
-		pin_intervals++;
-	}
-
-	ptemp = (const void *)pin_intervals;
-	for( i = 0; i < numframes; i++ )
-	{
-		ptemp = R_SpriteLoadFrame( mod, ptemp, &pspritegroup->frames[i], framenum * 10 + i );
-	}
-
-	return ptemp;
-}
-
-
-/*
-====================
-Mod_LoadSpriteModel
-
-load sprite model
-====================
-*/
-void Mod_LoadSpriteModel( model_t *mod, const void *buffer, qboolean *loaded, uint texFlags )
-{
-	const dsprite_t *pin;
-	const short     *numi = NULL;
-	const byte      *pframetype;
-	msprite_t       *psprite;
-	int i;
-
-	pin = buffer;
-	psprite = mod->cache.data;
-
-	if( pin->version == SPRITE_VERSION_Q1 || pin->version == SPRITE_VERSION_32 )
-		numi = NULL;
-	else if( pin->version == SPRITE_VERSION_HL )
-		numi = (const short *)((const byte *)buffer + sizeof( dsprite_hl_t ));
-
-	r_texFlags = texFlags;
-	sprite_version = pin->version;
-	Q_strncpy( sprite_name, mod->name, sizeof( sprite_name ));
-	COM_StripExtension( sprite_name );
-
-	if( numi == NULL )
-	{
-		rgbdata_t	*pal;
-
-		pal = gEngfuncs.FS_LoadImage( "#id.pal", (byte *)&i, 768 );
-		pframetype = ((const byte*)buffer + sizeof( dsprite_q1_t )); // pinq1 + 1
-		gEngfuncs.FS_FreeImage( pal ); // palette installed, no reason to keep this data
-	}
-	else if( *numi <= 256 )
-	{
-		const byte	*src = (const byte *)(numi+1);
-		rgbdata_t	*pal;
-		size_t pal_bytes = *numi * 3;
-
-		// install palette
-		switch( psprite->texFormat )
-		{
-		case SPR_INDEXALPHA:
-			pal = gEngfuncs.FS_LoadImage( "#gradient.pal", src, pal_bytes );
-			break;
-		case SPR_ALPHTEST:
-			pal = gEngfuncs.FS_LoadImage( "#masked.pal", src, pal_bytes );
-			break;
-		default:
-			pal = gEngfuncs.FS_LoadImage( "#texgamma.pal", src, pal_bytes );
-			break;
-		}
-
-		pframetype = (const byte *)(src + pal_bytes);
-		gEngfuncs.FS_FreeImage( pal ); // palette installed, no reason to keep this data
-	}
-	else
-	{
-		gEngfuncs.Con_DPrintf( S_ERROR "%s has wrong number of palette colors %i (should be less or equal than 256)\n", mod->name, *numi );
-		return;
-	}
-
-	if( mod->numframes < 1 )
-		return;
-
-	for( i = 0; i < mod->numframes; i++ )
-	{
-		frametype_t frametype;
-		dframetype_t dframetype;
-
-		memcpy( &dframetype, pframetype, sizeof( dframetype ));
-		frametype = dframetype.type;
-		psprite->frames[i].type = (spriteframetype_t)frametype;
-
-		switch( frametype )
-		{
-		case FRAME_SINGLE:
-			Q_strncpy( group_suffix, "frame", sizeof( group_suffix ));
-			pframetype = R_SpriteLoadFrame( mod, pframetype + sizeof( dframetype_t ), &psprite->frames[i].frameptr, i );
-			break;
-		case FRAME_GROUP:
-			Q_strncpy( group_suffix, "group", sizeof( group_suffix ));
-			pframetype = R_SpriteLoadGroup( mod, pframetype + sizeof( dframetype_t ), &psprite->frames[i].frameptr, i );
-			break;
-		case FRAME_ANGLED:
-			Q_strncpy( group_suffix, "angle", sizeof( group_suffix ));
-			pframetype = R_SpriteLoadGroup( mod, pframetype + sizeof( dframetype_t ), &psprite->frames[i].frameptr, i );
-			break;
-		}
-		if( pframetype == NULL ) break; // technically an error
-	}
-
-	if( loaded ) *loaded = true;	// done
-}
-
-/*
-====================
-Mod_UnloadSpriteModel
-
-release sprite model and frames
-====================
-*/
-void Mod_SpriteUnloadTextures( void *data )
-{
-	msprite_t *psprite = data;
-	int i;
-
-	if( !data )
-		return;
-
-	// release all textures
-	for( i = 0; i < psprite->numframes; i++ )
-	{
-		if( !psprite->frames[i].frameptr )
-			continue;
-
-		if( psprite->frames[i].type == SPR_SINGLE )
-		{
-			GL_FreeTexture( psprite->frames[i].frameptr->gl_texturenum );
-		}
-		else
-		{
-			mspritegroup_t *pspritegroup = (mspritegroup_t *)psprite->frames[i].frameptr;
-			int j;
-
-			for( j = 0; j < pspritegroup->numframes; j++ )
-			{
-				if( pspritegroup->frames[j] )
-					GL_FreeTexture( pspritegroup->frames[j]->gl_texturenum );
-			}
-		}
-	}
-}
-
-/*
-================
-R_GetSpriteFrame
-
-assume pModel is valid
-================
-*/
-mspriteframe_t *R_GetSpriteFrame( const model_t *pModel, int frame, float yaw )
-{
-	msprite_t		*psprite;
-	mspritegroup_t	*pspritegroup;
-	mspriteframe_t	*pspriteframe = NULL;
-	float		*pintervals, fullinterval;
-	int		i, numframes;
-	float		targettime;
-
-	Assert( pModel != NULL );
-	psprite = pModel->cache.data;
-
-	if( frame < 0 )
-	{
-		frame = 0;
-	}
-	else if( frame >= psprite->numframes )
-	{
-		if( frame > psprite->numframes )
-			gEngfuncs.Con_Printf( S_WARN "%s: no such frame %d (%s)\n", __func__, frame, pModel->name );
-		frame = psprite->numframes - 1;
-	}
-
-	if( psprite->frames[frame].type == SPR_SINGLE )
-	{
-		pspriteframe = psprite->frames[frame].frameptr;
-	}
-	else if( psprite->frames[frame].type == SPR_GROUP )
-	{
-		pspritegroup = (mspritegroup_t *)psprite->frames[frame].frameptr;
-		pintervals = pspritegroup->intervals;
-		numframes = pspritegroup->numframes;
-		fullinterval = pintervals[numframes-1];
-
-		// when loading in Mod_LoadSpriteGroup, we guaranteed all interval values
-		// are positive, so we don't have to worry about division by zero
-		targettime = gp_cl->time - ((int)( gp_cl->time / fullinterval )) * fullinterval;
-
-		for( i = 0; i < (numframes - 1); i++ )
-		{
-			if( pintervals[i] > targettime )
-				break;
-		}
-		pspriteframe = pspritegroup->frames[i];
-	}
-	else if( psprite->frames[frame].type == FRAME_ANGLED )
-	{
-		int	angleframe = (int)(Q_rint(( RI.viewangles[1] - yaw + 45.0f ) / 360 * 8) - 4) & 7;
-
-		// e.g. doom-style sprite monsters
-		pspritegroup = (mspritegroup_t *)psprite->frames[frame].frameptr;
-		pspriteframe = pspritegroup->frames[angleframe];
-	}
-
-	return pspriteframe;
-}
-
 /*
 ================
 R_GetSpriteFrameInterpolant
@@ -800,7 +479,7 @@ void R_DrawSpriteModel( cl_entity_t *e )
 
 	if( R_SpriteAllowLerping( e, psprite ))
 		lerp = R_GetSpriteFrameInterpolant( e, &oldframe, &frame );
-	else frame = oldframe = R_GetSpriteFrame( model, e->curstate.frame, e->angles[YAW] );
+	else frame = oldframe = gEngfuncs.R_GetSpriteFrame( model, e->curstate.frame, e->angles[YAW] );
 
 	type = psprite->type;
 

ref/gl/gl_studio.c

@@ -1441,7 +1441,7 @@ static void R_StudioDynamicLight( cl_entity_t *ent, alight_t *plight )
 
 	for( lnum = 0; lnum < MAX_DLIGHTS; lnum++ )
 	{
-		dl = &tr.dlights[lnum];
+		dl = &gp_dlights[lnum];
 
 		if( dl->die < g_studio.time || !r_dynamic->value )
 			continue;

ref/gl/gl_triapi.c

@@ -245,7 +245,10 @@ int TriSpriteTexture( model_t *pSpriteModel, int frame )
 {
 	int	gl_texturenum;
 
-	if(( gl_texturenum = R_GetSpriteTexture( pSpriteModel, frame )) == 0 )
+	if( !pSpriteModel || pSpriteModel->type != mod_sprite || !pSpriteModel->cache.data )
+		return 0;
+
+	if(( gl_texturenum = gEngfuncs.R_GetSpriteFrame( pSpriteModel, frame, 0.0f )->gl_texturenum ) == 0 )
 		return 0;
 
 	if( gl_texturenum <= 0 || gl_texturenum >= MAX_TEXTURES )

ref/gl/wscript

@@ -25,7 +25,7 @@ def configure(conf):
 		conf.check_cc(lib='log')
 
 def build(bld):
-	libs = [ 'engine_includes', 'werror' ]
+	libs = [ 'ref_common', 'engine_includes', 'werror' ]
 	# on PSVita do not link any libraries that are already in the main executable, but add the includes target
 	if bld.env.DEST_OS == 'psvita':
 		libs += [ 'sdk_includes', 'vgl_shim' ]

ref/null/r_context.c

@@ -75,11 +75,6 @@ static qboolean R_AddEntity( struct cl_entity_s *clent, int type )
 	return true;
 }
 
-static void CL_AddCustomBeam( cl_entity_t *pEnvBeam )
-{
-	;
-}
-
 static void R_ProcessEntData( qboolean allocate, cl_entity_t *entities, unsigned int max_entities )
 {
 	;
@@ -177,22 +172,6 @@ static void CL_RunLightStyles( lightstyle_t *ls )
 
 }
 
-static void R_GetSpriteParms( int *frameWidth, int *frameHeight, int *numFrames, int currentFrame, const model_t *pSprite )
-{
-	if( frameWidth )
-		*frameWidth	= 0;
-
-	if( frameHeight )
-		*frameHeight = 0;
-
-	if( numFrames )
-		*numFrames = 0;
-}
-
-static int R_GetSpriteTexture( const model_t *m_pSpriteModel, int frame )
-{
-	return 0;
-}
 
 static qboolean Mod_ProcessRenderData( model_t *mod, qboolean create, const byte *buffer, size_t buffersize )
 {
@@ -460,7 +439,6 @@ static const ref_interface_t gReffuncs =
 	.GL_SetRenderMode = R_SimpleStubInt,
 
 	.R_AddEntity      = R_AddEntity,
-	.CL_AddCustomBeam = CL_AddCustomBeam,
 	.R_ProcessEntData = R_ProcessEntData,
 	.R_Flush          = R_SimpleStubUInt,
 
@@ -495,8 +473,6 @@ static const ref_interface_t gReffuncs =
 	.GL_SubdivideSurface = GL_SubdivideSurface,
 	.CL_RunLightStyles   = CL_RunLightStyles,
 
-	.R_GetSpriteParms    = R_GetSpriteParms,
-	.R_GetSpriteTexture  = R_GetSpriteTexture,
 
 	.Mod_ProcessRenderData  = Mod_ProcessRenderData,
 	.Mod_StudioLoadTextures = Mod_StudioLoadTextures,
@@ -539,8 +515,6 @@ static const ref_interface_t gReffuncs =
 	.GL_TextureTarget       = R_SimpleStubUInt,
 	.GL_TexCoordArrayMode   = R_SimpleStubUInt,
 	.GL_UpdateTexSize       = GL_UpdateTexSize,
-	.GL_Reserved0           = NULL,
-	.GL_Reserved1           = NULL,
 
 	.GL_DrawParticles = GL_DrawParticles,
 	.LightVec         = LightVec,

ref/soft/r_beams.c

@@ -122,29 +122,6 @@ qboolean GAME_EXPORT R_BeamCull( const vec3_t start, const vec3_t end, qboolean
 	return false;
 }
 
-/*
-================
-CL_AddCustomBeam
-
-Add the beam that encoded as custom entity
-================
-*/
-void GAME_EXPORT CL_AddCustomBeam( cl_entity_t *pEnvBeam )
-{
-	if( tr.draw_list->num_beam_entities >= MAX_VISIBLE_PACKET )
-	{
-		gEngfuncs.Con_Printf( S_ERROR "Too many beams %d!\n", tr.draw_list->num_beam_entities );
-		return;
-	}
-
-	if( pEnvBeam )
-	{
-		tr.draw_list->beam_entities[tr.draw_list->num_beam_entities] = pEnvBeam;
-		tr.draw_list->num_beam_entities++;
-	}
-}
-
-
 /*
 ==============================================================
 

ref/soft/r_context.c

@@ -15,24 +15,10 @@ GNU General Public License for more details.
 
 #include "r_local.h"
 
-ref_api_t     gEngfuncs;
-ref_globals_t *gpGlobals;
-ref_client_t  *gp_cl;
-ref_host_t    *gp_host;
 gl_globals_t  tr;
 ref_speeds_t  r_stats;
-poolhandle_t  r_temppool;
 viddef_t      vid;
 
-void _Mem_Free( void *data, const char *filename, int fileline )
-{
-	gEngfuncs._Mem_Free( data, filename, fileline );
-}
-
-void *_Mem_Alloc( poolhandle_t poolptr, size_t size, qboolean clear, const char *filename, int fileline )
-{
-	return gEngfuncs._Mem_Alloc( poolptr, size, clear, filename, fileline );
-}
 
 static void GAME_EXPORT R_ClearScreen( void )
 {
@@ -96,7 +82,6 @@ static void Mod_UnloadTextures( model_t *mod )
 		Mod_BrushUnloadTextures( mod );
 		break;
 	case mod_sprite:
-		Mod_SpriteUnloadTextures( mod->cache.data );
 		break;
 	default: gEngfuncs.Host_Error( "%s: unsupported type %d\n", __func__, mod->type );
 	}
@@ -122,7 +107,7 @@ static qboolean GAME_EXPORT Mod_ProcessRenderData( model_t *mod, qboolean create
 		loaded = true;
 		break;
 	case mod_sprite:
-		Mod_LoadSpriteModel( mod, buf, &loaded, mod->numtexinfo );
+		loaded = true;
 		break;
 	default:
 		gEngfuncs.Host_Error( "%s: unsupported type %d\n", __func__, mod->type );
@@ -188,7 +173,7 @@ static int GL_RefGetParm( int parm, int arg )
 		return 0; // glState.activeTMU;
 	case PARM_LIGHTSTYLEVALUE:
 		arg = bound( 0, arg, MAX_LIGHTSTYLES - 1 );
-		return tr.lightstylevalue[arg];
+		return g_lightstylevalue[arg];
 	case PARM_MAX_IMAGE_UNITS:
 		return 0; // GL_MaxTextureUnits();
 	case PARM_REBUILD_GAMMA:
@@ -413,7 +398,7 @@ static void * GAME_EXPORT R_GetProcAddress( const char *name )
 	return gEngfuncs.GL_GetProcAddress( name );
 }
 
-static const ref_interface_t gReffuncs =
+const ref_interface_t gReffuncs =
 {
 	R_Init,
 	R_Shutdown,
@@ -438,7 +423,6 @@ static const ref_interface_t gReffuncs =
 	GL_SetRenderMode,
 
 	R_AddEntity,
-	CL_AddCustomBeam,
 	R_ProcessEntData,
 	R_Flush,
 
@@ -473,8 +457,6 @@ static const ref_interface_t gReffuncs =
 	GL_SubdivideSurface,
 	CL_RunLightStyles,
 
-	R_GetSpriteParms,
-	R_GetSpriteTexture,
 
 	Mod_ProcessRenderData,
 	Mod_StudioLoadTextures,
@@ -517,8 +499,6 @@ static const ref_interface_t gReffuncs =
 	GL_TextureTarget,
 	GL_SetTexCoordArrayMode,
 	GL_UpdateTexSize,
-	NULL,
-	NULL,
 
 	CL_DrawParticlesExternal,
 	R_LightVec,
@@ -550,19 +530,3 @@ static const ref_interface_t gReffuncs =
 	VGUI_UploadTextureBlock,
 };
 
-int EXPORT GetRefAPI( int version, ref_interface_t *funcs, ref_api_t *engfuncs, ref_globals_t *globals );
-int EXPORT GetRefAPI( int version, ref_interface_t *funcs, ref_api_t *engfuncs, ref_globals_t *globals )
-{
-	if( version != REF_API_VERSION )
-		return 0;
-
-	// fill in our callbacks
-	*funcs = gReffuncs;
-	gEngfuncs = *engfuncs;
-	gpGlobals = globals;
-
-	gp_cl = (ref_client_t *)ENGINE_GET_PARM( PARM_GET_CLIENT_PTR );
-	gp_host = (ref_host_t *)ENGINE_GET_PARM( PARM_GET_HOST_PTR );
-
-	return REF_API_VERSION;
-}

ref/soft/r_draw.c

@@ -31,39 +31,6 @@ void R_GetTextureParms( int *w, int *h, int texnum )
 		*h = glt->srcHeight;
 }
 
-/*
-=============
-R_GetSpriteParms
-
-same as GetImageParms but used
-for sprite models
-=============
-*/
-void GAME_EXPORT R_GetSpriteParms( int *frameWidth, int *frameHeight, int *numFrames, int currentFrame, const model_t *pSprite )
-{
-	mspriteframe_t *pFrame;
-
-	if( !pSprite || pSprite->type != mod_sprite )
-		return;                                       // bad model ?
-	pFrame = R_GetSpriteFrame( pSprite, currentFrame, 0.0f );
-
-	if( frameWidth )
-		*frameWidth = pFrame->width;
-	if( frameHeight )
-		*frameHeight = pFrame->height;
-	if( numFrames )
-		*numFrames = pSprite->numframes;
-}
-
-int GAME_EXPORT R_GetSpriteTexture( const model_t *m_pSpriteModel, int frame )
-{
-	if( !m_pSpriteModel || m_pSpriteModel->type != mod_sprite || !m_pSpriteModel->cache.data )
-		return 0;
-
-	return R_GetSpriteFrame( m_pSpriteModel, frame, 0.0f )->gl_texturenum;
-}
-
-
 /*
 =============
 Draw_StretchPicImplementation

ref/soft/r_image.c

@@ -115,98 +115,6 @@ static void GL_SetTextureDimensions( image_t *tex, int width, int height, int de
 	tex->depth = Q_max( 1, depth );
 }
 
-/*
-=================
-GL_ResampleTexture
-
-Assume input buffer is RGBA
-=================
-*/
-byte *GL_ResampleTexture( const byte *source, int inWidth, int inHeight, int outWidth, int outHeight, qboolean isNormalMap )
-{
-	uint        frac, fracStep;
-	uint        *in = (uint *)source;
-	uint        p1[0x1000], p2[0x1000];
-	byte        *pix1, *pix2, *pix3, *pix4;
-	uint        *out, *inRow1, *inRow2;
-	static byte *scaledImage = NULL;        // pointer to a scaled image
-	vec3_t      normal;
-	int         i, x, y;
-
-	if( !source )
-		return NULL;
-
-	scaledImage = Mem_Realloc( r_temppool, scaledImage, outWidth * outHeight * 4 );
-	fracStep = inWidth * 0x10000 / outWidth;
-	out = (uint *)scaledImage;
-
-	frac = fracStep >> 2;
-	for( i = 0; i < outWidth; i++ )
-	{
-		p1[i] = 4 * ( frac >> 16 );
-		frac += fracStep;
-	}
-
-	frac = ( fracStep >> 2 ) * 3;
-	for( i = 0; i < outWidth; i++ )
-	{
-		p2[i] = 4 * ( frac >> 16 );
-		frac += fracStep;
-	}
-
-	if( isNormalMap )
-	{
-		for( y = 0; y < outHeight; y++, out += outWidth )
-		{
-			inRow1 = in + inWidth * (int)(((float)y + 0.25f ) * inHeight / outHeight );
-			inRow2 = in + inWidth * (int)(((float)y + 0.75f ) * inHeight / outHeight );
-
-			for( x = 0; x < outWidth; x++ )
-			{
-				pix1 = (byte *)inRow1 + p1[x];
-				pix2 = (byte *)inRow1 + p2[x];
-				pix3 = (byte *)inRow2 + p1[x];
-				pix4 = (byte *)inRow2 + p2[x];
-
-				normal[0] = MAKE_SIGNED( pix1[0] ) + MAKE_SIGNED( pix2[0] ) + MAKE_SIGNED( pix3[0] ) + MAKE_SIGNED( pix4[0] );
-				normal[1] = MAKE_SIGNED( pix1[1] ) + MAKE_SIGNED( pix2[1] ) + MAKE_SIGNED( pix3[1] ) + MAKE_SIGNED( pix4[1] );
-				normal[2] = MAKE_SIGNED( pix1[2] ) + MAKE_SIGNED( pix2[2] ) + MAKE_SIGNED( pix3[2] ) + MAKE_SIGNED( pix4[2] );
-
-				if( !VectorNormalizeLength( normal ))
-					VectorSet( normal, 0.5f, 0.5f, 1.0f );
-
-				((byte *)( out + x ))[0] = 128 + (byte)( 127.0f * normal[0] );
-				((byte *)( out + x ))[1] = 128 + (byte)( 127.0f * normal[1] );
-				((byte *)( out + x ))[2] = 128 + (byte)( 127.0f * normal[2] );
-				((byte *)( out + x ))[3] = 255;
-			}
-		}
-	}
-	else
-	{
-		for( y = 0; y < outHeight; y++, out += outWidth )
-		{
-			inRow1 = in + inWidth * (int)(((float)y + 0.25f ) * inHeight / outHeight );
-			inRow2 = in + inWidth * (int)(((float)y + 0.75f ) * inHeight / outHeight );
-
-			for( x = 0; x < outWidth; x++ )
-			{
-				pix1 = (byte *)inRow1 + p1[x];
-				pix2 = (byte *)inRow1 + p2[x];
-				pix3 = (byte *)inRow2 + p1[x];
-				pix4 = (byte *)inRow2 + p2[x];
-
-				((byte *)( out + x ))[0] = ( pix1[0] + pix2[0] + pix3[0] + pix4[0] ) >> 2;
-				((byte *)( out + x ))[1] = ( pix1[1] + pix2[1] + pix3[1] + pix4[1] ) >> 2;
-				((byte *)( out + x ))[2] = ( pix1[2] + pix2[2] + pix3[2] + pix4[2] ) >> 2;
-				((byte *)( out + x ))[3] = ( pix1[3] + pix2[3] + pix3[3] + pix4[3] ) >> 2;
-			}
-		}
-	}
-
-	return scaledImage;
-}
-
 /*
 =================
 GL_BuildMipMap

ref/soft/r_light.c

@@ -1,463 +0,0 @@
-/*
-gl_rlight.c - dynamic and static lights
-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 "pm_local.h"
-#include "studio.h"
-#include "xash3d_mathlib.h"
-#include "ref_params.h"
-
-// unused, need refactor
-unsigned blocklights[10240];
-
-/*
-=============================================================================
-
-DYNAMIC LIGHTS
-
-=============================================================================
-*/
-/*
-==================
-CL_RunLightStyles
-
-==================
-*/
-void CL_RunLightStyles( lightstyle_t *ls )
-{
-	int   i;
-	float frametime = ( gp_cl->time - gp_cl->oldtime );
-
-	if( !WORLDMODEL )
-		return;
-
-	if( r_fullbright->value || !WORLDMODEL->lightdata )
-	{
-		for( i = 0; i < MAX_LIGHTSTYLES; i++ )
-			tr.lightstylevalue[i] = 256 * 256;
-		return;
-	}
-
-	// light animations
-	// 'm' is normal light, 'a' is no light, 'z' is double bright
-	for( i = 0; i < MAX_LIGHTSTYLES; i++ )
-	{
-		int   k, flight, clight;
-		float l, lerpfrac, backlerp;
-
-		if( !gp_cl->paused && frametime <= 0.1f )
-			ls[i].time += frametime; // evaluate local time
-
-		if( !ls[i].length )
-		{
-			tr.lightstylevalue[i] = 256;
-			continue;
-		}
-		else if( ls[i].length == 1 )
-		{
-			// single length style so don't bother interpolating
-			tr.lightstylevalue[i] = ( ls[i].map[0] ) * 22;
-			continue;
-		}
-
-		flight = (int)Q_floor( ls[i].time * 10 );
-
-		if( !ls[i].interp || !cl_lightstyle_lerping->value )
-		{
-			tr.lightstylevalue[i] = ls[i].map[flight % ls[i].length] * 22;
-			continue;
-		}
-
-		clight = (int)Q_ceil( ls[i].time * 10 );
-		lerpfrac = ( ls[i].time * 10 ) - flight;
-		backlerp = 1.0f - lerpfrac;
-
-		// interpolate animating light
-		// frame just gone
-		k = ls[i].map[flight % ls[i].length];
-		l = (float)( k * 22.0f ) * backlerp;
-
-		// upcoming frame
-		k = ls[i].map[clight % ls[i].length];
-		l += (float)( k * 22.0f ) * lerpfrac;
-
-		tr.lightstylevalue[i] = (int)l;
-	}
-}
-
-/*
-=============
-R_MarkLights
-=============
-*/
-void R_MarkLights( dlight_t *light, int bit, mnode_t *node )
-{
-	float		dist;
-	msurface_t	*surf;
-	int		i;
-	int firstsurface, numsurfaces;
-
-	if( !node || node->contents < 0 )
-		return;
-
-	dist = PlaneDiff( light->origin, node->plane );
-
-	firstsurface = node_firstsurface( node, RI.currentmodel );
-	numsurfaces = node_numsurfaces( node, RI.currentmodel );
-
-	if( dist > light->radius )
-	{
-		R_MarkLights( light, bit, node_child( node, 0, RI.currentmodel ));
-		return;
-	}
-	if( dist < -light->radius )
-	{
-		R_MarkLights( light, bit, node_child( node, 1, RI.currentmodel ));
-		return;
-	}
-
-	// mark the polygons
-	surf = RI.currentmodel->surfaces + firstsurface;
-
-	for( i = 0; i < numsurfaces; i++, surf++ )
-	{
-		if( !BoundsAndSphereIntersect( surf->info->mins, surf->info->maxs, light->origin, light->radius ))
-			continue;	// no intersection
-
-		if( surf->dlightframe != tr.dlightframecount )
-		{
-			surf->dlightbits = 0;
-			surf->dlightframe = tr.dlightframecount;
-		}
-		surf->dlightbits |= bit;
-	}
-
-	R_MarkLights( light, bit, node_child( node, 0, RI.currentmodel ));
-	R_MarkLights( light, bit, node_child( node, 1, RI.currentmodel ));
-}
-
-/*
-=============
-R_PushDlights
-=============
-*/
-void R_PushDlights( void )
-{
-	int i;
-
-	tr.dlightframecount = tr.framecount;
-
-	RI.currententity = CL_GetEntityByIndex( 0 );
-
-	// no world -- no dlights
-	if( !RI.currententity )
-		return;
-
-	RI.currentmodel = RI.currententity->model;
-
-	for( i = 0; i < MAX_DLIGHTS; i++ )
-	{
-		dlight_t *l = &tr.dlights[i];
-
-		if( l->die < gp_cl->time || !l->radius )
-			continue;
-
-		R_MarkLights( l, 1 << i, RI.currentmodel->nodes );
-	}
-}
-
-/*
-=======================================================================
-
-	AMBIENT LIGHTING
-
-=======================================================================
-*/
-static vec3_t g_trace_lightspot;
-static vec3_t g_trace_lightvec;
-static float  g_trace_fraction;
-
-/*
-=================
-R_RecursiveLightPoint
-=================
-*/
-static qboolean R_RecursiveLightPoint( model_t *model, mnode_t *node, float p1f, float p2f, colorVec *cv, const vec3_t start, const vec3_t end )
-{
-	float        front, back, frac, midf;
-	int          i, map, side, size;
-	float        ds, dt, s, t;
-	int          sample_size;
-	color24      *lm, *dm;
-	mextrasurf_t *info;
-	msurface_t   *surf;
-	matrix3x4    tbn;
-	vec3_t       mid;
-	int firstsurface, numsurfaces;
-
-	// didn't hit anything
-	if( !node || node->contents < 0 )
-	{
-		cv->r = cv->g = cv->b = cv->a = 0;
-		return false;
-	}
-
-	firstsurface = node_firstsurface( node, model );
-	numsurfaces = node_numsurfaces( node, model );
-
-	// calculate mid point
-	front = PlaneDiff( start, node->plane );
-	back = PlaneDiff( end, node->plane );
-
-	side = front < 0;
-	if(( back < 0 ) == side )
-		return R_RecursiveLightPoint( model, node_child( node, side, model ), p1f, p2f, cv, start, end );
-
-	frac = front / ( front - back );
-
-	VectorLerp( start, frac, end, mid );
-	midf = p1f + ( p2f - p1f ) * frac;
-
-	// co down front side
-	if( R_RecursiveLightPoint( model, node_child( node, side, model ), p1f, midf, cv, start, mid ))
-		return true; // hit something
-
-	if(( back < 0 ) == side )
-	{
-		cv->r = cv->g = cv->b = cv->a = 0;
-		return false; // didn't hit anything
-	}
-
-	// check for impact on this node
-	surf = model->surfaces + firstsurface;
-	VectorCopy( mid, g_trace_lightspot );
-
-	for( i = 0; i < numsurfaces; i++, surf++ )
-	{
-		int smax, tmax;
-
-		info = surf->info;
-
-		if( FBitSet( surf->flags, SURF_DRAWTILED ))
-			continue; // no lightmaps
-
-		s = DotProduct( mid, info->lmvecs[0] ) + info->lmvecs[0][3];
-		t = DotProduct( mid, info->lmvecs[1] ) + info->lmvecs[1][3];
-
-		if( s < info->lightmapmins[0] || t < info->lightmapmins[1] )
-			continue;
-
-		ds = s - info->lightmapmins[0];
-		dt = t - info->lightmapmins[1];
-
-		if( ds > info->lightextents[0] || dt > info->lightextents[1] )
-			continue;
-
-		cv->r = cv->g = cv->b = cv->a = 0;
-
-		if( !surf->samples )
-			return true;
-
-		sample_size = gEngfuncs.Mod_SampleSizeForFace( surf );
-		smax = ( info->lightextents[0] / sample_size ) + 1;
-		tmax = ( info->lightextents[1] / sample_size ) + 1;
-		ds /= sample_size;
-		dt /= sample_size;
-
-		lm = surf->samples + Q_rint( dt ) * smax + Q_rint( ds );
-		g_trace_fraction = midf;
-		size = smax * tmax;
-		dm = NULL;
-
-		if( surf->info->deluxemap )
-		{
-			vec3_t faceNormal;
-
-			if( FBitSet( surf->flags, SURF_PLANEBACK ))
-				VectorNegate( surf->plane->normal, faceNormal );
-			else
-				VectorCopy( surf->plane->normal, faceNormal );
-
-			// compute face TBN
-#if 1
-			Vector4Set( tbn[0], surf->info->lmvecs[0][0], surf->info->lmvecs[0][1], surf->info->lmvecs[0][2], 0.0f );
-			Vector4Set( tbn[1], -surf->info->lmvecs[1][0], -surf->info->lmvecs[1][1], -surf->info->lmvecs[1][2], 0.0f );
-			Vector4Set( tbn[2], faceNormal[0], faceNormal[1], faceNormal[2], 0.0f );
-#else
-			Vector4Set( tbn[0], surf->info->lmvecs[0][0], -surf->info->lmvecs[1][0], faceNormal[0], 0.0f );
-			Vector4Set( tbn[1], surf->info->lmvecs[0][1], -surf->info->lmvecs[1][1], faceNormal[1], 0.0f );
-			Vector4Set( tbn[2], surf->info->lmvecs[0][2], -surf->info->lmvecs[1][2], faceNormal[2], 0.0f );
-#endif
-			VectorNormalize( tbn[0] );
-			VectorNormalize( tbn[1] );
-			VectorNormalize( tbn[2] );
-			dm = surf->info->deluxemap + Q_rint( dt ) * smax + Q_rint( ds );
-		}
-
-		for( map = 0; map < MAXLIGHTMAPS && surf->styles[map] != 255; map++ )
-		{
-			uint scale = tr.lightstylevalue[surf->styles[map]];
-
-			cv->r += lm->r * scale;
-			cv->g += lm->g * scale;
-			cv->b += lm->b * scale;
-
-			lm += size; // skip to next lightmap
-
-			if( dm != NULL )
-			{
-				vec3_t srcNormal, lightNormal;
-				float  f = ( 1.0f / 128.0f );
-
-				VectorSet( srcNormal, ((float)dm->r - 128.0f ) * f, ((float)dm->g - 128.0f ) * f, ((float)dm->b - 128.0f ) * f );
-				Matrix3x4_VectorIRotate( tbn, srcNormal, lightNormal );        // turn to world space
-				VectorScale( lightNormal, (float)scale * -1.0f, lightNormal ); // turn direction from light
-				VectorAdd( g_trace_lightvec, lightNormal, g_trace_lightvec );
-				dm += size; // skip to next deluxmap
-			}
-		}
-
-		return true;
-	}
-
-	// go down back side
-	return R_RecursiveLightPoint( model, node_child( node, !side, model ), midf, p2f, cv, mid, end );
-}
-
-/*
-=================
-R_LightVec
-
-check bspmodels to get light from
-=================
-*/
-static colorVec R_LightVecInternal( const vec3_t start, const vec3_t end, vec3_t lspot, vec3_t lvec )
-{
-	float    last_fraction;
-	int      i, maxEnts = 1;
-	colorVec light, cv;
-
-	if( lspot )
-		VectorClear( lspot );
-	if( lvec )
-		VectorClear( lvec );
-
-	if( WORLDMODEL && WORLDMODEL->lightdata )
-	{
-		light.r = light.g = light.b = light.a = 0;
-		last_fraction = 1.0f;
-
-		// get light from bmodels too
-		// if( CVAR_TO_BOOL( r_lighting_extended ))
-		maxEnts = MAX_PHYSENTS;
-
-		// check all the bsp-models
-		for( i = 0; i < maxEnts; i++ )
-		{
-			physent_t *pe = gEngfuncs.EV_GetPhysent( i );
-			vec3_t    offset, start_l, end_l;
-			mnode_t   *pnodes;
-			matrix4x4 matrix;
-
-			if( !pe )
-				break;
-
-			if( !pe->model || pe->model->type != mod_brush )
-				continue; // skip non-bsp models
-
-			pnodes = &pe->model->nodes[pe->model->hulls[0].firstclipnode];
-			VectorSubtract( pe->model->hulls[0].clip_mins, vec3_origin, offset );
-			VectorAdd( offset, pe->origin, offset );
-			VectorSubtract( start, offset, start_l );
-			VectorSubtract( end, offset, end_l );
-
-			// rotate start and end into the models frame of reference
-			if( !VectorIsNull( pe->angles ))
-			{
-				Matrix4x4_CreateFromEntity( matrix, pe->angles, offset, 1.0f );
-				Matrix4x4_VectorITransform( matrix, start, start_l );
-				Matrix4x4_VectorITransform( matrix, end, end_l );
-			}
-
-			VectorClear( g_trace_lightspot );
-			VectorClear( g_trace_lightvec );
-			g_trace_fraction = 1.0f;
-
-			if( !R_RecursiveLightPoint( pe->model, pnodes, 0.0f, 1.0f, &cv, start_l, end_l ))
-				continue; // didn't hit anything
-
-			if( g_trace_fraction < last_fraction )
-			{
-				if( lspot )
-					VectorCopy( g_trace_lightspot, lspot );
-				if( lvec )
-					VectorNormalize2( g_trace_lightvec, lvec );
-				light.r = Q_min(( cv.r >> 8 ), 255 );
-				light.g = Q_min(( cv.g >> 8 ), 255 );
-				light.b = Q_min(( cv.b >> 8 ), 255 );
-				last_fraction = g_trace_fraction;
-
-				if(( light.r + light.g + light.b ) != 0 )
-					break; // we get light now
-			}
-		}
-	}
-	else
-	{
-		light.r = light.g = light.b = 255;
-		light.a = 0;
-	}
-
-	return light;
-}
-
-/*
-=================
-R_LightVec
-
-check bspmodels to get light from
-=================
-*/
-colorVec GAME_EXPORT R_LightVec( const vec3_t start, const vec3_t end, vec3_t lspot, vec3_t lvec )
-{
-	colorVec light = R_LightVecInternal( start, end, lspot, lvec );
-
-	// light.r = light.g = light.b = 255;
-
-	if( lspot != NULL && lvec != NULL ) // CVAR_TO_BOOL( r_lighting_extended ) &&
-	{
-		// trying to get light from ceiling (but ignore gradient analyze)
-		if(( light.r + light.g + light.b ) == 0 )
-			return R_LightVecInternal( end, start, lspot, lvec );
-	}
-
-	return light;
-}
-
-/*
-=================
-R_LightPoint
-
-light from floor
-=================
-*/
-colorVec GAME_EXPORT R_LightPoint( const vec3_t p0 )
-{
-	vec3_t p1;
-
-	VectorSet( p1, p0[0], p0[1], p0[2] - 2048.0f );
-
-	return R_LightVec( p0, p1, NULL, NULL );
-}

ref/soft/r_local.h

@@ -15,16 +15,11 @@ GNU General Public License for more details.
 
 #ifndef GL_LOCAL_H
 #define GL_LOCAL_H
+#include "ref_common.h"
 #include "port.h"
 #include "xash3d_types.h"
 #include "cvardef.h"
-#include "const.h"
-#include "com_model.h"
-#include "cl_entity.h"
-#include "render_api.h"
 #include "protocol.h"
-#include "ref_api.h"
-#include "xash3d_mathlib.h"
 #include "ref_params.h"
 #include "enginefeatures.h"
 #include "com_strings.h"
@@ -36,16 +31,13 @@ typedef struct mip_s mip_t;
 typedef int fixed8_t;
 typedef int fixed16_t;
 
-#define ASSERT( x ) if( !( x )) gEngfuncs.Host_Error( "assert failed at %s:%i\n", __FILE__, __LINE__ )
-#define Assert( x ) if( !( x )) gEngfuncs.Host_Error( "assert failed at %s:%i\n", __FILE__, __LINE__ )
+#define ASSERT( x ) Assert( x )
 
 #include <stdio.h>
 
 // make mod_ref.h?
 #define LM_SAMPLE_SIZE 16
 
-extern poolhandle_t r_temppool;
-
 #define BLOCK_SIZE         tr.block_size        // lightmap blocksize
 #define BLOCK_SIZE_DEFAULT 128                  // for keep backward compatibility
 #define BLOCK_SIZE_MAX     1024
@@ -259,7 +251,6 @@ typedef struct
 	int          max_recursion;
 
 	byte         visbytes[( MAX_MAP_LEAFS + 7 ) / 8]; // member custom PVS
-	int          lightstylevalue[MAX_LIGHTSTYLES];    // value 0 - 65536
 	int          block_size;                          // lightmap blocksize
 
 	double       frametime;         // special frametime for multipass rendering (will set to 0 on a nextview)
@@ -278,7 +269,6 @@ typedef struct
 	color24      *palette;
 	cl_entity_t  *viewent;
 	lightstyle_t *lightstyles;
-	dlight_t     *dlights;
 	dlight_t     *elights;
 	byte         *texgammatable;
 	uint         *lightgammatable;
@@ -375,7 +365,6 @@ image_t *R_GetTexture( unsigned int texnum );
 int GL_LoadTexture( const char *name, const byte *buf, size_t size, int flags );
 int GL_LoadTextureArray( const char **names, int flags );
 int GL_LoadTextureFromBuffer( const char *name, rgbdata_t *pic, texFlags_t flags, qboolean update );
-byte *GL_ResampleTexture( const byte *source, int in_w, int in_h, int out_w, int out_h, qboolean isNormalMap );
 int GL_CreateTexture( const char *name, int width, int height, const void *buffer, texFlags_t flags );
 int GL_CreateTextureArray( const char *name, int width, int height, int depth, const void *buffer, texFlags_t flags );
 void GL_ProcessTexture( int texnum, float gamma, int topColor, int bottomColor );
@@ -389,17 +378,6 @@ void R_InitImages( void );
 void R_ShutdownImages( void );
 int R_TexMemory( void );
 
-#if 1
-//
-// gl_rlight.c
-//
-void CL_RunLightStyles( lightstyle_t *ls );
-void R_PushDlights( void );
-void R_GetLightSpot( vec3_t lightspot );
-void R_MarkLights( dlight_t *light, int bit, mnode_t *node );
-colorVec R_LightVec( const vec3_t start, const vec3_t end, vec3_t lightspot, vec3_t lightvec );
-colorVec R_LightPoint( const vec3_t p0 );
-#endif
 //
 // gl_rmain.c
 //
@@ -419,18 +397,6 @@ void R_PushScene( void );
 void R_PopScene( void );
 void R_DrawFog( void );
 
-//
-// gl_rmath.c
-//
-void Matrix4x4_Concat( matrix4x4 out, const matrix4x4 in1, const matrix4x4 in2 );
-void Matrix4x4_ConcatTranslate( matrix4x4 out, float x, float y, float z );
-void Matrix4x4_ConcatRotate( matrix4x4 out, float angle, float x, float y, float z );
-void Matrix4x4_CreateTranslate( matrix4x4 out, float x, float y, float z );
-void Matrix4x4_CreateRotate( matrix4x4 out, float angle, float x, float y, float z );
-void Matrix4x4_CreateProjection( matrix4x4 out, float xMax, float xMin, float yMax, float yMin, float zNear, float zFar );
-void Matrix4x4_CreateOrtho( matrix4x4 m, float xLeft, float xRight, float yBottom, float yTop, float zNear, float zFar );
-void Matrix4x4_CreateModelview( matrix4x4 out );
-
 //
 // gl_rpart.c
 //
@@ -442,9 +408,6 @@ void CL_DrawTracers( double frametime, particle_t *cl_active_tracers );
 //
 // gl_sprite.c
 //
-void R_SpriteInit( void );
-void Mod_LoadSpriteModel( model_t *mod, const void *buffer, qboolean *loaded, uint texFlags );
-mspriteframe_t *R_GetSpriteFrame( const model_t *pModel, int frame, float yaw );
 void R_DrawSpriteModel( cl_entity_t *e );
 
 //
@@ -507,7 +470,6 @@ void R_RenderFrame( const struct ref_viewpass_s *vp );
 void R_EndFrame( void );
 void R_ClearScene( void );
 void R_GetTextureParms( int *w, int *h, int texnum );
-void R_GetSpriteParms( int *frameWidth, int *frameHeight, int *numFrames, int curFrame, const struct model_s *pSprite );
 void R_DrawStretchRaw( float x, float y, float w, float h, int cols, int rows, const byte *data, qboolean dirty );
 void R_DrawStretchPic( float x, float y, float w, float h, float s1, float t1, float s2, float t2, int texnum );
 qboolean R_SpeedsMessage( char *out, size_t size );
@@ -515,13 +477,11 @@ qboolean R_CullBox( const vec3_t mins, const vec3_t maxs );
 int R_WorldToScreen( const vec3_t point, vec3_t screen );
 void R_ScreenToWorld( const vec3_t screen, vec3_t point );
 qboolean R_AddEntity( struct cl_entity_s *pRefEntity, int entityType );
-void Mod_SpriteUnloadTextures( void *data );
 void Mod_UnloadAliasModel( struct model_s *mod );
 void Mod_AliasUnloadTextures( void *data );
 void GL_SetRenderMode( int mode );
 void R_RunViewmodelEvents( void );
 void R_DrawViewModel( void );
-int R_GetSpriteTexture( const struct model_s *m_pSpriteModel, int frame );
 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 );
@@ -529,7 +489,6 @@ void R_ClearAllDecals( void );
 byte *Mod_GetCurrentVis( void );
 void Mod_SetOrthoBounds( const float *mins, const float *maxs );
 void R_NewMap( void );
-void CL_AddCustomBeam( cl_entity_t *pEnvBeam );
 
 //
 // gl_triapi.c
@@ -552,15 +511,7 @@ void TriFogParams( float flDensity, int iFogSkybox );
 void TriCullFace( TRICULLSTYLE mode );
 void TriBrightness( float brightness );
 
-#define ENGINE_GET_PARM_ ( *gEngfuncs.EngineGetParm )
-#define ENGINE_GET_PARM( parm ) ENGINE_GET_PARM_(( parm ), 0 )
 
-extern ref_api_t     gEngfuncs;
-extern ref_globals_t *gpGlobals;
-extern ref_client_t  *gp_cl;
-extern ref_host_t    *gp_host;
-
-DECLARE_ENGINE_SHARED_CVAR_LIST()
 
 //
 // helper funcs
@@ -1099,7 +1050,6 @@ void R_ScanEdges( void );
 //
 // r_surf.c
 //
-void GL_InitRandomTable( void );
 void D_FlushCaches( void );
 
 //
@@ -1147,16 +1097,6 @@ void R_SetUpWorldTransform( void );
 //
 #include "crtlib.h"
 #include "crclib.h"
-void _Mem_Free( void *data, const char *filename, int fileline );
-void *_Mem_Alloc( poolhandle_t poolptr, size_t size, qboolean clear, const char *filename, int fileline )
-ALLOC_CHECK( 2 ) MALLOC_LIKE( _Mem_Free, 1 ) WARN_UNUSED_RESULT;
 
-#define Mem_Malloc( pool, size )       _Mem_Alloc( pool, size, false, __FILE__, __LINE__ )
-#define Mem_Calloc( pool, size )       _Mem_Alloc( pool, size, true, __FILE__, __LINE__ )
-#define Mem_Realloc( pool, ptr, size ) gEngfuncs._Mem_Realloc( pool, ptr, size, true, __FILE__, __LINE__ )
-#define Mem_Free( mem )                _Mem_Free( mem, __FILE__, __LINE__ )
-#define Mem_AllocPool( name )          gEngfuncs._Mem_AllocPool( name, __FILE__, __LINE__ )
-#define Mem_FreePool( pool )           gEngfuncs._Mem_FreePool( pool, __FILE__, __LINE__ )
-#define Mem_EmptyPool( pool )          gEngfuncs._Mem_EmptyPool( pool, __FILE__, __LINE__ )
 
 #endif // GL_LOCAL_H

ref/soft/r_main.c

@@ -71,7 +71,6 @@ CVAR_DEFINE_AUTO( sw_texfilt, "0", FCVAR_GLCONFIG, "texture dither" );
 static CVAR_DEFINE_AUTO( r_novis, "0", 0, "" );
 
 
-DEFINE_ENGINE_SHARED_CVAR_LIST()
 
 int r_viewcluster, r_oldviewcluster;
 
@@ -319,9 +318,6 @@ qboolean GAME_EXPORT R_AddEntity( struct cl_entity_s *clent, int type )
 	if( !r_drawentities->value )
 		return false; // not allow to drawing
 
-	if( !clent || !clent->model )
-		return false; // if set to invisible, skip
-
 	if( FBitSet( clent->curstate.effects, EF_NODRAW ))
 		return false; // done
 
@@ -331,7 +327,20 @@ qboolean GAME_EXPORT R_AddEntity( struct cl_entity_s *clent, int type )
 	if( type == ET_FRAGMENTED )
 		r_stats.c_client_ents++;
 
-	if( R_OpaqueEntity( clent ))
+	if( type == ET_BEAM )
+	{
+		if( tr.draw_list->num_beam_entities >= MAX_VISIBLE_PACKET )
+		{
+			gEngfuncs.Con_Printf( S_ERROR "Too many beams %d!\n", tr.draw_list->num_beam_entities );
+			return false;
+		}
+
+		tr.draw_list->beam_entities[tr.draw_list->num_beam_entities] = clent;
+		tr.draw_list->num_beam_entities++;
+
+		return true;
+	}
+	else if( R_OpaqueEntity( clent ))
 	{
 		if( clent->model->type == mod_brush )
 		{
@@ -831,21 +840,8 @@ static void R_DrawBEntitiesOnList( void )
 		R_RotateBmodel();
 
 		// calculate dynamic lighting for bmodel
-		for( k = 0; k < MAX_DLIGHTS; k++ )
-		{
-			dlight_t *l = &tr.dlights[k];
-			vec3_t   origin_l, oldorigin;
-
-			if( l->die < gp_cl->time || !l->radius )
-				continue;
-
-			VectorCopy( l->origin, oldorigin ); // save lightorigin
-			Matrix4x4_CreateFromEntity( RI.objectMatrix, RI.currententity->angles, RI.currententity->origin, 1 );
-			Matrix4x4_VectorITransform( RI.objectMatrix, l->origin, origin_l );
-			VectorCopy( origin_l, l->origin ); // move light in bmodel space
-			R_MarkLights( l, 1 << k, RI.currentmodel->nodes + RI.currentmodel->hulls[0].firstclipnode );
-			VectorCopy( oldorigin, l->origin ); // restore lightorigin
-		}
+		Matrix4x4_CreateFromEntity( RI.objectMatrix, RI.currententity->angles, RI.currententity->origin, 1 );
+		R_PushDlightsForBmodel( RI.currentmodel, tr.dlightframecount, RI.objectMatrix );
 
 		RI.currententity->topnode = topnode;
 		if( topnode->contents >= 0 )
@@ -956,22 +952,9 @@ void R_DrawBrushModel( cl_entity_t *pent )
 	R_RotateBmodel();
 
 	// calculate dynamic lighting for bmodel
-	for( k = 0; k < MAX_DLIGHTS; k++ )
-	{
-		dlight_t *l = &tr.dlights[k];
-		vec3_t   origin_l, oldorigin;
-
-		if( l->die < gp_cl->time || !l->radius )
-			continue;
-
-		VectorCopy( l->origin, oldorigin );         // save lightorigin
-		Matrix4x4_CreateFromEntity( RI.objectMatrix, RI.currententity->angles, RI.currententity->origin, 1 );
-		Matrix4x4_VectorITransform( RI.objectMatrix, l->origin, origin_l );
-		tr.modelviewIdentity = false;
-		VectorCopy( origin_l, l->origin );         // move light in bmodel space
-		R_MarkLights( l, 1 << k, RI.currentmodel->nodes + RI.currentmodel->hulls[0].firstclipnode );
-		VectorCopy( oldorigin, l->origin );         // restore lightorigin*/
-	}
+	Matrix4x4_CreateFromEntity( RI.objectMatrix, RI.currententity->angles, RI.currententity->origin, 1 );
+	R_PushDlightsForBmodel( RI.currentmodel, tr.dlightframecount, RI.objectMatrix );
+	tr.modelviewIdentity = false;
 
 	RI.currententity->topnode = topnode;
 	if( topnode->contents >= 0 )
@@ -1121,7 +1104,7 @@ void GAME_EXPORT R_RenderScene( void )
 	R_SetupFrustum();
 	R_SetupFrame();
 
-	R_PushDlights();
+	tr.dlightframecount = R_PushDlights( WORLDMODEL, tr.framecount );
 	R_SetupModelviewMatrix( RI.worldviewMatrix );
 	R_SetupProjectionMatrix( RI.projectionMatrix );
 
@@ -1397,9 +1380,6 @@ qboolean GAME_EXPORT R_Init( void )
 {
 	qboolean glblit = false;
 
-	RETRIEVE_ENGINE_SHARED_CVAR_LIST();
-
-
 	gEngfuncs.Cvar_RegisterVariable( &sw_clearcolor );
 	gEngfuncs.Cvar_RegisterVariable( &sw_drawflat );
 	gEngfuncs.Cvar_RegisterVariable( &sw_draworder );
@@ -1444,8 +1424,7 @@ qboolean GAME_EXPORT R_Init( void )
 	tr.lightgammatable = (uint *)ENGINE_GET_PARM( PARM_GET_LIGHTGAMMATABLE_PTR );
 	tr.screengammatable = (uint *)ENGINE_GET_PARM( PARM_GET_SCREENGAMMATABLE_PTR );
 	tr.lineargammatable = (uint *)ENGINE_GET_PARM( PARM_GET_LINEARGAMMATABLE_PTR );
-	tr.dlights = (dlight_t *)ENGINE_GET_PARM( PARM_GET_DLIGHTS_PTR );
-	tr.elights = (dlight_t *)ENGINE_GET_PARM( PARM_GET_ELIGHTS_PTR );
+		tr.elights = (dlight_t *)ENGINE_GET_PARM( PARM_GET_ELIGHTS_PTR );
 
 	if( !R_InitBlit( glblit ))
 	{
@@ -1462,7 +1441,6 @@ qboolean GAME_EXPORT R_Init( void )
 	qfrustum.view_clipplanes[1].leftedge = qfrustum.view_clipplanes[2].leftedge = qfrustum.view_clipplanes[3].leftedge = false;
 	qfrustum.view_clipplanes[0].rightedge = qfrustum.view_clipplanes[2].rightedge = qfrustum.view_clipplanes[3].rightedge = false;
 	R_StudioInit();
-	R_SpriteInit();
 	R_InitTurb();
 	GL_InitRandomTable();
 

ref/soft/r_sprite.c

@@ -21,317 +21,8 @@ GNU General Public License for more details.
 
 #define GLARE_FALLOFF 19000.0f
 
-static char  sprite_name[MAX_QPATH];
-static char  group_suffix[8];
-static uint  r_texFlags = 0;
-static int   sprite_version;
 static float sprite_radius;
 
-/*
-====================
-R_SpriteInit
-
-====================
-*/
-void R_SpriteInit( void )
-{
-}
-
-/*
-====================
-R_SpriteLoadFrame
-
-upload a single frame
-====================
-*/
-static const byte *R_SpriteLoadFrame( model_t *mod, const void *pin, mspriteframe_t **ppframe, int num )
-{
-	dspriteframe_t pinframe;
-	mspriteframe_t *pspriteframe;
-	int gl_texturenum = 0;
-	char           texname[128];
-	int bytes = 1;
-
-	memcpy( &pinframe, pin, sizeof( dspriteframe_t ));
-
-	if( sprite_version == SPRITE_VERSION_32 )
-		bytes = 4;
-
-	// build uinque frame name
-	if( FBitSet( mod->flags, MODEL_CLIENT )) // it's a HUD sprite
-	{
-		Q_snprintf( texname, sizeof( texname ), "#HUD/%s(%s:%i%i).spr", sprite_name, group_suffix, num / 10, num % 10 );
-		gl_texturenum = GL_LoadTexture( texname, pin, pinframe.width * pinframe.height * bytes, r_texFlags );
-	}
-	else
-	{
-		Q_snprintf( texname, sizeof( texname ), "#%s(%s:%i%i).spr", sprite_name, group_suffix, num / 10, num % 10 );
-		gl_texturenum = GL_LoadTexture( texname, pin, pinframe.width * pinframe.height * bytes, r_texFlags );
-	}
-
-	// setup frame description
-	pspriteframe = Mem_Malloc( mod->mempool, sizeof( mspriteframe_t ));
-	pspriteframe->width = pinframe.width;
-	pspriteframe->height = pinframe.height;
-	pspriteframe->up = pinframe.origin[1];
-	pspriteframe->left = pinframe.origin[0];
-	pspriteframe->down = pinframe.origin[1] - pinframe.height;
-	pspriteframe->right = pinframe.width + pinframe.origin[0];
-	pspriteframe->gl_texturenum = gl_texturenum;
-	*ppframe = pspriteframe;
-
-	return (const byte *)((const byte *)pin + sizeof( dspriteframe_t ) + pinframe.width * pinframe.height * bytes );
-}
-
-/*
-====================
-R_SpriteLoadGroup
-
-upload a group frames
-====================
-*/
-static const void *R_SpriteLoadGroup( model_t *mod, const void *pin, mspriteframe_t **ppframe, int framenum )
-{
-	const dspritegroup_t    *pingroup;
-	mspritegroup_t          *pspritegroup;
-	const dspriteinterval_t *pin_intervals;
-	float      *poutintervals;
-	int        i, groupsize, numframes;
-	const void *ptemp;
-
-	pingroup = (const dspritegroup_t *)pin;
-	numframes = pingroup->numframes;
-
-	groupsize = sizeof( mspritegroup_t ) + ( numframes - 1 ) * sizeof( pspritegroup->frames[0] );
-	pspritegroup = Mem_Calloc( mod->mempool, groupsize );
-	pspritegroup->numframes = numframes;
-
-	*ppframe = (mspriteframe_t *)pspritegroup;
-	pin_intervals = (const dspriteinterval_t *)( pingroup + 1 );
-	poutintervals = Mem_Calloc( mod->mempool, numframes * sizeof( float ));
-	pspritegroup->intervals = poutintervals;
-
-	for( i = 0; i < numframes; i++ )
-	{
-		*poutintervals = pin_intervals->interval;
-		if( *poutintervals <= 0.0f )
-			*poutintervals = 1.0f; // set error value
-		poutintervals++;
-		pin_intervals++;
-	}
-
-	ptemp = (const void *)pin_intervals;
-	for( i = 0; i < numframes; i++ )
-	{
-		ptemp = R_SpriteLoadFrame( mod, ptemp, &pspritegroup->frames[i], framenum * 10 + i );
-	}
-
-	return ptemp;
-}
-
-/*
-====================
-Mod_LoadSpriteModel
-
-load sprite model
-====================
-*/
-void Mod_LoadSpriteModel( model_t *mod, const void *buffer, qboolean *loaded, uint texFlags )
-{
-	const dsprite_t *pin;
-	const short     *numi = NULL;
-	const byte      *pframetype;
-	msprite_t       *psprite;
-	int i;
-
-	pin = buffer;
-	psprite = mod->cache.data;
-
-	if( pin->version == SPRITE_VERSION_Q1 || pin->version == SPRITE_VERSION_32 )
-		numi = NULL;
-	else if( pin->version == SPRITE_VERSION_HL )
-		numi = (const short *)((const byte *)buffer + sizeof( dsprite_hl_t ));
-
-	r_texFlags = texFlags;
-	sprite_version = pin->version;
-	Q_strncpy( sprite_name, mod->name, sizeof( sprite_name ));
-	COM_StripExtension( sprite_name );
-
-	if( numi == NULL )
-	{
-		rgbdata_t *pal;
-
-		pal = gEngfuncs.FS_LoadImage( "#id.pal", (byte *)&i, 768 );
-		pframetype = ((const byte *)buffer + sizeof( dsprite_q1_t )); // pinq1 + 1
-		gEngfuncs.FS_FreeImage( pal );                                // palette installed, no reason to keep this data
-	}
-	else if( *numi <= 256 )
-	{
-		const byte	*src = (const byte *)(numi+1);
-		rgbdata_t	*pal;
-		size_t pal_bytes = *numi * 3;
-
-		// install palette
-		switch( psprite->texFormat )
-		{
-		case SPR_INDEXALPHA:
-			pal = gEngfuncs.FS_LoadImage( "#gradient.pal", src, pal_bytes );
-			break;
-		case SPR_ALPHTEST:
-			pal = gEngfuncs.FS_LoadImage( "#masked.pal", src, pal_bytes );
-			break;
-		default:
-			pal = gEngfuncs.FS_LoadImage( "#texgamma.pal", src, pal_bytes );
-			break;
-		}
-
-		pframetype = (const byte *)(src + pal_bytes);
-		gEngfuncs.FS_FreeImage( pal ); // palette installed, no reason to keep this data
-	}
-	else
-	{
-		gEngfuncs.Con_DPrintf( S_ERROR "%s has wrong number of palette colors %i (should be less or equal than 256)\n", mod->name, *numi );
-		return;
-	}
-
-	if( mod->numframes < 1 )
-		return;
-
-	for( i = 0; i < mod->numframes; i++ )
-	{
-		frametype_t  frametype;
-		dframetype_t dframetype;
-
-		memcpy( &dframetype, pframetype, sizeof( dframetype ));
-		frametype = dframetype.type;
-		psprite->frames[i].type = (spriteframetype_t)frametype;
-
-		switch( frametype )
-		{
-		case FRAME_SINGLE:
-			Q_strncpy( group_suffix, "frame", sizeof( group_suffix ));
-			pframetype = R_SpriteLoadFrame( mod, pframetype + sizeof( dframetype_t ), &psprite->frames[i].frameptr, i );
-			break;
-		case FRAME_GROUP:
-			Q_strncpy( group_suffix, "group", sizeof( group_suffix ));
-			pframetype = R_SpriteLoadGroup( mod, pframetype + sizeof( dframetype_t ), &psprite->frames[i].frameptr, i );
-			break;
-		case FRAME_ANGLED:
-			Q_strncpy( group_suffix, "angle", sizeof( group_suffix ));
-			pframetype = R_SpriteLoadGroup( mod, pframetype + sizeof( dframetype_t ), &psprite->frames[i].frameptr, i );
-			break;
-		}
-		if( pframetype == NULL )
-			break;                  // technically an error
-	}
-
-	if( loaded )
-		*loaded = true;         // done
-}
-
-/*
-====================
-Mod_UnloadSpriteModel
-
-release sprite model and frames
-====================
-*/
-void Mod_SpriteUnloadTextures( void *data )
-{
-	msprite_t *psprite = data;
-	int i;
-
-	if( !data )
-		return;
-
-	// release all textures
-	for( i = 0; i < psprite->numframes; i++ )
-	{
-		if( !psprite->frames[i].frameptr )
-			continue;
-
-		if( psprite->frames[i].type == SPR_SINGLE )
-		{
-			GL_FreeTexture( psprite->frames[i].frameptr->gl_texturenum );
-		}
-		else
-		{
-			mspritegroup_t *pspritegroup = (mspritegroup_t *)psprite->frames[i].frameptr;
-			int j;
-
-			for( j = 0; j < pspritegroup->numframes; j++ )
-			{
-				if( pspritegroup->frames[j] )
-					GL_FreeTexture( pspritegroup->frames[j]->gl_texturenum );
-			}
-		}
-	}
-}
-
-/*
-================
-R_GetSpriteFrame
-
-assume pModel is valid
-================
-*/
-mspriteframe_t *R_GetSpriteFrame( const model_t *pModel, int frame, float yaw )
-{
-	msprite_t      *psprite;
-	mspritegroup_t *pspritegroup;
-	mspriteframe_t *pspriteframe = NULL;
-	float          *pintervals, fullinterval;
-	int i, numframes;
-	float          targettime;
-
-	Assert( pModel != NULL );
-	psprite = pModel->cache.data;
-
-	if( frame < 0 )
-	{
-		frame = 0;
-	}
-	else if( frame >= psprite->numframes )
-	{
-		if( frame > psprite->numframes )
-			gEngfuncs.Con_Printf( S_WARN "%s: no such frame %d (%s)\n", __func__, frame, pModel->name );
-		frame = psprite->numframes - 1;
-	}
-
-	if( psprite->frames[frame].type == SPR_SINGLE )
-	{
-		pspriteframe = psprite->frames[frame].frameptr;
-	}
-	else if( psprite->frames[frame].type == SPR_GROUP )
-	{
-		pspritegroup = (mspritegroup_t *)psprite->frames[frame].frameptr;
-		pintervals = pspritegroup->intervals;
-		numframes = pspritegroup->numframes;
-		fullinterval = pintervals[numframes - 1];
-
-		// when loading in Mod_LoadSpriteGroup, we guaranteed all interval values
-		// are positive, so we don't have to worry about division by zero
-		targettime = gp_cl->time - ((int)( gp_cl->time / fullinterval )) * fullinterval;
-
-		for( i = 0; i < ( numframes - 1 ); i++ )
-		{
-			if( pintervals[i] > targettime )
-				break;
-		}
-		pspriteframe = pspritegroup->frames[i];
-	}
-	else if( psprite->frames[frame].type == FRAME_ANGLED )
-	{
-		int angleframe = (int)( Q_rint(( RI.viewangles[1] - yaw + 45.0f ) / 360 * 8 ) - 4 ) & 7;
-
-		// e.g. doom-style sprite monsters
-		pspritegroup = (mspritegroup_t *)psprite->frames[frame].frameptr;
-		pspriteframe = pspritegroup->frames[angleframe];
-	}
-
-	return pspriteframe;
-}
-
 /*
 ================
 R_CullSpriteModel
@@ -371,16 +62,15 @@ Set sprite brightness factor
 */
 static float R_SpriteGlowBlend( vec3_t origin, int rendermode, int renderfx, float *pscale )
 {
-	float     dist, brightness;
-	vec3_t    glowDist;
-	pmtrace_t *tr;
+	float  dist, brightness;
+	vec3_t glowDist;
 
 	VectorSubtract( origin, RI.vieworg, glowDist );
 	dist = VectorLength( glowDist );
 
 	if( RP_NORMALPASS( ))
 	{
-		tr = gEngfuncs.EV_VisTraceLine( RI.vieworg, origin, r_traceglow.value ? PM_GLASS_IGNORE : ( PM_GLASS_IGNORE | PM_STUDIO_IGNORE ));
+		pmtrace_t *tr = gEngfuncs.EV_VisTraceLine( RI.vieworg, origin, r_traceglow.value ? PM_GLASS_IGNORE : ( PM_GLASS_IGNORE | PM_STUDIO_IGNORE ));
 
 		if(( 1.0f - tr->fraction ) * dist > 8.0f )
 			return 0.0f;
@@ -536,7 +226,7 @@ void R_DrawSpriteModel( cl_entity_t *e )
 		color[2] = 1.0f;
 	}
 
-	frame = R_GetSpriteFrame( model, e->curstate.frame, e->angles[YAW] );
+	frame = gEngfuncs.R_GetSpriteFrame( model, e->curstate.frame, e->angles[YAW] );
 
 	type = psprite->type;
 

ref/soft/r_studio.c

@@ -1467,7 +1467,7 @@ static void R_StudioDynamicLight( cl_entity_t *ent, alight_t *plight )
 
 	for( lnum = 0; lnum < MAX_DLIGHTS; lnum++ )
 	{
-		dl = &tr.dlights[lnum];
+		dl = &gp_dlights[lnum];
 
 		if( dl->die < g_studio.time || !r_dynamic->value )
 			continue;

ref/soft/r_surf.c

@@ -53,7 +53,7 @@ static void     (*surfmiptable[4])( void ) = {
 };
 
 // void R_BuildLightMap (void);
-extern unsigned blocklights[10240]; // allow some very large lightmaps
+static unsigned blocklights[10240]; // allow some very large lightmaps
 
 static float           surfscale;
 static qboolean        r_cache_thrash;         // set if surface cache is thrashing
@@ -62,7 +62,6 @@ static int sc_size;
 surfcache_t     *sc_rover;
 static surfcache_t *sc_base;
 
-static int      rtable[MOD_FRAMES][MOD_FRAMES];
 
 static void R_BuildLightMap( void );
 /*
@@ -108,7 +107,7 @@ static void R_AddDynamicLights( const msurface_t *surf )
 		if( !FBitSet( surf->dlightbits, BIT( lnum )))
 			continue; // not lit by this light
 
-		dl = &tr.dlights[lnum];
+		dl = &gp_dlights[lnum];
 
 		// transform light origin to local bmodel space
 		if( !tr.modelviewIdentity )
@@ -209,7 +208,7 @@ static void R_BuildLightMap( void )
 		if( surf->styles[map] >= 255 )
 			break;
 
-		scale = tr.lightstylevalue[surf->styles[map]];
+		scale = g_lightstylevalue[surf->styles[map]];
 
 		for( i = 0; i < size; i++ )
 			blocklights[i] += ( lm[i].r + lm[i].g + lm[i].b ) * scale;
@@ -238,20 +237,6 @@ static void R_BuildLightMap( void )
 	}
 }
 
-void GL_InitRandomTable( void )
-{
-	int tu, tv;
-
-	for( tu = 0; tu < MOD_FRAMES; tu++ )
-	{
-		for( tv = 0; tv < MOD_FRAMES; tv++ )
-		{
-			rtable[tu][tv] = gEngfuncs.COM_RandomLong( 0, 0x7FFF );
-		}
-	}
-
-	gEngfuncs.COM_SetRandomSeed( 0 );
-}
 
 /*
 ===============
@@ -1118,7 +1103,7 @@ surfcache_t *D_CacheSurface( msurface_t *surface, int miplevel )
 	// check for lightmap modification
 	for( maps = 0; maps < MAXLIGHTMAPS && surface->styles[maps] != 255; maps++ )
 	{
-		if( tr.lightstylevalue[surface->styles[maps]] != surface->cached_light[maps] )
+		if( g_lightstylevalue[surface->styles[maps]] != surface->cached_light[maps] )
 		{
 			surface->dlightframe = tr.framecount;
 		}
@@ -1188,10 +1173,7 @@ surfcache_t *D_CacheSurface( msurface_t *surface, int miplevel )
 	cache->lightadj[1] = r_drawsurf.lightadj[1];
 	cache->lightadj[2] = r_drawsurf.lightadj[2];
 	cache->lightadj[3] = r_drawsurf.lightadj[3];
-	for( maps = 0; maps < MAXLIGHTMAPS && surface->styles[maps] != 255; maps++ )
-	{
-		surface->cached_light[maps] = tr.lightstylevalue[surface->styles[maps]];
-	}
+	R_UpdateSurfaceCachedLight( surface );
 //
 // draw and light the surface texture
 //

ref/soft/r_triapi.c

@@ -286,7 +286,10 @@ int TriSpriteTexture( model_t *pSpriteModel, int frame )
 {
 	int gl_texturenum;
 
-	if(( gl_texturenum = R_GetSpriteTexture( pSpriteModel, frame )) == 0 )
+	if( !pSpriteModel || pSpriteModel->type != mod_sprite || !pSpriteModel->cache.data )
+		return 0;
+
+	if(( gl_texturenum = gEngfuncs.R_GetSpriteFrame( pSpriteModel, frame, 0.0f )->gl_texturenum ) == 0 )
 		return 0;
 
 	if( gl_texturenum <= 0 || gl_texturenum >= MAX_TEXTURES )

ref/soft/wscript

@@ -14,7 +14,7 @@ def configure(conf):
 	return
 
 def build(bld):
-	libs = [ 'engine_includes', 'werror' ]
+	libs = [ 'ref_common', 'engine_includes', 'werror' ]
 	# on PSVita do not link any libraries that are already in the main executable, but add the includes target
 	if bld.env.DEST_OS == 'psvita':
 		libs += [ 'sdk_includes' ]

wscript

@@ -91,6 +91,7 @@ SUBDIRS = [
 	Subproject('3rdparty/nanogl',       lambda x: x.env.CLIENT and x.env.NANOGL),
 	Subproject('3rdparty/gl-wes-v2',    lambda x: x.env.CLIENT and x.env.GLWES),
 	Subproject('3rdparty/gl4es',        lambda x: x.env.CLIENT and x.env.GL4ES),
+	Subproject('ref/common',            lambda x: x.env.CLIENT),
 	Subproject('ref/gl',                lambda x: x.env.CLIENT and (x.env.GL or x.env.NANOGL or x.env.GLWES or x.env.GL4ES or x.env.GLES3COMPAT)),
 	Subproject('ref/soft',              lambda x: x.env.CLIENT and x.env.SOFT),
 	Subproject('ref/null',              lambda x: x.env.CLIENT and x.env.NULL),