Slide Transition Factory

example/src/magSlideShowSource.cpp

@@ -8,6 +8,7 @@
 #include "magSlideShowSource.h"
 #include "magSlideTransition.h"
 #include "SettingsLoader.h"
+#include "magSlideTransitionFactory.h"
 
 magSlideShowSource::magSlideShowSource()
 {
@@ -72,6 +73,10 @@ void magSlideShowSource::update()
 
 	for (auto &slide : activeSlides)
 	{
+		if (slide->activeTransition)
+		{
+			slide->activeTransition->update(deltaTime);
+		}
 		slide->update(deltaTime);
 	}
 
@@ -99,15 +104,23 @@ void magSlideShowSource::draw()
 {
 	ofBackground(0, 0);
 	ofPushMatrix();
+	ofPushStyle();
 	ofTranslate(getWidth()/2.0f, getHeight()/2.0f);
+	ofEnableAlphaBlending();
 	ofSetRectMode(OF_RECTMODE_CENTER);
+	ofFill();
+	ofSetColor(255, 255);
 	for (auto &slide : activeSlides)
 	{
-		ofSetColor(255);
-		ofFill();
+		if (slide->activeTransition)
+		{
+			slide->activeTransition->draw();
+		}
 		slide->draw();
 	}
+	ofPopStyle();
 	ofPopMatrix();
+	ofDisableAlphaBlending();
 }
 
 bool magSlideShowSource::createFromFolderContents(std::string path)
@@ -258,6 +271,8 @@ bool magSlideShowSource::loadFromXml()
 		settings.resizeOption = magSlide::FillProportionally;
 	}
 
+	settings.transitionName = "FadeIn";
+	settings.transitionDuration = 1.0;
 	initialize(settings);
 
 	return true;
