mirror of
https://github.com/TTimo/GtkRadiant.git
synced 2024-11-10 07:11:54 +00:00
8aeff6b09a
The STL now defines `std::byte` so doing `using namespace std`
will conflict will custom definition of `byte`, which this
legacy code is full of.
It looks like NetRadiant went the route of making explicit
usage of `std::` prefixed types and did not renamed the
custom definition of byte, so doing the same reduces diff
noise between the two trees.
This also makes the code future proof if the STL decides
to define some other types with common name.
This patches replaces all usages of `map`, `pair` and
`vector` with `std::map`, `std::pair` and `std::vector`
and remove the `using namespace std` line in `stl_check.h`.
```
libs/mathlib.h:132:44: error: reference to ‘byte’ is ambiguous
132 | void NormalToLatLong( const vec3_t normal, byte bytes[2] );
| ^~~~
In file included from /usr/include/c++/11/bits/stl_algobase.h:61,
from /usr/include/c++/11/bits/char_traits.h:39,
from /usr/include/c++/11/ios:40,
from /usr/include/c++/11/ostream:38,
from /usr/include/c++/11/iostream:39,
from libs/missing.h:76,
from radiant/qe3.h:40,
from radiant/stdafx.h:39,
from radiant/bp_dlg.cpp:28:
/usr/include/c++/11/bits/cpp_type_traits.h:404:30: note: candidates are: ‘enum class std::byte’
404 | enum class byte : unsigned char;
| ^~~~
```
212 lines
6.6 KiB
C++
212 lines
6.6 KiB
C++
/*
|
|
Copyright (C) 1999-2007 id Software, Inc. and contributors.
|
|
For a list of contributors, see the accompanying CONTRIBUTORS file.
|
|
|
|
This file is part of GtkRadiant.
|
|
|
|
GtkRadiant 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.
|
|
|
|
GtkRadiant 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 GtkRadiant; if not, write to the Free Software
|
|
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
|
|
*/
|
|
|
|
#ifndef _PLUGINMANAGER_H_
|
|
#define _PLUGINMANAGER_H_
|
|
|
|
#include "plugin.h"
|
|
|
|
// global interfaces we are using
|
|
extern _QERShadersTable g_ShadersTable;
|
|
|
|
// NOTE: it's actually a module manager, the name should change to ModuleManager..
|
|
class CPlugInManager
|
|
{
|
|
private:
|
|
GSList* m_PlugIns;
|
|
CPtrArray m_BrushHandles;
|
|
CPtrArray m_SelectedBrushHandles;
|
|
CPtrArray m_ActiveBrushHandles;
|
|
|
|
// v1.70
|
|
//! brushes of the current entity ( see m_SelectedBrushHandles and m_ActiveBrushHandles )
|
|
CPtrArray m_EntityBrushHandles;
|
|
//! allocated entities, not commited yet ( see m_BrushHandles )
|
|
CPtrArray m_EntityHandles;
|
|
|
|
//! tells in which array to look when given a patch index
|
|
enum EPatchesMode { EActivePatches, ESelectedPatches, EAllocatedPatches } PatchesMode;
|
|
//! patches handles (brush_t*)
|
|
CPtrArray m_PatchesHandles;
|
|
//! plugin-allocated patches, not commited yet (patchMesh_t*)
|
|
CPtrArray m_PluginPatches;
|
|
|
|
void InitForDir( const Str &dir ); ///< init for plguins/modules below this directory
|
|
|
|
public:
|
|
CPtrArray& GetActiveHandles() {return m_ActiveBrushHandles; };
|
|
CPtrArray& GetSelectedHandles() {return m_SelectedBrushHandles; };
|
|
CPtrArray& GetPluginPatches() {return m_PluginPatches; };
|
|
brush_t* FindBrushHandle( void *vp );
|
|
patchMesh_t* FindPatchHandle( int index );
|
|
int CreatePatchHandle();
|
|
int AllocateActivePatchHandles();
|
|
int AllocateSelectedPatchHandles();
|
|
void CommitPatchHandleToMap( int index, patchMesh_t *pMesh, char *texName );
|
|
void CommitPatchHandleToEntity( int index, patchMesh_t *pMesh, char *texName, void *vpEntity );
|
|
void ReleasePatchesHandles() { m_PatchesHandles.RemoveAll(); m_PluginPatches.RemoveAll(); }
|
|
void AddFaceToBrushHandle( void *vp, vec3_t v1, vec3_t v2, vec3_t v3 );
|
|
void CommitBrushHandleToMap( void *vp );
|
|
void DeleteBrushHandle( void* vp );
|
|
void* CreateBrushHandle();
|
|
void Dispatch( int n, const char *p );
|
|
void Cleanup(); ///< cleanup of data structures allocated for plugins, not a plugin reload
|
|
void Init(); ///< go through the path where we will find modules and plugins
|
|
void LoadImage( const char *name, unsigned char **pic, int *width, int *height );
|
|
void ImportMap( IDataStream *in, CPtrArray *ents, const char *type );
|
|
void ExportMap( CPtrArray *ents, IDataStream *out, const char *type );
|
|
void Shutdown(); ///< shutdown all the plugins/module subsystem
|
|
CPlugInManager();
|
|
virtual ~CPlugInManager();
|
|
|
|
/*!
|
|
the texture manager front ends the single load
|
|
addins (texture, model, map formats.. etc.)
|
|
*/
|
|
_QERTextureInfo* GetTextureInfo();
|
|
void LoadTexture( const char *pFilename );
|
|
|
|
void* GetSurfaceFlags();
|
|
|
|
// v1.70
|
|
CPtrArray& GetEntityBrushHandles() {return m_EntityBrushHandles; };
|
|
CPtrArray& GetEntityHandles() {return m_EntityHandles; };
|
|
//! the vpBrush needs to be in m_BrushHandles
|
|
void CommitBrushHandleToEntity( void* vpBrush, void* vpEntity );
|
|
//! the vpEntity needs to be in m_EntityHandles
|
|
void CommitEntityHandleToMap( void* vpEntity );
|
|
|
|
protected:
|
|
//! read the interfaces this plugin implements
|
|
void LoadFromPath( const char *path ); ///< load all modules/plugins in specified path
|
|
void RegisterInterfaces();
|
|
};
|
|
|
|
class CPluginSlot : public IPlugIn
|
|
{
|
|
APIDescriptor_t *mpAPI;
|
|
_QERPluginTable *mpTable;
|
|
/*!
|
|
is false until Init() happened
|
|
*/
|
|
bool m_bReady;
|
|
/*!
|
|
below is valid only if m_bReady = true
|
|
*/
|
|
GSList *m_CommandStrings;
|
|
GSList *m_CommandIDs;
|
|
|
|
public:
|
|
/*!
|
|
build directly from a SYN_PROVIDE interface
|
|
*/
|
|
CPluginSlot( APIDescriptor_t *pAPI );
|
|
virtual ~CPluginSlot();
|
|
|
|
APIDescriptor_t* GetDescriptor() { return mpAPI; }
|
|
/*!
|
|
initialize some management data after the synapse interfaces have been hooked up
|
|
*/
|
|
void Init();
|
|
/*!
|
|
dispatching a command by name to the plugin
|
|
*/
|
|
void Dispatch( const char *p );
|
|
|
|
// IPlugIn ------------------------------------------------------------
|
|
const char* getMenuName();
|
|
int getCommandCount();
|
|
const char* getCommand( int n );
|
|
void addMenuID( int n );
|
|
bool ownsCommandID( int n );
|
|
|
|
};
|
|
|
|
class CRadiantPluginManager : public CSynapseAPIManager
|
|
{
|
|
std::list<CPluginSlot *> mSlots;
|
|
public:
|
|
CRadiantPluginManager() {}
|
|
virtual ~CRadiantPluginManager();
|
|
|
|
// CSynapseAPIManager interface -------------------
|
|
APIDescriptor_t *BuildRequireAPI( APIDescriptor_t *pAPI );
|
|
|
|
// CRadiantPluginManager --------------------------
|
|
void PopulateMenu();
|
|
bool Dispatch( int n, const char* p );
|
|
};
|
|
|
|
class CImageTableSlot
|
|
{
|
|
/*!
|
|
\todo this is a duplicate from the APIDescriptor_t* list that privately stored inside CSynapseAPIManager
|
|
this is probably useless to us in here?
|
|
*/
|
|
APIDescriptor_t *mpAPI;
|
|
/*!
|
|
shortcut to mpAPI->mpTable, with correct typing
|
|
this is what we allocate and should free locally
|
|
*/
|
|
_QERPlugImageTable *mpTable;
|
|
public:
|
|
CImageTableSlot() { }
|
|
virtual ~CImageTableSlot() { } ///\ \todo need to correctly free and release still..
|
|
|
|
APIDescriptor_t* GetDescriptor() { return mpAPI; }
|
|
_QERPlugImageTable* GetTable() { return mpTable; }
|
|
|
|
/*!
|
|
don't go through PrepareRequireAPI for init, just get this API and add the table info
|
|
*/
|
|
void InitForFillAPITable( APIDescriptor_t *pAPI );
|
|
};
|
|
|
|
class CRadiantImageManager : public CSynapseAPIManager
|
|
{
|
|
std::list<CImageTableSlot *> mSlots;
|
|
|
|
std::list<CImageTableSlot *>::iterator mExtScanSlot;
|
|
public:
|
|
CRadiantImageManager() {}
|
|
virtual ~CRadiantImageManager();
|
|
|
|
// CSynapseAPIManager interface --------------------
|
|
void FillAPITable( APIDescriptor_t *pAPI );
|
|
|
|
// CRadiantImageManager ----------------------------
|
|
/*!
|
|
extract the extension, go through the list of image interfaces, and load
|
|
*/
|
|
void LoadImage( const char *name, byte **pic, int *width, int *height );
|
|
|
|
/*!
|
|
we often need to walk through the extensions
|
|
this used to be hardcoded in texwindow.cpp
|
|
the two functions are related, they use a static to go through the list
|
|
*/
|
|
void BeginExtensionsScan();
|
|
const char* GetNextExtension(); ///< \return NULL when the list has been completely scanned
|
|
};
|
|
|
|
extern CRadiantImageManager g_ImageManager;
|
|
|
|
#endif // _PLUGINMANAGER_H_
|