FWGS
/
Xash3DArchive
Archived
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

07 Jun 2010

This commit is contained in:
g-cont 2010-06-07 00:00:00 +04:00 committed by Alibek Omarov
parent b4010e9519
commit e31162d22e
40 changed files with 2122 additions and 1048 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
bshift/client.cpp
View File

@ -840,6 +840,11 @@ int AutoClassify( edict_t *pentToClassify )
return ED_WORLDSPAWN;
}
if ( !strnicmp( "bodyque", classname, 7 ))
{
return ED_NORMAL;
}
// first pass: determine type by explicit parms
if ( pClass->pev->solid == SOLID_TRIGGER )
{
@ -854,7 +859,7 @@ int AutoClassify( edict_t *pentToClassify )
}
else if ( pClass->pev->movetype == MOVETYPE_PHYSIC )
return ED_RIGIDBODY;
else if ( pClass->pev->solid == SOLID_BSP || pClass->pev->origin == g_vecZero )
else if ( pClass->pev->solid == SOLID_BSP )
{
if ( pClass->pev->movetype == MOVETYPE_CONVEYOR )
return ED_MOVER;

2
client/global/ev_common.cpp
View File

@ -183,7 +183,7 @@ void EV_UpadteFlashlight( edict_t *pEnt )
AngleVectors( pEnt->v.viewangles, forward, NULL, NULL );
vecSrc = pEnt->v.origin +pEnt->v.view_ofs;
vecEnd = vecSrc + forward * 256;
vecEnd = vecSrc + forward * 512;
UTIL_TraceLine( vecSrc, vecEnd, dont_ignore_monsters, pEnt, &tr );

2
cms_hl/cm_local.h
View File

@ -26,6 +26,8 @@ extern stdlib_api_t com;
#define DVIS_PVS 0
#define DVIS_PHS 1
extern cvar_t *cm_novis;
typedef struct
{
char name[64];

5
cms_hl/cm_main.c
View File

@ -8,6 +8,9 @@
physic_imp_t pi;
stdlib_api_t com;
// cvars
cvar_t *cm_novis;
// main DLL entry point
BOOL WINAPI DllMain( HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved )
{
@ -16,6 +19,8 @@ BOOL WINAPI DllMain( HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved )
bool CM_InitPhysics( void )
{
cm_novis = Cvar_Get( "cm_novis", "0", 0, "force to ignore server visibility" );
Mem_Set( cm.nullrow, 0xFF, MAX_MAP_LEAFS / 8 );
return true;
}

10
cms_hl/cm_portals.c
View File

@ -179,7 +179,7 @@ CM_LeafPVS
*/
byte *CM_LeafPVS( int leafnum )
{
if( !worldmodel || leafnum <= 0 || leafnum >= worldmodel->numleafs || !cm.pvs )
if( !worldmodel || leafnum <= 0 || leafnum >= worldmodel->numleafs || !cm.pvs || cm_novis->integer )
return cm.nullrow;
return worldmodel->leafs[leafnum+1].visdata;
@ -192,7 +192,7 @@ CM_LeafPHS
*/
byte *CM_LeafPHS( int leafnum )
{
if( !worldmodel || leafnum <= 0 || leafnum >= worldmodel->numleafs || !cm.phs )
if( !worldmodel || leafnum <= 0 || leafnum >= worldmodel->numleafs || !cm.phs || cm_novis->integer )
return cm.nullrow;
return worldmodel->leafs[leafnum+1].pasdata;
@ -261,7 +261,8 @@ so we can't use a single PVS point
*/
byte *CM_FatPVS( const vec3_t org, bool portal )
{
if( !cm.pvs ) return cm.nullrow;
if( !cm.pvs || cm_novis->integer )
return cm.nullrow;
bitvector = fatpvs;
fatbytes = (worldmodel->numleafs+31)>>3;
@ -281,7 +282,8 @@ so we can't use a single PHS point
*/
byte *CM_FatPHS( const vec3_t org, bool portal )
{
if( !cm.pvs ) return cm.nullrow;
if( !cm.pvs || cm_novis->integer )
return cm.nullrow;
bitvector = fatphs;
fatbytes = (worldmodel->numleafs+31)>>3;

4
common/const.h
View File

@ -10,6 +10,10 @@
#define YAW 1
#define ROLL 2
// worldcraft predefined angles
#define ANGLE_UP -1
#define ANGLE_DOWN -2
// sound specific
#define VOL_NORM 1.0f // volume values

2
engine/client/cl_demo.c
View File

@ -522,7 +522,7 @@ void CL_PlayDemo_f( void )
CL_Disconnect();
Host_ShutdownServer();
com.snprintf( filename, MAX_STRING, "$demos/%s.dem", Cmd_Argv( 1 ));
com.snprintf( filename, MAX_STRING, "†demos/%s.dem", Cmd_Argv( 1 ));
if(!FS_FileExists( filename ))
{
MsgDev( D_ERROR, "couldn't open %s\n", filename );

49
engine/client/cl_effects.c
View File

@ -24,7 +24,7 @@ typedef struct
clightstyle_t cl_lightstyle[MAX_LIGHTSTYLES];
static int lastofs;
/*
================
CL_ClearLightStyles
@ -39,26 +39,53 @@ void CL_ClearLightStyles( void )
/*
================
CL_RunLightStyles
light animations
'm' is normal light, 'a' is no light, 'z' is double bright
================
*/
void CL_RunLightStyles( void )
{
int i, ofs;
clightstyle_t *ls;
ofs = cl.time / 100;
if( ofs == lastofs ) return;
lastofs = ofs;
float l, oldval, curval;
clightstyle_t *ls;
if( cls.state != ca_active ) return;
if( cl_lightstyle_lerping->integer )
{
ofs = cl.frame.servertime / 100;
}
else
{
ofs = cl.time / 100;
if( ofs == lastofs ) return;
lastofs = ofs;
}
for( i = 0, ls = cl_lightstyle; i < MAX_LIGHTSTYLES; i++, ls++ )
{
if( !ls->length )
if( ls->length == 0 ) l = 0.0f;
else if( ls->length == 1 ) l = ls->map[0];
else if( cl_lightstyle_lerping->integer )
{
VectorSet( ls->value, 1.0f, 1.0f, 1.0f );
continue;
int curnum = (ofs % ls->length);
int oldnum = curnum - 1;
// sequence is ends ?
if( oldnum < 0 )
oldnum += ls->length;
oldval = ls->map[oldnum];
curval = ls->map[curnum];
// don't lerping fast sequences
if( fabs( curval - oldval ) >= 1.0f ) l = curval;
else l = oldval + cl.lerpFrac * (curval - oldval);
}
if( ls->length == 1 ) ls->value[0] = ls->value[1] = ls->value[2] = ls->map[0];
else ls->value[0] = ls->value[1] = ls->value[2] = ls->map[ofs%ls->length];
else l = ls->map[ofs%ls->length];
VectorSet( ls->value, l, l, l );
}
}

5
engine/client/cl_main.c
View File

@ -18,7 +18,7 @@ cvar_t *cl_nodelta;
cvar_t *cl_crosshair;
cvar_t *cl_shownet;
cvar_t *cl_showmiss;
cvar_t *cl_mouselook;
cvar_t *cl_lightstyle_lerping;
cvar_t *userinfo;
//
@ -1032,7 +1032,8 @@ void CL_InitLocal( void )
userinfo = Cvar_Get( "@userinfo", "0", CVAR_READ_ONLY, "" ); // use ->modified value only
cl_showfps = Cvar_Get( "cl_showfps", "1", CVAR_ARCHIVE, "show client fps" );
cl_lw = Cvar_Get( "cl_lw", "1", CVAR_ARCHIVE|CVAR_USERINFO, "enable client weapon predicting" );
cl_lightstyle_lerping = Cvar_Get( "cl_lightstyle_lerping", "0", CVAR_ARCHIVE, "enables animated light lerping (perfomance option)" );
// register our commands
Cmd_AddCommand ("cmd", CL_ForwardToServer_f, "send a console commandline to the server" );
Cmd_AddCommand ("pause", NULL, "pause the game (if the server allows pausing)" );

1
engine/client/client.h
View File

@ -364,6 +364,7 @@ extern cvar_t *cl_testentities;
extern cvar_t *cl_testlights;
extern cvar_t *cl_testflashlight;
extern cvar_t *cl_levelshot_name;
extern cvar_t *cl_lightstyle_lerping;
extern cvar_t *scr_centertime;
extern cvar_t *scr_download;
extern cvar_t *scr_loading;

4
engine/common/con_utils.c
View File

@ -203,7 +203,7 @@ bool Cmd_GetDemoList( const char *s, char *completedname, int length )
string matchbuf;
int i, numdems;
t = FS_Search( va( "$demos/%s*.dem", s ), true );
t = FS_Search( va( "†demos/%s*.dem", s ), true );
if( !t ) return false;
FS_FileBase( t->filenames[0], matchbuf );
@ -337,7 +337,7 @@ bool Cmd_GetSavesList( const char *s, char *completedname, int length )
string matchbuf;
int i, numsaves;
t = FS_Search( va( "$save/%s*.sav", s ), true );
t = FS_Search( va( "†save/%s*.sav", s ), true );
if( !t ) return false;
FS_FileBase( t->filenames[0], matchbuf );

12
engine/server/sv_save.c
View File

@ -375,7 +375,7 @@ void SV_ClearSaveDir( void )
int i;
// just delete all HL? files
t = FS_Search( "$save/*.HL?", true );
t = FS_Search( "†save/*.HL?", true );
if( !t ) return; // already empty
for( i = 0; i < t->numfilenames; i++ )
@ -642,7 +642,7 @@ SAVERESTOREDATA *SV_LoadSaveData( const char *level )
char *pszTokenList;
int i, id, size, version;
com.snprintf( name, sizeof( name ), "$save/%s.HL1", level );
com.snprintf( name, sizeof( name ), "†save/%s.HL1", level );
MsgDev( D_INFO, "Loading game from %s...\n", name + 1 );
pFile = FS_Open( name, "rb" );
@ -814,7 +814,7 @@ void SV_EntityPatchRead( SAVERESTOREDATA *pSaveData, const char *level )
file_t *pFile;
int i, size, entityId;
com.snprintf( name, sizeof( name ), "$save/%s.HL3", level );
com.snprintf( name, sizeof( name ), "†save/%s.HL3", level );
pFile = FS_Open( name, "rb" );
if( !pFile ) return;
@ -1305,7 +1305,7 @@ int SV_SaveGameSlot( const char *pSaveName, const char *pSaveComment )
pSaveData = SV_SaveInit( 0 );
com.strncpy( hlPath, "$save/*.HL?", sizeof( hlPath ));
com.strncpy( hlPath, "†save/*.HL?", sizeof( hlPath ));
gameHeader.mapCount = SV_MapCount( hlPath );
com.strncpy( gameHeader.mapName, sv.name, sizeof( gameHeader.mapName ));
com.strncpy( gameHeader.comment, pSaveComment, sizeof( gameHeader.comment ));
@ -1445,7 +1445,7 @@ bool SV_LoadGame( const char *pName )
if( !pName || !pName[0] )
return false;
com.snprintf( name, sizeof( name ), "$save/%s.sav", pName );
com.snprintf( name, sizeof( name ), "†save/%s.sav", pName );
MsgDev( D_INFO, "Loading game from %s...\n", name + 1 );
SV_ClearSaveDir();
@ -1557,7 +1557,7 @@ used for reload game after player death
*/
const char *SV_GetLatestSave( void )
{
search_t *f = FS_Search( "$save/*.sav", true );
search_t *f = FS_Search( "†save/*.sav", true );
int i, found = 0;
long newest = 0, ft;
string savename;

2
engine/uimenu/ui_loadgame.c
View File

@ -131,7 +131,7 @@ static void UI_LoadGame_GetGameList( void )
search_t *t;
int i;
t = FS_Search( "$save/*.sav", true );
t = FS_Search( "†save/*.sav", true );
for( i = 0; t && i < t->numfilenames; i++ )
{

56
engine/uimenu/ui_main.c
View File

@ -72,6 +72,8 @@ typedef struct
// quit dialog
menuAction_s msgBox;
menuAction_s quitMessage;
menuAction_s dlgMessage1;
menuAction_s dlgMessage2;
menuAction_s yes;
menuAction_s no;
} uiMain_t;
@ -115,6 +117,32 @@ static void UI_QuitDialog( void )
}
static void UI_PromptDialog( void )
{
// toggle main menu between active\inactive
// show\hide quit dialog
uiMain.console.generic.flags ^= QMF_INACTIVE;
uiMain.resumeGame.generic.flags ^= QMF_INACTIVE;
uiMain.newGame.generic.flags ^= QMF_INACTIVE;
uiMain.hazardCourse.generic.flags ^= QMF_INACTIVE;
uiMain.saveRestore.generic.flags ^= QMF_INACTIVE;
uiMain.playRecord.generic.flags ^= QMF_INACTIVE;
uiMain.configuration.generic.flags ^= QMF_INACTIVE;
uiMain.multiPlayer.generic.flags ^= QMF_INACTIVE;
uiMain.customGame.generic.flags ^= QMF_INACTIVE;
uiMain.credits.generic.flags ^= QMF_INACTIVE;
uiMain.quit.generic.flags ^= QMF_INACTIVE;
uiMain.minimizeBtn.generic.flags ^= QMF_INACTIVE;
uiMain.quitButton.generic.flags ^= QMF_INACTIVE;
uiMain.msgBox.generic.flags ^= QMF_HIDDEN;
uiMain.dlgMessage1.generic.flags ^= QMF_HIDDEN;
uiMain.dlgMessage2.generic.flags ^= QMF_HIDDEN;
uiMain.no.generic.flags ^= QMF_HIDDEN;
uiMain.yes.generic.flags ^= QMF_HIDDEN;
}
/*
=================
UI_Main_KeyFunc
@ -204,7 +232,9 @@ static void UI_Main_Callback( void *self, int event )
UI_NewGame_Menu();
break;
case ID_HAZARDCOURSE:
UI_Main_HazardCourse();
if( cls.state == ca_active )
UI_PromptDialog();
else UI_Main_HazardCourse();
break;
case ID_MULTIPLAYER:
UI_MultiPlayer_Menu();
@ -236,10 +266,14 @@ static void UI_Main_Callback( void *self, int event )
Cbuf_ExecuteText( EXEC_APPEND, "minimize\n" );
break;
case ID_YES:
Cbuf_ExecuteText( EXEC_APPEND, "quit\n" );
if( !( uiMain.quitMessage.generic.flags & QMF_HIDDEN ))
Cbuf_ExecuteText( EXEC_APPEND, "quit\n" );
else UI_Main_HazardCourse();
break;
case ID_NO:
UI_QuitDialog();
if( !( uiMain.quitMessage.generic.flags & QMF_HIDDEN ))
UI_QuitDialog();
else UI_PromptDialog();
break;
}
}
@ -453,6 +487,20 @@ static void UI_Main_Init( void )
uiMain.quitMessage.generic.x = 248;
uiMain.quitMessage.generic.y = 280;
uiMain.dlgMessage1.generic.id = ID_MSGTEXT;
uiMain.dlgMessage1.generic.type = QMTYPE_ACTION;
uiMain.dlgMessage1.generic.flags = QMF_INACTIVE|QMF_HIDDEN;
uiMain.dlgMessage1.generic.name = "Starting a Hazard Course will exit";
uiMain.dlgMessage1.generic.x = 212;
uiMain.dlgMessage1.generic.y = 280;
uiMain.dlgMessage2.generic.id = ID_MSGTEXT;
uiMain.dlgMessage2.generic.type = QMTYPE_ACTION;
uiMain.dlgMessage2.generic.flags = QMF_INACTIVE|QMF_HIDDEN;
uiMain.dlgMessage2.generic.name = "any current game, OK to exit?";
uiMain.dlgMessage2.generic.x = 256;
uiMain.dlgMessage2.generic.y = 310;
uiMain.yes.generic.id = ID_YES;
uiMain.yes.generic.type = QMTYPE_ACTION;
uiMain.yes.generic.flags = QMF_HIGHLIGHTIFFOCUS|QMF_DROPSHADOW|QMF_HIDDEN;
@ -485,6 +533,8 @@ static void UI_Main_Init( void )
UI_AddItem( &uiMain.menu, (void *)&uiMain.quitButton );
UI_AddItem( &uiMain.menu, (void *)&uiMain.msgBox );
UI_AddItem( &uiMain.menu, (void *)&uiMain.quitMessage );
UI_AddItem( &uiMain.menu, (void *)&uiMain.dlgMessage1 );
UI_AddItem( &uiMain.menu, (void *)&uiMain.dlgMessage2 );
UI_AddItem( &uiMain.menu, (void *)&uiMain.no );
UI_AddItem( &uiMain.menu, (void *)&uiMain.yes );
}

2
engine/uimenu/ui_playdemo.c
View File

@ -131,7 +131,7 @@ static void UI_PlayDemo_GetDemoList( void )
search_t *t;
int i;
t = FS_Search( "$demos/*.dem", true );
t = FS_Search( "†demos/*.dem", true );
for( i = 0; t && i < t->numfilenames; i++ )
{

2
engine/uimenu/ui_recdemo.c
View File

@ -131,7 +131,7 @@ static void UI_RecDemo_GetDemoList( void )
search_t *t;
int i = 0, j;
t = FS_Search( "$demos/*.dem", true );
t = FS_Search( "†demos/*.dem", true );
if( cls.state == ca_active && !cls.demorecording && !cls.demoplayback )
{

2
engine/uimenu/ui_savegame.c
View File

@ -131,7 +131,7 @@ static void UI_SaveGame_GetGameList( void )
search_t *t;
int i = 0, j;
t = FS_Search( "$save/*.sav", true );
t = FS_Search( "†save/*.sav", true );
if( cls.state == ca_active )
{

6
launch/filesystem.c
View File

@ -2154,7 +2154,7 @@ file_t *FS_OpenReadFile( const char *filename, const char *mode, bool quiet )
bool gamedironly = false;
int pack_ind;
if( filename[0] == '$' )
if( filename[0] == '†' )
{
filename++;
gamedironly = true;
@ -2812,7 +2812,7 @@ bool FS_FileExists( const char *filename )
{
bool gamedironly = false;
if( filename[0] == '$' )
if( filename[0] == '†' )
{
filename++;
gamedironly = true;
@ -3013,7 +3013,7 @@ static search_t *_FS_Search( const char *pattern, int caseinsensitive, int quiet
return NULL;
}
if( pattern[0] == '$' )
if( pattern[0] == '†' )
{
gamedironly = true;
pattern++; // ignore this symbol

10
launch/imagelib/imagelib.h
View File

@ -479,6 +479,15 @@ enum
LUMP_EXTENDED // bmp images have extened palette with alpha-channel
};
enum
{
PAL_INVALID = -1,
PAL_CUSTOM = 0,
PAL_DOOM1,
PAL_QUAKE1,
PAL_QUAKE2,
};
extern imglib_t image;
extern cvar_t *fs_wadsupport;
extern cvar_t *png_compression;
@ -501,6 +510,7 @@ void Image_DecompressDDS( const byte *buffer, uint target );
void Image_GetPaletteLMP( const byte *pal, int rendermode );
void Image_GetPalettePCX( const byte *pal );
void Image_GetPaletteBMP( const byte *pal );
int Image_ComparePalette( const byte *pal );
void Image_CopyPalette24bit( void );
void Image_CopyPalette32bit( void );
bool Image_ForceDecompress( void );

6
launch/imagelib/img_main.c
View File

@ -451,10 +451,10 @@ bool FS_SaveImage( const char *filename, rgbdata_t *pix )
const suffix_t *box;
int i;
if( pix->flags & IMAGE_CUBEMAP )
box = cubemap_v2;
else if( pix->flags & IMAGE_SKYBOX )
if( pix->flags & IMAGE_SKYBOX )
box = skybox_qv1;
else if( pix->flags & IMAGE_CUBEMAP )
box = cubemap_v2;
else return false; // do not happens
pix->size /= 6; // now set as side size

18
launch/imagelib/img_utils.c
View File

@ -449,6 +449,24 @@ bool Image_LumpValidSize( const char *name )
return true;
}
/*
=============
Image_ComparePalette
=============
*/
int Image_ComparePalette( const byte *pal )
{
if( pal == NULL )
return PAL_INVALID;
else if( !memcmp( palette_d1, pal, 768 ))
return PAL_DOOM1;
else if( !memcmp( palette_q1, pal, 768 ))
return PAL_QUAKE1;
else if( !memcmp( palette_q2, pal, 768 ))
return PAL_QUAKE2;
return PAL_CUSTOM;
}
void Image_SetPalette( const byte *pal, uint *d_table )
{
int i;

37
launch/imagelib/img_wad.c
View File

@ -527,7 +527,42 @@ bool Image_LoadMIP( const char *name, const byte *buffer, size_t filesize )
}
image.flags |= IMAGE_HAS_ALPHA;
}
else rendermode = LUMP_NORMAL;
else
{
int pal_type;
// NOTE: we can have luma-pixels if quake1/2 texture
// converted into the hl texture but palette leave unchanged
// this is a good reason for using fullbright pixels
pal_type = Image_ComparePalette( pal );
// check for luma pixels
switch( pal_type )
{
case PAL_QUAKE1:
for( i = 0; i < image.width * image.height; i++ )
{
if( fin[i] > 224 )
{
image.flags |= IMAGE_HAS_LUMA_Q1;
break;
}
}
break;
case PAL_QUAKE2:
for( i = 0; i < image.width * image.height; i++ )
{
if( fin[i] > 208 && fin[i] < 240 )
{
image.flags |= IMAGE_HAS_LUMA_Q2;
break;
}
}
break;
}
rendermode = LUMP_NORMAL;
}
}
else if( image.hint != IL_HINT_HL && filesize >= (int)sizeof(mip) + ((pixels * 85)>>6))
{

7
server/global/client.cpp
View File

@ -1030,6 +1030,11 @@ int AutoClassify( edict_t *pentToClassify )
return ED_WORLDSPAWN;
}
if ( !strnicmp( "bodyque", classname, 7 ))
{
return ED_NORMAL;
}
// first pass: determine type by explicit parms
if ( pClass->pev->solid == SOLID_TRIGGER )
{
@ -1044,7 +1049,7 @@ int AutoClassify( edict_t *pentToClassify )
}
else if ( pClass->pev->movetype == MOVETYPE_PHYSIC )
return ED_RIGIDBODY;
else if ( pClass->pev->solid == SOLID_BSP || pClass->pev->origin == g_vecZero )
else if ( pClass->pev->solid == SOLID_BSP )
{
if ( pClass->pev->movetype == MOVETYPE_CONVEYOR )
return ED_MOVER;

7
spirit/client.cpp
View File

@ -998,6 +998,11 @@ int AutoClassify( edict_t *pentToClassify )
return ED_WORLDSPAWN;
}
if ( !strnicmp( "bodyque", classname, 7 ))
{
return ED_NORMAL;
}
// first pass: determine type by explicit parms
if ( pClass->pev->solid == SOLID_TRIGGER )
{
@ -1012,7 +1017,7 @@ int AutoClassify( edict_t *pentToClassify )
}
else if ( pClass->pev->movetype == MOVETYPE_PHYSIC )
return ED_RIGIDBODY;
else if ( pClass->pev->solid == SOLID_BSP || pClass->pev->origin == g_vecZero )
else if ( pClass->pev->solid == SOLID_BSP )
{
if ( pClass->pev->movetype == MOVETYPE_CONVEYOR )
return ED_MOVER;

314
vid_gl/r_backend.c
View File

@ -77,10 +77,11 @@ static vec4_t colorMagenta = { 1.0f, 0.0f, 1.0f, 1.0f };
static bool r_arraysLocked;
static bool r_normalsEnabled;
static bool r_triangleOutlines;
static ref_style_t r_currentLightStyle;
static ref_style_t *r_currentLightStyle;
static const meshbuffer_t *r_currentMeshBuffer;
static uint r_currentShadowBits;
static uint r_currentDlightBits;
static const ref_shader_t *r_currentShader;
static double r_currentShaderTime;
static int r_currentShaderState;
@ -88,11 +89,10 @@ static int r_currentShaderPassMask;
static const shadowGroup_t *r_currentCastGroup;
static const mfog_t *r_texFog, *r_colorFog;
static ref_stage_t r_fogPass;
static ref_stage_t r_dlightsPass, r_fogPass;
static float r_lightmapPassesArgs[MAX_TEXTURE_UNITS+1][3];
static ref_stage_t r_lightmapPasses[MAX_TEXTURE_UNITS+1];
static ref_stage_t r_GLSLpasses[4]; // dlights and base
static ref_stage_t r_GLSLpassOutline;
static ref_stage_t *r_accumPasses[MAX_TEXTURE_UNITS];
static int r_numAccumPasses;
@ -160,6 +160,11 @@ void R_BackendInit( void )
r_noiseperm[i] = Com_RandomLong( 0, 255 );
}
// init dynamic lights pass
Mem_Set( &r_dlightsPass, 0, sizeof( ref_stage_t ));
r_dlightsPass.flags = SHADERSTAGE_DLIGHT;
r_dlightsPass.glState = GLSTATE_DEPTHFUNC_EQ|GLSTATE_SRCBLEND_DST_COLOR|GLSTATE_DSTBLEND_ONE;
// init fog pass
Mem_Set( &r_fogPass, 0, sizeof( ref_stage_t ));
r_fogPass.tcgen = TCGEN_FOG;
@ -183,8 +188,8 @@ void R_BackendInit( void )
}
// init optional GLSL program passes
Mem_Set( r_GLSLpasses, 0, sizeof( r_GLSLpasses ));
r_GLSLpasses[0].flags = SHADERSTAGE_BLEND_ADD;
Mem_Set( r_GLSLpasses, 0, sizeof( r_GLSLpasses ) );
r_GLSLpasses[0].flags = SHADERSTAGE_DLIGHT|SHADERSTAGE_BLEND_ADD;
r_GLSLpasses[0].glState = GLSTATE_DEPTHFUNC_EQ|GLSTATE_SRCBLEND_ONE|GLSTATE_DSTBLEND_ONE;
r_GLSLpasses[1].flags = SHADERSTAGE_NOCOLORARRAY|SHADERSTAGE_BLEND_MODULATE;
@ -201,15 +206,6 @@ void R_BackendInit( void )
r_GLSLpasses[3].alphaGen.type = ALPHAGEN_IDENTITY;
r_GLSLpasses[3].program = DEFAULT_GLSL_SHADOWMAP_PROGRAM;
r_GLSLpasses[3].program_type = PROGRAM_TYPE_SHADOWMAP;
Mem_Set( &r_GLSLpassOutline, 0, sizeof( r_GLSLpassOutline ));
r_GLSLpassOutline.flags = SHADERSTAGE_NOCOLORARRAY|SHADERSTAGE_BLEND_MODULATE;
r_GLSLpassOutline.glState = GLSTATE_SRCBLEND_ONE|GLSTATE_DSTBLEND_ZERO|GLSTATE_DEPTHWRITE;
r_GLSLpassOutline.rgbGen.type = RGBGEN_OUTLINE;
r_GLSLpassOutline.alphaGen.type = ALPHAGEN_OUTLINE;
r_GLSLpassOutline.tcgen = TCGEN_NONE;
r_GLSLpassOutline.program = DEFAULT_GLSL_OUTLINE_PROGRAM;
r_GLSLpassOutline.program_type = PROGRAM_TYPE_OUTLINE;
}
/*
@ -281,6 +277,26 @@ void R_LatLongToNorm( const byte latlong[2], vec3_t out )
VectorSet( out, cos_b * sin_a, sin_b * sin_a, cos_a );
}
/*
==============
ColorToBytes
==============
*/
void ColorToBytes( const float *color, byte *colorBytes )
{
float max;
vec3_t sample;
VectorCopy( color, sample );
// clamp with color normalization
max = VectorMax( sample );
if( max > 255 )
VectorScale( sample, ( 255.0f / max ), sample );
VectorCopy( sample, colorBytes );
}
/*
==============
R_TableForFunc
@ -912,12 +928,6 @@ void R_DeformVertices( void )
}
}
break;
case DEFORM_OUTLINE:
// deflect vertex along its normal by outline amount
deflect = RI.currententity->outlineHeight * r_outlines_scale->value;
for( j = 0; j < r_backacc.numVerts; j++ )
VectorMA( inVertsArray[j], deflect, inNormalsArray[j], inVertsArray[j] );
break;
default: break;
}
}
@ -1054,10 +1064,10 @@ static bool R_VertexTCBase( const ref_stage_t *pass, int unit, matrix4x4 matrix
case TCGEN_REFLECTION_CELLSHADE:
if( RI.currententity && !( RI.params & RP_SHADOWMAPVIEW ) )
{
vec3_t dir, vpn, vright, vup;
matrix4x4 m;
vec3_t dir, vpn, vright, vup;
matrix4x4 m;
R_LightForOrigin( RI.currententity->lightingOrigin, dir, NULL, NULL, RI.currentmodel->radius * RI.currententity->scale );
R_LightDir( RI.currententity->lightingOrigin, dir, RI.currentmodel->radius * RI.currententity->scale );
// rotate direction
Matrix3x3_Transform( RI.currententity->axis, dir, vpn );
@ -1273,6 +1283,7 @@ static _inline texture_t *R_ShaderpassTex( const ref_stage_t *pass, int unit )
}
}
}
if( pass->flags & SHADERSTAGE_ANIMFREQUENCY && pass->animFrequency[0] && pass->num_textures )
{
int frame, numframes;
@ -1283,7 +1294,7 @@ static _inline texture_t *R_ShaderpassTex( const ref_stage_t *pass, int unit )
{
numframes = bound( 1, pass->num_textures - pass->anim_offset, MAX_STAGE_TEXTURES - 1 );
frame = (int)( pass->animFrequency[1] * r_currentShaderTime ) % numframes;
frame = bound( 0, frame + pass->anim_offset, pass->num_textures ); // bias
frame = bound( 0, frame + pass->anim_offset, pass->num_textures - 1 ); // bias
}
else
{
@ -1292,11 +1303,14 @@ static _inline texture_t *R_ShaderpassTex( const ref_stage_t *pass, int unit )
}
}
else frame = (int)( pass->animFrequency[0] * r_currentShaderTime ) % pass->num_textures;
Com_Assert( pass->textures[frame] == NULL );
return pass->textures[frame];
}
if( pass->flags & SHADERSTAGE_LIGHTMAP )
return tr.lightmapTextures[r_currentLightStyle.lightmapNum];
return tr.lightmapTextures[r_currentLightStyle->lightmapNum];
if( pass->flags & SHADERSTAGE_PORTALMAP )
return tr.portaltexture1;
return ( pass->textures[0] ? pass->textures[0] : tr.defaultTexture );
@ -1319,9 +1333,6 @@ static void R_ShaderpassRenderMode( ref_stage_t *pass )
if( RI.currentmodel && !glState.in2DMode && !triState.fActive )
mod_type = RI.currentmodel->type;
// completely ignore rendermodes for worldbrushes
if( mod_type == mod_world ) return;
switch( tr.iRenderMode )
{
case kRenderNormal:
@ -1580,12 +1591,6 @@ void R_ModifyColor( const ref_stage_t *pass )
for( i = 0, c = *(int *)rgba; i < r_backacc.numColors; i++, bArray += 4 )
*(int *)bArray = c;
break;
case RGBGEN_OUTLINE:
identityAlpha = ( RI.currententity->outlineColor[3] == 255 );
for( i = 0, c = *(int *)RI.currententity->outlineColor; i < r_backacc.numColors; i++, bArray += 4 )
*(int *)bArray = c;
break;
case RGBGEN_ONE_MINUS_ENTITY:
rgba[0] = 255 - RI.currententity->rendercolor[0];
rgba[1] = 255 - RI.currententity->rendercolor[1];
@ -1611,37 +1616,13 @@ void R_ModifyColor( const ref_stage_t *pass )
}
break;
case RGBGEN_LIGHTING_DIFFUSE:
if( RI.currententity ) R_LightForEntity( RI.currententity, bArray );
if( RI.currententity )
R_LightForEntity( RI.currententity, bArray );
break;
case RGBGEN_LIGHTING_DIFFUSE_ONLY:
if( RI.currententity && !( RI.params & RP_SHADOWMAPVIEW ) )
{
vec4_t diffuse;
vec3_t lightingOrigin;
if( RI.currententity )
VectorCopy( RI.currententity->lightingOrigin, lightingOrigin );
else if( triState.fActive )
VectorCopy( triState.lightingOrigin, lightingOrigin );
else VectorClear( lightingOrigin ); // FIXME: MB_POLY
if( RI.currententity->flags & EF_FULLBRIGHT || !r_worldbrushmodel->lightgrid )
VectorSet( diffuse, 1, 1, 1 );
else R_LightForOrigin( lightingOrigin, t, NULL, diffuse, RI.currentmodel->radius * RI.currententity->scale );
rgba[0] = R_FloatToByte( diffuse[0] );
rgba[1] = R_FloatToByte( diffuse[1] );
rgba[2] = R_FloatToByte( diffuse[2] );
for( i = 0, c = *(int *)rgba; i < r_backacc.numColors; i++, bArray += 4 )
*(int *)bArray = c;
}
break;
case RGBGEN_LIGHTING_AMBIENT_ONLY:
case RGBGEN_LIGHTING_AMBIENT:
if( RI.currententity && !( RI.params & RP_SHADOWMAPVIEW ))
{
vec4_t ambient;
vec3_t lightingOrigin;
vec3_t ambient, lightingOrigin;
if( RI.currententity )
VectorCopy( RI.currententity->lightingOrigin, lightingOrigin );
@ -1649,9 +1630,9 @@ void R_ModifyColor( const ref_stage_t *pass )
VectorCopy( triState.lightingOrigin, lightingOrigin );
else VectorClear( lightingOrigin ); // FIXME: MB_POLY
if( RI.currententity->flags & EF_FULLBRIGHT || !r_worldbrushmodel->lightgrid )
if( RI.currententity->flags & EF_FULLBRIGHT || !r_worldbrushmodel->lightdata )
VectorSet( ambient, 1.0f, 1.0f, 1.0f );
else R_LightForOrigin( lightingOrigin, t, ambient, NULL, RI.currentmodel->radius * RI.currententity->scale );
else R_LightForPoint( lightingOrigin, ambient );
rgba[0] = R_FloatToByte( ambient[0] );
rgba[1] = R_FloatToByte( ambient[1] );
@ -1741,10 +1722,6 @@ void R_ModifyColor( const ref_stage_t *pass )
for( i = 0; i < r_backacc.numColors; i++, bArray += 4 )
bArray[3] = rgba[3];
break;
case ALPHAGEN_OUTLINE:
for( i = 0; i < r_backacc.numColors; i++, bArray += 4 )
bArray[3] = RI.currententity->outlineColor[3];
break;
case ALPHAGEN_SPECULAR:
VectorSubtract( RI.viewOrigin, RI.currententity->origin, t );
if( !Matrix3x3_Compare( RI.currententity->axis, matrix3x3_identity ))
@ -2060,6 +2037,7 @@ static void R_RenderMeshGLSL_Material( void )
{
int i, tcgen;
int state;
bool breakIntoPasses = false;
int program, object;
int programFeatures = 0;
texture_t *base, *normalmap, *glossmap, *decalmap;
@ -2101,11 +2079,45 @@ static void R_RenderMeshGLSL_Material( void )
if( !( r_offsetmapping->integer & 1 ) )
offsetmappingScale = 0;
if( r_lightmap->integer )
if( r_lightmap->integer || ( r_currentDlightBits && !pass->textures[5] ))
{
if( !srcAlpha ) base = tr.whiteTexture; // white
else programFeatures |= PROGRAM_APPLY_BASETEX_ALPHA_ONLY;
}
// we use multipass for dynamic lights, so bind the white texture
// instead of base in GLSL program and add another modulative pass (diffusemap)
if( !r_lightmap->integer && ( r_currentDlightBits && !pass->textures[5] ))
{
breakIntoPasses = true;
r_GLSLpasses[1] = *pass;
r_GLSLpasses[1].flags = ( pass->flags & SHADERSTAGE_NOCOLORARRAY )|SHADERSTAGE_BLEND_MODULATE;
r_GLSLpasses[1].glState = GLSTATE_SRCBLEND_ZERO|GLSTATE_DSTBLEND_SRC_COLOR|((pass->glState & GLSTATE_ALPHAFUNC) ? GLSTATE_DEPTHFUNC_EQ : 0);
// decal
if( decalmap )
{
r_GLSLpasses[1].rgbGen.type = RGBGEN_IDENTITY;
r_GLSLpasses[1].alphaGen.type = ALPHAGEN_IDENTITY;
r_GLSLpasses[2] = *pass;
r_GLSLpasses[2].flags = ( pass->flags & SHADERSTAGE_NOCOLORARRAY )|SHADERSTAGE_BLEND_DECAL;
r_GLSLpasses[2].glState = GLSTATE_SRCBLEND_SRC_ALPHA|GLSTATE_DSTBLEND_ONE_MINUS_SRC_ALPHA|((pass->glState & GLSTATE_ALPHAFUNC) ? GLSTATE_DEPTHFUNC_EQ : 0);
r_GLSLpasses[2].textures[0] = decalmap;
}
if( offsetmappingScale <= 0 )
{
r_GLSLpasses[1].program = r_GLSLpasses[2].program = NULL;
r_GLSLpasses[1].program_type = r_GLSLpasses[2].program_type = PROGRAM_TYPE_NONE;
}
else
{
r_GLSLpasses[1].textures[2] = r_GLSLpasses[2].textures[2] = NULL; // no specular
r_GLSLpasses[1].textures[3] = r_GLSLpasses[2].textures[3] = NULL; // no decal
r_GLSLpasses[1].textures[6] = r_GLSLpasses[6].textures[2] = ((texture_t *)1); // HACKHACK no ambient
}
}
}
else if(( r_currentMeshBuffer->sortkey & 3 ) == MB_POLY )
{
@ -2126,8 +2138,16 @@ static void R_RenderMeshGLSL_Material( void )
pass->tcgen = TCGEN_BASE;
R_BindShaderpass( pass, base, 0 );
// calculate the fragment color
R_ModifyColor( pass );
if( !breakIntoPasses )
{
// calculate the fragment color
R_ModifyColor( pass );
}
else
{ // rgbgen identity (255,255,255,255)
r_backacc.numColors = 1;
colorArray[0][0] = colorArray[0][1] = colorArray[0][2] = colorArray[0][3] = 255;
}
// set shaderpass state (blending, depthwrite, etc)
state = r_currentShaderState | ( pass->glState & r_currentShaderPassMask ) | GLSTATE_BLEND_MTEX;
@ -2155,7 +2175,7 @@ static void R_RenderMeshGLSL_Material( void )
GL_SetTexCoordArrayMode( 0 );
}
if( decalmap )
if( decalmap && !breakIntoPasses )
{
programFeatures |= PROGRAM_APPLY_DECAL;
GL_Bind( 3, decalmap ); // decal
@ -2168,10 +2188,10 @@ static void R_RenderMeshGLSL_Material( void )
if( r_currentMeshBuffer->infokey > 0 )
{
// world surface
lightStyle = &r_currentLightStyle;
lightStyle = r_currentLightStyle;
// bind lightmap textures and set program's features for lightstyles
if( lightStyle->lightmapNum >= 0 )
if( lightStyle && lightStyle->lightmapNum >= 0 )
{
pass->tcgen = TCGEN_LIGHTMAP;
@ -2221,14 +2241,20 @@ static void R_RenderMeshGLSL_Material( void )
}
else
{
float radius = RI.currententity->model ? RI.currententity->model->radius * RI.currententity->scale : 0;
// get weighted incoming direction of world and dynamic lights
R_LightForOrigin( RI.currententity->lightingOrigin, temp, ambient, diffuse,
RI.currententity->model ? RI.currententity->model->radius * RI.currententity->scale : 0 );
R_LightForOrigin( RI.currententity->lightingOrigin, temp, ambient, diffuse, radius );
if( RI.currententity->flags & EF_MINLIGHT )
{
if( ambient[0] <= 0.1f || ambient[1] <= 0.1f || ambient[2] <= 0.1f )
VectorSet( ambient, 0.1f, 0.1f, 0.1f );
for( i = 0; i < 3; i++ )
{
if( ambient[i] > 0.01f )
break;
}
if( i == 3 ) VectorSet( ambient, 0.01f, 0.01f, 0.01f );
}
// rotate direction
@ -2246,12 +2272,38 @@ static void R_RenderMeshGLSL_Material( void )
pglUseProgramObjectARB( object );
// update uniforms
R_UpdateProgramUniforms( program, RI.viewOrigin, vec3_origin, lightDir, ambient, diffuse, true, 0, 0, 0, offsetmappingScale );
R_UpdateProgramUniforms( program, RI.viewOrigin, vec3_origin, lightDir, ambient, diffuse,
lightStyle, true, 0, 0, 0, offsetmappingScale );
R_FlushArrays();
pglUseProgramObjectARB( 0 );
}
if( breakIntoPasses )
{
uint oDB = r_currentDlightBits; // HACK HACK HACK
ref_style_t *oSL = r_currentLightStyle;
R_AccumulatePass( &r_GLSLpasses[0] ); // dynamic lighting pass
if( offsetmappingScale )
{
r_currentLightStyle = NULL;
r_currentDlightBits = 0;
}
R_AccumulatePass( &r_GLSLpasses[1] ); // modulate (diffusemap)
if( decalmap )
R_AccumulatePass( &r_GLSLpasses[2] ); // alpha-blended decal texture
if( offsetmappingScale )
{
r_currentLightStyle = oSL;
r_currentDlightBits = oDB;
}
}
}
/*
@ -2324,7 +2376,7 @@ static void R_RenderMeshGLSL_Distortion( void )
{
pglUseProgramObjectARB( object );
R_UpdateProgramUniforms( program, RI.viewOrigin, vec3_origin, vec3_origin, NULL, NULL,
R_UpdateProgramUniforms( program, RI.viewOrigin, vec3_origin, vec3_origin, NULL, NULL, NULL,
frontPlane, tr.portaltexture1->width, tr.portaltexture1->height, 0, 0 );
R_FlushArrays();
@ -2376,7 +2428,7 @@ static void R_RenderMeshGLSL_Shadowmap( void )
pglUseProgramObjectARB( object );
R_UpdateProgramUniforms( program, RI.viewOrigin, vec3_origin, vec3_origin, NULL, NULL, true,
R_UpdateProgramUniforms( program, RI.viewOrigin, vec3_origin, vec3_origin, NULL, NULL, NULL, true,
r_currentCastGroup->depthTexture->width, r_currentCastGroup->depthTexture->height,
r_currentCastGroup->projDist, 0 );
@ -2388,53 +2440,6 @@ static void R_RenderMeshGLSL_Shadowmap( void )
}
}
/*
================
R_RenderMeshGLSL_Outline
================
*/
static void R_RenderMeshGLSL_Outline( void )
{
int faceCull;
int state;
int program, object;
int programFeatures = GL_Support( R_GLSL_BRANCHING ) ? PROGRAM_APPLY_BRANCHING : 0;
ref_stage_t *pass = r_accumPasses[0];
if( RI.params & RP_CLIPPLANE )
programFeatures |= PROGRAM_APPLY_CLIPPING;
// update uniforms
program = R_RegisterGLSLProgram( pass->program, NULL, programFeatures );
object = R_GetProgramObject( program );
if( !object )
return;
faceCull = glState.faceCull;
GL_Cull( GL_BACK );
GL_SelectTexture( 0 );
GL_SetTexCoordArrayMode( 0 );
// calculate the fragment color
R_ModifyColor( pass );
// set shaderpass state (blending, depthwrite, etc)
state = r_currentShaderState | ( pass->glState & r_currentShaderPassMask ) | GLSTATE_BLEND_MTEX;
GL_SetState( state );
pglUseProgramObjectARB( object );
R_UpdateProgramUniforms( program, RI.viewOrigin, vec3_origin, vec3_origin, NULL, NULL, true,
0, 0, RI.currententity->outlineHeight * r_outlines_scale->value, 0 );
R_FlushArrays();
pglUseProgramObjectARB( 0 );
GL_Cull( faceCull );
}
/*
================
R_RenderMeshGLSLProgrammed
@ -2455,9 +2460,6 @@ static void R_RenderMeshGLSLProgrammed( void )
case PROGRAM_TYPE_SHADOWMAP:
R_RenderMeshGLSL_Shadowmap();
break;
case PROGRAM_TYPE_OUTLINE:
R_RenderMeshGLSL_Outline ();
break;
default:
MsgDev( D_WARN, "Unknown GLSL program type %i\n", pass->program_type );
break;
@ -2481,7 +2483,12 @@ static void R_RenderAccumulatedPasses( void )
R_RenderMeshGLSLProgrammed();
return;
}
if( pass->flags & SHADERSTAGE_DLIGHT )
{
r_numAccumPasses = 0;
R_AddDynamicLights( r_currentDlightBits, r_currentShaderState | ( pass->glState & r_currentShaderPassMask ));
return;
}
if( pass->flags & SHADERSTAGE_STENCILSHADOW )
{
r_numAccumPasses = 0;
@ -2515,7 +2522,7 @@ static void R_AccumulatePass( ref_stage_t *pass )
R_ShaderpassRenderMode( pass );
// see if there are any free texture units
renderNow = ( pass->flags & SHADERSTAGE_STENCILSHADOW ) || pass->program;
renderNow = ( pass->flags & ( SHADERSTAGE_DLIGHT|SHADERSTAGE_STENCILSHADOW )) || pass->program;
accumulate = ( r_numAccumPasses < glConfig.max_texture_units ) && !renderNow;
if( accumulate )
@ -2616,10 +2623,7 @@ R_NeedLightmapPass
bool R_NeedLightmapPass( msurface_t *surf )
{
// no valid lightmaps
if( r_currentLightStyle.lightmapNum < 0 || r_currentLightStyle.lightmapStyles[0] == 255 )
return false;
if( !( r_currentShader->flags & SHADER_HASLIGHTMAP ))
if( !r_currentLightStyle || r_currentLightStyle->lightmapNum < 0 || r_currentLightStyle->lightmapStyles[0] == 255 )
return false;
if( r_currentShader->flags & SHADER_RENDERMODE )
@ -2656,19 +2660,8 @@ void R_RenderMeshBuffer( const meshbuffer_t *mb )
Com_Assert( mb == NULL );
surf = mb->infokey > 0 ? &r_worldbrushmodel->surfaces[mb->infokey-1] : NULL;
if( surf )
{
r_currentLightStyle.lightmapNum = surf->lightmapTexnum;
for( i = 0; i < LM_STYLES; i++ )
r_currentLightStyle.lightmapStyles[i] = surf->styles[i];
}
else
{
r_currentLightStyle.lightmapNum = -1; // no valid lightmap
for( i = 0; i < LM_STYLES; i++ )
r_currentLightStyle.lightmapStyles[i] = LS_NONE;
}
if( surf ) r_currentLightStyle = &tr.superLightStyles[surf->superLightStyle];
else r_currentLightStyle = NULL;
r_currentMeshBuffer = mb;
MB_NUM2SHADER( mb->shaderkey, r_currentShader );
@ -2712,6 +2705,10 @@ void R_RenderMeshBuffer( const meshbuffer_t *mb )
// check if the fog volume is present but we can't use alpha texture
r_colorFog = ( fog && !r_texFog ) ? fog : NULL;
if( r_currentShader->type == SHADER_FLARE )
r_currentDlightBits = 0;
else r_currentDlightBits = surf ? mb->dlightbits : 0;
r_currentShadowBits = mb->shadowbits & RI.shadowBits;
R_LockArrays( r_backacc.numVerts );
@ -2743,9 +2740,9 @@ void R_RenderMeshBuffer( const meshbuffer_t *mb )
r_lightmapPasses[0].rgbGen.args = r_lightmapPassesArgs[0];
}
for( j = 0, l = 0, u = 0; j < LM_STYLES && r_currentLightStyle.lightmapStyles[j] != 255; j++ )
for( j = 0, l = 0, u = 0; j < LM_STYLES && r_currentLightStyle->lightmapStyles[j] != 255; j++ )
{
VectorCopy( r_lightStyles[r_currentLightStyle.lightmapStyles[j]].rgb, colorSum );
VectorCopy( r_lightStyles[r_currentLightStyle->lightmapStyles[j]].rgb, colorSum );
VectorClear( color );
for( ; ; l++ )
@ -2803,17 +2800,22 @@ void R_RenderMeshBuffer( const meshbuffer_t *mb )
continue;
if(( pass->flags & SHADERSTAGE_DETAIL ) && !r_detailtextures->integer )
continue;
if(( pass->flags & SHADERSTAGE_DLIGHT ) && !r_currentDlightBits )
continue;
}
R_AccumulatePass( pass );
}
// accumulate dynamic lights pass and fog pass if any
if( r_currentDlightBits && !( r_currentShader->flags & SHADER_NO_MODULATIVE_DLIGHTS ))
{
if( !r_lightmap->integer || !( r_currentShader->flags & SHADER_HASLIGHTMAP ))
R_AccumulatePass( &r_dlightsPass );
}
if( r_currentShadowBits && ( r_currentShader->sort >= SORT_OPAQUE ) && ( r_currentShader->sort <= SORT_ALPHATEST ))
R_AccumulatePass( &r_GLSLpasses[3] );
if( GL_Support( R_SHADER_GLSL100_EXT ) && RI.currententity && RI.currententity->outlineHeight && r_outlines_scale->value > 0
&& ( r_currentShader->sort == SORT_OPAQUE ) && ( r_currentShader->flags & SHADER_CULL_FRONT ) )
R_AccumulatePass( &r_GLSLpassOutline );
if( r_texFog && r_texFog->shader )
{
r_fogPass.textures[0] = tr.fogTexture;

86
vid_gl/r_image.c
View File

@ -2920,6 +2920,7 @@ static void R_UploadTexture( rgbdata_t *pic, texture_t *tex )
case PF_DXT5: tex->format = GL_COMPRESSED_RGBA_S3TC_DXT5_EXT; break;
default: dxtformat = false; break;
}
pglGenTextures( 1, &tex->texnum );
GL_Bind( GL_TEXTURE0, tex );
@ -3002,6 +3003,7 @@ texture_t *R_LoadTexture( const char *name, rgbdata_t *pic, int samples, texFlag
com.strncpy( texture->name, name, sizeof( texture->name ));
texture->srcWidth = pic->width;
texture->srcHeight = pic->height;
texture->srcFlags = pic->flags;
texture->depth = pic->depth;
texture->touchFrame = tr.registration_sequence;
if( samples <= 0 )
@ -3347,22 +3349,86 @@ R_InitDynamicLightTexture
*/
static rgbdata_t *R_InitDynamicLightTexture( int *flags, int *samples )
{
// NOTE: lightmap texture sizes must be smaller or equal data2D array size
// to avoid out of range
r_image.width = LIGHTMAP_TEXTURE_WIDTH;
r_image.height = LIGHTMAP_TEXTURE_HEIGHT;
vec3_t v = { 0, 0, 0 };
int x, y, z, size, size2, halfsize;
float intensity;
// dynamic light texture
if( GL_Support( R_TEXTURE_3D_EXT ))
{
r_image.depth = size = 32;
}
else
{
size = 128;
r_image.depth = 1;
}
r_image.width = r_image.height = size;
r_image.numMips = 1;
r_image.buffer = data2D;
r_image.flags = IMAGE_HAS_COLOR; // because we want colored dlights, right ?
r_image.flags = IMAGE_HAS_COLOR;
r_image.type = PF_RGBA_GN;
r_image.size = r_image.width * r_image.height * 4;
r_image.size = r_image.width * r_image.height * r_image.depth * 4;
*flags = TF_NOPICMIP|TF_NOMIPMAP|TF_CLAMP|TF_UNCOMPRESSED|TF_LIGHTMAP;
*samples = 4;
halfsize = size / 2;
intensity = halfsize * halfsize;
size2 = size * size;
// make white texture
Mem_Set( r_image.buffer, 0xff, r_image.size );
*flags = TF_NOPICMIP|TF_NOMIPMAP|TF_CLAMP|TF_UNCOMPRESSED;
*samples = 3;
if( GL_Support( R_TEXTURE_3D_EXT ))
{
for( x = 0; x < r_image.width; x++ )
{
for( y = 0; y < r_image.height; y++ )
{
for( z = 0; z < r_image.depth; z++ )
{
float dist, att;
v[0] = (float)x - halfsize;
v[1] = (float)y - halfsize;
v[2] = (float)z - halfsize;
dist = VectorLength( v );
if( dist > halfsize ) dist = halfsize;
if( x == 0 || y == 0 || z == 0 || x == size - 1 || y == size - 1 || z == size - 1 )
att = 0;
else att = (((dist * dist) / intensity) -1 ) * -255;
data2D[(x * size2 + y * size + z) * 4 + 0] = (byte)(att);
data2D[(x * size2 + y * size + z) * 4 + 1] = (byte)(att);
data2D[(x * size2 + y * size + z) * 4 + 2] = (byte)(att);
}
}
}
}
else
{
for( x = 0; x < size; x++ )
{
for( y = 0; y < size; y++ )
{
float result;
if( x == size - 1 || x == 0 || y == size - 1 || y == 0 )
result = 255;
else
{
float xf = ((float)x - 64 ) / 64.0f;
float yf = ((float)y - 64 ) / 64.0f;
result = ((xf * xf) + (yf * yf)) * 255;
if( result > 255 ) result = 255;
}
data2D[(x*size+y)*4+0] = (byte)255 - result;
data2D[(x*size+y)*4+1] = (byte)255 - result;
data2D[(x*size+y)*4+2] = (byte)255 - result;
}
}
}
return &r_image;
}

855
vid_gl/r_light.c
View File

File diff suppressed because it is too large Load Diff

36
vid_gl/r_local.h
View File

@ -93,6 +93,7 @@ typedef struct texture_s
string name; // game path, including extension
int srcWidth; // source dims, used for mipmap loading
int srcHeight;
int srcFlags; // rgbdata flags
int width; // upload width\height
int height;
@ -130,7 +131,6 @@ enum
#define LIGHTMAP_TEXTURE_WIDTH 256
#define LIGHTMAP_TEXTURE_HEIGHT 256
#define DLIGHT_TEXTURE (MAX_LIGHTMAPS-1)
#define VID_DEFAULTMODE "0"
@ -250,11 +250,6 @@ typedef struct ref_entity_s
// RT_SPRITE stuff
struct ref_shader_s *customShader; // client drawing stuff
float radius; // used as RT_SPRITE's radius
// outilne stuff
float outlineHeight;
rgba_t outlineColor;
} ref_entity_t;
typedef struct
@ -364,7 +359,6 @@ extern cvar_t *r_novis;
extern cvar_t *r_nocull;
extern cvar_t *r_ignorehwgamma;
extern cvar_t *r_overbrightbits;
extern cvar_t *r_mapoverbrightbits;
extern cvar_t *r_vertexbuffers;
extern cvar_t *r_lefthand;
extern cvar_t *r_physbdebug;
@ -426,9 +420,6 @@ extern cvar_t *r_bloom_intensity;
extern cvar_t *r_bloom_darken;
extern cvar_t *r_bloom_sample_size;
extern cvar_t *r_bloom_fast_sample;
extern cvar_t *r_outlines_world;
extern cvar_t *r_outlines_scale;
extern cvar_t *r_outlines_cutoff;
extern cvar_t *r_himodels;
extern cvar_t *r_environment_color;
@ -477,6 +468,7 @@ static _inline byte R_FloatToByte( float x )
float R_FastSin( float t );
void R_LatLongToNorm( const byte latlong[2], vec3_t out );
void NormToLatLong( const vec3_t normal, byte latlong[2] );
void ColorToBytes( const float *color, byte *colorBytes );
//====================================================================
@ -587,18 +579,16 @@ void R_BuildSurfaceLightmap( msurface_t *surf );
void R_EndBuildingLightmaps( void );
void R_UpdateSurfaceLightmap( msurface_t *surf );
void R_RecursiveLightNode( dlight_t *light, int bit, mnode_t *node );
void R_MarkLights( uint clipflags );
void R_LightBounds( const vec3_t origin, float intensity, vec3_t mins, vec3_t maxs );
bool R_SurfPotentiallyLit( msurface_t *surf );
uint R_AddSurfDlighbits( msurface_t *surf, uint dlightbits );
void R_AddDynamicLights( uint dlightbits, int state );
void R_LightForEntity( ref_entity_t *e, byte *bArray );
void R_LightForOrigin( const vec3_t origin, vec3_t dir, vec4_t ambient, vec4_t diffuse, float radius );
void R_LightForPoint( const vec3_t point, vec3_t ambientLight );
void R_LightDir( const vec3_t origin, vec3_t lightDir, float radius );
int R_AddSuperLightStyle( const int lightmapNum, const byte *lightmapStyles );
void R_SortSuperLightStyles( void );
void R_BuildLightGrid( mbrushmodel_t *world );
void R_InitCoronas( void );
void R_DrawCoronas( void );
@ -639,9 +629,6 @@ void R_InitCustomColors( void );
void R_SetCustomColor( int num, int r, int g, int b );
int R_GetCustomColor( int num );
void R_InitOutlines( void );
void R_AddModelMeshOutline( unsigned int modhandle, mfog_t *fog, int meshnum );
msurface_t *R_TraceLine( trace_t *tr, const vec3_t start, const vec3_t end );
//
@ -674,7 +661,6 @@ void R_BuildTangentVectors( int numVertexes, vec4_t *xyzArray, vec4_t *normalsA
#define DEFAULT_GLSL_PROGRAM "*r_defaultProgram"
#define DEFAULT_GLSL_DISTORTION_PROGRAM "*r_defaultDistortionProgram"
#define DEFAULT_GLSL_SHADOWMAP_PROGRAM "*r_defaultShadowmapProgram"
#define DEFAULT_GLSL_OUTLINE_PROGRAM "*r_defaultOutlineProgram"
enum
{
@ -682,7 +668,6 @@ enum
PROGRAM_TYPE_MATERIAL,
PROGRAM_TYPE_DISTORTION,
PROGRAM_TYPE_SHADOWMAP,
PROGRAM_TYPE_OUTLINE
};
enum
@ -716,7 +701,7 @@ int R_FindGLSLProgram( const char *name );
int R_RegisterGLSLProgram( const char *name, const char *string, unsigned int features );
int R_GetProgramObject( int elem );
void R_UpdateProgramUniforms( int elem, vec3_t eyeOrigin, vec3_t lightOrigin, vec3_t lightDir,
vec4_t ambient, vec4_t diffuse, bool frontPlane, int TexWidth, int TexHeight,
vec4_t ambient, vec4_t diffuse, ref_style_t *lightStyle, bool frontPlane, int TexWidth, int TexHeight,
float projDistance, float offsetmappingScale );
void R_ShutdownGLSLPrograms( void );
@ -855,14 +840,9 @@ enum
typedef struct
{
int pow2MapOvrbr;
float ambient[3];
rgba_t outlineColor;
rgba_t environmentColor;
bool lightmapsPacking;
bool deluxeMaps; // true if there are valid deluxemaps in the .bsp
bool deluxeMappingEnabled; // true if deluxeMaps is true and r_lighting_deluxemaps->integer != 0
} mapconfig_t;

37
vid_gl/r_main.c
View File

@ -302,20 +302,6 @@ void R_TransformEntityBBox( ref_entity_t *e, vec3_t mins, vec3_t maxs, vec3_t bb
}
}
/*
=============
R_LightForPoint
=============
*/
void R_LightForPoint( const vec3_t point, vec3_t ambientLight )
{
vec4_t ambient, diffuse;
vec3_t dir;
R_LightForOrigin( point, dir, ambient, diffuse, 256.0f );
VectorCopy( ambient, ambientLight );
}
/*
=============
R_LoadIdentity
@ -868,29 +854,6 @@ static void R_ApplySoftwareGamma( void )
}
//=============================================================================
static ref_shader_t *r_outlineShader;
/*
===============
R_InitOutlines
===============
*/
void R_InitOutlines( void )
{
r_outlineShader = R_LoadShader( "celloutline/default", SHADER_OUTLINE, false, 0, SHADER_INVALID );
}
/*
===============
R_AddModelMeshOutline
===============
*/
void R_AddModelMeshOutline( unsigned int modhandle, mfog_t *fog, int meshnum )
{
meshbuffer_t *mb = R_AddMeshToList( MB_MODEL, fog, r_outlineShader, -( meshnum+1 ) );
if( mb ) mb->modhandle = modhandle;
}
//=======================================================================
/*
===============
R_SetupFrustum

8
vid_gl/r_mesh.c
View File

@ -392,12 +392,6 @@ void R_AddModelMeshToList( uint modhandle, mfog_t *fog, ref_shader_t *shader, in
mb = R_AddMeshToList( MB_MODEL, fog, shader, -( meshnum+1 ) );
if( mb ) mb->modhandle = modhandle;
if( !GL_Support( R_SHADER_GLSL100_EXT ) && RI.currententity->outlineHeight/* && !(RI.params & RP_SHADOWMAPVIEW)*/ )
{
if(( shader->sort == SORT_OPAQUE ) && ( shader->flags & SHADER_CULL_FRONT ))
R_AddModelMeshOutline( modhandle, fog, meshnum );
}
}
/*
@ -452,8 +446,6 @@ static void R_BatchMeshBuffer( const meshbuffer_t *mb, const meshbuffer_t *nextm
features = shader->features;
if( r_shownormals->integer )
features |= MF_NORMALS;
if( ent->outlineHeight )
features |= (MF_NORMALS|MF_ENABLENORMALS);
if( features & MF_NONBATCHED )
{

1193
vid_gl/r_model.c
View File

File diff suppressed because it is too large Load Diff

12
vid_gl/r_model.h
View File

@ -109,12 +109,6 @@ typedef struct
};
// lighting info
int lightmapFrame;
int lightmapTexnum; // actual texnum
int dlightFrame;
int dlightBits;
int lmWidth;
int lmHeight;
int lmS;
@ -126,7 +120,6 @@ typedef struct
float cached[LM_STYLES]; // values currently used in lightmap
int superLightStyle;
int fragmentframe; // for multi-check avoidance
} msurface_t;
@ -207,12 +200,9 @@ typedef struct
msurface_t *surfaces;
msurface_t **marksurfaces;
int numlightgridelems;
int numgridpoints;
mgridlight_t *lightgrid;
int numlightarrayelems;
mgridlight_t **lightarray;
int numtexinfo;
mtexinfo_t *texinfo;

77
vid_gl/r_program.c
View File

@ -51,8 +51,6 @@ typedef struct
int locGlossIntensity;
int locGlossExponent;
int locOffsetMappingScale;
int locOutlineHeight;
int locOutlineCutOff;
int locFrontPlane;
int locTextureWidth;
int locTextureHeight;
@ -69,7 +67,6 @@ static void R_GetProgramUniformLocations( glsl_program_t *program );
static const char *r_defaultGLSLProgram;
static const char *r_defaultDistortionGLSLProgram;
static const char *r_defaultShadowmapGLSLProgram;
static const char *r_defaultOutlineGLSLProgram;
/*
================
@ -106,8 +103,6 @@ void R_InitGLSLPrograms( void )
R_RegisterGLSLProgram( DEFAULT_GLSL_DISTORTION_PROGRAM, r_defaultDistortionGLSLProgram, 0|features );
R_RegisterGLSLProgram( DEFAULT_GLSL_SHADOWMAP_PROGRAM, r_defaultShadowmapGLSLProgram, 0|features );
R_RegisterGLSLProgram( DEFAULT_GLSL_OUTLINE_PROGRAM, r_defaultOutlineGLSLProgram, 0|features );
}
/*
@ -764,55 +759,6 @@ static const char *r_defaultShadowmapGLSLProgram =
"#endif // FRAGMENT_SHADER\n"
"\n";
static const char *r_defaultOutlineGLSLProgram =
"// " APPLICATION " GLSL shader\n"
"\n"
"\n"
"varying vec4 ProjVector;\n"
"\n"
"#ifdef VERTEX_SHADER\n"
"// Vertex shader\n"
"\n"
"uniform float OutlineHeight;\n"
"\n"
"void main(void)\n"
"{\n"
"gl_FrontColor = gl_Color;\n"
"\n"
"vec4 n = vec4(gl_Normal.xyz, 0.0);\n"
"vec4 v = vec4(gl_Vertex) + n * OutlineHeight;\n"
"\n"
"gl_Position = gl_ModelViewProjectionMatrix * v;\n"
"ProjVector = gl_Position;\n"
"#ifdef APPLY_CLIPPING\n"
"#ifdef __GLSL_CG_DATA_TYPES\n"
"gl_ClipVertex = gl_ModelViewMatrix * gl_Vertex;\n"
"#endif\n"
"#endif\n"
"}\n"
"\n"
"#endif // VERTEX_SHADER\n"
"\n"
"\n"
"#ifdef FRAGMENT_SHADER\n"
"// Fragment shader\n"
"\n"
"uniform float OutlineCutOff;\n"
"\n"
"void main(void)\n"
"{\n"
"\n"
"#ifdef APPLY_BRANCHING\n"
"if (OutlineCutOff > 0.0 && (ProjVector.w > OutlineCutOff))\n"
"discard;\n"
"#endif\n"
"\n"
"gl_FragColor = vec4 (gl_Color);\n"
"}\n"
"\n"
"#endif // FRAGMENT_SHADER\n"
"\n";
/*
================
R_ProgramFeatures2Defines
@ -1024,7 +970,6 @@ void R_ProgramDump_f( void )
DUMP_PROGRAM( defaultGLSLProgram );
DUMP_PROGRAM( defaultDistortionGLSLProgram );
DUMP_PROGRAM( defaultShadowmapGLSLProgram );
DUMP_PROGRAM( defaultOutlineGLSLProgram );
}
#undef DUMP_PROGRAM
@ -1034,7 +979,8 @@ R_UpdateProgramUniforms
================
*/
void R_UpdateProgramUniforms( int elem, vec3_t eyeOrigin, vec3_t lightOrigin, vec3_t lightDir, vec4_t ambient,
vec4_t diffuse, bool frontPlane, int TexWidth, int TexHeight, float projDistance, float offsetmappingScale )
vec4_t diffuse, ref_style_t *lightStyle, bool frontPlane, int TexWidth, int TexHeight,
float projDistance, float offsetmappingScale )
{
glsl_program_t *program = r_glslprograms + elem - 1;
@ -1059,11 +1005,6 @@ void R_UpdateProgramUniforms( int elem, vec3_t eyeOrigin, vec3_t lightOrigin, ve
if( program->locOffsetMappingScale >= 0 )
pglUniform1fARB( program->locOffsetMappingScale, offsetmappingScale );
if( program->locOutlineHeight >= 0 )
pglUniform1fARB( program->locOutlineHeight, projDistance );
if( program->locOutlineCutOff >= 0 )
pglUniform1fARB( program->locOutlineCutOff, max( 0, r_outlines_cutoff->value ) );
if( program->locFrontPlane >= 0 )
pglUniform1fARB( program->locFrontPlane, frontPlane ? 1 : -1 );
@ -1075,18 +1016,16 @@ void R_UpdateProgramUniforms( int elem, vec3_t eyeOrigin, vec3_t lightOrigin, ve
if( program->locProjDistance >= 0 )
pglUniform1fARB( program->locProjDistance, projDistance );
#if 0
// FIXME: rewrite this code for new lightmaps implementation
if( superLightStyle )
if( lightStyle )
{
int i;
for( i = 0; i < LM_STYLES && superLightStyle->lightmapStyles[i] != 255; i++ )
for( i = 0; i < LM_STYLES && lightStyle->lightmapStyles[i] != 255; i++ )
{
vec_t *rgb = r_lightStyles[superLightStyle->lightmapStyles[i]].rgb;
vec_t *rgb = r_lightStyles[lightStyle->lightmapStyles[i]].rgb;
if( program->locDeluxemapOffset[i] >= 0 )
pglUniform1fARB( program->locDeluxemapOffset[i], superLightStyle->stOffset[i][0] );
pglUniform1fARB( program->locDeluxemapOffset[i], lightStyle->stOffset[0] );
if( program->loclsColor[i] >= 0 )
pglUniform3fARB( program->loclsColor[i], rgb[0], rgb[1], rgb[2] );
}
@ -1097,7 +1036,6 @@ void R_UpdateProgramUniforms( int elem, vec3_t eyeOrigin, vec3_t lightOrigin, ve
pglUniform3fARB( program->loclsColor[i], 0, 0, 0 );
}
}
#endif
}
/*
@ -1148,9 +1086,6 @@ static void R_GetProgramUniformLocations( glsl_program_t *program )
program->locOffsetMappingScale = pglGetUniformLocationARB( program->object, "OffsetMappingScale" );
program->locOutlineHeight = pglGetUniformLocationARB( program->object, "OutlineHeight" );
program->locOutlineCutOff = pglGetUniformLocationARB( program->object, "OutlineCutOff" );
program->locFrontPlane = pglGetUniformLocationARB( program->object, "FrontPlane" );
program->locTextureWidth = pglGetUniformLocationARB( program->object, "TextureWidth" );

11
vid_gl/r_register.c
View File

@ -39,7 +39,6 @@ cvar_t *r_nocull;
cvar_t *r_ignorehwgamma;
cvar_t *r_check_errors;
cvar_t *r_overbrightbits;
cvar_t *r_mapoverbrightbits;
cvar_t *r_vertexbuffers;
cvar_t *r_flares;
cvar_t *r_flaresize;
@ -94,10 +93,6 @@ cvar_t *r_bloom_darken;
cvar_t *r_bloom_sample_size;
cvar_t *r_bloom_fast_sample;
cvar_t *r_outlines_world;
cvar_t *r_outlines_scale;
cvar_t *r_outlines_cutoff;
cvar_t *r_allow_software;
cvar_t *r_3dlabs_broken;
@ -520,7 +515,6 @@ void GL_InitCommands( void )
r_environment_color = Cvar_Get( "r_environment_color", "128 128 128", CVAR_ARCHIVE, "map environment light color" );
r_ignorehwgamma = Cvar_Get( "r_ignorehwgamma", "0", CVAR_ARCHIVE|CVAR_LATCH_VIDEO, "ignore hardware gamma (e.g. not support)" );
r_overbrightbits = Cvar_Get( "r_overbrightbits", "0", CVAR_ARCHIVE|CVAR_LATCH_VIDEO, "renderer overbright bits" );
r_mapoverbrightbits = Cvar_Get( "r_mapoverbrightbits", "0", CVAR_ARCHIVE|CVAR_LATCH_VIDEO, "current map overbright bits" );
r_vertexbuffers = Cvar_Get( "r_vertexbuffers", "0", CVAR_ARCHIVE, "store vertex data in VBOs" );
r_detailtextures = Cvar_Get( "r_detailtextures", "1", CVAR_ARCHIVE, "enable or disable detail textures" );
@ -571,10 +565,6 @@ void GL_InitCommands( void )
r_shadows_pcf = Cvar_Get( "r_shadows_pcf", "0", CVAR_ARCHIVE, "allow pcf filtration" );
r_shadows_self_shadow = Cvar_Get( "r_shadows_self_shadow", "0", CVAR_ARCHIVE, "allow self-shadowing" );
r_outlines_world = Cvar_Get( "r_outlines_world", "1.8", CVAR_ARCHIVE, "cel-shading world outline thinkness" );
r_outlines_scale = Cvar_Get( "r_outlines_scale", "1", CVAR_ARCHIVE, "outilines scale" );
r_outlines_cutoff = Cvar_Get( "r_outlines_cutoff", "712", CVAR_ARCHIVE, "cutoff factor" );
r_himodels = Cvar_Get( "cl_himodels", "1", CVAR_ARCHIVE, "draw high-resolution player models in multiplayer" );
r_gamma = Cvar_Get( "vid_gamma", "1.0", CVAR_ARCHIVE, "gamma amount" );
@ -1028,7 +1018,6 @@ static void R_InitMedia( void )
R_InitShadows();
R_InitOcclusionQueries();
R_InitCustomColors ();
R_InitOutlines ();
GL_SetDefaultTexState ();

164
vid_gl/r_shader.c
View File

@ -64,16 +64,18 @@ static tcMod_t r_currentTcmods[MAX_SHADER_STAGES][MAX_SHADER_TCMODS];
static vec4_t r_currentTcGen[MAX_SHADER_STAGES][2];
const char *r_skyBoxSuffix[6] = { "rt", "bk", "lf", "ft", "up", "dn" }; // FIXME: get rid of this
static texture_t *r_stageTexture[MAX_STAGE_TEXTURES]; // MAX_FRAMES in spritegen.c
static texture_t *r_stageTexture[MAX_STAGE_TEXTURES]; // MAX_FRAMES in spritegen.c
static uint r_miptexFeatures; // bmodel miptex features
static kRenderMode_t r_shaderRenderMode; // sprite or studiomodel rendermode
static int r_numStageTextures; // num textures in group
static float r_stageAnimFrequency; // for auto-animate groups
static float r_stageAnimFrequency[2]; // anim fps / alt anim fps
static int r_stageAnimOffset; // offset for alternative animation
static bool r_shaderTwoSided;
static bool r_shaderNoMipMaps;
static bool r_shaderNoPicMip;
static bool r_shaderNoCompress;
static bool r_shaderNearest;
static bool r_shaderHasDlightPass;
#define Shader_FreePassCinematics( s ) if((s)->cinHandle ) { R_FreeCinematics((s)->cinHandle ); (s)->cinHandle = 0; }
#define Shader_CopyString( str ) com.stralloc( r_shaderpool, str, __FILE__, __LINE__ )
@ -964,10 +966,6 @@ static bool Shader_DeformVertexes( ref_shader_t *shader, ref_stage_t *pass, scri
{
deformv->type = DEFORM_AUTOPARTICLE;
}
else if( !com.stricmp( tok.string, "outline" ))
{
deformv->type = DEFORM_OUTLINE;
}
else
{
MsgDev( D_WARN, "unknown 'deformVertexes' parameter '%s' in shader '%s'\n", tok.string, shader->name );
@ -1188,6 +1186,12 @@ static bool Shader_Light( ref_shader_t *shader, ref_stage_t *pass, script_t *scr
return true;
}
static bool Shader_NoModulativeDlights( ref_shader_t *shader, ref_stage_t *pass, script_t *script )
{
shader->flags |= SHADER_NO_MODULATIVE_DLIGHTS;
return true;
}
static bool Shader_OffsetMappingScale( ref_shader_t *shader, ref_stage_t *pass, script_t *script )
{
if( !Com_ReadFloat( script, false, &shader->offsetmapping_scale ))
@ -1223,6 +1227,7 @@ static const ref_parsekey_t shaderkeys[] =
{ "deformvertexes", Shader_DeformVertexes },
{ "entitymergable", Shader_EntityMergable },
{ "offsetmappingscale", Shader_OffsetMappingScale },
{ "nomodulativedlights", Shader_NoModulativeDlights },
{ NULL, NULL }
};
@ -1322,16 +1327,26 @@ static bool Shaderpass_MapExt( ref_shader_t *shader, ref_stage_t *pass, int addF
if( !com.stricmp( tok.string, "$lightmap" ))
{
pass->tcgen = TCGEN_LIGHTMAP;
pass->flags = ( pass->flags & ~(SHADERSTAGE_PORTALMAP)) | SHADERSTAGE_LIGHTMAP;
pass->flags = ( pass->flags & ~(SHADERSTAGE_PORTALMAP|SHADERSTAGE_DLIGHT)) | SHADERSTAGE_LIGHTMAP;
pass->animFrequency[0] = pass->animFrequency[1] = 0.0f;
pass->anim_offset = 0;
pass->textures[0] = NULL;
return true;
}
else if( !com.stricmp( tok.string, "$dlight" ))
{
pass->tcgen = TCGEN_BASE;
pass->flags = ( pass->flags & ~(SHADERSTAGE_LIGHTMAP|SHADERSTAGE_PORTALMAP)) | SHADERSTAGE_DLIGHT;
pass->animFrequency[0] = pass->animFrequency[1] = 0.0f;
pass->anim_offset = 0;
pass->textures[0] = NULL;
r_shaderHasDlightPass = true;
return true;
}
else if( !com.stricmp( tok.string, "$portalmap" ) || !com.stricmp( tok.string, "$mirrormap" ))
{
pass->tcgen = TCGEN_PROJECTION;
pass->flags = ( pass->flags & ~(SHADERSTAGE_LIGHTMAP)) | SHADERSTAGE_PORTALMAP;
pass->flags = ( pass->flags & ~(SHADERSTAGE_LIGHTMAP|SHADERSTAGE_DLIGHT)) | SHADERSTAGE_PORTALMAP;
pass->animFrequency[0] = pass->animFrequency[1] = 0.0f;
pass->anim_offset = 0;
pass->textures[0] = NULL;
@ -1367,7 +1382,7 @@ static bool Shaderpass_MapExt( ref_shader_t *shader, ref_stage_t *pass, int addF
pass->textures[pass->num_textures] = Shader_FindImage( shader, name, flags );
pass->tcgen = TCGEN_BASE;
pass->flags &= ~(SHADERSTAGE_LIGHTMAP|SHADERSTAGE_PORTALMAP);
pass->flags &= ~(SHADERSTAGE_LIGHTMAP|SHADERSTAGE_DLIGHT|SHADERSTAGE_PORTALMAP);
}
pass->num_textures++;
@ -1384,7 +1399,7 @@ static bool Shaderpass_AnimMapExt( ref_shader_t *shader, ref_stage_t *pass, int
flags = Shader_SetImageFlags( shader ) | addFlags;
pass->tcgen = TCGEN_BASE;
pass->flags &= ~( SHADERSTAGE_LIGHTMAP|SHADERSTAGE_PORTALMAP );
pass->flags &= ~( SHADERSTAGE_LIGHTMAP|SHADERSTAGE_DLIGHT|SHADERSTAGE_PORTALMAP );
if( !Com_ReadFloat( script, false, &anim_fps ))
{
@ -1447,7 +1462,7 @@ static bool Shaderpass_CubeMapExt( ref_shader_t *shader, ref_stage_t *pass, int
pass->flags |= SHADERSTAGE_FRAMES;
}
pass->flags &= ~(SHADERSTAGE_LIGHTMAP|SHADERSTAGE_PORTALMAP);
pass->flags &= ~(SHADERSTAGE_LIGHTMAP|SHADERSTAGE_DLIGHT|SHADERSTAGE_PORTALMAP);
if( !GL_Support( R_TEXTURECUBEMAP_EXT ))
{
@ -1477,7 +1492,7 @@ static bool Shaderpass_CubeMapExt( ref_shader_t *shader, ref_stage_t *pass, int
pass->tcgen = TCGEN_BASE;
pass->textures[pass->num_textures] = Shader_FindImage( shader, name, flags );
pass->flags &= ~(SHADERSTAGE_LIGHTMAP|SHADERSTAGE_PORTALMAP);
pass->flags &= ~(SHADERSTAGE_LIGHTMAP|SHADERSTAGE_DLIGHT|SHADERSTAGE_PORTALMAP);
if( pass->textures[pass->num_textures] != tr.defaultTexture ) pass->tcgen = tcgen;
pass->num_textures++;
@ -1528,7 +1543,7 @@ static bool Shaderpass_VideoMap( ref_shader_t *shader, ref_stage_t *pass, script
pass->tcgen = TCGEN_BASE;
pass->cinHandle = R_StartCinematics( tok.string );
pass->flags &= ~(SHADERSTAGE_LIGHTMAP|SHADERSTAGE_PORTALMAP|SHADERSTAGE_ANIMFREQUENCY|SHADERSTAGE_FRAMES);
pass->flags &= ~(SHADERSTAGE_LIGHTMAP|SHADERSTAGE_DLIGHT|SHADERSTAGE_PORTALMAP|SHADERSTAGE_ANIMFREQUENCY|SHADERSTAGE_FRAMES);
pass->animFrequency[0] = pass->animFrequency[1] = 0.0f;
pass->anim_offset = 0;
@ -1575,7 +1590,7 @@ static bool Shaderpass_NormalMap( ref_shader_t *shader, ref_stage_t *pass, scrip
else name = tok.string;
pass->tcgen = TCGEN_BASE;
pass->flags &= ~(SHADERSTAGE_LIGHTMAP|SHADERSTAGE_PORTALMAP);
pass->flags &= ~(SHADERSTAGE_LIGHTMAP|SHADERSTAGE_DLIGHT|SHADERSTAGE_PORTALMAP);
pass->textures[1] = Shader_FindImage( shader, name, flags );
pass->num_textures++;
if( pass->textures[1] != tr.defaultTexture )
@ -1653,7 +1668,7 @@ static bool Shaderpass_Material( ref_shader_t *shader, ref_stage_t *pass, script
pass->textures[1] = pass->textures[2] = pass->textures[3] = NULL;
pass->tcgen = TCGEN_BASE;
pass->flags &= ~(SHADERSTAGE_LIGHTMAP|SHADERSTAGE_PORTALMAP);
pass->flags &= ~(SHADERSTAGE_LIGHTMAP|SHADERSTAGE_DLIGHT|SHADERSTAGE_PORTALMAP);
while( 1 )
{
@ -1749,7 +1764,7 @@ static bool Shaderpass_Distortion( ref_shader_t *shader, ref_stage_t *pass, scri
}
flags = Shader_SetImageFlags( shader );
pass->flags &= ~(SHADERSTAGE_LIGHTMAP|SHADERSTAGE_PORTALMAP);
pass->flags &= ~(SHADERSTAGE_LIGHTMAP|SHADERSTAGE_DLIGHT|SHADERSTAGE_PORTALMAP);
pass->textures[0] = pass->textures[1] = NULL;
while( 1 )
@ -1833,16 +1848,15 @@ static bool Shaderpass_RGBGen( ref_shader_t *shader, ref_stage_t *pass, script_t
else if( !com.stricmp( tok.string, "oneMinusEntity" )) pass->rgbGen.type = RGBGEN_ONE_MINUS_ENTITY;
else if( !com.stricmp( tok.string, "vertex" )) pass->rgbGen.type = RGBGEN_VERTEX;
else if( !com.stricmp( tok.string, "oneMinusVertex" )) pass->rgbGen.type = RGBGEN_ONE_MINUS_VERTEX;
else if( !com.stricmp( tok.string, "lightingDiffuseOnly" )) pass->rgbGen.type = RGBGEN_LIGHTING_DIFFUSE_ONLY;
else if( !com.stricmp( tok.string, "lightingDiffuse" )) pass->rgbGen.type = RGBGEN_LIGHTING_DIFFUSE;
else if( !com.stricmp( tok.string, "exactVertex" )) pass->rgbGen.type = RGBGEN_EXACT_VERTEX;
else if( !com.stricmp( tok.string, "lightingAmbientOnly" ))
else if( !com.stricmp( tok.string, "lightingAmbient" ))
{
// optional undocs parm 'invLight'
if( Com_ReadToken( script, false, &tok ))
if( !com.stricmp( tok.string, "invLight" ))
pass->rgbGen.args[0] = true;
pass->rgbGen.type = RGBGEN_LIGHTING_AMBIENT_ONLY;
pass->rgbGen.type = RGBGEN_LIGHTING_AMBIENT;
}
else if( !com.stricmp( tok.string, "const" ) || !com.stricmp( tok.string, "constant" ))
{
@ -2493,9 +2507,6 @@ void R_ShaderList_f( void )
case SHADER_OPAQUE_OCCLUDER:
Msg( "occl " );
break;
case SHADER_OUTLINE:
Msg( "outl " );
break;
case SHADER_NOMIP:
Msg( "pic " );
break;
@ -2619,8 +2630,10 @@ void R_InitShaders( void )
r_shaderTwoSided = 0;
r_miptexFeatures = 0;
r_stageAnimFrequency = 0.0f;
r_stageAnimOffset = 0;
r_numStageTextures = 0;
r_stageAnimFrequency[0] = 0.0f;
r_stageAnimFrequency[1] = 0.0f;
r_shaderRenderMode = kRenderNormal;
R_RegisterBuiltinShaders ();
@ -2802,7 +2815,7 @@ void Shader_SetBlendmode( ref_stage_t *pass )
if( pass->flags & SHADERSTAGE_BLENDMODE )
return;
if( !pass->textures[0] && !( pass->flags & SHADERSTAGE_LIGHTMAP ))
if( !pass->textures[0] && !( pass->flags & ( SHADERSTAGE_LIGHTMAP|SHADERSTAGE_DLIGHT )))
return;
if(!( pass->glState & (GLSTATE_SRCBLEND_MASK|GLSTATE_DSTBLEND_MASK)))
@ -2951,10 +2964,8 @@ static bool Shader_ParseShader( ref_shader_t *shader, script_t *script )
case RGBGEN_COLORWAVE:
case RGBGEN_ENTITY:
case RGBGEN_ONE_MINUS_ENTITY:
case RGBGEN_LIGHTING_DIFFUSE_ONLY:
case RGBGEN_LIGHTING_AMBIENT_ONLY:
case RGBGEN_LIGHTING_AMBIENT:
case RGBGEN_CUSTOM:
case RGBGEN_OUTLINE:
case RGBGEN_UNKNOWN: // assume RGBGEN_IDENTITY or RGBGEN_IDENTITY_LIGHTING
switch( stage->alphaGen.type )
{
@ -2964,7 +2975,6 @@ static bool Shader_ParseShader( ref_shader_t *shader, script_t *script )
case ALPHAGEN_WAVE:
case ALPHAGEN_ALPHAWAVE:
case ALPHAGEN_ENTITY:
case ALPHAGEN_OUTLINE:
stage->flags |= SHADERSTAGE_NOCOLORARRAY;
break;
default: break;
@ -3217,6 +3227,9 @@ void Shader_Finish( ref_shader_t *s )
if( s->flags & SHADER_AUTOSPRITE )
s->flags &= ~( SHADER_CULL_FRONT|SHADER_CULL_BACK );
if( r_shaderHasDlightPass )
s->flags |= SHADER_NO_MODULATIVE_DLIGHTS;
for( i = 0, pass = s->stages; i < s->num_stages; i++, pass++ )
{
if( pass->flags & SHADERSTAGE_ANIMFREQUENCY && pass->anim_offset == 0 )
@ -3230,8 +3243,11 @@ void Shader_Finish( ref_shader_t *s )
s->flags |= SHADER_HASLIGHTMAP;
if( pass->program )
{
s->flags |= SHADER_NO_MODULATIVE_DLIGHTS;
if( pass->program_type == PROGRAM_TYPE_MATERIAL )
s->flags |= SHADER_MATERIAL;
if( r_shaderHasDlightPass )
pass->textures[5] = ( (texture_t *)1); // HACKHACK no dlights
}
Shader_SetBlendmode( pass );
}
@ -3418,7 +3434,7 @@ static ref_shader_t *Shader_CreateDefault( ref_shader_t *shader, int type, int a
// normal transparency
pass->flags |= SHADERSTAGE_BLEND_MODULATE;
pass->glState = GLSTATE_SRCBLEND_SRC_ALPHA|GLSTATE_DSTBLEND_ONE_MINUS_SRC_ALPHA|GLSTATE_DEPTHWRITE;
pass->rgbGen.type = RGBGEN_LIGHTING_AMBIENT_ONLY;
pass->rgbGen.type = RGBGEN_LIGHTING_AMBIENT;
pass->alphaGen.type = ALPHAGEN_ENTITY;
shader->sort = SORT_ADDITIVE;
break;
@ -3432,7 +3448,7 @@ static ref_shader_t *Shader_CreateDefault( ref_shader_t *shader, int type, int a
case kRenderTransAlpha:
pass->flags |= SHADERSTAGE_BLEND_DECAL;
pass->glState = GLSTATE_AFUNC_GE128|GLSTATE_DEPTHWRITE;
pass->rgbGen.type = RGBGEN_LIGHTING_AMBIENT_ONLY;
pass->rgbGen.type = RGBGEN_LIGHTING_AMBIENT;
pass->alphaGen.type = ALPHAGEN_ENTITY;
shader->sort = SORT_ALPHATEST;
break;
@ -3487,7 +3503,7 @@ static ref_shader_t *Shader_CreateDefault( ref_shader_t *shader, int type, int a
shader->stages = (ref_stage_t *)( ( byte * )shader->name + length + 1 );
pass = &shader->stages[0];
pass->tcgen = TCGEN_BASE;
if( r_stageAnimFrequency == 0.0f && r_numStageTextures == 8 )
if( r_stageAnimFrequency[0] == 0.0f && r_numStageTextures == 8 )
{
// store angled map into one bundle
pass->flags |= SHADERSTAGE_ANGLEDMAP;
@ -3503,10 +3519,10 @@ static ref_shader_t *Shader_CreateDefault( ref_shader_t *shader, int type, int a
{
// store group frames into one stage
pass->flags |= SHADERSTAGE_FRAMES;
if( r_stageAnimFrequency != 0.0f )
if( r_stageAnimFrequency[0] != 0.0f )
{
pass->flags |= SHADERSTAGE_ANIMFREQUENCY;
pass->animFrequency[0] = r_stageAnimFrequency;
pass->animFrequency[0] = r_stageAnimFrequency[0];
}
for( i = 0; i < r_numStageTextures; i++ )
{
@ -3557,13 +3573,13 @@ static ref_shader_t *Shader_CreateDefault( ref_shader_t *shader, int type, int a
case kRenderTransAlpha:
pass->flags |= SHADERSTAGE_BLEND_DECAL;
pass->glState = GLSTATE_AFUNC_GE128|GLSTATE_DEPTHWRITE;
pass->rgbGen.type = RGBGEN_LIGHTING_AMBIENT_ONLY;
pass->rgbGen.type = RGBGEN_LIGHTING_AMBIENT;
pass->alphaGen.type = ALPHAGEN_IDENTITY;
shader->sort = SORT_ALPHATEST;
break;
default:
pass->glState = GLSTATE_DEPTHWRITE;
pass->rgbGen.type = RGBGEN_LIGHTING_AMBIENT_ONLY;
pass->rgbGen.type = RGBGEN_LIGHTING_AMBIENT;
pass->alphaGen.type = ALPHAGEN_IDENTITY;
shader->sort = SORT_OPAQUE;
break;
@ -3707,32 +3723,11 @@ static ref_shader_t *Shader_CreateDefault( ref_shader_t *shader, int type, int a
pass->tcgen = TCGEN_NONE;
pass->num_textures++;
break;
case SHADER_OUTLINE:
shader->type = SHADER_OUTLINE;
shader->features = MF_NORMALS|MF_DEFORMVS;
shader->sort = SORT_OPAQUE;
shader->flags = SHADER_CULL_BACK|SHADER_DEPTHWRITE|SHADER_STATIC;
shader->numDeforms = 1;
shader->num_stages = 1;
shader->name = Shader_Malloc( length + 1 + shader->numDeforms * sizeof( deform_t ) + sizeof( ref_stage_t ) * shader->num_stages );
strcpy( shader->name, shortname );
shader->deforms = ( deform_t * )( ( byte * )shader->name + length + 1 );
shader->deforms[0].type = DEFORM_OUTLINE;
shader->stages = ( ref_stage_t * )( ( byte * )shader->deforms + shader->numDeforms * sizeof( deform_t ) );
pass = &shader->stages[0];
pass->textures[0] = tr.whiteTexture;
pass->flags = SHADERSTAGE_NOCOLORARRAY|SHADERSTAGE_BLEND_MODULATE;
pass->glState = GLSTATE_SRCBLEND_ONE|GLSTATE_DSTBLEND_ZERO|GLSTATE_DEPTHWRITE;
pass->rgbGen.type = RGBGEN_OUTLINE;
pass->alphaGen.type = ALPHAGEN_OUTLINE;
pass->tcgen = TCGEN_NONE;
pass->num_textures++;
break;
case SHADER_TEXTURE:
if( mapConfig.deluxeMappingEnabled && Shaderpass_LoadMaterial( &materialImages[0], &materialImages[1], &materialImages[2], shortname, addFlags, 1 ))
{
shader->type = SHADER_TEXTURE;
shader->flags = SHADER_DEPTHWRITE|SHADER_CULL_FRONT|SHADER_HASLIGHTMAP|SHADER_MATERIAL;
shader->flags = SHADER_DEPTHWRITE|SHADER_CULL_FRONT|SHADER_NO_MODULATIVE_DLIGHTS|SHADER_HASLIGHTMAP|SHADER_MATERIAL;
shader->features = MF_STCOORDS|MF_LMCOORDS|MF_NORMALS|MF_SVECTORS|MF_ENABLENORMALS;
shader->sort = SORT_OPAQUE;
shader->num_stages = 1;
@ -3777,7 +3772,33 @@ static ref_shader_t *Shader_CreateDefault( ref_shader_t *shader, int type, int a
pass->flags = SHADERSTAGE_RENDERMODE|SHADERSTAGE_NOCOLORARRAY|SHADERSTAGE_BLEND_REPLACE;
pass->glState = GLSTATE_DEPTHWRITE;
pass->tcgen = TCGEN_BASE;
if( r_numStageTextures > 0 ) pass->textures[0] = r_stageTexture[0];
if( r_numStageTextures > 1 )
{
// extended sequence
if( r_stageAnimFrequency[0] != 0.0f )
{
pass->flags |= SHADERSTAGE_ANIMFREQUENCY;
pass->animFrequency[0] = r_stageAnimFrequency[0];
pass->animFrequency[1] = r_stageAnimFrequency[1];
pass->anim_offset = (r_stageAnimOffset == 0) ? r_numStageTextures : r_stageAnimOffset;
}
else pass->flags |= SHADERSTAGE_FRAMES;
for( i = 0; i < r_numStageTextures; i++ )
{
if( !r_stageTexture[i] )
pass->textures[i] = tr.defaultTexture;
else pass->textures[i] = r_stageTexture[i];
pass->num_textures++;
}
pass->textures[0] = r_stageTexture[0];
}
else if( r_numStageTextures == 1 )
{
pass->textures[0] = r_stageTexture[0];
pass->num_textures++;
}
else pass->textures[0] = Shader_FindImage( shader, shortname, addFlags );
pass->rgbGen.type = RGBGEN_IDENTITY_LIGHTING;
pass->alphaGen.type = ALPHAGEN_IDENTITY;
@ -3789,7 +3810,6 @@ static ref_shader_t *Shader_CreateDefault( ref_shader_t *shader, int type, int a
pass->numtcMods++;
}
pass->num_textures++;
if( !hasLightmap ) break;
pass = &shader->stages[1];
pass->flags = SHADERSTAGE_LIGHTMAP|SHADERSTAGE_NOCOLORARRAY|SHADERSTAGE_BLEND_REPLACE;
@ -3801,7 +3821,7 @@ static ref_shader_t *Shader_CreateDefault( ref_shader_t *shader, int type, int a
break;
case SHADER_GENERIC:
default: shader->type = SHADER_GENERIC;
shader->flags = SHADER_DEPTHWRITE|SHADER_CULL_FRONT;
shader->flags = SHADER_DEPTHWRITE|SHADER_CULL_FRONT|SHADER_NO_MODULATIVE_DLIGHTS;
shader->features = MF_STCOORDS;
shader->sort = SORT_OPAQUE;
shader->num_stages = 1;
@ -3822,8 +3842,10 @@ static ref_shader_t *Shader_CreateDefault( ref_shader_t *shader, int type, int a
// reset parms
r_shaderTwoSided = 0;
r_miptexFeatures = 0;
r_stageAnimOffset = 0;
r_numStageTextures = 0;
r_stageAnimFrequency = 0.0f;
r_stageAnimFrequency[0] = 0.0f;
r_stageAnimFrequency[1] = 0.0f;
Shader_SetRenderMode( shader );
@ -3904,6 +3926,7 @@ ref_shader_t *R_LoadShader( const char *name, int type, bool forceDefault, int a
r_shaderNoMipMaps = false;
r_shaderNoPicMip = false;
r_shaderNoCompress = false;
r_shaderHasDlightPass = false;
r_shaderNearest = false;
if( !forceDefault )
@ -3987,7 +4010,24 @@ void R_ShaderSetRenderMode( kRenderMode_t mode, bool twoSided )
void R_ShaderAddStageIntervals( float interval )
{
r_stageAnimFrequency += interval;
r_stageAnimFrequency[0] += interval;
}
void R_SetAnimFrequency( float anim_fps )
{
if( r_numStageTextures )
{
// tired to specify third anim sequence, ignore
if( r_stageAnimOffset ) return;
r_stageAnimFrequency[1] = anim_fps;
r_stageAnimOffset = r_numStageTextures;
}
else
{
r_stageAnimFrequency[0] = anim_fps;
r_stageAnimOffset = 0;
}
}
/*

27
vid_gl/r_shader.h
View File

@ -46,7 +46,6 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
#define SHADER_NEARBOX 11
#define SHADER_PLANAR_SHADOW 12
#define SHADER_OPAQUE_OCCLUDER 13
#define SHADER_OUTLINE 14
// shader flags
typedef enum
@ -63,7 +62,7 @@ typedef enum
SHADER_DEFORM_NORMAL = BIT(9),
SHADER_ENTITY_MERGABLE = BIT(10),
SHADER_AUTOSPRITE = BIT(11),
SHADER_NOFRAGMENTS = BIT(12),
SHADER_NO_MODULATIVE_DLIGHTS = BIT(12),
SHADER_HASLIGHTMAP = BIT(13),
SHADER_PORTAL = BIT(14),
SHADER_PORTAL_CAPTURE1 = BIT(15),
@ -72,7 +71,7 @@ typedef enum
SHADER_DEFAULTED = BIT(18),
SHADER_PORTAL_CAPTURE = (SHADER_PORTAL_CAPTURE1|SHADER_PORTAL_CAPTURE1),
SHADER_CULL = (SHADER_CULL_FRONT|SHADER_CULL_BACK),
SHADER_NOFRAGMENTS = BIT(19),
} shaderFlags_t;
// shaderstage flags
@ -84,13 +83,14 @@ enum
SHADERSTAGE_LIGHTMAP = BIT(3),
SHADERSTAGE_DETAIL = BIT(4),
SHADERSTAGE_NOCOLORARRAY = BIT(5),
SHADERSTAGE_PORTALMAP = BIT(6),
SHADERSTAGE_STENCILSHADOW = BIT(7),
SHADERSTAGE_RENDERMODE = BIT(8),
SHADERSTAGE_BLEND_REPLACE = BIT(9),
SHADERSTAGE_BLEND_MODULATE = BIT(10),
SHADERSTAGE_BLEND_ADD = BIT(11),
SHADERSTAGE_BLEND_DECAL = BIT(12)
SHADERSTAGE_DLIGHT = BIT(6),
SHADERSTAGE_PORTALMAP = BIT(7),
SHADERSTAGE_STENCILSHADOW = BIT(8),
SHADERSTAGE_RENDERMODE = BIT(9),
SHADERSTAGE_BLEND_REPLACE = BIT(10),
SHADERSTAGE_BLEND_MODULATE = BIT(11),
SHADERSTAGE_BLEND_ADD = BIT(12),
SHADERSTAGE_BLEND_DECAL = BIT(13)
} stageFlags_t;
#define SHADERSTAGE_BLENDMODE (SHADERSTAGE_BLEND_REPLACE|SHADERSTAGE_BLEND_MODULATE|SHADERSTAGE_BLEND_ADD|SHADERSTAGE_BLEND_DECAL)
@ -139,12 +139,10 @@ typedef enum
RGBGEN_VERTEX,
RGBGEN_ONE_MINUS_VERTEX,
RGBGEN_LIGHTING_DIFFUSE,
RGBGEN_LIGHTING_AMBIENT,
RGBGEN_EXACT_VERTEX,
RGBGEN_LIGHTING_DIFFUSE_ONLY,
RGBGEN_LIGHTING_AMBIENT_ONLY,
RGBGEN_CUSTOM,
RGBGEN_FOG, // followed extensions only for internal use
RGBGEN_OUTLINE,
RGBGEN_ENVIRONMENT
} rgbGenType_t;
@ -166,7 +164,6 @@ typedef enum
ALPHAGEN_ONE_MINUS_FADE,
ALPHAGEN_DOT,
ALPHAGEN_ONE_MINUS_DOT,
ALPHAGEN_OUTLINE // only for internal use
} alphaGenType_t;
// texture coordinates generation
@ -213,7 +210,6 @@ typedef enum
DEFORM_AUTOSPRITE2,
DEFORM_PROJECTION_SHADOW,
DEFORM_AUTOPARTICLE,
DEFORM_OUTLINE
} deformType_t;
typedef enum
@ -358,6 +354,7 @@ void Shader_TouchImages( ref_shader_t *shader, bool free_unused );
void R_ShaderAddStageTexture( texture_t *mipTex );
void R_ShaderSetMiptexFlags( uint addFlags );
void R_ShaderSetRenderMode( kRenderMode_t mode, bool twoSided );
void R_SetAnimFrequency( float anim_fps );
void R_ShaderAddStageIntervals( float interval );
void R_UploadCinematicShader( const ref_shader_t *shader );
void R_DeformvBBoxForShader( const ref_shader_t *shader, vec3_t ebbox );

6
vid_gl/r_shadow.c
View File

@ -61,11 +61,11 @@ static void R_GetShadowImpactAndDir( ref_entity_t *e, trace_t *tr, vec3_t lightd
{
vec3_t point;
R_LightForOrigin( e->lightingOrigin, lightdir, NULL, NULL, e->model->radius * e->scale );
R_LightDir( e->lightingOrigin, lightdir, e->model->radius * e->scale );
VectorSet( lightdir, -lightdir[0], -lightdir[1], -1 );
VectorNormalizeFast( lightdir );
VectorMA( e->origin, /*(e->model->radius*e->scale*4 + r_shadows_projection_distance->value)*/ 1024.0f, lightdir, point );
VectorMA( e->origin, 1024.0f, lightdir, point );
R_TraceLine( tr, e->origin, point );
}
@ -417,7 +417,7 @@ void R_DrawShadowmaps( void )
Vector4Set( RI.scissor, RI.refdef.viewport[0], RI.refdef.viewport[1], textureWidth, textureHeight );
// set the view transformation matrix according to lightgrid
R_LightForOrigin( group->origin, lightdir, NULL, NULL, group->projDist * 0.5 );
R_LightDir( group->origin, lightdir, group->projDist * 0.5f );
VectorSet( lightdir, -lightdir[0], -lightdir[1], -lightdir[2] );
VectorNormalizeFast( lightdir );

