void CEntityObject::OnXForm( CEntity* pEntity )
{
UpdateWorldTM(pEntity);
if (!m_worldTM.IsValid())
{
EntityWarning("CEntityObject::OnXForm: Invalid world matrix: %s", pEntity->GetEntityTextDescription());
return;
}
if (pLight)
{
ILightSource* pLightSource = pLight;
// Update light positions.
CDLight* pDLight = &pLightSource->GetLightProperties();
pDLight->SetPosition( m_worldTM.GetTranslation());
pDLight->SetMatrix(m_worldTM);
pDLight->m_sName = pEntity->GetName(); // For debugging only.
pDLight->m_nEntityId = pEntity->GetId();
pEntity->UpdateLightClipBounds(*pDLight);
pLightSource->SetMatrix(m_worldTM);
pLight->SetSrcEntity(pEntity);
}
else if (pChildRenderNode)
{
pChildRenderNode->SetMatrix( m_worldTM );
}
}
const Matrix34 & CEntityObject::GetWorldTM( CEntity* pEntity )
{
if (!bWorldTMValid)
{
UpdateWorldTM(pEntity);
}
return m_worldTM;
}
void CEntityObject::Update( CEntity* pEntity,bool bVisible,bool &bBoundsChanged )
{
bBoundsChanged = false;
if (pCharacter)
{
int characterFlags = pCharacter->GetFlags();
if ((flags & ENTITY_SLOT_RENDER) || (characterFlags & CS_FLAG_UPDATE_ALWAYS))
{
bBoundsChanged = true; // Lets bounds of character change constantly.
if (characterFlags & CS_FLAG_UPDATE)
{
if (!bWorldTMValid)
UpdateWorldTM(pEntity);
QuatTS AnimatedCharacter = QuatTS( m_worldTM );
const CCamera &camera = GetISystem()->GetViewCamera();
float fDistance = (camera.GetPosition() - AnimatedCharacter.t).GetLength();
float fZoomFactor = 0.001f + 0.999f * (RAD2DEG(camera.GetFov()) / 60.f);
SAnimationProcessParams params;
params.locationAnimation = AnimatedCharacter;
params.bOnRender = 0;
params.zoomAdjustedDistanceFromCamera = fDistance * fZoomFactor;
pCharacter->StartAnimationProcessing(params);
}
}
}
#if defined(USE_GEOM_CACHES)
else
{
IGeomCacheRenderNode* pGeomCacheRenderNode = GetGeomCacheRenderNode();
if (pGeomCacheRenderNode && pGeomCacheRenderNode->DidBoundsChange())
{
bBoundsChanged = true;
}
}
#endif
}
void CEntityObject::Render( CEntity* pEntity,SRendParams &rParams,int nRndFlags,CRenderProxy* pRenderProxy, const SRenderingPassInfo &passInfo )
{
if (!bWorldTMValid)
{
UpdateWorldTM(pEntity);
}
// Override with custom slot material.
IMaterial* pPrevMtl = rParams.pMaterial;
if (pMaterial)
rParams.pMaterial = pMaterial;
int32 nOldObjectFlags = rParams.dwFObjFlags;
rParams.dwFObjFlags |= dwFObjFlags;
if (flags & ENTITY_SLOT_RENDER_AFTER_POSTPROCESSING)
{
rParams.dwFObjFlags |= FOB_RENDER_AFTER_POSTPROCESSING;
}
#ifdef SEG_WORLD
rParams.nCustomFlags |= (1 << (COB_SW_SHIFT + pEntity->GetSwObjDebugFlag()));
#endif // SEG_WORLD
//////////////////////////////////////////////////////////////////////////
rParams.pInstance = this;
const bool bIsInCameraSpace = (flags & ENTITY_SLOT_RENDER_NEAREST) != 0;
// Draw static object.
if (pStatObj)
{
rParams.pMatrix = &m_worldTM;
rParams.dwFObjFlags |= FOB_TRANS_MASK;
rParams.pFoliage = pFoliage;
rParams.nSubObjHideMask = nSubObjHideMask;
// make sure object motion blur can be applied to this object
if (bObjectMoved)
{
rParams.dwFObjFlags |= FOB_DYNAMIC_OBJECT;
bObjectMoved = false;
}
Matrix34 entityTM;
if (bIsInCameraSpace)
{
rParams.pMatrix = &entityTM;
entityTM = m_worldTM;
// Camera space
if (m_pCameraSpacePos)
{
// Use camera space relative position
entityTM.SetTranslation(*m_pCameraSpacePos);
}
else
{
// We don't have camera space relative position, so calculate it out from world space
// (This will not have the precision advantages of camera space rendering)
entityTM.AddTranslation(-gEnv->pSystem->GetViewCamera().GetPosition());
}
}
if (rParams.pMatrix->IsValid())
pStatObj->Render( rParams, passInfo );
else
EntityWarning("CEntityObject::Render: Invalid world matrix: %s", pEntity->GetEntityTextDescription());
}
else if (pCharacter)
{
QuatTS Offset;
Matrix34 PhysLocation(pEntity->GetWorldTM());
if (m_pXForm)
Offset = QuatTS(m_pXForm->localTM);
else
{
//CRY_FIXME(03,12,2009,"Animation & Rendering of entities needs to be re-written to avoid derivation of local offset due to float inaccuracy - Richard Semmens");
if (!Matrix34::IsEquivalent(PhysLocation,m_worldTM))
{
Matrix34 invPhysLocation = PhysLocation.GetInverted();
Matrix34 matOffset = invPhysLocation * m_worldTM;
Offset = QuatTS(matOffset);
}
else
{
Offset.SetIdentity();
}
}
if (bIsInCameraSpace)
{
// Camera space
if (m_pCameraSpacePos)
{
// Use camera space relative position
const Matrix33 camRot = Matrix33(gEnv->pSystem->GetViewCamera().GetViewMatrix());
PhysLocation.SetTranslation(*m_pCameraSpacePos * camRot);
}
else
{
// We don't have camera space relative position, so calculate it out from world space
// (This will not have the precision advantages of camera space rendering)
PhysLocation.AddTranslation(-gEnv->pSystem->GetViewCamera().GetPosition());
}
Offset.SetIdentity();
}
rParams.pMatrix = &PhysLocation;
//rParams.pInstance = pCharacter;
// Disable hand-placed (static) decals on characters
rParams.dwFObjFlags |= FOB_DYNAMIC_OBJECT;
pCharacter->Render(rParams, Offset, passInfo);
const uint32 renderProxyFlags = pRenderProxy->GetFlags();
if (!passInfo.IsShadowPass() || (renderProxyFlags & CRenderProxy::FLAG_ANIMATE_OFFSCREEN_SHADOW))
{
// If We render character, make sure it is also gets animation activated.
if (!pEntity->m_bInActiveList)
pEntity->ActivateForNumUpdates(8);
}
}
else if (pChildRenderNode)
{
rParams.pMatrix = &m_worldTM;
//rParams.pInstance = pChildRenderNode;
pChildRenderNode->m_dwRndFlags = nRndFlags;
pChildRenderNode->Render( rParams, passInfo );
}
rParams.pMaterial = pPrevMtl;
rParams.dwFObjFlags = nOldObjectFlags;
if (!passInfo.IsShadowPass()) // Should also ignore rendering into the recursion.
{
if (pFoliage)
{
pFoliage->SetFlags(pFoliage->GetFlags() & ~IFoliage::FLAG_FROZEN | -(int)(rParams.nMaterialLayers & MTL_LAYER_FROZEN) & IFoliage::FLAG_FROZEN);
static ICVar* g_pWindActivationDist = gEnv->pConsole->GetCVar("e_FoliageWindActivationDist");
float maxdist = g_pWindActivationDist ? g_pWindActivationDist->GetFVal() : 0.0f;
Vec3 pos = m_worldTM.GetTranslation();
if (pStatObj && (gEnv->pSystem->GetViewCamera().GetPosition() - pos).len2() < sqr(maxdist) && gEnv->p3DEngine->GetWind(AABB(pos),false).len2() > 101.0f)
pStatObj->PhysicalizeFoliage(pEntity->GetPhysics(),m_worldTM,pFoliage,0,4);
}
}
}
void cUIObject::Update()
{
UpdateWorldTM();
UpdateChildren();
}
