//-----------------------------------------------------------------------------
// Purpose: Turns 'this' into an exact replica of 'pObject'.
// Input : pObject - Object to replicate.
// bUpdateDependencies -
// Output :
//-----------------------------------------------------------------------------
CMapClass *CMapLine::CopyFrom(CMapClass *pObject, bool bUpdateDependencies)
{
CMapLine *pFrom = dynamic_cast <CMapLine *>(pObject);
if (pFrom != NULL)
{
CMapClass::CopyFrom(pObject, bUpdateDependencies);
if (bUpdateDependencies)
{
m_pStartEntity = (CMapEntity *)UpdateDependency(m_pStartEntity, pFrom->m_pStartEntity);
m_pEndEntity = (CMapEntity *)UpdateDependency(m_pEndEntity, pFrom->m_pEndEntity);
}
else
{
m_pStartEntity = pFrom->m_pStartEntity;
m_pEndEntity = pFrom->m_pEndEntity;
}
strcpy(m_szStartValueKey, pFrom->m_szStartValueKey);
strcpy(m_szStartKey, pFrom->m_szStartKey);
strcpy(m_szEndValueKey, pFrom->m_szEndValueKey);
strcpy(m_szEndKey, pFrom->m_szEndKey);
}
return(this);
}
//-----------------------------------------------------------------------------
// Purpose: Updates the cached pointers to our start and end entities by looking
// for them in the given world.
// Input : pWorld - World to search.
//-----------------------------------------------------------------------------
void CMapLine::UpdateDependencies(CMapWorld *pWorld, CMapClass *pObject)
{
CMapClass::UpdateDependencies(pWorld, pObject);
if (pWorld == NULL)
{
return;
}
CMapEntity *pEntity = dynamic_cast <CMapEntity *> (m_pParent);
Assert(pEntity != NULL);
if (pEntity != NULL)
{
const char *pszValue = pEntity->GetKeyValue(m_szStartValueKey);
m_pStartEntity = (CMapEntity *)UpdateDependency(m_pStartEntity, pWorld->FindChildByKeyValue(m_szStartKey, pszValue));
if (m_szEndValueKey[0] != '\0')
{
pszValue = pEntity->GetKeyValue(m_szEndValueKey);
m_pEndEntity = (CMapEntity *)UpdateDependency(m_pEndEntity, pWorld->FindChildByKeyValue(m_szEndKey, pszValue));
}
else
{
// We don't have an end entity specified, use our parent as the end point.
m_pEndEntity = (CMapEntity *)UpdateDependency(m_pEndEntity, GetParent());
}
BuildLine();
}
}
//-----------------------------------------------------------------------------
// Purpose: Called just after this object has been removed from the world so
// that it can unlink itself from other objects in the world.
// Input : pWorld - The world that we were just removed from.
// bNotifyChildren - Whether we should forward notification to our children.
//-----------------------------------------------------------------------------
void CMapLine::OnRemoveFromWorld(CMapWorld *pWorld, bool bNotifyChildren)
{
CMapClass::OnRemoveFromWorld(pWorld, bNotifyChildren);
//
// Detach ourselves from the endpoint entities.
//
m_pStartEntity = (CMapEntity *)UpdateDependency(m_pStartEntity, NULL);
m_pEndEntity = (CMapEntity *)UpdateDependency(m_pEndEntity, NULL);
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *pObj -
// Output : CMapClass *
//-----------------------------------------------------------------------------
CMapClass *CMapKeyFrame::CopyFrom(CMapClass *pObj, bool bUpdateDependencies)
{
CMapClass::CopyFrom(pObj, bUpdateDependencies);
CMapKeyFrame *pFrom = dynamic_cast<CMapKeyFrame*>( pObj );
Assert( pFrom != NULL );
m_qAngles = pFrom->m_qAngles;
m_Angles = pFrom->m_Angles;
m_flSpeed = pFrom->m_flSpeed;
m_flMoveTime = pFrom->m_flMoveTime;
if (bUpdateDependencies)
{
m_pNextKeyFrame = (CMapKeyFrame *)UpdateDependency(m_pNextKeyFrame, pFrom->m_pNextKeyFrame);
}
else
{
m_pNextKeyFrame = pFrom->m_pNextKeyFrame;
}
m_bRebuildPath = true;
return this;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : key -
// value -
//-----------------------------------------------------------------------------
void CMapLine::OnParentKeyChanged( const char* key, const char* value )
{
CMapWorld *pWorld = (CMapWorld *)GetWorldObject(this);
if (pWorld != NULL)
{
if (stricmp(key, m_szStartValueKey) == 0)
{
m_pStartEntity = (CMapEntity *)UpdateDependency(m_pStartEntity, pWorld->FindChildByKeyValue(m_szStartKey, value));
BuildLine();
}
else if (stricmp(key, m_szEndValueKey) == 0)
{
m_pEndEntity = (CMapEntity *)UpdateDependency(m_pEndEntity, pWorld->FindChildByKeyValue(m_szEndKey, value));
BuildLine();
}
}
}
//-----------------------------------------------------------------------------
// Purpose: Called just after this object has been removed from the world so
// that it can unlink itself from other objects in the world.
// Input : pWorld - The world that we were just removed from.
// bNotifyChildren - Whether we should forward notification to our children.
//-----------------------------------------------------------------------------
void CMapKeyFrame::OnRemoveFromWorld(CMapWorld *pWorld, bool bNotifyChildren)
{
CMapClass::OnRemoveFromWorld(pWorld, bNotifyChildren);
//
// Detach ourselves from the next keyframe in the path.
//
m_pNextKeyFrame = (CMapKeyFrame *)UpdateDependency(m_pNextKeyFrame, NULL);
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : pszValue -
// pWorld - The world object that we are contained in.
//-----------------------------------------------------------------------------
void CMapSideList::BuildFaceListForValue(char const *pszValue, CMapWorld *pWorld)
{
CMapFaceList NewFaces;
pWorld->FaceID_StringToFaceLists(&NewFaces, NULL, pszValue);
//
// Detach from the faces that are not in the new list. Go
// in reverse order since we are removing items as we go.
//
if (m_Faces.Count() > 0)
{
for (int i = m_Faces.Count() - 1; i >= 0; i--)
{
CMapFace *pFace = m_Faces.Element(i);
ASSERT(pFace != NULL);
if ((pFace != NULL) && (NewFaces.Find(pFace) == -1))
{
CMapSolid *pSolid = (CMapSolid *)pFace->GetParent();
UpdateDependency(pSolid, NULL);
m_Faces.FastRemove(i);
}
}
}
//
// Attach to the faces that are not in the old list.
//
for (int i = 0; i < NewFaces.Count(); i++)
{
CMapFace *pFace = NewFaces.Element(i);
ASSERT(pFace != NULL);
if ((pFace != NULL) && (m_Faces.Find(pFace) == -1))
{
CMapSolid *pSolid = (CMapSolid *)pFace->GetParent();
UpdateDependency(NULL, pSolid);
m_Faces.AddToTail(pFace);
}
}
CalcBounds();
}
//-----------------------------------------------------------------------------
// Purpose: Called just after this object has been removed from the world so
// that it can unlink itself from other objects in the world.
// Input : pWorld - The world that we were just removed from.
// bNotifyChildren - Whether we should forward notification to our children.
//-----------------------------------------------------------------------------
void CMapSideList::OnRemoveFromWorld(CMapWorld *pWorld, bool bNotifyChildren)
{
CMapClass::OnRemoveFromWorld(pWorld, bNotifyChildren);
for (int i = 0; i < m_Faces.Count(); i++)
{
CMapFace *pFace = m_Faces.Element(i);
CMapSolid *pSolid = (CMapSolid *)pFace->GetParent();
UpdateDependency(pSolid, NULL);
}
m_Faces.RemoveAll();
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : List -
//-----------------------------------------------------------------------------
void CMapSideList::RemoveFacesNotInList(CMapObjectList &List)
{
if (m_Faces.Count() > 0)
{
for (int i = m_Faces.Count() - 1; i >= 0; i--)
{
CMapFace *pFace = m_Faces.Element(i);
if (FindFaceIDInList(pFace->GetFaceID(), List) == NULL)
{
CMapSolid *pSolid = (CMapSolid *)pFace->GetParent();
UpdateDependency(pSolid, NULL);
m_Faces.FastRemove(i);
}
}
}
}
//-----------------------------------------------------------------------------
// Purpose: Called from OnClone and OnPaste, updates references to face IDs
// in the one solid with references to corresponding face IDs in
// another solid.
// Input : pOrigSolid - Solid with faces to find.
// pNewSolid - Solid with faces to replace with.
// Output : Returns true if it replaced at least one face.
//-----------------------------------------------------------------------------
bool CMapSideList::ReplaceSolidFaces(CMapSolid *pOrigSolid, CMapSolid *pNewSolid)
{
bool bDidSomething = false;
for (int i = 0; i < pOrigSolid->GetFaceCount(); i++)
{
CMapFace *pFace = pOrigSolid->GetFace(i);
int nIndex = m_Faces.FindFaceID(pFace->GetFaceID());
if (nIndex != -1)
{
//
// Replace the element in our face list and unlink
// us from the original solid, relinking us to the new solid.
//
m_Faces.Element(nIndex) = pNewSolid->GetFace(i);
UpdateDependency(pOrigSolid, pNewSolid);
bDidSomething = true;
}
}
return(bDidSomething);
}
//-----------------------------------------------------------------------------
// Purpose: Turns us into an exact copy of the given object.
// Input : pFrom - Object to copy.
// Input : bUpdateDependencies - Whether we should link to any other objects
// in the world when we copy pointers.
//-----------------------------------------------------------------------------
CMapClass *CMapSideList::CopyFrom(CMapClass *pOther, bool bUpdateDependencies)
{
CMapSideList *pFrom = dynamic_cast <CMapSideList *>(pOther);
ASSERT(pFrom != NULL);
CMapClass::CopyFrom(pOther, bUpdateDependencies);
strcpy(m_szKeyName, pFrom->m_szKeyName);
m_Faces = pFrom->m_Faces;
if (bUpdateDependencies)
{
for (int i = 0; i < m_Faces.Count(); i++)
{
CMapFace *pFace = m_Faces.Element(i);
CMapSolid *pSolid = (CMapSolid *)pFace->GetParent();
UpdateDependency(pSolid, NULL);
}
}
return(this);
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CMapKeyFrame::SetNextKeyFrame(CMapKeyFrame *pNext)
{
m_pNextKeyFrame = (CMapKeyFrame *)UpdateDependency(m_pNextKeyFrame, pNext);
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CMapKeyFrame::SetAnimator(CMapAnimator *pAnimator)
{
m_pAnimator = (CMapAnimator *)UpdateDependency(m_pAnimator, pAnimator);
}
