Changeset 232

Timestamp:

05/08/14 17:28:37 (11 years ago)

Author:

epyon

Message:

• automatic link-time and draw-time uniforms added

Location:

trunk

Files:

• nv/interface/camera.hh (modified) (1 diff)
• nv/interface/context.hh (modified) (3 diffs)
• nv/interface/program.hh (modified) (8 diffs)
• nv/interface/uniform.hh (added)
• src/gl/gl_program.cc (modified) (1 diff)

trunk/nv/interface/camera.hh

@@ -41 +41 @@
                 }
         private:
+                bool m_dirty;
                 mat4 m_projection;
                 mat4 m_view;
         };
+
+        // TODO - this and camera should have dirty states
+        class scene_state
+        {
+        public:
+                const camera& get_camera() const   { return m_camera; }
+                camera& get_camera()               { return m_camera; }
+                void set_camera( const camera& c ) { m_camera = c; }
+                void set_model( const mat4& m )    { m_model  = m; } 
+
+                const mat4& get_model()      const { return m_model; }
+                const mat4& get_view()       const { return m_camera.get_view(); }
+                const mat4& get_projection() const { return m_camera.get_projection(); }
+                mat4 get_modelview()  const { return get_view() * m_model; }
+                mat4 get_mvp()        const { return m_camera.get_projection() * get_modelview(); }
+
+                mat4 get_view_inv()   const { return glm::inverse( get_view() ); }
+                mat3 get_normal()     const { return glm::transpose(glm::inverse(glm::mat3( get_modelview() ) ) ); }
+        protected:
+                mat4   m_model;
+                camera m_camera; 
+        };
+
+
 }
 

trunk/nv/interface/context.hh

@@ -14 +14 @@
 
 #include <nv/common.hh>
+#include <nv/interface/camera.hh>
 #include <nv/interface/program.hh>
 #include <nv/interface/vertex_buffer.hh>
@@ -51 +52 @@
         {
         public:
-                context( device* a_device ) { m_device = a_device; }
+                context( device* a_device )     
+                { 
+                        // TODO: this will pose a problem in case of multiple contexts
+                        program::initialize_engine_uniforms();
+                        m_device = a_device; 
+                }
                 virtual void clear( const clear_state& cs ) = 0;
                 // temporary
                 virtual void draw( primitive prim, const render_state& rs, program* p, vertex_array* va, size_t count ) = 0;
+
                 virtual void draw( const render_state& rs, program* p, mesh_interface* mesh )
                 {
                         draw( mesh->get_primitive_type(), rs, p, mesh->get_vertex_array(), mesh->get_index_count() );
+                }
+                virtual void draw( const render_state& rs, const scene_state& s, program* p, mesh_interface* mesh )
+                {
+                        p->apply_engine_uniforms( this, &s );
+                        draw( rs, p, mesh );
+                }
+                virtual void draw( primitive prim, const render_state& rs, const scene_state& s, program* p, vertex_array* va, size_t count )
+                {
+                        p->apply_engine_uniforms( this, &s );
+                        draw( prim, rs, p, va, count );
                 }
 
@@ -64 +81 @@
                 virtual void set_viewport( const ivec4& viewport ) = 0;
                 virtual device* get_device() { return m_device; }
-                virtual ~context() {}
+                virtual ~context() 
+                {
+                        // TODO: this will pose a problem in case of multiple contexts
+                        program::destroy_engine_uniforms();
+                }
         protected:
                 device*      m_device;

trunk/nv/interface/program.hh

@@ -1 @@
-// Copyright (C) 2012-2013 ChaosForge / Kornel Kisielewicz
+// Copyright (C) 2012-2014 ChaosForge / Kornel Kisielewicz
 // http://chaosforge.org/
 //
@@ -14 +14 @@
 
 #include <unordered_map>
+#include <nv/interface/uniform.hh>
 #include <nv/logging.hh>
 #include <nv/exception.hh>
@@ -22 +23 @@
 namespace nv
 {
+        class camera;
+
         enum slot
         {
@@ -30 +33 @@
                 TANGENT  = 4,
         };
+
+        enum texture_slot
+        {
+                TEX_DIFFUSE  = 0,
+                TEX_SPECULAR = 1,
+                TEX_NORMAL   = 2,
+                TEXTURE_0    = 0,
+                TEXTURE_1    = 1,
+                TEXTURE_2    = 2,
+                TEXTURE_3    = 3,
+                TEXTURE_4    = 4,
+                TEXTURE_5    = 5,
+                TEXTURE_6    = 6,
+                TEXTURE_7    = 7,
+        };
+
 
         class attribute
@@ -48 +67 @@
         };
 
-        class uniform_base
-        {
-        public: 
-                uniform_base( const string& name, datatype type, int location, int length ) 
-                        : m_name( name ), m_type( type ), m_location(location), m_length( length ), m_dirty( true ) {}
-                datatype get_type() const { return m_type; }
-                int get_location() const { return m_location; }
-                int get_length() const { return m_length; }
-                bool is_dirty() const { return m_dirty; }
-                void clean() { m_dirty = false; }
-        protected:
-                string   m_name;
-                datatype m_type;
-                int      m_location;
-                int      m_length;
-                bool     m_dirty;
-        };
-
-        template< typename T >
-        class uniform : public uniform_base
-        {
-        public:
-                typedef T value_type;
-
-                uniform( const string& name, int location, int length ) 
-                        : uniform_base( name, type_to_enum< T >::type, location, length ), m_value()
-                {}
-
-                void set_value( const T& value ) 
-                { 
-                        if ( value != m_value )
-                        {
-                                m_value = value; 
-                                m_dirty = true;
-                        }
-                }
-
-                const T& get_value() { return m_value; }
-        protected:
-                T m_value;
-        };
-
-        typedef std::unordered_map< string, uniform_base* > uniform_map;
         typedef std::unordered_map< string, attribute* >    attribute_map;
 
@@ -102 +78 @@
                 virtual ~program()
                 {
-                        for ( attribute_map::iterator i = m_attribute_map.begin(); 
-                                i != m_attribute_map.end(); ++i ) delete i->second;
-                        for ( uniform_map::iterator i = m_uniform_map.begin(); 
-                                        i != m_uniform_map.end(); ++i ) delete i->second;
+                        for ( auto& i : m_attribute_map )   delete i.second;
+                        for ( auto& i : m_uniform_map )     delete i.second;
                 }
 
@@ -181 +155 @@
                         }
                 }
