ioef/q3radiant/QE3.CPP

751 lines
14 KiB
C++

/*
===========================================================================
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);
}