tf2/tf2_src/movieobjects/dmx_to_vcd.cpp

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose: 
//
//=============================================================================

#include "movieobjects/dmx_to_vcd.h"
#include "movieobjects/movieobjects.h"
#include "choreoscene.h"
#include "choreoactor.h"
#include "choreochannel.h"
#include "choreoevent.h"
#include "iscenetokenprocessor.h"
#include "characterset.h"


bool ConvertEventToDmx( CChoreoEvent *event, CDmeChannelsClip *clip )
{
	clip->SetName( event->GetName() );
	clip->SetValue( "eventtype", CChoreoEvent::NameForType( event->GetType() ) );

	CDmeTimeFrame *tf = clip->GetTimeFrame();
	Assert( tf );
	if ( tf )
	{
		tf->SetStartTime( DmeTime_t( event->GetStartTime() ) );
		tf->SetDuration( DmeTime_t( event->GetDuration() ) );
	}

	clip->SetValue( "parameters", event->GetParameters() );
	clip->SetValue( "parameters2", event->GetParameters2() );

	// event_ramp is a channel under the event's channels clip
	CDmrElementArray<> array( clip, "channels" ); 
	Assert( array.IsValid() );
	if ( array.IsValid() )
	{
		CDmeChannel *channel = CreateElement< CDmeChannel >( "event_ramp", clip->GetFileId() );
		array.AddToTail( channel );

		// Fill in values..., just log for now
		channel->CreateLog( AT_FLOAT );
		CDmeTypedLog<float> *ramp = static_cast< CDmeTypedLog<float> * >( channel->GetLog() );
		if ( ramp )
		{
			CDmeFloatCurveInfo *pCurveInfo = CreateElement< CDmeFloatCurveInfo >( "floatcurveinfo", clip->GetFileId() );

			pCurveInfo->SetDefaultCurveType( MAKE_CURVE_TYPE( INTERPOLATE_CATMULL_ROM_NORMALIZE, INTERPOLATE_CATMULL_ROM_NORMALIZE ) );
			pCurveInfo->SetRightEdgeTime( DmeTime_t( event->GetDuration() ) );

			pCurveInfo->SetUseEdgeInfo( true );
			pCurveInfo->SetDefaultEdgeZeroValue( 0.0f );
			// Left edge
			pCurveInfo->SetEdgeInfo( 0, 
				event->GetRamp()->IsEdgeActive( true ), 
				event->GetRamp()->GetEdgeZeroValue( true ), 
				event->GetRamp()->GetEdgeCurveType( true ) );
			// Right edge
			pCurveInfo->SetEdgeInfo( 1, 
				event->GetRamp()->IsEdgeActive( false ), 
				event->GetRamp()->GetEdgeZeroValue( false ), 
				event->GetRamp()->GetEdgeCurveType( false ) );

			ramp->SetCurveInfo( pCurveInfo );

			int rampCount = event->GetRampCount();
			for ( int j = 0; j < rampCount; ++j )
			{
				CExpressionSample *sample = event->GetRamp( j );
				ramp->SetKey( DmeTime_t( sample->time ), sample->value, sample->GetCurveType() );
			}
		}
	}

	clip->SetValue< float >( "pitch", event->GetPitch() );
	clip->SetValue< float >( "yaw", event->GetYaw() );

	clip->SetValue< bool >( "resumecondition", event->IsResumeCondition() );
	clip->SetValue< bool >( "lockbodyfacing", event->IsLockBodyFacing() );
	clip->SetValue< float >( "distancetotarget", event->GetDistanceToTarget() );
	clip->SetValue< bool >( "fixedlength", event->IsFixedLength() );
	clip->SetValue< bool >( "forceshortmovement", event->GetForceShortMovement() );
	clip->SetValue< bool >( "active", event->GetActive() );

	// Relative tags
	if ( event->GetNumRelativeTags() > 0 )
	{
		CDmElement *tags = CreateElement< CDmElement >( "relative_tags", clip->GetFileId() );
		if ( tags )
		{
			clip->SetValue< CDmElement >( "tags", tags );

			// Now create arrays for the name and percentages
			CDmrStringArray names( tags, "tagname", true );
			CDmrArray<float> percentages( tags, "tagpercentage", true );
			Assert( names.IsValid() && percentages.IsValid() );

			for ( int t = 0; t < event->GetNumRelativeTags(); t++ )
			{
				CEventRelativeTag *rt = event->GetRelativeTag( t );
				Assert( rt );

				names.AddToTail( rt->GetName() );
				percentages.AddToTail( rt->GetPercentage() );
			}
		}
	}

	// Timing tags
	if ( event->GetNumTimingTags() > 0 )
	{
		CDmElement *tags = CreateElement< CDmElement >( "timing_tags", clip->GetFileId() );
		if ( tags )
		{
			clip->SetValue< CDmElement >( "flextimingtags", tags );

			// Now create arrays for the name and percentages
			CDmrStringArray names( tags, "tagname", true );
			CDmrArray<float> percentages( tags, "tagpercentage", true );
			CDmrArray<bool> lockstates( tags, "lockedstate", true );
			Assert( names.IsValid() && percentages.IsValid() && lockstates.IsValid() );

			for ( int t = 0; t < event->GetNumTimingTags(); t++ )
			{
				CFlexTimingTag *tt = event->GetTimingTag( t );
				Assert( tt );

				names.AddToTail( tt->GetName() );
				percentages.AddToTail( tt->GetPercentage() );
				lockstates.AddToTail( tt->GetLocked() );
			}
		}
	}

	// Abs tags
	int tagtype;
	for ( tagtype = 0; tagtype < CChoreoEvent::NUM_ABS_TAG_TYPES; tagtype++ )
	{
		if ( event->GetNumAbsoluteTags( (CChoreoEvent::AbsTagType)tagtype ) > 0 )
		{
			char sz[ 512 ];
			
			Q_snprintf( sz, sizeof( sz ), "absolutetags %s", CChoreoEvent::NameForAbsoluteTagType( (CChoreoEvent::AbsTagType)tagtype ) );

			CDmElement *tags = CreateElement< CDmElement >( sz, clip->GetFileId() );
			if ( tags )
			{
				clip->SetValue< CDmElement >( sz, tags );

				// Now create arrays for the name and percentages
				CDmrStringArray names( tags, "tagname", true );
				CDmrArray<float> percentages( tags, "tagpercentage", true );
				Assert( names.IsValid() && percentages.IsValid() );
				for ( int t = 0; t < event->GetNumAbsoluteTags( (CChoreoEvent::AbsTagType)tagtype ); t++ )
				{
					CEventAbsoluteTag *abstag = event->GetAbsoluteTag( (CChoreoEvent::AbsTagType)tagtype, t );
					Assert( abstag );

					names.AddToTail( abstag->GetName() );
					percentages.AddToTail( abstag->GetPercentage() );
				}
			}
		}
	}

	// IsUsingRelativeTag
	if ( event->IsUsingRelativeTag() )
	{
		CDmElement *relativeTag = CreateElement< CDmElement >( "relative_tag", clip->GetFileId() );
		if ( relativeTag )
		{
			clip->SetValue< CDmElement >( "relative_tag", relativeTag );

			relativeTag->SetValue( "tagname", event->GetRelativeTagName() );
			relativeTag->SetValue( "tagwav",  event->GetRelativeWavName() );
		}
	}

	switch ( event->GetType() )
	{
	default:
		break;
	case CChoreoEvent::SPEAK:
		{
			CDmElement *speakProperties = CreateElement< CDmElement >( "SPEAK", clip->GetFileId() );
			if ( speakProperties )
			{
				clip->SetValue< CDmElement >( "SPEAK", speakProperties );

				speakProperties->SetValue( "closedcaption_type", CChoreoEvent::NameForCCType( event->GetCloseCaptionType() ) );
				speakProperties->SetValue( "closedcaption_token", event->GetCloseCaptionToken() );
				bool usingCombined = ( event->GetCloseCaptionType() != CChoreoEvent::CC_DISABLED && event->IsUsingCombinedFile() );
				speakProperties->SetValue< bool >( "closedcaption_usingcombinedfile", usingCombined );
				speakProperties->SetValue< bool >( "closedcaption_combinedusesgender", event->IsCombinedUsingGenderToken() );
				speakProperties->SetValue< bool >( "closedcaption_noattenuate", event->IsSuppressingCaptionAttenuation() );
			}
		}
		break;
	case CChoreoEvent::GESTURE:
		{
			CDmElement *gestureProperties = CreateElement< CDmElement >( "GESTURE", clip->GetFileId() );
			if ( gestureProperties )
			{
				clip->SetValue< CDmElement >( "GESTURE", gestureProperties );

				float duration;
				event->GetGestureSequenceDuration( duration );
				gestureProperties->SetValue< float >( "sequenceduration", duration );
			}
		}
		break;
	case CChoreoEvent::FLEXANIMATION:
		{
			// Save flex animation tracks as channels
			CDmrElementArray<> array( clip, "channels" );
			Assert( array.IsValid() );
			if ( array.IsValid() )
			{
				// Now add a DmeChannel for each flex controller
				int numTracks = event->GetNumFlexAnimationTracks();
				for ( int i = 0 ; i < numTracks; ++i )
				{
					CFlexAnimationTrack *track = event->GetFlexAnimationTrack( i );

					CDmeChannel *channel = CreateElement< CDmeChannel >( track->GetFlexControllerName(), clip->GetFileId() );
					array.AddToTail( channel );

					channel->SetValue< bool >( "flexchannel", true );

					channel->SetValue< bool >( "disabled", !track->IsTrackActive() );
					channel->SetValue< bool >( "combo", track->IsComboType() );

					channel->SetValue< float >( "rangemin", track->GetMin() );
					channel->SetValue< float >( "rangemax", track->GetMax() );

					channel->SetValue< bool >( "isbalancechannel", false );

					// Fill in values..., just log for now
					channel->CreateLog( AT_FLOAT );
					CDmeTypedLog<float> *log = static_cast< CDmeTypedLog<float> * >( channel->GetLog() );
					if ( log )
					{
						CDmeFloatCurveInfo *pCurveInfo = CreateElement< CDmeFloatCurveInfo >( "floatcurveinfo", clip->GetFileId() );

						pCurveInfo->SetDefaultCurveType( MAKE_CURVE_TYPE( INTERPOLATE_CATMULL_ROM_NORMALIZEX, INTERPOLATE_CATMULL_ROM_NORMALIZEX ) );
						pCurveInfo->SetRightEdgeTime( DmeTime_t( event->GetDuration() ) );

						pCurveInfo->SetUseEdgeInfo( true );
						pCurveInfo->SetDefaultEdgeZeroValue( 0.0f );
						// Left edge
						pCurveInfo->SetEdgeInfo( 0, 
							track->IsEdgeActive( true ), 
							track->GetEdgeZeroValue( true ), 
							track->GetEdgeCurveType( true ) );
						// Right edge
						pCurveInfo->SetEdgeInfo( 1, 
							track->IsEdgeActive( false ), 
							track->GetEdgeZeroValue( false ), 
							track->GetEdgeCurveType( false ) );

						log->SetCurveInfo( pCurveInfo );

						// Now set up edge properties

						int sampleCount = track->GetNumSamples();
						for ( int j = 0; j < sampleCount; ++j )
						{
							CExpressionSample *sample = track->GetSample( j );                            
							log->SetKey( DmeTime_t( sample->time ), sample->value, sample->GetCurveType() );
						}
					}

					// Right out the stereo "balance" curve
					if ( track->IsComboType() )
					{
						char balanceChannelName[ 512 ];
						Q_snprintf( balanceChannelName, sizeof( balanceChannelName ), "%s_balance", track->GetFlexControllerName() );

						CDmeChannel *balanceChannel = CreateElement< CDmeChannel >( balanceChannelName, clip->GetFileId() );
						array.AddToTail( balanceChannel );

						channel->SetValue( "balanceChannel", balanceChannel );
						
						balanceChannel->SetValue< bool >( "flexchannel", true );

						balanceChannel->SetValue< bool >( "disabled", !track->IsTrackActive() );
						balanceChannel->SetValue< bool >( "isbalancechannel", true );

						balanceChannel->CreateLog( AT_FLOAT );
						CDmeTypedLog< float > *balance = static_cast< CDmeTypedLog< float > * >( balanceChannel->GetLog() );
						if ( balance )
						{
							CDmeFloatCurveInfo *pCurveInfo = CreateElement< CDmeFloatCurveInfo >( "floatcurveinfo", clip->GetFileId() );

							pCurveInfo->SetDefaultCurveType( MAKE_CURVE_TYPE( INTERPOLATE_CATMULL_ROM_NORMALIZEX, INTERPOLATE_CATMULL_ROM_NORMALIZEX ) );
							pCurveInfo->SetRightEdgeTime( DmeTime_t( event->GetDuration() ) );

							pCurveInfo->SetUseEdgeInfo( false );
							pCurveInfo->SetDefaultEdgeZeroValue( 0.5f );

							/*
							// Don't need to support edge properties for balance curves?
							// Left edge
							pCurveInfo->SetEdgeInfo( 0, 
								track->IsEdgeActive( true ), 
								track->GetEdgeZeroValue( true ), 
								track->GetEdgeCurveType( true ) );
							// Right edge
							pCurveInfo->SetEdgeInfo( 1, 
								track->IsEdgeActive( false ), 
								track->GetEdgeZeroValue( false ), 
								track->GetEdgeCurveType( false ) );
							*/

							balance->SetCurveInfo( pCurveInfo );

							// Now set up edge properties

							int sampleCount = track->GetNumSamples( 1 );
							for ( int j = 0; j < sampleCount; ++j )
							{
								CExpressionSample *sample = track->GetSample( j, 1 );
								balance->SetKey( DmeTime_t( sample->time ), sample->value, sample->GetCurveType() );
							}
						}
					}
				}
			}
		}
		break;
	case CChoreoEvent::LOOP:
		{
			CDmElement *loopProperties = CreateElement< CDmElement >( "LOOP", clip->GetFileId() );
			if ( loopProperties )
			{
				clip->SetValue< CDmElement >( "LOOP", loopProperties );

				loopProperties->SetValue< int >( "loopcount", event->GetLoopCount() );
			}
		}
		break;
	}

	return true;
}

