Changeset 508

Timestamp:

07/19/16 13:43:10 (9 years ago)

Author:

epyon

Message:

• nv::engine upgrades
• default_resource_manager implementation

Location:

trunk

Files:

• nv/engine/animation.hh (modified) (1 diff)
• nv/engine/default_resource_manager.hh (added)
• nv/engine/light.hh (added)
• nv/engine/mesh_manager.hh (modified) (1 diff)
• nv/engine/model_manager.hh (modified) (2 diffs)
• nv/engine/render_pass.hh (added)
• nv/engine/renderer.hh (modified) (1 diff)
• nv/engine/shadow.hh (added)
• nv/interface/device.hh (modified) (2 diffs)
• nv/io/c_stream.hh (modified) (2 diffs)
• nv/stl/flags.hh (modified) (3 diffs)
• src/engine/animation.cc (modified) (1 diff)
• src/engine/default_resource_manager.cc (added)
• src/engine/material_manager.cc (modified) (2 diffs)
• src/engine/mesh_manager.cc (modified) (1 diff)
• src/engine/model_manager.cc (modified) (2 diffs)
• src/engine/renderer.cc (modified) (1 diff)
• src/engine/shadow.cc (added)
• src/io/c_stream.cc (modified) (1 diff)

trunk/nv/engine/animation.hh

@@ -354 +354 @@
         };
 
-        class animator_manager : public nv::lua_resource_manager< animator_data >
+        class animator_manager : public file_resource_manager< animator_data, true, lua_resource_manager_base >
         {
         public:

trunk/nv/engine/mesh_manager.hh

@@ -26 +26 @@
         enum shader_geo
         {
-                NORMAL = 0,
+                DIRECT = 0,
                 BONE = 1,
         };

trunk/nv/engine/model_manager.hh

@@ -96 +96 @@
                 }
         protected:
-                static void flatten( flat_model& result, const model_node* m, random_base& rng, const transform& ptr, sint32 parent_id )
+                static void flatten( flat_model& result, const model_node* m, random_base& rng, const transform& ptr, sint16 parent_id )
                 {
                         if ( m->chance < 1.0f )
@@ -114 +114 @@
                                 re.parent_id = parent_id;
                                 re.attach_id = m->attach_id;
-                                parent_id = id;
+                                parent_id = sint16(id);
                         }
                         for ( auto c : m->children )

trunk/nv/engine/renderer.hh

@@ -18 +18 @@
 #include <nv/interface/device.hh>
 #include <nv/interface/context.hh>
