X-Git-Url: http://git.tdb.fi/?p=libs%2Fgl.git;a=blobdiff_plain;f=source%2Fbuilders%2Fsequencetemplate.h;h=5c13aebebc2263677447e93e33ab96de25883cf0;hp=acc852d4fa0ef0113e4a79a6ab6f46ffbead7087;hb=083a8227715fa32c841fc2b8126e4ab8d2840ba0;hpb=215b633d194920cc697d68cfec201c680210b73c

diff --git a/source/builders/sequencetemplate.h b/source/builders/sequencetemplate.h
index acc852d4..5c13aebe 100644
--- a/source/builders/sequencetemplate.h
+++ b/source/builders/sequencetemplate.h
@@ -4,8 +4,10 @@
 #include <string>
 #include <vector>
 #include <msp/core/typeregistry.h>
+#include <msp/datafile/dynamicobjectloader.h>
 #include <msp/datafile/objectloader.h>
 #include "depthtest.h"
+#include "effect.h"
 #include "postprocessor.h"
 #include "resources.h"
 #include "stenciltest.h"
@@ -19,47 +21,51 @@ class Renderable;
 class SequenceTemplate
 {
 private:
-	class PostProcLoader: virtual public DataFile::Loader
+	template<typename T>
+	class TemplateLoader: public DataFile::DynamicObjectLoader<typename T::Template>
 	{
-	private:
-		template<typename T>
-		struct AddPostProc
-		{
-			void operator()(const std::string &kw, PostProcLoader &ldr) const { ldr.add(kw, &PostProcLoader::postprocessor<T>); }
-		};
-
-	protected:
-		RefPtr<PostProcessor::Template> postproc;
+		friend class SequenceTemplate;
 
 	public:
-		PostProcLoader();
-
-		PostProcessor::Template *get_postprocessor_template() { return postproc.release(); }
-
-	protected:
-		virtual void postprocessor_loaded() { }
+		TemplateLoader(typename DataFile::DynamicObjectLoader<typename T::Template>::Collection &c): DataFile::DynamicObjectLoader<typename T::Template>(&c) { }
 
 	private:
-		template<typename T>
-		void postprocessor();
-
-		friend class SequenceTemplate;
+		virtual typename DataFile::DynamicObjectLoader<typename T::Template>::TypeRegistry &get_type_registry() const { return get_registry<T>(); }
 	};
 
+	template<typename T>
+	using TemplateRegistry = typename TemplateLoader<T>::TypeRegistry;
+
 public:
-	class Loader: public DataFile::CollectionObjectLoader<SequenceTemplate, Resources>, public PostProcLoader
+	class Loader: public DataFile::CollectionObjectLoader<SequenceTemplate>
 	{
+	private:
+		static ActionMap shared_actions;
+
 	public:
 		Loader(SequenceTemplate &, Collection &);
-
 	private:
-		virtual void postprocessor_loaded();
+		virtual void init_actions();
+
 		void clear();
+		void effect(const std::string &);
 		void multisample(unsigned);
 		void multisample_range(unsigned, unsigned);
-		void postprocessor(const std::string &);
-		void step(const std::string &);
-		void step_with_slot(const std::string &, const std::string &);
+		void postprocessor();
+		void postprocessor_with_slot(const std::string &);
+		void renderable(const std::string &);
+		void renderable_with_default(const std::string &, const std::string &);
+		void sequence(const std::string &, const std::string &);
+		void step(const std::string &, const std::string &);
+	};
+
+	struct Renderable
+	{
+		Effect::Template *effect_template = 0;
+		GL::Renderable *renderable = 0;
+		SequenceTemplate *sequence_template = 0;
+		std::map<std::string, std::string> sequence_renderables;
+		std::string slot_name;
 	};
 
 	struct Step
@@ -69,9 +75,14 @@ public:
 		private:
 			std::string inline_base_name;
 
+			static ActionMap shared_actions;
+
 		public:
 			Loader(Step &, Collection &);
+		private:
+			virtual void init_actions();
 
+		public:
 			void set_inline_base_name(const std::string &);
 
 		private:
@@ -79,8 +90,6 @@ public:
 			void depth_compare(Predicate);
 			void lighting(const std::string &);
 			void lighting_inline();
-			void object(const std::string &);
-			void scene(const std::string &);
 			void stencil_test();
 		};
 
@@ -88,8 +97,7 @@ public:
 		const Lighting *lighting = 0;
 		DepthTest depth_test;
 		StencilTest stencil_test;
-		std::string slot_name;
-		Renderable *default_renderable = 0;
+		std::string renderable_name;
 	};
 
 	struct PostProcessor
@@ -103,21 +111,37 @@ public:
 private:
 	class ClearLoader: public DataFile::ObjectLoader<SequenceTemplate>
 	{
+	private:
+		static ActionMap shared_actions;
+
 	public:
 		ClearLoader(SequenceTemplate &);
-
 	private:
+		virtual void init_actions();
+
 		void color(float, float, float, float);
 		void depth(float);
 		void stencil(int);
 	};
 
-	typedef TypeRegistry<PostProcLoader::AddPostProc, PostProcLoader &> PostProcessorRegistry;
+	class SequenceLoader: public DataFile::ObjectLoader<Renderable>
+	{
+	private:
+		static ActionMap shared_actions;
+
+	public:
+		SequenceLoader(Renderable &);
+	private:
+		virtual void init_actions();
+
+		void renderable(const std::string &, const std::string &);
+	};
 
 	bool hdr = false;
 	bool alpha = false;
 	unsigned required_multisample = 0;
 	unsigned max_multisample = 0;
+	std::vector<Renderable> renderables;
 	std::vector<Step> steps;
 	std::vector<PostProcessor> postprocessors;
 	bool clear_enabled = false;
@@ -132,6 +156,7 @@ public:
 	bool get_alpha() const { return alpha; }
 	unsigned get_required_multisample() const { return required_multisample; }
 	unsigned get_maximum_multisample() const { return max_multisample; }
+	const std::vector<Renderable> &get_renderables() const { return renderables; }
 	const std::vector<Step> &get_steps() const { return steps; }
 	const std::vector<PostProcessor> &get_postprocessors() const { return postprocessors; }
 	bool is_clear_enabled() const { return clear_enabled; }
@@ -139,28 +164,27 @@ public:
 	float get_clear_depth() const { return clear_depth; }
 	int get_clear_stencil() const { return clear_stencil; }
 
+	template<typename T>
+	static void register_effect(const std::string &);
+
 	template<typename T>
 	static void register_postprocessor(const std::string &);
+
 private:
-	static PostProcessorRegistry &get_postprocessor_registry();
+	template<typename T>
+	static TemplateRegistry<T> &get_registry();
 };
 
 template<typename T>
-void SequenceTemplate::register_postprocessor(const std::string &kw)
+void SequenceTemplate::register_effect(const std::string &kw)
 {
-	get_postprocessor_registry().register_type<T>(kw);
+	get_registry<Effect>().register_type<typename T::Template>(kw);
 }
 
 template<typename T>
-void SequenceTemplate::PostProcLoader::postprocessor()
+void SequenceTemplate::register_postprocessor(const std::string &kw)
 {
-	if(postproc)
-		throw std::logic_error("Only one postprocessor allowed per slot");
-	RefPtr<typename T::Template> pp = new typename T::Template;
-	load_sub(*pp);
-	postproc = pp;
-	pp = 0;
-	postprocessor_loaded();
+	get_registry<GL::PostProcessor>().register_type<typename T::Template>(kw);
 }
 
 } // namespace GL