GEEKING

App/include/v8datamodel/AnimationTrackState.h

@@ -0,0 +1,99 @@
+/* Copyright 2003-2007 ROBLOX Corporation, All Rights Reserved */
+#pragma once
+
+#include "V8Tree/Instance.h"
+#include "Util/ContentId.h"
+#include "V8DataModel/KeyframeSequence.h"
+
+namespace RBX {
+	extern const char *const sAnimationTrackState;
+
+	class KeyframeSequence;
+	class Animator;
+	class AnimationTrack;
+	struct PoseAccumulator;
+
+	class AnimationTrackState
+		: public DescribedNonCreatable<AnimationTrackState, Instance, sAnimationTrackState>
+	{
+	protected:
+		//Either set directly for solo/debugging or replicated by the AssetId
+		shared_ptr<const KeyframeSequence> keyframeSequence;
+
+		shared_ptr<AnimationTrack> animationTrack;
+
+		int preKeyframe;
+		
+		//Keep a weak ptr to our parent
+		weak_ptr<const Animator> animator;
+
+		double startTime; // reset by the "play" function.
+		double speed;
+		double phase; // speed-independent adjustment to keyframetime.
+		double fadeStartTime;
+		double fadeStartWeight;
+		double fadeEndTime;
+		double fadeEndWeight;
+
+		bool isPlaying;
+
+		double getGameTime(); // helper
+
+		void onPlay(float gameTime, float fadeTime, float weight, float speed);
+		void onStop(float gameTime, float fadeTime);
+		void onAdjustWeight(float gameTime, float weight, float fadeTime);
+		void onAdjustSpeed(float gameTime, float speed);
+
+		bool inReverse();
+		void detectKeyframeReached(double animationTime, double lastAnimationTime);
+
+		KeyframeSequence::Priority priority;
+		bool priorityOverridden;
+
+		// helper for step()
+		void triggerKeyframeReachedSignal(const shared_ptr<Instance>& child, double minKeyframeTime, double maxKeyframeTime);
+	protected:
+		double lastKeyframeTime; // keep track of last played frame for keyframe events.
+	public:
+		AnimationTrackState(shared_ptr<const KeyframeSequence> keyframeSequence, weak_ptr<const Animator> animator);
+		~AnimationTrackState() {}
+		void play(float fadeTime, float weight, float speed);
+		void stop(float fadeTime);
+		void adjustWeight(float weight, float fadeTime);
+		void adjustSpeed(float speed);
+
+		//Should be private
+		rbx::remote_signal<void(float,float,float, float)> internalPlaySignal;
+		rbx::remote_signal<void(float,float)>		internalStopSignal;
+		rbx::remote_signal<void(float,float,float)>	internalAdjustWeightSignal;
+		rbx::remote_signal<void(float,float)>		internalAdjustSpeedSignal;
+		rbx::remote_signal<void(std::string)>		keyframeReachedSignal;
+		rbx::remote_signal<void()>					stoppedSignal;
+
+		const KeyframeSequence* getKeyframeSequence() const { return keyframeSequence.get(); };
+		void setKeyframeSequence(shared_ptr<KeyframeSequence>);
+
+		double getWeightAtTime(double time);
+		double getKeyframeAtTime(double time);
+		void setKeyframeAtTime(double gameTime, double keyframeTime); // adjust phase to get animation on a specific keyframe.
+
+		double getSpeed() { return speed; }
+		float getDuration();
+
+		bool isStopped(double time);
+		bool getIsPlaying() const { return isPlaying; };
+
+		double getDurationClampedKeyframeTime(double keyframeTime);
+
+		KeyframeSequence::Priority getPriority() const;
+		void setPriority(KeyframeSequence::Priority priority);
+
+		void resetKeyframeReachedDetection(double keyframeTime);
+
+		void step(std::vector<PoseAccumulator>& jointposes, double time);
+
+		void setAnimationTrack(shared_ptr<AnimationTrack> animationTrackIn);
+		shared_ptr<AnimationTrack> getAnimationTrack() const { return animationTrack; };
+	};
+
+} // namespace