+#include <nv/engine/program_manager.hh>
+#include <nv/engine/material_manager.hh>
+#include <nv/engine/mesh_manager.hh>
+#include <nv/engine/render_pass.hh>
 
 namespace nv
 {
-        struct render_pass
+
+        struct renderer_element
         {
-                render_state rstate;
-                clear_state  cstate;
-                framebuffer  fbuffer;
-                output_slot  output[8];
-                uint32       output_count;
+                resource< gpu_mesh >     mesh;
+                resource< gpu_material > mat;
+                uint32                   layer;
+                sint32                   bone_offset;
+                transform                model;
+                flags< 32 >              flags;
+        };
 
+        struct renderer_direct_element
+        {
+                vertex_array             va;
+                uint32                   count;
+                uint32                   instances;
+                uint32                   first;
+                resource< gpu_material > material;
+                resource< program >      programs[4];
+                transform                model;
+                flags< 32 >              flags;
+        };
+
+        struct renderer_element_compare
+        {
+                bool operator()( const renderer_element& l, const renderer_element& r )
+                {
+                        if ( l.layer < r.layer ) return true;
+                        if ( l.layer > r.layer ) return false;
+                        if ( *l.flags.data() < *r.flags.data() ) return true;
+                        if ( *l.flags.data() > *r.flags.data() ) return false;
+                        if ( l.mat < r.mat ) return true;
+                        if ( l.mat > r.mat ) return false;
+                        return false;
+                }
         };
 
         class renderer
         {
+        public:
+                enum stats
+                {
+                        DRAW_CALL,
+                        TRIANGLE_COUNT,
+                        MAX
+                };
+
+                explicit renderer( context* ctx );
+                void start_frame()
+                {
+                        for ( uint32& s : m_statistics ) s = 0;
+                }
+
+                void push_element( const nv::renderer_element& element )
+                {
+                        m_elements.push_back( element );
+                }
+
+                void sort();
+                void render( const scene_state& ss, const render_pass& pass );
+                void render( const scene_state& ss, const render_pass& pass, vertex_array va, uint32 va_count, uint32 program_idx = 0 );
+                void render_quad( const scene_state& ss, const render_pass& pass, uint32 program_idx = 0 )
+                {
+                        render( ss, pass, m_quad, 6, program_idx );
+                }
+                void render_direct( const scene_state& ss, const render_pass& pass, const nv::array_view< renderer_direct_element >& elements, uint32 program_idx = 0 );
+
+                uint32 get_stat( stats s ) const { return m_statistics[s]; }
+
+                void end_frame()
+                {
+                        m_elements.clear();
+                }
+                void reset()
+                {
+                        m_elements.clear();
+                }
+
+        protected:
+                bool match( flags<32> f, const render_pass& pass )
+                {
+                        if ( ( f & pass.any ).empty() ) return false;
+                        if ( ( f & pass.exclude ).any() ) return false;
+                        return true;
+                }
+
+                context*                    m_context;
+                vertex_array                m_quad;
+                vector< renderer_element >  m_elements;
+                uint32                      m_statistics[MAX];
 
         };

trunk/nv/interface/device.hh

@@ -63 +63 @@
         enum texture_slot
         {
-                TEX_DIFFUSE   = 0,
-                TEX_NORMAL    = 1,
-                TEX_METALLIC  = 2,
-                TEX_SPECULAR  = 2, // obsolete
-                TEX_ROUGHNESS = 3,
-                TEX_GLOSS     = 3, // obsolete
-                TEX_EMISSIVE  = 4,
-                TEXTURE_0     = 0,
-                TEXTURE_1     = 1,
-                TEXTURE_2     = 2,
-                TEXTURE_3     = 3,
-                TEXTURE_4     = 4,
-                TEXTURE_5     = 5,
-                TEXTURE_6     = 6,
-                TEXTURE_7     = 7,
-                TEXTURE_8     = 8,
-                TEXTURE_9     = 9,
-                TEXTURE_10    = 10,
-                TEXTURE_11    = 11,
-                TEXTURE_12    = 12,
-                TEXTURE_13    = 13,
-                TEXTURE_14    = 14,
-                TEXTURE_15    = 15,
+                TEXTURE_0     = 0,  TEX_DIFFUSE   = 0,
+                TEXTURE_1     = 1,  TEX_NORMAL    = 1,
+                TEXTURE_2     = 2,  TEX_METALLIC  = 2,
+                TEXTURE_3     = 3,  TEX_ROUGHNESS = 3,
+                TEXTURE_4     = 4,  TEX_EMISSIVE  = 4,
+                TEXTURE_5     = 5,  TEX_DEPTH     = 5,
+                TEXTURE_6     = 6,  TEX_OCCLUSION = 6,
+                TEXTURE_7     = 7,  TEX_FINAL     = 7,
+                TEXTURE_8     = 8,  TEX_CUSTOM_0  = 8,
+                TEXTURE_9     = 9,  TEX_CUSTOM_1  = 9,
+                TEXTURE_10    = 10, TEX_CUSTOM_2  = 10,
+                TEXTURE_11    = 11, TEX_CUSTOM_3  = 11,
+                TEXTURE_12    = 12, TEX_CUSTOM_4  = 12,
+                TEXTURE_13    = 13, TEX_CUSTOM_5  = 13,
+                TEXTURE_14    = 14, TEX_CUSTOM_6  = 14,
+                TEXTURE_15    = 15, TEX_CUSTOM_7  = 15,
                 MAX_TEXTURES  = 16,
         };
@@ -355 +348 @@
                         factory_link_map[ "nv_t_normal"   ] = new engine_link_uniform_int<int( TEX_NORMAL )>();
                         factory_link_map[ "nv_t_metallic" ] = new engine_link_uniform_int<int( TEX_METALLIC )>();
-                        factory_link_map[ "nv_t_specular" ] = new engine_link_uniform_int<int( TEX_METALLIC )>();
                         factory_link_map[ "nv_t_roughness"] = new engine_link_uniform_int<int( TEX_ROUGHNESS )>();
-                        factory_link_map[ "nv_t_gloss"    ] = new engine_link_uniform_int<int( TEX_ROUGHNESS )>();
                         factory_link_map[ "nv_t_emissive" ] = new engine_link_uniform_int<int( TEX_EMISSIVE )>();
+                        factory_link_map[ "nv_t_depth"    ] = new engine_link_uniform_int<int( TEX_DEPTH )>();
+                        factory_link_map[ "nv_t_occlusion"] = new engine_link_uniform_int<int( TEX_OCCLUSION )>();
+                        factory_link_map[ "nv_t_final"    ] = new engine_link_uniform_int<int( TEX_FINAL )>();
                 }
                 void destroy_engine_uniforms()

