Clock.h

Go to the documentation of this file.

/*
Copyright 2007-2025. Algoryx Simulation AB.
 
All AGX source code, intellectual property, documentation, sample code,
tutorials, scene files and technical white papers, are copyrighted, proprietary
and confidential material of Algoryx Simulation AB. You may not download, read,
store, distribute, publish, copy or otherwise disseminate, use or expose this
material unless having a written signed agreement with Algoryx Simulation AB, or having been
advised so by Algoryx Simulation AB for a time limited evaluation, or having purchased a
valid commercial license from Algoryx Simulation AB.
 
Algoryx Simulation AB disclaims all responsibilities for loss or damage caused
from using this software, unless otherwise stated in written agreements with
Algoryx Simulation AB.
*/
#ifndef AGX_CLOCK_H
#define AGX_CLOCK_H
 
 
#include <agxData/Value.h>
#include <agx/Task.h>
 
 
namespace agx
{
  class TiXmlElement;
 
  AGX_DECLARE_POINTER_TYPES(Clock);
  AGX_DECLARE_VECTOR_TYPES(Clock);
 
  class AGXCORE_EXPORT Clock : public Component
  {
  public:
    static agx::Model *ClassModel();
 
    static Clock *load(TiXmlElement *eClock, Device *device);
    virtual void configure(TiXmlElement *eClock) override;
    virtual void save(TiXmlElement *eParent) const override;
 
 
    AGX_DECLARE_POINTER_TYPES(FrameWrapper);
    AGX_DECLARE_VECTOR_TYPES(FrameWrapper);
 
    AGX_DECLARE_POINTER_TYPES(Event);
    AGX_DECLARE_VECTOR_TYPES(Event);
 
  public:
    typedef Event1<Clock *> TickEvent;
    TickEvent preTick;
    TickEvent postTick;
 
  public:
    Clock(const agx::Name& name = "clock", agx::Real frequency = 60);
 
    void tick(bool blocking = true);
 
    void stepTo(agx::Real time);
 
    void stepForward(agx::Real delta);
 
    void setTime(agx::Real64 time);
 
    agx::Real getTime() const;
 
    agx::Bool isEnabled() const;
 
    void setEnable(agx::Bool flag);
 
    agx::Real getFrequency() const;
 
    void setFrequency(agx::Real frequency);
 
    agx::UInt getFrame() const;
 
    agx::Real getTimeStep() const;
 
    bool setTimeStep(agx::Real dt);
 
    agx::Real getTimeModulation() const;
 
    void setTimeModulation(agx::Real modulation);
 
    void addEvent(agx::Clock::Event *event);
 
    void removeEvent(agx::Clock::Event *event);
 
    void addFrameJob(agx::Job *job);
 
    void removeFrameJob(agx::Job *job);
 
    void addFrameTask(agx::Task *task);
 
    void removeFrameTask(agx::Task *task);
 
    void addSlave(agx::Clock *slave);
 
    void setFrame(UInt frame);
 
    void removeSlave(agx::Clock *slave);
 
    const agx::ClockPtrVector& getSlaves() const;
 
    agx::Clock *getReference();
 
 
    void reset();
 
    void bind(const agx::Path& path);
 
    const agx::Path& getBindPath() const;
 
    virtual void rebind() override;
 
    void setIsThreadTimelineResponsible(bool isResponsible);
 
    bool getIsThreadTimelineResponsible() const;
 
  protected:
    virtual ~Clock();
 
    // virtual bool bind(Object *object) override;
 
  private:
    void slaveTick();
    void rebuild( Real oldTimeStep );
    void schedule(Event *event);
    void schedule(Event *event, Real timeUntilDispatch);
    void unschedule(Event *event);
    void reschedule(Event *event);
 
    void enableCallback(agxData::Value *);
    void calculateTimestep();
 
  private:
    agxData::ValueRefT<Bool> m_enabled;
    agxData::ValueRefT<Real64> m_time;
    agxData::ValueRefT<Real> m_frequency;
    agxData::ValueRefT<Real> m_timeModulation;
    agxData::ValueRefT<Real> m_timeStep;
    agxData::ValueRefT<UInt> m_frame;
 
    agxData::Value::Event::CallbackType m_updateTimeStepCallback;
    agxData::Value::Event::CallbackType m_enableCallback;
 
    Path m_bindPath;
 
    ClockRef m_reference;
    ClockPtrVector m_slaves;
    EventRef m_syncEvent;
 
