{
GtkWidget* window = lookup_widget(GTK_WIDGET(button), "w_plugplug2");
ASSERT_NOTNULL(window);
- const char* cpath = GlobalRadiant().m_pfnFileDialog(window, false, "Save as Obj", 0, 0);
+ const char* cpath = GlobalRadiant().m_pfnFileDialog(window, false, "Save as Obj", 0, 0, false, false, true);
if(!cpath)
return;
pack QuakePack proprietary zip1 http://ingar.satgnu.net/files/gtkradiant/gamepacks/QuakePack.zip
pack TremulousPack proprietary zip1 http://ingar.satgnu.net/files/gtkradiant/gamepacks/TremulousPack.zip
pack UFOAIPack proprietary svn https://zerowing.idsoftware.com/svn/radiant.gamepacks/UFOAIPack/branches/1.5/
-#pack WarsowPack GPL svn https://svn.bountysource.com/wswpack/trunk/netradiant/games/WarsowPack/
+pack WarsowPack GPL svn https://svn.bountysource.com/wswpack/trunk/netradiant/games/WarsowPack/
pack XonoticPack GPL git git://git.xonotic.org/xonotic/netradiant-xonoticpack.git
: name(""), pattern("")
{
}
- filetype_t(const char* _name, const char* _pattern)
- : name(_name), pattern(_pattern)
+ filetype_t(const char* _name, const char* _pattern, bool _can_load = true, bool _can_import = true, bool _can_save = true)
+ : name(_name), pattern(_pattern), can_load(_can_load), can_import(_can_import), can_save(_can_save)
{
}
const char* name;
const char* pattern;
+ bool can_load;
+ bool can_import;
+ bool can_save;
};
STRING_CONSTANT(Name, "filetypes");
virtual void addType(const char* moduleType, const char* moduleName, filetype_t type) = 0;
- virtual void getTypeList(const char* moduleType, IFileTypeList* typelist) = 0;
+ virtual void getTypeList(const char* moduleType, IFileTypeList* typelist, bool want_load = false, bool want_import = false, bool want_save = false) = 0;
};
#include "modulesystem.h"
public:
INTEGER_CONSTANT(Version, 2);
STRING_CONSTANT(Name, "map");
+ mutable bool wrongFormat;
/// \brief Read a map graph into \p root from \p outputStream, using \p entityTable to create entities.
virtual void readGraph(scene::Node& root, TextInputStream& inputStream, EntityCreator& entityTable) const = 0;
// - 'title' is the dialog title (can be null)
// - 'path' is used to set the initial directory (can be null)
// - 'pattern': the first pattern is for the win32 mode, then comes the Gtk pattern list, see Radiant source for samples
-typedef const char* (* PFN_QERAPP_FILEDIALOG) (GtkWidget *parent, bool open, const char* title, const char* path/* = 0*/, const char* pattern/* = 0*/);
+typedef const char* (* PFN_QERAPP_FILEDIALOG) (GtkWidget *parent, bool open, const char* title, const char* path/* = 0*/, const char* pattern/* = 0*/, bool want_load/* = false*/, bool want_import/* = false*/, bool want_save/* = false*/);
// returns a gchar* string that must be g_free'd by the user
typedef char* (* PFN_QERAPP_DIRDIALOG) (GtkWidget *parent, const char* title/* = "Choose Directory"*/, const char* path/* = 0*/);
// if the spawn was fine
// TODO TTimo add functionality to track the process until it dies
-bool Q_Exec(const char *cmd, char *cmdline, const char *execdir, bool bCreateConsole);
+bool Q_Exec(const char *cmd, char *cmdline, const char *execdir, bool bCreateConsole, bool waitfor);
// some easy portability crap
#if defined (POSIX)
#include <unistd.h>
+#include <sys/types.h>
+#include <sys/wait.h>
-bool Q_Exec(const char *cmd, char *cmdline, const char *, bool)
+bool Q_Exec(const char *cmd, char *cmdline, const char *, bool, bool waitfor)
{
char fullcmd[2048];
char *pCmd;
+ pid_t pid;
#ifdef _DEBUG
printf("Q_Exec damnit\n");
#endif
- switch (fork())
+ switch ((pid = fork()))
{
+ default:
+ if(waitfor)
+ waitpid(pid, NULL, 0);
+ break;
case -1:
return true;
break;
#include <windows.h>
// NOTE TTimo windows is VERY nitpicky about the syntax in CreateProcess
-bool Q_Exec(const char *cmd, char *cmdline, const char *execdir, bool bCreateConsole)
+bool Q_Exec(const char *cmd, char *cmdline, const char *execdir, bool bCreateConsole, bool waitfor)
{
PROCESS_INFORMATION ProcessInformation;
STARTUPINFO startupinfo = {0};
&startupinfo,
&ProcessInformation
))
+ {
+ if(waitfor)
+ WaitForSingleObject(ProcessInformation.hProcess, INFINITE);
return true;
+ }
return false;
}
static char g_file_dialog_file[1024];
-const char* file_dialog_show(GtkWidget* parent, bool open, const char* title, const char* path, const char* pattern)
+const char* file_dialog_show(GtkWidget* parent, bool open, const char* title, const char* path, const char* pattern, bool want_load, bool want_import, bool want_save)
{
filetype_t type;
}
FileTypeList typelist;
- GlobalFiletypes().getTypeList(pattern, &typelist);
+ GlobalFiletypes().getTypeList(pattern, &typelist, want_load, want_import, want_save);
GTKMasks masks(typelist);
return filename;
}
-const char* file_dialog(GtkWidget* parent, bool open, const char* title, const char* path, const char* pattern)
+const char* file_dialog(GtkWidget* parent, bool open, const char* title, const char* path, const char* pattern, bool want_load, bool want_import, bool want_save)
{
for(;;)
{
- const char* file = file_dialog_show(parent, open, title, path, pattern);
+ const char* file = file_dialog_show(parent, open, title, path, pattern, want_load, want_import, want_save);
if(open
|| file == 0
/// GTK+ file-chooser dialogs.
typedef struct _GtkWidget GtkWidget;
-const char* file_dialog(GtkWidget *parent, bool open, const char* title, const char* path = 0, const char* pattern = 0);
+const char* file_dialog(GtkWidget *parent, bool open, const char* title, const char* path = 0, const char* pattern = 0, bool want_load = false, bool want_import = false, bool want_save = false);
/// \brief Prompts the user to browse for a directory.
class MapQ3API : public TypeSystemRef, public MapFormat, public PrimitiveParser
{
+ mutable bool detectedFormat;
public:
typedef MapFormat Type;
STRING_CONSTANT(Name, "mapq3");
MapQ3API()
{
- GlobalFiletypesModule::getTable().addType(Type::Name(), Name(), filetype_t("quake3 maps", "*.map"));
- GlobalFiletypesModule::getTable().addType(Type::Name(), Name(), filetype_t("quake3 region", "*.reg"));
+ GlobalFiletypesModule::getTable().addType(Type::Name(), Name(), filetype_t("quake3 maps", "*.map", true, true, true));
+ GlobalFiletypesModule::getTable().addType(Type::Name(), Name(), filetype_t("quake3 region", "*.reg", true, true, true));
+ GlobalFiletypesModule::getTable().addType(Type::Name(), Name(), filetype_t("quake3 compiled maps", "*.bsp", false, true, false));
}
MapFormat* getTable()
{
{
if(string_equal(primitive, "brushDef"))
{
+ detectedFormat = true;
return GlobalBrushModule::getTable().createBrush();
}
+ else if(!detectedFormat && string_equal(primitive, "("))
+ {
+ detectedFormat = true;
+ wrongFormat = true;
+ Tokeniser_unexpectedError(tokeniser, primitive, "#quake3-switch-to-texdef");
+ return g_nullNode;
+ }
}
else
{
if(string_equal(primitive, "("))
{
+ detectedFormat = true;
tokeniser.ungetToken(); // (
return GlobalBrushModule::getTable().createBrush();
}
+ else if(!detectedFormat && string_equal(primitive, "("))
+ {
+ detectedFormat = true;
+ wrongFormat = true;
+ Tokeniser_unexpectedError(tokeniser, primitive, "#quake3-switch-to-brush-primitives");
+ return g_nullNode;
+ }
}
}
void readGraph(scene::Node& root, TextInputStream& inputStream, EntityCreator& entityTable) const
{
+ detectedFormat = false;
+ wrongFormat = false;
Tokeniser& tokeniser = GlobalScripLibModule::getTable().m_pfnNewSimpleTokeniser(inputStream);
Map_Read(root, tokeniser, entityTable, *this);
tokeniser.release();
void transform(const Matrix4& matrix, bool mirror)
{
if(g_brush_texturelock_enabled)
- {
Texdef_transformLocked(m_texdefTransformed, m_shader.width(), m_shader.height(), m_plane.plane3(), matrix);
- }
m_planeTransformed.transform(matrix, mirror);
ASSERT_MESSAGE(projectionaxis_for_normal(normal) == projectionaxis_for_normal(plane3().normal()), "bleh");
#endif
m_observer->planeChanged();
+
+ if(g_brush_texturelock_enabled)
+ Brush_textureChanged();
}
void assign_planepts(const PlanePoints planepts)
PreferencesDialog_addSettingsPage(FreeCaller1<PreferenceGroup&, Brush_constructPage>());
}
+void Brush_unlatchPreferences()
+{
+ Brush_toggleFormat(0);
+}
+
+void Brush_toggleFormat(int i)
+{
+ if(g_showAlternativeTextureProjectionOption)
+ {
+ g_useAlternativeTextureProjection.m_value = g_useAlternativeTextureProjection.m_latched ^ i;
+ Brush::destroyStatic();
+ Brush::constructStatic(g_useAlternativeTextureProjection.m_value ? eBrushTypeQuake3BP : eBrushTypeQuake3);
+ }
+}
+
+int Brush_toggleFormatCount()
+{
+ if(g_showAlternativeTextureProjectionOption)
+ return 2;
+ return 1;
+}
void Brush_Construct(EBrushType type)
{
#define INCLUDED_BRUSHMODULE_H
void Brush_clipperColourChanged();
+void Brush_unlatchPreferences();
+int Brush_toggleFormatCount();
+void Brush_toggleFormat(int i);
#endif
// enable depth buffer writes
glDepthMask(GL_TRUE);
+ glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
Vector3 clearColour(0, 0, 0);
if(m_Camera.draw_mode != cd_lighting)
struct filetype_copy_t
{
filetype_copy_t(const char* moduleName, const filetype_t other)
- : m_moduleName(moduleName), m_name(other.name), m_pattern(other.pattern)
+ : m_moduleName(moduleName), m_name(other.name), m_pattern(other.pattern), m_can_load(other.can_load), m_can_import(other.can_import), m_can_save(other.can_save)
{
}
const char* getModuleName() const
}
filetype_t getType() const
{
- return filetype_t(m_name.c_str(), m_pattern.c_str());
+ return filetype_t(m_name.c_str(), m_pattern.c_str(), m_can_load, m_can_save, m_can_import);
}
+ bool m_can_load;
+ bool m_can_import;
+ bool m_can_save;
private:
CopiedString m_moduleName;
CopiedString m_name;
{
m_typelists[moduleType].push_back(filetype_copy_t(moduleName, type));
}
- void getTypeList(const char* moduleType, IFileTypeList* typelist)
+ void getTypeList(const char* moduleType, IFileTypeList* typelist, bool want_load, bool want_import, bool want_save)
{
filetype_list_t& list_ref = m_typelists[moduleType];
for(filetype_list_t::iterator i = list_ref.begin(); i != list_ref.end(); ++i)
{
+ if(want_load && !(*i).m_can_load) return;
+ if(want_import && !(*i).m_can_import) return;
+ if(want_save && !(*i).m_can_save) return;
typelist->addType((*i).getModuleName(), (*i).getType());
}
}
globalOutputStream() << "Launching: " << strEditCommand.c_str() << "\n";
// note: linux does not return false if the command failed so it will assume success
- if (Q_Exec(0, const_cast<char*>(strEditCommand.c_str()), 0, true) == false)
+ if (Q_Exec(0, const_cast<char*>(strEditCommand.c_str()), 0, true, false) == false)
{
globalOutputStream() << "Failed to execute " << strEditCommand.c_str() << ", using default\n";
}
#include "debugging/debugging.h"
#include "imap.h"
+MapModules& ReferenceAPI_getMapModules();
#include "iselection.h"
#include "iundo.h"
#include "ibrush.h"
#include "mru.h"
#include "commands.h"
#include "autosave.h"
+#include "brushmodule.h"
+#include "brush.h"
class NameObserver
{
FlushReferences();
g_currentMap = 0;
+ Brush_unlatchPreferences();
}
class EntityFindByClassname : public scene::Graph::Walker
globalOutputStream() << "Loading map from " << filename << "\n";
ScopeDisableScreenUpdates disableScreenUpdates("Processing...", "Loading Map");
- g_map.m_name = filename;
- Map_UpdateTitle(g_map);
-
{
ScopeTimer timer("map load");
- g_map.m_resource = GlobalReferenceCache().capture(g_map.m_name.c_str());
- g_map.m_resource->attach(g_map);
+ const MapFormat* format = NULL;
+ const char* moduleName = findModuleName(&GlobalFiletypes(), MapFormat::Name(), path_get_extension(filename));
+ if(string_not_empty(moduleName))
+ format = ReferenceAPI_getMapModules().findModule(moduleName);
+
+ for(int i = 0; i < Brush_toggleFormatCount(); ++i)
+ {
+ if(i)
+ Map_Free();
+ Brush_toggleFormat(i);
+ g_map.m_name = filename;
+ Map_UpdateTitle(g_map);
+ g_map.m_resource = GlobalReferenceCache().capture(g_map.m_name.c_str());
+ if(format)
+ format->wrongFormat = false;
+ g_map.m_resource->attach(g_map);
+ if(format)
+ if(!format->wrongFormat)
+ break;
+ }
Node_getTraversable(GlobalSceneGraph().root())->traverse(entity_updateworldspawn());
}
ScopeDisableScreenUpdates disableScreenUpdates("Processing...", "Loading Map");
bool success = false;
+
+ if(extension_equal(path_get_extension(filename), "bsp"))
+ goto tryDecompile;
+
{
Resource* resource = GlobalReferenceCache().capture(filename);
resource->refresh(); // avoid loading old version if map has changed on disk since last import
- if(resource->load())
+ if(!resource->load())
{
- NodeSmartReference clone(NewMapRoot(""));
-
- {
- //ScopeTimer timer("clone subgraph");
- Node_getTraversable(*resource->getNode())->traverse(CloneAll(clone));
- }
-
- Map_gatherNamespaced(clone);
- Map_mergeClonedNames();
- MergeMap(clone);
- success = true;
+ GlobalReferenceCache().release(filename);
+ goto tryDecompile;
}
+ NodeSmartReference clone(NewMapRoot(""));
+ Node_getTraversable(*resource->getNode())->traverse(CloneAll(clone));
+ Map_gatherNamespaced(clone);
+ Map_mergeClonedNames();
+ MergeMap(clone);
+ success = true;
GlobalReferenceCache().release(filename);
}
- SceneChangeNotify();
+ SceneChangeNotify();
return success;
+
+tryDecompile:
+
+ const char *type = GlobalRadiant().getRequiredGameDescriptionKeyValue("q3map2_type");
+ int n = string_length(path_get_extension(filename));
+ if(n && (extension_equal(path_get_extension(filename), "bsp") || extension_equal(path_get_extension(filename), "map")))
+ {
+ StringBuffer output;
+ output.push_string(AppPath_get());
+ output.push_string("q3map2.");
+ output.push_string(RADIANT_EXECUTABLE);
+ output.push_string(" -v -game ");
+ output.push_string((type && *type) ? type : "quake3");
+ output.push_string(" -fs_basepath \"");
+ output.push_string(EnginePath_get());
+ output.push_string("\" -fs_game ");
+ output.push_string(gamename_get());
+ output.push_string(" -convert -format ");
+ output.push_string(Brush::m_type == eBrushTypeQuake3BP ? "map_bp" : "map");
+ output.push_string(" \"");
+ output.push_string(filename);
+ output.push_string("\"");
+
+ // run
+ Q_Exec(NULL, output.c_str(), NULL, false, true);
+
+ // rebuild filename as "filenamewithoutext_converted.map"
+ output.clear();
+ output.push_range(filename, filename + string_length(filename) - (n + 1));
+ output.push_string("_converted.map");
+ filename = output.c_str();
+
+ // open
+ Resource* resource = GlobalReferenceCache().capture(filename);
+ resource->refresh(); // avoid loading old version if map has changed on disk since last import
+ if(!resource->load())
+ {
+ GlobalReferenceCache().release(filename);
+ goto tryDecompile;
+ }
+ NodeSmartReference clone(NewMapRoot(""));
+ Node_getTraversable(*resource->getNode())->traverse(CloneAll(clone));
+ Map_gatherNamespaced(clone);
+ Map_mergeClonedNames();
+ MergeMap(clone);
+ success = true;
+ GlobalReferenceCache().release(filename);
+ }
+
+ SceneChangeNotify();
+ return success;
}
/*
const char* map_open(const char* title)
{
- return file_dialog(GTK_WIDGET(MainFrame_getWindow()), TRUE, title, getMapsPath(), MapFormat::Name());
+ return file_dialog(GTK_WIDGET(MainFrame_getWindow()), TRUE, title, getMapsPath(), MapFormat::Name(), true, false, false);
+}
+
+const char* map_import(const char* title)
+{
+ return file_dialog(GTK_WIDGET(MainFrame_getWindow()), TRUE, title, getMapsPath(), MapFormat::Name(), false, true, false);
}
const char* map_save(const char* title)
{
- return file_dialog(GTK_WIDGET(MainFrame_getWindow()), FALSE, title, getMapsPath(), MapFormat::Name());
+ return file_dialog(GTK_WIDGET(MainFrame_getWindow()), FALSE, title, getMapsPath(), MapFormat::Name(), false, false, true);
}
void OpenMap()
void ImportMap()
{
- const char* filename = map_open("Import Map");
+ const char* filename = map_import("Import Map");
if(filename != 0)
{
#endif
globalOutputStream() << "Writing the compile script to '" << batpath << "'\n";
globalOutputStream() << "The build output will be saved in '" << junkpath << "'\n";
- Q_Exec(batpath, NULL, NULL, true);
+ Q_Exec(batpath, NULL, NULL, true, false);
}
}
globalOutputStream() << "=== running build command ===\n"
<< static_cast<const char*>(g_ptr_array_index( m_pCmd, m_iCurrentStep )) << "\n";
- if (!Q_Exec(NULL, (char *)g_ptr_array_index( m_pCmd, m_iCurrentStep ), NULL, true ))
+ if (!Q_Exec(NULL, (char *)g_ptr_array_index( m_pCmd, m_iCurrentStep ), NULL, true, false ))
{
StringOutputStream msg(256);
msg << "Failed to execute the following command: ";
globalOutputStream() << cmd.c_str() << " " << cmdline.c_str() << "\n";
// execute now
- if (!Q_Exec(cmd.c_str(), (char *)cmdline.c_str(), EnginePath_get(), false))
+ if (!Q_Exec(cmd.c_str(), (char *)cmdline.c_str(), EnginePath_get(), false, false))
{
StringOutputStream msg;
msg << "Failed to execute the following command: " << cmd.c_str() << cmdline.c_str();
numEntities = 0;
LoadShaderInfo();
- LoadMapFile( name, qfalse );
+ LoadMapFile( name, qfalse, qfalse );
SetModelNumbers();
SetLightStyles();
/* load original file from temp spot in case it was renamed by the editor on the way in */
if( strlen( tempSource ) > 0 )
- LoadMapFile( tempSource, qfalse );
+ LoadMapFile( tempSource, qfalse, qfalse );
else
- LoadMapFile( name, qfalse );
+ LoadMapFile( name, qfalse, qfalse );
/* div0: inject command line parameters */
InjectCommandLine(argv, 1, argc - 1);
ProcessAdvertisements();
/* finish and write bsp */
- EndBSPFile();
+ EndBSPFile(qtrue);
/* remove temp map source file if appropriate */
if( strlen( tempSource ) > 0)
if(strncmp(buildSide->shaderInfo->shader, "textures/common/", 16))
if(strcmp(buildSide->shaderInfo->shader, "noshader"))
if(strcmp(buildSide->shaderInfo->shader, "default"))
+ {
fprintf(stderr, "no matching triangle for brushside using %s (hopefully nobody can see this side anyway)\n", buildSide->shaderInfo->shader);
+ texture = "common/WTF";
+ }
MakeNormalVectors( buildPlane->normal, vecs[ 0 ], vecs[ 1 ] );
VectorMA( vec3_origin, buildPlane->dist, buildPlane->normal, pts[ 0 ] );
/* load map file */
value = ValueForKey( &entities[ 0 ], "_keepLights" );
if( value[ 0 ] != '1' )
- LoadMapFile( mapSource, qtrue );
+ LoadMapFile( mapSource, qtrue, qfalse );
/* set the entity/model origins and init yDrawVerts */
SetEntityOrigins();
}
+/*
+PseudoCompileBSP()
+a stripped down ProcessModels
+*/
+void PseudoCompileBSP(qboolean need_tree)
+{
+ int models;
+ char modelValue[10];
+ entity_t *entity;
+ face_t *faces;
+ tree_t *tree;
+ node_t *node;
+ brush_t *brush;
+ side_t *side;
+ int i;
+
+ SetDrawSurfacesBuffer();
+ mapDrawSurfs = safe_malloc( sizeof( mapDrawSurface_t ) * MAX_MAP_DRAW_SURFS );
+ memset( mapDrawSurfs, 0, sizeof( mapDrawSurface_t ) * MAX_MAP_DRAW_SURFS );
+ numMapDrawSurfs = 0;
+
+ BeginBSPFile();
+ models = 1;
+ for( mapEntityNum = 0; mapEntityNum < numEntities; mapEntityNum++ )
+ {
+ /* get entity */
+ entity = &entities[ mapEntityNum ];
+ if( entity->brushes == NULL && entity->patches == NULL )
+ continue;
+
+ if(mapEntityNum != 0)
+ {
+ sprintf( modelValue, "*%d", models++);
+ SetKeyValue(entity, "model", modelValue);
+ }
+
+ /* process the model */
+ Sys_FPrintf( SYS_VRB, "############### model %i ###############\n", numBSPModels );
+ BeginModel();
+
+ entity->firstDrawSurf = numMapDrawSurfs;
+
+ if(mapEntityNum == 0 && need_tree)
+ {
+ faces = MakeStructuralBSPFaceList(entities[0].brushes);
+ tree = FaceBSP(faces);
+ node = tree->headnode;
+ }
+ else
+ {
+ node = AllocNode();
+ node->planenum = PLANENUM_LEAF;
+ tree = AllocTree();
+ tree->headnode = node;
+ }
+
+ /* a minimized ClipSidesIntoTree */
+ for( brush = entity->brushes; brush; brush = brush->next )
+ {
+ /* walk the brush sides */
+ for( i = 0; i < brush->numsides; i++ )
+ {
+ /* get side */
+ side = &brush->sides[ i ];
+ if( side->winding == NULL )
+ continue;
+ /* shader? */
+ if( side->shaderInfo == NULL )
+ continue;
+ /* save this winding as a visible surface */
+ DrawSurfaceForSide(entity, brush, side, side->winding);
+ }
+ }
+
+ FilterDrawsurfsIntoTree(entity, tree);
+ FilterStructuralBrushesIntoTree(entity, tree);
+ FilterDetailBrushesIntoTree(entity, tree);
+
+ EmitBrushes(entity->brushes, &entity->firstBrush, &entity->numBrushes );
+ EndModel(entity, node);
+ }
+ EndBSPFile(qfalse);
+}
/*
ConvertBSPMain()
int i;
int (*convertFunc)( char * );
game_t *convertGame;
+ char ext[1024];
+ qboolean map_allowed;
/* set default */
convertFunc = ConvertBSPToASE;
convertGame = NULL;
+ map_allowed = qtrue;
/* arg checking */
if( argc < 1 )
{
i++;
if( !Q_stricmp( argv[ i ], "ase" ) )
+ {
convertFunc = ConvertBSPToASE;
+ map_allowed = qfalse;
+ }
else if( !Q_stricmp( argv[ i ], "map_bp" ) )
+ {
convertFunc = ConvertBSPToMap_BP;
+ map_allowed = qtrue;
+ }
else if( !Q_stricmp( argv[ i ], "map" ) )
+ {
convertFunc = ConvertBSPToMap;
+ map_allowed = qtrue;
+ }
else
{
convertGame = GetGame( argv[ i ] );
+ map_allowed = qfalse;
if( convertGame == NULL )
Sys_Printf( "Unknown conversion format \"%s\". Defaulting to ASE.\n", argv[ i ] );
}
else if( !strcmp( argv[ i ], "-shadersasbitmap" ) )
shadersAsBitmap = qtrue;
}
-
- /* clean up map name */
- strcpy( source, ExpandArg( argv[ i ] ) );
- StripExtension( source );
- DefaultExtension( source, ".bsp" );
-
+
LoadShaderInfo();
- Sys_Printf( "Loading %s\n", source );
-
- /* ydnar: load surface file */
- //% LoadSurfaceExtraFile( source );
-
- LoadBSPFile( source );
-
- /* parse bsp entities */
- ParseEntities();
+ /* clean up map name */
+ strcpy(source, ExpandArg(argv[i]));
+ ExtractFileExtension(source, ext);
+ if(!Q_stricmp(ext, "map"))
+ {
+ if(!map_allowed)
+ Sys_Printf("WARNING: the requested conversion should not be done from .map files. Compile a .bsp first.\n");
+ StripExtension(source);
+ DefaultExtension(source, ".map");
+ Sys_Printf("Loading %s\n", source);
+ LoadMapFile(source, qfalse, convertGame == NULL);
+ PseudoCompileBSP(convertGame != NULL);
+ }
+ else
+ {
+ StripExtension(source);
+ DefaultExtension(source, ".bsp");
+ Sys_Printf("Loading %s\n", source);
+ LoadBSPFile(source);
+ ParseEntities();
+ }
/* bsp format convert? */
if( convertGame != NULL )
SetKeyValue(ent, "origin", string);
}
-brush_t *FinishBrush( void )
+brush_t *FinishBrush( qboolean noCollapseGroups )
{
brush_t *b;
}
/* add bevel planes */
- AddBrushBevels();
+ if(!noCollapseGroups)
+ AddBrushBevels();
/* keep it */
b = CopyBrush( buildBrush );
parses a brush out of a map file and sets it up
*/
-static void ParseBrush( qboolean onlyLights )
+static void ParseBrush( qboolean onlyLights, qboolean noCollapseGroups )
{
brush_t *b;
}
/* finish the brush */
- b = FinishBrush();
+ b = FinishBrush(noCollapseGroups);
}
parses a single entity out of a map file
*/
-static qboolean ParseMapEntity( qboolean onlyLights )
+static qboolean ParseMapEntity( qboolean onlyLights, qboolean noCollapseGroups )
{
epair_t *ep;
const char *classname, *value;
g_bBrushPrimit = BPRIMIT_NEWBRUSHES;
/* parse brush primitive */
- ParseBrush( onlyLights );
+ ParseBrush( onlyLights, noCollapseGroups );
}
else
{
/* parse old brush format */
UnGetToken();
- ParseBrush( onlyLights );
+ ParseBrush( onlyLights, noCollapseGroups );
}
entitySourceBrushes++;
}
AdjustBrushesForOrigin( mapEnt );
/* group_info entities are just for editor grouping (fixme: leak!) */
- if( !Q_stricmp( "group_info", classname ) )
+ if( !noCollapseGroups && !Q_stricmp( "group_info", classname ) )
{
numEntities--;
return qtrue;
}
/* group entities are just for editor convenience, toss all brushes into worldspawn */
- if( funcGroup )
+ if( !noCollapseGroups && funcGroup )
{
MoveBrushesToWorld( mapEnt );
numEntities--;
loads a map file into a list of entities
*/
-void LoadMapFile( char *filename, qboolean onlyLights )
+void LoadMapFile( char *filename, qboolean onlyLights, qboolean noCollapseGroups )
{
FILE *file;
brush_t *b;
buildBrush = AllocBrush( MAX_BUILD_SIDES );
/* parse the map file */
- while( ParseMapEntity( onlyLights ) );
+ while( ParseMapEntity( onlyLights, noCollapseGroups ) );
/* light loading */
if( onlyLights )
/* map.c */
-void LoadMapFile( char *filename, qboolean onlyLights );
+void LoadMapFile( char *filename, qboolean onlyLights, qboolean noCollapseGroups );
int FindFloatPlane( vec3_t normal, vec_t dist, int numPoints, vec3_t *points );
int PlaneTypeForNormal( vec3_t normal );
void AddBrushBevels( void );
-brush_t *FinishBrush( void );
+brush_t *FinishBrush(qboolean noCollapseGroups);
/* portals.c */
int EmitShader( const char *shader, int *contentFlags, int *surfaceFlags );
void BeginBSPFile( void );
-void EndBSPFile( void );
+void EndBSPFile( qboolean do_write );
void EmitBrushes( brush_t *brushes, int *firstBrush, int *numBrushes );
void EmitFogs( void );
finishes a new bsp and writes to disk
*/
-void EndBSPFile( void )
+void EndBSPFile(qboolean do_write)
{
char path[ 1024 ];
numBSPEntities = numEntities;
UnparseEntities();
- /* write the surface extra file */
- WriteSurfaceExtraFile( source );
-
- /* write the bsp */
- sprintf( path, "%s.bsp", source );
- Sys_Printf( "Writing %s\n", path );
- WriteBSPFile( path );
+ if(do_write)
+ {
+ /* write the surface extra file */
+ WriteSurfaceExtraFile( source );
+
+ /* write the bsp */
+ sprintf( path, "%s.bsp", source );
+ Sys_Printf( "Writing %s\n", path );
+ WriteBSPFile( path );
+ }
}
projects / xonotic / netradiant.git / commitdiff