trunk/nv/io/c_stream.hh

@@ -16 +16 @@
 #include <nv/common.hh>
 #include <nv/stl/stream.hh>
+#include <nv/stl/string.hh>
 
 namespace nv
@@ -39 +40 @@
                 virtual void flush();
         private:
-                void*       m_file;      //!< FILE* structure, masked
-                const char* m_file_name; //!< File name
-                size_t      m_file_size; //!< Cached file size
+                void*        m_file;      //!< FILE* structure, masked
+                const_string m_file_name; //!< File name
+                size_t       m_file_size; //!< Cached file size
         };
 

trunk/nv/stl/flags.hh

@@ -183 +183 @@
                 }
 
+                bool any() const
+                {
+                        for ( auto c : m_data )
+                                if ( c != 0 ) return true;
+                        return false;
+                }
+
+                bool empty() const
+                {
+                        for ( auto c : m_data )
+                                if ( c != 0 ) return false;
+                        return true;
+                }
+
                 const data_type* data() const
                 {
@@ -212 +226 @@
                         return reference( this, idx );
                 }
+
+                template < uint32 SIZE, typename T >
+                inline friend flags< SIZE, T > operator &( const flags< SIZE, T >& lhs, const flags< SIZE, T >& rhs );
+
+                template < uint32 SIZE, typename T >
+                inline friend flags< SIZE, T > operator |( const flags< SIZE, T >& lhs, const flags< SIZE, T >& rhs );
 
         private:
@@ -217 +237 @@
         };
 
+        template < uint32 SIZE, typename T >
+        inline flags< SIZE, T > operator &( const flags< SIZE, T >& lhs, const flags< SIZE, T >& rhs )
+        {
+                flags< SIZE, T > result( lhs );
+                for ( uint32 i = 0; i < result.data_size; ++i )
+                        result.m_data[i] &= rhs.m_data[i];
+                return result;
+        }
+
+        template < uint32 SIZE, typename T >
+        inline flags< SIZE, T > operator |( const flags< SIZE, T >& lhs, const flags< SIZE, T >& rhs )
+        {
+                flags< SIZE, T > result( lhs );
+                for ( uint32 i = 0; i < result.data_size; ++i )
+                        result.m_data[i] |= rhs.m_data[i];
+                return result;
+        }
+
+
 } // namespace nv
 

trunk/src/engine/animation.cc

@@ -41 +41 @@
                 {
                         nv::c_file_system fs;
-                        nv::stream* poses_file = fs.open( poses_path );
+                        nv::stream* poses_file = open_stream( fs, poses_path );
+                        NV_ASSERT_ALWAYS( poses_file, "CANT FIND POSES FILE!" );
                         nv::nmd_loader* ploader = new nv::nmd_loader( nullptr );
                         ploader->load( *poses_file );

trunk/src/engine/material_manager.cc

@@ -39 +39 @@
 
                 // HACK
-                for ( uint32 i = 0; i < 8; ++i )
-                        if ( result->textures[i].is_nil() )
-                                result->textures[i] = m_default;
+                for ( uint32 i = 0; i < 5; ++i )
+                        if ( result->textures[i].is_nil() )
+                                result->textures[i] = m_default;
 
                 return add( id, result );
@@ -77 +77 @@
                                 if ( i != TEX_EMISSIVE )
                                         NV_LOG_ERROR( "Texture file not found! : ", m->paths[i] );
-                                m->paths[i].clear();
+                                //m->paths[i].clear();
                         }
                 }

trunk/src/engine/mesh_manager.cc

