class PipelineTemplate
{
-public:
- class Loader: public DataFile::CollectionObjectLoader<PipelineTemplate>
+private:
+ class PostProcLoader: virtual public DataFile::Loader
{
private:
template<typename T>
struct AddPostProc
{
- static void add(Loader &ldr, const std::string &kw) { ldr.add(kw, &Loader::postprocessor<T>); }
+ static void add(PostProcLoader &ldr, const std::string &kw) { ldr.add(kw, &PostProcLoader::postprocessor<T>); }
};
+ protected:
+ RefPtr<PostProcessor::Template> postproc;
+
+ public:
+ PostProcLoader();
+
+ PostProcessor::Template *get_postprocessor_template() { return postproc.release(); }
+
+ protected:
+ virtual void postprocessor_loaded() { }
+
+ private:
+ template<typename T>
+ void postprocessor();
+
+ friend class PipelineTemplate;
+ };
+
+public:
+ class Loader: public DataFile::CollectionObjectLoader<PipelineTemplate>, public PostProcLoader
+ {
public:
Loader(PipelineTemplate &);
Loader(PipelineTemplate &, Collection &);
private:
void init();
+ virtual void postprocessor_loaded();
void multisample(unsigned);
void multisample_range(unsigned, unsigned);
void pass(const std::string &, const std::string &);
-
- template<typename T>
- void postprocessor();
-
- friend class PipelineTemplate;
+ void postprocessor(const std::string &);
};
struct Pass
~Pass();
};
+ struct PostProcessor
+ {
+ GL::PostProcessor::Template *postprocessor_template;
+ std::string slot_name;
+
+ PostProcessor(GL::PostProcessor::Template * = 0);
+ };
+
typedef std::vector<Pass> PassArray;
- typedef std::vector<PostProcessor::Template *> PostProcessorArray;
+ typedef std::vector<PostProcessor> PostProcessorArray;
private:
- typedef DataFile::LoadableTypeRegistry<Loader, Loader::AddPostProc> PostProcessorRegistry;
+ typedef DataFile::LoadableTypeRegistry<PostProcLoader, PostProcLoader::AddPostProc> PostProcessorRegistry;
bool hdr;
+ bool alpha;
unsigned required_multisample;
unsigned max_multisample;
PassArray passes;
~PipelineTemplate();
bool get_hdr() const { return hdr; }
+ bool get_alpha() const { return alpha; }
unsigned get_required_multisample() const { return required_multisample; }
unsigned get_maximum_multisample() const { return max_multisample; }
const PassArray &get_passes() const { return passes; }
}
template<typename T>
-void PipelineTemplate::Loader::postprocessor()
+void PipelineTemplate::PostProcLoader::postprocessor()
{
- RefPtr<typename T::Template> postproc = new typename T::Template;
- load_sub(*postproc);
- obj.postprocessors.push_back(postproc.release());
+ 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();
}
} // namespace GL