    class Frame;
    typedef HashTable<UInt, Frame> FrameTable;
    // typedef VectorPOD<Frame *> FramePtrVector;
    FrameTable m_frameTable;
    EventPtrVector m_events;
    // EventPtrVector m_tickEvents;
    TaskObserverVector m_frameTasks;
    JobPtrVector m_frameJobs;
    // Job m_framePostJob;
    FrameWrapperRef m_frameTaskWrapper;
    bool m_slaveTrigger;
    bool m_isTimelineResponsible = true;
  };
 
 
  class AGXCORE_EXPORT Clock::Event : public Component, public agx::Event
  {
  public:
    static agx::Model *ClassModel();
 
    static Clock::Event *load(TiXmlElement *eEvent, Device *device);
    virtual void configure(TiXmlElement *eEvent) override;
 
  public:
 
    Event(const agx::Name& name = "Event");
    Event(const agx::Callback& callback, agx::Real startDelay, agx::Real interval = -1.0);
 
    agx::Clock *getClock();
 
    void setStartDelay(agx::Real time);
 
 
    agx::Real getStartDelay() const;
 
    void setInterval(agx::Real interval);
 
 
    agx::Real getInterval() const;
 
    void setRepeating(bool flag);
 
    bool isRepeating() const;
 
    void setEnable(bool flag);
 
    void start();
 
    void stop();
 
    void reset();
 
    size_t getIndex() const;
 
  protected:
    virtual ~Event();
 
  private:
    Real calculateTimeUntilDispatch( Real timeStep );
    Real calculateTimeUntilDispatch();
    void valueCallback(agxData::Value *value);
 
    friend class Clock;
    void setIndex(size_t index);
    Event *m_next;
 
    size_t m_index;
    Clock *m_clock;
    agxData::ValueRefT<Real> m_startDelay;
    agxData::ValueRefT<Real> m_interval;
    agxData::ValueRefT<Bool> m_repeating;
    agxData::ValueRefT<Bool> m_enabled;
 
    // CallbackVector m_callbacks;
    Callback m_mainCallback;
    Real m_subInterval; // Accumulator
    UInt m_scheduledFrame;
    agxData::Value::Event::CallbackType m_valueCallback;
  };
 
 
 
  class Clock::Frame
  {
  public:
    Frame() {}
    Frame(UInt frameId) : id(frameId), eventList(nullptr) {}
    UInt id;
    Event *eventList;
    // Real m_time;
  };
 
 
  class Clock::FrameWrapper : public TaskGroup
  {
  public:
    FrameWrapper(Clock *clock);
    void addFrameTask(Task *child);
 
    void execute();
    Clock* getClock();
 
  protected:
    virtual ~FrameWrapper();
 
  private:
    Clock *m_clock;
    TaskRefVector m_children;
  };
 
 
  DOXYGEN_START_INTERNAL_BLOCK()
  /* Implementation */
  AGX_FORCE_INLINE Clock *Clock::getReference() { return m_reference; }
  AGX_FORCE_INLINE const ClockPtrVector& Clock::getSlaves() const { return m_slaves; }
 
  AGX_FORCE_INLINE bool Clock::isEnabled() const { return m_enabled->get(); }
  AGX_FORCE_INLINE Real Clock::getTime() const { return agx::Real(m_time->get()); }
  AGX_FORCE_INLINE Real Clock::getFrequency() const { return m_frequency->get(); }
  AGX_FORCE_INLINE Real Clock::getTimeModulation() const { return m_timeModulation->get(); }
  AGX_FORCE_INLINE Real Clock::getTimeStep() const { return m_timeStep->get(); }
  AGX_FORCE_INLINE UInt Clock::getFrame() const { return m_frame->get(); }
  AGX_FORCE_INLINE const Path& Clock::getBindPath() const { return m_bindPath; }
 
  AGX_FORCE_INLINE Real Clock::Event::getStartDelay() const { return m_startDelay->get(); }
  AGX_FORCE_INLINE Real Clock::Event::getInterval() const { return m_interval->get(); }
  AGX_FORCE_INLINE bool Clock::Event::isRepeating() const { return m_interval->get() >= 0; }
  AGX_FORCE_INLINE Clock *Clock::Event::getClock() { return m_clock; }
  AGX_FORCE_INLINE size_t Clock::Event::getIndex() const { return m_index; }
  DOXYGEN_END_INTERNAL_BLOCK()
 
  // AGX_FORCE_INLINE const CallbackVector& Clock::Event::getCallbacks() const { return m_callbacks; }
}
 
#endif /* _AGX_CLOCK_H_ */