Access builtin resources through a global instance

[libs/gl.git] / source / materials / renderpass.h

diff --git a/source/materials/renderpass.h b/source/materials/renderpass.h
index e01b872daf56c2a0af7ec8a1e2d8bcfae7d017d4..91ff1b6c77f0e54590e4802981f80b16b7400e6a 100644 (file)
--- a/source/materials/renderpass.h
+++ b/source/materials/renderpass.h
@@ -3,11 +3,11 @@
 
 #include <msp/core/refptr.h>
 #include <msp/datafile/objectloader.h>
+#include "material.h"
 
 namespace Msp {
 namespace GL {
 
-class Material;
 class Program;
 class ProgramData;
 class Renderer;
@@ -24,20 +24,24 @@ class RenderPass
 public:
        class Loader: public DataFile::CollectionObjectLoader<RenderPass>
        {
+       private:
+               static ActionMap shared_actions;
+
        public:
                Loader(RenderPass &);
                Loader(RenderPass &, Collection &);
 
        private:
-               void init();
+               virtual void init_actions();
+               virtual void finish();
 
                static std::string get_shader_name(const std::string &);
 
                void material_inline();
                void material(const std::string &);
                void shader(const std::string &);
+               void texture(const std::string &);
                void texunit(unsigned);
-               void texunit_auto(const std::string &);
                void texunit_named(unsigned, const std::string &);
                void uniforms();
                void uniform_slot(const std::string &);
@@ -45,58 +49,66 @@ public:
        };
 
 private:
-       struct TextureLoader: public DataFile::CollectionObjectLoader<Texturing>
+       struct TextureSlot
        {
-       private:
-               unsigned index;
-               const Texture *tex;
-               const Sampler *samp;
+               class Loader: public DataFile::CollectionObjectLoader<TextureSlot>
+               {
+               private:
+                       std::string auto_slot_name;
 
-       public:
-               TextureLoader(Texturing &, unsigned, Collection *);
-       private:
-               virtual void finish();
+               public:
+                       Loader(TextureSlot &, const std::string &, Collection *);
 
-               void sampler(const std::string &);
-               void texture(const std::string &);
+               private:
+                       void slot_auto();
+               };
+
+               Tag tag;
+               std::string slot_name;
+               const Texture *texture;
+               const Sampler *sampler;
+
+               TextureSlot(Tag t): tag(t), texture(0), sampler(0) { }
        };
 
        RefPtr<const Program> shprog;
        bool shprog_from_material;
        RefPtr<ProgramData> shdata;
-       std::map<std::string, std::string> uniform_slots;
+       std::map<Tag, Tag> uniform_slots;
        RefPtr<const Material> material;
        std::string material_slot;
-       Texturing *texturing;
-       std::map<std::string, unsigned> tex_names;
+       std::vector<TextureSlot> textures;
        bool back_faces;
+       bool receive_shadows;
 
 public:
        RenderPass();
-       RenderPass(const RenderPass &);
-       RenderPass &operator=(const RenderPass &);
-       ~RenderPass();
 
 private:
-       void finalize_material(DataFile::Collection *);
-       void maybe_create_material_shader(DataFile::Collection *);
-       void ensure_private_shader_data();
+       void maybe_create_material_shader();
+       void set_material_textures();
 
 public:
        void set_shader_program(const Program *, const ProgramData *);
        const Program *get_shader_program() const { return shprog.get(); }
        const ProgramData *get_shader_data() const { return shdata.get(); }
-       const std::string &get_slotted_uniform_name(const std::string &) const;
+       Tag get_slotted_uniform_tag(Tag) const;
        void set_material(const Material *);
        const Material *get_material() const { return material.get(); }
        const std::string &get_material_slot_name() const { return material_slot; }
-       void set_texture(unsigned, const Texture *);
-       const Texturing *get_texturing() const { return texturing; }
-       int get_texture_index(const std::string &) const;
+       void set_texture(Tag, const Texture *, const Sampler * = 0);
+       Tag get_texture_tag(const std::string &) const;
+       DEPRECATED void set_texture(unsigned, const Texture *, const Sampler * = 0);
+       DEPRECATED const Texturing *get_texturing() const { return 0; }
+       DEPRECATED int get_texture_index(const std::string &) const;
        void set_back_faces(bool);
        bool get_back_faces() const { return back_faces; }
+       void set_receive_shadows(bool);
+       bool get_receive_shadows() const { return receive_shadows; }
 
        void apply(Renderer &) const;
+
+       void set_debug_name(const std::string &);
 };
 
 } // namespace GL