485 lines
24 KiB
C++
485 lines
24 KiB
C++
//====== Copyright © 1996-2009, Valve Corporation, All rights reserved. =======
|
|
//
|
|
// Declaration of CDmeGraphEditorState, a data model element which stores
|
|
// the active state data for the graph editor.
|
|
//
|
|
//=============================================================================
|
|
|
|
#ifndef DMEGRAPHEDITORCURVE_H
|
|
#define DMEGRAPHEDITORCURVE_H
|
|
#ifdef _WIN32
|
|
#pragma once
|
|
#endif
|
|
|
|
#include "movieobjects/dmechannel.h"
|
|
#include "datamodel/dmelement.h"
|
|
#include "checksum_crc.h"
|
|
|
|
enum SelectionMode_t
|
|
{
|
|
SELECT_SET,
|
|
SELECT_ADD,
|
|
SELECT_REMOVE,
|
|
SELECT_TOGGLE,
|
|
};
|
|
|
|
enum AddKeyMode_t
|
|
{
|
|
ADD_KEYS_AUTO,
|
|
ADD_KEYS_INTERPOLATE,
|
|
ADD_KEYS_STEPPED,
|
|
};
|
|
|
|
|
|
enum TangentOperation_t
|
|
{
|
|
TANGENTS_FLAT, // Tangents are modified so the value of the end points are equal to the key value
|
|
TANGENTS_LINEAR, // Tangents are modified so the endpoints are on the line between the key values
|
|
TANGENTS_SPLINE, // Tangents are modified so the that they are parallel to the line from the proceeding key to the next key
|
|
TANGENTS_UNIFIED, // Tangents are modified so both sides of the tangent lie on the same line
|
|
TANGENTS_ISOMETRIC, // Tangents are modified so both sides of the tangent are of equal length
|
|
TANGENTS_STEP, // Set the key to step mode, out tangent is ignored and all values between the key and the next key are equal to the key value
|
|
TANGENTS_WEIGHTED, // Set the key to perform tangent calculations using the time of of the tangents
|
|
TANGENTS_UNWEIGHTED, // Set the key to perform tangent calculations such that the delta time of the tangents is ignored ( always 1/3 time to next key ).
|
|
};
|
|
|
|
enum KeyTangentMode_t
|
|
{
|
|
TANGENT_MODE_DEFAULT,
|
|
TANGENT_MODE_LINEAR,
|
|
TANGENT_MODE_SPLINE,
|
|
TANGENT_MODE_STEPPED
|
|
};
|
|
|
|
class CDmeGraphEditorCurve;
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// The CDmeCurveKey class represents a single key on a curve an hold
|
|
// information about the position of the key and its tangents. The tangent
|
|
// values are stored as delta so they do not have to be updated when the value
|
|
// of the key changes.
|
|
//-----------------------------------------------------------------------------
|
|
class CDmeCurveKey : public CDmElement
|
|
{
|
|
DEFINE_ELEMENT( CDmeCurveKey, CDmElement );
|
|
|
|
enum KeyDirtyFlags_t
|
|
{
|
|
KEY_CLEAN = 0,
|
|
KEY_IN_DIRTY = 1,
|
|
KEY_OUT_DIRTY = 2
|
|
};
|
|
|
|
static const int UNWEIGHTED_DISPLAY_LENGTH = 60;
|
|
|
|
public:
|
|
|
|
// Initialize the key with the specified time and value
|
|
void Initialize( DmeTime_t time, float flValue, int nComponent );
|
|
|
|
// Get a pointer to the curve to which the key belongs
|
|
CDmeGraphEditorCurve *GetCurve() const;
|
|
|
|
// Return the sort value for the two keys based on their times
|
|
static int SortFunc( CDmeCurveKey * const *pKeyA, CDmeCurveKey * const *pKeyB );
|
|
|
|
// Clear the selection state of the key and its tangents
|
|
void ClearSelection();
|
|
|
|
// Set the key tangents to be flat
|
|
void SetTangentsFlat( const CDmeCurveKey *pPrevKey, const CDmeCurveKey *pNextKey, bool bSetIn, bool bSetOut );
|
|
|
|
// Set the key tangents to be linear
|
|
void SetTangentsLinear( const CDmeCurveKey *pPrevKey, const CDmeCurveKey *pNextKey, bool bSetIn, bool bSetOut );
|
|
|
|
// Set the key tangents using a spline method
|
|
void SetTangentsSpline( const CDmeCurveKey *pPrevKey, const CDmeCurveKey *pNextKey, bool bSetIn, bool bSetOut );
|
|
|
|
// Make both of the tangents of the key lie one the same line
|
|
void SetTangentsUnified( float flUnitsPerSecond, bool bSetIn, bool bSetOut );
|
|
|
|
// Make both of the tangents of the key be the same length
|
|
void SetTangentsIsometric( float flUnitsPerSecond, bool bSetIn, bool bSetOut );
|
|
|
|
// Set the key tangents as being broken (not unified)
|
|
void SetTangentsBroken();
|
|
|
|
// Set the key as being in stepped mode
|
|
void SetStepped( bool bStepped );
|
|
|
|
// Enable or disable weighted tangents
|
|
void SetWeighted( bool bWeighted, const CDmeCurveKey *pPrevKey, const CDmeCurveKey *pNextKey );
|
|
|
|
// Make the specified key match the unweighted form
|
|
void ConformUnweighted( const CDmeCurveKey *pPrevKey, const CDmeCurveKey *pNextKey );
|
|
|
|
|
|
|
|
void SetSelected( bool bSelect ) { m_Selected = bSelect; }
|
|
void SetInSelected( bool bSelect ) { m_InSelected = bSelect; }
|
|
void SetOutSelected( bool bSelect ) { m_OutSelected = bSelect; }
|
|
void SetKeyClean() { m_KeyDirtyFlags = KEY_CLEAN; }
|
|
void SetKeyInClean() { m_KeyDirtyFlags &= ~KEY_IN_DIRTY; }
|
|
void SetKeyOutClean() { m_KeyDirtyFlags &= ~KEY_OUT_DIRTY;}
|
|
void SetKeyInDirty() { m_KeyDirtyFlags |= KEY_IN_DIRTY; }
|
|
void SetKeyOutDirty() { m_KeyDirtyFlags |= KEY_OUT_DIRTY; }
|
|
|
|
// Tangent manipulation
|
|
void SetInTime( DmeTime_t dt ) { m_InTime = dt; }
|
|
void SetInDelta( float flDelta ) { m_InDelta = flDelta; }
|
|
void SetOutTime( DmeTime_t dt ) { m_OutTime = dt; }
|
|
void SetOutDelta( float flDelta ) { m_OutDelta = flDelta; }
|
|
|
|
// Accessors
|
|
bool IsSelected() const { return m_Selected; }
|
|
bool InTangentSelected() const { return m_InSelected; }
|
|
bool OutTangentSelected() const { return m_OutSelected; }
|
|
bool IsKeyWeighted() const { return m_Weighted; }
|
|
bool IsKeyUnified() const { return m_Unified; }
|
|
int GetComponent() const { return m_Component; }
|
|
DmeTime_t GetTime() const { return m_Time; }
|
|
float GetValue() const { return m_Value; }
|
|
DmeTime_t GetInTime() const { return m_InTime; }
|
|
float GetInDelta() const { return m_InDelta; }
|
|
DmeTime_t GetOutTime() const { return m_OutTime; }
|
|
float GetOutDelta() const { return m_OutDelta; }
|
|
bool IsKeyStepped() const { return m_OutMode == TANGENT_MODE_STEPPED; }
|
|
KeyTangentMode_t GetInMode() const { return ( KeyTangentMode_t )m_InMode.Get(); }
|
|
KeyTangentMode_t GetOutMode() const { return ( KeyTangentMode_t )m_OutMode.Get(); }
|
|
|
|
bool IsInTangentValid() const { return ( m_InTime != DMETIME_ZERO ); }
|
|
bool IsOutTangentValid() const { return ( m_OutTime != DMETIME_ZERO ); }
|
|
bool IsKeyDirty() const { return ( m_KeyDirtyFlags != KEY_CLEAN ); }
|
|
bool IsKeyInDirty() const { return ( m_KeyDirtyFlags & KEY_IN_DIRTY ) != 0; }
|
|
bool IsKeyOutDirty() const { return ( m_KeyDirtyFlags & KEY_OUT_DIRTY ) != 0; }
|
|
|
|
static int GetUnweightedDisplayLength() { return UNWEIGHTED_DISPLAY_LENGTH; }
|
|
|
|
private:
|
|
|
|
friend class CDmeGraphEditorCurve; // GraphEditorCurve is a friend so that it may manipulate the key values
|
|
friend class CUndoGraphEditorModifyKeys; // The modify keys undo element is also allowed to touch keys directly to restore state
|
|
|
|
// Key time and value manipulation, these functions are private as they are intended to be used
|
|
// only by the CDmeGraphEditorCurve to which the key belongs. This is because the curve needs
|
|
// to know when these values change, in particular the keys are stored ordered by time in the
|
|
// curve, so the change of key time may require re-ordering of the key list in the curve.
|
|
void SetTime( DmeTime_t time ) { m_Time = time; }
|
|
void SetValue( float value ) { m_Value = value; }
|
|
void SetInMode( KeyTangentMode_t mode ) { m_InMode = mode; }
|
|
void SetOutMode( KeyTangentMode_t mode ) { m_OutMode = mode; }
|
|
|
|
// Save all of the current values of the key internally.
|
|
void StoreCurrentValues();
|
|
|
|
// Mark the previous values as being invalid
|
|
void ClearPreviousValues() { m_bOldValuesValid = false; }
|
|
|
|
// The old values are copied from the current values of the key by calling StoreCurrentValues(). These
|
|
// are temporary values that are used to determine the delta values of operations. The following functions
|
|
// return the old values if they have been stored or the current values if the old values have not been stored.
|
|
bool GetPreviousStepped() const { return m_bOldValuesValid ? ( m_OldOutMode == TANGENT_MODE_STEPPED ) : ( m_OutMode == TANGENT_MODE_STEPPED ); }
|
|
DmeTime_t GetPreviousTime() const { return m_bOldValuesValid ? m_OldTime : m_Time; }
|
|
float GetPreviousValue() const { return m_bOldValuesValid ? m_OldValue : m_Value; }
|
|
DmeTime_t GetPreviousInTime() const { return m_bOldValuesValid ? m_OldInTime : m_InTime; }
|
|
float GetPreviousInDelta() const { return m_bOldValuesValid ? m_OldInDelta : m_InDelta; }
|
|
DmeTime_t GetPreviousOutTime() const { return m_bOldValuesValid ? m_OldOutTime : m_OutTime; }
|
|
float GetPreviousOutDelta() const { return m_bOldValuesValid ? m_OldOutDelta : m_OutDelta; }
|
|
|
|
// Multi-selected tangent state, these will return true if the specified tangent is selected or just the key is selected
|
|
bool InMultiSelected() const { return m_InSelected || ( m_Selected && !m_OutSelected ); }
|
|
bool OutMultiSelected() const { return m_OutSelected || ( m_Selected && !m_InSelected ); }
|
|
|
|
|
|
int m_Component; // Index of the component of the curve the key is associated with
|
|
int m_KeyDirtyFlags; // Flags indicating if the key has been changed and on which side
|
|
CDmaVar< bool > m_Selected; // "selected" : flag indicating if the key is currently selected
|
|
CDmaVar< bool > m_InSelected; // "inSelected" : flag indicating if the in tangent of the key is selected
|
|
CDmaVar< bool > m_OutSelected; // "outSelected" : flag indicating if the out tangent of the key is selected
|
|
CDmaVar< bool > m_Weighted; // "weighted" : flag indicating if the tangents of the keys are operating in weighted mode
|
|
CDmaVar< bool > m_Unified; // "unified" : flag indicating if the tangents of the key are to be manipulated together
|
|
CDmaVar< int > m_InMode; // "inMode" : mode in which the in tangent is currently operating
|
|
CDmaVar< int > m_OutMode; // "outMode" : mode in which the out tangent is currently operating
|
|
CDmaVar< DmeTime_t > m_Time; // "time" : The time the key is located at
|
|
CDmaVar< float > m_Value; // "value" : The value of the curve at the point of the key
|
|
CDmaVar< DmeTime_t > m_InTime; // "inTime" : The time length of the left tangent of the key
|
|
CDmaVar< float > m_InDelta; // "inDelta" : The delta value of the left tangent of the key
|
|
CDmaVar< DmeTime_t > m_OutTime; // "outTime" : The time length of the right tangent of the key
|
|
CDmaVar< float > m_OutDelta; // "outDelta" : The delta value of the right tangent of the key
|
|
|
|
bool m_bOldValuesValid; // Flag indicating if the set of old values have been stored and are valid
|
|
int m_OldInMode; // Previous in tangent operation mode
|
|
int m_OldOutMode; // Previous out tangent operation mode
|
|
DmeTime_t m_OldTime; // Previous time of the key
|
|
float m_OldValue; // Previous value of the key
|
|
DmeTime_t m_OldInTime; // Previous time length of the in tangent
|
|
float m_OldInDelta; // Previous delta value of the in tangent
|
|
DmeTime_t m_OldOutTime; // Previous time length of the out tangent
|
|
float m_OldOutDelta; // Previous delta value of the out tangent
|
|
};
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// The CDmeEditCurve represents a channel which is being displayed for editing
|
|
// int the graph editor.
|
|
//-----------------------------------------------------------------------------
|
|
class CDmeGraphEditorCurve : public CDmElement
|
|
{
|
|
DEFINE_ELEMENT( CDmeGraphEditorCurve, CDmElement );
|
|
|
|
static const int MAX_COMPONENTS = LOG_MAX_COMPONENTS;
|
|
|
|
struct SamplePoint_t
|
|
{
|
|
DmeTime_t time;
|
|
float value;
|
|
};
|
|
|
|
public:
|
|
|
|
// Set the channel and components assigned to the curve and initialize the curve data.
|
|
void Initialize( CDmeChannel *pChannel, DmeFramerate_t framerate, bool bFrameSnap, const DmeClipStack_t &clipstack );
|
|
|
|
// Initialize the edit log.
|
|
void InitializeEditLog( DmeFramerate_t framerate, const DmeClipStack_t &clipstack );
|
|
|
|
// Make sure all results of curve editing are applied to the log
|
|
void Finalize();
|
|
|
|
// Determine if the CRC of the log is the same as the last time finalize was called on the curve
|
|
bool VerifyLogCRC() const;
|
|
|
|
// Compute the tangents of the specified key
|
|
void ComputeTangentsForKey( CDmeCurveKey *pKey, bool bStepped ) const;
|
|
|
|
// Set the tangents for the key to be the specified type
|
|
void SetKeyTangents( CDmeCurveKey *pKey, TangentOperation_t tangentType, bool bRespectSelection, float flUnitsPerSecond ) const;
|
|
|
|
// Add keys to the curve at the specified time for the specified components
|
|
void AddKeysAtTime( DmeTime_t time, LogComponents_t nComponentFlags, bool bComputeTangents, AddKeyMode_t addMode, bool bVisibleOnly );
|
|
|
|
// Remove all of keys at the specified time
|
|
bool RemoveKeysAtTime( DmeTime_t time );
|
|
|
|
// Add a key to the curve at the specified time on the specified component
|
|
void AddKeyAtTime( DmeTime_t time, int nComponent, bool bRecomputeNeigbors );
|
|
|
|
// Set the value of the key at the specified time or create a new key at the time with the specified value
|
|
CDmeCurveKey *SetKeyAtTime( DmeTime_t time, int nComponent, float flValue );
|
|
|
|
// Set the position value of the key at the specified time or create a new key at the time with the specified value
|
|
void SetKeyAtTime( DmeTime_t time, LogComponents_t nComponentFlags, const Vector &position );
|
|
|
|
// Set the position value of the key at the specified time or create a new key at the time with the specified value
|
|
void SetKeyAtTime( DmeTime_t time, LogComponents_t nComponentFlags, const Quaternion &orientation );
|
|
|
|
// Set the position value of the key at the specified time or create a new key at the time with the specified value
|
|
void SetKeyAtTime( DmeTime_t time, LogComponents_t nComponentFlags, const CDmAttribute *pAttr );
|
|
|
|
// Remove a key from the specified component of the curve at the specified time
|
|
bool RemoveKeyAtTime( DmeTime_t time, int nComponent );
|
|
|
|
// Find the keys within the specified time range
|
|
void FindKeysInTimeRange( CUtlVector< CDmeCurveKey * > &keyList, DmeTime_t startTime, DmeTime_t endTime, int nComponent );
|
|
|
|
// Offset the specified keys by the specified about of time
|
|
void OffsetKeyTimes( const CUtlVector< CDmeCurveKey * > &keyList, DmeTime_t timeDelta );
|
|
|
|
// Move the specified key by the specified amount
|
|
void MoveKeys( const CUtlVector< CDmeCurveKey * > &moveKeyList, DmeTime_t timeDelta, float flValueDelta,
|
|
const DmeClipStack_t &localTimeClipStack, DmeFramerate_t framerate, float flValueScale,
|
|
float timeScale, DmeTime_t cursorTime, bool bFrameSnap, bool bUnifiedTangents );
|
|
|
|
// Scale the specified keys about the specified
|
|
void ScaleKeys( const CUtlVector< CDmeCurveKey * > &keyList, float flTimeScaleFactor, float flValueScaleFactor,
|
|
DmeTime_t originTime, float flOriginValue, const DmeClipStack_t &localTimeClipStack, DmeFramerate_t framerate );
|
|
|
|
// Blend the specified keys toward the provided value using the specified blend factor
|
|
void BlendKeys( const CUtlVector< CDmeCurveKey * > &keyList, Vector4D targetValue, DmAttributeType_t targetValueType, float flBlendFactor );
|
|
|
|
// Blend the specified keys toward the value at the specified time using the specified blend factor
|
|
void BlendKeys( const CUtlVector< CDmeCurveKey * > &keyList, DmeTime_t targetValueTime, float flBlendFactor );
|
|
|
|
// Delete the specified keys from the curve
|
|
void DeleteKeys( const CUtlVector< CDmeCurveKey * > &keyList );
|
|
|
|
// Build the keys from the log bookmarks
|
|
void BuildKeysFromLog( DmeFramerate_t framerate, bool bFrameSnap, const DmeClipStack_t &graphClipStack );
|
|
|
|
// Update the edit layer for changes to the specified keys
|
|
void UpdateEditLayer( DmeFramerate_t framerate, const DmeClipStack_t &graphClipStack, bool bEditLayerUndoable, bool bOffsetMode );
|
|
|
|
// Flatten the layers of the edit log, overwriting the base log layer with the active edit layer
|
|
void FlattenEditLog();
|
|
|
|
// Get the range of values within the specified time range
|
|
bool GetValueRangeForTime( DmeTime_t minTime, DmeTime_t maxTime, float &minValue, float &maxValue ) const;
|
|
|
|
// Get the shot relative time of the specified key
|
|
DmeTime_t GetKeyShotTime( int nKeyIndex, int nComponent ) const;
|
|
|
|
// Get the shot relative time of the specified key
|
|
DmeTime_t GetKeyShotTime( CDmeCurveKey *pKey ) const;
|
|
|
|
// Get the shot relative time of the key and its tangents
|
|
void GetKeyShotTimes( CDmeCurveKey *pKey, DmeTime_t &keyTime, DmeTime_t &inTime, DmeTime_t &outTime ) const;
|
|
|
|
// Find the neighboring keys of the specified key
|
|
int FindKeyNeighbors( const CDmeCurveKey *pKey, CDmeCurveKey *&pPreviousKey, CDmeCurveKey *&pNextKey ) const;
|
|
|
|
// Build the clip stack for channel used by the the curve
|
|
bool BuildClipStack( DmeClipStack_t *pClipStack, CDmeClip *pRoot, CDmeClip *pShot ) const;
|
|
|
|
// Get the channels clip to which the channel of the curve belongs
|
|
CDmeChannelsClip *GetChannelsClip() const;
|
|
|
|
// Mark all components as not being visible
|
|
void ClearComponents();
|
|
|
|
// Add the specified components to the current set of components
|
|
void UpdateComponents( LogComponents_t nComponentFlags );
|
|
|
|
// Get the flag specifying which components of the log are to be displayed.
|
|
LogComponents_t GetComponentFlags() const;
|
|
|
|
// Get the number of components in the curve
|
|
int GetNumComponents() const;
|
|
|
|
// Determine if the component specified by index is visible
|
|
bool IsComponentVisible( int nComponentIndex ) const;
|
|
|
|
// Determine if the specified component is selected
|
|
bool IsComponentSelected( int nComponentIndex ) const;
|
|
|
|
// Set the selected state of the component
|
|
void SetComponentSelection( LogComponents_t nComponentIndex, SelectionMode_t selectionMode );
|
|
|
|
// Clear the component selection of the curve
|
|
void ClearComponentSelection();
|
|
|
|
// Get all of the keys for the components specified by the provided flags
|
|
void GetKeysForComponents( CUtlVector< CDmeCurveKey * > &keyList, LogComponents_t nComponentFlags ) const;
|
|
|
|
// Get the value of the specified component of the edit log at the specified time
|
|
float GetEditValue( DmeTime_t time, int nComponentIndex ) const;
|
|
|
|
// Return true if the specified channel is the one in use by the curve
|
|
bool IsCurveUsingChannel( const CDmeChannel *pChannel ) { return m_Channel == pChannel; }
|
|
|
|
// Accessors
|
|
CDmeChannel *GetChannel() const { return m_Channel; }
|
|
const CDmeLog *GetEditLog() const { return m_EditLog; }
|
|
const CDmeCurveKey *GetKey( int nIndex, int nComponent ) const { return m_KeyList[ nComponent ][ nIndex ]; }
|
|
CDmeCurveKey *GetKey( int nIndex, int nComponent ) { return m_KeyList[ nComponent ][ nIndex ]; }
|
|
int GetNumKeys( int nComponent ) const { return m_KeyList[ nComponent ].Count(); }
|
|
bool IsVisibleX() const { return GetValue< bool >( "xVisible", false ); }
|
|
bool IsVisibleY() const { return GetValue< bool >( "yVisible", false ); }
|
|
bool IsVisibleZ() const { return GetValue< bool >( "zVisible", false ); }
|
|
|
|
|
|
private:
|
|
|
|
|
|
// Find the key on the specified component at the specified time
|
|
int FindKeyAtLocalTime( DmeTime_t localTime, int nComponent ) const;
|
|
|
|
// Find the index of the specified key
|
|
int FindKeyIndex( const CDmeCurveKey *pKey ) const;
|
|
|
|
// Find the neighboring keys of the key with the specified index
|
|
void FindKeyNeighbors( int nKeyIndex, int nComponent, CDmeCurveKey *&pPreviousKey, CDmeCurveKey *&pNextKey ) const;
|
|
|
|
// Find the previous neighbors of the key using the stored key ordering list
|
|
bool FindOldKeyNeighbors( const CDmeCurveKey *pKey, CDmeCurveKey *&pPreviousKey, CDmeCurveKey *&pNextKey ) const;
|
|
|
|
// Find the key which was previously at the first key of the curve segment containing the specified time.
|
|
const CDmeCurveKey *FindOldSegmentForTime( DmeTime_t time, int nComponent ) const;
|
|
|
|
// Create a key at the specified time, with the specified value.
|
|
CDmeCurveKey *CreateKey( DmeTime_t time, float flValue, int nComponent, bool bRecomputeNeighbors );
|
|
|
|
// Remove the specified key from the curve
|
|
void RemoveKey( int nKeyIndex, int nComponent );
|
|
|
|
// Compute the tangents for the curve segment between the two keys
|
|
void ComputeKeyTangentsForSegment( CDmeCurveKey *pStartKey, CDmeCurveKey *pEndKey, bool bAllowStepped ) const;
|
|
|
|
// Update the tangent handles of keys based on the current mode
|
|
void UpdateTangentHandles();
|
|
|
|
// Update the key list so that all keys are valid and in order
|
|
void FixupKeyList( const CUtlVector< CDmeCurveKey * > &editKeyList );
|
|
|
|
// Make sure all of the keys are in order, but make no other changes to the keys
|
|
void SortKeyList();
|
|
|
|
// Make a copy of the current key list so that it may be used to compare the key ordering after changes have been made
|
|
void StoreCurrentKeyList();
|
|
|
|
// Clear the copy of the stored key list
|
|
void ClearCachedKeyList();
|
|
|
|
// Update the base log from the edit log.
|
|
void UpdateBaseLog( bool bUseEditLayer );
|
|
|
|
// Update the edit layer for changes to the specified keys
|
|
template < typename T >
|
|
void UpdateEditLayer( CDmeTypedLog< T > *pEditLog, DmeFramerate_t framerate, const DmeClipStack_t &graphClipstack, bool bEditLayerUndoable, bool bOffsetMode );
|
|
|
|
// Generate samples for the curve between two keys and write them into the edit layer
|
|
template < typename T >
|
|
void GenerateCurveSamples( const CDmeCurveKey *pKeyA, const CDmeCurveKey *pKeyB, CUtlVector< DmeTime_t > &sampleTimes, CUtlVector< T > &sampleValues, int nComponent,
|
|
const CDmeTypedLogLayer< T > *pBaseLayer, int &nLayerKeyIndex, DmeFramerate_t sampleRate, const DmeClipStack_t &clipstack, bool bOffsetMode ) const;
|
|
|
|
// Generate sample values for the specified component using the provided sample points
|
|
template < typename T >
|
|
void GenerateSampleValues( const CUtlVector< Vector2D > &points, const CUtlVector< DmeTime_t > &pointTimes, CUtlVector< DmeTime_t > &sampleTimes, CUtlVector< T > &sampleValues,
|
|
int nComponent, const CDmeTypedLogLayer< T > *pBaseLayer, int &nLayerKeyIndex, DmeFramerate_t sampleRate, const DmeClipStack_t &clipstack ) const;
|
|
|
|
// Generate sample values for the specified component using the provided previous curve points and the new curve points
|
|
template < typename T >
|
|
void GenerateOffsetSampleValues( const CUtlVector< Vector2D > &points, const CUtlVector< DmeTime_t > &pointTimes, const CUtlVector< Vector2D > &prevPoints,
|
|
const CUtlVector< DmeTime_t > &prevPointTimes, CUtlVector< DmeTime_t > &sampleTimes, CUtlVector< T > &sampleValues, int nComponent,
|
|
const CDmeTypedLogLayer< T > *pBaseLayer, int nLayerKeyIndex, DmeFramerate_t sampleRate, const DmeClipStack_t &clipstack, bool bRescaleTime ) const;
|
|
|
|
// Get the range of values within the specified time range for the specified log
|
|
template < typename T >
|
|
bool GetValueRangeForTime( CDmeTypedLog< T > *pEditLog, DmeTime_t minTime, DmeTime_t maxTime, float &minValue, float &maxValue ) const;
|
|
|
|
// Update the log bookmarks to match the keys
|
|
void UpdateLogBookmarks() const;
|
|
|
|
// Compute the crc of the log associated with channel
|
|
CRC32_t ComputeLogCRC() const;
|
|
|
|
// Re-scale the provided list of times from one time frame to another.
|
|
static void RescaleTimes( DmeTime_t prevStart, DmeTime_t prevEnd, DmeTime_t newStart, DmeTime_t newEnd, const CUtlVector< DmeTime_t > &oldTimes, CUtlVector< DmeTime_t > &newTimes );
|
|
|
|
// Interleave a set of times with times occurring at a regular global interval between the provided start and end time.
|
|
static void InterleaveGlobalSampleTimes( DmeTime_t startTime, DmeTime_t endTime, const CUtlVector< DmeTime_t > &existingSampleTimes, CUtlVector< DmeTime_t > &sampleTimes, DmeFramerate_t sampleRate, const DmeClipStack_t &clipstack );
|
|
|
|
private:
|
|
|
|
CDmaElement< CDmeChannel > m_Channel; // "channel" : The channel associated with the curve
|
|
CDmaElement< CDmeLog > m_EditLog; // "editLog" : Log that will be used for editing, for quaternions this is the log of Euler angles.
|
|
CDmaElementArray< CDmeCurveKey > m_KeyList[ MAX_COMPONENTS ]; // "keyList" : List of keys on the curve
|
|
CDmaVar< int > m_ComponentSelection; // "componentSelection" : Flags specifying which components are selected
|
|
|
|
CRC32_t m_logCRC; // CRC value of the log the last time Finalize() was called
|
|
CDmeLogLayer *m_pEditLayer; // Pointer to the log layer used to store the results of the curve manipulation
|
|
CUtlVector< CDmeCurveKey * > m_OldKeyList[ MAX_COMPONENTS ]; // A list of the ordering of keys before the current modification
|
|
|
|
friend class CUndoGraphEditorModifyKeys;
|
|
};
|
|
|
|
// Quaternion <==> Euler conversion utilities.
|
|
void QuaternionToEuler( const Quaternion &q, Vector &rotation, Vector &absRotation );
|
|
void EulerToQuaternion( const Vector &euler, Quaternion &quat );
|
|
bool ConvertLogEulerToQuaternion( const CDmeVector3LogLayer *pEulerLayer, CDmeQuaternionLogLayer *pQuatLayer );
|
|
bool ConvertLogQuaterionToEuler( const CDmeQuaternionLogLayer *pQuatLayer, CDmeVector3LogLayer *pEulerLayer, DmeFramerate_t sampleRate, const DmeClipStack_t &clipstack );
|
|
|
|
|
|
|
|
#endif // DMEGRAPHEDITORCURVE_H
|