Backups/csgo-2018-source
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
93f753e8ef
csgo-2018-source/movieobjects/dmedag.cpp

1788 lines
56 KiB
C++
Raw Normal View History

uid issue
2021-07-25 12:11:47 +08:00
//====== Copyright <20> 1996-2004, Valve Corporation, All rights reserved. =======
//
// Purpose:
//
//=============================================================================
#include "movieobjects/dmedag.h"
#include "movieobjects/dmeshape.h"
#include "datamodel/dmelementfactoryhelper.h"
#include "movieobjects/dmetransform.h"
#include "movieobjects/dmeoverlay.h"
#include "movieobjects_interfaces.h"
#include "movieobjects/dmedrawsettings.h"
#include "movieobjects/dmeclip.h"
#include "movieobjects/dmelog.h"
#include "movieobjects/dmechannel.h"
#include "movieobjects/dmerigconstraintoperators.h"
#include "movieobjects/dmetransformcontrol.h"
#include "movieobjects/dmeattributereference.h"
#include "movieobjects/dmerig.h"
// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"
static const char OVERRIDE_PARENT[] = "overrideParent";
//-----------------------------------------------------------------------------
// Expose this class to the scene database
//-----------------------------------------------------------------------------
IMPLEMENT_ELEMENT_FACTORY( DmeDag, CDmeDag );
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CUtlStack<CDmeDag::TransformInfo_t> CDmeDag::s_TransformStack;
bool CDmeDag::s_bDrawUsingEngineCoordinates = false;
bool CDmeDag::s_bDrawZUp = false;
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CDmeDag::OnConstruction()
{
m_Transform.InitAndCreate( this, "transform" );
m_Shape.Init( this, "shape" );
m_Visible.InitAndSet( this, "visible", true, FATTRIB_HAS_CALLBACK );
m_Children.Init( this, "children" );
m_bDisableOverrideParent.InitAndSet( this, "disableOverride", false, FATTRIB_DONTSAVE | FATTRIB_HIDDEN );
}
void CDmeDag::OnDestruction()
{
g_pDataModel->DestroyElement( m_Transform.GetHandle() );
}
void CDmeDag::Resolve()
{
// Since the overrideParent attribute is added dynamically we must update
// its flags is it present when re-loaded since the flags are not stored.
CDmAttribute *pAttribute = GetAttribute( OVERRIDE_PARENT );
if ( pAttribute )
{
pAttribute->AddFlag( FATTRIB_NEVERCOPY );
}
}
//-----------------------------------------------------------------------------
// Accessors
//-----------------------------------------------------------------------------
CDmeTransform *CDmeDag::GetTransform() const
{
return m_Transform.GetElement();
}
CDmeShape *CDmeDag::GetShape()
{
return m_Shape.GetElement();
}
void CDmeDag::SetShape( CDmeShape *pShape )
{
m_Shape = pShape;
}
bool CDmeDag::IsVisible() const
{
return m_Visible;
}
void CDmeDag::SetVisible( bool bVisible )
{
m_Visible = bVisible;
}
//-----------------------------------------------------------------------------
// Returns the visibility attribute for DmeRenderable support
//-----------------------------------------------------------------------------
CDmAttribute *CDmeDag::GetVisibilityAttribute()
{
return m_Visible.GetAttribute();
}
//-----------------------------------------------------------------------------
// child helpers
//-----------------------------------------------------------------------------
const CUtlVector< DmElementHandle_t > &CDmeDag::GetChildren() const
{
return m_Children.Get();
}
int CDmeDag::GetChildCount() const
{
return m_Children.Count();
}
CDmeDag *CDmeDag::GetChild( int i ) const
{
if ( i < 0 || i >= m_Children.Count() )
return NULL;
return m_Children.Get( i );
}
bool CDmeDag::AddChild( CDmeDag* pDag )
{
if ( !pDag || pDag == this )
return false;
// Don't allow a cycle to be created
if ( pDag->IsAncestorOfDag( this ) )
return false;
m_Children.AddToTail( pDag );
return true;
}
void CDmeDag::RemoveChild( int i )
{
m_Children.FastRemove( i );
}
void CDmeDag::RemoveChild( const CDmeDag *pChild, bool bRecurse )
{
int i = FindChild( pChild );
if ( i >= 0 )
{
RemoveChild( i );
}
}
void CDmeDag::RemoveAllChildren()
{
m_Children.RemoveAll();
}
//-----------------------------------------------------------------------------
// Sets the parent of this node to the specified parent. Removes any other
// parent nodes
//-----------------------------------------------------------------------------
bool CDmeDag::SetParent( CDmeDag *pDmeDagParent )
{
if ( !pDmeDagParent || pDmeDagParent == this )
return false;
CUtlVector< CDmeDag * > parentList;
FindAncestorsReferencingElement( this, parentList );
for ( int i = 0; i < parentList.Count(); ++i )
{
if ( !parentList[ i ] )
continue;
parentList[ i ]->RemoveChild( this );
}
return pDmeDagParent->AddChild( this );
}
int CDmeDag::FindChild( const CDmeDag *pChild ) const
{
return m_Children.Find( pChild->GetHandle() );
}
// recursive
int CDmeDag::FindChild( CDmeDag *&pParent, const CDmeDag *pChild )
{
int index = FindChild( pChild );
if ( index >= 0 )
{
pParent = this;
return index;
}
int nChildren = m_Children.Count();
for ( int ci = 0; ci < nChildren; ++ci )
{
index = m_Children[ ci ]->FindChild( pParent, pChild );
if ( index >= 0 )
return index;
}
pParent = NULL;
return -1;
}
int CDmeDag::FindChild( const char *name ) const
{
int nChildren = m_Children.Count();
for ( int ci = 0; ci < nChildren; ++ci )
{
if ( V_strcmp( m_Children[ ci ]->GetName(), name ) == 0 )
return ci;
}
return -1;
}
CDmeDag *CDmeDag::FindOrAddChild( const char *name )
{
int i = FindChild( name );
if ( i >= 0 )
return GetChild( i );
CDmeDag *pChild = CreateElement< CDmeDag >( name, GetFileId() );
AddChild( pChild );
return pChild;
}
CDmeDag *CDmeDag::FindChildByName_R( const char *name ) const
{
int i = FindChild( name );
if ( i >= 0 )
return GetChild( i );
int nChildren = m_Children.Count();
for ( int ci = 0; ci < nChildren; ++ci )
{
CDmeDag *found = m_Children[ ci ]->FindChildByName_R( name );
if ( found )
return found;
}
return NULL;
}
//-----------------------------------------------------------------------------
// Purpose: Return the number of steps ( levels, connections, etc...) between
// the the node a the specified child node. If the provided node is not a
// child of this node -1 will be returned.
//-----------------------------------------------------------------------------
int CDmeDag::StepsToChild( const CDmeDag *pChild ) const
{
int nSteps = 0;
for ( const CDmeDag *pDag = pChild; pDag; pDag = pDag->GetParent(), ++nSteps )
{
if ( pDag == this )
return nSteps;
}
return -1;
}
//-----------------------------------------------------------------------------
// Recursively render the Dag hierarchy
//-----------------------------------------------------------------------------
void CDmeDag::PushDagTransform()
{
int i = s_TransformStack.Push();
TransformInfo_t &info = s_TransformStack[i];
info.m_pTransform = GetTransform();
info.m_bComputedDagToWorld = false;
}
void CDmeDag::PopDagTransform()
{
Assert( s_TransformStack.Top().m_pTransform == GetTransform() );
s_TransformStack.Pop();
}
//-----------------------------------------------------------------------------
// Transform from DME to engine coordinates
//-----------------------------------------------------------------------------
void CDmeDag::DmeToEngineMatrix( matrix3x4_t& dmeToEngine, bool bZUp )
{
if ( bZUp )
{
VMatrix rotationZ;
MatrixBuildRotationAboutAxis( rotationZ, Vector( 0, 0, 1 ), 90 );
rotationZ.Set3x4( dmeToEngine );
}
else
{
VMatrix rotation, rotationZ;
MatrixBuildRotationAboutAxis( rotation, Vector( 1, 0, 0 ), 90 );
MatrixBuildRotationAboutAxis( rotationZ, Vector( 0, 1, 0 ), 90 );
ConcatTransforms( rotation.As3x4(), rotationZ.As3x4(), dmeToEngine );
}
}
//-----------------------------------------------------------------------------
// Transform from engine to DME coordinates
//-----------------------------------------------------------------------------
void CDmeDag::EngineToDmeMatrix( matrix3x4_t& engineToDme, bool bZUp )
{
if ( bZUp )
{
VMatrix rotationZ;
MatrixBuildRotationAboutAxis( rotationZ, Vector( 0, 0, 1 ), -90 );
rotationZ.Set3x4( engineToDme );
}
else
{
VMatrix rotation, rotationZ;
MatrixBuildRotationAboutAxis( rotation, Vector( 1, 0, 0 ), -90 );
MatrixBuildRotationAboutAxis( rotationZ, Vector( 0, 1, 0 ), -90 );
ConcatTransforms( rotationZ.As3x4(), rotation.As3x4(), engineToDme );
}
}
void CDmeDag::GetShapeToWorldTransform( matrix3x4_t &mat )
{
int nCount = s_TransformStack.Count();
if ( nCount == 0 )
{
if ( !s_bDrawUsingEngineCoordinates )
{
SetIdentityMatrix( mat );
}
else
{
DmeToEngineMatrix( mat, s_bDrawZUp );
}
return;
}
if ( s_TransformStack.Top().m_bComputedDagToWorld )
{
MatrixCopy( s_TransformStack.Top().m_DagToWorld, mat );
return;
}
// Compute all uncomputed dag to worls
int i;
for ( i = 0; i < nCount; ++i )
{
TransformInfo_t &info = s_TransformStack[i];
if ( !info.m_bComputedDagToWorld )
break;
}
// Set up the initial transform
if ( i == 0 )
{
if ( !s_bDrawUsingEngineCoordinates )
{
SetIdentityMatrix( mat );
}
else
{
DmeToEngineMatrix( mat, s_bDrawZUp );
}
}
else
{
MatrixCopy( s_TransformStack[i-1].m_DagToWorld, mat );
}
// Compute all transforms
for ( ; i < nCount; ++i )
{
matrix3x4_t localToParent;
TransformInfo_t &info = s_TransformStack[i];
info.m_pTransform->GetTransform( localToParent );
ConcatTransforms( mat, localToParent, info.m_DagToWorld );
info.m_bComputedDagToWorld = true;
MatrixCopy( info.m_DagToWorld, mat );
}
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
void CDmeDag::GetLocalMatrix( matrix3x4_t &m ) const
{
CDmeTransform *pTransform = GetTransform();
if ( pTransform )
{
pTransform->GetTransform( m );
}
else
{
SetIdentityMatrix( m );
}
}
void CDmeDag::SetLocalMatrix( matrix3x4_t &mat )
{
CDmeTransform *pTransform = GetTransform();
if ( !pTransform )
return;
pTransform->SetTransform( mat );
}
//-----------------------------------------------------------------------------
// Get the transform matrix which converts from the space of the parent of the
// dag node to world space. If the dag node has an override parent specified
// it will be accounted for when generating the matrix.
//-----------------------------------------------------------------------------
void CDmeDag::GetParentWorldMatrix( matrix3x4_t &mParentToWorld ) const
{
CDmeDag *pParent = GetParent();
if ( HasOverrideParent() )
{
bool bOverridePos = false;
bool bOverrideRot = false;
const CDmeDag *pOverrideParent = GetOverrideParent( bOverridePos, bOverrideRot );
if ( bOverridePos && bOverrideRot )
{
pOverrideParent->GetAbsTransform( mParentToWorld );
}
else
{
if ( pParent )
{
pParent->GetAbsTransform( mParentToWorld );
}
else
{
SetIdentityMatrix( mParentToWorld );
}
Quaternion absOrientation;
Vector absPosition;
if ( bOverridePos )
{
// The desired result of a position only parent override is that no changes to the original parent in either
// position or rotation will have any impact on the position of the dag. Furthermore we prefer rotations of
// the original parent to pivot around the dag node's center, not the override parent's center. To accomplish
// this we essentially want to compute the rotation normally, but then apply the local translation of the dag
// to the position of the override dag in world space. In order to construct the a parent matrix that still
// allows the local transform of the dag to be concatenated normally, we essentially do the whole transform
// here when constructing the parent matrix and then apply the inverse of the local matrix, so we know when
// the local matrix is concatenated later the result will be what we setup before applying the inverse of the
// local matrix.
CDmeTransform *pLocalTransform = GetTransform();
if ( pLocalTransform )
{
Vector localPosition = pLocalTransform->GetPosition();
Quaternion localOrientation = pLocalTransform->GetOrientation();
// Compute the orientation normally as if there is no override parent
// by concatenating the local orientation with the parent orientation.
Quaternion parentOrientation;
Quaternion worldOrientation;
MatrixQuaternion( mParentToWorld, parentOrientation );
QuaternionMult( parentOrientation, localOrientation, worldOrientation );
// Compute the position by simply adding the local position to the world space
// position of the override parent, this effectively make the local translation
// of the dag a world space operation so it is never effected by rotation.
Vector overridePosition;
pOverrideParent->GetAbsPosition( overridePosition );
Vector worldPosition = overridePosition + localPosition;
// Compute the final world transform we will want for the dag
// (i.e. this is the reuslt we want GetAbsTransform() to return)
matrix3x4_t mWorldTransform;
QuaternionMatrix( worldOrientation, worldPosition, mWorldTransform );
// Now construct an apply the inverse of the local transform in order to get
// an appropriate parent matrix that will yield the desired mWorldTransfom
// when the local transform of the dag is applied to it.
matrix3x4_t mLocalTransform;
matrix3x4_t mInvLocalTransform;
QuaternionMatrix( localOrientation, localPosition, mLocalTransform );
MatrixInvert( mLocalTransform, mInvLocalTransform );
ConcatTransforms( mWorldTransform, mInvLocalTransform, mParentToWorld );
}
}
else if ( bOverrideRot )
{
// Rotation only override is much simpler than position, just construct a matrix with
// the orientation of the override parent and the position of the original parent.
pOverrideParent->GetAbsOrientation( absOrientation );
MatrixPosition( mParentToWorld, absPosition );
QuaternionMatrix( absOrientation, absPosition, mParentToWorld );
}
}
}
else if ( pParent )
{
pParent->GetAbsTransform( mParentToWorld );
}
else
{
SetIdentityMatrix( mParentToWorld );
}
}
//-----------------------------------------------------------------------------
// Get the matrix matrix for computing the position of the dag node. This is
// the same as GetParentWorldMatrix except in the case where the dag node has
// a position only override parent. This should be used when trying to apply a
// translation to the dag and conversion from world space to the space of the
// parent of the dag is required.
//-----------------------------------------------------------------------------
void CDmeDag::GetTranslationParentWorldMatrix( matrix3x4_t &mParentToWorld )
{
bool bOverridePos = false;
bool bOverrideRot = false;
const CDmeDag *pOverrideParent = GetOverrideParent( bOverridePos, bOverrideRot );
if ( pOverrideParent && bOverridePos && !bOverrideRot )
{
Vector overridePosition;
pOverrideParent->GetAbsPosition( overridePosition );
SetIdentityMatrix( mParentToWorld );
PositionMatrix( overridePosition, mParentToWorld );
}
else
{
GetParentWorldMatrix( mParentToWorld );
}
}
//-----------------------------------------------------------------------------
// Recursively render the Dag hierarchy
//-----------------------------------------------------------------------------
void CDmeDag::DrawUsingEngineCoordinates( bool bEnable )
{
s_bDrawUsingEngineCoordinates = bEnable;
}
//-----------------------------------------------------------------------------
// Specify if the model is a Z Up Model
//-----------------------------------------------------------------------------
void CDmeDag::DrawZUp( bool bZUp )
{
s_bDrawZUp = bZUp;
}
//-----------------------------------------------------------------------------
// Recursively render the Dag hierarchy
//-----------------------------------------------------------------------------
void CDmeDag::Draw( CDmeDrawSettings *pDrawSettings )
{
if ( !m_Visible )
return;
PushDagTransform();
CDmeShape *pShape = GetShape();
if ( pShape )
{
matrix3x4_t shapeToWorld;
GetShapeToWorldTransform( shapeToWorld );
pShape->Draw( shapeToWorld, pDrawSettings );
}
uint cn = m_Children.Count();
for ( uint ci = 0; ci < cn; ++ci )
{
m_Children[ ci ]->Draw( pDrawSettings );
}
PopDagTransform();
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
void CDmeDag::GetBoundingSphere( Vector &c0, float &r0, const matrix3x4_t &pMat ) const
{
matrix3x4_t lMat;
m_Transform.GetElement()->GetTransform( lMat );
matrix3x4_t wMat;
ConcatTransforms( pMat, lMat, wMat );
c0.Zero();
r0 = 0.0f;
Vector vTemp;
const CDmeShape *pShape = m_Shape.GetElement();
if ( pShape )
{
pShape->GetBoundingSphere( c0, r0 );
VectorTransform( c0, lMat, vTemp );
c0 = vTemp;
}
// No scale in Dme! :)
VectorTransform( c0, pMat, vTemp );
c0 = vTemp;
const int nChildren = m_Children.Count();
if ( nChildren > 0 )
{
Vector c1; // Child center
float r1; // Child radius
Vector v01; // c1 - c0
float l01; // |v01|
for ( int i = 0; i < nChildren; ++i )
{
m_Children[ i ]->GetBoundingSphere( c1, r1, wMat );
if ( r0 == 0.0f )
{
c0 = c1;
r0 = r1;
continue;
}
v01 = c1 - c0;
l01 = v01.NormalizeInPlace();
if ( r0 < l01 + r1 )
{
// Current sphere doesn't contain both spheres
if ( r1 < l01 + r0 )
{
// Child sphere doesn't contain both spheres
c0 = c0 + 0.5f * ( r1 + l01 - r0 ) * v01;
r0 = 0.5f * ( r0 + l01 + r1 );
}
else
{
// Child sphere contains both spheres
c0 = c1;
r0 = r1;
}
}
}
}
}
//-----------------------------------------------------------------------------
// Purpose: Find the channels targeting the transform of the object either
// directly or through a constraint
//-----------------------------------------------------------------------------
void CDmeDag::FindTransformChannels( CUtlVector< CDmeChannel * > &channelList ) const
{
// Find and channels targeting the transform of the dag node
FindAncestorsReferencingElement( GetTransform(), channelList );
// Find the slave instances targeting the specified node
CUtlVector< CDmeConstraintSlave* > slaveList;
FindAncestorsReferencingElement( this, slaveList );
int nSlaves = slaveList.Count();
for ( int iSlave = 0; iSlave < nSlaves; ++iSlave )
{
CDmeConstraintSlave *pSlave = slaveList[ iSlave ];
if ( pSlave )
{
FindAncestorsReferencingElement( pSlave, channelList );
}
}
}
//-----------------------------------------------------------------------------
// Purpose: Find the transform controls driving the dag node
//-----------------------------------------------------------------------------
CDmeTransformControl *CDmeDag::FindTransformControl() const
{
CUtlVector< CDmeChannel* > channelList( 0, 4 );
FindTransformChannels( channelList );
int nChannels = channelList.Count();
for ( int iChannel = 0; iChannel < nChannels; ++iChannel )
{
CDmeChannel *pChannel = channelList[ iChannel ];
if ( pChannel )
{
CDmeTransformControl *pTransformControl = CastElement< CDmeTransformControl >( pChannel->GetFromElement() );
if ( pTransformControl )
return pTransformControl;
}
}
return NULL;
}
//-----------------------------------------------------------------------------
// Purpose: Find the channels and operators which must be evaluated in order
// to determine the state of the dag node. Note that this function returns only
// the operators targeting this dag node, it does not include those targeting
// the parent of this node, but it does return all operators that this node
// is dependent on even if they are are connected to this node through other
// operators.
//-----------------------------------------------------------------------------
void CDmeDag::FindLocalOperators( CUtlVector< CDmeOperator* > &operatorList ) const
{
// Find any operators directly targeting the transform of the dag node
GatherOperatorsForElement( GetTransform(), operatorList );
// Find the slave instances targeting the specified node
for ( DmAttributeReferenceIterator_t it = g_pDataModel->FirstAttributeReferencingElement( GetHandle() );
it != DMATTRIBUTE_REFERENCE_ITERATOR_INVALID;
it = g_pDataModel->NextAttributeReferencingElement( it ) )
{
CDmAttribute *pAttr = g_pDataModel->GetAttribute( it );
CDmElement *pElement = pAttr->GetOwner();
if ( !g_pDataModel->GetElement( pElement->GetHandle() ) )
continue;
CDmeConstraintSlave *pConstraintSlave = CastElement< CDmeConstraintSlave >( pElement );
if ( pConstraintSlave )
{
CDmeRigBaseConstraintOperator *pConstraint = pConstraintSlave->GetConstraint();
if ( pConstraint )
{
if ( operatorList.Find( pConstraint ) == operatorList.InvalidIndex() )
{
pConstraint->GatherInputOperators( operatorList );
operatorList.AddToTail( pConstraint );
}
}
}
}
}
//-----------------------------------------------------------------------------
// Purpose: Find all of the operators on which dag node is dependent, this
// recursively finds operators for the parents of the dag. The list of operators
// that is returned represents all of the operators which must be evaluated in
// order to determine the current state of the node. The list is returned in
// the order that the operators should be run.
//-----------------------------------------------------------------------------
void CDmeDag::FindRelevantOperators( CUtlVector< CDmeOperator * > &operatorList ) const
{
const CDmeDag *pOverrideParent = GetOverrideParent();
if ( pOverrideParent )
{
pOverrideParent->FindRelevantOperators( operatorList );
}
CDmeDag *pParent = GetParent();
if ( pParent )
{
pParent->FindRelevantOperators( operatorList );
}
FindLocalOperators( operatorList );
}
//-----------------------------------------------------------------------------
// Purpose: Find all of the operators on which the dag node is dependent,
// splitting the channels into a separate list. This function merely calls
// the FindRelvantOperators() which returns a single list of operators and
// then creates a list of channels and a list of other operators. It is
// preferable to just use the version which returns a single list of operators.
//-----------------------------------------------------------------------------
void CDmeDag::FindRelevantOperators( CUtlVector< CDmeChannel * > &channelList, CUtlVector< CDmeOperator * > &operatorList ) const
{
CUtlVector< CDmeOperator* > allOperatorsList( 0, 128 );
FindRelevantOperators( allOperatorsList );
int nTotalOperators = allOperatorsList.Count();
channelList.EnsureCapacity( channelList.Count() + nTotalOperators );
operatorList.EnsureCapacity( operatorList.Count() + nTotalOperators );
for ( int iOperator = 0; iOperator < nTotalOperators; ++iOperator )
{
CDmeOperator *pOperator = allOperatorsList[ iOperator ];
if ( pOperator == NULL )
continue;
CDmeChannel *pChannel = CastElement< CDmeChannel >( pOperator );
if ( pChannel )
{
channelList.AddToTail( pChannel );
}
else
{
operatorList.AddToTail( pOperator );
}
}
}
void CDmeDag::GetBoundingBox( Vector &min, Vector &max, const matrix3x4_t &pMat ) const
{
matrix3x4_t lMat;
m_Transform.GetElement()->GetTransform( lMat );
matrix3x4_t wMat;
ConcatTransforms( pMat, lMat, wMat );
min.Zero();
max.Zero();
bool bHasBox = false;
const CDmeShape *pShape = m_Shape.GetElement();
if ( pShape )
{
Vector cmin, cmax;
pShape->GetBoundingBox( cmin, cmax );
if ( cmin != cmax )
{
Vector bmin( cmin ), bmax( cmax );
VectorTransform( cmin, pMat, bmin );
VectorTransform( cmax, pMat, bmax );
for ( int kx = 0; kx < 2; ++ kx )
for ( int ky = 0; ky < 2; ++ ky )
for ( int kz = 0; kz < 2; ++ kz )
{
Vector tp(
kx ? cmax.x : cmin.x,
ky ? cmax.y : cmin.y,
kz ? cmax.z : cmin.z );
Vector vTemp;
VectorTransform( tp, pMat, vTemp );
bmin = bmin.Min( vTemp );
bmax = bmax.Max( vTemp );
}
if ( !bHasBox )
{
min = bmin;
max = bmax;
}
min = min.Min( bmin );
max = max.Max( bmax );
bHasBox = true;
}
}
for ( int i = 0, nChildren = m_Children.Count(); i < nChildren; ++ i )
{
CDmeDag *pChild = m_Children[i];
Vector cmin, cmax;
pChild->GetBoundingBox( cmin, cmax, wMat );
if ( cmin != cmax )
{
if ( !bHasBox )
{
min = cmin;
max = cmax;
}
min = min.Min( cmin );
max = max.Max( cmax );
bHasBox = true;
}
}
}
Quaternion QuaternionTransform( const Quaternion &quat, const matrix3x4_t &mat )
{
matrix3x4_t quatmat;
QuaternionMatrix( quat, quatmat );
matrix3x4_t newmat;
ConcatTransforms( mat, quatmat, newmat );
Quaternion result;
MatrixQuaternion( newmat, result );
return result;
}
void CDmeDag::BakeStaticTransforms( bool bRecurse /*= true*/ )
{
// determine whether to bake this transform into its children
if ( FindAncestorReferencingElement< CDmeChannel >( this ) || FindAncestorReferencingElement< CDmeConstraintSlave >( this ) )
return; // don't bake, since it's transform isn't static
if ( ( GetType() != CDmeDag::GetStaticTypeSymbol() ) && ( GetType() != CDmeRig::GetStaticTypeSymbol() ) )
return; // don't bake CDmeGameModel's root transform into the child bones, CDmeParticleSystem's root transform into the control points, etc.
int nChildrenFound = 0;
int nChildren = GetChildCount();
for ( int i = 0; i < nChildren; ++i )
{
CDmeDag *pChild = GetChild( i );
if ( !pChild )
continue;
if ( FindAncestorReferencingElement< CDmeConstraintSlave >( pChild ) )
return; // don't bake, since child's transform isn't static
// TODO: it probably wouldn't be that hard to make this work with dags with overriden parents
// the simplest path may be to unparent (and let the unparent do the conversion keeping everything in place), bake, and reparent
// there are faster and less obtrusive ways, but we don't need this functionality now, so I'm not solving it yet
if ( pChild->HasOverrideParent() )
return; // don't bake
++nChildrenFound;
}
if ( nChildrenFound == 0 )
return;
// now, actually bake this transform into its children
matrix3x4_t parentMat;
GetLocalMatrix( parentMat );
matrix3x4_t identityMat;
SetIdentityMatrix( identityMat );
SetLocalMatrix( identityMat );
static CUtlSymbolLarge symToElement = g_pDataModel->GetSymbol( "toElement" );
for ( int i = 0; i < nChildren; ++i )
{
CDmeDag *pChild = GetChild( i );
if ( !pChild )
continue;
CDmeTransform *pTransform = pChild->GetTransform();
if ( !pTransform )
continue;
CDmeVector3Log *pPosLog = NULL;
CDmeQuaternionLog *pRotLog = NULL;
CDmeTransformControl *pTransformControl = NULL;
for ( CAttributeReferenceIterator it( pTransform ); it; ++it )
{
if ( CDmeChannel *pChannel = it.FilterReference< CDmeChannel >( symToElement, true, TD_ALL ) )
{
CDmAttribute *pToAttr = pChannel->GetToAttribute();
if ( pToAttr == pTransform->GetPositionAttribute() )
{
pPosLog = CastElement< CDmeVector3Log >( pChannel->GetLog() );
}
else if ( pToAttr == pTransform->GetOrientationAttribute() )
{
pRotLog = CastElement< CDmeQuaternionLog >( pChannel->GetLog() );
}
if ( !pTransformControl )
{
pTransformControl = CastElement< CDmeTransformControl >( pChannel->GetFromElement() );
}
}
}
if ( pPosLog )
{
int bestLayer = pPosLog->GetTopmostLayer();
CDmeVector3LogLayer *pPosLogLayer = bestLayer >= 0 ? pPosLog->GetLayer( bestLayer ) : NULL;
if ( pPosLogLayer )
{
int nPosKeys = pPosLogLayer->GetKeyCount();
for ( int i = 0; i < nPosKeys; ++i )
{
pPosLogLayer->SetKeyValue( i, VectorTransform( pPosLogLayer->GetKeyValue( i ), parentMat ) );
}
}
pPosLog->SetDefaultValue( VectorTransform( pPosLog->GetDefaultValue(), parentMat ) ); // do we really want to transform the default???
}
if ( pRotLog )
{
int bestLayer = pRotLog->GetTopmostLayer();
CDmeQuaternionLogLayer *pRotLogLayer = bestLayer >= 0 ? pRotLog->GetLayer( bestLayer ) : NULL;
if ( pRotLogLayer )
{
int nRotKeys = pRotLogLayer->GetKeyCount();
for ( int i = 0; i < nRotKeys; ++i )
{
pRotLogLayer->SetKeyValue( i, QuaternionTransform( pRotLogLayer->GetKeyValue( i ), parentMat ) );
}
}
pRotLog->SetDefaultValue( QuaternionTransform( pRotLog->GetDefaultValue(), parentMat ) ); // do we really want to transform the default???
}
if ( pTransformControl )
{
// bake into transform control
pTransformControl->SetPosition ( VectorTransform ( pTransformControl->GetPosition (), parentMat ) );
pTransformControl->SetOrientation( QuaternionTransform( pTransformControl->GetOrientation(), parentMat ) );
// we explicitly do NOT set the transform control's defaults, since the root default should still be the origin
}
// bake into transform
pTransform->SetPosition ( VectorTransform ( pTransform->GetPosition (), parentMat ) );
pTransform->SetOrientation( QuaternionTransform( pTransform->GetOrientation(), parentMat ) );
if ( bRecurse )
{
pChild->BakeStaticTransforms( bRecurse );
}
}
}
//-----------------------------------------------------------------------------
// Purpose: Attach the dag node to the specified parent node. If the dag node
// is currently a child of another node it will be removed the from that node.
// The local space transform of the dag node will be modified so that it will
// have the same world space transform after being attached as before it was
// attached. Passing in NULL for the parent effectively moves the dag node into
// world space without any parents.
//
//-----------------------------------------------------------------------------
void CDmeDag::OnAttachToDmeDag( CDmeDag *pParentDag, bool bFixupLogs /*= true*/ )
{
if ( GetParent() == pParentDag )
return;
CDmeTransform *pTransform = GetTransform();
if ( !pTransform )
return;
CUndoScopeGuard guard( NOTIFY_SETDIRTYFLAG, "CDmeDag::OnAttachToDmeDag" );
CDmeFilmClip *pFilmClip = NULL;
if ( pParentDag != NULL )
{
pFilmClip = FindFilmClipContainingDag( pParentDag );
}
else
{
pFilmClip = FindFilmClipContainingDag( this );
}
matrix3x4_t cameraMat, parentMat, invParentMat, newCameraMat;
GetAbsTransform( cameraMat );
if ( pParentDag && pFilmClip )
{
pParentDag->GetAbsTransform( parentMat );
}
else
{
SetIdentityMatrix( parentMat );
}
MatrixInvert( parentMat, invParentMat );
ConcatTransforms( invParentMat, cameraMat, newCameraMat );
pTransform->SetTransform( newCameraMat );
matrix3x4_t cameraParentMat, oldToNewCameraMat;
GetParentWorldMatrix( cameraParentMat );
ConcatTransforms( invParentMat, cameraParentMat, oldToNewCameraMat );
CUtlVector< CDmeDag* > parents;
FindAncestorsReferencingElement( this, parents );
int nParents = parents.Count();
for ( int i = 0; i < nParents; ++i )
{
parents[ i ]->RemoveChild( this );
}
if ( ( bFixupLogs ) && ( pFilmClip != NULL ) )
{
CDmeTransform *pTransform = GetTransform();
CDmeChannel *pPosChannel = FindChannelTargetingElement( pFilmClip, pTransform, TRANSFORM_POSITION, NULL );
if ( pPosChannel )
{
CDmeLog *pLog = pPosChannel->GetLog();
if ( pLog )
{
CDmeLogLayer *pLayer = pLog->GetLayer( pLog->GetTopmostLayer() );
CDmeTypedLogLayer< Vector > *pVectorLayer = CastElement< CDmeTypedLogLayer< Vector > >( pLayer );
if ( pVectorLayer )
{
int nKeys = pVectorLayer->GetKeyCount();
for ( int i = 0; i < nKeys; ++i )
{
Vector newvec, oldvec = pVectorLayer->GetKeyValue( i );
VectorTransform( oldvec, oldToNewCameraMat, newvec );
pVectorLayer->SetKeyValue( i, newvec );
}
}
}
}
CDmeChannel *pRotChannel = FindChannelTargetingElement( pFilmClip, pTransform, TRANSFORM_ORIENTATION, NULL );
if ( pRotChannel )
{
CDmeLog *pLog = pRotChannel->GetLog();
if ( pLog )
{
CDmeLogLayer *pLayer = pLog->GetLayer( pLog->GetTopmostLayer() );
CDmeTypedLogLayer< Quaternion > *pQuatLayer = CastElement< CDmeTypedLogLayer< Quaternion > >( pLayer );
if ( pQuatLayer )
{
int nKeys = pQuatLayer->GetKeyCount();
for ( int i = 0; i < nKeys; ++i )
{
matrix3x4_t oldmat, newmat;
QuaternionMatrix( pQuatLayer->GetKeyValue( i ), oldmat );
ConcatTransforms( oldToNewCameraMat, oldmat, newmat );
Quaternion quat;
MatrixQuaternion( newmat, quat );
pQuatLayer->SetKeyValue( i, quat );
}
}
}
}
}
if ( pParentDag )
{
pParentDag->AddChild( this );
}
}
//-----------------------------------------------------------------------------
// Purpose: Modify the logs controlling the transform of this dag node so that
// the transform maintains the same relative position and orientation to the
// target dag node for the duration of the provided time period.
// Input : pTargetDag - Pointer to the dag node whose transform the transform
// of this dag node it to be bound to.
// Input : timeSelection - Time selection for which the modifications are to
// be applied, including falloffs.
// Input : pMovie - Pointer to the movie to which the dag belongs
// Input : offset - Offset relative to the dag where the offset is going to be
// placed if the reset position flag is true.
// Input : bPosition - flag indicating that the position of the dag node
// should be modified.
// Input : bOrientation - flag indicating that the orientation of the dag
// node should be modified.
// Input : bResetPosition - flag indicating that the position of the target
// dag node should be repositioned.
//-----------------------------------------------------------------------------
void CDmeDag::BindTransformToDmeDag( const CDmeDag *pTargetDag, const DmeLog_TimeSelection_t &timeSelection, const CDmeClip* pMovie, const Vector& offset, bool bPosition, bool bOrientation, bool bMaintainOffset )
{
// Must specify a target dag and it must not be this dag.
if ( ( pTargetDag == NULL ) || ( pTargetDag == this ) )
{
Assert( pTargetDag );
return;
}
// Find the film clip for this dag and the target dag node and make sure they are the same
CDmeFilmClip *pFilmClip = FindFilmClipContainingDag( this );
if ( pFilmClip == NULL )
{
pFilmClip = FindReferringElement< CDmeFilmClip >( this, "camera" );
}
// Find the channels which must be updated in order to evaluate
// transforms of both this dag node and the target dag node.
CUtlVector< CDmeChannel* > localChannelList, targetChannelList;
CUtlVector< CDmeOperator* > localOperatorList, targetOperatorList;
FindRelevantOperators( localChannelList, localOperatorList );
pTargetDag->FindRelevantOperators( targetChannelList, targetOperatorList );
// Build the clip stacks for the channel lists.
CUtlVector< DmeClipStack_t > localClipStackList, targetClipStackList;
CUtlVector< DmeTime_t > localChannelTimeList, targetChannelTimeList;
BuildClipStackList( localChannelList, localClipStackList, localChannelTimeList, pMovie, pFilmClip );
BuildClipStackList( targetChannelList, targetClipStackList, targetChannelTimeList, pMovie, pFilmClip );
// Construct the offset transform matrix which will be used to maintain the relative
// offset and orientation of the current dag to the target dag at the current time
CDmeTransform *pTransform = GetTransform();
matrix3x4_t targetMat;
matrix3x4_t invTargetMat;
pTargetDag->GetAbsTransform( targetMat );
MatrixInvert( targetMat, invTargetMat );
matrix3x4_t orginalTransform;
if ( bMaintainOffset )
{
GetAbsTransform( orginalTransform );
}
else
{
Vector basePosition;
Vector offsetPosition;
MatrixPosition( targetMat, basePosition );
offsetPosition = basePosition + offset;
orginalTransform = targetMat;
PositionMatrix( offsetPosition, orginalTransform );
}
matrix3x4_t offsetTransform;
ConcatTransforms( invTargetMat, orginalTransform, offsetTransform );
// Find the position and orientation channels associated with the transform
CDmeChannel *pLocalPosChannel = bPosition ? FindChannelTargetingElement( pFilmClip, pTransform, "position", NULL ) : NULL;
CDmeChannel *pLocalRotChannel = bOrientation ? FindChannelTargetingElement( pFilmClip, pTransform, "orientation", NULL ) : NULL;
if ( pLocalPosChannel || pLocalRotChannel )
{
// Start a new undo group for the operation
g_pDataModel->StartUndo( "Attach Transform", "Attach Transform" );
CDmeLog *pPosLog = ( pLocalPosChannel != NULL ) ? pLocalPosChannel->GetLog() : NULL;
CDmeLog *pRotLog = ( pLocalRotChannel != NULL ) ? pLocalRotChannel->GetLog() : NULL;
CDmeChannelsClip *pPosChannelsClip = ( pLocalPosChannel != NULL ) ? FindAncestorReferencingElement< CDmeChannelsClip >( pLocalPosChannel ) : NULL;
CDmeChannelsClip *pRotChannelsClip = ( pLocalRotChannel != NULL ) ? FindAncestorReferencingElement< CDmeChannelsClip >( pLocalRotChannel ) : NULL;
CDmeChannelsClip *pChannelsClip = ( pPosChannelsClip != NULL ) ? pPosChannelsClip : pRotChannelsClip;
Assert( pPosChannelsClip == pRotChannelsClip || pPosChannelsClip == NULL || pRotChannelsClip == NULL );
Assert( pPosLog != pRotLog );
Assert( pChannelsClip );
if ( pChannelsClip )
{
// Construct the clip stack from the movie down to the channels clip containing the channel
DmeClipStack_t clipStack;
if ( pPosChannelsClip )
{
pPosChannelsClip->BuildClipStack( &clipStack, pMovie, pFilmClip );
}
else
{
pRotChannelsClip->BuildClipStack( &clipStack, pMovie, pFilmClip );
}
// Add a new layer to the active logs, the new layer will contain the values
// required to position and orient the transform relative to the target.
CDmeLogLayer *pPosLayer = ( pPosLog != NULL ) ? pPosLog->AddNewLayer() : NULL;
CDmeLogLayer *pRotLayer = ( pRotLog != NULL ) ? pRotLog->AddNewLayer() : NULL;
CDmeTypedLogLayer< Vector > *pVectorLayer = CastElement< CDmeTypedLogLayer< Vector > >( pPosLayer );
CDmeTypedLogLayer< Quaternion > *pQuatLayer = CastElement< CDmeTypedLogLayer< Quaternion > >( pRotLayer );
// Iterate through the time selection based on the resample interval
// and generate keys in the active logs at each time time step.
DmeTime_t time = timeSelection.m_nTimes[ 0 ];
DmeTime_t endTime = timeSelection.m_nTimes[ 3 ];
bool done = false;
// Disable the undo, the only thing that is actually
// needed is the add new layer and the flatten layers.
CDisableUndoScopeGuard undosg;
while ( !done )
{
// Make sure the time does not pass the end of the time selection and set the
// done flag if it has. By setting the flag instead of breaking immediately we
// are guaranteed a sample will be made at the very end of the time selection.
if ( time >= endTime )
{
time = endTime;
done = true;
}
// Evaluate all of the channels relevant to the target dag and the local dag at the
// specified time so that the transform evaluations will correspond to the correct time.
PlayChannelsAtTime( time, targetChannelList, targetOperatorList, targetClipStackList );
PlayChannelsAtTime( time, localChannelList, localOperatorList, localClipStackList );
// Get the world space transform of the target
matrix3x4_t targetTransform;
pTargetDag->GetAbsTransform( targetTransform );
// Apply the offset transform to the target transform and make the
// result the world space transform of the current dag node.
matrix3x4_t finalTransform;
ConcatTransforms( targetTransform, offsetTransform, finalTransform );
SetAbsTransform( finalTransform );
// Calculate the time relative to the log
DmeTime_t logTime = clipStack.ToChildMediaTime( time );
// Add the position of the transform to the position log of the dag node's transform
if ( pVectorLayer )
{
Vector position = pTransform->GetPosition();
pVectorLayer->SetKey( logTime, position, SEGMENT_INTERPOLATE, CURVE_DEFAULT, false );
}
// Add the orientation of the transform to the orientation log of the dag node's transform
if ( pQuatLayer )
{
Quaternion rotation = pTransform->GetOrientation();
pQuatLayer->SetKey( logTime, rotation, SEGMENT_INTERPOLATE, CURVE_DEFAULT, false );
}
// Move the evaluation time up by the resample interval
time += timeSelection.m_nResampleInterval;
}
// Convert the time selection into the local time space of the log.
DmeLog_TimeSelection_t logTimeSelection = timeSelection;
clipStack.ToChildMediaTime( logTimeSelection.m_nTimes );
// Blend the top level log layers contain the new position and orientation with the base log
// layer according to the time selection parameters and then flatten the log layers.
if ( pPosLog )
{
pPosLog->BlendLayersUsingTimeSelection( logTimeSelection );
CEnableUndoScopeGuard undosg;
pPosLog->FlattenLayers( timeSelection.m_flThreshold, 0 );
}
if ( pRotLog )
{
pRotLog->BlendLayersUsingTimeSelection( logTimeSelection );
CEnableUndoScopeGuard undosg;
pRotLog->FlattenLayers( timeSelection.m_flThreshold, 0 );
}
// Restore all of the channels to the original times so that this operation does not have side effects.
PlayChannelsAtLocalTimes( targetChannelTimeList, targetChannelList, targetOperatorList );
PlayChannelsAtLocalTimes( localChannelTimeList, localChannelList, localOperatorList );
}
g_pDataModel->FinishUndo();
}
}
//-----------------------------------------------------------------------------
// Compute the absolute and the local transform of the dag node at the
// specified global time.
//-----------------------------------------------------------------------------
void CDmeDag::ComputeTransformAtTime( DmeTime_t globalTime, const CDmeClip* pMovie, matrix3x4_t &matAbsTransform, matrix3x4_t &localTransform )
{
// This operation should have no side effects and
// no entries should be added to the undo stack.
CDisableUndoScopeGuard disableUndoSG;
// Find the film clip containing this dag
CDmeFilmClip *pFilmClip = FindFilmClipContainingDag( this );
if ( pFilmClip == NULL )
{
pFilmClip = FindReferringElement< CDmeFilmClip >( this, "camera" );
}
// Get the transform associated with the dag
CDmeTransform *pTransform = GetTransform();
if ( ( pMovie == NULL ) || ( pFilmClip == NULL ) || ( pTransform == NULL ) )
return;
// Build a list of channels and other operators which must be
// evaluated in order to evaluate the transform of this dag node.
CUtlVector< CDmeChannel* > channelList;
CUtlVector< CDmeOperator* > operatorList;
CUtlVector< DmeClipStack_t > clipStackList;
CUtlVector< DmeTime_t > channelTimeList;
FindRelevantOperators( channelList, operatorList );
BuildClipStackList( channelList, clipStackList, channelTimeList, pMovie, pFilmClip );
// Evaluate the channels and operators relevant to the dag at the specified time
PlayChannelsAtTime( globalTime, channelList, operatorList, clipStackList );
// Get the absolute world transform and the local transform
GetAbsTransform( matAbsTransform );
pTransform->GetTransform( localTransform );
// Restore all of the channels to the original times so that this operation does not have side effects.
PlayChannelsAtLocalTimes( channelTimeList, channelList, operatorList );
}
//-----------------------------------------------------------------------------
// Move the the dag node to the position of the specified node at the current
// time, for the rest of the time selection apply the same world space offset
// that was required to move the dag to the target position at the current time.
//-----------------------------------------------------------------------------
void CDmeDag::MoveToTarget( const CDmeDag *pTargetDag, const DmeLog_TimeSelection_t &timeSelection, const CDmeClip *pMovie )
{
// Must specify a target dag and it must not be this dag.
if ( ( pTargetDag == NULL ) || ( pTargetDag == this ) )
{
Assert( pTargetDag );
return;
}
// Find the film clip for the dag
CDmeFilmClip *pFilmClip = FindFilmClipContainingDag( this );
if ( pFilmClip == NULL )
{
pFilmClip = FindReferringElement< CDmeFilmClip >( this, "camera" );
}
// Find the channels which must be updated in order to evaluate transforms of both this dag node.
CUtlVector< CDmeChannel* > channelList;
CUtlVector< CDmeOperator* > operatorList;
FindRelevantOperators( channelList,operatorList );
// Build the clip stacks for the channel lists.
CUtlVector< DmeClipStack_t > clipStackList;
CUtlVector< DmeTime_t > channelTimeList;
BuildClipStackList( channelList, clipStackList, channelTimeList, pMovie, pFilmClip );
// Compute the world space offset between the dag node and the target
Vector vWorldPos, vTargetPos;
GetAbsPosition( vWorldPos );
pTargetDag->GetAbsPosition( vTargetPos );
Vector vOffset = vTargetPos - vWorldPos;
// Find the position channel of driving the dag node which will be updated.
CDmeTransform *pTransform = GetTransform();
CDmeChannel *pLocalPosChannel = FindChannelTargetingElement( pFilmClip, pTransform, "position", NULL );
if ( pLocalPosChannel != NULL )
{
// Start a new undo group for the operation
g_pDataModel->StartUndo( "Move dag to target", "Move dag to target" );
CDmeLog *pPosLog = ( pLocalPosChannel != NULL ) ? pLocalPosChannel->GetLog() : NULL;
CDmeChannelsClip *pChannelsClip = FindAncestorReferencingElement< CDmeChannelsClip >( pLocalPosChannel );
Assert( pChannelsClip );
if ( pChannelsClip && pPosLog )
{
// Construct the clip stack from the movie down to the channels clip containing the channel
DmeClipStack_t clipStack;
pChannelsClip->BuildClipStack( &clipStack, pMovie, pFilmClip );
// Add a new layer to the active logs, the new layer will contain the values
// required to position and orient the transform relative to the target.
CDmeLogLayer *pPosLayer = pPosLog->AddNewLayer();
CDmeTypedLogLayer< Vector > *pVectorLayer = CastElement< CDmeTypedLogLayer< Vector > >( pPosLayer );
// Iterate through the time selection based on the resample interval
// and generate keys in the active logs at each time time step.
DmeTime_t time = timeSelection.m_nTimes[ 0 ];
DmeTime_t endTime = timeSelection.m_nTimes[ 3 ];
bool done = false;
// Disable the undo, the only thing that is actually
// needed is the add new layer and the flatten layers.
CDisableUndoScopeGuard undosg;
int nAproxNumTimes = ( ( endTime - time ) / timeSelection.m_nResampleInterval ) + 2;
CUtlVector< Vector > samplePositions( 0, nAproxNumTimes );
CUtlVector< DmeTime_t > sampleTimes( 0, nAproxNumTimes );
while ( !done )
{
// Make sure the time does not pass the end of the time selection and set the
// done flag if it has. By setting the flag instead of breaking immediately we
// are guaranteed a sample will be made at the very end of the time selection.
if ( time >= endTime )
{
time = endTime;
done = true;
}
// Evaluate all of the channels relevant to the target dag and the local dag at the
// specified time so that the transform evaluations will correspond to the correct time.
PlayChannelsAtTime( time, channelList, operatorList, clipStackList );
// Get the current world space position of the node
Vector vOriginalWorldPos;
GetAbsPosition( vOriginalWorldPos );
Vector vNewWorldPos = vOriginalWorldPos + vOffset;
SetAbsPosition( vNewWorldPos );
Vector vLocalPosition = pTransform->GetPosition();
// Store the sample time and the local position
samplePositions.AddToTail( vLocalPosition );
sampleTimes.AddToTail( time );
// Move the evaluation time up by the resample interval
time += timeSelection.m_nResampleInterval;
}
// Iterate through all of the samples and construct
int nNumSamples = sampleTimes.Count();
for ( int i = 0; i < nNumSamples; ++i )
{
// Calculate the time relative to the log
DmeTime_t logTime = clipStack.ToChildMediaTime( sampleTimes[ i ] );
// Add the position of the transform to the position log of the dag node's transform
if ( pVectorLayer )
{
Vector vLocalPosition = samplePositions[ i ];
pVectorLayer->SetKey( logTime, vLocalPosition, SEGMENT_INTERPOLATE, CURVE_DEFAULT, false );
}
}
// Convert the time selection into the local time space of the log.
DmeLog_TimeSelection_t logTimeSelection = timeSelection;
clipStack.ToChildMediaTime( logTimeSelection.m_nTimes );
// Blend the top level log layers contain the new position and orientation with the base log
// layer according to the time selection parameters and then flatten the log layers.
pPosLog->BlendLayersUsingTimeSelection( logTimeSelection );
{
CEnableUndoScopeGuard undosg;
pPosLog->FlattenLayers( timeSelection.m_flThreshold, 0 );
}
// Restore all of the channels to the original times so that this operation does not have side effects.
PlayChannelsAtLocalTimes( channelTimeList, channelList, operatorList );
}
g_pDataModel->FinishUndo();
}
}
void CDmeDag::GetAbsTransform( matrix3x4_t &matAbsTransform ) const
{
matrix3x4_t parentToWorld;
GetParentWorldMatrix( parentToWorld );
matrix3x4_t localMatrix;
GetLocalMatrix( localMatrix );
ConcatTransforms( parentToWorld, localMatrix, matAbsTransform );
}
void CDmeDag::SetAbsTransform( const matrix3x4_t &matAbsTransform )
{
CDmeTransform *pTransform = GetTransform();
if ( pTransform == NULL )
return;
matrix3x4_t parentToWorld;
GetParentWorldMatrix( parentToWorld );
matrix3x4_t worldToParent;
MatrixInvert( parentToWorld, worldToParent );
matrix3x4_t localSpace;
ConcatTransforms( worldToParent, matAbsTransform, localSpace );
Vector localPos;
Quaternion localRot;
MatrixAngles( localSpace, localRot, localPos );
// The position only override depends on the local transform when calculating the parent transform,
// meaning that simply inverting the parent to world matrix and concatenating it with the desired
// absolute transform does not produce the correct local matrix since changing the local matrix
// changes the result of GetParentWorldMatrix(). So when the position only override is enabled we
// must compute the rotation and position separately.
if ( HasOverrideParent() )
{
matrix3x4_t mTranslationParentToWorld;
GetTranslationParentWorldMatrix( mTranslationParentToWorld );
matrix3x4_t mTranslationWorldToParent;
MatrixInvert( mTranslationParentToWorld, mTranslationWorldToParent );
matrix3x4_t mTranslationLocalSpace;
ConcatTransforms( mTranslationWorldToParent, matAbsTransform, mTranslationLocalSpace );
MatrixPosition( mTranslationLocalSpace, localPos);
}
pTransform->SetPosition( localPos );
pTransform->SetOrientation( localRot );
}
CDmeDag *CDmeDag::GetParent() const
{
const static CUtlSymbolLarge symChildren = g_pDataModel->GetSymbol( "children" );
CDmeDag *pParent = FindReferringElement< CDmeDag >( this, symChildren, false );
return pParent;
}
//-----------------------------------------------------------------------------
// Determine if the dag has an override parent
//-----------------------------------------------------------------------------
bool CDmeDag::HasOverrideParent() const
{
if ( m_bDisableOverrideParent )
return false;
return ( GetValueElement< CDmeDag >( OVERRIDE_PARENT ) != NULL );
}
//-----------------------------------------------------------------------------
// Get the current override parent, returns NULL if no override parent is set
//-----------------------------------------------------------------------------
const CDmeDag *CDmeDag::GetOverrideParent( bool bIgnoreEnable ) const
{
if ( m_bDisableOverrideParent && !bIgnoreEnable )
return NULL;
return GetValueElement< CDmeDag >( OVERRIDE_PARENT );
}
//-----------------------------------------------------------------------------
// Get the current override parent, returns NULL if no override parent is set
//-----------------------------------------------------------------------------
const CDmeDag *CDmeDag::GetOverrideParent( bool &bPosition, bool &bRotation, bool bIgnoreEnable ) const
{
bPosition = false;
bRotation = false;
if ( m_bDisableOverrideParent && !bIgnoreEnable )
return NULL;
CDmeDag *pOverrideParent = GetValueElement< CDmeDag >( OVERRIDE_PARENT );
if ( pOverrideParent )
{
bPosition = GetValue< bool >( "overridePos", false );
bRotation = GetValue< bool >( "overrideRot", false );
}
if ( bPosition || bRotation )
{
return pOverrideParent;
}
return NULL;
}
//-----------------------------------------------------------------------------
// Set the current override parent, if the parameter is NULL the overrider
// parent will be cleared.
//-----------------------------------------------------------------------------
void CDmeDag::SetOverrideParent( const CDmeDag *pParentDag, bool bPosition, bool bRotation )
{
if ( ( pParentDag == NULL ) || ( !bPosition && !bRotation ) )
{
RemoveAttribute( OVERRIDE_PARENT );
RemoveAttribute( "overridePos" );
RemoveAttribute( "overrideRot" );
}
else
{
CDmAttribute *pOverrideAttr = SetValue( OVERRIDE_PARENT, pParentDag );
if ( pOverrideAttr )
{
// Set the never copy flag so that the reference
// will not be walked when deleting an animation set.
pOverrideAttr->AddFlag( FATTRIB_NEVERCOPY );
}
SetValue< bool >( "overridePos", bPosition );
SetValue< bool >( "overrideRot", bRotation );
}
}
//-----------------------------------------------------------------------------
// Set the flag which enables or disables the override parent
//-----------------------------------------------------------------------------
void CDmeDag::EnableOverrideParent( bool bEnable )
{
m_bDisableOverrideParent = !bEnable;
}
//-----------------------------------------------------------------------------
// Determine if the override parent is enabled. This only says if an override
// parent is allowed, not if the dag has an override parent)
//-----------------------------------------------------------------------------
bool CDmeDag::IsOverrideParentEnabled() const
{
return !m_bDisableOverrideParent;
}
//-----------------------------------------------------------------------------
// Determine if this dag node is ancestor of the specified dag
//-----------------------------------------------------------------------------
bool CDmeDag::IsAncestorOfDag( const CDmeDag *pDag ) const
{
if ( pDag == NULL )
return false;
const CDmeDag *pCurrentDag = pDag;
const CDmeDag *pParent = pDag->GetParent();
while ( pParent )
{
if ( pParent == this )
return true;
pCurrentDag = pParent;
pParent = pParent->GetParent();
}
return false;
}
//-----------------------------------------------------------------------------
// Purpose: Find the dag node which is the root of the tree the dag node is in.
//-----------------------------------------------------------------------------
CDmeDag *CDmeDag::FindRoot()
{
CDmeDag *pRoot = this;
CDmeDag *pParent = GetParent();
while ( pParent )
{
pRoot = pParent;
pParent = pParent->GetParent();
}
return pRoot;
}
void CDmeDag::GetAbsPosition( Vector &absPos ) const
{
matrix3x4_t abs;
GetAbsTransform( abs );
MatrixGetColumn( abs, 3, absPos );
}
void CDmeDag::SetAbsPosition( const Vector &absPos )
{
matrix3x4_t abs;
GetAbsTransform( abs );
MatrixSetColumn( absPos, 3, abs );
SetAbsTransform( abs );
}
void CDmeDag::GetAbsOrientation( Quaternion &absOrientation ) const
{
matrix3x4_t abs;
GetAbsTransform( abs );
Vector absPos;
MatrixQuaternion( abs, absOrientation );
}
void CDmeDag::SetAbsOrientation( const Quaternion &absOrientation )
{
matrix3x4_t abs;
GetAbsTransform( abs );
Vector absPos;
MatrixGetColumn( abs, 3, absPos );
QuaternionMatrix( absOrientation, absPos, abs );
SetAbsTransform( abs );
}
void RemoveDagFromParents( CDmeDag *pDag, bool bRecursivelyRemoveEmptyDagsFromParents /*= false*/ )
{
DmAttributeReferenceIterator_t hAttr = g_pDataModel->FirstAttributeReferencingElement( pDag->GetHandle() );
for ( ; hAttr != DMATTRIBUTE_REFERENCE_ITERATOR_INVALID; hAttr = g_pDataModel->NextAttributeReferencingElement( hAttr ) )
{
CDmAttribute *pAttr = g_pDataModel->GetAttribute( hAttr );
if ( !pAttr )
continue;
CDmeDag *pParent = CastElement< CDmeDag >( pAttr->GetOwner() );
if ( !pParent )
continue;
pParent->RemoveChild( pDag );
if ( bRecursivelyRemoveEmptyDagsFromParents && pParent->GetChildCount() == 0 )
{
RemoveDagFromParents( pParent );
}
}
}
Reference in New Issue Copy Permalink