bool ConvertSceneToDmx( CChoreoScene *scene, CDmeFilmClip *dmx )
{
	bool bret = true;

	dmx->SetName( scene->GetFilename() );

	CDmeTimeFrame *tf = dmx->GetTimeFrame();
	Assert( tf );
	if ( tf )
	{
		tf->SetDuration( DmeTime_t( scene->FindStopTime() ) );
	}

	CDmElement *scaleSettings = CreateElement< CDmElement >( "scalesettings", dmx->GetFileId() );
	Assert( scaleSettings );
	CDmAttribute *scaleAttribute = dmx->AddAttributeElement< CDmElement >( "scalesettings" );
	Assert( scaleAttribute );
	scaleAttribute->SetValue( scaleSettings->GetHandle() );
	if ( scaleSettings )
	{
		for ( int i = scene->TimeZoomFirst(); i != scene->TimeZoomInvalid(); i = scene->TimeZoomNext( i ) )
		{
			const char *name = scene->TimeZoomName( i );
			int value = scene->GetTimeZoom( name );
		
			scaleSettings->SetValue< int >( name, value );
		}
	}

	CDmeTrackGroup *pTrackGroup = dmx->FindOrAddTrackGroup( VCD_SCENE_RAMP_TRACK_GROUP_NAME );
	CDmeTrack *track = pTrackGroup->FindOrAddTrack( VCD_SCENE_RAMP_TRACK_GROUP_NAME, DMECLIP_CHANNEL );
	Assert( track );

	// Set a CDmeChannel for the scene_ramp
	CDmeChannelsClip *pClip = CreateElement< CDmeChannelsClip >( VCD_SCENE_RAMP_TRACK_GROUP_NAME, dmx->GetFileId() );
	Assert( pClip );
	track->AddClip( pClip );

	int rampCount = scene->GetSceneRampCount();
	if ( rampCount > 0 )
	{
		// scene_ramp is a channels
		CDmrElementArray<> array( pClip, "channels" );
		Assert( array.IsValid() );
		if ( array.IsValid() )
		{																			   
			CDmeChannel *channel = CreateElement< CDmeChannel >( VCD_SCENE_RAMP_TRACK_GROUP_NAME, dmx->GetFileId() );
			array.AddToTail( channel );
	
			// Fill in values..., just log for now
			channel->CreateLog( AT_FLOAT );
			CDmeTypedLog<float> *ramp = static_cast< CDmeTypedLog<float> * >( channel->GetLog() );
			if ( ramp )
			{
				CDmeFloatCurveInfo *pCurveInfo = CreateElement< CDmeFloatCurveInfo >( "floatcurveinfo", dmx->GetFileId() );

				pCurveInfo->SetDefaultCurveType( MAKE_CURVE_TYPE( INTERPOLATE_CATMULL_ROM_NORMALIZE, INTERPOLATE_CATMULL_ROM_NORMALIZE ) );
				pCurveInfo->SetRightEdgeTime( DmeTime_t( scene->FindStopTime() ) );

				pCurveInfo->SetUseEdgeInfo( true );
				pCurveInfo->SetDefaultEdgeZeroValue( 0.0f );
				// Left edge
				pCurveInfo->SetEdgeInfo( 0, 
					scene->GetSceneRamp()->IsEdgeActive( true ), 
					scene->GetSceneRamp()->GetEdgeZeroValue( true ), 
					scene->GetSceneRamp()->GetEdgeCurveType( true ) );
				// Right edge
				pCurveInfo->SetEdgeInfo( 1, 
					scene->GetSceneRamp()->IsEdgeActive( false ), 
					scene->GetSceneRamp()->GetEdgeZeroValue( false ), 
					scene->GetSceneRamp()->GetEdgeCurveType( false ) );

				ramp->SetCurveInfo( pCurveInfo );

				for ( int j = 0; j < rampCount; ++j )
				{
					CExpressionSample *sample = scene->GetSceneRamp( j );
					ramp->SetKey( DmeTime_t( sample->time ), sample->value, sample->GetCurveType() );
				}
			}
		}
	}

	// Walk the actors and channels
	int numActors = scene->GetNumActors();
	for ( int actor = 0; actor < numActors; ++actor )
	{
		CChoreoActor *pActor = scene->GetActor( actor );
		Assert( pActor );
		if ( !pActor )
			continue;

		CDmeTrackGroup *pTrackGroup = dmx->FindOrAddTrackGroup( pActor->GetName() );
		Assert( pTrackGroup );

		pTrackGroup->SetValue< bool >( "isActor", true );
		pTrackGroup->SetValue< bool >( "actorDisabled", !pActor->GetActive() );
		pTrackGroup->SetValue( "actorModel", pActor->GetFacePoserModelName() );

		int numChannels = pActor->GetNumChannels();
		for ( int channel = 0; channel < numChannels; ++channel )
		{
			CChoreoChannel *pChannel = pActor->GetChannel( channel );
			Assert( pChannel );
			if ( !pChannel )
				continue;

			const char *channelName = pChannel->GetName();
			CDmeTrack *track = pTrackGroup->FindOrAddTrack( channelName, DMECLIP_CHANNEL );
			Assert( track );
			if ( !track )
				continue;

			track->SetMute( !pChannel->GetActive() );

			int numEvents = pChannel->GetNumEvents();
			for ( int event = 0; event < numEvents; ++event )
			{
				CChoreoEvent *pEvent = pChannel->GetEvent( event );
				Assert( pEvent );
				if ( !pEvent )
					continue;

				// Set up event
				CDmeChannelsClip *pClip = CreateElement< CDmeChannelsClip >( "", dmx->GetFileId() );
				Assert( pClip );
				track->AddClip( pClip );

				// Fill in data
				bool success = ConvertEventToDmx( pEvent, pClip );
				if ( !success )
				{
					bret = false;
					Assert( 0 );
					break;
				}
    		}
		}
	}

	pTrackGroup = dmx->FindOrAddTrackGroup( VCD_GLOBAL_EVENTS_TRACK_GROUP_NAME );
	Assert( pTrackGroup );

	track = pTrackGroup->FindOrAddTrack( VCD_GLOBAL_EVENTS_TRACK_GROUP_NAME, DMECLIP_CHANNEL );
	Assert( track );

	// Now add global events
	int numEvents = scene->GetNumEvents();
	for ( int event = 0; event < numEvents; ++event )
	{
		CChoreoEvent *pEvent = scene->GetEvent( event );
		if ( !pEvent || pEvent->GetActor() )
			continue;

		// Set up event
		CDmeChannelsClip *pClip = CreateElement< CDmeChannelsClip >( "", dmx->GetFileId() );
		Assert( pClip );

		track->AddClip( pClip );

		// Fill in data
		bool success = ConvertEventToDmx( pEvent, pClip );
		if ( !success )
		{
			bret = false;
			Assert( 0 );
			break;
		}
	}

	dmx->SetValue( "associated_bsp", scene->GetMapname() );
	dmx->SetValue< float >( "fps", scene->GetSceneFPS() );
	dmx->SetValue< bool >( "snap", scene->IsUsingFrameSnap() );

	return bret;
}