@@ -324,11 +339,13 @@ void magSlideShowSource::addSlide(std::shared_ptr<magSlide> slide)
 	if (!settings.transitionName.empty())
 	{
 		static ofParameterGroup bogusParamGroup; // This is temporary so that things compile
-		slide->buildIn = magSlideTransition::createTransition(settings.transitionName,
+
+		auto tf = magSlideTransitionFactory::instance();
+		slide->buildIn = tf->createTransition(settings.transitionName,
 															  slide,
 															  bogusParamGroup,
 															  slide->buildInDuration);
-		slide->buildOut = magSlideTransition::createTransition(settings.transitionName,
+		slide->buildOut = tf->createTransition(settings.transitionName,
 															   slide,
 															   bogusParamGroup,
 															   slide->buildOutDuration);

example/src/magSlideTransition.cpp

@@ -6,17 +6,6 @@
 
 #include "magSlideTransition.h"
 
-std::shared_ptr<magSlideTransition>
-magSlideTransition::createTransition(std::string transitionName, std::shared_ptr<magSlide> slide,
-								  ofParameterGroup &settings, u_int64_t duration)
-{
-	auto transition = magSlideTransition::instantiateTransition(transitionName);
-	transition->slide = slide;
-	transition->duration = duration;
-	transition->loadSettings(settings);
-	return transition;
-}
-
 void magSlideTransition::start()
 {
 	runningTime = 0;
@@ -47,14 +36,8 @@ float magSlideTransition::getNormalizedTime()
 	return (double)runningTime / (double)duration;
 }
 
-std::shared_ptr<magSlideTransition> magSlideTransition::instantiateTransition(string transitionName)
+void magFadeInTransition::draw()
 {
-	return std::make_shared<magVoidTransition>();
-}
-
-//magDissolveTransition::magDissolveTransition()
-//{}
-void magVoidTransition::loadSettings(ofParameterGroup &settings)
-{
-	ofLogNotice("magVoidTransition") << "Void Transition is loading nothing";
-}
+	ofLogVerbose() << "fade in draw";
+	ofSetColor(255, getNormalizedTime() * 255);
+}

example/src/magSlideTransition.h

@@ -7,25 +7,24 @@
 #ifndef MAGSLIDETRANSITION_H
 #define MAGSLIDETRANSITION_H
 
-
 #include "magSlide.h"
 
+class magSlideTransitionFactory;
+
 class magSlideTransition
 {
 public:
-	static std::shared_ptr<magSlideTransition> createTransition(string transitionName,
-																shared_ptr<magSlide> ptr,
-																ofParameterGroup &group,
-																u_int64_t i);
+	magSlideTransition() {}
 	/**
 	 * Begins the transition. This must be called in order for the
 	 * transition to actually do anything!
 	 */
 	void start();
-	virtual void loadSettings(ofParameterGroup &settings) = 0;
-	virtual void setup(){}
+	virtual void loadSettings(ofParameterGroup &settings){}
 	virtual void update(u_int64_t timeDelta);
-	virtual void draw(){}
+	virtual void draw(){
+		ofLogVerbose() << "transiwiton draw " << getNormalizedTime();
+	}
 
 	/**
 	 * Current running time in milliseconds.
@@ -40,28 +39,35 @@ public:
 	 */
 	float getNormalizedTime();
 
+	string const &getName() const
+	{
+		return name;
+	}
+
 	ofEvent<ofEventArgs> transitionCompleteEvent;
 
 protected:
-	magSlideTransition(){}
+	std::string name = "Void";
 	std::shared_ptr<magSlide> slide;
 	u_int64_t runningTime;
 	u_int64_t duration;
 	u_int64_t endTime;
 	bool isActive = false;
-	static shared_ptr<magSlideTransition> instantiateTransition(string transitionName);
-};
 
-class magVoidTransition : public magSlideTransition
-{
-public:
-	void loadSettings(ofParameterGroup &settings) override;
+	friend class magSlideTransitionFactory;
 };
 
-class magDissolveTransition : public magSlideTransition
+class magFadeInTransition : public magSlideTransition
 {
 public:
+	magFadeInTransition()
+	{
+		name = "FadeIn";
+	}
 
+	void draw() override ;
 };
 
+
+
 #endif

example/src/magSlideTransitionFactory.cpp

@@ -0,0 +1,76 @@
+//
+// Created by Cristobal Mendoza on 12/3/17.
+//
+
+#include "magSlideTransitionFactory.h"
+
+/*
+ *
+ *
+ *
+class Base {};
+
+class DerivedA : public Base {};
+class DerivedB : public Base {};
+class DerivedC : public Base {};
+
+Base* create(const std::string& type)
+{
+    static std::map<std::string, std::function<Base*()>> type_creator_map =
+    {
+        {"DerivedA", [](){return new DerivedA();}},
+        {"DerivedB", [](){return new DerivedB();}},
+        {"DerivedC", [](){return new DerivedC();}}
+    };
+
+    auto it = type_creator_map.find(type);
+    if(it != type_creator_map.end())
+    {
+        return it->second();
+    }
+
+    return nullptr;
+}
+ */
+
+magSlideTransitionFactory* magSlideTransitionFactory::_instance = 0;
+
+magSlideTransitionFactory::magSlideTransitionFactory()
+{
+	magSlideTransition voidTransition;
+	magFadeInTransition fadeIn;
+
+	registerTransition<magSlideTransition>(voidTransition);
+	registerTransition<magFadeInTransition>(fadeIn);
+}
+
+magSlideTransitionFactory* magSlideTransitionFactory::instance()
+{
+	if (_instance == 0)
+	{
+		_instance = new magSlideTransitionFactory();
+	}
+
+	return _instance;
+}
+
+std::shared_ptr<magSlideTransition>
+magSlideTransitionFactory::createTransition(std::string transitionName, std::shared_ptr<magSlide> slide,
+											ofParameterGroup &settings, u_int64_t duration)
+{
+	std::shared_ptr<magSlideTransition> transition;
+
+	if (transitionsMap.count(transitionName) > 0)
+	{
+		transition = transitionsMap[transitionName]();
+	}
+	else
+	{
+		transition = transitionsMap[transition->getName()]();
+	}
+
+	transition->slide = slide;
+	transition->duration = duration;
+	transition->loadSettings(settings);
+	return transition;
+}

example/src/magSlideTransitionFactory.h

@@ -0,0 +1,41 @@
+//
+// Created by Cristobal Mendoza on 12/3/17.
+//
+
+#ifndef MAGSLIDETRANSITIONFACTORY_H
+#define MAGSLIDETRANSITIONFACTORY_H
+
+#include "magSlide.h"
+#include "magSlideTransition.h"
+
+/**
+ * Factory class to register and instantiate transitions.
+ */
+class magSlideTransitionFactory
+{
+public:
+	static magSlideTransitionFactory* instance();
+
+	std::shared_ptr<magSlideTransition> createTransition(string transitionName,
+														 std::shared_ptr<magSlide> slide,
+														 ofParameterGroup &group,
+														 u_int64_t duration);
+	template<typename T>
+	void registerTransition(T transition)
+	{
+		if (transitionsMap.count(transition.getName()) == 0)
+		{
+			transitionsMap[transition.getName()] = [](){
+				return std::make_shared<T>();
+			};
+		}
+	}
+
+protected:
+	std::unordered_map<std::string, std::function<std::shared_ptr<magSlideTransition>()>> transitionsMap;
+private:
+	static magSlideTransitionFactory* _instance;
+	magSlideTransitionFactory();
+};
+
+#endif //MAGSLIDETRANSITIONFACTORY_H