752 lines
15 KiB
C++
Executable File
752 lines
15 KiB
C++
Executable File
/*
|
|
===========================================================================
|
|
Copyright (C) 1999-2005 Id Software, Inc.
|
|
|
|
This file is part of Quake III Arena source code.
|
|
|
|
Quake III Arena source code is free software; you can redistribute it
|
|
and/or modify it under the terms of the GNU General Public License as
|
|
published by the Free Software Foundation; either version 2 of the License,
|
|
or (at your option) any later version.
|
|
|
|
Quake III Arena source code is distributed in the hope that it will be
|
|
useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with Foobar; if not, write to the Free Software
|
|
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
|
|
===========================================================================
|
|
*/
|
|
#include "stdafx.h"
|
|
#include "qe3.h"
|
|
#include "PrefsDlg.h"
|
|
#include <direct.h>
|
|
#include <sys\stat.h>
|
|
|
|
QEGlobals_t g_qeglobals;
|
|
|
|
void WINAPI QE_CheckOpenGLForErrors(void)
|
|
{
|
|
CString strMsg;
|
|
int i = qglGetError();
|
|
if (i != GL_NO_ERROR)
|
|
{
|
|
if (i == GL_OUT_OF_MEMORY)
|
|
{
|
|
//strMsg.Format("OpenGL out of memory error %s\nDo you wish to save before exiting?", qgluErrorString((GLenum)i));
|
|
if (MessageBox(g_qeglobals.d_hwndMain, strMsg, "Q3Radiant Error", MB_YESNO) == IDYES)
|
|
{
|
|
Map_SaveFile(NULL, false);
|
|
}
|
|
exit(1);
|
|
}
|
|
else
|
|
{
|
|
//strMsg.Format("Warning: OpenGL Error %s\n ", qgluErrorString((GLenum)i));
|
|
Sys_Printf (strMsg.GetBuffer(0));
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
char *ExpandReletivePath (char *p)
|
|
{
|
|
static char temp[1024];
|
|
char *base;
|
|
|
|
if (!p || !p[0])
|
|
return NULL;
|
|
if (p[0] == '/' || p[0] == '\\')
|
|
return p;
|
|
|
|
base = ValueForKey(g_qeglobals.d_project_entity, "basepath");
|
|
sprintf (temp, "%s/%s", base, p);
|
|
return temp;
|
|
}
|
|
|
|
char *copystring (char *s)
|
|
{
|
|
char *b;
|
|
b = (char*)malloc(strlen(s)+1);
|
|
strcpy (b,s);
|
|
return b;
|
|
}
|
|
|
|
|
|
bool DoesFileExist(const char* pBuff, long& lSize)
|
|
{
|
|
CFile file;
|
|
if (file.Open(pBuff, CFile::modeRead | CFile::shareDenyNone))
|
|
{
|
|
lSize += file.GetLength();
|
|
file.Close();
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
|
|
void Map_Snapshot()
|
|
{
|
|
CString strMsg;
|
|
// we need to do the following
|
|
// 1. make sure the snapshot directory exists (create it if it doesn't)
|
|
// 2. find out what the lastest save is based on number
|
|
// 3. inc that and save the map
|
|
CString strOrgPath, strOrgFile;
|
|
ExtractPath_and_Filename(currentmap, strOrgPath, strOrgFile);
|
|
AddSlash(strOrgPath);
|
|
strOrgPath += "snapshots";
|
|
bool bGo = true;
|
|
struct _stat Stat;
|
|
if (_stat(strOrgPath, &Stat) == -1)
|
|
{
|
|
bGo = (_mkdir(strOrgPath) != -1);
|
|
}
|
|
AddSlash(strOrgPath);
|
|
if (bGo)
|
|
{
|
|
int nCount = 0;
|
|
long lSize = 0;
|
|
CString strNewPath = strOrgPath;
|
|
strNewPath += strOrgFile;
|
|
CString strFile;
|
|
while (bGo)
|
|
{
|
|
strFile.Format("%s.%i", strNewPath, nCount);
|
|
bGo = DoesFileExist(strFile, lSize);
|
|
nCount++;
|
|
}
|
|
// strFile has the next available slot
|
|
Map_SaveFile(strFile.GetBuffer(0), false);
|
|
Sys_SetTitle (currentmap);
|
|
if (lSize > 12 * 1024 * 1024) // total size of saves > 4 mb
|
|
{
|
|
Sys_Printf("The snapshot files in the [%s] directory total more than 4 megabytes. You might consider cleaning the directory up.", strOrgPath);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
strMsg.Format("Snapshot save failed.. unabled to create directory\n%s", strOrgPath);
|
|
g_pParentWnd->MessageBox(strMsg);
|
|
}
|
|
}
|
|
/*
|
|
===============
|
|
QE_CheckAutoSave
|
|
|
|
If five minutes have passed since making a change
|
|
and the map hasn't been saved, save it out.
|
|
===============
|
|
*/
|
|
|
|
|
|
void QE_CheckAutoSave( void )
|
|
{
|
|
static clock_t s_start;
|
|
clock_t now;
|
|
|
|
now = clock();
|
|
|
|
if ( modified != 1 || !s_start)
|
|
{
|
|
s_start = now;
|
|
return;
|
|
}
|
|
|
|
if ( now - s_start > ( CLOCKS_PER_SEC * 60 * g_PrefsDlg.m_nAutoSave))
|
|
{
|
|
|
|
if (g_PrefsDlg.m_bAutoSave)
|
|
{
|
|
CString strMsg = g_PrefsDlg.m_bSnapShots ? "Autosaving snapshot..." : "Autosaving...";
|
|
Sys_Printf(strMsg.GetBuffer(0));
|
|
Sys_Printf("\n");
|
|
Sys_Status (strMsg.GetBuffer(0),0);
|
|
|
|
// only snapshot if not working on a default map
|
|
if (g_PrefsDlg.m_bSnapShots && stricmp(currentmap, "unnamed.map") != 0)
|
|
{
|
|
Map_Snapshot();
|
|
}
|
|
else
|
|
{
|
|
Map_SaveFile (ValueForKey(g_qeglobals.d_project_entity, "autosave"), false);
|
|
}
|
|
|
|
Sys_Status ("Autosaving...Saved.", 0 );
|
|
modified = 2;
|
|
}
|
|
else
|
|
{
|
|
Sys_Printf ("Autosave skipped...\n");
|
|
Sys_Status ("Autosave skipped...", 0 );
|
|
}
|
|
s_start = now;
|
|
}
|
|
}
|
|
|
|
|
|
int BuildShortPathName(const char* pPath, char* pBuffer, int nBufferLen)
|
|
{
|
|
char *pFile = NULL;
|
|
int nResult = GetFullPathName(pPath, nBufferLen, pBuffer, &pFile);
|
|
nResult = GetShortPathName(pPath, pBuffer, nBufferLen);
|
|
if (nResult == 0)
|
|
strcpy(pBuffer, pPath); // Use long filename
|
|
return nResult;
|
|
}
|
|
|
|
|
|
|
|
const char *g_pPathFixups[]=
|
|
{
|
|
"basepath",
|
|
"remotebasepath",
|
|
"entitypath",
|
|
"texturepath",
|
|
"autosave",
|
|
"mapspath"
|
|
};
|
|
|
|
const int g_nPathFixupCount = sizeof(g_pPathFixups) / sizeof(const char*);
|
|
|
|
/*
|
|
===========
|
|
QE_LoadProject
|
|
===========
|
|
*/
|
|
qboolean QE_LoadProject (char *projectfile)
|
|
{
|
|
char *data;
|
|
|
|
Sys_Printf ("QE_LoadProject (%s)\n", projectfile);
|
|
|
|
if ( LoadFileNoCrash (projectfile, (void **)&data) == -1)
|
|
return false;
|
|
|
|
g_strProject = projectfile;
|
|
|
|
CString strData = data;
|
|
free(data);
|
|
|
|
CString strQ2Path = g_PrefsDlg.m_strQuake2;
|
|
CString strQ2File;
|
|
ExtractPath_and_Filename(g_PrefsDlg.m_strQuake2, strQ2Path, strQ2File);
|
|
AddSlash(strQ2Path);
|
|
|
|
|
|
char* pBuff = new char[1024];
|
|
|
|
BuildShortPathName(strQ2Path, pBuff, 1024);
|
|
FindReplace(strData, "__Q2PATH", pBuff);
|
|
BuildShortPathName(g_strAppPath, pBuff, 1024);
|
|
FindReplace(strData, "__QERPATH", pBuff);
|
|
|
|
char* pFile;
|
|
if (GetFullPathName(projectfile, 1024, pBuff, &pFile))
|
|
{
|
|
g_PrefsDlg.m_strLastProject = pBuff;
|
|
BuildShortPathName(g_PrefsDlg.m_strLastProject, pBuff, 1024);
|
|
g_PrefsDlg.m_strLastProject = pBuff;
|
|
g_PrefsDlg.SavePrefs();
|
|
|
|
ExtractPath_and_Filename(pBuff, strQ2Path, strQ2File);
|
|
int nLen = strQ2Path.GetLength();
|
|
if (nLen > 0)
|
|
{
|
|
if (strQ2Path[nLen - 1] == '\\')
|
|
strQ2Path.SetAt(nLen-1,'\0');
|
|
char* pBuffer = strQ2Path.GetBufferSetLength(_MAX_PATH + 1);
|
|
int n = strQ2Path.ReverseFind('\\');
|
|
if (n >=0 )
|
|
pBuffer[n + 1] = '\0';
|
|
strQ2Path.ReleaseBuffer();
|
|
FindReplace(strData, "__QEPROJPATH", strQ2Path);
|
|
}
|
|
}
|
|
|
|
|
|
StartTokenParsing (strData.GetBuffer(0));
|
|
g_qeglobals.d_project_entity = Entity_Parse (true);
|
|
if (!g_qeglobals.d_project_entity)
|
|
Error ("Couldn't parse %s", projectfile);
|
|
|
|
for (int i = 0; i < g_nPathFixupCount; i++)
|
|
{
|
|
char *pPath = ValueForKey (g_qeglobals.d_project_entity, g_pPathFixups[i]);
|
|
if (pPath[0] != '\\' && pPath[0] != '/')
|
|
{
|
|
if (GetFullPathName(pPath, 1024, pBuff, &pFile))
|
|
{
|
|
SetKeyValue(g_qeglobals.d_project_entity, g_pPathFixups[i], pBuff);
|
|
}
|
|
}
|
|
}
|
|
|
|
delete []pBuff;
|
|
|
|
// set here some default project settings you need
|
|
if ( strlen( ValueForKey( g_qeglobals.d_project_entity, "brush_primit" ) ) == 0 )
|
|
{
|
|
SetKeyValue( g_qeglobals.d_project_entity, "brush_primit", "0" );
|
|
}
|
|
|
|
g_qeglobals.m_bBrushPrimitMode = IntForKey( g_qeglobals.d_project_entity, "brush_primit" );
|
|
|
|
|
|
Eclass_InitForSourceDirectory (ValueForKey (g_qeglobals.d_project_entity, "entitypath"));
|
|
FillClassList(); // list in entity window
|
|
|
|
Map_New();
|
|
|
|
|
|
FillTextureMenu();
|
|
FillBSPMenu();
|
|
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
===========
|
|
QE_SaveProject
|
|
===========
|
|
*/
|
|
//extern char *bsp_commands[256];
|
|
|
|
qboolean QE_SaveProject (const char* pProjectFile)
|
|
{
|
|
//char filename[1024];
|
|
FILE *fp;
|
|
epair_t *ep;
|
|
|
|
//sprintf (filename, "%s\\%s.prj", g_projectdir, g_username);
|
|
|
|
if (!(fp = fopen (pProjectFile, "w+")))
|
|
Error ("Could not open project file!");
|
|
|
|
fprintf (fp, "{\n");
|
|
for (ep = g_qeglobals.d_project_entity->epairs; ep; ep=ep->next)
|
|
fprintf (fp, "\"%s\" \"%s\"\n", ep->key, ep->value);
|
|
fprintf (fp, "}\n");
|
|
|
|
fclose (fp);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
===========
|
|
QE_KeyDown
|
|
===========
|
|
*/
|
|
#define SPEED_MOVE 32
|
|
#define SPEED_TURN 22.5
|
|
|
|
|
|
/*
|
|
===============
|
|
ConnectEntities
|
|
|
|
Sets target / targetname on the two entities selected
|
|
from the first selected to the secon
|
|
===============
|
|
*/
|
|
void ConnectEntities (void)
|
|
{
|
|
entity_t *e1, *e2, *e;
|
|
char *target, *tn;
|
|
int maxtarg, targetnum;
|
|
char newtarg[32];
|
|
|
|
if (g_qeglobals.d_select_count != 2)
|
|
{
|
|
Sys_Status ("Must have two brushes selected.", 0);
|
|
Sys_Beep ();
|
|
return;
|
|
}
|
|
|
|
e1 = g_qeglobals.d_select_order[0]->owner;
|
|
e2 = g_qeglobals.d_select_order[1]->owner;
|
|
|
|
if (e1 == world_entity || e2 == world_entity)
|
|
{
|
|
Sys_Status ("Can't connect to the world.", 0);
|
|
Sys_Beep ();
|
|
return;
|
|
}
|
|
|
|
if (e1 == e2)
|
|
{
|
|
Sys_Status ("Brushes are from same entity.", 0);
|
|
Sys_Beep ();
|
|
return;
|
|
}
|
|
|
|
target = ValueForKey (e1, "target");
|
|
if (target && target[0])
|
|
strcpy (newtarg, target);
|
|
else
|
|
{
|
|
target = ValueForKey (e2, "targetname");
|
|
if (target && target[0])
|
|
strcpy (newtarg, target);
|
|
else
|
|
{
|
|
// make a unique target value
|
|
maxtarg = 0;
|
|
for (e=entities.next ; e != &entities ; e=e->next)
|
|
{
|
|
tn = ValueForKey (e, "targetname");
|
|
if (tn && tn[0])
|
|
{
|
|
targetnum = atoi(tn+1);
|
|
if (targetnum > maxtarg)
|
|
maxtarg = targetnum;
|
|
}
|
|
}
|
|
sprintf (newtarg, "t%i", maxtarg+1);
|
|
}
|
|
}
|
|
|
|
SetKeyValue (e1, "target", newtarg);
|
|
SetKeyValue (e2, "targetname", newtarg);
|
|
Sys_UpdateWindows (W_XY | W_CAMERA);
|
|
|
|
Select_Deselect();
|
|
Select_Brush (g_qeglobals.d_select_order[1]);
|
|
}
|
|
|
|
qboolean QE_SingleBrush (bool bQuiet)
|
|
{
|
|
if ( (selected_brushes.next == &selected_brushes)
|
|
|| (selected_brushes.next->next != &selected_brushes) )
|
|
{
|
|
if (!bQuiet)
|
|
{
|
|
Sys_Printf ("Error: you must have a single brush selected\n");
|
|
}
|
|
return false;
|
|
}
|
|
if (selected_brushes.next->owner->eclass->fixedsize)
|
|
{
|
|
if (!bQuiet)
|
|
{
|
|
Sys_Printf ("Error: you cannot manipulate fixed size entities\n");
|
|
}
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
void QE_Init (void)
|
|
{
|
|
/*
|
|
** initialize variables
|
|
*/
|
|
g_qeglobals.d_gridsize = 8;
|
|
g_qeglobals.d_showgrid = true;
|
|
|
|
/*
|
|
** other stuff
|
|
*/
|
|
Texture_Init (true);
|
|
//Cam_Init ();
|
|
//XY_Init ();
|
|
Z_Init ();
|
|
Terrain_Init();
|
|
}
|
|
|
|
void WINAPI QE_ConvertDOSToUnixName( char *dst, const char *src )
|
|
{
|
|
while ( *src )
|
|
{
|
|
if ( *src == '\\' )
|
|
*dst = '/';
|
|
else
|
|
*dst = *src;
|
|
dst++; src++;
|
|
}
|
|
*dst = 0;
|
|
}
|
|
|
|
int g_numbrushes, g_numentities;
|
|
|
|
void QE_CountBrushesAndUpdateStatusBar( void )
|
|
{
|
|
static int s_lastbrushcount, s_lastentitycount;
|
|
static qboolean s_didonce;
|
|
|
|
//entity_t *e;
|
|
brush_t *b, *next;
|
|
|
|
g_numbrushes = 0;
|
|
g_numentities = 0;
|
|
|
|
if ( active_brushes.next != NULL )
|
|
{
|
|
for ( b = active_brushes.next ; b != NULL && b != &active_brushes ; b=next)
|
|
{
|
|
next = b->next;
|
|
if (b->brush_faces )
|
|
{
|
|
if ( !b->owner->eclass->fixedsize)
|
|
g_numbrushes++;
|
|
else
|
|
g_numentities++;
|
|
}
|
|
}
|
|
}
|
|
/*
|
|
if ( entities.next != NULL )
|
|
{
|
|
for ( e = entities.next ; e != &entities && g_numentities != MAX_MAP_ENTITIES ; e = e->next)
|
|
{
|
|
g_numentities++;
|
|
}
|
|
}
|
|
*/
|
|
if ( ( ( g_numbrushes != s_lastbrushcount ) || ( g_numentities != s_lastentitycount ) ) || ( !s_didonce ) )
|
|
{
|
|
Sys_UpdateStatusBar();
|
|
|
|
s_lastbrushcount = g_numbrushes;
|
|
s_lastentitycount = g_numentities;
|
|
s_didonce = true;
|
|
}
|
|
}
|
|
|
|
char com_token[1024];
|
|
qboolean com_eof;
|
|
|
|
/*
|
|
================
|
|
I_FloatTime
|
|
================
|
|
*/
|
|
double I_FloatTime (void)
|
|
{
|
|
time_t t;
|
|
|
|
time (&t);
|
|
|
|
return t;
|
|
#if 0
|
|
// more precise, less portable
|
|
struct timeval tp;
|
|
struct timezone tzp;
|
|
static int secbase;
|
|
|
|
gettimeofday(&tp, &tzp);
|
|
|
|
if (!secbase)
|
|
{
|
|
secbase = tp.tv_sec;
|
|
return tp.tv_usec/1000000.0;
|
|
}
|
|
|
|
return (tp.tv_sec - secbase) + tp.tv_usec/1000000.0;
|
|
#endif
|
|
}
|
|
|
|
|
|
/*
|
|
==============
|
|
COM_Parse
|
|
|
|
Parse a token out of a string
|
|
==============
|
|
*/
|
|
char *COM_Parse (char *data)
|
|
{
|
|
int c;
|
|
int len;
|
|
|
|
len = 0;
|
|
com_token[0] = 0;
|
|
|
|
if (!data)
|
|
return NULL;
|
|
|
|
// skip whitespace
|
|
skipwhite:
|
|
while ( (c = *data) <= ' ')
|
|
{
|
|
if (c == 0)
|
|
{
|
|
com_eof = true;
|
|
return NULL; // end of file;
|
|
}
|
|
data++;
|
|
}
|
|
|
|
// skip // comments
|
|
if (c=='/' && data[1] == '/')
|
|
{
|
|
while (*data && *data != '\n')
|
|
data++;
|
|
goto skipwhite;
|
|
}
|
|
|
|
|
|
// handle quoted strings specially
|
|
if (c == '\"')
|
|
{
|
|
data++;
|
|
do
|
|
{
|
|
c = *data++;
|
|
if (c=='\"')
|
|
{
|
|
com_token[len] = 0;
|
|
return data;
|
|
}
|
|
com_token[len] = c;
|
|
len++;
|
|
} while (1);
|
|
}
|
|
|
|
// parse single characters
|
|
if (c=='{' || c=='}'|| c==')'|| c=='(' || c=='\'' || c==':')
|
|
{
|
|
com_token[len] = c;
|
|
len++;
|
|
com_token[len] = 0;
|
|
return data+1;
|
|
}
|
|
|
|
// parse a regular word
|
|
do
|
|
{
|
|
com_token[len] = c;
|
|
data++;
|
|
len++;
|
|
c = *data;
|
|
if (c=='{' || c=='}'|| c==')'|| c=='(' || c=='\'' || c==':')
|
|
break;
|
|
} while (c>32);
|
|
|
|
com_token[len] = 0;
|
|
return data;
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
=============================================================================
|
|
|
|
MISC FUNCTIONS
|
|
|
|
=============================================================================
|
|
*/
|
|
|
|
|
|
int argc;
|
|
char *argv[MAX_NUM_ARGVS];
|
|
|
|
/*
|
|
============
|
|
ParseCommandLine
|
|
============
|
|
*/
|
|
void ParseCommandLine (char *lpCmdLine)
|
|
{
|
|
argc = 1;
|
|
argv[0] = "programname";
|
|
|
|
while (*lpCmdLine && (argc < MAX_NUM_ARGVS))
|
|
{
|
|
while (*lpCmdLine && ((*lpCmdLine <= 32) || (*lpCmdLine > 126)))
|
|
lpCmdLine++;
|
|
|
|
if (*lpCmdLine)
|
|
{
|
|
argv[argc] = lpCmdLine;
|
|
argc++;
|
|
|
|
while (*lpCmdLine && ((*lpCmdLine > 32) && (*lpCmdLine <= 126)))
|
|
lpCmdLine++;
|
|
|
|
if (*lpCmdLine)
|
|
{
|
|
*lpCmdLine = 0;
|
|
lpCmdLine++;
|
|
}
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
=================
|
|
CheckParm
|
|
|
|
Checks for the given parameter in the program's command line arguments
|
|
Returns the argument number (1 to argc-1) or 0 if not present
|
|
=================
|
|
*/
|
|
int CheckParm (char *check)
|
|
{
|
|
int i;
|
|
|
|
for (i = 1;i<argc;i++)
|
|
{
|
|
if ( stricmp(check, argv[i]) )
|
|
return i;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
==============
|
|
ParseNum / ParseHex
|
|
==============
|
|
*/
|
|
int ParseHex (char *hex)
|
|
{
|
|
char *str;
|
|
int num;
|
|
|
|
num = 0;
|
|
str = hex;
|
|
|
|
while (*str)
|
|
{
|
|
num <<= 4;
|
|
if (*str >= '0' && *str <= '9')
|
|
num += *str-'0';
|
|
else if (*str >= 'a' && *str <= 'f')
|
|
num += 10 + *str-'a';
|
|
else if (*str >= 'A' && *str <= 'F')
|
|
num += 10 + *str-'A';
|
|
else
|
|
Error ("Bad hex number: %s",hex);
|
|
str++;
|
|
}
|
|
|
|
return num;
|
|
}
|
|
|
|
|
|
int ParseNum (char *str)
|
|
{
|
|
if (str[0] == '$')
|
|
return ParseHex (str+1);
|
|
if (str[0] == '0' && str[1] == 'x')
|
|
return ParseHex (str+2);
|
|
return atol (str);
|
|
}
|
|
|
|
|