2
vid_gl/r_studio.c
View File

@ -2284,8 +2284,6 @@ void R_StudioDrawPoints( const meshbuffer_t *mb, ref_entity_t *e )
{
if(( features & MF_SVECTORS ) || r_shownormals->integer )
features |= MF_NORMALS;
if( RI.currententity->outlineHeight )
features |= MF_NORMALS|(GL_Support( R_SHADER_GLSL100_EXT ) ? MF_ENABLENORMALS : 0);
}
Com_Assert( studio == NULL );

82
vid_gl/r_surf.c
View File

@ -73,11 +73,7 @@ bool R_CullSurface( msurface_t *surf, uint clipflags )
if( shader->flags & SHADER_AUTOSPRITE )
return false;
// never cull turblent or warp surfaces
// FIXME: this is probably not actual for sudivided surfaces. comment this ?
if( shader->tessSize ) return false;
if( r_faceplanecull->integer && !RI.currententity->outlineHeight && ( shader->flags & (SHADER_CULL_FRONT|SHADER_CULL_BACK)))
if( r_faceplanecull->integer && ( shader->flags & (SHADER_CULL_FRONT|SHADER_CULL_BACK)))
{
if( !VectorCompare( surf->plane->normal, vec3_origin ))
{
@ -261,15 +257,11 @@ R_AddBrushModelToList
void R_AddBrushModelToList( ref_entity_t *e )
{
bool rotated;
uint i, dlightbits;
ref_model_t *model = e->model;
mbrushmodel_t *bmodel = (mbrushmodel_t *)model->extradata;
msurface_t *psurf;
meshbuffer_t *mb;
dlight_t *lt;
uint i;
e->outlineHeight = r_worldent->outlineHeight;
Vector4Copy( r_worldent->outlineColor, e->outlineColor );
rotated = !Matrix3x3_Compare( e->axis, matrix3x3_identity );
VectorSubtract( RI.refdef.vieworg, e->origin, modelorg );
@ -282,11 +274,14 @@ void R_AddBrushModelToList( ref_entity_t *e )
Matrix3x3_Transform( e->axis, temp, modelorg );
}
for( i = 0, lt = r_dlights; i < r_numDlights; i++, lt++ )
dlightbits = 0;
if(( r_dynamiclight->integer == 1 ) && !r_fullbright->integer && !( RI.params & RP_SHADOWMAPVIEW ))
{
VectorSubtract( lt->origin, modelorg, lt->origin );
R_RecursiveLightNode( lt, BIT( i ), bmodel->firstmodelnode );
VectorAdd( lt->origin, modelorg, lt->origin );
for( i = 0; i < r_numDlights; i++ )
{
if( BoundsIntersect( modelmins, modelmaxs, r_dlights[i].mins, r_dlights[i].maxs ))
dlightbits |= ( 1<<i );
}
}
for( i = 0, psurf = bmodel->firstmodelsurface; i < bmodel->nummodelsurfaces; i++, psurf++ )
@ -319,7 +314,7 @@ void R_AddBrushModelToList( ref_entity_t *e )
{
mb->sortkey |= (( psurf->superLightStyle+1 ) << 10 );
if( R_SurfPotentiallyLit( psurf ))
mb->dlightbits = psurf->dlightBits;
mb->dlightbits = dlightbits;
}
}
}
@ -336,10 +331,11 @@ WORLD MODEL
R_RecursiveWorldNode
================
*/
static void R_RecursiveWorldNode( mnode_t *node, uint clipflags )
static void R_RecursiveWorldNode( mnode_t *node, uint clipflags, uint dlightbits )
{
const cplane_t *clipplane;
int i, clipped;
uint newDlightbits;
msurface_t **mark, *surf;
mleaf_t *leaf;
meshbuffer_t *mb;
@ -366,8 +362,28 @@ static void R_RecursiveWorldNode( mnode_t *node, uint clipflags )
// recurse down the children
if( node->contents == CONTENTS_NODE )
{
R_RecursiveWorldNode( node->children[0], clipflags );
R_RecursiveWorldNode( node->children[1], clipflags );
newDlightbits = 0;
if( dlightbits )
{
float dist;
for( i = 0; i < r_numDlights; i++ )
{
if(!( dlightbits & ( 1<<i )))
continue;
dist = PlaneDiff( r_dlights[i].origin, node->plane );
if( dist < -r_dlights[i].intensity )
dlightbits &= ~(1<<i);
if( dist < r_dlights[i].intensity )
newDlightbits |= (1<<i);
}
}
R_RecursiveWorldNode( node->children[0], clipflags, dlightbits );
dlightbits = newDlightbits;
R_RecursiveWorldNode( node->children[1], clipflags, dlightbits );
return;
}
@ -403,8 +419,9 @@ static void R_RecursiveWorldNode( mnode_t *node, uint clipflags )
mb = RI.surfmbuffers[surf - r_worldbrushmodel->surfaces];
}
if( mb && R_SurfPotentiallyLit( surf ))
mb->dlightbits = surf->dlightBits;
newDlightbits = mb ? dlightbits & ~mb->dlightbits : 0;
if( newDlightbits && R_SurfPotentiallyLit( surf ))
mb->dlightbits |= R_AddSurfDlighbits( surf, newDlightbits );
}
c_world_leafs++;
@ -569,8 +586,8 @@ R_DrawWorld
*/
void R_DrawWorld( void )
{
int clipflags;
int msec = 0;
int clipflags, msec = 0;
uint dlightbits;
if( !r_drawworld->integer )
return;
@ -587,12 +604,6 @@ void R_DrawWorld( void )
RI.currententity = r_worldent;
RI.currentmodel = RI.currententity->model;
if( r_outlines_world->integer && r_viewleaf != NULL )
RI.currententity->outlineHeight = max( 0.0f, r_outlines_world->value );
else RI.currententity->outlineHeight = 0.0f;
Vector4Copy( mapConfig.outlineColor, RI.currententity->outlineColor );
if(!( RI.params & RP_SHADOWMAPVIEW ))
{
R_AllocMeshbufPointers( &RI );
@ -611,15 +622,12 @@ void R_DrawWorld( void )
if( r_speeds->integer )
msec = Sys_Milliseconds();
if( RI.params & RP_SHADOWMAPVIEW )
{
R_LinearShadowLeafs ();
}
else
{
R_RecursiveWorldNode( r_worldbrushmodel->nodes, clipflags );
R_MarkLights( clipflags );
}
if( r_dynamiclight->integer != 1 || r_fullbright->integer )
dlightbits = 0;
else dlightbits = r_numDlights < 32 ? ( 1 << r_numDlights ) - 1 : -1;
if( RI.params & RP_SHADOWMAPVIEW ) R_LinearShadowLeafs ();
else R_RecursiveWorldNode( r_worldbrushmodel->nodes, clipflags, dlightbits );
if( r_speeds->integer )
r_world_node += Sys_Milliseconds() - msec;

2
xtools/ximage.c
View File

@ -29,7 +29,7 @@ bool ConvertImages( byte *mempool, const char *name, byte parms )
else if( !com.stricmp( value, "270" ))
flags |= IMAGE_ROT270;
else if( !com.stricmp( value, "360" ))
Sys_Break( "Stupid User!!! What you doing?\n" );
Sys_Break( "Stupid User!!! What are you doing?\n" );
else if( !unknown_rotate )
{
Msg( "Usage: -rotate <90|180|270>\n" );