Serious-Engine/Sources/Engine/Entities/EntityProperties.h
Ryan C. Gordon 1a2ccb8f50 Merge github.com:Croteam-Official/Serious-Engine
Conflicts:
	Sources/Ecc/Parser.cpp
	Sources/Ecc/Scanner.cpp
	Sources/Engine/Base/Scanner.cpp
	Sources/Engine/GameAgent/GameAgent.cpp
	Sources/Engine/Graphics/Gfx_wrapper.h
	Sources/Engine/Network/Network.cpp
	Sources/Engine/Sound/SoundDecoder.h
	Sources/Engine/Templates/HashTableTemplate.cpp
	Sources/Engine/Terrain/Terrain.h
	Sources/EntitiesMP/ParticleCloudsHolder.es
	Sources/EntitiesMP/ParticleCloudsMarker.es
	Sources/SeriousSam/CDCheck.h
	Sources/SeriousSam/Menu.cpp
	Sources/SeriousSam/MenuGadgets.cpp
	Sources/SeriousSam/SeriousSam.cpp
	Sources/SeriousSam/SplashScreen.cpp
	Sources/SeriousSam/StdH.cpp
	Sources/SeriousSam/StdH.h
	Sources/Shaders/StdH.cpp
2016-04-02 23:56:12 -04:00

292 lines
13 KiB
C++

