You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
3107 lines
111 KiB
3107 lines
111 KiB
//=========== (C) Copyright 1999 Valve, L.L.C. All rights reserved. ===========
|
|
//
|
|
// The copyright to the contents herein is the property of Valve, L.L.C.
|
|
// The contents may be used and/or copied only with the written permission of
|
|
// Valve, L.L.C., or in accordance with the terms and conditions stipulated in
|
|
// the agreement/contract under which the contents have been supplied.
|
|
//
|
|
// $Header: $
|
|
// $NoKeywords: $
|
|
//
|
|
// Converts from any one DMX file format to another
|
|
//
|
|
//=============================================================================
|
|
|
|
#include "dmserializers.h"
|
|
#include "dmserializers/idmserializers.h"
|
|
#include "appframework/iappsystem.h"
|
|
#include "filesystem.h"
|
|
#include "datamodel/idatamodel.h"
|
|
#include "datamodel/dmattributevar.h"
|
|
#include "datamodel/dmelementfactoryhelper.h"
|
|
#include "tier2/tier2.h"
|
|
#include "tier1/timeutils.h"
|
|
#include "tier1/fmtstr.h"
|
|
#include "tier1/utldict.h"
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// format updater macros
|
|
//-----------------------------------------------------------------------------
|
|
typedef bool (*FnUpdater)( CDmElement *pElement );
|
|
|
|
#define IMPLEMENT_UPDATER( n ) \
|
|
bool Update##n##_R( CDmElement **ppElement, bool bParity ) \
|
|
{ \
|
|
return UpdateElement_R( &Update##n, ppElement, bParity ); \
|
|
}
|
|
|
|
#define DECLARE_FORMAT_UPDATER( _name, _description, _extension, _encoding, _updaters ) \
|
|
class CDmFormatUpdater_ ## _name : public IDmFormatUpdater \
|
|
{ \
|
|
public: \
|
|
CDmFormatUpdater_ ## _name() {} \
|
|
virtual const char *GetName() const { return #_name; } \
|
|
virtual const char *GetDescription() const { return _description; } \
|
|
virtual const char *GetExtension() const { return _extension; } \
|
|
virtual const char *GetDefaultEncoding() const { return _encoding; } \
|
|
virtual int GetCurrentVersion() const { return ARRAYSIZE( _updaters ); } \
|
|
virtual bool Update( CDmElement **ppRoot, int nSourceVersion ) \
|
|
{ \
|
|
if ( !ppRoot || !*ppRoot ) \
|
|
return false; \
|
|
if ( nSourceVersion > GetCurrentVersion() ) \
|
|
return false; \
|
|
int nUpdater = MAX( 0, nSourceVersion - 1 ); \
|
|
bool bParity = true; \
|
|
while ( _updaters[ nUpdater ] ) \
|
|
{ \
|
|
if ( !_updaters[ nUpdater ]( ppRoot, bParity ) ) \
|
|
return false; \
|
|
bParity = !bParity; \
|
|
++nUpdater; \
|
|
} \
|
|
return true; \
|
|
} \
|
|
}; \
|
|
static CDmFormatUpdater_ ## _name s_FormatUpdater ## _name;
|
|
|
|
#define INSTALL_FORMAT_UPDATER( _name ) g_pDataModel->AddFormatUpdater( &s_FormatUpdater ## _name )
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// updater helper functions
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void ChangeAttributeType( CDmElement *pElement, const char *pAttrName, DmAttributeType_t type )
|
|
{
|
|
CDmAttribute *pAttr = pElement->GetAttribute( pAttrName );
|
|
Assert( pAttr );
|
|
if ( !pAttr )
|
|
return;
|
|
|
|
pAttr->ChangeType_UNSAFE( type );
|
|
}
|
|
|
|
CDmElement *FindElementNamed( CDmrElementArray<> elements, const char *pTargetName )
|
|
{
|
|
int nElements = elements.Count();
|
|
for ( int i = 0; i < nElements; ++i )
|
|
{
|
|
CDmElement *pElement = elements[ i ];
|
|
if ( pElement && !V_strcmp( pTargetName, pElement->GetName() ) )
|
|
return pElement;
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
CDmElement *FindChannelsClipForChannel( CDmElement *pFilmClip, CDmElement *pChannel )
|
|
{
|
|
const static CUtlSymbolLarge channelsClipSym = g_pDataModel->GetSymbol( "DmeChannelsClip" );
|
|
const static CUtlSymbolLarge channelsSym = g_pDataModel->GetSymbol( "channels" );
|
|
DmAttributeReferenceIterator_t i = g_pDataModel->FirstAttributeReferencingElement( pChannel->GetHandle() );
|
|
while ( i != DMATTRIBUTE_REFERENCE_ITERATOR_INVALID )
|
|
{
|
|
CDmAttribute *pAttribute = g_pDataModel->GetAttribute( i );
|
|
CDmElement *pParent = pAttribute->GetOwner();
|
|
if ( pParent && pParent->GetType() == channelsClipSym && pAttribute->GetNameSymbol() == channelsSym )
|
|
{
|
|
CUtlVector< ElementPathItem_t > path;
|
|
if ( pParent->FindReferer( pFilmClip->GetHandle(), path, TD_ALL ) ) // NOTE - with non-typed elements, TD_SHALLOW == TD_NONE and TD_DEEP == TD_ALL
|
|
return pParent;
|
|
}
|
|
|
|
i = g_pDataModel->NextAttributeReferencingElement( i );
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
CDmElement *FindChannelTargettingElement( CDmElement *pTarget, const char *pTargetAttr, bool bFromTarget )
|
|
{
|
|
const static CUtlSymbolLarge channelSym = g_pDataModel->GetSymbol( "DmeChannel" );
|
|
const static CUtlSymbolLarge fromElementSym = g_pDataModel->GetSymbol( bFromTarget ? "fromElement" : "toElement" );
|
|
DmAttributeReferenceIterator_t i = g_pDataModel->FirstAttributeReferencingElement( pTarget->GetHandle() );
|
|
for( ; i != DMATTRIBUTE_REFERENCE_ITERATOR_INVALID; i = g_pDataModel->NextAttributeReferencingElement( i ) )
|
|
{
|
|
CDmAttribute *pAttribute = g_pDataModel->GetAttribute( i );
|
|
if ( pAttribute->GetNameSymbol() != fromElementSym )
|
|
continue;
|
|
|
|
CDmElement *pParent = pAttribute->GetOwner();
|
|
if ( !pParent || pParent->GetType() != channelSym )
|
|
continue;
|
|
|
|
if ( !V_strcmp( pParent->GetValueString( bFromTarget ? "fromAttribute" : "toAttribute" ), pTargetAttr ) )
|
|
return pParent;
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
CDmElement *GetLogLayerFromChannel( CDmElement *pChannel )
|
|
{
|
|
CDmElement *pLog = pChannel->GetValueElement< CDmElement >( "log" );
|
|
if ( !pLog )
|
|
return NULL;
|
|
|
|
const CUtlVector< DmElementHandle_t > &layers = pLog->GetValue< CUtlVector< DmElementHandle_t > >( "layers" );
|
|
if ( layers.Count() != 1 )
|
|
return NULL;
|
|
|
|
return g_pDataModel->GetElement( layers[ 0 ] );
|
|
}
|
|
|
|
void ConcatTransforms( Quaternion qParent, Vector vParent, Quaternion qLocal, Vector vLocal, Quaternion &qFinal, Vector &vFinal )
|
|
{
|
|
matrix3x4_t mLocal, mParent, mFinal;
|
|
QuaternionMatrix( qLocal, vLocal, mLocal );
|
|
QuaternionMatrix( qParent, vParent, mParent );
|
|
ConcatTransforms( mParent, mLocal, mFinal );
|
|
MatrixQuaternion( mFinal, qFinal );
|
|
MatrixPosition( mFinal, vFinal );
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// format updater functions
|
|
//-----------------------------------------------------------------------------
|
|
|
|
// IMPORTANT: all elements created during update MUST have their parity set to the parity of the current updater
|
|
// otherwise, they (and their children) won't be traversed during the next updater
|
|
|
|
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Update19 -- Removal of Control display sets. Removes all control display
|
|
// sets from animation sets and removes references to display sets from all
|
|
// controls. Also updates rigs to have hidden control groups instead of
|
|
// display sets.
|
|
//-----------------------------------------------------------------------------
|
|
void FixupRigGroups( CDmElement *pRig );
|
|
|
|
bool Update19( CDmElement *pElement )
|
|
{
|
|
const static CUtlSymbolLarge symDmeControlDisplaySet = g_pDataModel->GetSymbol( "DmeControlDisplaySet" );
|
|
const static CUtlSymbolLarge symDmeAnimationSet = g_pDataModel->GetSymbol( "DmeAnimationSet" );
|
|
const static CUtlSymbolLarge symDmeRig = g_pDataModel->GetSymbol( "DmeRig" );
|
|
const static CUtlSymbolLarge symDisplaySetAttr = g_pDataModel->GetSymbol( "displaySet" );
|
|
|
|
if ( pElement->GetType() == symDmeControlDisplaySet )
|
|
{
|
|
// This case shouldn't actually happen all paths which refer to display
|
|
// sets should be removed before the display set can actually be reached.
|
|
DestroyElement( pElement );
|
|
}
|
|
else if ( pElement->GetType() == symDmeAnimationSet )
|
|
{
|
|
pElement->RemoveAttribute( "displaySets" );
|
|
}
|
|
else if ( pElement->GetType() == symDmeRig )
|
|
{
|
|
if ( pElement->HasAttribute( "displaySetElements" ) )
|
|
{
|
|
FixupRigGroups( pElement );
|
|
pElement->RemoveAttribute( "displaySetElements" );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
pElement->RemoveAttribute( "displaySet" );
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
CDmElement *FindChildControlGroup( CDmElement *pGroup, const char *pName, bool bRecursive )
|
|
{
|
|
CDmAttribute *pChildrenAttr = pGroup->GetAttribute( "children", AT_ELEMENT_ARRAY );
|
|
if ( pChildrenAttr == NULL )
|
|
return NULL;
|
|
|
|
CDmrElementArray< CDmElement > children( pChildrenAttr );
|
|
int nNumChildren = children.Count();
|
|
|
|
for ( int iChild = 0; iChild < nNumChildren; ++iChild )
|
|
{
|
|
CDmElement *pChild = children[ iChild ];
|
|
if ( pChild )
|
|
{
|
|
if ( V_stricmp( pChild->GetName(), pName ) == 0 )
|
|
return pChild;
|
|
|
|
if ( bRecursive )
|
|
{
|
|
FindChildControlGroup( pChild, pName, true );
|
|
}
|
|
}
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
|
|
CDmElement *FindOrCreateControlGroup( CDmElement *pRig, CDmElement *pParentGroup, const char *pGroupName )
|
|
{
|
|
CDmElement *pGroup = FindChildControlGroup( pParentGroup, pGroupName, true );
|
|
|
|
if ( pGroup == NULL )
|
|
{
|
|
pGroup = CreateElement< CDmElement >( "DmeControlGroup", pGroupName, pParentGroup->GetFileId() );
|
|
pGroup->SetParity( pRig->GetParity() );
|
|
|
|
// Add the new group to the parent
|
|
CDmAttribute *pChildrenAttr = pParentGroup->GetAttribute( "children", AT_ELEMENT_ARRAY );
|
|
if ( pChildrenAttr )
|
|
{
|
|
CDmrElementArray< CDmElement > children( pChildrenAttr );
|
|
children.AddToTail( pGroup );
|
|
}
|
|
}
|
|
|
|
return pGroup;
|
|
}
|
|
|
|
void ReParentCongrolGroup( CDmElement *pControlGroup, CDmElement *pNewParent )
|
|
{
|
|
const static CUtlSymbolLarge symChildren = g_pDataModel->GetSymbol( "children" );
|
|
|
|
if ( ( pControlGroup == NULL ) || ( pNewParent == NULL ) )
|
|
return;
|
|
|
|
// Find the current parent of the control group
|
|
CDmElement *pCurrentParent = FindReferringElement< CDmElement >( pControlGroup, symChildren );
|
|
if ( pCurrentParent == pNewParent )
|
|
return;
|
|
|
|
// Add the group to the children of the new parent
|
|
CDmAttribute *pNewChildrenAttr = pNewParent->GetAttribute( "children", AT_ELEMENT_ARRAY );
|
|
if ( pNewChildrenAttr == NULL )
|
|
{
|
|
pNewChildrenAttr = pNewParent->AddAttributeElementArray< CDmElement >( "children" );
|
|
}
|
|
|
|
CDmrElementArray< CDmElement > newChildren( pNewChildrenAttr );
|
|
newChildren.AddToTail( pControlGroup );
|
|
|
|
// Remove the group from the children of the old parent
|
|
if ( pCurrentParent )
|
|
{
|
|
CDmAttribute *pOldChildrenAttr = pCurrentParent->GetAttribute( "children", AT_ELEMENT_ARRAY );
|
|
if ( pOldChildrenAttr )
|
|
{
|
|
CDmrElementArray< CDmElement > oldChildren( pOldChildrenAttr );
|
|
int nIndex = oldChildren.Find( pControlGroup );
|
|
oldChildren.Remove( nIndex );
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
bool IsControlGroupEmpty( CDmElement *pControlGroup )
|
|
{
|
|
CDmAttribute *pControlsAttr = pControlGroup->GetAttribute( "controls" );
|
|
if ( pControlsAttr )
|
|
{
|
|
CDmrElementArray< CDmElement > controls( pControlsAttr );
|
|
if ( controls.Count() > 0 )
|
|
return false;
|
|
}
|
|
|
|
CDmAttribute *pChildrenAttr = pControlGroup->GetAttribute( "children", AT_ELEMENT_ARRAY );
|
|
if ( pChildrenAttr )
|
|
{
|
|
CDmrElementArray< CDmElement > children( pChildrenAttr );
|
|
int nNumChildren = children.Count();
|
|
for ( int iChild = 0; iChild < nNumChildren; ++iChild )
|
|
{
|
|
CDmElement *pChild = children[ iChild ];
|
|
if ( pChild )
|
|
{
|
|
if ( IsControlGroupEmpty( pChild ) == false )
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
void SetControlGroupState( CDmElement *pRootControlGroup, const char *pGroupName, bool bVisible, bool bSnappable )
|
|
{
|
|
CDmElement *pControlGroup = FindChildControlGroup( pRootControlGroup, pGroupName, true );
|
|
if ( pControlGroup == NULL )
|
|
return;
|
|
|
|
pControlGroup->SetValue< bool >( "visible", bVisible, true );
|
|
pControlGroup->SetValue< bool >( "snappable", bSnappable, true );
|
|
}
|
|
|
|
void MoveRigControlsToGroup( CDmElement *pRig, CDmElement *pAnimSetElements, CDmElement *pRootGroup, const char *pSrcGroupName, const char *pDstGroupName, bool bTransformOnly )
|
|
{
|
|
const static CUtlSymbolLarge symDmeTransformControl = g_pDataModel->GetSymbol( "DmeTransformControl" );
|
|
const static CUtlSymbolLarge symElementList = g_pDataModel->GetSymbol( "elementList" );
|
|
|
|
// First find the specified source control group
|
|
CDmElement *pSrcGroup = pRootGroup;
|
|
if ( pSrcGroupName )
|
|
{
|
|
pSrcGroup = FindChildControlGroup( pRootGroup, pSrcGroupName, true );
|
|
}
|
|
if ( pSrcGroup == NULL )
|
|
return;
|
|
|
|
// Iterate through the controls in the source control group,
|
|
// if they are rig elements add them to the destination group.
|
|
CDmAttribute *pControlsAttr = pSrcGroup->GetAttribute( "controls", AT_ELEMENT_ARRAY );
|
|
if ( pControlsAttr == NULL )
|
|
return;
|
|
|
|
CDmrElementArray< CDmElement > controls( pControlsAttr );
|
|
int nNumControls = controls.Count();
|
|
|
|
CDmElement *pDstGroup = NULL;
|
|
CDmAttribute *pDstControlsAttr = NULL;
|
|
|
|
for ( int iControl = 0; iControl < nNumControls; ++iControl )
|
|
{
|
|
CDmElement *pControl = controls[ iControl ];
|
|
if ( pControl == NULL )
|
|
continue;
|
|
|
|
if ( bTransformOnly && ( pControl->GetType() != symDmeTransformControl ) )
|
|
continue;
|
|
|
|
CUtlVector< CDmElement* > referringElements( 0, 4 );
|
|
FindReferringElements( referringElements, pControl, symElementList );
|
|
if ( referringElements.Find( pAnimSetElements ) != referringElements.InvalidIndex() )
|
|
{
|
|
if ( pDstGroup == NULL )
|
|
{
|
|
pDstGroup = FindOrCreateControlGroup( pRig, pRootGroup, pDstGroupName );
|
|
}
|
|
|
|
if ( pDstControlsAttr == NULL )
|
|
{
|
|
pDstControlsAttr = pDstGroup->GetAttribute( "controls", AT_ELEMENT_ARRAY );
|
|
if ( pDstControlsAttr == NULL )
|
|
{
|
|
pDstControlsAttr = pDstGroup->AddAttributeElementArray< CDmElement >( "controls" );
|
|
}
|
|
}
|
|
|
|
CDmrElementArray< CDmElement > dstControls( pDstControlsAttr );
|
|
dstControls.AddToTail( pControl );
|
|
}
|
|
}
|
|
|
|
// Now remove the rig controls from the source group
|
|
if ( pDstControlsAttr != NULL )
|
|
{
|
|
CDmrElementArray< CDmElement > rigControls( pDstControlsAttr );
|
|
int nNumRigControls = rigControls.Count();
|
|
|
|
for ( int iControl = 0; iControl < nNumRigControls; ++iControl )
|
|
{
|
|
CDmElement *pControl = rigControls[ iControl ];
|
|
int nIndex = controls.Find( pControl );
|
|
if ( nIndex != controls.InvalidIndex() )
|
|
{
|
|
controls.Remove( nIndex );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void RemoveInvalidTransformControls( CDmElement *pAnimSet )
|
|
{
|
|
const static CUtlSymbolLarge symDmeTransformControl = g_pDataModel->GetSymbol( "DmeTransformControl" );
|
|
const static CUtlSymbolLarge symControls = g_pDataModel->GetSymbol( "controls" );
|
|
|
|
CDmAttribute *pControlsAttr = pAnimSet->GetAttribute( "controls", AT_ELEMENT_ARRAY );
|
|
if ( pControlsAttr == NULL )
|
|
return;
|
|
|
|
CDmrElementArray< CDmElement > controls( pControlsAttr );
|
|
int nNumControls = controls.Count();
|
|
|
|
CUtlVector< CDmElement* > invalidControls( 0, nNumControls / 2 );
|
|
for ( int iControl = 0; iControl < nNumControls; ++iControl )
|
|
{
|
|
CDmElement *pControl = controls[ iControl ];
|
|
if ( pControl == NULL )
|
|
continue;
|
|
|
|
if ( pControl->GetType() == symDmeTransformControl )
|
|
{
|
|
CDmElement *pPosChannel = pControl->GetValueElement< CDmElement >( "positionChannel" );
|
|
CDmElement *pRotChannel = pControl->GetValueElement< CDmElement >( "orientationChannel" );
|
|
|
|
if ( ( pPosChannel == NULL ) && ( pRotChannel == NULL ) )
|
|
{
|
|
invalidControls.AddToTail( pControl );
|
|
}
|
|
}
|
|
}
|
|
|
|
int nNumInvalid = invalidControls.Count();
|
|
for ( int iInvalid = 0; iInvalid < nNumInvalid; ++iInvalid )
|
|
{
|
|
CDmElement *pInvalidControl = invalidControls[ iInvalid ];
|
|
if ( pInvalidControl == NULL )
|
|
return;
|
|
|
|
// Remove the control from the animation set
|
|
int nIndex = controls.Find( pInvalidControl );
|
|
if ( nIndex != controls.InvalidIndex() )
|
|
{
|
|
controls.Remove( nIndex );
|
|
}
|
|
|
|
// Remove the control from the control groups
|
|
CUtlVector < CDmElement* > referringElements( 0, 4 );
|
|
FindReferringElements( referringElements, pInvalidControl, symControls );
|
|
int nNumReferringElements = referringElements.Count();
|
|
|
|
for ( int iElement = 0; iElement < nNumReferringElements; ++iElement )
|
|
{
|
|
CDmElement *pElement = referringElements[ iElement ];
|
|
if ( pElement == NULL )
|
|
continue;
|
|
|
|
CDmAttribute *pControlsAttr = pElement->GetAttribute( "controls", AT_ELEMENT_ARRAY );
|
|
if ( pControlsAttr == NULL )
|
|
continue;
|
|
|
|
CDmrElementArray< CDmElement > controls( pControlsAttr );
|
|
nIndex = controls.Find( pInvalidControl );
|
|
if ( nIndex != controls.InvalidIndex() )
|
|
{
|
|
controls.Remove( nIndex );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void FixupRigGroupsForAnimationSet( CDmElement *pRig, CDmElement *pAnimSetElements )
|
|
{
|
|
const static CUtlSymbolLarge symDmeAnimationSet = g_pDataModel->GetSymbol( "DmeAnimationSet" );
|
|
|
|
// Get the animation set
|
|
CDmElement *pAnimSet = pAnimSetElements->GetValueElement< CDmElement >( "animationSet" );
|
|
if ( ( pAnimSet == NULL ) || ( pAnimSet->GetType() != symDmeAnimationSet ) )
|
|
return;
|
|
|
|
// First clean out any invalid controls from the animations set
|
|
RemoveInvalidTransformControls( pAnimSet );
|
|
|
|
|
|
// Get the root control group of the animation set
|
|
CDmElement *pRootControlGroup = pAnimSet->GetValueElement< CDmElement >( "rootControlGroup" );
|
|
if ( pRootControlGroup == NULL )
|
|
return;
|
|
|
|
// Move the rig controls into their own groups
|
|
MoveRigControlsToGroup( pRig, pAnimSetElements, pRootControlGroup, NULL, "RigHelpers", false );
|
|
MoveRigControlsToGroup( pRig, pAnimSetElements, pRootControlGroup, "Body", "RigBody", true );
|
|
MoveRigControlsToGroup( pRig, pAnimSetElements, pRootControlGroup, "Arms", "RigArms", true );
|
|
MoveRigControlsToGroup( pRig, pAnimSetElements, pRootControlGroup, "Legs", "RigLegs", true );
|
|
MoveRigControlsToGroup( pRig, pAnimSetElements, pRootControlGroup, "Root", "RigRoot", true );
|
|
|
|
// Move the fingers into their own groups
|
|
CDmElement *pArmsGroup = FindChildControlGroup( pRootControlGroup, "Arms", true );
|
|
if ( pArmsGroup )
|
|
{
|
|
// Find the fingers group and make sure it is a child of the root and then
|
|
// make sure the left and right fingers groups children of the fingers group.
|
|
CDmElement *pFingers = FindOrCreateControlGroup( pRig, pRootControlGroup, "Fingers" );
|
|
if ( pFingers )
|
|
{
|
|
ReParentCongrolGroup( pFingers, pRootControlGroup );
|
|
|
|
CDmElement *pFingersR = FindChildControlGroup( pArmsGroup, "Fingers_R", false );
|
|
if ( pFingersR )
|
|
{
|
|
pFingersR->SetName( "RightFingers" );
|
|
ReParentCongrolGroup( pFingersR, pFingers );
|
|
}
|
|
|
|
CDmElement *pFingersL = FindChildControlGroup( pArmsGroup, "Fingers_L", false );
|
|
if ( pFingersL )
|
|
{
|
|
pFingersL->SetName( "LeftFingers" );
|
|
ReParentCongrolGroup( pFingersL, pFingers );
|
|
}
|
|
}
|
|
}
|
|
|
|
// Hide the original body groups and rig utility groups
|
|
SetControlGroupState( pRootControlGroup, "Arms", false, true );
|
|
SetControlGroupState( pRootControlGroup, "Legs", false, true );
|
|
SetControlGroupState( pRootControlGroup, "Body", false, true );
|
|
SetControlGroupState( pRootControlGroup, "Root", false, true );
|
|
SetControlGroupState( pRootControlGroup, "Other", false, true );
|
|
SetControlGroupState( pRootControlGroup, "Unknown", false, true );
|
|
SetControlGroupState( pRootControlGroup, "Attachments", false, true );
|
|
SetControlGroupState( pRootControlGroup, "RigHelpers", false, false );
|
|
SetControlGroupState( pRootControlGroup, "RigConstraints", false, false );
|
|
|
|
// Add the body groups to the list of groups hidden by the rig
|
|
CDmAttribute *pHiddenGroupsAttr = pAnimSetElements->GetAttribute( "hiddenGroups", AT_STRING_ARRAY );
|
|
if ( pHiddenGroupsAttr == NULL )
|
|
{
|
|
pHiddenGroupsAttr = pAnimSetElements->AddAttribute( "hiddenGroups", AT_STRING_ARRAY );
|
|
}
|
|
|
|
CDmrStringArray hiddenGroups( pHiddenGroupsAttr );
|
|
hiddenGroups.AddToTail( "Body" );
|
|
hiddenGroups.AddToTail( "Arms" );
|
|
hiddenGroups.AddToTail( "Legs" );
|
|
hiddenGroups.AddToTail( "Root" );
|
|
hiddenGroups.AddToTail( "Other" );
|
|
hiddenGroups.AddToTail( "Unknown" );
|
|
|
|
|
|
// Set the color of all of the top level groups and remove any control groups which are empty
|
|
CDmAttribute *pChildrenAttr = pRootControlGroup->GetAttribute( "children", AT_ELEMENT_ARRAY );
|
|
if ( pChildrenAttr )
|
|
{
|
|
Color topLevelColor( 0, 128, 255, 255 );
|
|
Color controlColor( 200, 200, 200, 255 );
|
|
|
|
CDmrElementArray< CDmElement > children( pChildrenAttr );
|
|
int nChildren = children.Count();
|
|
|
|
CUtlVector< CDmElement* > emptyGroups( 0, nChildren );
|
|
|
|
for ( int iChild = 0; iChild < nChildren; ++iChild )
|
|
{
|
|
CDmElement *pChildGroup = children[ iChild ];
|
|
pChildGroup->SetValue< Color >( "groupColor", topLevelColor );
|
|
pChildGroup->SetValue< Color >( "controlColor", controlColor );
|
|
|
|
// If the child group is empty add it to the list of children to remove
|
|
if ( IsControlGroupEmpty( pChildGroup ) )
|
|
{
|
|
emptyGroups.AddToTail( pChildGroup );
|
|
}
|
|
}
|
|
|
|
// Remove the empty groups
|
|
int nNumEmptyGroups = emptyGroups.Count();
|
|
for ( int iEmptyGroup = 0; iEmptyGroup < nNumEmptyGroups; ++iEmptyGroup )
|
|
{
|
|
CDmElement *pEmptyGroup = emptyGroups[ iEmptyGroup ];
|
|
int nIndex = children.Find( pEmptyGroup );
|
|
if ( nIndex != children.InvalidIndex() )
|
|
{
|
|
children.Remove( nIndex );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void FixupRigGroups( CDmElement *pRig )
|
|
{
|
|
CDmAttribute *pAnimSetListAttr = pRig->GetAttribute( "animSetList", AT_ELEMENT_ARRAY );
|
|
if ( pAnimSetListAttr == NULL )
|
|
return;
|
|
|
|
CDmrElementArray<> animSetList( pAnimSetListAttr );
|
|
|
|
int nNumAnimSets = animSetList.Count();
|
|
for ( int iAnimSet = 0; iAnimSet < nNumAnimSets; ++iAnimSet )
|
|
{
|
|
CDmElement *pAnimSetElements = animSetList[ iAnimSet ];
|
|
if ( pAnimSetElements )
|
|
{
|
|
FixupRigGroupsForAnimationSet( pRig, pAnimSetElements );
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Update18 -- removing procedural presetgroup and presets (now exist only in code, and not as elements)
|
|
//-----------------------------------------------------------------------------
|
|
|
|
bool Update18( CDmElement *pElement )
|
|
{
|
|
const static CUtlSymbolLarge symDmeAnimationSet = g_pDataModel->GetSymbol( "DmeAnimationSet" );
|
|
const static CUtlSymbolLarge symDmePreset = g_pDataModel->GetSymbol( "DmePreset" );
|
|
|
|
if ( pElement->GetType() == symDmeAnimationSet )
|
|
{
|
|
CDmAttribute *pPresetGroupsAttr = pElement->GetAttribute( "presetGroups", AT_ELEMENT_ARRAY );
|
|
if ( pPresetGroupsAttr )
|
|
{
|
|
CDmrElementArray<> presetGroups( pPresetGroupsAttr );
|
|
int nNumPresetGroups = presetGroups.Count();
|
|
for ( int i = nNumPresetGroups - 1; i >= 0; --i )
|
|
{
|
|
if ( CDmElement *pPresetGroup = presetGroups[ i ] )
|
|
{
|
|
if ( V_strcmp( pPresetGroup->GetName(), "procedural" ) != 0 && V_strcmp( pPresetGroup->GetName(), "Procedural" ) != 0 )
|
|
continue;
|
|
}
|
|
|
|
presetGroups.Remove( i );
|
|
}
|
|
}
|
|
}
|
|
else if ( pElement->GetType() == symDmePreset )
|
|
{
|
|
pElement->RemoveAttribute( "procedural" );
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Update17 -- Transform control unification. Separate transform controls for
|
|
// position and orientation are combine in to a single transform control and
|
|
// the control group which previously contained the separate position and
|
|
// orientation controls is removed.
|
|
//-----------------------------------------------------------------------------
|
|
void UnifyTransformControl( CDmElement *pControl, CDmElement *pAnimSet );
|
|
void DestroyControl( CDmElement *pControl );
|
|
CDmElement *CollapseControlGroup( CDmElement *pControlGroup, CDmElement *pRootGroup );
|
|
|
|
bool Update17( CDmElement *pElement )
|
|
{
|
|
const static CUtlSymbolLarge symDmeAnimationSet = g_pDataModel->GetSymbol( "DmeAnimationSet" );
|
|
const static CUtlSymbolLarge symDmePreset = g_pDataModel->GetSymbol( "DmePreset" );
|
|
|
|
// If the element is an animation set iterate through its controls and unify the transform controls.
|
|
// Note that while the transform controls themselves would be visited they may be visited from the
|
|
// animation set or control group containing them, making removing the controls from the animation set
|
|
// or control group problematic since the calling function is in the middle of walking the array that
|
|
// will be modified.
|
|
if ( pElement->GetType() == symDmeAnimationSet )
|
|
{
|
|
CDmAttribute *pControlsAttr = pElement->GetAttribute( "controls", AT_ELEMENT_ARRAY );
|
|
if ( pControlsAttr )
|
|
{
|
|
// Make a copy of the controls list. A copy is must be made
|
|
// since the actual list may be modified during iteration.
|
|
CDmrElementArray<> controls( pControlsAttr );
|
|
int nNumControls = controls.Count();
|
|
|
|
CUtlVector< DmElementHandle_t > controlHandles;
|
|
controlHandles.SetSize( nNumControls );
|
|
for ( int iControl = 0; iControl < nNumControls; ++iControl )
|
|
{
|
|
controlHandles[ iControl ] = controls[ iControl ]->GetHandle();
|
|
}
|
|
|
|
// Iterate through the controls, unifying and of the transform controls which contain only a
|
|
// position or rotation with the corresponding control containing the other component.
|
|
for ( int iControl = 0; iControl < nNumControls; ++iControl )
|
|
{
|
|
CDmElement *pControl = g_pDataModel->GetElement( controlHandles[ iControl ] );
|
|
if ( pControl )
|
|
{
|
|
UnifyTransformControl( pControl, pElement );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else if ( pElement->GetType() == symDmePreset )
|
|
{
|
|
// For presets merge all control value elements that share the same base name
|
|
CDmAttribute *pControlValuesAttr = pElement->GetAttribute( "controlValues", AT_ELEMENT_ARRAY );
|
|
if ( pControlValuesAttr )
|
|
{
|
|
CDmrElementArray<> controlValueElements( pControlValuesAttr );
|
|
int nControlValues = controlValueElements.Count();
|
|
if ( nControlValues > 0 )
|
|
{
|
|
CUtlDict< CDmElement*, int > mergedControls;
|
|
CUtlVector< DmElementHandle_t > validControlValues( 0, nControlValues );
|
|
|
|
for ( int iValue = 0; iValue < nControlValues; ++iValue )
|
|
{
|
|
CDmElement *pControlValue = controlValueElements[ iValue ];
|
|
if ( pControlValue == NULL )
|
|
continue;
|
|
|
|
bool bPos = pControlValue->HasAttribute( "valuePosition" );
|
|
bool bRot = pControlValue->HasAttribute( "valueOrientation" );
|
|
const char *pComponentStart = NULL;
|
|
const char *pName = pControlValue->GetName();
|
|
|
|
// Must have a position or rotation value, but not both
|
|
if ( bPos && !bRot )
|
|
{
|
|
pComponentStart = V_strstr( pName, " - pos" );
|
|
}
|
|
else if ( bRot && !bPos )
|
|
{
|
|
pComponentStart = V_strstr( pName, " - rot" );
|
|
}
|
|
|
|
// If the control value will not be merged,
|
|
// add it to the list of valid control values.
|
|
if ( pComponentStart == NULL )
|
|
{
|
|
validControlValues.AddToTail( pControlValue->GetHandle() );
|
|
continue;
|
|
}
|
|
|
|
// Construct the base name by removing the component extension
|
|
char baseName[ 256 ];
|
|
V_strncpy( baseName, pName, 256 );
|
|
baseName[ pComponentStart - pName ] = 0;
|
|
|
|
// Find or create the new control value
|
|
CDmElement *pNewControlValue = NULL;
|
|
int nIndex = mergedControls.Find( baseName );
|
|
if ( nIndex == mergedControls.InvalidIndex() )
|
|
{
|
|
pNewControlValue = CreateElement< CDmElement >( "DmElement", baseName, pElement->GetFileId() );
|
|
pNewControlValue->SetParity( pElement->GetParity() );
|
|
nIndex = mergedControls.Insert( baseName, pNewControlValue );
|
|
validControlValues.AddToTail( pNewControlValue->GetHandle() );
|
|
}
|
|
else
|
|
{
|
|
pNewControlValue = mergedControls.Element( nIndex );
|
|
}
|
|
|
|
// Copy the value from the old control value element
|
|
if ( pNewControlValue )
|
|
{
|
|
if ( bPos )
|
|
{
|
|
Vector position = pControlValue->GetValue< Vector >( "valuePosition" );
|
|
pNewControlValue->SetValue< Vector >( "valuePosition", position );
|
|
}
|
|
else
|
|
{
|
|
Quaternion orentation = pControlValue->GetValue< Quaternion >( "valueOrientation" );
|
|
pNewControlValue->SetValue< Quaternion >( "valueOrientation", orentation );
|
|
}
|
|
}
|
|
}
|
|
|
|
// Replace the original list of control elements with
|
|
// the list of currently valid control elements.
|
|
controlValueElements = validControlValues;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
void UnifyTransformControl( CDmElement *pTransformControl, CDmElement *pAnimSet )
|
|
{
|
|
const static CUtlSymbolLarge symDmeTransformControl = g_pDataModel->GetSymbol( "DmeTransformControl" );
|
|
const static CUtlSymbolLarge symDmeControlGroup = g_pDataModel->GetSymbol( "DmeControlGroup" );
|
|
const static CUtlSymbolLarge symDmeAnimationSet = g_pDataModel->GetSymbol( "DmeAnimationSet" );
|
|
const static CUtlSymbolLarge symDmeRigAnimSetElements = g_pDataModel->GetSymbol( "DmeRigAnimSetElements" );
|
|
const static CUtlSymbolLarge symDmeRig = g_pDataModel->GetSymbol( "DmeRig" );
|
|
const static CUtlSymbolLarge symControls = g_pDataModel->GetSymbol( "controls" );
|
|
const static CUtlSymbolLarge symElementList = g_pDataModel->GetSymbol( "elementList" );
|
|
const static CUtlSymbolLarge symDisplaySetElements = g_pDataModel->GetSymbol( "displaySetElements" );
|
|
|
|
if ( pTransformControl->GetType() == symDmeTransformControl )
|
|
{
|
|
const char *baseName = pTransformControl->GetValueString( "baseName" );
|
|
|
|
// Find the control group containing the specified control
|
|
CDmElement *pTransformControlGroup = NULL;
|
|
CUtlVector< CDmElement* > controlGroups;
|
|
FindReferringElements( controlGroups, pTransformControl, symControls );
|
|
int nNumGroups = controlGroups.Count();
|
|
for ( int iGroup = 0; iGroup < nNumGroups; ++iGroup )
|
|
{
|
|
CDmElement *pGroup = controlGroups[ iGroup ];
|
|
if ( pGroup->GetType() == symDmeControlGroup )
|
|
{
|
|
pTransformControlGroup = pGroup;
|
|
break;
|
|
}
|
|
}
|
|
|
|
Assert( pTransformControlGroup );
|
|
if ( pTransformControlGroup == NULL )
|
|
return;
|
|
|
|
// Find the position or orientation control that corresponds to the given control
|
|
CDmElement *pPositionControl = NULL;
|
|
CDmElement *pOrientationControl = NULL;
|
|
CDmElement *pPositionChannel = NULL;
|
|
CDmElement *pOrientationChannel = NULL;
|
|
|
|
CDmAttribute *pControlsAttr = pTransformControlGroup->GetAttribute( "controls", AT_ELEMENT_ARRAY );
|
|
if ( pControlsAttr )
|
|
{
|
|
CDmrElementArray<> controlList( pControlsAttr );
|
|
for ( int iControl = 0; iControl < controlList.Count(); ++iControl )
|
|
{
|
|
CDmElement *pControl = controlList[ iControl ];
|
|
if ( pControl->HasAttribute( "position", AT_ELEMENT ) )
|
|
{
|
|
pPositionControl = pControl;
|
|
pPositionChannel = pPositionControl->GetValueElement< CDmElement >( "position" );
|
|
}
|
|
else if ( pControl->HasAttribute( "orientation", AT_ELEMENT ) )
|
|
{
|
|
pOrientationControl = pControl;
|
|
pOrientationChannel = pOrientationControl->GetValueElement< CDmElement >( "orientation" );
|
|
}
|
|
|
|
if ( pPositionControl && pOrientationControl )
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
// Make sure we got the correct element
|
|
if ( ( pPositionControl != pTransformControl ) && ( pOrientationControl != pTransformControl ) )
|
|
return;
|
|
|
|
// Get the position and value controls from the old element
|
|
Vector position = pPositionControl ? pPositionControl->GetValue< Vector >( "valuePosition", vec3_origin ) : vec3_origin;
|
|
Quaternion orientation = pOrientationControl ? pOrientationControl->GetValue< Quaternion >( "valueOrientation", quat_identity ) : quat_identity;
|
|
|
|
|
|
// Create the new transform control
|
|
CDmElement *pNewTransformControl = CreateElement< CDmElement >( "DmeTransformControl", baseName, pTransformControl->GetFileId() );
|
|
pNewTransformControl->SetParity( pTransformControl->GetParity() );
|
|
pNewTransformControl->SetValue( "positionChannel", pPositionChannel );
|
|
pNewTransformControl->SetValue( "orientationChannel", pOrientationChannel );
|
|
pNewTransformControl->SetValue( "valuePosition", position );
|
|
pNewTransformControl->SetValue( "valueOrientation", orientation );
|
|
|
|
if ( pPositionChannel )
|
|
{
|
|
pPositionChannel->SetValue( "fromElement", pNewTransformControl );
|
|
}
|
|
|
|
if ( pOrientationChannel )
|
|
{
|
|
pOrientationChannel->SetValue( "fromElement", pNewTransformControl );
|
|
}
|
|
|
|
|
|
// If the old transform control was in a display set, add the new one to the display set as well
|
|
CDmElement *pDisplaySet = pTransformControl->GetValueElement< CDmElement >( "displaySet" );
|
|
if ( pDisplaySet )
|
|
{
|
|
pNewTransformControl->SetValue( "displaySet", pDisplaySet );
|
|
}
|
|
|
|
// Add the new control to the animation set
|
|
CDmAttribute *pAnimSetControlsAttr = pAnimSet->GetAttribute( "controls", AT_ELEMENT_ARRAY );
|
|
if ( pAnimSetControlsAttr )
|
|
{
|
|
CDmrElementArray<> animSetControls( pAnimSetControlsAttr );
|
|
animSetControls.AddToTail( pNewTransformControl );
|
|
}
|
|
|
|
// If the old transform control was part of a rig, add the new transform control to the rig as well
|
|
CUtlVector< CDmElement * > animSetRigList;
|
|
FindReferringElements( animSetRigList, pTransformControl, symElementList );
|
|
int nNumAnimSetRigs = animSetRigList.Count();
|
|
for ( int iAnimSetRig = 0; iAnimSetRig < nNumAnimSetRigs; ++iAnimSetRig )
|
|
{
|
|
CDmElement *pAnimElements = animSetRigList[ iAnimSetRig ];
|
|
if ( ( pAnimElements != NULL ) && ( pAnimElements->GetType() == symDmeRigAnimSetElements ) &&
|
|
( pAnimElements->GetValueElement< CDmElement >( "animationSet" ) == pAnimSet ) )
|
|
{
|
|
CDmAttribute *pElementsAttr = pAnimElements->GetAttribute( "elementList", AT_ELEMENT_ARRAY );
|
|
if ( pElementsAttr )
|
|
{
|
|
CDmrElementArray<> elementsList( pElementsAttr );
|
|
elementsList.AddToTail( pNewTransformControl );
|
|
}
|
|
}
|
|
}
|
|
|
|
CUtlVector< CDmElement * > rigList;
|
|
FindReferringElements( rigList, pTransformControl, symDisplaySetElements );
|
|
int nNumRigs = rigList.Count();
|
|
for ( int iRig = 0; iRig < nNumRigs; ++iRig )
|
|
{
|
|
CDmElement *pRig = rigList[ iRig ];
|
|
if ( ( pRig != NULL ) && ( pRig->GetType() == symDmeRig ) )
|
|
{
|
|
CDmAttribute *pDisplaySetElementsAttr = pRig->GetAttribute( "displaySetElements", AT_ELEMENT_ARRAY );
|
|
if ( pDisplaySetElementsAttr )
|
|
{
|
|
CDmrElementArray<> displaySetElements( pDisplaySetElementsAttr );
|
|
displaySetElements.AddToTail( pNewTransformControl );
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
// Move all the controls and children from the transform control group up to
|
|
// its parent and remove the the transform control group from its parent.
|
|
CDmElement *pParentControlGroup = pAnimSet->GetValueElement< CDmElement >( "rootControlGroup" );
|
|
if ( pTransformControlGroup )
|
|
{
|
|
pParentControlGroup = CollapseControlGroup( pTransformControlGroup, pParentControlGroup );
|
|
}
|
|
|
|
// Add the new control to parent control group
|
|
if ( pParentControlGroup )
|
|
{
|
|
CDmAttribute *pParentControlsAttr = pParentControlGroup->GetAttribute( "controls", AT_ELEMENT_ARRAY );
|
|
if ( pParentControlsAttr )
|
|
{
|
|
CDmrElementArray<> parentControls( pParentControlsAttr );
|
|
parentControls.AddToTail( pNewTransformControl );
|
|
}
|
|
}
|
|
|
|
// Remove the old controls from all animation sets and
|
|
// control groups they belong to, and then destroy them.
|
|
DestroyControl( pPositionControl );
|
|
DestroyControl( pOrientationControl );
|
|
}
|
|
}
|
|
|
|
|
|
void DestroyControl( CDmElement *pControl )
|
|
{
|
|
const static CUtlSymbolLarge symControls = g_pDataModel->GetSymbol( "controls" );
|
|
const static CUtlSymbolLarge symElementList = g_pDataModel->GetSymbol( "elementList" );
|
|
const static CUtlSymbolLarge symDisplaySetElements = g_pDataModel->GetSymbol( "displaySetElements" );
|
|
|
|
if ( pControl == NULL )
|
|
return;
|
|
|
|
// Remove the control from any animation sets and control groups it belongs to
|
|
CUtlVector< CDmElement* > ownerList;
|
|
FindReferringElements( ownerList, pControl, symControls );
|
|
Assert( ownerList.Count() == 2 );
|
|
|
|
for ( int iElement = 0; iElement < ownerList.Count(); ++iElement )
|
|
{
|
|
CDmElement *pElement = ownerList[ iElement ];
|
|
if ( pElement == NULL )
|
|
continue;
|
|
|
|
CDmAttribute *pControlsAttr = pElement->GetAttribute( "controls", AT_ELEMENT_ARRAY );
|
|
if ( pControlsAttr == NULL )
|
|
continue;
|
|
|
|
CDmrElementArray<> controlList( pControlsAttr );
|
|
int nIndex = controlList.Find( pControl );
|
|
if ( nIndex != controlList.InvalidIndex() )
|
|
{
|
|
controlList.Remove( nIndex );
|
|
}
|
|
}
|
|
|
|
// Remove the control from any rigs it is a part of
|
|
CUtlVector< CDmElement * > animSetRigList;
|
|
FindReferringElements( animSetRigList, pControl, symElementList );
|
|
int nAimSetRigs = animSetRigList.Count();
|
|
for ( int iAnimSetRig = 0; iAnimSetRig < nAimSetRigs; ++iAnimSetRig )
|
|
{
|
|
CDmElement *pElement = animSetRigList[ iAnimSetRig ];
|
|
if ( pElement == NULL )
|
|
continue;
|
|
|
|
CDmAttribute *pElementsAttr = pElement->GetAttribute( "elementList", AT_ELEMENT_ARRAY );
|
|
if ( pElementsAttr == NULL )
|
|
continue;
|
|
|
|
CDmrElementArray<> elementsList( pElementsAttr );
|
|
int nIndex = elementsList.Find( pControl );
|
|
if ( nIndex != elementsList.InvalidIndex() )
|
|
{
|
|
elementsList.Remove( nIndex );
|
|
}
|
|
}
|
|
|
|
CUtlVector< CDmElement * > rigList;
|
|
FindReferringElements( rigList, pControl, symDisplaySetElements );
|
|
int nNumRigs = rigList.Count();
|
|
for ( int iRig = 0; iRig < nNumRigs; ++iRig )
|
|
{
|
|
CDmElement *pRig = rigList[ iRig ];
|
|
if ( pRig == NULL )
|
|
continue;
|
|
|
|
CDmAttribute *pDisplaySetElementsAttr = pRig->GetAttribute( "displaySetElements", AT_ELEMENT_ARRAY );
|
|
if ( pDisplaySetElementsAttr == NULL )
|
|
continue;
|
|
|
|
CDmrElementArray<> displaySetElements( pDisplaySetElementsAttr );
|
|
int nIndex = displaySetElements.Find( pControl );
|
|
if ( nIndex != displaySetElements.InvalidIndex() )
|
|
{
|
|
displaySetElements.Remove( nIndex );
|
|
}
|
|
}
|
|
|
|
|
|
// Destroy the control even if something is holding on to it
|
|
DestroyElement( pControl );
|
|
}
|
|
|
|
|
|
CDmElement *CollapseControlGroup( CDmElement *pControlGroup, CDmElement *pRootGroup )
|
|
{
|
|
const static CUtlSymbolLarge symDmeControlGroup = g_pDataModel->GetSymbol( "DmeControlGroup" );
|
|
const static CUtlSymbolLarge symChildren = g_pDataModel->GetSymbol( "children" );
|
|
|
|
if ( pControlGroup->GetType() != symDmeControlGroup )
|
|
return NULL;
|
|
|
|
if ( pRootGroup && ( pRootGroup->GetType() != symDmeControlGroup ) )
|
|
return NULL;
|
|
|
|
// Find the parent control group of the specified control group
|
|
CDmElement *pParentControlGroup = NULL;
|
|
CUtlVector< CDmElement* > parentList;
|
|
FindReferringElements( parentList, pControlGroup, symChildren );
|
|
for ( int i = 0; i < parentList.Count(); ++i )
|
|
{
|
|
CDmElement *pElement = parentList[ i ];
|
|
if ( pElement->GetType() == symDmeControlGroup )
|
|
{
|
|
pParentControlGroup = pElement;
|
|
break;
|
|
}
|
|
}
|
|
|
|
Assert( pParentControlGroup );
|
|
|
|
// If no parent was found, use the supplied root group
|
|
if ( pParentControlGroup == NULL )
|
|
{
|
|
pParentControlGroup = pRootGroup;
|
|
}
|
|
|
|
|
|
if ( ( pParentControlGroup != NULL ) && ( pParentControlGroup != pControlGroup ) )
|
|
{
|
|
// Move add the controls of the child to its parent
|
|
CDmAttribute *pChildControlsAttr = pControlGroup->GetAttribute( "controls", AT_ELEMENT_ARRAY );
|
|
CDmAttribute *pParentControlsAttr = pParentControlGroup->GetAttribute( "controls", AT_ELEMENT_ARRAY );
|
|
if ( pChildControlsAttr && pParentControlsAttr )
|
|
{
|
|
CDmrElementArray<> childControls( pChildControlsAttr );
|
|
CDmrElementArray<> parentControls( pParentControlsAttr );
|
|
for ( int iControl = 0; iControl < childControls.Count(); ++iControl )
|
|
{
|
|
parentControls.AddToTail( childControls[ iControl ] );
|
|
}
|
|
childControls.RemoveAll();
|
|
}
|
|
|
|
// Move the children of the child to its parent
|
|
CDmAttribute *pChildChildrenAttr = pControlGroup->GetAttribute( "children", AT_ELEMENT_ARRAY );
|
|
CDmAttribute *pParentChildrenAttr = pParentControlGroup->GetAttribute( "children", AT_ELEMENT_ARRAY );
|
|
|
|
|
|
if ( pParentChildrenAttr )
|
|
{
|
|
CDmrElementArray<> parentChildren( pParentChildrenAttr );
|
|
|
|
// Move the children from the control group to its parent
|
|
if ( pChildChildrenAttr )
|
|
{
|
|
CDmrElementArray<> childChildren( pChildChildrenAttr );
|
|
for ( int iChild = 0; iChild < childChildren.Count(); ++iChild )
|
|
{
|
|
parentChildren.AddToTail( childChildren[ iChild ] );
|
|
}
|
|
childChildren.RemoveAll();
|
|
}
|
|
|
|
// Remove the control group from its parent
|
|
int nGroupIndex = parentChildren.Find( pControlGroup );
|
|
parentChildren.Remove( nGroupIndex );
|
|
}
|
|
}
|
|
|
|
|
|
return pParentControlGroup;
|
|
}
|
|
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Update16 -- remove settings from sfm sessions
|
|
//-----------------------------------------------------------------------------
|
|
bool Update16( CDmElement *pElement )
|
|
{
|
|
// remove manipulatorsettings from sfm sessions
|
|
if ( !V_strcmp( pElement->GetName(), "sessionSettings" ) )
|
|
{
|
|
pElement->RemoveAttribute( "manipulatorSettings" );
|
|
|
|
CDmElement *pRenderSettings = pElement->GetValueElement< CDmElement >( "renderSettings" );
|
|
if ( pRenderSettings )
|
|
{
|
|
CDmElement *pMovieSettings = pRenderSettings->GetValueElement< CDmElement >( "MovieSettings" );
|
|
pElement->SetValue( "movieSettings", pMovieSettings ); // lower-casing first letter to match other settings
|
|
pRenderSettings->RemoveAttribute( "MovieSettings" );
|
|
|
|
if ( pMovieSettings )
|
|
{
|
|
pMovieSettings->RemoveAttribute( "shutterSpeed" );
|
|
pMovieSettings->RemoveAttribute( "framerate" );
|
|
pMovieSettings->RemoveAttribute( "nLayoffState" );
|
|
pMovieSettings->RemoveAttribute( "startTime" );
|
|
pMovieSettings->RemoveAttribute( "endTime" );
|
|
pMovieSettings->RemoveAttribute( "renderOnlySelectedClips" );
|
|
|
|
pMovieSettings->InitValue( "videoTarget", 2 ); // TGA
|
|
pMovieSettings->InitValue( "audioTarget", 2 ); // WAV
|
|
pMovieSettings->InitValue( "stereoscopic", false );
|
|
pMovieSettings->InitValue( "stereoSingleFile", false );
|
|
pMovieSettings->InitValue( "clearDecals", false );
|
|
pMovieSettings->InitValue( "width", 1280 );
|
|
pMovieSettings->InitValue( "height", 720 );
|
|
pMovieSettings->InitValue( "filename", "" );
|
|
}
|
|
|
|
CDmElement *pPosterSettings = pRenderSettings->GetValueElement< CDmElement >( "PosterSettings" );
|
|
pElement->SetValue( "posterSettings", pPosterSettings ); // lower-casing first letter to match other settings
|
|
pRenderSettings->RemoveAttribute( "PosterSettings" );
|
|
|
|
pRenderSettings->RemoveAttribute( "syncEngineFramerate" );
|
|
pRenderSettings->RemoveAttribute( "showFocalPlane" );
|
|
pRenderSettings->RemoveAttribute( "showCameraFrustum" );
|
|
pRenderSettings->RemoveAttribute( "showViewTargets" );
|
|
pRenderSettings->RemoveAttribute( "StereoFlip" );
|
|
|
|
pRenderSettings->InitValue( "ambientOcclusionMode", 0 ); // Perform ambient occlusion and/or outlining
|
|
pRenderSettings->InitValue( "showAmbientOcclusion", 0 ); // Show just AO/outlining (vs combined with normal scene rendering)
|
|
pRenderSettings->InitValue( "drawGameRenderablesMask", 0xd8 ); // RENDER_GAME_ROPES | RENDER_GAME_BEAMS | RENDER_GAME_WORLD_BRUSHES | RENDER_GAME_WORLD_PROPS
|
|
pRenderSettings->InitValue( "drawToolRenderablesMask", 0x0f ); // RENDER_TOOL_PUPPETS | RENDER_TOOL_EFFECTS | RENDER_TOOL_PARTICLE_SYSTEMS | RENDER_TOOL_LIGHTS
|
|
pRenderSettings->InitValue( "toneMapScale", 1.0f );
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Remove the "parentConstraint" attribute from all dmeDag elements and the
|
|
// "embeddedTarget" attribute from all operators.
|
|
//-----------------------------------------------------------------------------
|
|
bool IsRigConstraint( CDmElement *pElement )
|
|
{
|
|
const static CUtlSymbolLarge rigSym[] =
|
|
{
|
|
g_pDataModel->GetSymbol( "DmeRigPointConstraintOperator" ),
|
|
g_pDataModel->GetSymbol( "DmeRigOrientConstraintOperator" ),
|
|
g_pDataModel->GetSymbol( "DmeRigAimConstraintOperator" ),
|
|
g_pDataModel->GetSymbol( "DmeRigRotationConstraintOperator" ),
|
|
g_pDataModel->GetSymbol( "DmeRigParentConstraintOperator" ),
|
|
g_pDataModel->GetSymbol( "DmeRigIKConstraintOperator" ),
|
|
};
|
|
|
|
static const int nNumConstraintOperators = sizeof( rigSym ) / sizeof( CUtlSymbolLarge );
|
|
|
|
CUtlSymbolLarge elementSym = pElement->GetType();
|
|
for ( int i = 0; i < nNumConstraintOperators; ++i )
|
|
{
|
|
if ( elementSym == rigSym[ i ] )
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
|
|
bool Update15( CDmElement *pElement )
|
|
{
|
|
const static CUtlSymbolLarge dmeDagSym = g_pDataModel->GetSymbol( "DmeDag" );
|
|
|
|
if ( pElement->GetType() == dmeDagSym )
|
|
{
|
|
pElement->RemoveAttribute( "parentConstraint" );
|
|
}
|
|
else if ( IsRigConstraint( pElement ) )
|
|
{
|
|
pElement->RemoveAttribute( "embeddedTarget" );
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
|
|
|
|
void CollectAnimSetsAndDestroyAnimSetGroups( CDmrElementArray< CDmElement > animationSets, CDmElement *pSrcAnimSetGroup )
|
|
{
|
|
if ( !pSrcAnimSetGroup || !animationSets.IsValid() )
|
|
return;
|
|
|
|
CDmrElementArray< CDmElement > srcAnimationSets( pSrcAnimSetGroup, "animationSets" );
|
|
int nAnimationSets = srcAnimationSets.IsValid() ? srcAnimationSets.Count() : 0;
|
|
for ( int i = 0; i < nAnimationSets; ++i )
|
|
{
|
|
if ( CDmElement *pAnimSet = srcAnimationSets[ i ] )
|
|
{
|
|
animationSets.AddToTail( pAnimSet );
|
|
}
|
|
}
|
|
|
|
CDmrElementArray< CDmElement > children( pSrcAnimSetGroup, "children" );
|
|
int nChildren = children.IsValid() ? children.Count() : 0;
|
|
for ( int i = 0; i < nChildren; ++i )
|
|
{
|
|
CollectAnimSetsAndDestroyAnimSetGroups( animationSets, children[ i ] );
|
|
}
|
|
|
|
DestroyElement( pSrcAnimSetGroup );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// eliminating animationsetsgroups and moving their animationsets to a single filmclip attribute
|
|
//-----------------------------------------------------------------------------
|
|
bool Update14( CDmElement *pElement )
|
|
{
|
|
const static CUtlSymbolLarge filmClipSym = g_pDataModel->GetSymbol( "DmeFilmClip" );
|
|
if ( pElement->GetType() == filmClipSym )
|
|
{
|
|
CDmrElementArray< CDmElement > animationSets( pElement, "animationSets", true );
|
|
|
|
CDmrElementArray< CDmElement > animSetGroups( pElement, "animationSetGroups" );
|
|
int nAnimSetGroups = animSetGroups.IsValid() ? animSetGroups.Count() : 0;
|
|
for ( int i = 0; i < nAnimSetGroups; ++i )
|
|
{
|
|
CollectAnimSetsAndDestroyAnimSetGroups( animationSets, animSetGroups[ i ] );
|
|
}
|
|
|
|
pElement->RemoveAttribute( "animationSetGroups" );
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
// this works because both CDmeFilmClip and CDmeAnimationSetGroup have an element array called "bookmarks" that is being replaced
|
|
void CreateBookmarkSetAndMoveBookmarks( CDmrElementArray< CDmElement > bookmarkSets, CDmElement *pSrcElement, const char *pSetName, bool bForce )
|
|
{
|
|
CDmAttribute *pSrcBookmarks = pSrcElement->GetAttribute( "bookmarks" );
|
|
CDmrElementArray< CDmElement > srcBookmarks( pSrcBookmarks );
|
|
if ( bForce || ( srcBookmarks.IsValid() && srcBookmarks.Count() > 0 ) )
|
|
{
|
|
CDmElement *pOwner = bookmarkSets.GetAttribute()->GetOwner();
|
|
|
|
CDmElement *pBookmarkSet = CreateElement< CDmElement >( "DmeBookmarkSet", pSetName, pOwner->GetFileId() );
|
|
pBookmarkSet->SetParity( pOwner->GetParity() );
|
|
|
|
bookmarkSets.AddToTail( pBookmarkSet );
|
|
|
|
CDmAttribute *pSetBookmarks = pBookmarkSet->AddAttribute( "bookmarks", AT_ELEMENT_ARRAY );
|
|
if ( pSrcBookmarks && pSetBookmarks )
|
|
{
|
|
pSetBookmarks->SetValue( pSrcBookmarks );
|
|
}
|
|
}
|
|
pSrcElement->RemoveAttributeByPtr( pSrcBookmarks );
|
|
}
|
|
|
|
void MoveBookmarksFromAnimSetGroups( CDmrElementArray< CDmElement > bookmarkSets, CDmElement *pSrcAnimSetGroup )
|
|
{
|
|
if ( !pSrcAnimSetGroup || !bookmarkSets.IsValid() )
|
|
return;
|
|
|
|
CreateBookmarkSetAndMoveBookmarks( bookmarkSets, pSrcAnimSetGroup, pSrcAnimSetGroup->GetName(), false );
|
|
|
|
CDmrElementArray< CDmElement > children( pSrcAnimSetGroup, "children" );
|
|
int nChildren = children.IsValid() ? children.Count() : 0;
|
|
for ( int i = 0; i < nChildren; ++i )
|
|
{
|
|
MoveBookmarksFromAnimSetGroups( bookmarkSets, children[ i ] );
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// moving bookmarks from filmclip and animsetionsetgroup to bookmarkset
|
|
// and adding bookmarksets to filmclip to allow named sets of bookmarks,
|
|
// and in preparation for removing animationsetgroups
|
|
//-----------------------------------------------------------------------------
|
|
bool Update13( CDmElement *pElement )
|
|
{
|
|
const static CUtlSymbolLarge filmClipSym = g_pDataModel->GetSymbol( "DmeFilmClip" );
|
|
if ( pElement->GetType() == filmClipSym )
|
|
{
|
|
pElement->SetValue( "activeBookmarkSet", 0 );
|
|
CDmrElementArray< CDmElement > bookmarkSets( pElement, "bookmarkSets", true );
|
|
CreateBookmarkSetAndMoveBookmarks( bookmarkSets, pElement, "default set", true );
|
|
|
|
CDmrElementArray< CDmElement > animSetGroups( pElement, "animationSetGroups" );
|
|
int nAnimSetGroups = animSetGroups.IsValid() ? animSetGroups.Count() : 0;
|
|
for ( int i = 0; i < nAnimSetGroups; ++i )
|
|
{
|
|
MoveBookmarksFromAnimSetGroups( bookmarkSets, animSetGroups[ i ] );
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// moving displaySets from animsetionsetgroup to animationset in preparation for removing animationsetgroups
|
|
//-----------------------------------------------------------------------------
|
|
bool Update12( CDmElement *pElement )
|
|
{
|
|
const static CUtlSymbolLarge animSetSym = g_pDataModel->GetSymbol( "DmeAnimationSet" );
|
|
const static CUtlSymbolLarge animSetGroupSym = g_pDataModel->GetSymbol( "DmeAnimationSetGroup" );
|
|
const static CUtlSymbolLarge controlDisplaySetSym = g_pDataModel->GetSymbol( "DmeControlDisplaySet" );
|
|
const static CUtlSymbolLarge displaySetSym = g_pDataModel->GetSymbol( "displaySet" );
|
|
const static CUtlSymbolLarge controlsSym = g_pDataModel->GetSymbol( "controls" );
|
|
|
|
if ( pElement->GetType() == animSetGroupSym )
|
|
{
|
|
CDmrElementArray<> displaySets( pElement, "displaySets" );
|
|
int nDisplaySets = displaySets.IsValid() ? displaySets.Count() : 0;
|
|
for ( int di = 0; di < nDisplaySets; ++di )
|
|
{
|
|
CDmElement *pDisplaySet = displaySets[ di ];
|
|
if ( !pDisplaySet )
|
|
continue;
|
|
|
|
// gather controls referencing the displayset
|
|
CUtlVector< CDmElement* > controls;
|
|
FindReferringElements( controls, pDisplaySet, displaySetSym );
|
|
|
|
// gather animationsets referencing those controls
|
|
CUtlVector< CDmElement* > animsets;
|
|
int nControls = controls.Count();
|
|
for ( int ci = 0; ci < nControls; ++ci )
|
|
{
|
|
CDmElement *pControl = controls[ ci ];
|
|
if ( !pControl )
|
|
continue;
|
|
|
|
CUtlVector< CDmElement* > controlGroupsAndAnimationSets;
|
|
FindReferringElements( controlGroupsAndAnimationSets, pControl, controlsSym );
|
|
|
|
int nControlGroupsAndAnimationSets = controlGroupsAndAnimationSets.Count();
|
|
for ( int gi = 0; gi < nControlGroupsAndAnimationSets; ++gi )
|
|
{
|
|
CDmElement *pGroupOrAnimSet = controlGroupsAndAnimationSets[ gi ];
|
|
if ( !pGroupOrAnimSet || pGroupOrAnimSet->GetType() != animSetSym )
|
|
continue;
|
|
|
|
if ( animsets.Find( pGroupOrAnimSet ) < 0 )
|
|
{
|
|
animsets.AddToTail( pGroupOrAnimSet );
|
|
}
|
|
}
|
|
}
|
|
|
|
// add displayset to gathered animationsets (and replace controls' displaysets with new copy if needed)
|
|
int nAnimSets = animsets.Count();
|
|
for ( int ai = 0; ai < nAnimSets; ++ai )
|
|
{
|
|
CDmElement *pAnimSet = animsets[ ai ];
|
|
CDmElement *pNewDisplaySet = pDisplaySet;
|
|
if ( ai > 0 )
|
|
{
|
|
// copy displayset
|
|
pNewDisplaySet = pDisplaySet->Copy( TD_SHALLOW );
|
|
pNewDisplaySet->SetParity( pElement->GetParity(), TD_SHALLOW );
|
|
|
|
// replace displayset with copy on each control in this animationset
|
|
CDmrElementArray<> controls( pAnimSet, "controls" );
|
|
int nControls = controls.Count();
|
|
for ( int ci = 0; ci < nControls; ++ci )
|
|
{
|
|
CDmElement *pControl = controls[ ci ];
|
|
if ( !pControl )
|
|
continue;
|
|
|
|
if ( pControl->GetValueElement< CDmElement >( "displaySet" ) == pDisplaySet )
|
|
{
|
|
pControl->SetValue( "displaySet", pNewDisplaySet );
|
|
}
|
|
}
|
|
}
|
|
|
|
// add displayset (or copy) to animationset
|
|
CDmrElementArray<> newDisplaySets( pAnimSet, "displaySets", true );
|
|
newDisplaySets.AddToTail( pNewDisplaySet );
|
|
}
|
|
}
|
|
|
|
// remove displaysets attribute from animationsetgroup
|
|
pElement->RemoveAttribute( "displaySets" );
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Remove redundant attributes in animationset controls to save memory
|
|
//-----------------------------------------------------------------------------
|
|
bool Update11( CDmElement *pElement )
|
|
{
|
|
const static CUtlSymbolLarge animSetSym = g_pDataModel->GetSymbol( "DmeAnimationSet" );
|
|
|
|
if ( pElement->GetType() == animSetSym )
|
|
{
|
|
CDmrElementArray<> controls( pElement, "controls" );
|
|
Assert( controls.IsValid() );
|
|
if ( !controls.IsValid() )
|
|
return false;
|
|
|
|
int nControls = controls.Count();
|
|
for ( int i = 0; i < nControls; ++i )
|
|
{
|
|
CDmElement *pControl = controls[ i ];
|
|
if ( !pControl )
|
|
continue;
|
|
|
|
if ( pControl->HasAttribute( "combo" ) )
|
|
{
|
|
if ( pControl->GetValue< bool >( "combo" ) )
|
|
{
|
|
float flDefaultLeftValue = pControl->GetValue< float >( "defaultLeftValue" );
|
|
float flDefaultRightValue = pControl->GetValue< float >( "defaultRightValue" );
|
|
pControl->SetValue( "defaultValue", 0.5f * ( flDefaultLeftValue + flDefaultRightValue ) );
|
|
pControl->RemoveAttribute( "value" );
|
|
pControl->RemoveAttribute( "channel" );
|
|
}
|
|
else
|
|
{
|
|
pControl->RemoveAttribute( "rightValue" );
|
|
pControl->RemoveAttribute( "leftValue" );
|
|
pControl->RemoveAttribute( "rightvaluechannel" );
|
|
pControl->RemoveAttribute( "leftvaluechannel" );
|
|
}
|
|
pControl->RemoveAttribute( "combo" );
|
|
pControl->RemoveAttribute( "defaultLeftValue" );
|
|
pControl->RemoveAttribute( "defaultRightValue" );
|
|
}
|
|
else
|
|
{
|
|
if ( !pControl->GetValue< bool >( "isPosition" ) )
|
|
{
|
|
pControl->RemoveAttribute( "position" );
|
|
pControl->RemoveAttribute( "valuePosition" );
|
|
}
|
|
if ( !pControl->GetValue< bool >( "isOrientation" ) )
|
|
{
|
|
pControl->RemoveAttribute( "orientation" );
|
|
pControl->RemoveAttribute( "valueOrientation" );
|
|
}
|
|
pControl->RemoveAttribute( "transform" );
|
|
pControl->RemoveAttribute( "isPosition" );
|
|
pControl->RemoveAttribute( "isOrientation" );
|
|
}
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Create a control group with the specified name and add it to the
|
|
// provided parent if the parent is a DmeControlGroup.
|
|
//-----------------------------------------------------------------------------
|
|
CDmElement *CreateControlGroup( const char *pchName, CDmElement *pParent )
|
|
{
|
|
const static CUtlSymbolLarge controlGroupSym = g_pDataModel->GetSymbol( "DmeControlGroup" );
|
|
|
|
CDmElement *pGroup = CreateElement< CDmElement >( "DmeControlGroup", pchName, pParent->GetFileId() );
|
|
pGroup->SetParity( pParent->GetParity() );
|
|
|
|
pGroup->AddAttribute( "children", AT_ELEMENT_ARRAY );
|
|
pGroup->AddAttribute( "controls", AT_ELEMENT_ARRAY );
|
|
pGroup->SetValue< Color >( "groupColor", Color( 200, 200, 200, 255 ) );
|
|
pGroup->SetValue< Color >( "controlColor", Color( 200, 200, 200, 255 ) );
|
|
|
|
if ( pParent->GetType() == controlGroupSym )
|
|
{
|
|
CDmAttribute *pChildrenAttr = pParent->GetAttribute( "children", AT_ELEMENT_ARRAY );
|
|
CDmrElementArray<> childList( pChildrenAttr );
|
|
childList.AddToTail( pGroup );
|
|
}
|
|
|
|
return pGroup;
|
|
}
|
|
|
|
#define MULTI_CONTROL_FORMAT_STRING "multi_%s"
|
|
|
|
bool ConvertControlGroup_R( CDmrElementArray<> &animSetControls, CDmElement *pControlGroup )
|
|
{
|
|
if ( !pControlGroup )
|
|
return true;
|
|
|
|
CDmrElementArray<> children( pControlGroup, "children" );
|
|
int nChildren = children.Count();
|
|
for ( int i = 0; i < nChildren; ++i )
|
|
{
|
|
ConvertControlGroup_R( animSetControls, children[ i ] );
|
|
}
|
|
|
|
CDmrElementArray<> controls( pControlGroup, "controls" );
|
|
Assert( controls.IsValid() );
|
|
if ( !controls.IsValid() )
|
|
return true;
|
|
|
|
int nControls = controls.Count();
|
|
for ( int i = 0; i < nControls; ++i )
|
|
{
|
|
CDmElement *pControl = controls[ i ];
|
|
if ( !pControl )
|
|
continue;
|
|
|
|
if ( pControl->GetValue< bool >( "multi" ) )
|
|
{
|
|
CDmElement *pMultiChannel = pControl->GetValueElement< CDmElement >( "multilevelchannel" );
|
|
Assert( pMultiChannel );
|
|
if ( pMultiChannel )
|
|
{
|
|
// create new multi control
|
|
char multiName[ 256 ];
|
|
V_snprintf( multiName, sizeof( multiName ), MULTI_CONTROL_FORMAT_STRING, pControl->GetName() );
|
|
CDmElement *pMultiControl = CreateElement< CDmElement >( "DmElement", multiName, pControl->GetFileId() );
|
|
pMultiControl->SetParity( pControlGroup->GetParity() );
|
|
pMultiControl->SetValue( "value", pControl->GetValue< float >( "multilevel" ) );
|
|
pMultiControl->SetValue( "defaultValue", pControl->GetValue< float >( "defaultMultilevel" ) );
|
|
pMultiControl->SetValue( "channel", pMultiChannel );
|
|
|
|
// add multi control to animset's flat control list
|
|
int j = animSetControls.Find( pControl );
|
|
if ( j < 0 )
|
|
return false;
|
|
|
|
// WARNING: this isn't a great practice, since it's technically possible that we're iterating controls,
|
|
// but some control's channel would have to reference a control group (with multi controls) for that to be true
|
|
animSetControls.Remove( j );
|
|
animSetControls.InsertBefore( 0, pControl );
|
|
animSetControls.InsertBefore( 1, pMultiControl );
|
|
|
|
// update channel to point to new element
|
|
pMultiChannel->SetValue( "fromElement", pMultiControl );
|
|
pMultiChannel->SetValue( "fromAttribute", "value" );
|
|
|
|
// create control group to contain both controls and add it to the parent group
|
|
CDmElement *pNewControlGroup = CreateControlGroup( pControl->GetName(), pControlGroup );
|
|
|
|
// add original and multi control to new control group
|
|
CDmrElementArray<> newControls( pNewControlGroup, "controls" );
|
|
if ( !newControls.IsValid() )
|
|
return false;
|
|
|
|
newControls.AddToTail( pControl );
|
|
newControls.AddToTail( pMultiControl );
|
|
|
|
// remove original control from its old parent group
|
|
controls.Remove( i );
|
|
--i; --nControls;
|
|
}
|
|
}
|
|
|
|
// remove multi-related attributes from original control
|
|
pControl->RemoveAttribute( "multi" );
|
|
pControl->RemoveAttribute( "multilevel" );
|
|
pControl->RemoveAttribute( "defaultMultilevel" );
|
|
pControl->RemoveAttribute( "multilevelchannel" );
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Convert multi controls into a control group and two controls
|
|
//-----------------------------------------------------------------------------
|
|
bool Update10( CDmElement *pElement )
|
|
{
|
|
const static CUtlSymbolLarge animSetSym = g_pDataModel->GetSymbol( "DmeAnimationSet" );
|
|
const static CUtlSymbolLarge presetSym = g_pDataModel->GetSymbol( "DmePreset" );
|
|
|
|
if ( pElement->GetType() == animSetSym )
|
|
{
|
|
CDmrElementArray<> controls( pElement, "controls" );
|
|
Assert( controls.IsValid() );
|
|
if ( !controls.IsValid() )
|
|
return false;
|
|
|
|
ConvertControlGroup_R( controls, pElement->GetValueElement< CDmElement >( "rootControlGroup" ) );
|
|
}
|
|
else if ( pElement->GetType() == presetSym )
|
|
{
|
|
CDmrElementArray<> controlValues( pElement, "controlValues" );
|
|
Assert( controlValues.IsValid() );
|
|
if ( !controlValues.IsValid() )
|
|
return true;
|
|
|
|
int nControls = controlValues.Count();
|
|
for ( int ci = 0; ci < nControls; ++ci )
|
|
{
|
|
CDmElement *pControlValue = controlValues[ ci ];
|
|
if ( !pControlValue )
|
|
continue;
|
|
|
|
CDmAttribute *pAttr = pControlValue->GetAttribute( "multilevel", AT_FLOAT );
|
|
if ( !pAttr )
|
|
continue;
|
|
|
|
// create new multi control value
|
|
char multiName[ 256 ];
|
|
V_snprintf( multiName, sizeof( multiName ), MULTI_CONTROL_FORMAT_STRING, pControlValue->GetName() );
|
|
CDmElement *pMultiControlValue = CreateElement< CDmElement >( "DmElement", multiName, pControlValue->GetFileId() );
|
|
pMultiControlValue->SetParity( pElement->GetParity() );
|
|
pMultiControlValue->SetValue( "value", pAttr->GetValue< float >() );
|
|
controlValues.InsertBefore( ci + 1, pMultiControlValue );
|
|
++ci; ++nControls;
|
|
|
|
// remove multilevel attribute from original control
|
|
pControlValue->RemoveAttributeByPtr( pAttr );
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------------------------
|
|
// Update9 -- AnimationSet DmElement to DmeControlGroup conversion
|
|
//-------------------------------------------------------------------------------------------------
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Find the control in the animation set with the specified name
|
|
//-----------------------------------------------------------------------------
|
|
CDmElement *FindAnimSetControl( CDmElement* pAnimSet, const char *pchControlName )
|
|
{
|
|
CDmAttribute *pControlsAttr = pAnimSet->GetAttribute( "controls" );
|
|
if ( pControlsAttr == NULL )
|
|
return NULL;
|
|
|
|
CDmrElementArray<> controls( pControlsAttr );
|
|
int nControls = controls.Count();
|
|
for ( int iControl = 0; iControl < nControls; ++iControl )
|
|
{
|
|
CDmElement *pElement = controls[ iControl ];
|
|
if ( pElement )
|
|
{
|
|
if ( V_stricmp( pchControlName, pElement->GetName() ) == 0 )
|
|
{
|
|
return pElement;
|
|
}
|
|
}
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Recursively convert the generic DmElement selection group and its
|
|
// children into a DmeControlGroup
|
|
//-----------------------------------------------------------------------------
|
|
void ConvertSelectionGroup_R( CDmElement* pAnimSet, CDmElement *pParentControlGroup, CDmElement *pSelectionElement )
|
|
{
|
|
if ( ( pAnimSet == NULL ) || ( pParentControlGroup == NULL ) || ( pSelectionElement == NULL ) )
|
|
return;
|
|
|
|
bool isGroup = pSelectionElement->GetValue< bool >( "isGroup" );
|
|
if ( isGroup )
|
|
{
|
|
// Create a control group and add it to the parent group.
|
|
CDmElement *pControlGroup = CreateControlGroup( pSelectionElement->GetName(), pParentControlGroup );
|
|
if ( pControlGroup )
|
|
{
|
|
// Copy the tree color of the element to the group color of the control group
|
|
if ( pSelectionElement->HasAttribute( "treeColor", AT_COLOR ) )
|
|
{
|
|
pControlGroup->SetValue< Color >( "groupColor", pSelectionElement->GetValue< Color >( "treeColor" ) );
|
|
}
|
|
|
|
// Process the children of the selection element group
|
|
CDmAttribute *pSelectionControlsAttr = pSelectionElement->GetAttribute( "controls" );
|
|
if ( pSelectionControlsAttr )
|
|
{
|
|
CDmrElementArray<> children( pSelectionControlsAttr );
|
|
int nChildren = children.Count();
|
|
for ( int iChild = 0; iChild < nChildren; ++iChild )
|
|
{
|
|
CDmElement *pChild = children[ iChild ];
|
|
ConvertSelectionGroup_R( pAnimSet, pControlGroup, pChild );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// If the selection element is not a group, it is a control selection element which shares
|
|
// its name with the control it targets. Find that control and add it to the parent group.
|
|
CDmElement *pControl = FindAnimSetControl( pAnimSet, pSelectionElement->GetName() );
|
|
if ( pControl )
|
|
{
|
|
CDmAttribute *pControlsAttr = pParentControlGroup->GetAttribute( "controls" );
|
|
if ( pControlsAttr )
|
|
{
|
|
CDmrElementArray<> controls( pControlsAttr );
|
|
controls.AddToTail( pControl );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Convert the animation set selection group DmElements into
|
|
// DmeControlGroups. Removes "selectionGroups" and creates "rootControlGroup"
|
|
//-----------------------------------------------------------------------------
|
|
bool Update9( CDmElement *pElement )
|
|
{
|
|
const static CUtlSymbolLarge animSetSym = g_pDataModel->GetSymbol( "DmeAnimationSet" );
|
|
|
|
if ( pElement->GetType() == animSetSym )
|
|
{
|
|
CDmElement* pAnimSet = pElement;
|
|
|
|
// Create the root selection group
|
|
CDmElement *pRootGroup = CreateControlGroup( "rootGroup", pAnimSet );
|
|
pAnimSet->SetValue( "rootControlGroup", pRootGroup );
|
|
|
|
// Iterate through the selection DmElement groups and recursively
|
|
// convert them to them to the DmeControlGroup format.
|
|
CDmAttribute *pSelectionGroupsAttr = pAnimSet->GetAttribute( "selectionGroups", AT_ELEMENT_ARRAY );
|
|
if ( pSelectionGroupsAttr )
|
|
{
|
|
CDmrElementArray<> controls( pSelectionGroupsAttr );
|
|
int nControls = controls.Count();
|
|
for ( int ci = 0; ci < nControls; ++ci )
|
|
{
|
|
CDmElement *pSelectionElement = controls[ ci ];
|
|
if ( !pSelectionElement )
|
|
continue;
|
|
|
|
// Convert the generic DmElement group into a DmeControlGroup
|
|
ConvertSelectionGroup_R( pAnimSet, pRootGroup, pSelectionElement );
|
|
|
|
// Destroy the generic DmElement group
|
|
DestroyElement( pSelectionElement );
|
|
}
|
|
}
|
|
|
|
// Remove the selection groups list
|
|
pAnimSet->RemoveAttributeByPtr( pSelectionGroupsAttr );
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------------------------
|
|
//-------------------------------------------------------------------------------------------------
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Change DmeModel.jointTransforms to DmeModel.jointList
|
|
//-----------------------------------------------------------------------------
|
|
bool Update8( CDmElement *pElement )
|
|
{
|
|
const static CUtlSymbolLarge modelSetSym = g_pDataModel->GetSymbol( "DmeModel" );
|
|
|
|
CUtlSymbolLarge typeSym = pElement->GetType();
|
|
|
|
if ( typeSym == modelSetSym )
|
|
{
|
|
CDmAttribute *pJointTransformsAttr = pElement->GetAttribute( "jointTransforms", AT_ELEMENT_ARRAY );
|
|
if ( pJointTransformsAttr )
|
|
{
|
|
CDmAttribute *pJointListAttr = pElement->GetAttribute( "jointList", AT_ELEMENT_ARRAY );
|
|
if ( !pJointListAttr )
|
|
{
|
|
pJointListAttr = pElement->AddAttribute( "jointList", AT_ELEMENT_ARRAY );
|
|
}
|
|
|
|
if ( pJointListAttr )
|
|
{
|
|
const static CUtlSymbolLarge transformSym = g_pDataModel->GetSymbol( "transform" );
|
|
const static CUtlSymbolLarge dmeJointSym = g_pDataModel->GetSymbol( "DmeJoint" );
|
|
const static CUtlSymbolLarge dmeDagSym = g_pDataModel->GetSymbol( "DmeDag" );
|
|
|
|
CUtlVector< CDmElement * > refList;
|
|
|
|
CDmrElementArray<> jt( pJointTransformsAttr );
|
|
CDmrElementArray<> jl( pJointListAttr );
|
|
|
|
jl.RemoveAll();
|
|
const int nJointCount = jt.Count();
|
|
for ( int ji = 0; ji < nJointCount; ++ji )
|
|
{
|
|
refList.RemoveAll();
|
|
if ( FindReferringElements( refList, jt[ ji ], transformSym ) )
|
|
{
|
|
const int nRefCount = refList.Count();
|
|
for ( int ri = 0; ri < nRefCount; ++ri )
|
|
{
|
|
typeSym = refList[ ri ]->GetType();
|
|
if ( typeSym == dmeJointSym || typeSym == dmeDagSym )
|
|
{
|
|
jl.AddToTail( refList[ ri ] );
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
pElement->RemoveAttribute( "jointTransforms" );
|
|
}
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Convert base control elements with the "transform" flag set into
|
|
// CDmeTransformControl elements and remove the obsolete attributes from the
|
|
// element which are now part of the CDmeTransfrom control class.
|
|
//-----------------------------------------------------------------------------
|
|
bool Update7( CDmElement *pElement )
|
|
{
|
|
const static CUtlSymbolLarge animSetSym = g_pDataModel->GetSymbol( "DmeAnimationSet" );
|
|
|
|
CUtlSymbolLarge typeSym = pElement->GetType();
|
|
|
|
if ( typeSym == animSetSym )
|
|
{
|
|
CDmAttribute *pControlsAttr = pElement->GetAttribute( "controls", AT_ELEMENT_ARRAY );
|
|
if ( pControlsAttr )
|
|
{
|
|
CDmrElementArray<> controls( pControlsAttr );
|
|
int nControls = controls.Count();
|
|
for ( int ci = 0; ci < nControls; ++ci )
|
|
{
|
|
CDmElement *pControl = controls[ ci ];
|
|
if ( !pControl )
|
|
continue;
|
|
|
|
if ( pControl->GetValue<bool>( "transform", false ) )
|
|
{
|
|
// Remove the obsolete attributes that are now part of the transform control class
|
|
pControl->RemoveAttribute( "valueTransform" );
|
|
pControl->RemoveAttribute( "valueDeltaRotation" );
|
|
pControl->RemoveAttribute( "valuePivot" );
|
|
pControl->RemoveAttribute( "pivotOffset" );
|
|
pControl->RemoveAttribute( "refOrientation" );
|
|
|
|
// Change the element type to specify a CDmeTransformControl
|
|
pControl->SetType( "DmeTransformControl" );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool Update6( CDmElement *pElement )
|
|
{
|
|
CUtlSymbolLarge typeSym = pElement->GetType();
|
|
|
|
const static CUtlSymbolLarge grainFXClipSym = g_pDataModel->GetSymbol( "DmeHSLGrainFXClip" );
|
|
if ( typeSym == grainFXClipSym )
|
|
{
|
|
pElement->RemoveAttribute( "scale" );
|
|
pElement->RemoveAttribute( "left" );
|
|
pElement->RemoveAttribute( "top" );
|
|
pElement->RemoveAttribute( "width" );
|
|
pElement->RemoveAttribute( "height" );
|
|
return true;
|
|
}
|
|
|
|
const static CUtlSymbolLarge dirLightSym = g_pDataModel->GetSymbol( "DmeDirectionalLight" );
|
|
const static CUtlSymbolLarge pointLightSym = g_pDataModel->GetSymbol( "DmePointLight" );
|
|
const static CUtlSymbolLarge spotLightSym = g_pDataModel->GetSymbol( "DmeSpotLight" );
|
|
const static CUtlSymbolLarge projLightSym = g_pDataModel->GetSymbol( "DmeProjectedLight" );
|
|
if ( typeSym == dirLightSym || typeSym == pointLightSym || typeSym == spotLightSym || typeSym == projLightSym )
|
|
{
|
|
Vector pos = pElement->GetValue< Vector >( "position" );
|
|
Vector dir = pElement->GetValue< Vector >( "direction" );
|
|
Quaternion quat = pElement->GetValue< Quaternion >( "orientation" );
|
|
if ( dir != vec3_origin )
|
|
{
|
|
// HACK - there's some question here as to whether to use VectorAngles, which assumes forward is 1,0,0,
|
|
// or to compute the 0,0,1->dir quaternion manually, but since dirlights aren't used anyways, I'm not worrying about it
|
|
QAngle angles;
|
|
VectorAngles( dir, angles );
|
|
AngleQuaternion( angles, quat );
|
|
}
|
|
|
|
CDmElement *pTransform = pElement->GetValueElement< CDmElement >( "transform" );
|
|
if ( !pTransform )
|
|
{
|
|
pTransform = CreateElement< CDmElement >( "DmeTransform", "transform", pElement->GetFileId() );
|
|
pTransform->SetParity( pElement->GetParity() );
|
|
pElement->SetValue( "transform", pTransform );
|
|
}
|
|
|
|
Vector parentPos = pTransform->GetValue< Vector >( "position" );
|
|
Quaternion parentQuat = pTransform->GetValue< Quaternion >( "orientation" );
|
|
|
|
Vector finalPos;
|
|
Quaternion finalQuat;
|
|
ConcatTransforms( parentQuat, parentPos, quat, pos, finalQuat, finalPos );
|
|
|
|
pTransform->SetValue( "position", finalPos );
|
|
pTransform->SetValue( "orientation", finalQuat );
|
|
|
|
// NOTE - not bothering to convert logs on transform, since up until this change, updating the light's transform didn't do anything
|
|
|
|
CDmElement *pPosChannel = FindChannelTargettingElement( pElement, "position", false );
|
|
CDmElement *pPosLog = pPosChannel ? GetLogLayerFromChannel( pPosChannel ) : NULL;
|
|
if ( pPosLog )
|
|
{
|
|
Quaternion qDummy;
|
|
Vector temp;
|
|
CDmAttribute *pAttr = pPosLog->GetAttribute( "values", AT_VECTOR3_ARRAY );
|
|
CDmrArray< Vector > values( pAttr );
|
|
int nValues = values.Count();
|
|
for ( int i = 0; i < nValues; ++i )
|
|
{
|
|
ConcatTransforms( parentQuat, parentPos, quat_identity, values[ i ], qDummy, temp );
|
|
values.Set( i, temp );
|
|
}
|
|
pPosChannel->SetValue( "toElement", pTransform );
|
|
}
|
|
|
|
CDmElement *pRotChannel = FindChannelTargettingElement( pElement, "orientation", false );
|
|
CDmElement *pRotLog = pRotChannel ? GetLogLayerFromChannel( pRotChannel ) : NULL;
|
|
if ( pRotLog )
|
|
{
|
|
Quaternion temp;
|
|
Vector vDummy;
|
|
CDmAttribute *pAttr = pRotLog->GetAttribute( "values", AT_QUATERNION_ARRAY );
|
|
CDmrArray< Quaternion > values( pAttr );
|
|
int nValues = values.Count();
|
|
for ( int i = 0; i < nValues; ++i )
|
|
{
|
|
ConcatTransforms( parentQuat, parentPos, values[ i ], vec3_origin, temp, vDummy );
|
|
values.Set( i, temp );
|
|
}
|
|
pRotChannel->SetValue( "toElement", pTransform );
|
|
}
|
|
|
|
pElement->RemoveAttribute( "position" );
|
|
pElement->RemoveAttribute( "direction" );
|
|
pElement->RemoveAttribute( "orientation" );
|
|
return true;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
bool Update4( CDmElement *pElement )
|
|
{
|
|
const static CUtlSymbolLarge filmClipSym = g_pDataModel->GetSymbol( "DmeFilmClip" );
|
|
const static CUtlSymbolLarge presetGroupSym = g_pDataModel->GetSymbol( "DmePresetGroup" );
|
|
|
|
CUtlSymbolLarge typeSym = pElement->GetType();
|
|
if ( typeSym == presetGroupSym )
|
|
{
|
|
CDmElement *pPresetRemap = pElement->GetValueElement< CDmElement >( "presetRemap" );
|
|
if ( pPresetRemap )
|
|
{
|
|
DestroyElement( pPresetRemap, TD_NONE );
|
|
}
|
|
pElement->RemoveAttribute( "presetRemap" );
|
|
}
|
|
|
|
if ( typeSym != filmClipSym )
|
|
return true;
|
|
|
|
CDmAttribute *pClipAnimSetsAttr = pElement->GetAttribute( "animationSets", AT_ELEMENT_ARRAY );
|
|
Assert( pClipAnimSetsAttr );
|
|
if ( !pClipAnimSetsAttr )
|
|
return true;
|
|
|
|
CDmrElementArray<> clipAnimSets( pClipAnimSetsAttr );
|
|
|
|
CDmAttribute *pAnimSetGroupsAttr = pElement->AddAttribute( "animationSetGroups", AT_ELEMENT_ARRAY );
|
|
Assert( pAnimSetGroupsAttr );
|
|
if ( !pAnimSetGroupsAttr )
|
|
return true;
|
|
|
|
CDmrElementArray<> animSetGroups( pAnimSetGroupsAttr );
|
|
|
|
int nClipAnimSets = clipAnimSets.Count();
|
|
for ( int i = 0; i < nClipAnimSets; ++i )
|
|
{
|
|
CDmElement *pAnimSet = clipAnimSets[ i ];
|
|
if ( !pAnimSet )
|
|
{
|
|
animSetGroups.AddToTail( NULL );
|
|
continue;
|
|
}
|
|
|
|
CDmElement *pAnimSetGroup = CreateElement< CDmElement >( "DmeAnimationSetGroup", pAnimSet->GetName(), pAnimSet->GetFileId() );
|
|
pAnimSetGroup->SetParity( pElement->GetParity() );
|
|
animSetGroups.AddToTail( pAnimSetGroup );
|
|
|
|
CDmAttribute *pBookmarksAttr = pAnimSetGroup->AddAttribute( "bookmarks", AT_ELEMENT_ARRAY );
|
|
CDmAttribute *pAnimSetsAttr = pAnimSetGroup->AddAttribute( "animationSets", AT_ELEMENT_ARRAY );
|
|
/*CDmAttribute *pChildrenAttr*/pAnimSetGroup->AddAttribute( "children", AT_ELEMENT_ARRAY );
|
|
|
|
CDmrElementArray<> animSets( pAnimSetsAttr );
|
|
animSets.AddToTail( pAnimSet );
|
|
|
|
CDmAttribute *pClipBookmarksAttr = pElement->GetAttribute( "bookmarks", AT_ELEMENT_ARRAY );
|
|
Assert( pClipBookmarksAttr );
|
|
if ( pClipBookmarksAttr )
|
|
{
|
|
CDmrElementArray<> clipBookmarks( pClipBookmarksAttr );
|
|
CDmrElementArray<> bookmarks( pBookmarksAttr );
|
|
|
|
int nBookmarks = clipBookmarks.Count();
|
|
for ( int bi = 0; bi < nBookmarks; ++bi )
|
|
{
|
|
bookmarks.AddToTail( clipBookmarks[ bi ] );
|
|
}
|
|
}
|
|
|
|
pAnimSet->RemoveAttribute( "bookmarks" );
|
|
}
|
|
|
|
pElement->RemoveAttribute( "animationSets" );
|
|
|
|
return true;
|
|
}
|
|
|
|
inline void ValueBalanceToLeftRight( float *pLeft, float *pRight, float flValue, float flBalance, float flDefaultValue )
|
|
{
|
|
*pLeft = ( flBalance <= 0.5f ) ? flValue : ( ( 1.0f - flBalance ) / 0.5f ) * ( flValue - flDefaultValue ) + flDefaultValue;
|
|
*pRight = ( flBalance >= 0.5f ) ? flValue : ( flBalance / 0.5f ) * ( flValue - flDefaultValue ) + flDefaultValue;
|
|
}
|
|
|
|
bool ConvertIntArrayToTimeArray( CDmAttribute *pAttribute )
|
|
{
|
|
if ( !pAttribute )
|
|
return false;
|
|
|
|
DmAttributeType_t type = pAttribute->GetType();
|
|
if ( type == AT_TIME_ARRAY )
|
|
return true;
|
|
|
|
Assert( type == AT_INT_ARRAY );
|
|
if ( type != AT_INT_ARRAY )
|
|
return false;
|
|
|
|
pAttribute->ChangeType_UNSAFE( AT_TIME_ARRAY );
|
|
|
|
Assert( pAttribute->GetType() == AT_TIME_ARRAY );
|
|
if ( pAttribute->GetType() != AT_TIME_ARRAY )
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
float GetDefaultControlValue( const char *pControlName )
|
|
{
|
|
// HACK - this is nasty, (and not 100% correct - the engineer's BrowInV is 1-way control) but it's either that or manually fix every preset file
|
|
// fortunately, even if this isn't perfect, it's almost undetectable
|
|
// we had to search the movies to find a spot where 0.0f wasn't a good enough default for every control, and the difference wasn't a big deal
|
|
const static char *s_2WayControls[] =
|
|
{
|
|
"TongueWidth",
|
|
"TongueV",
|
|
"TongueH",
|
|
"TongueD",
|
|
"TongueCurl",
|
|
"ScalpD",
|
|
"NostrilFlare",
|
|
"NoseV",
|
|
"LipUpV",
|
|
"LipsV",
|
|
"LipLoV",
|
|
"JawV",
|
|
"JawH",
|
|
"JawD",
|
|
"FoldLipUp",
|
|
"FoldLipLo",
|
|
"CheekH",
|
|
"BrowInV",
|
|
"CloseLid", // this is actually a multi (3-way) control, so it's defaultValue *should* be 0, but due to dmxedit's trickery it's (intentionally???) 0.5
|
|
};
|
|
|
|
for ( int i = 0; i < ARRAYSIZE( s_2WayControls ); ++i )
|
|
{
|
|
if ( !V_strcmp( pControlName, s_2WayControls[i] ) )
|
|
return 0.5f;
|
|
}
|
|
return 0.0f;
|
|
}
|
|
|
|
bool UpdatePreset( CDmElement *pPreset )
|
|
{
|
|
if ( !pPreset )
|
|
return true;
|
|
|
|
CDmAttribute *pControlValuesAttr = pPreset->GetAttribute( "controlValues", AT_ELEMENT_ARRAY );
|
|
if ( !pControlValuesAttr )
|
|
return true;
|
|
|
|
const char *pPresetName = pPreset->GetName();
|
|
bool bFixupBalance = !V_stricmp( pPresetName, "zero" ) || !V_stricmp( pPresetName, "one" );
|
|
|
|
CDmrElementArray<> controlValues( pControlValuesAttr );
|
|
int nControlValues = controlValues.Count();
|
|
for ( int vi = 0; vi < nControlValues; ++vi )
|
|
{
|
|
CDmElement *pControlValue = controlValues[ vi ];
|
|
if ( !pControlValue )
|
|
return true;
|
|
|
|
if ( pControlValue->HasAttribute( "balance" ) )
|
|
{
|
|
float flDefaultValue = GetDefaultControlValue( pControlValue->GetName() );
|
|
|
|
float flValue = pControlValue->GetValue< float >( "value" );
|
|
float flBalance = pControlValue->GetValue< float >( "balance" );
|
|
pControlValue->RemoveAttribute( "value" );
|
|
pControlValue->RemoveAttribute( "balance" );
|
|
|
|
if ( bFixupBalance )
|
|
{
|
|
flBalance = 0.5f;
|
|
}
|
|
|
|
float flLeft, flRight;
|
|
ValueBalanceToLeftRight( &flLeft, &flRight, flValue, flBalance, flDefaultValue );
|
|
|
|
pControlValue->SetValue( "leftValue", flLeft );
|
|
pControlValue->SetValue( "rightValue", flRight );
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool Update3( CDmElement *pElement )
|
|
{
|
|
const static CUtlSymbolLarge animSetSym = g_pDataModel->GetSymbol( "DmeAnimationSet" );
|
|
const static CUtlSymbolLarge presetSym = g_pDataModel->GetSymbol( "DmePreset" );
|
|
const static CUtlSymbolLarge comboOpSym = g_pDataModel->GetSymbol( "DmeCombinationOperator" );
|
|
|
|
const static CUtlSymbolLarge logLayerSym = g_pDataModel->GetSymbol( "DmeLogLayer" );
|
|
const static CUtlSymbolLarge intLogLayerSym = g_pDataModel->GetSymbol( "DmeIntLogLayer" );
|
|
const static CUtlSymbolLarge floatLogLayerSym = g_pDataModel->GetSymbol( "DmeFloatLogLayer" );
|
|
const static CUtlSymbolLarge boolLogLayerSym = g_pDataModel->GetSymbol( "DmeBoolLogLayer" );
|
|
const static CUtlSymbolLarge colorLogLayerSym = g_pDataModel->GetSymbol( "DmeColorLogLayer" );
|
|
const static CUtlSymbolLarge vec2LogLayerSym = g_pDataModel->GetSymbol( "DmeVector2LogLayer" );
|
|
const static CUtlSymbolLarge vec3LogLayerSym = g_pDataModel->GetSymbol( "DmeVector3LogLayer" );
|
|
const static CUtlSymbolLarge vec4LogLayerSym = g_pDataModel->GetSymbol( "DmeVector4LogLayer" );
|
|
const static CUtlSymbolLarge qangleLogLayerSym = g_pDataModel->GetSymbol( "DmeQAngleLogLayer" );
|
|
const static CUtlSymbolLarge quatLogLayerSym = g_pDataModel->GetSymbol( "DmeQuaternionLogLayer" );
|
|
const static CUtlSymbolLarge vmatrixLogLayerSym = g_pDataModel->GetSymbol( "DmeVMatrixLogLayer" );
|
|
const static CUtlSymbolLarge stringLogLayerSym = g_pDataModel->GetSymbol( "DmeStringLogLayer" );
|
|
const static CUtlSymbolLarge timeLogLayerSym = g_pDataModel->GetSymbol( "DmeTimeLogLayer" );
|
|
|
|
CUtlSymbolLarge typeSym = pElement->GetType();
|
|
if ( typeSym == logLayerSym
|
|
|| typeSym == intLogLayerSym
|
|
|| typeSym == floatLogLayerSym
|
|
|| typeSym == boolLogLayerSym
|
|
|| typeSym == colorLogLayerSym
|
|
|| typeSym == vec2LogLayerSym
|
|
|| typeSym == vec3LogLayerSym
|
|
|| typeSym == vec4LogLayerSym
|
|
|| typeSym == qangleLogLayerSym
|
|
|| typeSym == quatLogLayerSym
|
|
|| typeSym == vmatrixLogLayerSym
|
|
|| typeSym == stringLogLayerSym
|
|
|| typeSym == timeLogLayerSym )
|
|
{
|
|
return ConvertIntArrayToTimeArray( pElement->GetAttribute( "times" ) );
|
|
}
|
|
|
|
if ( typeSym == comboOpSym )
|
|
{
|
|
CDmAttribute *pControlsAttr = pElement->GetAttribute( "controls", AT_ELEMENT_ARRAY );
|
|
CDmAttribute *pControlValuesAttr = pElement->GetAttribute( "controlValues", AT_VECTOR3_ARRAY );
|
|
CDmAttribute *pControlValuesLaggedAttr = pElement->GetAttribute( "controlValuesLagged", AT_VECTOR3_ARRAY );
|
|
if ( !pControlsAttr || !pControlValuesAttr || !pControlValuesLaggedAttr )
|
|
return false;
|
|
|
|
CDmrElementArray<> controls( pControlsAttr );
|
|
CDmrArray< Vector > controlValues( pControlValuesAttr );
|
|
CDmrArray< Vector > controlValuesLagged( pControlValuesLaggedAttr );
|
|
|
|
int nControls = controls.Count();
|
|
for ( int i = 0; i < nControls; ++i )
|
|
{
|
|
CDmElement *pControl = controls[ i ];
|
|
if ( !pControl || !pControl->GetValue<bool>( "stereo" ) )
|
|
continue;
|
|
|
|
CDmAttribute *pRawControlNames = pControl->GetAttribute( "rawControlNames", AT_STRING_ARRAY );
|
|
if ( !pRawControlNames )
|
|
continue;
|
|
|
|
CDmrStringArray rawControlNames( pRawControlNames );
|
|
float flDefaultValue = rawControlNames.Count() == 2 ? 0.5f : 0.0f;
|
|
|
|
float flLeftValue, flRightValue;
|
|
|
|
Vector cv = controlValues[ i ];
|
|
ValueBalanceToLeftRight( &flLeftValue, &flRightValue, cv.x, cv.y, flDefaultValue );
|
|
controlValues.Set( i, Vector( flLeftValue, flRightValue, cv.z ) );
|
|
|
|
Vector cvl = controlValuesLagged[ i ];
|
|
ValueBalanceToLeftRight( &flLeftValue, &flRightValue, cvl.x, cvl.y, flDefaultValue );
|
|
controlValuesLagged.Set( i, Vector( flLeftValue, flRightValue, cvl.z ) );
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
if ( typeSym == presetSym )
|
|
{
|
|
return UpdatePreset( pElement );
|
|
}
|
|
|
|
if ( typeSym == animSetSym )
|
|
{
|
|
CDmElement *pFilmClip = FindReferringElement< CDmElement >( pElement, "animationSets" );
|
|
if ( !pFilmClip )
|
|
return true;
|
|
|
|
// remove multi from controls, and move multilevel, defaultMultilevel and multilevelChannel to new _alt control
|
|
// split preset multilevel controlValues into new controlValue
|
|
// put new _alt control into same selection group as original
|
|
|
|
// convert stereo controls from value/balance to left/right
|
|
// - convert old VB into new LR, remove VB attributes
|
|
// - convert and copy old VB log data into LR log data, and delete VB channels and logs
|
|
CDmAttribute *pControlsAttr = pElement->GetAttribute( "controls", AT_ELEMENT_ARRAY );
|
|
if ( pControlsAttr )
|
|
{
|
|
CDmrElementArray<> controls( pControlsAttr );
|
|
int nControls = controls.Count();
|
|
for ( int ci = 0; ci < nControls; ++ci )
|
|
{
|
|
CDmElement *pControl = controls[ ci ];
|
|
if ( !pControl )
|
|
continue;
|
|
|
|
if ( !pControl->GetValue<bool>( "multi", false ) )
|
|
{
|
|
// these shouldn't be here anyways, but sometimes they are so...
|
|
pControl->RemoveAttribute( "multilevel" );
|
|
pControl->RemoveAttribute( "defaultMultilevel" );
|
|
pControl->RemoveAttribute( "multilevelchannel" );
|
|
}
|
|
|
|
if ( !pControl->GetValue<bool>( "combo", false ) )
|
|
{
|
|
// these shouldn't be here anyways, but sometimes they are so...
|
|
pControl->RemoveAttribute( "balance" );
|
|
pControl->RemoveAttribute( "defaultBalance" );
|
|
pControl->RemoveAttribute( "balancechannel" );
|
|
continue;
|
|
}
|
|
|
|
float flValue = pControl->GetValue<float>( "value" );
|
|
float flBalance = pControl->GetValue<float>( "balance" );
|
|
|
|
float flDefaultValue = pControl->GetValue<float>( "defaultValue" );
|
|
float flDefaultBalance = pControl->GetValue<float>( "defaultBalance" );
|
|
|
|
CDmElement *pValueChannel = pControl->GetValueElement< CDmElement >( "valuechannel" );
|
|
CDmElement *pBalanceChannel = pControl->GetValueElement< CDmElement >( "balancechannel" );
|
|
|
|
pControl->RemoveAttribute( "value" );
|
|
pControl->RemoveAttribute( "balance" );
|
|
pControl->RemoveAttribute( "defaultValue" );
|
|
pControl->RemoveAttribute( "defaultBalance" );
|
|
pControl->RemoveAttribute( "valuechannel" );
|
|
pControl->RemoveAttribute( "balancechannel" );
|
|
|
|
float flLeftValue, flRightValue;
|
|
ValueBalanceToLeftRight( &flLeftValue, &flRightValue, flValue, flBalance, flDefaultValue );
|
|
pControl->SetValue( "leftValue", flLeftValue );
|
|
pControl->SetValue( "rightValue", flRightValue );
|
|
|
|
float flLeftDefaultValue, flRightDefaultValue;
|
|
ValueBalanceToLeftRight( &flLeftDefaultValue, &flRightDefaultValue, flDefaultValue, flDefaultBalance, 0.0f ); // this is kind of silly, since we expect flDefaultBalance to always be 0.5
|
|
pControl->SetValue( "defaultLeftValue", flLeftDefaultValue );
|
|
pControl->SetValue( "defaultRightValue", flRightDefaultValue );
|
|
|
|
if ( !pValueChannel || !pBalanceChannel )
|
|
continue;
|
|
|
|
CDmElement *pChannelsClip = FindChannelsClipForChannel( pFilmClip, pValueChannel );
|
|
Assert( pChannelsClip == FindChannelsClipForChannel( pFilmClip, pBalanceChannel ) );
|
|
if ( !pChannelsClip )
|
|
continue;
|
|
|
|
CDmAttribute *pChannelsAttr = pChannelsClip->GetAttribute( "channels" );
|
|
if ( !pChannelsAttr )
|
|
continue;
|
|
|
|
CDmrElementArray<> channels( pChannelsAttr );
|
|
channels.Remove( channels.Find( pValueChannel ) );
|
|
channels.Remove( channels.Find( pBalanceChannel ) );
|
|
|
|
CDmElement *pVB2LRCalcOp = pValueChannel->GetValueElement< CDmElement >( "toElement" );
|
|
Assert( pVB2LRCalcOp == pBalanceChannel->GetValueElement< CDmElement >( "toElement" ) );
|
|
|
|
CDmElement *pLeftChannel = FindChannelTargettingElement( pVB2LRCalcOp, "result_left", true );
|
|
CDmElement *pRightChannel = FindChannelTargettingElement( pVB2LRCalcOp, "result_right", true );
|
|
if ( !pLeftChannel || !pRightChannel )
|
|
return false;
|
|
|
|
pControl->SetValue( "leftvaluechannel", pLeftChannel );
|
|
pControl->SetValue( "rightvaluechannel", pRightChannel );
|
|
|
|
int nChannelMode = pValueChannel->GetValue< int >( "mode" );
|
|
pLeftChannel ->SetValue( "fromElement", pControl );
|
|
pLeftChannel ->SetValue( "fromAttribute", "leftValue" );
|
|
pLeftChannel ->SetValue( "mode", nChannelMode );
|
|
pRightChannel->SetValue( "fromElement", pControl );
|
|
pRightChannel->SetValue( "fromAttribute", "rightValue" );
|
|
pRightChannel->SetValue( "mode", nChannelMode );
|
|
|
|
CDmElement *pValueLog = GetLogLayerFromChannel( pValueChannel );
|
|
CDmElement *pBalanceLog = GetLogLayerFromChannel( pBalanceChannel );
|
|
CDmElement *pLeftLog = GetLogLayerFromChannel( pLeftChannel );
|
|
CDmElement *pRightLog = GetLogLayerFromChannel( pRightChannel );
|
|
if ( !pValueLog || !pBalanceLog || !pLeftLog || !pRightLog )
|
|
continue;
|
|
|
|
// doing this on-demand, in case the loglayer wasn't reached directly yet
|
|
if ( !ConvertIntArrayToTimeArray( pValueLog->GetAttribute( "times" ) ) ||
|
|
!ConvertIntArrayToTimeArray( pBalanceLog->GetAttribute( "times" ) ) )
|
|
return false;
|
|
|
|
const CUtlVector< DmeTime_t > &valueTimes = pValueLog ->GetValue< CUtlVector< DmeTime_t > >( "times" );
|
|
const CUtlVector< float > &valueValues = pValueLog ->GetValue< CUtlVector< float > >( "values" );
|
|
const CUtlVector< DmeTime_t > &balanceTimes = pBalanceLog->GetValue< CUtlVector< DmeTime_t > >( "times" );
|
|
const CUtlVector< float > &balanceValues = pBalanceLog->GetValue< CUtlVector< float > >( "values" );
|
|
|
|
CDmAttribute *pLeftTimesAttr = pLeftLog ->GetAttribute( "times" );
|
|
CDmAttribute *pLeftValuesAttr = pLeftLog ->GetAttribute( "values", AT_FLOAT_ARRAY );
|
|
CDmAttribute *pRightTimesAttr = pRightLog->GetAttribute( "times" );
|
|
CDmAttribute *pRightValuesAttr = pRightLog->GetAttribute( "values", AT_FLOAT_ARRAY );
|
|
|
|
if ( !pLeftTimesAttr || !pLeftValuesAttr || !pRightTimesAttr || !pRightValuesAttr )
|
|
return false;
|
|
|
|
// doing this on-demand, in case the loglayer wasn't reached directly yet
|
|
if ( !ConvertIntArrayToTimeArray( pLeftTimesAttr ) ||
|
|
!ConvertIntArrayToTimeArray( pRightTimesAttr ) )
|
|
return false;
|
|
|
|
CDmrArray< DmeTime_t > leftTimes ( pLeftTimesAttr );
|
|
CDmrArray< float > leftValues ( pLeftValuesAttr );
|
|
CDmrArray< DmeTime_t > rightTimes ( pRightTimesAttr );
|
|
CDmrArray< float > rightValues( pRightValuesAttr );
|
|
|
|
// convert and copy log data
|
|
int vi = 0, bi = 0;
|
|
int vn = valueTimes.Count(), bn = balanceTimes.Count();
|
|
leftTimes .EnsureCapacity( MAX( vn, bn ) );
|
|
leftValues .EnsureCapacity( MAX( vn, bn ) );
|
|
rightTimes .EnsureCapacity( MAX( vn, bn ) );
|
|
rightValues.EnsureCapacity( MAX( vn, bn ) );
|
|
while ( vi < vn || bi < bn )
|
|
{
|
|
float value, balance;
|
|
DmeTime_t t;
|
|
if ( vi >= vn )
|
|
{
|
|
t = balanceTimes[ bi ];
|
|
value = vn > 0 ? valueValues[ vn - 1 ] : flDefaultValue;
|
|
balance = balanceValues[ bi ];
|
|
++bi;
|
|
}
|
|
else if ( bi >= bn )
|
|
{
|
|
t = valueTimes[ vi ];
|
|
value = valueValues[ vi ];
|
|
balance = bn > 0 ? balanceValues[ bn - 1 ] : flDefaultBalance;
|
|
++vi;
|
|
}
|
|
else
|
|
{
|
|
DmeTime_t vt = valueTimes [ vi ];
|
|
DmeTime_t bt = balanceTimes[ bi ];
|
|
value = valueValues [ vi ];
|
|
balance = balanceValues[ bi ];
|
|
if ( vt < bt )
|
|
{
|
|
t = vt;
|
|
if ( bi > 0 )
|
|
{
|
|
float f = ( t - balanceTimes[ bi - 1 ] ) / ( bt - balanceTimes[ bi - 1 ] );
|
|
balance = Lerp( f, balanceValues[ bi - 1 ], balance );
|
|
}
|
|
++vi;
|
|
}
|
|
else if ( bt < vt )
|
|
{
|
|
t = bt;
|
|
if ( vi > 0 )
|
|
{
|
|
float f = ( t - valueTimes[ vi - 1 ] ) / ( vt - valueTimes[ vi - 1 ] );
|
|
value = Lerp( f, valueValues[ vi - 1 ], value );
|
|
}
|
|
++bi;
|
|
}
|
|
else
|
|
{
|
|
t = vt;
|
|
++vi;
|
|
++bi;
|
|
}
|
|
}
|
|
|
|
float left, right;
|
|
ValueBalanceToLeftRight( &left, &right, value, balance, flDefaultValue );
|
|
|
|
leftTimes .AddToTail( t );
|
|
rightTimes.AddToTail( t );
|
|
leftValues .AddToTail( left );
|
|
rightValues.AddToTail( right );
|
|
|
|
}
|
|
|
|
// NOTE - with non-typed elements, TD_SHALLOW == TD_NONE and TD_DEEP == TD_ALL
|
|
DestroyElement( pValueChannel, TD_NONE );
|
|
DestroyElement( pValueLog, TD_ALL );
|
|
DestroyElement( pBalanceChannel, TD_NONE );
|
|
DestroyElement( pBalanceLog, TD_ALL );
|
|
}
|
|
}
|
|
|
|
// remove and delete BalanceToStereoCalculatorOperators
|
|
CDmAttribute *pOperatorsAttr = pElement->GetAttribute( "operators" );
|
|
if ( pOperatorsAttr )
|
|
{
|
|
const static CUtlSymbolLarge balanceToStereoSym = g_pDataModel->GetSymbol( "DmeBalanceToStereoCalculatorOperator" );
|
|
CDmrElementArray<> operators( pOperatorsAttr );
|
|
int nOperators = operators.Count();
|
|
for ( int i = nOperators-1; i >= 0; --i )
|
|
{
|
|
CDmElement *pOperator = operators[ i ];
|
|
if ( pOperator && pOperator->GetType() != balanceToStereoSym )
|
|
continue;
|
|
|
|
DestroyElement( pOperator, TD_NONE ); // NOTE - with non-typed elements, TD_SHALLOW == TD_NONE and TD_DEEP == TD_ALL
|
|
operators.Remove( i );
|
|
}
|
|
}
|
|
|
|
// convert preset control values from VB to LR
|
|
CDmAttribute *pPresetGroupsAttr = pElement->GetAttribute( "presetGroups", AT_ELEMENT_ARRAY );
|
|
if ( pPresetGroupsAttr )
|
|
{
|
|
CDmrElementArray<> presetGroups( pPresetGroupsAttr );
|
|
int nPresetGroups = presetGroups.Count();
|
|
for ( int gi = 0; gi < nPresetGroups; ++gi )
|
|
{
|
|
CDmElement *pPresetGroup = presetGroups[ gi ];
|
|
if ( !pPresetGroup )
|
|
continue;
|
|
|
|
CDmAttribute *pPresetsAttr = pPresetGroup->GetAttribute( "presets", AT_ELEMENT_ARRAY );
|
|
if ( !pPresetsAttr )
|
|
continue;
|
|
|
|
CDmrElementArray<> presets( pPresetsAttr );
|
|
int nPresets = presets.Count();
|
|
for ( int pi = 0; pi < nPresets; ++pi )
|
|
{
|
|
if ( !UpdatePreset( presets[ pi ] ) )
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
static CDmElement *FindAnimSetControlByName( CDmrElementArray<> &array, char const *pchControlName, int *pIndex )
|
|
{
|
|
Assert( pIndex );
|
|
*pIndex = array.InvalidIndex();
|
|
|
|
for ( int i = 0; i < array.Count(); ++i )
|
|
{
|
|
CDmElement *e = array[ i ];
|
|
if ( !Q_stricmp( e->GetName(), pchControlName ) )
|
|
{
|
|
*pIndex = i;
|
|
return e;
|
|
}
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
bool Update2( CDmElement *pElement )
|
|
{
|
|
const char *g_pControlType[] = { "isPosition", "isOrientation" };
|
|
const char *g_pSuffix[] = { "pos", "rot" };
|
|
|
|
const static CUtlSymbolLarge animSetSym = g_pDataModel->GetSymbol( "DmeAnimationSet" );
|
|
|
|
CUtlSymbolLarge typeSym = pElement->GetType();
|
|
if ( typeSym == animSetSym )
|
|
{
|
|
// Split transform controls out from the groups
|
|
// Add the isPosition/isOrientation and baseName bools/string
|
|
// Split the actual controls for transforms
|
|
|
|
// First find the selectionGroups attribute and the controls attribute
|
|
CDmAttribute *pGroupsAttr = pElement->GetAttribute( "selectionGroups", AT_ELEMENT_ARRAY );
|
|
CDmAttribute *pControlsAttr = pElement->GetAttribute( "controls", AT_ELEMENT_ARRAY );
|
|
|
|
if ( pGroupsAttr && pControlsAttr )
|
|
{
|
|
CDmrElementArray<> groups( pGroupsAttr );
|
|
CDmrElementArray<> controls( pControlsAttr );
|
|
|
|
// Walk through groups and for the controls which point to transforms, build the subgroups
|
|
int c = groups.Count();
|
|
for ( int i = 0; i < c; ++i )
|
|
{
|
|
CDmElement *pGroup = groups[ i ];
|
|
CDmAttribute *temp = pGroup->GetAttribute( "selectedControls", AT_STRING_ARRAY );
|
|
CDmrStringArray temp2( temp );
|
|
|
|
pGroup->RenameAttribute( "selectedControls", "selectedControls2" );
|
|
CDmAttribute *pControlsAttr = pGroup->GetAttribute( "selectedControls2", AT_STRING_ARRAY );
|
|
// First convert all of the string array stuff into an element array
|
|
if ( pControlsAttr )
|
|
{
|
|
CDmrStringArray controlsInGroup( pControlsAttr );
|
|
|
|
CDmAttribute *pNewControlsAttr = pGroup->AddAttribute( "controls", AT_ELEMENT_ARRAY );
|
|
CDmrElementArray< CDmElement > newControls( pNewControlsAttr );
|
|
|
|
for ( int j = 0 ; j < controlsInGroup.Count(); ++j )
|
|
{
|
|
char const *pchControlName = controlsInGroup[ j ];
|
|
|
|
CDmElement *pNewControl = CreateElement< CDmElement >( pchControlName, pElement->GetFileId() );
|
|
pNewControl->SetParity( pElement->GetParity() );
|
|
// Assume the new ones are not groups
|
|
pNewControl->SetValue< bool >( "isGroup", false );
|
|
newControls.AddToTail( pNewControl );
|
|
}
|
|
|
|
// Discard the old one
|
|
pGroup->RemoveAttribute( "selectedControls2" );
|
|
}
|
|
|
|
pGroup->SetValue< bool >( "isGroup", true );
|
|
}
|
|
|
|
// In the 2nd pass, create the subgroups for the transforms and update the "controls" array accordingly
|
|
for ( int i = 0; i < c; ++i )
|
|
{
|
|
CDmElement *pGroup = groups[ i ];
|
|
CDmAttribute *pControlsAttr = pGroup->GetAttribute( "controls", AT_ELEMENT_ARRAY );
|
|
if ( pControlsAttr )
|
|
{
|
|
CDmrElementArray< CDmElement > controlsInGroup( pControlsAttr );
|
|
for ( int j = 0 ; j < controlsInGroup.Count(); ++j )
|
|
{
|
|
char const *pchControlName = controlsInGroup[ j ]->GetName();
|
|
|
|
// Now that we have a control, we'll see if it corresponds to a transform
|
|
int nIndex = controls.InvalidIndex();
|
|
CDmElement *pControl = FindAnimSetControlByName( controls, pchControlName, &nIndex );
|
|
if ( pControl && pControl->GetValue< bool >( "transform" ) )
|
|
{
|
|
controlsInGroup[ j ]->SetValue< bool >( "isGroup", true );
|
|
CDmAttribute *pNewControlsAttr = controlsInGroup[ j ]->AddAttribute( "controls", AT_ELEMENT_ARRAY );
|
|
CDmrElementArray< CDmElement > newControls( pNewControlsAttr );
|
|
|
|
CUtlVector< CDmElement * > added;
|
|
|
|
// Build the pos and rot versions
|
|
for ( int k = 0; k < 2; ++k )
|
|
{
|
|
CDmElement *control = CreateElement< CDmElement >( CFmtStr( "%s - %s", pchControlName, g_pSuffix[ k ] ), pElement->GetFileId() );
|
|
control->SetParity( pElement->GetParity() );
|
|
control->SetValue< bool >( "transform", true );
|
|
control->SetValue< bool >( g_pControlType[ k ], true );
|
|
control->SetValue< bool >( g_pControlType[ 1 - k ], false );
|
|
control->SetValue( "baseName", pchControlName );
|
|
|
|
if ( k == 0 )
|
|
{
|
|
control->SetValue< Vector >( "valuePosition", pControl->GetValue< Vector >( "valuePosition" ) );
|
|
|
|
CDmElement *p = pControl->GetValueElement< CDmElement >( "position" );
|
|
if ( p )
|
|
{
|
|
control->SetValue< CDmElement >( "position", p );
|
|
// Now find the position channel's "from" and set it to the new control
|
|
p->SetValue< CDmElement >( "fromElement", control );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
control->SetValue< Quaternion >( "valueOrientation", pControl->GetValue< Quaternion >( "valueOrientation" ) );
|
|
CDmElement *p = pControl->GetValueElement< CDmElement >( "orientation" );
|
|
if ( p )
|
|
{
|
|
control->SetValue< CDmElement >( "orientation", p );
|
|
// Now find the orientation channel's "from" and set it to the new control
|
|
p->SetValue< CDmElement >( "fromElement", control );
|
|
}
|
|
}
|
|
|
|
added.AddToTail( control );
|
|
|
|
CDmElement *groupControl = CreateElement< CDmElement >( CFmtStr( "%s - %s", pchControlName, g_pSuffix[ k ] ), pElement->GetFileId() );
|
|
groupControl->SetParity( pElement->GetParity() );
|
|
groupControl->SetValue< bool >( "isGroup", false );
|
|
newControls.AddToTail( groupControl );
|
|
}
|
|
|
|
// Remove the singular one and replace with paired ones
|
|
controls.Remove( nIndex );
|
|
|
|
for ( int k = 0; k < 2; ++k )
|
|
{
|
|
controls.AddToTail( added[ k ] );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool Update1( CDmElement *pElement )
|
|
{
|
|
// remove lights attribute from filmclips
|
|
|
|
const static CUtlSymbolLarge projectedLightSym = g_pDataModel->GetSymbol( "DmeProjectedLight" );
|
|
const static CUtlSymbolLarge filmClipSym = g_pDataModel->GetSymbol( "DmeFilmClip" );
|
|
const static CUtlSymbolLarge bookmarkSym = g_pDataModel->GetSymbol( "DmeBookmark" );
|
|
const static CUtlSymbolLarge timeframeSym = g_pDataModel->GetSymbol( "DmeTimeFrame" );
|
|
const static CUtlSymbolLarge timeSelectionSym = g_pDataModel->GetSymbol( "DmeTimeSelection" );
|
|
const static CUtlSymbolLarge proceduralPresetSym = g_pDataModel->GetSymbol( "DmeProceduralPresetSettings" );
|
|
const static CUtlSymbolLarge gameParticleSysSym = g_pDataModel->GetSymbol( "DmeGameParticleSystem" );
|
|
const static CUtlSymbolLarge cameraSym = g_pDataModel->GetSymbol( "DmeCamera" );
|
|
|
|
const static CUtlSymbolLarge intCurveInfoSym = g_pDataModel->GetSymbol( "DmeIntCurveInfo" );
|
|
const static CUtlSymbolLarge floatCurveInfoSym = g_pDataModel->GetSymbol( "DmeFloatCurveInfo" );
|
|
const static CUtlSymbolLarge boolCurveInfoSym = g_pDataModel->GetSymbol( "DmeBoolCurveInfo" );
|
|
const static CUtlSymbolLarge colorCurveInfoSym = g_pDataModel->GetSymbol( "DmeColorCurveInfo" );
|
|
const static CUtlSymbolLarge vec2CurveInfoSym = g_pDataModel->GetSymbol( "DmeVector2CurveInfo" );
|
|
const static CUtlSymbolLarge vec3CurveInfoSym = g_pDataModel->GetSymbol( "DmeVector3CurveInfo" );
|
|
const static CUtlSymbolLarge vec4CurveInfoSym = g_pDataModel->GetSymbol( "DmeVector4CurveInfo" );
|
|
const static CUtlSymbolLarge qangleCurveInfoSym = g_pDataModel->GetSymbol( "DmeQAngleCurveInfo" );
|
|
const static CUtlSymbolLarge quatCurveInfoSym = g_pDataModel->GetSymbol( "DmeQuaternionCurveInfo" );
|
|
const static CUtlSymbolLarge vmatrixCurveInfoSym = g_pDataModel->GetSymbol( "DmeVMatrixCurveInfo" );
|
|
const static CUtlSymbolLarge stringCurveInfoSym = g_pDataModel->GetSymbol( "DmeStringCurveInfo" );
|
|
const static CUtlSymbolLarge timeCurveInfoSym = g_pDataModel->GetSymbol( "DmeTimeCurveInfo" );
|
|
|
|
CUtlSymbolLarge typeSym = pElement->GetType();
|
|
if ( typeSym == projectedLightSym )
|
|
{
|
|
pElement->RemoveAttribute( "textureFrame" );
|
|
|
|
ChangeAttributeType( pElement, "animationTime", AT_TIME );
|
|
}
|
|
else if ( typeSym == filmClipSym )
|
|
{
|
|
pElement->RemoveAttribute( "lights" );
|
|
|
|
ChangeAttributeType( pElement, "fadeIn", AT_TIME );
|
|
ChangeAttributeType( pElement, "fadeOut", AT_TIME );
|
|
}
|
|
else if ( typeSym == bookmarkSym )
|
|
{
|
|
ChangeAttributeType( pElement, "time", AT_TIME );
|
|
ChangeAttributeType( pElement, "duration", AT_TIME );
|
|
}
|
|
else if ( typeSym == timeframeSym )
|
|
{
|
|
pElement->RenameAttribute( "startTime", "start" );
|
|
pElement->RenameAttribute( "durationTime", "duration" );
|
|
pElement->RenameAttribute( "offsetTime", "offset" );
|
|
ChangeAttributeType( pElement, "start", AT_TIME );
|
|
ChangeAttributeType( pElement, "duration", AT_TIME );
|
|
ChangeAttributeType( pElement, "offset", AT_TIME );
|
|
}
|
|
else if ( typeSym == timeSelectionSym )
|
|
{
|
|
ChangeAttributeType( pElement, "falloff_left", AT_TIME );
|
|
ChangeAttributeType( pElement, "falloff_right", AT_TIME );
|
|
ChangeAttributeType( pElement, "hold_left", AT_TIME );
|
|
ChangeAttributeType( pElement, "hold_right", AT_TIME );
|
|
ChangeAttributeType( pElement, "resampleinterval", AT_TIME );
|
|
}
|
|
else if ( typeSym == proceduralPresetSym )
|
|
{
|
|
ChangeAttributeType( pElement, "staggerinterval", AT_TIME );
|
|
}
|
|
else if ( typeSym == gameParticleSysSym )
|
|
{
|
|
ChangeAttributeType( pElement, "simulationTime", AT_TIME );
|
|
ChangeAttributeType( pElement, "startTime", AT_TIME );
|
|
ChangeAttributeType( pElement, "emissionStopTime", AT_TIME );
|
|
ChangeAttributeType( pElement, "endTime", AT_TIME );
|
|
}
|
|
else if ( typeSym == cameraSym )
|
|
{
|
|
ChangeAttributeType( pElement, "shutterSpeed", AT_TIME );
|
|
}
|
|
else if ( typeSym == intCurveInfoSym
|
|
|| typeSym == floatCurveInfoSym
|
|
|| typeSym == boolCurveInfoSym
|
|
|| typeSym == colorCurveInfoSym
|
|
|| typeSym == vec2CurveInfoSym
|
|
|| typeSym == vec3CurveInfoSym
|
|
|| typeSym == vec4CurveInfoSym
|
|
|| typeSym == qangleCurveInfoSym
|
|
|| typeSym == quatCurveInfoSym
|
|
|| typeSym == vmatrixCurveInfoSym
|
|
|| typeSym == stringCurveInfoSym
|
|
|| typeSym == timeCurveInfoSym )
|
|
{
|
|
ChangeAttributeType( pElement, "rightEdgeTime", AT_TIME );
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
static char *s_RemapOperatorNameTable[]={
|
|
"alpha_fade", "Alpha Fade and Decay",
|
|
"alpha_fade_in_random", "Alpha Fade In Random",
|
|
"alpha_fade_out_random", "Alpha Fade Out Random",
|
|
"basic_movement", "Movement Basic",
|
|
"color_fade", "Color Fade",
|
|
"controlpoint_light", "Color Light From Control Point",
|
|
"Dampen Movement Relative to Control Point", "Movement Dampen Relative to Control Point",
|
|
"Distance Between Control Points Scale", "Remap Distance Between Two Control Points to Scalar",
|
|
"Distance to Control Points Scale", "Remap Distance to Control Point to Scalar",
|
|
"lifespan_decay", "Lifespan Decay",
|
|
"lock to bone", "Movement Lock to Bone",
|
|
"postion_lock_to_controlpoint", "Movement Lock to Control Point",
|
|
"maintain position along path", "Movement Maintain Position Along Path",
|
|
"Match Particle Velocities", "Movement Match Particle Velocities",
|
|
"Max Velocity", "Movement Max Velocity",
|
|
"noise", "Noise Scalar",
|
|
"vector noise", "Noise Vector",
|
|
"oscillate_scalar", "Oscillate Scalar",
|
|
"oscillate_vector", "Oscillate Vector",
|
|
"Orient Rotation to 2D Direction", "Rotation Orient to 2D Direction",
|
|
"radius_scale", "Radius Scale",
|
|
"Random Cull", "Cull Random",
|
|
"remap_scalar", "Remap Scalar",
|
|
"rotation_movement", "Rotation Basic",
|
|
"rotation_spin", "Rotation Spin Roll",
|
|
"rotation_spin yaw", "Rotation Spin Yaw",
|
|
"alpha_random", "Alpha Random",
|
|
"color_random", "Color Random",
|
|
"create from parent particles", "Position From Parent Particles",
|
|
"Create In Hierarchy", "Position In CP Hierarchy",
|
|
"random position along path", "Position Along Path Random",
|
|
"random position on model", "Position on Model Random",
|
|
"sequential position along path", "Position Along Path Sequential",
|
|
"position_offset_random", "Position Modify Offset Random",
|
|
"position_warp_random", "Position Modify Warp Random",
|
|
"position_within_box", "Position Within Box Random",
|
|
"position_within_sphere", "Position Within Sphere Random",
|
|
"Inherit Velocity", "Velocity Inherit from Control Point",
|
|
"Initial Repulsion Velocity", "Velocity Repulse from World",
|
|
"Initial Velocity Noise", "Velocity Noise",
|
|
"Initial Scalar Noise", "Remap Noise to Scalar",
|
|
"Lifespan from distance to world", "Lifetime from Time to Impact",
|
|
"Pre-Age Noise", "Lifetime Pre-Age Noise",
|
|
"lifetime_random", "Lifetime Random",
|
|
"radius_random", "Radius Random",
|
|
"random yaw", "Rotation Yaw Random",
|
|
"Randomly Flip Yaw", "Rotation Yaw Flip Random",
|
|
"rotation_random", "Rotation Random",
|
|
"rotation_speed_random", "Rotation Speed Random",
|
|
"sequence_random", "Sequence Random",
|
|
"second_sequence_random", "Sequence Two Random",
|
|
"trail_length_random", "Trail Length Random",
|
|
"velocity_random", "Velocity Random",
|
|
};
|
|
|
|
bool Update5( CDmElement *pElement )
|
|
{
|
|
const static CUtlSymbolLarge ParticleOperatorSym = g_pDataModel->GetSymbol( "DmeParticleOperator" );
|
|
|
|
CUtlSymbolLarge typeSym = pElement->GetType();
|
|
|
|
if ( typeSym == ParticleOperatorSym )
|
|
{
|
|
const char *pOpName = pElement->GetValueString( "functionName" );
|
|
for( int i = 0 ; i < ARRAYSIZE( s_RemapOperatorNameTable ) ; i += 2 )
|
|
{
|
|
if ( Q_stricmp( pOpName, s_RemapOperatorNameTable[i] ) == 0 )
|
|
{
|
|
pElement->SetValueFromString( "functionName", s_RemapOperatorNameTable[i + 1 ] );
|
|
// pElement->SetValueFromString( "name", s_RemapOperatorNameTable[i + 1 ] );
|
|
pElement->SetName( s_RemapOperatorNameTable[i + 1 ] );
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
bool UpdateElement_R( FnUpdater pfnUpdate, CDmElement **ppElement, bool bParity )
|
|
{
|
|
CDmElement *pElement = *ppElement;
|
|
if ( pElement->GetParity() == bParity )
|
|
return true; // already visited
|
|
|
|
pElement->SetParity( bParity );
|
|
|
|
if ( !pfnUpdate( pElement ) )
|
|
return false;
|
|
|
|
for ( CDmAttribute *pAttribute = pElement->FirstAttribute(); pAttribute; pAttribute = pAttribute->NextAttribute() )
|
|
{
|
|
if ( pAttribute->GetType() == AT_ELEMENT )
|
|
{
|
|
CDmElement *pElement = pAttribute->GetValueElement< CDmElement >();
|
|
if ( pElement )
|
|
{
|
|
if ( !UpdateElement_R( pfnUpdate, &pElement, bParity ) )
|
|
return false;
|
|
pAttribute->SetValue< CDmElement >( pElement );
|
|
}
|
|
continue;
|
|
}
|
|
|
|
if ( pAttribute->GetType() == AT_ELEMENT_ARRAY )
|
|
{
|
|
CDmrElementArray<> array( pAttribute );
|
|
int nCount = array.Count();
|
|
for ( int i = 0; i < nCount; ++i )
|
|
{
|
|
CDmElement *pChild = array[ i ];
|
|
if ( pChild )
|
|
{
|
|
if ( !UpdateElement_R( pfnUpdate, &pChild, bParity ) )
|
|
return false;
|
|
array.Set( i, pChild );
|
|
}
|
|
}
|
|
continue;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
IMPLEMENT_UPDATER( 1 ); // Creates Update1_R, which requires an Update1 func
|
|
IMPLEMENT_UPDATER( 2 );
|
|
IMPLEMENT_UPDATER( 3 );
|
|
IMPLEMENT_UPDATER( 4 );
|
|
IMPLEMENT_UPDATER( 5 );
|
|
IMPLEMENT_UPDATER( 6 );
|
|
IMPLEMENT_UPDATER( 7 );
|
|
IMPLEMENT_UPDATER( 8 );
|
|
IMPLEMENT_UPDATER( 9 );
|
|
IMPLEMENT_UPDATER( 10 );
|
|
IMPLEMENT_UPDATER( 11 );
|
|
IMPLEMENT_UPDATER( 12 );
|
|
IMPLEMENT_UPDATER( 13 );
|
|
IMPLEMENT_UPDATER( 14 );
|
|
IMPLEMENT_UPDATER( 15 );
|
|
IMPLEMENT_UPDATER( 16 );
|
|
IMPLEMENT_UPDATER( 17 );
|
|
IMPLEMENT_UPDATER( 18 );
|
|
IMPLEMENT_UPDATER( 19 );
|
|
|
|
|
|
typedef bool (*ElementUpdateFunction)( CDmElement **pRoot, bool bParity );
|
|
ElementUpdateFunction EmptyUpdateFunctionList[] = { NULL };
|
|
ElementUpdateFunction PresetUpdateFunctionList[] = { Update3_R, Update4_R, Update10_R, NULL };
|
|
ElementUpdateFunction MovieObjectsUpdateFunctionList[] =
|
|
{
|
|
Update1_R, Update2_R, Update3_R, Update4_R, Update6_R, Update7_R, Update8_R, Update9_R,
|
|
Update10_R, Update11_R, Update12_R, Update13_R, Update14_R, Update15_R, Update17_R, Update18_R, Update19_R, NULL
|
|
};
|
|
ElementUpdateFunction SFMSessionObjectsUpdateFunctionList[] =
|
|
{
|
|
Update1_R, Update2_R, Update3_R, Update4_R, Update6_R, Update7_R, Update8_R, Update9_R,
|
|
Update10_R, Update11_R, Update12_R, Update13_R, Update14_R, Update15_R, Update16_R, Update17_R, Update18_R, Update19_R, NULL
|
|
};
|
|
ElementUpdateFunction ParticleUpdateFunctionList[] = { Update5_R, NULL };
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// declare format updaters
|
|
//-----------------------------------------------------------------------------
|
|
|
|
DECLARE_FORMAT_UPDATER( dmx, "Generic DMX", "dmx", "binary", MovieObjectsUpdateFunctionList )
|
|
DECLARE_FORMAT_UPDATER( movieobjects, "Generic MovieObjects", "dmx", "binary", MovieObjectsUpdateFunctionList )
|
|
DECLARE_FORMAT_UPDATER( sfm, "Generic SFM", "dmx", "binary", MovieObjectsUpdateFunctionList )
|
|
DECLARE_FORMAT_UPDATER( sfm_settings, "SFM Settings", "dmx", "keyvalues2",MovieObjectsUpdateFunctionList )
|
|
DECLARE_FORMAT_UPDATER( sfm_session, "SFM Session", "dmx", "binary", SFMSessionObjectsUpdateFunctionList )
|
|
DECLARE_FORMAT_UPDATER( sfm_trackgroup, "SFM TrackGroup", "dmx", "binary", MovieObjectsUpdateFunctionList )
|
|
DECLARE_FORMAT_UPDATER( pcf, "Particle Configuration File", "pcf", "binary", ParticleUpdateFunctionList )
|
|
DECLARE_FORMAT_UPDATER( preset, "Preset File", "dmx", "keyvalues2",PresetUpdateFunctionList )
|
|
DECLARE_FORMAT_UPDATER( facial_animation, "Facial Animation File", "dmx", "binary", MovieObjectsUpdateFunctionList )
|
|
DECLARE_FORMAT_UPDATER( model, "DMX Model", "dmx", "binary", MovieObjectsUpdateFunctionList )
|
|
DECLARE_FORMAT_UPDATER( ved, "Vgui editor file", "ved", "keyvalues2", EmptyUpdateFunctionList )
|
|
DECLARE_FORMAT_UPDATER( mks, "Make sheet file", "mks", "keyvalues2", EmptyUpdateFunctionList )
|
|
DECLARE_FORMAT_UPDATER( mp_preprocess, "DMX Model Pipeline Preprocess File", "mpp", "keyvalues2", EmptyUpdateFunctionList )
|
|
DECLARE_FORMAT_UPDATER( mp_root, "DMX Model Pipeline Root Script File", "root", "keyvalues2", EmptyUpdateFunctionList )
|
|
DECLARE_FORMAT_UPDATER( mp_model, "DMX Model Pipeline Model Script File", "model", "keyvalues2", EmptyUpdateFunctionList )
|
|
DECLARE_FORMAT_UPDATER( mp_anim, "DMX Model Pipeline Animation Script File", "anim", "keyvalues2", EmptyUpdateFunctionList )
|
|
DECLARE_FORMAT_UPDATER( mp_physics, "DMX Model Pipeline Physics Script File", "physics", "keyvalues2", EmptyUpdateFunctionList )
|
|
DECLARE_FORMAT_UPDATER( mp_hitbox, "DMX Model Pipeline Hitbox Script File", "hitbox", "keyvalues2", EmptyUpdateFunctionList )
|
|
DECLARE_FORMAT_UPDATER( mp_materialgroup, "DMX Model Pipeline Material Group Script File", "materialgroup", "keyvalues2", EmptyUpdateFunctionList )
|
|
DECLARE_FORMAT_UPDATER( mp_keyvalues, "DMX Model Pipeline KeyValues Script File", "keyvalues", "keyvalues2", EmptyUpdateFunctionList )
|
|
DECLARE_FORMAT_UPDATER( mp_eyes, "DMX Model Pipeline Eyes Script File", "eyes", "keyvalues2", EmptyUpdateFunctionList )
|
|
DECLARE_FORMAT_UPDATER( mp_bonemask, "DMX Model Pipeline Bone Mask Script File", "bonemask", "keyvalues2", EmptyUpdateFunctionList )
|
|
DECLARE_FORMAT_UPDATER( gui, "Compiled GUI file", "gui", "keyvalues2",EmptyUpdateFunctionList )
|
|
DECLARE_FORMAT_UPDATER( schema, "Schema description file", "sch", "keyvalues2",EmptyUpdateFunctionList )
|
|
DECLARE_FORMAT_UPDATER( tex, "Texture Configuration File", "tex", "keyvalues2",EmptyUpdateFunctionList )
|
|
DECLARE_FORMAT_UPDATER( world, "World Files", "wld", "binary", EmptyUpdateFunctionList )
|
|
DECLARE_FORMAT_UPDATER( worldnode, "World Node Files", "wnd", "binary", EmptyUpdateFunctionList )
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// The application object
|
|
//-----------------------------------------------------------------------------
|
|
class CDmSerializers : public CBaseAppSystem< IDmSerializers >
|
|
{
|
|
typedef CBaseAppSystem< IDmSerializers > BaseClass;
|
|
|
|
public:
|
|
// Inherited from IAppSystem
|
|
virtual bool Connect( CreateInterfaceFn factory );
|
|
virtual void *QueryInterface( const char *pInterfaceName );
|
|
virtual InitReturnVal_t Init();
|
|
};
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Singleton interface
|
|
//-----------------------------------------------------------------------------
|
|
static CDmSerializers g_DmSerializers;
|
|
IDmSerializers *g_pDmSerializers = &g_DmSerializers;
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Here's where the app systems get to learn about each other
|
|
//-----------------------------------------------------------------------------
|
|
bool CDmSerializers::Connect( CreateInterfaceFn factory )
|
|
{
|
|
if ( !BaseClass::Connect( factory ) )
|
|
return false;
|
|
|
|
if ( !factory( FILESYSTEM_INTERFACE_VERSION, NULL ) )
|
|
{
|
|
Warning( "DmSerializers needs the file system to function" );
|
|
return false;
|
|
}
|
|
|
|
// Here's the main point where all DM element classes get installed
|
|
// Necessary to do it here so all type symbols for all DME classes are set
|
|
// up prior to install
|
|
InstallDmElementFactories( );
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Here's where systems can access other interfaces implemented by this object
|
|
//-----------------------------------------------------------------------------
|
|
void *CDmSerializers::QueryInterface( const char *pInterfaceName )
|
|
{
|
|
if ( !V_strcmp( pInterfaceName, DMSERIALIZERS_INTERFACE_VERSION ) )
|
|
return (IDmSerializers*)this;
|
|
|
|
return NULL;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Init, shutdown
|
|
//-----------------------------------------------------------------------------
|
|
InitReturnVal_t CDmSerializers::Init()
|
|
{
|
|
InitReturnVal_t nRetVal = BaseClass::Init();
|
|
if ( nRetVal != INIT_OK )
|
|
return nRetVal;
|
|
|
|
// Install non-dmx importers
|
|
InstallActBusyImporter( g_pDataModel );
|
|
InstallCommentaryImporter( g_pDataModel );
|
|
InstallVMTImporter( g_pDataModel );
|
|
InstallVMFImporter( g_pDataModel );
|
|
InstallMKSImporter( g_pDataModel );
|
|
InstallTEXImporter( g_pDataModel );
|
|
|
|
// Install legacy dmx importers
|
|
InstallSFMV1Importer( g_pDataModel );
|
|
InstallSFMV2Importer( g_pDataModel );
|
|
InstallSFMV3Importer( g_pDataModel );
|
|
InstallSFMV4Importer( g_pDataModel );
|
|
InstallSFMV5Importer( g_pDataModel );
|
|
InstallSFMV6Importer( g_pDataModel );
|
|
InstallSFMV7Importer( g_pDataModel );
|
|
InstallSFMV8Importer( g_pDataModel );
|
|
InstallSFMV9Importer( g_pDataModel );
|
|
|
|
// install dmx format updaters
|
|
INSTALL_FORMAT_UPDATER( dmx );
|
|
INSTALL_FORMAT_UPDATER( movieobjects );
|
|
INSTALL_FORMAT_UPDATER( sfm );
|
|
INSTALL_FORMAT_UPDATER( sfm_settings );
|
|
INSTALL_FORMAT_UPDATER( sfm_session );
|
|
INSTALL_FORMAT_UPDATER( sfm_trackgroup );
|
|
INSTALL_FORMAT_UPDATER( pcf );
|
|
INSTALL_FORMAT_UPDATER( gui );
|
|
INSTALL_FORMAT_UPDATER( schema );
|
|
INSTALL_FORMAT_UPDATER( preset );
|
|
INSTALL_FORMAT_UPDATER( facial_animation );
|
|
INSTALL_FORMAT_UPDATER( model );
|
|
INSTALL_FORMAT_UPDATER( ved );
|
|
INSTALL_FORMAT_UPDATER( mks );
|
|
INSTALL_FORMAT_UPDATER( mp_preprocess );
|
|
INSTALL_FORMAT_UPDATER( mp_root );
|
|
INSTALL_FORMAT_UPDATER( mp_model );
|
|
INSTALL_FORMAT_UPDATER( mp_anim );
|
|
INSTALL_FORMAT_UPDATER( mp_physics );
|
|
INSTALL_FORMAT_UPDATER( mp_hitbox );
|
|
INSTALL_FORMAT_UPDATER( mp_materialgroup );
|
|
INSTALL_FORMAT_UPDATER( mp_keyvalues );
|
|
INSTALL_FORMAT_UPDATER( mp_eyes );
|
|
INSTALL_FORMAT_UPDATER( mp_bonemask );
|
|
INSTALL_FORMAT_UPDATER( tex );
|
|
INSTALL_FORMAT_UPDATER( world );
|
|
INSTALL_FORMAT_UPDATER( worldnode );
|
|
|
|
return INIT_OK;
|
|
}
|
|
|