abstracted and extended animation controls to the mask data class

Author: granolaboy

mask-resource-animation.h

@@ -64,6 +64,20 @@ namespace Mask {
 			virtual void SetAnimatableValue(float v, AnimationChannelType act) = 0;
 		};
 
+		class IAnimationControls {
+		public:
+			virtual void	Play() = 0;
+			virtual void	PlayBackwards() = 0;
+			virtual void	Stop() = 0;
+			virtual void	Rewind(bool last = false) = 0;
+			virtual float	GetDuration() = 0;
+			virtual float	LastFrame() = 0;
+			virtual float	GetFPS() = 0;
+			virtual float	GetPlaybackSpeed() = 0;
+			virtual void	SetPlaybackSpeed(float speed) = 0;
+			virtual void    Seek(float time) = 0;
+		};
+
 		struct AnimationInstanceData : public InstanceData {
 			float	elapsed;
 			AnimationInstanceData() : elapsed(0.0f) {}
@@ -72,16 +86,16 @@ namespace Mask {
 
 		struct AnimationChannel {
 			std::shared_ptr<IAnimatable>	item;
-			AnimationChannelType		type;
-			AnimationBehaviour			preState;
-			AnimationBehaviour			postState;
-			std::vector<float>			values;
+			AnimationChannelType			type;
+			AnimationBehaviour				preState;
+			AnimationBehaviour				postState;
+			std::vector<float>				values;
 
 			float	GetValue(int frame);
 		};
 
 
-		class Animation : public IBase {
+		class Animation : public IBase, IAnimationControls {
 		public:
 			Animation(Mask::MaskData* parent, std::string name, obs_data_t* data);
 			virtual ~Animation();
@@ -90,16 +104,16 @@ namespace Mask {
 			virtual void Update(Mask::Part* part, float time) override;
 			virtual void Render(Mask::Part* part) override;
 
-			void	Play() { m_speed = 1.0f; }
-			void	PlayBackwards() { m_speed = -1.0f; }
-			void	Stop() { m_speed = 0.0f; }
-			void	Rewind(bool last = false) { last ? Seek(LastFrame()) : Seek(0); }
-			float	GetDuration() { return m_duration; }
-			float	LastFrame() { return m_duration - (1.0f / m_fps); }
-			float	GetFPS() { return m_fps; }
-			float	GetPlaybackSpeed() { return m_speed; }
-			void	SetPlaybackSpeed(float speed) { m_speed = speed; }
-			void    Seek(float time);
+			void	Play() override { m_speed = 1.0f; }
+			void	PlayBackwards() override { m_speed = -1.0f; }
+			void	Stop() override { m_speed = 0.0f; }
+			void	Rewind(bool last = false) override { last ? Seek(LastFrame()) : Seek(0); }
+			float	GetDuration() override { return m_duration; }
+			float	LastFrame() override { return m_duration - (1.0f / m_fps); }
+			float	GetFPS() override { return m_fps; }
+			float	GetPlaybackSpeed() override { return m_speed; }
+			void	SetPlaybackSpeed(float speed) override { m_speed = speed; }
+			void    Seek(float time) override;
 
 		protected:
 			float							m_speed;

mask.cpp

@@ -468,12 +468,14 @@ void  Mask::MaskData::PartCalcMatrix(std::shared_ptr<Mask::Part> _part) {
 
 void Mask::MaskData::Tick(float time) {
 	// update animations with the first Part
+	Part* p = nullptr;
 	for (auto aakv : m_animations) {
 		if (aakv.second) {
-			Part* p = nullptr;
-			for (auto kv : m_parts) {
-				p = kv.second.get();
-				break;
+			if (!p) {
+				for (auto kv : m_parts) {
+					p = kv.second.get();
+					break;
+				}
 			}
 			aakv.second->Update(p, time);
 		}
@@ -637,6 +639,101 @@ std::shared_ptr<Mask::Part> Mask::MaskData::LoadPart(std::string name, obs_data_
 	return current;
 }
 
+
+void	Mask::MaskData::Play() {
+	for (auto aakv : m_animations) {
+		if (aakv.second) {
+			aakv.second->Play();
+		}
+	}
+}
+
+void	Mask::MaskData::PlayBackwards() {
+	for (auto aakv : m_animations) {
+		if (aakv.second) {
+			aakv.second->PlayBackwards();
+		}
+	}
+}
+
+void	Mask::MaskData::Stop() {
+	for (auto aakv : m_animations) {
+		if (aakv.second) {
+			aakv.second->Stop();
+		}
+	}
+}
+
+void	Mask::MaskData::Rewind(bool last) {
+	for (auto aakv : m_animations) {
+		if (aakv.second) {
+			aakv.second->Rewind(last);
+		}
+	}
+}
+
+float	Mask::MaskData::GetDuration() {
+	// find max
+	float d = 0.0f;
+	for (auto aakv : m_animations) {
+		if (aakv.second) {
+			if (d < aakv.second->GetDuration())
+				d = aakv.second->GetDuration();
+		}
+	}
+	return d;
+}
+
+float	Mask::MaskData::LastFrame() {
+	// find max
+	float f = 0.0f;
+	for (auto aakv : m_animations) {
+		if (aakv.second) {
+			if (f < aakv.second->LastFrame())
+				f = aakv.second->LastFrame();
+		}
+	}
+	return f;
+}
+
+float	Mask::MaskData::GetFPS() {
+	// just grab first
+	for (auto aakv : m_animations) {
+		if (aakv.second) {
+			return aakv.second->GetFPS();
+		}
+	}
+	return 0.0f;
+}
+
+float	Mask::MaskData::GetPlaybackSpeed() {
+	// just grab first
+	for (auto aakv : m_animations) {
+		if (aakv.second) {
+			return aakv.second->GetPlaybackSpeed();
+		}
+	}
+	return 0.0f;
+}
+
+void	Mask::MaskData::SetPlaybackSpeed(float speed) {
+	for (auto aakv : m_animations) {
+		if (aakv.second) {
+			aakv.second->SetPlaybackSpeed(speed);
+		}
+	}
+}
+
+void   Mask::MaskData::Seek(float time) {
+	for (auto aakv : m_animations) {
+		if (aakv.second) {
+			aakv.second->Seek(time);
+		}
+	}
+}
+
+
+
 Mask::Resource::Morph* Mask::MaskData::GetMorph() {
 	// cache the morph pointer so we dont constantly search for it
 	if (m_morph == nullptr) {

mask.h

@@ -86,7 +86,7 @@ namespace Mask {
 		class Animation;
 	}
 
-	class MaskData {
+	class MaskData : public Resource::IAnimationControls {
 	public:
 		MaskData();
 		virtual ~MaskData();
@@ -114,6 +114,18 @@ namespace Mask {
 		void Tick(float time);
 		void Render(bool depthOnly = false);
 
+		// IAnimationControls
+		void	Play() override;
+		void	PlayBackwards() override;
+		void	Stop() override;
+		void	Rewind(bool last = false) override;
+		float	GetDuration() override;
+		float	LastFrame() override;
+		float	GetFPS() override;
+		float	GetPlaybackSpeed() override;
+		void	SetPlaybackSpeed(float speed) override;
+		void    Seek(float time) override;
+
 		// sorted draw objects
 		void ClearSortedDrawObjects();
 		void AddSortedDrawObject(SortedDrawObject* obj);