From 952c5c128f9efaea89d41d882c4ea3ade7df4591 Mon Sep 17 00:00:00 2001 From: zakk Date: Fri, 26 Aug 2005 04:48:05 +0000 Subject: Itsa me, quake3io! git-svn-id: svn://svn.icculus.org/quake3/trunk@2 edf5b092-35ff-0310-97b2-ce42778d08ea --- q3radiant/qerplugin.h | 566 ++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 566 insertions(+) create mode 100755 q3radiant/qerplugin.h (limited to 'q3radiant/qerplugin.h') diff --git a/q3radiant/qerplugin.h b/q3radiant/qerplugin.h new file mode 100755 index 0000000..97d55d9 --- /dev/null +++ b/q3radiant/qerplugin.h @@ -0,0 +1,566 @@ +/* +=========================================================================== +Copyright (C) 1999-2005 Id Software, Inc. + +This file is part of Quake III Arena source code. + +Quake III Arena source code 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. + +Quake III Arena source code 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 Foobar; if not, write to the Free Software +Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA +=========================================================================== +*/ +// QERadiant PlugIns +// +// + +#ifndef __QERPLUGIN_H__ +#define __QERPLUGIN_H__ + +#include +#include "qertypes.h" + +#define QER_PLUG_VERSION_1 1.00 +#define QER_PLUG_VERSION 1.70f + +#define QER_MAX_NAMELEN 1024 + +// the editor will look for plugins in two places, the plugins path +// under the application path, and the path under the basepath as defined +// in the project (.qe4) file. +// +// you can drop any number of new texture, model format DLL's in the standard plugin path +// but only one plugin that overrides map loading/saving, surface dialog, surface flags, etc.. +// should be used at one time.. if multiples are loaded then the last one loaded will be the +// active one +// +// type of services the plugin supplies, pass any combo of these flags +// it is assumed the plugin will have a matching function as defined below +// to correlate to the implied functionality +// +// FIXME: after specing this crap i went to a simpler model so this may disappear +#define QER_PLUG_GAME_TEXTURE 0x0001 // defines new texture format +#define QER_PLUG_GAME_MODEL 0x0002 // defines new model format +#define QER_PLUG_GAME_MAP 0x0004 // handles map load/save +#define QER_PLUG_GAME_SURFACEDLG 0x0008 // handles surface dialog +#define QER_PLUG_GAME_SURFACEFLAGS 0x0010 // renames surface/content names + +// basics +#define QERPLUG_INIT "QERPlug_Init" +#define QERPLUG_GETNAME "QERPlug_GetName" +#define QERPLUG_GETCOMMANDLIST "QERPlug_GetCommandList" +#define QERPLUG_DISPATCH "QERPlug_Dispatch" +#define QERPLUG_GETFUNCTABLE "QERPlug_GetFuncTable" + +// FIXME: not used, probably should remove +#define QERPLUG_GETSERVICETPE "QERPlug_GetServiceType" + +// game stuff +#define QERPLUG_GETTEXTUREINFO "QERPlug_GetTextureInfo" // gets a texture info structure +#define QERPLUG_LOADTEXTURE "QERPlug_LoadTexture" // loads a texture, will return an RGBA structure + // and any surface flags/contents for it +#define QERPLUG_GETTMODELINFO "QERPlug_GetModelInfo" // gets a model info structure +#define QERPLUG_LOADMODEL "QERPlug_LoadModel" // loads model data from a plugin +#define QERPLUG_DOSURFACEDLG "QERPlug_DoSurfaceDlg" // runs the surface dialog in a plugin + // this is going to get icky +#define QERPLUG_GETSURFACEFLAGS "QERPlug_GetSurfaceFlags" // gets a list of surface/content flag names from a plugin + +struct _QERTextureInfo +{ + char m_TextureExtension[QER_MAX_NAMELEN]; // the extension these textures have + qboolean m_bHiColor; // if textures are NOT high color, the default + // palette (as described inthe qe4 file will be used for gamma correction) + // if they are high color, gamma and shading are computed on the fly + // based on the rgba data + //--bool m_bIsShader; // will probably do q3 shaders this way when i merge + qboolean m_bWadStyle; // if this is true, the plugin will be presented with the texture path + // defined in the .qe4 file and is expected to preload all the textures + qboolean m_bHalfLife; // causes brushes to be saved/parsed without the surface contents/flags/value +}; + +struct _QERTextureLoad // returned by a plugin +{ + _QERTextureLoad() + { + memset(reinterpret_cast(this), 0, sizeof(_QERTextureLoad)); + }; + + ~_QERTextureLoad() + { + delete []m_pRGBA; + delete []m_pName; + }; + + void makeSpace(int nSize) + { + m_pRGBA = new unsigned char[nSize+1]; + }; + + void setName(const char* p) + { + m_pName = new char[strlen(p)+1]; + strcpy(m_pName, p); + }; + + + unsigned char *m_pRGBA; // rgba data (alpha channel is supported and drawn appropriately) + int m_nWidth; // width + int m_nHeight; // height + int m_nContents; // default contents + int m_nFlags; // "" flags + int m_nValue; // "" value + char *m_pName; // name to be referenced in map, build tools, etc. +}; + +struct _QERModelInfo +{ + char m_ModelExtension[QER_MAX_NAMELEN]; + bool m_bSkinned; + bool m_bMultipart; +}; + +struct _QERModelLoad +{ + // vertex and skin data +}; + + +// hook functions +// FIXME: none of the hook stuff works for v1.00 +#define QERPLUG_MAPLOAD "QERPlug_MapLoad" +#define QERPLUG_MAPSAVE "QERPlug_MapSave" + +//========================================= +// plugin functions version 1.0 +typedef LPCSTR (WINAPI* PFN_QERPLUG_INIT)(HMODULE hApp, HWND hwndMain); +typedef LPCSTR (WINAPI* PFN_QERPLUG_GETNAME)(); +typedef LPCSTR (WINAPI* PFN_QERPLUG_GETCOMMANDLIST)(); +typedef void (WINAPI* PFN_QERPLUG_DISPATCH)(LPCSTR p, vec3_t vMin, vec3_t vMax, BOOL bSingleBrush); +typedef LPVOID (WINAPI* PFN_QERPLUG_GETFUNCTABLE)(); +typedef void (WINAPI* PFN_QERPLUG_MAPLOAD)(); +typedef void (WINAPI* PFN_QERPLUG_MAPSAVE)(); + +// editor defined plugin dispatches +// these are used to signal the completion after a 'Get' function is called in the editor +#define QERPLUG_DISPATCH_POINTDONE "PointDone" +#define QERPLUG_DISPATCH_BRUSHDONE "BrushDone" + +// v1.5 +// +// Texture loading +// returns a ptr to _QERTextureInfo +typedef LPVOID (WINAPI* PFN_QERPLUG_GETTEXTUREINFO)(); +// +// loads a texture by calling the texture load func in the editor (defined below) +// transparency (for water, fog, lava, etc.. ) can be emulated in the editor +// by passing in appropriate alpha data or by setting the appropriate surface flags +// expected by q2 (which the editor will use.. ) +typedef void (WINAPI* PFN_QERPLUG_LOADTEXTURE)(LPCSTR pFilename); + +// v1.6 +typedef LPVOID (WINAPI* PFN_QERPLUG_GETSURFACEFLAGS)(); + +// v1.7 +// if exists in plugin, gets called between INIT and GETCOMMANDLIST +// the plugin can register the EClasses he wants to handle +//++timo TODO: this has got to move into the table, and be requested by QERPlug_RequestInterface +//++timo FIXME: the LPVOID parameter must be casted to an IEpair interface +#define QERPLUG_REGISTERPLUGINENTITIES "QERPlug_RegisterPluginEntities" +typedef void (WINAPI* PFN_QERPLUG_REGISTERPLUGINENTITIES)( LPVOID ); +// if exists in plugin, gets called between INIT and GETCOMMANDLIST +// the plugin can Init all it needs for surface properties +#define QERPLUG_INITSURFACEPROPERTIES "QERPlug_InitSurfaceProperties" +typedef void (WINAPI* PFN_QERPLUG_INITSURFACEPROPERTIES)(); +// if Radiant needs to use a particular set of commands, it can request the plugin to fill a func table +// this is similar to PFN_QERAPP_REQUESTINTERFACE +#define QERPLUG_REQUESTINTERFACE "QERPlug_RequestInterface" +typedef int (WINAPI* PFN_QERPLUG_REQUESTINTERFACE)( REFGUID, LPVOID ); + +//========================================= +// editor functions + +// There are 3 potential brush handle lists +// 1. the list that contains brushes a plugin creates using CreateBrushHandle +// 2. the selected brush list (brushes the user has selected) +// 3. the active brush list (brushes in the map that are not selected) +// +// In general, the same things can be done to brush handles (face manip, delete brushhandle, etc.. ) in each +// list. There are a few exceptions. +// 1. You cannot commit a selected or active brush handle to the map. This is because it is already in the map. +// 2. You cannot bind brush handles from the selected or active brush list to an entity. As of v1.0 of the plugins +// the only way for a plugin to create entities is to create a brush handles (or a list of handles) and then bind +// them to an entity. This will commit the brush(s) and/or the entities to the map as well. +// +// To use the active or selected brush lists, you must first allocate them (which returns a count) and then +// release them when you are finish manipulating brushes in one of those lists. + +//++timo NOTE : the #defines here are never used, but can help finding where things are done in the editor + +// brush manipulation routines +#define QERAPP_CREATEBRUSH "QERApp_CreateBrush" +#define QERAPP_CREATEBRUSHHANDLE "QERApp_CreateBrushHandle" +#define QERAPP_DELETEBRUSHHANDLE "QERApp_DeleteBrushHandle" +#define QERAPP_COMMITBRUSHHANDLETOMAP "QERApp_CommitBrushHandleToMap" +//++timo not implemented .. remove +// #define QERAPP_BINDHANDLESTOENTITY "QERApp_BindHandlesToEntity" +#define QERAPP_ADDFACE "QERApp_AddFace" +#define QERAPP_ADDFACEDATA "QERApp_AddFaceData" +#define QERAPP_GETFACECOUNT "QERApp_GetFaceCount" +#define QERAPP_GETFACEDATA "QERApp_GetFaceData" +#define QERAPP_SETFACEDATA "QERApp_SetFaceData" +#define QERAPP_DELETEFACE "QERApp_DeleteFace" +#define QERAPP_TEXTUREBRUSH "QERApp_TextureBrush" +#define QERAPP_BUILDBRUSH "QERApp_BuildBrush" // PGM +#define QERAPP_SELECTEDBRUSHCOUNT "QERApp_SelectedBrushCount" +#define QERAPP_ALLOCATESELECTEDBRUSHHANDLES "QERApp_AllocateSelectedBrushHandles" +#define QERAPP_RELEASESELECTEDBRUSHHANDLES "QERApp_ReleaseSelectedBrushHandles" +#define QERAPP_GETSELECTEDBRUSHHANDLE "QERApp_GetSelectedBrushHandle" +#define QERAPP_ACTIVEBRUSHCOUNT "QERApp_ActiveBrushCount" +#define QERAPP_ALLOCATEACTIVEBRUSHHANDLES "QERApp_AllocateActiveBrushHandles" +#define QERAPP_RELEASEACTIVEBRUSHHANDLES "QERApp_ReleaseActiveBrushHandles" +#define QERAPP_GETACTIVEBRUSHHANDLE "QERApp_GetActiveBrushHandle" + +// texture stuff +#define QERAPP_TEXTURECOUNT "QERApp_TextureCount" +#define QERAPP_GETTEXTURE "QERApp_GetTexture" +#define QERAPP_GETCURRENTTEXTURE "QERApp_GetCurrentTexture" +#define QERAPP_SETCURRENTTEXTURE "QERApp_SetCurrentTexture" + +// selection +#define QERAPP_DELETESELECTION "QERApp_DeleteSelection" +#define QERAPP_SELECTBRUSH "QERApp_SelectBrush" // PGM +#define QERAPP_DESELECTBRUSH "QERApp_DeselectBrush" // PGM +#define QERAPP_DESELECTALLBRUSHES "QERApp_DeselectAllBrushes" // PGM + +// data gathering +#define QERAPP_GETPOINTS "QERApp_GetPoints" +#define QERAPP_SELECTBRUSHES "QERApp_GetBrushes" + +// entity class stuff +// the entity handling is very basic for 1.0 +#define QERAPP_GETECLASSCOUNT "QERApp_GetEClassCount" +#define QERAPP_GETECLASS "QERApp_GetEClass" + +// misc +#define QERAPP_SYSMSG "QERApp_SysMsg" +#define QERAPP_INFOMSG "QERApp_InfoMsg" +#define QERAPP_HIDEINFOMSG "QERApp_HideInfoMsg" +#define QERAPP_POSITIONVIEW "QERApp_PositionView" // PGM +#define QERAPP_RESET_PLUGINS "QERApp_ResetPlugins" + +// texture loading +#define QERAPP_LOADTEXTURERGBA "QERApp_LoadTextureRGBA" + +// FIXME: the following are not implemented yet +// hook registrations +#define QERAPP_REGISTER_MAPLOADFUNC "QERApp_Register_MapLoadFunc" +#define QERAPP_REGISTER_MAPSAVEFUNC "QERApp_Register_MapSaveFunc" + +// FIXME: the following are not implemented yet +#define QERAPP_REGISTER_PROJECTLOADFUNC "QERApp_Register_ProjectLoadFunc" +#define QERAPP_REGISTER_MOUSEHANDLER "QERApp_Register_MouseHandler" +#define QERAPP_REGISTER_KEYHANDLER "QERApp_Register_KeyHandler" + +// FIXME: new primtives do not work in v1.00 +// primitives are new types of things in the map +// for instance, the Q3 curves could have been done as +// primitives instead of being built in +// it will be a plugins responsibility to hook the map load and save funcs to load +// and/or save any additional data (like new primitives of some type) +// the editor will call each registered renderer during the rendering process to repaint +// any primitives the plugin owns +// each primitive object has a temporary sibling brush that lives in the map +// FIXME: go backwards on this a bit.. orient it more towards the temp brush mode as it will be cleaner +// basically a plugin will hook the map load and save and will add the primitives to the map.. this will +// produce a temporary 'primitive' brush and the appropriate renderer will be called as well as the +// edit handler (for edge drags, sizes, rotates, etc.. ) and the vertex maker will be called when vertex +// mode is attemped on the brush.. there will need to be a GetPrimitiveBounds callback in the edit handler +// so the brush can resize appropriately as needed.. this might be the plugins responsibility to set the +// sibling brushes size.. it will then be the plugins responsibility to hook map save to save the primitives +// as the editor will discard any temp primitive brushes.. (there probably needs to be some kind of sanity check +// here as far as keeping the brushes and the plugin in sync.. i suppose the edit handler can deal with all of that +// crap but it looks like a nice place for a mess) +#define QERAPP_REGISTER_PRIMITIVE "QERApp_Register_Primitive" +#define QERAPP_REGISTER_RENDERER "QERApp_Register_Renderer" +#define QERAPP_REGISTER_EDITHANDLER "QERApp_Register_EditHandler" +#define QERAPP_REGISTER_VERTEXMAKER "QERApp_Register_VertexMaker" +#define QERAPP_ADDPRIMITIVE "QERApp_AddPrimitive" + +// v1.70 +#define QERAPP_GETENTITYCOUNT "QERApp_GetEntityCount" +#define QERAPP_GETENTITYHANDLE "QERApp_GetEntityHandle" +//++timo not implemented for the moment +// #define QERAPP_GETENTITYINFO "QERApp_GetEntityInfo" +//++timo does the keyval need some more funcs to add/remove ? +// get the pointer and do the changes yourself +#define QERAPP_GETENTITYKEYVALLIST "QERApp_GetKeyValList" +#define QERAPP_ALLOCATEEPAIR "QERApp_AllocateEpair" +// will check current KeyVal list is NULL, otherwise use GetKeyValList +#define QERAPP_SETENTITYKEYVALLIST "QERApp_SetKeyValList" +#define QERAPP_ALLOCATEENTITYBRUSHHANDLES "QERApp_AllocateEntityBrushHandles" +#define QERAPP_RELEASEENTITYBRUSHHANDLES "QERApp_ReleaseEntityBrushHandles" +#define QERAPP_GETENTITYBRUSHHANDLE "QERApp_GetEntityBrushHandle" +#define QERAPP_CREATEENTITYHANDLE "QERApp_CreateEntityHandle" +#define QERAPP_COMMITBRUSHHANDLETOENTITY "QERApp_CommitBrushHandleToEntity" +#define QERAPP_COMMITENTITYHANDLETOMAP "QERApp_CommitEntityHandleToMap" +#define QERAPP_SETSCREENUPDATE "QERApp_SetScreenUpdate" +#define QERAPP_BUILDBRUSH2 "QERApp_BuildBrush2" + +struct _QERPointData +{ + int m_nCount; + vec3_t *m_pVectors; +}; + +struct _QERFaceData +{ + char m_TextureName[QER_MAX_NAMELEN]; + int m_nContents; + int m_nFlags; + int m_nValue; + float m_fShift[2]; + float m_fRotate; + float m_fScale[2]; + vec3_t m_v1, m_v2, m_v3; + // brush primitive additions + qboolean m_bBPrimit; + brushprimit_texdef_t brushprimit_texdef; +}; + +typedef void (WINAPI* PFN_QERAPP_CREATEBRUSH)(vec3_t vMin, vec3_t vMax); + +typedef LPVOID (WINAPI* PFN_QERAPP_CREATEBRUSHHANDLE)(); +typedef void (WINAPI* PFN_QERAPP_DELETEBRUSHHANDLE)(LPVOID pv); +typedef void (WINAPI* PFN_QERAPP_COMMITBRUSHHANDLETOMAP)(LPVOID pv); +typedef void (WINAPI* PFN_QERAPP_ADDFACE)(LPVOID pv, vec3_t v1, vec3_t v2, vec3_t v3); + +typedef void (WINAPI* PFN_QERAPP_ADDFACEDATA)(LPVOID pv, _QERFaceData *pData); +typedef int (WINAPI* PFN_QERAPP_GETFACECOUNT)(LPVOID pv); +typedef _QERFaceData* (WINAPI* PFN_QERAPP_GETFACEDATA)(LPVOID pv, int nFaceIndex); +typedef void (WINAPI* PFN_QERAPP_SETFACEDATA)(LPVOID pv, int nFaceIndex, _QERFaceData *pData); +typedef void (WINAPI* PFN_QERAPP_DELETEFACE)(LPVOID pv, int nFaceIndex); +typedef void (WINAPI* PFN_QERAPP_TEXTUREBRUSH)(LPVOID pv, LPCSTR pName); +typedef void (WINAPI* PFN_QERAPP_BUILDBRUSH)(LPVOID pv); // PGM +typedef void (WINAPI* PFN_QERAPP_SELECTBRUSH)(LPVOID pv); // PGM +typedef void (WINAPI* PFN_QERAPP_DESELECTBRUSH)(LPVOID pv); // PGM +typedef void (WINAPI* PFN_QERAPP_DESELECTALLBRUSHES)(); // PGM + +typedef void (WINAPI* PFN_QERAPP_DELETESELECTION)(); +typedef void (WINAPI* PFN_QERAPP_GETPOINTS)(int nMax, _QERPointData *pData, LPCSTR pMsg); +typedef void (WINAPI* PFN_QERAPP_SYSMSG)(LPCSTR pMsg); +typedef void (WINAPI* PFN_QERAPP_INFOMSG)(LPCSTR pMsg); +typedef void (WINAPI* PFN_QERAPP_HIDEINFOMSG)(); +typedef void (WINAPI* PFN_QERAPP_POSITIONVIEW)(vec3_t v1, vec3_t v2); //PGM + +typedef int (WINAPI* PFN_QERAPP_SELECTEDBRUSHCOUNT)(); +typedef int (WINAPI* PFN_QERAPP_ALLOCATESELECTEDBRUSHHANDLES)(); +typedef void (WINAPI* PFN_QERAPP_RELEASESELECTEDBRUSHHANDLES)(); +typedef LPVOID (WINAPI* PFN_QERAPP_GETSELECTEDBRUSHHANDLE)(int nIndex); + +typedef int (WINAPI* PFN_QERAPP_ACTIVEBRUSHCOUNT)(); +typedef int (WINAPI* PFN_QERAPP_ALLOCATEACTIVEBRUSHHANDLES)(); +typedef void (WINAPI* PFN_QERAPP_RELEASEACTIVEBRUSHHANDLES)(); +typedef LPVOID (WINAPI* PFN_QERAPP_GETACTIVEBRUSHHANDLE)(int nIndex); + +typedef int (WINAPI* PFN_QERAPP_TEXTURECOUNT)(); +typedef LPCSTR (WINAPI* PFN_QERAPP_GETTEXTURE)(int nIndex); +typedef LPCSTR (WINAPI* PFN_QERAPP_GETCURRENTTEXTURE)(); +typedef void (WINAPI* PFN_QERAPP_SETCURRENTTEXTURE)(LPCSTR pName); + +typedef void (WINAPI* PFN_QERAPP_REGISTERMAPLOAD)(LPVOID vp); +typedef void (WINAPI* PFN_QERAPP_REGISTERMAPSAVE)(LPVOID vp); + +typedef int (WINAPI* PFN_QERAPP_GETECLASSCOUNT)(); +typedef LPCSTR (WINAPI* PFN_QERAPP_GETECLASS)(int nIndex); + +typedef void (WINAPI* PFN_QERAPP_RESETPLUGINS)(); +//--typedef int (WINAPI* PFN_QERAPP_GETENTITYCOUNT)(); + + +// called by texture loaders for each texture loaded +typedef void (WINAPI* PFN_QERAPP_LOADTEXTURERGBA)(LPVOID vp); + +//--typedef LPCSTR (WINAPI* PFN_QERAPP_GETENTITY)(int nIndex); + +// v1.70 +typedef int (WINAPI* PFN_QERAPP_GETENTITYCOUNT)(); +typedef LPVOID (WINAPI* PFN_QERAPP_GETENTITYHANDLE)(int nIndex); +typedef epair_t** (WINAPI* PFN_QERAPP_GETENTITYKEYVALLIST)(LPVOID vp); +typedef epair_t* (WINAPI* PFN_QERAPP_ALLOCATEEPAIR)( char*, char* ); +typedef void (WINAPI* PFN_QERAPP_SETENTITYKEYVALLIST)(LPVOID vp, epair_t* ep); +typedef int (WINAPI* PFN_QERAPP_ALLOCATEENTITYBRUSHHANDLES)(LPVOID vp); +typedef void (WINAPI* PFN_QERAPP_RELEASEENTITYBRUSHHANDLES)(); +typedef LPVOID (WINAPI* PFN_QERAPP_GETENTITYBRUSHHANDLE)(int nIndex); +typedef LPVOID (WINAPI* PFN_QERAPP_CREATEENTITYHANDLE)(); +typedef void (WINAPI* PFN_QERAPP_COMMITBRUSHHANDLETOENTITY)( LPVOID vpBrush, LPVOID vpEntity); +typedef void (WINAPI* PFN_QERAPP_COMMITENTITYHANDLETOMAP)(LPVOID vp); +typedef void (WINAPI* PFN_QERAPP_SETSCREENUPDATE)(int bScreenUpdate); +// this one uses window flags defined in qertypes.h +typedef void (WINAPI* PFN_QERAPP_SYSUPDATEWINDOWS)(int bits); +//++timo remove this one +typedef void (WINAPI* PFN_QERAPP_BUILDBRUSH2)(LPVOID vp, int bConvert); +// Radiant functions for Plugin Entities +// will look for the value of the correponding key in the project epairs +typedef char* (WINAPI* PFN_QERAPP_READPROJECTKEY)(char* ); +// will scan the file, parse the first EClass found, and associate it to the caller plugin +// will only read first EClass in the file, and return true/false +typedef int (WINAPI* PFN_QERAPP_SCANFILEFORECLASS)(char* ); +// plugins can request additional interfaces from the editor when they need specific services +typedef int (WINAPI* PFN_QERAPP_REQUESTINTERFACE)( REFGUID, LPVOID ); +// use this one for errors, Radiant will stop after the "edit preferences" dialog +typedef void (WINAPI* PFN_QERAPP_ERRORMSG)(LPCSTR pMsg); +// use to gain read access to the project epairs +// FIXME: removed, accessed through QERPlug_RegisterPluginEntities with the IEpair interface +// typedef void (WINAPI* PFN_QERAPP_GETPROJECTEPAIR)(epair_t **); +// used to allocate and read a buffer +//++timo NOTE: perhaps this would need moving to some kind of dedicated interface +typedef int (WINAPI* PFN_QERAPP_LOADFILE)(const char *pLocation, void ** buffer); +typedef char* (WINAPI* PFN_QERAPP_EXPANDRELETIVEPATH)(char *); +typedef void (WINAPI* PFN_QERAPP_QECONVERTDOSTOUNIXNAME)( char *dst, const char *src ); +typedef int (WINAPI* PFN_QERAPP_HASSHADER)(const char *); +typedef int (WINAPI* PFN_QERAPP_TEXTURELOADSKIN)(char *pName, int *pnWidth, int *pnHeight); +// free memory previously allocated by Radiant +// NOTE: this is dirty +typedef void (WINAPI* PFN_QERAPP_RADIANTFREE)( void * ); +// retrieves the path to the engine from the preferences dialog box +typedef char* (WINAPI* PFN_QERAPP_GETGAMEPATH)(); +// retrieves full Radiant path +typedef char* (WINAPI* PFN_QERAPP_GETQERPATH)(); + +// patches in/out +// NOTE: this is a bit different from the brushes in/out, no LPVOID handles this time +// use int indexes instead +// if you call AllocateActivePatchHandles, you'll be playing with active patches +// AllocateSelectedPatcheHandles for selected stuff +// a call to CreatePatchHandle will move you to a seperate index table +typedef int (WINAPI* PFN_QERAPP_ALLOCATEACTIVEPATCHHANDLES) (); +typedef int (WINAPI* PFN_QERAPP_ALLOCATESELECTEDPATCHHANDLES) (); +typedef void (WINAPI* PFN_QERAPP_RELEASEPATCHHANDLES) (); +typedef patchMesh_t* (WINAPI* PFN_QERAPP_GETPATCHDATA) (int); +typedef void (WINAPI* PFN_QERAPP_DELETEPATCH) (int); +typedef int (WINAPI* PFN_QERAPP_CREATEPATCHHANDLE) (); +// when commiting, only a few patchMesh_t members are relevant: +// int width, height; // in control points, not patches +// int contents, flags, value, type; +// drawVert_t ctrl[MAX_PATCH_WIDTH][MAX_PATCH_HEIGHT]; +// once you have commited the index is still available, if the patch handle was allocated by you +// then you can re-use the index to commit other patches .. otherwise you can change existing patches +// NOTE: the handle thing for plugin-allocated patches is a bit silly (nobody's perfect) +// TODO: change current behaviour to an index = 0 to tell Radiant to allocate, other indexes to existing patches +// patch is selected after a commit +// you can add an optional texture / shader name .. if NULL will use the current texture +typedef void (WINAPI* PFN_QERAPP_COMMITPATCHHANDLETOMAP) (int, patchMesh_t* pMesh, char *texName); + +// FIXME: +// add map format extensions +// add texture format handlers +// add surface dialog handler +// add model handler/displayer + +// v1 func table +// Plugins need to declare one of these and implement the getfunctable as described above +struct _QERFuncTable_1 +{ + float m_fVersion; + int m_nSize; + PFN_QERAPP_CREATEBRUSH m_pfnCreateBrush; + PFN_QERAPP_CREATEBRUSHHANDLE m_pfnCreateBrushHandle; + PFN_QERAPP_DELETEBRUSHHANDLE m_pfnDeleteBrushHandle; + PFN_QERAPP_COMMITBRUSHHANDLETOMAP m_pfnCommitBrushHandle; + PFN_QERAPP_ADDFACE m_pfnAddFace; + PFN_QERAPP_ADDFACEDATA m_pfnAddFaceData; + PFN_QERAPP_GETFACEDATA m_pfnGetFaceData; + PFN_QERAPP_GETFACECOUNT m_pfnGetFaceCount; + PFN_QERAPP_SETFACEDATA m_pfnSetFaceData; + PFN_QERAPP_DELETEFACE m_pfnDeleteFace; + PFN_QERAPP_TEXTUREBRUSH m_pfnTextureBrush; + PFN_QERAPP_BUILDBRUSH m_pfnBuildBrush; // PGM + PFN_QERAPP_SELECTBRUSH m_pfnSelectBrush; // PGM + PFN_QERAPP_DESELECTBRUSH m_pfnDeselectBrush; // PGM + PFN_QERAPP_DESELECTALLBRUSHES m_pfnDeselectAllBrushes; // PGM + + PFN_QERAPP_DELETESELECTION m_pfnDeleteSelection; + PFN_QERAPP_GETPOINTS m_pfnGetPoints; + PFN_QERAPP_SYSMSG m_pfnSysMsg; + PFN_QERAPP_INFOMSG m_pfnInfoMsg; + PFN_QERAPP_HIDEINFOMSG m_pfnHideInfoMsg; + PFN_QERAPP_POSITIONVIEW m_pfnPositionView; // PGM + + PFN_QERAPP_SELECTEDBRUSHCOUNT m_pfnSelectedBrushCount; + PFN_QERAPP_ALLOCATESELECTEDBRUSHHANDLES m_pfnAllocateSelectedBrushHandles; + PFN_QERAPP_RELEASESELECTEDBRUSHHANDLES m_pfnReleaseSelectedBrushHandles; + PFN_QERAPP_GETSELECTEDBRUSHHANDLE m_pfnGetSelectedBrushHandle; + + PFN_QERAPP_ACTIVEBRUSHCOUNT m_pfnActiveBrushCount; + PFN_QERAPP_ALLOCATEACTIVEBRUSHHANDLES m_pfnAllocateActiveBrushHandles; + PFN_QERAPP_RELEASEACTIVEBRUSHHANDLES m_pfnReleaseActiveBrushHandles; + PFN_QERAPP_GETACTIVEBRUSHHANDLE m_pfnGetActiveBrushHandle; + + //++timo this would need to be removed and replaced by the IShaders interface + PFN_QERAPP_TEXTURECOUNT m_pfnTextureCount; + PFN_QERAPP_GETTEXTURE m_pfnGetTexture; + PFN_QERAPP_GETCURRENTTEXTURE m_pfnGetCurrentTexture; + PFN_QERAPP_SETCURRENTTEXTURE m_pfnSetCurrentTexture; + + PFN_QERAPP_GETECLASSCOUNT m_pfnGetEClassCount; + PFN_QERAPP_GETECLASS m_pfnGetEClass; + PFN_QERAPP_RESETPLUGINS m_pfnResetPlugins; + // v1.00 ends here + // v1.50 starts here + PFN_QERAPP_LOADTEXTURERGBA m_pfnLoadTextureRGBA; + // v1.50 ends here + // v1.70 starts here + PFN_QERAPP_GETENTITYCOUNT m_pfnGetEntityCount; + PFN_QERAPP_GETENTITYHANDLE m_pfnGetEntityHandle; + PFN_QERAPP_GETENTITYKEYVALLIST m_pfnGetEntityKeyValList; + PFN_QERAPP_SETENTITYKEYVALLIST m_pfnSetEntityKeyValList; + PFN_QERAPP_ALLOCATEENTITYBRUSHHANDLES m_pfnAllocateEntityBrushHandles; + PFN_QERAPP_RELEASEENTITYBRUSHHANDLES m_pfnReleaseEntityBrushHandles; + PFN_QERAPP_GETENTITYBRUSHHANDLE m_pfnGetEntityBrushHandle; + PFN_QERAPP_CREATEENTITYHANDLE m_pfnCreateEntityHandle; + PFN_QERAPP_COMMITBRUSHHANDLETOENTITY m_pfnCommitBrushHandleToEntity; + PFN_QERAPP_COMMITENTITYHANDLETOMAP m_pfnCommitEntityHandleToMap; + PFN_QERAPP_ALLOCATEEPAIR m_pfnAllocateEpair; + PFN_QERAPP_SETSCREENUPDATE m_pfnSetScreenUpdate; + PFN_QERAPP_SYSUPDATEWINDOWS m_pfnSysUpdateWindows; + PFN_QERAPP_BUILDBRUSH2 m_pfnBuildBrush2; + // Radiant functions for Plugin Entities + PFN_QERAPP_READPROJECTKEY m_pfnReadProjectKey; + PFN_QERAPP_SCANFILEFORECLASS m_pfnScanFileForEClass; + // plugins can request additional interfaces + PFN_QERAPP_REQUESTINTERFACE m_pfnRequestInterface; + PFN_QERAPP_ERRORMSG m_pfnErrorMsg; + // loading a file into a buffer + PFN_QERAPP_LOADFILE m_pfnLoadFile; + PFN_QERAPP_EXPANDRELETIVEPATH m_pfnExpandReletivePath; + PFN_QERAPP_QECONVERTDOSTOUNIXNAME m_pfnQE_ConvertDOSToUnixName; + PFN_QERAPP_HASSHADER m_pfnHasShader; + PFN_QERAPP_TEXTURELOADSKIN m_pfnTexture_LoadSkin; + PFN_QERAPP_RADIANTFREE m_pfnRadiantFree; + PFN_QERAPP_GETGAMEPATH m_pfnGetGamePath; + PFN_QERAPP_GETQERPATH m_pfnGetQERPath; + // patches in / out + PFN_QERAPP_ALLOCATEACTIVEPATCHHANDLES m_pfnAllocateActivePatchHandles; + PFN_QERAPP_ALLOCATESELECTEDPATCHHANDLES m_pfnAllocateSelectedPatchHandles; + PFN_QERAPP_RELEASEPATCHHANDLES m_pfnReleasePatchHandles; + PFN_QERAPP_GETPATCHDATA m_pfnGetPatchData; + PFN_QERAPP_DELETEPATCH m_pfnDeletePatch; + PFN_QERAPP_CREATEPATCHHANDLE m_pfnCreatePatchHandle; + PFN_QERAPP_COMMITPATCHHANDLETOMAP m_pfnCommitPatchHandleToMap; +}; + + +//--typedef int (WINAPI* PFN_QERAPP_BRUSHCOUNT )(); +//--typedef brush_t* (WINAPI* PFN_QERAPP_GETBRUSH )(); +//--typedef void (WINAPI* PFN_QERAPP_DELETEBRUSH )(); + +#endif \ No newline at end of file -- cgit v1.2.3