1534 lines
40 KiB
C++
1534 lines
40 KiB
C++
//========= Copyright Valve Corporation, All rights reserved. ============//
|
|
//
|
|
// Purpose:
|
|
//
|
|
//=============================================================================
|
|
|
|
#include "dme_controls/BaseAnimSetAttributeSliderPanel.h"
|
|
#include "movieobjects/dmechannel.h"
|
|
#include "movieobjects/dmeanimationset.h"
|
|
#include "vgui_controls/TextImage.h"
|
|
#include "vgui_controls/Button.h"
|
|
#include "vgui_controls/Slider.h"
|
|
#include "vgui_controls/PanelListPanel.h"
|
|
#include "dme_controls/BaseAnimSetPresetFaderPanel.h"
|
|
#include "dme_controls/BaseAnimationSetEditor.h"
|
|
#include "dme_controls/attributeslider.h"
|
|
#include "vgui/ISurface.h"
|
|
#include "vgui/ISystem.h"
|
|
#include "vgui/IInput.h"
|
|
|
|
|
|
// memdbgon must be the last include file in a .cpp file!!!
|
|
#include "tier0/memdbgon.h"
|
|
|
|
using namespace vgui;
|
|
|
|
#define ANIMATION_SET_EDITOR_ATTRIBUTESLIDERS_BUTTONTRAY_HEIGHT 32
|
|
#define ANIMATION_SET_EDITOR_ATTRIBUTESLIDERS_BUTTONTRAY_YPOS 0
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Enums
|
|
//-----------------------------------------------------------------------------
|
|
#define SLIDER_PIXEL_SPACING 3
|
|
#define RECOMPUTE_PREVIEW_INTERVAL ( 0.5f )
|
|
#define CIRCULAR_CONTROL_RADIUS 6.0f
|
|
#define FRAC_PER_PIXEL 0.0025f
|
|
|
|
static ConVar ifm_attributesliderbalance_sensitivity( "ifm_attributesliderbalance_sensitivity", "1.0", 0 );
|
|
|
|
extern float ifm_fader_timescale;
|
|
|
|
enum
|
|
{
|
|
// Just some arbitrary number that we're not likely to see in another .lib or the main app's code
|
|
UNDO_CHAIN_MOUSEWHEEL_ATTRIBUTE_SLIDER = 9876,
|
|
};
|
|
|
|
|
|
bool CBaseAnimSetAttributeSliderPanel::ChannelToSliderLookup_t::Less( const ChannelToSliderLookup_t& lhs, const ChannelToSliderLookup_t& rhs )
|
|
{
|
|
return lhs.ch.Get() < rhs.ch.Get();
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Blends flex values in left-right space instead of balance/value space
|
|
//-----------------------------------------------------------------------------
|
|
static void BlendFlexValues( AttributeValue_t *pResult, const AttributeValue_t &src, const AttributeValue_t &dest, float flBlend, float flBalanceFilter = 0.5f )
|
|
{
|
|
// Apply the left-right balance to the target
|
|
float flLeftFilter, flRightFilter;
|
|
ValueBalanceToLeftRight( &flLeftFilter, &flRightFilter, flBlend, flBalanceFilter );
|
|
|
|
// Do the math in 'left-right' space because we filter in that space
|
|
float flSrcLeft, flSrcRight;
|
|
ValueBalanceToLeftRight( &flSrcLeft, &flSrcRight, src.m_pValue[ANIM_CONTROL_VALUE], src.m_pValue[ANIM_CONTROL_BALANCE] );
|
|
|
|
float flDestLeft, flDestRight;
|
|
ValueBalanceToLeftRight( &flDestLeft, &flDestRight, dest.m_pValue[ANIM_CONTROL_VALUE], dest.m_pValue[ANIM_CONTROL_BALANCE] );
|
|
|
|
float flTargetLeft = flSrcLeft + flLeftFilter * ( flDestLeft - flSrcLeft );
|
|
float flTargetRight = flSrcRight + flRightFilter * ( flDestRight - flSrcRight );
|
|
|
|
LeftRightToValueBalance( &pResult->m_pValue[ANIM_CONTROL_VALUE], &pResult->m_pValue[ANIM_CONTROL_BALANCE], flTargetLeft, flTargetRight,
|
|
( flBlend <= 0.5f ) ? src.m_pValue[ANIM_CONTROL_BALANCE] : dest.m_pValue[ANIM_CONTROL_BALANCE] );
|
|
|
|
pResult->m_pValue[ANIM_CONTROL_MULTILEVEL] = src.m_pValue[ANIM_CONTROL_MULTILEVEL] + ( dest.m_pValue[ANIM_CONTROL_MULTILEVEL] - src.m_pValue[ANIM_CONTROL_MULTILEVEL] ) * flBlend;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
// CPresetSideFilterSlider class begins
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
class CPresetSideFilterSlider : public Slider
|
|
{
|
|
DECLARE_CLASS_SIMPLE( CPresetSideFilterSlider, Slider );
|
|
|
|
public:
|
|
CPresetSideFilterSlider( CBaseAnimSetAttributeSliderPanel *pParent, const char *panelName );
|
|
virtual ~CPresetSideFilterSlider();
|
|
|
|
float GetPos();
|
|
void SetPos( float frac );
|
|
|
|
protected:
|
|
virtual void Paint();
|
|
virtual void PaintBackground();
|
|
virtual void ApplySchemeSettings( IScheme *scheme );
|
|
virtual void GetTrackRect( int &x, int &y, int &w, int &h );
|
|
virtual void OnMousePressed(MouseCode code);
|
|
virtual void OnMouseDoublePressed(MouseCode code);
|
|
|
|
private:
|
|
CBaseAnimSetAttributeSliderPanel *m_pParent;
|
|
|
|
Color m_ZeroColor;
|
|
Color m_TextColor;
|
|
Color m_TextColorFocus;
|
|
TextImage *m_pName;
|
|
float m_flCurrent;
|
|
};
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Constructor, destructor
|
|
//-----------------------------------------------------------------------------
|
|
CPresetSideFilterSlider::CPresetSideFilterSlider( CBaseAnimSetAttributeSliderPanel *parent, const char *panelName ) :
|
|
BaseClass( (Panel *)parent, panelName ), m_pParent( parent )
|
|
{
|
|
SetRange( 0, 1000 );
|
|
SetDragOnRepositionNob( true );
|
|
SetPos( 0.5f );
|
|
SetPaintBackgroundEnabled( true );
|
|
|
|
m_pName = new TextImage( "Preset Side Filter" );
|
|
|
|
SetBgColor( Color( 128, 128, 128, 128 ) );
|
|
|
|
m_ZeroColor = Color( 33, 33, 33, 255 );
|
|
m_TextColor = Color( 200, 200, 200, 255 );
|
|
m_TextColorFocus = Color( 208, 143, 40, 255 );
|
|
}
|
|
|
|
CPresetSideFilterSlider::~CPresetSideFilterSlider()
|
|
{
|
|
delete m_pName;
|
|
}
|
|
|
|
void CPresetSideFilterSlider::OnMousePressed(MouseCode code)
|
|
{
|
|
if ( code == MOUSE_RIGHT )
|
|
{
|
|
SetPos( 0.5f );
|
|
return;
|
|
}
|
|
|
|
BaseClass::OnMousePressed( code );
|
|
}
|
|
|
|
void CPresetSideFilterSlider::OnMouseDoublePressed(MouseCode code)
|
|
{
|
|
if ( code == MOUSE_LEFT )
|
|
{
|
|
SetPos( 0.5f );
|
|
return;
|
|
}
|
|
|
|
BaseClass::OnMouseDoublePressed( code );
|
|
}
|
|
|
|
float CPresetSideFilterSlider::GetPos()
|
|
{
|
|
return GetValue() * 0.001f;
|
|
}
|
|
|
|
void CPresetSideFilterSlider::SetPos( float frac )
|
|
{
|
|
SetValue( (int)( frac * 1000.0f + 0.5f ), false );
|
|
}
|
|
|
|
void CPresetSideFilterSlider::ApplySchemeSettings( IScheme *scheme )
|
|
{
|
|
BaseClass::ApplySchemeSettings( scheme );
|
|
|
|
m_pName->SetFont( scheme->GetFont( "DefaultBold" ) );
|
|
m_pName->SetColor( m_TextColor );
|
|
m_pName->ResizeImageToContent();
|
|
|
|
SetFgColor( Color( 194, 120, 0, 255 ) );
|
|
SetThumbWidth( 3 );
|
|
}
|
|
|
|
void CPresetSideFilterSlider::GetTrackRect( int &x, int &y, int &w, int &h )
|
|
{
|
|
GetSize( w, h );
|
|
x = 0;
|
|
y = 2;
|
|
h -= 4;
|
|
}
|
|
|
|
void CPresetSideFilterSlider::Paint()
|
|
{
|
|
// horizontal nob
|
|
int x, y;
|
|
int wide,tall;
|
|
GetTrackRect( x, y, wide, tall );
|
|
|
|
Color col = GetFgColor();
|
|
surface()->DrawSetColor( col );
|
|
surface()->DrawFilledRect( _nobPos[0], 1, _nobPos[1], GetTall() - 1 );
|
|
surface()->DrawSetColor( m_ZeroColor );
|
|
surface()->DrawFilledRect( _nobPos[0] - 1, y + 1, _nobPos[0], y + tall - 1 );
|
|
}
|
|
|
|
void CPresetSideFilterSlider::PaintBackground()
|
|
{
|
|
int w, h;
|
|
GetSize( w, h );
|
|
|
|
int tx, ty, tw, th;
|
|
GetTrackRect( tx, ty, tw, th );
|
|
surface()->DrawSetColor( m_ZeroColor );
|
|
surface()->DrawFilledRect( tx, ty, tx + tw, ty + th );
|
|
|
|
int cw, ch;
|
|
m_pName->SetColor( _dragging ? m_TextColorFocus : m_TextColor );
|
|
m_pName->GetContentSize( cw, ch );
|
|
m_pName->SetPos( ( w - cw ) * 0.5f, ( h - ch ) * 0.5f );
|
|
m_pName->Paint();
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//
|
|
// CBaseAnimSetAttributeSliderPanel begins
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
CBaseAnimSetAttributeSliderPanel::CBaseAnimSetAttributeSliderPanel( vgui::Panel *parent, const char *className, CBaseAnimationSetEditor *editor ) :
|
|
BaseClass( parent, className ),
|
|
m_flEstimatedValue( 0.0f ),
|
|
m_ChannelToSliderLookup( 0, 0, ChannelToSliderLookup_t::Less ),
|
|
m_flRecomputePreviewTime( -1.0f ),
|
|
m_bRequestedNewPreview( false ),
|
|
m_flPrevTime( 0.0f ),
|
|
m_nFaderChangeFlags( 0 )
|
|
{
|
|
m_hEditor = editor;
|
|
|
|
m_pLeftRightBoth[ 0 ] = new Button( this, "AttributeSliderLeftOnly", "", this, "OnLeftOnly" );
|
|
m_pLeftRightBoth[ 1 ] = new Button( this, "AttributeSliderRightOnly", "", this, "OnRightOnly" );
|
|
m_pPresetSideFilter = new CPresetSideFilterSlider( this, "PresetSideFilter" );
|
|
m_Sliders = new PanelListPanel( this, "AttributeSliders" );
|
|
m_Sliders->SetFirstColumnWidth( 0 );
|
|
m_Sliders->SetAutoResize
|
|
(
|
|
Panel::PIN_TOPLEFT,
|
|
Panel::AUTORESIZE_DOWNANDRIGHT,
|
|
0, ANIMATION_SET_EDITOR_ATTRIBUTESLIDERS_BUTTONTRAY_HEIGHT,
|
|
0, 0
|
|
);
|
|
m_Sliders->SetVerticalBufferPixels( 0 );
|
|
|
|
m_PreviousPreviewFader = "";
|
|
m_Previous.isbeingdragged = false;
|
|
m_Previous.holdingctrl = false;
|
|
m_Previous.amount = 0.0f;
|
|
}
|
|
|
|
void CBaseAnimSetAttributeSliderPanel::OnCommand( const char *pCommand )
|
|
{
|
|
if ( !Q_stricmp( pCommand, "OnLeftOnly" ) )
|
|
{
|
|
m_pPresetSideFilter->SetPos( 0.0f );
|
|
return;
|
|
}
|
|
|
|
if ( !Q_stricmp( pCommand, "OnRightOnly" ) )
|
|
{
|
|
m_pPresetSideFilter->SetPos( 1.0f );
|
|
return;
|
|
}
|
|
|
|
BaseClass::OnCommand( pCommand );
|
|
}
|
|
|
|
void CBaseAnimSetAttributeSliderPanel::StampValueIntoLogs( CDmElement *control, AnimationControlType_t type, float flValue )
|
|
{
|
|
}
|
|
|
|
void CBaseAnimSetAttributeSliderPanel::ApplySchemeSettings( IScheme *scheme )
|
|
{
|
|
BaseClass::ApplySchemeSettings( scheme );
|
|
m_Sliders->SetBgColor( Color( 42, 42, 42, 255 ) );
|
|
}
|
|
|
|
void CBaseAnimSetAttributeSliderPanel::PerformLayout()
|
|
{
|
|
BaseClass::PerformLayout();
|
|
|
|
int w, h;
|
|
GetSize( w, h );
|
|
|
|
int availH = ANIMATION_SET_EDITOR_ATTRIBUTESLIDERS_BUTTONTRAY_HEIGHT;
|
|
|
|
int btnSize = 9;
|
|
m_pLeftRightBoth[ 0 ]->SetBounds( 15, ( availH - btnSize ) / 2, btnSize, btnSize );
|
|
m_pLeftRightBoth[ 1 ]->SetBounds( w - 15, ( availH - btnSize ) / 2, btnSize, btnSize );
|
|
m_pPresetSideFilter->SetBounds( 23 + btnSize, 4, w - 38 - 2 * btnSize, availH - 8 );
|
|
}
|
|
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Determines:
|
|
// a) are we holding the ctrl key still, if so
|
|
// figures out the crossfade amount of each preset slider with non-zero influence
|
|
// b) not holding control, then just see if we are previewing whichever preset the mouse is over
|
|
// Input : -
|
|
//-----------------------------------------------------------------------------
|
|
void CBaseAnimSetAttributeSliderPanel::OnThink()
|
|
{
|
|
BaseClass::OnThink();
|
|
|
|
CBaseAnimSetPresetFaderPanel *presets = m_hEditor->GetPresetFader();
|
|
if ( !presets )
|
|
return;
|
|
|
|
FaderPreview_t fader;
|
|
presets->GetPreviewFader( fader );
|
|
|
|
bool nameChanged = ( fader.name && ( m_PreviousPreviewFader.IsEmpty() || Q_stricmp( m_PreviousPreviewFader.Get(), fader.name ) ) ) ? true : false;
|
|
bool beingDraggedChanged = fader.isbeingdragged != m_Previous.isbeingdragged ? true : false;
|
|
bool ctrlKeyChanged = fader.holdingctrl != m_Previous.holdingctrl ? true : false;
|
|
bool bFaderChanged = ( nameChanged || beingDraggedChanged || ctrlKeyChanged );
|
|
bool bPresetChanged = fader.preset != m_Previous.preset;
|
|
bool faderAmountChanged = fader.amount != m_Previous.amount ? true : false;
|
|
|
|
m_nFaderChangeFlags = 0;
|
|
if ( nameChanged )
|
|
{
|
|
m_nFaderChangeFlags |= FADER_NAME_CHANGED;
|
|
}
|
|
if ( beingDraggedChanged )
|
|
{
|
|
m_nFaderChangeFlags |= FADER_DRAG_CHANGED;
|
|
}
|
|
if ( ctrlKeyChanged )
|
|
{
|
|
m_nFaderChangeFlags |= FADER_CTRLKEY_CHANGED;
|
|
}
|
|
if ( faderAmountChanged )
|
|
{
|
|
m_nFaderChangeFlags |= FADER_AMOUNT_CHANGED;
|
|
}
|
|
if ( bPresetChanged )
|
|
{
|
|
m_nFaderChangeFlags |= FADER_PRESET_CHANGED;
|
|
}
|
|
|
|
m_PreviousPreviewFader = fader.name;
|
|
m_Previous = fader;
|
|
|
|
int c = m_SliderList.Count();
|
|
for ( int i = 0; i < c; ++i )
|
|
{
|
|
CAttributeSlider *slider = m_SliderList[ i ];
|
|
slider->EnablePreview( false, false, false );
|
|
if ( !slider->IsVisible() )
|
|
continue;
|
|
|
|
if ( !slider->GetControl() )
|
|
continue;
|
|
|
|
const char *name = slider->GetName();
|
|
Assert( name );
|
|
|
|
if ( m_CtrlKeyPreviewSlider.Get() == slider )
|
|
{
|
|
// The preset stuff shouldn't be active when we're holding ctrl over the raw attribute sliders!!!
|
|
Assert( !fader.isbeingdragged );
|
|
m_CtrlKeyPreviewSliderElement = NULL;
|
|
m_CtrlKeyPreviewSlider = NULL;
|
|
|
|
AttributeValue_t dest;
|
|
if ( !slider->IsTransform() )
|
|
{
|
|
dest.m_pValue[ ANIM_CONTROL_VALUE ] = m_flEstimatedValue;
|
|
dest.m_pValue[ ANIM_CONTROL_BALANCE ] = slider->GetValue( ANIM_CONTROL_BALANCE );
|
|
dest.m_pValue[ ANIM_CONTROL_MULTILEVEL ] = slider->GetValue( ANIM_CONTROL_MULTILEVEL );
|
|
}
|
|
else
|
|
{
|
|
dest.m_pValue[ ANIM_CONTROL_VALUE ] = 0.0f;
|
|
dest.m_pValue[ ANIM_CONTROL_BALANCE ] = 0.5f;
|
|
dest.m_pValue[ ANIM_CONTROL_MULTILEVEL ] = 0.5f;
|
|
}
|
|
|
|
// If we aren't over any of the preset sliders, then we need to be able to ramp down to the current value, too
|
|
slider->EnablePreview( true, false, false );
|
|
slider->SetPreview( dest, dest, true, true );
|
|
continue;
|
|
}
|
|
|
|
if ( !fader.values )
|
|
continue;
|
|
|
|
AttributeValue_t preview;
|
|
preview.m_pValue[ ANIM_CONTROL_VALUE ] = slider->IsTransform() ? 0.0f : slider->GetControlDefaultValue( ANIM_CONTROL_VALUE );
|
|
preview.m_pValue[ ANIM_CONTROL_BALANCE ] = 0.5f;
|
|
preview.m_pValue[ ANIM_CONTROL_MULTILEVEL ] = 0.5f;
|
|
|
|
AttributeValue_t current = slider->GetValue();
|
|
|
|
int idx = fader.values->Find( name );
|
|
if ( idx != fader.values->InvalidIndex() )
|
|
{
|
|
preview = (*fader.values)[ idx ];
|
|
}
|
|
BlendFlexValues( &preview, current, preview, 1.0f, slider->IsControlActive( ANIM_CONTROL_BALANCE ) ? m_pPresetSideFilter->GetPos() : 0.5f );
|
|
|
|
bool simple = fader.isbeingdragged || ( !fader.holdingctrl && !slider->IsRampingTowardPreview() && !ctrlKeyChanged );
|
|
|
|
slider->EnablePreview( true, simple, fader.isbeingdragged );
|
|
if ( bFaderChanged || fader.isbeingdragged )
|
|
{
|
|
// If being dragged, slam to current value right away
|
|
if ( simple )
|
|
{
|
|
slider->SetPreview( preview, preview, true, true );
|
|
}
|
|
else
|
|
{
|
|
// For the "ramp down" case (just released ctrl key), we need the original values instead of the preview valuees
|
|
if ( ctrlKeyChanged && !fader.holdingctrl && slider->IsRampingTowardPreview() )
|
|
{
|
|
Assert( !fader.isbeingdragged );
|
|
slider->RampDown();
|
|
}
|
|
else
|
|
{
|
|
// Apply the left-right balance to the target
|
|
AttributeValue_t dest;
|
|
BlendFlexValues( &dest, current, preview, fader.amount );
|
|
slider->SetPreview( dest, preview, !fader.holdingctrl, !nameChanged );
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( faderAmountChanged || fader.isbeingdragged || fader.holdingctrl )
|
|
{
|
|
slider->UpdateFaderAmount( fader.amount );
|
|
}
|
|
}
|
|
|
|
UpdatePreviewSliderTimes();
|
|
|
|
ApplySliderValues( false );
|
|
|
|
PerformRecomputePreview();
|
|
}
|
|
|
|
void CBaseAnimSetAttributeSliderPanel::ChangeAnimationSet( CDmeAnimationSet *newAnimSet )
|
|
{
|
|
int i;
|
|
// Force recomputation
|
|
m_nActiveControlSetMode = -1;
|
|
|
|
bool rebuild = true;
|
|
|
|
if ( m_AnimSet.Get() && newAnimSet == m_AnimSet )
|
|
{
|
|
// See if every slider is the same as before
|
|
const CDmaElementArray< CDmElement > &controls = m_AnimSet->GetControls();
|
|
int controlCount = controls.Count();
|
|
if ( m_SliderList.Count() == controlCount )
|
|
{
|
|
rebuild = false;
|
|
for ( i = 0 ; i < controlCount; ++i )
|
|
{
|
|
CDmElement *control = controls[ i ];
|
|
if ( !control )
|
|
continue;
|
|
|
|
if ( Q_stricmp( control->GetName(), m_SliderList[ i ]->GetName() ) )
|
|
{
|
|
rebuild = true;
|
|
break;
|
|
}
|
|
|
|
bool bStereo = control->GetValue< bool >( "combo" );
|
|
bool bIsMulti = control->GetValue< bool >( "multi" );
|
|
if ( m_SliderList[ i ]->IsControlActive( ANIM_CONTROL_BALANCE ) != bStereo ||
|
|
m_SliderList[ i ]->IsControlActive( ANIM_CONTROL_MULTILEVEL ) != bIsMulti )
|
|
{
|
|
rebuild = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
m_AnimSet = newAnimSet;
|
|
|
|
if ( !m_AnimSet.Get() )
|
|
return;
|
|
|
|
if ( !rebuild )
|
|
return;
|
|
|
|
int c = m_SliderList.Count();
|
|
for ( i = 0 ; i < c; ++i )
|
|
{
|
|
delete m_SliderList[ i ];
|
|
}
|
|
m_SliderList.RemoveAll();
|
|
m_Sliders->RemoveAll();
|
|
m_ChannelToSliderLookup.Purge();
|
|
|
|
const CDmaElementArray< CDmElement > &controls = m_AnimSet->GetControls();
|
|
|
|
// Now create sliders for all known controls, nothing visible by default
|
|
int controlCount = controls.Count();
|
|
for ( i = 0 ; i < controlCount; ++i )
|
|
{
|
|
CDmElement *control = controls[ i ];
|
|
if ( !control )
|
|
continue;
|
|
|
|
CAttributeSlider *slider = new CAttributeSlider( this, control->GetName(), control );
|
|
|
|
slider->SetVisible( false );
|
|
slider->SetValue( ANIM_CONTROL_VALUE, control->GetValue< float >( "value" ) );
|
|
slider->SetSize( 100, 20 );
|
|
|
|
bool bStereo = control->GetValue< bool >( "combo" );
|
|
slider->ActivateControl( ANIM_CONTROL_BALANCE, bStereo );
|
|
if ( bStereo )
|
|
{
|
|
slider->SetValue( ANIM_CONTROL_BALANCE, control->GetValue< float >( "balance" ) );
|
|
}
|
|
|
|
bool bMulti = control->GetValue< bool >( "multi" );
|
|
slider->ActivateControl( ANIM_CONTROL_MULTILEVEL, bMulti );
|
|
if ( bMulti )
|
|
{
|
|
slider->SetValue( ANIM_CONTROL_MULTILEVEL, control->GetValue< float >( "multilevel" ) );
|
|
}
|
|
m_SliderList.AddToTail( slider );
|
|
|
|
ChannelToSliderLookup_t lookup;
|
|
lookup.slider = control;
|
|
|
|
CDmeChannel *ctrlChannels[ LOG_PREVIEW_MAX_CHANNEL_COUNT ];
|
|
GetChannelsForControl( control, ctrlChannels );
|
|
for ( int j = 0 ; j < LOG_PREVIEW_MAX_CHANNEL_COUNT; ++j )
|
|
{
|
|
lookup.ch = ctrlChannels[ j ];
|
|
lookup.type = (AnimationControlType_t)j;
|
|
if ( lookup.ch )
|
|
{
|
|
Assert( m_ChannelToSliderLookup.Find( lookup) == m_ChannelToSliderLookup.InvalidIndex() );
|
|
m_ChannelToSliderLookup.Insert( lookup );
|
|
}
|
|
}
|
|
}
|
|
|
|
RecomputePreview();
|
|
}
|
|
|
|
void CBaseAnimSetAttributeSliderPanel::SetVisibleControlsForSelectionGroup( CUtlSymbolTable& visible )
|
|
{
|
|
int i, c;
|
|
|
|
bool changed = false;
|
|
|
|
// Walk through all sliders and show only those in the symbol table
|
|
c = m_SliderList.Count();
|
|
for ( i = 0; i < c; ++i )
|
|
{
|
|
CAttributeSlider *slider = m_SliderList[ i ];
|
|
const char *sliderName = slider->GetName();
|
|
|
|
bool showSlider = visible.Find( sliderName ) != UTL_INVAL_SYMBOL ? true : false;
|
|
if ( slider->IsVisible() != showSlider )
|
|
{
|
|
changed = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if ( !changed )
|
|
return;
|
|
|
|
m_Sliders->RemoveAll();
|
|
c = m_SliderList.Count();
|
|
for ( i = 0; i < c; ++i )
|
|
{
|
|
CAttributeSlider *slider = m_SliderList[ i ];
|
|
const char *sliderName = slider->GetName();
|
|
|
|
if ( visible.Find( sliderName ) != UTL_INVAL_SYMBOL )
|
|
{
|
|
slider->SetVisible( true );
|
|
m_Sliders->AddItem( NULL, slider );
|
|
}
|
|
else
|
|
{
|
|
slider->SetVisible( false );
|
|
}
|
|
}
|
|
|
|
// Force mode to recompute
|
|
m_nActiveControlSetMode = -1;
|
|
RecomputePreview();
|
|
}
|
|
|
|
|
|
void CBaseAnimSetAttributeSliderPanel::ApplyPreset( float flScale, AttributeDict_t& values )
|
|
{
|
|
int c = m_SliderList.Count();
|
|
for ( int i = 0; i < c; ++i )
|
|
{
|
|
CAttributeSlider *slider = m_SliderList[ i ];
|
|
if ( !slider || !slider->IsVisible() )
|
|
continue;
|
|
|
|
if ( slider->IsTransform() )
|
|
continue;
|
|
|
|
AttributeValue_t current, target;
|
|
current = slider->GetValue( );
|
|
|
|
target.m_pValue[ ANIM_CONTROL_VALUE ] = slider->GetControlDefaultValue( ANIM_CONTROL_VALUE );
|
|
target.m_pValue[ ANIM_CONTROL_BALANCE ] = 0.5f;
|
|
target.m_pValue[ ANIM_CONTROL_MULTILEVEL ] = 0.5f;
|
|
|
|
const char *name = slider->GetName();
|
|
int idx = name ? values.Find( name ) : values.InvalidIndex();
|
|
if ( idx != values.InvalidIndex() )
|
|
{
|
|
target = values[ idx ];
|
|
}
|
|
|
|
// Apply the left-right balance to the target
|
|
AttributeValue_t blend;
|
|
BlendFlexValues( &blend, current, target, flScale, slider->IsControlActive( ANIM_CONTROL_BALANCE ) ? m_pPresetSideFilter->GetPos() : 0.5f );
|
|
slider->SetValue( blend );
|
|
}
|
|
}
|
|
|
|
static const char *s_pAnimControlAttribute[ANIM_CONTROL_COUNT] =
|
|
{
|
|
"value", "balance", "multilevel"
|
|
};
|
|
|
|
bool CBaseAnimSetAttributeSliderPanel::ApplySliderValues( bool bForce )
|
|
{
|
|
if ( !m_AnimSet.Get() )
|
|
return false;
|
|
|
|
if ( !bForce )
|
|
{
|
|
bForce = m_Previous.isbeingdragged;
|
|
}
|
|
|
|
const CDmaElementArray< CDmElement > &controls = m_AnimSet->GetControls();
|
|
|
|
bool valuesChanged = false;
|
|
|
|
CDisableUndoScopeGuard guard;
|
|
|
|
int c = m_SliderList.Count();
|
|
for ( int i = 0; i < c; ++i )
|
|
{
|
|
CAttributeSlider *pSlider = m_SliderList[ i ];
|
|
if ( !pSlider->IsVisible() )
|
|
continue;
|
|
|
|
CDmElement *pControl = controls[ i ];
|
|
if ( !pControl )
|
|
continue;
|
|
|
|
// Skip these types of sliders...
|
|
if ( pControl->GetValue< bool >( "transform" ) )
|
|
continue;
|
|
|
|
CDmeChannel *ctrlChannels[ LOG_PREVIEW_MAX_CHANNEL_COUNT ];
|
|
GetChannelsForControl( pControl, ctrlChannels );
|
|
|
|
bool bUsePreviewValue = pSlider->IsPreviewEnabled() && ( !pSlider->IsSimplePreview() || bForce );
|
|
|
|
for ( int j = 0; j < LOG_PREVIEW_MAX_CHANNEL_COUNT; ++j )
|
|
{
|
|
AnimationControlType_t type = (AnimationControlType_t)j;
|
|
CDmeChannel *pChannel = ctrlChannels[ j ];
|
|
|
|
// Figure out what to do based on the channel's mode
|
|
ChannelMode_t mode = pChannel ? pChannel->GetMode() : CM_PASS;
|
|
bool bPushSlidersIntoScene = ( mode == CM_PASS || mode == CM_RECORD );
|
|
bool bPullSlidersFromScene = ( mode == CM_PLAY );
|
|
|
|
if ( bPullSlidersFromScene )
|
|
{
|
|
Assert( pChannel );
|
|
|
|
// If it's actively being manipulated, the UI will be up to date
|
|
if ( pSlider->GetDragControl() == type )
|
|
continue;
|
|
|
|
// If we're dragging value, we're now going to be changing balance as well
|
|
if ( pSlider->GetDragControl() == ANIM_CONTROL_VALUE && type == ANIM_CONTROL_BALANCE )
|
|
continue;
|
|
|
|
// Drive value setting based on the output data
|
|
// NOTE: GetCurrentPlaybackValue might not overwrite flValue.
|
|
float flValue = pSlider->GetControlDefaultValue( type );
|
|
pChannel->GetCurrentPlaybackValue< float >( flValue );
|
|
pSlider->SetValue( type, flValue );
|
|
pControl->SetValue< float >( s_pAnimControlAttribute[type], flValue );
|
|
}
|
|
else if ( bPushSlidersIntoScene )
|
|
{
|
|
float flValue = bUsePreviewValue ? pSlider->GetPreview( type ) : pSlider->GetValue( type );
|
|
if ( pControl->GetValue< float >( s_pAnimControlAttribute[type] ) != flValue || bForce )
|
|
{
|
|
valuesChanged = true;
|
|
pControl->SetValue< float >( s_pAnimControlAttribute[type], flValue );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
guard.Release();
|
|
|
|
return valuesChanged;
|
|
}
|
|
|
|
void CBaseAnimSetAttributeSliderPanel::UpdatePreviewSliderTimes()
|
|
{
|
|
if ( !m_AnimSet.Get() )
|
|
return;
|
|
|
|
const CDmaElementArray< CDmElement > &controls = m_AnimSet->GetControls();
|
|
|
|
float curtime = system()->GetFrameTime();
|
|
float dt = clamp( curtime - m_flPrevTime, 0.0f, 0.1f );
|
|
m_flPrevTime = curtime;
|
|
|
|
dt *= ifm_fader_timescale;
|
|
|
|
bool previewing = false;
|
|
bool changingvalues = false;
|
|
|
|
bool ctrlDown = input()->IsKeyDown( KEY_LCONTROL ) || input()->IsKeyDown( KEY_RCONTROL );
|
|
int mx, my;
|
|
input()->GetCursorPos( mx, my );
|
|
if ( ctrlDown )
|
|
{
|
|
bool bInside = m_Sliders->IsWithin( mx, my );
|
|
if ( !bInside )
|
|
{
|
|
ctrlDown = false;
|
|
}
|
|
|
|
VPANEL topMost = input()->GetMouseOver();
|
|
if ( topMost && !ipanel()->HasParent( topMost, GetVPanel() ) )
|
|
{
|
|
ctrlDown = false;
|
|
}
|
|
}
|
|
|
|
CAttributeSlider *dragSlider = NULL;
|
|
CDmElement *dragSliderElement = NULL;
|
|
|
|
m_CtrlKeyPreviewSliderElement = NULL;
|
|
m_CtrlKeyPreviewSlider = NULL;
|
|
m_flEstimatedValue = 0.0f;
|
|
|
|
int c = m_SliderList.Count();
|
|
for ( int i = 0; i < c; ++i )
|
|
{
|
|
CAttributeSlider *slider = m_SliderList[ i ];
|
|
slider->UpdateTime( dt );
|
|
|
|
if ( !slider->IsVisible() )
|
|
continue;
|
|
|
|
bool ctrlDownOnThisSlider = false;
|
|
if ( ctrlDown )
|
|
{
|
|
int x, y;
|
|
x = mx;
|
|
y = my;
|
|
slider->ScreenToLocal( x, y );
|
|
|
|
int sw, st;
|
|
slider->GetSize( sw, st );
|
|
if ( x >= 0 && x < sw && y >= 0 && y < st )
|
|
{
|
|
// Should only hit one slider!!!
|
|
Assert( !ctrlDownOnThisSlider );
|
|
ctrlDownOnThisSlider = true;
|
|
if ( !slider->IsTransform() )
|
|
{
|
|
m_flEstimatedValue = slider->EstimateValueAtPos( x, y );
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( slider->IsPreviewEnabled() )
|
|
{
|
|
if ( !slider->IsSimplePreview() )
|
|
{
|
|
previewing = true;
|
|
}
|
|
}
|
|
// If a fader is being dragged, or we're directly manipulating the slider, then we are going to put
|
|
// this slider into record mode
|
|
if ( slider->IsFaderBeingDragged() )
|
|
{
|
|
changingvalues = true;
|
|
Assert( !dragSlider );
|
|
dragSlider = NULL;
|
|
dragSliderElement = NULL;
|
|
}
|
|
else if ( slider->IsDragging() )
|
|
{
|
|
Assert( !dragSlider );
|
|
dragSlider = slider;
|
|
dragSliderElement = controls[ i ];
|
|
changingvalues = true;
|
|
}
|
|
|
|
if ( ctrlDownOnThisSlider )
|
|
{
|
|
m_CtrlKeyPreviewSliderElement = controls[ i ];
|
|
m_CtrlKeyPreviewSlider = slider;
|
|
}
|
|
}
|
|
|
|
switch ( m_hEditor->GetRecordingState() )
|
|
{
|
|
default:
|
|
Assert( 0 );
|
|
break;
|
|
case AS_OFF:
|
|
{
|
|
ActivateControlSetInMode( CM_OFF, CM_OFF, CM_OFF, NULL );
|
|
}
|
|
break;
|
|
case AS_RECORD:
|
|
{
|
|
// Put one or all things into record mode (if dragging a single slider, other channels should be in playback mode)
|
|
if ( changingvalues || previewing )
|
|
{
|
|
ActivateControlSetInMode( changingvalues ? CM_RECORD : CM_PASS, CM_PLAY, CM_PLAY, dragSlider );
|
|
}
|
|
else
|
|
{
|
|
ActivateControlSetInMode( CM_PLAY, CM_PLAY, CM_PLAY, dragSlider );
|
|
}
|
|
}
|
|
break;
|
|
case AS_PLAYBACK:
|
|
{
|
|
// Put things into playback, except if dragging a slider, to preview
|
|
if ( changingvalues || previewing )
|
|
{
|
|
ActivateControlSetInMode( CM_PASS, CM_PLAY, CM_PLAY, NULL );
|
|
}
|
|
else
|
|
{
|
|
ActivateControlSetInMode( CM_PLAY, CM_PLAY, CM_PLAY, NULL );
|
|
}
|
|
}
|
|
break;
|
|
case AS_PREVIEW:
|
|
{
|
|
// Put things into passthru
|
|
ActivateControlSetInMode( CM_PASS, CM_PASS, CM_PLAY, NULL );
|
|
}
|
|
break;
|
|
}
|
|
|
|
if ( dragSliderElement )
|
|
{
|
|
SetLogPreviewControl( dragSliderElement );
|
|
}
|
|
else if ( m_CtrlKeyPreviewSliderElement.Get() )
|
|
{
|
|
SetLogPreviewControl( m_CtrlKeyPreviewSliderElement );
|
|
}
|
|
}
|
|
|
|
bool CBaseAnimSetAttributeSliderPanel::GetAttributeSliderValue( AttributeValue_t *pValue, const char *name )
|
|
{
|
|
int c = m_SliderList.Count();
|
|
for ( int i = 0; i < c; ++i )
|
|
{
|
|
CAttributeSlider *slider = m_SliderList[ i ];
|
|
if ( Q_stricmp( slider->GetName(), name ) )
|
|
continue;
|
|
|
|
*pValue = slider->GetValue( );
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void CBaseAnimSetAttributeSliderPanel::GetChannelsForControl( CDmElement *control, CDmeChannel *channels[LOG_PREVIEW_MAX_CHANNEL_COUNT] )
|
|
{
|
|
if ( control->GetValue< bool >( "transform" ) )
|
|
{
|
|
CDmeChannel *ch1 = control->GetValueElement< CDmeChannel >( "position" );
|
|
CDmeChannel *ch2 = control->GetValueElement< CDmeChannel >( "orientation" );
|
|
|
|
channels[ LOG_PREVIEW_POSITION ] = ch1;
|
|
channels[ LOG_PREVIEW_ORIENTATION ] = ch2;
|
|
for ( int i = 2; i < LOG_PREVIEW_MAX_CHANNEL_COUNT; ++i )
|
|
{
|
|
channels[i] = NULL;
|
|
}
|
|
return;
|
|
}
|
|
|
|
if ( control->GetValue< bool >( "combo" ) )
|
|
{
|
|
channels[ LOG_PREVIEW_VALUE ] = control->GetValueElement< CDmeChannel >( "valuechannel" );
|
|
channels[ LOG_PREVIEW_BALANCE ] = control->GetValueElement< CDmeChannel >( "balancechannel" );
|
|
}
|
|
else
|
|
{
|
|
channels[ LOG_PREVIEW_VALUE ] = control->GetValueElement< CDmeChannel >( "channel" );
|
|
channels[ LOG_PREVIEW_BALANCE ] = 0;
|
|
}
|
|
|
|
if ( control->GetValue< bool >( "multi" ) )
|
|
{
|
|
channels[ LOG_PREVIEW_MULTILEVEL ] = control->GetValueElement< CDmeChannel >( "multilevelchannel" );
|
|
}
|
|
else
|
|
{
|
|
channels[ LOG_PREVIEW_MULTILEVEL ] = NULL;
|
|
}
|
|
for ( int i = 3; i < LOG_PREVIEW_MAX_CHANNEL_COUNT; ++i )
|
|
{
|
|
channels[i] = NULL;
|
|
}
|
|
}
|
|
|
|
void CBaseAnimSetAttributeSliderPanel::GetActiveTimeSelectionParams( DmeLog_TimeSelection_t& params )
|
|
{
|
|
Assert( 0 );
|
|
}
|
|
|
|
void CBaseAnimSetAttributeSliderPanel::ActivateControlSetInMode( int mode, int otherChannelsMode, int hiddenChannelsMode, CAttributeSlider *whichSlider /*= NULL*/ )
|
|
{
|
|
int i, c;
|
|
|
|
if ( !m_AnimSet.Get() )
|
|
return;
|
|
|
|
bool updateChannelsModeChanged = m_nActiveControlSetMode != mode ? true : false;
|
|
if ( !updateChannelsModeChanged )
|
|
return;
|
|
|
|
int previousMode = m_nActiveControlSetMode;
|
|
m_nActiveControlSetMode = mode;
|
|
|
|
if ( previousMode == CM_RECORD )
|
|
{
|
|
DmeLog_TimeSelection_t params;
|
|
GetActiveTimeSelectionParams( params );
|
|
|
|
// Finalize any previously recording layers!!!
|
|
g_pChannelRecordingMgr->FinishLayerRecording( params.m_flThreshold, true );
|
|
}
|
|
|
|
ChannelMode_t channelMode = ( ChannelMode_t )mode;
|
|
|
|
const CDmaElementArray< CDmElement > &controls = m_AnimSet->GetControls();
|
|
|
|
// Build the list of channels to alter
|
|
CUtlVector< CDmeChannel * > updateChannels;
|
|
CUtlVector< CDmeChannel * > otherChannels;
|
|
CUtlVector< CDmeChannel * > hiddenChannels;
|
|
|
|
CDisableUndoScopeGuard guard;
|
|
|
|
c = m_SliderList.Count();
|
|
int j;
|
|
for ( i = 0; i < c; ++i )
|
|
{
|
|
CAttributeSlider *slider = m_SliderList[ i ];
|
|
CDmElement *ctrl = controls[ i ];
|
|
if ( !ctrl )
|
|
continue;
|
|
|
|
CDmeChannel *ctrlChannels[ LOG_PREVIEW_MAX_CHANNEL_COUNT ];
|
|
GetChannelsForControl( ctrl, ctrlChannels );
|
|
|
|
for ( j = 0 ; j < LOG_PREVIEW_MAX_CHANNEL_COUNT; ++j )
|
|
{
|
|
if ( !ctrlChannels[ j ] )
|
|
continue;
|
|
|
|
CUtlVector< CDmeChannel * > *useArray = NULL;;
|
|
|
|
// now characterize it
|
|
bool hidden = !slider->IsVisible();
|
|
if ( hidden )
|
|
{
|
|
useArray = &hiddenChannels;
|
|
}
|
|
else
|
|
{
|
|
if ( !whichSlider )
|
|
{
|
|
useArray = &updateChannels;
|
|
}
|
|
else if ( slider == whichSlider )
|
|
{
|
|
// this causes value and balance to get lumped together, since we're now dragging left/right values
|
|
if ( slider->GetDragControl() == ANIM_CONTROL_MULTILEVEL )
|
|
{
|
|
useArray = ( j == LOG_PREVIEW_MULTILEVEL ) ? &updateChannels : &otherChannels;
|
|
}
|
|
else
|
|
{
|
|
useArray = ( j != LOG_PREVIEW_MULTILEVEL ) ? &updateChannels : &otherChannels;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
useArray = &otherChannels;
|
|
}
|
|
}
|
|
|
|
useArray->AddToTail( ctrlChannels[ j ] );
|
|
}
|
|
}
|
|
|
|
guard.Release();
|
|
|
|
c = updateChannels.Count();
|
|
if ( c > 0 )
|
|
{
|
|
if ( channelMode == CM_RECORD )
|
|
{
|
|
DmeLog_TimeSelection_t params;
|
|
GetActiveTimeSelectionParams( params );
|
|
params.SetRecordingMode( ( NULL == whichSlider ) ? RECORD_PRESET : RECORD_ATTRIBUTESLIDER );
|
|
|
|
g_pChannelRecordingMgr->StartLayerRecording( "Dragging Sliders", ¶ms );
|
|
|
|
for ( i = 0; i < c; ++i )
|
|
{
|
|
// THIS PUTS THEM INTO CM_RECORD
|
|
g_pChannelRecordingMgr->AddChannelToRecordingLayer( updateChannels[ i ], GetCurrentMovie(), GetCurrentShot() );
|
|
}
|
|
|
|
SetTimeSelectionParametersForRecordingChannels( ( NULL == whichSlider ) ? m_Previous.amount : 1.0f );
|
|
}
|
|
else
|
|
{
|
|
// Don't create undo records for this
|
|
CDisableUndoScopeGuard guardSet;
|
|
for ( i = 0; i < c; ++i )
|
|
{
|
|
updateChannels[ i ]->SetMode( channelMode );
|
|
}
|
|
}
|
|
}
|
|
|
|
c = otherChannels.Count();
|
|
if ( c > 0 )
|
|
{
|
|
// Don't create undo records for this
|
|
CDisableUndoScopeGuard guardRecord;
|
|
|
|
for ( i = 0; i < c; ++i )
|
|
{
|
|
// These should never go into record!!!
|
|
Assert( (ChannelMode_t)otherChannelsMode != CM_RECORD );
|
|
otherChannels[ i ]->SetMode( (ChannelMode_t)otherChannelsMode );
|
|
}
|
|
}
|
|
|
|
c = hiddenChannels.Count();
|
|
if ( c > 0 )
|
|
{
|
|
// Don't create undo records for this
|
|
CDisableUndoScopeGuard guardRecord;
|
|
|
|
// For now these should only be able to go into Playback
|
|
//Assert( (ChannelMode_t)hiddenChannelsMode == CM_PLAY );
|
|
|
|
for ( i = 0; i < c; ++i )
|
|
{
|
|
hiddenChannels[ i ]->SetMode( (ChannelMode_t)hiddenChannelsMode );
|
|
}
|
|
}
|
|
}
|
|
|
|
static const char *s_pDefaultAttributeName[ANIM_CONTROL_COUNT] =
|
|
{
|
|
"defaultValue", "defaultBalance", "defaultMultilevel"
|
|
};
|
|
|
|
void CBaseAnimSetAttributeSliderPanel::SetupForPreset( FaderPreview_t &fader, int nChangeFlags )
|
|
{
|
|
// Nothing special here
|
|
}
|
|
|
|
float CBaseAnimSetAttributeSliderPanel::GetBalanceSliderValue()
|
|
{
|
|
return m_pPresetSideFilter->GetPos();
|
|
}
|
|
|
|
void CBaseAnimSetAttributeSliderPanel::SetTimeSelectionParametersForRecordingChannels( float flIntensity )
|
|
{
|
|
CBaseAnimSetPresetFaderPanel *pPresets = m_hEditor->GetPresetFader();
|
|
if ( !pPresets )
|
|
{
|
|
Assert( 0 );
|
|
return;
|
|
}
|
|
|
|
FaderPreview_t fader;
|
|
pPresets->GetPreviewFader( fader );
|
|
|
|
SetupForPreset( fader, m_nFaderChangeFlags );
|
|
|
|
int c = g_pChannelRecordingMgr->GetLayerRecordingChannelCount();
|
|
for ( int i = 0; i < c; ++i )
|
|
{
|
|
CDmeChannel *ch = g_pChannelRecordingMgr->GetLayerRecordingChannel( i );
|
|
if ( !ch )
|
|
continue;
|
|
|
|
CDmAttribute *pPreset = NULL;
|
|
|
|
ChannelToSliderLookup_t search;
|
|
search.ch = ch;
|
|
unsigned int idx = m_ChannelToSliderLookup.Find( search );
|
|
if ( idx != m_ChannelToSliderLookup.InvalidIndex() && fader.values )
|
|
{
|
|
ChannelToSliderLookup_t &item = m_ChannelToSliderLookup[ idx ];
|
|
|
|
CDmElement *pControl = item.slider;
|
|
Assert( pControl );
|
|
|
|
int faderIndex = fader.values->Find( pControl->GetName() );
|
|
if ( faderIndex != fader.values->InvalidIndex() )
|
|
{
|
|
pPreset = (*fader.values)[ faderIndex ].m_pAttribute[ item.type ];
|
|
}
|
|
if ( !pPreset )
|
|
{
|
|
pPreset = pControl->GetAttribute( s_pDefaultAttributeName[item.type] );
|
|
}
|
|
}
|
|
|
|
g_pChannelRecordingMgr->SetPresetValue( ch, pPreset );
|
|
}
|
|
}
|
|
|
|
static bool CanPreviewType( DmAttributeType_t attType )
|
|
{
|
|
switch ( attType )
|
|
{
|
|
default:
|
|
return false;
|
|
case AT_FLOAT:
|
|
case AT_VECTOR3:
|
|
case AT_QUATERNION:
|
|
break;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
void CBaseAnimSetAttributeSliderPanel::MaybeAddPreviewLog( CDmeFilmClip *shot, CUtlVector< LogPreview_t >& list, CDmElement *control, bool bDragging, bool isActiveLog, bool bSelected )
|
|
{
|
|
CDmeChannel *ctrlChannels[ LOG_PREVIEW_MAX_CHANNEL_COUNT ];
|
|
GetChannelsForControl( control, ctrlChannels );
|
|
|
|
LogPreview_t preview;
|
|
|
|
preview.m_bDragging = bDragging;
|
|
preview.m_bActiveLog = isActiveLog;
|
|
preview.m_bSelected = bSelected;
|
|
|
|
for ( int channel = 0; channel < LOG_PREVIEW_MAX_CHANNEL_COUNT; ++channel )
|
|
{
|
|
CDmeChannel *ch = ctrlChannels[ channel ];
|
|
if ( !ch )
|
|
continue;
|
|
|
|
CDmeLog *log = ch->GetLog();
|
|
if ( !log )
|
|
continue;
|
|
|
|
DmAttributeType_t attType = log->GetDataType();
|
|
if ( !CanPreviewType( attType ) )
|
|
continue;
|
|
|
|
Assert( control );
|
|
|
|
preview.m_hControl = control;
|
|
preview.m_hShot = shot;
|
|
preview.m_hChannels[ channel ] = ch;
|
|
preview.m_hOwner = ch->FindOwnerClipForChannel( shot );
|
|
}
|
|
|
|
list.AddToTail( preview );
|
|
}
|
|
|
|
void CBaseAnimSetAttributeSliderPanel::RecomputePreview()
|
|
{
|
|
float curtime = system()->GetFrameTime();
|
|
m_flRecomputePreviewTime = curtime + RECOMPUTE_PREVIEW_INTERVAL;
|
|
m_bRequestedNewPreview = true;
|
|
}
|
|
|
|
CDmeFilmClip *CBaseAnimSetAttributeSliderPanel::GetCurrentShot()
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
CDmeFilmClip *CBaseAnimSetAttributeSliderPanel::GetCurrentMovie()
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
void CBaseAnimSetAttributeSliderPanel::PerformRecomputePreview()
|
|
{
|
|
m_CurrentPreview.RemoveAll();
|
|
if ( !m_bRequestedNewPreview )
|
|
return;
|
|
|
|
#if 0
|
|
// Tracker 54528: While this saves recomputing things all of the time, the delay is annoying so
|
|
// we'll turn it off for now
|
|
float curtime = system()->GetFrameTime();
|
|
if ( curtime < m_flRecomputePreviewTime )
|
|
return;
|
|
#endif
|
|
|
|
m_bRequestedNewPreview = false;
|
|
m_flRecomputePreviewTime = -1.0f;
|
|
// list of bones/root transforms which are in the control set
|
|
m_ActiveTransforms.Purge();
|
|
if ( !m_AnimSet.Get() )
|
|
return;
|
|
|
|
CDmeFilmClip *shot = GetCurrentShot();
|
|
CDmElement *previewControl = GetLogPreviewControl();
|
|
const CDmaElementArray< CDmElement > &controls = m_AnimSet->GetControls();
|
|
|
|
int c = m_SliderList.Count();
|
|
int i;
|
|
for ( i = 0; i < c; ++i )
|
|
{
|
|
CAttributeSlider *slider = m_SliderList[ i ];
|
|
if ( !slider->IsVisible() )
|
|
continue;
|
|
CDmElement *control = controls[ i ];
|
|
|
|
MaybeAddPreviewLog( shot, m_ActiveTransforms, control, slider->IsDragging(), false, slider->IsSelected() );
|
|
MaybeAddPreviewLog( shot, m_CurrentPreview, control, slider->IsDragging(), ( control == previewControl ), slider->IsSelected() );
|
|
}
|
|
}
|
|
|
|
CUtlVector< LogPreview_t >* CBaseAnimSetAttributeSliderPanel::GetActiveTransforms()
|
|
{
|
|
return &m_ActiveTransforms;
|
|
}
|
|
|
|
CDmElement *CBaseAnimSetAttributeSliderPanel::GetElementFromSlider( CAttributeSlider *pSlider )
|
|
{
|
|
const CDmaElementArray< CDmElement > &controls = m_AnimSet->GetControls();
|
|
|
|
int c = m_SliderList.Count();
|
|
int i;
|
|
for ( i = 0; i < c; ++i )
|
|
{
|
|
CAttributeSlider *slider = m_SliderList[ i ];
|
|
if ( slider != pSlider )
|
|
continue;
|
|
|
|
CDmElement *control = controls[ i ];
|
|
return control;
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
CDmElement *CBaseAnimSetAttributeSliderPanel::GetLogPreviewControl()
|
|
{
|
|
return m_PreviewControl.Get();
|
|
}
|
|
|
|
void CBaseAnimSetAttributeSliderPanel::SetLogPreviewControlFromSlider( CAttributeSlider *pSlider )
|
|
{
|
|
CDmElement *control = GetElementFromSlider( pSlider );
|
|
// Note can be NULL
|
|
SetLogPreviewControl( control );
|
|
}
|
|
|
|
void CBaseAnimSetAttributeSliderPanel::SetLogPreviewControl( CDmElement *control )
|
|
{
|
|
if ( !m_hEditor.Get() )
|
|
return;
|
|
|
|
bool changed = m_PreviewControl != control ? true : false;
|
|
m_PreviewControl = control;
|
|
if ( changed )
|
|
{
|
|
const CDmaElementArray< CDmElement > &controls = m_AnimSet->GetControls();
|
|
|
|
int itemNumber = 0;
|
|
int nSliders = m_SliderList.Count();
|
|
for ( int i = 0; i < nSliders; ++i )
|
|
{
|
|
CAttributeSlider *slider = m_SliderList[ i ];
|
|
slider->SetIsLogPreviewControl( false );
|
|
if ( !slider->IsVisible() )
|
|
continue;
|
|
|
|
CDmElement *c = controls[ i ];
|
|
if ( c == control )
|
|
{
|
|
slider->SetIsLogPreviewControl( true );
|
|
slider->RequestFocus();
|
|
m_Sliders->ScrollToItem( itemNumber );
|
|
}
|
|
|
|
++itemNumber;
|
|
}
|
|
|
|
RecomputePreview();
|
|
}
|
|
}
|
|
|
|
|
|
void CBaseAnimSetAttributeSliderPanel::GetVisibleControls( CUtlVector< VisItem_t>& list )
|
|
{
|
|
const CDmaElementArray< CDmElement > &controls = m_AnimSet->GetControls();
|
|
|
|
int i, c;
|
|
c = m_SliderList.Count();
|
|
for ( i = 0; i < c; ++i )
|
|
{
|
|
CAttributeSlider *slider = m_SliderList[ i ];
|
|
if ( !slider->IsVisible() )
|
|
continue;
|
|
|
|
CDmElement *ctrl = controls[ i ];
|
|
if ( !ctrl )
|
|
continue;
|
|
|
|
VisItem_t item;
|
|
item.element = ctrl;
|
|
item.selected = slider->IsSelected();
|
|
item.index = i;
|
|
|
|
list.AddToTail( item );
|
|
}
|
|
}
|
|
|
|
int CBaseAnimSetAttributeSliderPanel::BuildVisibleControlList( CUtlVector< LogPreview_t >& list )
|
|
{
|
|
if ( !m_AnimSet.Get() )
|
|
return 0;
|
|
|
|
const CDmaElementArray< CDmElement > &controls = m_AnimSet->GetControls();
|
|
|
|
int i, c;
|
|
c = m_SliderList.Count();
|
|
for ( i = 0; i < c; ++i )
|
|
{
|
|
CAttributeSlider *slider = m_SliderList[ i ];
|
|
if ( !slider->IsVisible() )
|
|
continue;
|
|
|
|
CDmElement *ctrl = controls[ i ];
|
|
if ( !ctrl )
|
|
continue;
|
|
|
|
MaybeAddPreviewLog( NULL, list, ctrl, slider->IsDragging(), false, slider->IsSelected() );
|
|
}
|
|
|
|
return list.Count();
|
|
}
|
|
|
|
int CBaseAnimSetAttributeSliderPanel::BuildFullControlList( CUtlVector< LogPreview_t >& list )
|
|
{
|
|
if ( !m_AnimSet.Get() )
|
|
return 0;
|
|
|
|
const CDmaElementArray< CDmElement > &controls = m_AnimSet->GetControls();
|
|
|
|
int i, c;
|
|
c = m_SliderList.Count();
|
|
for ( i = 0; i < c; ++i )
|
|
{
|
|
CAttributeSlider *slider = m_SliderList[ i ];
|
|
CDmElement *ctrl = controls[ i ];
|
|
if ( !ctrl )
|
|
continue;
|
|
|
|
MaybeAddPreviewLog( NULL, list, ctrl, slider->IsDragging(), false, slider->IsSelected() );
|
|
}
|
|
|
|
return list.Count();
|
|
}
|
|
|
|
|
|
|
|
|
|
void SpewLayer( const char *desc, CDmeTypedLogLayer< float > *l )
|
|
{
|
|
Msg( "%s\n", desc );
|
|
|
|
int c = l->GetKeyCount();
|
|
for ( int i = 0; i < c; ++i )
|
|
{
|
|
DmeTime_t kt = l->GetKeyTime( i );
|
|
float v = l->GetKeyValue( i );
|
|
|
|
Msg( "%d %.3f = %f\n", i, kt.GetSeconds(), v );
|
|
|
|
if ( i > 20 )
|
|
break;
|
|
|
|
}
|
|
}
|
|
|
|
void CBaseAnimSetAttributeSliderPanel::MoveToSlider( CAttributeSlider *pCurrentSlider, int nDirection )
|
|
{
|
|
Assert( pCurrentSlider );
|
|
if ( !pCurrentSlider )
|
|
return;
|
|
|
|
// Find current slider index and then move to next / previous one
|
|
CUtlVector< CAttributeSlider * > visible;
|
|
|
|
int c = m_SliderList.Count();
|
|
if ( c <= 1 )
|
|
return;
|
|
|
|
int i;
|
|
for ( i = 0; i < c; ++i )
|
|
{
|
|
if ( !m_SliderList[ i ]->IsVisible() )
|
|
continue;
|
|
visible.AddToTail( m_SliderList[ i ] );
|
|
}
|
|
|
|
c = visible.Count();
|
|
|
|
if ( c <= 1 )
|
|
return;
|
|
|
|
for ( i = 0; i < c; ++i )
|
|
{
|
|
if ( visible[ i ] != pCurrentSlider )
|
|
continue;
|
|
|
|
Msg( "Found slider at %d (old %s)\n", i, pCurrentSlider->GetName() );
|
|
|
|
i += nDirection;
|
|
if ( i < 0 )
|
|
{
|
|
i = c - 1;
|
|
}
|
|
else if ( i >= c )
|
|
{
|
|
i = 0;
|
|
}
|
|
|
|
Msg( "Change to slider %d %s\n", i, visible[ i ]->GetName() );
|
|
|
|
// m_SliderList[ i ]->RequestFocus();
|
|
SetLogPreviewControl( visible[ i ]->GetControl() );
|
|
break;
|
|
}
|
|
}
|
|
|
|
void CBaseAnimSetAttributeSliderPanel::OnKBDeselectAll()
|
|
{
|
|
ClearSelectedControls();
|
|
}
|
|
|
|
void CBaseAnimSetAttributeSliderPanel::ClearSelectedControls()
|
|
{
|
|
int c = m_SliderList.Count();
|
|
int i;
|
|
for ( i = 0; i < c; ++i )
|
|
{
|
|
m_SliderList[ i ]->SetSelected( false );
|
|
}
|
|
RecomputePreview();
|
|
}
|
|
|
|
void CBaseAnimSetAttributeSliderPanel::SetControlSelected( CAttributeSlider *slider, bool state )
|
|
{
|
|
slider->SetSelected( state);
|
|
RecomputePreview();
|
|
}
|
|
|
|
void CBaseAnimSetAttributeSliderPanel::SetControlSelected( CDmElement *control, bool state )
|
|
{
|
|
CAttributeSlider *slider = FindSliderForControl( control );
|
|
if ( !slider )
|
|
return;
|
|
SetControlSelected( slider, state );
|
|
}
|
|
|
|
CAttributeSlider *CBaseAnimSetAttributeSliderPanel::FindSliderForControl( CDmElement *control )
|
|
{
|
|
int c = m_SliderList.Count();
|
|
int i;
|
|
for ( i = 0; i < c; ++i )
|
|
{
|
|
if ( m_SliderList[ i ]->GetControl() == control )
|
|
return m_SliderList[ i ];
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
bool CBaseAnimSetAttributeSliderPanel::GetSliderValues( AttributeValue_t *pValue, int nIndex )
|
|
{
|
|
Assert( pValue );
|
|
Assert( nIndex >= 0 && nIndex < m_SliderList.Count() );
|
|
|
|
CAttributeSlider *pSlider = m_SliderList[ nIndex ];
|
|
bool bForce = m_Previous.isbeingdragged;
|
|
bool bGetPreview = ( pSlider->IsPreviewEnabled() && ( !pSlider->IsSimplePreview() || bForce ) );
|
|
*pValue = bGetPreview ? pSlider->GetPreview() : pSlider->GetValue();
|
|
return pSlider->IsVisible();
|
|
} |