+
+                void apply_engine_uniforms( const context* ctx, const scene_state* s )
+                {
+                        for ( auto u : m_engine_uniforms )
+                        {
+                                u->set( ctx, s );
+                        }
+                }
+
+                void apply_link_engine_uniforms()
+                {
+                        engine_link_uniform_factory_map& factory_map = get_link_uniform_factory();
+                        for ( auto& i : m_uniform_map )
+                        {
+                                auto j = factory_map.find( i.first );
+                                if ( j != factory_map.end() )
+                                {
+                                        j->second->set( i.second );
+                                }                               
+                        }
+                }
+
+                void bind_engine_uniforms()
+                {
+                        engine_uniform_factory_map& factory_map = get_uniform_factory();
+                        for ( auto& i : m_uniform_map )
+                        {
+                                auto j = factory_map.find( i.first );
+                                if ( j != factory_map.end() )
+                                {
+                                        m_engine_uniforms.push_back( j->second->create( i.second ) );
+                                }                               
+                        }
+                }
+
+                // This is done this way to avoid compilation unit creation
+                static engine_uniform_factory_map& get_uniform_factory()
+                {
+                        static engine_uniform_factory_map s_engine_uniform_factory_map;
+                        return s_engine_uniform_factory_map;
+                }
+
+                // This is done this way to avoid compilation unit creation
+                static engine_link_uniform_factory_map& get_link_uniform_factory()
+                {
+                        static engine_link_uniform_factory_map s_engine_link_uniform_factory_map;
+                        return s_engine_link_uniform_factory_map;
+                }
+
+                static void initialize_engine_uniforms()
+                {
+                        engine_uniform_factory_map& factory_map = get_uniform_factory();
+                        factory_map[ "nv_m_view" ]       = new engine_uniform_factory< engine_uniform_m_view >();
+                        factory_map[ "nv_m_view_inv" ]   = new engine_uniform_factory< engine_uniform_m_view_inv >();
+                        factory_map[ "nv_m_view" ]       = new engine_uniform_factory< engine_uniform_m_view >();
+                        factory_map[ "nv_m_model" ]      = new engine_uniform_factory< engine_uniform_m_model >();
+                        factory_map[ "nv_m_modelview" ]  = new engine_uniform_factory< engine_uniform_m_modelview >();
+                        factory_map[ "nv_m_projection" ] = new engine_uniform_factory< engine_uniform_m_projection >();
+                        factory_map[ "nv_m_normal" ]     = new engine_uniform_factory< engine_uniform_m_normal >();
+                        factory_map[ "nv_m_mvp" ]        = new engine_uniform_factory< engine_uniform_m_mvp >();
+
+                        engine_link_uniform_factory_map& factory_link_map = get_link_uniform_factory();
+                        factory_link_map[ "nv_texture_0" ] = new engine_link_uniform_int<0>();
+                        factory_link_map[ "nv_texture_1" ] = new engine_link_uniform_int<1>();
+                        factory_link_map[ "nv_texture_2" ] = new engine_link_uniform_int<2>();
+                        factory_link_map[ "nv_texture_3" ] = new engine_link_uniform_int<3>();
+                        factory_link_map[ "nv_texture_4" ] = new engine_link_uniform_int<4>();
+                        factory_link_map[ "nv_texture_5" ] = new engine_link_uniform_int<5>();
+                        factory_link_map[ "nv_texture_6" ] = new engine_link_uniform_int<6>();
+                        factory_link_map[ "nv_texture_7" ] = new engine_link_uniform_int<7>();
+                        factory_link_map[ "nv_t_diffuse" ] = new engine_link_uniform_int<0>();
+                        factory_link_map[ "nv_t_specular"] = new engine_link_uniform_int<1>();
+                        factory_link_map[ "nv_t_normal"  ] = new engine_link_uniform_int<2>();
+                }
+
+                static void destroy_engine_uniforms()
+                {
+                        for ( auto& i : get_uniform_factory() ) delete i.second;
+                        for ( auto& i : get_link_uniform_factory() ) delete i.second;
+                        get_uniform_factory().clear();
+                        get_link_uniform_factory().clear();
+                }
+
         protected:
+
                 uniform_base* create_uniform( datatype utype, const string& name, int location, int length )
                 {
@@ -201 +259 @@
                 }
 
-                attribute_map m_attribute_map;
-                uniform_map   m_uniform_map;
+                attribute_map                     m_attribute_map;
+                uniform_map                           m_uniform_map;
+                engine_uniform_list               m_engine_uniforms;
         };
 

trunk/src/gl/gl_program.cc

@@ -189 +189 @@
                 m_uniform_map[ name ] = create_uniform( utype, name, uni_loc, uni_len );
         }
+
+        apply_link_engine_uniforms();
+        bind_engine_uniforms();
 }