/*
===============
idSessionLocal::GetSaveGameList
===============
*/
void idSessionLocal::GetSaveGameList( idStrList &fileList, idList<fileTIME_T> &fileTimes ) {
int i;
idFileList *files;
// NOTE: no fs_game_base for savegames
idStr game = cvarSystem->GetCVarString( "fs_game" );
if( game.Length() ) {
files = fileSystem->ListFiles( "savegames", ".save", false, false, game );
} else {
files = fileSystem->ListFiles( "savegames", ".save" );
}
fileList = files->GetList();
fileSystem->FreeFileList( files );
for ( i = 0; i < fileList.Num(); i++ ) {
ID_TIME_T timeStamp;
fileSystem->ReadFile( "savegames/" + fileList[i], NULL, &timeStamp );
fileList[i].StripLeading( '/' );
fileList[i].StripFileExtension();
fileTIME_T ft;
ft.index = i;
ft.timeStamp = timeStamp;
fileTimes.Append( ft );
}
fileTimes.Sort( idListSaveGameCompare );
}
/*
================
DialogScriptEditor::InitScriptEvents
================
*/
void DialogScriptEditor::InitScriptEvents( void ) {
int index;
idParser src;
idToken token;
idStr whiteSpace;
scriptEventInfo_t info;
if( !src.LoadFile( "script/doom_events.script" ) ) {
return;
}
scriptEvents.Clear();
while( src.ReadToken( &token ) ) {
if( token == "scriptEvent" ) {
src.GetLastWhiteSpace( whiteSpace );
index = whiteSpace.Find( "//" );
if( index != -1 ) {
info.help = whiteSpace.Right( whiteSpace.Length() - index );
info.help.Remove( '\r' );
info.help.Replace( "\n", "\r\n" );
} else {
info.help = "";
}
src.ExpectTokenType( TT_NAME, 0, &token );
info.parms = token;
src.ExpectTokenType( TT_NAME, 0, &token );
info.name = token;
src.ExpectTokenString( "(" );
info.parms += " " + info.name + "(";
while( src.ReadToken( &token ) && token != ";" ) {
info.parms.Append( " " + token );
}
scriptEvents.Append( info );
}
}
}
/*
================
idAASFileLocal::ParseIndex
================
*/
bool idAASFileLocal::ParseIndex( idLexer &src, idList<aasIndex_t> &indexes )
{
int numIndexes, i;
aasIndex_t index;
numIndexes = src.ParseInt();
indexes.Resize( numIndexes );
if ( !src.ExpectTokenString( "{" ) )
{
return false;
}
for ( i = 0; i < numIndexes; i++ )
{
src.ParseInt();
src.ExpectTokenString( "(" );
index = src.ParseInt();
src.ExpectTokenString( ")" );
indexes.Append( index );
}
if ( !src.ExpectTokenString( "}" ) )
{
return false;
}
return true;
}
void PushButton( int key, bool value ) {
// So we don't keep sending the same SE_KEY message over and over again
if ( buttonStates[key] != value ) {
buttonStates[key] = value;
sysEvent_t res = { SE_KEY, key, value ? 1 : 0, 0, NULL };
event_overflow.Append(res);
}
}
clipHandle_t CM_PrecacheModel( const char* Name ) {
if ( !Name[ 0 ] ) {
common->Error( "CM_ForName: NULL name" );
}
//
// search the currently loaded models
//
for ( int i = 0; i < CMNonMapModels.Num(); i++ ) {
if ( CMNonMapModels[ i ]->Name == Name ) {
return ( i + 1 ) << CMH_NON_MAP_SHIFT;
}
}
//
// load the file
//
idList<quint8> Buffer;
if ( FS_ReadFile( Name, Buffer ) <= 0 ) {
common->Error( "CM_PrecacheModel: %s not found", Name );
}
// call the apropriate loader
switch ( LittleLong( *( unsigned* )Buffer.Ptr() ) ) {
case BSP29_VERSION:
{
QClipMap* LoadCMap = CM_CreateQClipMap29();
CMNonMapModels.Append( LoadCMap );
LoadCMap->LoadMap( Name, Buffer );
if ( LoadCMap->GetNumInlineModels() > 1 ) {
common->Printf( "Non-map BSP models are not supposed to have submodels\n" );
}
break;
}
default:
{
QClipMapNonMap* LoadCMap = new QClipMapNonMap;
CMNonMapModels.Append( LoadCMap );
LoadCMap->LoadMap( Name, Buffer );
}
}
return CMNonMapModels.Num() << CMH_NON_MAP_SHIFT;
}
/*
========================
ParseInOutStruct
========================
*/
void ParseInOutStruct( idLexer & src, int attribType, idList< inOutVariable_t > & inOutVars ) {
src.ExpectTokenString( "{" );
while( !src.CheckTokenString( "}" ) ) {
inOutVariable_t var;
idToken token;
src.ReadToken( &token );
var.type = token;
src.ReadToken( &token );
var.nameCg = token;
if ( !src.CheckTokenString( ":" ) ) {
src.SkipUntilString( ";" );
continue;
}
src.ReadToken( &token );
var.nameGLSL = token;
src.ExpectTokenString( ";" );
// convert the type
for ( int i = 0; typeConversion[i].typeCG != NULL; i++ ) {
if ( var.type.Cmp( typeConversion[i].typeCG ) == 0 ) {
var.type = typeConversion[i].typeGLSL;
break;
}
}
// convert the semantic to a GLSL name
for ( int i = 0; attribsPC[i].semantic != NULL; i++ ) {
if ( ( attribsPC[i].flags & attribType ) != 0 ) {
if ( var.nameGLSL.Cmp( attribsPC[i].semantic ) == 0 ) {
var.nameGLSL = attribsPC[i].glsl;
break;
}
}
}
// check if it was defined previously
var.declareInOut = true;
for ( int i = 0; i < inOutVars.Num(); i++ ) {
if ( var.nameGLSL == inOutVars[i].nameGLSL ) {
var.declareInOut = false;
break;
}
}
inOutVars.Append( var );
}
src.ExpectTokenString( ";" );
}
/*
============
idCmdSystemLocal::BufferCommandArgs
============
*/
void idCmdSystemLocal::BufferCommandArgs( cmdExecution_t exec, const idCmdArgs &args ) {
switch ( exec ) {
case CMD_EXEC_NOW: {
ExecuteTokenizedString( args );
break;
}
case CMD_EXEC_APPEND: {
AppendCommandText( "_execTokenized\n" );
tokenizedCmds.Append( args );
break;
}
default: {
common->FatalError( "idCmdSystemLocal::BufferCommandArgs: bad exec type" );
}
}
}
/*
============
idCVarSystemLocal::SetInternal
============
*/
void idCVarSystemLocal::SetInternal( const char *name, const char *value, int flags ) {
int hash;
idInternalCVar *internal;
internal = FindInternal( name );
if ( internal ) {
internal->InternalSetString( value );
internal->flags |= flags & ~CVAR_STATIC;
internal->UpdateCheat();
} else {
internal = new idInternalCVar( name, value, flags );
hash = cvarHash.GenerateKey( internal->nameString.c_str(), false );
cvarHash.Add( hash, cvars.Append( internal ) );
}
}
/*
============
idCVarSystemLocal::Register
============
*/
void idCVarSystemLocal::Register( idCVar *cvar ) {
int hash;
idInternalCVar *internal;
cvar->SetInternalVar( cvar );
internal = FindInternal( cvar->GetName() );
if ( internal ) {
internal->Update( cvar );
} else {
internal = new idInternalCVar( cvar );
hash = cvarHash.GenerateKey( internal->nameString.c_str(), false );
cvarHash.Add( hash, cvars.Append( internal ) );
}
cvar->SetInternalVar( internal );
}
/*
===============
idClipModel::AllocTraceModel
===============
*/
int idClipModel::AllocTraceModel( const idTraceModel &trm ) {
int i, hashKey, traceModelIndex;
trmCache_t *entry;
hashKey = GetTraceModelHashKey( trm );
for( i = traceModelHash.First( hashKey ); i >= 0; i = traceModelHash.Next( i ) ) {
if( traceModelCache[i]->trm == trm ) {
traceModelCache[i]->refCount++;
return i;
}
}
entry = new trmCache_t;
entry->trm = trm;
entry->trm.GetMassProperties( 1.0f, entry->volume, entry->centerOfMass, entry->inertiaTensor );
entry->refCount = 1;
traceModelIndex = traceModelCache.Append( entry );
traceModelHash.Add( hashKey, traceModelIndex );
return traceModelIndex;
}
/*
=================
idRenderModelManagerLocal::FindSkeletalMeshes
=================
*/
void idRenderModelManagerLocal::FindSkeletalMeshes( idList<idStr> &skeletalMeshes ) {
const idDecl *decl;
skeletalMeshes.Clear();
for(int i = 0; i < declManager->GetNumDecls( DECL_MODELDEF ); i++)
{
decl = declManager->DeclByIndex( DECL_MODELDEF, i, false );
// This probley isn't the best way to do this, just check to see if the decl def has the skeletal model extension.
char *text = (char *)_alloca( decl->GetTextLength() + 1 );
decl->GetText( text );
if(!strstr(text, ".md5mesh"))
{
_resetstkoflw();
continue;
}
_resetstkoflw();
skeletalMeshes.Append( decl->GetName() );
}
}
//
// GetValidEntitiesInside()
//
void hhReactionVolume::GetValidEntitiesInside(idList<idEntity*> &outValidEnts) {
assert(GetPhysics() != NULL);
assert(flags != 0); // have to be looking for something - else whats the point?
idEntity * entityList[ MAX_GENTITIES ];
int numEnts = gameLocal.clip.EntitiesTouchingBounds(GetPhysics()->GetAbsBounds(), CONTENTS_BODY, entityList, MAX_GENTITIES);
for(int i=0;i<numEnts;i++) {
if(!entityList[i] || entityList[i]->IsHidden())
continue;
if(flags & flagPlayers && entityList[i]->IsType(hhPlayer::Type)) {
outValidEnts.Append(entityList[i]);
if(ai_debugBrain.GetInteger()) {
gameRenderWorld->DebugArrow(colorMagenta, GetOrigin(), entityList[i]->GetOrigin(), 10, 1000);
}
continue;
}
}
if(ai_debugBrain.GetInteger()) {
gameRenderWorld->DebugBounds(colorWhite, GetPhysics()->GetBounds(), GetOrigin(), 1000);
}
}
/*
============
sdStatsTracker::GetTopLifeStats
============
*/
void sdStatsTracker::GetTopLifeStats( idList< const lifeStatsData_t* >& improved,
idList< const lifeStatsData_t* >& unchanged,
idList< const lifeStatsData_t* >& worse ) const {
improved.SetNum( 0, false );
unchanged.SetNum( 0, false );
worse.SetNum( 0, false );
for( int i = 0; i < lifeStatsData.Num(); i++ ) {
const lifeStatsData_t& data = lifeStatsData[ i ];
switch ( data.newValue.GetType() ) {
case sdNetStatKeyValue::SVT_FLOAT:
case sdNetStatKeyValue::SVT_FLOAT_MAX:
if ( data.newValue.GetFloat() > data.oldValue.GetFloat() ) {
improved.Append( &data );
} else if( idMath::Fabs( data.newValue.GetFloat() - data.oldValue.GetFloat() ) < STATS_EPSILON ) {
unchanged.Append( &data );
} else {
worse.Append( &data );
}
break;
case sdNetStatKeyValue::SVT_INT:
case sdNetStatKeyValue::SVT_INT_MAX:
if ( data.newValue.GetInt() > data.oldValue.GetInt() ) {
improved.Append( &data );
} else if( data.newValue.GetInt() == data.oldValue.GetInt() ) {
unchanged.Append( &data );
} else {
worse.Append( &data );
}
break;
default:
assert( false );
break;
}
}
sdQuickSort( improved.Begin(), improved.End(), sdSortPercentageImprovement() );
}
/*
============
hhDebrisSpawner::GetNextDebrisData
============
*/
bool hhDebrisSpawner::GetNextDebrisData( idList<idStr> &entityDefs, int &count, const idKeyValue * &kv, idVec3 &origin, idAngles &angle ) {
static char debrisDef[] = "def_debris";
static char debrisKey[] = "debris";
idStr indexStr;
idStr entityDefBase;
int numDebris, minDebris, maxDebris;
origin = vec3_zero;
// Loop through looking for the next valid debris key
for ( kv = spawnArgs.MatchPrefix( debrisDef, kv );
kv && kv->GetValue().Length();
kv = spawnArgs.MatchPrefix( debrisDef, kv ) ) {
indexStr = kv->GetKey();
indexStr.Strip( debrisDef );
// Is a valid debris base And it isn't a variation. (ie, contains a .X postfix)
if ( idStr::IsNumeric( indexStr ) && indexStr.Find( '.' ) < 0 ) {
// Get Number of Debris
numDebris = -1;
if ( sourceEntity && sourceEntity->IsType( idAI::Type ) ) {
idVec3 bonePos;
idMat3 boneAxis;
idStr bone = spawnArgs.GetString( va( "%s%s%s", debrisKey, "_bone", ( const char * ) indexStr ) );
if( !bone.IsEmpty() ) {
static_cast<idAI*>(sourceEntity)->GetJointWorldTransform( bone.c_str(), bonePos, boneAxis );
origin = bonePos;
angle = spawnArgs.GetAngles( va( "%s%s%s", debrisKey, "_angle", ( const char * ) indexStr ) );
}
}
if ( !spawnArgs.GetInt( va( "%s%s%s", debrisKey, "_num",
( const char * ) indexStr ),
"-1", numDebris ) || numDebris < 0 ) {
// No num found, look for min and max
if ( spawnArgs.GetInt( va( "%s%s%s", debrisKey, "_min",
( const char * ) indexStr ),
"-1", minDebris ) && minDebris >= 0 &&
spawnArgs.GetInt( va( "%s%s%s", debrisKey, "_max",
( const char * ) indexStr ),
"-1", maxDebris ) && maxDebris >= 0 ) {
numDebris =
gameLocal.random.RandomInt( ( maxDebris - minDebris ) ) + minDebris;
} //. No min/max found
} //. No num found
// No valid num found
if ( numDebris < 0 ) {
gameLocal.Warning( "ERROR: No debris num could be be found for %s%s",
( const char * ) debrisDef,
( const char * ) indexStr );
}
else { // Valid num found
const char * entityDefPrefix;
const idKeyValue * otherDefKey = NULL;
entityDefBase = kv->GetValue();
count = numDebris;
entityDefs.Append( entityDefBase );
// Find the other defs that may be there. using .X scheme
entityDefPrefix = va( "%s.", (const char *) kv->GetKey() );
// gameLocal.Printf( "Looking for %s\n", entityDefPrefix );
for ( otherDefKey = spawnArgs.MatchPrefix( entityDefPrefix, otherDefKey );
otherDefKey && otherDefKey->GetValue().Length();
otherDefKey = spawnArgs.MatchPrefix( entityDefPrefix, otherDefKey ) ) {
// gameLocal.Printf( "Would have added %s\n", (const char *) otherDefKey->GetValue() );
entityDefs.Append( otherDefKey->GetValue() );
}
return( true );
}
} //. Valid debris base
} //. debris loop
return( false );
}
static idStr R_LoadPreprocessed( const idStr& filename, idList<idStr>& previoulsyLoadedFiles, idList<idStr>& includeStack ) {
includeStack.Append( filename );
previoulsyLoadedFiles.Append( filename );
const int fileIndex = previoulsyLoadedFiles.Num() - 1;
idStr content = R_ReadFile(filename.c_str());
idStr ret;
fhStrRef ptr = fhStrRef( content.c_str(), content.Length() );
fhStrRef remaining = ptr;
int currentLine = 1;
int currentColumn = 1;
bool isLineComment = false;
for (; !ptr.IsEmpty(); ++ptr) {
if (ptr[0] == '\n') {
++currentLine;
currentColumn = 1;
isLineComment = false;
continue;
}
if (isLineComment) {
continue;
}
if (ptr.StartsWith( "//" )) {
isLineComment = true;
continue;
}
static const fhStrRef includeDirective = "#include \"";
if (currentColumn == 1 && ptr.StartsWith( includeDirective )) {
fhStrRef includeFilename = ptr.Substr( includeDirective.Length() );
for (int i = 0; i < includeFilename.Length() + 1; ++i) {
if (i == includeFilename.Length())
throw fhParseException( filename, currentLine, currentColumn, "unexpected end-of-file in preprocessor include" );
if (includeFilename[i] == '\n')
throw fhParseException( filename, currentLine, currentColumn, "unexpected end-of-line in preprocessor include" );
if (includeFilename[i] == '"') {
includeFilename = includeFilename.Substr( 0, i );
break;
}
}
if (includeFilename.IsEmpty())
throw fhParseException( filename, currentLine, currentColumn, "empty filename in preprocessor include" );
if (includeStack.FindIndex( includeFilename.ToString() ) >= 0)
throw fhParseException( filename, currentLine, currentColumn, "circular preprocessor include" );
idStr includeContent;
//try to load included shader relative to current file. If that fails try to load included shader from root directory.
try {
idStr includeFilePath;
filename.ExtractFilePath(includeFilePath);
includeFilePath.AppendPath( includeFilename.c_str(), includeFilename.Length() );
includeContent = R_LoadPreprocessed( includeFilePath, previoulsyLoadedFiles, includeStack );
ret.Append( remaining.c_str(), ptr.c_str() - remaining.c_str() );
ret.Append( includeContent );
//ret.Append( "\n#line " + toString( currentLine + 1 ) + " \"" + filename + "\"" );
} catch (const fhFileNotFoundException& e) {
try {
includeContent = R_LoadPreprocessed( includeFilename.ToString(), previoulsyLoadedFiles, includeStack );
ret.Append( remaining.c_str(), ptr.c_str() - remaining.c_str() );
ret.Append( includeContent );
//ret.append( "\n#line " + ToString( currentLine + 1 ) + " \"" + filename + "\"" );
} catch (const fhFileNotFoundException& e) {
throw fhParseException( filename, currentLine, currentColumn, idStr( "include file not found: " ) + includeFilename.ToString() );
}
}
//skip rest of the line
while (!ptr.IsEmpty() && ptr[0] != '\n') {
++ptr;
}
++currentLine;
currentColumn = 1;
remaining = ptr;
continue;
}
currentColumn++;
}
ret.Append( remaining.ToString() );
includeStack.RemoveIndex(includeStack.Num() - 1);
return ret;
}
/*
================================================================================================
idRenderProgManager::LoadGLSLShader
================================================================================================
*/
GLuint idRenderProgManager::LoadGLSLShader( GLenum target, const char * name, idList<int> & uniforms ) {
idStr inFile;
idStr outFileHLSL;
idStr outFileGLSL;
idStr outFileUniforms;
inFile.Format( "renderprogs\\%s", name );
inFile.StripFileExtension();
outFileHLSL.Format( "renderprogs\\glsl\\%s", name );
outFileHLSL.StripFileExtension();
outFileGLSL.Format( "renderprogs\\glsl\\%s", name );
outFileGLSL.StripFileExtension();
outFileUniforms.Format( "renderprogs\\glsl\\%s", name );
outFileUniforms.StripFileExtension();
if ( target == GL_FRAGMENT_SHADER ) {
inFile += ".pixel";
outFileHLSL += "_fragment.hlsl";
outFileGLSL += "_fragment.glsl";
outFileUniforms += "_fragment.uniforms";
} else {
inFile += ".vertex";
outFileHLSL += "_vertex.hlsl";
outFileGLSL += "_vertex.glsl";
outFileUniforms += "_vertex.uniforms";
}
// first check whether we already have a valid GLSL file and compare it to the hlsl timestamp;
ID_TIME_T hlslTimeStamp;
int hlslFileLength = fileSystem->ReadFile( inFile.c_str(), NULL, &hlslTimeStamp );
ID_TIME_T glslTimeStamp;
int glslFileLength = fileSystem->ReadFile( outFileGLSL.c_str(), NULL, &glslTimeStamp );
// if the glsl file doesn't exist or we have a newer HLSL file we need to recreate the glsl file.
idStr programGLSL;
idStr programUniforms;
if ( ( glslFileLength <= 0 ) || ( hlslTimeStamp > glslTimeStamp ) ) {
if ( hlslFileLength <= 0 ) {
// hlsl file doesn't even exist bail out
return false;
}
void * hlslFileBuffer = NULL;
int len = fileSystem->ReadFile( inFile.c_str(), &hlslFileBuffer );
if ( len <= 0 ) {
return false;
}
idStr hlslCode( ( const char* ) hlslFileBuffer );
idStr programHLSL = StripDeadCode( hlslCode, inFile );
programGLSL = ConvertCG2GLSL( programHLSL, inFile, target == GL_VERTEX_SHADER, programUniforms );
fileSystem->WriteFile( outFileHLSL, programHLSL.c_str(), programHLSL.Length(), "fs_basepath" );
fileSystem->WriteFile( outFileGLSL, programGLSL.c_str(), programGLSL.Length(), "fs_basepath" );
if ( r_useUniformArrays.GetBool() ) {
fileSystem->WriteFile( outFileUniforms, programUniforms.c_str(), programUniforms.Length(), "fs_basepath" );
}
} else {
// read in the glsl file
void * fileBufferGLSL = NULL;
int lengthGLSL = fileSystem->ReadFile( outFileGLSL.c_str(), &fileBufferGLSL );
if ( lengthGLSL <= 0 ) {
idLib::Error( "GLSL file %s could not be loaded and may be corrupt", outFileGLSL.c_str() );
}
programGLSL = ( const char * ) fileBufferGLSL;
Mem_Free( fileBufferGLSL );
if ( r_useUniformArrays.GetBool() ) {
// read in the uniform file
void * fileBufferUniforms = NULL;
int lengthUniforms = fileSystem->ReadFile( outFileUniforms.c_str(), &fileBufferUniforms );
if ( lengthUniforms <= 0 ) {
idLib::Error( "uniform file %s could not be loaded and may be corrupt", outFileUniforms.c_str() );
}
programUniforms = ( const char* ) fileBufferUniforms;
Mem_Free( fileBufferUniforms );
}
}
// find the uniforms locations in either the vertex or fragment uniform array
if ( r_useUniformArrays.GetBool() ) {
uniforms.Clear();
idLexer src( programUniforms, programUniforms.Length(), "uniforms" );
idToken token;
while ( src.ReadToken( &token ) ) {
int index = -1;
for ( int i = 0; i < RENDERPARM_TOTAL && index == -1; i++ ) {
const char * parmName = GetGLSLParmName( i );
if ( token == parmName ) {
index = i;
}
}
for ( int i = 0; i < MAX_GLSL_USER_PARMS && index == -1; i++ ) {
const char * parmName = GetGLSLParmName( RENDERPARM_USER + i );
if ( token == parmName ) {
index = RENDERPARM_USER + i;
}
}
if ( index == -1 ) {
idLib::Error( "couldn't find uniform %s for %s", token.c_str(), outFileGLSL.c_str() );
}
uniforms.Append( index );
}
}
// create and compile the shader
const GLuint shader = qglCreateShader( target );
if ( shader ) {
const char * source[1] = { programGLSL.c_str() };
qglShaderSource( shader, 1, source, NULL );
qglCompileShader( shader );
int infologLength = 0;
qglGetShaderiv( shader, GL_INFO_LOG_LENGTH, &infologLength );
if ( infologLength > 1 ) {
idTempArray<char> infoLog( infologLength );
int charsWritten = 0;
qglGetShaderInfoLog( shader, infologLength, &charsWritten, infoLog.Ptr() );
// catch the strings the ATI and Intel drivers output on success
if ( strstr( infoLog.Ptr(), "successfully compiled to run on hardware" ) != NULL ||
strstr( infoLog.Ptr(), "No errors." ) != NULL ) {
//idLib::Printf( "%s program %s from %s compiled to run on hardware\n", typeName, GetName(), GetFileName() );
} else if ( r_displayGLSLCompilerMessages.GetBool() ) {
idLib::Printf( "While compiling %s program %s\n", ( target == GL_FRAGMENT_SHADER ) ? "fragment" : "vertex" , inFile.c_str() );
const char separator = '\n';
idList<idStr> lines;
lines.Clear();
idStr source( programGLSL );
lines.Append( source );
for ( int index = 0, ofs = lines[index].Find( separator ); ofs != -1; index++, ofs = lines[index].Find( separator ) ) {
lines.Append( lines[index].c_str() + ofs + 1 );
lines[index].CapLength( ofs );
}
idLib::Printf( "-----------------\n" );
for ( int i = 0; i < lines.Num(); i++ ) {
idLib::Printf( "%3d: %s\n", i+1, lines[i].c_str() );
}
idLib::Printf( "-----------------\n" );
idLib::Printf( "%s\n", infoLog.Ptr() );
}
}
GLint compiled = GL_FALSE;
qglGetShaderiv( shader, GL_COMPILE_STATUS, &compiled );
if ( compiled == GL_FALSE ) {
qglDeleteShader( shader );
return INVALID_PROGID;
}
}
return shader;
}
/*
================
Sys_GetEvent
================
*/
sysEvent_t Sys_GetEvent() {
SDL_Event ev;
sysEvent_t res = { };
byte key;
static const sysEvent_t res_none = { SE_NONE, 0, 0, 0, NULL };
// process any overflow.
if (event_overflow.Num() > 0)
{
res = event_overflow[0];
event_overflow.RemoveIndex(0);
return res;
}
// overflow text input.
static char *s = NULL;
static size_t s_pos = 0;
if (s) {
res.evType = SE_CHAR;
res.evValue = s[s_pos];
s_pos++;
if (!s[s_pos]) {
free(s);
s = NULL;
s_pos = 0;
}
return res;
}
static byte c = 0;
if (c) {
res.evType = SE_CHAR;
res.evValue = c;
c = 0;
return res;
}
bool getNext = true;
while (SDL_PollEvent(&ev) && getNext) {
getNext = false;
switch (ev.type) {
#ifdef __WINDOWS__ // on windows we need to grab the hwnd.
case SDL_SYSWMEVENT:
if (win32.hWnd == NULL)
{
win32.hWnd = ev.syswm.msg->msg.win.hwnd;
}
getNext = true; // try to get a decent event.
break;
#endif
case SDL_WINDOWEVENT:
switch (ev.window.event) {
case SDL_WINDOWEVENT_FOCUS_GAINED: {
// unset modifier, in case alt-tab was used to leave window and ALT is still set
// as that can cause fullscreen-toggling when pressing enter...
SDL_Keymod currentmod = SDL_GetModState();
int newmod = KMOD_NONE;
if (currentmod & KMOD_CAPS) // preserve capslock
newmod |= KMOD_CAPS;
SDL_SetModState((SDL_Keymod)newmod);
} // new context because visual studio complains about newmod and currentmod not initialized because of the case SDL_WINDOWEVENT_FOCUS_LOST
GLimp_GrabInput(GRAB_ENABLE | GRAB_REENABLE | GRAB_HIDECURSOR);
break;
case SDL_WINDOWEVENT_FOCUS_LOST:
GLimp_GrabInput(0);
break;
}
return res_none;
case SDL_KEYDOWN:
if (ev.key.keysym.sym == SDLK_RETURN && (ev.key.keysym.mod & KMOD_ALT) > 0) {
cvarSystem->SetCVarBool("r_fullscreen", !renderSystem->IsFullScreen());
PushConsoleEvent("vid_restart");
return res_none;
}
// fall through
case SDL_KEYUP:
key = mapkey(ev.key.keysym.sym);
if(!key) {
if (ev.key.keysym.scancode == SDL_SCANCODE_GRAVE) {
key = Sys_GetConsoleKey(true);
} else {
if (ev.type == SDL_KEYDOWN) {
common->Warning("unmapped SDL key %d", ev.key.keysym.sym);
getNext = true; // try to get a decent event.
break;
}
}
}
res.evType = SE_KEY;
res.evValue = key;
res.evValue2 = ev.key.state == SDL_PRESSED ? 1 : 0;
kbd_polls.Append(kbd_poll_t(key, ev.key.state == SDL_PRESSED));
if ( (key == K_BACKSPACE && ev.key.state == SDL_PRESSED)
|| SDL_GetEventState(SDL_TEXTINPUT) == SDL_DISABLE)
c = key;
return res;
case SDL_TEXTINPUT:
if (ev.text.text && *ev.text.text) {
res.evType = SE_CHAR;
res.evValue = *ev.text.text;
// if there are more characters hold onto them for later events.
if (ev.text.text[1] != 0)
s = strdup(ev.text.text+1);
return res;
}
getNext = true; // try to get a decent event.
break;
case SDL_MOUSEMOTION:
if (g_inputGrabbed)
{
res.evType = SE_MOUSE;
res.evValue = ev.motion.xrel;
res.evValue2 = ev.motion.yrel;
mouse_polls.Append(mouse_poll_t(M_DELTAX, ev.motion.xrel));
mouse_polls.Append(mouse_poll_t(M_DELTAY, ev.motion.yrel));
return res;
}
getNext = true;
break;
case SDL_MOUSEWHEEL:
if (g_inputGrabbed)
{
res.evType = SE_KEY;
if (ev.wheel.y > 0) {
res.evValue = K_MWHEELUP;
mouse_polls.Append(mouse_poll_t(M_DELTAZ, 1));
} else {
res.evValue = K_MWHEELDOWN;
mouse_polls.Append(mouse_poll_t(M_DELTAZ, -1));
}
res.evValue2 = 1;
return res;
}
getNext = true;
break;
case SDL_MOUSEBUTTONDOWN:
case SDL_MOUSEBUTTONUP:
if (g_inputGrabbed)
{
res.evType = SE_KEY;
switch (ev.button.button) {
case SDL_BUTTON_LEFT:
res.evValue = K_MOUSE1;
mouse_polls.Append(mouse_poll_t(M_ACTION1, ev.button.state == SDL_PRESSED ? 1 : 0));
break;
case SDL_BUTTON_MIDDLE:
res.evValue = K_MOUSE3;
mouse_polls.Append(mouse_poll_t(M_ACTION3, ev.button.state == SDL_PRESSED ? 1 : 0));
break;
case SDL_BUTTON_RIGHT:
res.evValue = K_MOUSE2;
mouse_polls.Append(mouse_poll_t(M_ACTION2, ev.button.state == SDL_PRESSED ? 1 : 0));
break;
}
res.evValue2 = ev.button.state == SDL_PRESSED ? 1 : 0;
return res;
}
getNext = true;
break;
case SDL_CONTROLLERBUTTONDOWN:
case SDL_CONTROLLERBUTTONUP:
{
sys_jEvents jEvent = mapjoybutton( (SDL_GameControllerButton)ev.cbutton.button);
joystick_polls.Append(joystick_poll_t( jEvent,
ev.cbutton.state == SDL_PRESSED ? 1 : 0) );
res.evType = SE_KEY;
res.evValue2 = ev.cbutton.state == SDL_PRESSED ? 1 : 0;
if ( ( jEvent >= J_ACTION1 ) && ( jEvent <= J_ACTION_MAX ) ) {
res.evValue = K_JOY1 + ( jEvent - J_ACTION1 );
return res;
} else if ( ( jEvent >= J_DPAD_UP ) && ( jEvent <= J_DPAD_RIGHT ) ) {
res.evValue = K_JOY_DPAD_UP + ( jEvent - J_DPAD_UP );
return res;
}
getNext = true; // try to get a decent event.
}
break;
case SDL_CONTROLLERAXISMOTION:
{
const int range = 16384;
sys_jEvents jEvent = mapjoyaxis( (SDL_GameControllerAxis)ev.caxis.axis);
joystick_polls.Append(joystick_poll_t( jEvent, ev.caxis.value) );
if ( jEvent == J_AXIS_LEFT_X ) {
PushButton( K_JOY_STICK1_LEFT, ( ev.caxis.value < -range ) );
PushButton( K_JOY_STICK1_RIGHT, ( ev.caxis.value > range ) );
} else if ( jEvent == J_AXIS_LEFT_Y ) {
PushButton( K_JOY_STICK1_UP, ( ev.caxis.value < -range ) );
PushButton( K_JOY_STICK1_DOWN, ( ev.caxis.value > range ) );
} else if ( jEvent == J_AXIS_RIGHT_X ) {
PushButton( K_JOY_STICK2_LEFT, ( ev.caxis.value < -range ) );
PushButton( K_JOY_STICK2_RIGHT, ( ev.caxis.value > range ) );
} else if ( jEvent == J_AXIS_RIGHT_Y ) {
PushButton( K_JOY_STICK2_UP, ( ev.caxis.value < -range ) );
PushButton( K_JOY_STICK2_DOWN, ( ev.caxis.value > range ) );
} else if ( jEvent == J_AXIS_LEFT_TRIG ) {
PushButton( K_JOY_TRIGGER1, ( ev.caxis.value > range ) );
} else if ( jEvent == J_AXIS_RIGHT_TRIG ) {
PushButton( K_JOY_TRIGGER2, ( ev.caxis.value > range ) );
}
if ( jEvent >= J_AXIS_MIN && jEvent <= J_AXIS_MAX ) {
int axis = jEvent - J_AXIS_MIN;
int percent = ( ev.caxis.value * 16 ) / range;
if ( joyAxis[axis] != percent ) {
joyAxis[axis] = percent;
res.evType = SE_JOYSTICK;
res.evValue = axis;
res.evValue2 = percent;
return res;
}
}
getNext = true; // try to get a decent event.
}
break;
case SDL_JOYDEVICEADDED:
SDL_GameControllerOpen( ev.jdevice.which );
// TODO: hot swapping maybe.
//lbOnControllerPlugIn(event.jdevice.which);
break;
case SDL_JOYDEVICEREMOVED:
// TODO: hot swapping maybe.
//lbOnControllerUnPlug(event.jdevice.which);
break;
case SDL_QUIT:
PushConsoleEvent("quit");
return res_none;
case SDL_USEREVENT:
switch (ev.user.code) {
case SE_CONSOLE:
res.evType = SE_CONSOLE;
res.evPtrLength = (intptr_t)ev.user.data1;
res.evPtr = ev.user.data2;
return res;
default:
common->Warning("unknown user event %u", ev.user.code);
getNext = true; // try to get a decent event.
break;
}
default:
getNext = true; // try to get a decent event.
break;
}
}
return res_none;
}
/*
========================
idConsoleLocal::CreateGraph
========================
*/
idDebugGraph* idConsoleLocal::CreateGraph( int numItems )
{
idDebugGraph* graph = new( TAG_SYSTEM ) idDebugGraph( numItems );
debugGraphs.Append( graph );
return graph;
}
/*
================
Sys_GetEvent
================
*/
sysEvent_t Sys_GetEvent() {
SDL_Event ev;
sysEvent_t res = { };
byte key;
static const sysEvent_t res_none = { SE_NONE, 0, 0, 0, NULL };
#if SDL_VERSION_ATLEAST(2, 0, 0)
static char s[SDL_TEXTINPUTEVENT_TEXT_SIZE] = {0};
static size_t s_pos = 0;
if (s[0] != '\0') {
res.evType = SE_CHAR;
res.evValue = s[s_pos];
++s_pos;
if (!s[s_pos] || s_pos == SDL_TEXTINPUTEVENT_TEXT_SIZE) {
memset(s, 0, sizeof(s));
s_pos = 0;
}
return res;
}
#endif
static byte c = 0;
if (c) {
res.evType = SE_CHAR;
res.evValue = c;
c = 0;
return res;
}
// loop until there is an event we care about (will return then) or no more events
while(SDL_PollEvent(&ev)) {
switch (ev.type) {
#if SDL_VERSION_ATLEAST(2, 0, 0)
case SDL_WINDOWEVENT:
switch (ev.window.event) {
case SDL_WINDOWEVENT_FOCUS_GAINED: {
// unset modifier, in case alt-tab was used to leave window and ALT is still set
// as that can cause fullscreen-toggling when pressing enter...
SDL_Keymod currentmod = SDL_GetModState();
int newmod = KMOD_NONE;
if (currentmod & KMOD_CAPS) // preserve capslock
newmod |= KMOD_CAPS;
SDL_SetModState((SDL_Keymod)newmod);
} // new context because visual studio complains about newmod and currentmod not initialized because of the case SDL_WINDOWEVENT_FOCUS_LOST
GLimp_GrabInput(GRAB_ENABLE | GRAB_REENABLE | GRAB_HIDECURSOR);
break;
case SDL_WINDOWEVENT_FOCUS_LOST:
GLimp_GrabInput(0);
break;
}
continue; // handle next event
#else
case SDL_ACTIVEEVENT:
{
int flags = 0;
if (ev.active.gain) {
flags = GRAB_ENABLE | GRAB_REENABLE | GRAB_HIDECURSOR;
// unset modifier, in case alt-tab was used to leave window and ALT is still set
// as that can cause fullscreen-toggling when pressing enter...
SDLMod currentmod = SDL_GetModState();
int newmod = KMOD_NONE;
if (currentmod & KMOD_CAPS) // preserve capslock
newmod |= KMOD_CAPS;
SDL_SetModState((SDLMod)newmod);
}
GLimp_GrabInput(flags);
}
continue; // handle next event
case SDL_VIDEOEXPOSE:
continue; // handle next event
#endif
case SDL_KEYDOWN:
if (ev.key.keysym.sym == SDLK_RETURN && (ev.key.keysym.mod & KMOD_ALT) > 0) {
cvarSystem->SetCVarBool("r_fullscreen", !renderSystem->IsFullScreen());
PushConsoleEvent("vid_restart");
return res_none;
}
// fall through
case SDL_KEYUP:
key = mapkey(ev.key.keysym.sym);
#if !SDL_VERSION_ATLEAST(2, 0, 0)
if (!key) {
unsigned char c;
// check if its an unmapped console key
if (ev.key.keysym.unicode == (c = Sys_GetConsoleKey(false))) {
key = c;
} else if (ev.key.keysym.unicode == (c = Sys_GetConsoleKey(true))) {
key = c;
} else {
if (ev.type == SDL_KEYDOWN)
common->Warning("unmapped SDL key %d (0x%x)", ev.key.keysym.sym, ev.key.keysym.unicode);
continue; // handle next event
}
}
#else
if(!key) {
if (ev.key.keysym.scancode == SDL_SCANCODE_GRAVE) { // TODO: always do this check?
key = Sys_GetConsoleKey(true);
} else {
if (ev.type == SDL_KEYDOWN) {
common->Warning("unmapped SDL key %d", ev.key.keysym.sym);
}
continue; // handle next event
}
}
#endif
res.evType = SE_KEY;
res.evValue = key;
res.evValue2 = ev.key.state == SDL_PRESSED ? 1 : 0;
kbd_polls.Append(kbd_poll_t(key, ev.key.state == SDL_PRESSED));
#if SDL_VERSION_ATLEAST(2, 0, 0)
if (key == K_BACKSPACE && ev.key.state == SDL_PRESSED)
c = key;
#else
if (ev.key.state == SDL_PRESSED && (ev.key.keysym.unicode & 0xff00) == 0)
c = ev.key.keysym.unicode & 0xff;
#endif
return res;
#if SDL_VERSION_ATLEAST(2, 0, 0)
case SDL_TEXTINPUT:
if (ev.text.text[0]) {
res.evType = SE_CHAR;
res.evValue = ev.text.text[0];
if (ev.text.text[1] != '\0')
{
memcpy(s, ev.text.text, SDL_TEXTINPUTEVENT_TEXT_SIZE);
s_pos = 1; // pos 0 is returned
}
return res;
}
continue; // handle next event
#endif
case SDL_MOUSEMOTION:
res.evType = SE_MOUSE;
res.evValue = ev.motion.xrel;
res.evValue2 = ev.motion.yrel;
mouse_polls.Append(mouse_poll_t(M_DELTAX, ev.motion.xrel));
mouse_polls.Append(mouse_poll_t(M_DELTAY, ev.motion.yrel));
return res;
#if SDL_VERSION_ATLEAST(2, 0, 0)
case SDL_MOUSEWHEEL:
res.evType = SE_KEY;
if (ev.wheel.y > 0) {
res.evValue = K_MWHEELUP;
mouse_polls.Append(mouse_poll_t(M_DELTAZ, 1));
} else {
res.evValue = K_MWHEELDOWN;
mouse_polls.Append(mouse_poll_t(M_DELTAZ, -1));
}
res.evValue2 = 1;
return res;
#endif
case SDL_MOUSEBUTTONDOWN:
case SDL_MOUSEBUTTONUP:
res.evType = SE_KEY;
switch (ev.button.button) {
case SDL_BUTTON_LEFT:
res.evValue = K_MOUSE1;
mouse_polls.Append(mouse_poll_t(M_ACTION1, ev.button.state == SDL_PRESSED ? 1 : 0));
break;
case SDL_BUTTON_MIDDLE:
res.evValue = K_MOUSE3;
mouse_polls.Append(mouse_poll_t(M_ACTION3, ev.button.state == SDL_PRESSED ? 1 : 0));
break;
case SDL_BUTTON_RIGHT:
res.evValue = K_MOUSE2;
mouse_polls.Append(mouse_poll_t(M_ACTION2, ev.button.state == SDL_PRESSED ? 1 : 0));
break;
#if !SDL_VERSION_ATLEAST(2, 0, 0)
case SDL_BUTTON_WHEELUP:
res.evValue = K_MWHEELUP;
if (ev.button.state == SDL_PRESSED)
mouse_polls.Append(mouse_poll_t(M_DELTAZ, 1));
break;
case SDL_BUTTON_WHEELDOWN:
res.evValue = K_MWHEELDOWN;
if (ev.button.state == SDL_PRESSED)
mouse_polls.Append(mouse_poll_t(M_DELTAZ, -1));
break;
#endif
}
res.evValue2 = ev.button.state == SDL_PRESSED ? 1 : 0;
return res;
case SDL_QUIT:
PushConsoleEvent("quit");
return res_none;
case SDL_USEREVENT:
switch (ev.user.code) {
case SE_CONSOLE:
res.evType = SE_CONSOLE;
res.evPtrLength = (intptr_t)ev.user.data1;
res.evPtr = ev.user.data2;
return res;
default:
common->Warning("unknown user event %u", ev.user.code);
continue; // handle next event
}
default:
common->Warning("unknown event %u", ev.type);
continue; // handle next event
}
}
return res_none;
}
/*
================
Sys_GetEvent
================
*/
sysEvent_t Sys_GetEvent() {
SDL_Event ev;
sysEvent_t res = { };
byte key;
static const sysEvent_t res_none = { SE_NONE, 0, 0, 0, NULL };
static char *s = NULL;
static size_t s_pos = 0;
if (s) {
res.evType = SE_CHAR;
res.evValue = s[s_pos];
s_pos++;
if (!s[s_pos]) {
free(s);
s = NULL;
s_pos = 0;
}
return res;
}
static byte c = 0;
if (c) {
res.evType = SE_CHAR;
res.evValue = c;
c = 0;
return res;
}
if (SDL_PollEvent(&ev)) {
switch (ev.type) {
case SDL_WINDOWEVENT:
switch (ev.window.event) {
case SDL_WINDOWEVENT_SHOWN:
SDL_Log("Window %d shown", ev.window.windowID);
break;
case SDL_WINDOWEVENT_HIDDEN:
SDL_Log("Window %d hidden", ev.window.windowID);
break;
case SDL_WINDOWEVENT_EXPOSED:
SDL_Log("Window %d exposed", ev.window.windowID);
break;
case SDL_WINDOWEVENT_MOVED:
SDL_Log("Window %d moved to %d,%d",
ev.window.windowID, ev.window.data1,
ev.window.data2);
break;
case SDL_WINDOWEVENT_RESIZED:
SDL_Log("Window %d resized to %dx%d",
ev.window.windowID, ev.window.data1,
ev.window.data2);
break;
case SDL_WINDOWEVENT_MINIMIZED:
SDL_Log("Window %d minimized", ev.window.windowID);
break;
case SDL_WINDOWEVENT_MAXIMIZED:
SDL_Log("Window %d maximized", ev.window.windowID);
break;
case SDL_WINDOWEVENT_RESTORED:
SDL_Log("Window %d restored", ev.window.windowID);
break;
case SDL_WINDOWEVENT_ENTER:
SDL_Log("Mouse entered window %d",
ev.window.windowID);
break;
case SDL_WINDOWEVENT_LEAVE:
SDL_Log("Mouse left window %d", ev.window.windowID);
break;
case SDL_WINDOWEVENT_FOCUS_GAINED:
SDL_Log("Window %d gained keyboard focus",
ev.window.windowID);
cvarSystem->SetCVarBool( "com_pause", false );
GLimp_GrabInput(GRAB_ENABLE | GRAB_REENABLE | GRAB_HIDECURSOR);
break;
case SDL_WINDOWEVENT_FOCUS_LOST:
SDL_Log("Window %d lost keyboard focus",
ev.window.windowID);
cvarSystem->SetCVarBool( "com_pause", true );
GLimp_GrabInput(0);
break;
case SDL_WINDOWEVENT_CLOSE:
SDL_Log("Window %d closed", ev.window.windowID);
break;
default:
SDL_Log("Window %d got unknown event %d",
ev.window.windowID, ev.window.event);
break;
}
return res_none;
case SDL_KEYDOWN:
if (ev.key.keysym.sym == SDLK_RETURN && (ev.key.keysym.mod & KMOD_ALT) > 0) {
cvarSystem->SetCVarBool("r_fullscreen", !renderSystem->IsFullScreen());
PushConsoleEvent("vid_restart");
/*
* FIXME vid_restart
*/
return res_none;
}
// fall through
case SDL_KEYUP:
key = mapkey(ev.key.keysym.sym);
if(!key) {
if (ev.key.keysym.scancode == SDL_SCANCODE_GRAVE) {
key = Sys_GetConsoleKey(true);
} else {
if (ev.type == SDL_KEYDOWN) {
common->Warning("unmapped SDL key %d", ev.key.keysym.sym);
return res_none;
}
}
}
res.evType = SE_KEY;
res.evValue = key;
res.evValue2 = ev.key.state == SDL_PRESSED ? 1 : 0;
kbd_polls.Append(kbd_poll_t(key, ev.key.state == SDL_PRESSED));
if (key == K_BACKSPACE && ev.key.state == SDL_PRESSED)
c = key;
return res;
case SDL_TEXTINPUT:
if (ev.text.text && *ev.text.text) {
if (!ev.text.text[1])
c = *ev.text.text;
else
s = strdup(ev.text.text);
}
return res_none;
case SDL_TEXTEDITING:
SDL_StartTextInput();
SDL_Log("SDL_TextEditingEvent");
//SDL_StopTextInput();
break;
case SDL_SYSWMEVENT:
SDL_Log("SDL_SYSWMEVENT");
break;
case SDL_CLIPBOARDUPDATE:
SDL_Log("SDL_CLIPBOARDUPDATE");
break;
case SDL_MOUSEMOTION:
res.evType = SE_MOUSE;
res.evValue = ev.motion.xrel;
res.evValue2 = ev.motion.yrel;
mouse_polls.Append(mouse_poll_t(M_DELTAX, ev.motion.xrel));
mouse_polls.Append(mouse_poll_t(M_DELTAY, ev.motion.yrel));
return res;
case SDL_MOUSEWHEEL:
res.evType = SE_KEY;
if (ev.wheel.y > 0) {
res.evValue = K_MWHEELUP;
mouse_polls.Append(mouse_poll_t(M_DELTAZ, 1));
} else {
res.evValue = K_MWHEELDOWN;
mouse_polls.Append(mouse_poll_t(M_DELTAZ, -1));
}
res.evValue2 = 1;
return res;
case SDL_MOUSEBUTTONDOWN:
case SDL_MOUSEBUTTONUP:
res.evType = SE_KEY;
switch (ev.button.button) {
case SDL_BUTTON_LEFT:
res.evValue = K_MOUSE1;
mouse_polls.Append(mouse_poll_t(M_ACTION1, ev.button.state == SDL_PRESSED ? 1 : 0));
break;
case SDL_BUTTON_MIDDLE:
res.evValue = K_MOUSE3;
mouse_polls.Append(mouse_poll_t(M_ACTION3, ev.button.state == SDL_PRESSED ? 1 : 0));
break;
case SDL_BUTTON_RIGHT:
res.evValue = K_MOUSE2;
mouse_polls.Append(mouse_poll_t(M_ACTION2, ev.button.state == SDL_PRESSED ? 1 : 0));
break;
}
res.evValue2 = ev.button.state == SDL_PRESSED ? 1 : 0;
return res;
case SDL_QUIT:
PushConsoleEvent("quit");
SDL_Quit();
return res_none;
case SDL_USEREVENT:
switch (ev.user.code) {
case SE_CONSOLE:
res.evType = SE_CONSOLE;
res.evPtrLength = (intptr_t)ev.user.data1;
res.evPtr = ev.user.data2;
return res;
default:
common->Warning("unknown user event %u", ev.user.code);
return res_none;
}
default:
common->Warning("unknown event %u", ev.type);
return res_none;
}
}
return res_none;
}
void Select_AutoCaulk()
{
/*Sys_Printf*/common->Printf("Caulking...\n");
FacesToCaulk.Clear();
int iSystemBrushesSkipped = 0;
face_t *pSelectedFace;
brush_t *next;
for (brush_t *pSelectedBrush = selected_brushes.next ; pSelectedBrush != &selected_brushes ; pSelectedBrush = next)
{
next = pSelectedBrush->next;
if (pSelectedBrush->owner->eclass->fixedsize)
continue; // apparently this means it's a model, so skip it...
// new check, we can't caulk a brush that has any "system/" faces...
//
bool bSystemFacePresent = false;
for ( pSelectedFace = pSelectedBrush->brush_faces; pSelectedFace; pSelectedFace = pSelectedFace->next)
{
if (!strnicmp(pSelectedFace->d_texture->GetName(),"system/",7))
{
bSystemFacePresent = true;
break;
}
}
if (bSystemFacePresent)
{
iSystemBrushesSkipped++;
continue; // verboten to caulk this.
}
for (int iBrushListToScan = 0; iBrushListToScan<2; iBrushListToScan++)
{
brush_t *snext;
for (brush_t *pScannedBrush = (iBrushListToScan?active_brushes.next:selected_brushes.next); pScannedBrush != (iBrushListToScan?&active_brushes:&selected_brushes) ; pScannedBrush = snext)
{
snext = pScannedBrush->next;
if ( pScannedBrush == pSelectedBrush)
continue;
if (pScannedBrush->owner->eclass->fixedsize || pScannedBrush->pPatch || pScannedBrush->hiddenBrush)
continue;
if (FilterBrush(pScannedBrush))
continue;
// idMaterial stuff no longer support this, not sure what else to do.
// Searching for other occurences of QER_NOCARVE just shows people REMing the code and ignoring ths issue...
//
// if (pScannedBrush->brush_faces->d_texture->bFromShader && (pScannedBrush->brush_faces->d_texture->TestMaterialFlag(QER_NOCARVE)))
// continue;
// basic-reject first to see if brushes can even possibly touch (coplanar counts as touching)
//
int i;
for (i=0 ; i<3 ; i++)
{
if (pSelectedBrush->mins[i] > pScannedBrush->maxs[i] ||
pSelectedBrush->maxs[i] < pScannedBrush->mins[i])
{
break;
}
}
if (i != 3)
continue; // can't be touching
// ok, now for the clever stuff, we need to detect only those faces that are both coplanar and smaller
// or equal to the face they're coplanar with...
//
for (pSelectedFace = pSelectedBrush->brush_faces; pSelectedFace; pSelectedFace = pSelectedFace->next)
{
idWinding *pSelectedWinding = pSelectedFace->face_winding;
if (!pSelectedWinding)
continue; // freed face, probably won't happen here, but who knows with this program?
// SquaredFace_t SelectedSquaredFace;
// WindingToSquaredFace( &SelectedSquaredFace, pSelectedWinding);
for (face_t *pScannedFace = pScannedBrush->brush_faces; pScannedFace; pScannedFace = pScannedFace->next)
{
// don't even try caulking against a system face, because these are often transparent and will leave holes
//
if (!strnicmp(pScannedFace->d_texture->GetName(),"system/",7))
continue;
// and don't try caulking against something inherently transparent...
//
if (pScannedFace->d_texture->TestMaterialFlag(QER_TRANS))
continue;
idWinding *pScannedWinding = pScannedFace->face_winding;
if (!pScannedWinding)
continue; // freed face, probably won't happen here, but who knows with this program?
// SquaredFace_t ScannedSquaredFace;
// WindingToSquaredFace( &ScannedSquaredFace, pScannedWinding);
/* if (VectorCompare(ScannedSquaredFace.v3NormalisedRotationVector, SelectedSquaredFace.v3NormalisedRotationVector)
&&
VectorCompare(ScannedSquaredFace.v3NormalisedElevationVector, SelectedSquaredFace.v3NormalisedElevationVector)
)
*/
{
// brush faces are in parallel planes to each other, so check that their normals
// are opposite, by adding them together and testing for zero...
// (if normals are opposite, then faces can be against/touching each other?)
//
idVec3 v3ZeroTest;
idVec3 v3Zero;v3Zero.Zero(); //static idVec3 v3Zero={0,0,0};
VectorAdd(pSelectedFace->plane.Normal(),pScannedFace->plane.Normal(),v3ZeroTest);
if (v3ZeroTest == v3Zero)
{
// planes are facing each other...
//
// coplanar? (this is some maths of Gil's, which I don't even pretend to understand)
//
float fTotalDist = 0;
for (int _i=0; _i<3; _i++)
{
fTotalDist += fabs( DotProduct(pSelectedFace->plane.Normal(),(*pSelectedWinding)[0])
-
DotProduct(pSelectedFace->plane.Normal(),(*pScannedWinding)[i])
);
}
//OutputDebugString(va("Dist = %g\n",fTotalDist));
if (fTotalDist > 0.01)
continue;
// every point in the selected face must be within (or equal to) the bounds of the
// scanned face...
//
// work out the bounds first...
//
idVec3 v3ScannedBoundsMins, v3ScannedBoundsMaxs;
ClearBounds (v3ScannedBoundsMins, v3ScannedBoundsMaxs);
int iPoint;
for (iPoint=0; iPoint<pScannedWinding->GetNumPoints(); iPoint++)
{
AddPointToBounds( (*pScannedWinding)[iPoint].ToVec3(), v3ScannedBoundsMins, v3ScannedBoundsMaxs);
}
// floor 'em... (or .001 differences mess things up...
//
FloorBounds(v3ScannedBoundsMins, v3ScannedBoundsMaxs);
// now check points from selected face...
//
bool bWithin = true;
for (iPoint=0; iPoint < pSelectedWinding->GetNumPoints(); iPoint++)
{
for (int iXYZ=0; iXYZ<3; iXYZ++)
{
float f = floor((*pSelectedWinding)[iPoint][iXYZ] + 0.5);
if (!
(
f >= v3ScannedBoundsMins[iXYZ]
&&
f <= v3ScannedBoundsMaxs[iXYZ]
)
)
{
bWithin = false;
}
}
}
if (bWithin)
{
PairBrushFace_t PairBrushFace;
PairBrushFace.pFace = pSelectedFace;
PairBrushFace.pBrush= pSelectedBrush;
FacesToCaulk.Append(PairBrushFace);
}
}
}
}
}
}
}
}
// apply caulk...
//
int iFacesCaulked = 0;
if (FacesToCaulk.Num())
{
LPCSTR psCaulkName = "textures/common/caulk";
const idMaterial *pCaulk = Texture_ForName(psCaulkName);
if (pCaulk)
{
//
// and call some other junk that Radiant wants so so we can use it later...
//
texdef_t tex;
memset (&tex, 0, sizeof(tex));
tex.scale[0] = 1;
tex.scale[1] = 1;
//tex.flags = pCaulk->flags; // field missing in Q4
//tex.value = pCaulk->value; // ditto
//tex.contents = pCaulk->contents; // ditto
tex.SetName( pCaulk->GetName() );
//Texture_SetTexture (&tex);
for (int iListEntry = 0; iListEntry < FacesToCaulk.Num(); iListEntry++)
{
PairBrushFace_t &PairBrushFace = FacesToCaulk[iListEntry];
face_t *pFace = PairBrushFace.pFace;
brush_t*pBrush= PairBrushFace.pBrush;
pFace->d_texture = pCaulk;
pFace->texdef = tex;
Face_FitTexture(pFace, 1, 1); // this doesn't work here for some reason... duh.
Brush_Build(pBrush);
iFacesCaulked++;
}
}
else
{
/*Sys_Printf*/common->Printf(" Unable to locate caulk texture at: \"%s\"!\n",psCaulkName);
}
}
/*Sys_Printf*/common->Printf("( %d faces caulked )\n",iFacesCaulked);
if (iSystemBrushesSkipped)
{
/*Sys_Printf*/common->Printf("( %d system-faced brushes skipped )\n",iSystemBrushesSkipped);
}
Sys_UpdateWindows (W_ALL);
}
/*
========================
idLobbyBackendDirect::GetSearchResults
========================
*/
void idLobbyBackendDirect::GetSearchResults( idList< lobbyConnectInfo_t >& searchResults )
{
lobbyConnectInfo_t fakeResult;
searchResults.Clear();
searchResults.Append( fakeResult );
}
/*
================
Sys_GetEvent
================
*/
sysEvent_t Sys_GetEvent() {
SDL_Event ev;
sysEvent_t res = { };
byte key;
static const sysEvent_t res_none = { SE_NONE, 0, 0, 0, NULL };
static byte c = 0;
if (c) {
res.evType = SE_CHAR;
res.evValue = c;
c = 0;
return res;
}
if (SDL_PollEvent(&ev)) {
switch (ev.type) {
case SDL_ACTIVEEVENT:
GrabInput(grabbed && ev.active.gain == 1, ev.active.gain == 1, false);
return res_none;
case SDL_VIDEOEXPOSE:
return res_none;
case SDL_KEYDOWN:
if (ev.key.keysym.sym == SDLK_RETURN && (ev.key.keysym.mod & KMOD_ALT) > 0) {
cvarSystem->SetCVarBool("r_fullscreen", !renderSystem->IsFullScreen());
PushConsoleEvent("vid_restart");
return res_none;
}
// fall through
case SDL_KEYUP:
key = mapkey(ev.key.keysym.sym);
if (!key) {
unsigned char c;
// check if its an unmapped console key
if (ev.key.keysym.unicode == (c = Sys_GetConsoleKey(false))) {
key = c;
} else if (ev.key.keysym.unicode == (c = Sys_GetConsoleKey(true))) {
key = c;
} else {
if (ev.type == SDL_KEYDOWN)
common->Warning("unmapped SDL key %d (0x%x)", ev.key.keysym.sym, ev.key.keysym.unicode);
return res_none;
}
}
res.evType = SE_KEY;
res.evValue = key;
res.evValue2 = ev.key.state == SDL_PRESSED ? 1 : 0;
kbd_polls.Append(kbd_poll_t(key, ev.key.state == SDL_PRESSED));
if (ev.key.state == SDL_PRESSED && (ev.key.keysym.unicode & 0xff00) == 0)
c = ev.key.keysym.unicode & 0xff;
return res;
case SDL_MOUSEMOTION:
res.evType = SE_MOUSE;
res.evValue = ev.motion.xrel;
res.evValue2 = ev.motion.yrel;
mouse_polls.Append(mouse_poll_t(M_DELTAX, ev.motion.xrel));
mouse_polls.Append(mouse_poll_t(M_DELTAY, ev.motion.yrel));
return res;
case SDL_MOUSEBUTTONDOWN:
case SDL_MOUSEBUTTONUP:
res.evType = SE_KEY;
switch (ev.button.button) {
case SDL_BUTTON_LEFT:
res.evValue = K_MOUSE1;
mouse_polls.Append(mouse_poll_t(M_ACTION1, ev.button.state == SDL_PRESSED ? 1 : 0));
break;
case SDL_BUTTON_MIDDLE:
res.evValue = K_MOUSE3;
mouse_polls.Append(mouse_poll_t(M_ACTION3, ev.button.state == SDL_PRESSED ? 1 : 0));
break;
case SDL_BUTTON_RIGHT:
res.evValue = K_MOUSE2;
mouse_polls.Append(mouse_poll_t(M_ACTION2, ev.button.state == SDL_PRESSED ? 1 : 0));
break;
case SDL_BUTTON_WHEELUP:
res.evValue = K_MWHEELUP;
if (ev.button.state == SDL_PRESSED)
mouse_polls.Append(mouse_poll_t(M_DELTAZ, 1));
break;
case SDL_BUTTON_WHEELDOWN:
res.evValue = K_MWHEELDOWN;
if (ev.button.state == SDL_PRESSED)
mouse_polls.Append(mouse_poll_t(M_DELTAZ, -1));
break;
}
res.evValue2 = ev.button.state == SDL_PRESSED ? 1 : 0;
return res;
case SDL_QUIT:
PushConsoleEvent("quit");
return res_none;
case SDL_USEREVENT:
switch (ev.user.code) {
case SE_CONSOLE:
res.evType = SE_CONSOLE;
res.evPtrLength = (intptr_t)ev.user.data1;
res.evPtr = ev.user.data2;
return res;
default:
common->Warning("unknown user event %u", ev.user.code);
return res_none;
}
default:
common->Warning("unknown event %u", ev.type);
return res_none;
}
}
return res_none;
}
/*
===============
idClipModel::AllocTraceModel
===============
*/
int idClipModel::AllocTraceModel( const idTraceModel& trm, bool persistantThroughSaves )
{
int i, hashKey, traceModelIndex;
trmCache_t* entry;
hashKey = GetTraceModelHashKey( trm );
if( persistantThroughSaves )
{
// Look Inside the saved list.
for( i = traceModelHash.First( hashKey ); i >= 0; i = traceModelHash.Next( i ) )
{
if( traceModelCache[i]->trm == trm )
{
traceModelCache[i]->refCount++;
int flagged_index = i | TRACE_MODEL_SAVED;
return flagged_index;
}
}
}
else
{
// Look inside the unsaved list.
for( i = traceModelHash_Unsaved.First( hashKey ); i >= 0; i = traceModelHash_Unsaved.Next( i ) )
{
if( traceModelCache_Unsaved[i]->trm == trm )
{
traceModelCache_Unsaved[i]->refCount++;
return i;
}
}
}
entry = new( TAG_PHYSICS_CLIP ) trmCache_t;
entry->trm = trm;
entry->trm.GetMassProperties( 1.0f, entry->volume, entry->centerOfMass, entry->inertiaTensor );
entry->refCount = 1;
if( persistantThroughSaves )
{
traceModelIndex = traceModelCache.Append( entry );
traceModelHash.Add( hashKey, traceModelIndex );
// Set the saved bit.
traceModelIndex |= TRACE_MODEL_SAVED;
}
else
{
traceModelIndex = traceModelCache_Unsaved.Append( entry );
traceModelHash_Unsaved.Add( hashKey, traceModelIndex );
// remove the saved bit
traceModelIndex &= ~TRACE_MODEL_SAVED;
}
return traceModelIndex;
}
/*
=================
idRenderModelManagerLocal::AddModel
=================
*/
void idRenderModelManagerLocal::AddModel( idRenderModel *model ) {
hash.Add( hash.GenerateKey( model->Name(), false ), models.Append( model ) );
}
/*
================
Sys_GetEvent
================
*/
sysEvent_t Sys_GetEvent() {
SDL_Event ev;
sysEvent_t res = { };
byte key;
static const sysEvent_t res_none = { SE_NONE, 0, 0, 0, NULL };
static char *s = NULL;
static size_t s_pos = 0;
if (s) {
res.evType = SE_CHAR;
res.evValue = s[s_pos];
s_pos++;
if (!s[s_pos]) {
free(s);
s = NULL;
s_pos = 0;
}
return res;
}
static byte c = 0;
if (c) {
res.evType = SE_CHAR;
res.evValue = c;
c = 0;
return res;
}
if (SDL_PollEvent(&ev)) {
switch (ev.type) {
case SDL_WINDOWEVENT:
switch (ev.window.event) {
case SDL_WINDOWEVENT_FOCUS_GAINED:
{
// unset modifier, in case alt-tab was used to leave window and ALT is still set
// as that can cause fullscreen-toggling when pressing enter...
SDL_Keymod currentmod = SDL_GetModState();
int newmod = KMOD_NONE;
if (currentmod & KMOD_CAPS) // preserve capslock
newmod |= KMOD_CAPS;
SDL_SetModState((SDL_Keymod)newmod);
GLimp_GrabInput(GRAB_ENABLE | GRAB_REENABLE | GRAB_HIDECURSOR);
break;
}
case SDL_WINDOWEVENT_FOCUS_LOST:
GLimp_GrabInput(0);
break;
}
return res_none;
case SDL_KEYDOWN:
if (ev.key.keysym.sym == SDLK_RETURN && (ev.key.keysym.mod & KMOD_ALT) > 0) {
cvarSystem->SetCVarBool("r_fullscreen", !renderSystem->IsFullScreen());
PushConsoleEvent("vid_restart");
return res_none;
}
// fall through
case SDL_KEYUP:
key = mapkey(ev.key.keysym.sym);
if (!key) {
unsigned char c;
// check if its an unmapped console key
if (ev.key.keysym.unicode == (c = Sys_GetConsoleKey(false))) {
key = c;
} else if (ev.key.keysym.unicode == (c = Sys_GetConsoleKey(true))) {
key = c;
} else {
if (ev.type == SDL_KEYDOWN)
common->Warning("unmapped SDL key %d (0x%x)", ev.key.keysym.sym, ev.key.keysym.unicode);
return res_none;
}
}
res.evType = SE_KEY;
res.evValue = key;
res.evValue2 = ev.key.state == SDL_PRESSED ? 1 : 0;
kbd_polls.Append(kbd_poll_t(key, ev.key.state == SDL_PRESSED));
if (key == K_BACKSPACE && ev.key.state == SDL_PRESSED)
c = key;
return res;
case SDL_TEXTINPUT:
if (ev.text.text && *ev.text.text) {
if (!ev.text.text[1])
c = *ev.text.text;
else
s = strdup(ev.text.text);
}
return res_none;
case SDL_MOUSEMOTION:
res.evType = SE_MOUSE;
res.evValue = ev.motion.xrel;
res.evValue2 = ev.motion.yrel;
mouse_polls.Append(mouse_poll_t(M_DELTAX, ev.motion.xrel));
mouse_polls.Append(mouse_poll_t(M_DELTAY, ev.motion.yrel));
return res;
case SDL_MOUSEWHEEL:
res.evType = SE_KEY;
if (ev.wheel.y > 0) {
res.evValue = K_MWHEELUP;
mouse_polls.Append(mouse_poll_t(M_DELTAZ, 1));
} else {
res.evValue = K_MWHEELDOWN;
mouse_polls.Append(mouse_poll_t(M_DELTAZ, -1));
}
res.evValue2 = 1;
return res;
case SDL_MOUSEBUTTONDOWN:
case SDL_MOUSEBUTTONUP:
res.evType = SE_KEY;
switch (ev.button.button) {
case SDL_BUTTON_LEFT:
res.evValue = K_MOUSE1;
mouse_polls.Append(mouse_poll_t(M_ACTION1, ev.button.state == SDL_PRESSED ? 1 : 0));
break;
case SDL_BUTTON_MIDDLE:
res.evValue = K_MOUSE3;
mouse_polls.Append(mouse_poll_t(M_ACTION3, ev.button.state == SDL_PRESSED ? 1 : 0));
break;
case SDL_BUTTON_RIGHT:
res.evValue = K_MOUSE2;
mouse_polls.Append(mouse_poll_t(M_ACTION2, ev.button.state == SDL_PRESSED ? 1 : 0));
break;
}
res.evValue2 = ev.button.state == SDL_PRESSED ? 1 : 0;
return res;
case SDL_QUIT:
PushConsoleEvent("quit");
return res_none;
case SDL_USEREVENT:
switch (ev.user.code) {
case SE_CONSOLE:
res.evType = SE_CONSOLE;
res.evPtrLength = (intptr_t)ev.user.data1;
res.evPtr = ev.user.data2;
return res;
default:
common->Warning("unknown user event %u", ev.user.code);
return res_none;
}
default:
common->Warning("unknown event %u", ev.type);
return res_none;
}
}
return res_none;
}