void EnsureActorAndChannelForTrack( CChoreoScene *scene, CDmeTrackGroup *pActor, CDmeTrack *pChannel )
{
	const char *actorName = pActor->GetName();
	const char *channelName = pChannel->GetName();

	CChoreoActor *a = scene->FindActor( actorName );
	if ( !a )
	{
		a = scene->AllocActor();
		Assert( a );
		a->SetName( actorName );
		a->SetActive( !pActor->GetValue< bool >( "actorDisabled" ) );
		a->SetFacePoserModelName( pActor->GetValueString( "actorModel" ) );
	}

	CChoreoChannel *c = a->FindChannel( channelName );
	if ( !c )
	{
		c = scene->AllocChannel();
		Assert( c );
		c->SetName( channelName );
		c->SetActor( a );
		c->SetActive( !pChannel->IsMute() );
		a->AddChannel( c );
	}
}

template< class T >
T *FindAttributeInArray( const CDmrElementArray<> &array, const char *elementName )
{
	int c = array.Count();
	for ( int i = 0; i < c; ++i )
	{
		T *element = CastElement< T >( array[ i ] );
		if ( !element )
			continue;

		if ( !Q_stricmp( element->GetName(), elementName ) )
			return element;
	}

	return NULL;
}

bool ConvertDmxToEvent( CChoreoScene *scene, CDmeTrackGroup *pActor, CDmeTrack *pChannel, CDmeChannelsClip *clip, bool globalEvent )
{
	bool bret = true;

	// Allocate choreo event
	CChoreoEvent *event = scene->AllocEvent();
	Assert( event );
	if ( !event )
	{
		bret = false;
		return bret;
	}

	event->SetName( clip->GetName() );
	event->SetType( CChoreoEvent::TypeForName( clip->GetValueString( "eventtype" ) ) );

	if ( !globalEvent )
	{
		EnsureActorAndChannelForTrack( scene, pActor, pChannel );

		const char *actorName = pActor->GetName();
		const char *channelName = pChannel->GetName();

		CChoreoActor *a = scene->FindActor( actorName );
		Assert( a );
		CChoreoChannel *c = a->FindChannel( channelName );
		Assert( c );

		if ( !a || !c )
		{
			bret = false;
			return bret;
		}

		event->SetActor( a );
		event->SetChannel( c );
		c->AddEvent( event );
	}

	// Set timeframe info
	CDmeTimeFrame *tf = clip->GetTimeFrame();
	Assert( tf );
	if ( tf )
	{
		event->SetStartTime( tf->GetStartTime().GetSeconds() );
		float duration =  tf->GetDuration().GetSeconds();
		if ( duration <= 0.0f )
		{
			event->SetEndTime( -1.0f );
		}
		else
		{
			event->SetEndTime( event->GetStartTime() + duration );
		}
	}

	event->SetParameters( clip->GetValueString( "parameters" ) );
	event->SetParameters2( clip->GetValueString( "parameters2" ) );

	const CDmrElementArray<> array( clip, "channels" );
	Assert( array.IsValid() );
	if ( array.IsValid() )
	{
		int c = array.Count();
		for ( int i = 0 ; i < c; ++i )
		{
			CDmeChannel *channel = CastElement< CDmeChannel >( array[i] );
			if ( !channel || Q_stricmp( channel->GetName(), "event_ramp" ) )
				continue;

			CDmeTypedLog< float > *ramp = static_cast< CDmeTypedLog< float > * >( channel->GetLog() );
			if ( !ramp )
				continue;

			bool active[ 2 ];
			float value[ 2 ];
			int curveType[ 2 ];

			ramp->GetEdgeInfo( 0, active[ 0 ], value[ 0 ], curveType[ 0 ] );
			ramp->GetEdgeInfo( 1, active[ 1 ], value[ 1 ], curveType[ 1 ] );

			event->GetRamp()->SetEdgeActive( true, active[ 0 ] ); 
			event->GetRamp()->SetEdgeActive( false, active[ 1 ] ); 

			event->GetRamp()->SetEdgeInfo( true, curveType[ 0 ], value[ 0 ] );
			event->GetRamp()->SetEdgeInfo( false, curveType[ 1 ], value[ 1 ] );

			int rampCount = ramp->GetKeyCount();
			for ( int j = 0; j < rampCount; ++j )
			{
				CExpressionSample *sample = event->AddRamp( ramp->GetKeyTime( j ).GetSeconds(), ramp->GetKeyValue( j ), false );
				sample->SetCurveType( ramp->GetKeyCurveType( j ) );
			}
		}
	}

	event->SetPitch( clip->GetValue< float >( "pitch" ) );
	event->SetYaw( clip->GetValue< float >( "yaw" ) );

	event->SetResumeCondition( clip->GetValue< bool >( "resumecondition" ) );
	event->SetLockBodyFacing( clip->GetValue< bool >( "lockbodyfacing" ) );
	event->SetDistanceToTarget( clip->GetValue< float >( "distancetotarget" ) );
	event->SetFixedLength( clip->GetValue< bool >( "fixedlength" ) );
	event->SetForceShortMovement( clip->GetValue< bool >( "forceshortmovement" ) );
	event->SetActive( clip->GetValue< bool >( "active" ) );

	if ( clip->HasAttribute( "tags" ) )
	{
		CDmElement *tags = clip->GetValueElement< CDmElement >( "tags" );
		if ( tags )
		{
			// Now create arrays for the name and percentages
			const CDmrStringArray names( tags, "tagname" );
			const CDmrArray<float> percentages( tags, "tagpercentage" );
			Assert( names.IsValid() && percentages.IsValid() );
			
			Assert( names.Count() == percentages.Count() );
			for ( int t = 0; t < names.Count(); t++ )
			{
				event->AddRelativeTag( names[t], percentages[t] );
			}
		}
	}

	if ( clip->HasAttribute( "timing_tags" ) )
	{
		CDmElement *tags = clip->GetValueElement< CDmElement >( "timing_tags" );
		if ( tags )
		{
			// Now create arrays for the name and percentages
			const CDmrStringArray names( tags, "tagname" );
			const CDmrArray<float> percentages( tags, "tagpercentage" );
			const CDmrArray<bool> lockstates( tags, "lockedstate" );

			Assert( names.IsValid() && percentages.IsValid() && lockstates.IsValid() );
			Assert( names.Count() == percentages.Count() && names.Count() == lockstates.Count() );

			for ( int t = 0; t < names.Count(); t++ )
			{
				event->AddTimingTag( names[ t ], percentages[ t ], lockstates[ t ] );
			}
		}
	}

	
	// Abs tags
	int tagtype;
	for ( tagtype = 0; tagtype < CChoreoEvent::NUM_ABS_TAG_TYPES; tagtype++ )
	{
		char sz[ 512 ];
		Q_snprintf( sz, sizeof( sz ), "absolutetags %s", CChoreoEvent::NameForAbsoluteTagType( (CChoreoEvent::AbsTagType)tagtype ) );

		if ( clip->HasAttribute( sz ) )
		{
			CDmElement *tags = clip->GetValueElement< CDmElement >( sz );
			if ( tags )
			{
				// Now create arrays for the name and percentages
				const CDmrStringArray names( tags, "tagname" );
				const CDmrArray<float> percentages( tags, "tagpercentage" );

				Assert( names.IsValid() && percentages.IsValid() );
				Assert( names.Count() == percentages.Count() );

				for ( int t = 0; t < names.Count(); t++ )
				{
					event->AddAbsoluteTag( (CChoreoEvent::AbsTagType)tagtype, names[ t ], percentages[ t ] );
				}
			}
		}
	}
	
	if ( clip->HasAttribute( "relative_tag" ) )
	{
		CDmElement *relativeTag = clip->GetValueElement< CDmElement >( "relative_tag" );
		if ( relativeTag )
		{
			event->SetUsingRelativeTag
			( 
				true,
				relativeTag->GetValueString( "tagname" ),
				relativeTag->GetValueString( "tagwav" ) 
			);
		}
	}
				
	switch ( event->GetType() )
	{
	default:
		break;
	case CChoreoEvent::SPEAK:
		{
			CDmElement *speakProperties = NULL;
			if ( clip->HasAttribute( "SPEAK" ) )
			{
				speakProperties = clip->GetValueElement< CDmElement >( "SPEAK" );
			}
			if ( speakProperties )
			{
				event->SetCloseCaptionType( CChoreoEvent::CCTypeForName( speakProperties->GetValueString( "closedcaption_type" ) ) );
				event->SetCloseCaptionToken( speakProperties->GetValueString( "closedcaption_token" ) );
				event->SetUsingCombinedFile( speakProperties->GetValue< bool >( "closedcaption_usingcombinedfile" ) );
				event->SetCombinedUsingGenderToken( speakProperties->GetValue< bool >( "closedcaption_combinedusesgender" ) );
				event->SetSuppressingCaptionAttenuation( speakProperties->GetValue< bool >( "closedcaption_noattenuate" ) );
			}
		}
		break;
	case CChoreoEvent::GESTURE:
		{
			CDmElement *gestureProperties = NULL;
			if ( clip->HasAttribute( "GESTURE" ) )
			{
				gestureProperties = clip->GetValueElement< CDmElement >( "GESTURE" );
			}
			if ( gestureProperties )
			{
				if ( Q_stricmp( clip->GetName(), "NULL" ) )
				{
					event->SetGestureSequenceDuration( gestureProperties->GetValue< float >( "sequenceduration" ) );
				}
			}
		}
		break;
	case CChoreoEvent::FLEXANIMATION:
		{
			// Save flex animation tracks as channels
			const CDmrElementArray<> array( clip, "channels" );
			if ( array.IsValid() )
			{
				// Now add a DmeChannel for each flex controller
				int numTracks = array.Count();
				for ( int i = 0 ; i < numTracks; ++i )
				{
					CDmeChannel *channel = CastElement< CDmeChannel >( array[ i ] );
					Assert( channel );
					if ( !channel )
					{
						bret = false;
						break;
					}

					if ( !channel->HasAttribute( "flexchannel" ) )
						continue;

					// Skip all helper channels, only care about flexchannels
					if ( !channel->GetValue< bool >( "flexchannel" ) )
						continue;

					// Skip the balance channels, we'll pull their data below
					if ( channel->GetValue< bool >( "isbalancechannel" ) )
						continue;

					Assert( !Q_stristr( channel->GetName(), "_balance" ) );

					CFlexAnimationTrack *track = event->AddTrack( channel->GetName() );
					Assert( track );

					if ( !track )
					{
						bret = false;
						break;
					}

					track->SetTrackActive( !channel->GetValue< bool >( "disabled" ) );
					track->SetComboType( channel->GetValue< bool >( "combo" ) );

					track->SetMin( channel->GetValue< float >( "rangemin" ) );
					track->SetMax( channel->GetValue< float >( "rangemax" ) );

					CDmeTypedLog<float> *log = static_cast< CDmeTypedLog<float> * >( channel->GetLog() );
					if ( log )
					{
						bool active[ 2 ];
						float value[ 2 ];
						int curveType[ 2 ];

						log->GetEdgeInfo( 0, active[ 0 ], value[ 0 ], curveType[ 0 ] );
						log->GetEdgeInfo( 1, active[ 1 ], value[ 1 ], curveType[ 1 ] );

						track->SetEdgeActive( true, active[ 0 ] ); 
						track->SetEdgeActive( false, active[ 1 ] ); 

						track->SetEdgeInfo( true, curveType[ 0 ], value[ 0 ] );
						track->SetEdgeInfo( false, curveType[ 1 ], value[ 1 ] );

                        int sampleCount = log->GetKeyCount();
						for ( int j = 0; j < sampleCount; ++j )
						{
							int curveType = log->GetKeyCurveType( j );
							float value = log->GetKeyValue( j );
							DmeTime_t time = log->GetKeyTime( j );
 
							CExpressionSample *sample = track->AddSample( time.GetSeconds(), value, 0 );
							sample->SetCurveType( curveType );
						}
					}

					// Right out the stereo "balance" curve
					if ( track->IsComboType() )
					{
						char balanceChannelName[ 512 ];
						Q_snprintf( balanceChannelName, sizeof( balanceChannelName ), "%s_balance", track->GetFlexControllerName() );

						// Find the balance data
						CDmeChannel *balanceChannel = FindAttributeInArray< CDmeChannel >( array, balanceChannelName );
						if ( balanceChannel )
						{
							CDmeTypedLog< float > *balance = static_cast< CDmeTypedLog< float > * >( balanceChannel->GetLog() );
							if ( balance )
							{
								// Now set up edge properties
								int sampleCount = balance->GetKeyCount();
								for ( int j = 0; j < sampleCount; ++j )
								{
									int curveType = balance->GetKeyCurveType( j );
									float value = balance->GetKeyValue( j );
									DmeTime_t time = balance->GetKeyTime( j );
		 
									CExpressionSample *sample = track->AddSample( time.GetSeconds(), value, 1 );
									sample->SetCurveType( curveType );
								}
							}
							else
							{
								char msg[ 512 ];
								Q_snprintf( msg, sizeof( msg ), "Error:  Missing balance channel for combo flex track (%s) in (%s)\n", track->GetFlexControllerName(), event->GetName() );
								Warning( msg );
							}
						}
					}
				}
			}
		}
		break;
	case CChoreoEvent::LOOP:
		{
			CDmElement *loopProperties = NULL;
			if ( clip->HasAttribute( "LOOP" ) )
			{
				loopProperties = clip->GetValueElement< CDmElement >( "LOOP" );
			}
			if ( loopProperties )
			{
				event->SetLoopCount( loopProperties->GetValue< int >( "loopcount" ) );
			}
		}
		break;
	}

	return true;
}

