q3aql/Serious-Engine
q3aql/Serious-Engine
1
0
Fork 0
mirror of https://github.com/ptitSeb/Serious-Engine synced 2024-12-25 15:14:51 +01:00
Code Issues Packages Projects Releases Wiki Activity
c5f5d72e3f
Serious-Engine/Sources/Engine/Entities/Entity.cpp
zcaliptium ef0b970490 Fixes
2016-03-22 21:03:12 +03:00

3966 lines
119 KiB
C++
Raw Blame History

/* 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. */
#include "stdh.h"
#include <Engine/Entities/Entity.h>
#include <Engine/Entities/EntityClass.h>
#include <Engine/Entities/EntityProperties.h>
#include <Engine/Entities/LastPositions.h>
#include <Engine/Entities/EntityCollision.h>
#include <Engine/Entities/Precaching.h>
#include <Engine/Entities/ShadingInfo.h>
#include <Engine/Light/LightSource.h>
#include <Engine/Math/Geometry.inl>
#include <Engine/Math/Clipping.inl>
#include <Engine/Math/Float.h>
#include <Engine/Math/OBBox.h>
#include <Engine/Math/Functions.h>
#include <Engine/Base/CRC.h>
#include <Engine/Base/Console.h>
#include <Engine/Base/Statistics_Internal.h>
#include <Engine/Network/Network.h>
#include <Engine/Network/PlayerTarget.h>
#include <Engine/Network/SessionState.h>
#include <Engine/Brushes/Brush.h>
#include <Engine/Brushes/BrushTransformed.h>
#include <Engine/Brushes/BrushArchive.h>
#include <Engine/Terrain/TerrainArchive.h>
#include <Engine/World/World.h>
#include <Engine/World/WorldRayCasting.h>
#include <Engine/World/PhysicsProfile.h>
#include <Engine/Base/ReplaceFile.h>
#include <Engine/Entities/InternalClasses.h>
#include <Engine/Models/ModelObject.h>
#include <Engine/Sound/SoundData.h>
#include <Engine/Sound/SoundObject.h>
#include <Engine/Graphics/Texture.h>
#include <Engine/Ska/Render.h>
#include <Engine/Terrain/Terrain.h>
#include <Engine/Terrain/TerrainRayCasting.h>
#include <Engine/Terrain/TerrainMisc.h>
#include <Engine/Base/ListIterator.inl>
#include <Engine/Templates/BSP.h>
#include <Engine/Templates/DynamicArray.cpp>
#include <Engine/Templates/DynamicContainer.cpp>
#include <Engine/Templates/StaticArray.cpp>
#include <Engine/Templates/StaticStackArray.cpp>
#include <Engine/Templates/Stock_CAnimData.h>
#include <Engine/Templates/Stock_CTextureData.h>
#include <Engine/Templates/Stock_CModelData.h>
#include <Engine/Templates/Stock_CSoundData.h>
// a reference to a void event for use as default parameter
const EVoid _evVoid;
const CEntityEvent &_eeVoid = _evVoid;
// allocation step for state stack of a CRationalEntity
#define STATESTACK_ALLOCATIONSTEP 5
extern INDEX _ctEntities;
extern INDEX _ctPredictorEntities;
// check if entity is of given class
BOOL IsOfClass(CEntity *pen, const char *pstrClassName)
{
if (pen==NULL || pstrClassName==NULL) {
return FALSE;
}
if (strcmp(pen->GetClass()->ec_pdecDLLClass->dec_strName, pstrClassName)==0) {
return TRUE;
} else {
return FALSE;
}
}
BOOL IsOfSameClass(CEntity *pen1, CEntity *pen2)
{
if (pen1==NULL || pen2==NULL) {
return FALSE;
}
if (pen1->GetClass()->ec_pdecDLLClass == pen2->GetClass()->ec_pdecDLLClass) {
return TRUE;
} else {
return FALSE;
}
}
// check if entity is of given class or derived from
BOOL IsDerivedFromClass(CEntity *pen, const char *pstrClassName)
{
if (pen==NULL || pstrClassName==NULL) {
return FALSE;
}
// for all classes in hierarchy of the entity
for(CDLLEntityClass *pdecDLLClass = pen->GetClass()->ec_pdecDLLClass;
pdecDLLClass!=NULL;
pdecDLLClass = pdecDLLClass->dec_pdecBase) {
// if it is the wanted class
if (strcmp(pdecDLLClass->dec_strName, pstrClassName)==0) {
// it is derived
return TRUE;
}
}
// otherwise, it is not derived
return FALSE;
}
/////////////////////////////////////////////////////////////////////
// CEntity
/*
* Default constructor.
*/
CEntity::CEntity(void)
{
en_pbrBrush = NULL;
en_psiShadingInfo = NULL;
en_pciCollisionInfo = NULL;
en_pecClass = NULL;
en_ulFlags = 0;
en_ulSpawnFlags = 0xFFFFFFFFL; // active always
en_ulPhysicsFlags = 0;
en_ulCollisionFlags = 0;
en_ctReferences = 0;
en_ulID = 0;
en_RenderType = RT_NONE;
en_fSpatialClassificationRadius = -1.0f;
en_penParent = NULL;
en_plpLastPositions = NULL;
_ctEntities++;
}
/*
* Destructor.
*/
CEntity::~CEntity(void)
{
ASSERT(en_ctReferences==0);
ASSERT(en_ulID!=0);
ASSERT(en_RenderType==RT_NONE);
// remove it from container in its world
ASSERT(!en_pwoWorld->wo_cenEntities.IsMember(this));
en_pwoWorld->wo_cenAllEntities.Remove(this);
// unset spatial clasification
en_rdSectors.Clear();
/*
Models are always destructed on End(), but brushes and terrains are not, so
if the pointer is not NULL, then it must be a brush or terrain.
Both of them are derived from CBrushBase so GetBrushType() will return its real type
*/
// if it is brush of terrain
if(en_pbrBrush != NULL) {
INDEX btType = en_pbrBrush->GetBrushType();
// if this is brush3d
if(btType==CBrushBase::BT_BRUSH3D) {
// free the brush
en_pwoWorld->wo_baBrushes.ba_abrBrushes.Delete(en_pbrBrush);
en_pbrBrush = NULL;
// if this is terrain
} else if(btType==CBrushBase::BT_TERRAIN) {
// free the brush
en_pwoWorld->wo_taTerrains.ta_atrTerrains.Delete(en_ptrTerrain);
en_pbrBrush = NULL;
// unknown type
} else {
ASSERTALWAYS("Unsupported brush type");
}
}
// clear entity type
en_RenderType = RT_NONE;
en_pecClass->RemReference();
en_pecClass = NULL;
en_fSpatialClassificationRadius = -1.0f;
_ctEntities--;
if (IsPredictable()) {
if (en_pwoWorld->wo_cenPredictable.IsMember(this)) {
en_pwoWorld->wo_cenPredictable.Remove(this);
}
}
if (en_ulFlags&ENF_WILLBEPREDICTED) {
if (en_pwoWorld->wo_cenWillBePredicted.IsMember(this)) {
en_pwoWorld->wo_cenWillBePredicted.Remove(this);
}
}
if (IsPredictor()) {
if (en_pwoWorld->wo_cenPredictor.IsMember(this)) {
en_pwoWorld->wo_cenPredictor.Remove(this);
_ctPredictorEntities--;
}
}
}
/////////////////////////////////////////////////////////////////////
// Access functions
/* Test if the entity is an empty brush. */
BOOL CEntity::IsEmptyBrush(void) const
{
// if it is not brush
if (en_RenderType != CEntity::RT_BRUSH && en_RenderType != RT_FIELDBRUSH) {
// it is not empty brush
return FALSE;
// if it is brush
} else {
// get its brush
CBrush3D &brBrush = *en_pbrBrush;
// get the first mip of the brush
CBrushMip *pbmMip = brBrush.GetFirstMip();
// it is empty if it has zero sectors
return pbmMip->bm_abscSectors.Count()==0;
}
}
/* Return max Game Players */
INDEX CEntity::GetMaxPlayers(void) {
return NET_MAXGAMEPLAYERS;
};
/* Return Player Entity */
CEntity *CEntity::GetPlayerEntity(INDEX iPlayer)
{
ASSERT(iPlayer>=0 && iPlayer<GetMaxPlayers());
CSessionState &ses = _pNetwork->ga_sesSessionState;
if (ses.ses_apltPlayers[iPlayer].plt_bActive) {
return ses.ses_apltPlayers[iPlayer].plt_penPlayerEntity;
} else {
return NULL;
}
}
/* Get bounding box of this entity - for AI purposes only. */
void CEntity::GetBoundingBox(FLOATaabbox3D &box)
{
if (en_pciCollisionInfo!=NULL) {
box = en_pciCollisionInfo->ci_boxCurrent;
} else {
GetSize(box);
box += GetPlacement().pl_PositionVector;
}
}
/* Get size of this entity - for UI purposes only. */
void CEntity::GetSize(FLOATaabbox3D &box)
{
if (en_RenderType==CEntity::RT_MODEL || en_RenderType==CEntity::RT_EDITORMODEL) {
en_pmoModelObject->GetCurrentFrameBBox( box);
box.StretchByVector(en_pmoModelObject->mo_Stretch);
} else if(en_RenderType==CEntity::RT_SKAMODEL || en_RenderType==CEntity::RT_SKAEDITORMODEL) {
GetModelInstance()->GetCurrentColisionBox( box);
box.StretchByVector(GetModelInstance()->mi_vStretch);
} else if (en_RenderType==CEntity::RT_TERRAIN) {
GetTerrain()->GetAllTerrainBBox(box);
} else if (en_RenderType==CEntity::RT_BRUSH || en_RenderType==CEntity::RT_FIELDBRUSH) {
CBrushMip *pbm = en_pbrBrush->GetFirstMip();
if (pbm == NULL) {
box = FLOATaabbox3D(FLOAT3D(0,0,0), FLOAT3D(0,0,0));
} else {
box = pbm->bm_boxBoundingBox;
box += -GetPlacement().pl_PositionVector;
}
}
else {
box = FLOATaabbox3D(FLOAT3D(0,0,0), FLOAT3D(0,0,0));
}
}
/* Get name of this entity. */
const CTString &CEntity::GetName(void) const
{
static const CTString strDummyName("");
return strDummyName;
}
const CTString &CEntity::GetDescription(void) const // name + some more verbose data
{
static const CTString strDummyDescription("");
return strDummyDescription;
}
/* Get first target of this entity. */
CEntity *CEntity::GetTarget(void) const
{
return NULL;
}
/* Check if entity can be used as a target. */
BOOL CEntity::IsTargetable(void) const
{
// cannot be targeted unless this function is overridden
return FALSE;
}
/* Check if entity is marker */
BOOL CEntity::IsMarker(void) const{
// cannot be marker unless this function is overridden
return FALSE;
}
/* Check if entity is important */
BOOL CEntity::IsImportant(void) const{
// cannot be important unless this function is overridden
return FALSE;
}
/* Check if entity is moved on a route set up by its targets. */
BOOL CEntity::MovesByTargetedRoute(CTString &strTargetProperty) const
{
return FALSE;
}
/* Check if entity can drop marker for making linked route. */
BOOL CEntity::DropsMarker(CTFileName &fnmMarkerClass, CTString &strTargetProperty) const
{
return FALSE;
}
/* Get light source information - return NULL if not a light source. */
CLightSource *CEntity::GetLightSource(void)
{
return NULL;
}
BOOL CEntity::IsTargetValid(SLONG slPropertyOffset, CEntity *penTarget)
{
return TRUE;
}
/* Get anim data for given animation property - return NULL for none. */
CAnimData *CEntity::GetAnimData(SLONG slPropertyOffset)
{
return NULL;
}
/* Get force type name, return empty string if not used. */
const CTString &CEntity::GetForceName(INDEX iForce)
{
static const CTString strDummyName("");
return strDummyName;
}
/* Get forces in given point. */
void CEntity::GetForce(INDEX iForce, const FLOAT3D &vPoint,
CForceStrength &fsGravity, CForceStrength &fsField)
{
// default gravity
fsGravity.fs_vDirection = FLOAT3D(0,-1,0);
fsGravity.fs_fAcceleration = 9.81f;
fsGravity.fs_fVelocity = 0;
// no force field
fsField.fs_fAcceleration = 0;
}
/* Get entity that controls the force, used for change notification checking. */
CEntity *CEntity::GetForceController(INDEX iForce)
{
return NULL;
}
/* Adjust model shading parameters if needed - return TRUE if needs model shadows. */
BOOL CEntity::AdjustShadingParameters(FLOAT3D &vLightDirection,
COLOR &colLight, COLOR &colAmbient)
{
return TRUE;
}
/* Adjust model mip factor if needed. */
void CEntity::AdjustMipFactor(FLOAT &fMipFactor)
{
(void)fMipFactor;
NOTHING;
}
// get a different model object for rendering - so entity can change its appearance dynamically
// NOTE: base model is always used for other things (physics, etc).
CModelObject *CEntity::GetModelForRendering(void)
{
return en_pmoModelObject;
}
// get a different model instance for rendering - so entity can change its appearance dynamically
// NOTE: base model is always used for other things (physics, etc).
CModelInstance *CEntity::GetModelInstanceForRendering(void)
{
return en_pmiModelInstance;
}
/* Get fog type name, return empty string if not used. */
const CTString &CEntity::GetFogName(INDEX iFog)
{
static const CTString strDummyName("");
return strDummyName;
}
/* Get fog, return FALSE for none. */
BOOL CEntity::GetFog(INDEX iFog, class CFogParameters &fpFog)
{
return FALSE;
}
/* Get haze type name, return empty string if not used. */
const CTString &CEntity::GetHazeName(INDEX iHaze)
{
static const CTString strDummyName("");
return strDummyName;
}
/* Get haze, return FALSE for none. */
BOOL CEntity::GetHaze(INDEX iHaze, class CHazeParameters &hpHaze, FLOAT3D &vViewDir)
{
return FALSE;
}
/* Get mirror type name, return empty string if not used. */
const CTString &CEntity::GetMirrorName(INDEX iMirror)
{
static const CTString strDummyName("");
return strDummyName;
}
/* Get mirror, return FALSE for none. */
BOOL CEntity::GetMirror(INDEX iMirror, class CMirrorParameters &mpMirror)
{
return FALSE;
}
/* Get gradient type name, return empty string if not used. */
const CTString &CEntity::GetGradientName(INDEX iGradient)
{
static const CTString strDummyName("");
return strDummyName;
}
/* Get gradient, return FALSE for none. */
BOOL CEntity::GetGradient(INDEX iGradient, class CGradientParameters &gpGradient)
{
return FALSE;
}
FLOAT3D CEntity::GetClassificationBoxStretch(void)
{
return FLOAT3D( 1.0f, 1.0f, 1.0f);
}
/* Get field information - return NULL if not a field. */
CFieldSettings *CEntity::GetFieldSettings(void)
{
return NULL;
}
/* Render particles made by this entity. */
void CEntity::RenderParticles(void)
{
NOTHING;
}
/* Get current collision box index for this entity. */
INDEX CEntity::GetCollisionBoxIndex(void)
{
// by default, use only box 0
return 0;
}
/* Get current collision box - override for custom collision boxes. */
void CEntity::GetCollisionBoxParameters(INDEX iBox, FLOATaabbox3D &box, INDEX &iEquality)
{
// if this is ska model
if(en_RenderType==RT_SKAMODEL || en_RenderType==RT_SKAEDITORMODEL) {
box.minvect = GetModelInstance()->GetCollisionBoxMin(iBox);
box.maxvect = GetModelInstance()->GetCollisionBoxMax(iBox);
FLOATaabbox3D boxNS = box;
box.StretchByVector(GetModelInstance()->mi_vStretch);
iEquality = GetModelInstance()->GetCollisionBoxDimensionEquality(iBox);
} else {
box.minvect = en_pmoModelObject->GetCollisionBoxMin(iBox);
box.maxvect = en_pmoModelObject->GetCollisionBoxMax(iBox);
box.StretchByVector(en_pmoModelObject->mo_Stretch);
iEquality = en_pmoModelObject->GetCollisionBoxDimensionEquality(iBox);
}
}
/* Render game view */
void CEntity::RenderGameView(CDrawPort *pdp, void *pvUserData)
{
NOTHING;
}
// apply mirror and stretch to the entity if supported
void CEntity::MirrorAndStretch(FLOAT fStretch, BOOL bMirrorX)
{
NOTHING;
}
// get offset for depth-sorting of alpha models (in meters, positive is nearer)
FLOAT CEntity::GetDepthSortOffset(void)
{
return 0.0f;
}
// get visibility tweaking bits
ULONG CEntity::GetVisTweaks(void)
{
return 0;
}
// Get max tessellation level
FLOAT CEntity::GetMaxTessellationLevel(void)
{
return 0.0f;
}
// get pointer to your predictor/predicted
CEntity *CEntity::GetPredictionPair(void)
{
// this should never be called, it must be overriden if prediction is used!
ASSERT(FALSE);
return this; // this is safest to return if in release version
}
void CEntity::SetPredictionPair(CEntity *penPair)
{
// this should never be called, it must be overriden if prediction is used!
ASSERT(FALSE);
}
// add to prediction any entities that this entity depends on
void CEntity::AddDependentsToPrediction(void)
{
}
// called by other entities to set time prediction parameter
void CEntity::SetPredictionTime(TIME tmAdvance) // give time interval in advance to set
{
NOTHING; // by default, don't use time prediction
}
// called by engine to get the upper time limit
TIME CEntity::GetPredictionTime(void) // return moment in time up to which to predict this entity
{
return -1.0f; // by default, don't use time prediction
}
// get maximum allowed range for predicting this entity
FLOAT CEntity::GetPredictionRange(void)
{
return UpperLimit(0.0f); // by default, cli_fPredictEntitiesRange is the limit
}
// copy for prediction
void CEntity::CopyForPrediction(CEntity &enOrg)
{
// this should never be called, it must be overriden if prediction is used!
ASSERT(FALSE);
}
CEntity *CEntity::GetPredictor(void)
{
ASSERT(IsPredicted());
CEntity *pen = GetPredictionPair();
ASSERT(pen->IsPredictor());
return pen;
}
CEntity *CEntity::GetPredicted(void)
{
ASSERT(IsPredictor());
CEntity *pen = GetPredictionPair();
ASSERT(pen!=NULL);
ASSERT(pen->IsPredicted());
return pen;
}
// become predictable/unpredictable
void CEntity::SetPredictable(BOOL bON)
{
// if predictor
if (IsPredictor()) {
// do nothing
return;
}
// if already set
if (IsPredictable()) {
// check that valid
ASSERT(en_pwoWorld->wo_cenPredictable.IsMember(this));
// if turning on
if (bON) {
// do nothing
return;
}
// mark as not predictable
en_ulFlags&=~ENF_PREDICTABLE;
// remove from container
en_pwoWorld->wo_cenPredictable.Remove(this);
// if not set
} else {
// check that valid
ASSERT(!en_pwoWorld->wo_cenPredictable.IsMember(this));
ASSERT(!IsPredictor());
ASSERT(!IsPredicted());
// if turning off
if (!bON) {
// do nothing
return;
}
// mark as predictable
en_ulFlags|=ENF_PREDICTABLE;
// add to container
en_pwoWorld->wo_cenPredictable.Add(this);
}
}
// check if this instance is head of prediction chain
BOOL CEntity::IsPredictionHead(void)
{
// if predicted, or will be predicted, or is a temporary predictor
if (en_ulFlags&(ENF_PREDICTED|ENF_WILLBEPREDICTED|ENF_TEMPPREDICTOR)) {
// it cannot be head of the chain
return FALSE;
}
// if predictor, but not currently in the last step of prediction
if ((en_ulFlags&ENF_PREDICTOR) &&
_pTimer->CurrentTick()<=_pNetwork->ga_sesSessionState.ses_tmPredictionHeadTick) {
// it cannot be head of the chain
return FALSE;
}
// otherwise it is head of the chain
return TRUE;
}
// get the prediction original (predicted), or self if not predicting
CEntity *CEntity::GetPredictionTail(void)
{
// if this is a predictor
if (IsPredictor()) {
// it must be head of the prediction chain
//ASSERT(IsPredictionHead());
// get its predicted
return GetPredicted();
}
// in other cases, return self
return this;
}
// check if active for prediction now
BOOL CEntity::IsAllowedForPrediction(void) const
{
return !_pNetwork->IsPredicting() || IsPredictor();
}
// check an event for prediction, returns true if already predicted
BOOL CEntity::CheckEventPrediction(ULONG ulTypeID, ULONG ulEventID)
{
return _pNetwork->ga_sesSessionState.CheckEventPrediction(this, ulTypeID, ulEventID);
}
/* Called after creating and setting its properties. */
void CEntity::OnInitialize(const CEntityEvent &eeInput)
{
ASSERT(GetFPUPrecision()==FPT_24BIT);
// try to find a handler in start state
pEventHandler pehHandler = HandlerForStateAndEvent(1, eeInput.ee_slEvent);
// if there is a handler
if (pehHandler!=NULL) {
// call the function
(this->*pehHandler)(eeInput);
// if there is no handler
} else {
ASSERTALWAYS("All entities must have Main procedure!");
}
}
/* Called before releasing entity. */
void CEntity::OnEnd(void)
{
}
// print stack to debug output
const char *CEntity::PrintStackDebug(void)
{
return "not CRationalEntity";
};
/*
* Prepare entity (call after setting properties).
*/
void CEntity::Initialize(const CEntityEvent &eeInput)
{
CSetFPUPrecision FPUPrecision(FPT_24BIT);
// make sure we are not deleted during intialization
CEntityPointer penThis = this;
Initialize_internal(eeInput);
// set spatial clasification
FindSectorsAroundEntity();
// precache all other things
Precache();
}
void CEntity::Initialize_internal(const CEntityEvent &eeInput)
{
#ifndef NDEBUG
// clear settings for debugging
en_RenderType = RT_ILLEGAL;
#endif
// remember brush zoning flag
BOOL bWasZoning = en_ulFlags&ENF_ZONING;
// let derived class initialize according to the properties
OnInitialize(eeInput);
// derived class must set all properties
// ASSERT(en_RenderType != RT_ILLEGAL);
// if this is a brush
if (en_RenderType==RT_BRUSH || en_RenderType==RT_FIELDBRUSH) {
// test if zoning
BOOL bZoning = en_ulFlags&ENF_ZONING;
// if switching from zoning to non-zoning
if (bWasZoning && !bZoning) {
// switch from zoning to non-zoning
en_pbrBrush->SwitchToNonZoning();
en_rdSectors.Clear();
// if switching from non-zoning to zoning
} else if (!bWasZoning && bZoning) {
// switch from non-zoning to zoning
en_pbrBrush->SwitchToZoning();
en_rdSectors.Clear();
}
}
// if it is a field brush
CFieldSettings *pfs = GetFieldSettings();
if (pfs!=NULL) {
// remember its field settings
ASSERT(en_RenderType == RT_FIELDBRUSH);
en_pbrBrush->br_pfsFieldSettings = pfs;
}
}
/*
* Clean-up entity.
*/
void CEntity::End(void)
{
CSetFPUPrecision FPUPrecision(FPT_24BIT);
/* NOTE: Must not remove from thinker/mover list here, or CServer::ProcessGameTick()
* might crash!
*/
End_internal();
}
void CEntity::End_internal(void)
{
ASSERT(GetFPUPrecision()==FPT_24BIT);
// let derived class clean-up after itself
OnEnd();
// clear last positions
if (en_plpLastPositions!=NULL) {
delete en_plpLastPositions;
en_plpLastPositions = NULL;
}
// clear spatial classification
en_fSpatialClassificationRadius = -1.0f;
en_boxSpatialClassification = FLOATaabbox3D();
// depending on entity type
switch(en_RenderType) {
// if it is brush
case RT_BRUSH:
DiscardCollisionInfo();
break;
// if it is field brush
case RT_FIELDBRUSH:
DiscardCollisionInfo();
break;
// if it is model
case RT_MODEL:
case RT_EDITORMODEL:
// free its model object
delete en_pmoModelObject;
delete en_psiShadingInfo;
DiscardCollisionInfo();
en_pmoModelObject = NULL;
en_psiShadingInfo = NULL;
break;
// if it is ska model
case RT_SKAMODEL:
case RT_SKAEDITORMODEL:
en_pmiModelInstance->Clear();
delete en_pmiModelInstance;
delete en_psiShadingInfo;
DiscardCollisionInfo();
en_pmiModelInstance = NULL;
en_psiShadingInfo = NULL;
break;
case RT_TERRAIN:
DiscardCollisionInfo();
break;
// if it is nothing
case RT_NONE:
case RT_VOID:
// do nothing
NOTHING;
break;
// if it is any other type
default:
ASSERTALWAYS("Unsupported entity type");
}
// clear entity type
en_RenderType = RT_NONE;
}
/*
* Reinitialize the entity.
*/
void CEntity::Reinitialize(void)
{
ASSERT(GetFPUPrecision()==FPT_24BIT);
End_internal();
Initialize_internal(_eeVoid);
}
// teleport this entity to a new location -- takes care of telefrag damage
void CEntity::Teleport(const CPlacement3D &plNew, BOOL bTelefrag /*=TRUE*/)
{
ASSERT(GetFPUPrecision()==FPT_24BIT);
ASSERT(en_fSpatialClassificationRadius>0);
// if telefragging is on and the entity has collision box
if (bTelefrag && en_pciCollisionInfo!=NULL) {
// create the box of the entity at its new placement
FLOATmatrix3D mRot;
MakeRotationMatrixFast(mRot, plNew.pl_OrientationAngle);
FLOAT3D vPos = plNew.pl_PositionVector;
CMovingSphere &ms0 = en_pciCollisionInfo->ci_absSpheres[0];
CMovingSphere &ms1 = en_pciCollisionInfo->ci_absSpheres[en_pciCollisionInfo->ci_absSpheres.Count()-1];
FLOATaabbox3D box;
box = FLOATaabbox3D(vPos+ms0.ms_vCenter*mRot, ms0.ms_fR);
box |= FLOATaabbox3D(vPos+ms1.ms_vCenter*mRot, ms1.ms_fR);
// first inflict huge damage there in the entities box
InflictBoxDamage(this, DMT_TELEPORT, 100000.0f, box);
}
// remember original orientation matrix
FLOATmatrix3D mOld = en_mRotation;
// now put the entity there
SetPlacement(plNew);
// movable entity
if (en_ulPhysicsFlags & EPF_MOVABLE) {
((CMovableEntity*)this)->ClearTemporaryData();
((CMovableEntity*)this)->en_plLastPlacement = en_plPlacement;
// transform speeds
FLOATmatrix3D mRel = en_mRotation*!mOld;
((CMovableEntity*)this)->en_vCurrentTranslationAbsolute *= mRel;
if (_pNetwork->ga_ulDemoMinorVersion>=7) {
// clear reference
((CMovableEntity*)this)->en_penReference = NULL;
((CMovableEntity*)this)->en_pbpoStandOn = NULL;
}
// notify that it was teleported
SendEvent(ETeleport());
((CMovableEntity*)this)->AddToMovers();
extern INDEX ent_bReportSpawnInWall;
if (ent_bReportSpawnInWall) {
// if movable model
if (en_RenderType==RT_MODEL || en_RenderType==RT_EDITORMODEL ||
en_RenderType==RT_SKAMODEL || en_RenderType==RT_SKAEDITORMODEL) {
// check if it was teleported inside a wall
CMovableModelEntity *pmme = (CMovableModelEntity*)this;
CEntity *ppenObstacleDummy;
if (pmme->CheckForCollisionNow(pmme->en_iCollisionBox, &ppenObstacleDummy)) {
CPrintF("Entity '%s' was teleported inside a wall at (%g,%g,%g)!\n",
GetName(),
en_plPlacement.pl_PositionVector(1),
en_plPlacement.pl_PositionVector(2),
en_plPlacement.pl_PositionVector(3));
}
}
}
}
}
/*
* Set placement of this entity. (use only in WEd!)
*/
void CEntity::SetPlacement(const CPlacement3D &plNew)
{
CSetFPUPrecision FPUPrecision(FPT_24BIT);
// check if orientation is changed
BOOL bSameOrientation = (plNew.pl_OrientationAngle==en_plPlacement.pl_OrientationAngle);
// if the orientation has not changed
if (bSameOrientation) {
// set the placement and do all needed recalculation
SetPlacement_internal(plNew, en_mRotation, FALSE /* doesn't have to be near. */);
// if the orientation has changed
} else {
// calculate new rotation matrix
FLOATmatrix3D mRotation;
MakeRotationMatrixFast(mRotation, plNew.pl_OrientationAngle);
// set the placement and do all needed recalculation
SetPlacement_internal(plNew, mRotation, FALSE /* doesn't have to be near. */);
}
// if this entity has parent
if (en_penParent!=NULL) {
// adjust relative placement
en_plRelativeToParent = en_plPlacement;
en_plRelativeToParent.AbsoluteToRelativeSmooth(en_penParent->en_plPlacement);
}
}
/*
* Fall down to floor. (use only in WEd!)
*/
void CEntity::FallDownToFloor( void)
{
CEntity::RenderType rt = GetRenderType();
// is this old model
if(rt==CEntity::RT_MODEL || rt==CEntity::RT_EDITORMODEL) {
ASSERT(en_pmoModelObject != NULL);
// is this ska model
} else if(rt==CEntity::RT_SKAMODEL || rt==CEntity::RT_SKAEDITORMODEL) {
ASSERT(GetModelInstance() != NULL);
} else {
return;
}
// if( rt!=CEntity::RT_MODEL && rt!=CEntity::RT_EDITORMODEL) return;
// ASSERT(en_pmoModelObject != NULL);
CPlacement3D plPlacement = GetPlacement();
FLOAT3D vRay[4];
// if it is movable entity
if( en_ulPhysicsFlags & EPF_MOVABLE) {
INDEX iEq;
FLOATaabbox3D box;
GetCollisionBoxParameters(GetCollisionBoxIndex(), box, iEq);
FLOAT3D vMin = box.Min();
FLOAT3D vMax = box.Max();
// all ray casts start from same height
vRay[0](2) = vMax(2);
vRay[1](2) = vMax(2);
vRay[2](2) = vMax(2);
vRay[3](2) = vMax(2);
vRay[0](1) = vMin(1);
vRay[0](3) = vMin(3);
vRay[1](1) = vMin(1);
vRay[1](3) = vMax(3);
vRay[2](1) = vMax(1);
vRay[2](3) = vMin(3);
vRay[3](1) = vMax(1);
vRay[3](3) = vMax(3);
}
else {
FLOATaabbox3D box;
if(rt==CEntity::RT_SKAMODEL || rt==CEntity::RT_SKAEDITORMODEL) {
GetModelInstance()->GetCurrentColisionBox( box);
} else {
en_pmoModelObject->GetCurrentFrameBBox( box);
}
FLOAT3D vCenterUp = box.Center();
vCenterUp(2) = box.Max()(2);
vRay[0] = vCenterUp;
vRay[1] = vCenterUp;
vRay[2] = vCenterUp;
vRay[3] = vCenterUp;
}
FLOAT fMaxY = -9999999.0f;
BOOL bFloorHitted = FALSE;
for( INDEX iRay=0; iRay<4; iRay++)
{
FLOAT3D vSource = plPlacement.pl_PositionVector+vRay[iRay];
FLOAT3D vTarget = vSource;
vTarget(2) -= 1000.0f;
CCastRay crRay( this, vSource, vTarget);
crRay.cr_ttHitModels = CCastRay::TT_NONE; // CCastRay::TT_FULLSEETHROUGH;
crRay.cr_bHitTranslucentPortals = TRUE;
crRay.cr_bPhysical = TRUE;
GetWorld()->CastRay(crRay);
if( (crRay.cr_penHit != NULL) && (crRay.cr_vHit(2) > fMaxY)) {
fMaxY = crRay.cr_vHit(2);
bFloorHitted = TRUE;
}
}
if( bFloorHitted) plPlacement.pl_PositionVector(2) += fMaxY-plPlacement.pl_PositionVector(2)+0.01f;
SetPlacement( plPlacement);
}
extern CEntity *_penLightUpdating;
extern BOOL _bDontDiscardLinks = FALSE;
// internal repositioning function
void CEntity::SetPlacement_internal(const CPlacement3D &plNew, const FLOATmatrix3D &mRotation,
BOOL bNear)
{
ASSERT(GetFPUPrecision()==FPT_24BIT);
_pfPhysicsProfile.StartTimer(CPhysicsProfile::PTI_SETPLACEMENT);
_pfPhysicsProfile.IncrementTimerAveragingCounter(CPhysicsProfile::PTI_SETPLACEMENT);
// invalidate eventual cached info for still models
en_ulFlags &= ~ENF_VALIDSHADINGINFO;
_pfPhysicsProfile.StartTimer(CPhysicsProfile::PTI_SETPLACEMENT_COORDSUPDATE);
// remembel old placement of the entity
CPlacement3D plOld = en_plPlacement;
// set new placement of the entity
en_plPlacement = plNew;
en_mRotation = mRotation;
_pfPhysicsProfile.StopTimer(CPhysicsProfile::PTI_SETPLACEMENT_COORDSUPDATE);
// if this is a brush entity
if (en_RenderType==RT_BRUSH || en_RenderType==RT_FIELDBRUSH) {
_pfPhysicsProfile.StartTimer(CPhysicsProfile::PTI_SETPLACEMENT_BRUSHUPDATE);
// recalculate all bounding boxes relative to new position
_bDontDiscardLinks = TRUE;
en_pbrBrush->CalculateBoundingBoxes();
_bDontDiscardLinks = FALSE;
BOOL bHasShadows=FALSE;
// for all brush mips
FOREACHINLIST(CBrushMip, bm_lnInBrush, en_pbrBrush->br_lhBrushMips, itbm) {
// for all sectors in the mip
{FOREACHINDYNAMICARRAY(itbm->bm_abscSectors, CBrushSector, itbsc) {
// for all polygons in this sector
{FOREACHINSTATICARRAY(itbsc->bsc_abpoPolygons, CBrushPolygon, itbpo) {
// if the polygon has shadows
if (!(itbpo->bpo_ulFlags & BPOF_FULLBRIGHT)) {
// discard shadows
itbpo->DiscardShadows();
bHasShadows = TRUE;
}
}}
}}
}
// find possible shadow layers near affected area
if (bHasShadows) {
if (en_ulFlags&ENF_DYNAMICSHADOWS) {
_penLightUpdating = NULL;
} else {
_penLightUpdating = this;
}
en_pwoWorld->FindShadowLayers(en_pbrBrush->GetFirstMip()->bm_boxBoundingBox,
FALSE, FALSE /* no directional */);
_penLightUpdating = NULL;
}
// if it is zoning
if (en_ulFlags&ENF_ZONING) {
// FPU must be in 53-bit mode
CSetFPUPrecision FPUPrecision(FPT_53BIT);
// for all brush mips
FOREACHINLIST(CBrushMip, bm_lnInBrush, en_pbrBrush->br_lhBrushMips, itbm) {
// for all sectors in the mip
{FOREACHINDYNAMICARRAY(itbm->bm_abscSectors, CBrushSector, itbsc) {
// find entities in sector
itbsc->FindEntitiesInSector();
}}
}
}
_pfPhysicsProfile.StopTimer(CPhysicsProfile::PTI_SETPLACEMENT_BRUSHUPDATE);
} else if(en_RenderType==RT_TERRAIN) {
// Update terrain shadow map
CTerrain *ptrTerrain = GetTerrain();
ASSERT(ptrTerrain!=NULL);
ptrTerrain->UpdateShadowMap();
}
// set spatial clasification
_pfPhysicsProfile.StartTimer(CPhysicsProfile::PTI_SETPLACEMENT_SPATIALUPDATE);
if (bNear) {
FindSectorsAroundEntityNear();
} else {
FindSectorsAroundEntity();
}
_pfPhysicsProfile.StopTimer(CPhysicsProfile::PTI_SETPLACEMENT_SPATIALUPDATE);
_pfPhysicsProfile.StartTimer(CPhysicsProfile::PTI_SETPLACEMENT_LIGHTUPDATE);
// if it is a light source
{CLightSource *pls = GetLightSource();
if (pls!=NULL) {
// find all shadow maps that should have layers from this light source
pls->FindShadowLayers(FALSE);
// update shadow map on all terrains in world
pls->UpdateTerrains(plOld,en_plPlacement);
}}
_pfPhysicsProfile.StopTimer(CPhysicsProfile::PTI_SETPLACEMENT_LIGHTUPDATE);
// move the entity to new position in collision grid
if (en_pciCollisionInfo!=NULL) {
_pfPhysicsProfile.StartTimer(CPhysicsProfile::PTI_SETPLACEMENT_COLLISIONUPDATE);
FLOATaabbox3D boxNew;
en_pciCollisionInfo->MakeBoxAtPlacement(
en_plPlacement.pl_PositionVector, en_mRotation, boxNew);
if (en_RenderType!=RT_BRUSH && en_RenderType!=RT_FIELDBRUSH) {
en_pwoWorld->MoveEntityInCollisionGrid( this, en_pciCollisionInfo->ci_boxCurrent, boxNew);
}
en_pciCollisionInfo->ci_boxCurrent = boxNew;
_pfPhysicsProfile.StopTimer(CPhysicsProfile::PTI_SETPLACEMENT_COLLISIONUPDATE);
}
_pfPhysicsProfile.StopTimer(CPhysicsProfile::PTI_SETPLACEMENT);
// NOTE: this is outside profile because it uses recursion
// for each child of this entity
{FOREACHINLIST(CEntity, en_lnInParent, en_lhChildren, itenChild) {
CPlacement3D plNew = itenChild->en_plRelativeToParent;
plNew.RelativeToAbsoluteSmooth(en_plPlacement);
itenChild->SetPlacement(plNew);
}}
}
// this one is used in rendering - gets lerped placement between ticks
CPlacement3D CEntity::GetLerpedPlacement(void) const
{
// if it has no parent
if (en_penParent==NULL) {
// no lerping
return en_plPlacement;
// if it has parent
} else {
// get lerped placement relative to parent
CPlacement3D plParentLerped = en_penParent->GetLerpedPlacement();
CPlacement3D plLerped = en_plRelativeToParent;
plLerped.RelativeToAbsoluteSmooth(plParentLerped);
return plLerped;
}
}
void CEntity::SetFlags(ULONG ulFlags)
{
en_ulFlags = ulFlags;
}
void CEntity::SetPhysicsFlags(ULONG ulFlags)
{
// remember the new flags
en_ulPhysicsFlags = ulFlags;
// cache eventual collision info
FindCollisionInfo();
}
void CEntity::SetCollisionFlags(ULONG ulFlags)
{
// remember the new flags
en_ulCollisionFlags = ulFlags;
// cache eventual collision info
FindCollisionInfo();
}
void CEntity::SetParent(CEntity *penNewParent)
{
// if there is a parent already
if (en_penParent!=NULL) {
// remove from it
en_penParent = NULL;
en_lnInParent.Remove();
}
// if should set new parent
if (penNewParent!=NULL) {
// for each predecesor (parent) entity in the chain
for (CEntity *penPred=penNewParent; penPred!=NULL; penPred=penPred->en_penParent) {
// if self
if (penPred==this) {
// refuse to set parent
return;
}
}
// set new parent
en_penParent = penNewParent;
penNewParent->en_lhChildren.AddTail(en_lnInParent);
// calculate relative placement
en_plRelativeToParent = en_plPlacement;
en_plRelativeToParent.AbsoluteToRelativeSmooth(en_penParent->en_plPlacement);
}
}
// find first child of given class
CEntity *CEntity::GetChildOfClass(const char *strClass)
{
// for each child of this entity
{FOREACHINLIST(CEntity, en_lnInParent, en_lhChildren, itenChild) {
// if it is of given class
if (IsOfClass(itenChild, strClass)) {
return itenChild;
}
}}
// not found
return NULL;
}
/*
* Destroy this entity (entity must not be targetable).
*/
void CEntity::Destroy(void)
{
ASSERT(GetFPUPrecision()==FPT_24BIT);
// if it is already destroyed
if (en_ulFlags&ENF_DELETED) {
// do nothing
return;
}
// if it is a light source
{CLightSource *pls = GetLightSource();
if (pls!=NULL) {
// destroy all of its shadow layers
pls->DiscardShadowLayers();
}}
// clean up the entity
End();
SetDefaultProperties(); // this effectively clears all entity pointers!
// unlink parent-child links
if (en_penParent != NULL) {
en_penParent = NULL;
en_lnInParent.Remove();
}
{FORDELETELIST( CEntity, en_lnInParent, en_lhChildren, itenChild) {
itenChild->en_penParent = NULL;
itenChild->en_lnInParent.Remove();
}}
// set its flags to mark that it doesn't not exist anymore
en_ulFlags|=ENF_DELETED;
// make sure that no deleted entity can be alive
en_ulFlags&=~ENF_ALIVE;
// remove from all sectors
en_rdSectors.Clear();
// remove from active entities in the world
en_pwoWorld->wo_cenEntities.Remove(this);
// remove the reference made by the entity itself (this can delete it!)
RemReference();
}
FLOAT3D _vHandle;
CBrushPolygon *_pbpoNear;
CTerrain *_ptrTerrainNear;
FLOAT _fNearDistance;
FLOAT3D _vNearPoint;
static void CheckPolygonForShadingInfo(CBrushPolygon &bpo)
{
// if it is not a wall
if (bpo.bpo_ulFlags&(BPOF_INVISIBLE|BPOF_PORTAL) ) {
// skip it
return;
}
// if the polygon or it's entity are invisible
if (bpo.bpo_pbscSector->bsc_pbmBrushMip->bm_pbrBrush->br_penEntity->en_ulFlags&ENF_HIDDEN) {
// skip it
return;
}
const FLOATplane3D &plPolygon = bpo.bpo_pbplPlane->bpl_plAbsolute;
// find distance of the polygon plane from the handle
FLOAT fDistance = plPolygon.PointDistance(_vHandle);
// if it is behind the plane or further than nearest found
if (fDistance<0.0f || fDistance>_fNearDistance) {
// skip it
return;
}
// find projection of handle to the polygon plane
FLOAT3D vOnPlane = plPolygon.ProjectPoint(_vHandle);
// if it is not in the bounding box of polygon
const FLOATaabbox3D &boxPolygon = bpo.bpo_boxBoundingBox;
const FLOAT EPSILON = 0.01f;
if (
(boxPolygon.Min()(1)-EPSILON>vOnPlane(1)) ||
(boxPolygon.Max()(1)+EPSILON<vOnPlane(1)) ||
(boxPolygon.Min()(2)-EPSILON>vOnPlane(2)) ||
(boxPolygon.Max()(2)+EPSILON<vOnPlane(2)) ||
(boxPolygon.Min()(3)-EPSILON>vOnPlane(3)) ||
(boxPolygon.Max()(3)+EPSILON<vOnPlane(3))) {
// skip it
return;
}
// find major axes of the polygon plane
INDEX iMajorAxis1, iMajorAxis2;
GetMajorAxesForPlane(plPolygon, iMajorAxis1, iMajorAxis2);
// create an intersector
CIntersector isIntersector(_vHandle(iMajorAxis1), _vHandle(iMajorAxis2));
// for all edges in the polygon
FOREACHINSTATICARRAY(bpo.bpo_abpePolygonEdges, CBrushPolygonEdge, itbpePolygonEdge) {
// get edge vertices (edge direction is irrelevant here!)
const FLOAT3D &vVertex0 = itbpePolygonEdge->bpe_pbedEdge->bed_pbvxVertex0->bvx_vAbsolute;
const FLOAT3D &vVertex1 = itbpePolygonEdge->bpe_pbedEdge->bed_pbvxVertex1->bvx_vAbsolute;
// pass the edge to the intersector
isIntersector.AddEdge(
vVertex0(iMajorAxis1), vVertex0(iMajorAxis2),
vVertex1(iMajorAxis1), vVertex1(iMajorAxis2));
}
// if the point is not inside polygon
if (!isIntersector.IsIntersecting()) {
// skip it
return;
}
// remember the polygon
_pbpoNear = &bpo;
_fNearDistance = fDistance;
_vNearPoint = vOnPlane;
}
static void CheckTerrainForShadingInfo(CTerrain *ptrTerrain)
{
ASSERT(ptrTerrain!=NULL);
ASSERT(ptrTerrain->tr_penEntity!=NULL);
CEntity *pen = ptrTerrain->tr_penEntity;
FLOAT3D vTerrainNormal;
FLOAT3D vHitPoint;
FLOATplane3D plHitPlane;
vTerrainNormal = FLOAT3D(0,-1,0) * pen->en_mRotation;
FLOAT fDistance = TestRayCastHit(ptrTerrain,pen->en_mRotation,pen->en_plPlacement.pl_PositionVector,
_vHandle,_vHandle+vTerrainNormal,_fNearDistance,FALSE,plHitPlane,vHitPoint);
if(fDistance<_fNearDistance) {
_vNearPoint = vHitPoint;
_fNearDistance = fDistance;
_ptrTerrainNear = ptrTerrain;
}
}
/* Find and remember shading info for this entity if invalid. */
void CEntity::FindShadingInfo(void)
{
ASSERT(GetFPUPrecision()==FPT_24BIT);
// if this entity can't even have shading info
if (en_psiShadingInfo==NULL) {
// do nothing
return;
}
// if info is valid
if (en_ulFlags & ENF_VALIDSHADINGINFO) {
// !!! check if the polygon is still there !
// do nothing
return;
}
en_ulFlags |= ENF_VALIDSHADINGINFO;
en_psiShadingInfo->si_penEntity = this;
// clear shading info
en_psiShadingInfo->si_pbpoPolygon = NULL;
en_psiShadingInfo->si_ptrTerrain = NULL;
if (en_psiShadingInfo->si_lnInPolygon.IsLinked()) {
en_psiShadingInfo->si_lnInPolygon.Remove();
}
// take reference point at handle of the model entity
_vHandle = en_plPlacement.pl_PositionVector;
// start infinitely far away
_pbpoNear = NULL;
_ptrTerrainNear = NULL;
_fNearDistance = UpperLimit(1.0f);
// if this is movable entity
if (en_ulPhysicsFlags&EPF_MOVABLE) {
// for each cached near polygon
CStaticStackArray<CBrushPolygon *> &apbpo = ((CMovableEntity*)this)->en_apbpoNearPolygons;
for(INDEX iPolygon=0; iPolygon<apbpo.Count(); iPolygon++) {
CheckPolygonForShadingInfo(*apbpo[iPolygon]);
}
}
// for each sector that this entity is in
{FOREACHSRCOFDST(en_rdSectors, CBrushSector, bsc_rsEntities, pbsc)
// for each brush or terrain in this sector
{FOREACHDSTOFSRC(pbsc->bsc_rsEntities, CEntity, en_rdSectors, pen)
if(pen->en_RenderType==CEntity::RT_TERRAIN) {
CheckTerrainForShadingInfo(pen->GetTerrain());
} else if(pen->en_RenderType!=CEntity::RT_BRUSH && pen->en_RenderType!=CEntity::RT_FIELDBRUSH) {
break;
}
}}
ENDFOR}
// if this is non-movable entity, or no polygon or terrain found so far
if (_pbpoNear==NULL && _ptrTerrainNear==NULL) {
// for each sector that this entity is in
{FOREACHSRCOFDST(en_rdSectors, CBrushSector, bsc_rsEntities, pbsc)
// for each polygon in the sector
{FOREACHINSTATICARRAY(pbsc->bsc_abpoPolygons, CBrushPolygon, itbpo) {
CBrushPolygon &bpo = *itbpo;
CheckPolygonForShadingInfo(bpo);
}}
ENDFOR}
}
// if there is some polygon found
if( _pbpoNear!=NULL) {
// remember shading info
en_psiShadingInfo->si_pbpoPolygon = _pbpoNear;
_pbpoNear->bpo_lhShadingInfos.AddTail(en_psiShadingInfo->si_lnInPolygon);
en_psiShadingInfo->si_vNearPoint = _vNearPoint;
CEntity *penWithPolygon = _pbpoNear->bpo_pbscSector->bsc_pbmBrushMip->bm_pbrBrush->br_penEntity;
ASSERT(penWithPolygon!=NULL);
const FLOATmatrix3D &mPolygonRotation = penWithPolygon->en_mRotation;
const FLOAT3D &vPolygonTranslation = penWithPolygon->GetPlacement().pl_PositionVector;
_vNearPoint = (_vNearPoint-vPolygonTranslation)*!mPolygonRotation;
MEX2D vmexShadow;
_pbpoNear->bpo_mdShadow.GetTextureCoordinates(
_pbpoNear->bpo_pbplPlane->bpl_pwplWorking->wpl_mvRelative,
_vNearPoint, vmexShadow);
CBrushShadowMap &bsm = _pbpoNear->bpo_smShadowMap;
INDEX iMipLevel = bsm.sm_iFirstMipLevel;
FLOAT fpixU = FLOAT(vmexShadow(1)+bsm.sm_mexOffsetX)*(1.0f/(1<<iMipLevel));
FLOAT fpixV = FLOAT(vmexShadow(2)+bsm.sm_mexOffsetY)*(1.0f/(1<<iMipLevel));
en_psiShadingInfo->si_pixShadowU = floor(fpixU);
en_psiShadingInfo->si_pixShadowV = floor(fpixV);
en_psiShadingInfo->si_fUDRatio = fpixU-en_psiShadingInfo->si_pixShadowU;
en_psiShadingInfo->si_fLRRatio = fpixV-en_psiShadingInfo->si_pixShadowV;
// else if there is some terrain found
} else if(_ptrTerrainNear!=NULL) {
// remember shading info
en_psiShadingInfo->si_ptrTerrain = _ptrTerrainNear;
en_psiShadingInfo->si_vNearPoint = _vNearPoint;
FLOAT2D vTc = CalculateShadingTexCoords(_ptrTerrainNear,_vNearPoint);
en_psiShadingInfo->si_pixShadowU = floor(vTc(1));
en_psiShadingInfo->si_pixShadowV = floor(vTc(2));
en_psiShadingInfo->si_fLRRatio = vTc(1) - en_psiShadingInfo->si_pixShadowU;
en_psiShadingInfo->si_fUDRatio = vTc(2) - en_psiShadingInfo->si_pixShadowV;
_ptrTerrainNear->tr_lhShadingInfos.AddTail(en_psiShadingInfo->si_lnInPolygon);
}
}
CBrushSector *CEntity::GetFirstSector(void)
{
{FOREACHSRCOFDST(en_rdSectors, CBrushSector, bsc_rsEntities, pbsc)
return pbsc;
ENDFOR};
return NULL;
}
CBrushSector *CEntity::GetFirstSectorWithName(void)
{
CBrushSector *pbscResult = NULL;
{FOREACHSRCOFDST(en_rdSectors, CBrushSector, bsc_rsEntities, pbsc)
if (pbsc->bsc_strName!="") {
pbscResult = pbsc;
break;
}
ENDFOR};
return pbscResult;
}
// max. distance between two spheres (as factor of radius of one sphere)
#define MIN_SPHEREDENSITY 1.0f
CCollisionInfo::CCollisionInfo(const CCollisionInfo &ciOrg)
{
ci_absSpheres = ciOrg.ci_absSpheres ;
ci_fMinHeight = ciOrg.ci_fMinHeight ;
ci_fMaxHeight = ciOrg.ci_fMaxHeight ;
ci_fHandleY = ciOrg.ci_fHandleY ;
ci_fHandleR = ciOrg.ci_fHandleR ;
ci_boxCurrent = ciOrg.ci_boxCurrent ;
ci_ulFlags = ciOrg.ci_ulFlags ;
}
/* Create collision info for a model. */
void CCollisionInfo::FromModel(CEntity *penModel, INDEX iBox)
{
ASSERT(GetFPUPrecision()==FPT_24BIT);
// get collision box information from the model
FLOATaabbox3D boxModel;
INDEX iBoxType;
penModel->GetCollisionBoxParameters(iBox, boxModel, iBoxType);
FLOAT3D vBoxOffset = boxModel.Center();
FLOAT3D vBoxSize = boxModel.Size();
// ASSERT(iBoxType==LENGHT_EQ_WIDTH);
ci_ulFlags = 0;
INDEX iAxisMain; // in which direction are spheres set
INDEX iAxis1, iAxis2; // other axis
if (iBoxType==LENGTH_EQ_WIDTH) {
iAxisMain = 2;
iAxis1 = 1; iAxis2 = 3;
} else if (iBoxType==HEIGHT_EQ_WIDTH) {
iAxisMain = 3;
iAxis1 = 2; iAxis2 = 1;
} else if (iBoxType==LENGTH_EQ_HEIGHT) {
iAxisMain = 1;
iAxis1 = 2; iAxis2 = 3;
} else {
ASSERTALWAYS("Invalid collision box");
iAxisMain = 2;
iAxis1 = 1; iAxis2 = 3;
}
// calculate radius of one sphere
FLOAT fSphereRadius = vBoxSize(iAxis1)/2.0f;
// calculate length along which to set spheres
FLOAT fSphereCentersSpan = vBoxSize(iAxisMain)-fSphereRadius*2;
// calculate number of spheres to use
INDEX ctSpheres = 0;
if (fSphereRadius>0.0001f) {
ctSpheres = INDEX(ceil(fSphereCentersSpan/(fSphereRadius*MIN_SPHEREDENSITY)))+1;
}
if (ctSpheres==0) {
ctSpheres=1;
}
// calculate how far from each other to set sphere centers
FLOAT fSphereCentersDistance;
if (ctSpheres==1) {
fSphereCentersDistance = 0.0f;
} else {
fSphereCentersDistance = fSphereCentersSpan/(FLOAT)(ctSpheres-1);
}
// calculate coordinates for spreading sphere centers
FLOAT fSphereCenterX = vBoxOffset(iAxis1);
FLOAT fSphereCenterZ = vBoxOffset(iAxis2);
FLOAT fSphereCenterY0 = vBoxOffset(iAxisMain)-(vBoxSize(iAxisMain)/2.0f)+fSphereRadius;
FLOAT fSphereCenterKY = fSphereCentersDistance;
ci_fMinHeight = boxModel.Min()(2);
ci_fMaxHeight = boxModel.Max()(2);
ci_fHandleY = UpperLimit(1.0f);
// create needed number of spheres in the array
ci_absSpheres.Clear();
ci_absSpheres.New(ctSpheres);
// for each sphere
for(INDEX iSphere=0; iSphere<ctSpheres; iSphere++) {
CMovingSphere &ms = ci_absSpheres[iSphere];
// set its center and radius
ms.ms_vCenter(iAxis1) = fSphereCenterX;
ms.ms_vCenter(iAxis2) = fSphereCenterZ;
ms.ms_vCenter(iAxisMain) = fSphereCenterY0+iSphere*fSphereCenterKY;
ms.ms_fR = fSphereRadius;
ci_fHandleY = Min(ci_fHandleY, ms.ms_vCenter(2));
}
// remember handle parameters
if (ctSpheres==1 || iBoxType==LENGTH_EQ_WIDTH) {
ci_ulFlags|=CIF_CANSTANDONHANDLE;
ci_fHandleR = fSphereRadius;
} else {
ci_fHandleR = 0.0f;
}
// set optimization flags
if (ctSpheres==1 &&
ci_absSpheres[0].ms_vCenter(1)==0 &&
ci_absSpheres[0].ms_vCenter(2)==0 &&
ci_absSpheres[0].ms_vCenter(3)==0) {
ci_ulFlags|=CIF_IGNOREROTATION;
}
if (iBoxType==LENGTH_EQ_WIDTH &&
ci_absSpheres[0].ms_vCenter(1)==0 &&
ci_absSpheres[0].ms_vCenter(3)==0) {
ci_ulFlags|=CIF_IGNOREHEADING;
}
}
/* Create collision info for a ska model */
void CCollisionInfo::FromSkaModel(CEntity *penModel, INDEX iBox)
{
}
/* Create collision info for a brush. */
void CCollisionInfo::FromBrush(CBrush3D *pbrBrush)
{
ASSERT(GetFPUPrecision()==FPT_24BIT);
ci_absSpheres.Clear();
ci_absSpheres.New(1);
ci_ulFlags = CIF_BRUSH;
// clear brush's relative box
FLOATaabbox3D box;
// get first brush mip
CBrushMip *pbm = pbrBrush->GetFirstMip();
// for each sector in the brush mip
{FOREACHINDYNAMICARRAY(pbm->bm_abscSectors, CBrushSector, itbsc) {
// for each vertex in the sector
{FOREACHINSTATICARRAY(itbsc->bsc_abvxVertices, CBrushVertex, itbvx) {
CBrushVertex &bvx = *itbvx;
// add it to bounding box
box |= DOUBLEtoFLOAT(bvx.bvx_vdPreciseRelative);
}}
}}
// create a sphere from the relative box
ci_absSpheres[0].ms_vCenter = box.Center();
ci_absSpheres[0].ms_fR = box.Size().Length()/2;
ci_fMinHeight = UpperLimit(1.0f);
ci_fMaxHeight = LowerLimit(1.0f);
ci_fHandleY = 0.0f;
ci_fHandleR = 1.0f;
}
/* Calculate current bounding box in absolute space from position. */
void CCollisionInfo::MakeBoxAtPlacement(const FLOAT3D &vPosition, const FLOATmatrix3D &mRotation,
FLOATaabbox3D &box)
{
ASSERT(GetFPUPrecision()==FPT_24BIT);
CMovingSphere &ms0 = ci_absSpheres[0];
CMovingSphere &ms1 = ci_absSpheres[ci_absSpheres.Count()-1];
box = FLOATaabbox3D(vPosition+ms0.ms_vCenter*mRotation, ms0.ms_fR);
box |= FLOATaabbox3D(vPosition+ms1.ms_vCenter*mRotation, ms1.ms_fR);
}
// get maximum radius of entity in xz plane (relative to entity handle)
FLOAT CCollisionInfo::GetMaxFloorRadius(void)
{
ASSERT(GetFPUPrecision()==FPT_24BIT);
// get first and last sphere
CMovingSphere &ms0 = ci_absSpheres[0];
CMovingSphere &ms1 = ci_absSpheres[ci_absSpheres.Count()-1];
// get their positions in xz plane
FLOAT3D vPosXZ0 = ms0.ms_vCenter;
FLOAT3D vPosXZ1 = ms1.ms_vCenter;
vPosXZ0(2) = 0.0f;
vPosXZ1(2) = 0.0f;
// return maximum distance from the handle in xz plane
return Max(
vPosXZ0.Length()+ms0.ms_fR,
vPosXZ1.Length()+ms1.ms_fR);
}
/* Find and remember collision info for this entity. */
void CEntity::FindCollisionInfo(void)
{
ASSERT(GetFPUPrecision()==FPT_24BIT);
// discard eventual collision info
DiscardCollisionInfo();
// if the entity is colliding
if (en_ulCollisionFlags&ECF_TESTMASK) {
// if it is a model
if ((en_RenderType==RT_MODEL||en_RenderType==RT_EDITORMODEL)
&&(en_pmoModelObject->GetData()!=NULL)) {
// cache its new collision info
en_pciCollisionInfo = new CCollisionInfo;
en_pciCollisionInfo->FromModel(this, GetCollisionBoxIndex());
} else if ((en_RenderType==RT_SKAMODEL||en_RenderType==RT_SKAEDITORMODEL)
&&(GetModelInstance()!=NULL)) {
// cache its new collision info
en_pciCollisionInfo = new CCollisionInfo;
en_pciCollisionInfo->FromModel(this, GetCollisionBoxIndex());
// if it is a brush
} else if (en_RenderType==RT_BRUSH) {
// if it is zoning brush and non movable
if ((en_ulFlags&ENF_ZONING) && !(en_ulPhysicsFlags&EPF_MOVABLE)) {
// do nothing
return;
}
// cache its new collision info
en_pciCollisionInfo = new CCollisionInfo;
en_pciCollisionInfo->FromBrush(en_pbrBrush);
// if it is a field brush
} else if (en_RenderType==RT_FIELDBRUSH) {
// cache its new collision info
en_pciCollisionInfo = new CCollisionInfo;
en_pciCollisionInfo->FromBrush(en_pbrBrush);
return;
} else if (en_RenderType==RT_TERRAIN) {
return;
} else {
return;
}
// add entity to collision grid
FLOATaabbox3D boxNew;
en_pciCollisionInfo->MakeBoxAtPlacement(
en_plPlacement.pl_PositionVector, en_mRotation, boxNew);
if (en_RenderType!=RT_BRUSH && en_RenderType!=RT_FIELDBRUSH) {
en_pwoWorld->AddEntityToCollisionGrid(this, boxNew);
}
en_pciCollisionInfo->ci_boxCurrent = boxNew;
}
}
// discard collision info for this entity
void CEntity::DiscardCollisionInfo(void)
{
// if there was any collision info
if (en_pciCollisionInfo!=NULL) {
// remove entity from collision grid
if (en_RenderType!=RT_BRUSH && en_RenderType!=RT_FIELDBRUSH) {
en_pwoWorld->RemoveEntityFromCollisionGrid(this, en_pciCollisionInfo->ci_boxCurrent);
}
// free it
delete en_pciCollisionInfo;
en_pciCollisionInfo = NULL;
}
// movable entity
if (en_ulPhysicsFlags & EPF_MOVABLE) {
((CMovableEntity*)this)->ClearTemporaryData();
}
}
// copy collision info from some other entity
void CEntity::CopyCollisionInfo(CEntity &enOrg)
{
ASSERT(GetFPUPrecision()==FPT_24BIT);
// if there is no collision info
if (enOrg.en_pciCollisionInfo==NULL) {
// do nothing
en_pciCollisionInfo = NULL;
return;
}
// create info and copy it
en_pciCollisionInfo = new CCollisionInfo(*enOrg.en_pciCollisionInfo);
// add entity to collision grid
FLOATaabbox3D boxNew;
en_pciCollisionInfo->MakeBoxAtPlacement(
en_plPlacement.pl_PositionVector, en_mRotation, boxNew);
if (en_RenderType!=RT_BRUSH && en_RenderType!=RT_FIELDBRUSH) {
en_pwoWorld->AddEntityToCollisionGrid(this, boxNew);
}
en_pciCollisionInfo->ci_boxCurrent = boxNew;
}
/* Get box and sphere for spatial clasification. */
void CEntity::UpdateSpatialRange(void)
{
CSetFPUPrecision FPUPrecision(FPT_24BIT);
en_fSpatialClassificationRadius = -1.0f;
// if zoning
if (en_ulFlags&ENF_ZONING) {
// do nothing
return;
}
FLOATaabbox3D box;
FLOATaabbox3D boxStretched;
// get bounding box of the entity
// is this old model
if (en_RenderType==CEntity::RT_MODEL
||en_RenderType==CEntity::RT_EDITORMODEL) {
en_pmoModelObject->GetAllFramesBBox(box);
box.StretchByVector(en_pmoModelObject->mo_Stretch);
FLOAT3D fClassificationStretch = GetClassificationBoxStretch();
boxStretched = box;
boxStretched .StretchByVector( fClassificationStretch);
en_boxSpatialClassification = boxStretched;
// is this ska model
} else if (en_RenderType==CEntity::RT_SKAMODEL
|| en_RenderType==RT_SKAEDITORMODEL) {
GetModelInstance()->GetAllFramesBBox(box);
box.StretchByVector(GetModelInstance()->mi_vStretch);
FLOAT3D fClassificationStretch = GetClassificationBoxStretch();
boxStretched = box;
boxStretched.StretchByVector( fClassificationStretch);
en_boxSpatialClassification = boxStretched;
// is this brush
} else if (en_RenderType==CEntity::RT_BRUSH || en_RenderType==RT_FIELDBRUSH) {
box = en_pbrBrush->GetFirstMip()->bm_boxRelative;
boxStretched = box;
en_boxSpatialClassification = box;
// is this terrain
} else if (en_RenderType==CEntity::RT_TERRAIN) {
GetTerrain()->GetAllTerrainBBox(box);
boxStretched = box;
en_boxSpatialClassification = box;
} else {
return; // sound entities are not related to sectors !!!!
}
en_fSpatialClassificationRadius = Max( box.Min().Length(), box.Max().Length() );
ASSERT(IsValidFloat(en_fSpatialClassificationRadius));
}
/* Find and remember all sectors that this entity is in. */
void CEntity::FindSectorsAroundEntity(void)
{
CSetFPUPrecision sfp(FPT_53BIT);
// if not in spatial clasification
if (en_fSpatialClassificationRadius<0) {
// do nothing
return;
}
// get bounding sphere and box of entity
FLOAT fSphereRadius = en_fSpatialClassificationRadius;
const FLOAT3D &vSphereCenter = en_plPlacement.pl_PositionVector;
// make oriented bounding box of the entity
FLOATobbox3D boxEntity = FLOATobbox3D(en_boxSpatialClassification,
en_plPlacement.pl_PositionVector, en_mRotation);
DOUBLEobbox3D boxdEntity = FLOATtoDOUBLE(boxEntity);
// unset spatial clasification
en_rdSectors.Clear();
// for each brush in the world
FOREACHINDYNAMICARRAY(en_pwoWorld->wo_baBrushes.ba_abrBrushes, CBrush3D, itbr) {
CBrush3D &br=*itbr;
// if the brush entity is not zoning
if (itbr->br_penEntity==NULL || !(itbr->br_penEntity->en_ulFlags&ENF_ZONING)) {
// skip it
continue;
}
// for each mip in the brush
FOREACHINLIST(CBrushMip, bm_lnInBrush, itbr->br_lhBrushMips, itbm) {
// for each sector in the brush mip
FOREACHINDYNAMICARRAY(itbm->bm_abscSectors, CBrushSector, itbsc) {
// if the sector's bounding box has contact with the sphere
if(itbsc->bsc_boxBoundingBox.TouchesSphere(vSphereCenter, fSphereRadius)
// and with the box
&& boxEntity.HasContactWith(FLOATobbox3D(itbsc->bsc_boxBoundingBox))) {
// if the sphere is inside the sector
if (itbsc->bsc_bspBSPTree.TestSphere(
FLOATtoDOUBLE(vSphereCenter), FLOATtoDOUBLE(fSphereRadius))>=0) {
// if the box is inside the sector
if (itbsc->bsc_bspBSPTree.TestBox(boxdEntity)>=0) {
// relate the entity to the sector
if (en_RenderType==RT_BRUSH
||en_RenderType==RT_FIELDBRUSH
||en_RenderType==RT_TERRAIN) { // brushes first
AddRelationPairHeadHead(itbsc->bsc_rsEntities, en_rdSectors);
} else {
AddRelationPairTailTail(itbsc->bsc_rsEntities, en_rdSectors);
}
}
}
}
}
}
}
}
void CEntity::FindSectorsAroundEntityNear(void)
{
ASSERT(GetFPUPrecision()==FPT_24BIT);
// if not in spatial clasification
if (en_fSpatialClassificationRadius<0) {
// do nothing
return;
}
// this may be called only for movable entities
ASSERT(en_ulPhysicsFlags&EPF_MOVABLE);
CMovableEntity *pen = (CMovableEntity *)this;
// get bounding sphere and box of entity
FLOAT fSphereRadius = en_fSpatialClassificationRadius;
const FLOAT3D &vSphereCenter = en_plPlacement.pl_PositionVector;
FLOATaabbox3D boxEntity(vSphereCenter, fSphereRadius);
// make oriented bounding box of the entity
FLOATobbox3D oboxEntity = FLOATobbox3D(en_boxSpatialClassification,
en_plPlacement.pl_PositionVector, en_mRotation);
DOUBLEobbox3D oboxdEntity = FLOATtoDOUBLE(oboxEntity);
CListHead lhActive;
// for each sector around this entity
{FOREACHSRCOFDST(en_rdSectors, CBrushSector, bsc_rsEntities, pbsc)
// remember its link
pbsc->bsc_prlLink = pbsc_iter;
// add it to list of active sectors
lhActive.AddTail(pbsc->bsc_lnInActiveSectors);
ENDFOR}
CStaticStackArray<CBrushPolygon *> &apbpo = pen->en_apbpoNearPolygons;
// for each cached polygon
for(INDEX iPolygon=0; iPolygon<apbpo.Count(); iPolygon++) {
CBrushSector *pbsc = apbpo[iPolygon]->bpo_pbscSector;
// add its sector if not already added, and has BSP (is zoning)
if (!pbsc->bsc_lnInActiveSectors.IsLinked() && pbsc->bsc_bspBSPTree.bt_pbnRoot!=NULL) {
lhActive.AddTail(pbsc->bsc_lnInActiveSectors);
pbsc->bsc_prlLink = NULL;
}
}
// for each active sector
FOREACHINLIST(CBrushSector, bsc_lnInActiveSectors, lhActive, itbsc) {
CBrushSector *pbsc = itbsc;
// test if entity is in sector
BOOL bIn =
// the sector's bounding box has contact with given bounding box,
(pbsc->bsc_boxBoundingBox.HasContactWith(boxEntity))&&
// the sphere is inside the sector
(pbsc->bsc_bspBSPTree.TestSphere(
FLOATtoDOUBLE(vSphereCenter), FLOATtoDOUBLE(fSphereRadius))>=0)&&
// (use more detailed testing for moving brushes)
(en_RenderType!=RT_BRUSH||
// oriented box touches box of sector
(oboxEntity.HasContactWith(FLOATobbox3D(pbsc->bsc_boxBoundingBox)))&&
// oriented box is in bsp
(pbsc->bsc_bspBSPTree.TestBox(oboxdEntity)>=0));
// if it is not
if (!bIn) {
// if it has link
if (pbsc->bsc_prlLink!=NULL) {
// remove link to that sector
delete pbsc->bsc_prlLink;
pbsc->bsc_prlLink = NULL;
}
// if it is
} else {
// if it doesn't have link
if (pbsc->bsc_prlLink==NULL) {
// add the link
if (en_RenderType==RT_BRUSH
||en_RenderType==RT_FIELDBRUSH
||en_RenderType==RT_TERRAIN) { // brushes first
AddRelationPairHeadHead(pbsc->bsc_rsEntities, en_rdSectors);
} else {
AddRelationPairTailTail(pbsc->bsc_rsEntities, en_rdSectors);
}
}
}
}
// clear list of active sectors
{FORDELETELIST(CBrushSector, bsc_lnInActiveSectors, lhActive, itbsc) {
itbsc->bsc_prlLink = NULL;
itbsc->bsc_lnInActiveSectors.Remove();
}}
ASSERT(lhActive.IsEmpty());
// if there is no link found
if (en_rdSectors.IsEmpty()) {
// test with brute force algorithm
FindSectorsAroundEntity();
}
}
/*
* Uncache shadows of each polygon that has given gradient index
*/
void CEntity::UncacheShadowsForGradient(INDEX iGradient)
{
if(en_RenderType != CEntity::RT_BRUSH)
{
ASSERTALWAYS("Uncache shadows for gradient called on non-brush entity!");
return;
}
// for all brush mips
FOREACHINLIST(CBrushMip, bm_lnInBrush, en_pbrBrush->br_lhBrushMips, itbm)
{
// for all sectors in the mip
{FOREACHINDYNAMICARRAY(itbm->bm_abscSectors, CBrushSector, itbsc)
{
// for all polygons in this sector
{FOREACHINSTATICARRAY(itbsc->bsc_abpoPolygons, CBrushPolygon, itbpo)
{
// if the polygon has shadows
if (itbpo->bpo_bppProperties.bpp_ubGradientType == iGradient)
{
// uncache shadows
itbpo->bpo_smShadowMap.Uncache();
}
}}
}}
}
}
/*
* Get state transition for given state and event code.
*/
CEntity::pEventHandler CEntity::HandlerForStateAndEvent(SLONG slState, SLONG slEvent)
{
// find translation in the translation table of the DLL class
return en_pecClass->HandlerForStateAndEvent(slState, slEvent);
}
/*
* Handle an event - return false if event was not handled.
*/
BOOL CEntity::HandleEvent(const CEntityEvent &ee)
{
/*
By default, base entities ignore all events.
Events are handled by classes derived from CRationalEntity using state stack.
Anyway, it is possible to override this in some class if some other way
of event handling is desired.
*/
return FALSE;
}
/////////////////////////////////////////////////////////////////////
// Event posting system
class CSentEvent {
public:
CEntityPointer se_penEntity;
CEntityEvent *se_peeEvent;
inline void Clear(void) { se_penEntity = NULL; }
};
static CStaticStackArray<CSentEvent> _aseSentEvents; // delayed events
/* Send an event to this entity. */
void CEntity::SendEvent(const CEntityEvent &ee)
{
if (this==NULL) {
ASSERT(FALSE);
return;
}
CSentEvent &se = _aseSentEvents.Push();
se.se_penEntity = this;
se.se_peeEvent = ((CEntityEvent&)ee).MakeCopy(); // discard const qualifier
}
// find entities in a box (box must be around this entity)
void CEntity::FindEntitiesInRange(
const FLOATaabbox3D &boxRange, CDynamicContainer<CEntity> &cen, BOOL bCollidingOnly)
{
ASSERT(GetFPUPrecision()==FPT_24BIT);
// for each entity in the world of this entity
FOREACHINDYNAMICCONTAINER(en_pwoWorld->wo_cenEntities, CEntity, iten) {
// if it is zoning brush entity
if (iten->en_RenderType == CEntity::RT_BRUSH && (iten->en_ulFlags&ENF_ZONING)) {
// get first mip in its brush
CBrushMip *pbm = iten->en_pbrBrush->GetFirstMip();
// if the mip doesn't touch the box
if (!pbm->bm_boxBoundingBox.HasContactWith(boxRange)) {
// skip it
continue;
}
// for all sectors in this mip
FOREACHINDYNAMICARRAY(pbm->bm_abscSectors, CBrushSector, itbsc) {
// if the sector doesn't touch the box
if (!itbsc->bsc_boxBoundingBox.HasContactWith(boxRange)) {
// skip it
continue;
}
// for all entities in the sector
{FOREACHDSTOFSRC(itbsc->bsc_rsEntities, CEntity, en_rdSectors, pen)
// if the model entity touches the box
if ((pen->en_RenderType==RT_MODEL || pen->en_RenderType==RT_EDITORMODEL)
&& boxRange.HasContactWith(
FLOATaabbox3D(pen->GetPlacement().pl_PositionVector, pen->en_fSpatialClassificationRadius))) {
// if it has collision box
if (pen->en_pciCollisionInfo!=NULL) {
// for each sphere
FOREACHINSTATICARRAY(pen->en_pciCollisionInfo->ci_absSpheres, CMovingSphere, itms) {
// project it
itms->ms_vRelativeCenter0 = itms->ms_vCenter*pen->en_mRotation+pen->en_plPlacement.pl_PositionVector;
// if the sphere touches the range
if (boxRange.HasContactWith(FLOATaabbox3D(itms->ms_vRelativeCenter0, itms->ms_fR))) {
// add it to container
if (!cen.IsMember(pen)) {
cen.Add(pen);
}
goto next_entity;
}
}
// if no collision box, but non-colliding are allowed
} else if (!bCollidingOnly) {
// add it to container
if (!cen.IsMember(pen)) {
cen.Add(pen);
}
}
// if the brush entity touches the box
} else if (pen->en_RenderType==RT_BRUSH &&
boxRange.HasContactWith(
FLOATaabbox3D(pen->GetPlacement().pl_PositionVector, pen->en_fSpatialClassificationRadius))) {
// if the brush touches the box
if (boxRange.HasContactWith(pen->en_pbrBrush->GetFirstMip()->bm_boxBoundingBox)) {
// add it to container
if (!cen.IsMember(pen)) {
cen.Add(pen);
}
}
} else if ((pen->en_RenderType==RT_SKAMODEL || pen->en_RenderType==RT_SKAEDITORMODEL)
&& boxRange.HasContactWith(
FLOATaabbox3D(pen->GetPlacement().pl_PositionVector, pen->en_fSpatialClassificationRadius))) {
// if it has collision box
if (pen->en_pciCollisionInfo!=NULL) {
// for each sphere
FOREACHINSTATICARRAY(pen->en_pciCollisionInfo->ci_absSpheres, CMovingSphere, itms) {
// project it
itms->ms_vRelativeCenter0 = itms->ms_vCenter*pen->en_mRotation+pen->en_plPlacement.pl_PositionVector;
// if the sphere touches the range
if (boxRange.HasContactWith(FLOATaabbox3D(itms->ms_vRelativeCenter0, itms->ms_fR))) {
// add it to container
if (!cen.IsMember(pen)) {
cen.Add(pen);
}
goto next_entity;
}
}
// if no collision box, but non-colliding are allowed
} else if (!bCollidingOnly) {
// add it to container
if (!cen.IsMember(pen)) {
cen.Add(pen);
}
}
}
next_entity:;
ENDFOR}
}
}
}
}
/* Send an event to all entities in a box (box must be around this entity). */
void CEntity::SendEventInRange(const CEntityEvent &ee, const FLOATaabbox3D &boxRange)
{
// find entities in the range
CDynamicContainer<CEntity> cenToReceive;
FindEntitiesInRange(boxRange, cenToReceive, FALSE);
// for each entity in container
FOREACHINDYNAMICCONTAINER(cenToReceive, CEntity, iten) {
// send the event to it
iten->SendEvent(ee);
}
}
/* Handle all sent events. */
void CEntity::HandleSentEvents(void)
{
CSetFPUPrecision FPUPrecision(FPT_24BIT);
// while there are any unhandled events
INDEX iFirstEvent = 0;
while (iFirstEvent<_aseSentEvents.Count()) {
CSentEvent &se = _aseSentEvents[iFirstEvent];
// if not allowed to execute now
if (!se.se_penEntity->IsAllowedForPrediction()) {
// skip it
iFirstEvent++;
continue;
}
// if the entity is not destroyed
if (!(se.se_penEntity->en_ulFlags&ENF_DELETED)) {
// handle the current event
se.se_penEntity->HandleEvent(*se.se_peeEvent);
}
// go to next event
iFirstEvent++;
}
// for each event
for(INDEX iee=0; iee<_aseSentEvents.Count(); iee++) {
CSentEvent &se = _aseSentEvents[iee];
// release the entity and destroy the event
se.se_penEntity = NULL;
delete se.se_peeEvent;
se.se_peeEvent = NULL;
}
// flush all events
_aseSentEvents.PopAll();
}
/////////////////////////////////////////////////////////////////////
// DLL class interface
/* Initialize for being virtual entity that is not rendered. */
void CEntity::InitAsVoid(void)
{
en_RenderType = RT_VOID;
en_pbrBrush = NULL;
}
/*
* Initialize for beeing a model object.
*/
void CEntity::InitAsModel(void)
{
// set render type to model
en_RenderType = RT_MODEL;
// create a model object
en_pmoModelObject = new CModelObject;
en_psiShadingInfo = new CShadingInfo;
en_ulFlags &= ~ENF_VALIDSHADINGINFO;
}
/*
* Initialize for beeing a ska model object.
*/
void CEntity::InitAsSkaModel(void)
{
en_RenderType = RT_SKAMODEL;
en_psiShadingInfo = new CShadingInfo;
en_ulFlags &= ~ENF_VALIDSHADINGINFO;
}
/*
* Initialize for beeing a terrain object.
*/
void CEntity::InitAsTerrain(void)
{
en_RenderType = RT_TERRAIN;
// if there is no existing terrain
if(en_ptrTerrain == NULL) {
// create a new empty terrain in the brush archive of current world
en_ptrTerrain = en_pwoWorld->wo_taTerrains.ta_atrTerrains.New();
en_ptrTerrain->tr_penEntity = this;
// Create empty terrain
en_ptrTerrain->CreateEmptyTerrain_t(257,257);
en_ptrTerrain->SetTerrainSize(FLOAT3D(256,50,256));
en_ptrTerrain->SetShadowMapsSize(0,0);
en_ptrTerrain->UpdateShadowMap();
}
UpdateSpatialRange();
}
/*
* Initialize for beeing a model object, for editor only.
*/
void CEntity::InitAsEditorModel(void)
{
// set render type to model
en_RenderType = RT_EDITORMODEL;
// create a model object
en_pmoModelObject = new CModelObject;
en_psiShadingInfo = new CShadingInfo;
en_ulFlags &= ~ENF_VALIDSHADINGINFO;
}
/*
* Initialize for beeing a ska model object, for editor only.
*/
void CEntity::InitAsSkaEditorModel(void)
{
// set render type to model
en_RenderType = RT_SKAEDITORMODEL;
// create a model object
en_psiShadingInfo = new CShadingInfo;
en_ulFlags &= ~ENF_VALIDSHADINGINFO;
}
/*
* Initialize for beeing a brush object.
*/
void CEntity::InitAsBrush(void)
{
ASSERT(GetFPUPrecision()==FPT_24BIT);
// set render type to brush
en_RenderType = RT_BRUSH;
// if there is no existing brush
if (en_pbrBrush == NULL) {
// create a new empty brush in the brush archive of current world
en_pbrBrush = en_pwoWorld->wo_baBrushes.ba_abrBrushes.New();
en_pbrBrush->br_penEntity = this;
// create a brush mip for it
CBrushMip *pbmMip = new CBrushMip;
// add it to list
en_pbrBrush->br_lhBrushMips.AddTail(pbmMip->bm_lnInBrush);
// set back-pointer to the brush
pbmMip->bm_pbrBrush = en_pbrBrush;
en_pbrBrush->CalculateBoundingBoxes();
}
UpdateSpatialRange();
}
/*
* Initialize for beeing a field brush object.
*/
void CEntity::InitAsFieldBrush(void)
{
ASSERT(GetFPUPrecision()==FPT_24BIT);
// set render type to brush
en_RenderType = RT_FIELDBRUSH;
// if there is no existing brush
if (en_pbrBrush == NULL) {
// create a new empty brush in the brush archive of current world
en_pbrBrush = en_pwoWorld->wo_baBrushes.ba_abrBrushes.New();
en_pbrBrush->br_penEntity = this;
// create a brush mip for it
CBrushMip *pbmMip = new CBrushMip;
// add it to list
en_pbrBrush->br_lhBrushMips.AddTail(pbmMip->bm_lnInBrush);
// set back-pointer to the brush
pbmMip->bm_pbrBrush = en_pbrBrush;
en_pbrBrush->CalculateBoundingBoxes();
}
UpdateSpatialRange();
}
/*
* Switch to Model/Editor model
*/
void CEntity::SwitchToModel(void)
{
// change to editor model
if(en_RenderType==RT_MODEL || en_RenderType==RT_EDITORMODEL) {
en_RenderType = RT_MODEL;
} else if( en_RenderType==RT_SKAMODEL || en_RenderType==RT_SKAEDITORMODEL) {
en_RenderType = RT_SKAMODEL;
} else {
// it must be model (not brush)
ASSERT(FALSE);
}
}
void CEntity::SwitchToEditorModel(void)
{
// change to editor model
if(en_RenderType==RT_MODEL || en_RenderType==RT_EDITORMODEL) {
en_RenderType = RT_EDITORMODEL;
} else if( en_RenderType==RT_SKAMODEL || en_RenderType==RT_SKAEDITORMODEL) {
en_RenderType = RT_SKAEDITORMODEL;
} else {
// it must be model (not brush)
ASSERT(FALSE);
}
}
/////////////////////////////////////////////////////////////////////
// Model manipulation
/* Set the model data for model entity. */
void CEntity::SetModel(const CTFileName &fnmModel)
{
ASSERT(en_RenderType==RT_MODEL || en_RenderType==RT_EDITORMODEL);
// try to
try {
// load the new model data
en_pmoModelObject->SetData_t(fnmModel);
// if failed
} catch(char *strError) {
(void)strError;
DECLARE_CTFILENAME(fnmDefault, "Models\\Editor\\Axis.mdl");
// try to
try {
// load the default model data
en_pmoModelObject->SetData_t(fnmDefault);
// if failed
} catch(char *strErrorDefault) {
FatalError(TRANS("Cannot load default model '%s':\n%s"),
(CTString&)fnmDefault, strErrorDefault);
}
}
UpdateSpatialRange();
FindCollisionInfo();
}
void CEntity::SetModel(SLONG idModelComponent)
{
ASSERT(en_RenderType==RT_MODEL || en_RenderType==RT_EDITORMODEL);
CEntityComponent *pecModel = en_pecClass->ComponentForTypeAndID(
ECT_MODEL, idModelComponent);
en_pmoModelObject->SetData(pecModel->ec_pmdModel);
UpdateSpatialRange();
FindCollisionInfo();
}
void CEntity::SetSkaColisionInfo()
{
ASSERT(en_RenderType==RT_SKAMODEL || en_RenderType==RT_SKAEDITORMODEL);
// if there is no colision boxes for ska model
if(en_pmiModelInstance->mi_cbAABox.Count() == 0) {
// add one default colision box
en_pmiModelInstance->AddColisionBox("Default",FLOAT3D(-0.5,0,-0.5),FLOAT3D(0.5,2,0.5));
}
UpdateSpatialRange();
FindCollisionInfo();
}
void CEntity::SetSkaModel_t(const CTString &fnmModel)
{
ASSERT(en_RenderType==RT_SKAMODEL || en_RenderType==RT_SKAEDITORMODEL);
// if model instance allready exists
if(en_pmiModelInstance!=NULL) {
// release it first
en_pmiModelInstance->Clear();
}
try {
// load the new model data
en_pmiModelInstance = ParseSmcFile_t(fnmModel);
} catch (char *strErrorDefault) {
throw(strErrorDefault);
}
SetSkaColisionInfo();
}
BOOL CEntity::SetSkaModel(const CTString &fnmModel)
{
ASSERT(en_RenderType==RT_SKAMODEL || en_RenderType==RT_SKAEDITORMODEL);
// try to
try {
SetSkaModel_t(fnmModel);
// if failed
} catch(char *strError) {
(void)strError;
WarningMessage("%s\n\rLoading default model.\n", strError);
DECLARE_CTFILENAME(fnmDefault, "Models\\Editor\\Ska\\Axis.smc");
// try to
try {
// load the default model data
en_pmiModelInstance = ParseSmcFile_t(fnmDefault);
// if failed
} catch(char *strErrorDefault) {
FatalError(TRANS("Cannot load default model '%s':\n%s"),
(CTString&)fnmDefault, strErrorDefault);
}
// set colision info for default model
SetSkaColisionInfo();
return FALSE;
}
return TRUE;
}
// set/get model main blend color
void CEntity::SetModelColor( const COLOR colBlend)
{
ASSERT(en_RenderType==RT_MODEL || en_RenderType==RT_EDITORMODEL);
en_pmoModelObject->mo_colBlendColor = colBlend;
}
COLOR CEntity::GetModelColor(void) const
{
ASSERT(en_RenderType==RT_MODEL || en_RenderType==RT_EDITORMODEL);
return en_pmoModelObject->mo_colBlendColor;
}
/* Get the model data for model entity. */
const CTFileName &CEntity::GetModel(void)
{
ASSERT(en_RenderType==RT_MODEL || en_RenderType==RT_EDITORMODEL);
return ((CAnimData*)en_pmoModelObject->GetData())->GetName();
}
/* Start new animation for model entity. */
void CEntity::StartModelAnim(INDEX iNewModelAnim, ULONG ulFlags)
{
ASSERT(en_RenderType==RT_MODEL || en_RenderType==RT_EDITORMODEL);
en_pmoModelObject->PlayAnim(iNewModelAnim, ulFlags);
}
/* Set the main texture data for model entity. */
void CEntity::SetModelMainTexture(const CTFileName &fnmTexture)
{
ASSERT(en_RenderType==RT_MODEL || en_RenderType==RT_EDITORMODEL);
// try to
try {
// load the texture data
en_pmoModelObject->mo_toTexture.SetData_t(fnmTexture);
// if failed
} catch(char *strError) {
(void)strError;
DECLARE_CTFILENAME(fnmDefault, "Textures\\Editor\\Default.tex");
// try to
try {
// load the default model data
en_pmoModelObject->mo_toTexture.SetData_t(fnmDefault);
// if failed
} catch(char *strErrorDefault) {
FatalError(TRANS("Cannot load default texture '%s':\n%s"),
(CTString&)fnmDefault, strErrorDefault);
}
}
}
void CEntity::SetModelMainTexture(SLONG idTextureComponent)
{
ASSERT(en_RenderType==RT_MODEL || en_RenderType==RT_EDITORMODEL);
CEntityComponent *pecTexture = en_pecClass->ComponentForTypeAndID(
ECT_TEXTURE, idTextureComponent);
en_pmoModelObject->mo_toTexture.SetData(pecTexture->ec_ptdTexture);
}
/* Get the main texture data for model entity. */
const CTFileName &CEntity::GetModelMainTexture(void)
{
ASSERT(en_RenderType==RT_MODEL || en_RenderType==RT_EDITORMODEL);
return en_pmoModelObject->mo_toTexture.GetData()->GetName();
}
/* Start new animation for main texture of model entity. */
void CEntity::StartModelMainTextureAnim(INDEX iNewTextureAnim)
{
ASSERT(en_RenderType==RT_MODEL || en_RenderType==RT_EDITORMODEL);
en_pmoModelObject->mo_toTexture.StartAnim(iNewTextureAnim);
}
/* Set the reflection texture data for model entity. */
void CEntity::SetModelReflectionTexture(SLONG idTextureComponent)
{
ASSERT(en_RenderType==RT_MODEL || en_RenderType==RT_EDITORMODEL);
CEntityComponent *pecTexture = en_pecClass->ComponentForTypeAndID(
ECT_TEXTURE, idTextureComponent);
en_pmoModelObject->mo_toReflection.SetData(pecTexture->ec_ptdTexture);
}
/* Set the specular texture data for model entity. */
void CEntity::SetModelSpecularTexture(SLONG idTextureComponent)
{
ASSERT(en_RenderType==RT_MODEL || en_RenderType==RT_EDITORMODEL);
CEntityComponent *pecTexture = en_pecClass->ComponentForTypeAndID(
ECT_TEXTURE, idTextureComponent);
en_pmoModelObject->mo_toSpecular.SetData(pecTexture->ec_ptdTexture);
}
/* Add attachment to model */
void CEntity::AddAttachment(INDEX iAttachment, ULONG ulIDModel, ULONG ulIDTexture)
{
// add attachment
CModelObject &mo = en_pmoModelObject->AddAttachmentModel(iAttachment)->amo_moModelObject;
// update model data
CEntityComponent *pecWeaponModel = ComponentForTypeAndID( ECT_MODEL, ulIDModel);
mo.SetData(pecWeaponModel->ec_pmdModel);
// update texture data if different
CEntityComponent *pecWeaponTexture = ComponentForTypeAndID( ECT_TEXTURE, ulIDTexture);
mo.SetTextureData(pecWeaponTexture->ec_ptdTexture);
}
void CEntity::AddAttachment(INDEX iAttachment, CTFileName fnModel, CTFileName fnTexture)
{
if( fnModel == CTString("")) return;
CModelObject *pmo = GetModelObject();
ASSERT( pmo != NULL);
if( pmo == NULL) return;
CAttachmentModelObject *pamo = pmo->AddAttachmentModel( iAttachment);
try
{
pamo->amo_moModelObject.SetData_t( fnModel);
}
catch(char *strError)
{
(void) strError;
pmo->RemoveAttachmentModel( iAttachment);
return;
}
try
{
pamo->amo_moModelObject.mo_toTexture.SetData_t( fnTexture);
}
catch(char *strError)
{
(void) strError;
}
}
/* Set the reflection texture data for attachment model entity. */
void CEntity::SetModelAttachmentReflectionTexture(INDEX iAttachment, SLONG idTextureComponent)
{
ASSERT(en_RenderType==RT_MODEL || en_RenderType==RT_EDITORMODEL);
CModelObject &mo = en_pmoModelObject->GetAttachmentModel(iAttachment)->amo_moModelObject;
CEntityComponent *pecTexture = en_pecClass->ComponentForTypeAndID(
ECT_TEXTURE, idTextureComponent);
mo.mo_toReflection.SetData(pecTexture->ec_ptdTexture);
}
/* Set the specular texture data for attachment model entity. */
void CEntity::SetModelAttachmentSpecularTexture(INDEX iAttachment, SLONG idTextureComponent)
{
ASSERT(en_RenderType==RT_MODEL || en_RenderType==RT_EDITORMODEL);
CModelObject &mo = en_pmoModelObject->GetAttachmentModel(iAttachment)->amo_moModelObject;
CEntityComponent *pecTexture = en_pecClass->ComponentForTypeAndID(
ECT_TEXTURE, idTextureComponent);
mo.mo_toSpecular.SetData(pecTexture->ec_ptdTexture);
}
// Get all vertices of model entity in absolute space
void CEntity::GetModelVerticesAbsolute( CStaticStackArray<FLOAT3D> &avVertices, FLOAT fNormalOffset, FLOAT fMipFactor)
{
ASSERT(en_RenderType==RT_MODEL || en_RenderType==RT_EDITORMODEL ||
en_RenderType==RT_SKAMODEL || en_RenderType==RT_SKAEDITORMODEL);
// get placement
CPlacement3D plPlacement = GetLerpedPlacement();
// calculate rotation matrix
FLOATmatrix3D mRotation;
MakeRotationMatrixFast(mRotation, plPlacement.pl_OrientationAngle);
if(en_RenderType==RT_MODEL || en_RenderType==RT_EDITORMODEL) {
en_pmoModelObject->GetModelVertices( avVertices, mRotation, plPlacement.pl_PositionVector, fNormalOffset, fMipFactor);
} else {
GetModelInstance()->GetModelVertices( avVertices, mRotation, plPlacement.pl_PositionVector, fNormalOffset, fMipFactor);
}
}
void EntityAdjustBonesCallback(void *pData)
{
((CEntity*)pData)->AdjustBones();
}
void EntityAdjustShaderParamsCallback(void *pData,INDEX iSurfaceID,CShader *pShader,ShaderParams &spParams)
{
((CEntity*)pData)->AdjustShaderParams(iSurfaceID,pShader,spParams);
}
// Returns true if bone exists and sets two given vectors as start and end point of specified bone
BOOL CEntity::GetBoneRelPosition(INDEX iBoneID, FLOAT3D &vStartPoint, FLOAT3D &vEndPoint)
{
ASSERT(en_RenderType==RT_SKAMODEL || en_RenderType==RT_SKAEDITORMODEL);
RM_SetObjectPlacement(CPlacement3D(FLOAT3D(0.0f,0.0f,0.0f),ANGLE3D(0.0f,0.0f,0.0f)));
RM_SetBoneAdjustCallback(&EntityAdjustBonesCallback,this);
return RM_GetBoneAbsPosition(*GetModelInstance(),iBoneID,vStartPoint,vEndPoint);
}
// Returns true if bone exists and sets two given vectors as start and end point of specified bone
BOOL CEntity::GetBoneAbsPosition(INDEX iBoneID, FLOAT3D &vStartPoint, FLOAT3D &vEndPoint)
{
ASSERT(en_RenderType==RT_SKAMODEL || en_RenderType==RT_SKAEDITORMODEL);
RM_SetObjectPlacement(GetLerpedPlacement());
RM_SetBoneAdjustCallback(&EntityAdjustBonesCallback,this);
return RM_GetBoneAbsPosition(*GetModelInstance(),iBoneID,vStartPoint,vEndPoint);
}
// Callback function for aditional bone adjustment
void CEntity::AdjustBones()
{
}
// Callback function for aditional shader params adjustment
void CEntity::AdjustShaderParams(INDEX iSurfaceID,CShader *pShader,ShaderParams &spParams)
{
}
// precache given component
void CEntity::PrecacheModel(SLONG slID)
{
en_pecClass->ec_pdecDLLClass->PrecacheModel(slID);
}
void CEntity::PrecacheTexture(SLONG slID)
{
en_pecClass->ec_pdecDLLClass->PrecacheTexture(slID);
}
void CEntity::PrecacheSound(SLONG slID)
{
en_pecClass->ec_pdecDLLClass->PrecacheSound(slID);
}
void CEntity::PrecacheClass(SLONG slID, INDEX iUser /* = -1*/)
{
en_pecClass->ec_pdecDLLClass->PrecacheClass(slID, iUser);
}
CAutoPrecacheSound::CAutoPrecacheSound()
{
apc_psd = NULL;
}
CAutoPrecacheSound::~CAutoPrecacheSound()
{
if (apc_psd!=NULL) {
_pSoundStock->Release(apc_psd);
}
}
void CAutoPrecacheSound::Precache(const CTFileName &fnm)
{
if (apc_psd!=NULL) {
_pSoundStock->Release(apc_psd);
}
try {
if (fnm!="") {
apc_psd = _pSoundStock->Obtain_t(fnm);
}
} catch (char *strError) {
CPrintF("%s\n", strError);
}
}
CAutoPrecacheModel::CAutoPrecacheModel()
{
apc_pmd = NULL;
}
CAutoPrecacheModel::~CAutoPrecacheModel()
{
if (apc_pmd!=NULL) {
_pModelStock->Release(apc_pmd);
}
}
void CAutoPrecacheModel::Precache(const CTFileName &fnm)
{
if (apc_pmd!=NULL) {
_pModelStock->Release(apc_pmd);
}
try {
if (fnm!="") {
apc_pmd = _pModelStock->Obtain_t(fnm);
}
} catch (char *strError) {
CPrintF("%s\n", strError);
}
}
CAutoPrecacheTexture::CAutoPrecacheTexture()
{
apc_ptd = NULL;
}
CAutoPrecacheTexture::~CAutoPrecacheTexture()
{
if (apc_ptd!=NULL) {
_pTextureStock->Release(apc_ptd);
}
}
void CAutoPrecacheTexture::Precache(const CTFileName &fnm)
{
if (apc_ptd!=NULL) {
_pTextureStock->Release(apc_ptd);
}
try {
if (fnm!="") {
apc_ptd = _pTextureStock->Obtain_t(fnm);
}
} catch (char *strError) {
CPrintF("%s\n", strError);
}
}
/* Get a filename for a component of given id. */
const CTFileName &CEntity::FileNameForComponent(SLONG slType, SLONG slID)
{
// find the component
CEntityComponent *pec = en_pecClass->ComponentForTypeAndID(
(EntityComponentType)slType, slID);
// the component must exist
ASSERT(pec!=NULL);
// get its name
return pec->ec_fnmComponent;
}
// Get data for a texture component
CTextureData *CEntity::GetTextureDataForComponent(SLONG slID)
{
CEntityComponent *pec = ComponentForTypeAndID( ECT_TEXTURE, slID);
if (pec!=NULL) {
return pec->ec_ptdTexture;
} else {
return NULL;
}
}
// Get data for a model component
CModelData *CEntity::GetModelDataForComponent(SLONG slID)
{
CEntityComponent *pec = ComponentForTypeAndID( ECT_MODEL, slID);
if (pec!=NULL) {
return pec->ec_pmdModel;
} else {
return NULL;
}
}
/* Remove attachment from model */
void CEntity::RemoveAttachment(INDEX iAttachment)
{
// remove attachment
en_pmoModelObject->RemoveAttachmentModel(iAttachment);
}
/* Initialize last positions structure for particles. */
CLastPositions *CEntity::GetLastPositions(INDEX ctPositions)
{
TIME tmNow = _pTimer->CurrentTick();
if (en_plpLastPositions==NULL) {
en_plpLastPositions = new CLastPositions;
en_plpLastPositions->lp_avPositions.New(ctPositions);
en_plpLastPositions->lp_ctUsed = 0;
en_plpLastPositions->lp_iLast = 0;
en_plpLastPositions->lp_tmLastAdded = tmNow;
const FLOAT3D &vNow = GetPlacement().pl_PositionVector;
for(INDEX iPos = 0; iPos<ctPositions; iPos++) {
en_plpLastPositions->lp_avPositions[iPos] = vNow;
}
}
while(en_plpLastPositions->lp_tmLastAdded<tmNow) {
en_plpLastPositions->AddPosition(en_plpLastPositions->GetPosition(0));
}
return en_plpLastPositions;
}
/* Get absolute position of point on entity given relative to its size. */
void CEntity::GetEntityPointRatio(const FLOAT3D &vRatio, FLOAT3D &vAbsPoint, BOOL bLerped)
{
ASSERT(bLerped || GetFPUPrecision()==FPT_24BIT);
if (en_RenderType!=RT_MODEL && en_RenderType!=RT_EDITORMODEL &&
en_RenderType!=RT_SKAMODEL && en_RenderType!=RT_SKAEDITORMODEL &&
en_RenderType!=RT_BRUSH) {
ASSERT(FALSE);
vAbsPoint = en_plPlacement.pl_PositionVector;
return;
}
FLOAT3D vMin, vMax;
if (en_RenderType==RT_BRUSH)
{
CBrushMip *pbmMip = en_pbrBrush->GetFirstMip();
vMin = pbmMip->bm_boxBoundingBox.Min();
vMax = pbmMip->bm_boxBoundingBox.Max();
FLOAT3D vOff = vMax-vMin;
vOff(1) *= vRatio(1);
vOff(2) *= vRatio(2);
vOff(3) *= vRatio(3);
vAbsPoint = vMin+vOff;
}
else
{
if (_pNetwork->ga_ulDemoMinorVersion<=2) {
vMin = en_pmoModelObject->GetCollisionBoxMin(GetCollisionBoxIndex());
vMax = en_pmoModelObject->GetCollisionBoxMax(GetCollisionBoxIndex());
} else {
INDEX iEq;
FLOATaabbox3D box;
GetCollisionBoxParameters(GetCollisionBoxIndex(), box, iEq);
vMin = box.Min();
vMax = box.Max();
}
FLOAT3D vOff = vMax-vMin;
vOff(1) *= vRatio(1);
vOff(2) *= vRatio(2);
vOff(3) *= vRatio(3);
FLOAT3D vPos = vMin+vOff;
if( bLerped)
{
CPlacement3D plLerped=GetLerpedPlacement();
FLOATmatrix3D mRot;
MakeRotationMatrixFast(mRot, plLerped.pl_OrientationAngle);
vAbsPoint=plLerped.pl_PositionVector+vPos*mRot;
}
else
{
vAbsPoint = en_plPlacement.pl_PositionVector+vPos*en_mRotation;
}
}
}
/* Get absolute position of point on entity given in meters. */
void CEntity::GetEntityPointFixed(const FLOAT3D &vFixed, FLOAT3D &vAbsPoint)
{
vAbsPoint = en_plPlacement.pl_PositionVector+vFixed*en_mRotation;
}
/* Get sector that given point is in - point must be inside this entity. */
CBrushSector *CEntity::GetSectorFromPoint(const FLOAT3D &vPointAbs)
{
// for each sector around entity
{FOREACHSRCOFDST(en_rdSectors, CBrushSector, bsc_rsEntities, pbsc)
// if point is in this sector
if( pbsc->bsc_bspBSPTree.TestSphere(FLOATtoDOUBLE(vPointAbs), 0.01)>=0) {
// return that
return pbsc;
}
ENDFOR;}
return NULL;
}
/* Model change notify */
void CEntity::ModelChangeNotify(void)
{
// if this is ska model
if(en_RenderType == RT_SKAMODEL || en_RenderType == RT_SKAEDITORMODEL) {
if(GetModelInstance()==NULL) {
return;
}
// this is old model
} else {
if (en_pmoModelObject==NULL || en_pmoModelObject->GetData()==NULL) {
return;
}
}
UpdateSpatialRange();
FindCollisionInfo();
}
void CEntity::TerrainChangeNotify(void)
{
// GetTerrain()->RemoveLayer(0,FALSE);
// GetTerrain()->AddDefaultLayer_t();
GetTerrain()->ReBuildTerrain(TRUE);
UpdateSpatialRange();
}
// map world polygon to/from indices
CBrushPolygon *CEntity::GetWorldPolygonPointer(INDEX ibpo)
{
if (ibpo==-1) {
return NULL;
} else {
return en_pwoWorld->wo_baBrushes.ba_apbpo[ibpo];
}
}
INDEX CEntity::GetWorldPolygonIndex(CBrushPolygon *pbpo)
{
if (pbpo==NULL) {
return -1;
} else {
return pbpo->bpo_iInWorld;
}
}
/////////////////////////////////////////////////////////////////////
// Sound functions
void CEntity::PlaySound(CSoundObject &so, SLONG idSoundComponent, SLONG slPlayType)
{
CEntityComponent *pecSound = en_pecClass->ComponentForTypeAndID(ECT_SOUND, idSoundComponent);
//so.Stop();
so.Play(pecSound->ec_psdSound, slPlayType);
}
double CEntity::GetSoundLength(SLONG idSoundComponent)
{
CEntityComponent *pecSound = en_pecClass->ComponentForTypeAndID(ECT_SOUND, idSoundComponent);
return pecSound->ec_psdSound->GetSecondsLength();
}
void CEntity::PlaySound(CSoundObject &so, const CTFileName &fnmSound, SLONG slPlayType)
{
// try to
try {
// load the sound data
//so.Stop();
so.Play_t(fnmSound, slPlayType);
// if failed
} catch(char *strError) {
(void)strError;
DECLARE_CTFILENAME(fnmDefault, "Sounds\\Default.wav");
// try to
try {
// load the default sound data
so.Play_t(fnmDefault, slPlayType);
// if failed
} catch(char *strErrorDefault) {
FatalError(TRANS("Cannot load default sound '%s':\n%s"),
(CTString&)fnmDefault, strErrorDefault);
}
}
}
/////////////////////////////////////////////////////////////////////
/*
* Apply some damage directly to one entity.
*/
void CEntity::InflictDirectDamage(CEntity *penToDamage, CEntity *penInflictor, enum DamageType dmtType,
FLOAT fDamageAmmount, const FLOAT3D &vHitPoint, const FLOAT3D &vDirection)
{
ASSERT(GetFPUPrecision()==FPT_24BIT);
// if any of the entities are not allowed to execute now
if (!IsAllowedForPrediction()
||!penToDamage->IsAllowedForPrediction()
||!penInflictor->IsAllowedForPrediction()) {
// do nothing
return;
}
// if significant damage
if (fDamageAmmount>0) {
penToDamage->ReceiveDamage(penInflictor, dmtType, fDamageAmmount, vHitPoint, vDirection);
}
}
// find intensity of current entity at given distance
static inline FLOAT IntensityAtDistance(
FLOAT fDamageAmmount, FLOAT fHotSpotRange, FLOAT fFallOffRange, FLOAT fDistance)
{
// if further than fall-off range
if (fDistance>fFallOffRange) {
// intensity is zero
return 0;
// if closer than hot-spot range
} else if (fDistance<fHotSpotRange) {
// intensity is maximum
return fDamageAmmount;
// if between fall-off and hot-spot range
} else {
// interpolate
return fDamageAmmount*(fFallOffRange-fDistance)/(fFallOffRange-fHotSpotRange);
}
}
// check if a range damage can hit given model entity
static BOOL CheckModelRangeDamage(
CEntity &en, const FLOAT3D &vCenter, FLOAT &fMinD, FLOAT3D &vHitPos)
{
CCollisionInfo *pci = en.en_pciCollisionInfo;
if (pci==NULL) {
return FALSE;
}
// create 3 points along entity
const FLOATmatrix3D &mR = en.en_mRotation;
const FLOAT3D &vO = en.en_plPlacement.pl_PositionVector;
FLOAT3D avPoints[3];
INDEX ctSpheres = pci->ci_absSpheres.Count();
if (ctSpheres<1) {
return FALSE;
}
avPoints[1] = pci->ci_absSpheres[ctSpheres-1].ms_vCenter*mR+vO;
avPoints[2] = pci->ci_absSpheres[0].ms_vCenter*mR+vO;
avPoints[0] = (avPoints[1]+avPoints[2])*0.5f;
// check if any point can be hit
BOOL bCanHit = FALSE;
for(INDEX i=0; i<3; i++) {
CCastRay crRay( &en, avPoints[i], vCenter);
crRay.cr_ttHitModels = CCastRay::TT_NONE; // only brushes block the damage
crRay.cr_bHitTranslucentPortals = FALSE;
crRay.cr_bPhysical = TRUE;
en.en_pwoWorld->CastRay(crRay);
if (crRay.cr_penHit==NULL) {
bCanHit = TRUE;
break;
}
}
// if none can be hit
if (!bCanHit) {
// skip this entity
return FALSE;
}
// find minimum distance
fMinD = UpperLimit(0.0f);
vHitPos = vO;
// for each sphere
FOREACHINSTATICARRAY(pci->ci_absSpheres, CMovingSphere, itms) {
// project it
itms->ms_vRelativeCenter0 = itms->ms_vCenter*en.en_mRotation+vO;
FLOAT fD = (itms->ms_vRelativeCenter0-vCenter).Length()-itms->ms_fR;
if (fD<fMinD) {
fMinD = Min(fD, fMinD);
vHitPos = itms->ms_vRelativeCenter0;
}
}
if (fMinD<0) {
fMinD = 0;
}
return TRUE;
}
// check if a range damage can hit given brush entity
static BOOL CheckBrushRangeDamage(
CEntity &en, const FLOAT3D &vCenter, FLOAT &fMinD, FLOAT3D &vHitPos)
{
// don't actually check for brushes, doesn't have to be too exact
const FLOAT3D &vO = en.en_plPlacement.pl_PositionVector;
fMinD = (vO-vCenter).Length();
vHitPos = vO;
return TRUE;
}
/* Apply some damage to all entities in some range. */
void CEntity::InflictRangeDamage(CEntity *penInflictor, enum DamageType dmtType,
FLOAT fDamageAmmount, const FLOAT3D &vCenter, FLOAT fHotSpotRange, FLOAT fFallOffRange)
{
ASSERT(GetFPUPrecision()==FPT_24BIT);
// if any of the entities are not allowed to execute now
if (!IsAllowedForPrediction()
||!penInflictor->IsAllowedForPrediction()) {
// do nothing
return;
}
// find entities in the range
CDynamicContainer<CEntity> cenInRange;
FindEntitiesInRange(FLOATaabbox3D(vCenter, fFallOffRange), cenInRange, TRUE);
// for each entity in container
FOREACHINDYNAMICCONTAINER(cenInRange, CEntity, iten) {
CEntity &en = *iten;
// if entity is not allowed to execute now
if (!en.IsAllowedForPrediction()) {
// do nothing
continue;
}
// if can be hit
FLOAT3D vHitPos;
FLOAT fMinD;
if (
(en.en_RenderType==RT_MODEL || en.en_RenderType==RT_EDITORMODEL ||
en.en_RenderType==RT_SKAMODEL || en.en_RenderType==RT_SKAEDITORMODEL )&&
CheckModelRangeDamage(en, vCenter, fMinD, vHitPos) ||
(en.en_RenderType==RT_BRUSH)&&
CheckBrushRangeDamage(en, vCenter, fMinD, vHitPos)) {
// find damage ammount
FLOAT fAmmount = IntensityAtDistance(fDamageAmmount, fHotSpotRange, fFallOffRange, fMinD);
// if significant
if (fAmmount>0) {
// inflict damage to it
en.ReceiveDamage(penInflictor, dmtType, fAmmount, vHitPos, (vHitPos-vCenter).Normalize());
}
}
}
}
/* Apply some damage to all entities in a box (this doesn't test for obstacles). */
void CEntity::InflictBoxDamage(CEntity *penInflictor, enum DamageType dmtType,
FLOAT fDamageAmmount, const FLOATaabbox3D &box)
{
ASSERT(GetFPUPrecision()==FPT_24BIT);
// if any of the entities are not allowed to execute now
if (!IsAllowedForPrediction()
||!penInflictor->IsAllowedForPrediction()) {
// do nothing
return;
}
// find entities in the range
CDynamicContainer<CEntity> cenInRange;
FindEntitiesInRange(box, cenInRange, TRUE);
// for each entity in container
FOREACHINDYNAMICCONTAINER(cenInRange, CEntity, iten) {
CEntity &en = *iten;
//ASSERT(en.en_pciCollisionInfo!=NULL); // assured by FindEntitiesInRange()
if (en.en_pciCollisionInfo==NULL) {
continue;
}
CCollisionInfo *pci = en.en_pciCollisionInfo;
// if entity is not allowed to execute now
if (!en.IsAllowedForPrediction()) {
// do nothing
continue;
}
// if significant damage
if (fDamageAmmount>0) {
// inflict damage to it
en.ReceiveDamage(penInflictor, dmtType,
fDamageAmmount, box.Center(),
(box.Center()-en.GetPlacement().pl_PositionVector).Normalize());
}
}
}
// notify engine that gravity defined by this entity has changed
void CEntity::NotifyGravityChanged(void)
{
if (_pNetwork->ga_ulDemoMinorVersion<=2) {
// for each entity in the world of this entity
FOREACHINDYNAMICCONTAINER(en_pwoWorld->wo_cenEntities, CEntity, iten) {
CEntity *pen = &*iten;
// if movable
if (pen->en_ulPhysicsFlags&EPF_MOVABLE) {
CMovableEntity *pmen = (CMovableEntity*)pen;
// if the gravity has changed
// add to movers
pmen->AddToMovers();
}
}
} else {
// for each zoning brush in the world of this entity
FOREACHINDYNAMICCONTAINER(en_pwoWorld->wo_cenEntities, CEntity, iten) {
CEntity *penBrush = &*iten;
if (iten->en_RenderType != CEntity::RT_BRUSH || !(iten->en_ulFlags&ENF_ZONING)) {
continue;
}
CBrush3D *pbr = penBrush->en_pbrBrush;
// get first brush mip
CBrushMip *pbm = pbr->GetFirstMip();
// for each sector in the brush mip
{FOREACHINDYNAMICARRAY(pbm->bm_abscSectors, CBrushSector, itbsc) {
// if controlled by this entity
if ( penBrush->GetForceController(itbsc->GetForceType()) == this ) {
// for each entity in the sector
{FOREACHDSTOFSRC(itbsc->bsc_rsEntities, CEntity, en_rdSectors, pen) {
// if movable
if (pen->en_ulPhysicsFlags&EPF_MOVABLE) {
CMovableEntity *pmen = (CMovableEntity*)pen;
// add to movers
pmen->AddToMovers();
}
ENDFOR}}
}
}}
}
}
}
// notify engine that collision of this entity was changed
void CEntity::NotifyCollisionChanged(void)
{
if (en_pciCollisionInfo==NULL) {
return;
}
// find colliding entities near this one
static CStaticStackArray<CEntity*> apenNearEntities;
en_pwoWorld->FindEntitiesNearBox(en_pciCollisionInfo->ci_boxCurrent, apenNearEntities);
// for each of the found entities
{for(INDEX ienFound=0; ienFound<apenNearEntities.Count(); ienFound++) {
CEntity &enToNear = *apenNearEntities[ienFound];
// if movable
if (enToNear.en_ulPhysicsFlags&EPF_MOVABLE) {
// add to movers
((CMovableEntity*)&enToNear)->AddToMovers();
}
}}
apenNearEntities.PopAll();
}
// apply some damage to the entity (see event EDamage for more info)
void CEntity::ReceiveDamage(CEntity *penInflictor, enum DamageType dmtType,
FLOAT fDamageAmmount, const FLOAT3D &vHitPoint, const FLOAT3D &vDirection)
{
CEntityPointer penThis = this; // keep this entity alive during this function
// just throw an event that you are damaged (base entities don't really have health)
EDamage eDamage;
eDamage.penInflictor = penInflictor;
eDamage.vDirection = vDirection;
eDamage.vHitPoint = vHitPoint;
eDamage.fAmount = fDamageAmmount;
eDamage.dmtType = dmtType;
SendEvent(eDamage);
}
/* Receive item through event */
BOOL CEntity::ReceiveItem(const CEntityEvent &ee)
{
return FALSE;
}
/* Get entity info */
void *CEntity::GetEntityInfo(void)
{
return NULL;
};
/* Fill in entity statistics - for AI purposes only */
BOOL CEntity::FillEntityStatistics(struct EntityStats *pes)
{
return FALSE;
}
/////////////////////////////////////////////////////////////////////
// Overrides from CSerial
/*
* Read from stream.
*/
void CEntity::Read_t( CTStream *istr) // throw char *
{
ASSERT(GetFPUPrecision()==FPT_24BIT);
// read base class data from stream
if (istr->PeekID_t()==CChunkID("ENT4")) { // entity v4
istr->ExpectID_t("ENT4");
ULONG ulID;
SLONG slSize;
(*istr)>>ulID>>slSize; // skip id and size
(*istr)>>(ULONG &)en_RenderType
>>en_ulPhysicsFlags
>>en_ulCollisionFlags
>>en_ulSpawnFlags
>>en_ulFlags;
(*istr).Read_t(&en_mRotation, sizeof(en_mRotation));
} else if (istr->PeekID_t()==CChunkID("ENT3")) { // entity v3
istr->ExpectID_t("ENT3");
(*istr)>>(ULONG &)en_RenderType
>>en_ulPhysicsFlags
>>en_ulCollisionFlags
>>en_ulSpawnFlags
>>en_ulFlags;
(*istr).Read_t(&en_mRotation, sizeof(en_mRotation));
} else if (istr->PeekID_t()==CChunkID("ENT2")) { // entity v2
istr->ExpectID_t("ENT2");
(*istr)>>(ULONG &)en_RenderType
>>en_ulPhysicsFlags
>>en_ulCollisionFlags
>>en_ulSpawnFlags
>>en_ulFlags;
} else {
(*istr)>>(ULONG &)en_RenderType
>>en_ulPhysicsFlags
>>en_ulCollisionFlags
>>en_ulFlags;
}
// clear flags for selection and caching info
en_ulFlags &= ~(ENF_SELECTED|ENF_INRENDERING|ENF_VALIDSHADINGINFO);
en_psiShadingInfo = NULL;
en_pciCollisionInfo = NULL;
// if this is a brush
if ( en_RenderType == RT_BRUSH || en_RenderType == RT_FIELDBRUSH) {
// read brush index in world's brush archive
INDEX iBrush;
(*istr)>>iBrush;
en_pbrBrush = &en_pwoWorld->wo_baBrushes.ba_abrBrushes[iBrush];
en_pbrBrush->br_penEntity = this;
// if this is a terrain
} else if (en_RenderType == RT_TERRAIN) {
// read terrain index in world's terrain archive
INDEX iTerrain;
(*istr)>>iTerrain;
en_ptrTerrain = &en_pwoWorld->wo_taTerrains.ta_atrTerrains[iTerrain];
en_ptrTerrain->tr_penEntity = this;
// force terrain regeneration (regenerate tiles on next render)
en_ptrTerrain->ReBuildTerrain(TRUE);
// if this is a model
} else if ( en_RenderType == RT_MODEL || en_RenderType == RT_EDITORMODEL) {
// create a new model object
en_pmoModelObject = new CModelObject;
en_psiShadingInfo = new CShadingInfo;
en_ulFlags &= ~ENF_VALIDSHADINGINFO;
// read model
ReadModelObject_t(*istr, *en_pmoModelObject);
// if this is a ska model
} else if( en_RenderType == RT_SKAMODEL || en_RenderType == RT_SKAEDITORMODEL) {
en_pmiModelInstance = CreateModelInstance("Temp");
en_psiShadingInfo = new CShadingInfo;
en_ulFlags &= ~ENF_VALIDSHADINGINFO;
ReadModelInstance_t(*istr, *GetModelInstance());
// if this is a void
} else if (en_RenderType == RT_VOID) {
en_pbrBrush = NULL;
}
// if the entity has a parent
if (istr->PeekID_t()==CChunkID("PART")) { // parent
// read the parent pointer and relative offset
istr->ExpectID_t("PART");
INDEX iParent;
*istr>>iParent;
extern BOOL _bReadEntitiesByID;
if (_bReadEntitiesByID) {
en_penParent = en_pwoWorld->EntityFromID(iParent);
} else {
en_penParent = en_pwoWorld->wo_cenAllEntities.Pointer(iParent);
}
*istr>>en_plRelativeToParent;
// link to parent
en_penParent->en_lhChildren.AddTail(en_lnInParent);
}
// read the derived class properties from stream
ReadProperties_t(*istr);
// if it is a light source
{CLightSource *pls = GetLightSource();
if (pls!=NULL) {
// read the light source layer list
pls->ls_penEntity = this;
pls->Read_t(istr);
}}
// if it is a field brush
CFieldSettings *pfs = GetFieldSettings();
if (pfs!=NULL) {
// remember its field settings
ASSERT(en_RenderType == RT_FIELDBRUSH);
en_pbrBrush->br_pfsFieldSettings = pfs;
}
// if entity was predictable
if (en_ulFlags&ENF_PREDICTABLE) {
// restore that condition
en_ulFlags&=~ENF_PREDICTABLE; // have to clear it to be able to set it back
SetPredictable(TRUE);
}
}
/*
* Write to stream.
*/
void CEntity::Write_t( CTStream *ostr) // throw char *
{
ASSERT(GetFPUPrecision()==FPT_24BIT);
// write base class data to stream
ostr->WriteID_t("ENT4");
SLONG slSize = 0;
(*ostr)<<en_ulID<<slSize; // save id and keep space for size
(*ostr)<<(ULONG &)en_RenderType
<<en_ulPhysicsFlags
<<en_ulCollisionFlags
<<en_ulSpawnFlags
<<en_ulFlags;
(*ostr).Write_t(&en_mRotation, sizeof(en_mRotation));
// if this is a brush
if ( en_RenderType == RT_BRUSH || en_RenderType == RT_FIELDBRUSH) {
// write brush index in world's brush archive
(*ostr)<<en_pwoWorld->wo_baBrushes.ba_abrBrushes.Index(en_pbrBrush);
// if this is a terrain
} else if ( en_RenderType == RT_TERRAIN) {
// write brush index in world's brush archive
(*ostr)<<en_pwoWorld->wo_taTerrains.ta_atrTerrains.Index(en_ptrTerrain);
// if this is a model
} else if ( en_RenderType == RT_MODEL || en_RenderType == RT_EDITORMODEL) {
// write model
WriteModelObject_t(*ostr, *en_pmoModelObject);
// if this is ska model
} else if ( en_RenderType == RT_SKAMODEL || en_RenderType == RT_SKAEDITORMODEL) {
// write ska model
WriteModelInstance_t(*ostr, *GetModelInstance());
// if this is a void
} else if (en_RenderType == RT_VOID) {
NOTHING;
}
// if the entity has a parent
if (en_penParent!=NULL) {
// write the parent pointer and relative offset
ostr->WriteID_t("PART"); // parent
INDEX iParent = en_penParent->en_ulID;
*ostr<<iParent;
*ostr<<en_plRelativeToParent;
}
// write the derived class properties to stream
WriteProperties_t(*ostr);
// if it is a light source
{CLightSource *pls = GetLightSource();
if (pls!=NULL) {
// read the light source layer list
pls->Write_t(ostr);
}}
}
/* Precache components that might be needed. */
void CEntity::Precache(void)
{
NOTHING;
}
void CEntity::ChecksumForSync(ULONG &ulCRC, INDEX iExtensiveSyncCheck)
{
if (iExtensiveSyncCheck>0) {
CRC_AddLONG(ulCRC, en_ulFlags&~
(ENF_SELECTED|ENF_INRENDERING|ENF_VALIDSHADINGINFO|ENF_FOUNDINGRIDSEARCH|ENF_WILLBEPREDICTED|ENF_PREDICTABLE));
CRC_AddLONG(ulCRC, en_ulPhysicsFlags);
CRC_AddLONG(ulCRC, en_ulCollisionFlags);
CRC_AddLONG(ulCRC, en_ctReferences);
}
CRC_AddLONG(ulCRC, en_RenderType);
if (iExtensiveSyncCheck>0) {
CRC_AddLONG(ulCRC, en_ulID);
CRC_AddFLOAT(ulCRC, en_fSpatialClassificationRadius);
CRC_AddFLOAT(ulCRC, en_plPlacement.pl_PositionVector(1));
CRC_AddFLOAT(ulCRC, en_plPlacement.pl_PositionVector(2));
CRC_AddFLOAT(ulCRC, en_plPlacement.pl_PositionVector(3));
CRC_AddFLOAT(ulCRC, en_plPlacement.pl_OrientationAngle(1));
CRC_AddFLOAT(ulCRC, en_plPlacement.pl_OrientationAngle(2));
CRC_AddFLOAT(ulCRC, en_plPlacement.pl_OrientationAngle(3));
CRC_AddBlock(ulCRC, (UBYTE*)(void*)&en_mRotation, sizeof(en_mRotation));
} else {
CRC_AddLONG(ulCRC, (int)en_plPlacement.pl_PositionVector(1));
CRC_AddLONG(ulCRC, (int)en_plPlacement.pl_PositionVector(2));
CRC_AddLONG(ulCRC, (int)en_plPlacement.pl_PositionVector(3));
}
}
void CEntity::DumpSync_t(CTStream &strm, INDEX iExtensiveSyncCheck) // throw char *
{
strm.FPrintF_t("\n---- #%05d ($%05d)----------------\n",
en_pwoWorld->wo_cenAllEntities.Index(this), en_pwoWorld->wo_cenEntities.Index(this));
if (en_ulFlags&ENF_DELETED) {
strm.FPrintF_t("*** DELETED ***\n");
}
strm.FPrintF_t("class: '%s'\n", GetClass()->ec_pdecDLLClass->dec_strName);
strm.FPrintF_t("name: '%s'\n", GetName());
if (iExtensiveSyncCheck>0) {
strm.FPrintF_t("en_ulFlags: 0x%08X\n", en_ulFlags&~
(ENF_SELECTED|ENF_INRENDERING|ENF_VALIDSHADINGINFO|ENF_FOUNDINGRIDSEARCH|ENF_WILLBEPREDICTED|ENF_PREDICTABLE));
strm.FPrintF_t("en_ulPhysicsFlags: 0x%08X\n", en_ulPhysicsFlags);
strm.FPrintF_t("en_ulCollisionFlags: 0x%08X\n", en_ulCollisionFlags);
strm.FPrintF_t("en_ctReferences: %d\n", en_ctReferences);
}
strm.FPrintF_t("en_RenderType: %d\n", en_RenderType);
strm.FPrintF_t("en_ulID: 0x%08x\n", en_ulID);
if (iExtensiveSyncCheck>0) {
strm.FPrintF_t("en_fSpatialClassificationRadius: %g(%08x)\n",
en_fSpatialClassificationRadius, (ULONG&)en_fSpatialClassificationRadius);
}
strm.FPrintF_t("placement: %g,%g,%g : %g,%g,%g\n",
en_plPlacement.pl_PositionVector(1),
en_plPlacement.pl_PositionVector(2),
en_plPlacement.pl_PositionVector(3),
en_plPlacement.pl_OrientationAngle(1),
en_plPlacement.pl_OrientationAngle(2),
en_plPlacement.pl_OrientationAngle(3));
if (iExtensiveSyncCheck>0) {
strm.FPrintF_t("placement raw:\n %08X %08X %08X\n %08X %08X %08X\n",
(ULONG&)en_plPlacement.pl_PositionVector(1),
(ULONG&)en_plPlacement.pl_PositionVector(2),
(ULONG&)en_plPlacement.pl_PositionVector(3),
(ULONG&)en_plPlacement.pl_OrientationAngle(1),
(ULONG&)en_plPlacement.pl_OrientationAngle(2),
(ULONG&)en_plPlacement.pl_OrientationAngle(3));
strm.FPrintF_t("matrix:\n %g %g %g\n %g %g %g\n %g %g %g\n",
en_mRotation(1,1), en_mRotation(1,2), en_mRotation(1,3),
en_mRotation(2,1), en_mRotation(2,2), en_mRotation(2,3),
en_mRotation(3,1), en_mRotation(3,2), en_mRotation(3,3));
strm.FPrintF_t("matrix raw:\n %08X %08X %08X\n %08X %08X %08X\n %08X %08X %08X\n",
(ULONG&)en_mRotation(1,1), (ULONG&)en_mRotation(1,2), (ULONG&)en_mRotation(1,3),
(ULONG&)en_mRotation(2,1), (ULONG&)en_mRotation(2,2), (ULONG&)en_mRotation(2,3),
(ULONG&)en_mRotation(3,1), (ULONG&)en_mRotation(3,2), (ULONG&)en_mRotation(3,3));
if( en_pciCollisionInfo == NULL) {
strm.FPrintF_t("Collision info NULL\n");
} else if (en_RenderType==RT_BRUSH || en_RenderType==RT_FIELDBRUSH) {
strm.FPrintF_t("Collision info: Brush entity\n");
} else {
strm.FPrintF_t("Collision info:\n");
strm.FPrintF_t("Min height, Max height: %g, %g\n",
en_pciCollisionInfo->ci_fMinHeight, en_pciCollisionInfo->ci_fMaxHeight);
strm.FPrintF_t("Handle Y, Handle R: %g, %g\n",
en_pciCollisionInfo->ci_fHandleY, en_pciCollisionInfo->ci_fHandleR);
strm.FPrintF_t("Handle Y, Handle R: %g, %g\n",
en_pciCollisionInfo->ci_fHandleY, en_pciCollisionInfo->ci_fHandleR);
DUMPVECTOR(en_pciCollisionInfo->ci_boxCurrent.Min());
DUMPVECTOR(en_pciCollisionInfo->ci_boxCurrent.Max());
DUMPLONG(en_pciCollisionInfo->ci_ulFlags);
}
}
}
// get a pseudo-random number (safe for network gaming)
ULONG CEntity::IRnd(void)
{
return ((_pNetwork->ga_sesSessionState.Rnd()>>(31-16))&0xFFFF);
}
FLOAT CEntity::FRnd(void)
{
return ((_pNetwork->ga_sesSessionState.Rnd()>>(31-24))&0xFFFFFF)/FLOAT(0xFFFFFF);
}
// returns ammount of memory used by entity
SLONG CEntity::GetUsedMemory(void)
{
// initial size
SLONG slUsedMemory = sizeof(CEntity);
// add relations
slUsedMemory += en_rdSectors.Count() * sizeof(CRelationLnk);
// add allocated memory for model type (if any)
switch( en_RenderType) {
case CEntity::RT_MODEL:
case CEntity::RT_EDITORMODEL:
slUsedMemory += en_pmoModelObject->GetUsedMemory();
break;
case CEntity::RT_SKAMODEL:
case CEntity::RT_SKAEDITORMODEL:
slUsedMemory += en_pmiModelInstance->GetUsedMemory();
default:
break;
}
// add shading info (if any)
if( en_psiShadingInfo !=NULL) {
slUsedMemory += sizeof(CShadingInfo);
}
// add collision info (if any)
if( en_pciCollisionInfo!=NULL) {
slUsedMemory += sizeof(CCollisionInfo) + (en_pciCollisionInfo->ci_absSpheres.sa_Count * sizeof(CMovingSphere));
}
// add last positions memory (if any)
if( en_plpLastPositions!=NULL) {
slUsedMemory += sizeof(CLastPositions) + (en_plpLastPositions->lp_avPositions.sa_Count * sizeof(FLOAT3D));
}
// done
return slUsedMemory;
}
/* Get pointer to entity property from its packed identifier. */
class CEntityProperty *CEntity::PropertyForTypeAndID(ULONG ulType, ULONG ulID)
{
return en_pecClass->PropertyForTypeAndID(ulType, ulID);
}
/* Get pointer to entity component from its packed identifier. */
class CEntityComponent *CEntity::ComponentForTypeAndID(ULONG ulType, ULONG ulID)
{
return en_pecClass->ComponentForTypeAndID((enum EntityComponentType)ulType, ulID);
}
/* Get pointer to entity property from its name. */
class CEntityProperty *CEntity::PropertyForName(const CTString &strPropertyName)
{
return en_pecClass->PropertyForName(strPropertyName);
}
/* Create a new entity of given class in this world. */
CEntity *CEntity::CreateEntity(const CPlacement3D &plPlacement, SLONG idClass)
{
CEntityComponent *pecClassComponent = en_pecClass->ComponentForTypeAndID(
ECT_CLASS, idClass);
return en_pwoWorld->CreateEntity(plPlacement, pecClassComponent->ec_pecEntityClass);
}
/////////////////////////////////////////////////////////////////////
// CLiveEntity
/*
* Constructor.
*/
CLiveEntity::CLiveEntity(void)
{
en_fHealth = 0;
}
/* Copy entity from another entity of same class. */
void CLiveEntity::Copy(CEntity &enOther, ULONG ulFlags)
{
CEntity::Copy(enOther, ulFlags);
CLiveEntity *plenOther = (CLiveEntity *)(&enOther);
en_fHealth = plenOther->en_fHealth;
}
/* Read from stream. */
void CLiveEntity::Read_t( CTStream *istr) // throw char *
{
CEntity::Read_t(istr);
(*istr)>>en_fHealth;
}
/* Write to stream. */
void CLiveEntity::Write_t( CTStream *ostr) // throw char *
{
CEntity::Write_t(ostr);
(*ostr)<<en_fHealth;
}
// apply some damage to the entity (see event EDamage for more info)
void CLiveEntity::ReceiveDamage(CEntity *penInflictor, enum DamageType dmtType,
FLOAT fDamage, const FLOAT3D &vHitPoint, const FLOAT3D &vDirection)
{
CEntityPointer penThis = this; // keep this entity alive during this function
// reduce your health
en_fHealth-=fDamage;
// throw an event that you are damaged
EDamage eDamage;
eDamage.penInflictor = penInflictor;
eDamage.vDirection = vDirection;
eDamage.vHitPoint = vHitPoint;
eDamage.fAmount = fDamage;
eDamage.dmtType = dmtType;
SendEvent(eDamage);
// if health reached zero
if (en_fHealth<=0) {
// throw an event that you have died
EDeath eDeath;
eDeath.eLastDamage = eDamage;
SendEvent(eDeath);
}
}
/////////////////////////////////////////////////////////////////////
// CRationalEntity
/*
* Constructor.
*/
CRationalEntity::CRationalEntity(void)
{
}
/* Calculate physics for moving. */
void CRationalEntity::ClearMovingTemp(void)
{
}
void CRationalEntity::PreMoving(void)
{
}
void CRationalEntity::DoMoving(void)
{
}
void CRationalEntity::PostMoving(void)
{
}
// create a checksum value for sync-check
void CRationalEntity::ChecksumForSync(ULONG &ulCRC, INDEX iExtensiveSyncCheck)
{
CEntity::ChecksumForSync(ulCRC, iExtensiveSyncCheck);
if (iExtensiveSyncCheck>0) {
CRC_AddFLOAT(ulCRC, en_timeTimer);
CRC_AddLONG(ulCRC, en_stslStateStack.Count());
}
if (iExtensiveSyncCheck>0) {
}
}
// dump sync data to text file
void CRationalEntity::DumpSync_t(CTStream &strm, INDEX iExtensiveSyncCheck) // throw char *
{
CEntity::DumpSync_t(strm, iExtensiveSyncCheck);
if (iExtensiveSyncCheck>0) {
strm.FPrintF_t("en_timeTimer: %g(%08x)\n", en_timeTimer, (ULONG&)en_timeTimer);
strm.FPrintF_t("en_stslStateStack.Count(): %d\n", en_stslStateStack.Count());
}
strm.FPrintF_t("en_fHealth: %g(%08x)\n", en_fHealth, (ULONG&)en_fHealth);
}
/* Copy entity from another entity of same class. */
void CRationalEntity::Copy(CEntity &enOther, ULONG ulFlags)
{
CLiveEntity::Copy(enOther, ulFlags);
if (!(ulFlags&COPY_REINIT)) {
CRationalEntity *prenOther = (CRationalEntity *)(&enOther);
en_timeTimer = prenOther->en_timeTimer;
en_stslStateStack = prenOther->en_stslStateStack;
if (prenOther->en_lnInTimers.IsLinked()) {
en_pwoWorld->AddTimer(this);
}
}
}
/* Read from stream. */
void CRationalEntity::Read_t( CTStream *istr) // throw char *
{
CLiveEntity::Read_t(istr);
(*istr)>>en_timeTimer;
// if waiting for thinking
if (en_timeTimer!=THINKTIME_NEVER) {
// add to list of thinkers
en_pwoWorld->AddTimer(this);
}
// read the state stack
en_stslStateStack.Clear();
en_stslStateStack.SetAllocationStep(STATESTACK_ALLOCATIONSTEP);
INDEX ctStates;
(*istr)>>ctStates;
for (INDEX iState=0; iState<ctStates; iState++) {
(*istr)>>en_stslStateStack.Push();
}
}
/* Write to stream. */
void CRationalEntity::Write_t( CTStream *ostr) // throw char *
{
CLiveEntity::Write_t(ostr);
// if not currently waiting for thinking
if (!en_lnInTimers.IsLinked()) {
// set dummy thinking time as a flag for later loading
en_timeTimer = THINKTIME_NEVER;
}
(*ostr)<<en_timeTimer;
// write the state stack
(*ostr)<<en_stslStateStack.Count();
for(INDEX iState=0; iState<en_stslStateStack.Count(); iState++) {
(*ostr)<<en_stslStateStack[iState];
}
}
/*
* Set next timer event to occur at given moment time.
*/
void CRationalEntity::SetTimerAt(TIME timeAbsolute)
{
// must never set think back in time, except for special 'never' time
ASSERTMSG(timeAbsolute>_pTimer->CurrentTick() ||
timeAbsolute==THINKTIME_NEVER, "Do not SetThink() back in time!");
// set the timer
en_timeTimer = timeAbsolute;
// add to world's list of timers if neccessary
if (en_timeTimer != THINKTIME_NEVER) {
en_pwoWorld->AddTimer(this);
} else {
if (en_lnInTimers.IsLinked()) {
en_lnInTimers.Remove();
}
}
}
/*
* Set next timer event to occur after given time has elapsed.
*/
void CRationalEntity::SetTimerAfter(TIME timeDelta)
{
// set the execution for the moment that is that much ahead of the current tick
SetTimerAt(_pTimer->CurrentTick()+timeDelta);
}
/* Cancel eventual pending timer. */
void CRationalEntity::UnsetTimer(void)
{
en_timeTimer = THINKTIME_NEVER;
if (en_lnInTimers.IsLinked()) {
en_lnInTimers.Remove();
}
}
/*
* Unwind stack to a given state.
*/
void CRationalEntity::UnwindStack(SLONG slThisState)
{
// for each state on the stack (from top to bottom)
for(INDEX iStateInStack=en_stslStateStack.Count()-1; iStateInStack>=0; iStateInStack--) {
// if it is the state
if (en_stslStateStack[iStateInStack]==slThisState) {
// unwind to it
en_stslStateStack.PopUntil(iStateInStack);
return;
}
}
// the state must be on the stack
ASSERTALWAYS("Unwinding to unexisting state!");
}
/*
* Jump to a new state.
*/
void CRationalEntity::Jump(SLONG slThisState, SLONG slTargetState, BOOL bOverride, const CEntityEvent &eeInput)
{
// unwind the stack to this state
UnwindStack(slThisState);
// set the new topmost state
if (bOverride) {
slTargetState = en_pecClass->ec_pdecDLLClass->GetOverridenState(slTargetState);
}
en_stslStateStack[en_stslStateStack.Count()-1] = slTargetState;
// handle the given event in the new state
HandleEvent(eeInput);
};
/*
* Call a subautomaton.
*/
void CRationalEntity::Call(SLONG slThisState, SLONG slTargetState, BOOL bOverride, const CEntityEvent &eeInput)
{
// unwind the stack to this state
UnwindStack(slThisState);
// push the new state to stack
if (bOverride) {
slTargetState = en_pecClass->ec_pdecDLLClass->GetOverridenState(slTargetState);
}
en_stslStateStack.Push() = slTargetState;
// handle the given event in the new state
HandleEvent(eeInput);
};
/*
* Return from a subautomaton.
*/
void CRationalEntity::Return(SLONG slThisState, const CEntityEvent &eeReturn)
{
// unwind the stack to this state
UnwindStack(slThisState);
// pop one state from the stack
en_stslStateStack.PopUntil(en_stslStateStack.Count()-2);
// handle the given event in the new topmost state
HandleEvent(eeReturn);
};
// print stack to debug output
const char *CRationalEntity::PrintStackDebug(void)
{
_RPT2(_CRT_WARN, "-- stack of '%s'@%gs\n", GetName(), _pTimer->CurrentTick());
INDEX ctStates = en_stslStateStack.Count();
for(INDEX iState=ctStates-1; iState>=0; iState--) {
SLONG slState = en_stslStateStack[iState];
_RPT2(_CRT_WARN, "0x%08x %s\n", slState,
en_pecClass->ec_pdecDLLClass->HandlerNameForState(slState));
}
_RPT0(_CRT_WARN, "----\n");
return "ok";
}
/*
* Handle an event - return false if event was not handled.
*/
BOOL CRationalEntity::HandleEvent(const CEntityEvent &ee)
{
// for each state on the stack (from top to bottom)
for(INDEX iStateInStack=en_stslStateStack.Count()-1; iStateInStack>=0; iStateInStack--) {
// try to find a handler in that state
pEventHandler pehHandler =
HandlerForStateAndEvent(en_stslStateStack[iStateInStack], ee.ee_slEvent);
// if there is a handler
if (pehHandler!=NULL) {
// call the function
BOOL bHandled = (this->*pehHandler)(ee);
// if the event was successfully handled
if (bHandled) {
// return that it was handled
return TRUE;
}
}
}
// if no transition was found, the event was not handled
return FALSE;
}
/*
* Called after creating and setting its properties.
*/
void CRationalEntity::OnInitialize(const CEntityEvent &eeInput)
{
// make sure entity doesn't destroy itself during intialization
CEntityPointer penThis = this;
// do not think
en_timeTimer = THINKTIME_NEVER;
if (en_lnInTimers.IsLinked()) {
en_lnInTimers.Remove();
}
// initialize state stack
en_stslStateStack.Clear();
en_stslStateStack.SetAllocationStep(STATESTACK_ALLOCATIONSTEP);
en_stslStateStack.Push() = 1; // start state is always state with number 1
// call the main function of the entity
HandleEvent(eeInput);
}
/* Called before releasing entity. */
void CRationalEntity::OnEnd(void)
{
// cancel eventual pending timer
UnsetTimer();
}
Reference in New Issue View Git Blame Copy Permalink