archive
/
tf2
mirror of https://github.com/sr2echa/TF2-Source-Code
2
0
Fork 0
Code Issues Projects Releases Wiki Activity
Team Fortress 2 Source Code as on 22/4/2020
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
10 Commits
1 Branch
0 Tags
1.4 GiB
 
 
 
 
 
 
Tree: c61d975061
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'c61d975061'
${ noResults }
tf2/tf2_src/utils/hlfaceposer/expressiontool.cpp

4816 lines
106 KiB
Raw Blame History

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
// $NoKeywords: $
//
//=============================================================================//
#include <stdio.h>
#include "hlfaceposer.h"
#include "ExpressionTool.h"
#include "mdlviewer.h"
#include "choreowidgetdrawhelper.h"
#include "TimelineItem.h"
#include "expressions.h"
#include "expclass.h"
#include "choreoevent.h"
#include "StudioModel.h"
#include "choreoscene.h"
#include "choreoactor.h"
#include "choreochannel.h"
#include "ChoreoView.h"
#include "InputProperties.h"
#include "ControlPanel.h"
#include "FlexPanel.h"
#include "mxExpressionTray.h"
#include "ExpressionProperties.h"
#include "tier1/strtools.h"
#include "faceposer_models.h"
#include "UtlBuffer.h"
#include "filesystem.h"
#include "iscenetokenprocessor.h"
#include "MatSysWin.h"
#include "choreoviewcolors.h"
#include "scriplib.h"
#include "EdgeProperties.h"
ExpressionTool *g_pExpressionTool = 0;
#define TRAY_HEIGHT 55
#define TRAY_ITEM_INSET 10
#define MAX_TIME_ZOOM 1000
// 10% per step
#define TIME_ZOOM_STEP 2
void SetupFlexControllerTracks( CStudioHdr *hdr, CChoreoEvent *event );
class CExpressionToolWorkspace : public mxWindow
{
public:
CExpressionToolWorkspace( mxWindow *parent );
~CExpressionToolWorkspace();
virtual int handleEvent( mxEvent *event );
virtual void redraw( void );
virtual bool PaintBackground( void )
{
redraw();
return false;
}
void RepositionVSlider( void );
int ComputeVPixelsNeeded( void );
// Playback tick
void Think( float dt );
void LayoutItems( bool force = false );
void HideTimelines( void );
void CollapseAll( TimelineItem *keepExpanded );
void ExpandAll( void );
void ExpandValid( void );
void DisableAllExcept( void );
void EnableValid( void );
TimelineItem *GetItem( int number );
TimelineItem *GetClickedItem( void );
void ClearClickedItem( void );
void OnSnapAll();
void OnDeleteColumn();
void MoveSelectedSamples( float dfdx, float dfdy, bool snap );
void DeleteSelectedSamples( void );
int CountSelectedSamples( void );
void DeselectAll( void );
void SelectPoints( float start, float end );
void DrawEventEnd( CChoreoWidgetDrawHelper& drawHelper );
void OnSortByUsed( void );
void OnSortByName( void );
private:
int GetItemUnderMouse( int mx, int my );
void MouseToToolMouse( int& mx, int& my, char *reason );
TimelineItem *m_pItems[ GLOBAL_STUDIO_FLEX_CONTROL_COUNT ];
// The scroll bars
mxScrollbar *m_pVertScrollBar;
int m_nLastVPixelsNeeded;
int m_nTopOffset;
int m_nScrollbarHeight;
int m_nItemGap;
int m_nFocusItem;
};
CExpressionToolWorkspace::CExpressionToolWorkspace( mxWindow *parent ) :
mxWindow( parent, 0, 0, 0, 0 )
{
HWND wnd = (HWND)getHandle();
DWORD style = GetWindowLong( wnd, GWL_STYLE );
style |= WS_CLIPCHILDREN | WS_CLIPSIBLINGS;
SetWindowLong( wnd, GWL_STYLE, style );
for ( int i = 0; i < GLOBAL_STUDIO_FLEX_CONTROL_COUNT; i++ )
{
m_pItems[ i ] = new TimelineItem( this );
}
m_nItemGap = 2;
m_nScrollbarHeight = 12;
m_nTopOffset = 0;
m_nLastVPixelsNeeded = -1;
m_pVertScrollBar = new mxScrollbar( this, 0, 0, 12, 100, IDC_EXPRESSIONTOOLVSCROLL, mxScrollbar::Vertical );
m_nFocusItem = -1;
HideTimelines();
LayoutItems();
}
CExpressionToolWorkspace::~CExpressionToolWorkspace()
{
}
void CExpressionToolWorkspace::redraw()
{
CChoreoWidgetDrawHelper drawHelper( this );
DrawEventEnd( drawHelper );
for ( int i = 0; i < GLOBAL_STUDIO_FLEX_CONTROL_COUNT; i++ )
{
TimelineItem *item = GetItem( i );
if ( !item )
continue;
if ( !item->GetVisible() )
continue;
RECT rcBounds;
item->GetBounds( rcBounds );
if ( rcBounds.bottom < 0 )
continue;
if ( rcBounds.top > h2() )
continue;
item->Draw( drawHelper );
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *elem1 -
// *elem2 -
// Output : int
//-----------------------------------------------------------------------------
int SortFuncByUse(const void *elem1, const void *elem2 )
{
TimelineItem *item1 = *( TimelineItem ** )elem1;
TimelineItem *item2 = *( TimelineItem ** )elem2;
if ( item1->IsValid() == item2->IsValid() )
return 0;
if ( !item2->IsValid() && item1->IsValid() )
return -1;
return 1;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *elem1 -
// *elem2 -
// Output : int
//-----------------------------------------------------------------------------
int SortFuncByName(const void *elem1, const void *elem2 )
{
TimelineItem *item1 = *( TimelineItem ** )elem1;
TimelineItem *item2 = *( TimelineItem ** )elem2;
CFlexAnimationTrack *track1 = item1->GetSafeTrack();
CFlexAnimationTrack *track2 = item2->GetSafeTrack();
if ( !track1 || !track2 )
{
if ( track1 )
return -1;
if ( track2 )
return 1;
return 0;
}
return stricmp( track1->GetFlexControllerName(), track2->GetFlexControllerName() );
}
void CExpressionToolWorkspace::OnSortByUsed( void )
{
qsort( m_pItems, GLOBAL_STUDIO_FLEX_CONTROL_COUNT, sizeof( TimelineItem * ), SortFuncByUse );
LayoutItems( false );
}
void CExpressionToolWorkspace::OnSortByName( void )
{
qsort( m_pItems, GLOBAL_STUDIO_FLEX_CONTROL_COUNT, sizeof( TimelineItem * ), SortFuncByName );
LayoutItems( false );
}
void CExpressionToolWorkspace::DrawEventEnd( CChoreoWidgetDrawHelper& drawHelper )
{
if ( !g_pExpressionTool )
return;
CChoreoEvent *e = g_pExpressionTool->GetSafeEvent();
if ( !e )
return;
float duration = e->GetDuration();
if ( !duration )
return;
int leftx = g_pExpressionTool->GetPixelForTimeValue( duration ) -5;
if ( leftx >= w2() )
return;
RECT rcClient;
drawHelper.GetClientRect( rcClient );
drawHelper.DrawColoredLine(
COLOR_CHOREO_ENDTIME, PS_SOLID, 1,
leftx, rcClient.top, leftx, rcClient.bottom );
}
int CExpressionToolWorkspace::GetItemUnderMouse( int mx, int my )
{
POINT pt;
pt.x = mx;
pt.y = my;
for ( int i = 0; i < GLOBAL_STUDIO_FLEX_CONTROL_COUNT; i++ )
{
TimelineItem *item = GetItem( i );
if ( !item )
continue;
if ( !item->GetVisible() )
continue;
RECT rc;
item->GetBounds( rc );
if ( PtInRect( &rc, pt ) )
{
return i;
}
}
return -1;
}
void CExpressionToolWorkspace::MouseToToolMouse( int& mx, int& my, char *reason )
{
POINT pt;
pt.x = mx;
pt.y = my;
ClientToScreen( (HWND)getHandle(), &pt );
ScreenToClient( (HWND)getParent()->getHandle(), &pt );
mx = pt.x;
my = pt.y;
}
int CExpressionToolWorkspace::handleEvent( mxEvent *event )
{
MDLCACHE_CRITICAL_SECTION_( g_pMDLCache );
int iret = 0;
switch ( event->event )
{
case mxEvent::MouseDown:
{
HWND wnd = (HWND)getParent()->getHandle();
SetFocus( wnd );
SetWindowPos( wnd, HWND_TOP, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_SHOWWINDOW);
{
int mx = (short)event->x;
int my = (short)event->y;
MouseToToolMouse( mx, my, "CExpressionToolWorkspace mousedown" );
g_pExpressionTool->SetClickedPos( mx, my );
g_pExpressionTool->SetMouseOverPos( mx, my );
g_pExpressionTool->DrawMouseOverPos();
}
int oldFocus = m_nFocusItem;
m_nFocusItem = GetItemUnderMouse( (short)event->x, (short)event->y );
if ( oldFocus != -1 &&
oldFocus != m_nFocusItem )
{
TimelineItem *item = GetItem( oldFocus );
if ( item )
{
item->DrawSelf();
}
}
if ( m_nFocusItem != -1 )
{
TimelineItem *item = GetItem( m_nFocusItem );
if ( item )
{
RECT rc;
item->GetBounds( rc );
event->x -= rc.left;
event->y -= rc.top;
iret = item->handleEvent( event );
}
}
iret = 1;
}
break;
case mxEvent::MouseDrag:
case mxEvent::MouseMove:
{
//
bool handled = false;
if ( m_nFocusItem != -1 )
{
TimelineItem *item = GetItem( m_nFocusItem );
if ( item )
{
RECT rc;
item->GetBounds( rc );
event->x -= rc.left;
event->y -= rc.top;
iret = item->handleEvent( event );
if ( event->event == mxEvent::MouseDrag )
{
int mx, my;
item->GetLastMouse( mx, my );
mx += rc.left;
my += rc.top;
MouseToToolMouse( mx, my, "CExpressionToolWorkspace mousedrag" );
g_pExpressionTool->SetMouseOverPos( mx, my );
g_pExpressionTool->DrawMouseOverPos();
handled = true;
}
}
}
if ( !handled )
{
int mx = (short)event->x;
int my = (short)event->y;
mx += TRAY_ITEM_INSET;
MouseToToolMouse( mx, my, "CExpressionToolWorkspace mousemove" );
g_pExpressionTool->SetMouseOverPos( mx, my );
g_pExpressionTool->DrawMouseOverPos();
}
}
break;
case mxEvent::MouseUp:
{
//
{
int mx = (short)event->x;
int my = (short)event->y;
MouseToToolMouse( mx, my, "CExpressionToolWorkspace mouseup" );
g_pExpressionTool->SetMouseOverPos( mx, my );
g_pExpressionTool->DrawMouseOverPos();
}
if ( m_nFocusItem != -1 )
{
TimelineItem *item = GetItem( m_nFocusItem );
if ( item )
{
RECT rc;
item->GetBounds( rc );
event->x -= rc.left;
event->y -= rc.top;
iret = item->handleEvent( event );
}
}
}
break;
case mxEvent::Size:
{
RepositionVSlider();
LayoutItems();
iret = 1;
}
break;
case mxEvent::MouseWheeled:
// Tell parent
{
if ( event->modifiers & mxEvent::KeyShift )
{
CChoreoScene *scene = g_pChoreoView->GetScene();
if ( scene )
{
int tz = g_pChoreoView->GetTimeZoom( g_pExpressionTool->GetToolName() );
// Zoom time in / out
if ( event->height > 0 )
{
g_pChoreoView->SetTimeZoom( g_pExpressionTool->GetToolName(), min( tz + TIME_ZOOM_STEP, MAX_TIME_ZOOM ), false );
}
else
{
g_pChoreoView->SetTimeZoom( g_pExpressionTool->GetToolName(), min( tz - TIME_ZOOM_STEP, MAX_TIME_ZOOM ), false );
}
g_pExpressionTool->RepositionHSlider();
}
redraw();
iret = 1;
return iret;
}
int offset = 0;
int jump = 50;
if ( event->height < 0 )
{
offset = m_pVertScrollBar->getValue();
offset += jump;
offset = min( offset, m_pVertScrollBar->getMaxValue() );
}
else
{
offset = m_pVertScrollBar->getValue();
offset -= jump;
offset = max( offset, m_pVertScrollBar->getMinValue() );
}
m_pVertScrollBar->setValue( offset );
InvalidateRect( (HWND)m_pVertScrollBar->getHandle(), NULL, TRUE );
m_nTopOffset = offset;
LayoutItems();
iret = 1;
}
break;
case mxEvent::Action:
{
iret = 1;
switch ( event->action )
{
default:
iret = 0;
break;
case IDC_EXPRESSIONTOOLVSCROLL:
{
int offset = 0;
bool processed = true;
switch ( event->modifiers )
{
case SB_THUMBTRACK:
offset = event->height;
break;
case SB_PAGEUP:
offset = m_pVertScrollBar->getValue();
offset -= 100;
offset = max( offset, m_pVertScrollBar->getMinValue() );
break;
case SB_PAGEDOWN:
offset = m_pVertScrollBar->getValue();
offset += 100;
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;
LayoutItems();
}
}
}
}
break;
}
return iret;
}
void CExpressionToolWorkspace::HideTimelines( void )
{
for ( int i = 0; i < GLOBAL_STUDIO_FLEX_CONTROL_COUNT; i++ )
{
TimelineItem *item = GetItem( i );
Assert( item );
item->SetVisible( false );
}
redraw();
}
TimelineItem *CExpressionToolWorkspace::GetItem( int number )
{
if ( number < 0 || number >= GLOBAL_STUDIO_FLEX_CONTROL_COUNT )
{
return NULL;
}
return m_pItems[ number ];
}
TimelineItem *CExpressionToolWorkspace::GetClickedItem( void )
{
return GetItem( m_nFocusItem );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CExpressionToolWorkspace::ClearClickedItem( void )
{
m_nFocusItem = -1;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : force - force vert scrollbar recomputation
//-----------------------------------------------------------------------------
void CExpressionToolWorkspace::LayoutItems( bool force /* = false */ )
{
int x = TRAY_ITEM_INSET;
int y = - m_nTopOffset;
int width = w2() - 2 * TRAY_ITEM_INSET - m_nScrollbarHeight;
int height;
for ( int i = 0; i < GLOBAL_STUDIO_FLEX_CONTROL_COUNT; i++ )
{
TimelineItem *item = GetItem( i );
if ( !item || !item->GetVisible() )
continue;
height = item->GetHeight();
RECT rcBounds;
rcBounds.left = x;
rcBounds.top = y;
rcBounds.right = x + width;
rcBounds.bottom = y + height;
item->SetBounds( rcBounds );
y += height + m_nItemGap;
}
if ( force || ( ComputeVPixelsNeeded() != m_nLastVPixelsNeeded ) )
{
RepositionVSlider();
}
redraw();
}
int CExpressionToolWorkspace::ComputeVPixelsNeeded( void )
{
int pixels = 0;
// Count visible
int c = 0;
for ( int i = 0; i < GLOBAL_STUDIO_FLEX_CONTROL_COUNT; i++ )
{
TimelineItem *item = GetItem( i );
if ( !item || !item->GetVisible() )
continue;
c += item->GetHeight();
c += m_nItemGap;
}
pixels += c;
return pixels;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CExpressionToolWorkspace::RepositionVSlider( void )
{
int pixelsneeded = ComputeVPixelsNeeded();
if ( pixelsneeded <= ( h2() ))
{
m_pVertScrollBar->setVisible( false );
m_nTopOffset = 0;
}
else
{
m_pVertScrollBar->setVisible( true );
}
m_pVertScrollBar->setBounds(
w2() - m_nScrollbarHeight,
0,
m_nScrollbarHeight,
h2() );
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() );
m_nLastVPixelsNeeded = pixelsneeded;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CExpressionToolWorkspace::DisableAllExcept( void )
{
TimelineItem *keepExpanded = GetClickedItem();
if ( !keepExpanded )
return;
g_pChoreoView->SetDirty( true );
g_pChoreoView->PushUndo( "Disable All Except" );
for ( int i = 0; i < GLOBAL_STUDIO_FLEX_CONTROL_COUNT; i++ )
{
TimelineItem *item = GetItem( i );
item->SetActive( item == keepExpanded ? true : false );
}
LayoutItems();
g_pChoreoView->PushRedo( "Disable All Except" );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CExpressionToolWorkspace::EnableValid( void )
{
g_pChoreoView->SetDirty( true );
g_pChoreoView->PushUndo( "Enable Valid" );
for ( int i = 0; i < GLOBAL_STUDIO_FLEX_CONTROL_COUNT; i++ )
{
TimelineItem *item = GetItem( i );
item->SetActive( item->IsValid() );
}
LayoutItems();
g_pChoreoView->PushRedo( "Enable Valid" );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CExpressionToolWorkspace::CollapseAll( TimelineItem *keepExpanded )
{
for ( int i = 0; i < GLOBAL_STUDIO_FLEX_CONTROL_COUNT; i++ )
{
TimelineItem *item = GetItem( i );
item->SetCollapsed( item == keepExpanded ? false : true );
}
LayoutItems();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CExpressionToolWorkspace::ExpandAll( void )
{
for ( int i = 0; i < GLOBAL_STUDIO_FLEX_CONTROL_COUNT; i++ )
{
TimelineItem *item = GetItem( i );
item->SetCollapsed( false );
}
LayoutItems();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CExpressionToolWorkspace::OnSnapAll()
{
g_pChoreoView->SetDirty( true );
g_pChoreoView->PushUndo( "Snap All" );
for ( int i = 0; i < GLOBAL_STUDIO_FLEX_CONTROL_COUNT; i++ )
{
TimelineItem *item = GetItem( i );
item->SnapAll();
}
g_pChoreoView->PushRedo( "Snap All" );
redraw();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CExpressionToolWorkspace::OnDeleteColumn()
{
float t = g_pExpressionTool->GetTimeForClickedPos();
float snapped = FacePoser_SnapTime( t );
int scenefps = FacePoser_GetSceneFPS();
if ( scenefps <= 0 )
{
Con_Printf( "Can't delete column, scene fps is <= 0 (%i)\n", scenefps );
return;
}
int clickedframe = ( int ) ( scenefps * snapped + 0.5f );
// One half of 1/fps on each side
float epsilon = epsilon = 0.5f / (float)scenefps;
CInputParams params;
memset( &params, 0, sizeof( params ) );
strcpy( params.m_szDialogTitle, "Delete Column" );
strcpy( params.m_szPrompt, "Frame(s) to delete [e.g., 82 or 81-91 ]:" );
Q_snprintf( params.m_szInputText, sizeof( params.m_szInputText ), "%i", clickedframe );
if ( !InputProperties( &params ) )
return;
int deleteframestart;
int deleteframeend;
char *sep = Q_strstr( params.m_szInputText, "-" );
if ( sep )
{
*sep = 0;
deleteframestart = atoi( params.m_szInputText );
deleteframeend = atoi( sep + 1 );
deleteframeend = max( deleteframestart, deleteframeend );
}
else
{
deleteframestart = atoi( params.m_szInputText );
deleteframeend = deleteframestart;
}
float start, end;
start = (float)deleteframestart / (float)scenefps;
end = (float)deleteframeend / (float)scenefps;
g_pChoreoView->SetDirty( true );
g_pChoreoView->PushUndo( "Delete Column" );
for ( int i = 0; i < GLOBAL_STUDIO_FLEX_CONTROL_COUNT; i++ )
{
TimelineItem *item = GetItem( i );
item->DeletePoints( start - epsilon, end + epsilon );
}
g_pChoreoView->PushRedo( "Delete Column" );
redraw();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CExpressionToolWorkspace::ExpandValid( void )
{
for ( int i = 0; i < GLOBAL_STUDIO_FLEX_CONTROL_COUNT; i++ )
{
TimelineItem *item = GetItem( i );
bool valid = item->IsValid();
item->SetCollapsed( !valid );
}
LayoutItems();
}
//-----------------------------------------------------------------------------
// Purpose:
// Output : int
//-----------------------------------------------------------------------------
int CExpressionToolWorkspace::CountSelectedSamples( void )
{
int c = 0;
for ( int i = 0; i < GLOBAL_STUDIO_FLEX_CONTROL_COUNT; i++ )
{
TimelineItem *item = GetItem( i );
Assert( item );
item->CountSelected();
c += item->GetNumSelected();
}
return c;
}
void CExpressionToolWorkspace::MoveSelectedSamples( float dfdx, float dfdy, bool snap )
{
int selecteditems = CountSelectedSamples();
if ( !selecteditems )
return;
CChoreoEvent *e = g_pExpressionTool->GetSafeEvent();
if ( !e )
return;
float eventduration = e->GetDuration();
for ( int controller = 0; controller < GLOBAL_STUDIO_FLEX_CONTROL_COUNT; controller++ )
{
TimelineItem *item = GetItem( controller );
if ( !item )
continue;
CFlexAnimationTrack *track = item->GetSafeTrack();
if ( !track )
continue;
// If the track is a combo type track, then move any underlying selected samples, too
for ( int edittype = 0; edittype <= ( track->IsComboType() ? 1 : 0 ); edittype++ )
{
for ( int i = 0; i < (int)track->GetNumSamples( edittype ); i++ )
{
CExpressionSample *sample = track->GetSample( i, edittype );
if ( !sample || !sample->selected )
continue;
sample->time += dfdx;
sample->time = clamp( sample->time, 0.0f, eventduration );
if ( snap )
{
sample->time = FacePoser_SnapTime( sample->time );
}
sample->value -= dfdy;
sample->value = clamp( sample->value, 0.0f, 1.0f );
}
}
track->Resort();
item->DrawSelf();
}
}
void CExpressionToolWorkspace::DeleteSelectedSamples( void )
{
int i, t;
int selecteditems = CountSelectedSamples();
if ( !selecteditems )
return;
g_pChoreoView->SetDirty( true );
g_pChoreoView->PushUndo( "Delete points" );
for ( int controller = 0; controller < GLOBAL_STUDIO_FLEX_CONTROL_COUNT; controller++ )
{
TimelineItem *item = GetItem( controller );
if ( !item )
continue;
CFlexAnimationTrack *track = item->GetSafeTrack();
if ( !track )
continue;
for ( t = 0; t < 2; t++ )
{
for ( i = track->GetNumSamples( t ) - 1; i >= 0 ; i-- )
{
CExpressionSample *sample = track->GetSample( i, t );
if ( !sample->selected )
continue;
track->RemoveSample( i, t );
}
}
item->DrawSelf();
}
g_pChoreoView->PushRedo( "Delete points" );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CExpressionToolWorkspace::DeselectAll( void )
{
int i, t;
int selecteditems = CountSelectedSamples();
if ( !selecteditems )
return;
for ( int controller = 0; controller < GLOBAL_STUDIO_FLEX_CONTROL_COUNT; controller++ )
{
TimelineItem *item = GetItem( controller );
if ( !item )
continue;
CFlexAnimationTrack *track = item->GetSafeTrack();
if ( !track )
continue;
for ( t = 0; t < 2; t++ )
{
for ( i = track->GetNumSamples( t ) - 1; i >= 0 ; i-- )
{
CExpressionSample *sample = track->GetSample( i, t );
sample->selected = false;
}
}
item->DrawSelf();
}
}
void CExpressionToolWorkspace::SelectPoints( float start, float end )
{
int i, t;
for ( int controller = 0; controller < GLOBAL_STUDIO_FLEX_CONTROL_COUNT; controller++ )
{
TimelineItem *item = GetItem( controller );
if ( !item )
continue;
CFlexAnimationTrack *track = item->GetSafeTrack();
if ( !track )
continue;
for ( t = 0; t < 2; t++ )
{
for ( i = track->GetNumSamples( t ) - 1; i >= 0 ; i-- )
{
CExpressionSample *sample = track->GetSample( i, t );
bool inrange = ( sample->time >= start && sample->time <= end );
sample->selected = inrange;
}
}
item->DrawSelf();
}
}
ExpressionTool::ExpressionTool( mxWindow *parent )
: IFacePoserToolWindow( "ExpressionTool", "Flex Animation" ), mxWindow( parent, 0, 0, 0, 0 )
{
m_bSuppressLayout = false;
SetAutoProcess( true );
m_pWorkspace = new CExpressionToolWorkspace( this );
m_nFocusEventGlobalID = -1;
m_flScrub = 0.0f;
m_flScrubTarget = 0.0f;
m_nDragType = DRAGTYPE_NONE;
m_nClickedX = 0;
m_nClickedY = 0;
m_hPrevCursor = 0;
m_nStartX = 0;
m_nStartY = 0;
m_nMinX = 0;
m_nMaxX = 0;
m_bUseBounds = false;
m_pLastEvent = NULL;
m_nMousePos[ 0 ] = m_nMousePos[ 1 ] = 0;
m_flSelection[ 0 ] = m_flSelection[ 1 ] = 0.0f;
m_bSelectionActive = false;
m_bLayoutIsValid = false;
m_flPixelsPerSecond = 500.0f;
m_flLastDuration = 0.0f;
m_nScrollbarHeight = 12;
m_flLeftOffset = 0.0f;
m_nLastHPixelsNeeded = -1;
m_pHorzScrollBar = new mxScrollbar( this, 0, 0, 18, 100, IDC_FLEXHSCROLL, mxScrollbar::Horizontal );
m_pHorzScrollBar->setVisible( false );
m_bInSetEvent = false;
m_flScrubberTimeOffset = 0.0f;
}
ExpressionTool::~ExpressionTool( void )
{
}
void ExpressionTool::DoTrackLookup( CChoreoEvent *event )
{
if ( !event || !models->GetActiveStudioModel() )
return;
//if ( event->GetTrackLookupSet() )
// return;
// Force recompute
SetEvent( event );
}
#pragma optimize( "g", off )
void ExpressionTool::SetEvent( CChoreoEvent *event )
{
if ( m_bInSetEvent )
return;
m_bInSetEvent = true;
if ( event == m_pLastEvent )
{
if ( event )
{
float dur = event->GetDuration();
if ( dur != m_flLastDuration )
{
m_flLastDuration = dur;
m_nLastHPixelsNeeded = -1;
m_flLeftOffset = 0.0f;
InvalidateLayout();
}
m_nFocusEventGlobalID = event->GetGlobalID();
}
m_bInSetEvent = false;
return;
}
m_pLastEvent = event;
m_pWorkspace->HideTimelines();
m_nFocusEventGlobalID = -1;
if ( event )
{
m_nFocusEventGlobalID = event->GetGlobalID();
if ( models->GetActiveStudioModel() )
{
CStudioHdr *hdr = models->GetActiveStudioModel()->GetStudioHdr();
if ( hdr )
{
// Force re-lookup
event->SetTrackLookupSet( false );
SetupFlexControllerTracks( hdr, event );
int itemCount = 0;
for ( int i = 0; i < event->GetNumFlexAnimationTracks(); i++ )
{
CFlexAnimationTrack *track = event->GetFlexAnimationTrack( i );
Assert( track );
if ( !track )
continue;
TimelineItem *item = m_pWorkspace->GetItem( itemCount++ );
item->SetExpressionInfo( track, track->GetFlexControllerIndex( 0 ) );
item->SetCollapsed( track->GetNumSamples( 0 ) <= 0 );
item->SetVisible( true );
}
m_pWorkspace->LayoutItems( true );
}
}
}
DeselectAll();
if ( event )
{
m_flLastDuration = event->GetDuration();
}
else
{
m_flLastDuration = 0.0f;
}
m_flLeftOffset = 0.0f;
m_nLastHPixelsNeeded = -1;
InvalidateLayout();
m_bInSetEvent = false;
}
#pragma optimize( "g", on )
//-----------------------------------------------------------------------------
// Purpose:
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool ExpressionTool::HasCopyData( void )
{
return ( m_CopyData[0].Size() != 0 ) ? true : false;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *source -
//-----------------------------------------------------------------------------
void ExpressionTool::Copy( CFlexAnimationTrack *source )
{
for ( int t = 0; t < 2; t++ )
{
m_CopyData[ t ].RemoveAll();
if ( t == 0 || source->IsComboType() )
{
for ( int i = 0 ; i < source->GetNumSamples( t ); i++ )
{
CExpressionSample *s = source->GetSample( i, t );
m_CopyData[ t ].AddToTail( *s );
}
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *destination -
//-----------------------------------------------------------------------------
void ExpressionTool::Paste( CFlexAnimationTrack *destination )
{
g_pChoreoView->SetDirty( true );
g_pChoreoView->PushUndo( "Paste" );
destination->Clear();
for ( int t = 0; t < 2; t++ )
{
for ( int i = 0; i < m_CopyData[ t ].Size() ; i++ )
{
CExpressionSample *s = &m_CopyData[ t ][ i ];
if ( t == 0 || destination->IsComboType() )
{
destination->AddSample( s->time, s->value, t );
}
}
destination->Resort( t );
}
g_pChoreoView->PushRedo( "Paste" );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CChoreoEvent *ExpressionTool::GetSafeEvent( void )
{
if ( m_nFocusEventGlobalID == -1 )
return NULL;
if ( !g_pChoreoView )
return NULL;
CChoreoScene *scene = g_pChoreoView->GetScene();
if ( !scene )
return NULL;
// look to see if it's focused any any event
for ( int i = 0; i < scene->GetNumEvents() ; i++ )
{
CChoreoEvent *e = scene->GetEvent( i );
if ( !e || e->GetType() != CChoreoEvent::FLEXANIMATION )
continue;
if ( e->GetGlobalID() == m_nFocusEventGlobalID )
{
DoTrackLookup( e );
return e;
}
}
return NULL;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : rcHandle -
//-----------------------------------------------------------------------------
void ExpressionTool::GetScrubHandleRect( RECT& rcHandle, bool clipped )
{
float pixel = 0.0f;
if ( m_pWorkspace->w2() > 0 )
{
pixel = GetPixelForTimeValue( m_flScrub );
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 : drawHelper -
// rcHandle -
//-----------------------------------------------------------------------------
void ExpressionTool::DrawScrubHandle( CChoreoWidgetDrawHelper& drawHelper, RECT& rcHandle )
{
HBRUSH br = CreateSolidBrush( RGB( 0, 150, 100 ) );
COLORREF areaBorder = RGB( 230, 230, 220 );
drawHelper.DrawColoredLine( areaBorder,
PS_SOLID, 1, 0, rcHandle.top, w2(), rcHandle.top );
drawHelper.DrawColoredLine( areaBorder,
PS_SOLID, 1, 0, rcHandle.bottom, w2(), rcHandle.bottom );
drawHelper.DrawFilledRect( br, rcHandle );
//
char sz[ 32 ];
sprintf( sz, "%.3f", m_flScrub );
CChoreoEvent *ev = GetSafeEvent();
if ( ev )
{
float st, ed;
st = ev->GetStartTime();
ed = ev->GetEndTime();
float dt = ed - st;
if ( dt > 0.0f )
{
sprintf( sz, "%.3f", st + 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 ExpressionTool::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;
}
//-----------------------------------------------------------------------------
// Purpose:
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool ExpressionTool::IsProcessing( void )
{
if ( !GetSafeEvent() )
return false;
if ( m_flScrub != m_flScrubTarget )
return true;
return false;
}
bool ExpressionTool::IsScrubbing( void ) const
{
bool scrubbing = ( m_nDragType == DRAGTYPE_SCRUBBER ) ? true : false;
return scrubbing;
}
void ExpressionTool::Think( float dt )
{
CChoreoEvent *event = GetSafeEvent();
if ( !event )
return;
bool scrubbing = IsScrubbing();
ScrubThink( dt, scrubbing );
}
void ExpressionTool::SetScrubTime( float t )
{
m_flScrub = t;
CChoreoEvent *e = GetSafeEvent();
if ( e )
{
float realtime = e->GetStartTime() + m_flScrub;
g_pChoreoView->SetScrubTime( realtime );
g_pChoreoView->DrawScrubHandle();
}
}
void ExpressionTool::SetScrubTargetTime( float t )
{
m_flScrubTarget = t;
CChoreoEvent *e = GetSafeEvent();
if ( e )
{
float realtime = e->GetStartTime() + m_flScrubTarget;
g_pChoreoView->SetScrubTargetTime( realtime );
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : dt -
//-----------------------------------------------------------------------------
void ExpressionTool::ScrubThink( float dt, bool scrubbing )
{
CChoreoEvent *event = GetSafeEvent();
if ( !event )
return;
if ( m_flScrubTarget == m_flScrub && !scrubbing )
return;
float d = m_flScrubTarget - m_flScrub;
int sign = d > 0.0f ? 1 : -1;
float maxmove = dt;
if ( sign > 0 )
{
if ( d < maxmove )
{
SetScrubTime( m_flScrubTarget );
}
else
{
SetScrubTime( m_flScrub + maxmove );
}
}
else
{
if ( -d < maxmove )
{
SetScrubTime( m_flScrubTarget );
}
else
{
SetScrubTime( m_flScrub - maxmove );
}
}
if ( scrubbing )
{
g_pMatSysWindow->Frame();
}
}
void ExpressionTool::redraw()
{
if ( !ToolCanDraw() )
return;
CChoreoWidgetDrawHelper drawHelper( this );
HandleToolRedraw( drawHelper );
COLORREF areaBorder = RGB( 230, 230, 220 );
RECT rcSelection;
GetWorkspaceRect( rcSelection );
drawHelper.DrawColoredLine( areaBorder,
PS_SOLID, 1, 0, rcSelection.top, w2(), rcSelection.top );
drawHelper.DrawColoredLine( areaBorder,
PS_SOLID, 1, 0, rcSelection.bottom, w2(), rcSelection.bottom );
if ( m_bSelectionActive )
{
RECT rcClient;
drawHelper.GetClientRect( rcClient );
int left, right;
left = GetPixelForTimeValue( m_flSelection[ 0 ] );
right = GetPixelForTimeValue( m_flSelection[ 1 ] );
rcSelection.left = left;
rcSelection.right = right;
rcSelection.bottom = TRAY_HEIGHT;
drawHelper.DrawFilledRect( RGB( 200, 220, 230 ), rcSelection );
drawHelper.DrawColoredLine( RGB( 100, 100, 255 ), PS_SOLID, 3, rcSelection.left, rcSelection.top, rcSelection.left, rcSelection.bottom );
drawHelper.DrawColoredLine( RGB( 100, 100, 255 ), PS_SOLID, 3, rcSelection.right, rcSelection.top, rcSelection.right, rcSelection.bottom );
}
CChoreoEvent *ev = GetSafeEvent();
if ( ev )
{
RECT rcText;
drawHelper.GetClientRect( rcText );
rcText.top += GetCaptionHeight()+1;
rcText.bottom = rcText.top + 13;
rcText.left += 5;
rcText.right -= 5;
OffsetRect( &rcText, 0, 12 );
int current, total;
g_pChoreoView->GetUndoLevels( current, total );
if ( total > 0 )
{
RECT rcUndo = rcText;
OffsetRect( &rcUndo, 0, 2 );
drawHelper.DrawColoredText( "Small Fonts", 8, FW_NORMAL, RGB( 0, 100, 0 ), rcUndo,
"Undo: %i/%i", current, total );
}
rcText.left += 60;
// Found it, write out description
//
drawHelper.DrawColoredText( "Arial", 11, 900, RGB( 200, 150, 100 ), rcText,
"Event: %s",
ev->GetName() );
OffsetRect( &rcText, 0, 30 );
rcText.left = 5;
RECT timeRect = rcText;
timeRect.right = timeRect.left + 100;
char sz[ 32 ];
float st, ed;
GetStartAndEndTime( st, ed );
st += ev->GetStartTime();
ed += ev->GetStartTime();
Q_snprintf( sz, sizeof( sz ), "%.2f", st );
drawHelper.DrawColoredText( "Arial", 9, FW_NORMAL, RGB( 0, 0, 0 ), timeRect, sz );
timeRect = rcText;
Q_snprintf( sz, sizeof( sz ), "%.2f", ed );
int textW = drawHelper.CalcTextWidth( "Arial", 9, FW_NORMAL, sz );
timeRect.right = w2() - 10;
timeRect.left = timeRect.right - textW;
drawHelper.DrawColoredText( "Arial", 9, FW_NORMAL, RGB( 0, 0, 0 ), timeRect, sz );
}
RECT rcHandle;
GetScrubHandleRect( rcHandle, true );
DrawScrubHandle( drawHelper, rcHandle );
DrawRelativeTags( drawHelper );
RECT rcPos;
GetMouseOverPosRect( rcPos );
DrawMouseOverPos( drawHelper, rcPos );
DrawEventEnd( drawHelper );
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *tag -
//-----------------------------------------------------------------------------
bool ExpressionTool::GetTimingTagRect( RECT& rcClient, CChoreoEvent *event, CFlexTimingTag *tag, RECT& rcTag )
{
rcTag = rcClient;
int tagx = GetPixelForTimeValue( tag->GetStartTime() - event->GetStartTime() );
rcTag.top = rcClient.bottom - 6;
rcTag.bottom = rcTag.top + 6;
rcTag.left = tagx - 3;
rcTag.right = tagx + 3;
return true;
}
// Get workspace min, max point in terms of tool window
void ExpressionTool::GetWorkspaceLeftRight( int& left, int& right )
{
POINT pt;
pt.x = TRAY_ITEM_INSET;
pt.y = 0;
ClientToScreen( (HWND)m_pWorkspace->getHandle(), &pt );
ScreenToClient( (HWND)getHandle(), &pt );
left = (short)pt.x;
pt.x = m_pWorkspace->w2() - TRAY_ITEM_INSET - 12;
pt.y = 0;
ClientToScreen( (HWND)m_pWorkspace->getHandle(), &pt );
ScreenToClient( (HWND)getHandle(), &pt );
right = (short)pt.x;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : mx -
// my -
// Output : CFlexTimingTag
//-----------------------------------------------------------------------------
CFlexTimingTag *ExpressionTool::IsMouseOverTag( int mx, int my )
{
CChoreoEvent *event = GetSafeEvent();
if ( !event )
return NULL;
RECT rcClient;
GetClientRect( (HWND)getHandle(), &rcClient );
int left, right;
GetWorkspaceLeftRight( left, right );
rcClient.left = left;
rcClient.right = right;
rcClient.top = GetCaptionHeight();
rcClient.bottom = rcClient.top + TRAY_HEIGHT;
POINT pt;
pt.x = mx;
pt.y = my;
for ( int i = 0 ; i < event->GetNumTimingTags(); i++ )
{
CFlexTimingTag *tag = event->GetTimingTag( i );
if ( !tag )
continue;
RECT rcTag;
if ( !GetTimingTagRect( rcClient, event, tag, rcTag ) )
continue;
if ( !PtInRect( &rcTag, pt ) )
continue;
return tag;
}
return NULL;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : drawHelper -
//-----------------------------------------------------------------------------
void ExpressionTool::DrawRelativeTags( CChoreoWidgetDrawHelper& drawHelper )
{
CChoreoEvent *event = GetSafeEvent();
if ( !event )
return;
float st, ed;
GetStartAndEndTime( st, ed );
if ( event->GetDuration() <= 0.0f )
return;
CChoreoScene *scene = g_pChoreoView->GetScene();
if ( !scene )
return;
RECT rcClient;
drawHelper.GetClientRect( rcClient );
int left, right;
GetWorkspaceLeftRight( left, right );
rcClient.top += GetCaptionHeight();
rcClient.left = left;
rcClient.right = right;
rcClient.bottom = rcClient.top + TRAY_HEIGHT;
// Iterate relative tags
for ( int i = 0; i < scene->GetNumActors(); i++ )
{
CChoreoActor *a = scene->GetActor( i );
if ( !a )
continue;
for ( int j = 0; j < a->GetNumChannels(); j++ )
{
CChoreoChannel *c = a->GetChannel( j );
if ( !c )
continue;
for ( int k = 0 ; k < c->GetNumEvents(); k++ )
{
CChoreoEvent *e = c->GetEvent( k );
if ( !e )
continue;
// add each tag to combo box
for ( int t = 0; t < e->GetNumRelativeTags(); t++ )
{
CEventRelativeTag *tag = e->GetRelativeTag( t );
if ( !tag )
continue;
//SendMessage( control, CB_ADDSTRING, 0, (LPARAM)va( "\"%s\" \"%s\"", tag->GetName(), e->GetParameters() ) );
bool clipped;
int tagx = GetPixelForTimeValue( tag->GetStartTime() - event->GetStartTime(), &clipped );
if ( clipped )
continue;
//drawHelper.DrawColoredLine( RGB( 180, 180, 220 ), PS_SOLID, 1, tagx, rcClient.top, tagx, rcClient.bottom );
RECT rcMark;
rcMark = rcClient;
rcMark.top = rcClient.bottom - 6;
rcMark.left = tagx - 3;
rcMark.right = tagx + 3;
drawHelper.DrawTriangleMarker( rcMark, RGB( 0, 100, 250 ) );
RECT rcText;
rcText = rcMark;
rcText.top -= 10;
int len = drawHelper.CalcTextWidth( "Arial", 9, FW_NORMAL, tag->GetName() );
rcText.left = tagx - len / 2;
rcText.right = rcText.left + len + 2;
rcText.bottom = rcText.top + 10;
drawHelper.DrawColoredText( "Arial", 9, FW_NORMAL, RGB( 0, 100, 200 ), rcText, tag->GetName() );
}
}
}
}
for ( int t = 0; t < event->GetNumTimingTags(); t++ )
{
CFlexTimingTag *tag = event->GetTimingTag( t );
if ( !tag )
continue;
RECT rcMark;
if ( !GetTimingTagRect( rcClient, event, tag, rcMark ) )
continue;
drawHelper.DrawTriangleMarker( rcMark, RGB( 250, 100, 0 ) );
RECT rcText;
rcText = rcMark;
rcText.top -= 20;
char text[ 256 ];
sprintf( text, "%s", tag->GetName() );
if ( tag->GetLocked() )
{
strcat( text, " - locked" );
}
int len = drawHelper.CalcTextWidth( "Arial", 9, FW_NORMAL, text );
rcText.left = ( rcMark.left + rcMark.right ) / 2 - len / 2;
rcText.right = rcText.left + len + 2;
rcText.bottom = rcText.top + 10;
drawHelper.DrawColoredText( "Arial", 9, FW_NORMAL, RGB( 200, 100, 0 ), rcText, text );
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void ExpressionTool::ShowContextMenu( mxEvent *event, bool include_track_menus )
{
// Construct main menu
mxPopupMenu *pop = new mxPopupMenu();
TimelineItem *item = NULL;
CFlexAnimationTrack *track = NULL;
if ( include_track_menus )
{
item = m_pWorkspace->GetClickedItem();
if ( item )
{
item->CountSelected();
track = item->GetSafeTrack();
}
}
int current, total;
g_pChoreoView->GetUndoLevels( current, total );
if ( total > 0 )
{
if ( current > 0 )
{
pop->add( va( "Undo %s", g_pChoreoView->GetUndoDescription() ), IDC_UNDO_FA );
}
if ( current <= total - 1 )
{
pop->add( va( "Redo %s", g_pChoreoView->GetRedoDescription() ), IDC_REDO_FA );
}
pop->addSeparator();
}
// Create expand menu
mxPopupMenu *expand = new mxPopupMenu();
if ( item && track && item->IsCollapsed() )
{
expand->add( va( "Track '%s'", track->GetFlexControllerName() ), IDC_TL_EXPAND );
}
expand->add( "All tracks", IDC_EXPANDALL );
expand->add( "Used tracks", IDC_EXPANDVALID );
pop->addMenu( "Expand", expand );
mxPopupMenu *collapse = new mxPopupMenu;
if ( item && track && !item->IsCollapsed() )
{
collapse->add( va( "Track '%s'", track->GetFlexControllerName() ), IDC_TL_COLLAPSE );
collapse->add( va( "All tracks except '%s'", track->GetFlexControllerName() ), IDC_COLLAPSE_ALL_EXCEPT );
}
collapse->add( "All tracks", IDC_COLLAPSEALL );
pop->addMenu( "Collapse", collapse );
pop->addSeparator();
pop->add( va( "Enable all valid" ), IDC_ENABLE_ALL_VALID );
if ( item && track )
{
if ( item->IsActive() )
{
pop->add( va( "Disable '%s'", track->GetFlexControllerName() ), IDC_TL_DISABLE );
}
else
{
pop->add( va( "Enable '%s'", track->GetFlexControllerName() ), IDC_TL_ENABLE );
}
pop->add( va( "Disable all except '%s'", track->GetFlexControllerName() ), IDC_DISABLE_ALL_EXCEPT );
pop->addSeparator();
pop->add( "Copy", IDC_TL_COPY );
if ( HasCopyData() )
{
pop->add( "Paste", IDC_TL_PASTE );
}
pop->addSeparator();
if ( item->GetNumSelected() > 0 )
{
pop->add( va( "Delete" ), IDC_TL_DELETE );
pop->add( "Deselect all", IDC_TL_DESELECT );
pop->add( va( "Scale selected..." ), IDC_FLEX_SCALESAMPLES );
}
pop->add( "Select all", IDC_TL_SELECTALL );
if ( FacePoser_IsSnapping() )
{
mxPopupMenu *snap = new mxPopupMenu();
snap->add( va( "All points" ), IDC_TL_SNAPALL );
snap->add( va( "All points in '%s'", track->GetFlexControllerName() ), IDC_TL_SNAPPOINTS );
snap->add( va( "Selected points in '%s'", track->GetFlexControllerName() ), IDC_TL_SNAPSELECTED );
pop->addSeparator();
pop->addMenu( "Snap", snap );
}
if ( track->IsComboType() )
{
pop->addSeparator();
if ( item->GetEditType() == 0 )
{
pop->add( "Edit <left/right>", IDC_TL_EDITLEFTRIGHT );
}
else
{
pop->add( "Edit <amount>", IDC_TL_EDITNORMAL );
}
}
pop->addSeparator();
mxPopupMenu *heightMenu = new mxPopupMenu();
heightMenu->add( va( "Reset '%s'", track->GetFlexControllerName() ) , IDC_ET_RESET_ITEM_SIZE );
heightMenu->add( "Reset All", IDC_ET_RESET_ALL_ITEM_SIZES );
pop->addMenu( "Height", heightMenu );
pop->addSeparator();
pop->add( "Edge Properties...", IDC_ET_EDGEPROPERTIES );
}
pop->addSeparator();
mxPopupMenu *tagmenu = new mxPopupMenu();
CFlexTimingTag *tag = IsMouseOverTag( (short)event->x, (short)event->y );
if ( tag )
{
if ( tag->GetLocked() )
{
tagmenu->add( va( "Unlock tag '%s'...", tag->GetName() ), IDC_UNLOCK_TIMING_TAG );
}
else
{
tagmenu->add( va( "Lock tag '%s'...", tag->GetName() ), IDC_LOCK_TIMING_TAG );
}
tagmenu->addSeparator();
tagmenu->add( va( "Delete tag '%s'...", tag->GetName() ), IDC_DELETE_TIMING_TAG );
}
else
{
tagmenu->add( "Insert...", IDC_INSERT_TIMING_TAG );
}
bool bMouseOverSelection = IsMouseOverSelection( (short)event->x, (short)event->y );
if ( bMouseOverSelection || HasCopiedColumn() )
{
mxPopupMenu *selectionMenu = new mxPopupMenu();
if ( bMouseOverSelection )
{
selectionMenu->add( "Copy samples", IDC_ET_SELECTION_COPY );
}
if ( HasCopiedColumn() )
{
selectionMenu->add( "Paste samples", IDC_ET_SELECTION_PASTE );
}
if ( bMouseOverSelection )
{
selectionMenu->addSeparator();
selectionMenu->add( "Delete samples", IDC_ET_SELECTION_DELETE );
selectionMenu->add( "Delete samples and shift remainder", IDC_ET_SELECTION_EXCISE );
}
pop->addMenu( "Column", selectionMenu );
}
pop->addMenu( "Timing Tags", tagmenu );
if ( FacePoser_IsSnapping() )
{
pop->addSeparator();
pop->add( "Delete keys by frame", IDC_TL_DELETECOLUMN );
pop->addSeparator();
}
mxPopupMenu *flexmenu = new mxPopupMenu();
flexmenu->add( "Copy to sliders", IDC_COPY_TO_FLEX );
flexmenu->add( "Copy from sliders", IDC_COPY_FROM_FLEX );
pop->addMenu( "Flex", flexmenu );
pop->add( "Create expression...", IDC_NEW_EXPRESSION_FROM_FLEXANIMATION );
CChoreoEvent *e = GetSafeEvent();
if ( e )
{
mxPopupMenu *importexport = new mxPopupMenu();
importexport->add( "Export flex animation...", IDC_EXPORT_FA );
importexport->add( "Import flex animation...", IDC_IMPORT_FA );
pop->addMenu( "Import/Export", importexport );
}
pop->add( va( "Change scale..." ), IDC_FLEX_CHANGESCALE );
mxPopupMenu *sortmenu = new mxPopupMenu();
sortmenu->add( "Sort by name", IDC_ET_SORT_BY_NAME );
sortmenu->add( "Sort by used", IDC_ET_SORT_BY_USED );
pop->addMenu( "Sort", sortmenu );
pop->popup( this, (short)event->x, (short)event->y );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void ExpressionTool::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 );
}
void ExpressionTool::SetClickedPos( int x, int y )
{
m_nClickedX = x;
m_nClickedY = y;
}
float ExpressionTool::GetTimeForClickedPos( void )
{
CChoreoEvent *e = GetSafeEvent();
if ( !e )
return 0.0f;
float t = GetTimeValueForMouse( m_nClickedX );
// Get spline intensity for controller
float faketime = e->GetStartTime() + t;
return faketime;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : dragtype -
// startx -
// cursor -
//-----------------------------------------------------------------------------
void ExpressionTool::StartDragging( int dragtype, int startx, int starty, HCURSOR cursor )
{
m_nDragType = dragtype;
m_nStartX = startx;
m_nLastX = startx;
m_nStartY = starty;
m_nLastY = starty;
if ( m_hPrevCursor )
{
SetCursor( m_hPrevCursor );
m_hPrevCursor = NULL;
}
m_hPrevCursor = SetCursor( cursor );
m_FocusRects.Purge();
RECT rc;
GetWorkspaceRect( rc );
RECT rcStart;
rcStart.left = startx;
rcStart.right = startx;
bool addrect = true;
switch ( dragtype )
{
default:
case DRAGTYPE_SCRUBBER:
{
RECT rcScrub;
GetScrubHandleRect( rcScrub, true );
rcStart = rcScrub;
rcStart.left = ( rcScrub.left + rcScrub.right ) / 2;
rcStart.right = rcStart.left;
rcStart.top = rcScrub.bottom;
rcStart.bottom = h2();
}
break;
case DRAGTYPE_FLEXTIMINGTAG:
{
rcStart.top = rc.top;
rcStart.bottom = h2();
}
break;
case DRAGTYPE_SELECTSAMPLES:
{
float st = GetTimeValueForMouse( startx );
rcStart.left = GetPixelForTimeValue( st );
rcStart.right = rcStart.left;
m_nStartX = rcStart.left;
m_nLastX = rcStart.left;
}
case DRAGTYPE_MOVESELECTIONSTART:
case DRAGTYPE_MOVESELECTIONEND:
{
rcStart.top = rc.top;
rcStart.bottom = rc.bottom;
}
break;
case DRAGTYPE_MOVESELECTION:
{
rcStart.top = rc.top;
rcStart.bottom = rc.bottom;
// Compute left/right pixels for selection
rcStart.left = GetPixelForTimeValue( m_flSelection[ 0 ] );
rcStart.right = GetPixelForTimeValue( m_flSelection[ 1 ] );
}
break;
}
if ( addrect )
{
AddFocusRect( rcStart );
}
DrawFocusRect();
}
void ExpressionTool::OnMouseMove( mxEvent *event )
{
int mx = (short)event->x;
int my = (short)event->y;
event->x = (short)mx;
if ( m_nDragType != DRAGTYPE_NONE )
{
DrawFocusRect();
for ( int i = 0; i < m_FocusRects.Size(); i++ )
{
CFocusRect *f = &m_FocusRects[ i ];
f->m_rcFocus = f->m_rcOrig;
switch ( m_nDragType )
{
default:
{
OffsetRect( &f->m_rcFocus, ( (short)event->x - m_nStartX ), 0 );
}
break;
case DRAGTYPE_SELECTSAMPLES:
{
float st = GetTimeValueForMouse( mx );
int snapx = GetPixelForTimeValue( st );
f->m_rcFocus.left = min( snapx, m_nStartX );
f->m_rcFocus.right = max( snapx, m_nStartY );
POINT offset;
offset.x = 0;
offset.y = 0;
ClientToScreen( (HWND)getHandle(), &offset );
OffsetRect( &f->m_rcFocus, offset.x, 0 );
}
break;
}
}
DrawFocusRect();
}
else
{
if ( m_hPrevCursor )
{
SetCursor( m_hPrevCursor );
m_hPrevCursor = NULL;
}
if ( IsMouseOverScrubHandle( event ) )
{
m_hPrevCursor = SetCursor( LoadCursor( NULL, IDC_SIZEWE ) );
}
else if ( IsMouseOverTag( mx, my ) )
{
m_hPrevCursor = SetCursor( LoadCursor( NULL, IDC_SIZEWE ) );
}
else if ( IsMouseOverSelection( (short)event->x, (short)event->y ) )
{
if ( IsMouseOverSelectionStartEdge( event ) )
{
m_hPrevCursor = SetCursor( LoadCursor( NULL, IDC_SIZEWE ) );
}
else if ( IsMouseOverSelectionEndEdge( event ) )
{
m_hPrevCursor = SetCursor( LoadCursor( NULL, IDC_SIZEWE ) );
}
else
{
if ( event->modifiers & mxEvent::KeyShift )
{
m_hPrevCursor = SetCursor( LoadCursor( NULL, IDC_SIZEALL ) );
}
}
}
}
switch ( m_nDragType )
{
default:
break;
case DRAGTYPE_FLEXTIMINGTAG:
{
ApplyBounds( mx, my );
}
break;
case DRAGTYPE_SCRUBBER:
{
ApplyBounds( mx, my );
if ( w2() > 0 )
{
float t = GetTimeValueForMouse( mx );
t += m_flScrubberTimeOffset;
ForceScrubPosition( t );
}
}
break;
}
m_nLastX = (short)event->x;
m_nLastY = (short)event->y;
}
int ExpressionTool::handleEvent( mxEvent *event )
{
MDLCACHE_CRITICAL_SECTION_( g_pMDLCache );
int iret = 0;
if ( HandleToolEvent( event ) )
{
return iret;
}
switch ( event->event )
{
case mxEvent::Size:
{
int w, h;
w = event->width;
h = event->height;
m_pWorkspace->setBounds( 5, TRAY_HEIGHT + GetCaptionHeight(), w - 10, h - ( TRAY_HEIGHT + 5 + GetCaptionHeight() ) - m_nScrollbarHeight );
m_nLastHPixelsNeeded = 0;
InvalidateLayout();
iret = 1;
}
break;
case mxEvent::MouseWheeled:
{
CChoreoScene *scene = g_pChoreoView->GetScene();
if ( scene )
{
int tz = g_pChoreoView->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 );
}
g_pChoreoView->SetPreservedTimeZoom( this, tz );
}
//RepositionHSlider();
m_pWorkspace->redraw();
redraw();
iret = 1;
}
break;
case mxEvent::MouseDown:
{
// bool ctrldown = ( event->modifiers & mxEvent::KeyCtrl ) ? true : false;
bool shiftdown = ( event->modifiers & mxEvent::KeyShift ) ? true : false;
iret = 1;
int mx = (short)event->x;
int my = (short)event->y;
SetClickedPos( mx, my );
SetMouseOverPos( mx, my );
DrawMouseOverPos();
if ( event->buttons & mxEvent::MouseRightButton )
{
ShowContextMenu( event, false );
return iret;
}
if ( m_nDragType == DRAGTYPE_NONE )
{
if ( IsMouseOverScrubHandle( event ) )
{
if ( w2() > 0 )
{
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;
ForceScrubPosition( t );
}
StartDragging( DRAGTYPE_SCRUBBER, m_nClickedX, m_nClickedY, LoadCursor( NULL, IDC_SIZEWE ) );
}
else if ( IsMouseOverTag( m_nClickedX, m_nClickedY ) )
{
StartDragging( DRAGTYPE_FLEXTIMINGTAG, m_nClickedX, m_nClickedY, LoadCursor( NULL, IDC_SIZEWE ) );
}
else if ( IsMouseOverPoints( m_nClickedX, m_nClickedY ) )
{
if ( !m_bSelectionActive )
{
StartDragging( DRAGTYPE_SELECTSAMPLES, m_nClickedX, m_nClickedY, LoadCursor( NULL, IDC_SIZEWE ) );
}
else
{
// Either move, move edge if ctrl key is held, or deselect
if ( IsMouseOverSelection( m_nClickedX,m_nClickedY ) )
{
if ( IsMouseOverSelectionStartEdge( event ) )
{
StartDragging( DRAGTYPE_MOVESELECTIONSTART, m_nClickedX, m_nClickedY, LoadCursor( NULL, IDC_SIZEWE ) );
}
else if ( IsMouseOverSelectionEndEdge( event ) )
{
StartDragging( DRAGTYPE_MOVESELECTIONEND, m_nClickedX, m_nClickedY, LoadCursor( NULL, IDC_SIZEWE ) );
}
else
{
if ( shiftdown )
{
StartDragging( DRAGTYPE_MOVESELECTION, m_nClickedX, m_nClickedY, LoadCursor( NULL, IDC_SIZEALL ) );
}
}
}
else
{
m_bSelectionActive = false;
redraw();
return iret;
}
}
}
else
{
if ( w2() > 0 )
{
float t = GetTimeValueForMouse( (short)event->x );
SetScrubTargetTime( t );
}
}
CalcBounds( m_nDragType );
}
}
break;
case mxEvent::MouseDrag:
case mxEvent::MouseMove:
{
int mx = (short)event->x;
int my = (short)event->y;
SetMouseOverPos( mx, my );
DrawMouseOverPos();
OnMouseMove( event );
iret = 1;
}
break;
case mxEvent::MouseUp:
{
if ( event->buttons & mxEvent::MouseRightButton )
{
return 1;
}
int mx = (short)event->x;
int my = (short)event->y;
if ( m_nDragType != DRAGTYPE_NONE )
{
DrawFocusRect();
}
if ( m_hPrevCursor )
{
SetCursor( m_hPrevCursor );
m_hPrevCursor = 0;
}
switch ( m_nDragType )
{
case DRAGTYPE_NONE:
break;
case DRAGTYPE_SELECTSAMPLES:
FinishSelect( m_nStartX, mx );
break;
case DRAGTYPE_MOVESELECTION:
FinishMoveSelection( m_nStartX, mx );
break;
case DRAGTYPE_MOVESELECTIONSTART:
FinishMoveSelectionStart( m_nStartX, mx );
break;
case DRAGTYPE_MOVESELECTIONEND:
FinishMoveSelectionEnd( m_nStartX, mx );
break;
case DRAGTYPE_SCRUBBER:
{
ApplyBounds( mx, my );
// int dx = mx - m_nStartX;
// int dy = my = m_nStartY;
if ( w2() > 0 )
{
float t = GetTimeValueForMouse( (short)event->x );
t += m_flScrubberTimeOffset;
m_flScrubberTimeOffset = 0.0f;
ForceScrubPosition( t );
}
}
break;
case DRAGTYPE_FLEXTIMINGTAG:
{
ApplyBounds( mx, my );
// int dx = mx - m_nStartX;
// int dy = my = m_nStartY;
// Compute dx, dy and apply to sections
//Con_Printf( "dx == %i\n", dx );
CFlexTimingTag *tag = IsMouseOverTag( m_nStartX, m_nStartY );
CChoreoEvent *ev = GetSafeEvent();
if ( tag && g_pChoreoView && ev && ev->GetDuration() )
{
float t = GetTimeValueForMouse( mx );
float percent = t / ev->GetDuration();
g_pChoreoView->SetDirty( true );
g_pChoreoView->PushUndo( "Move Timing Tag" );
if ( tag->GetLocked() )
{
// Resample all control points on right/left
// of locked tags all the way to the next lock or edge
ResampleControlPoints( tag, percent );
}
tag->SetPercentage( percent );
g_pChoreoView->PushRedo( "Move Timing Tag" );
}
LayoutItems( true );
redraw();
}
break;
}
m_nDragType = DRAGTYPE_NONE;
SetMouseOverPos( mx, my );
DrawMouseOverPos();
iret = 1;
}
break;
case mxEvent::Action:
{
iret = 1;
switch ( event->action )
{
default:
iret = 0;
break;
case IDC_ET_RESET_ITEM_SIZE:
OnResetItemSize();
break;
case IDC_ET_RESET_ALL_ITEM_SIZES:
OnResetAllItemSizes();
break;
case IDC_ET_SELECTION_DELETE:
OnDeleteSelection( false );
break;
case IDC_ET_SELECTION_EXCISE:
OnDeleteSelection( true );
break;
case IDC_ET_SELECTION_COPY:
OnCopyColumn();
break;
case IDC_ET_SELECTION_PASTE:
OnPasteColumn();
break;
case IDC_ET_SORT_BY_USED:
OnSortByUsed();
break;
case IDC_ET_SORT_BY_NAME:
OnSortByName();
break;
case IDC_EXPORT_FA:
OnExportFlexAnimation();
break;
case IDC_IMPORT_FA:
OnImportFlexAnimation();
break;
case IDC_LOCK_TIMING_TAG:
LockTimingTag();
break;
case IDC_UNLOCK_TIMING_TAG:
UnlockTimingTag();
break;
case IDC_DELETE_TIMING_TAG:
DeleteFlexTimingTag( m_nClickedX, m_nClickedY );
break;
case IDC_INSERT_TIMING_TAG:
AddFlexTimingTag( m_nClickedX );
break;
case IDC_EXPANDALL:
m_pWorkspace->ExpandAll();
break;
case IDC_COLLAPSEALL:
m_pWorkspace->CollapseAll( NULL );
break;
case IDC_COLLAPSE_ALL_EXCEPT:
m_pWorkspace->CollapseAll( m_pWorkspace->GetClickedItem() );
break;
case IDC_EXPANDVALID:
m_pWorkspace->ExpandValid();
break;
case IDC_COPY_TO_FLEX:
OnCopyToFlex( true );
break;
case IDC_COPY_FROM_FLEX:
OnCopyFromFlex( false );
break;
case IDC_NEW_EXPRESSION_FROM_FLEXANIMATION:
OnNewExpression();
break;
case IDC_UNDO_FA:
OnUndo();
break;
case IDC_REDO_FA:
OnRedo();
break;
case IDC_TL_EDITNORMAL:
{
TimelineItem *item = m_pWorkspace->GetClickedItem();
if ( item )
{
item->SetEditType( 0 );
item->DrawSelf();
}
}
break;
case IDC_TL_EDITLEFTRIGHT:
{
TimelineItem *item = m_pWorkspace->GetClickedItem();
if ( item )
{
item->SetEditType( 1 );
item->DrawSelf();
}
}
break;
case IDC_TL_EXPAND:
{
TimelineItem *item = m_pWorkspace->GetClickedItem();
if ( item )
{
item->SetCollapsed( false );
}
LayoutItems();
}
break;
case IDC_TL_COLLAPSE:
{
TimelineItem *item = m_pWorkspace->GetClickedItem();
if ( item )
{
item->SetCollapsed( true );
}
LayoutItems();
}
break;
case IDC_TL_ENABLE:
{
TimelineItem *item = m_pWorkspace->GetClickedItem();
if ( item )
{
g_pChoreoView->SetDirty( true );
g_pChoreoView->PushUndo( "Enable item" );
item->SetActive( true );
g_pChoreoView->PushRedo( "Enable item" );
item->DrawSelf();
}
}
break;
case IDC_TL_DISABLE:
{
TimelineItem *item = m_pWorkspace->GetClickedItem();
if ( item )
{
g_pChoreoView->SetDirty( true );
g_pChoreoView->PushUndo( "Disable item" );
item->SetActive( false );
g_pChoreoView->PushRedo( "Disable item" );
item->DrawSelf();
}
}
break;
case IDC_TL_COPY:
{
TimelineItem *item = m_pWorkspace->GetClickedItem();
if ( item )
{
item->Copy();
}
}
break;
case IDC_TL_PASTE:
{
TimelineItem *item = m_pWorkspace->GetClickedItem();
if ( item )
{
item->Paste();
item->DrawSelf();
}
}
break;
case IDC_TL_DELETE:
{
TimelineItem *item = m_pWorkspace->GetClickedItem();
if ( item )
{
item->Delete();
item->DrawSelf();
}
}
break;
case IDC_TL_DESELECT:
{
TimelineItem *item = m_pWorkspace->GetClickedItem();
if ( item )
{
item->DeselectAll();
item->DrawSelf();
}
}
break;
case IDC_TL_SELECTALL:
{
TimelineItem *item = m_pWorkspace->GetClickedItem();
if ( item )
{
item->SelectAll();
item->DrawSelf();
}
}
break;
case IDC_DISABLE_ALL_EXCEPT:
{
m_pWorkspace->DisableAllExcept();
}
break;
case IDC_ENABLE_ALL_VALID:
{
m_pWorkspace->EnableValid();
}
break;
case IDC_TL_SNAPSELECTED:
{
TimelineItem *item = m_pWorkspace->GetClickedItem();
if ( item )
{
g_pChoreoView->SetDirty( true );
g_pChoreoView->PushUndo( "Snap Selected" );
item->SnapSelected();
g_pChoreoView->PushRedo( "Snap Selected" );
item->DrawSelf();
}
}
break;
case IDC_TL_SNAPPOINTS:
{
TimelineItem *item = m_pWorkspace->GetClickedItem();
if ( item )
{
g_pChoreoView->SetDirty( true );
g_pChoreoView->PushUndo( "Snap Item" );
item->SnapAll();
g_pChoreoView->PushRedo( "Snap Item" );
item->DrawSelf();
}
}
break;
case IDC_TL_DELETECOLUMN:
{
m_pWorkspace->OnDeleteColumn();
}
break;
case IDC_TL_SNAPALL:
{
m_pWorkspace->OnSnapAll();
}
break;
case IDC_FLEXHSCROLL:
{
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_FLEX_CHANGESCALE:
{
OnChangeScale();
}
break;
case IDC_FLEX_SCALESAMPLES:
{
OnScaleSamples();
}
break;
case IDC_ET_EDGEPROPERTIES:
{
OnEdgeProperties();
}
break;
}
}
break;
case mxEvent::KeyDown:
case mxEvent::KeyUp:
{
TimelineItem *item = m_pWorkspace->GetClickedItem();
if ( item )
{
iret = item->handleEvent( event );
}
if ( !iret )
{
switch ( event->key )
{
default:
break;
case VK_ESCAPE:
{
DeselectAll();
iret = 1;
}
break;
}
}
}
break;
}
return iret;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : false -
//-----------------------------------------------------------------------------
void ExpressionTool::LayoutItems( bool force /*= false*/ )
{
m_pWorkspace->LayoutItems( force );
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *event -
//-----------------------------------------------------------------------------
void ExpressionTool::AddFlexTimingTag( int mx )
{
Assert( g_pChoreoView );
CChoreoEvent *event = GetSafeEvent();
if ( !event )
return;
if ( event->GetType() != CChoreoEvent::FLEXANIMATION )
{
Con_ErrorPrintf( "Timing Tag: Can only tag FLEXANIMATION events\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( "Timing Tag Name: No name entered!\n" );
return;
}
// Convert click to frac
float t = GetTimeValueForMouse( mx );
float frac = 0.0f;
if ( event->GetDuration() )
{
frac = t / event->GetDuration();
frac = clamp( frac, 0.0f, 1.0f );
}
g_pChoreoView->SetDirty( true );
g_pChoreoView->PushUndo( "Add Timing Tag" );
event->AddTimingTag( params.m_szInputText, frac, true );
g_pChoreoView->PushRedo( "Add Timing Tag" );
// Redraw this window
m_pWorkspace->redraw();
redraw();
}
void ExpressionTool::DeleteFlexTimingTag( int mx, int my )
{
Assert( g_pChoreoView );
CChoreoEvent *event = GetSafeEvent();
if ( !event )
return;
CFlexTimingTag *tag = IsMouseOverTag( mx, my );
if ( !tag )
return;
g_pChoreoView->SetDirty( true );
g_pChoreoView->PushUndo( "Delete Timing Tag" );
event->RemoveTimingTag( tag->GetName() );
g_pChoreoView->PushRedo( "Delete Timing Tag" );
LayoutItems( true );
// Redraw this window
redraw();
}
void ExpressionTool::LockTimingTag( void )
{
Assert( g_pChoreoView );
CChoreoEvent *event = GetSafeEvent();
if ( !event )
return;
CFlexTimingTag *tag = IsMouseOverTag( m_nClickedX, m_nClickedY );
if ( !tag )
return;
if ( tag->GetLocked() )
return;
g_pChoreoView->SetDirty( true );
g_pChoreoView->PushUndo( "Lock Timing Tag" );
tag->SetLocked( true );
g_pChoreoView->PushRedo( "Lock Timing Tag" );
redraw();
}
void ExpressionTool::UnlockTimingTag( void )
{
Assert( g_pChoreoView );
CChoreoEvent *event = GetSafeEvent();
if ( !event )
return;
CFlexTimingTag *tag = IsMouseOverTag( m_nClickedX, m_nClickedY );
if ( !tag )
return;
if ( !tag->GetLocked() )
return;
g_pChoreoView->SetDirty( true );
g_pChoreoView->PushUndo( "Unlock Timing Tag" );
tag->SetLocked( false );
g_pChoreoView->PushRedo( "Unlock Timing Tag" );
redraw();
}
void ExpressionTool::ApplyBounds( int& mx, int& my )
{
if ( !m_bUseBounds )
return;
mx = clamp( mx, m_nMinX, m_nMaxX );
}
void ExpressionTool::CalcBounds( int movetype )
{
switch ( movetype )
{
default:
case DRAGTYPE_NONE:
m_bUseBounds = false;
m_nMinX = 0;
m_nMaxX = 0;
break;
case DRAGTYPE_SCRUBBER:
m_bUseBounds = true;
m_nMinX = 0;
m_nMaxX = w2();
break;
case DRAGTYPE_FLEXTIMINGTAG:
{
m_bUseBounds = true;
int left, right;
GetWorkspaceLeftRight( left, right );
m_nMinX = left;
m_nMaxX = right;
RECT rcClient;
rcClient.left = left;
rcClient.right = right;
rcClient.top = 0;
rcClient.bottom = TRAY_HEIGHT;
CFlexTimingTag *tag = IsMouseOverTag( m_nStartX, m_nStartY );
if ( tag &&
tag->GetOwner() )
{
CChoreoEvent *e = tag->GetOwner();
float st = e->GetStartTime();
float ed = e->GetEndTime();
if ( ed > st )
{
// Find previous tag, if any
CFlexTimingTag *prev = NULL;
CFlexTimingTag *next = NULL;
for ( int i = 0; i < e->GetNumTimingTags(); i++ )
{
CFlexTimingTag *test = e->GetTimingTag( i );
if ( test != tag )
continue;
// Found it
if ( i > 0 )
{
prev = e->GetTimingTag( i - 1 );
}
if ( i + 1 < e->GetNumTimingTags() )
{
next = e->GetTimingTag( i + 1 );
}
break;
}
if ( prev )
{
// Compute x pixel of prev tag
float frac = ( prev->GetStartTime() - st ) / ( ed - st );
if ( frac >= 0.0f && frac <= 1.0f )
{
int tagx = rcClient.left + (int)( frac * (float)( rcClient.right - rcClient.left ) );
m_nMinX = max( m_nMinX, tagx + 5 );
}
}
if ( next )
{
// Compute x pixel of next tag
float frac = ( next->GetStartTime() - st ) / ( ed - st );
if ( frac >= 0.0f && frac <= 1.0f )
{
int tagx = rcClient.left + (int)( frac * (float)( rcClient.right - rcClient.left ) );
m_nMaxX = min( m_nMaxX, tagx - 5 );
}
}
}
}
}
break;
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *tag -
// newposition -
//-----------------------------------------------------------------------------
void ExpressionTool::ResampleControlPoints( CFlexTimingTag *tag, float newposition )
{
CChoreoEvent *e = tag->GetOwner();
if ( !e )
return;
float duration = e->GetDuration();
float leftedge = 0.0f;
float rightedge = duration;
// Find neighboring locked tags, if any
CFlexTimingTag *prev = NULL;
CFlexTimingTag *next = NULL;
int i;
for ( i = 0; i < e->GetNumTimingTags(); i++ )
{
CFlexTimingTag *test = e->GetTimingTag( i );
if ( test != tag )
continue;
// Found it
if ( i > 0 )
{
int i1 = i - 1;
while ( 1 )
{
if ( i1 < 0 )
{
prev = NULL;
break;
}
prev = e->GetTimingTag( i1 );
if ( prev->GetLocked() )
break;
i1--;
}
}
if ( i + 1 < e->GetNumTimingTags() )
{
int i1 = i + 1;
while ( 1 )
{
if ( i1 >= e->GetNumTimingTags() )
{
next = NULL;
break;
}
next = e->GetTimingTag( i1 );
if ( next->GetLocked() )
break;
i1++;
}
}
break;
}
if ( prev )
{
leftedge = prev->GetPercentage() * duration;
}
if ( next )
{
rightedge = next->GetPercentage() * duration;
}
// Now, using the tags old position as a pivot, rescale intervening
// sample points based on size delta of new vs old range
float oldpivot = tag->GetPercentage() * duration;
float newpivot = newposition * duration;
float oldleftrange = oldpivot - leftedge;
float oldrightrange = rightedge - oldpivot;
float newleftrange = newpivot - leftedge;
float newrightrange = rightedge - newpivot;
if ( oldleftrange <= 0.0f ||
oldrightrange <= 0.0f ||
newleftrange <= 0.0f ||
newrightrange <= 0.0f )
{
Con_Printf( "Range problem!!! avoiding division by zero\n" );
return;
}
for ( i = 0 ; i < e->GetNumFlexAnimationTracks(); i++ )
{
CFlexAnimationTrack *track = e->GetFlexAnimationTrack( i );
if ( !track )
continue;
for ( int t = 0; t < ( track->IsComboType() ? 2 : 1 ); t++ )
{
for ( int j = 0; j < track->GetNumSamples( t ); j++ )
{
CExpressionSample *s = track->GetSample( j, t );
if ( !s )
continue;
float oldtime = s->time;
// In old range?
if ( oldtime < leftedge )
continue;
if ( oldtime > rightedge )
continue;
// In left or right side( tiebreak toward left )
float newtime = oldtime;
if ( oldtime <= oldpivot )
{
float n = ( oldtime - leftedge ) / oldleftrange;
newtime = leftedge + n * newleftrange;
}
else
{
float n = ( oldtime - oldpivot ) / oldrightrange;
newtime = newpivot + n * newrightrange;
}
//newtime = FacePoser_SnapTime( newtime );
s->time = newtime;
}
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void ExpressionTool::OnNewExpression( void )
{
CChoreoEvent *e = GetSafeEvent();
if ( !e )
return;
CStudioHdr *hdr = models->GetActiveStudioModel()->GetStudioHdr();
if ( !hdr )
{
Con_ErrorPrintf( "ExpressionTool::OnNewExpression: Can't create new face pose, must load a model first!\n" );
return;
}
CExpClass *active = expressions->GetActiveClass();
if ( !active )
{
Con_ErrorPrintf( "ExpressionTool::OnNewExpression: Can't create new face pose, must load an expression file first!\n" );
return;
}
g_pExpressionTrayTool->Deselect();
float t = GetTimeValueForMouse( m_nClickedX );
// Get spline intensity for controller
float faketime = e->GetStartTime() + t;
float settings[ GLOBAL_STUDIO_FLEX_CONTROL_COUNT ];
float weights[ GLOBAL_STUDIO_FLEX_CONTROL_COUNT ];
memset( settings, 0, sizeof( settings ) );
memset( weights, 0, sizeof( settings ) );
for ( int i = 0 ; i < e->GetNumFlexAnimationTracks(); i++ )
{
CFlexAnimationTrack *track = e->GetFlexAnimationTrack( i );
if ( !track )
continue;
// Disabled
if ( !track->IsTrackActive() )
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( faketime, side );
settings[ controller ] = flIntensity;
weights[ controller ] = 1.0f;
}
}
}
else
{
int controller = track->GetFlexControllerIndex( 0 );
if ( controller != -1 )
{
// Get spline intensity for controller
float flIntensity = track->GetIntensity( faketime, 0 );
settings[ controller ] = flIntensity;
weights[ controller ] = 1.0f;
}
}
}
CExpressionParams params;
memset( &params, 0, sizeof( params ) );
strcpy( params.m_szDialogTitle, "Add Expression" );
strcpy( params.m_szName, "" );
strcpy( params.m_szDescription, "" );
if ( !ExpressionProperties( &params ) )
return;
if ( ( strlen( params.m_szName ) <= 0 ) ||
!stricmp( params.m_szName, "unnamed" ) )
{
Con_ErrorPrintf( "You must type in a valid name\n" );
return;
}
if ( ( strlen( params.m_szDescription ) <= 0 ) ||
!stricmp( params.m_szDescription, "description" ) )
{
Con_ErrorPrintf( "You must type in a valid description\n" );
return;
}
active->AddExpression( params.m_szName, params.m_szDescription, settings, weights, true, true );
}
LocalFlexController_t FindFlexControllerIndexByName( StudioModel *model, char const *searchname )
{
if ( !model )
return LocalFlexController_t(-1);
CStudioHdr *hdr = model->GetStudioHdr();
if ( !hdr )
return LocalFlexController_t(-1);
for ( LocalFlexController_t i = LocalFlexController_t(0); i < hdr->numflexcontrollers(); i++ )
{
char const *name = hdr->pFlexcontroller( i )->pszName();
if ( !name )
continue;
if ( strcmp( name, searchname ) )
continue;
return i;
}
return LocalFlexController_t(-1);
}
void ExpressionTool::OnCopyToFlex( bool isEdited )
{
// local time in the expression tool for the last mouse click
float t = GetTimeValueForMouse( m_nClickedX );
CChoreoEvent *e = GetSafeEvent();
if ( !e )
return;
float scenetime = e->GetStartTime() + t;
OnCopyToFlex( scenetime, isEdited );
return;
}
void ExpressionTool::OnCopyToFlex( float scenetime, bool isEdited )
{
CChoreoEvent *e = GetSafeEvent();
if ( !e )
return;
if ( scenetime < e->GetStartTime() || scenetime > e->GetEndTime() )
return;
bool needundo = false;
float *settings = NULL;
float *weights = NULL;
CExpression *exp = NULL;
CExpClass *active = expressions->GetActiveClass();
if ( active )
{
int index = active->GetSelectedExpression();
if ( index != -1 )
{
exp = active->GetExpression( index );
if ( exp )
{
needundo = true;
settings = exp->GetSettings();
weights = exp->GetWeights();
}
}
}
if ( needundo && exp )
{
exp->PushUndoInformation();
active->SetDirty( true );
}
g_pFlexPanel->ResetSliders( false, true );
StudioModel *model = models->GetActiveStudioModel();
for ( int i = 0 ; i < e->GetNumFlexAnimationTracks(); i++ )
{
CFlexAnimationTrack *track = e->GetFlexAnimationTrack( i );
if ( !track )
continue;
// Disabled
if ( !track->IsTrackActive() )
continue;
// Map track flex controller to global name
for ( int side = 0; side < 1 + track->IsComboType(); side++ )
{
int controller = track->GetFlexControllerIndex( side );
if ( controller != -1 )
{
// Get spline intensity for controller
float flIntensity = track->GetIntensity( scenetime, side );
g_pFlexPanel->SetSlider( controller, flIntensity );
g_pFlexPanel->SetInfluence( controller, 1.0f );
g_pFlexPanel->SetEdited( controller, isEdited );
if( model )
{
LocalFlexController_t raw = track->GetRawFlexControllerIndex( side );
if ( raw != LocalFlexController_t(-1) )
{
model->SetFlexController( raw, flIntensity );
}
}
if ( settings && weights )
{
settings[ controller ] = flIntensity;
weights[ controller ] = 1.0f;
}
}
}
}
if ( needundo && exp )
{
exp->PushRedoInformation();
}
}
void ExpressionTool::OnCopyFromFlex( bool isEdited )
{
// local time in the expression tool for the last mouse click
float t = GetTimeValueForMouse( m_nClickedX );
CChoreoEvent *e = GetSafeEvent();
if ( !e )
return;
float scenetime = e->GetStartTime() + t;
OnCopyFromFlex( scenetime, isEdited );
return;
}
void ExpressionTool::OnSetSingleKeyFromFlex( char const *sliderName )
{
CChoreoEvent *e = GetSafeEvent();
if ( !e || !e->GetDuration() )
return;
float scenetime = g_pChoreoView->GetScene()->GetTime();
if ( scenetime < e->GetStartTime() || scenetime > e->GetEndTime() )
return;
scenetime = FacePoser_SnapTime( scenetime );
float relativetime = scenetime - e->GetStartTime();
// Get spline intensity for controller
float setting;
float influence;
float minvalue, maxvalue;
g_pChoreoView->SetDirty( true );
g_pChoreoView->PushUndo( "Set Single Key" );
for (int j = 0; j < GLOBAL_STUDIO_FLEX_CONTROL_COUNT; j++)
{
if ( !g_pFlexPanel->IsValidSlider( j ) )
continue;
if ( Q_stricmp( g_pFlexPanel->getLabel(), sliderName ) )
continue;
setting = g_pFlexPanel->GetSliderRawValue( j );
influence = g_pFlexPanel->GetInfluence( j );
// g_pFlexPanel->SetEdited( j, isEdited );
g_pFlexPanel->GetSliderRange( j, minvalue, maxvalue );
bool found = false;
for ( int i = 0 ; i < e->GetNumFlexAnimationTracks() && !found; i++ )
{
CFlexAnimationTrack *track = e->GetFlexAnimationTrack( i );
if ( !track )
continue;
for ( int side = 0; side < 1 + track->IsComboType(); side++ )
{
if ( track->GetFlexControllerIndex( side ) != j )
continue;
float normalized = setting;
if ( side == 0 )
{
if ( minvalue != maxvalue )
{
normalized = ( setting - minvalue ) / ( maxvalue - minvalue );
}
if (track->IsInverted())
{
normalized = 1.0 - normalized;
}
}
found = true;
int nSampleCount = track->GetNumSamples( side );
int j = 0;
for ( ; j < nSampleCount; ++j )
{
CExpressionSample *s = track->GetSample( j, side );
if ( s->time == relativetime )
break;
}
if ( j >= nSampleCount )
{
track->AddSample( relativetime, normalized, side );
track->Resort( side );
}
else
{
CExpressionSample *s = track->GetSample( j, side );
s->value = normalized;
}
track->SetTrackActive( true );
break;
}
}
}
g_pChoreoView->PushRedo( "Set Single Key" );
m_pWorkspace->redraw();
redraw();
}
void ExpressionTool::OnCopyFromFlex( float scenetime, bool isEdited )
{
CChoreoEvent *e = GetSafeEvent();
if ( !e || !e->GetDuration() )
return;
if ( scenetime < e->GetStartTime() || scenetime > e->GetEndTime() )
return;
scenetime = FacePoser_SnapTime( scenetime );
float relativetime = scenetime - e->GetStartTime();
// Get spline intensity for controller
float setting;
float influence;
float minvalue, maxvalue;
g_pChoreoView->SetDirty( true );
g_pChoreoView->PushUndo( "Copy from Flex" );
for (int j = 0; j < GLOBAL_STUDIO_FLEX_CONTROL_COUNT; j++)
{
if ( !g_pFlexPanel->IsValidSlider( j ) )
continue;
setting = g_pFlexPanel->GetSliderRawValue( j );
//setting = g_pFlexPanel->GetSlider( j );
influence = g_pFlexPanel->GetInfluence( j );
g_pFlexPanel->SetEdited( j, isEdited );
g_pFlexPanel->GetSliderRange( j, minvalue, maxvalue );
// Found it
if ( !influence )
{
continue;
}
bool found = false;
for ( int i = 0 ; i < e->GetNumFlexAnimationTracks() && !found; i++ )
{
CFlexAnimationTrack *track = e->GetFlexAnimationTrack( i );
if ( !track )
continue;
for ( int side = 0; side < 1 + track->IsComboType(); side++ )
{
if ( track->GetFlexControllerIndex( side ) != j )
continue;
float normalized = setting;
if ( side == 0 )
{
if ( minvalue != maxvalue )
{
normalized = ( setting - minvalue ) / ( maxvalue - minvalue );
}
if (track->IsInverted())
{
normalized = 1.0 - normalized;
}
}
found = true;
track->AddSample( relativetime, normalized, side );
track->Resort( side );
track->SetTrackActive( true );
break;
}
}
}
g_pChoreoView->PushRedo( "Copy from Flex" );
m_pWorkspace->redraw();
redraw();
}
bool ExpressionTool::SetFlexAnimationTrackFromExpression( int mx, int my, CExpClass *cl, CExpression *exp )
{
CChoreoEvent *e = GetSafeEvent();
if ( !e | !e->GetDuration() )
{
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;
}
float t = GetTimeValueForMouse( (short)pt.x );
// Get spline intensity for controller
// Get spline intensity for controller
float relativetime = t;
float faketime = e->GetStartTime() + relativetime;
faketime = FacePoser_SnapTime( faketime );
float *settings = exp->GetSettings();
float *influence = exp->GetWeights();
if ( !settings || !influence )
return false;
g_pChoreoView->SetDirty( true );
g_pChoreoView->PushUndo( "Copy from Expression" );
for ( int i = 0 ; i < e->GetNumFlexAnimationTracks(); i++ )
{
CFlexAnimationTrack *track = e->GetFlexAnimationTrack( i );
if ( !track )
continue;
if ( track->IsComboType() )
{
int left = track->GetFlexControllerIndex( 0 );
int right = track->GetFlexControllerIndex( 1 );
float leftval = settings[ left ];
float leftinfluence = influence[ left ];
float rightval = settings[ right ];
float rightinfluence = influence[ right ];
if ( leftinfluence || rightinfluence )
{
//Con_Printf( "%s %i(side %i): amount %f inf %f\n", track->GetFlexControllerName(), j, side, s, inf );
float mag, leftright;
if (leftval < rightval)
{
mag = rightval;
leftright = 1.0 - (leftval / rightval) * 0.5;
}
else if (leftval > rightval)
{
mag = leftval;
leftright = (rightval / leftval) * 0.5;
}
else
{
mag = leftval;
leftright = 0.5;
}
track->AddSample( relativetime, mag * leftinfluence, 0 );
track->AddSample( relativetime, leftright, 1 );
track->Resort( 0 );
track->Resort( 1 );
track->SetTrackActive( true );
}
}
else
{
int j = track->GetFlexControllerIndex( 0 );
float s = settings[ j ];
float inf = influence[ j ];
if ( inf )
{
track->AddSample( relativetime, s, 0 );
track->Resort( 0 );
track->SetTrackActive( true );
}
}
}
g_pChoreoView->PushRedo( "Copy from Expression" );
m_pWorkspace->redraw();
redraw();
return true;
}
bool ExpressionTool::PaintBackground()
{
redraw();
return false;
}
void ExpressionTool::OnExportFlexAnimation( void )
{
CChoreoEvent *event = GetSafeEvent();
if ( !event )
return;
// Create flexanimations dir
CreatePath( "flexanimations/foo" );
char fafilename[ 512 ];
if ( !FacePoser_ShowSaveFileNameDialog( fafilename, sizeof( fafilename ), "flexanimations", "*.vfa" ) )
{
return;
}
Q_DefaultExtension( fafilename, ".vfa", sizeof( fafilename ) );
Con_Printf( "Exporting events to %s\n", fafilename );
CUtlBuffer buf( 0, 0, CUtlBuffer::TEXT_BUFFER );
CChoreoScene::FileSaveFlexAnimations( buf, 0, event );
// Write it out baby
FileHandle_t fh = filesystem->Open( fafilename, "wt" );
if (fh)
{
filesystem->Write( buf.Base(), buf.TellPut(), fh );
filesystem->Close(fh);
}
else
{
Con_Printf( "Unable to write file %s!!!\n", fafilename );
}
}
void ExpressionTool::OnImportFlexAnimation( void )
{
CChoreoEvent *event = GetSafeEvent();
if ( !event )
return;
char fafilename[ 512 ];
if ( !FacePoser_ShowOpenFileNameDialog( fafilename, sizeof( fafilename ), "flexanimations", "*.vfa" ) )
{
return;
}
if ( !filesystem->FileExists( fafilename ) )
return;
char fullpath[ 512 ];
filesystem->RelativePathToFullPath( fafilename, "MOD", fullpath, sizeof( fullpath ) );
LoadScriptFile( (char *)fullpath );
tokenprocessor->GetToken( true );
if ( stricmp( tokenprocessor->CurrentToken(), "flexanimations" ) )
{
Con_Printf( "ExpressionTool::OnImportFlexAnimation: %s, expecting \"flexanimations\"\n",
fullpath );
}
else
{
g_pChoreoView->SetDirty( true );
g_pChoreoView->PushUndo( "Import flex animations" );
CChoreoScene::ParseFlexAnimations( tokenprocessor, event, true );
// Force a full reset
m_pLastEvent = NULL;
SetEvent( event );
g_pChoreoView->PushRedo( "Import flex animations" );
Con_Printf( "Parsed flex animations from %s\n", fullpath );
}
}
void ExpressionTool::OnUndo( void )
{
g_pChoreoView->Undo();
}
void ExpressionTool::OnRedo( void )
{
g_pChoreoView->Redo();
}
void ExpressionTool::ForceScrubPositionFromSceneTime( float scenetime )
{
CChoreoEvent *e = GetSafeEvent();
if ( !e || !e->GetDuration() )
return;
float t = scenetime - e->GetStartTime();
m_flScrub = t;
m_flScrubTarget = t;
DrawScrubHandles();
}
void ExpressionTool::ForceScrubPosition( float frac )
{
m_flScrub = frac;
m_flScrubTarget = frac;
CChoreoEvent *e = GetSafeEvent();
if ( e )
{
float realtime = e->GetStartTime() + frac;
g_pChoreoView->SetScrubTime( realtime );
g_pChoreoView->SetScrubTargetTime( realtime );
g_pChoreoView->DrawScrubHandle();
}
DrawScrubHandles();
}
void ExpressionTool::DrawScrubHandles()
{
RECT rcHandle;
GetScrubHandleRect( rcHandle, true );
RECT rcTray = rcHandle;
rcTray.left = 0;
rcTray.right = w2();
CChoreoWidgetDrawHelper drawHelper( this, rcTray );
DrawScrubHandle( drawHelper, rcHandle );
}
void ExpressionTool::SetMouseOverPos( int x, int y )
{
m_nMousePos[ 0 ] = x;
m_nMousePos[ 1 ] = y;
}
void ExpressionTool::GetMouseOverPos( int &x, int& y )
{
x = m_nMousePos[ 0 ];
y = m_nMousePos[ 1 ];
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : rcPos -
//-----------------------------------------------------------------------------
void ExpressionTool::GetMouseOverPosRect( RECT& rcPos )
{
rcPos.top = GetCaptionHeight() + 12;
rcPos.left = w2() - 200;
rcPos.right = w2() - 5;
rcPos.bottom = rcPos.top + 13;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : drawHelper -
// rcPos -
//-----------------------------------------------------------------------------
void ExpressionTool::DrawMouseOverPos( CChoreoWidgetDrawHelper& drawHelper, RECT& rcPos )
{
// Compute time for pixel x
float t = GetTimeValueForMouse( m_nMousePos[ 0 ] );
CChoreoEvent *e = GetSafeEvent();
if ( !e )
return;
t += e->GetStartTime();
float snapped = FacePoser_SnapTime( t );
// Found it, write out description
//
char sz[ 128 ];
if ( t != snapped )
{
Q_snprintf( sz, sizeof( sz ), "%s", FacePoser_DescribeSnappedTime( t ) );
}
else
{
Q_snprintf( sz, sizeof( sz ), "%.3f", t );
}
int len = drawHelper.CalcTextWidth( "Arial", 11, 900, sz );
RECT rcText = rcPos;
rcText.left = max( rcPos.left, rcPos.right - len );
drawHelper.DrawColoredText( "Arial", 11, 900, RGB( 255, 50, 70 ), rcText, sz );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void ExpressionTool::DrawMouseOverPos()
{
RECT rcPos;
GetMouseOverPosRect( rcPos );
CChoreoWidgetDrawHelper drawHelper( this, rcPos );
DrawMouseOverPos( drawHelper, rcPos );
}
int ExpressionTool::CountSelectedSamples( void )
{
return m_pWorkspace->CountSelectedSamples();
}
void ExpressionTool::MoveSelectedSamples( float dfdx, float dfdy, bool snap )
{
m_pWorkspace->MoveSelectedSamples( dfdx, dfdy, snap );
}
void ExpressionTool::DeleteSelectedSamples( void )
{
m_pWorkspace->DeleteSelectedSamples();
}
void ExpressionTool::DeselectAll( void )
{
m_pWorkspace->DeselectAll();
m_bSelectionActive = false;
redraw();
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : start -
// end -
//-----------------------------------------------------------------------------
void ExpressionTool::SelectPoints( float starttime, float endtime )
{
// Make sure order is correct
if ( endtime < starttime )
{
float temp = endtime;
endtime = starttime;
starttime = temp;
}
DeselectAll();
m_flSelection[ 0 ] = starttime;
m_flSelection[ 1 ] = endtime;
m_bSelectionActive = true;
// Select any words that span the selection
//
m_pWorkspace->SelectPoints( starttime, endtime );
redraw();
}
void ExpressionTool::FinishMoveSelection( int startx, int mx )
{
float start = GetTimeValueForMouse( startx );
float end = GetTimeValueForMouse( mx );
float delta = end - start;
for ( int i = 0; i < 2; i++ )
{
m_flSelection[ i ] += delta;
}
SelectPoints( m_flSelection[ 0 ], m_flSelection[ 1 ] );
redraw();
}
void ExpressionTool::FinishMoveSelectionStart( int startx, int mx )
{
float start = GetTimeValueForMouse( startx );
float end = GetTimeValueForMouse( mx );
float delta = end - start;
m_flSelection[ 0 ] += delta;
SelectPoints( m_flSelection[ 0 ], m_flSelection[ 1 ] );
redraw();
}
void ExpressionTool::FinishMoveSelectionEnd( int startx, int mx )
{
float start = GetTimeValueForMouse( startx );
float end = GetTimeValueForMouse( mx );
float delta = end - start;
m_flSelection[ 1 ] += delta;
SelectPoints( m_flSelection[ 0 ], m_flSelection[ 1 ] );
redraw();
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : startx -
// mx -
//-----------------------------------------------------------------------------
void ExpressionTool::FinishSelect( int startx, int mx )
{
// Don't select really small areas
if ( abs( startx - mx ) < 1 )
return;
float start = GetTimeValueForMouse( startx );
float end = GetTimeValueForMouse( mx );
SelectPoints( start, end );
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : mx -
// my -
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool ExpressionTool::IsMouseOverPoints( int mx, int my )
{
RECT rc;
GetWorkspaceRect( rc );
// Over tag
if ( my > TRAY_HEIGHT )
return false;
if ( my <= 12 + GetCaptionHeight() )
return false;
return true;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : mx -
// my -
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool ExpressionTool::IsMouseOverSelection( int mx, int my )
{
if ( !m_bSelectionActive )
return false;
if ( !IsMouseOverPoints( mx, my ) )
return false;
float t = GetTimeValueForMouse( mx );
if ( t >= m_flSelection[ 0 ] &&
t <= m_flSelection[ 1 ] )
{
return true;
}
return false;
}
bool ExpressionTool::IsMouseOverSelectionStartEdge( mxEvent *event )
{
int mx, my;
mx = (short)event->x;
my = (short)event->y;
if ( !(event->modifiers & mxEvent::KeyCtrl ) )
return false;
if ( !IsMouseOverSelection( mx, my ) )
return false;
int left;
left = GetPixelForTimeValue( m_flSelection[ 0 ] );
if ( abs( left - mx ) <= 2 )
{
return true;
}
return false;
}
bool ExpressionTool::IsMouseOverSelectionEndEdge( mxEvent *event )
{
int mx, my;
mx = (short)event->x;
my = (short)event->y;
if ( !(event->modifiers & mxEvent::KeyCtrl ) )
return false;
if ( !IsMouseOverSelection( mx, my ) )
return false;
int right;
right = GetPixelForTimeValue( m_flSelection[ 1 ] );
if ( abs( right - mx ) <= 2 )
{
return true;
}
return false;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : &rc -
//-----------------------------------------------------------------------------
void ExpressionTool::GetWorkspaceRect( RECT &rc )
{
GetClientRect( (HWND)getHandle(), &rc );
rc.top = TRAY_HEIGHT - 17;
rc.bottom = TRAY_HEIGHT - 1;
//InflateRect( &rc, -1, -1 );
}
void ExpressionTool::AddFocusRect( RECT& rc )
{
RECT rcFocus = rc;
POINT offset;
offset.x = 0;
offset.y = 0;
ClientToScreen( (HWND)getHandle(), &offset );
OffsetRect( &rcFocus, offset.x, offset.y );
// Convert to screen space?
CFocusRect fr;
fr.m_rcFocus = rcFocus;
fr.m_rcOrig = rcFocus;
m_FocusRects.AddToTail( fr );
}
//-----------------------------------------------------------------------------
// Purpose:
// Output : int
//-----------------------------------------------------------------------------
int ExpressionTool::ComputeHPixelsNeeded( void )
{
CChoreoEvent *event = GetSafeEvent();
if ( !event )
return 0;
int pixels = 0;
float maxtime = event->GetDuration();
pixels = (int)( ( maxtime + 5.0 ) * GetPixelsPerSecond() + 10 );
return pixels;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void ExpressionTool::RepositionHSlider( void )
{
int pixelsneeded = ComputeHPixelsNeeded();
if ( pixelsneeded <= w2() )
{
m_pHorzScrollBar->setVisible( false );
}
else
{
m_pHorzScrollBar->setVisible( true );
}
m_pHorzScrollBar->setBounds( 0, h2() - m_nScrollbarHeight, w2(), m_nScrollbarHeight );
m_flLeftOffset = max( 0.f, m_flLeftOffset );
m_flLeftOffset = min( (float)pixelsneeded, m_flLeftOffset );
m_pHorzScrollBar->setRange( 0, pixelsneeded );
m_pHorzScrollBar->setValue( m_flLeftOffset );
m_pHorzScrollBar->setPagesize( w2() );
m_nLastHPixelsNeeded = pixelsneeded;
}
//-----------------------------------------------------------------------------
// Purpose:
// Output : float
//-----------------------------------------------------------------------------
float ExpressionTool::GetPixelsPerSecond( void )
{
return m_flPixelsPerSecond * (float)g_pChoreoView->GetTimeZoom( GetToolName() ) / 100.0f;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : x -
//-----------------------------------------------------------------------------
void ExpressionTool::MoveTimeSliderToPos( int x )
{
m_flLeftOffset = x;
m_pHorzScrollBar->setValue( m_flLeftOffset );
InvalidateRect( (HWND)m_pHorzScrollBar->getHandle(), NULL, TRUE );
InvalidateLayout();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void ExpressionTool::InvalidateLayout( void )
{
if ( m_bSuppressLayout )
return;
if ( ComputeHPixelsNeeded() != m_nLastHPixelsNeeded )
{
RepositionHSlider();
}
m_bLayoutIsValid = false;
m_pWorkspace->redraw();
redraw();
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : time -
// *clipped -
// Output : int
//-----------------------------------------------------------------------------
int ExpressionTool::GetPixelForTimeValue( float time, bool *clipped /*=NULL*/ )
{
int left, right;
GetWorkspaceLeftRight( left, right );
if ( clipped )
{
*clipped = false;
}
float st, ed;
GetStartAndEndTime( st, ed );
float frac = ( time - st ) / ( ed - st );
if ( frac < 0.0 || frac > 1.0 )
{
if ( clipped )
{
*clipped = true;
}
}
int pixel = left + ( int )( frac * (right - left ) );
return pixel;
}
void ExpressionTool::OnChangeScale( void )
{
CChoreoScene *scene = g_pChoreoView->GetScene();
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)g_pChoreoView->GetTimeZoom( GetToolName() ) / 100.0f );
if ( !InputProperties( &params ) )
return;
g_pChoreoView->SetTimeZoom( GetToolName(), clamp( (int)( 100.0f * atof( params.m_szInputText ) ), 1, MAX_TIME_ZOOM ), false );
m_nLastHPixelsNeeded = -1;
InvalidateLayout();
Con_Printf( "Zoom factor %i %%\n", g_pChoreoView->GetTimeZoom( GetToolName() ) );
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : st -
// ed -
//-----------------------------------------------------------------------------
void ExpressionTool::GetStartAndEndTime( float& st, float& ed )
{
st = m_flLeftOffset / GetPixelsPerSecond();
int left, right;
GetWorkspaceLeftRight( left, right );
if ( right <= left )
{
ed = st;
}
else
{
ed = st + (float)( right - left ) / GetPixelsPerSecond();
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : -
// Output : float
//-----------------------------------------------------------------------------
float ExpressionTool::GetEventEndTime()
{
CChoreoEvent *ev = GetSafeEvent();
if ( !ev )
return 1.0f;
return ev->GetDuration();
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : mx -
// clip -
// Output : float
//-----------------------------------------------------------------------------
float ExpressionTool::GetTimeValueForMouse( int mx, bool clip /*=false*/)
{
int left, right;
GetWorkspaceLeftRight( left, right );
float st, ed;
GetStartAndEndTime( st, ed );
if ( clip )
{
if ( mx < 0 )
{
return st;
}
if ( mx > w2() )
{
return ed;
}
}
float frac = (float)( mx - left ) / (float)( right - left );
return st + frac * ( ed - st );
}
void ExpressionTool::DrawEventEnd( CChoreoWidgetDrawHelper& drawHelper )
{
CChoreoEvent *e = GetSafeEvent();
if ( !e )
return;
float duration = e->GetDuration();
if ( !duration )
return;
int leftx = GetPixelForTimeValue( duration );
if ( leftx >= w2() )
return;
RECT rcClient;
drawHelper.GetClientRect( rcClient );
drawHelper.DrawColoredLine(
COLOR_CHOREO_ENDTIME, PS_SOLID, 1,
leftx, rcClient.top + TRAY_HEIGHT, leftx, rcClient.bottom );
}
void ExpressionTool::OnSortByUsed( void )
{
m_pWorkspace->OnSortByUsed();
}
void ExpressionTool::OnSortByName( void )
{
m_pWorkspace->OnSortByName();
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *item -
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool ExpressionTool::IsFocusItem( TimelineItem *item )
{
return m_pWorkspace->GetClickedItem() == item;
}
//-----------------------------------------------------------------------------
// Purpose: Delete a vertical column of samples between the selection
// markers. If excise_time is true, shifts remaining samples left
// Input : excise_time -
//-----------------------------------------------------------------------------
void ExpressionTool::OnDeleteSelection( bool excise_time )
{
if ( !m_bSelectionActive )
return;
// Force selection of everything again!
SelectPoints( m_flSelection[ 0 ], m_flSelection[ 1 ] );
int i, t;
char const *undotext = excise_time ? "Excise column" : "Delete column";
float shift_left_time = m_flSelection[ 1 ] - m_flSelection[ 0 ];
Assert( shift_left_time > 0.0f );
g_pChoreoView->SetDirty( true );
g_pChoreoView->PushUndo( undotext );
for ( int controller = 0; controller < GLOBAL_STUDIO_FLEX_CONTROL_COUNT; controller++ )
{
TimelineItem *item = m_pWorkspace->GetItem( controller );
if ( !item )
continue;
CFlexAnimationTrack *track = item->GetSafeTrack();
if ( !track )
continue;
for ( t = 0; t < 2; t++ )
{
for ( i = track->GetNumSamples( t ) - 1; i >= 0 ; i-- )
{
CExpressionSample *sample = track->GetSample( i, t );
if ( !sample->selected )
continue;
track->RemoveSample( i, t );
}
if ( !excise_time )
continue;
// Now shift things after m_flSelection[0] to the left
for ( i = track->GetNumSamples( t ) - 1; i >= 0 ; i-- )
{
CExpressionSample *sample = track->GetSample( i, t );
if ( sample->time < m_flSelection[ 1 ] )
continue;
// Shift it
sample->time -= shift_left_time;
}
}
item->DrawSelf();
}
g_pChoreoView->PushRedo( undotext );
// Clear selection and redraw()
DeselectAll();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void ExpressionTool::OnResetItemSize()
{
TimelineItem *item = m_pWorkspace->GetClickedItem();
if ( !item )
return;
item->ResetHeight();
m_pWorkspace->LayoutItems( true );
redraw();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void ExpressionTool::OnResetAllItemSizes()
{
for ( int controller = 0; controller < GLOBAL_STUDIO_FLEX_CONTROL_COUNT; controller++ )
{
TimelineItem *item = m_pWorkspace->GetItem( controller );
if ( !item )
continue;
item->ResetHeight();
}
m_pWorkspace->LayoutItems( true );
redraw();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void ExpressionTool::OnScaleSamples()
{
int t, i;
//Scale samples
CInputParams params;
memset( &params, 0, sizeof( params ) );
strcpy( params.m_szDialogTitle, "Scale selected samples" );
strcpy( params.m_szPrompt, "Factor:" );
strcpy( params.m_szInputText, "1.0" );
if ( !InputProperties( &params ) )
return;
float scale_factor = atof( params.m_szInputText );
if( scale_factor <= 0.0f )
{
Con_Printf( "Can't scale to %.2f\n", scale_factor );
}
char const *undotext = "Scale samples";
g_pChoreoView->SetDirty( true );
g_pChoreoView->PushUndo( undotext );
for ( int controller = 0; controller < GLOBAL_STUDIO_FLEX_CONTROL_COUNT; controller++ )
{
TimelineItem *item = m_pWorkspace->GetItem( controller );
if ( !item )
continue;
CFlexAnimationTrack *track = item->GetSafeTrack();
if ( !track )
continue;
for ( t = 0; t < 2; t++ )
{
for ( i = track->GetNumSamples( t ) - 1; i >= 0 ; i-- )
{
CExpressionSample *sample = track->GetSample( i, t );
if ( !sample->selected )
continue;
// Scale it
float curvalue = sample->value;
curvalue *= scale_factor;
// Clamp it
curvalue = clamp( curvalue, 0.0f, 1.0f );
sample->value = curvalue;
}
}
}
g_pChoreoView->PushRedo( undotext );
m_pWorkspace->redraw();
redraw();
}
void ExpressionTool::OnModelChanged()
{
SetEvent( NULL );
redraw();
}
void ExpressionTool::OnEdgeProperties()
{
TimelineItem *item = m_pWorkspace->GetClickedItem();
if ( !item )
return;
CFlexAnimationTrack *track = item->GetSafeTrack();
if ( !track )
return;
CEdgePropertiesParams params;
Q_memset( &params, 0, sizeof( params ) );
Q_strcpy( params.m_szDialogTitle, "Edge Properties" );
params.SetFromFlexTrack( track );
if ( !EdgeProperties( &params ) )
{
return;
}
char const *undotext = "Change Edge Properties";
g_pChoreoView->SetDirty( true );
g_pChoreoView->PushUndo( undotext );
// Apply changes.
params.ApplyToTrack( track );
g_pChoreoView->PushRedo( undotext );
m_pWorkspace->redraw();
redraw();
}
float ExpressionTool::GetScrubberSceneTime()
{
CChoreoEvent *ev = GetSafeEvent();
if ( !ev )
return 0.0f;
float curtime = GetScrub();
curtime += ev->GetStartTime();
return curtime;
}
void ExpressionTool::GetTimelineItems( CUtlVector< TimelineItem * >& list )
{
for ( int i = 0; i < GLOBAL_STUDIO_FLEX_CONTROL_COUNT; i++ )
{
TimelineItem *item = m_pWorkspace->GetItem( i );
if ( !item )
continue;
list.AddToTail( item );
}
}
bool ExpressionTool::HasCopiedColumn()
{
return m_ColumnCopy.m_bActive;
}
void ExpressionTool::OnCopyColumn()
{
m_ColumnCopy.Reset();
m_ColumnCopy.m_bActive = true;
m_ColumnCopy.m_flCopyTimes[ 0 ] = m_flSelection[ 0 ];
m_ColumnCopy.m_flCopyTimes[ 1 ] = m_flSelection[ 1 ];
for ( int controller = 0; controller < GLOBAL_STUDIO_FLEX_CONTROL_COUNT; ++controller )
{
TimelineItem *item = m_pWorkspace->GetItem( controller );
if ( !item )
continue;
CFlexAnimationTrack *track = item->GetSafeTrack();
if ( !track )
continue;
for ( int t = 0; t < 2; t++ )
{
for ( int i = track->GetNumSamples( t ) - 1; i >= 0 ; i-- )
{
CExpressionSample *sample = track->GetSample( i, t );
if ( !sample->selected )
continue;
// Add to dictionary
CExpressionSample copy( *sample );
copy.selected = false;
int tIndex = m_ColumnCopy.m_Data.Find( track->GetFlexControllerName() );
if ( tIndex == m_ColumnCopy.m_Data.InvalidIndex() )
{
tIndex = m_ColumnCopy.m_Data.Insert( track->GetFlexControllerName() );
}
CColumnCopier::CTrackData &data = m_ColumnCopy.m_Data[ tIndex ];
data.m_Samples[ t ].AddToTail( copy );
}
}
}
}
void ExpressionTool::OnPasteColumn()
{
if ( !m_ColumnCopy.m_bActive )
{
Msg( "Nothing to paste\n" );
return;
}
float flPasteTime = GetTimeForClickedPos();
float flPasteEndTime = flPasteTime + m_ColumnCopy.m_flCopyTimes[ 1 ] - m_ColumnCopy.m_flCopyTimes[ 0 ];
// Clear selection and redraw()
DeselectAll();
// Select everthing in the paste region so we can delete the existing stuff
SelectPoints( flPasteTime, flPasteEndTime );
int i, t;
char const *undotext = "Paste column";
g_pChoreoView->SetDirty( true );
g_pChoreoView->PushUndo( undotext );
for ( int controller = 0; controller < GLOBAL_STUDIO_FLEX_CONTROL_COUNT; controller++ )
{
TimelineItem *item = m_pWorkspace->GetItem( controller );
if ( !item )
continue;
CFlexAnimationTrack *track = item->GetSafeTrack();
if ( !track )
continue;
int tIndex = m_ColumnCopy.m_Data.Find( track->GetFlexControllerName() );
for ( t = 0; t < 2; t++ )
{
// Remove all selected samples
for ( i = track->GetNumSamples( t ) - 1; i >= 0 ; i-- )
{
CExpressionSample *sample = track->GetSample( i, t );
if ( !sample->selected )
continue;
track->RemoveSample( i, t );
}
// Now add the new samples, if any in the time selection
if ( tIndex != m_ColumnCopy.m_Data.InvalidIndex() )
{
CColumnCopier::CTrackData &data = m_ColumnCopy.m_Data[ tIndex ];
for ( int j = 0; j < data.m_Samples[ t ].Count(); ++j )
{
CExpressionSample *s = &data.m_Samples[ t ][ j ];
CExpressionSample *newSample = track->AddSample( s->time - m_ColumnCopy.m_flCopyTimes[ 0 ] + flPasteTime, s->value, t );
newSample->selected = true;
}
}
track->Resort( t );
}
item->DrawSelf();
}
g_pChoreoView->PushRedo( undotext );
}
void ExpressionTool::ClearColumnCopy()
{
m_ColumnCopy.Reset();
}