bool ConvertDmxToScene( CDmeFilmClip *dmx, CChoreoScene *scene )
{
	bool bret = true;

	// This should have been created correctly already
	// Assert( !Q_stricmp( scene->GetFilename(), dmx->GetName() ) );

	CDmElement *scaleSettings = dmx->GetValueElement< CDmElement >( "scalesettings" );
	Assert( scaleSettings );
	if ( scaleSettings )
	{
		CDmAttribute *setting = scaleSettings->FirstAttribute();
		for ( ; setting ; setting = setting->NextAttribute() )
		{
			if ( setting->GetType() != AT_INT )
				continue;

			scene->SetTimeZoom( setting->GetName(), setting->GetValue<int>() );
		}
	}

	// Deal with the scene ramp
	CDmeTrackGroup *pTrackGroup = dmx->FindTrackGroup( VCD_SCENE_RAMP_TRACK_GROUP_NAME );
	if ( pTrackGroup )
	{
		CDmeTrack *track = pTrackGroup->FindTrack( VCD_SCENE_RAMP_TRACK_GROUP_NAME );
		if ( track )
		{
			CDmeChannelsClip *pClip = CastElement< CDmeChannelsClip >( track->FindNamedClip( VCD_SCENE_RAMP_TRACK_GROUP_NAME ) );
			if ( pClip )
			{
				// scene_ramp should be the first subchannel
				const CDmrElementArray<> array( pClip, "channels" );
				Assert( array.IsValid() );
				if ( array.IsValid() && ( array.Count() > 0 ) )
				{
					CDmeChannel *channel = CastElement< CDmeChannel >( array[0] );
					if ( channel )
					{
						CDmeTypedLog< float > *ramp = static_cast< CDmeTypedLog< float > * >( channel->GetLog() );
						if ( ramp )
						{
							bool active[ 2 ];
							float value[ 2 ];
							int curveType[ 2 ];

							ramp->GetEdgeInfo( 0, active[ 0 ], value[ 0 ], curveType[ 0 ] );
							ramp->GetEdgeInfo( 1, active[ 1 ], value[ 1 ], curveType[ 1 ] );

							scene->GetSceneRamp()->SetEdgeActive( true, active[ 0 ] ); 
							scene->GetSceneRamp()->SetEdgeActive( false, active[ 1 ] ); 

							scene->GetSceneRamp()->SetEdgeInfo( true, curveType[ 0 ], value[ 0 ] );
							scene->GetSceneRamp()->SetEdgeInfo( false, curveType[ 1 ], value[ 1 ] );

							int rampCount = ramp->GetKeyCount();
							for ( int j = 0; j < rampCount; ++j )
							{
								CExpressionSample *sample = scene->AddSceneRamp( ramp->GetKeyTime( j ).GetSeconds(), ramp->GetKeyValue( j ), false );
								sample->SetCurveType( ramp->GetKeyCurveType( j ) );
							}
						}
					}
				}
			}
		}
	}

	// Deal with global events
	pTrackGroup = dmx->FindTrackGroup( VCD_GLOBAL_EVENTS_TRACK_GROUP_NAME );
	if ( pTrackGroup )
	{
		CDmeTrack *pTrack = pTrackGroup->FindTrack( VCD_GLOBAL_EVENTS_TRACK_GROUP_NAME );
		if ( pTrack )
		{
			// Now add global events
			int numEvents = pTrack->GetClipCount();
			for ( int event = 0; event < numEvents; ++event )
			{
				CDmeChannelsClip *pClip = CastElement< CDmeChannelsClip >( pTrack->GetClip( event ) );
				if ( !pClip )
					continue;

				bool success = ConvertDmxToEvent( scene, pTrackGroup, pTrack, pClip, true );
				if ( !success )
				{
					bret = false;
					Assert( 0 );
					break;
				}
			}
		}
	}

	int nNumTrackGroups = dmx->GetTrackGroupCount();
	for ( int i = 0; i < nNumTrackGroups; ++i )
	{
		CDmeTrackGroup *pTrackGroup = dmx->GetTrackGroup( i );
		if ( !pTrackGroup->GetValue< bool >( "isActor" ) )
			continue;

		// Walk the track groups
		int nNumTracks = pTrackGroup->GetTrackCount();
		for ( int j = 0 ; j < nNumTracks; ++j )
		{
			CDmeTrack *pTrack = pTrackGroup->GetTrack( j );
			
			EnsureActorAndChannelForTrack( scene, pTrackGroup, pTrack );

			int numEvents = pTrack->GetClipCount();
			for ( int clip = 0; clip < numEvents; ++clip )
			{
				CDmeChannelsClip *pClip = CastElement< CDmeChannelsClip >( pTrack->GetClip( clip ) );
				if ( !pClip )
					continue;
				
				bool success = ConvertDmxToEvent( scene, pTrackGroup, pTrack, pClip, false );
				if ( !success )
				{
					bret = false;
					Assert( 0 );
					break;
				}
			}
		}
	}

	scene->SetMapname( dmx->GetValueString( "associated_bsp" ) );
	scene->SetSceneFPS( dmx->GetValue< float >( "fps" ) );
	scene->SetUsingFrameSnap( dmx->GetValue< bool >( "snap" ) );

	return bret;
}