H3cJP/source-engine
1
0
Fork 0
mirror of https://github.com/nillerusr/source-engine.git synced 2024-12-23 22:56:50 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
3bf9df6b27
source-engine/vgui2/dme_controls/BaseAnimSetAttributeSliderPanel.cpp

1534 lines
40 KiB
C++
Raw Normal View History

1
2020-04-22 16:56:21 +00:00
//========= 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", &params );
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();
}
Reference in New Issue Copy Permalink