07 Jun 2010
This commit is contained in:
parent
b4010e9519
commit
e31162d22e
|
@ -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;
|
||||
|
|
|
@ -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 );
|
||||
|
||||
|
|
|
@ -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];
|
||||
|
|
|
@ -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;
|
||||
}
|
||||
|
|
|
@ -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;
|
||||
|
|
|
@ -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
|
||||
|
||||
|
|
|
@ -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 );
|
||||
|
|
|
@ -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 );
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
@ -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)" );
|
||||
|
|
|
@ -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;
|
||||
|
|
|
@ -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 );
|
||||
|
|
|
@ -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;
|
||||
|
|
|
@ -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++ )
|
||||
{
|
||||
|
|
|
@ -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 );
|
||||
}
|
||||
|
|
|
@ -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++ )
|
||||
{
|
||||
|
|
|
@ -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 )
|
||||
{
|
||||
|
|
|
@ -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 )
|
||||
{
|
||||
|
|
|
@ -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
|
||||
|
|
|
@ -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 );
|
||||
|
|
|
@ -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
|
||||
|
|
|
@ -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;
|
||||
|
|
|
@ -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))
|
||||
{
|
||||
|
|
|
@ -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;
|
||||
|
|
|
@ -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;
|
||||
|
|
|
@ -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;
|
||||
|
|
|
@ -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
855
vid_gl/r_light.c
File diff suppressed because it is too large
Load Diff
|
@ -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;
|
||||
|
||||
|
|
|
@ -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
|
||||
|
|
|
@ -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
1193
vid_gl/r_model.c
File diff suppressed because it is too large
Load Diff
|
@ -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;
|
||||
|
||||
|
|
|
@ -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" );
|
||||
|
|
|
@ -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 ();
|
||||
|
||||
|
|
|
@ -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;
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
|
|
|
@ -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 );
|
||||
|
|
|
@ -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 );
|
||||
|
||||
|
|
|
@ -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 );
|
||||
|
|
|
@ -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;
|
||||
|
|
|
@ -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" );
|
||||
|
|
Reference in New Issue