/* Copyright (c) 2002-2012 Croteam Ltd.
This program is free software; you can redistribute it and/or modify
it under the terms of version 2 of the GNU General Public License as published by
the Free Software Foundation
This program 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 this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */
#ifndef SE_INCL_ENTITYPROPERTIES_H
#define SE_INCL_ENTITYPROPERTIES_H
#ifdef PRAGMA_ONCE
#pragma once
#endif
#include <Engine/Base/FileName.h>
#include <Engine/Entities/Entity.h>
/////////////////////////////////////////////////////////////////////
// Classes and macros for defining enums for entity properties
class CEntityPropertyEnumValue {
public:
INDEX epev_iValue; // value
const char *epev_strName; // descriptive name of the enum value (for editor)
};
class CEntityPropertyEnumType {
public:
CEntityPropertyEnumValue *epet_aepevValues; // array of values
INDEX epet_ctValues; // number of values
// convert value of an enum to its name
ENGINE_API const char *NameForValue(INDEX iValue);
};
/* rcg10072001 */
#ifdef _MSC_VER
#define ENUMEXTERN extern _declspec (dllexport)
#else
#define ENUMEXTERN
#endif
#define EP_ENUMBEG(typename) ENUMEXTERN CEntityPropertyEnumValue typename##_values[] = {
#define EP_ENUMVALUE(value, name) {value, name}
#define EP_ENUMEND(typename) }; CEntityPropertyEnumType typename##_enum = { \
typename##_values, sizeof(typename##_values)/sizeof(CEntityPropertyEnumValue ) }
// types that are used only for properties.
// range, edited visually as sphere around entity
typedef FLOAT RANGE;
// type of illumination (for lights that illuminate through polygons)
typedef INDEX ILLUMINATIONTYPE;
// type of light animation
typedef INDEX ANIMATION;
// CTString browsed like a file - doesn't cause dependencies
typedef CTString CTFileNameNoDep;
// CTString that gets translated to different languages
typedef CTString CTStringTrans;
/////////////////////////////////////////////////////////////////////
// Classes and macros for defining entity properties
#define EPROPF_HIDEINPERSPECTIVE (1UL<<0) // not visualized in perspective view (for ranges)
class ENGINE_API CEntityProperty {
public:
enum PropertyType {
/* IMPORTANT: Take care not to renumber the property types, since it would ruin loading
* of previously saved data like levels etc.! Always give a new type new number, and
* never change existing number, nor reuse old ones!
* Update 'next free number' comment when adding new type, but not when removing some!
*/
EPT_PARENT = 9998, // used internaly in WED for setting entity's parents
EPT_SPAWNFLAGS = 9999, // used internaly in WED for spawn flags property
EPT_ENUM = 1, // enum xxx, INDEX with descriptions
EPT_BOOL = 2, // BOOL
EPT_FLOAT = 3, // FLOAT
EPT_COLOR = 4, // COLOR
EPT_STRING = 5, // CTString
EPT_RANGE = 6, // RANGE FLOAT edited as a sphere around the entity
EPT_ENTITYPTR = 7, // CEntityPointer
EPT_FILENAME = 8, // CTFileName
EPT_INDEX = 9, // INDEX
EPT_ANIMATION = 10, // ANIMATION, INDEX edited by animation names
EPT_ILLUMINATIONTYPE = 11, // ILLUMINATIONTYPE, INDEX edited by illumination names
EPT_FLOATAABBOX3D = 12, // FLOATaabbox3D
EPT_ANGLE = 13, // ANGLE, INDEX edited in degrees
EPT_FLOAT3D = 14, // FLOAT3D
EPT_ANGLE3D = 15, // ANGLE3D
EPT_FLOATplane3D = 16, // FLOATplane3D
EPT_MODELOBJECT = 17, // CModelObject
EPT_PLACEMENT3D = 18, // PLACEMENT3D
EPT_ANIMOBJECT = 19, // CAnimObject
EPT_FILENAMENODEP = 20, // CTString browsed like a file - doesn't cause dependencies
EPT_SOUNDOBJECT = 21, // CSoundObject
EPT_STRINGTRANS = 22, // CTString that gets translated to different languages
EPT_FLOATQUAT3D = 23, // FLOATquat3D
EPT_FLOATMATRIX3D = 24, // FLOATmatrix3D
EPT_FLAGS = 25, // flags - ULONG bitfield with names for each field
EPT_MODELINSTANCE = 26,
// next free number: 27
} ep_eptType; // type of property
CEntityPropertyEnumType *ep_pepetEnumType; // if the type is EPT_ENUM or EPT_FLAGS
ULONG ep_ulID; // property ID for this class
SLONG ep_slOffset; // offset of the property in the class
const char *ep_strName; // descriptive name of the property (for editor)
ULONG ep_ulFlags; // additional flags for the property
char ep_chShortcut; // shortcut key for selecting the property in editor (0 for none)
COLOR ep_colColor; // property color, for various wed purposes (like target arrows)
CEntityProperty(PropertyType eptType, CEntityPropertyEnumType *pepetEnumType,
ULONG ulID, SLONG slOffset, const char *strName, char chShortcut, COLOR colColor, ULONG ulFlags)
: ep_eptType (eptType )
, ep_pepetEnumType (pepetEnumType)
, ep_ulID (ulID )
, ep_slOffset (slOffset )
, ep_strName (strName )
, ep_chShortcut (chShortcut )
, ep_colColor (colColor )
, ep_ulFlags (ulFlags )
{};
CEntityProperty(void) {};
};
// macro for accessing property inside an entity
#define ENTITYPROPERTY(entityptr, offset, type) (*((type *)(((UBYTE *)entityptr)+offset)))
/////////////////////////////////////////////////////////////////////
// Classes and macros for defining entity event handler functions
// one entry in function table
class CEventHandlerEntry {
public:
SLONG ehe_slState; // code of the automaton state
SLONG ehe_slBaseState; // code of the base state if overridden
CEntity::pEventHandler ehe_pEventHandler; // handler function
const char *ehe_strName; // symbolic name of handler for debugging
};
/////////////////////////////////////////////////////////////////////
// Classes and macros for defining entity components
enum EntityComponentType { // DO NOT RENUMBER!
ECT_TEXTURE = 1, // texture data
ECT_MODEL = 2, // model data
ECT_CLASS = 3, // entity class
ECT_SOUND = 4, // sound data
};
class ENGINE_API CEntityComponent {
public:
/* Obtain the component. */
void Obtain_t(void); // throw char *
void ObtainWithCheck(void);
// add component to crc table
void AddToCRCTable(void);
/* Release the component. */
void Release(void);
public:
EntityComponentType ec_ectType; // type of component
ULONG ec_slID; // component ID in this class
CTFileName ec_fnmComponent; // component file name
// this one is auto-filled by SCape on DLL initialization
union { // pointer to component
CTextureData *ec_ptdTexture; // for textures
CModelData *ec_pmdModel; // for models
CSoundData *ec_psdSound; // for sounds
CEntityClass *ec_pecEntityClass; // for entity classes
void *ec_pvPointer; // for comparison needs
};
// NOTE: This uses special EFNM initialization for CTFileName class!
CEntityComponent(EntityComponentType ectType,
ULONG ulID, const char *strEFNMComponent)
: ec_ectType(ectType)
, ec_slID(ulID)
, ec_fnmComponent(strEFNMComponent, 4) { ec_pvPointer = NULL; };
CEntityComponent(void) { ec_slID = (ULONG) -1; ec_pvPointer = NULL; };
};
/////////////////////////////////////////////////////////////////////
// The class defining an entity class DLL itself
class ENGINE_API CDLLEntityClass {
public:
CEntityProperty *dec_aepProperties; // array of properties
INDEX dec_ctProperties; // number of properties
CEventHandlerEntry *dec_aeheHandlers; // array of event handlers
INDEX dec_ctHandlers; // number of handlers
CEntityComponent *dec_aecComponents;// array of components
INDEX dec_ctComponents; // number of components
const char *dec_strName; // descriptive name of the class
const char *dec_strIconFileName; // filename of texture or thumbnail
INDEX dec_iID; // class ID
CDLLEntityClass *dec_pdecBase; // pointer to the base class
CEntity *(*dec_New)(void); // pointer to function that creates a member of class
void (*dec_OnInitClass)(void); // pointer to function for connecting DLL
void (*dec_OnEndClass)(void); // pointer to function for disconnecting DLL
void (*dec_OnPrecache)(CDLLEntityClass *pdec, INDEX iUser); // function for precaching data
void (*dec_OnWorldInit)(CWorld *pwoWorld); // function called on world initialization
void (*dec_OnWorldTick)(CWorld *pwoWorld); // function called for each tick
void (*dec_OnWorldRender)(CWorld *pwoWorld); // function called for each rendering
void (*dec_OnWorldEnd)(CWorld *pwoWorld); // function called on world cleanup
/* Get pointer to entity property from its name. */
class CEntityProperty *PropertyForName(const CTString &strPropertyName);
/* Get pointer to entity property from its packed identifier. */
class CEntityProperty *PropertyForTypeAndID(CEntityProperty::PropertyType eptType, ULONG ulID);
/* Get event handler given state and event code. */
CEntity::pEventHandler HandlerForStateAndEvent(SLONG slState, SLONG slEvent);
/* Get event handler name for given state. */
const char *HandlerNameForState(SLONG slState);
/* Get derived class override for given state. */
SLONG GetOverridenState(SLONG slState);
/* Get pointer to component from its type and identifier. */
class CEntityComponent *ComponentForTypeAndID(EntityComponentType ectType,
SLONG slID);
/* Get pointer to component from the component. */
class CEntityComponent *ComponentForPointer(void *pv);
// precache given component
void PrecacheModel(SLONG slID);
void PrecacheTexture(SLONG slID);
void PrecacheSound(SLONG slID);
void PrecacheClass(SLONG slID, INDEX iUser = -1);
};
/* rcg10062001 */
#if (defined _MSC_VER)
#define DECLSPEC_DLLEXPORT _declspec (dllexport)
#else
#define DECLSPEC_DLLEXPORT
#endif
// macro for defining entity class DLL structures
#define ENTITY_CLASSDEFINITION(classname, basename, descriptivename, iconfilename, id)\
extern "C" DECLSPEC_DLLEXPORT CDLLEntityClass classname##_DLLClass; \
CDLLEntityClass classname##_DLLClass = { \
classname##_properties, \
classname##_propertiesct, \
classname##_handlers, \
classname##_handlersct, \
classname##_components, \
classname##_componentsct, \
descriptivename, \
iconfilename, \
id, \
&basename##_DLLClass, \
&classname##_New, \
&classname##_OnInitClass, \
&classname##_OnEndClass, \
&classname##_OnPrecache, \
&classname##_OnWorldInit, \
&classname##_OnWorldTick, \
&classname##_OnWorldRender, \
&classname##_OnWorldEnd \
}
#define ENTITY_CLASSDEFINITION_BASE(classname, id) \
extern "C" DECLSPEC_DLLEXPORT CDLLEntityClass classname##_DLLClass; \
CDLLEntityClass classname##_DLLClass = { \
NULL,0, NULL,0, NULL,0, "", "", id, \
NULL, NULL,NULL,NULL,NULL, NULL,NULL,NULL,NULL \
}
inline ENGINE_API void ClearToDefault(FLOAT &f) { f = 0.0f; };
inline ENGINE_API void ClearToDefault(INDEX &i) { i = 0; };
inline ENGINE_API void ClearToDefault(BOOL &b) { b = FALSE; };
inline ENGINE_API void ClearToDefault(CEntityPointer &pen) { pen = NULL; };
inline ENGINE_API void ClearToDefault(CTString &str) { str = ""; };
inline ENGINE_API void ClearToDefault(FLOATplane3D &pl) { pl = FLOATplane3D(FLOAT3D(0,1,0), 0); };
inline ENGINE_API void ClearToDefault(FLOAT3D &v) { v = FLOAT3D(0,1,0); };
inline ENGINE_API void ClearToDefault(COLOR &c) { c = 0xFFFFFFFF; };
inline ENGINE_API void ClearToDefault(CModelData *&pmd) { pmd = NULL; };
inline ENGINE_API void ClearToDefault(CTextureData *&pmt) { pmt = NULL; };
#endif /* include-once check. */