--- /dev/null
+/*
+BobToolz plugin for GtkRadiant
+Copyright (C) 2001 Gordon Biggans
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+
+This library 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
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+*/
+
+#include "misc.h"
+
+#include <list>
+#include "str.h"
+
+#include "DPoint.h"
+#include "DPlane.h"
+#include "DBrush.h"
+#include "DEPair.h"
+#include "DPatch.h"
+#include "DEntity.h"
+
+#include "funchandlers.h"
+
+#ifdef __linux__
+#include <sys/types.h>
+#include <unistd.h>
+#endif
+
+#include "iundo.h"
+#include "ientity.h"
+#include "iscenegraph.h"
+#include "qerplugin.h"
+
+#include <vector>
+#include <list>
+#include <map>
+#include <algorithm>
+
+#include "scenelib.h"
+
+/*==========================
+ Global Vars
+==========================*/
+
+//HANDLE bsp_process;
+char g_CurrentTexture[256] = "";
+
+//=============================================================
+//=============================================================
+
+void ReadCurrentTexture()
+{
+ const char* textureName = GlobalRadiant().TextureBrowser_getSelectedShader();
+ strcpy(g_CurrentTexture, textureName);
+}
+
+const char* GetCurrentTexture()
+{
+ ReadCurrentTexture();
+ return g_CurrentTexture;
+}
+
+void MoveBlock(int dir, vec3_t min, vec3_t max, float dist)
+{
+ switch(dir)
+ {
+ case MOVE_EAST:
+ {
+ min[0]+=dist;
+ max[0]+=dist;
+ break;
+ }
+ case MOVE_WEST:
+ {
+ min[0]-=dist;
+ max[0]-=dist;
+ break;
+ }
+ case MOVE_NORTH:
+ {
+ min[1]+=dist;
+ max[1]+=dist;
+ break;
+ }
+ case MOVE_SOUTH:
+ {
+ min[1]-=dist;
+ max[1]-=dist;
+ break;
+ }
+ }
+}
+
+void SetInitialStairPos(int dir, vec3_t min, vec3_t max, float width)
+{
+ switch(dir)
+ {
+ case MOVE_EAST:
+ {
+ max[0] = min[0] + width;
+ break;
+ }
+ case MOVE_WEST:
+ {
+ min[0] = max[0] - width;
+ break;
+ }
+ case MOVE_NORTH:
+ {
+ max[1] = min[1] + width;
+ break;
+ }
+ case MOVE_SOUTH:
+ {
+ min[1] = max[1] - width;
+ break;
+ }
+ }
+}
+
+char* TranslateString (char *buf)
+{
+ static char buf2[32768];
+
+ std::size_t l = strlen(buf);
+ char* out = buf2;
+ for (int i=0 ; i<l ; i++)
+ {
+ if (buf[i] == '\n')
+ {
+ *out++ = '\r';
+ *out++ = '\n';
+ }
+ else
+ *out++ = buf[i];
+ }
+ *out++ = 0;
+
+ return buf2;
+}
+
+
+char* UnixToDosPath(char* path)
+{
+#ifndef WIN32
+ return path;
+#else
+ for(char* p = path; *p; p++)
+ {
+ if(*p == '/')
+ *p = '\\';
+ }
+ return path;
+#endif
+}
+
+const char* ExtractFilename(const char* path)
+{
+ const char* p = strrchr(path, '/');
+ if(!p)
+ {
+ p = strrchr(path, '\\');
+
+ if(!p)
+ return path;
+ }
+ return ++p;
+}
+
+extern char* PLUGIN_NAME;
+/*char* GetGameFilename(char* buffer, const char* filename)
+{
+ strcpy(buffer, g_FuncTable.m_pfnGetGamePath());
+ char* p = strrchr(buffer, '/');
+ *++p = '\0';
+ strcat(buffer, filename);
+ buffer = UnixToDosPath(buffer);
+ return buffer;
+}*/
+
+#if defined (POSIX)
+// the bCreateConsole parameter is ignored on linux ..
+bool Q_Exec( const char *pCmd, bool bCreateConsole )
+{
+ switch (fork())
+ {
+ case -1:
+ return false;
+// Error ("CreateProcess failed");
+ break;
+ case 0:
+#ifdef _DEBUG
+ printf("Running system...\n");
+ printf("Command: %s\n", pCmd);
+#endif
+ // NOTE: we could use that to detect when a step finishes. But then it
+ // would not work for remote compiling stuff.
+// execlp (pCmd, pCmd, NULL);
+ system( pCmd );
+ printf ("system() returned");
+ _exit (0);
+ break;
+ }
+ return true;
+}
+#endif
+
+#ifdef WIN32
+
+#include <windows.h>
+
+bool Q_Exec( const char *pCmd, bool bCreateConsole )
+{
+ // G_DeWan: Don't know if this is needed for linux version
+
+ PROCESS_INFORMATION pi;
+ STARTUPINFO si = {0}; // Initialize all members to zero
+ si.cb = sizeof(STARTUPINFO); // Set byte count
+ DWORD dwCreationFlags;
+
+ if (bCreateConsole)
+ dwCreationFlags = CREATE_NEW_CONSOLE | NORMAL_PRIORITY_CLASS;
+ else
+ dwCreationFlags = DETACHED_PROCESS | NORMAL_PRIORITY_CLASS;
+
+ for(; *pCmd == ' '; pCmd++);
+
+ if(!CreateProcess(NULL, (char *)pCmd, NULL, NULL, false, dwCreationFlags, NULL, NULL, &si, &pi))
+ return false;
+
+ return true;
+}
+#endif
+
+void StartBSP()
+{
+ char exename[256];
+ GetFilename(exename, "q3map");
+ UnixToDosPath(exename); // do we want this done in linux version?
+
+ char mapname[256];
+ const char *pn = GlobalRadiant().getMapsPath();
+
+ strcpy( mapname, pn );
+ strcat( mapname, "/ac_prt.map" );
+ UnixToDosPath(mapname);
+
+ char command[1024];
+ sprintf(command, "%s -nowater -fulldetail %s", exename, mapname);
+
+ Q_Exec( command, true );
+}
+
+class EntityWriteMiniPrt
+{
+ mutable DEntity world;
+ FILE* pFile;
+ std::list<Str>* exclusionList;
+public:
+ EntityWriteMiniPrt(FILE* pFile, std::list<Str>* exclusionList)
+ : pFile(pFile), exclusionList(exclusionList)
+ {
+ }
+ void operator()(scene::Instance& instance) const
+ {
+ const char* classname = Node_getEntity(instance.path().top())->getKeyValue("classname");
+
+ if(!strcmp(classname, "worldspawn"))
+ {
+ world.LoadFromEntity(instance.path().top(), false);
+ world.RemoveNonCheckBrushes(exclusionList, true);
+ world.SaveToFile(pFile);
+ }
+ else if(strstr(classname, "info_"))
+ {
+ world.ClearBrushes();
+ world.ClearEPairs();
+ world.LoadEPairList(Node_getEntity(instance.path().top()));
+ world.SaveToFile(pFile);
+ }
+ }
+};
+
+void BuildMiniPrt(std::list<Str>* exclusionList)
+{
+ // yes, we could just use -fulldetail option, but, as SPOG said
+ // it'd be faster without all the hint, donotenter etc textures and
+ // doors, etc
+
+
+
+ char buffer[128];
+ const char *pn = GlobalRadiant().getMapsPath();
+
+ strcpy( buffer, pn );
+ strcat( buffer, "/ac_prt.map" );
+ FILE* pFile = fopen(buffer, "w");
+
+ // ahem, thx rr2
+ if(!pFile)
+ return;
+
+ Scene_forEachEntity(EntityWriteMiniPrt(pFile, exclusionList));
+
+ fclose(pFile);
+
+ StartBSP();
+}
+
+class EntityFindByTargetName
+{
+ const char* targetname;
+public:
+ mutable const scene::Path* result;
+ EntityFindByTargetName(const char* targetname)
+ : targetname(targetname), result(0)
+ {
+ }
+ void operator()(scene::Instance& instance) const
+ {
+ if(result == 0)
+ {
+ const char* value = Node_getEntity(instance.path().top())->getKeyValue("targetname");
+
+ if(!strcmp(value, targetname))
+ {
+ result = &instance.path();
+ }
+ }
+ }
+};
+
+const scene::Path* FindEntityFromTargetname(const char* targetname)
+{
+ return Scene_forEachEntity(EntityFindByTargetName(targetname)).result;
+}
+
+void FillDefaultTexture(_QERFaceData* faceData, vec3_t va, vec3_t vb, vec3_t vc, const char* texture)
+{
+ faceData->m_texdef.rotate = 0;
+ faceData->m_texdef.scale[0] = 0.5;
+ faceData->m_texdef.scale[1] = 0.5;
+ faceData->m_texdef.shift[0] = 0;
+ faceData->m_texdef.shift[1] = 0;
+ faceData->contents = 0;
+ faceData->flags = 0;
+ faceData->value = 0;
+ if(*texture)
+ faceData->m_shader = texture;
+ else
+ faceData->m_shader = "textures/common/caulk";
+ VectorCopy(va, faceData->m_p0);
+ VectorCopy(vb, faceData->m_p1);
+ VectorCopy(vc, faceData->m_p2);
+}
+
+float Determinant3x3(float a1, float a2, float a3,
+ float b1, float b2, float b3,
+ float c1, float c2, float c3)
+{
+ return a1*(b2*c3-b3*c2) - a2*(b1*c3-b3*c1) + a3*(b1*c2-b2*c1);
+}
+
+bool GetEntityCentre(const char* entity, vec3_t centre)
+{
+ const scene::Path* ent = FindEntityFromTargetname(entity);
+ if(!ent)
+ return false;
+
+ scene::Instance& instance = *GlobalSceneGraph().find(*ent);
+ VectorCopy(instance.worldAABB().origin, centre);
+
+ return true;
+}
+
+vec_t Min(vec_t a, vec_t b)
+{
+ if(a < b)
+ return a;
+ return b;
+}
+
+void MakeNormal( const vec_t* va, const vec_t* vb, const vec_t* vc, vec_t* out ) {
+ vec3_t v1, v2;
+ VectorSubtract(va, vb, v1);
+ VectorSubtract(vc, vb, v2);
+ CrossProduct(v1, v2, out);
+}
+
+char* GetFilename(char* buffer, const char* filename) {
+ strcpy(buffer, GlobalRadiant().getAppPath());
+ strcat(buffer, "plugins/");
+ strcat(buffer, filename);
+ return buffer;
+}
+
projects / voretournament / voretournament.git / blobdiff