@@ -18 +18 @@
                 gm->va = m_context->create_vertex_array( &*lmesh, STATIC_DRAW );
                 gm->count = lmesh->get_channel_size( slot::INDEX );
-                gm->shader = lmesh->get_channel( slot::BONEINDEX ) != nullptr ? BONE : NORMAL;
+                gm->shader = lmesh->get_channel( slot::BONEINDEX ) != nullptr ? BONE : DIRECT;
                 return add( mesh.id(), gm );
         }

trunk/src/engine/model_manager.cc

@@ -64 +64 @@
                 if ( table.is_number( "attach" ) )
                 {
-                        attach_id = table.get_integer( "attach", -1 );
+                        attach_id = sint16( table.get_integer( "attach", -1 ) );
                         //                              parent_id = 0;
                 }
@@ -71 +71 @@
                         auto it = m->node_names.find( table.get_string_hash_64( "attach" ) );
                         if ( it != m->node_names.end() )
-                                attach_id = it->second + 1;
+                                attach_id = sint16( it->second + 1 );
                         int error; int hack;
                 }

trunk/src/engine/renderer.cc

@@ -6 +6 @@
 
 #include "nv/engine/renderer.hh"
+
+#include "nv/core/profiler.hh"
+
+using namespace nv;
+
+renderer::renderer( context* ctx )
+        : m_context( ctx )
+{
+        for ( auto& i : m_statistics ) i = 0;
+
+        struct qvtx
+        {
+                nv::vec2 position;
+                nv::vec2 texcoord;
+        };
+
+        qvtx quad[] = {
+                qvtx{ vec2( -1.0f,-1.0f ), vec2( 0.0f, 0.0f ) },
+                qvtx{ vec2( 1.0f,-1.0f ),  vec2( 1.0f, 0.0f ) },
+                qvtx{ vec2( 1.0f,1.0f ),   vec2( 1.0f, 1.0f ) },
+                qvtx{ vec2( 1.0f,1.0f ),   vec2( 1.0f, 1.0f ) },
+                qvtx{ vec2( -1.0f,1.0f ),  vec2( 0.0f, 1.0f ) },
+                qvtx{ vec2( -1.0f,-1.0f ), vec2( 0.0f, 0.0f ) },
+        };
+        m_quad = m_context->create_vertex_array( quad, 6, STATIC_DRAW );
+}
+
+void renderer::sort()
+{
+        stable_sort( m_elements.begin(), m_elements.end(), renderer_element_compare() );
+}
+
+
+void renderer::render( const scene_state& s, const render_pass& pass )
+{
+        scene_state ss( s );
+        m_context->bind( pass.fbuffer, FRAMEBUFFER );
+        m_context->set_draw_buffers( pass.output_count, pass.output );
+        m_context->set_viewport( ss.get_viewport() );
+
+        if ( pass.cstate.buffers != buffer_mask::NO_BUFFER )
+                m_context->clear( pass.cstate );
+
+        for ( uint32 i = 0; i < size( pass.binds ); ++i )
+                if ( pass.binds[i] )
+                        m_context->bind( pass.binds[i], texture_slot( i ) );
+
+        resource_id current_mat;
+        mat4 model = ss.get_model();
+        for ( const renderer_element& element : m_elements )
+                if ( match( element.flags, pass ) )
+                {
+                        ss.set_model( model * element.model.extract() );
+                        if ( auto mesh = element.mesh.lock() )
+                                if ( mesh->count > 0 )
+                                        if ( auto program = pass.programs[mesh->shader].lock() )
+                                        {
+                                                if ( element.mat.id() != current_mat )
+                                                {
+                                                        if ( auto mat = element.mat.lock() )
+                                                        {
+                                                                for ( uint32 i = 0; i < 8; ++i )
+                                                                        if ( mat->textures[i] && !pass.binds[i] )
+                                                                                m_context->bind( mat->textures[i], nv::texture_slot( i ) );
+                                                                current_mat = element.mat.id();
+                                                        }
+                                                }
+
+                                                m_context->get_device()->set_opt_uniform( *program, "nv_bone_offset", element.bone_offset );
+                                                m_context->get_device()->set_opt_uniform( *program, "nv_flags", unsigned( *element.flags.data() ) );
+
+                                                m_context->apply_engine_uniforms( *program, ss );
+                                                m_context->draw( TRIANGLES, pass.rstate, *program, mesh->va, mesh->count );
+
+                                                m_statistics[TRIANGLE_COUNT] += mesh->count / 3;
+                                                m_statistics[DRAW_CALL]++;
+                                        }
+                }
+
+        m_context->bind( pass.fbuffer, FRAMEBUFFER );
+}
+
+void renderer::render( const scene_state& ss, const render_pass& pass, vertex_array va, uint32 va_count, uint32 program_idx )
+{
+        m_context->bind( pass.fbuffer, FRAMEBUFFER );
+        m_context->set_draw_buffers( pass.output_count, pass.output );
+        m_context->set_viewport( ss.get_viewport() );
+
+        if ( pass.cstate.buffers != buffer_mask::NO_BUFFER )
+                m_context->clear( pass.cstate );
+
+        for ( uint32 i = 0; i < size( pass.binds ); ++i )
+                if ( pass.binds[i] )
+                        m_context->bind( pass.binds[i], texture_slot(i) );
+
+        if ( auto program = pass.programs[program_idx].lock() )
+        {
+                m_context->apply_engine_uniforms( *program, ss );
+                m_context->draw( TRIANGLES, pass.rstate, *program, va, va_count );
+                m_statistics[ TRIANGLE_COUNT ] += 2;
+                m_statistics[ DRAW_CALL ]++;
+        }
+
+        m_context->bind( pass.fbuffer, FRAMEBUFFER );
+}
+
+void nv::renderer::render_direct( const scene_state& s, const render_pass& pass, const nv::array_view< renderer_direct_element >& elements, uint32 program_idx )
+{
+        if ( m_elements.size() == 0 ) return;
+
+        scene_state ss( s );
+        m_context->bind( pass.fbuffer, FRAMEBUFFER );
+        m_context->set_draw_buffers( pass.output_count, pass.output );
+        m_context->set_viewport( ss.get_viewport() );
+
+        if ( pass.cstate.buffers != buffer_mask::NO_BUFFER )
+                m_context->clear( pass.cstate );
+
+        for ( uint32 i = 0; i < size( pass.binds ); ++i )
+                if ( pass.binds[i] )
+                        m_context->bind( pass.binds[i], texture_slot( i ) );
+
+        resource_id current_mat;
+        resource_id current_prog;
+
+        mat4 model = ss.get_model();
+        for ( uint32 index = 0; index < elements.size(); ++index )
+        {
+                const renderer_direct_element& element = elements[index];
+                if ( match( element.flags, pass ) )
+                {
+                        ss.set_model( model * element.model.extract() );
+                        if ( element.count > 0 )
+                        {
+                                if ( auto program = element.programs[program_idx].lock() )
+                                {
+                                        if ( element.material.id() != current_mat )
+                                        {
+                                                if ( auto mat = element.material.lock() )
+                                                {
+                                                        for ( uint32 i = 0; i < 8; ++i )
+                                                                if ( mat->textures[i] && !pass.binds[i] )
+                                                                        m_context->bind( mat->textures[i], nv::texture_slot( i ) );
+                                                        current_mat = element.material.id();
+                                                }
+                                        }
+
+                                        m_context->get_device()->set_opt_uniform( *program, "nv_flags", unsigned( *element.flags.data() ) );
+                                        m_context->get_device()->set_opt_uniform( *program, "nv_index", unsigned( index ) );
+                                        m_context->apply_engine_uniforms( *program, ss );
+
+                                        if ( element.instances > 0 )
+                                                m_context->draw_instanced( TRIANGLES, pass.rstate, *program, element.instances, element.va, element.count, element.first );
+                                        else
+                                                m_context->draw( TRIANGLES, pass.rstate, *program, element.va, element.count, element.first );
+
+                                        m_statistics[TRIANGLE_COUNT] += ( element.count / 3 ) * max< uint32 >( element.instances, 1 );
+                                        m_statistics[DRAW_CALL]++;
+                                }
+                        }
+                }
+        }
+        m_context->bind( pass.fbuffer, FRAMEBUFFER );
+}

trunk/src/io/c_stream.cc

@@ -75 +75 @@
         {
                 struct stat fstat; 
-                int result = stat(m_file_name, &fstat ); 
+                int result = stat(m_file_name.data(), &fstat ); 
                 if ( result != 0 ) 
                 {