Eagle517/tge
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Initial commit

Browse Source
This commit is contained in:
Eagle517
2026-01-14 10:27:57 -06:00
commit c1576fee30
11290 changed files with 1552799 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

568
Torque/SDK/tools/map2dif/main.cc Normal file
View File

@@ -0,0 +1,568 @@
//-----------------------------------------------------------------------------
// Torque Game Engine
// Copyright (C) GarageGames.com, Inc.
//-----------------------------------------------------------------------------
#include "platform/platform.h"
#include "platform/event.h"
#include "platform/platformAssert.h"
#include "platform/platformVideo.h"
#include "math/mMath.h"
#include "console/console.h"
#include "dgl/gBitmap.h"
#include "core/tVector.h"
#include "core/fileStream.h"
#include "dgl/gTexManager.h"
#include "console/consoleTypes.h"
#include "math/mathTypes.h"
#include "map2dif/tokenizer.h"
#include "map2dif/editGeometry.h"
#include "interior/interior.h"
#include "map2dif/editInteriorRes.h"
#include "map2dif/entityTypes.h"
#include "interior/floorPlanRes.h"
#include "map2dif/morianGame.h"
#include "core/frameAllocator.h"
#include "gui/core/guiCanvas.h"
#include "map2dif/lmapPacker.h"
#include <stdlib.h>
MorianGame GameObject;
// FOR SILLY LINK DEPENDANCY
bool gEditingMission = false;
#if defined(TORQUE_DEBUG)
const char* const gProgramVersion = "0.900r-beta";
#else
const char* const gProgramVersion = "0.900d-beta";
#endif
//bool gRenderPreview = false;
bool gSpecifiedDetailOnly = false;
bool gBuildAsLowDetail = false;
bool gVerbose = false;
const char* gWadPath = "base/textures/";
bool gTextureSearch = true;
int gQuakeVersion = 2;
U32 gMaxPlanesConsidered = 32;
EditInteriorResource* gWorkingResource = NULL;
//#if defined(TORQUE_OS_WIN32) // huger hack
// huge hack
//GuiCanvas *Canvas;
//void GuiCanvas::paint() {}
//#endif
//
static bool initLibraries()
{
// asserts should be created FIRST
PlatformAssert::create();
FrameAllocator::init(2 << 20);
_StringTable::create();
TextureManager::create();
Con::init();
Math::init();
Platform::init(); // platform specific initialization
return(true);
}
static void shutdownLibraries()
{
// shut down
Platform::shutdown();
Con::shutdown();
TextureManager::destroy();
_StringTable::destroy();
// asserts should be destroyed LAST
FrameAllocator::destroy();
PlatformAssert::destroy();
}
S32 getGraphNodes( char * mapFileName )
{
// setup the tokenizer
Tokenizer* pTokenizer = new Tokenizer();
if (pTokenizer->openFile(mapFileName) == false) {
dPrintf("getGraphNodes(): Error opening map file: %s", mapFileName);
delete pTokenizer;
shutdownLibraries();
return -1;
}
// Create a geometry object
AssertFatal(gWorkingGeometry == NULL, "EditGeometry already exists");
gWorkingGeometry = new EditGeometry;
// configure graph for generation. not doing extrusion approach now.
gWorkingGeometry->setGraphGeneration(true, false);
// parse and create the geometry
dPrintf("Map file opened for graph work: %s\n"
" Parsing mapfile...", mapFileName); dFflushStdout();
if (gWorkingGeometry->parseMapFile(pTokenizer) == false) {
dPrintf("getGraphNodes(): Error parsing map file: %s\n", mapFileName);
delete pTokenizer;
delete gWorkingGeometry;
shutdownLibraries();
return -1;
}
delete pTokenizer;
dPrintf("done.\n");
// The code that gives us the node list is down in the createBSP()
// call tree. Kind of klunky but simpler for now.
dPrintf(" Creating graph node list"); dFflushStdout();
gWorkingGeometry->xferDetailToStructural();
bool result = gWorkingGeometry->createBSP();
if( result )
gWorkingGeometry->writeGraphInfo();
delete gWorkingGeometry; gWorkingGeometry = NULL;
delete gWorkingResource; gWorkingResource = NULL;
shutdownLibraries();
if( result == false ){
dPrintf( "getGraphNodes(): Error in BSP processing (%s)!\n", mapFileName);
return -1;
}
else{
dPrintf( "getGraphNodes(): Seemed to work... \n" );
return 0;
}
}
char* cleanPath(const char* _path)
{
char* path = new char[dStrlen(_path) + 2];
dStrcpy(path, _path);
// Clean up path char.
for (char* ptr = path; *ptr != '\0'; ptr++)
if (*ptr == '\\')
*ptr = '/';
// Check termination
char* end = &path[dStrlen(path) - 1];
if (*end != '/') {
end[1] = '/';
end[2] = 0;
}
return path;
}
char* getPath(const char* file)
{
char* path = new char[dStrlen(file) + 2];
dStrcpy(path, file);
// Strip back to first path char.
char* slash = dStrrchr(path, '/');
if (!slash)
slash = dStrrchr(path, '\\');
if (slash)
*slash = 0;
// Clean up path char.
char* ptr = path;
for (; *ptr != '\0'; ptr++)
if (*ptr == '\\')
*ptr = '/';
// Check termination
ptr--;
if (*ptr != '/') {
ptr[1] = '/';
ptr[2] = 0;
}
return path;
}
char* getBaseName(const char* file)
{
// Get rid of path
const char* slash = dStrrchr(file, '/');
if (!slash)
slash = dStrrchr(file, '\\');
if (!slash)
slash = file;
else
slash++;
char* name = new char[dStrlen(slash) + 1];
dStrcpy(name, slash);
// Strip extension & trailing _N
char* dot = dStrrchr(name, '.') - 2;
if (dot[0] == '_' && (dot[1] >= '0' && dot[1] <= '9'))
dot[0] = '\0';
else
dot[2] = '\0';
return name;
}
char* mergePath(const char* path1, const char* path2)
{
// Will merge and strip off leading ".." from path2
char* base = new char[dStrlen(path1) + dStrlen(path2) + 2];
dStrcpy(base,path1);
// Strip off ending path char.
char* end = &base[dStrlen(base) - 1];
if (*end == '/' || *end == '\\')
*end = 0;
// Deal with lead ./ and ../
while (path2[0] == '.')
if (path2[1] == '.') {
// Chop off ../ and remove the trailing dir from base
path2 += 2;
if (*path2 == '/' || *path2 == '\\')
path2++;
char *ptr = dStrrchr(base, '/');
if (!ptr)
ptr = dStrrchr(base, '\\');
AssertISV(ptr,"Error, could not merge relative path past root");
*ptr = 0;
}
else {
// Simply swallow the ./
path2 += 1;
if (*path2 == '/' || *path2 == '\\')
path2++;
}
dStrcat(base,"/");
dStrcat(base,path2);
return base;
}
S32 MorianGame::main(int argc, const char** argv)
{
// Set the memory manager page size to 64 megs...
setMinimumAllocUnit(64 << 20);
if(!initLibraries())
return 0;
// Set up the command line args for the console scripts...
Con::setIntVariable("Game::argc", argc);
for (S32 i = 0; i < argc; i++)
Con::setVariable(avar("Game::argv%d", i), argv[i]);
// Parse command line args...
bool isForNavigation = false, extrusionTest = false;
const char* wadPath = 0;
const char* difPath = 0;
S32 i = 1;
for (; i < argc; i++) {
if (argv[i][0] != '-')
break;
switch(dToupper(argv[i][1])) {
case 'D':
gSpecifiedDetailOnly = true;
break;
case 'L':
gSpecifiedDetailOnly = true;
gBuildAsLowDetail = true;
break;
case 'H':
gMaxPlanesConsidered = U32(1 << 30);
break;
case 'N':
gVerbose = true;
break;
case 'G':
isForNavigation = true;
extrusionTest = true;
break;
case 'E':
extrusionTest = true;
break;
case 'S':
gTextureSearch = false;
break;
case 'Q':
gQuakeVersion = atoi (argv[++i]);
break;
case 'T':
wadPath = cleanPath(argv[++i]);
break;
case 'O':
difPath = cleanPath(argv[++i]);
break;
}
}
U32 args = argc - i;
if (args != 1) {
dPrintf("\nmap2dif - Torque .MAP file converter\n"
" Copyright (C) GarageGames.com, Inc.\n"
" Program version: %s\n"
" Programmers: John Folliard & Dave Moore\n"
" Built: %s at %s\n\n"
"Usage: map2dif [-v] [-p] [-s] [-l] [-h] [-g] [-e] [-n] [-q ver] [-o outputDirectory] [-t textureDirectory] <file>.map\n"
" -p : Include a preview bitmap in the interior file\n"
" -d : Process only the detail specified on the command line\n"
" -l : Process as a low detail shape (implies -s)\n"
" -h : Process for final build (exhaustive BSP search)\n"
" -g : Generate navigation graph info\n"
" -e : Do extrusion test\n"
" -s : Don't search for textures in parent dir.\n"
" -n : Noisy error/statistic reporting\n"
" -q ver: Quake map file version (2, 3)\n"
" -o dir: Directory in which to place the .dif file\n"
" -t dir: Location of textures\n", gProgramVersion, __DATE__, __TIME__);
shutdownLibraries();
return -1;
}
// Check map file extension
const char* mapFile = argv[i];
const char* pDot = dStrrchr(mapFile, '.');
AssertISV(pDot && ((dStricmp(pDot, ".map") == 0)),
"Error, the map file must have a .MAP extension.");
// Get path and file name arguments
const char* mapPath = getPath(mapFile);
const char* baseName = getBaseName(mapFile);
if (!wadPath)
wadPath = mapPath;
if (!difPath)
difPath = mapPath;
// Old relative path merge, should think about what to do with it.
// wadPath = mergePath(mapPath,wadPath);
// difPath = mergePath(mapPath,difPath);
// Dif file name
char* pOutputName = new char[dStrlen(difPath) + dStrlen(baseName) + 5];
dStrcpy(pOutputName,difPath);
dStrcat(pOutputName,baseName);
dStrcat(pOutputName,".dif");
// Wad path
gWadPath = wadPath;
//
Vector<char*> mapFileNames;
if (gSpecifiedDetailOnly == false) {
const char* pDot = dStrrchr(mapFile, '.');
if (pDot && *(pDot - 2) == '_') {
// This is a detail based interior
char buffer[1024];
dStrcpy(buffer, mapFile);
char* pBufDot = dStrrchr(buffer, '.');
AssertFatal(pBufDot, "Error, why isn't it in this buffer too?");
*(pBufDot-1) = '\0';
for (U32 i = 0; i <= 9; i++) {
mapFileNames.push_back(new char[1024]);
dSprintf(mapFileNames.last(), 1023, "%s%d%s", buffer, i, pDot);
}
// Now, eliminate all mapFileNames that aren't actually map files
for (S32 i = S32(mapFileNames.size() - 1); i >= 0; i--) {
Tokenizer* pTokenizer = new Tokenizer();
if (pTokenizer->openFile(mapFileNames[i]) == false) {
delete [] mapFileNames[i];
mapFileNames.erase(i);
}
delete pTokenizer;
}
} else {
// normal interior
mapFileNames.push_back(new char[dStrlen(mapFile) + 1]);
dStrcpy(mapFileNames.last(), mapFile);
}
} else {
mapFileNames.push_back(new char[dStrlen(mapFile) + 1]);
dStrcpy(mapFileNames.last(), mapFile);
}
gWorkingResource = new EditInteriorResource;
if( isForNavigation ){
S32 retCode = getGraphNodes( mapFileNames[0] );
delete [] pOutputName;
for (U32 i = 0; i < mapFileNames.size(); i++)
delete [] mapFileNames[i];
return retCode;
}
for (U32 i = 0; i < mapFileNames.size(); i++) {
// setup the tokenizer
Tokenizer* pTokenizer = new Tokenizer();
if (pTokenizer->openFile(mapFileNames[i]) == false) {
dPrintf("Error opening map file: %s", mapFileNames[i]);
delete pTokenizer;
shutdownLibraries();
return -1;
}
// Create a geometry object
AssertFatal(gWorkingGeometry == NULL, "Already working?");
gWorkingGeometry = new EditGeometry;
// parse and create the geometry
dPrintf("Successfully opened map file: %s\n"
" Parsing mapfile...", mapFileNames[i]);
dFflushStdout();
if (gWorkingGeometry->parseMapFile(pTokenizer) == false) {
dPrintf("Error parsing map file: %s\n", mapFileNames[i]);
delete pTokenizer;
delete gWorkingGeometry;
delete gWorkingResource;
shutdownLibraries();
return -1;
}
delete pTokenizer;
dPrintf("done.\n");
gWorkingGeometry->setGraphGeneration(false,extrusionTest);
dPrintf(" Creating BSP...");
dFflushStdout();
if (gWorkingGeometry->createBSP() == false) {
dPrintf("Error creating BSP!\n", mapFileNames[i]);
// delete pTokenizer; (already)
delete gWorkingGeometry;
delete gWorkingResource;
shutdownLibraries();
return -1;
}
dPrintf("done.\n Marking active zones...");
gWorkingGeometry->markEmptyZones();
dPrintf("done\n Creating surfaces..."); dFflushStdout();
gWorkingGeometry->createSurfaces();
dPrintf("done.\n Lightmaps: Normal...");
dFflushStdout();
gWorkingGeometry->computeLightmaps(false);
dPrintf("Alarm...");
dFflushStdout();
gWorkingGeometry->computeLightmaps(true);
dPrintf("done.\n Resorting and Packing LightMaps..."); dFflushStdout();
gWorkingGeometry->preprocessLighting();
gWorkingGeometry->sortLitSurfaces();
gWorkingGeometry->packLMaps();
dPrintf("done.\n");
dFflushStdout();
// Process any special entitys...
for (U32 i = 0; i < gWorkingGeometry->mEntities.size(); i++)
{
if (dynamic_cast<DoorEntity*>(gWorkingGeometry->mEntities[i]) != NULL) {
DoorEntity* pDoor = static_cast<DoorEntity*>(gWorkingGeometry->mEntities[i]);
pDoor->process();
}
// else if (dynamic_cast<ForceFieldEntity*>(gWorkingGeometry->mEntities[i]) != NULL) {
// ForceFieldEntity* pForceField = static_cast<ForceFieldEntity*>(gWorkingGeometry->mEntities[i]);
// pForceField->process();
// }
}
// Give status
dPrintf("\n STATISTICS\n"
" - Total brushes: %d\n"
" + structural: %d\n"
" + detail: %d\n"
" + portal: %d\n"
" - Number of zones: %d\n"
" - Number of surfaces: %d\n", gWorkingGeometry->getTotalNumBrushes(),
gWorkingGeometry->getNumStructuralBrushes(),
gWorkingGeometry->getNumDetailBrushes(),
gWorkingGeometry->getNumPortalBrushes(),
gWorkingGeometry->getNumZones(),
gWorkingGeometry->getNumSurfaces());
if (gWorkingGeometry->getNumAmbiguousBrushes() != 0 ||
gWorkingGeometry->getNumOrphanPolys() != 0) {
dPrintf(
"\n ** *** WARNING WARNING WARNING *** **\n"
" *** ** WARNING WARNING WARNING ** ***\n"
"\n Errors exists in this interior. Please use the debug rendering modes\n"
" to find and correct the following problems:\n"
"\n * Ambiguous brushes: %d"
"\n * Orphaned Polygons: %d\n"
"\n *** ** WARNING WARNING WARNING ** ***\n"
" ** *** WARNING WARNING WARNING *** **\n",
gWorkingGeometry->getNumAmbiguousBrushes(),
gWorkingGeometry->getNumOrphanPolys());
}
// DMMTODO: store new geometry in the correct instance location
Interior* pRuntime = new Interior;
//
// Support for interior light map border sizes.
//
pRuntime->setLightMapBorderSize(SG_LIGHTMAP_BORDER_SIZE);
dPrintf("\n Exporting to runtime..."); dFflushStdout();
gWorkingGeometry->exportToRuntime(pRuntime, gWorkingResource);
dPrintf("done.\n\n");
dFflushStdout();
gWorkingResource->addDetailLevel(pRuntime);
delete gWorkingGeometry;
gWorkingGeometry = NULL;
}
if (gWorkingResource->getNumDetailLevels() > 0) {
dPrintf(" Writing Resource: "); dFflushStdout();
dPrintf("persist..(%s) ", pOutputName); dFflushStdout();
gWorkingResource->sortDetailLevels();
gWorkingResource->getDetailLevel(0)->processHullPolyLists();
gWorkingResource->getDetailLevel(0)->processVehicleHullPolyLists();
for (U32 i = 1; i < gWorkingResource->getNumDetailLevels(); i++)
gWorkingResource->getDetailLevel(i)->purgeLODData();
FileStream fws;
fws.open(pOutputName, FileStream::Write);
gWorkingResource->write(fws);
fws.close();
dPrintf("Done.\n\n");
dFflushStdout();
delete gWorkingResource;
}
delete [] pOutputName;
for (U32 i = 0; i < mapFileNames.size(); i++)
delete [] mapFileNames[i];
shutdownLibraries();
return 0;
}
void GameReactivate()
{
}
void GameDeactivate( bool )
{
}