gtkradiant/radiant/pluginmanager.h

/*
   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_