UT_Playback.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:        UT_Playback.h ( UT Library, C++)
 *
 * COMMENTS:
 *
 *      This class is used to store framebar info for
 *      classes above the SI library. 
 *
 *      This is primarily read-only for users - the set
 *      methods are used to update from the UI, but can't be
 *      used to update the UI.  stopPlayback() is the exception.
 *      
 */

#ifndef __UT_Playback__
#define __UT_Playback__

#include "UT_API.h"
#include "UT_ValArray.h"
#include <SYS/SYS_StaticInit.h>
#include <SYS/SYS_Types.h>
#include "UT_Function.h"
#include "UT_Lock.h"
#include "UT_Set.h"
#include "UT_Map.h"

#include <iosfwd>
#include <utility>

class ut_PlayCB;

// cbdata, UT_PlaybackMode, oldframe, newframe
typedef void (*UT_PlayCallback)(void *, int, fpreal, fpreal);
typedef bool (*UT_PlayAdvanceCB)(void *);

class UT_API UT_Playback 
{
public:

     UT_Playback();

    enum UT_PlaybackMode {
        REVERSE,
        STOPPED,
        FORWARD,
        SCRUB,
        RESET,

        FLIPBOOKING
    };

    enum class RealtimeBehaviour
    {
        MAINTAIN_PLAYBACK_SPEED = 0,
        PLAY_EVERY_FRAME
    };

    void                setPlaybackMode(UT_PlaybackMode mode);

    UT_PlaybackMode     getPlaybackMode() const
                        { return myPlayback; }

    void                setContinuousCook(bool continuous);
    bool                isContinuousCook() const
                        { return myContinuousCook; }

    int                 getStopCount() const
                        { return myStopCount; }

    void                setRealtimeMode(bool mode)
                        { myRealtimeMode = mode; }

    bool                getRealtimeMode() const
                        { return myRealtimeMode; }

    void                setPlaybackRange(fpreal start,fpreal end)
                        { myStartRange = start; myEndRange = end; }

    void                getPlaybackRange(fpreal &start, fpreal &end) const
                        { start = myStartRange; end = myEndRange; }

    bool                isPlaybackReset();
    bool                isPlaying() const { return (myPlayback == FORWARD ||
                                                    myPlayback == REVERSE); }
    bool                isScrubbing() const { return myPlayback == SCRUB; }

    void                setCurrentFrame(fpreal frame);
    fpreal              getCurrentFrame() { return myCurrentFrame; }

    void                resetAbsoluteFrame(); 
    unsigned long       getAbsoluteFrame() { return myAbsoluteFrame; }

    // tells SI_Playback to stop.
    void                stopPlayback();
    void                setStopCallback(void (*cb)(void *), void *data);

    void                setInterceptMode(int mode) { myInterceptMode = mode; }
    int                 getInterceptMode() const   { return myInterceptMode; }

    void                setLastFrameTime(fpreal time_sec)
                        { myLastFrameTime = time_sec; }
    fpreal              getLastFrameTime() const { return myLastFrameTime; }

    void                setSamplesPerSec(fpreal samples_sec)
                        { mySamplesPerSec = samples_sec; }
    fpreal              getSamplesPerSec() const { return mySamplesPerSec; }

    // Callbacks are passed the UT_PlaybackMode and 'data'.
    void                addPlayCallback(UT_PlayCallback cb, void *cbdata);
    void                removePlayCallback(UT_PlayCallback cb, void *cbdata);

    void                addPlayAdvanceCB(UT_PlayAdvanceCB, void *cbdata);
    void                removePlayAdvanceCB(UT_PlayAdvanceCB, void *cbdata);
    bool                canAdvancePlay();

    /// Register callbacks for when flipbooks are started and/or finished, returning
    /// the callback id.
    int                 addFlipbookCallbacks(UT_Function<void()> started_cb = nullptr,
                                             UT_Function<void()> finished_cb = nullptr);

    /// Remove flipbook callbacks by the respective id.
    void                removeFlipbookCallbacks(int id);

   
    /// Register nodes as continuous playback nodes, these will have
    /// their continuouscook_tick incremented on continuouscook
    /// frames
    void                registerContinuousCookNode(int nodeid);
    void                unregisterContinuousCookNode(int nodeid);
    void                getContinuousCookNodes(UT_IntArray &nodeids) const;

    void                setRealtimeBehaviour(const RealtimeBehaviour behaviour)
                        { myRealtimeBehaviour = behaviour; } 
    RealtimeBehaviour   getRealtimeBehaviour() const { return myRealtimeBehaviour; }

    static UT_Playback *getPlayback();
    
    
    // Utility function to find a frame separation that is an intelligent
    // multiple/subdivision of the current frame rate, close to the
    // initialSep parameter.
    static int          niceFrameSeparation(fpreal samples_sec,
                                            fpreal initial_sep,
                                            int minimum_sep = 1);

private:

    using CallbackPair = std::pair<UT_PlayAdvanceCB, void *>;

    UT_PlaybackMode                              myPlayback;
    bool                                         myContinuousCook;
    fpreal                                       myStartRange;
    fpreal                                       myEndRange;
    fpreal                                       myCurrentFrame;
    unsigned long                                myAbsoluteFrame;
    fpreal                                       myLastFrameTime;
    fpreal                                       mySamplesPerSec;
    bool                                         myRealtimeMode;
    bool                                         myResetFlag;
    int                                          myInterceptMode;
    UT_ValArray<ut_PlayCB *>                     myPlayCallbacks;
    UT_Array<CallbackPair>                       myPlayAdvanceCBs;
    RealtimeBehaviour                            myRealtimeBehaviour;

    int                                          myStopCount;

    mutable UT_Lock             myLock;
    UT_Set<int>                 myContinuousNodes;

    UT_Map<int, std::pair<UT_Function<void()>, UT_Function<void()>>> myFlipbookCallbacks;

    static int theNextFlipbookCallbackId;

    void handleFlipbookStarted() const;
    void handleFlipbookFinished() const;
};

SYSdeclareStaticObject(UT_API, UTplaybackObject);

#endif