CH_Types.h

Go to the documentation of this file.

/*
 * PROPRIETARY INFORMATION.  This software is proprietary to
 * Side Effects Software Inc., and is not to be reproduced,
 * transmitted, or disclosed in any way without written permission.
 *
 * NAME:        CH library (C++)
 *
 * COMMENTS:    Convenient types used by the channel library.
 *
 */

#ifndef __CH_Types_h__
#define __CH_Types_h__

#include "CH_API.h"
#include <UT/UT_Array.h>

class CH_Group;
class CH_Segment;
class CH_Channel;
class CH_ChannelRef;
class CH_Collection;

using CH_GroupList = UT_Array<CH_Group *>;
using CH_SegmentList = UT_Array<CH_Segment *>;
using CH_ChannelList = UT_Array<CH_Channel *>;
using CH_ChannelRefList = UT_Array<CH_ChannelRef>;
using CH_CollectionList = UT_Array<CH_Collection *>;
using CH_NameList = UT_Array<const char *>;

using CHfindCallBack = int(*)(CH_Collection *grp, CH_Channel *chp, void *);

typedef enum {
    CH_SCOPEMASK_NONE = 0x0,

    CH_SCOPED = 0x1,
    CH_SELECTED = 0x2,
    CH_PINNED = 0x4,
    CH_DISPLAY = 0x8,
    CH_TEMPLATE = 0x10,

    CH_LAYER_SCOPED = 0x20,
    CH_LAYER_SELECTED = 0x40,
    CH_LAYER_PINNED = 0x80,
    CH_LAYER_DISPLAY = 0x100,

    CH_HIDDEN = 0x200,
    CH_VECTOR_HIDDEN = 0x400,

    CH_GRAPH_SELECTED = 0x800,
    CH_PARM_SELECTED = 0x1000,

    CH_NUM_FLAGS = 13,
    CH_ALL_FLAGS = ((1<<13)-1)

} CH_ScopeMasks;

typedef enum {
    CH_CHANNEL_DEFAULT,  // Channel is default value beyond defined range
    CH_CHANNEL_HOLD,     // Channel is start/end value before/after
    CH_CHANNEL_CYCLE,    // Channel wraps to defined range
    CH_CHANNEL_EXTEND,   // Channel function continues outside start/end
    CH_CHANNEL_SLOPE,    // Channel extends at start/end slope
    CH_CHANNEL_CYCLEOFF, // Channel warps tot defined range and offsets.
    CH_CHANNEL_OSCILLATE, // Channel warps tot defined range and offsets.
    CH_CHANNEL_BEHAVIOR_COUNT
} CH_ChannelBehavior;


// NB: This enum only has 8 bits.
// Do not change these values as they get saved.
typedef enum {
    CH_CHANNEL_NONE         = 0x00,
    CH_CHANNEL_MODIFIED     = 0x01,
    CH_CHANNEL_COOKING      = 0x02,
    CH_CACHE_ENABLED        = 0x04,     // no longer used!
    CH_CHANNEL_SPARE        = 0x08,     // no longer used!
    CH_CHANNEL_ACTIVE       = 0x10,

    CH_CHANNEL_PENDING      = 0x20,     // only used for saving/loading
    CH_CHANNEL_PENDINGHOLD  = 0x40,     // no longer used!

    CH_CHANNEL_LOCKED       = 0x80,

    // We save/load CH_CHANNEL_PENDING via myPending
    //CH_CHANNEL_SAVE_MASK    = CH_CHANNEL_PENDING,

    CH_CHANNEL_FLAG_MASK    = 0xFF      // sentinel: we've only got 8 bits
} CH_ChannelFlag;

// Enum for the CH_Channel::getKey and getFullKey methods
typedef enum {
    CH_GETKEY_EXTEND_NONE,      // Don't extend the channel cycle.
    CH_GETKEY_EXTEND_DEFAULT,  // Extend the channel extrapolation, and returns keys in the middle.
    CH_GETKEY_EXTEND_BOUNDARY, // Extend the channel extrapolation, but give a hint that the key is the last or the first.
} CH_GetKeyExtend;

CH_API extern const char *const
chScopeFlagNames[];

//
//  This enum is used when calling the changeSegLength method and provides
//  a hint as to how the change is to be done. This is currently only
//  necessary when changing the length of raw segments and the channel
//  manager raw interpolation option is turned off.
//
typedef enum {
    CH_SCALE_ANY,               // Don't care.
    CH_SCALE_START,             // Adjusting the segment start time.
    CH_SCALE_END                // Adjusting the segment end time.
} CH_SegmentScale;

typedef enum {
    CH_VALUE = 0,
    CH_SLOPE,
    CH_ACCEL,
    CH_NUM_VALUES
} CH_ValueTypes;

CH_API extern char
CHvalueNames[2][CH_NUM_VALUES];

/// CH_TweenMode - Tweening modes used by the CH_Tweener and CH_TweenTools
///
/// Classic: Blends the given key linearly between neighboring keys. Adds
///          a key if none exists at the given time.
/// BlendToNeighbor: Blends between the current key value and the neighbor's
///                  value. Whether it is the left or right neighbor depends
///                  on which direction the slider is dragged. Resets base
///                  values on mouse up.
/// EaseInOut:   Tweens a sequence of keys between a perfect Ease In/Out
///              between the previous keys
/// BlendToEase: Tweens a sequence of keys between their current values and
///              an ease In/Out depending on which direction the slider is
///              dragged. Resets base values on mouse up.
/// BlendToFrame: Tweens the selected keys linearly between the values
///               evaluated at the frames defined in CH_Tweener (See
///               CH_Tweener::setBlendTimes)
/// PullPush: Softens or Intensifies the animation curve by blending the keys
///           towards or away from the linear curve between the neighboring keys
/// NoiseWave: Adds noise to or waves out keys
/// BlendToSnapshot: Blends to the channel's snapshot
/// TimeOffsetter: "Offsets" the channel's timing by adjusting key values
///                instead of shifting them in time.
/// TimeOffsetterStagger: Offsets channels as with TimeOffsetter, but also
///                       applies a small stagger to each selected channel
/// ReduceResample: Reduces keys in the selected segments, or adds keys by
///                 resampling the selected segments.
/// SmoothRough: Applies a smoothing filter when dragging left, or a noise
///              filter when dragging right.
/// Reverse: Reverses the animation (button)
enum class CH_TweenMode
{
    // "Viewport" modes
    Classic,
    BlendToNeighbor,
    BlendToFrame,
    // "Animation Editor" modes
    EaseInOut,
    BlendToEase,
    PullPush,
    NoiseWave,
    BlendToSnapshot,
    TimeOffsetter,
    TimeOffsetterStagger,
    ReduceResample,
    SmoothRough,

    Reverse,

    Count,
};

enum class CH_TweenToolType
{
    SLIDER,
    BUTTON,
};

#endif