#include <vector>
#include <msp/core/typeregistry.h>
#include <msp/datafile/objectloader.h>
-#include "blend.h"
+#include "depthtest.h"
#include "postprocessor.h"
-#include "predicate.h"
+#include "resources.h"
+#include "stenciltest.h"
namespace Msp {
namespace GL {
-class DepthTest;
class Lighting;
class Renderable;
Loader(SequenceTemplate &, Collection &);
virtual void postprocessor_loaded();
+ void clear();
void multisample(unsigned);
void multisample_range(unsigned, unsigned);
void postprocessor(const std::string &);
{
class Loader: public DataFile::CollectionObjectLoader<Step>
{
+ private:
+ std::string inline_base_name;
+
public:
- Loader(Step &);
Loader(Step &, Collection &);
- private:
- void init();
- void blend(BlendFactor, BlendFactor);
- void blend_predefined(const std::string &);
- void depth_test(Predicate);
- void depth_test_predefined(const std::string &);
+ void set_inline_base_name(const std::string &);
+
+ private:
+ void depth_test();
+ 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();
};
std::string tag;
- RefPtr<Lighting> lighting;
- RefPtr<const DepthTest> depth_test;
- RefPtr<const Blend> blend;
+ const Lighting *lighting = 0;
+ DepthTest depth_test;
+ StencilTest stencil_test;
std::string slot_name;
- Renderable *default_renderable;
-
- ~Step();
+ Renderable *default_renderable = 0;
};
struct PostProcessor
PostProcessor(GL::PostProcessor::Template * = 0);
};
- typedef std::vector<PostProcessor> PostProcessorArray;
-
private:
+ class ClearLoader: public DataFile::ObjectLoader<SequenceTemplate>
+ {
+ public:
+ ClearLoader(SequenceTemplate &);
+
+ private:
+ void color(float, float, float, float);
+ void depth(float);
+ void stencil(int);
+ };
+
typedef TypeRegistry<PostProcLoader::AddPostProc, PostProcLoader &> PostProcessorRegistry;
- Resources *resources;
- bool hdr;
- bool alpha;
- unsigned required_multisample;
- unsigned max_multisample;
+ bool hdr = false;
+ bool alpha = false;
+ unsigned required_multisample = 0;
+ unsigned max_multisample = 0;
std::vector<Step> steps;
- PostProcessorArray postprocessors;
+ std::vector<PostProcessor> postprocessors;
+ bool clear_enabled = false;
+ std::vector<Color> clear_colors;
+ float clear_depth = 1.0f;
+ int clear_stencil = 0;
public:
- SequenceTemplate();
~SequenceTemplate();
- Resources &get_resources() const;
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 std::vector<Step> &get_steps() const { return steps; }
- const PostProcessorArray &get_postprocessors() const { return postprocessors; }
+ const std::vector<PostProcessor> &get_postprocessors() const { return postprocessors; }
+ bool is_clear_enabled() const { return clear_enabled; }
+ const std::vector<Color> &get_clear_colors() const { return clear_colors; }
+ float get_clear_depth() const { return clear_depth; }
+ int get_clear_stencil() const { return clear_stencil; }
template<typename T>
static void register_postprocessor(const std::string &);