expvintl/source-engine-2018-hl2_src
0
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
master
source-engine-2018-hl2_src/movieobjects/importintovcd.cpp

863 lines
26 KiB
C++
Raw Permalink Normal View History

1
2020-04-23 00:56:21 +08:00
//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
//=============================================================================
#include "movieobjects/importintovcd.h"
#include "movieobjects/movieobjects.h"
#include "tier3/scenetokenprocessor.h"
#include "choreoscene.h"
#include "choreoactor.h"
#include "choreochannel.h"
#include "choreoevent.h"
#include "tier2/p4helpers.h"
#include "tier1/utlbuffer.h"
#include "tier3/tier3.h"
#include "datacache/imdlcache.h"
#include "filesystem.h"
#include "studio.h"
//-----------------------------------------------------------------------------
// Helper wrapper class for log layers (necessary to avoid movieobjects dependence)
//-----------------------------------------------------------------------------
class CDmeLogLayerHelper
{
public:
CDmeLogLayerHelper( CDmElement *pLogLayer, int nDefaultCurveType );
// Finds a key
int FindKey( int nTime ) const;
// Gets a value at a particular time
float GetValue( int nTime ) const;
// Inserts keys
void AddToTail( int nTime, float flValue, int nCurveType );
void InsertAfter( int nAfter, int nTime, float flValue, int nCurveType );
int InsertKey( int nTime, float flValue, int nCurveType );
// Simplifies the curve
void Simplify( float flThreshhold );
void SetCurveType( int nKey, int nCurveType );
// Total simplified points
static int TotalRemovedPoints();
private:
void CurveSimplify_R( float flThreshold, int nStartPoint, int nEndPoint, CDmeLogLayerHelper *pDest );
// Computes the total error
float ComputeTotalError( CDmeLogLayerHelper *pDest, int nStartPoint, int nEndPoint );
// Select the best fit curve type
void ChooseBestCurveType( int nKey, int nStartPoint, int nEndPoint, CDmeLogLayerHelper *pDest );
// Compute first + second derivatives of data
void ComputeDerivates( float *pSlope, float *pAccel, int nPoint, CDmeLogLayerHelper *pDest );
CDmElement *m_pLogLayer;
CDmrArray<int> m_times;
CDmrArray<float> m_values;
CDmrArray<int> m_curvetypes;
int m_nDefaultCurveType;
static int s_nTotalRemovedPoints;
};
//-----------------------------------------------------------------------------
// Total simplified points
//-----------------------------------------------------------------------------
int CDmeLogLayerHelper::s_nTotalRemovedPoints = 0;
int CDmeLogLayerHelper::TotalRemovedPoints()
{
return s_nTotalRemovedPoints;
}
//-----------------------------------------------------------------------------
// Constructor
//-----------------------------------------------------------------------------
CDmeLogLayerHelper::CDmeLogLayerHelper( CDmElement *pLogLayer, int nDefaultCurveType ) :
m_pLogLayer( pLogLayer ), m_times( pLogLayer, "times", true ),
m_values( pLogLayer, "values", true ), m_curvetypes( pLogLayer, "curvetypes", true )
{
m_nDefaultCurveType = nDefaultCurveType;
}
//-----------------------------------------------------------------------------
// Inserts keys
//-----------------------------------------------------------------------------
void CDmeLogLayerHelper::AddToTail( int nTime, float flValue, int nCurveType )
{
m_times.AddToTail( nTime );
m_values.AddToTail( flValue );
m_curvetypes.AddToTail( nCurveType );
}
void CDmeLogLayerHelper::InsertAfter( int nAfter, int nTime, float flValue, int nCurveType )
{
int nBefore = nAfter + 1;
m_times.InsertBefore( nBefore, nTime );
m_values.InsertBefore( nBefore, flValue );
m_curvetypes.InsertBefore( nBefore, nCurveType );
}
int CDmeLogLayerHelper::InsertKey( int nTime, float flValue, int nCurveType )
{
int nAfter = FindKey( nTime );
InsertAfter( nAfter, nTime, flValue, nCurveType );
return nAfter + 1;
}
void CDmeLogLayerHelper::SetCurveType( int nKey, int nCurveType )
{
m_curvetypes.Set( nKey, nCurveType );
}
//-----------------------------------------------------------------------------
// Finds a key
//-----------------------------------------------------------------------------
int CDmeLogLayerHelper::FindKey( int nTime ) const
{
int tn = m_times.Count();
for ( int ti = tn - 1; ti >= 0; --ti )
{
if ( nTime >= m_times[ ti ] )
return ti;
}
return -1;
}
//-----------------------------------------------------------------------------
// Gets a value at a particular time
//-----------------------------------------------------------------------------
float CDmeLogLayerHelper::GetValue( int nTime ) const
{
int tc = m_times.Count();
Assert( m_values.Count() == tc );
int ti = FindKey( nTime );
if ( ti < 0 )
{
if ( tc > 0 )
return m_values[ 0 ];
return 0.0f;
}
// Early out if we're at the end
if ( ti >= tc - 1 )
return m_values[ ti ];
// Figure out the lerp factor
int nDummy, nInterpolationType;
int nCurveType = m_curvetypes.Count() ? m_curvetypes[ti] : m_nDefaultCurveType;
Interpolator_CurveInterpolatorsForType( nCurveType, nInterpolationType, nDummy );
Vector vecOutput;
Vector vecArg1( 0.0f, m_values[ti], 0.0f );
Vector vecArg2( 1.0f, m_values[ti+1], 0.0f );
float t = (float)( nTime - m_times[ti] ) / (float)( m_times[ti+1] - m_times[ti] );
Interpolator_CurveInterpolate( nInterpolationType, vecArg1, vecArg1, vecArg2, vecArg2, t, vecOutput );
return vecOutput.y;
}
//-----------------------------------------------------------------------------
// Computes the total error
//-----------------------------------------------------------------------------
float CDmeLogLayerHelper::ComputeTotalError( CDmeLogLayerHelper *pDest, int nStartPoint, int nEndPoint )
{
float flTotalDistance = 0.0f;
for ( int i = nStartPoint; i <= nEndPoint; ++i )
{
float flCheck = m_values[i];
float flCheck2 = pDest->GetValue( m_times[i] );
float flDistance = fabs( flCheck2 - flCheck );
flTotalDistance += flDistance;
}
return flTotalDistance;
}
//-----------------------------------------------------------------------------
// Select the best fit curve type
//-----------------------------------------------------------------------------
static int s_nInterpTypes[] =
{
INTERPOLATE_LINEAR_INTERP,
INTERPOLATE_EASE_INOUT,
// INTERPOLATE_EASE_IN,
// INTERPOLATE_EASE_OUT,
// INTERPOLATE_EXPONENTIAL_DECAY,
// INTERPOLATE_HOLD,
-1,
};
void CDmeLogLayerHelper::ChooseBestCurveType( int nKey, int nStartPoint, int nEndPoint, CDmeLogLayerHelper *pDest )
{
return;
float flMinError = FLT_MAX;
int nBestInterpType = -1;
for ( int i = 0; s_nInterpTypes[i] >= 0; ++i )
{
pDest->SetCurveType( nKey, MAKE_CURVE_TYPE( s_nInterpTypes[i], s_nInterpTypes[i] ) );
float flError = ComputeTotalError( pDest, nStartPoint, nEndPoint );
if ( flMinError > flError )
{
nBestInterpType = s_nInterpTypes[i];
flMinError = flError;
}
}
Assert( nBestInterpType >= 0 );
pDest->SetCurveType( nKey, MAKE_CURVE_TYPE( nBestInterpType, nBestInterpType ) );
}
//-----------------------------------------------------------------------------
// Compute first + second derivatives of data
//-----------------------------------------------------------------------------
void CDmeLogLayerHelper::ComputeDerivates( float *pSlope, float *pAccel, int nPoint, CDmeLogLayerHelper *pDest )
{
// Central difference, assume linear slope between points.
// Find neighboring point with minimum distance
bool bLeftEdge = ( nPoint == 0 );
bool bRightEdge = ( nPoint == m_times.Count() - 1 );
int nTime = m_times[nPoint];
int nPrevTime = ( !bLeftEdge ) ? m_times[ nPoint - 1 ] : nTime - 1000;
int nNextTime = ( !bRightEdge ) ? m_times[ nPoint + 1 ] : nTime + 1000;
float flPrevPoint, flNextPoint;
if ( nTime - nPrevTime < nNextTime - nTime )
{
// prev point is closer
flPrevPoint = ( !bLeftEdge ) ? m_values[ nPoint - 1 ] : m_values[ nPoint ];
nNextTime = nTime + ( nTime - nPrevTime );
flNextPoint = GetValue( nNextTime );
}
else
{
// next point is closer
flNextPoint = ( !bRightEdge ) ? m_values[ nPoint + 1 ] : m_values[ nPoint ];
nPrevTime = nTime - ( nNextTime - nTime );
flPrevPoint = GetValue( nPrevTime );
}
// Central difference: slope = ( vnext - vprev ) / ( tnext - tprev );
// accel = ( vnext - 2 * vcurr + vprev ) / ( 0.5 * ( tnext - tprev ) )^2
float flCurrPoint = m_values[nPoint];
flPrevPoint -= pDest->GetValue( nPrevTime );
flCurrPoint -= pDest->GetValue( nTime );
flNextPoint -= pDest->GetValue( nNextTime );
float flDeltaTime = DMETIME_TO_SECONDS( nTime - nPrevTime );
*pSlope = ( flNextPoint - flPrevPoint ) / ( 2.0f * flDeltaTime );
*pAccel = ( flNextPoint - 2 * flCurrPoint + flPrevPoint ) / ( flDeltaTime * flDeltaTime );
}
//-----------------------------------------------------------------------------
// Implementation of Douglas-Peucker curve simplification routine
// (hacked to only care about error against original curve (sort of 1D)
//-----------------------------------------------------------------------------
void CDmeLogLayerHelper::CurveSimplify_R( float flThreshold, int nStartPoint, int nEndPoint, CDmeLogLayerHelper *pDest )
{
if ( nEndPoint <= nStartPoint + 1 )
return;
int nMaxPoint = nStartPoint;
float flMaxDistance = 0.0f;
for ( int i = nStartPoint + 1 ; i < nEndPoint; ++i )
{
float flCheck = m_values[i];
float flCheck2 = pDest->GetValue( m_times[i] );
float flDistance = fabs( flCheck2 - flCheck );
if ( flDistance < flMaxDistance )
continue;
nMaxPoint = i;
flMaxDistance = flDistance;
}
/*
float flMaxAccel = 0.0f;
for ( int i = nStartPoint + 1 ; i < nEndPoint; ++i )
{
float flSlope, flAccel;
ComputeDerivates( &flSlope, &flAccel, i, pDest );
flAccel = fabs( flAccel );
if ( flAccel < flMaxAccel )
continue;
nMaxPoint = i;
flMaxAccel = flAccel;
}
*/
if ( flMaxDistance > flThreshold )
{
int nKey = pDest->InsertKey( m_times[ nMaxPoint ], m_values[ nMaxPoint ], m_nDefaultCurveType );
Assert( nKey != 0 );
ChooseBestCurveType( nKey-1, nStartPoint, nMaxPoint, pDest );
ChooseBestCurveType( nKey, nMaxPoint, nEndPoint, pDest );
CurveSimplify_R( flThreshold, nStartPoint, nMaxPoint, pDest );
CurveSimplify_R( flThreshold, nMaxPoint, nEndPoint, pDest );
}
}
//-----------------------------------------------------------------------------
// Simplifies the curve
//-----------------------------------------------------------------------------
void CDmeLogLayerHelper::Simplify( float flThreshhold )
{
int nFirstKey, nLastKey;
int nKeys = m_values.Count();
if ( nKeys <= 1 )
return;
for ( nFirstKey = 1; nFirstKey < nKeys; ++nFirstKey )
{
// FIXME: Should we use a tolerance check here?
if ( m_values[ nFirstKey ] != m_values[ nFirstKey - 1 ] )
break;
}
--nFirstKey;
for ( nLastKey = nKeys; --nLastKey >= 1; )
{
// FIXME: Should we use a tolerance check here?
if ( m_values[ nLastKey ] != m_values[ nLastKey - 1 ] )
break;
}
if ( nLastKey <= nFirstKey )
{
m_times.RemoveMultiple( 1, nKeys - 1 );
m_values.RemoveMultiple( 1, nKeys - 1 );
s_nTotalRemovedPoints += nKeys - 1;
return;
}
CDmElement *pTemp = CreateElement< CDmElement >( "simplified" );
CDmeLogLayerHelper destLayer( pTemp, m_nDefaultCurveType );
destLayer.AddToTail( m_times[nFirstKey], m_values[nFirstKey], m_nDefaultCurveType );
destLayer.AddToTail( m_times[nLastKey], m_values[nLastKey], m_nDefaultCurveType );
// Recursively finds the point with the largest error from the "simplified curve"
// and subdivides the problem on both sides until the largest delta from the simplified
// curve is less than the tolerance
CurveSimplify_R( flThreshhold, nFirstKey, nLastKey, &destLayer );
m_times.CopyArray( destLayer.m_times.Base(), destLayer.m_times.Count() );
m_values.CopyArray( destLayer.m_values.Base(), destLayer.m_values.Count() );
m_curvetypes.CopyArray( destLayer.m_curvetypes.Base(), destLayer.m_curvetypes.Count() );
DestroyElement( pTemp );
s_nTotalRemovedPoints += nKeys - m_times.Count();
}
//-----------------------------------------------------------------------------
// Finds or adds actors, channels
//-----------------------------------------------------------------------------
static CChoreoActor* FindOrAddActor( CChoreoScene *pScene, const char *pActorName, const char *pActorModel )
{
CChoreoActor *a = pScene->FindActor( pActorName );
if ( !a )
{
a = pScene->AllocActor();
Assert( a );
a->SetName( pActorName );
a->SetActive( true );
a->SetFacePoserModelName( pActorModel );
}
return a;
}
//-----------------------------------------------------------------------------
// Finds animation events
//-----------------------------------------------------------------------------
static CChoreoEvent* FindOrAddAnimationEvent( CChoreoScene *pScene, CChoreoActor *pActor )
{
int nEventCount = pScene->GetNumEvents();
for ( int i = 0; i < nEventCount; ++i )
{
CChoreoEvent* pEvent = pScene->GetEvent(i);
if ( pEvent->GetActor() != pActor )
continue;
if ( pEvent->GetType() != CChoreoEvent::FLEXANIMATION )
continue;
return pEvent;
}
// Allocate new channel
CChoreoChannel *pChannel = pScene->AllocChannel();
pChannel->SetName( "imported_flex" );
pChannel->SetActor( pActor );
pChannel->SetActive( true );
pActor->AddChannel( pChannel );
// Allocate choreo event
CChoreoEvent *pEvent = pScene->AllocEvent();
pEvent->SetName( pActor->GetName() );
pEvent->SetType( CChoreoEvent::FLEXANIMATION );
pEvent->SetActor( pActor );
pEvent->SetChannel( pChannel );
pEvent->SetActive( true );
pChannel->AddEvent( pEvent );
return pEvent;
}
//-----------------------------------------------------------------------------
// Finds sound events
//-----------------------------------------------------------------------------
static CChoreoEvent* FindOrAddSoundEvent( CChoreoScene *pScene, CChoreoActor *pActor, const char *pEventName )
{
int nEventCount = pScene->GetNumEvents();
for ( int i = 0; i < nEventCount; ++i )
{
CChoreoEvent* pEvent = pScene->GetEvent(i);
if ( pEvent->GetActor() != pActor )
continue;
if ( pEvent->GetType() != CChoreoEvent::SPEAK )
continue;
if ( Q_stricmp( pEvent->GetName(), pEventName ) )
continue;
return pEvent;
}
// Allocate new channel
CChoreoChannel *pChannel = pScene->AllocChannel();
pChannel->SetName( "imported sounds" );
pChannel->SetActor( pActor );
pChannel->SetActive( true );
pActor->AddChannel( pChannel );
// Allocate sound event
CChoreoEvent *pEvent = pScene->AllocEvent();
pEvent->SetName( pEventName );
pEvent->SetType( CChoreoEvent::SPEAK );
pEvent->SetActor( pActor );
pEvent->SetChannel( pChannel );
pEvent->SetActive( true );
pChannel->AddEvent( pEvent );
return pEvent;
}
static CFlexAnimationTrack *FindOrCreateTrack( CChoreoEvent *pEvent, const char *pFlexControllerName )
{
CFlexAnimationTrack *pTrack = pEvent->FindTrack( pFlexControllerName );
if ( pTrack )
{
pTrack->Clear();
}
else
{
pTrack = pEvent->AddTrack( pFlexControllerName );
pTrack->SetTrackActive( true );
}
pTrack->SetMin( 0.0f );
pTrack->SetMax( 1.0f );
pTrack->SetInverted( false );
return pTrack;
}
//-----------------------------------------------------------------------------
// Returns flex controller ranges
//-----------------------------------------------------------------------------
void GetStereoFlexControllerRange( float *pMin, float *pMax, studiohdr_t *pStudioHdr, const char *pFlexName )
{
char pRightBuf[MAX_PATH];
char pLeftBuf[MAX_PATH];
Q_snprintf( pRightBuf, sizeof(pRightBuf), "right_%s", pFlexName );
Q_snprintf( pLeftBuf, sizeof(pLeftBuf), "left_%s", pFlexName );
for ( LocalFlexController_t i = LocalFlexController_t(0); i < pStudioHdr->numflexcontrollers; ++i )
{
mstudioflexcontroller_t *pFlex = pStudioHdr->pFlexcontroller( i );
const char *pFlexControllerName = pFlex->pszName();
if ( !Q_stricmp( pFlexControllerName, pFlexName ) )
{
*pMin = pFlex->min;
*pMax = pFlex->max;
return;
}
// FIXME: Probably want to get the left + right controller + find the min and max of each, but this is unnecessary.
if ( !Q_stricmp( pFlexControllerName, pRightBuf ) )
{
*pMin = pFlex->min;
*pMax = pFlex->max;
return;
}
}
*pMin = 0.0f;
*pMax = 1.0f;
}
void GetFlexControllerRange( float *pMin, float *pMax, studiohdr_t *pStudioHdr, const char *pFlexName )
{
for ( LocalFlexController_t i = LocalFlexController_t(0); i < pStudioHdr->numflexcontrollers; ++i )
{
mstudioflexcontroller_t *pFlex = pStudioHdr->pFlexcontroller( i );
const char *pFlexControllerName = pFlex->pszName();
if ( !Q_stricmp( pFlexControllerName, pFlexName ) )
{
*pMin = pFlex->min;
*pMax = pFlex->max;
return;
}
}
*pMin = 0.0f;
*pMax = 1.0f;
}
//-----------------------------------------------------------------------------
// Imports samples into a track
//-----------------------------------------------------------------------------
void ImportSamplesIntoTrack( CFlexAnimationTrack *pTrack, CDmElement *pLog, int nSampleType, int nTimeOffset, const ImportVCDInfo_t& info )
{
CDmrArray<int> times( pLog, "times" );
CDmrArray<float> values( pLog, "values" );
// Add the samples
int nSampleCount = times.Count();
if ( nSampleCount == 0 )
return;
int nDefaultCurveType = MAKE_CURVE_TYPE( info.m_nInterpolationType, info.m_nInterpolationType );
if ( info.m_flSimplificationThreshhold > 0.0f )
{
CDmeLogLayerHelper helper( pLog, nDefaultCurveType );
helper.Simplify( info.m_flSimplificationThreshhold );
}
CDmrArray<int> curveTypes( pLog, "curvetypes" );
nSampleCount = times.Count();
bool bHasCurveTypeData = ( curveTypes.Count() > 0 );
for ( int j = 0; j < nSampleCount; ++j )
{
int nCurveType = bHasCurveTypeData ? curveTypes[j] : nDefaultCurveType;
float flValue = values[j];
float flTime = DMETIME_TO_SECONDS( times[j] - nTimeOffset );
CExpressionSample *pSample = pTrack->AddSample( flTime, flValue, nSampleType );
pSample->SetCurveType( nCurveType );
}
if ( nSampleType == 0 )
{
pTrack->SetEdgeActive( true, true );
pTrack->SetEdgeActive( false, true );
int nCurveType0, nCurveType1;
if ( bHasCurveTypeData )
{
nCurveType0 = curveTypes[0];
nCurveType1 = curveTypes[nSampleCount-1];
}
else
{
nCurveType0 = nCurveType1 = nDefaultCurveType;
}
pTrack->SetEdgeInfo( true, nCurveType0, values[ 0 ] );
pTrack->SetEdgeInfo( false, nCurveType1, values[ nSampleCount-1 ] );
}
}
//-----------------------------------------------------------------------------
// Imports mono log data into a event, creates a new track if necessary
//-----------------------------------------------------------------------------
void ImportMonoLogDataIntoEvent( studiohdr_t *pStudioHdr, CChoreoEvent *pEvent, const char *pTrackName, CDmElement *pLog, int nTimeOffset, const ImportVCDInfo_t& info )
{
CDmrArray<int> times( pLog, "times" );
if ( times.Count() == 0 )
return;
float flMin, flMax;
GetFlexControllerRange( &flMin, &flMax, pStudioHdr, pTrackName );
CFlexAnimationTrack *pTrack = FindOrCreateTrack( pEvent, pTrackName );
pTrack->Clear();
pTrack->SetComboType( false );
pTrack->SetMin( flMin );
pTrack->SetMax( flMax );
ImportSamplesIntoTrack( pTrack, pLog, 0, nTimeOffset, info );
}
//-----------------------------------------------------------------------------
// Imports stereo log data into a event, creates a new track if necessary
//-----------------------------------------------------------------------------
void ImportStereoLogDataIntoEvent( studiohdr_t *pStudioHdr, CChoreoEvent *pEvent, const char *pTrackName, CDmElement *pValueLog, CDmElement *pBalanceLog, int nTimeOffset, const ImportVCDInfo_t& info )
{
CDmrArray<int> valueTimes( pValueLog, "times" );
CDmrArray<int> balanceTimes( pBalanceLog, "times" );
if ( valueTimes.Count() == 0 && balanceTimes.Count() == 0 )
return;
float flMin, flMax;
GetStereoFlexControllerRange( &flMin, &flMax, pStudioHdr, pTrackName );
CFlexAnimationTrack *pTrack = FindOrCreateTrack( pEvent, pTrackName );
pTrack->Clear();
pTrack->SetComboType( true );
pTrack->SetMin( flMin );
pTrack->SetMax( flMax );
ImportSamplesIntoTrack( pTrack, pValueLog, 0, nTimeOffset, info );
ImportSamplesIntoTrack( pTrack, pBalanceLog, 1, nTimeOffset, info );
}
//-----------------------------------------------------------------------------
// Compute track start, end time
//-----------------------------------------------------------------------------
static int ComputeEventTime( CDmElement *pRoot, CChoreoEvent *pEvent )
{
int nStartTime = INT_MAX;
int nEndTime = INT_MIN;
// Iterate over all elements in the animations attribute; each one refers to a log.
CDmrElementArray<> animations( pRoot, "animations" );
if ( !animations.IsValid() )
return 0;
int nCount = animations.Count();
for( int i = 0; i < nCount; ++i )
{
CDmElement *pLog = animations[i];
if ( !pLog )
continue;
CDmrArray<int> times( pLog, "times" );
int nSampleCount = times.Count();
if ( nSampleCount == 0 )
continue;
if ( nStartTime > times[0] )
{
nStartTime = times[0];
}
if ( nEndTime < times[nSampleCount-1] )
{
nEndTime = times[nSampleCount-1];
}
}
pEvent->SetStartTime( DMETIME_TO_SECONDS( nStartTime ) );
pEvent->SetEndTime( DMETIME_TO_SECONDS( nEndTime ) );
return nStartTime;
}
//-----------------------------------------------------------------------------
// Main entry point for importing animations
//-----------------------------------------------------------------------------
void ImportAnimations( CDmElement *pRoot, CChoreoScene *pChoreoScene, CChoreoActor *pActor, studiohdr_t *pStudioHdr, const ImportVCDInfo_t& info )
{
CChoreoEvent *pEvent = FindOrAddAnimationEvent( pChoreoScene, pActor );
pEvent->SetDefaultCurveType( MAKE_CURVE_TYPE( info.m_nInterpolationType, info.m_nInterpolationType ) );
int nTimeOffset = ComputeEventTime( pRoot, pEvent );
// Iterate over all elements in the animations attribute; each one refers to a log.
CDmrElementArray<> animations( pRoot, "animations" );
if ( !animations.IsValid() )
return;
int nCount = animations.Count();
for( int i = 0; i < nCount; ++i )
{
CDmElement *pLog = animations[i];
if ( !pLog )
continue;
const char *pLogName = pLog->GetName();
// Balance is done at the same time as value
if ( StringHasPrefix( pLogName, "balance_" ) )
continue;
if ( StringHasPrefix( pLogName, "value_" ) )
{
if ( i == nCount - 1 )
continue;
char pBalanceName[256];
Q_snprintf( pBalanceName, sizeof(pBalanceName), "balance_%s", pLogName + 6 );
CDmElement *pBalanceLog = animations[i+1];
if ( !Q_stricmp( pBalanceName, pBalanceLog->GetName() ) )
{
++i;
}
else
{
pBalanceLog = NULL;
}
if ( pBalanceLog )
{
ImportStereoLogDataIntoEvent( pStudioHdr, pEvent, pLogName + 6, pLog, pBalanceLog, nTimeOffset, info );
}
}
else
{
ImportMonoLogDataIntoEvent( pStudioHdr, pEvent, pLogName, pLog, nTimeOffset, info );
}
}
}
//-----------------------------------------------------------------------------
// Main entry point for importing sounds
//-----------------------------------------------------------------------------
void ImportSounds( CDmElement *pRoot, CChoreoScene *pChoreoScene, CChoreoActor *pActor, const ImportVCDInfo_t& info )
{
// Iterate over all element in the sound attribute; each one refers to a sound
CDmrElementArray<> sounds( pRoot, "sounds" );
if ( !sounds.IsValid() )
return;
int nCount = sounds.Count();
for( int i = 0; i < nCount; ++i )
{
CDmElement *pSound = sounds[i];
if ( !pSound )
continue;
const char *pEventName = pSound->GetName();
CChoreoEvent *pEvent = FindOrAddSoundEvent( pChoreoScene, pActor, pEventName );
int nStart = pSound->GetValue<int>( "start" );
int nEnd = pSound->GetValue<int>( "end" );
const char *pGameSound = pSound->GetValueString( "gamesound" );
pEvent->SetStartTime( DMETIME_TO_SECONDS( nStart ) );
pEvent->SetEndTime( DMETIME_TO_SECONDS( nEnd ) );
pEvent->SetParameters( pGameSound );
pEvent->SetCloseCaptionType( CChoreoEvent::CC_MASTER );
}
}
//-----------------------------------------------------------------------------
// Main entry point for importing a .fac file into a .vcd file
//-----------------------------------------------------------------------------
bool ImportLogsIntoVCD( const char *pFacFullPath, CChoreoScene *pChoreoScene, const ImportVCDInfo_t& info )
{
CDmElement *pRoot;
DmFileId_t id = g_pDataModel->RestoreFromFile( pFacFullPath, NULL, NULL, &pRoot, CR_FORCE_COPY );
if ( id == DMFILEID_INVALID )
{
Warning( "Unable to load file %s\n", pFacFullPath );
return false;
}
pChoreoScene->IgnorePhonemes( info.m_bIgnorePhonemes );
// Create the actor in the scene
const char *pActorName = pRoot->GetName();
const char *pActorModel = pRoot->GetValueString( "gamemodel" );
MDLHandle_t hMDL = g_pMDLCache->FindMDL( pActorModel );
if ( hMDL == MDLHANDLE_INVALID )
{
Warning( "vcdimport: Model %s doesn't exist!\n", pActorModel );
return false;
}
studiohdr_t *pStudioHdr = g_pMDLCache->GetStudioHdr( hMDL );
if ( !pStudioHdr || g_pMDLCache->IsErrorModel( hMDL ) )
{
Warning( "vcdimport: Model %s doesn't exist!\n", pActorModel );
return false;
}
CChoreoActor *pActor = FindOrAddActor( pChoreoScene, pActorName, pActorModel );
ImportAnimations( pRoot, pChoreoScene, pActor, pStudioHdr, info );
ImportSounds( pRoot, pChoreoScene, pActor, info );
DestroyElement( pRoot, TD_DEEP );
return true;
}
//-----------------------------------------------------------------------------
// Main entry point for importing a .fac file into a .vcd file
//-----------------------------------------------------------------------------
bool ImportLogsIntoVCD( const char *pFacFullPath, const char *pVCDInFullPath, const char *pVCDOutPath, const ImportVCDInfo_t& info )
{
CUtlBuffer buf;
if ( !g_pFullFileSystem->ReadFile( pVCDInFullPath, NULL, buf ) )
{
Warning( "Unable to load file %s\n", pVCDInFullPath );
return false;
}
SetTokenProcessorBuffer( (char *)buf.Base() );
CChoreoScene *pScene = ChoreoLoadScene( pVCDInFullPath, NULL, GetTokenProcessor(), NULL );
if ( !pScene )
{
Warning( "Unable to parse file %s\n", pVCDInFullPath );
return false;
}
bool bOk = ImportLogsIntoVCD( pFacFullPath, pScene, info );
if ( !bOk )
return false;
Msg( "Removed %d samples\n", CDmeLogLayerHelper::TotalRemovedPoints() );
char pTemp[MAX_PATH];
if ( !Q_IsAbsolutePath( pVCDOutPath ) )
{
g_pFullFileSystem->RelativePathToFullPath( pVCDOutPath, NULL, pTemp, sizeof(pTemp) );
if ( !Q_IsAbsolutePath( pTemp ) )
{
char pDir[MAX_PATH];
if ( g_pFullFileSystem->GetCurrentDirectory( pDir, sizeof(pDir) ) )
{
Q_ComposeFileName( pDir, pVCDOutPath, pTemp, sizeof(pTemp) );
pVCDOutPath = pTemp;
}
}
else
{
pVCDOutPath = pTemp;
}
}
CP4AutoEditFile checkout( pVCDOutPath );
return pScene->SaveToFile( pVCDOutPath );
}
Reference in New Issue Copy Permalink