BotoX
/
hl2_src-leak-2017
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
hl2_src-leak-2017/src/utils/hlfaceposer/choreoview.cpp

11648 lines
262 KiB
C++
Raw Permalink Blame History

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
// $NoKeywords: $
//===========================================================================//
#include "cbase.h"
#include <stdio.h>
#include <mxtk/mxWindow.h>
#include "mdlviewer.h"
#include "hlfaceposer.h"
#include "StudioModel.h"
#include "expressions.h"
#include "expclass.h"
#include "ChoreoView.h"
#include "choreoevent.h"
#include "choreoactor.h"
#include "choreochannel.h"
#include "choreoscene.h"
#include "choreowidget.h"
#include "choreoactorwidget.h"
#include "choreochannelwidget.h"
#include "choreoglobaleventwidget.h"
#include "choreowidgetdrawhelper.h"
#include "choreoeventwidget.h"
#include "viewerSettings.h"
#include "filesystem.h"
#include "choreoviewcolors.h"
#include "ActorProperties.h"
#include "ChannelProperties.h"
#include "EventProperties.h"
#include "GlobalEventProperties.h"
#include "ifaceposersound.h"
#include "snd_wave_source.h"
#include "ifaceposerworkspace.h"
#include "PhonemeEditor.h"
#include "iscenetokenprocessor.h"
#include "InputProperties.h"
#include "filesystem.h"
#include "ExpressionTool.h"
#include "ControlPanel.h"
#include "faceposer_models.h"
#include "choiceproperties.h"
#include "MatSysWin.h"
#include "tier1/strtools.h"
#include "GestureTool.h"
#include "npcevent.h"
#include "RampTool.h"
#include "SceneRampTool.h"
#include "KeyValues.h"
#include "SoundEmitterSystem/isoundemittersystembase.h"
#include "cclookup.h"
#include "iclosecaptionmanager.h"
#include "AddSoundEntry.h"
#include "isoundcombiner.h"
#include <vgui/ILocalize.h>
#include "scriplib.h"
#include "WaveBrowser.h"
#include "filesystem_init.h"
#include "flexpanel.h"
#include "tier3/choreoutils.h"
#include "tier2/p4helpers.h"
using namespace vgui;
extern vgui::ILocalize *g_pLocalize;
// 10x magnification
#define MAX_TIME_ZOOM 1000
#define TIME_ZOOM_STEP 4
#define PHONEME_FILTER 0.08f
#define PHONEME_DELAY 0.0f
#define SCRUBBER_HEIGHT 15
#define TIMELINE_NUMBERS_HEIGHT 11
#define COPYPASTE_FILENAME "scenes/copydatavcd.txt"
extern double realtime;
extern bool NameLessFunc( const char *const& name1, const char *const& name2 );
// Try to keep shifted times at same absolute time
static void RescaleExpressionTimes( CChoreoEvent *event, float newstart, float newend )
{
if ( !event || event->GetType() != CChoreoEvent::FLEXANIMATION )
return;
// Did it actually change
if ( newstart == event->GetStartTime() &&
newend == event->GetEndTime() )
{
return;
}
float newduration = newend - newstart;
float dt = 0.0f;
//If the end is moving, leave tags stay where they are (dt == 0.0f)
if ( newstart != event->GetStartTime() )
{
// Otherwise, if the new start is later, then tags need to be shifted backwards
dt -= ( newstart - event->GetStartTime() );
}
int count = event->GetNumFlexAnimationTracks();
int i;
for ( i = 0; i < count; i++ )
{
CFlexAnimationTrack *track = event->GetFlexAnimationTrack( i );
if ( !track )
continue;
for ( int type = 0; type < 2; type++ )
{
int sampleCount = track->GetNumSamples( type );
for ( int sample = sampleCount - 1; sample >= 0 ; sample-- )
{
CExpressionSample *s = track->GetSample( sample, type );
if ( !s )
continue;
s->time += dt;
if ( s->time > newduration || s->time < 0.0f )
{
track->RemoveSample( sample, type );
}
}
}
}
}
static void RescaleRamp( CChoreoEvent *event, float newduration )
{
float oldduration = event->GetDuration();
if ( fabs( oldduration - newduration ) < 0.000001f )
return;
if ( newduration <= 0.0f )
return;
float midpointtime = oldduration * 0.5f;
float newmidpointtime = newduration * 0.5f;
int count = event->GetRampCount();
int i;
for ( i = 0; i < count; i++ )
{
CExpressionSample *sample = event->GetRamp( i );
if ( !sample )
continue;
float t = sample->time;
if ( t < midpointtime )
continue;
float timefromend = oldduration - t;
// There's room to just shift it
if ( timefromend <= newmidpointtime )
{
t = newduration - timefromend;
}
else
{
// No room, rescale them instead
float frac = ( t - midpointtime ) / midpointtime;
t = newmidpointtime + frac * newmidpointtime;
}
sample->time = t;
}
}
bool DoesAnyActorHaveAssociatedModelLoaded( CChoreoScene *scene )
{
if ( !scene )
return false;
int c = scene->GetNumActors();
int i;
for ( i = 0; i < c; i++ )
{
CChoreoActor *a = scene->GetActor( i );
if ( !a )
continue;
char const *modelname = a->GetFacePoserModelName();
if ( !modelname )
continue;
if ( !modelname[ 0 ] )
continue;
char mdlname[ 256 ];
Q_strncpy( mdlname, modelname, sizeof( mdlname ) );
Q_FixSlashes( mdlname );
int idx = models->FindModelByFilename( mdlname );
if ( idx >= 0 )
{
return true;
}
}
return false;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *a -
// Output : StudioModel
//-----------------------------------------------------------------------------
StudioModel *FindAssociatedModel( CChoreoScene *scene, CChoreoActor *a )
{
if ( !a || !scene )
return NULL;
Assert( models->GetActiveStudioModel() );
StudioModel *model = NULL;
if ( a->GetFacePoserModelName()[ 0 ] )
{
int idx = models->FindModelByFilename( a->GetFacePoserModelName() );
if ( idx >= 0 )
{
model = models->GetStudioModel( idx );
return model;
}
}
// Is there any loaded model with the actorname in it?
int c = models->Count();
for ( int i = 0; i < c; i++ )
{
char const *modelname = models->GetModelName( i );
if ( !Q_stricmp( modelname, a->GetName() ) )
{
return models->GetStudioModel( i );
}
}
// Does any actor have an associated model which is loaded
if ( DoesAnyActorHaveAssociatedModelLoaded( scene ) )
{
// Then return NULL here so we don't override with the default an actor who has a valid model going
return NULL;
}
// Couldn't find it and nobody else has a loaded associated model, so just use the default model
if ( !model )
{
model = models->GetActiveStudioModel();
}
return model;
}
CChoreoView *g_pChoreoView = 0;
//-----------------------------------------------------------------------------
// Purpose:
// Input : *parent -
// x -
// y -
// w -
// h -
// id -
//-----------------------------------------------------------------------------
CChoreoView::CChoreoView( mxWindow *parent, int x, int y, int w, int h, int id )
: IFacePoserToolWindow( "CChoreoView", "Choreography" ), mxWindow( parent, x, y, w, h )
{
m_bRampOnly = false;
m_bForceProcess = false;
m_bSuppressLayout = true;
SetAutoProcess( true );
m_flLastMouseClickTime = -1.0f;
m_bProcessSequences = true;
m_flPlaybackRate = 1.0f;
m_pScene = NULL;
m_flScrub = 0.0f;
m_flScrubTarget = 0.0f;
m_bCanDraw = false;
m_bRedoPending = false;
m_nUndoLevel = 0;
CChoreoEventWidget::LoadImages();
CChoreoWidget::m_pView = this;
setId( id );
m_flLastSpeedScale = 0.0f;
m_bResetSpeedScale = false;
m_nTopOffset = 0;
m_flLeftOffset = 0.0f;
m_nLastHPixelsNeeded = -1;
m_nLastVPixelsNeeded = -1;
m_nStartRow = 45;
m_nLabelWidth = 140;
m_nRowHeight = 35;
m_bSimulating = false;
m_bPaused = false;
m_bForward = true;
m_flStartTime = 0.0f;
m_flEndTime = 0.0f;
m_flFrameTime = 0.0f;
m_bAutomated = false;
m_nAutomatedAction = SCENE_ACTION_UNKNOWN;
m_flAutomationDelay = 0.0f;
m_flAutomationTime = 0.0f;
m_pVertScrollBar = new mxScrollbar( this, 0, 0, 18, 100, IDC_CHOREOVSCROLL, mxScrollbar::Vertical );
m_pHorzScrollBar = new mxScrollbar( this, 0, 0, 18, 100, IDC_CHOREOHSCROLL, mxScrollbar::Horizontal );
m_bLayoutIsValid = false;
m_flPixelsPerSecond = 150.0f;
m_btnPlay = new mxBitmapButton( this, 2, 4, 16, 16, IDC_PLAYSCENE, "gfx/hlfaceposer/play.bmp" );
m_btnPause = new mxBitmapButton( this, 18, 4, 16, 16, IDC_PAUSESCENE, "gfx/hlfaceposer/pause.bmp" );
m_btnStop = new mxBitmapButton( this, 34, 4, 16, 16, IDC_STOPSCENE, "gfx/hlfaceposer/stop.bmp" );
m_pPlaybackRate = new mxSlider( this, 0, 0, 16, 16, IDC_CHOREO_PLAYBACKRATE );
m_pPlaybackRate->setRange( 0.0, 2.0, 40 );
m_pPlaybackRate->setValue( m_flPlaybackRate );
ShowButtons( false );
m_nFontSize = 12;
for ( int i = 0; i < MAX_ACTORS; i++ )
{
m_ActorExpanded[ i ].expanded = true;
}
SetChoreoFile( "" );
//SetFocus( (HWND)getHandle() );
if ( workspacefiles->GetNumStoredFiles( IWorkspaceFiles::CHOREODATA ) >= 1 )
{
LoadSceneFromFile( workspacefiles->GetStoredFile( IWorkspaceFiles::CHOREODATA, 0 ) );
}
ClearABPoints();
m_pClickedActor = NULL;
m_pClickedChannel = NULL;
m_pClickedEvent = NULL;
m_pClickedGlobalEvent = NULL;
m_nClickedX = 0;
m_nClickedY = 0;
m_nSelectedEvents = 0;
m_nClickedTag = -1;
m_nClickedChannelCloseCaptionButton = CChoreoChannelWidget::CLOSECAPTION_NONE;
// Mouse dragging
m_bDragging = false;
m_xStart = 0;
m_yStart = 0;
m_nDragType = DRAGTYPE_NONE;
m_hPrevCursor = 0;
m_nMinX = 0;
m_nMaxX = 0;
m_bUseBounds = false;
m_nScrollbarHeight = 12;
m_nInfoHeight = 30;
ClearStatusArea();
SetDirty( false );
m_bCanDraw = true;
m_bSuppressLayout = false;
m_flScrubberTimeOffset = 0.0f;
m_bShowCloseCaptionData = true;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : closing -
//-----------------------------------------------------------------------------
bool CChoreoView::Close( void )
{
if ( m_pScene && m_bDirty )
{
int retval = mxMessageBox( NULL, va( "Save changes to scene '%s'?", GetChoreoFile() ), g_appTitle, MX_MB_YESNOCANCEL );
if ( retval == 2 )
{
return false;
}
if ( retval == 0 )
{
Save();
}
}
if ( m_pScene )
{
UnloadScene();
}
return true;
}
bool CChoreoView::CanClose()
{
if ( m_pScene )
{
workspacefiles->StartStoringFiles( IWorkspaceFiles::CHOREODATA );
workspacefiles->StoreFile( IWorkspaceFiles::CHOREODATA, GetChoreoFile() );
workspacefiles->FinishStoringFiles( IWorkspaceFiles::CHOREODATA );
}
if ( m_pScene && m_bDirty && !Close() )
{
return false;
}
return true;
}
//-----------------------------------------------------------------------------
// Purpose: Called just before window is destroyed
//-----------------------------------------------------------------------------
void CChoreoView::OnDelete()
{
if ( m_pScene )
{
UnloadScene();
}
CChoreoWidget::m_pView = NULL;
CChoreoEventWidget::DestroyImages();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CChoreoView::~CChoreoView()
{
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CChoreoView::ReportSceneClearToTools( void )
{
if ( m_pScene )
{
m_pScene->ResetSimulation();
}
g_pPhonemeEditor->ClearEvent();
g_pExpressionTool->LayoutItems( true );
g_pExpressionTool->redraw();
g_pGestureTool->redraw();
g_pRampTool->redraw();
g_pSceneRampTool->redraw();
}
//-----------------------------------------------------------------------------
// Purpose: Find a time that's less than input on the granularity:
// e.g., 3.01 granularity 0.05 will be 3.00, 3.05 will be 3.05
// Input : input -
// granularity -
// Output : float
//-----------------------------------------------------------------------------
float SnapTime( float input, float granularity )
{
float base = (float)(int)input;
float multiplier = (float)(int)( 1.0f / granularity );
float fracpart = input - (int)input;
fracpart *= multiplier;
fracpart = (float)(int)fracpart;
fracpart *= granularity;
return base + fracpart;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : drawHelper -
// rc -
// left -
// right -
//-----------------------------------------------------------------------------
void CChoreoView::DrawTimeLine( CChoreoWidgetDrawHelper& drawHelper, RECT& rc, float left, float right )
{
RECT rcFill = m_rcTimeLine;
rcFill.bottom -= TIMELINE_NUMBERS_HEIGHT;
drawHelper.DrawFilledRect( COLOR_CHOREO_DARKBACKGROUND, rcFill );
RECT rcLabel;
float granularity = 0.5f / ((float)GetTimeZoom( GetToolName() ) / 100.0f);
drawHelper.DrawColoredLine( COLOR_CHOREO_TIMELINE, PS_SOLID, 1, rc.left, GetStartRow() - 1, rc.right, GetStartRow() - 1 );
float f = SnapTime( left, granularity );
while ( f < right )
{
float frac = ( f - left ) / ( right - left );
if ( frac >= 0.0f && frac <= 1.0f )
{
rcLabel.left = GetLabelWidth() + (int)( frac * ( rc.right - GetLabelWidth() ) );
rcLabel.bottom = GetStartRow() - 1;
rcLabel.top = rcLabel.bottom - 10;
if ( f != left )
{
drawHelper.DrawColoredLine( RGB( 220, 220, 240 ), PS_DOT, 1,
rcLabel.left, GetStartRow(), rcLabel.left, h2() );
}
char sz[ 32 ];
sprintf( sz, "%.2f", f );
int textWidth = drawHelper.CalcTextWidth( "Arial", 9, FW_NORMAL, sz );
rcLabel.right = rcLabel.left + textWidth;
OffsetRect( &rcLabel, -textWidth / 2, 0 );
drawHelper.DrawColoredText( "Arial", 9, FW_NORMAL, COLOR_CHOREO_TEXT, rcLabel, sz );
}
f += granularity;
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CChoreoView::PaintBackground( void )
{
redraw();
return false;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : drawHelper -
//-----------------------------------------------------------------------------
void CChoreoView::DrawSceneABTicks( CChoreoWidgetDrawHelper& drawHelper )
{
RECT rcThumb;
float scenestart = m_rgABPoints[ 0 ].active ? m_rgABPoints[ 0 ].time : 0.0f;
float sceneend = m_rgABPoints[ 1 ].active ? m_rgABPoints[ 1 ].time : 0.0f;
if ( scenestart )
{
int markerstart = GetPixelForTimeValue( scenestart );
rcThumb.left = markerstart - 4;
rcThumb.right = markerstart + 4;
rcThumb.top = 2 + GetCaptionHeight() + SCRUBBER_HEIGHT;
rcThumb.bottom = rcThumb.top + 8;
drawHelper.DrawTriangleMarker( rcThumb, COLOR_CHOREO_TICKAB );
}
if ( sceneend )
{
int markerend = GetPixelForTimeValue( sceneend );
rcThumb.left = markerend - 4;
rcThumb.right = markerend + 4;
rcThumb.top = 2 + GetCaptionHeight() + SCRUBBER_HEIGHT;
rcThumb.bottom = rcThumb.top + 8;
drawHelper.DrawTriangleMarker( rcThumb, COLOR_CHOREO_TICKAB );
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : drawHelper -
// rc -
//-----------------------------------------------------------------------------
void CChoreoView::DrawRelativeTagLines( CChoreoWidgetDrawHelper& drawHelper, RECT& rc )
{
if ( !m_pScene )
return;
RECT rcClip;
GetClientRect( (HWND)getHandle(), &rcClip );
rcClip.top = GetStartRow();
rcClip.bottom -= ( m_nInfoHeight + m_nScrollbarHeight );
rcClip.right -= m_nScrollbarHeight;
drawHelper.StartClipping( rcClip );
for ( int i = 0; i < m_SceneActors.Size(); i++ )
{
CChoreoActorWidget *a = m_SceneActors[ i ];
if ( !a )
continue;
for ( int j = 0; j < a->GetNumChannels(); j++ )
{
CChoreoChannelWidget *c = a->GetChannel( j );
if ( !c )
continue;
for ( int k = 0; k < c->GetNumEvents(); k++ )
{
CChoreoEventWidget *e = c->GetEvent( k );
if ( !e )
continue;
CChoreoEvent *event = e->GetEvent();
if ( !event )
continue;
if ( !event->IsUsingRelativeTag() )
continue;
// Using it, find the tag and figure out the time for it
CEventRelativeTag *tag = m_pScene->FindTagByName(
event->GetRelativeWavName(),
event->GetRelativeTagName() );
if ( !tag )
continue;
// Found it, draw a vertical line
//
float tagtime = tag->GetStartTime();
// Convert to pixel value
bool clipped = false;
int pixel = GetPixelForTimeValue( tagtime, &clipped );
if ( clipped )
continue;
drawHelper.DrawColoredLine( RGB( 180, 180, 220 ), PS_SOLID, 1,
pixel, rcClip.top, pixel, rcClip.bottom );
}
}
}
drawHelper.StopClipping();
}
//-----------------------------------------------------------------------------
// Purpose: Draw the background markings (actor names, etc)
// Input : drawHelper -
// rc -
//-----------------------------------------------------------------------------
void CChoreoView::DrawBackground( CChoreoWidgetDrawHelper& drawHelper, RECT& rc )
{
RECT rcClip;
GetClientRect( (HWND)getHandle(), &rcClip );
rcClip.top = GetStartRow();
rcClip.bottom -= ( m_nInfoHeight + m_nScrollbarHeight );
rcClip.right -= m_nScrollbarHeight;
int i;
for ( i = 0; i < m_SceneGlobalEvents.Size(); i++ )
{
CChoreoGlobalEventWidget *event = m_SceneGlobalEvents[ i ];
if ( event )
{
event->redraw( drawHelper );
}
}
drawHelper.StartClipping( rcClip );
for ( i = 0; i < m_SceneActors.Size(); i++ )
{
CChoreoActorWidget *actorW = m_SceneActors[ i ];
if ( !actorW )
continue;
actorW->redraw( drawHelper );
}
drawHelper.StopClipping();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CChoreoView::redraw()
{
if ( !ToolCanDraw() )
return;
if ( m_bSuppressLayout )
return;
LayoutScene();
CChoreoWidgetDrawHelper drawHelper( this, COLOR_CHOREO_BACKGROUND );
HandleToolRedraw( drawHelper );
if ( !m_bCanDraw )
return;
RECT rc;
rc.left = 0;
rc.top = GetCaptionHeight();
rc.right = drawHelper.GetWidth();
rc.bottom = drawHelper.GetHeight();
RECT rcInfo;
rcInfo.left = rc.left;
rcInfo.right = rc.right - m_nScrollbarHeight;
rcInfo.bottom = rc.bottom - m_nScrollbarHeight;
rcInfo.top = rcInfo.bottom - m_nInfoHeight;
drawHelper.StartClipping( rcInfo );
RedrawStatusArea( drawHelper, rcInfo );
drawHelper.StopClipping();
RECT rcClip = rc;
rcClip.bottom -= ( m_nInfoHeight + m_nScrollbarHeight );
drawHelper.StartClipping( rcClip );
if ( !m_pScene )
{
char sz[ 256 ];
sprintf( sz, "No choreography scene file (.vcd) loaded" );
int pointsize = 18;
int textlen = drawHelper.CalcTextWidth( "Arial", pointsize, FW_NORMAL, sz );
RECT rcText;
rcText.top = ( rc.bottom - rc.top ) / 2 - pointsize / 2;
rcText.bottom = rcText.top + pointsize + 10;
rcText.left = rc.right / 2 - textlen / 2;
rcText.right = rcText.left + textlen;
drawHelper.DrawColoredText( "Arial", pointsize, FW_NORMAL, COLOR_CHOREO_LIGHTTEXT, rcText, sz );
drawHelper.StopClipping();
return;
}
DrawTimeLine( drawHelper, rc, m_flStartTime, m_flEndTime );
bool clipped = false;
int finishx = GetPixelForTimeValue( m_pScene->FindStopTime(), &clipped );
if ( !clipped )
{
drawHelper.DrawColoredLine( COLOR_CHOREO_ENDTIME, PS_DOT, 1, finishx, rc.top + GetStartRow(), finishx, rc.bottom );
}
DrawRelativeTagLines( drawHelper, rc );
DrawBackground( drawHelper, rc );
DrawSceneABTicks( drawHelper );
drawHelper.StopClipping();
if ( m_UndoStack.Size() > 0 )
{
int length = drawHelper.CalcTextWidth( "Arial", 9, FW_NORMAL,
"undo %i/%i", m_nUndoLevel, m_UndoStack.Size() );
RECT rcText = rc;
rcText.top = rc.top + 48;
rcText.bottom = rcText.top + 10;
rcText.left = GetLabelWidth() - length - 20;
rcText.right = rcText.left + length;
drawHelper.DrawColoredText( "Arial", 9, FW_NORMAL, RGB( 100, 180, 100 ), rcText,
"undo %i/%i", m_nUndoLevel, m_UndoStack.Size() );
}
DrawScrubHandle( drawHelper );
char sz[ 48 ];
sprintf( sz, "Speed: %.2fx", m_flPlaybackRate );
int fontsize = 9;
int length = drawHelper.CalcTextWidth( "Arial", fontsize, FW_NORMAL, sz);
RECT rcText = rc;
rcText.top = rc.top + 25;
rcText.bottom = rcText.top + 10;
rcText.left = GetLabelWidth() + 20;
rcText.right = rcText.left + length;
drawHelper.DrawColoredText( "Arial", fontsize, FW_NORMAL,
RGB( 50, 50, 50 ), rcText, sz );
sprintf( sz, "Zoom: %.2fx", (float)GetTimeZoom( GetToolName() ) / 100.0f );
length = drawHelper.CalcTextWidth( "Arial", fontsize, FW_NORMAL, sz);
rcText = rc;
rcText.left = 5;
rcText.top = rc.top + 48;
rcText.bottom = rcText.top + 10;
rcText.right = rcText.left + length;
drawHelper.DrawColoredText( "Arial", fontsize, FW_NORMAL,
RGB( 50, 50, 50 ), rcText, sz );
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : current -
// number -
// Output : int
//-----------------------------------------------------------------------------
void CChoreoView::GetUndoLevels( int& current, int& number )
{
current = m_nUndoLevel;
number = m_UndoStack.Size();
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : time -
// *clipped -
// Output : int
//-----------------------------------------------------------------------------
int CChoreoView::GetPixelForTimeValue( float time, bool *clipped /*=NULL*/ )
{
if ( clipped )
{
*clipped = false;
}
float frac = ( time - m_flStartTime ) / ( m_flEndTime - m_flStartTime );
if ( frac < 0.0 || frac > 1.0 )
{
if ( clipped )
{
*clipped = true;
}
}
int pixel = GetLabelWidth() + (int)( frac * ( w2() - GetLabelWidth() ) );
return pixel;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : mx -
// clip -
// Output : float
//-----------------------------------------------------------------------------
float CChoreoView::GetTimeValueForMouse( int mx, bool clip /*=false*/)
{
RECT rc = m_rcTimeLine;
rc.left = GetLabelWidth();
if ( clip )
{
if ( mx < rc.left )
{
return m_flStartTime;
}
if ( mx > rc.right )
{
return m_flEndTime;
}
}
float frac = (float)( mx - rc.left ) / (float)( rc.right - rc.left );
return m_flStartTime + frac * ( m_flEndTime - m_flStartTime );
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : time -
//-----------------------------------------------------------------------------
void CChoreoView::SetStartTime( float time )
{
m_flStartTime = time;
InvalidateLayout();
}
//-----------------------------------------------------------------------------
// Purpose:
// Output : float
//-----------------------------------------------------------------------------
float CChoreoView::GetStartTime( void )
{
return m_flStartTime;
}
//-----------------------------------------------------------------------------
// Purpose:
// Output : float
//-----------------------------------------------------------------------------
float CChoreoView::GetEndTime( void )
{
return m_flEndTime;
}
//-----------------------------------------------------------------------------
// Purpose:
// Output : float
//-----------------------------------------------------------------------------
float CChoreoView::GetPixelsPerSecond( void )
{
return m_flPixelsPerSecond * (float)GetTimeZoom( GetToolName() ) / 100.0f;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : mx -
// origmx -
// Output : float
//-----------------------------------------------------------------------------
float CChoreoView::GetTimeDeltaForMouseDelta( int mx, int origmx )
{
float t1, t2;
t2 = GetTimeValueForMouse( mx );
t1 = GetTimeValueForMouse( origmx );
return t2 - t1;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : mx -
//-----------------------------------------------------------------------------
void CChoreoView::PlaceABPoint( int mx )
{
m_rgABPoints[ ( m_nCurrentABPoint) & 0x01 ].time = GetTimeValueForMouse( mx );
m_rgABPoints[ ( m_nCurrentABPoint) & 0x01 ].active = true;
m_nCurrentABPoint++;
if ( m_rgABPoints[ 0 ].active && m_rgABPoints [ 1 ].active &&
m_rgABPoints[ 0 ].time > m_rgABPoints[ 1 ].time )
{
float temp = m_rgABPoints[ 0 ].time;
m_rgABPoints[ 0 ].time = m_rgABPoints[ 1 ].time;
m_rgABPoints[ 1 ].time = temp;
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CChoreoView::ClearABPoints( void )
{
memset( m_rgABPoints, 0, sizeof( m_rgABPoints ) );
m_nCurrentABPoint = 0;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : mx -
// my -
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CChoreoView::IsMouseOverTimeline( int mx, int my )
{
POINT pt;
pt.x = mx;
pt.y = my;
RECT rcCheck = m_rcTimeLine;
rcCheck.bottom -= TIMELINE_NUMBERS_HEIGHT;
if ( PtInRect( &rcCheck, pt ) )
return true;
return false;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : mx -
// my -
//-----------------------------------------------------------------------------
void CChoreoView::ShowContextMenu( int mx, int my )
{
CChoreoActorWidget *a = NULL;
CChoreoChannelWidget *c = NULL;
CChoreoEventWidget *e = NULL;
CChoreoGlobalEventWidget *ge = NULL;
int ct = -1;
CEventAbsoluteTag *at = NULL;
int clickedCloseCaptionButton = CChoreoChannelWidget::CLOSECAPTION_NONE;
GetObjectsUnderMouse( mx, my, &a, &c, &e, &ge, &ct, &at, &clickedCloseCaptionButton );
m_pClickedActor = a;
m_pClickedChannel = c;
m_pClickedEvent = e;
m_pClickedGlobalEvent = ge;
m_nClickedX = mx;
m_nClickedY = my;
m_nClickedTag = ct;
m_pClickedAbsoluteTag = at;
m_nClickedChannelCloseCaptionButton = clickedCloseCaptionButton;
// Construct main
mxPopupMenu *pop = new mxPopupMenu();
if ( a && c )
{
if (!e)
{
pop->add( "Expression...", IDC_ADDEVENT_EXPRESSION );
pop->add( "WAV File...", IDC_ADDEVENT_SPEAK );
pop->add( "Gesture...", IDC_ADDEVENT_GESTURE );
pop->add( "NULL Gesture...", IDC_ADDEVENT_NULLGESTURE );
pop->add( "Look at actor...", IDC_ADDEVENT_LOOKAT );
pop->add( "Move to actor...", IDC_ADDEVENT_MOVETO );
pop->add( "Face actor...", IDC_ADDEVENT_FACE );
pop->add( "Fire Trigger...", IDC_ADDEVENT_FIRETRIGGER );
pop->add( "Generic(AI)...", IDC_ADDEVENT_GENERIC );
pop->add( "Sequence...", IDC_ADDEVENT_SEQUENCE );
pop->add( "Flex animation...", IDC_ADDEVENT_FLEXANIMATION );
pop->add( "Sub-scene...", IDC_ADDEVENT_SUBSCENE );
pop->add( "Interrupt...", IDC_ADDEVENT_INTERRUPT );
pop->add( "Permit Responses...", IDC_ADDEVENT_PERMITRESPONSES );
pop->addSeparator();
}
else
{
pop->add( va( "Edit Event '%s'...", e->GetEvent()->GetName() ), IDC_EDITEVENT );
switch ( e->GetEvent()->GetType() )
{
default:
break;
case CChoreoEvent::FLEXANIMATION:
{
pop->add( va( "Edit Event '%s' in expression tool", e->GetEvent()->GetName() ), IDC_EXPRESSIONTOOL );
}
break;
case CChoreoEvent::GESTURE:
{
pop->add( va( "Edit Event '%s' in gesture tool", e->GetEvent()->GetName() ), IDC_GESTURETOOL );
}
break;
}
if ( e->GetEvent()->HasEndTime() )
{
pop->add( "Timing Tag...", IDC_ADDTIMINGTAG );
}
pop->addSeparator();
}
}
// Construct "New..."
mxPopupMenu *newMenu = new mxPopupMenu();
{
newMenu->add( "Actor...", IDC_ADDACTOR );
if ( a )
{
newMenu->add( "Channel...", IDC_ADDCHANNEL );
}
newMenu->add( "Section Pause...", IDC_ADDEVENT_PAUSE );
newMenu->add( "Loop...", IDC_ADDEVENT_LOOP );
newMenu->add( "Fire Completion...", IDC_ADDEVENT_STOPPOINT );
}
pop->addMenu( "New", newMenu );
// Now construct "Edit..."
if ( a || c || e || ge )
{
mxPopupMenu *editMenu = new mxPopupMenu();
{
if ( a )
{
editMenu->add( va( "Actor '%s'...", a->GetActor()->GetName() ), IDC_EDITACTOR );
}
if ( c )
{
editMenu->add( va( "Channel '%s'...", c->GetChannel()->GetName() ), IDC_EDITCHANNEL );
}
if ( ge )
{
switch ( ge->GetEvent()->GetType() )
{
default:
break;
case CChoreoEvent::SECTION:
{
editMenu->add( va( "Section Pause '%s'...", ge->GetEvent()->GetName() ), IDC_EDITGLOBALEVENT );
}
break;
case CChoreoEvent::LOOP:
{
editMenu->add( va( "Loop Point '%s'...", ge->GetEvent()->GetName() ), IDC_EDITGLOBALEVENT );
}
break;
case CChoreoEvent::STOPPOINT:
{
editMenu->add( va( "Fire Completion '%s'...", ge->GetEvent()->GetName() ), IDC_EDITGLOBALEVENT );
}
break;
}
}
}
pop->addMenu( "Edit", editMenu );
}
// Move up/down
if ( a || c )
{
mxPopupMenu *moveUpMenu = new mxPopupMenu();
mxPopupMenu *moveDownMenu = new mxPopupMenu();
if ( a )
{
moveUpMenu->add( va( "Move '%s' up", a->GetActor()->GetName() ), IDC_MOVEACTORUP );
moveDownMenu->add( va( "Move '%s' down", a->GetActor()->GetName() ), IDC_MOVEACTORDOWN );
}
if ( c )
{
moveUpMenu->add( va( "Move '%s' up", c->GetChannel()->GetName() ), IDC_MOVECHANNELUP );
moveDownMenu->add( va( "Move '%s' down", c->GetChannel()->GetName() ), IDC_MOVECHANNELDOWN );
}
pop->addMenu( "Move Up", moveUpMenu );
pop->addMenu( "Move Down", moveDownMenu );
}
// Delete
if ( a || c || e || ge || (ct != -1) )
{
mxPopupMenu *deleteMenu = new mxPopupMenu();
if ( a )
{
deleteMenu->add( va( "Actor '%s'", a->GetActor()->GetName() ), IDC_DELETEACTOR );
}
if ( c )
{
deleteMenu->add( va( "Channel '%s'", c->GetChannel()->GetName() ), IDC_DELETECHANNEL );
}
if ( e )
{
deleteMenu->add( va( "Event '%s'", e->GetEvent()->GetName() ), IDC_DELETEEVENT );
}
if ( ge )
{
switch ( ge->GetEvent()->GetType() )
{
default:
break;
case CChoreoEvent::SECTION:
{
deleteMenu->add( va( "Section Pause '%s'...", ge->GetEvent()->GetName() ), IDC_DELETEGLOBALEVENT );
}
break;
case CChoreoEvent::LOOP:
{
deleteMenu->add( va( "Loop Point '%s'...", ge->GetEvent()->GetName() ), IDC_DELETEGLOBALEVENT );
}
break;
case CChoreoEvent::STOPPOINT:
{
deleteMenu->add( va( "Fire Completion '%s'...", ge->GetEvent()->GetName() ), IDC_DELETEGLOBALEVENT );
}
break;
}
}
if ( e && ct != -1 )
{
CEventRelativeTag *tag = e->GetEvent()->GetRelativeTag( ct );
if ( tag )
{
deleteMenu->add( va( "Relative Tag '%s'...", tag->GetName() ), IDC_DELETERELATIVETAG );
}
}
pop->addMenu( "Delete", deleteMenu );
}
// Select
{
mxPopupMenu *selectMenu = new mxPopupMenu();
selectMenu->add( "Select All", IDC_SELECTALL );
selectMenu->add( "Deselect All", IDC_DESELECTALL );
selectMenu->addSeparator();
selectMenu->add( "All events before", IDC_SELECTEVENTS_ALL_BEFORE );
selectMenu->add( "All events after", IDC_SELECTEVENTS_ALL_AFTER );
selectMenu->add( "Active events before", IDC_SELECTEVENTS_ACTIVE_BEFORE );
selectMenu->add( "Active events after", IDC_SELECTEVENTS_ACTIVE_AFTER );
selectMenu->add( "Channel events before", IDC_SELECTEVENTS_CHANNEL_BEFORE );
selectMenu->add( "Channel events after", IDC_SELECTEVENTS_CHANNEL_AFTER );
if ( a || c )
{
selectMenu->addSeparator();
if ( a )
{
selectMenu->add( va( "All events in actor '%s'", a->GetActor()->GetName() ), IDC_CV_ALLEVENTS_ACTOR );
}
if ( c )
{
selectMenu->add( va( "All events in channel '%s'", c->GetChannel()->GetName() ), IDC_CV_ALLEVENTS_CHANNEL );
}
}
pop->addMenu( "Select/Deselect", selectMenu );
}
// Quick delete for events
if ( e )
{
pop->addSeparator();
switch ( e->GetEvent()->GetType() )
{
default:
break;
case CChoreoEvent::FLEXANIMATION:
{
pop->add( va( "Edit event '%s' in expression tool", e->GetEvent()->GetName() ), IDC_EXPRESSIONTOOL );
}
break;
case CChoreoEvent::GESTURE:
{
pop->add( va( "Edit event '%s' in gesture tool", e->GetEvent()->GetName() ), IDC_GESTURETOOL );
}
break;
}
pop->add( va( "Move event '%s' to back", e->GetEvent()->GetName() ), IDC_MOVETOBACK );
if ( CountSelectedEvents() > 1 )
{
pop->add( va( "Delete events" ), IDC_DELETEEVENT );
pop->addSeparator();
pop->add( "Enable events", IDC_CV_ENABLEEVENTS );
pop->add( "Disable events", IDC_CV_DISABLEEVENTS );
}
else
{
pop->add( va( "Delete event '%s'", e->GetEvent()->GetName() ), IDC_DELETEEVENT );
pop->addSeparator();
if ( e->GetEvent()->GetActive() )
{
pop->add( va( "Disable event '%s'", e->GetEvent()->GetName() ), IDC_CV_DISABLEEVENTS );
}
else
{
pop->add( va( "Enable event '%s'", e->GetEvent()->GetName() ), IDC_CV_ENABLEEVENTS );
}
}
}
if ( m_rgABPoints[ 0 ].active && m_rgABPoints[ 1 ].active )
{
pop->addSeparator();
mxPopupMenu *timeMenu = new mxPopupMenu();
timeMenu->add( "Insert empty space between marks (shifts events right)", IDC_INSERT_TIME );
timeMenu->add( "Delete events between marks (shifts remaining events left)", IDC_DELETE_TIME );
pop->addMenu( "Time Marks", timeMenu );
}
// Copy/paste
if ( CanPaste() || e )
{
pop->addSeparator();
if ( CountSelectedEvents() > 1 )
{
pop->add( va( "Copy events to clipboard" ), IDC_COPYEVENTS );
}
else if ( e )
{
pop->add( va( "Copy event '%s' to clipboard", e->GetEvent()->GetName() ), IDC_COPYEVENTS );
}
if ( CanPaste() )
{
pop->add( va( "Paste events" ), IDC_PASTEEVENTS );
}
}
// Export / import
pop->addSeparator();
if ( e )
{
mxPopupMenu *exportMenu = new mxPopupMenu();
if ( CountSelectedEvents() > 1 )
{
exportMenu->add( va( "Export events to .vce..." ), IDC_EXPORTEVENTS );
}
else if ( e )
{
exportMenu->add( va( "Export event '%s' to .vce...", e->GetEvent()->GetName() ), IDC_EXPORTEVENTS );
}
exportMenu->add( va( "Export as .vcd..." ), IDC_EXPORT_VCD );
pop->addMenu( "Export", exportMenu );
}
mxPopupMenu *importMenu = new mxPopupMenu();
importMenu->add( va( "Import events from .vce..." ), IDC_IMPORTEVENTS );
importMenu->add( va( "Merge from .vcd..." ), IDC_IMPORT_VCD );
pop->addMenu( "Import", importMenu );
bool bShowAlignLeft = ( CountSelectedEvents() + CountSelectedGlobalEvents() ) > 1 ? true : false;
if ( e && ( ( CountSelectedEvents() > 1 ) || bShowAlignLeft ) )
{
pop->addSeparator();
mxPopupMenu *alignMenu = new mxPopupMenu();
alignMenu->add( "Align Left", IDC_CV_ALIGN_LEFT );
if ( CountSelectedEvents() > 1 )
{
alignMenu->add( "Align Right", IDC_CV_ALIGN_RIGHT );
alignMenu->add( "Size to Smallest", IDC_CV_SAMESIZE_SMALLEST );
alignMenu->add( "Size to Largest", IDC_CV_SAMESIZE_LARGEST );
}
pop->addMenu( "Align", alignMenu );
}
// Misc.
pop->addSeparator();
pop->add( va( "Change scale..." ), IDC_CV_CHANGESCALE );
pop->add( va( "Check sequences" ), IDC_CV_CHECKSEQLENGTHS );
pop->add( va( "Process sequences" ), IDC_CV_PROCESSSEQUENCES );
pop->add( va( m_bRampOnly ? "Ramp normal" : "Ramp only" ), IDC_CV_TOGGLERAMPONLY );
pop->setChecked( IDC_CV_PROCESSSEQUENCES, m_bProcessSequences );
bool onmaster= ( m_pClickedChannel &&
m_pClickedChannel->GetCaptionClickedEvent() &&
m_pClickedChannel->GetCaptionClickedEvent()->GetCloseCaptionType() == CChoreoEvent::CC_MASTER ) ? true : false;
bool ondisabled = ( m_pClickedChannel &&
m_pClickedChannel->GetCaptionClickedEvent() &&
m_pClickedChannel->GetCaptionClickedEvent()->GetCloseCaptionType() == CChoreoEvent::CC_DISABLED ) ? true : false;
// The close captioning menu
if ( m_bShowCloseCaptionData && ( AreSelectedEventsCombinable() || AreSelectedEventsInSpeakGroup() || onmaster || ondisabled ) )
{
pop->addSeparator();
if ( AreSelectedEventsCombinable() )
{
pop->add( "Combine Speak Events", IDC_CV_COMBINESPEAKEVENTS );
}
if ( AreSelectedEventsInSpeakGroup() )
{
pop->add( "Uncombine Speak Events", IDC_CV_REMOVESPEAKEVENTFROMGROUP );
}
if ( onmaster )
{
// Can only change tokens for "combined" files
if ( m_pClickedChannel->GetCaptionClickedEvent()->GetNumSlaves() >= 1 )
{
pop->add( "Change Token", IDC_CV_CHANGECLOSECAPTIONTOKEN );
}
pop->add( "Disable captions", IDC_CV_TOGGLECLOSECAPTIONS );
}
if ( ondisabled )
{
pop->add( "Enable captions", IDC_CV_TOGGLECLOSECAPTIONS );
}
}
// Undo/redo
if ( CanUndo() || CanRedo() )
{
pop->addSeparator();
if ( CanUndo() )
{
pop->add( va( "Undo %s", GetUndoDescription() ), IDC_CVUNDO );
}
if ( CanRedo() )
{
pop->add( va( "Redo %s", GetRedoDescription() ), IDC_CVREDO );
}
}
if ( m_pScene )
{
// Associate map file
pop->addSeparator();
pop->add( va( "Associate .bsp (%s)", m_pScene->GetMapname() ), IDC_ASSOCIATEBSP );
if ( a )
{
if ( a->GetActor() && a->GetActor()->GetFacePoserModelName()[0] )
{
pop->add( va( "Change .mdl for %s", a->GetActor()->GetName() ), IDC_ASSOCIATEMODEL );
}
else
{
pop->add( va( "Associate .mdl with %s", a->GetActor()->GetName() ), IDC_ASSOCIATEMODEL );
}
}
}
pop->popup( this, mx, my );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CChoreoView::AssociateModel( void )
{
if ( !m_pScene )
return;
CChoreoActorWidget *actor = m_pClickedActor;
if ( !actor )
return;
CChoreoActor *a = actor->GetActor();
if ( !a )
return;
CChoiceParams params;
strcpy( params.m_szDialogTitle, "Associate Model" );
params.m_bPositionDialog = false;
params.m_nLeft = 0;
params.m_nTop = 0;
strcpy( params.m_szPrompt, "Choose model:" );
params.m_Choices.RemoveAll();
params.m_nSelected = -1;
int oldsel = -1;
int c = models->Count();
ChoiceText text;
for ( int i = 0; i < c; i++ )
{
char const *modelname = models->GetModelName( i );
strcpy( text.choice, modelname );
if ( !stricmp( a->GetName(), modelname ) )
{
params.m_nSelected = i;
oldsel = -1;
}
params.m_Choices.AddToTail( text );
}
// Add an extra entry which is "No association"
strcpy( text.choice, "No Associated Model" );
params.m_Choices.AddToTail( text );
if ( !ChoiceProperties( &params ) )
return;
if ( params.m_nSelected == oldsel )
return;
// Chose something new...
if ( params.m_nSelected >= 0 &&
params.m_nSelected < params.m_Choices.Count() )
{
AssociateModelToActor( a, params.m_nSelected );
}
else
{
// Chose "No association"
AssociateModelToActor( a, -1 );
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *actor -
// modelindex -
//-----------------------------------------------------------------------------
void CChoreoView::AssociateModelToActor( CChoreoActor *actor, int modelindex )
{
Assert( actor );
SetDirty( true );
PushUndo( "Associate model" );
// Chose something new...
if ( modelindex >= 0 &&
modelindex < models->Count() )
{
actor->SetFacePoserModelName( models->GetModelFileName( modelindex ) );
}
else
{
// Chose "No Associated Model"
actor->SetFacePoserModelName( "" );
}
RecomputeWaves();
PushRedo( "Associate model" );
}
void CChoreoView::AssociateBSP( void )
{
if ( !m_pScene )
return;
// Strip game directory and slash
char mapname[ 512 ];
if ( !FacePoser_ShowOpenFileNameDialog( mapname, sizeof( mapname ), "maps", "*.bsp" ) )
{
return;
}
m_pScene->SetMapname( mapname );
redraw();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CChoreoView::DrawFocusRect( void )
{
HDC dc = GetDC( NULL );
for ( int i = 0; i < m_FocusRects.Size(); i++ )
{
RECT rc = m_FocusRects[ i ].m_rcFocus;
::DrawFocusRect( dc, &rc );
}
ReleaseDC( NULL, dc );
}
int CChoreoView::GetSelectedEventWidgets( CUtlVector< CChoreoEventWidget * >& events )
{
events.RemoveAll();
int c = 0;
for ( int i = 0; i < m_SceneActors.Size(); i++ )
{
CChoreoActorWidget *actor = m_SceneActors[ i ];
if ( !actor )
continue;
for ( int j = 0; j < actor->GetNumChannels(); j++ )
{
CChoreoChannelWidget *channel = actor->GetChannel( j );
if ( !channel )
continue;
for ( int k = 0; k < channel->GetNumEvents(); k++ )
{
CChoreoEventWidget *event = channel->GetEvent( k );
if ( !event )
continue;
if ( event->IsSelected() )
{
events.AddToTail( event );
c++;
}
}
}
}
return c;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : events -
// Output : int
//-----------------------------------------------------------------------------
int CChoreoView::GetSelectedEvents( CUtlVector< CChoreoEvent * >& events )
{
events.RemoveAll();
int c = 0;
for ( int i = 0; i < m_SceneActors.Size(); i++ )
{
CChoreoActorWidget *actor = m_SceneActors[ i ];
if ( !actor )
continue;
for ( int j = 0; j < actor->GetNumChannels(); j++ )
{
CChoreoChannelWidget *channel = actor->GetChannel( j );
if ( !channel )
continue;
for ( int k = 0; k < channel->GetNumEvents(); k++ )
{
CChoreoEventWidget *event = channel->GetEvent( k );
if ( !event )
continue;
if ( event->IsSelected() )
{
events.AddToTail( event->GetEvent() );
c++;
}
}
}
}
return c;
}
int CChoreoView::CountSelectedGlobalEvents( void )
{
int c = 0;
for ( int i = 0; i < m_SceneGlobalEvents.Size(); i++ )
{
CChoreoGlobalEventWidget *event = m_SceneGlobalEvents[ i ];
if ( !event || !event->IsSelected() )
continue;
++c;
}
return c;
}
//-----------------------------------------------------------------------------
// Purpose:
// Output : int
//-----------------------------------------------------------------------------
int CChoreoView::CountSelectedEvents( void )
{
int c = 0;
for ( int i = 0; i < m_SceneActors.Size(); i++ )
{
CChoreoActorWidget *actor = m_SceneActors[ i ];
if ( !actor )
continue;
for ( int j = 0; j < actor->GetNumChannels(); j++ )
{
CChoreoChannelWidget *channel = actor->GetChannel( j );
if ( !channel )
continue;
for ( int k = 0; k < channel->GetNumEvents(); k++ )
{
CChoreoEventWidget *event = channel->GetEvent( k );
if ( !event )
continue;
if ( event->IsSelected() )
c++;
}
}
}
return c;
}
bool CChoreoView::IsMouseOverEvent( CChoreoEventWidget *ew, int mx, int my )
{
int tolerance = DRAG_EVENT_EDGE_TOLERANCE;
RECT bounds = ew->getBounds();
mx -= bounds.left;
my -= bounds.top;
if ( mx <= -tolerance )
{
return false;
}
CChoreoEvent *event = ew->GetEvent();
if ( event )
{
if ( event->HasEndTime() )
{
int rightside = ew->GetDurationRightEdge() ? ew->GetDurationRightEdge() : ew->w();
if ( mx > rightside + tolerance )
{
return false;
}
}
}
return true;
}
bool CChoreoView::IsMouseOverEventEdge( CChoreoEventWidget *ew, bool bLeftEdge, int mx, int my )
{
int tolerance = DRAG_EVENT_EDGE_TOLERANCE;
RECT bounds = ew->getBounds();
mx -= bounds.left;
my -= bounds.top;
CChoreoEvent *event = ew->GetEvent();
if ( event && event->HasEndTime() )
{
if ( mx > -tolerance && mx <= tolerance )
{
return bLeftEdge;
}
int rightside = ew->GetDurationRightEdge() ? ew->GetDurationRightEdge() : ew->w();
if ( mx >= rightside - tolerance )
{
if ( mx > rightside + tolerance )
{
return false;
}
else
{
return !bLeftEdge;
}
}
}
return false;
}
int CChoreoView::GetEarliestEventIndex( CUtlVector< CChoreoEventWidget * >& events )
{
int best = -1;
float minTime = FLT_MAX;
int c = events.Count();
for ( int i = 0; i < c; ++i )
{
CChoreoEvent *e = events[ i ]->GetEvent();
float t = e->GetStartTime();
if ( t < minTime )
{
minTime = t;
best = i;
}
}
return best;
}
int CChoreoView::GetLatestEventIndex( CUtlVector< CChoreoEventWidget * >& events )
{
int best = -1;
float maxTime = FLT_MIN;
int c = events.Count();
for ( int i = 0; i < c; ++i )
{
CChoreoEvent *e = events[ i ]->GetEvent();
float t = e->GetEndTime();
if ( t > maxTime )
{
maxTime = t;
best = i;
}
}
return best;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : mx -
// Output : int
//-----------------------------------------------------------------------------
int CChoreoView::ComputeEventDragType( int mx, int my )
{
int tolerance = DRAG_EVENT_EDGE_TOLERANCE;
// Iterate the events and see who's closest
CChoreoEventWidget *ew = GetEventUnderCursorPos( mx, my );
if ( !ew )
{
return DRAGTYPE_NONE;
}
// Deal with small windows by lowering tolerance
if ( ew->w() < 4 * tolerance )
{
tolerance = 2;
}
int tagnum = GetTagUnderCursorPos( ew, mx, my );
if ( tagnum != -1 && CountSelectedEvents() <= 1 )
{
return DRAGTYPE_EVENTTAG_MOVE;
}
CEventAbsoluteTag *tag = GetAbsoluteTagUnderCursorPos( ew, mx, my );
if ( tag != NULL && CountSelectedEvents() <= 1 )
{
return DRAGTYPE_EVENTABSTAG_MOVE;
}
if ( CountSelectedEvents() > 1 )
{
CUtlVector< CChoreoEventWidget * > events;
GetSelectedEventWidgets( events );
int iStart, iEnd;
iStart = GetEarliestEventIndex( events );
iEnd = GetLatestEventIndex( events );
if ( events.IsValidIndex( iStart ) )
{
// See if mouse is over left edge of starting event
if ( IsMouseOverEventEdge( events[ iStart ], true, mx, my ) )
{
return DRAGTYPE_RESCALELEFT;
}
}
if ( events.IsValidIndex( iEnd ) )
{
if ( IsMouseOverEventEdge( events[ iEnd ], false, mx, my ) )
{
return DRAGTYPE_RESCALERIGHT;
}
}
return DRAGTYPE_EVENT_MOVE;
}
CChoreoEvent *event = ew->GetEvent();
if ( event )
{
if ( event->IsFixedLength() || !event->HasEndTime() )
{
return DRAGTYPE_EVENT_MOVE;
}
}
if ( IsMouseOverEventEdge( ew, true, mx, my ) )
{
if ( GetAsyncKeyState( VK_SHIFT ) )
return DRAGTYPE_EVENT_STARTTIME_RESCALE;
return DRAGTYPE_EVENT_STARTTIME;
}
if ( IsMouseOverEventEdge( ew, false, mx, my ) )
{
if ( GetAsyncKeyState( VK_SHIFT ) )
return DRAGTYPE_EVENT_ENDTIME_RESCALE;
return DRAGTYPE_EVENT_ENDTIME;
}
if ( IsMouseOverEvent( ew, mx, my ) )
{
return DRAGTYPE_EVENT_MOVE;
}
return DRAGTYPE_NONE;
}
void CChoreoView::StartDraggingSceneEndTime( int mx, int my )
{
m_nDragType = DRAGTYPE_SCENE_ENDTIME;
m_FocusRects.Purge();
RECT rcFocus;
rcFocus.left = mx;
rcFocus.top = 0;
rcFocus.bottom = h2();
rcFocus.right = rcFocus.left + 2;
POINT offset;
offset.x = 0;
offset.y = 0;
ClientToScreen( (HWND)getHandle(), &offset );
OffsetRect( &rcFocus, offset.x, offset.y );
CFocusRect fr;
fr.m_rcFocus = rcFocus;
fr.m_rcOrig = rcFocus;
// Relative tag events don't move
m_FocusRects.AddToTail( fr );
m_xStart = mx;
m_yStart = my;
m_hPrevCursor = SetCursor( LoadCursor( NULL, IDC_SIZEWE ) );
DrawFocusRect();
m_bDragging = true;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CChoreoView::StartDraggingEvent( int mx, int my )
{
m_nDragType = ComputeEventDragType( mx, my );
if ( m_nDragType == DRAGTYPE_NONE )
{
if( m_pClickedGlobalEvent )
{
m_nDragType = DRAGTYPE_EVENT_MOVE;
}
else
{
return;
}
}
m_FocusRects.Purge();
// Go through all selected events
RECT rcFocus;
for ( int i = 0; i < m_SceneActors.Size(); i++ )
{
CChoreoActorWidget *actor = m_SceneActors[ i ];
if ( !actor )
continue;
for ( int j = 0; j < actor->GetNumChannels(); j++ )
{
CChoreoChannelWidget *channel = actor->GetChannel( j );
if ( !channel )
continue;
for ( int k = 0; k < channel->GetNumEvents(); k++ )
{
CChoreoEventWidget *event = channel->GetEvent( k );
if ( !event )
continue;
if ( !event->IsSelected() )
continue;
if ( event == m_pClickedEvent &&
( m_nClickedTag != -1 || m_pClickedAbsoluteTag ) )
{
int leftEdge = 0;
int tagWidth = 1;
if ( !m_pClickedAbsoluteTag )
{
CEventRelativeTag *tag = event->GetEvent()->GetRelativeTag( m_nClickedTag );
if ( tag )
{
// Determine left edcge
RECT bounds;
bounds = event->getBounds();
if ( bounds.right - bounds.left > 0 )
{
leftEdge = (int)( tag->GetPercentage() * (float)( bounds.right - bounds.left ) + 0.5f );
}
}
}
else
{
// Determine left edcge
RECT bounds;
bounds = event->getBounds();
if ( bounds.right - bounds.left > 0 )
{
leftEdge = (int)( m_pClickedAbsoluteTag->GetPercentage() * (float)( bounds.right - bounds.left ) + 0.5f );
}
}
rcFocus.left = event->x() + leftEdge - tagWidth;
rcFocus.top = event->y() - tagWidth;
rcFocus.right = rcFocus.left + 2 * tagWidth;
rcFocus.bottom = event->y() + event->h();
}
else
{
rcFocus.left = event->x();
rcFocus.top = event->y();
if ( event->GetDurationRightEdge() )
{
rcFocus.right = event->x() + event->GetDurationRightEdge();
}
else
{
rcFocus.right = rcFocus.left + event->w();
}
rcFocus.bottom = rcFocus.top + event->h();
}
POINT offset;
offset.x = 0;
offset.y = 0;
ClientToScreen( (HWND)getHandle(), &offset );
OffsetRect( &rcFocus, offset.x, offset.y );
CFocusRect fr;
fr.m_rcFocus = rcFocus;
fr.m_rcOrig = rcFocus;
// Relative tag events don't move
m_FocusRects.AddToTail( fr );
}
}
}
for ( int i = 0; i < m_SceneGlobalEvents.Count(); i++ )
{
CChoreoGlobalEventWidget *gew = m_SceneGlobalEvents[ i ];
if ( !gew )
continue;
if ( !gew->IsSelected() )
continue;
rcFocus.left = gew->x() + gew->w() / 2;
rcFocus.top = 0;
rcFocus.right = rcFocus.left + 2;
rcFocus.bottom = h2();
POINT offset;
offset.x = 0;
offset.y = 0;
ClientToScreen( (HWND)getHandle(), &offset );
OffsetRect( &rcFocus, offset.x, offset.y );
CFocusRect fr;
fr.m_rcFocus = rcFocus;
fr.m_rcOrig = rcFocus;
m_FocusRects.AddToTail( fr );
}
m_xStart = mx;
m_yStart = my;
m_hPrevCursor = NULL;
switch ( m_nDragType )
{
default:
break;
case DRAGTYPE_EVENTTAG_MOVE:
m_hPrevCursor = SetCursor( LoadCursor( NULL, IDC_SIZEWE ) );
break;
case DRAGTYPE_EVENTABSTAG_MOVE:
m_hPrevCursor = SetCursor( LoadCursor( NULL, IDC_IBEAM ) );
break;
case DRAGTYPE_EVENT_MOVE:
m_hPrevCursor = SetCursor( LoadCursor( NULL, IDC_SIZEALL ) );
break;
case DRAGTYPE_EVENT_STARTTIME:
case DRAGTYPE_EVENT_STARTTIME_RESCALE:
m_hPrevCursor = SetCursor( LoadCursor( NULL, IDC_SIZEWE ) );
break;
case DRAGTYPE_EVENT_ENDTIME:
case DRAGTYPE_EVENT_ENDTIME_RESCALE:
m_hPrevCursor = SetCursor( LoadCursor( NULL, IDC_SIZEWE ) );
break;
case DRAGTYPE_RESCALELEFT:
case DRAGTYPE_RESCALERIGHT:
m_hPrevCursor = SetCursor( LoadCursor( NULL, IDC_SIZEWE ) );
break;
}
DrawFocusRect();
m_bDragging = true;
}
bool CChoreoView::IsMouseOverSceneEndTime( int mx )
{
// See if mouse if over scene end time instead
if ( m_pScene )
{
float endtime = m_pScene->FindStopTime();
bool clip = false;
int lastpixel = GetPixelForTimeValue( endtime, &clip );
if ( !clip )
{
if ( abs( mx - lastpixel ) < DRAG_EVENT_EDGE_TOLERANCE )
{
return true;
}
}
}
return false;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : mx -
// my -
//-----------------------------------------------------------------------------
void CChoreoView::MouseStartDrag( mxEvent *event, int mx, int my )
{
bool isrightbutton = event->buttons & mxEvent::MouseRightButton ? true : false;
if ( m_bDragging )
{
return;
}
GetObjectsUnderMouse( mx, my, &m_pClickedActor, &m_pClickedChannel, &m_pClickedEvent, &m_pClickedGlobalEvent, &m_nClickedTag, &m_pClickedAbsoluteTag, &m_nClickedChannelCloseCaptionButton );
if ( m_pClickedEvent )
{
CChoreoEvent *e = m_pClickedEvent->GetEvent();
Assert( e );
int dtPreview = ComputeEventDragType( mx, my );
// Shift clicking on exact edge shouldn't toggle selection state
bool bIsEdgeRescale = ( dtPreview == DRAGTYPE_EVENT_ENDTIME_RESCALE || dtPreview == DRAGTYPE_EVENT_STARTTIME_RESCALE );
if ( !( event->modifiers & ( mxEvent::KeyCtrl | mxEvent::KeyShift ) ) )
{
if ( !m_pClickedEvent->IsSelected() )
{
DeselectAll();
}
TraverseWidgets( &CChoreoView::Select, m_pClickedEvent );
}
else if ( !bIsEdgeRescale )
{
m_pClickedEvent->SetSelected( !m_pClickedEvent->IsSelected() );
}
switch ( m_pClickedEvent->GetEvent()->GetType() )
{
default:
break;
case CChoreoEvent::FLEXANIMATION:
{
g_pExpressionTool->SetEvent( e );
g_pFlexPanel->SetEvent( e );
}
break;
case CChoreoEvent::GESTURE:
{
g_pGestureTool->SetEvent( e );
}
break;
case CChoreoEvent::SPEAK:
{
g_pWaveBrowser->SetEvent( e );
}
break;
}
if ( e->HasEndTime() )
{
g_pRampTool->SetEvent( e );
}
redraw();
StartDraggingEvent( mx, my );
}
else if ( m_pClickedGlobalEvent )
{
if ( !( event->modifiers & ( mxEvent::KeyCtrl | mxEvent::KeyShift ) ) )
{
if ( !m_pClickedGlobalEvent->IsSelected() )
{
DeselectAll();
}
TraverseWidgets( &CChoreoView::Select, m_pClickedGlobalEvent );
}
else
{
m_pClickedGlobalEvent->SetSelected( !m_pClickedGlobalEvent->IsSelected() );
}
redraw();
StartDraggingEvent( mx, my );
}
else if ( IsMouseOverScrubArea( event ) )
{
if ( IsMouseOverScrubHandle( event ) )
{
m_nDragType = DRAGTYPE_SCRUBBER;
m_bDragging = true;
float t = GetTimeValueForMouse( (short)event->x );
m_flScrubberTimeOffset = m_flScrub - t;
float maxoffset = 0.5f * (float)SCRUBBER_HANDLE_WIDTH / GetPixelsPerSecond();
m_flScrubberTimeOffset = clamp( m_flScrubberTimeOffset, -maxoffset, maxoffset );
t += m_flScrubberTimeOffset;
ClampTimeToSelectionInterval( t );
SetScrubTime( t );
SetScrubTargetTime( t );
redraw();
RECT rcScrub;
GetScrubHandleRect( rcScrub, true );
m_FocusRects.Purge();
// Go through all selected events
RECT rcFocus;
rcFocus.top = GetStartRow();
rcFocus.bottom = h2() - m_nScrollbarHeight - m_nInfoHeight;
rcFocus.left = ( rcScrub.left + rcScrub.right ) / 2;
rcFocus.right = rcFocus.left;
POINT pt;
pt.x = pt.y = 0;
ClientToScreen( (HWND)getHandle(), &pt );
OffsetRect( &rcFocus, pt.x, pt.y );
CFocusRect fr;
fr.m_rcFocus = rcFocus;
fr.m_rcOrig = rcFocus;
m_FocusRects.AddToTail( fr );
m_xStart = mx;
m_yStart = my;
m_hPrevCursor = SetCursor( LoadCursor( NULL, IDC_SIZEWE ) );
DrawFocusRect();
}
else
{
float t = GetTimeValueForMouse( mx );
ClampTimeToSelectionInterval( t );
SetScrubTargetTime( t );
// Unpause the scene
m_bPaused = false;
redraw();
}
}
else if ( IsMouseOverSceneEndTime( mx ) )
{
redraw();
StartDraggingSceneEndTime( mx, my );
}
else if ( m_pClickedChannel &&
m_nClickedChannelCloseCaptionButton != CChoreoChannelWidget::CLOSECAPTION_NONE &&
m_nClickedChannelCloseCaptionButton != CChoreoChannelWidget::CLOSECAPTION_CAPTION )
{
switch ( m_nClickedChannelCloseCaptionButton )
{
default:
case CChoreoChannelWidget::CLOSECAPTION_EXPANDCOLLAPSE:
{
OnToggleCloseCaptionTags();
}
break;
case CChoreoChannelWidget::CLOSECAPTION_PREVLANGUAGE:
{
// Change language
int id = GetCloseCaptionLanguageId();
--id;
if ( id < 0 )
{
id = CC_NUM_LANGUAGES - 1;
Assert( id >= 0 );
}
SetCloseCaptionLanguageId( id );
redraw();
}
break;
case CChoreoChannelWidget::CLOSECAPTION_NEXTLANGUAGE:
{
int id = GetCloseCaptionLanguageId();
++id;
if ( id >= CC_NUM_LANGUAGES )
{
id = 0;
}
SetCloseCaptionLanguageId( id );
redraw();
}
break;
case CChoreoChannelWidget::CLOSECAPTION_SELECTOR:
{
SetDirty( true );
PushUndo( "Change selector" );
m_pClickedChannel->HandleSelectorClicked();
PushRedo( "Change selector" );
redraw();
}
break;
}
}
else
{
if ( !( event->modifiers & ( mxEvent::KeyCtrl | mxEvent::KeyShift ) ) )
{
DeselectAll();
if ( !isrightbutton )
{
if ( realtime - m_flLastMouseClickTime < 0.3f )
{
OnDoubleClicked();
m_flLastMouseClickTime = -1.0f;
}
else
{
m_flLastMouseClickTime = realtime;
}
}
redraw();
}
}
CalcBounds( m_nDragType );
}
void CChoreoView::OnDoubleClicked()
{
if ( m_pClickedChannel )
{
switch (m_nClickedChannelCloseCaptionButton )
{
default:
break;
case CChoreoChannelWidget::CLOSECAPTION_NONE:
{
SetDirty( true );
PushUndo( "Enable/disable Channel" );
m_pClickedChannel->GetChannel()->SetActive( !m_pClickedChannel->GetChannel()->GetActive() );
PushRedo( "Enable/disable Channel" );
}
break;
case CChoreoChannelWidget::CLOSECAPTION_CAPTION:
{
CChoreoEvent *e = m_pClickedChannel->GetCaptionClickedEvent();
if ( e && e->GetNumSlaves() >= 1 )
{
OnChangeCloseCaptionToken( e );
}
}
break;
}
return;
}
if ( m_pClickedActor )
{
SetDirty( true );
PushUndo( "Enable/disable Actor" );
m_pClickedActor->GetActor()->SetActive( !m_pClickedActor->GetActor()->GetActive() );
PushRedo( "Enable/disable Actor" );
return;
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : mx -
// my -
//-----------------------------------------------------------------------------
void CChoreoView::MouseContinueDrag( mxEvent *event, int mx, int my )
{
if ( !m_bDragging )
return;
DrawFocusRect();
ApplyBounds( mx, my );
for ( int i = 0; i < m_FocusRects.Size(); i++ )
{
CFocusRect *f = &m_FocusRects[ i ];
f->m_rcFocus = f->m_rcOrig;
switch ( m_nDragType )
{
default:
case DRAGTYPE_SCRUBBER:
{
float t = GetTimeValueForMouse( mx );
t += m_flScrubberTimeOffset;
ClampTimeToSelectionInterval( t );
float dt = t - m_flScrub;
SetScrubTargetTime( t );
m_bSimulating = true;
ScrubThink( dt, true, this );
SetScrubTime( t );
OffsetRect( &f->m_rcFocus, ( mx - m_xStart ), 0 );
}
break;
case DRAGTYPE_EVENT_MOVE:
case DRAGTYPE_EVENTTAG_MOVE:
case DRAGTYPE_EVENTABSTAG_MOVE:
{
int dx = mx - m_xStart;
int dy = my - m_yStart;
if ( m_pClickedEvent )
{
bool shiftdown = ( event->modifiers & mxEvent::KeyShift ) ? true : false;
// Only allow jumping channels if shift is down
if ( !shiftdown )
{
dy = 0;
}
if ( abs( dy ) < m_pClickedEvent->GetItemHeight() )
{
dy = 0;
}
if ( m_nSelectedEvents > 1 )
{
dy = 0;
}
if ( m_nDragType == DRAGTYPE_EVENTTAG_MOVE || m_nDragType == DRAGTYPE_EVENTABSTAG_MOVE )
{
dy = 0;
}
if ( m_pClickedEvent->GetEvent()->IsUsingRelativeTag() )
{
dx = 0;
}
}
else
{
dy = 0;
}
OffsetRect( &f->m_rcFocus, dx, dy );
}
break;
case DRAGTYPE_EVENT_STARTTIME:
case DRAGTYPE_EVENT_STARTTIME_RESCALE:
f->m_rcFocus.left += ( mx - m_xStart );
break;
case DRAGTYPE_EVENT_ENDTIME:
case DRAGTYPE_EVENT_ENDTIME_RESCALE:
f->m_rcFocus.right += ( mx - m_xStart );
break;
case DRAGTYPE_SCENE_ENDTIME:
OffsetRect( &f->m_rcFocus, ( mx - m_xStart ), 0 );
break;
case DRAGTYPE_RESCALELEFT:
case DRAGTYPE_RESCALERIGHT:
//f->m_rcFocus.right += ( mx - m_xStart );
break;
}
}
if ( m_nDragType == DRAGTYPE_RESCALELEFT ||
m_nDragType == DRAGTYPE_RESCALERIGHT )
{
int c = m_FocusRects.Count();
int m_nStart = INT_MAX;
int m_nEnd = INT_MIN;
for ( int i = 0; i < c; ++i )
{
CFocusRect *f = &m_FocusRects[ i ];
if ( f->m_rcFocus.left < m_nStart )
{
m_nStart = f->m_rcFocus.left;
}
if ( f->m_rcFocus.right > m_nEnd )
{
m_nEnd = f->m_rcFocus.right;
}
}
// Now figure out rescaling logic
int dxPixels = mx - m_xStart;
int oldSize = m_nEnd - m_nStart;
if ( oldSize > 0 )
{
float rescale = 1.0f;
if ( m_nDragType == DRAGTYPE_RESCALERIGHT )
{
rescale = (float)( oldSize + dxPixels )/(float)oldSize;
}
else
{
rescale = (float)( oldSize - dxPixels )/(float)oldSize;
}
for ( int i = 0; i < c; ++i )
{
CFocusRect *f = &m_FocusRects[ i ];
int w = f->m_rcFocus.right - f->m_rcFocus.left;
if ( m_nDragType == DRAGTYPE_RESCALERIGHT )
{
f->m_rcFocus.left = m_nStart + ( int )( rescale * (float)( f->m_rcFocus.left - m_nStart ) + 0.5f );
f->m_rcFocus.right = f->m_rcFocus.left + ( int )( rescale * (float)w + 0.5f );
}
else
{
f->m_rcFocus.right = m_nEnd - ( int )( rescale * (float)( m_nEnd - f->m_rcFocus.right ) + 0.5f );
f->m_rcFocus.left = f->m_rcFocus.right - ( int )( rescale * (float)w + 0.5f );
}
}
}
}
DrawFocusRect();
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : mx -
// my -
//-----------------------------------------------------------------------------
void CChoreoView::MouseMove( int mx, int my )
{
if ( m_bDragging )
return;
int dragtype = ComputeEventDragType( mx, my );
if ( dragtype == DRAGTYPE_NONE )
{
CChoreoGlobalEventWidget *ge = NULL;
GetObjectsUnderMouse( mx, my, NULL, NULL, NULL, &ge, NULL, NULL, NULL );
if ( ge )
{
dragtype = DRAGTYPE_EVENT_MOVE;
}
if ( dragtype == DRAGTYPE_NONE )
{
if ( IsMouseOverSceneEndTime( mx ) )
{
dragtype = DRAGTYPE_SCENE_ENDTIME;
}
}
}
if ( m_hPrevCursor )
{
SetCursor( m_hPrevCursor );
m_hPrevCursor = NULL;
}
switch ( dragtype )
{
default:
break;
case DRAGTYPE_EVENTTAG_MOVE:
m_hPrevCursor = SetCursor( LoadCursor( NULL, IDC_SIZEWE ) );
break;
case DRAGTYPE_EVENTABSTAG_MOVE:
m_hPrevCursor = SetCursor( LoadCursor( NULL, IDC_IBEAM ) );
break;
case DRAGTYPE_EVENT_MOVE:
m_hPrevCursor = SetCursor( LoadCursor( NULL, IDC_SIZEALL ) );
break;
case DRAGTYPE_EVENT_STARTTIME:
case DRAGTYPE_EVENT_STARTTIME_RESCALE:
case DRAGTYPE_EVENT_ENDTIME:
case DRAGTYPE_EVENT_ENDTIME_RESCALE:
case DRAGTYPE_SCENE_ENDTIME:
case DRAGTYPE_RESCALELEFT:
case DRAGTYPE_RESCALERIGHT:
m_hPrevCursor = SetCursor( LoadCursor( NULL, IDC_SIZEWE ) );
break;
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *e -
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CChoreoView::CheckGestureLength( CChoreoEvent *e, bool bCheckOnly )
{
Assert( e );
if ( !e )
return false;
if ( e->GetType() != CChoreoEvent::GESTURE )
{
Con_Printf( "CheckGestureLength: called on non-GESTURE event %s\n", e->GetName() );
return false;
}
StudioModel *model = FindAssociatedModel( e->GetScene(), e->GetActor() );
if ( !model )
return false;
CStudioHdr *pStudioHdr = model->GetStudioHdr();
if ( !pStudioHdr )
return false;
return UpdateGestureLength( e, pStudioHdr, model->GetPoseParameters(), bCheckOnly );
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *e -
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CChoreoView::DefaultGestureLength( CChoreoEvent *e, bool bCheckOnly )
{
Assert( e );
if ( !e )
return false;
if ( e->GetType() != CChoreoEvent::GESTURE )
{
Con_Printf( "DefaultGestureLength: called on non-GESTURE event %s\n", e->GetName() );
return false;
}
StudioModel *model = FindAssociatedModel( e->GetScene(), e->GetActor() );
if ( !model )
return false;
if ( !model->GetStudioHdr() )
return false;
int iSequence = model->LookupSequence( e->GetParameters() );
if ( iSequence < 0 )
return false;
bool bret = false;
float seqduration = model->GetDuration( iSequence );
if ( seqduration != 0.0f )
{
bret = true;
if ( !bCheckOnly )
{
e->SetEndTime( e->GetStartTime() + seqduration );
}
}
return bret;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *e -
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CChoreoView::AutoaddGestureKeys( CChoreoEvent *e, bool bCheckOnly )
{
if ( !e )
return false;
StudioModel *model = FindAssociatedModel( e->GetScene(), e->GetActor() );
if ( !model )
return false;
CStudioHdr *pStudioHdr = model->GetStudioHdr();
if ( !pStudioHdr )
return false;
return AutoAddGestureKeys( e, pStudioHdr, model->GetPoseParameters(), bCheckOnly );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CChoreoView::CheckSequenceLength( CChoreoEvent *e, bool bCheckOnly )
{
Assert( e );
if ( !e )
return false;
if ( e->GetType() != CChoreoEvent::SEQUENCE )
{
Con_Printf( "CheckSequenceLength: called on non-SEQUENCE event %s\n", e->GetName() );
return false;
}
StudioModel *model = FindAssociatedModel( e->GetScene(), e->GetActor() );
if ( !model )
return false;
CStudioHdr *pStudioHdr = model->GetStudioHdr();
if ( !pStudioHdr )
return false;
return UpdateSequenceLength( e, pStudioHdr, model->GetPoseParameters(), bCheckOnly, true );
}
void CChoreoView::FinishDraggingSceneEndTime( mxEvent *event, int mx, int my )
{
DrawFocusRect();
m_FocusRects.Purge();
m_bDragging = false;
float mouse_dt = GetTimeDeltaForMouseDelta( mx, m_xStart );
if ( !mouse_dt )
{
return;
}
SetDirty( true );
const char *desc = "Change Scene Duration";
PushUndo( desc );
float newendtime = GetTimeValueForMouse( mx );
float oldendtime = m_pScene->FindStopTime();
float scene_dt = newendtime - oldendtime;
for ( int i = 0; i < m_SceneActors.Size(); i++ )
{
CChoreoActorWidget *a = m_SceneActors[ i ];
if ( !a )
continue;
for ( int j = 0; j < a->GetNumChannels(); j++ )
{
CChoreoChannelWidget *channel = a->GetChannel( j );
if ( !channel )
continue;
int k;
CChoreoEvent *finalGesture = NULL;
for ( k = channel->GetNumEvents() - 1; k >= 0; k-- )
{
CChoreoEventWidget *event = channel->GetEvent( k );
CChoreoEvent *e = event->GetEvent();
if ( e->GetType() != CChoreoEvent::GESTURE )
continue;
if ( !finalGesture )
{
finalGesture = e;
}
else
{
if ( e->GetStartTime() > finalGesture->GetStartTime() )
{
finalGesture = e;
}
}
}
for ( k = channel->GetNumEvents() - 1; k >= 0; k-- )
{
CChoreoEventWidget *event = channel->GetEvent( k );
CChoreoEvent *e = event->GetEvent();
// Event starts after new end time, kill it
if ( e->GetStartTime() > newendtime )
{
channel->GetChannel()->RemoveEvent( e );
m_pScene->DeleteReferencedObjects( e );
continue;
}
// No change to normal events that end earlier than new time (but do change gestures)
if ( e->GetEndTime() < newendtime &&
e != finalGesture )
{
continue;
}
float dt = scene_dt;
if ( e->GetType() == CChoreoEvent::GESTURE )
{
if ( e->GetEndTime() < newendtime )
{
dt = newendtime - e->GetEndTime();
}
}
float newduration = e->GetDuration() + dt;
RescaleRamp( e, newduration );
switch ( e->GetType() )
{
default:
break;
case CChoreoEvent::GESTURE:
{
e->RescaleGestureTimes( e->GetStartTime(), e->GetEndTime() + dt, true );
}
break;
case CChoreoEvent::FLEXANIMATION:
{
RescaleExpressionTimes( e, e->GetStartTime(), e->GetEndTime() + dt );
}
break;
}
e->OffsetEndTime( dt );
e->SnapTimes();
e->ResortRamp();
}
}
}
// Remove event and move to new object
DeleteSceneWidgets();
m_nDragType = DRAGTYPE_NONE;
if ( m_hPrevCursor )
{
SetCursor( m_hPrevCursor );
m_hPrevCursor = 0;
}
PushRedo( desc );
CreateSceneWidgets();
InvalidateLayout();
g_pExpressionTool->LayoutItems( true );
g_pExpressionTool->redraw();
g_pGestureTool->redraw();
g_pRampTool->redraw();
g_pSceneRampTool->redraw();
}
//-----------------------------------------------------------------------------
// Purpose: Called after association changes to reset .wav file images
// Input : -
//-----------------------------------------------------------------------------
void CChoreoView::RecomputeWaves()
{
for ( int i = 0; i < m_SceneActors.Size(); i++ )
{
CChoreoActorWidget *a = m_SceneActors[ i ];
if ( !a )
continue;
for ( int j = 0; j < a->GetNumChannels(); j++ )
{
CChoreoChannelWidget *c = a->GetChannel( j );
if ( !c )
continue;
for ( int k = 0; k < c->GetNumEvents(); k++ )
{
CChoreoEventWidget *e = c->GetEvent( k );
if ( !e )
continue;
e->RecomputeWave();
}
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : mx -
// my -
//-----------------------------------------------------------------------------
void CChoreoView::FinishDraggingEvent( mxEvent *event, int mx, int my )
{
DrawFocusRect();
m_FocusRects.Purge();
m_bDragging = false;
float dt = GetTimeDeltaForMouseDelta( mx, m_xStart );
if ( !dt )
{
if ( m_pScene && m_pClickedEvent && m_pClickedEvent->GetEvent()->GetType() == CChoreoEvent::SPEAK )
{
// Show phone wav in wav viewer
char sndname[ 512 ];
Q_strncpy( sndname, FacePoser_TranslateSoundName( m_pClickedEvent->GetEvent() ), sizeof( sndname ) );
if ( sndname[ 0 ] )
{
SetCurrentWaveFile( va( "sound/%s", sndname ), m_pClickedEvent->GetEvent() );
}
else
{
Warning( "Unable to resolve sound name for '%s', check actor associations\n", m_pClickedEvent->GetEvent()->GetName() );
}
}
return;
}
SetDirty( true );
char const *desc = "";
switch ( m_nDragType )
{
default:
case DRAGTYPE_EVENT_MOVE:
desc = "Event Move";
break;
case DRAGTYPE_EVENT_STARTTIME:
case DRAGTYPE_EVENT_STARTTIME_RESCALE:
desc = "Change Start Time";
break;
case DRAGTYPE_EVENT_ENDTIME:
case DRAGTYPE_EVENT_ENDTIME_RESCALE:
desc = "Change End Time";
break;
case DRAGTYPE_EVENTTAG_MOVE:
desc = "Move Event Tag";
break;
case DRAGTYPE_EVENTABSTAG_MOVE:
desc = "Move Abs Event Tag";
break;
case DRAGTYPE_RESCALELEFT:
case DRAGTYPE_RESCALERIGHT:
desc = "Rescale Time";
break;
}
PushUndo( desc );
CUtlVector< CChoreoEvent * > rescaleHelper;
for ( int i = 0; i < m_SceneActors.Size(); i++ )
{
CChoreoActorWidget *actor = m_SceneActors[ i ];
if ( !actor )
continue;
for ( int j = 0; j < actor->GetNumChannels(); j++ )
{
CChoreoChannelWidget *channel = actor->GetChannel( j );
if ( !channel )
continue;
for ( int k = 0; k < channel->GetNumEvents(); k++ )
{
CChoreoEventWidget *event = channel->GetEvent( k );
if ( !event )
continue;
if ( !event->IsSelected() )
continue;
// Figure out true dt
CChoreoEvent *e = event->GetEvent();
if ( e )
{
switch ( m_nDragType )
{
default:
case DRAGTYPE_EVENT_MOVE:
e->OffsetTime( dt );
e->SnapTimes();
break;
case DRAGTYPE_EVENT_STARTTIME:
case DRAGTYPE_EVENT_STARTTIME_RESCALE:
{
float newduration = e->GetDuration() - dt;
RescaleRamp( e, newduration );
switch ( e->GetType() )
{
default:
break;
case CChoreoEvent::GESTURE:
{
e->RescaleGestureTimes( e->GetStartTime() + dt, e->GetEndTime(), m_nDragType == DRAGTYPE_EVENT_STARTTIME );
}
break;
case CChoreoEvent::FLEXANIMATION:
{
RescaleExpressionTimes( e, e->GetStartTime() + dt, e->GetEndTime() );
}
break;
}
e->OffsetStartTime( dt );
e->SnapTimes();
e->ResortRamp();
}
break;
case DRAGTYPE_EVENT_ENDTIME:
case DRAGTYPE_EVENT_ENDTIME_RESCALE:
{
float newduration = e->GetDuration() + dt;
RescaleRamp( e, newduration );
switch ( e->GetType() )
{
default:
break;
case CChoreoEvent::GESTURE:
{
e->RescaleGestureTimes( e->GetStartTime(), e->GetEndTime() + dt, m_nDragType == DRAGTYPE_EVENT_ENDTIME );
}
break;
case CChoreoEvent::FLEXANIMATION:
{
RescaleExpressionTimes( e, e->GetStartTime(), e->GetEndTime() + dt );
}
break;
}
e->OffsetEndTime( dt );
e->SnapTimes();
e->ResortRamp();
}
break;
case DRAGTYPE_RESCALELEFT:
case DRAGTYPE_RESCALERIGHT:
{
rescaleHelper.AddToTail( e );
}
break;
case DRAGTYPE_EVENTTAG_MOVE:
{
// Get current x position
if ( m_nClickedTag != -1 )
{
CEventRelativeTag *tag = e->GetRelativeTag( m_nClickedTag );
if ( tag )
{
float dx = mx - m_xStart;
// Determine left edcge
RECT bounds;
bounds = event->getBounds();
if ( bounds.right - bounds.left > 0 )
{
int left = bounds.left + (int)( tag->GetPercentage() * (float)( bounds.right - bounds.left ) + 0.5f );
left += dx;
if ( left < bounds.left )
{
left = bounds.left;
}
else if ( left >= bounds.right )
{
left = bounds.right - 1;
}
// Now convert back to a percentage
float frac = (float)( left - bounds.left ) / (float)( bounds.right - bounds.left );
tag->SetPercentage( frac );
}
}
}
}
break;
case DRAGTYPE_EVENTABSTAG_MOVE:
{
// Get current x position
if ( m_pClickedAbsoluteTag != NULL )
{
CEventAbsoluteTag *tag = m_pClickedAbsoluteTag;
if ( tag )
{
float dx = mx - m_xStart;
// Determine left edcge
RECT bounds;
bounds = event->getBounds();
if ( bounds.right - bounds.left > 0 )
{
int left = bounds.left + (int)( tag->GetPercentage() * (float)( bounds.right - bounds.left ) + 0.5f );
left += dx;
if ( left < bounds.left )
{
left = bounds.left;
}
else if ( left >= bounds.right )
{
left = bounds.right - 1;
}
// Now convert back to a percentage
float frac = (float)( left - bounds.left ) / (float)( bounds.right - bounds.left );
tag->SetPercentage( frac );
}
}
}
}
break;
}
}
switch ( e->GetType() )
{
default:
break;
case CChoreoEvent::SPEAK:
{
// Try and load wav to get length
CAudioSource *wave = sound->LoadSound( va( "sound/%s", FacePoser_TranslateSoundName( e ) ) );
if ( wave )
{
e->SetEndTime( e->GetStartTime() + wave->GetRunningLength() );
delete wave;
}
}
break;
case CChoreoEvent::SEQUENCE:
{
CheckSequenceLength( e, false );
}
break;
case CChoreoEvent::GESTURE:
{
CheckGestureLength( e, false );
}
break;
}
}
}
}
if ( rescaleHelper.Count() > 0 )
{
int i;
// Determine start and end times for existing "selection"
float flStart = FLT_MAX;
float flEnd = FLT_MIN;
for ( i = 0; i < rescaleHelper.Count(); ++i )
{
CChoreoEvent *e = rescaleHelper[ i ];
float st = e->GetStartTime();
float ed = e->GetEndTime();
if ( st < flStart )
{
flStart = st;
}
if ( ed > flEnd )
{
flEnd = ed;
}
}
float flSelectionDuration = flEnd - flStart;
if ( flSelectionDuration > 0.0f )
{
float flNewDuration = 0.0f;
if ( m_nDragType == DRAGTYPE_RESCALELEFT )
{
flNewDuration = max( 0.1f, flSelectionDuration - dt );
}
else
{
flNewDuration = max( 0.1f, flSelectionDuration + dt );
}
float flScale = flNewDuration / flSelectionDuration;
for ( i = 0; i < rescaleHelper.Count(); ++i )
{
CChoreoEvent *e = rescaleHelper[ i ];
float st = e->GetStartTime();
float et = e->HasEndTime() ? e->GetEndTime() : e->GetStartTime();
float flTimeFromStart = st - flStart;
float flTimeFromEnd = flEnd - et;
float flDuration = e->GetDuration();
float flNewStartTime = 0.0f;
float flNewDuration = 0.0f;
if ( m_nDragType == DRAGTYPE_RESCALELEFT )
{
float flNewEndTime = flEnd - flTimeFromEnd * flScale;
if ( !e->HasEndTime() || e->IsFixedLength() )
{
e->OffsetTime( flNewEndTime - flDuration - st );
continue;
}
flNewDuration = flDuration * flScale;
flNewStartTime = flNewEndTime - flNewDuration;
}
else
{
flNewStartTime = flTimeFromStart * flScale + flStart;
if ( !e->HasEndTime() || e->IsFixedLength() )
{
e->OffsetTime( flNewStartTime - st );
continue;
}
flNewDuration = flDuration * flScale;
}
RescaleRamp( e, flNewDuration );
switch ( e->GetType() )
{
default:
break;
case CChoreoEvent::GESTURE:
{
e->RescaleGestureTimes( flNewStartTime, flNewStartTime + flNewDuration, m_nDragType == DRAGTYPE_EVENT_STARTTIME || m_nDragType == DRAGTYPE_EVENT_ENDTIME );
}
break;
case CChoreoEvent::FLEXANIMATION:
{
RescaleExpressionTimes( e, flNewStartTime, flNewStartTime + flNewDuration );
}
break;
}
e->SetStartTime( flNewStartTime );
Assert( e->HasEndTime() );
e->SetEndTime( flNewStartTime + flNewDuration );
}
}
}
for ( int i = 0; i < m_SceneGlobalEvents.Count(); i++ )
{
CChoreoGlobalEventWidget *gew = m_SceneGlobalEvents[ i ];
if ( !gew || !gew->IsSelected() )
continue;
CChoreoEvent *e = gew->GetEvent();
if ( !e )
continue;
e->OffsetTime( dt );
e->SnapTimes();
}
m_nDragType = DRAGTYPE_NONE;
if ( m_hPrevCursor )
{
SetCursor( m_hPrevCursor );
m_hPrevCursor = 0;
}
CChoreoEvent *e = m_pClickedEvent ? m_pClickedEvent->GetEvent() : NULL;
if ( e )
{
// See if event is moving to a new owner
CChoreoChannelWidget *chOrig, *chNew;
int dy = my - m_yStart;
bool shiftdown = ( event->modifiers & mxEvent::KeyShift ) ? true : false;
if ( !shiftdown )
{
dy = 0;
}
if ( abs( dy ) < m_pClickedEvent->GetItemHeight() )
{
my = m_yStart;
}
chNew = GetChannelUnderCursorPos( mx, my );
InvalidateLayout();
mx = m_xStart;
my = m_yStart;
chOrig = m_pClickedChannel;
if ( chOrig && chNew && chOrig != chNew )
{
// Swap underlying objects
CChoreoChannel *pOrigChannel, *pNewChannel;
pOrigChannel = chOrig->GetChannel();
pNewChannel = chNew->GetChannel();
Assert( pOrigChannel && pNewChannel );
// Remove event and move to new object
DeleteSceneWidgets();
pOrigChannel->RemoveEvent( e );
pNewChannel->AddEvent( e );
e->SetChannel( pNewChannel );
e->SetActor( pNewChannel->GetActor() );
CreateSceneWidgets();
}
else
{
if ( e && e->GetType() == CChoreoEvent::SPEAK )
{
// Show phone wav in wav viewer
SetCurrentWaveFile( va( "sound/%s", FacePoser_TranslateSoundName( e ) ), e );
}
}
}
PushRedo( desc );
InvalidateLayout();
if ( e )
{
switch ( e->GetType() )
{
default:
break;
case CChoreoEvent::FLEXANIMATION:
{
g_pExpressionTool->SetEvent( e );
g_pFlexPanel->SetEvent( e );
}
break;
case CChoreoEvent::GESTURE:
{
g_pGestureTool->SetEvent( e );
}
break;
}
if ( e->HasEndTime() )
{
g_pRampTool->SetEvent( e );
}
}
g_pExpressionTool->LayoutItems( true );
g_pExpressionTool->redraw();
g_pGestureTool->redraw();
g_pRampTool->redraw();
g_pSceneRampTool->redraw();
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : mx -
// my -
//-----------------------------------------------------------------------------
void CChoreoView::MouseFinishDrag( mxEvent *event, int mx, int my )
{
if ( !m_bDragging )
return;
ApplyBounds( mx, my );
switch ( m_nDragType )
{
case DRAGTYPE_SCRUBBER:
{
DrawFocusRect();
m_FocusRects.Purge();
float t = GetTimeValueForMouse( mx );
t += m_flScrubberTimeOffset;
m_flScrubberTimeOffset = 0.0f;
ClampTimeToSelectionInterval( t );
SetScrubTime( t );
SetScrubTargetTime( t );
m_bDragging = false;
m_nDragType = DRAGTYPE_NONE;
redraw();
}
break;
case DRAGTYPE_EVENT_MOVE:
case DRAGTYPE_EVENT_STARTTIME:
case DRAGTYPE_EVENT_STARTTIME_RESCALE:
case DRAGTYPE_EVENT_ENDTIME:
case DRAGTYPE_EVENT_ENDTIME_RESCALE:
case DRAGTYPE_EVENTTAG_MOVE:
case DRAGTYPE_EVENTABSTAG_MOVE:
case DRAGTYPE_RESCALELEFT:
case DRAGTYPE_RESCALERIGHT:
FinishDraggingEvent( event, mx, my );
break;
case DRAGTYPE_SCENE_ENDTIME:
FinishDraggingSceneEndTime( event, mx, my );
break;
default:
break;
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *event -
// Output : int
//-----------------------------------------------------------------------------
int CChoreoView::handleEvent( mxEvent *event )
{
MDLCACHE_CRITICAL_SECTION_( g_pMDLCache );
int iret = 0;
if ( HandleToolEvent( event ) )
{
return iret;
}
switch ( event->event )
{
case mxEvent::MouseWheeled:
{
CChoreoScene *scene = GetScene();
if ( scene )
{
int tz = GetTimeZoom( GetToolName() );
bool shiftdown = ( event->modifiers & mxEvent::KeyShift ) ? true : false;
int stepMultipiler = shiftdown ? 5 : 1;
// Zoom time in / out
if ( event->height > 0 )
{
tz = min( tz + TIME_ZOOM_STEP * stepMultipiler, MAX_TIME_ZOOM );
}
else
{
tz = max( tz - TIME_ZOOM_STEP * stepMultipiler, TIME_ZOOM_STEP );
}
SetTimeZoom( GetToolName(), tz, true );
CUtlVector< CChoreoEvent * > selected;
RememberSelectedEvents( selected );
DeleteSceneWidgets();
CreateSceneWidgets();
ReselectEvents( selected );
InvalidateLayout();
Con_Printf( "Zoom factor %i %%\n", GetTimeZoom( GetToolName() ) );
}
iret = 1;
}
break;
case mxEvent::Size:
{
// Force scroll bars to recompute
ForceScrollBarsToRecompute( false );
InvalidateLayout();
PositionControls();
iret = 1;
}
break;
case mxEvent::MouseDown:
{
if ( !m_bDragging )
{
if ( event->buttons & mxEvent::MouseRightButton )
{
if ( IsMouseOverTimeline( (short)event->x, (short)event->y ) )
{
PlaceABPoint( (short)event->x );
redraw();
}
else if ( IsMouseOverScrubArea( event ) )
{
float t = GetTimeValueForMouse( (short)event->x );
ClampTimeToSelectionInterval( t );
SetScrubTime( t );
SetScrubTargetTime( t );
sound->Flush();
// Unpause the scene
m_bPaused = false;
redraw();
}
else
{
// Show right click menu
ShowContextMenu( (short)event->x, (short)event->y );
}
}
else
{
if ( IsMouseOverTimeline( (short)event->x, (short)event->y ) )
{
ClearABPoints();
redraw();
}
else
{
// Handle mouse dragging here
MouseStartDrag( event, (short)event->x, (short)event->y );
}
}
}
iret = 1;
}
break;
case mxEvent::MouseDrag:
{
MouseContinueDrag( event, (short)event->x, (short)event->y );
iret = 1;
}
break;
case mxEvent::MouseUp:
{
MouseFinishDrag( event, (short)event->x, (short)event->y );
iret = 1;
}
break;
case mxEvent::MouseMove:
{
MouseMove( (short)event->x, (short)event->y );
UpdateStatusArea( (short)event->x, (short)event->y );
iret = 1;
}
break;
case mxEvent::KeyDown:
{
iret = 1;
switch ( event->key )
{
default:
iret = 0;
break;
case 'E':
if ( GetAsyncKeyState( VK_CONTROL ) )
{
OnPlaceNextSpeakEvent();
}
break;
case VK_ESCAPE:
DeselectAll();
break;
case 'C':
CopyEvents();
iret = 1;
break;
case 'V':
PasteEvents();
redraw();
break;
case VK_DELETE:
{
if ( IsActiveTool() )
{
DeleteSelectedEvents();
}
}
break;
case VK_RETURN:
{
CUtlVector< CChoreoEvent * > events;
GetSelectedEvents( events );
if ( events.Count() == 1 )
{
if ( GetAsyncKeyState( VK_MENU ) )
{
EditEvent( events[ 0 ] );
redraw();
iret = 1;
}
}
}
break;
case 'Z': // Undo/Redo
{
if ( GetAsyncKeyState( VK_CONTROL ) )
{
if ( GetAsyncKeyState( VK_SHIFT ) )
{
if ( CanRedo() )
{
Con_Printf( "Redo %s\n", GetRedoDescription() );
Redo();
iret = 1;
}
}
else
{
if ( CanUndo() )
{
Con_Printf( "Undo %s\n", GetUndoDescription() );
Undo();
iret = 1;
}
}
}
}
break;
case VK_SPACE:
{
if ( IsPlayingScene() )
{
StopScene();
}
}
break;
case 188: // VK_OEM_COMMA:
{
SetScrubTargetTime( 0.0f );
}
break;
case 190: // VK_OEM_PERIOD:
{
CChoreoScene *scene = GetScene();
if ( scene )
{
SetScrubTargetTime( scene->FindStopTime() );
}
}
break;
case VK_LEFT:
{
CChoreoScene *scene = GetScene();
if ( scene && scene->GetSceneFPS() > 0 )
{
float curscrub = m_flScrub;
curscrub -= ( 1.0f / (float)scene->GetSceneFPS() );
curscrub = max( curscrub, 0.0f );
SetScrubTargetTime( curscrub );
}
}
break;
case VK_RIGHT:
{
CChoreoScene *scene = GetScene();
if ( scene && scene->GetSceneFPS() > 0 )
{
float curscrub = m_flScrub;
curscrub += ( 1.0f / (float)scene->GetSceneFPS() );
curscrub = min( curscrub, scene->FindStopTime() );
SetScrubTargetTime( curscrub );
}
}
break;
case VK_HOME:
{
MoveTimeSliderToPos( 0 );
}
break;
case VK_END:
{
float maxtime = m_pScene->FindStopTime() - 1.0f;
int pixels = (int)( maxtime * GetPixelsPerSecond() );
MoveTimeSliderToPos( pixels - 1 );
}
break;
case VK_PRIOR: // PgUp
{
int window = w2() - GetLabelWidth();
m_flLeftOffset = max( m_flLeftOffset - (float)window, 0.0f );
MoveTimeSliderToPos( (int)m_flLeftOffset );
}
break;
case VK_NEXT: // PgDown
{
int window = w2() - GetLabelWidth();
int pixels = ComputeHPixelsNeeded();
m_flLeftOffset = min( m_flLeftOffset + (float)window, (float)pixels );
MoveTimeSliderToPos( (int)m_flLeftOffset );
}
break;
}
}
break;
case mxEvent::Action:
{
iret = 1;
switch ( event->action )
{
default:
{
iret = 0;
int lang_index = event->action - IDC_CV_CC_LANGUAGESTART;
if ( lang_index >= 0 && lang_index < CC_NUM_LANGUAGES )
{
iret = 1;
SetCloseCaptionLanguageId( lang_index );
}
}
break;
case IDC_CV_TOGGLECLOSECAPTIONS:
{
OnToggleCloseCaptionsForEvent();
}
break;
case IDC_CV_CHANGECLOSECAPTIONTOKEN:
{
if ( m_pClickedChannel )
{
CChoreoEvent *e = m_pClickedChannel->GetCaptionClickedEvent();
if ( e && e->GetNumSlaves() >= 1 )
{
OnChangeCloseCaptionToken( e );
}
}
}
break;
case IDC_CV_REMOVESPEAKEVENTFROMGROUP:
{
OnRemoveSpeakEventFromGroup();
}
break;
case IDC_CV_COMBINESPEAKEVENTS:
{
OnCombineSpeakEvents();
}
break;
case IDC_CV_CC_SHOW:
{
OnToggleCloseCaptionTags();
}
break;
case IDC_CV_TOGGLERAMPONLY:
{
m_bRampOnly = !m_bRampOnly;
redraw();
}
break;
case IDC_CV_PROCESSSEQUENCES:
{
m_bProcessSequences = !m_bProcessSequences;
}
break;
case IDC_CV_CHECKSEQLENGTHS:
{
OnCheckSequenceLengths();
}
break;
case IDC_CV_CHANGESCALE:
{
OnChangeScale();
}
break;
case IDC_CHOREO_PLAYBACKRATE:
{
m_flPlaybackRate = m_pPlaybackRate->getValue();
redraw();
}
break;
case IDC_COPYEVENTS:
CopyEvents();
break;
case IDC_PASTEEVENTS:
PasteEvents();
redraw();
break;
case IDC_IMPORTEVENTS:
ImportEvents();
redraw();
break;
case IDC_EXPORTEVENTS:
ExportEvents();
redraw();
break;
case IDC_EXPORT_VCD:
ExportVCD();
redraw();
break;
case IDC_IMPORT_VCD:
ImportVCD();
redraw();
break;
case IDC_EXPRESSIONTOOL:
OnExpressionTool();
break;
case IDC_GESTURETOOL:
OnGestureTool();
break;
case IDC_ASSOCIATEBSP:
AssociateBSP();
break;
case IDC_ASSOCIATEMODEL:
AssociateModel();
break;
case IDC_CVUNDO:
Undo();
break;
case IDC_CVREDO:
Redo();
break;
case IDC_SELECTALL:
SelectAll();
break;
case IDC_DESELECTALL:
DeselectAll();
break;
case IDC_PLAYSCENE:
Con_Printf( "Commencing playback\n" );
PlayScene( true );
break;
case IDC_PAUSESCENE:
Con_Printf( "Pausing playback\n" );
PauseScene();
break;
case IDC_STOPSCENE:
Con_Printf( "Canceling playback\n" );
StopScene();
break;
case IDC_CHOREOVSCROLL:
{
int offset = 0;
bool processed = true;
switch ( event->modifiers )
{
case SB_THUMBTRACK:
offset = event->height;
break;
case SB_PAGEUP:
offset = m_pVertScrollBar->getValue();
offset -= 20;
offset = max( offset, m_pVertScrollBar->getMinValue() );
break;
case SB_PAGEDOWN:
offset = m_pVertScrollBar->getValue();
offset += 20;
offset = min( offset, m_pVertScrollBar->getMaxValue() );
break;
case SB_LINEDOWN:
offset = m_pVertScrollBar->getValue();
offset += 10;
offset = min( offset, m_pVertScrollBar->getMaxValue() );
break;
case SB_LINEUP:
offset = m_pVertScrollBar->getValue();
offset -= 10;
offset = max( offset, m_pVertScrollBar->getMinValue() );
break;
default:
processed = false;
break;
}
if ( processed )
{
m_pVertScrollBar->setValue( offset );
InvalidateRect( (HWND)m_pVertScrollBar->getHandle(), NULL, TRUE );
m_nTopOffset = offset;
InvalidateLayout();
}
}
break;
case IDC_CHOREOHSCROLL:
{
int offset = 0;
bool processed = true;
switch ( event->modifiers )
{
case SB_THUMBTRACK:
offset = event->height;
break;
case SB_PAGEUP:
offset = m_pHorzScrollBar->getValue();
offset -= 20;
offset = max( offset, m_pHorzScrollBar->getMinValue() );
break;
case SB_PAGEDOWN:
offset = m_pHorzScrollBar->getValue();
offset += 20;
offset = min( offset, m_pHorzScrollBar->getMaxValue() );
break;
case SB_LINEUP:
offset = m_pHorzScrollBar->getValue();
offset -= 10;
offset = max( offset, m_pHorzScrollBar->getMinValue() );
break;
case SB_LINEDOWN:
offset = m_pHorzScrollBar->getValue();
offset += 10;
offset = min( offset, m_pHorzScrollBar->getMaxValue() );
break;
default:
processed = false;
break;
}
if ( processed )
{
MoveTimeSliderToPos( offset );
}
}
break;
case IDC_ADDACTOR:
{
NewActor();
}
break;
case IDC_EDITACTOR:
{
CChoreoActorWidget *actor = m_pClickedActor;
if ( actor )
{
EditActor( actor->GetActor() );
}
}
break;
case IDC_DELETEACTOR:
{
CChoreoActorWidget *actor = m_pClickedActor;
if ( actor )
{
DeleteActor( actor->GetActor() );
}
}
break;
case IDC_MOVEACTORUP:
{
CChoreoActorWidget *actor = m_pClickedActor;
if ( actor )
{
MoveActorUp( actor->GetActor() );
}
}
break;
case IDC_MOVEACTORDOWN:
{
CChoreoActorWidget *actor = m_pClickedActor;
if ( actor )
{
MoveActorDown( actor->GetActor() );
}
}
break;
case IDC_CHANNELOPEN:
{
CActorBitmapButton *btn = static_cast< CActorBitmapButton * >( event->widget );
if ( btn )
{
CChoreoActorWidget *a = btn->GetActor();
if ( a )
{
a->ShowChannels( true );
}
}
}
break;
case IDC_CHANNELCLOSE:
{
CActorBitmapButton *btn = static_cast< CActorBitmapButton * >( event->widget );
if ( btn )
{
CChoreoActorWidget *a = btn->GetActor();
if ( a )
{
a->ShowChannels( false );
}
}
}
break;
case IDC_ADDEVENT_INTERRUPT:
{
AddEvent( CChoreoEvent::INTERRUPT );
}
break;
case IDC_ADDEVENT_PERMITRESPONSES:
{
AddEvent( CChoreoEvent::PERMIT_RESPONSES );
}
break;
case IDC_ADDEVENT_EXPRESSION:
{
AddEvent( CChoreoEvent::EXPRESSION );
}
break;
case IDC_ADDEVENT_FLEXANIMATION:
{
AddEvent( CChoreoEvent::FLEXANIMATION );
}
break;
case IDC_ADDEVENT_GESTURE:
{
AddEvent( CChoreoEvent::GESTURE );
}
break;
case IDC_ADDEVENT_NULLGESTURE:
{
AddEvent( CChoreoEvent::GESTURE, 1 );
}
break;
case IDC_ADDEVENT_LOOKAT:
{
AddEvent( CChoreoEvent::LOOKAT );
}
break;
case IDC_ADDEVENT_MOVETO:
{
AddEvent( CChoreoEvent::MOVETO );
}
break;
case IDC_ADDEVENT_FACE:
{
AddEvent( CChoreoEvent::FACE );
}
break;
case IDC_ADDEVENT_SPEAK:
{
AddEvent( CChoreoEvent::SPEAK );
}
break;
case IDC_ADDEVENT_FIRETRIGGER:
{
AddEvent( CChoreoEvent::FIRETRIGGER );
}
break;
case IDC_ADDEVENT_GENERIC:
{
AddEvent( CChoreoEvent::GENERIC );
}
break;
case IDC_ADDEVENT_SUBSCENE:
{
AddEvent( CChoreoEvent::SUBSCENE );
}
break;
case IDC_ADDEVENT_SEQUENCE:
{
AddEvent( CChoreoEvent::SEQUENCE );
}
break;
case IDC_EDITEVENT:
{
CChoreoEventWidget *event = m_pClickedEvent;
if ( event )
{
EditEvent( event->GetEvent() );
redraw();
}
}
break;
case IDC_DELETEEVENT:
{
DeleteSelectedEvents();
}
break;
case IDC_CV_ENABLEEVENTS:
{
EnableSelectedEvents( true );
}
break;
case IDC_CV_DISABLEEVENTS:
{
EnableSelectedEvents( false );
}
break;
case IDC_MOVETOBACK:
{
CChoreoEventWidget *event = m_pClickedEvent;
if ( event )
{
MoveEventToBack( event->GetEvent() );
}
}
break;
case IDC_DELETERELATIVETAG:
{
CChoreoEventWidget *event = m_pClickedEvent;
if ( event && m_nClickedTag >= 0 )
{
DeleteEventRelativeTag( event->GetEvent(), m_nClickedTag );
}
}
break;
case IDC_ADDTIMINGTAG:
{
AddEventRelativeTag();
}
break;
case IDC_ADDEVENT_PAUSE:
{
AddGlobalEvent( CChoreoEvent::SECTION );
}
break;
case IDC_ADDEVENT_LOOP:
{
AddGlobalEvent( CChoreoEvent::LOOP );
}
break;
case IDC_ADDEVENT_STOPPOINT:
{
AddGlobalEvent( CChoreoEvent::STOPPOINT );
}
break;
case IDC_EDITGLOBALEVENT:
{
CChoreoGlobalEventWidget *event = m_pClickedGlobalEvent;
if ( event )
{
EditGlobalEvent( event->GetEvent() );
redraw();
}
}
break;
case IDC_DELETEGLOBALEVENT:
{
CChoreoGlobalEventWidget *event = m_pClickedGlobalEvent;
if ( event )
{
DeleteGlobalEvent( event->GetEvent() );
}
}
break;
case IDC_ADDCHANNEL:
{
NewChannel();
}
break;
case IDC_EDITCHANNEL:
{
CChoreoChannelWidget *channel = m_pClickedChannel;
if ( channel )
{
EditChannel( channel->GetChannel() );
}
}
break;
case IDC_DELETECHANNEL:
{
CChoreoChannelWidget *channel = m_pClickedChannel;
if ( channel )
{
DeleteChannel( channel->GetChannel() );
}
}
break;
case IDC_MOVECHANNELUP:
{
CChoreoChannelWidget *channel = m_pClickedChannel;
if ( channel )
{
MoveChannelUp( channel->GetChannel() );
}
}
break;
case IDC_MOVECHANNELDOWN:
{
CChoreoChannelWidget *channel = m_pClickedChannel;
if ( channel )
{
MoveChannelDown( channel->GetChannel() );
}
}
break;
case IDC_CV_ALLEVENTS_CHANNEL:
{
CChoreoChannelWidget *channel = m_pClickedChannel;
if ( channel )
{
SelectAllEventsInChannel( channel );
}
}
break;
case IDC_CV_ALLEVENTS_ACTOR:
{
CChoreoActorWidget *actor = m_pClickedActor;
if ( actor )
{
SelectAllEventsInActor( actor );
}
}
break;
case IDC_SELECTEVENTS_ALL_BEFORE:
{
SelectionParams_t params;
Q_memset( &params, 0, sizeof( params ) );
params.forward = false;
params.time = GetTimeValueForMouse( m_nClickedX );
params.type = SelectionParams_t::SP_ALL;
SelectEvents( params );
}
break;
case IDC_SELECTEVENTS_ALL_AFTER:
{
SelectionParams_t params;
Q_memset( &params, 0, sizeof( params ) );
params.forward = true;
params.time = GetTimeValueForMouse( m_nClickedX );
params.type = SelectionParams_t::SP_ALL;
SelectEvents( params );
}
break;
case IDC_SELECTEVENTS_ACTIVE_BEFORE:
{
SelectionParams_t params;
Q_memset( &params, 0, sizeof( params ) );
params.forward = false;
params.time = GetTimeValueForMouse( m_nClickedX );
params.type = SelectionParams_t::SP_ACTIVE;
SelectEvents( params );
}
break;
case IDC_SELECTEVENTS_ACTIVE_AFTER:
{
SelectionParams_t params;
Q_memset( &params, 0, sizeof( params ) );
params.forward = true;
params.time = GetTimeValueForMouse( m_nClickedX );
params.type = SelectionParams_t::SP_ACTIVE;
SelectEvents( params );
}
break;
case IDC_SELECTEVENTS_CHANNEL_BEFORE:
{
SelectionParams_t params;
Q_memset( &params, 0, sizeof( params ) );
params.forward = false;
params.time = GetTimeValueForMouse( m_nClickedX );
params.type = SelectionParams_t::SP_CHANNEL;
SelectEvents( params );
}
break;
case IDC_SELECTEVENTS_CHANNEL_AFTER:
{
SelectionParams_t params;
Q_memset( &params, 0, sizeof( params ) );
params.forward = true;
params.time = GetTimeValueForMouse( m_nClickedX );
params.type = SelectionParams_t::SP_CHANNEL;
SelectEvents( params );
}
break;
case IDC_INSERT_TIME:
{
OnInsertTime();
}
break;
case IDC_DELETE_TIME:
{
OnDeleteTime();
}
break;
case IDC_CV_ALIGN_LEFT:
{
OnAlign( true );
}
break;
case IDC_CV_ALIGN_RIGHT:
{
OnAlign( false );
}
break;
case IDC_CV_SAMESIZE_SMALLEST:
{
OnMakeSameSize( true );
}
break;
case IDC_CV_SAMESIZE_LARGEST:
{
OnMakeSameSize( false );
}
break;
}
if ( iret == 1 )
{
SetActiveTool( this );
}
}
break;
}
return iret;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CChoreoView::PlayScene( bool forward )
{
m_bForward = forward;
if ( !m_pScene )
return;
sound->Flush();
// Make sure phonemes are loaded
FacePoser_EnsurePhonemesLoaded();
// Unpause
if ( m_bSimulating && m_bPaused )
{
m_bPaused = false;
return;
}
m_bSimulating = true;
m_bPaused = false;
// float soundlatency = max( sound->GetAmountofTimeAhead(), 0.0f );
// soundlatency = min( 0.5f, soundlatency );
float soundlatency = 0.0f;
float sceneendtime = m_pScene->FindStopTime();
m_pScene->SetSoundFileStartupLatency( soundlatency );
if ( m_rgABPoints[ 0 ].active ||
m_rgABPoints[ 1 ].active )
{
if ( m_rgABPoints[ 0 ].active &&
m_rgABPoints[ 1 ].active )
{
float st = m_rgABPoints[ 0 ].time;
float ed = m_rgABPoints[ 1 ].time;
m_pScene->ResetSimulation( m_bForward, st, ed );
SetScrubTime( m_bForward ? st : ed );
SetScrubTargetTime( m_bForward ? ed : st );
}
else
{
float startonly = m_rgABPoints[ 0 ].active ? m_rgABPoints[ 0 ].time : m_rgABPoints[ 1 ].time;
m_pScene->ResetSimulation( m_bForward, startonly );
SetScrubTime( m_bForward ? startonly : sceneendtime );
SetScrubTargetTime( m_bForward ? sceneendtime : startonly );
}
}
else
{
// NO start end/loop
m_pScene->ResetSimulation( m_bForward );
SetScrubTime( m_bForward ? 0 : sceneendtime );
SetScrubTargetTime( m_bForward ? sceneendtime : 0 );
}
if ( g_viewerSettings.speedScale == 0.0f )
{
m_flLastSpeedScale = g_viewerSettings.speedScale;
m_bResetSpeedScale = true;
g_viewerSettings.speedScale = 1.0f;
Con_Printf( "Resetting speed scale to 1.0\n" );
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : x -
//-----------------------------------------------------------------------------
void CChoreoView::MoveTimeSliderToPos( int x )
{
m_flLeftOffset = (float)x;
m_pHorzScrollBar->setValue( (int)m_flLeftOffset );
InvalidateRect( (HWND)m_pHorzScrollBar->getHandle(), NULL, TRUE );
InvalidateLayout();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CChoreoView::PauseScene( void )
{
if ( !m_bSimulating )
return;
m_bPaused = true;
sound->StopAll();
}
//-----------------------------------------------------------------------------
// Purpose: Apply expression to actor's face
// Input : *event -
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
void CChoreoView::ProcessExpression( CChoreoScene *scene, CChoreoEvent *event )
{
Assert( event->GetType() == CChoreoEvent::EXPRESSION );
StudioModel *model = FindAssociatedModel( scene, event->GetActor() );
if ( !model )
return;
CStudioHdr *hdr = model->GetStudioHdr();
if ( !hdr )
{
return;
}
CExpClass *p = expressions->FindClass( event->GetParameters(), true );
if ( !p )
{
return;
}
CExpression *exp = p->FindExpression( event->GetParameters2() );
if ( !exp )
{
return;
}
CChoreoActor *a = event->GetActor();
if ( !a )
return;
CChoreoActorWidget *actor = NULL;
int i;
for ( i = 0; i < m_SceneActors.Size(); i++ )
{
actor = m_SceneActors[ i ];
if ( !actor )
continue;
if ( actor->GetActor() == a )
break;
}
if ( !actor || i >= m_SceneActors.Size() )
return;
float *settings = exp->GetSettings();
Assert( settings );
float *weights = exp->GetWeights();
Assert( weights );
float *current = actor->GetSettings();
Assert( current );
float flIntensity = event->GetIntensity( scene->GetTime() );
// blend in target values for correct actor
for ( LocalFlexController_t i = (LocalFlexController_t)0; i < hdr->numflexcontrollers(); i++ )
{
mstudioflexcontroller_t *pFlex = hdr->pFlexcontroller( i );
int j = pFlex->localToGlobal;
if ( j < 0 )
continue;
float s = clamp( weights[j] * flIntensity, 0.0, 1.0 );
current[ j ] = current[j] * (1.0f - s) + settings[ j ] * s;
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *hdr -
// *event -
//-----------------------------------------------------------------------------
void SetupFlexControllerTracks( CStudioHdr *hdr, CChoreoEvent *event )
{
Assert( hdr );
Assert( event );
if ( !hdr )
return;
if ( !event )
return;
// Already done
if ( event->GetTrackLookupSet() )
return;
/*
// FIXME: Brian hooked this stuff up for some took work, but at this point the .mdl files don't look like they've been updated to include the remapping data yet...
int c = hdr->numflexcontrollerremaps();
for ( i = 0; i < c; ++i )
{
mstudioflexcontrollerremap_t *remap = hdr->pFlexcontrollerRemap( i );
Msg( "remap %s\n", remap->pszName() );
Msg( " type %d\n", remap->remaptype );
Msg( " num remaps %d (stereo %s)\n", remap->numremaps, remap->stereo ? "true" : "false" );
for ( int j = 0 ; j < remap->numremaps; ++j )
{
int index = remap->pRemapControlIndex( j );
Msg( " %d: maps to %d (%s) with %s\n", j, index, hdr->pFlexcontroller( index )->pszName(), remap->pRemapControl( j ) );
}
}
*/
// Unlink stuff in case it doesn't exist
int nTrackCount = event->GetNumFlexAnimationTracks();
for ( int i = 0; i < nTrackCount; ++i )
{
CFlexAnimationTrack *pTrack = event->GetFlexAnimationTrack( i );
pTrack->SetFlexControllerIndex( LocalFlexController_t(-1), -1, 0 );
pTrack->SetFlexControllerIndex( LocalFlexController_t(-1), -1, 1 );
}
for ( LocalFlexController_t i = LocalFlexController_t(0); i < hdr->numflexcontrollers(); ++i )
{
int j = hdr->pFlexcontroller( i )->localToGlobal;
char const *name = hdr->pFlexcontroller( i )->pszName();
if ( !name )
continue;
bool combo = false;
// Look up or create all necessary tracks
if ( strncmp( "right_", name, 6 ) == 0 )
{
combo = true;
name = &name[6];
}
CFlexAnimationTrack *track = event->FindTrack( name );
if ( !track )
{
track = event->AddTrack( name );
Assert( track );
}
track->SetFlexControllerIndex( i, j, 0 );
if ( combo )
{
track->SetFlexControllerIndex( LocalFlexController_t(i + 1), hdr->pFlexcontroller( LocalFlexController_t(i + 1) )->localToGlobal, 1 );
track->SetComboType( true );
}
float orig_min = track->GetMin( );
float orig_max = track->GetMax( );
// set range
if (hdr->pFlexcontroller( i )->min == 0.0f || hdr->pFlexcontroller( i )->max == 1.0f)
{
track->SetInverted( false );
track->SetMin( hdr->pFlexcontroller( i )->min );
track->SetMax( hdr->pFlexcontroller( i )->max );
}
else
{
// invert ranges for wide ranged, makes sense considering flexcontroller names...
track->SetInverted( true );
track->SetMin( hdr->pFlexcontroller( i )->max );
track->SetMax( hdr->pFlexcontroller( i )->min );
}
// resample track based on this models dynamic range
if (track->GetNumSamples( 0 ) > 0)
{
float range = track->GetMax( ) - track->GetMin( );
for (int i = 0; i < track->GetNumSamples( 0 ); i++)
{
CExpressionSample *sample = track->GetSample( i, 0 );
float rangedValue = orig_min * (1 - sample->value) + orig_max * sample->value;
sample->value = clamp( (rangedValue - track->GetMin( )) / range, 0.0, 1.0 );
}
}
// skip next flex since we've already assigned it
if ( combo )
{
i++;
}
}
event->SetTrackLookupSet( true );
}
//-----------------------------------------------------------------------------
// Purpose: Apply flexanimation to actor's face
// Input : *event -
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
void CChoreoView::ProcessFlexAnimation( CChoreoScene *scene, CChoreoEvent *event )
{
Assert( event->GetType() == CChoreoEvent::FLEXANIMATION );
StudioModel *model = FindAssociatedModel( scene, event->GetActor() );
if ( !model )
return;
CStudioHdr *hdr = model->GetStudioHdr();
if ( !hdr )
{
return;
}
CChoreoActor *a = event->GetActor();
CChoreoActorWidget *actor = NULL;
int i;
for ( i = 0; i < m_SceneActors.Size(); i++ )
{
actor = m_SceneActors[ i ];
if ( !actor )
continue;
if ( !stricmp( actor->GetActor()->GetName(), a->GetName() ) )
break;
}
if ( !actor || i >= m_SceneActors.Size() )
return;
float *current = actor->GetSettings();
Assert( current );
if ( !event->GetTrackLookupSet() )
{
SetupFlexControllerTracks( hdr, event );
}
float weight = event->GetIntensity( scene->GetTime() );
CChoreoEventWidget *eventwidget = FindWidgetForEvent( event );
bool bUpdateSliders = (eventwidget && eventwidget->IsSelected() && model == models->GetActiveStudioModel() );
// Iterate animation tracks
for ( i = 0; i < event->GetNumFlexAnimationTracks(); i++ )
{
CFlexAnimationTrack *track = event->GetFlexAnimationTrack( i );
if ( !track )
continue;
// Disabled
if ( !track->IsTrackActive() )
{
if ( bUpdateSliders )
{
for ( int side = 0; side < 1 + track->IsComboType(); side++ )
{
int controller = track->GetFlexControllerIndex( side );
if ( controller != -1 && !g_pFlexPanel->IsEdited( controller ))
{
g_pFlexPanel->SetSlider( controller, 0.0 );
g_pFlexPanel->SetInfluence( controller, 0.0f );
}
}
}
continue;
}
// Map track flex controller to global name
if ( track->IsComboType() )
{
for ( int side = 0; side < 2; side++ )
{
int controller = track->GetFlexControllerIndex( side );
if ( controller != -1 )
{
// Get spline intensity for controller
float flIntensity = track->GetIntensity( scene->GetTime(), side );
if (bUpdateSliders && !g_pFlexPanel->IsEdited( controller ) )
{
g_pFlexPanel->SetSlider( controller, flIntensity );
g_pFlexPanel->SetInfluence( controller, 1.0f );
}
flIntensity = current[ controller ] * (1 - weight) + flIntensity * weight;
current[ controller ] = flIntensity;
}
}
}
else
{
int controller = track->GetFlexControllerIndex( 0 );
if ( controller != -1 )
{
// Get spline intensity for controller
float flIntensity = track->GetIntensity( scene->GetTime(), 0 );
if (bUpdateSliders && !g_pFlexPanel->IsEdited( controller ) )
{
g_pFlexPanel->SetSlider( controller, flIntensity );
g_pFlexPanel->SetInfluence( controller, 1.0f );
}
flIntensity = current[ controller ] * (1 - weight) + flIntensity * weight;
current[ controller ] = flIntensity;
}
}
}
}
#include "mapentities.h"
//-----------------------------------------------------------------------------
// Purpose: Apply lookat target
// Input : *event -
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
void CChoreoView::ProcessLookat( CChoreoScene *scene, CChoreoEvent *event )
{
Assert( event->GetType() == CChoreoEvent::LOOKAT );
if ( !event->GetActor() )
return;
CChoreoActor *a = event->GetActor();
Assert( a );
StudioModel *model = FindAssociatedModel( scene, a );
if ( !model )
{
return;
}
float flIntensity = event->GetIntensity( scene->GetTime() );
// clamp in-ramp to 0.3 seconds
float flDuration = scene->GetTime() - event->GetStartTime();
float flMaxIntensity = flDuration < 0.3f ? SimpleSpline( flDuration / 0.3f ) : 1.0f;
flDuration = event->GetEndTime() - scene->GetTime();
flMaxIntensity = min( flMaxIntensity, flDuration < 0.3f ? SimpleSpline( flDuration / 0.3f ) : 1.0f );
flIntensity = clamp( flIntensity, 0.0f, flMaxIntensity );
if (!stricmp( event->GetParameters(), a->GetName() ) || !stricmp( event->GetParameters(), "!self" ))
{
model->AddLookTargetSelf( flIntensity );
}
else if ( !stricmp( event->GetParameters(), "player" ) ||
!stricmp( event->GetParameters(), "!player" ) )
{
Vector vecTarget = model->m_origin;
vecTarget.z = 0;
model->AddLookTarget( vecTarget, flIntensity );
}
else
{
mapentities->CheckUpdateMap( scene->GetMapname() );
Vector orgActor;
Vector orgTarget;
QAngle anglesActor;
QAngle anglesDummy;
if ( event->GetPitch() != 0 ||
event->GetYaw() != 0 )
{
QAngle angles( -(float)event->GetPitch(),
(float)event->GetYaw(),
0 );
matrix3x4_t matrix;
AngleMatrix( model->m_angles, matrix );
Vector vecForward;
AngleVectors( angles, &vecForward );
Vector eyeTarget;
VectorRotate( vecForward, matrix, eyeTarget );
VectorScale( eyeTarget, 75, eyeTarget );
model->AddLookTarget( eyeTarget, flIntensity );
}
else
{
if ( mapentities->LookupOrigin( a->GetName(), orgActor, anglesActor ) )
{
if ( mapentities->LookupOrigin( event->GetParameters(), orgTarget, anglesDummy ) )
{
Vector delta = orgTarget - orgActor;
matrix3x4_t matrix;
Vector lookTarget;
// Rotate around actor's placed forward direction since we look straight down x in faceposer/hlmv
AngleMatrix( anglesActor, matrix );
VectorIRotate( delta, matrix, lookTarget );
model->AddLookTarget( lookTarget, flIntensity );
return;
}
}
// hack up something based on the name.
{
const char *cp = event->GetParameters();
float value = 0.0;
while (*cp)
{
value += *cp++;
}
value = cos( value );
value = acos( value );
QAngle angles( 0.0, value * 45 / M_PI, 0.0 );
matrix3x4_t matrix;
AngleMatrix( model->m_angles, matrix );
Vector vecForward;
AngleVectors( angles, &vecForward );
Vector eyeTarget;
VectorRotate( vecForward, matrix, eyeTarget );
VectorScale( eyeTarget, 75, eyeTarget );
model->AddLookTarget( eyeTarget, flIntensity );
}
}
}
}
//-----------------------------------------------------------------------------
// Purpose: Returns a target for Faceing
// Input : *event -
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CChoreoView::GetTarget( CChoreoScene *scene, CChoreoEvent *event, Vector &vecTarget, QAngle &vecAngle )
{
if ( !event->GetActor() )
return false;
CChoreoActor *a = event->GetActor();
Assert( a );
StudioModel *model = FindAssociatedModel( scene, a );
if ( !model )
{
return false;
}
if (!stricmp( event->GetParameters(), a->GetName() ))
{
vecTarget = vec3_origin;
return true;
}
else if ( !stricmp( event->GetParameters(), "player" ) ||
!stricmp( event->GetParameters(), "!player" ) )
{
vecTarget = model->m_origin;
vecTarget.z = 0;
vecAngle = model->m_angles;
return true;
}
else
{
mapentities->CheckUpdateMap( scene->GetMapname() );
Vector orgActor;
Vector orgTarget;
QAngle anglesActor;
QAngle anglesDummy;
if ( event->GetPitch() != 0 ||
event->GetYaw() != 0 )
{
QAngle angles( -(float)event->GetPitch(),
(float)event->GetYaw(),
0 );
matrix3x4_t matrix;
AngleMatrix( model->m_angles, matrix );
QAngle angles2 = angles;
angles2.x *= 0.6f;
angles2.y *= 0.8f;
Vector vecForward, vecForward2;
AngleVectors( angles, &vecForward );
AngleVectors( angles2, &vecForward2 );
VectorNormalize( vecForward );
VectorNormalize( vecForward2 );
Vector eyeTarget, headTarget;
VectorRotate( vecForward, matrix, eyeTarget );
VectorRotate( vecForward2, matrix, headTarget );
VectorScale( eyeTarget, 150, eyeTarget );
VectorScale( headTarget, 150, vecTarget );
return true;
}
else
{
if ( mapentities->LookupOrigin( a->GetName(), orgActor, anglesActor ) )
{
if ( mapentities->LookupOrigin( event->GetParameters(), orgTarget, anglesDummy ) )
{
Vector delta = orgTarget - orgActor;
matrix3x4_t matrix;
Vector lookTarget;
// Rotate around actor's placed forward direction since we look straight down x in faceposer/hlmv
AngleMatrix( anglesActor, matrix );
VectorIRotate( delta, matrix, vecTarget );
return true;
}
}
}
}
return false;
}
//-----------------------------------------------------------------------------
// Purpose: Apply lookat target
// Input : *event -
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
void CChoreoView::ProcessFace( CChoreoScene *scene, CChoreoEvent *event )
{
Assert( event->GetType() == CChoreoEvent::FACE );
if ( !event->GetActor() )
return;
CChoreoActor *a = event->GetActor();
Assert( a );
StudioModel *model = FindAssociatedModel( scene, a );
if ( !model )
{
return;
}
Vector vecTarget;
QAngle vecAngle;
if (!GetTarget( scene, event, vecTarget, vecAngle ))
{
return;
}
/*
// FIXME: this is broke
float goalYaw = -(vecAngle.y > 180 ? 360 - vecAngle.y : vecAngle.y );
float intensity = event->GetIntensity( scene->GetTime() );
float diff = goalYaw * intensity;
float dir = 1.0;
if (diff < 0)
{
diff = -diff;
dir = -1;
}
float spineintensity = 0 * max( 0.0, (intensity - 0.5) / 0.5 );
float goalSpineYaw = min( diff * (1.0 - spineintensity), 30 );
//float idealYaw = info->m_flInitialYaw + (diff - m_goalBodyYaw * dir - m_goalSpineYaw * dir) * dir;
// float idealYaw = UTIL_AngleMod( info->m_flInitialYaw + diff * intensity );
// FIXME: this is broke
// model->SetSpineYaw( goalSpineYaw * dir);
// model->SetBodyYaw( goalBodyYaw * dir );
// Msg("yaw %.1f : %.1f (%.1f)\n", info->m_flInitialYaw, idealYaw, intensity );
*/
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *scene -
// *event -
//-----------------------------------------------------------------------------
void CChoreoView::ProcessLoop( CChoreoScene *scene, CChoreoEvent *event )
{
Assert( event->GetType() == CChoreoEvent::LOOP );
// Don't loop when dragging scrubber!
if ( IsScrubbing() )
return;
float backtime = (float)atof( event->GetParameters() );
bool process = true;
int counter = event->GetLoopCount();
if ( counter != -1 )
{
int remaining = event->GetNumLoopsRemaining();
if ( remaining <= 0 )
{
process = false;
}
else
{
event->SetNumLoopsRemaining( --remaining );
}
}
if ( !process )
return;
scene->LoopToTime( backtime );
SetScrubTime( backtime );
}
//-----------------------------------------------------------------------------
// Purpose: Add a gesture layer
// Input : *event -
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
void CChoreoView::ProcessGesture( CChoreoScene *scene, CChoreoEvent *event )
{
Assert( event->GetType() == CChoreoEvent::GESTURE );
// NULL event is just a placeholder
if ( !Q_stricmp( event->GetName(), "NULL" ) )
{
return;
}
StudioModel *model = FindAssociatedModel( scene, event->GetActor() );
if ( !model )
return;
if ( !event->GetActor() )
return;
CChoreoActor *a = event->GetActor();
Assert( a );
int iSequence = model->LookupSequence( event->GetParameters() );
if (iSequence < 0)
return;
// Get spline intensity for controller
float eventlocaltime = scene->GetTime() - event->GetStartTime();
float referencetime = event->GetOriginalPercentageFromPlaybackPercentage( eventlocaltime / event->GetDuration() ) * event->GetDuration();
float resampledtime = event->GetStartTime() + referencetime;
float cycle = event->GetCompletion( resampledtime );
int iLayer = model->GetNewAnimationLayer( a->FindChannelIndex( event->GetChannel() ) );
model->SetOverlaySequence( iLayer, iSequence, event->GetIntensity( scene->GetTime() ) );
model->SetOverlayRate( iLayer, cycle, 0.0 );
}
//-----------------------------------------------------------------------------
// Purpose: Apply a sequence
// Input : *event -
//-----------------------------------------------------------------------------
void CChoreoView::ProcessSequence( CChoreoScene *scene, CChoreoEvent *event )
{
Assert( event->GetType() == CChoreoEvent::SEQUENCE );
if ( !m_bProcessSequences )
{
return;
}
StudioModel *model = FindAssociatedModel( scene, event->GetActor() );
if ( !model )
return;
if ( !event->GetActor() )
return;
CChoreoActor *a = event->GetActor();
Assert( a );
int iSequence = model->LookupSequence( event->GetParameters() );
if (iSequence < 0)
return;
float flFrameRate;
float flGroundSpeed;
model->GetSequenceInfo( iSequence, &flFrameRate, &flGroundSpeed );
float cycle;
bool looping = model->GetSequenceLoops( iSequence );
if (looping)
{
float dt = scene->GetTime() - event->m_flPrevTime;
event->m_flPrevTime = scene->GetTime();
dt = clamp( dt, 0.0, 0.1 );
cycle = event->m_flPrevCycle + flFrameRate * dt;
cycle = cycle - (int)cycle;
event->m_flPrevCycle = cycle;
}
else
{
float dt = scene->GetTime() - event->GetStartTime();
cycle = flFrameRate * dt;
cycle = cycle - (int)(cycle);
}
// FIXME: shouldn't sequences always be lower priority than gestures?
int iLayer = model->GetNewAnimationLayer( a->FindChannelIndex( event->GetChannel() ) );
model->SetOverlaySequence( iLayer, iSequence, event->GetIntensity( scene->GetTime() ) );
model->SetOverlayRate( iLayer, cycle, 0.0 );
}
//-----------------------------------------------------------------------------
// Purpose: Apply a walking animation
// Input : *event -
//-----------------------------------------------------------------------------
void CChoreoView::ProcessMoveto( CChoreoScene *scene, CChoreoEvent *event )
{
Assert( event->GetType() == CChoreoEvent::MOVETO );
if ( !m_bProcessSequences )
{
return;
}
StudioModel *model = FindAssociatedModel( scene, event->GetActor() );
if ( !model )
return;
if ( !event->GetActor() )
return;
int iSequence = GetMovetoSequence( scene, event, model );
if (iSequence < 0)
return;
float flFrameRate;
float flGroundSpeed;
model->GetSequenceInfo( iSequence, &flFrameRate, &flGroundSpeed );
float dt = scene->GetTime() - event->GetStartTime();
float cycle = flFrameRate * dt;
cycle = cycle - (int)(cycle);
float idealAccel = 100;
// accel to ideal
float t1 = flGroundSpeed / idealAccel;
float intensity = 1.0;
if (dt < t1)
{
intensity = dt / t1;
}
else if (event->GetDuration() - dt < t1)
{
intensity = (event->GetDuration() - dt) / t1;
}
// movement should always be higher priority than postures, but not gestures....grrr, any way to tell them apart?
int iLayer = model->GetNewAnimationLayer( 0 /* a->FindChannelIndex( event->GetChannel() ) */ );
model->SetOverlaySequence( iLayer, iSequence, intensity );
model->SetOverlayRate( iLayer, cycle, 0.0 );
}
int CChoreoView::GetMovetoSequence( CChoreoScene *scene, CChoreoEvent *event, StudioModel *model )
{
// FIXME: needs to pull from event (activity or sequence?)
if ( !event->GetParameters2() || !event->GetParameters2()[0] )
return model->LookupSequence( "walk_all" );
// Custom distance styles are appended to param2 with a space as a separator
const char *pszAct = Q_strstr( event->GetParameters2(), " " );
if ( pszAct )
{
char szActName[256];
Q_strncpy( szActName, event->GetParameters2(), sizeof(szActName) );
szActName[ (pszAct-event->GetParameters2()) ] = '\0';
pszAct = szActName;
}
else
{
pszAct = event->GetParameters2();
}
if ( !Q_strcmp( pszAct, "Walk" ) )
{
pszAct = "ACT_WALK";
}
else if ( !Q_strcmp( pszAct, "Run" ) )
{
pszAct = "ACT_RUN";
}
else if ( !Q_strcmp( pszAct, "CrouchWalk" ) )
{
pszAct = "ACT_WALK_CROUCH";
}
int iSequence = model->LookupActivity( pszAct );
if (iSequence == -1)
{
return model->LookupSequence( "walk_all" );
}
return iSequence;
}
//-----------------------------------------------------------------------------
// Purpose: Process a pause event
// Input : *event -
//-----------------------------------------------------------------------------
void CChoreoView::ProcessPause( CChoreoScene *scene, CChoreoEvent *event )
{
Assert( event->GetType() == CChoreoEvent::SECTION );
// Don't pause if scrubbing
bool scrubbing = ( m_nDragType == DRAGTYPE_SCRUBBER ) ? true : false;
if ( scrubbing )
return;
PauseScene();
m_bAutomated = false;
m_nAutomatedAction = SCENE_ACTION_UNKNOWN;
m_flAutomationDelay = 0.0f;
m_flAutomationTime = 0.0f;
// Check for auto resume/cancel
ParseFromMemory( (char *)event->GetParameters(), strlen( event->GetParameters() ) );
if ( tokenprocessor->TokenAvailable() )
{
tokenprocessor->GetToken( false );
if ( !stricmp( tokenprocessor->CurrentToken(), "automate" ) )
{
if ( tokenprocessor->TokenAvailable() )
{
tokenprocessor->GetToken( false );
if ( !stricmp( tokenprocessor->CurrentToken(), "Cancel" ) )
{
m_nAutomatedAction = SCENE_ACTION_CANCEL;
}
else if ( !stricmp( tokenprocessor->CurrentToken(), "Resume" ) )
{
m_nAutomatedAction = SCENE_ACTION_RESUME;
}
if ( tokenprocessor->TokenAvailable() &&
m_nAutomatedAction != SCENE_ACTION_UNKNOWN )
{
tokenprocessor->GetToken( false );
m_flAutomationDelay = (float)atof( tokenprocessor->CurrentToken() );
if ( m_flAutomationDelay > 0.0f )
{
// Success
m_bAutomated = true;
m_flAutomationTime = 0.0f;
}
}
}
}
}
}
//-----------------------------------------------------------------------------
// Purpose: Main event processor
// Input : *event -
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
void CChoreoView::ProcessEvent( float currenttime, CChoreoScene *scene, CChoreoEvent *event )
{
if ( !event || !event->GetActive() )
return;
CChoreoActor *actor = event->GetActor();
if ( actor && !actor->GetActive() )
{
return;
}
CChoreoChannel *channel = event->GetChannel();
if ( channel && !channel->GetActive() )
{
return;
}
switch( event->GetType() )
{
case CChoreoEvent::EXPRESSION:
ProcessExpression( scene, event );
break;
case CChoreoEvent::FLEXANIMATION:
ProcessFlexAnimation( scene, event );
break;
case CChoreoEvent::LOOKAT:
ProcessLookat( scene, event );
break;
case CChoreoEvent::FACE:
ProcessFace( scene, event );
break;
case CChoreoEvent::GESTURE:
ProcessGesture( scene, event );
break;
case CChoreoEvent::SEQUENCE:
ProcessSequence( scene, event );
break;
case CChoreoEvent::SUBSCENE:
ProcessSubscene( scene, event );
break;
case CChoreoEvent::SPEAK:
ProcessSpeak( scene, event );
break;
case CChoreoEvent::MOVETO:
ProcessMoveto( scene, event );
break;
case CChoreoEvent::STOPPOINT:
// Nothing
break;
case CChoreoEvent::INTERRUPT:
ProcessInterrupt( scene, event );
break;
case CChoreoEvent::PERMIT_RESPONSES:
ProcessPermitResponses( scene, event );
break;
default:
break;
}
}
//-----------------------------------------------------------------------------
// Purpose: Main event completion checker
// Input : *event -
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CChoreoView::CheckEvent( float currenttime, CChoreoScene *scene, CChoreoEvent *event )
{
if ( !event || !event->GetActive() )
return true;
CChoreoActor *actor = event->GetActor();
if ( actor && !actor->GetActive() )
{
return true;
}
CChoreoChannel *channel = event->GetChannel();
if ( channel && !channel->GetActive() )
{
return true;
}
switch( event->GetType() )
{
case CChoreoEvent::EXPRESSION:
break;
case CChoreoEvent::FLEXANIMATION:
break;
case CChoreoEvent::LOOKAT:
break;
case CChoreoEvent::GESTURE:
break;
case CChoreoEvent::SEQUENCE:
break;
case CChoreoEvent::SUBSCENE:
break;
case CChoreoEvent::SPEAK:
break;
case CChoreoEvent::MOVETO:
break;
case CChoreoEvent::INTERRUPT:
break;
case CChoreoEvent::PERMIT_RESPONSES:
break;
default:
break;
}
return true;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CChoreoView::PauseThink( void )
{
// FIXME: Game code would check for conditions being met
if ( !m_bAutomated )
return;
m_flAutomationTime += fabs( m_flFrameTime );
RECT rcPauseRect;
rcPauseRect.left = 0;
rcPauseRect.right = w2();
rcPauseRect.top = GetCaptionHeight() + SCRUBBER_HEIGHT;
rcPauseRect.bottom = rcPauseRect.top + 10;
CChoreoWidgetDrawHelper drawHelper( this,
rcPauseRect,
COLOR_CHOREO_BACKGROUND );
DrawSceneABTicks( drawHelper );
if ( m_flAutomationDelay > 0.0f &&
m_flAutomationTime < m_flAutomationDelay )
{
char sz[ 256 ];
sprintf( sz, "Pause %.2f/%.2f", m_flAutomationTime, m_flAutomationDelay );
int textlen = drawHelper.CalcTextWidth( "Arial", 9, FW_NORMAL, sz );
RECT rcText;
GetScrubHandleRect( rcText, true );
rcText.left = ( rcText.left + rcText.right ) / 2;
rcText.left -= ( textlen * 0.5f );
rcText.right = rcText.left + textlen + 1;
rcText.top = rcPauseRect.top;
rcText.bottom = rcPauseRect.bottom;
drawHelper.DrawColoredText( "Arial", 9, FW_NORMAL, COLOR_CHOREO_PLAYBACKTICKTEXT, rcText, sz );
return;
}
// Time to act
m_bAutomated = false;
switch ( m_nAutomatedAction )
{
case SCENE_ACTION_RESUME:
m_bPaused = false;
sound->StopAll();
break;
case SCENE_ACTION_CANCEL:
FinishSimulation();
break;
default:
break;
}
m_nAutomatedAction = SCENE_ACTION_UNKNOWN;
m_flAutomationTime = 0.0f;
m_flAutomationDelay = 0.0f;
}
//-----------------------------------------------------------------------------
// Purpose: Conclude simulation
//-----------------------------------------------------------------------------
void CChoreoView::FinishSimulation( void )
{
if ( !m_bSimulating )
return;
// m_pScene->ResetSimulation();
m_bSimulating = false;
m_bPaused = false;
sound->StopAll();
if ( m_bResetSpeedScale )
{
m_bResetSpeedScale = false;
g_viewerSettings.speedScale = m_flLastSpeedScale;
m_flLastSpeedScale = 0.0f;
Con_Printf( "Resetting speed scale to %f\n", m_flLastSpeedScale );
}
models->ClearOverlaysSequences();
// redraw();
}
void CChoreoView::SceneThink( float time )
{
if ( !m_pScene )
return;
if ( m_bSimulating )
{
if ( m_bPaused )
{
PauseThink();
}
else
{
m_pScene->SetSoundFileStartupLatency( 0.0f );
models->CheckResetFlexes();
ResetTargetSettings();
models->ClearOverlaysSequences();
// Tell scene to go
m_pScene->Think( time );
// Move flexes toward their targets
UpdateCurrentSettings();
}
}
else
{
FinishSimulation();
}
if ( !ShouldProcessSpeak() )
{
bool autoprocess = ShouldAutoProcess();
bool anyscrub = IsAnyToolScrubbing() ;
bool anyprocessing = IsAnyToolProcessing();
//Con_Printf( "autoprocess %i anyscrub %i anyprocessing %i\n",
// autoprocess ? 1 : 0,
// anyscrub ? 1 : 0,
// anyprocessing ? 1 : 0 );
if ( !anyscrub &&
!anyprocessing &&
autoprocess &&
!m_bForceProcess )
{
sound->StopAll();
// why clear lookat?
//models->ClearModelTargets( false );
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CChoreoView::LayoutScene( void )
{
if ( !m_pScene )
return;
if ( m_bLayoutIsValid )
return;
m_pScene->ReconcileTags();
RECT rc;
GetClientRect( (HWND)getHandle(), &rc );
RECT rcClient = rc;
rcClient.top += GetStartRow();
OffsetRect( &rcClient, 0, -m_nTopOffset );
m_flStartTime = m_flLeftOffset / GetPixelsPerSecond();
m_flEndTime = m_flStartTime + (float)( rcClient.right - GetLabelWidth() ) / GetPixelsPerSecond();
m_rcTimeLine = rcClient;
m_rcTimeLine.top = GetCaptionHeight() + SCRUBBER_HEIGHT;
m_rcTimeLine.bottom = m_rcTimeLine.top + 44;
int currentRow = rcClient.top + 2;
int itemHeight;
// Draw actors
int i;
for ( i = 0; i < m_SceneActors.Size(); i++ )
{
CChoreoActorWidget *a = m_SceneActors[ i ];
Assert( a );
if ( !a )
{
continue;
}
// Figure out rectangle
itemHeight = a->GetItemHeight();
RECT rcActor = rcClient;
rcActor.top = currentRow;
rcActor.bottom = currentRow + itemHeight;
a->Layout( rcActor );
currentRow += itemHeight;
}
// Draw section tabs
for ( i = 0; i < m_SceneGlobalEvents.Size(); i++ )
{
CChoreoGlobalEventWidget *e = m_SceneGlobalEvents[ i ];
if ( !e )
continue;
RECT rcEvent;
rcEvent = m_rcTimeLine;
float frac = ( e->GetEvent()->GetStartTime() - m_flStartTime ) / ( m_flEndTime - m_flStartTime );
rcEvent.left = GetLabelWidth() + rcEvent.left + (int)( frac * ( m_rcTimeLine.right - m_rcTimeLine.left - GetLabelWidth() ) );
rcEvent.left -= 4;
rcEvent.right = rcEvent.left + 8;
rcEvent.bottom += 0;
rcEvent.top = rcEvent.bottom - 8;
if ( rcEvent.left + 10 < GetLabelWidth() )
{
e->setVisible( false );
}
else
{
e->setVisible( true );
}
// OffsetRect( &rcEvent, GetLabelWidth(), 0 );
e->Layout( rcEvent );
}
m_bLayoutIsValid = true;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CChoreoView::DeleteSceneWidgets( void )
{
bool oldcandraw = m_bCanDraw;
m_bCanDraw = false;
int i;
CChoreoWidget *w;
ClearStatusArea();
for( i = 0 ; i < m_SceneActors.Size(); i++ )
{
w = m_SceneActors[ i ];
m_ActorExpanded[ i ].expanded = ((CChoreoActorWidget *)w)->GetShowChannels();
delete w;
}
m_SceneActors.RemoveAll();
for( i = 0 ; i < m_SceneGlobalEvents.Size(); i++ )
{
w = m_SceneGlobalEvents[ i ];
delete w;
}
m_SceneGlobalEvents.RemoveAll();
m_bCanDraw = oldcandraw;
// Make sure nobody is still pointing at us
m_pClickedActor = NULL;
m_pClickedChannel = NULL;
m_pClickedEvent = NULL;
m_pClickedGlobalEvent = NULL;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CChoreoView::InvalidateLayout( void )
{
if ( m_bSuppressLayout )
return;
if ( ComputeHPixelsNeeded() != m_nLastHPixelsNeeded )
{
RepositionHSlider();
}
if ( ComputeVPixelsNeeded() != m_nLastVPixelsNeeded )
{
RepositionVSlider();
}
// Recheck gesture start/end times
if ( m_pScene )
{
m_pScene->ReconcileGestureTimes();
m_pScene->ReconcileCloseCaption();
}
m_bLayoutIsValid = false;
redraw();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CChoreoView::CreateSceneWidgets( void )
{
DeleteSceneWidgets();
m_bSuppressLayout = true;
int i;
for ( i = 0; i < m_pScene->GetNumActors(); i++ )
{
CChoreoActor *a = m_pScene->GetActor( i );
Assert( a );
if ( !a )
continue;
CChoreoActorWidget *actorWidget = new CChoreoActorWidget( NULL );
Assert( actorWidget );
actorWidget->SetActor( a );
actorWidget->Create();
m_SceneActors.AddToTail( actorWidget );
actorWidget->ShowChannels( m_ActorExpanded[ i ].expanded );
}
// Find global events
for ( i = 0; i < m_pScene->GetNumEvents(); i++ )
{
CChoreoEvent *e = m_pScene->GetEvent( i );
if ( !e || e->GetActor() )
continue;
CChoreoGlobalEventWidget *eventWidget = new CChoreoGlobalEventWidget( NULL );
Assert( eventWidget );
eventWidget->SetEvent( e );
eventWidget->Create();
m_SceneGlobalEvents.AddToTail( eventWidget );
}
m_bSuppressLayout = false;
}
//-----------------------------------------------------------------------------
// Purpose:
// Output : int
//-----------------------------------------------------------------------------
int CChoreoView::GetLabelWidth( void )
{
return m_nLabelWidth;
}
//-----------------------------------------------------------------------------
// Purpose:
// Output : int
//-----------------------------------------------------------------------------
int CChoreoView::GetStartRow( void )
{
return m_nStartRow + GetCaptionHeight() + SCRUBBER_HEIGHT;
}
//-----------------------------------------------------------------------------
// Purpose:
// Output : int
//-----------------------------------------------------------------------------
int CChoreoView::GetRowHeight( void )
{
return m_nRowHeight;
}
//-----------------------------------------------------------------------------
// Purpose:
// Output : int
//-----------------------------------------------------------------------------
int CChoreoView::GetFontSize( void )
{
return m_nFontSize;
}
//-----------------------------------------------------------------------------
// Purpose:
// Output : int
//-----------------------------------------------------------------------------
int CChoreoView::ComputeVPixelsNeeded( void )
{
int pixels = 0;
for ( int i = 0; i < m_SceneActors.Size(); i++ )
{
CChoreoActorWidget *actor = m_SceneActors[ i ];
if ( !actor )
continue;
pixels += actor->GetItemHeight() + 2;
}
pixels += GetStartRow() + 15;
// pixels += m_nInfoHeight;
//pixels += 30;
return pixels;
}
//-----------------------------------------------------------------------------
// Purpose:
// Output : int
//-----------------------------------------------------------------------------
int CChoreoView::ComputeHPixelsNeeded( void )
{
if ( !m_pScene )
{
return 0;
}
int pixels = 0;
float maxtime = m_pScene->FindStopTime();
if ( maxtime < 5.0 )
{
maxtime = 5.0f;
}
pixels = (int)( ( maxtime + 5.0 ) * GetPixelsPerSecond() );
return pixels;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CChoreoView::RepositionVSlider( void )
{
int pixelsneeded = ComputeVPixelsNeeded();
if ( pixelsneeded <= ( h2() - GetStartRow() ))
{
m_pVertScrollBar->setVisible( false );
m_nTopOffset = 0;
}
else
{
m_pVertScrollBar->setVisible( true );
}
m_pVertScrollBar->setBounds( w2() - m_nScrollbarHeight, GetStartRow(), m_nScrollbarHeight, h2() - m_nScrollbarHeight - GetStartRow() );
//int visiblepixels = h2() - m_nScrollbarHeight - GetStartRow();
//m_nTopOffset = min( pixelsneeded - visiblepixels, m_nTopOffset );
m_nTopOffset = max( 0, m_nTopOffset );
m_nTopOffset = min( pixelsneeded, m_nTopOffset );
m_pVertScrollBar->setRange( 0, pixelsneeded );
m_pVertScrollBar->setValue( m_nTopOffset );
m_pVertScrollBar->setPagesize( h2() - GetStartRow() );
m_nLastVPixelsNeeded = pixelsneeded;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CChoreoView::RepositionHSlider( void )
{
int pixelsneeded = ComputeHPixelsNeeded();
int w = w2();
int lw = GetLabelWidth();
if ( pixelsneeded <= ( w - lw ) )
{
m_pHorzScrollBar->setVisible( false );
}
else
{
m_pHorzScrollBar->setVisible( true );
}
m_pHorzScrollBar->setBounds( 0, h2() - m_nScrollbarHeight, w - m_nScrollbarHeight, m_nScrollbarHeight );
m_flLeftOffset = max( 0.f, m_flLeftOffset );
m_flLeftOffset = min( (float)pixelsneeded, m_flLeftOffset );
m_pHorzScrollBar->setRange( 0, pixelsneeded );
m_pHorzScrollBar->setValue( (int)m_flLeftOffset );
m_pHorzScrollBar->setPagesize(w - lw );
m_nLastHPixelsNeeded = pixelsneeded;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : dirty -
//-----------------------------------------------------------------------------
void CChoreoView::SetDirty( bool dirty, bool clearundo /*=true*/ )
{
bool changed = dirty != m_bDirty;
m_bDirty = dirty;
if ( !dirty && clearundo )
{
WipeUndo();
redraw();
}
if ( changed )
{
SetPrefix( m_bDirty ? "* " : "" );
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CChoreoView::New( void )
{
if ( m_pScene )
{
Close( );
if ( m_pScene )
{
return;
}
}
char scenefile[ 512 ];
if ( FacePoser_ShowSaveFileNameDialog( scenefile, sizeof( scenefile ), "scenes", "*.vcd" ) )
{
Q_DefaultExtension( scenefile, ".vcd", sizeof( scenefile ) );
m_pScene = new CChoreoScene( this );
g_MDLViewer->InitGridSettings();
SetChoreoFile( scenefile );
m_pScene->SetPrintFunc( Con_Printf );
ShowButtons( true );
SetDirty( false );
}
if ( !m_pScene )
return;
// Get first actor name
CActorParams params;
memset( &params, 0, sizeof( params ) );
strcpy( params.m_szDialogTitle, "Create Actor" );
strcpy( params.m_szName, "" );
if ( !ActorProperties( &params ) )
return;
if ( strlen( params.m_szName ) <= 0 )
return;
SetDirty( true );
PushUndo( "Create Actor" );
Con_Printf( "Creating scene %s with actor '%s'\n", GetChoreoFile(), params.m_szName );
CChoreoActor *actor = m_pScene->AllocActor();
if ( actor )
{
actor->SetName( params.m_szName );
}
PushRedo( "Create Actor" );
CreateSceneWidgets();
// Redraw
InvalidateLayout();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CChoreoView::Save( void )
{
if ( !m_pScene )
return;
if ( !MakeFileWriteablePrompt( GetChoreoFile(), "VCD File" ) )
{
Con_Printf( "Not saving changes to %s\n", GetChoreoFile() );
return;
}
Con_Printf( "Saving changes to %s\n", GetChoreoFile() );
CP4AutoEditAddFile checkout( GetChoreoFile() );
if ( !m_pScene->SaveToFile( GetChoreoFile() ) )
{
mxMessageBox( this, va( "Unable to write \"%s\"", GetChoreoFile() ),
"SaveToFile", MX_MB_OK | MX_MB_ERROR );
}
g_MDLViewer->OnVCDSaved();
// Refresh the suffix
SetChoreoFile( GetChoreoFile() );
SetDirty( false, false );
redraw();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CChoreoView::SaveAs( void )
{
if ( !m_pScene )
return;
char scenefile[ 512 ];
if ( !FacePoser_ShowSaveFileNameDialog( scenefile, sizeof( scenefile ), "scenes", "*.vcd" ) )
return;
Q_DefaultExtension( scenefile, ".vcd", sizeof( scenefile ) );
Con_Printf( "Saving %s\n", scenefile );
MakeFileWriteable( scenefile );
// Change filename
SetChoreoFile( scenefile );
// Write it out baby
CP4AutoEditAddFile checkout( scenefile );
if (!m_pScene->SaveToFile( GetChoreoFile() ))
{
mxMessageBox( this, va( "Unable to write \"%s\"", GetChoreoFile() ),
"SaveToFile", MX_MB_OK | MX_MB_ERROR );
}
g_MDLViewer->OnVCDSaved();
SetDirty( false, false );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CChoreoView::Load( void )
{
char scenefile[ 512 ];
if ( !FacePoser_ShowOpenFileNameDialog( scenefile, sizeof( scenefile ), "scenes", "*.vcd" ) )
{
return;
}
Q_DefaultExtension( scenefile, ".vcd", sizeof( scenefile ) );
LoadSceneFromFile( scenefile );
m_nextFileList.RemoveAll();
}
void CChoreoView::LoadNext( void )
{
if (GetChoreoFile() == NULL)
return;
char fixedupFile[ 512 ];
V_FixupPathName( fixedupFile, sizeof( fixedupFile ), GetChoreoFile() );
char relativeFile[ 512 ];
filesystem->FullPathToRelativePath( fixedupFile, relativeFile, sizeof( relativeFile ) );
char relativePath[ 512 ];
Q_ExtractFilePath( relativeFile, relativePath, sizeof( relativePath ) );
if (m_nextFileList.Count() == 0)
{
// iterate files in the local directory
char path[ 512 ];
strcpy( path, relativePath );
strcat( path, "/*.vcd" );
FileFindHandle_t hFindFile;
char const *fn = filesystem->FindFirstEx( path, "MOD", &hFindFile );
if ( fn )
{
while ( fn )
{
// Don't do anything with directories
if ( !filesystem->FindIsDirectory( hFindFile ) )
{
CUtlString s = fn;
m_nextFileList.AddToTail( s );
}
fn = filesystem->FindNext( hFindFile );
}
filesystem->FindClose( hFindFile );
}
}
// look for a match, then pick the next in the list
const char *fileBase;
fileBase = V_UnqualifiedFileName( fixedupFile );
for (int i = 0; i < m_nextFileList.Count(); i++)
{
if (!stricmp( fileBase, m_nextFileList[i] ))
{
char fileName[512];
strcpy( fileName, relativePath );
if (i < m_nextFileList.Count() - 1)
{
strcat( fileName, m_nextFileList[i+1] );
}
else
{
strcat( fileName, m_nextFileList[0] );
}
LoadSceneFromFile( fileName );
break;
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *filename -
//-----------------------------------------------------------------------------
void CChoreoView::LoadSceneFromFile( const char *filename )
{
if ( filename[ 0 ] == '/' ||
filename[ 0 ] == '\\' )
{
++filename;
}
char fn[ 512 ];
Q_strncpy( fn, filename, sizeof( fn ) );
if ( m_pScene )
{
Close();
if ( m_pScene )
{
return;
}
}
m_pScene = LoadScene( fn );
g_MDLViewer->InitGridSettings();
if ( !m_pScene )
return;
g_MDLViewer->OnFileLoaded( fn );
ShowButtons( true );
CChoreoWidget::m_pScene = m_pScene;
SetChoreoFile( fn );
bool cleaned = FixupSequenceDurations( m_pScene, false );
SetDirty( cleaned );
DeleteSceneWidgets();
CreateSceneWidgets();
// Force scroll bars to recompute
ForceScrollBarsToRecompute( false );
InvalidateLayout();
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : closing -
//-----------------------------------------------------------------------------
void CChoreoView::UnloadScene( void )
{
InvalidateLayout();
ReportSceneClearToTools();
ClearStatusArea();
delete m_pScene;
m_pScene = NULL;
SetDirty( false );
SetChoreoFile( "" );
g_MDLViewer->InitGridSettings();
CChoreoWidget::m_pScene = NULL;
DeleteSceneWidgets();
m_pVertScrollBar->setVisible( false );
m_pHorzScrollBar->setVisible( false );
ShowButtons( false );
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *channel -
//-----------------------------------------------------------------------------
void CChoreoView::DeleteChannel( CChoreoChannel *channel )
{
if ( !channel || !m_pScene )
return;
SetDirty( true );
PushUndo( "Delete Channel" );
DeleteSceneWidgets();
// Delete channel and it's children
// Find the appropriate actor
for ( int i = 0; i < m_pScene->GetNumActors(); i++ )
{
CChoreoActor *a = m_pScene->GetActor( i );
if ( !a )
continue;
if ( a->FindChannelIndex( channel ) == -1 )
continue;
Con_Printf( "Deleting %s\n", channel->GetName() );
a->RemoveChannel( channel );
m_pScene->DeleteReferencedObjects( channel );
break;
}
ReportSceneClearToTools();
CreateSceneWidgets();
PushRedo( "Delete Channel" );
// Redraw
InvalidateLayout();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CChoreoView::NewChannel( void )
{
if ( !m_pScene )
return;
if ( !m_pScene->GetNumActors() )
{
Con_Printf( "You must create an actor before you can add a channel\n" );
return;
}
CChannelParams params;
memset( &params, 0, sizeof( params ) );
strcpy( params.m_szDialogTitle, "Create Channel" );
strcpy( params.m_szName, "" );
params.m_bShowActors = true;
strcpy( params.m_szSelectedActor, "" );
params.m_pScene = m_pScene;
if ( !ChannelProperties( &params ) )
{
return;
}
if ( strlen( params.m_szName ) <= 0 )
{
return;
}
CChoreoActor *actor = m_pScene->FindActor( params.m_szSelectedActor );
if ( !actor )
{
Con_Printf( "Can't add channel %s, actor %s doesn't exist\n", params.m_szName, params.m_szSelectedActor );
return;
}
SetDirty( true );
PushUndo( "Add Channel" );
DeleteSceneWidgets();
CChoreoChannel *channel = m_pScene->AllocChannel();
if ( !channel )
{
Con_Printf( "Unable to allocate channel %s!\n", params.m_szName );
}
else
{
channel->SetName( params.m_szName );
channel->SetActor( actor );
actor->AddChannel( channel );
}
CreateSceneWidgets();
PushRedo( "Add Channel" );
// Redraw
InvalidateLayout();
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *channel -
//-----------------------------------------------------------------------------
void CChoreoView::MoveChannelUp( CChoreoChannel *channel )
{
SetDirty( true );
PushUndo( "Move Channel Up" );
DeleteSceneWidgets();
// Find the appropriate actor
for ( int i = 0; i < m_pScene->GetNumActors(); i++ )
{
CChoreoActor *a = m_pScene->GetActor( i );
if ( !a )
continue;
int index = a->FindChannelIndex( channel );
if ( index == -1 )
continue;
if ( index != 0 )
{
Con_Printf( "Moving %s up\n", channel->GetName() );
a->SwapChannels( index, index - 1 );
}
break;
}
CreateSceneWidgets();
PushRedo( "Move Channel Up" );
// Redraw
InvalidateLayout();
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *channel -
//-----------------------------------------------------------------------------
void CChoreoView::MoveChannelDown( CChoreoChannel *channel )
{
SetDirty( true );
PushUndo( "Move Channel Down" );
DeleteSceneWidgets();
// Find the appropriate actor
for ( int i = 0; i < m_pScene->GetNumActors(); i++ )
{
CChoreoActor *a = m_pScene->GetActor( i );
if ( !a )
continue;
int index = a->FindChannelIndex( channel );
if ( index == -1 )
continue;
if ( index < a->GetNumChannels() - 1 )
{
Con_Printf( "Moving %s down\n", channel->GetName() );
a->SwapChannels( index, index + 1 );
}
break;
}
CreateSceneWidgets();
PushRedo( "Move Channel Down" );
// Redraw
InvalidateLayout();
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *channel -
//-----------------------------------------------------------------------------
void CChoreoView::EditChannel( CChoreoChannel *channel )
{
if ( !channel )
return;
CChannelParams params;
memset( &params, 0, sizeof( params ) );
strcpy( params.m_szDialogTitle, "Edit Channel" );
V_strcpy_safe( params.m_szName, channel->GetName() );
if ( !ChannelProperties( &params ) )
return;
if ( strlen( params.m_szName ) <= 0 )
return;
SetDirty( true );
PushUndo( "Edit Channel" );
channel->SetName( params.m_szName );
PushRedo( "Edit Channel" );
// Redraw
InvalidateLayout();
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *actor -
//-----------------------------------------------------------------------------
void CChoreoView::DeleteActor( CChoreoActor *actor )
{
if ( !actor || !m_pScene )
return;
SetDirty( true );
PushUndo( "Delete Actor" );
DeleteSceneWidgets();
// Delete channel and it's children
// Find the appropriate actor
Con_Printf( "Deleting %s\n", actor->GetName() );
m_pScene->RemoveActor( actor );
m_pScene->DeleteReferencedObjects( actor );
ReportSceneClearToTools();
CreateSceneWidgets();
PushRedo( "Delete Actor" );
// Redraw
InvalidateLayout();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CChoreoView::NewActor( void )
{
if ( !m_pScene )
{
Con_ErrorPrintf( "You must load or create a scene file first\n" );
return;
}
CActorParams params;
memset( &params, 0, sizeof( params ) );
strcpy( params.m_szDialogTitle, "Create Actor" );
strcpy( params.m_szName, "" );
if ( !ActorProperties( &params ) )
return;
if ( strlen( params.m_szName ) <= 0 )
return;
SetDirty( true );
PushUndo( "Add Actor" );
DeleteSceneWidgets();
Con_Printf( "Adding new actor '%s'\n", params.m_szName );
CChoreoActor *actor = m_pScene->AllocActor();
if ( actor )
{
actor->SetName( params.m_szName );
}
CreateSceneWidgets();
PushRedo( "Add Actor" );
// Redraw
InvalidateLayout();
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *actor -
//-----------------------------------------------------------------------------
void CChoreoView::MoveActorUp( CChoreoActor *actor )
{
DeleteSceneWidgets();
int index = m_pScene->FindActorIndex( actor );
// found it and it's not first
if ( index != -1 && index != 0 )
{
Con_Printf( "Moving %s up\n", actor->GetName() );
SetDirty( true );
PushUndo( "Move Actor Up" );
m_pScene->SwapActors( index, index - 1 );
PushRedo( "Move Actor Up" );
}
CreateSceneWidgets();
// Redraw
InvalidateLayout();
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *actor -
//-----------------------------------------------------------------------------
void CChoreoView::MoveActorDown( CChoreoActor *actor )
{
DeleteSceneWidgets();
int index = m_pScene->FindActorIndex( actor );
// found it and it's not first
if ( index != -1 && ( index < m_pScene->GetNumActors() - 1 ) )
{
Con_Printf( "Moving %s down\n", actor->GetName() );
SetDirty( true );
PushUndo( "Move Actor Down" );
m_pScene->SwapActors( index, index + 1 );
PushRedo( "Move Actor Down" );
}
CreateSceneWidgets();
// Redraw
InvalidateLayout();
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *actor -
//-----------------------------------------------------------------------------
void CChoreoView::EditActor( CChoreoActor *actor )
{
if ( !actor )
return;
CActorParams params;
memset( &params, 0, sizeof( params ) );
strcpy( params.m_szDialogTitle, "Edit Actor" );
V_strcpy_safe( params.m_szName, actor->GetName() );
if ( !ActorProperties( &params ) )
return;
if ( strlen( params.m_szName ) <= 0 )
return;
SetDirty( true );
PushUndo( "Edit Actor" );
actor->SetName( params.m_szName );
PushRedo( "Edit Actor" );
// Redraw
InvalidateLayout();
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : type -
//-----------------------------------------------------------------------------
void CChoreoView::AddEvent( int type, int subtype /*= 0*/, char const *defaultparameters /*= NULL*/ )
{
int mx, my;
mx = m_nClickedX;
my = m_nClickedY;
CChoreoChannelWidget *channel = m_pClickedChannel;
if ( !channel || !channel->GetChannel() )
{
CChoreoActorWidget *actor = m_pClickedActor;
if ( actor )
{
if ( actor->GetNumChannels() <= 0 )
return;
channel = actor->GetChannel( 0 );
if ( !channel || !channel->GetChannel() )
return;
}
else
{
return;
}
}
// Convert click position local to this window
POINT pt;
pt.x = mx;
pt.y = my;
CEventParams params;
memset( &params, 0, sizeof( params ) );
if ( defaultparameters )
{
Q_strncpy( params.m_szParameters, defaultparameters, sizeof( params.m_szParameters ) );
}
strcpy( params.m_szDialogTitle, "Create Event" );
params.m_nType = type;
params.m_pScene = m_pScene;
params.m_bFixedLength = false;
params.m_bResumeCondition = false;
params.m_flStartTime = GetTimeValueForMouse( pt.x );
params.m_bCloseCaptionNoAttenuate = false;
params.m_bForceShortMovement = false;
params.m_bSyncToFollowingGesture = false;
params.m_bDisabled = false;
params.m_bPlayOverScript = false;
switch ( type )
{
case CChoreoEvent::EXPRESSION:
case CChoreoEvent::FLEXANIMATION:
case CChoreoEvent::GESTURE:
case CChoreoEvent::SEQUENCE:
case CChoreoEvent::LOOKAT:
case CChoreoEvent::MOVETO:
case CChoreoEvent::FACE:
case CChoreoEvent::SUBSCENE:
case CChoreoEvent::INTERRUPT:
case CChoreoEvent::GENERIC:
case CChoreoEvent::PERMIT_RESPONSES:
params.m_bHasEndTime = true;
params.m_flEndTime = params.m_flStartTime + 0.5f;
if ( type == CChoreoEvent::GESTURE && subtype == 1 )
{
strcpy( params.m_szDialogTitle, "Create <NULL> Gesture" );
strcpy( params.m_szName, "NULL" );
}
break;
case CChoreoEvent::SPEAK:
params.m_bFixedLength = true;
params.m_bHasEndTime = false;
params.m_flEndTime = -1.0f;
break;
default:
params.m_bHasEndTime = false;
params.m_flEndTime = -1.0f;
break;
}
params.m_bUsesTag = false;
while (1)
{
SetScrubTargetTime( m_flScrub );
FinishSimulation();
sound->Flush();
m_bForceProcess = true;
if (!EventProperties( &params ))
{
m_bForceProcess = false;
return;
}
m_bForceProcess = false;
if ( Q_strlen( params.m_szName ) <= 0 )
{
mxMessageBox( this, va( "Event must have a valid name" ),
"Edit Event", MX_MB_OK | MX_MB_ERROR );
continue;
}
if ( Q_strlen( params.m_szParameters ) <= 0 )
{
bool shouldBreak = false;
switch ( params.m_nType )
{
case CChoreoEvent::FLEXANIMATION:
case CChoreoEvent::INTERRUPT:
case CChoreoEvent::PERMIT_RESPONSES:
shouldBreak = true;
break;
case CChoreoEvent::GESTURE:
if ( subtype == 1 )
{
shouldBreak = true;
}
break;
default:
// Have to have a non-null parameters block
break;
}
if ( !shouldBreak )
{
mxMessageBox( this, va( "No parameters specified for %s\n", params.m_szName ),
"Edit Event", MX_MB_OK | MX_MB_ERROR );
continue;
}
}
break;
}
SetDirty( true );
PushUndo( "Add Event" );
CChoreoEvent *event = m_pScene->AllocEvent();
if ( event )
{
event->SetType( (CChoreoEvent::EVENTTYPE)type );
event->SetName( params.m_szName );
event->SetParameters( params.m_szParameters );
event->SetParameters2( params.m_szParameters2 );
event->SetParameters3( params.m_szParameters3 );
event->SetStartTime( params.m_flStartTime );
event->SetResumeCondition( params.m_bResumeCondition );
event->SetLockBodyFacing( params.m_bLockBodyFacing );
event->SetDistanceToTarget( params.m_flDistanceToTarget );
event->SetForceShortMovement( params.m_bForceShortMovement );
event->SetSyncToFollowingGesture( params.m_bSyncToFollowingGesture );
event->SetActive( !params.m_bDisabled );
event->SetPlayOverScript( params.m_bPlayOverScript );
if ( params.m_bUsesTag )
{
event->SetUsingRelativeTag( true, params.m_szTagName, params.m_szTagWav );
}
else
{
event->SetUsingRelativeTag( false );
}
CChoreoChannel *pchannel = channel->GetChannel();
event->SetChannel( pchannel );
event->SetActor( pchannel->GetActor() );
if ( params.m_bHasEndTime &&
params.m_flEndTime != -1.0 &&
params.m_flEndTime > params.m_flStartTime )
{
event->SetEndTime( params.m_flEndTime );
}
else
{
event->SetEndTime( -1.0f );
}
switch ( event->GetType() )
{
default:
break;
case CChoreoEvent::SUBSCENE:
{
// Just grab end time
CChoreoScene *scene = LoadScene( event->GetParameters() );
if ( scene )
{
event->SetEndTime( params.m_flStartTime + scene->FindStopTime() );
}
delete scene;
}
break;
case CChoreoEvent::SEQUENCE:
{
CheckSequenceLength( event, false );
// AutoaddSequenceKeys( event);
}
break;
case CChoreoEvent::GESTURE:
{
DefaultGestureLength( event, false );
AutoaddGestureKeys( event, false );
}
break;
case CChoreoEvent::LOOKAT:
case CChoreoEvent::FACE:
{
if ( params.usepitchyaw )
{
event->SetPitch( params.pitch );
event->SetYaw( params.yaw );
}
else
{
event->SetPitch( 0 );
event->SetYaw( 0 );
}
}
break;
case CChoreoEvent::SPEAK:
{
// Try and load wav to get length
CAudioSource *wave = sound->LoadSound( va( "sound/%s", FacePoser_TranslateSoundName( event ) ) );
if ( wave )
{
event->SetEndTime( params.m_flStartTime + wave->GetRunningLength() );
delete wave;
}
event->SetSuppressingCaptionAttenuation( params.m_bCloseCaptionNoAttenuate );
}
break;
}
event->SnapTimes();
DeleteSceneWidgets();
// Add to appropriate channel
pchannel->AddEvent( event );
CreateSceneWidgets();
// Redraw
InvalidateLayout();
}
PushRedo( "Add Event" );
}
//-----------------------------------------------------------------------------
// Purpose: Adds a scene "pause" event
//-----------------------------------------------------------------------------
void CChoreoView::AddGlobalEvent( CChoreoEvent::EVENTTYPE type )
{
int mx, my;
mx = m_nClickedX;
my = m_nClickedY;
// Convert click position local to this window
POINT pt;
pt.x = mx;
pt.y = my;
CGlobalEventParams params;
memset( &params, 0, sizeof( params ) );
params.m_nType = type;
switch ( type )
{
default:
Assert( 0 );
strcpy( params.m_szDialogTitle, "???" );
break;
case CChoreoEvent::SECTION:
{
strcpy( params.m_szDialogTitle, "Add Pause Point" );
}
break;
case CChoreoEvent::LOOP:
{
strcpy( params.m_szDialogTitle, "Add Loop Point" );
}
break;
case CChoreoEvent::STOPPOINT:
{
strcpy( params.m_szDialogTitle, "Add Fire Completion" );
}
break;
}
strcpy( params.m_szName, "" );
strcpy( params.m_szAction, "" );
params.m_flStartTime = GetTimeValueForMouse( pt.x );
if ( !GlobalEventProperties( &params ) )
return;
if ( strlen( params.m_szName ) <= 0 )
{
Con_Printf( "Pause section event must have a valid name\n" );
return;
}
if ( strlen( params.m_szAction ) <= 0 )
{
Con_Printf( "No action specified for section pause\n" );
return;
}
char undotext[ 256 ];
undotext[0]=0;
switch( type )
{
default:
Assert( 0 );
break;
case CChoreoEvent::SECTION:
{
Q_strcpy( undotext, "Add Section Pause" );
}
break;
case CChoreoEvent::LOOP:
{
Q_strcpy( undotext, "Add Loop Point" );
}
break;
case CChoreoEvent::STOPPOINT:
{
Q_strcpy( undotext, "Add Fire Completion" );
}
break;
}
SetDirty( true );
PushUndo( undotext );
CChoreoEvent *event = m_pScene->AllocEvent();
if ( event )
{
event->SetType( type );
event->SetName( params.m_szName );
event->SetParameters( params.m_szAction );
event->SetStartTime( params.m_flStartTime );
event->SetEndTime( -1.0f );
switch ( type )
{
default:
break;
case CChoreoEvent::LOOP:
{
event->SetLoopCount( params.m_nLoopCount );
event->SetParameters( va( "%f", params.m_flLoopTime ) );
}
break;
}
event->SnapTimes();
DeleteSceneWidgets();
CreateSceneWidgets();
// Redraw
InvalidateLayout();
}
PushRedo( undotext );
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *event -
//-----------------------------------------------------------------------------
void CChoreoView::EditGlobalEvent( CChoreoEvent *event )
{
if ( !event )
return;
CGlobalEventParams params;
memset( &params, 0, sizeof( params ) );
params.m_nType = event->GetType();
switch ( event->GetType() )
{
default:
Assert( 0 );
strcpy( params.m_szDialogTitle, "???" );
break;
case CChoreoEvent::SECTION:
{
strcpy( params.m_szDialogTitle, "Edit Pause Point" );
V_strcpy_safe( params.m_szAction, event->GetParameters() );
}
break;
case CChoreoEvent::LOOP:
{
strcpy( params.m_szDialogTitle, "Edit Loop Point" );
strcpy( params.m_szAction, "" );
params.m_flLoopTime = (float)atof( event->GetParameters() );
params.m_nLoopCount = event->GetLoopCount();
}
break;
case CChoreoEvent::STOPPOINT:
{
strcpy( params.m_szDialogTitle, "Edit Fire Completion" );
strcpy( params.m_szAction, "" );
}
break;
}
strcpy( params.m_szName, event->GetName() );
params.m_flStartTime = event->GetStartTime();
if ( !GlobalEventProperties( &params ) )
return;
if ( strlen( params.m_szName ) <= 0 )
{
Con_Printf( "Event %s must have a valid name\n", event->GetName() );
return;
}
if ( strlen( params.m_szAction ) <= 0 )
{
Con_Printf( "No action specified for %s\n", event->GetName() );
return;
}
SetDirty( true );
char undotext[ 256 ];
undotext[0]=0;
switch( event->GetType() )
{
default:
Assert( 0 );
break;
case CChoreoEvent::SECTION:
{
Q_strcpy( undotext, "Edit Section Pause" );
}
break;
case CChoreoEvent::LOOP:
{
Q_strcpy( undotext, "Edit Loop Point" );
}
break;
case CChoreoEvent::STOPPOINT:
{
Q_strcpy( undotext, "Edit Fire Completion" );
}
break;
}
PushUndo( undotext );
event->SetName( params.m_szName );
event->SetStartTime( params.m_flStartTime );
event->SetEndTime( -1.0f );
switch ( event->GetType() )
{
default:
{
event->SetParameters( params.m_szAction );
}
break;
case CChoreoEvent::LOOP:
{
event->SetLoopCount( params.m_nLoopCount );
event->SetParameters( va( "%f", params.m_flLoopTime ) );
}
break;
}
event->SnapTimes();
PushRedo( undotext );
// Redraw
InvalidateLayout();
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *event -
//-----------------------------------------------------------------------------
void CChoreoView::DeleteGlobalEvent( CChoreoEvent *event )
{
if ( !event || !m_pScene )
return;
SetDirty( true );
char undotext[ 256 ];
undotext[0]=0;
switch( event->GetType() )
{
default:
Assert( 0 );
break;
case CChoreoEvent::SECTION:
{
Q_strcpy( undotext, "Delete Section Pause" );
}
break;
case CChoreoEvent::LOOP:
{
Q_strcpy( undotext, "Delete Loop Point" );
}
break;
case CChoreoEvent::STOPPOINT:
{
Q_strcpy( undotext, "Delete Fire Completion" );
}
break;
}
PushUndo( undotext );
DeleteSceneWidgets();
Con_Printf( "Deleting %s\n", event->GetName() );
m_pScene->DeleteReferencedObjects( event );
CreateSceneWidgets();
PushRedo( undotext );
// Redraw
InvalidateLayout();
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *event -
//-----------------------------------------------------------------------------
void CChoreoView::EditEvent( CChoreoEvent *event )
{
if ( !event )
return;
CEventParams params;
memset( &params, 0, sizeof( params ) );
strcpy( params.m_szDialogTitle, "Edit Event" );
// Copy in current even properties
params.m_nType = event->GetType();
params.m_bDisabled = !event->GetActive();
switch ( params.m_nType )
{
case CChoreoEvent::EXPRESSION:
case CChoreoEvent::SEQUENCE:
case CChoreoEvent::MOVETO:
case CChoreoEvent::SPEAK:
case CChoreoEvent::GESTURE:
case CChoreoEvent::INTERRUPT:
case CChoreoEvent::PERMIT_RESPONSES:
case CChoreoEvent::GENERIC:
V_strcpy_safe( params.m_szParameters3, event->GetParameters3() );
V_strcpy_safe( params.m_szParameters2, event->GetParameters2() );
V_strcpy_safe( params.m_szParameters, event->GetParameters() );
V_strcpy_safe( params.m_szName, event->GetName() );
break;
case CChoreoEvent::FACE:
case CChoreoEvent::LOOKAT:
case CChoreoEvent::FIRETRIGGER:
case CChoreoEvent::FLEXANIMATION:
case CChoreoEvent::SUBSCENE:
V_strcpy_safe( params.m_szParameters, event->GetParameters() );
V_strcpy_safe( params.m_szName, event->GetName() );
if ( params.m_nType == CChoreoEvent::LOOKAT || params.m_nType == CChoreoEvent::FACE )
{
if ( event->GetPitch() != 0 ||
event->GetYaw() != 0 )
{
params.usepitchyaw = true;
params.pitch = event->GetPitch();
params.yaw = event->GetYaw();
}
}
break;
default:
Con_Printf( "Don't know how to edit event type %s\n",
CChoreoEvent::NameForType( (CChoreoEvent::EVENTTYPE)params.m_nType ) );
return;
}
params.m_pScene = m_pScene;
params.m_pEvent = event;
params.m_flStartTime = event->GetStartTime();
params.m_flEndTime = event->GetEndTime();
params.m_bHasEndTime = event->HasEndTime();
params.m_bFixedLength = event->IsFixedLength();
params.m_bResumeCondition = event->IsResumeCondition();
params.m_bLockBodyFacing = event->IsLockBodyFacing();
params.m_flDistanceToTarget = event->GetDistanceToTarget();
params.m_bForceShortMovement = event->GetForceShortMovement();
params.m_bSyncToFollowingGesture = event->GetSyncToFollowingGesture();
params.m_bPlayOverScript = event->GetPlayOverScript();
params.m_bUsesTag = event->IsUsingRelativeTag();
params.m_bCloseCaptionNoAttenuate = event->IsSuppressingCaptionAttenuation();
if ( params.m_bUsesTag )
{
V_strcpy_safe( params.m_szTagName, event->GetRelativeTagName() );
V_strcpy_safe( params.m_szTagWav, event->GetRelativeWavName() );
}
while (1)
{
SetScrubTargetTime( m_flScrub );
FinishSimulation();
sound->Flush();
m_bForceProcess = true;
if (!EventProperties( &params ))
{
m_bForceProcess = false;
return;
}
m_bForceProcess = false;
if ( Q_strlen( params.m_szName ) <= 0 )
{
mxMessageBox( this, va( "Event %s must have a valid name", event->GetName() ),
"Edit Event", MX_MB_OK | MX_MB_ERROR );
continue;
}
if ( Q_strlen( params.m_szParameters ) <= 0 )
{
bool shouldBreak = false;
switch ( params.m_nType )
{
case CChoreoEvent::FLEXANIMATION:
case CChoreoEvent::INTERRUPT:
case CChoreoEvent::PERMIT_RESPONSES:
shouldBreak = true;
break;
case CChoreoEvent::GESTURE:
if ( !Q_stricmp( params.m_szName, "NULL" ) )
{
shouldBreak = true;
}
break;
default:
// Have to have a non-null parameters block
break;
}
if ( !shouldBreak )
{
mxMessageBox( this, va( "No parameters specified for %s\n", params.m_szName ),
"Edit Event", MX_MB_OK | MX_MB_ERROR );
continue;
}
}
break;
}
SetDirty( true );
PushUndo( "Edit Event" );
event->SetName( params.m_szName );
event->SetParameters( params.m_szParameters );
event->SetParameters2( params.m_szParameters2 );
event->SetParameters3( params.m_szParameters3 );
event->SetStartTime( params.m_flStartTime );
event->SetResumeCondition( params.m_bResumeCondition );
event->SetLockBodyFacing( params.m_bLockBodyFacing );
event->SetDistanceToTarget( params.m_flDistanceToTarget );
event->SetForceShortMovement( params.m_bForceShortMovement );
event->SetSyncToFollowingGesture( params.m_bSyncToFollowingGesture );
event->SetActive( !params.m_bDisabled );
event->SetPlayOverScript( params.m_bPlayOverScript );
if ( params.m_bUsesTag )
{
event->SetUsingRelativeTag( true, params.m_szTagName, params.m_szTagWav );
}
else
{
event->SetUsingRelativeTag( false );
}
if ( params.m_bHasEndTime &&
params.m_flEndTime != -1.0 &&
params.m_flEndTime > params.m_flStartTime )
{
float dt = params.m_flEndTime - event->GetEndTime();
float newduration = event->GetDuration() + dt;
RescaleRamp( event, newduration );
switch ( event->GetType() )
{
default:
break;
case CChoreoEvent::GESTURE:
{
event->RescaleGestureTimes( event->GetStartTime(), event->GetEndTime() + dt, true );
}
break;
case CChoreoEvent::FLEXANIMATION:
{
RescaleExpressionTimes( event, event->GetStartTime(), event->GetEndTime() + dt );
}
break;
}
event->SetEndTime( params.m_flEndTime );
event->SnapTimes();
event->ResortRamp();
}
else
{
event->SetEndTime( -1.0f );
}
switch ( event->GetType() )
{
default:
break;
case CChoreoEvent::SPEAK:
{
// Try and load wav to get length
CAudioSource *wave = sound->LoadSound( va( "sound/%s", FacePoser_TranslateSoundName( event ) ) );
if ( wave )
{
event->SetEndTime( params.m_flStartTime + wave->GetRunningLength() );
delete wave;
}
event->SetSuppressingCaptionAttenuation( params.m_bCloseCaptionNoAttenuate );
}
break;
case CChoreoEvent::SUBSCENE:
{
// Just grab end time
CChoreoScene *scene = LoadScene( event->GetParameters() );
if ( scene )
{
event->SetEndTime( params.m_flStartTime + scene->FindStopTime() );
}
delete scene;
}
break;
case CChoreoEvent::SEQUENCE:
{
CheckSequenceLength( event, false );
}
break;
case CChoreoEvent::GESTURE:
{
CheckGestureLength( event, false );
AutoaddGestureKeys( event, false );
g_pGestureTool->redraw();
}
break;
case CChoreoEvent::LOOKAT:
case CChoreoEvent::FACE:
{
if ( params.usepitchyaw )
{
event->SetPitch( params.pitch );
event->SetYaw( params.yaw );
}
else
{
event->SetPitch( 0 );
event->SetYaw( 0 );
}
}
break;
}
event->SnapTimes();
PushRedo( "Edit Event" );
// Redraw
InvalidateLayout();
}
void CChoreoView::EnableSelectedEvents( bool state )
{
if ( !m_pScene )
return;
SetDirty( true );
// If we right clicked on an unseleced event, then select it for the user.
if ( CountSelectedEvents() == 0 )
{
CChoreoEventWidget *event = m_pClickedEvent;
if ( event )
{
event->SetSelected( true );
}
}
char const *desc = state ? "Enable Events" : "Disable Events";
PushUndo( desc );
// Find the appropriate event by iterating across all actors and channels
for ( int i = 0; i < m_SceneActors.Size(); i++ )
{
CChoreoActorWidget *a = m_SceneActors[ i ];
if ( !a )
continue;
for ( int j = 0; j < a->GetNumChannels(); j++ )
{
CChoreoChannelWidget *channel = a->GetChannel( j );
if ( !channel )
continue;
for ( int k = channel->GetNumEvents() - 1; k >= 0; k-- )
{
CChoreoEventWidget *event = channel->GetEvent( k );
if ( !event->IsSelected() )
continue;
event->GetEvent()->SetActive( state );
}
}
}
for ( int i = 0; i < m_SceneGlobalEvents.Size(); i++ )
{
CChoreoGlobalEventWidget *event = m_SceneGlobalEvents[ i ];
if ( !event || !event->IsSelected() )
continue;
event->GetEvent()->SetActive( state );
}
PushRedo( desc );
// Redraw
InvalidateLayout();
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *event -
//-----------------------------------------------------------------------------
void CChoreoView::DeleteSelectedEvents( void )
{
if ( !m_pScene )
return;
SetDirty( true );
PushUndo( "Delete Events" );
int deleteCount = 0;
float oldstoptime = m_pScene->FindStopTime();
// Find the appropriate event by iterating across all actors and channels
for ( int i = 0; i < m_SceneActors.Size(); i++ )
{
CChoreoActorWidget *a = m_SceneActors[ i ];
if ( !a )
continue;
for ( int j = 0; j < a->GetNumChannels(); j++ )
{
CChoreoChannelWidget *channel = a->GetChannel( j );
if ( !channel )
continue;
for ( int k = channel->GetNumEvents() - 1; k >= 0; k-- )
{
CChoreoEventWidget *event = channel->GetEvent( k );
if ( !event->IsSelected() )
continue;
channel->GetChannel()->RemoveEvent( event->GetEvent() );
m_pScene->DeleteReferencedObjects( event->GetEvent() );
deleteCount++;
}
}
}
for ( int i = 0; i < m_SceneGlobalEvents.Size(); i++ )
{
CChoreoGlobalEventWidget *event = m_SceneGlobalEvents[ i ];
if ( !event || !event->IsSelected() )
continue;
m_pScene->DeleteReferencedObjects( event->GetEvent() );
deleteCount++;
}
DeleteSceneWidgets();
ReportSceneClearToTools();
CreateSceneWidgets();
PushRedo( "Delete Events" );
Con_Printf( "Deleted <%i> events\n", deleteCount );
if ( m_pScene->FindStopTime() != oldstoptime )
{
// Force scroll bars to recompute
ForceScrollBarsToRecompute( false );
}
// Redraw
InvalidateLayout();
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : resetthumb -
//-----------------------------------------------------------------------------
void CChoreoView::ForceScrollBarsToRecompute( bool resetthumb )
{
if ( resetthumb )
{
m_flLeftOffset = 0.0f;
}
m_nLastHPixelsNeeded = -1;
m_nLastVPixelsNeeded = -1;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *filename -
// Output : CChoreoScene
//-----------------------------------------------------------------------------
CChoreoScene *CChoreoView::LoadScene( char const *filename )
{
// If relative path, then make a full path
char pFullPathBuf[ MAX_PATH ];
if ( !Q_IsAbsolutePath( filename ) )
{
filesystem->RelativePathToFullPath( filename, "GAME", pFullPathBuf, sizeof( pFullPathBuf ) );
filename = pFullPathBuf;
}
if ( !filesystem->FileExists( filename ) )
return NULL;
LoadScriptFile( const_cast<char*>( filename ) );
CChoreoScene *scene = ChoreoLoadScene( filename, this, tokenprocessor, Con_Printf );
return scene;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CChoreoView::FixupSequenceDurations( CChoreoScene *scene, bool checkonly )
{
bool bret = false;
if ( !scene )
return bret;
int c = scene->GetNumEvents();
for ( int i = 0; i < c; i++ )
{
CChoreoEvent *event = scene->GetEvent( i );
if ( !event )
continue;
switch ( event->GetType() )
{
default:
break;
case CChoreoEvent::SPEAK:
{
// Try and load wav to get length
CAudioSource *wave = sound->LoadSound( va( "sound/%s", FacePoser_TranslateSoundName( event ) ) );
if ( wave )
{
float endtime = event->GetStartTime() + wave->GetRunningLength();
if ( event->GetEndTime() != endtime )
{
event->SetEndTime( event->GetStartTime() + wave->GetRunningLength() );
bret = true;
}
delete wave;
}
}
break;
case CChoreoEvent::SEQUENCE:
{
if ( CheckSequenceLength( event, checkonly ) )
{
bret = true;
}
}
break;
case CChoreoEvent::GESTURE:
{
if ( CheckGestureLength( event, checkonly ) )
{
bret = true;
}
if ( AutoaddGestureKeys( event, checkonly ) )
{
bret = true;
}
}
break;
}
}
return bret;
}
//-----------------------------------------------------------------------------
// Purpose: IChoreoEventCallback
// Input : currenttime -
// *event -
//-----------------------------------------------------------------------------
void CChoreoView::StartEvent( float currenttime, CChoreoScene *scene, CChoreoEvent *event )
{
if ( !event || !event->GetActive() )
return;
CChoreoActor *actor = event->GetActor();
if ( actor && !actor->GetActive() )
{
return;
}
CChoreoChannel *channel = event->GetChannel();
if ( channel && !channel->GetActive() )
{
return;
}
// Con_Printf( "%8.4f: start %s\n", currenttime, event->GetDescription() );
switch ( event->GetType() )
{
case CChoreoEvent::SEQUENCE:
{
ProcessSequence( scene, event );
}
break;
case CChoreoEvent::SUBSCENE:
{
if ( !scene->IsSubScene() )
{
CChoreoScene *subscene = event->GetSubScene();
if ( !subscene )
{
subscene = LoadScene( event->GetParameters() );
subscene->SetSubScene( true );
event->SetSubScene( subscene );
}
if ( subscene )
{
subscene->ResetSimulation( m_bForward );
}
}
}
break;
case CChoreoEvent::SECTION:
{
ProcessPause( scene, event );
}
break;
case CChoreoEvent::SPEAK:
{
if ( ShouldProcessSpeak() )
{
// See if we should trigger CC
char soundname[ 512 ];
Q_strncpy( soundname, event->GetParameters(), sizeof( soundname ) );
float actualEndTime = event->GetEndTime();
if ( event->GetCloseCaptionType() == CChoreoEvent::CC_MASTER )
{
char tok[ CChoreoEvent::MAX_CCTOKEN_STRING ];
if ( event->GetPlaybackCloseCaptionToken( tok, sizeof( tok ) ) )
{
float duration = max( event->GetDuration(), event->GetLastSlaveEndTime() - event->GetStartTime() );
closecaptionmanager->Process( tok, duration, GetCloseCaptionLanguageId() );
// Use the token as the sound name lookup, too.
if ( event->IsUsingCombinedFile() &&
( event->GetNumSlaves() > 0 ) )
{
Q_strncpy( soundname, tok, sizeof( soundname ) );
actualEndTime = max( actualEndTime, event->GetLastSlaveEndTime() );
}
}
}
StudioModel *model = FindAssociatedModel( scene, event->GetActor() );
CAudioMixer *mixer = event->GetMixer();
if ( !mixer || !sound->IsSoundPlaying( mixer ) )
{
CSoundParameters params;
float volume = VOL_NORM;
gender_t gender = GENDER_NONE;
if (model)
{
gender = soundemitter->GetActorGender( model->GetFileName() );
}
if ( !Q_stristr( soundname, ".wav" ) &&
soundemitter->GetParametersForSound( soundname, params, gender ) )
{
volume = params.volume;
}
sound->PlaySound(
model,
volume,
va( "sound/%s", FacePoser_TranslateSoundName( soundname, model ) ),
&mixer );
event->SetMixer( mixer );
}
if ( mixer )
{
mixer->SetDirection( m_flFrameTime >= 0.0f );
float starttime, endtime;
starttime = event->GetStartTime();
endtime = actualEndTime;
float soundtime = endtime - starttime;
if ( soundtime > 0.0f )
{
float f = ( currenttime - starttime ) / soundtime;
f = clamp( f, 0.0f, 1.0f );
// Compute sample
float numsamples = (float)mixer->GetSource()->SampleCount();
int cursample = f * numsamples;
cursample = clamp( cursample, 0, numsamples - 1 );
mixer->SetSamplePosition( cursample );
mixer->SetActive( true );
}
}
}
}
break;
case CChoreoEvent::EXPRESSION:
{
}
break;
case CChoreoEvent::LOOP:
{
ProcessLoop( scene, event );
}
break;
case CChoreoEvent::STOPPOINT:
{
// Nothing, this is a symbolic event for keeping the vcd alive for ramping out after the last true event
}
break;
default:
break;
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : currenttime -
// *event -
//-----------------------------------------------------------------------------
void CChoreoView::EndEvent( float currenttime, CChoreoScene *scene, CChoreoEvent *event )
{
if ( !event || !event->GetActive() )
return;
CChoreoActor *actor = event->GetActor();
if ( actor && !actor->GetActive() )
{
return;
}
CChoreoChannel *channel = event->GetChannel();
if ( channel && !channel->GetActive() )
{
return;
}
switch ( event->GetType() )
{
case CChoreoEvent::SUBSCENE:
{
CChoreoScene *subscene = event->GetSubScene();
if ( subscene )
{
subscene->ResetSimulation();
}
}
break;
case CChoreoEvent::SPEAK:
{
CAudioMixer *mixer = event->GetMixer();
if ( mixer && sound->IsSoundPlaying( mixer ) )
{
sound->StopSound( mixer );
}
event->SetMixer( NULL );
}
break;
default:
break;
}
// Con_Printf( "%8.4f: finish %s\n", currenttime, event->GetDescription() );
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *event -
// mx -
// my -
//-----------------------------------------------------------------------------
int CChoreoView::GetTagUnderCursorPos( CChoreoEventWidget *event, int mx, int my )
{
if ( !event )
{
return -1;
}
for ( int i = 0; i < event->GetEvent()->GetNumRelativeTags(); i++ )
{
CEventRelativeTag *tag = event->GetEvent()->GetRelativeTag( i );
if ( !tag )
continue;
// Determine left edcge
RECT bounds;
bounds = event->getBounds();
int left = bounds.left + (int)( tag->GetPercentage() * (float)( bounds.right - bounds.left ) + 0.5f );
int tolerance = 3;
if ( abs( mx - left ) < tolerance )
{
if ( abs( my - bounds.top ) < tolerance )
{
return i;
}
}
}
return -1;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *event -
// mx -
// my -
//-----------------------------------------------------------------------------
CEventAbsoluteTag *CChoreoView::GetAbsoluteTagUnderCursorPos( CChoreoEventWidget *event, int mx, int my )
{
if ( !event )
{
return NULL;
}
for ( int i = 0; i < event->GetEvent()->GetNumAbsoluteTags( CChoreoEvent::PLAYBACK ); i++ )
{
CEventAbsoluteTag *tag = event->GetEvent()->GetAbsoluteTag( CChoreoEvent::PLAYBACK, i );
if ( !tag )
continue;
// Determine left edcge
RECT bounds;
bounds = event->getBounds();
int left = bounds.left + (int)( tag->GetPercentage() * (float)( bounds.right - bounds.left ) + 0.5f );
int tolerance = 3;
if ( abs( mx - left ) < tolerance )
{
if ( abs( my - bounds.top ) < tolerance )
{
return tag;
}
}
}
return NULL;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : mx -
// my -
// **actor -
// **channel -
// **event -
//-----------------------------------------------------------------------------
void CChoreoView::GetObjectsUnderMouse( int mx, int my, CChoreoActorWidget **actor,
CChoreoChannelWidget **channel, CChoreoEventWidget **event, CChoreoGlobalEventWidget **globalevent,
int *clickedTag,
CEventAbsoluteTag **absolutetag, int *clickedCCArea )
{
if ( actor )
{
*actor = GetActorUnderCursorPos( mx, my );
}
if ( channel )
{
*channel = GetChannelUnderCursorPos( mx, my );
if ( *channel && clickedCCArea )
{
*clickedCCArea = (*channel)->GetChannelItemUnderMouse( mx, my );
}
}
if ( event )
{
*event = GetEventUnderCursorPos( mx, my );
}
if ( globalevent )
{
*globalevent = GetGlobalEventUnderCursorPos( mx, my );
}
if ( clickedTag )
{
if ( event && *event )
{
*clickedTag = GetTagUnderCursorPos( *event, mx, my );
}
else
{
*clickedTag = -1;
}
}
if ( absolutetag )
{
if ( event && *event )
{
*absolutetag = GetAbsoluteTagUnderCursorPos( *event, mx, my );
}
else
{
*absolutetag = NULL;
}
}
m_nSelectedEvents = CountSelectedEvents();
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : mx -
// my -
// Output : CChoreoGlobalEventWidget
//-----------------------------------------------------------------------------
CChoreoGlobalEventWidget *CChoreoView::GetGlobalEventUnderCursorPos( int mx, int my )
{
POINT check;
check.x = mx;
check.y = my;
CChoreoGlobalEventWidget *event;
for ( int i = 0; i < m_SceneGlobalEvents.Size(); i++ )
{
event = m_SceneGlobalEvents[ i ];
if ( !event )
continue;
RECT bounds;
event->getBounds( bounds );
if ( PtInRect( &bounds, check ) )
{
return event;
}
}
return NULL;
}
//-----------------------------------------------------------------------------
// Purpose: Caller must first translate mouse into screen coordinates
// Input : mx -
// my -
//-----------------------------------------------------------------------------
CChoreoActorWidget *CChoreoView::GetActorUnderCursorPos( int mx, int my )
{
POINT check;
check.x = mx;
check.y = my;
CChoreoActorWidget *actor;
for ( int i = 0; i < m_SceneActors.Size(); i++ )
{
actor = m_SceneActors[ i ];
if ( !actor )
continue;
RECT bounds;
actor->getBounds( bounds );
if ( PtInRect( &bounds, check ) )
{
return actor;
}
}
return NULL;
}
//-----------------------------------------------------------------------------
// Purpose: Caller must first translate mouse into screen coordinates
// Input : mx -
// my -
// Output : CChoreoChannelWidget
//-----------------------------------------------------------------------------
CChoreoChannelWidget *CChoreoView::GetChannelUnderCursorPos( int mx, int my )
{
CChoreoActorWidget *actor = GetActorUnderCursorPos( mx, my );
if ( !actor )
{
return NULL;
}
POINT check;
check.x = mx;
check.y = my;
CChoreoChannelWidget *channel;
for ( int i = 0; i < actor->GetNumChannels(); i++ )
{
channel = actor->GetChannel( i );
if ( !channel )
continue;
RECT bounds;
channel->getBounds( bounds );
if ( PtInRect( &bounds, check ) )
{
return channel;
}
}
return NULL;
}
//-----------------------------------------------------------------------------
// Purpose: Caller must first translate mouse into screen coordinates
// Input : mx -
// my -
//-----------------------------------------------------------------------------
CChoreoEventWidget *CChoreoView::GetEventUnderCursorPos( int mx, int my )
{
CChoreoChannelWidget *channel = GetChannelUnderCursorPos( mx, my );
if ( !channel )
{
return NULL;
}
POINT check;
check.x = mx;
check.y = my;
if ( mx < GetLabelWidth() )
return NULL;
if ( my < GetStartRow() )
return NULL;
if ( my >= h2() - ( m_nInfoHeight + m_nScrollbarHeight ) )
return NULL;
CChoreoEventWidget *event;
for ( int i = 0; i < channel->GetNumEvents(); i++ )
{
event = channel->GetEvent( i );
if ( !event )
continue;
RECT bounds;
event->getBounds( bounds );
// Events get an expanded border
InflateRect( &bounds, 8, 4 );
if ( PtInRect( &bounds, check ) )
{
return event;
}
}
return NULL;
}
//-----------------------------------------------------------------------------
// Purpose: Select wave file for phoneme editing
// Input : *filename -
//-----------------------------------------------------------------------------
void CChoreoView::SetCurrentWaveFile( const char *filename, CChoreoEvent *event )
{
g_pPhonemeEditor->SetCurrentWaveFile( filename, false, event );
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : pfn -
// *param1 -
//-----------------------------------------------------------------------------
void CChoreoView::TraverseWidgets( CVMEMBERFUNC pfn, CChoreoWidget *param1 )
{
for ( int i = 0; i < m_SceneActors.Size(); i++ )
{
CChoreoActorWidget *actor = m_SceneActors[ i ];
if ( !actor )
continue;
(this->*pfn)( actor, param1 );
for ( int j = 0; j < actor->GetNumChannels(); j++ )
{
CChoreoChannelWidget *channel = actor->GetChannel( j );
if ( !channel )
continue;
(this->*pfn)( channel, param1 );
for ( int k = 0; k < channel->GetNumEvents(); k++ )
{
CChoreoEventWidget *event = channel->GetEvent( k );
if ( !event )
continue;
(this->*pfn)( event, param1 );
}
}
}
for ( int i = 0; i < m_SceneGlobalEvents.Size(); i++ )
{
CChoreoGlobalEventWidget *event = m_SceneGlobalEvents[ i ];
if ( !event )
continue;
(this->*pfn)( event, param1 );
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *widget -
// *param1 -
//-----------------------------------------------------------------------------
void CChoreoView::Deselect( CChoreoWidget *widget, CChoreoWidget *param1 )
{
if ( widget->IsSelected() )
{
widget->SetSelected( false );
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *widget -
// *param1 -
//-----------------------------------------------------------------------------
void CChoreoView::Select( CChoreoWidget *widget, CChoreoWidget *param1 )
{
if ( widget != param1 )
return;
if ( widget->IsSelected() )
return;
widget->SetSelected( true );
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *widget -
// *param1 -
//-----------------------------------------------------------------------------
void CChoreoView::SelectAllEvents( CChoreoWidget *widget, CChoreoWidget *param1 )
{
CChoreoEventWidget *ew = dynamic_cast< CChoreoEventWidget * >( widget );
CChoreoGlobalEventWidget *gew = dynamic_cast< CChoreoGlobalEventWidget * >( widget );
if ( ew || gew )
{
if ( widget->IsSelected() )
return;
widget->SetSelected( true );
}
}
bool CChoreoView::CreateAnimationEvent( int mx, int my, char const *animationname )
{
if ( !animationname || !animationname[0] )
return false;
// Convert screen to client
POINT pt;
pt.x = mx;
pt.y = my;
ScreenToClient( (HWND)getHandle(), &pt );
if ( pt.x < 0 || pt.y < 0 )
return false;
if ( pt.x > w2() || pt.y > h2() )
return false;
pt.x -= GetLabelWidth();
m_nClickedX = pt.x;
GetObjectsUnderMouse( pt.x, pt.y, &m_pClickedActor, &m_pClickedChannel, &m_pClickedEvent, &m_pClickedGlobalEvent, &m_nClickedTag, &m_pClickedAbsoluteTag, &m_nClickedChannelCloseCaptionButton );
// Find channel actor and time ( uses screen space coordinates )
//
CChoreoChannelWidget *channel = GetChannelUnderCursorPos( pt.x, pt.y );
if ( !channel )
{
CChoreoActorWidget *actor = GetActorUnderCursorPos( pt.x, pt.y );
if ( !actor )
return false;
// Grab first channel
if ( !actor->GetNumChannels() )
return false;
channel = actor->GetChannel( 0 );
}
if ( !channel )
return false;
CChoreoChannel *pchannel = channel->GetChannel();
if ( !pchannel )
{
Assert( 0 );
return false;
}
// At this point we need to ask the user what type of even to create (gesture or sequence) and just show the approprite dialog
CChoiceParams params;
strcpy( params.m_szDialogTitle, "Create Animation Event" );
params.m_bPositionDialog = false;
params.m_nLeft = 0;
params.m_nTop = 0;
strcpy( params.m_szPrompt, "Type of event:" );
params.m_Choices.RemoveAll();
params.m_nSelected = 0;
ChoiceText text;
strcpy( text.choice, "gesture" );
params.m_Choices.AddToTail( text );
strcpy( text.choice, "sequence" );
params.m_Choices.AddToTail( text );
if ( !ChoiceProperties( &params ) )
return false;
if ( params.m_nSelected < 0 )
return false;
switch ( params.m_nSelected )
{
default:
case 0:
AddEvent( CChoreoEvent::GESTURE, 0, animationname );
break;
case 1:
AddEvent( CChoreoEvent::SEQUENCE, 0, animationname );
break;
}
return true;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : mx -
// my -
// *cl -
// *exp -
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CChoreoView::CreateExpressionEvent( int mx, int my, CExpClass *cl, CExpression *exp )
{
if ( !m_pScene )
return false;
if ( !exp )
return false;
// Convert screen to client
POINT pt;
pt.x = mx;
pt.y = my;
ScreenToClient( (HWND)getHandle(), &pt );
if ( pt.x < 0 || pt.y < 0 )
return false;
if ( pt.x > w2() || pt.y > h2() )
return false;
// Find channel actor and time ( uses screen space coordinates )
//
CChoreoChannelWidget *channel = GetChannelUnderCursorPos( pt.x, pt.y );
if ( !channel )
{
CChoreoActorWidget *actor = GetActorUnderCursorPos( pt.x, pt.y );
if ( !actor )
return false;
// Grab first channel
if ( !actor->GetNumChannels() )
return false;
channel = actor->GetChannel( 0 );
}
if ( !channel )
return false;
CChoreoChannel *pchannel = channel->GetChannel();
if ( !pchannel )
{
Assert( 0 );
return false;
}
CChoreoEvent *event = m_pScene->AllocEvent();
if ( !event )
{
Assert( 0 );
return false;
}
float starttime = GetTimeValueForMouse( pt.x, false );
SetDirty( true );
PushUndo( "Create Expression" );
event->SetType( CChoreoEvent::EXPRESSION );
event->SetName( exp->name );
event->SetParameters( cl->GetName() );
event->SetParameters2( exp->name );
event->SetStartTime( starttime );
event->SetChannel( pchannel );
event->SetActor( pchannel->GetActor() );
event->SetEndTime( starttime + 1.0f );
event->SnapTimes();
DeleteSceneWidgets();
// Add to appropriate channel
pchannel->AddEvent( event );
CreateSceneWidgets();
PushRedo( "Create Expression" );
// Redraw
InvalidateLayout();
return true;
}
//-----------------------------------------------------------------------------
// Purpose:
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CChoreoView::IsPlayingScene( void )
{
return m_bSimulating;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CChoreoView::ResetTargetSettings( void )
{
for ( int i = 0; i < m_SceneActors.Size(); i++ )
{
CChoreoActorWidget *w = m_SceneActors[ i ];
if ( w )
{
w->ResetSettings();
}
}
models->ClearModelTargets( true );
}
//-----------------------------------------------------------------------------
// Purpose: copies the actors "settings" into the models FlexControllers
// Input : dt -
//-----------------------------------------------------------------------------
void CChoreoView::UpdateCurrentSettings( void )
{
StudioModel *defaultModel = models->GetActiveStudioModel();
for ( int i = 0; i < m_SceneActors.Size(); i++ )
{
CChoreoActorWidget *w = m_SceneActors[ i ];
if ( !w )
continue;
if ( !w->GetActor()->GetActive() )
continue;
StudioModel *model = FindAssociatedModel( m_pScene, w->GetActor() );
if ( !model )
continue;
CStudioHdr *hdr = model->GetStudioHdr();
if ( !hdr )
continue;
float *current = w->GetSettings();
for ( LocalFlexController_t j = LocalFlexController_t(0); j < hdr->numflexcontrollers(); j++ )
{
int k = hdr->pFlexcontroller( j )->localToGlobal;
if (k != -1)
{
if ( defaultModel == model && g_pFlexPanel->IsEdited( k ) )
{
model->SetFlexController( j, g_pFlexPanel->GetSlider( k ) );
}
else
{
model->SetFlexController( j, current[ k ] );
}
}
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *event -
// tagnum -
//-----------------------------------------------------------------------------
void CChoreoView::DeleteEventRelativeTag( CChoreoEvent *event, int tagnum )
{
if ( !event )
return;
CEventRelativeTag *tag = event->GetRelativeTag( tagnum );
if ( !tag )
return;
SetDirty( true );
PushUndo( "Delete Event Tag" );
event->RemoveRelativeTag( tag->GetName() );
m_pScene->ReconcileTags();
PushRedo( "Delete Event Tag" );
g_pPhonemeEditor->redraw();
InvalidateLayout();
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *event -
//-----------------------------------------------------------------------------
void CChoreoView::AddEventRelativeTag( void )
{
CChoreoEventWidget *ew = m_pClickedEvent;
if ( !ew )
return;
CChoreoEvent *event = ew->GetEvent();
if ( !event->GetEndTime() )
{
Con_ErrorPrintf( "Event Tag: Can only tag events with an end time\n" );
return;
}
CInputParams params;
memset( &params, 0, sizeof( params ) );
strcpy( params.m_szDialogTitle, "Event Tag Name" );
strcpy( params.m_szPrompt, "Name:" );
strcpy( params.m_szInputText, "" );
if ( !InputProperties( &params ) )
return;
if ( strlen( params.m_szInputText ) <= 0 )
{
Con_ErrorPrintf( "Event Tag Name: No name entered!\n" );
return;
}
RECT bounds = ew->getBounds();
// Convert click to frac
float frac = 0.0f;
if ( bounds.right - bounds.left > 0 )
{
frac = (float)( m_nClickedX - bounds.left ) / (float)( bounds.right - bounds.left );
frac = min( 1.0f, frac );
frac = max( 0.0f, frac );
}
SetDirty( true );
PushUndo( "Add Event Tag" );
event->AddRelativeTag( params.m_szInputText, frac );
PushRedo( "Add Event Tag" );
InvalidateLayout();
g_pPhonemeEditor->redraw();
g_pExpressionTool->redraw();
g_pGestureTool->redraw();
g_pRampTool->redraw();
g_pSceneRampTool->redraw();
}
CChoreoChannelWidget *CChoreoView::FindChannelForEvent( CChoreoEvent *event )
{
for ( int i = 0; i < m_SceneActors.Size(); i++ )
{
CChoreoActorWidget *a = m_SceneActors[ i ];
if ( !a )
continue;
for ( int j = 0; j < a->GetNumChannels(); j++ )
{
CChoreoChannelWidget *c = a->GetChannel( j );
if ( !c )
continue;
for ( int k = 0; k < c->GetNumEvents(); k++ )
{
CChoreoEventWidget *e = c->GetEvent( k );
if ( !e )
continue;
if ( e->GetEvent() != event )
continue;
return c;
}
}
}
return NULL;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *event -
// Output : CChoreoEventWidget
//-----------------------------------------------------------------------------
CChoreoEventWidget *CChoreoView::FindWidgetForEvent( CChoreoEvent *event )
{
for ( int i = 0; i < m_SceneActors.Size(); i++ )
{
CChoreoActorWidget *a = m_SceneActors[ i ];
if ( !a )
continue;
for ( int j = 0; j < a->GetNumChannels(); j++ )
{
CChoreoChannelWidget *c = a->GetChannel( j );
if ( !c )
continue;
for ( int k = 0; k < c->GetNumEvents(); k++ )
{
CChoreoEventWidget *e = c->GetEvent( k );
if ( !e )
continue;
if ( e->GetEvent() != event )
continue;
return e;
}
}
}
return NULL;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CChoreoView::SelectAll( void )
{
TraverseWidgets( &CChoreoView::SelectAllEvents, NULL );
redraw();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CChoreoView::DeselectAll( void )
{
TraverseWidgets( &CChoreoView::Deselect, NULL );
redraw();
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : mx -
// my -
//-----------------------------------------------------------------------------
void CChoreoView::UpdateStatusArea( int mx, int my )
{
FLYOVER fo;
GetObjectsUnderMouse( mx, my, &fo.a, &fo.c,
&fo.e, &fo.ge, &fo.tag, &fo.at, &fo.ccbutton );
if ( fo.a )
{
m_Flyover.a = fo.a;
}
if ( fo.e )
{
m_Flyover.e = fo.e;
}
if ( fo.c )
{
m_Flyover.c = fo.c;
}
if ( fo.ge )
{
m_Flyover.ge = fo.ge;
}
if ( fo.tag != -1 )
{
m_Flyover.tag = fo.tag;
}
if ( fo.ccbutton != -1 )
{
m_Flyover.ccbutton = fo.ccbutton;
// m_Flyover.e = NULL;
}
RECT rcClip;
GetClientRect( (HWND)getHandle(), &rcClip );
rcClip.bottom -= m_nScrollbarHeight;
rcClip.top = rcClip.bottom - m_nInfoHeight;
rcClip.right -= m_nScrollbarHeight;
CChoreoWidgetDrawHelper drawHelper( this, rcClip, COLOR_CHOREO_BACKGROUND );
drawHelper.StartClipping( rcClip );
RedrawStatusArea( drawHelper, rcClip );
drawHelper.StopClipping();
ValidateRect( (HWND)getHandle(), &rcClip );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CChoreoView::ClearStatusArea( void )
{
memset( &m_Flyover, 0, sizeof( m_Flyover ) );
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : drawHelper -
// rcStatus -
//-----------------------------------------------------------------------------
void CChoreoView::RedrawStatusArea( CChoreoWidgetDrawHelper& drawHelper, RECT& rcStatus )
{
drawHelper.DrawFilledRect( COLOR_CHOREO_BACKGROUND, rcStatus );
drawHelper.DrawColoredLine( COLOR_INFO_BORDER, PS_SOLID, 1, rcStatus.left, rcStatus.top,
rcStatus.right, rcStatus.top );
RECT rcInfo = rcStatus;
rcInfo.top += 2;
if ( m_Flyover.e )
{
m_Flyover.e->redrawStatus( drawHelper, rcInfo );
}
if ( m_Flyover.c &&
m_Flyover.ccbutton != -1 )
{
m_Flyover.c->redrawStatus( drawHelper, rcInfo, m_Flyover.ccbutton );
}
if ( m_pScene )
{
char sz[ 512 ];
int fontsize = 9;
int fontweight = FW_NORMAL;
RECT rcText;
rcText = rcInfo;
rcText.bottom = rcText.top + fontsize + 2;
char const *mapname = m_pScene->GetMapname();
if ( mapname )
{
sprintf( sz, "Associated .bsp: %s", mapname[ 0 ] ? mapname : "none" );
int len = drawHelper.CalcTextWidth( "Arial", fontsize, fontweight, sz );
rcText.left = rcText.right - len - 10;
drawHelper.DrawColoredText( "Arial", fontsize, fontweight, COLOR_INFO_TEXT, rcText, sz );
OffsetRect( &rcText, 0, fontsize + 2 );
}
sprintf( sz, "Scene: %s", GetChoreoFile() );
int len = drawHelper.CalcTextWidth( "Arial", fontsize, fontweight, sz );
rcText.left = rcText.right - len - 10;
drawHelper.DrawColoredText( "Arial", fontsize, fontweight, COLOR_INFO_TEXT, rcText, sz );
}
// drawHelper.DrawColoredText( "Arial", 12, 500, RGB( 0, 0, 0 ), rcInfo, m_Flyover.e ? m_Flyover.e->GetEvent()->GetName() : "" );
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *event -
//-----------------------------------------------------------------------------
void CChoreoView::MoveEventToBack( CChoreoEvent *event )
{
// Now find channel widget
for ( int i = 0; i < m_SceneActors.Size(); i++ )
{
CChoreoActorWidget *a = m_SceneActors[ i ];
if ( !a )
continue;
for ( int j = 0; j < a->GetNumChannels(); j++ )
{
CChoreoChannelWidget *c = a->GetChannel( j );
if ( !c )
continue;
for ( int k = 0; k < c->GetNumEvents(); k++ )
{
CChoreoEventWidget *e = c->GetEvent( k );
if ( !e )
continue;
if ( event == e->GetEvent() )
{
// Move it to back of channel's list
c->MoveEventToTail( e );
InvalidateLayout();
return;
}
}
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Output : int
//-----------------------------------------------------------------------------
int CChoreoView::GetEndRow( void )
{
RECT rcClient;
GetClientRect( (HWND)getHandle(), &rcClient );
return rcClient.bottom - ( m_nInfoHeight + m_nScrollbarHeight );
}
// Undo/Redo
void CChoreoView::Undo( void )
{
if ( m_UndoStack.Size() > 0 && m_nUndoLevel > 0 )
{
m_nUndoLevel--;
CVUndo *u = m_UndoStack[ m_nUndoLevel ];
Assert( u->undo );
DeleteSceneWidgets();
*m_pScene = *(u->undo);
g_MDLViewer->InitGridSettings();
CreateSceneWidgets();
ReportSceneClearToTools();
ClearStatusArea();
m_pClickedActor = NULL;
m_pClickedChannel = NULL;
m_pClickedEvent = NULL;
m_pClickedGlobalEvent = NULL;
}
InvalidateLayout();
}
void CChoreoView::Redo( void )
{
if ( m_UndoStack.Size() > 0 && m_nUndoLevel <= m_UndoStack.Size() - 1 )
{
CVUndo *u = m_UndoStack[ m_nUndoLevel ];
Assert( u->redo );
DeleteSceneWidgets();
*m_pScene = *(u->redo);
g_MDLViewer->InitGridSettings();
CreateSceneWidgets();
ReportSceneClearToTools();
ClearStatusArea();
m_pClickedActor = NULL;
m_pClickedChannel = NULL;
m_pClickedEvent = NULL;
m_pClickedGlobalEvent = NULL;
m_nUndoLevel++;
}
InvalidateLayout();
}
static char *CopyString( const char *in )
{
int len = strlen( in );
char *n = new char[ len + 1 ];
strcpy( n, in );
return n;
}
void CChoreoView::PushUndo( const char *description )
{
Assert( !m_bRedoPending );
m_bRedoPending = true;
WipeRedo();
// Copy current data
CChoreoScene *u = new CChoreoScene( this );
*u = *m_pScene;
CVUndo *undo = new CVUndo;
undo->undo = u;
undo->redo = NULL;
undo->udescription = CopyString( description );
undo->rdescription = NULL;
m_UndoStack.AddToTail( undo );
m_nUndoLevel++;
}
void CChoreoView::PushRedo( const char *description )
{
Assert( m_bRedoPending );
m_bRedoPending = false;
// Copy current data
CChoreoScene *r = new CChoreoScene( this );
*r = *m_pScene;
CVUndo *undo = m_UndoStack[ m_nUndoLevel - 1 ];
undo->redo = r;
undo->rdescription = CopyString( description );
// Always redo here to reflect that someone has made a change
redraw();
}
void CChoreoView::WipeUndo( void )
{
while ( m_UndoStack.Size() > 0 )
{
CVUndo *u = m_UndoStack[ 0 ];
delete u->undo;
delete u->redo;
delete[] u->udescription;
delete[] u->rdescription;
delete u;
m_UndoStack.Remove( 0 );
}
m_nUndoLevel = 0;
}
void CChoreoView::WipeRedo( void )
{
// Wipe everything above level
while ( m_UndoStack.Size() > m_nUndoLevel )
{
CVUndo *u = m_UndoStack[ m_nUndoLevel ];
delete u->undo;
delete u->redo;
delete[] u->udescription;
delete[] u->rdescription;
delete u;
m_UndoStack.Remove( m_nUndoLevel );
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Output : const char
//-----------------------------------------------------------------------------
const char *CChoreoView::GetUndoDescription( void )
{
if ( CanUndo() )
{
CVUndo *u = m_UndoStack[ m_nUndoLevel - 1 ];
return u->udescription;
}
return "???undo";
}
//-----------------------------------------------------------------------------
// Purpose:
// Output : const char
//-----------------------------------------------------------------------------
const char *CChoreoView::GetRedoDescription( void )
{
if ( CanRedo() )
{
CVUndo *u = m_UndoStack[ m_nUndoLevel ];
return u->rdescription;
}
return "???redo";
}
//-----------------------------------------------------------------------------
// Purpose:
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CChoreoView::CanUndo()
{
return m_nUndoLevel != 0;
}
//-----------------------------------------------------------------------------
// Purpose:
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CChoreoView::CanRedo()
{
return m_nUndoLevel != m_UndoStack.Size();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CChoreoView::OnGestureTool( void )
{
if ( m_pClickedEvent->GetEvent()->GetType() != CChoreoEvent::GESTURE )
return;
g_pGestureTool->SetEvent( m_pClickedEvent->GetEvent() );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CChoreoView::OnExpressionTool( void )
{
if ( m_pClickedEvent->GetEvent()->GetType() != CChoreoEvent::FLEXANIMATION )
return;
g_pExpressionTool->SetEvent( m_pClickedEvent->GetEvent() );
}
//-----------------------------------------------------------------------------
// Purpose:
// Output : CChoreoScene
//-----------------------------------------------------------------------------
CChoreoScene *CChoreoView::GetScene( void )
{
return m_pScene;
}
bool CChoreoView::CanPaste( void )
{
char const *copyfile = COPYPASTE_FILENAME;
if ( !filesystem->FileExists( copyfile ) )
{
return false;
}
return true;
}
void CChoreoView::CopyEvents( void )
{
if ( !m_pScene )
return;
char const *copyfile = COPYPASTE_FILENAME;
MakeFileWriteable( copyfile );
ExportVCDFile( copyfile );
}
void CChoreoView::PasteEvents( void )
{
if ( !m_pScene )
return;
if ( !CanPaste() )
return;
char const *copyfile = COPYPASTE_FILENAME;
ImportVCDFile( copyfile );
}
void CChoreoView::ImportEvents( void )
{
if ( !m_pScene )
return;
if ( !m_pClickedActor || !m_pClickedChannel )
return;
char eventfile[ 512 ];
if ( !FacePoser_ShowOpenFileNameDialog( eventfile, sizeof( eventfile ), "scenes", "*.vce" ) )
return;
char fullpathbuf[ 512 ];
char *fullpath = eventfile;
if ( !Q_IsAbsolutePath( eventfile ) )
{
filesystem->RelativePathToFullPath( eventfile, "GAME", fullpathbuf, sizeof( fullpathbuf ) );
fullpath = fullpathbuf;
}
if ( !filesystem->FileExists( fullpath ) )
return;
LoadScriptFile( fullpath );
DeselectAll();
SetDirty( true );
PushUndo( "Import Events" );
m_pScene->ImportEvents( tokenprocessor, m_pClickedActor->GetActor(), m_pClickedChannel->GetChannel() );
PushRedo( "Import Events" );
CreateSceneWidgets();
// Redraw
InvalidateLayout();
Con_Printf( "Imported events from %s\n", fullpath );
}
void CChoreoView::ExportEvents( void )
{
char eventfilename[ 512 ];
if ( !FacePoser_ShowSaveFileNameDialog( eventfilename, sizeof( eventfilename ), "scenes", "*.vce" ) )
return;
Q_DefaultExtension( eventfilename, ".vce", sizeof( eventfilename ) );
Con_Printf( "Exporting events to %s\n", eventfilename );
// Write to file
CUtlVector< CChoreoEvent * > events;
// Find selected eventss
for ( int i = 0; i < m_SceneActors.Size(); i++ )
{
CChoreoActorWidget *a = m_SceneActors[ i ];
if ( !a )
continue;
for ( int j = 0; j < a->GetNumChannels(); j++ )
{
CChoreoChannelWidget *c = a->GetChannel( j );
if ( !c )
continue;
for ( int k = 0; k < c->GetNumEvents(); k++ )
{
CChoreoEventWidget *e = c->GetEvent( k );
if ( !e )
continue;
if ( !e->IsSelected() )
continue;
CChoreoEvent *event = e->GetEvent();
if ( !event )
continue;
events.AddToTail( event );
}
}
}
if ( events.Size() > 0 )
{
m_pScene->ExportEvents( eventfilename, events );
}
else
{
Con_Printf( "No events selected\n" );
}
}
void CChoreoView::ExportVCDFile( char const *filename )
{
Con_Printf( "Exporting to %s\n", filename );
// Unmark everything
m_pScene->MarkForSaveAll( false );
// Mark everything related to selected events
for ( int i = 0; i < m_SceneActors.Size(); i++ )
{
CChoreoActorWidget *a = m_SceneActors[ i ];
if ( !a )
continue;
for ( int j = 0; j < a->GetNumChannels(); j++ )
{
CChoreoChannelWidget *c = a->GetChannel( j );
if ( !c )
continue;
for ( int k = 0; k < c->GetNumEvents(); k++ )
{
CChoreoEventWidget *e = c->GetEvent( k );
if ( !e )
continue;
if ( !e->IsSelected() )
continue;
CChoreoEvent *event = e->GetEvent();
if ( !event )
continue;
event->SetMarkedForSave( true );
if ( event->GetChannel() )
{
event->GetChannel()->SetMarkedForSave( true );
}
if ( event->GetActor() )
{
event->GetActor()->SetMarkedForSave( true );
}
}
}
}
m_pScene->ExportMarkedToFile( filename );
}
void CChoreoView::ImportVCDFile( char const *filename )
{
CChoreoScene *merge = LoadScene( filename );
if ( !merge )
{
Con_Printf( "Couldn't load from .vcd %s\n", filename );
return;
}
DeselectAll();
CUtlRBTree< CChoreoEvent *, int > oldEvents( 0, 0, DefLessFunc( CChoreoEvent * ) );
int i;
for ( i = 0; i < m_SceneActors.Count(); ++i )
{
CChoreoActorWidget *actor = m_SceneActors[ i ];
if ( !actor )
continue;
for ( int j = 0; j < actor->GetNumChannels(); j++ )
{
CChoreoChannelWidget *channel = actor->GetChannel( j );
if ( !channel )
continue;
for ( int k = 0; k < channel->GetNumEvents(); k++ )
{
CChoreoEventWidget *event = channel->GetEvent( k );
if ( !event )
continue;
oldEvents.Insert( event->GetEvent() );
}
}
}
SetDirty( true );
PushUndo( "Merge/Import VCD" );
m_pScene->Merge( merge );
PushRedo( "Merge/Import VCD" );
DeleteSceneWidgets();
CreateSceneWidgets();
// Force scroll bars to recompute
ForceScrollBarsToRecompute( false );
// Now walk through the "new" events and select everything that wasn't already there (all of the stuff that was "added" during the merge)
for ( i = 0; i < m_SceneActors.Count(); ++i )
{
CChoreoActorWidget *actor = m_SceneActors[ i ];
if ( !actor )
continue;
for ( int j = 0; j < actor->GetNumChannels(); j++ )
{
CChoreoChannelWidget *channel = actor->GetChannel( j );
if ( !channel )
continue;
for ( int k = 0; k < channel->GetNumEvents(); k++ )
{
CChoreoEventWidget *event = channel->GetEvent( k );
if ( !event )
continue;
if ( oldEvents.Find( event->GetEvent() ) == oldEvents.InvalidIndex() )
{
event->SetSelected( true );
}
}
}
}
// Redraw
InvalidateLayout();
Con_Printf( "Imported vcd '%s'\n", filename );
delete merge;
redraw();
}
void CChoreoView::ExportVCD()
{
char scenefile[ 512 ];
if ( !FacePoser_ShowSaveFileNameDialog( scenefile, sizeof( scenefile ), "scenes", "*.vcd" ) )
{
return;
}
Q_DefaultExtension( scenefile, ".vcd", sizeof( scenefile ) );
ExportVCDFile( scenefile );
}
void CChoreoView::ImportVCD()
{
if ( !m_pScene )
return;
if ( !m_pClickedActor || !m_pClickedChannel )
return;
char scenefile[ 512 ];
if ( !FacePoser_ShowOpenFileNameDialog( scenefile, sizeof( scenefile ), "scenes", "*.vcd" ) )
{
return;
}
ImportVCDFile( scenefile );
}
//-----------------------------------------------------------------------------
// Purpose:
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CChoreoView::IsProcessing( void )
{
if ( !m_pScene )
return false;
if ( m_flScrub != m_flScrubTarget )
return true;
return false;
}
//-----------------------------------------------------------------------------
// Purpose:
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CChoreoView::ShouldProcessSpeak( void )
{
if ( !g_pControlPanel->AllToolsDriveSpeech() )
{
if ( !IsActiveTool() )
return false;
}
if ( IFacePoserToolWindow::IsAnyToolScrubbing() )
return true;
if ( IFacePoserToolWindow::IsAnyToolProcessing() )
return true;
return false;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *scene -
// *event -
//-----------------------------------------------------------------------------
void CChoreoView::ProcessSpeak( CChoreoScene *scene, CChoreoEvent *event )
{
if ( !ShouldProcessSpeak() )
return;
Assert( event->GetType() == CChoreoEvent::SPEAK );
Assert( scene );
float t = scene->GetTime();
StudioModel *model = FindAssociatedModel( scene, event->GetActor() );
// See if we should trigger CC
char soundname[ 512 ];
Q_strncpy( soundname, event->GetParameters(), sizeof( soundname ) );
float actualEndTime = event->GetEndTime();
if ( event->GetCloseCaptionType() == CChoreoEvent::CC_MASTER )
{
char tok[ CChoreoEvent::MAX_CCTOKEN_STRING ];
if ( event->GetPlaybackCloseCaptionToken( tok, sizeof( tok ) ) )
{
// Use the token as the sound name lookup, too.
if ( event->IsUsingCombinedFile() &&
( event->GetNumSlaves() > 0 ) )
{
Q_strncpy( soundname, tok, sizeof( soundname ) );
actualEndTime = max( actualEndTime, event->GetLastSlaveEndTime() );
}
}
}
CAudioMixer *mixer = event->GetMixer();
if ( !mixer || !sound->IsSoundPlaying( mixer ) )
{
CSoundParameters params;
float volume = VOL_NORM;
gender_t gender = GENDER_NONE;
if (model)
{
gender = soundemitter->GetActorGender( model->GetFileName() );
}
if ( !Q_stristr( soundname, ".wav" ) &&
soundemitter->GetParametersForSound( soundname, params, gender ) )
{
volume = params.volume;
}
sound->PlaySound(
model,
volume,
va( "sound/%s", FacePoser_TranslateSoundName( soundname, model ) ),
&mixer );
event->SetMixer( mixer );
}
mixer = event->GetMixer();
if ( !mixer )
return;
mixer->SetDirection( m_flFrameTime >= 0.0f );
float starttime, endtime;
starttime = event->GetStartTime();
endtime = actualEndTime;
float soundtime = endtime - starttime;
if ( soundtime <= 0.0f )
return;
float f = ( t - starttime ) / soundtime;
f = clamp( f, 0.0f, 1.0f );
// Compute sample
float numsamples = (float)mixer->GetSource()->SampleCount();
int cursample = f * numsamples;
cursample = clamp( cursample, 0, numsamples - 1 );
int realsample = mixer->GetSamplePosition();
int dsample = cursample - realsample;
int samplelimit = mixer->GetSource()->SampleRate() * 0.02f; // don't shift until samples are off by this much
if (IsScrubbing())
{
samplelimit = mixer->GetSource()->SampleRate() * 0.01f; // make it shorter tolerance when scrubbing
}
if ( abs( dsample ) > samplelimit )
{
mixer->SetSamplePosition( cursample, IsScrubbing() );
}
mixer->SetActive( true );
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *event -
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
void CChoreoView::ProcessSubscene( CChoreoScene *scene, CChoreoEvent *event )
{
Assert( event->GetType() == CChoreoEvent::SUBSCENE );
CChoreoScene *subscene = event->GetSubScene();
if ( !subscene )
return;
if ( subscene->SimulationFinished() )
return;
// Have subscenes think for appropriate time
subscene->Think( m_flScrub );
}
void CChoreoView::PositionControls()
{
int topx = GetCaptionHeight() + SCRUBBER_HEIGHT;
int bx = 2;
int bw = 16;
m_btnPlay->setBounds( bx, topx + 4, 16, 16 );
bx += bw + 2;
m_btnPause->setBounds( bx, topx + 4, 16, 16 );
bx += bw + 2;
m_btnStop->setBounds( bx, topx + 4, 16, 16 );
bx += bw + 2;
m_pPlaybackRate->setBounds( bx, topx + 4, 100, 16 );
}
void CChoreoView::SetChoreoFile( char const *filename )
{
strcpy( m_szChoreoFile, filename );
if ( m_szChoreoFile[ 0 ] )
{
char sz[ 256 ];
if ( IsFileWriteable( m_szChoreoFile ) )
{
Q_snprintf( sz, sizeof( sz ), " - %s", m_szChoreoFile );
}
else
{
Q_snprintf( sz, sizeof( sz ), " - %s [Read-Only]", m_szChoreoFile );
}
SetSuffix( sz );
}
else
{
SetSuffix( "" );
}
}
char const *CChoreoView::GetChoreoFile( void ) const
{
return m_szChoreoFile;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : rcHandle -
//-----------------------------------------------------------------------------
void CChoreoView::GetScrubHandleRect( RECT& rcHandle, bool clipped )
{
float pixel = 0.0f;
if ( m_pScene )
{
float currenttime = m_flScrub;
float starttime = m_flStartTime;
float endtime = m_flEndTime;
float screenfrac = ( currenttime - starttime ) / ( endtime - starttime );
pixel = GetLabelWidth() + screenfrac * ( w2() - GetLabelWidth() );
if ( clipped )
{
pixel = clamp( pixel, SCRUBBER_HANDLE_WIDTH/2, w2() - SCRUBBER_HANDLE_WIDTH/2 );
}
}
rcHandle.left = pixel-SCRUBBER_HANDLE_WIDTH/2;
rcHandle.right = pixel + SCRUBBER_HANDLE_WIDTH/2;
rcHandle.top = 2 + GetCaptionHeight();
rcHandle.bottom = rcHandle.top + SCRUBBER_HANDLE_HEIGHT;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : rcArea -
//-----------------------------------------------------------------------------
void CChoreoView::GetScrubAreaRect( RECT& rcArea )
{
rcArea.left = 0;
rcArea.right = w2();
rcArea.top = 2 + GetCaptionHeight();
rcArea.bottom = rcArea.top + SCRUBBER_HEIGHT - 4;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : drawHelper -
// rcHandle -
//-----------------------------------------------------------------------------
void CChoreoView::DrawScrubHandle( CChoreoWidgetDrawHelper& drawHelper )
{
RECT rcHandle;
GetScrubHandleRect( rcHandle, true );
HBRUSH br = CreateSolidBrush( RGB( 0, 150, 100 ) );
drawHelper.DrawFilledRect( br, rcHandle );
//
char sz[ 32 ];
sprintf( sz, "%.3f", m_flScrub );
int len = drawHelper.CalcTextWidth( "Arial", 9, 500, sz );
RECT rcText = rcHandle;
int textw = rcText.right - rcText.left;
rcText.left += ( textw - len ) / 2;
drawHelper.DrawColoredText( "Arial", 9, 500, RGB( 255, 255, 255 ), rcText, sz );
DeleteObject( br );
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *event -
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CChoreoView::IsMouseOverScrubHandle( mxEvent *event )
{
RECT rcHandle;
GetScrubHandleRect( rcHandle, true );
InflateRect( &rcHandle, 2, 2 );
POINT pt;
pt.x = (short)event->x;
pt.y = (short)event->y;
if ( PtInRect( &rcHandle, pt ) )
{
return true;
}
return false;
}
bool CChoreoView::IsMouseOverScrubArea( mxEvent *event )
{
RECT rcArea;
GetScrubAreaRect( rcArea );
InflateRect( &rcArea, 2, 2 );
POINT pt;
pt.x = (short)event->x;
pt.y = (short)event->y;
if ( PtInRect( &rcArea, pt ) )
{
return true;
}
return false;
}
bool CChoreoView::IsScrubbing( void ) const
{
bool scrubbing = ( m_nDragType == DRAGTYPE_SCRUBBER ) ? true : false;
return scrubbing;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : dt -
//-----------------------------------------------------------------------------
void CChoreoView::Think( float dt )
{
bool scrubbing = IFacePoserToolWindow::IsAnyToolScrubbing();
ScrubThink( dt, scrubbing, this );
}
static int lastthinkframe = -1;
void CChoreoView::ScrubThink( float dt, bool scrubbing, IFacePoserToolWindow *invoker )
{
// Make sure we don't get called more than once per frame
int thisframe = g_MDLViewer->GetCurrentFrame();
if ( thisframe == lastthinkframe )
return;
lastthinkframe = thisframe;
if ( !m_pScene )
return;
if ( m_flScrubTarget == m_flScrub && !scrubbing )
{
// Act like it's paused
if ( IFacePoserToolWindow::ShouldAutoProcess() )
{
m_bSimulating = true;
SceneThink( m_flScrub );
}
if ( m_bSimulating && !m_bPaused )
{
//FinishSimulation();
}
return;
}
// Make sure we're solving head turns during playback
models->SetSolveHeadTurn( 1 );
if ( m_bPaused )
{
SceneThink( m_flScrub );
return;
}
// Make sure phonemes are loaded
FacePoser_EnsurePhonemesLoaded();
if ( !m_bSimulating )
{
m_bSimulating = true;
}
float d = m_flScrubTarget - m_flScrub;
int sign = d > 0.0f ? 1 : -1;
float maxmove = dt * m_flPlaybackRate;
float prevScrub = m_flScrub;
if ( sign > 0 )
{
if ( d < maxmove )
{
m_flScrub = m_flScrubTarget;
}
else
{
m_flScrub += maxmove;
}
}
else
{
if ( -d < maxmove )
{
m_flScrub = m_flScrubTarget;
}
else
{
m_flScrub -= maxmove;
}
}
m_flFrameTime = ( m_flScrub - prevScrub );
SceneThink( m_flScrub );
DrawScrubHandle();
if ( scrubbing )
{
g_pMatSysWindow->Frame();
}
if ( invoker != g_pExpressionTool )
{
g_pExpressionTool->ForceScrubPositionFromSceneTime( m_flScrub );
}
if ( invoker != g_pGestureTool )
{
g_pGestureTool->ForceScrubPositionFromSceneTime( m_flScrub );
}
if ( invoker != g_pRampTool )
{
g_pRampTool->ForceScrubPositionFromSceneTime( m_flScrub );
}
if ( invoker != g_pSceneRampTool )
{
g_pSceneRampTool->ForceScrubPositionFromSceneTime( m_flScrub );
}
}
void CChoreoView::DrawScrubHandle( void )
{
if ( !m_bCanDraw )
return;
// Handle new time and
RECT rcArea;
GetScrubAreaRect( rcArea );
CChoreoWidgetDrawHelper drawHelper( this, rcArea, COLOR_CHOREO_BACKGROUND );
DrawScrubHandle( drawHelper );
}
void CChoreoView::SetScrubTime( float t )
{
m_flScrub = t;
m_bPaused = false;
}
void CChoreoView::SetScrubTargetTime( float t )
{
m_flScrubTarget = t;
m_bPaused = false;
}
void CChoreoView::ClampTimeToSelectionInterval( float& timeval )
{
// FIXME hook this up later
return;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : show -
//-----------------------------------------------------------------------------
void CChoreoView::ShowButtons( bool show )
{
m_btnPlay->setVisible( show );
m_btnPause->setVisible( show );
m_btnStop->setVisible( show );
m_pPlaybackRate->setVisible( show );
}
void CChoreoView::RememberSelectedEvents( CUtlVector< CChoreoEvent * >& list )
{
GetSelectedEvents( list );
}
void CChoreoView::ReselectEvents( CUtlVector< CChoreoEvent * >& list )
{
for ( int i = 0; i < m_SceneActors.Size(); i++ )
{
CChoreoActorWidget *actor = m_SceneActors[ i ];
if ( !actor )
continue;
for ( int j = 0; j < actor->GetNumChannels(); j++ )
{
CChoreoChannelWidget *channel = actor->GetChannel( j );
if ( !channel )
continue;
for ( int k = 0; k < channel->GetNumEvents(); k++ )
{
CChoreoEventWidget *event = channel->GetEvent( k );
if ( !event )
continue;
CChoreoEvent *check = event->GetEvent();
if ( list.Find( check ) != list.InvalidIndex() )
{
event->SetSelected( true );
}
}
}
}
}
void CChoreoView::OnChangeScale( void )
{
CChoreoScene *scene = m_pScene;
if ( !scene )
{
return;
}
// Zoom time in / out
CInputParams params;
memset( &params, 0, sizeof( params ) );
strcpy( params.m_szDialogTitle, "Change Zoom" );
strcpy( params.m_szPrompt, "New scale (e.g., 2.5x):" );
Q_snprintf( params.m_szInputText, sizeof( params.m_szInputText ), "%.2f", (float)GetTimeZoom( GetToolName() ) / 100.0f );
if ( !InputProperties( &params ) )
return;
SetTimeZoom( GetToolName(), clamp( (int)( 100.0f * atof( params.m_szInputText ) ), 1, MAX_TIME_ZOOM ), false );
// Force scroll bars to recompute
ForceScrollBarsToRecompute( false );
CUtlVector< CChoreoEvent * > selected;
RememberSelectedEvents( selected );
DeleteSceneWidgets();
CreateSceneWidgets();
ReselectEvents( selected );
InvalidateLayout();
Con_Printf( "Zoom factor %i %%\n", GetTimeZoom( GetToolName() ) );
}
void CChoreoView::OnCheckSequenceLengths( void )
{
if ( !m_pScene )
return;
Con_Printf( "Checking sequence durations...\n" );
bool changed = FixupSequenceDurations( m_pScene, true );
if ( !changed )
{
Con_Printf( " no changes...\n" );
return;
}
SetDirty( true );
PushUndo( "Check sequence lengths" );
FixupSequenceDurations( m_pScene, false );
PushRedo( "Check sequence lengths" );
InvalidateLayout();
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *scene -
//-----------------------------------------------------------------------------
void CChoreoView::InvalidateTrackLookup_R( CChoreoScene *scene )
{
// No need to undo since this data doesn't matter
int c = scene->GetNumEvents();
for ( int i = 0; i < c; i++ )
{
CChoreoEvent *event = scene->GetEvent( i );
if ( !event )
continue;
switch ( event->GetType() )
{
default:
break;
case CChoreoEvent::FLEXANIMATION:
{
event->SetTrackLookupSet( false );
}
break;
case CChoreoEvent::SUBSCENE:
{
CChoreoScene *sub = event->GetSubScene();
// NOTE: Don't bother loading it now if it's not on hand
if ( sub )
{
InvalidateTrackLookup_R( sub );
}
}
break;
}
}
}
//-----------------------------------------------------------------------------
// Purpose: Model changed so we'll have to re-index flex anim tracks
//-----------------------------------------------------------------------------
void CChoreoView::InvalidateTrackLookup( void )
{
if ( !m_pScene )
return;
InvalidateTrackLookup_R( m_pScene );
}
bool CChoreoView::IsRampOnly( void ) const
{
return m_bRampOnly;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *scene -
// *event -
//-----------------------------------------------------------------------------
void CChoreoView::ProcessInterrupt( CChoreoScene *scene, CChoreoEvent *event )
{
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *scene -
// *event -
//-----------------------------------------------------------------------------
void CChoreoView::ProcessPermitResponses( CChoreoScene *scene, CChoreoEvent *event )
{
}
void CChoreoView::ApplyBounds( int& mx, int& my )
{
if ( !m_bUseBounds )
return;
mx = clamp( mx, m_nMinX, m_nMaxX );
}
//-----------------------------------------------------------------------------
// Purpose: Returns -1 if no event found
// Input : *channel -
// *e -
// forward -
// Output : float
//-----------------------------------------------------------------------------
float CChoreoView::FindNextEventTime( CChoreoEvent::EVENTTYPE type, CChoreoChannel *channel, CChoreoEvent *e, bool forward )
{
bool foundone = false;
float bestTime = -1.0f;
float bestGap = 999999.0f;
int c = channel->GetNumEvents();
for ( int i = 0; i < c; i++ )
{
CChoreoEvent *test = channel->GetEvent( i );
if ( test->GetType() != type )
continue;
if ( forward )
{
float dt = test->GetStartTime() - e->GetEndTime();
if ( dt <= 0.0f )
continue;
if ( dt < bestGap )
{
foundone = true;
bestGap = dt;
bestTime = test->GetStartTime();
}
}
else
{
float dt = e->GetStartTime() - test->GetEndTime();
if ( dt <= 0.0f )
continue;
if ( dt < bestGap )
{
foundone = true;
bestGap = dt;
bestTime = test->GetEndTime();
}
}
}
return bestTime;
}
void CChoreoView::CalcBounds( int movetype )
{
m_bUseBounds = false;
m_nMinX = 0;
m_nMaxX = 0;
if ( !m_pClickedEvent )
return;
switch ( movetype )
{
default:
break;
case DRAGTYPE_EVENT_MOVE:
case DRAGTYPE_EVENT_STARTTIME:
case DRAGTYPE_EVENT_ENDTIME:
case DRAGTYPE_EVENT_STARTTIME_RESCALE:
case DRAGTYPE_EVENT_ENDTIME_RESCALE:
{
m_nMinX = GetPixelForTimeValue( 0 );
m_nMaxX = GetPixelForTimeValue( m_pScene->FindStopTime() );
CChoreoEvent *e = m_pClickedEvent->GetEvent();
m_bUseBounds = false; // e && e->GetType() == CChoreoEvent::GESTURE;
// FIXME: use this for finding adjacent gesture edges (kenb)
if ( m_bUseBounds )
{
CChoreoChannel *channel = e->GetChannel();
Assert( channel );
float forwardTime = FindNextEventTime( e->GetType(), channel, e, true );
float reverseTime = FindNextEventTime( e->GetType(), channel, e, false );
// Compute pixel for time
int nextPixel = forwardTime != -1 ? GetPixelForTimeValue( forwardTime ) : m_nMaxX;
int prevPixel = reverseTime != -1 ? GetPixelForTimeValue( reverseTime ) : m_nMinX;
int startPixel = GetPixelForTimeValue( e->GetStartTime() );
int endPixel = GetPixelForTimeValue( e->GetEndTime() );
switch ( movetype )
{
case DRAGTYPE_EVENT_MOVE:
{
m_nMinX = prevPixel + ( m_xStart - startPixel ) + 1;
m_nMaxX = nextPixel - ( endPixel - m_xStart ) - 1;
}
break;
case DRAGTYPE_EVENT_STARTTIME:
case DRAGTYPE_EVENT_STARTTIME_RESCALE:
{
m_nMinX = prevPixel + ( m_xStart - startPixel ) + 1;
}
break;
case DRAGTYPE_EVENT_ENDTIME:
case DRAGTYPE_EVENT_ENDTIME_RESCALE:
{
m_nMaxX = nextPixel - ( endPixel - m_xStart ) - 1;
}
break;
}
}
}
break;
}
}
bool CChoreoView::ShouldSelectEvent( SelectionParams_t &params, CChoreoEvent *event )
{
if ( params.forward )
{
if ( event->GetStartTime() >= params.time )
return true;
}
else
{
float endtime = event->HasEndTime() ? event->GetEndTime() : event->GetStartTime();
if ( endtime <= params.time )
return true;
}
return false;
}
void CChoreoView::SelectEvents( SelectionParams_t& params )
{
if ( !m_pScene )
return;
if ( !m_pClickedActor )
return;
if ( params.type == SelectionParams_t::SP_CHANNEL && !m_pClickedChannel )
return;
//CChoreoActor *actor = m_pClickedActor->GetActor();
CChoreoChannel *channel = m_pClickedChannel ? m_pClickedChannel->GetChannel() : NULL;
for ( int i = 0; i < m_SceneActors.Size(); i++ )
{
CChoreoActorWidget *a = m_SceneActors[ i ];
if ( !a )
continue;
//if ( a->GetActor() != actor )
// continue;
for ( int j = 0; j < a->GetNumChannels(); j++ )
{
CChoreoChannelWidget *c = a->GetChannel( j );
if ( !c )
continue;
if ( params.type == SelectionParams_t::SP_CHANNEL &&
c->GetChannel() != channel )
continue;
if ( params.type == SelectionParams_t::SP_ACTIVE &&
!c->GetChannel()->GetActive() )
continue;
for ( int k = 0; k < c->GetNumEvents(); k++ )
{
CChoreoEventWidget *e = c->GetEvent( k );
if ( !e )
continue;
CChoreoEvent *event = e->GetEvent();
if ( !event )
continue;
if ( !ShouldSelectEvent( params, event ) )
continue;
e->SetSelected( true );
}
}
}
// Now handle global events, too
for ( int i = 0; i < m_SceneGlobalEvents.Count(); i++ )
{
CChoreoGlobalEventWidget *e = m_SceneGlobalEvents[ i ];
if ( !e )
continue;
CChoreoEvent *event = e->GetEvent();
if ( !event )
continue;
if ( !ShouldSelectEvent( params, event ) )
continue;
e->SetSelected( true );
}
redraw();
}
void CChoreoView::SetTimeZoom( char const *tool, int tz, bool preserveFocus )
{
if ( !m_pScene )
return;
// No change
int oldZoom = GetTimeZoom( tool );
if ( tz == oldZoom )
return;
SetDirty( true );
POINT pt;
::GetCursorPos( &pt );
::ScreenToClient( (HWND)getHandle(), &pt );
// Now figure out time under cursor at old zoom scale
float t = GetTimeValueForMouse( pt.x, true );
m_pScene->SetTimeZoom( tool, tz );
if ( preserveFocus )
{
RECT rc;
GetClientRect( (HWND)getHandle(), &rc );
RECT rcClient = rc;
rcClient.top += GetStartRow();
OffsetRect( &rcClient, 0, -m_nTopOffset );
m_flStartTime = m_flLeftOffset / GetPixelsPerSecond();
m_flEndTime = m_flStartTime + (float)( rcClient.right - GetLabelWidth() ) / GetPixelsPerSecond();
// Now figure out tie under pt.x
float newT = GetTimeValueForMouse( pt.x, true );
if ( newT != t )
{
// We need to scroll over a bit
float pps = GetPixelsPerSecond();
float movePixels = pps * ( newT - t );
m_flLeftOffset -= movePixels;
if ( m_flLeftOffset < 0.0f )
{
//float fixup = - m_flLeftOffset;
m_flLeftOffset = 0;
}
// float maxtime = m_pScene->FindStopTime();
float flApparentEndTime = max( m_pScene->FindStopTime(), 5.0f ) + 5.0f;
if ( m_flEndTime > flApparentEndTime )
{
movePixels = pps * ( m_flEndTime - flApparentEndTime );
m_flLeftOffset = max( 0.0f, m_flLeftOffset - movePixels );
}
}
}
// Deal with the slider
RepositionHSlider();
redraw();
}
int CChoreoView::GetTimeZoom( char const *tool )
{
if ( !m_pScene )
return 100;
return m_pScene->GetTimeZoom( tool );
}
void CChoreoView::CheckInsertTime( CChoreoEvent *e, float dt, float starttime, float endtime )
{
// Not influenced
float eventend = e->HasEndTime() ? e->GetEndTime() : e->GetStartTime();
if ( eventend < starttime )
return;
if ( e->GetStartTime() > starttime )
{
e->OffsetTime( dt );
e->SnapTimes();
}
else if ( !e->IsFixedLength() && e->HasEndTime() ) // the event starts before start, but ends after start time, need to insert space into the event, act like user dragged end time
{
float newduration = e->GetDuration() + dt;
RescaleRamp( e, newduration );
switch ( e->GetType() )
{
default:
break;
case CChoreoEvent::GESTURE:
{
e->RescaleGestureTimes( e->GetStartTime(), e->GetEndTime() + dt, true );
}
break;
case CChoreoEvent::FLEXANIMATION:
{
RescaleExpressionTimes( e, e->GetStartTime(), e->GetEndTime() + dt );
}
break;
}
e->OffsetEndTime( dt );
e->SnapTimes();
e->ResortRamp();
}
switch ( e->GetType() )
{
default:
break;
case CChoreoEvent::SPEAK:
{
// Try and load wav to get length
CAudioSource *wave = sound->LoadSound( va( "sound/%s", FacePoser_TranslateSoundName( e ) ) );
if ( wave )
{
e->SetEndTime( e->GetStartTime() + wave->GetRunningLength() );
delete wave;
}
}
break;
case CChoreoEvent::SEQUENCE:
{
CheckSequenceLength( e, false );
}
break;
case CChoreoEvent::GESTURE:
{
CheckGestureLength( e, false );
}
break;
}
}
void CChoreoView::OnInsertTime()
{
if ( !m_rgABPoints[ 0 ].active &&
!m_rgABPoints[ 1 ].active )
{
return;
}
Con_Printf( "OnInsertTime()\n" );
float starttime = m_rgABPoints[ 0 ].time;
float endtime = m_rgABPoints[ 1 ].time;
// Sort samples correctly
if ( starttime > endtime )
{
float temp = starttime;
starttime = endtime;
endtime = temp;
}
float dt = endtime - starttime;
if ( dt == 0.0f )
{
// Nothing to do...
return;
}
SetDirty( true );
PushUndo( "Insert Time" );
for ( int i = 0; i < m_SceneActors.Size(); i++ )
{
CChoreoActorWidget *actor = m_SceneActors[ i ];
if ( !actor )
continue;
for ( int j = 0; j < actor->GetNumChannels(); j++ )
{
CChoreoChannelWidget *channel = actor->GetChannel( j );
if ( !channel )
continue;
for ( int k = 0; k < channel->GetNumEvents(); k++ )
{
CChoreoEventWidget *event = channel->GetEvent( k );
if ( !event )
continue;
CChoreoEvent *e = event->GetEvent();
if ( !e )
continue;
CheckInsertTime( e, dt, starttime, endtime );
}
}
}
// Now handle global events, too
for ( int i = 0; i < m_SceneGlobalEvents.Count(); i++ )
{
CChoreoGlobalEventWidget *event = m_SceneGlobalEvents[ i ];
if ( !event )
continue;
CChoreoEvent *e = event->GetEvent();
if ( !e )
continue;
CheckInsertTime( e, dt, starttime, endtime );
}
PushRedo( "Insert Time" );
InvalidateLayout();
g_pExpressionTool->LayoutItems( true );
g_pExpressionTool->redraw();
g_pGestureTool->redraw();
g_pRampTool->redraw();
g_pSceneRampTool->redraw();
}
void CChoreoView::CheckDeleteTime( CChoreoEvent *e, float dt, float starttime, float endtime, bool& deleteEvent )
{
deleteEvent = false;
// Not influenced
float eventend = e->HasEndTime() ? e->GetEndTime() : e->GetStartTime();
if ( eventend < starttime )
{
return;
}
// On right side of start mark, just shift left
if ( e->GetStartTime() > starttime )
{
// If it has no duration and it's in the bounds then kill it.
if ( !e->HasEndTime() && e->GetStartTime() < endtime )
{
deleteEvent = true;
return;
}
else
{
float shift = e->GetStartTime() - starttime;
float maxoffset = min( dt, shift );
e->OffsetTime( -maxoffset );
e->SnapTimes();
}
}
else if ( !e->IsFixedLength() && e->HasEndTime() ) // the event starts before start, but ends after start time, need to insert space into the event, act like user dragged end time
{
float shiftend = e->GetEndTime() - starttime;
float maxoffset = min( dt, shiftend );
float newduration = e->GetDuration() - maxoffset;
if ( newduration <= 0.0f )
{
deleteEvent = true;
return;
}
else
{
RescaleRamp( e, newduration );
switch ( e->GetType() )
{
default:
break;
case CChoreoEvent::GESTURE:
{
e->RescaleGestureTimes( e->GetStartTime(), e->GetEndTime() - maxoffset, true );
}
break;
case CChoreoEvent::FLEXANIMATION:
{
RescaleExpressionTimes( e, e->GetStartTime(), e->GetEndTime() - maxoffset );
}
break;
}
e->OffsetEndTime( -maxoffset );
e->SnapTimes();
e->ResortRamp();
}
}
switch ( e->GetType() )
{
default:
break;
case CChoreoEvent::SPEAK:
{
// Try and load wav to get length
CAudioSource *wave = sound->LoadSound( va( "sound/%s", FacePoser_TranslateSoundName( e ) ) );
if ( wave )
{
e->SetEndTime( e->GetStartTime() + wave->GetRunningLength() );
delete wave;
}
}
break;
case CChoreoEvent::SEQUENCE:
{
CheckSequenceLength( e, false );
}
break;
case CChoreoEvent::GESTURE:
{
CheckGestureLength( e, false );
}
break;
}
}
void CChoreoView::OnDeleteTime()
{
if ( !m_rgABPoints[ 0 ].active &&
!m_rgABPoints[ 1 ].active )
{
return;
}
Con_Printf( "OnDeleteTime()\n" );
float starttime = m_rgABPoints[ 0 ].time;
float endtime = m_rgABPoints[ 1 ].time;
// Sort samples correctly
if ( starttime > endtime )
{
float temp = starttime;
starttime = endtime;
endtime = temp;
}
float dt = endtime - starttime;
if ( dt == 0.0f )
{
// Nothing to do...
return;
}
SetDirty( true );
PushUndo( "Delete Time" );
CUtlVector< CChoreoEventWidget * > deletions;
CUtlVector< CChoreoGlobalEventWidget * > global_deletions;
for ( int i = 0; i < m_SceneActors.Size(); i++ )
{
CChoreoActorWidget *actor = m_SceneActors[ i ];
if ( !actor )
continue;
for ( int j = 0; j < actor->GetNumChannels(); j++ )
{
CChoreoChannelWidget *channel = actor->GetChannel( j );
if ( !channel )
continue;
for ( int k = 0; k < channel->GetNumEvents(); k++ )
{
CChoreoEventWidget *event = channel->GetEvent( k );
if ( !event )
continue;
CChoreoEvent *e = event->GetEvent();
if ( !e )
continue;
bool deleteEvent = false;
CheckDeleteTime( e, dt, starttime, endtime, deleteEvent );
if ( deleteEvent )
{
deletions.AddToTail( event );
}
}
}
}
// Now handle global events, too
for ( int i = 0; i < m_SceneGlobalEvents.Count(); i++ )
{
CChoreoGlobalEventWidget *event = m_SceneGlobalEvents[ i ];
if ( !event )
continue;
CChoreoEvent *e = event->GetEvent();
if ( !e )
continue;
bool deleteEvent = false;
CheckDeleteTime( e, dt, starttime, endtime, deleteEvent );
if ( deleteEvent )
{
global_deletions.AddToTail( event );
}
}
for ( int i = 0; i < deletions.Count(); i++ )
{
CChoreoEventWidget *w = deletions[ i ];
CChoreoEvent *e = w->GetEvent();
CChoreoChannel *channel = e->GetChannel();
if ( channel )
{
channel->RemoveEvent( e );
}
m_pScene->DeleteReferencedObjects( e );
}
for ( int i = 0; i < global_deletions.Count(); i++ )
{
CChoreoGlobalEventWidget *w = global_deletions[ i ];
CChoreoEvent *e = w->GetEvent();
m_pScene->DeleteReferencedObjects( e );
}
// Force scroll bars to recompute
ForceScrollBarsToRecompute( false );
if ( deletions.Count() > 0 || global_deletions.Count() > 0 )
{
DeleteSceneWidgets();
CreateSceneWidgets();
}
PushRedo( "Delete Time" );
InvalidateLayout();
g_pExpressionTool->LayoutItems( true );
g_pExpressionTool->redraw();
g_pGestureTool->redraw();
g_pRampTool->redraw();
g_pSceneRampTool->redraw();
}
void CChoreoView::OnModelChanged()
{
InvalidateTrackLookup();
// OnCheckSequenceLengths();
}
void CChoreoView::SetShowCloseCaptionData( bool show )
{
m_bShowCloseCaptionData = show;
}
bool CChoreoView::GetShowCloseCaptionData( void ) const
{
return m_bShowCloseCaptionData;
}
void CChoreoView::OnToggleCloseCaptionTags()
{
m_bShowCloseCaptionData = !m_bShowCloseCaptionData;
InvalidateLayout();
}
static bool EventStartTimeLessFunc( CChoreoEvent * const &p1, CChoreoEvent * const &p2 )
{
CChoreoEvent *w1;
CChoreoEvent *w2;
w1 = const_cast< CChoreoEvent * >( p1 );
w2 = const_cast< CChoreoEvent * >( p2 );
return w1->GetStartTime() < w2->GetStartTime();
}
bool CChoreoView::GenerateCombinedFile( char const *outfilename, char const *cctoken, gender_t gender, CUtlRBTree< CChoreoEvent * >& sorted )
{
CUtlVector< CombinerEntry > work;
char actualfile[ 512 ];
soundemitter->GenderExpandString( gender, outfilename, actualfile, sizeof( actualfile ) );
if ( Q_strlen( actualfile ) <= 0 )
{
return false;
}
int i = sorted.FirstInorder();
if ( i != sorted.InvalidIndex() )
{
CChoreoEvent *e = sorted[ i ];
float startoffset = e->GetStartTime();
do
{
e = sorted[ i ];
float curoffset = e->GetStartTime();
CombinerEntry ce;
Q_snprintf( ce.wavefile, sizeof( ce.wavefile ), "sound/%s", FacePoser_TranslateSoundNameGender( e->GetParameters(), gender ) );
ce.startoffset = curoffset - startoffset;
work.AddToTail( ce );
i = sorted.NextInorder( i );
}
while ( i != sorted.InvalidIndex() );
}
bool ok = soundcombiner->CombineSoundFiles( filesystem, actualfile, work );
if ( !ok )
{
Con_ErrorPrintf( "Failed to create combined sound '%s':'%s'\n", cctoken, actualfile );
return false;
}
Con_Printf( "Created combined sound '%s':'%s'\n", cctoken, actualfile );
return true;
}
bool CChoreoView::ValidateCombinedFileCheckSum( char const *outfilename, char const *cctoken, gender_t gender, CUtlRBTree< CChoreoEvent * >& sorted )
{
CUtlVector< CombinerEntry > work;
char actualfile[ 512 ];
soundemitter->GenderExpandString( gender, outfilename, actualfile, sizeof( actualfile ) );
if ( Q_strlen( actualfile ) <= 0 )
{
return false;
}
int i = sorted.FirstInorder();
if ( i != sorted.InvalidIndex() )
{
CChoreoEvent *e = sorted[ i ];
float startoffset = e->GetStartTime();
do
{
e = sorted[ i ];
float curoffset = e->GetStartTime();
CombinerEntry ce;
Q_snprintf( ce.wavefile, sizeof( ce.wavefile ), "sound/%s", FacePoser_TranslateSoundNameGender( e->GetParameters(), gender ) );
ce.startoffset = curoffset - startoffset;
work.AddToTail( ce );
i = sorted.NextInorder( i );
}
while ( i != sorted.InvalidIndex() );
}
return soundcombiner->IsCombinedFileChecksumValid( filesystem, actualfile, work );
}
void SuggestCaption( char *dest, int destlen, CUtlVector< CChoreoEvent * >& events )
{
// Walk through events and concatenate current captions, or raw wav data if have any
dest[ 0 ] = 0;
int c = events.Count();
for ( int i = 0 ; i < c; ++i )
{
CChoreoEvent *e = events[ i ];
bool found = false;
char tok[ CChoreoEvent::MAX_CCTOKEN_STRING ];
if ( e->GetPlaybackCloseCaptionToken( tok, sizeof( tok ) ) )
{
wchar_t *localized = g_pLocalize->Find( tok );
if ( localized )
{
found = true;
char ansi[ 1024 ];
g_pLocalize->ConvertUnicodeToANSI( localized, ansi, sizeof( ansi ) );
Q_strncat( dest, ansi, destlen, COPY_ALL_CHARACTERS );
}
}
if ( !found )
{
// See if the wav file has data...
CAudioSource *wave = sound->LoadSound( va( "sound/%s", FacePoser_TranslateSoundName( e ) ) );
if ( wave )
{
CSentence *sentence = wave->GetSentence();
if ( sentence )
{
Q_strncat( dest, sentence->GetText(), destlen, COPY_ALL_CHARACTERS );
found = true;
}
}
}
if ( found && Q_strlen( dest ) > 0 && i != c - 1 )
{
Q_strncat( dest, " ", destlen, COPY_ALL_CHARACTERS );
}
}
}
void CChoreoView::OnCombineSpeakEvents()
{
if ( !m_pScene )
return;
CChoreoChannel *firstChannel = NULL;
CUtlVector< CChoreoEvent * > selected;
GetSelectedEvents( selected );
int c = selected.Count();
// Find the appropriate event by iterating across all actors and channels
for ( int i = c - 1; i >= 0; --i )
{
CChoreoEvent *e = selected[ i ];
if ( e->GetType() != CChoreoEvent::SPEAK )
{
Con_ErrorPrintf( "Can't combine events, all events must be SPEAK events.\n" );
return;
}
if ( !firstChannel )
{
firstChannel = e->GetChannel();
}
else if ( e->GetChannel() != firstChannel )
{
Con_ErrorPrintf( "Can't combine events, all events must reside in the same channel.\n" );
return;
}
}
if ( selected.Count() < 2 )
{
Con_ErrorPrintf( "Can't combine events, must have at least two events selected.\n" );
return;
}
// Let the user pick a CC phrase
CCloseCaptionLookupParams params;
Q_strncpy( params.m_szDialogTitle, "Choose Close Caption Token", sizeof( params.m_szDialogTitle ) );
params.m_bPositionDialog = false;
params.m_nLeft = 0;
params.m_nTop = 0;
char playbacktoken[ CChoreoEvent::MAX_CCTOKEN_STRING ];
if ( !selected[0]->GetPlaybackCloseCaptionToken( playbacktoken, sizeof( playbacktoken ) ) )
{
return;
}
if ( !Q_stristr( playbacktoken, "_cc" ) )
{
Q_strncpy( params.m_szCCToken, va( "%s_cc", playbacktoken ), sizeof( params.m_szCCToken ) );
}
else
{
Q_strncpy( params.m_szCCToken, va( "%s", playbacktoken ), sizeof( params.m_szCCToken ) );
}
// User hit okay and value actually changed?
if ( !CloseCaptionLookup( &params ) &&
params.m_szCCToken[0] != 0 )
{
return;
}
// See if the token exists?
StringIndex_t stringIndex = g_pLocalize->FindIndex( params.m_szCCToken );
if ( INVALID_LOCALIZE_STRING_INDEX == stringIndex )
{
// Add token to closecaption_english file.
// Guess at string and ask user to confirm.
CInputParams ip;
memset( &ip, 0, sizeof( ip ) );
Q_strncpy( ip.m_szDialogTitle, "Add Close Caption", sizeof( ip.m_szDialogTitle ) );
Q_snprintf( ip.m_szPrompt, sizeof( ip.m_szPrompt ), "Token (%s):", params.m_szCCToken );
char suggested[ 2048 ];
SuggestCaption( suggested, sizeof( suggested ), selected );
Q_snprintf( ip.m_szInputText, sizeof( ip.m_szInputText ), "%s", suggested );
if ( !InputProperties( &ip ) )
{
Con_Printf( "Combining of sound events cancelled\n" );
return;
}
if ( Q_strlen( ip.m_szInputText ) == 0 )
{
Q_snprintf( ip.m_szInputText, sizeof( ip.m_szInputText ), "!!!%s", params.m_szCCToken );
}
char const *captionFile = "resource/closecaption_english.txt";
if ( !filesystem->IsFileWritable( captionFile, "GAME" ) )
{
Warning( "Forcing %s to be writable!!!\n", captionFile );
MakeFileWriteable( captionFile );
}
wchar_t unicode[ 2048 ];
g_pLocalize->ConvertANSIToUnicode( ip.m_szInputText, unicode, sizeof( unicode ) );
g_pLocalize->AddString( params.m_szCCToken, unicode, captionFile );
g_pLocalize->SaveToFile( captionFile );
}
SetDirty( true );
PushUndo( "Combine Sound Events" );
c = selected.Count();
for ( int i = 0 ; i < c; ++i )
{
selected[ i ]->SetCloseCaptionToken( params.m_szCCToken );
}
PushRedo( "Combine Sound Events" );
// Redraw
InvalidateLayout();
Con_Printf( "Changed %i events to use close caption token '%s'\n", c, params.m_szCCToken );
// Sort the sounds by start time
CUtlRBTree< CChoreoEvent * > sorted( 0, 0, EventStartTimeLessFunc );
// Sort items
c = selected.Count();
bool genderwildcard = false;
for ( int i = 0; i < c; i++ )
{
CChoreoEvent *e = selected[ i ];
sorted.Insert( e );
// Get the sound entry name and use it to look up the gender info
// Look up the sound level from the soundemitter system
if ( !genderwildcard )
{
genderwildcard = soundemitter->IsUsingGenderToken( e->GetParameters() );
}
}
char outfilename[ 512 ];
Q_memset( outfilename, 0, sizeof( outfilename ) );
CChoreoEvent *e = sorted[ sorted.FirstInorder() ];
// Update whether we use the $gender token
e->SetCombinedUsingGenderToken( genderwildcard );
if ( !e->ComputeCombinedBaseFileName( outfilename, sizeof( outfilename ), genderwildcard ) )
{
Con_ErrorPrintf( "Unable to regenerate wav file name for combined sound\n" );
return;
}
int soundindex = soundemitter->GetSoundIndex( e->GetParameters() );
char const *scriptfile = soundemitter->GetSourceFileForSound( soundindex );
if ( !scriptfile || !scriptfile[0] )
{
Con_ErrorPrintf( "Unable to find existing script to use for new combined sound entry.\n" );
return;
}
// Create a new sound entry for this sound
CAddSoundParams asp;
Q_memset( &asp, 0, sizeof( asp ) );
Q_strncpy( asp.m_szDialogTitle, "Add Combined Sound Entry", sizeof( asp.m_szDialogTitle ) );
Q_strncpy( asp.m_szWaveFile, outfilename + Q_strlen( "sound/"), sizeof( asp.m_szWaveFile ) );
Q_strncpy( asp.m_szScriptName, scriptfile, sizeof( asp.m_szScriptName ) );
Q_strncpy( asp.m_szSoundName, params.m_szCCToken, sizeof( asp.m_szSoundName ) );
asp.m_bAllowExistingSound = true;
asp.m_bReadOnlySoundName = true;
if ( !AddSound( &asp, (HWND)g_MDLViewer->getHandle() ) )
{
return;
}
if ( genderwildcard )
{
GenerateCombinedFile( outfilename, params.m_szCCToken, GENDER_MALE, sorted );
GenerateCombinedFile( outfilename, params.m_szCCToken, GENDER_FEMALE, sorted );
}
else
{
GenerateCombinedFile( outfilename, params.m_szCCToken, GENDER_NONE, sorted );
}
}
bool CChoreoView::ValidateCombinedSoundCheckSum( CChoreoEvent *e )
{
if ( !e || e->GetType() != CChoreoEvent::SPEAK )
return false;
bool genderwildcard = e->IsCombinedUsingGenderToken();
char outfilename[ 512 ];
Q_memset( outfilename, 0, sizeof( outfilename ) );
if ( !e->ComputeCombinedBaseFileName( outfilename, sizeof( outfilename ), genderwildcard ) )
{
Con_ErrorPrintf( "Unable to regenerate wav file name for combined sound (%s)\n", e->GetCloseCaptionToken() );
return false;
}
bool checksumvalid = false;
CUtlRBTree< CChoreoEvent * > eventList( 0, 0, EventStartTimeLessFunc );
if ( !e->GetChannel()->GetSortedCombinedEventList( e->GetCloseCaptionToken(), eventList ) )
{
Con_ErrorPrintf( "Unable to generated combined event list (%s)\n", e->GetCloseCaptionToken() );
return false;
}
if ( genderwildcard )
{
checksumvalid = ValidateCombinedFileCheckSum( outfilename, e->GetCloseCaptionToken(), GENDER_MALE, eventList );
checksumvalid &= ValidateCombinedFileCheckSum( outfilename, e->GetCloseCaptionToken(), GENDER_FEMALE, eventList );
}
else
{
checksumvalid = ValidateCombinedFileCheckSum( outfilename, e->GetCloseCaptionToken(), GENDER_NONE, eventList );
}
return checksumvalid;
}
void CChoreoView::OnRemoveSpeakEventFromGroup()
{
if ( !m_pScene )
return;
int i, c;
CUtlVector< CChoreoEvent * > selected;
CUtlVector< CChoreoEvent * > processlist;
if ( GetSelectedEvents( selected ) > 0 )
{
int c = selected.Count();
// Find the appropriate event by iterating across all actors and channels
for ( i = c - 1; i >= 0; --i )
{
CChoreoEvent *e = selected[ i ];
if ( e->GetType() != CChoreoEvent::SPEAK )
{
selected.Remove( i );
continue;
}
if ( e->GetCloseCaptionType() == CChoreoEvent::CC_DISABLED )
{
selected.Remove( i );
continue;
}
m_pClickedChannel->GetMasterAndSlaves( e, processlist );
}
}
else
{
m_pClickedChannel->GetMasterAndSlaves( m_pClickedChannel->GetCaptionClickedEvent(), processlist );
}
if ( selected.Count() < 1 )
{
Con_ErrorPrintf( "No eligible SPEAK event selected.\n" );
return;
}
SetDirty( true );
PushUndo( "Remove speak event(s)" );
c = processlist.Count();
for ( i = 0 ; i < c; ++i )
{
processlist[ i ]->SetCloseCaptionToken( "" );
processlist[ i ]->SetCloseCaptionType( CChoreoEvent::CC_MASTER );
processlist[ i ]->SetUsingCombinedFile( false );
processlist[ i ]->SetRequiredCombinedChecksum( 0 );
processlist[ i ]->SetNumSlaves( 0 );
processlist[ i ]->SetLastSlaveEndTime( 0.0f );
}
PushRedo( "Remove speak event(s)" );
// Redraw
InvalidateLayout();
Con_Printf( "Reverted %i events to use default close caption token\n", c );
}
bool CChoreoView::AreSelectedEventsCombinable()
{
CUtlVector< CChoreoEvent * > events;
if ( GetSelectedEvents( events ) <= 0 )
return false;
CChoreoChannel *firstChannel = NULL;
CUtlVector< CChoreoEvent * > selected;
GetSelectedEvents( selected );
int c = selected.Count();
// Find the appropriate event by iterating across all actors and channels
for ( int i = c - 1; i >= 0; --i )
{
CChoreoEvent *e = selected[ i ];
if ( e->GetType() != CChoreoEvent::SPEAK )
{
return false;
}
if ( !firstChannel )
{
firstChannel = e->GetChannel();
}
else if ( e->GetChannel() != firstChannel )
{
return false;
}
}
return selected.Count() >= 2 ? true : false;
}
bool CChoreoView::AreSelectedEventsInSpeakGroup()
{
CUtlVector< CChoreoEvent * > selected;
if ( GetSelectedEvents( selected ) <= 0 )
{
if ( m_pClickedChannel )
{
CChoreoEvent *e = m_pClickedChannel->GetCaptionClickedEvent();
if ( e && e->GetCloseCaptionType() == CChoreoEvent::CC_MASTER &&
e->GetNumSlaves() >= 1 )
{
return true;
}
}
return false;
}
int c = selected.Count();
// Find the appropriate event by iterating across all actors and channels
for ( int i = c - 1; i >= 0; --i )
{
CChoreoEvent *e = selected[ i ];
if ( e->GetType() != CChoreoEvent::SPEAK )
{
selected.Remove( i );
continue;
}
if ( e->GetCloseCaptionType() == CChoreoEvent::CC_DISABLED )
{
selected.Remove( i );
continue;
}
}
return selected.Count() >= 1 ? true : false;
}
void CChoreoView::OnChangeCloseCaptionToken( CChoreoEvent *e )
{
CCloseCaptionLookupParams params;
Q_strncpy( params.m_szDialogTitle, "Close Caption Token Lookup", sizeof( params.m_szDialogTitle ) );
params.m_bPositionDialog = false;
params.m_nLeft = 0;
params.m_nTop = 0;
// strcpy( params.m_szPrompt, "Choose model:" );
Q_strncpy( params.m_szCCToken, e->GetCloseCaptionToken(), sizeof( params.m_szCCToken ) );
// User hit okay and value actually changed?
if ( CloseCaptionLookup( &params ) &&
Q_stricmp( e->GetCloseCaptionToken(), params.m_szCCToken ) )
{
char oldToken[ CChoreoEvent::MAX_CCTOKEN_STRING ];
Q_strncpy( oldToken, e->GetCloseCaptionToken(), sizeof( oldToken ) );
CUtlVector< CChoreoEvent * > events;
m_pClickedChannel->GetMasterAndSlaves( e, events );
if ( events.Count() < 2 )
{
Con_ErrorPrintf( "Can't combine events, must have at least two events selected.\n" );
}
SetDirty( true );
PushUndo( "Change closecaption token" );
// Make the change...
int c = events.Count();
for ( int i = 0 ; i < c; ++i )
{
events[i]->SetCloseCaptionToken( params.m_szCCToken );
}
PushRedo( "Change closecaption token" );
InvalidateLayout();
Con_Printf( "Close Caption token for '%s' changed to '%s'\n", e->GetName(), params.m_szCCToken );
}
}
void CChoreoView::OnToggleCloseCaptionsForEvent()
{
if ( !m_pClickedChannel )
{
return;
}
CChoreoEvent *e = m_pClickedChannel->GetCaptionClickedEvent();
if ( !e )
{
return;
}
CChoreoEvent::CLOSECAPTION newType = CChoreoEvent::CC_MASTER;
// Can't mess with slave
switch ( e->GetCloseCaptionType() )
{
default:
case CChoreoEvent::CC_SLAVE:
return;
case CChoreoEvent::CC_MASTER:
newType = CChoreoEvent::CC_DISABLED;
break;
case CChoreoEvent::CC_DISABLED:
newType = CChoreoEvent::CC_MASTER;
break;
}
SetDirty( true );
PushUndo( "Enable/disable captions" );
// Make the change...
e->SetCloseCaptionType( newType );
PushRedo( "Enable/disable captions" );
InvalidateLayout();
Con_Printf( "Close Caption type for '%s' changed to '%s'\n", e->GetName(), CChoreoEvent::NameForCCType( newType ) );
}
void CChoreoView::StopScene()
{
SetScrubTargetTime( m_flScrub );
FinishSimulation();
sound->Flush();
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : -
//-----------------------------------------------------------------------------
template <class T>
void DeleteAllAndPurge( T &tree )
{
T::IndexType_t i;
for ( i = tree.FirstInorder(); i != T::InvalidIndex(); i = tree.NextInorder( i ) )
{
delete tree[i];
}
tree.Purge();
}
void CChoreoView::OnPlaceNextSpeakEvent()
{
CUtlVector< CChoreoEvent * > list;
GetSelectedEvents( list );
if ( list.Count() != 1 )
{
Warning( "Can't place sound event, nothing selected\n" );
return;
}
CChoreoEvent *ev = list[ 0 ];
if ( ev->GetType() != CChoreoEvent::SPEAK )
{
Warning( "Can't place sound event, no previous sound event selected\n" );
return;
}
CChoreoChannelWidget *widget = FindChannelForEvent( ev );
if ( !widget )
{
Warning( "Can't place sound event, can't find channel widget for event\n" );
return;
}
CChoreoChannel *channel = widget->GetChannel();
if ( !channel )
{
Warning( "Can't place sound event, can't find channel for new event\n" );
return;
}
CUtlRBTree< char const *, int > m_SortedNames( 0, 0, NameLessFunc );
int c = soundemitter->GetSoundCount();
for ( int i = 0; i < c; i++ )
{
char const *name = soundemitter->GetSoundName( i );
if ( name && name[ 0 ] )
{
m_SortedNames.Insert( strdup( name ) );
}
}
int idx = m_SortedNames.Find( ev->GetParameters() );
if ( idx == m_SortedNames.InvalidIndex() )
{
Warning( "Can't place sound event, can't find '%s' in sound list\n", ev->GetParameters() );
DeleteAllAndPurge( m_SortedNames );
return;
}
int nextIdx = m_SortedNames.NextInorder( idx );
if ( nextIdx == m_SortedNames.InvalidIndex() )
{
Warning( "Can't place sound event, can't next sound after '%s' in sound list\n", ev->GetParameters() );
DeleteAllAndPurge( m_SortedNames );
return;
}
DeselectAll();
SetDirty( true );
PushUndo( "Place Next Speak Event" );
CChoreoEvent *event = m_pScene->AllocEvent();
Assert( event );
if ( event )
{
// Copy everything for source event
*event = *ev;
event->SetParameters( m_SortedNames[ nextIdx ] );
// Start it at the end time...
event->SetStartTime( event->GetEndTime() );
event->SetResumeCondition( false );
event->ClearAllRelativeTags();
event->ClearAllTimingTags();
event->ClearAllAbsoluteTags( CChoreoEvent::PLAYBACK );
event->ClearAllAbsoluteTags( CChoreoEvent::ORIGINAL );
event->SetChannel( channel );
event->SetActor( channel->GetActor() );
// Try and load wav to get length
CAudioSource *wave = sound->LoadSound( va( "sound/%s", FacePoser_TranslateSoundName( event ) ) );
if ( wave )
{
event->SetEndTime( event->GetStartTime() + wave->GetRunningLength() );
delete wave;
}
DeleteSceneWidgets();
// Add to appropriate channel
channel->AddEvent( event );
CreateSceneWidgets();
CChoreoEventWidget *eventWidget = FindWidgetForEvent( event );
if ( eventWidget )
{
eventWidget->SetSelected( true );
}
// Redraw
InvalidateLayout();
}
PushRedo( "Place Next Speak Event" );
DeleteAllAndPurge( m_SortedNames );
}
enum
{
FM_LEFT = 0,
FM_RIGHT,
FM_SMALLESTWIDE,
FM_LARGESTWIDE
};
static int FindMetric( int type, CUtlVector< CChoreoEvent * > &list, float& value )
{
float bestVal = 999999.0f;
int bestIndex = -1;
bool greater = true;
switch ( type )
{
default:
case FM_LEFT:
case FM_SMALLESTWIDE:
greater = false;
break;
case FM_RIGHT:
case FM_LARGESTWIDE:
bestVal = -bestVal;
greater = true;
break;
}
int c = list.Count();
for ( int i = 0; i < c; ++i )
{
CChoreoEvent *e = list[ i ];
if ( type != FM_LEFT &&
!e->HasEndTime() )
continue;
float val;
switch ( type )
{
default:
case FM_LEFT:
val = e->GetStartTime();
break;
case FM_RIGHT:
val = e->GetEndTime();
break;
case FM_SMALLESTWIDE:
case FM_LARGESTWIDE:
val = e->GetDuration();
break;
}
if ( greater )
{
if ( val <= bestVal )
continue;
}
else
{
if ( val >= bestVal )
continue;
}
bestVal = val;
bestIndex = i;
}
value = bestVal;
return bestIndex;
}
void CChoreoView::OnAlign( bool left )
{
CUtlVector< CChoreoEvent * > list;
GetSelectedEvents( list );
if ( left )
{
for ( int i = 0; i < m_SceneGlobalEvents.Size(); i++ )
{
CChoreoGlobalEventWidget *event = m_SceneGlobalEvents[ i ];
if ( !event || !event->IsSelected() )
continue;
list.AddToTail( event->GetEvent() );
}
}
int numSel = list.Count();
if ( numSel < 2 )
{
Warning( "Can't align, must have at least two events selected\n" );
return;
}
float value;
int idx = FindMetric( left ? FM_LEFT : FM_RIGHT, list, value );
if ( idx == -1 )
{
return;
}
SetDirty( true );
char undotext[ 128 ];
Q_snprintf( undotext, sizeof( undotext ), "Align %s", left ? "Left" : "Right" );
PushUndo( undotext );
for ( int i = 0; i < numSel; ++i )
{
if ( i == idx )
continue;
CChoreoEvent *e = list[ i ];
float newStartTime = left ? value : ( value - e->GetDuration() );
float offset = newStartTime - e->GetStartTime();
e->OffsetTime( offset );
}
PushRedo( undotext );
InvalidateLayout();
}
void CChoreoView::OnMakeSameSize( bool smallest )
{
CUtlVector< CChoreoEvent * > list;
int numSel = GetSelectedEvents( list );
if ( numSel < 2 )
{
Warning( "Can't align, must have at least two events selected\n" );
return;
}
float value;
int idx = FindMetric( smallest ? FM_SMALLESTWIDE : FM_LARGESTWIDE, list, value );
if ( idx == -1 )
{
return;
}
SetDirty( true );
char undotext[ 128 ];
Q_snprintf( undotext, sizeof( undotext ), "Size to %s", smallest ? "Smallest" : "Largest" );
PushUndo( undotext );
for ( int i = 0; i < numSel; ++i )
{
if ( i == idx )
continue;
list[ i ]->SetEndTime( list[ i ]->GetStartTime() + value );
}
PushRedo( undotext );
InvalidateLayout();
}
void CChoreoView::SelectAllEventsInActor( CChoreoActorWidget *actor )
{
TraverseWidgets( &CChoreoView::SelectInActor, actor );
redraw();
}
void CChoreoView::SelectAllEventsInChannel( CChoreoChannelWidget *channel )
{
TraverseWidgets( &CChoreoView::SelectInChannel, channel );
redraw();
}
void CChoreoView::SelectInActor( CChoreoWidget *widget, CChoreoWidget *param1 )
{
CChoreoEventWidget *ev = dynamic_cast< CChoreoEventWidget * >( widget );
if ( !ev )
return;
if ( ev->IsSelected() )
return;
CChoreoChannel *ch = ev->GetEvent()->GetChannel();
if ( !ch )
return;
CChoreoActor *actor = ch->GetActor();
if ( !actor )
return;
CChoreoActorWidget *actorw = dynamic_cast< CChoreoActorWidget * >( param1 );
if ( !actorw )
return;
if ( actorw->GetActor() != actor )
return;
widget->SetSelected( true );
}
void CChoreoView::SelectInChannel( CChoreoWidget *widget, CChoreoWidget *param1 )
{
CChoreoEventWidget *ev = dynamic_cast< CChoreoEventWidget * >( widget );
if ( !ev )
return;
if ( ev->IsSelected() )
return;
CChoreoChannel *ch = ev->GetEvent()->GetChannel();
if ( !ch )
return;
CChoreoChannelWidget *chw = dynamic_cast< CChoreoChannelWidget * >( param1 );
if ( !chw )
return;
if ( chw->GetChannel() != ch )
return;
widget->SetSelected( true );
}
Reference in New Issue View Git Blame Copy Permalink