Changeset 486

Timestamp:

02/24/16 18:47:54 (9 years ago)

Author:

epyon

Message:

• mass update once again...

Location:

trunk

Files:

• nv.lua (modified) (1 diff)
• nv/base/common.hh (modified) (1 diff)
• nv/core/transform.hh (modified) (2 diffs)
• nv/engine/animation.hh (modified) (5 diffs)
• nv/engine/material_manager.hh (modified) (1 diff)
• nv/engine/resource_system.hh (modified) (1 diff)
• nv/formats/assimp_loader.hh (modified) (1 diff)
• nv/gfx/poses.hh (added)
• nv/gfx/skeleton_instance.hh (modified) (4 diffs)
• nv/image/png_loader.hh (modified) (1 diff)
• nv/interface/camera.hh (modified) (3 diffs)
• nv/interface/device.hh (modified) (3 diffs)
• nv/interface/easing.hh (added)
• nv/interface/image_data.hh (modified) (2 diffs)
• nv/interface/image_loader.hh (modified) (1 diff)
• nv/interface/interpolate.hh (added)
• nv/interface/uniform.hh (modified) (1 diff)
• nv/lua/lua_state.hh (modified) (1 diff)
• nv/stl/container/hash_table.hh (modified) (2 diffs)
• nv/stl/hash_store.hh (modified) (1 diff)
• nv/stl/math/basic.hh (modified) (2 diffs)
• nv/stl/math/mat2.hh (modified) (4 diffs)
• nv/stl/math/mat3.hh (modified) (4 diffs)
• nv/stl/math/vec2.hh (modified) (1 diff)
• src/core/ascii_printer.cc (added)
• src/engine/animation.cc (added)
• src/engine/material_manager.cc (modified) (3 diffs)
• src/engine/resource_system.cc (modified) (1 diff)
• src/formats/assimp_loader.cc (modified) (7 diffs)
• src/formats/nmd_loader.cc (modified) (1 diff)
• src/gfx/skeleton_instance.cc (modified) (5 diffs)
• src/image/miniz.cc (modified) (1 diff)
• src/image/png_loader.cc (modified) (3 diffs)
• src/io/c_stream.cc (modified) (1 diff)
• src/lua/lua_state.cc (modified) (2 diffs)
• src/sdl/sdl_window.cc (modified) (1 diff)

trunk/nv.lua

@@ -117 +117 @@
                 if _ACTION == "gmake-clang" then
                         buildoptions { 
-                                "-std=c++11",
+                                "-std=c++1z",
 --                                -- on Mac OS X don't try to use old stdc++
 --                                "-stdlib=libc++",
                                 "-Weverything",
+                                -- math is so much easier with these
+                                "-Wno-gnu-anonymous-struct", 
+                                "-Wno-nested-anon-types", 
                                 -- obviously we don't care about C++98 compatibility
                                 "-Wno-c++98-compat", 

trunk/nv/base/common.hh

@@ -266 +266 @@
         constexpr T narrow_cast( const U& a )
         {
+                NV_MSVC_SUPRESS( 4806 );
                 return static_cast<T>( a & static_cast<T>( -1 ) );
         }

trunk/nv/core/transform.hh

@@ -17 +17 @@
         {
         public:
+                typedef float value_type;
+
                 transform() {}
                 explicit transform( const vec3& a_position ) : m_position( a_position ) {}
@@ -106 +108 @@
         template <> struct type_to_enum< transform > { static const datatype type = TRANSFORM; };
 
+        namespace math
+        {
+
+                inline transform lerp( const transform& a, const transform& b, float value )
+                {
+                        return transform(
+                                math::lerp( a.get_position(), b.get_position(), value ),
+                                math::lerp( a.get_orientation(), b.get_orientation(), value )
+                                );
+                }
+
+        }
+
 }
 

trunk/nv/engine/animation.hh

@@ -17 +17 @@
 #include <nv/core/resource.hh>
 #include <nv/interface/mesh_data.hh>
+#include <nv/interface/easing.hh>
 #include <nv/gfx/skeleton_instance.hh>
 #include <nv/gfx/poses.hh>
+#include <nv/engine/resource_system.hh>
 
 namespace nv
 {
         class animator_bind_data;
-        class animator_data;
+        struct animator_data;
 }
 
@@ -33 +35 @@
 {
 
-        struct animator_clip_data
-        {
-                uint32      id;
-                frame_range range;
-        };
-
-        class animator_data
+        struct animator_pose_data
+        {
+                uint32 pose;
+                // float  time;
+                //      float      easing_data[4];
+        };
+
+        struct animator_transition_data
+        {
+                uint32        target;
+                float         duration;
+                interpolation interp;
+                easing        easing;
+        };
+
+        typedef hash_store< shash64, animator_transition_data > animator_transition_table;
+
+        struct animator_state_data
+        {
+                shash64                      name;
+                uint32                       base_pose;
+                vector< animator_pose_data > poses;
+                bool                         loop;
+                float                        duration;
+                interpolation                interp;
+                animator_transition_table    transitions;
+        };
+
+        struct animator_layer_data
+        {
+                shash64 name;
+                sint32  def_state;
+                sint32  mask;
+                vector< bool >                mask_vector;
+                vector< animator_state_data > states;
+        };
+
+        struct animator_data
+        {
+                vector< animator_layer_data > layers;
+                pose_data_set*                poses;
+        };
+
+        struct animator_transition_instance : animator_transition_data
+        {
+                uint32        source;
+                float         time;
+
+                animator_transition_instance() {}
+
+                animator_transition_instance( const animator_transition_data& data, uint32 source )
+                        : animator_transition_data( data ), source( source ), time( 0.0f )
+                {
+
+                }
+        };
+
+        class animator_layer_instance
         {
         public:
-                animator_data( pose_data_set* data ) : m_data( data ) {}
-                //
-                pose_data_set* get_pose_data() { return m_data;  }
-                const pose_data_set* get_pose_data() const { return m_data; }
-
-                const animator_clip_data* get_clip( shash64 name ) const
-                {
-                        auto it = m_clip_data.find( name );
-                        return ( it != m_clip_data.end() ? &it->second : nullptr );
-                }
-                bool has_clip( shash64 name ) const
-                {
-                        auto it = m_clip_data.find( name );
-                        return it != m_clip_data.end();
-                }
-                void add_clip( shash64 name, animator_clip_data&& entry )
-                {
-                        m_clip_data.assign( name, entry );
-                }
-        protected:
-                pose_data_set* m_data;
-                hash_store< shash64, animator_clip_data > m_clip_data;
+                vector< animator_transition_instance > m_transitions;
+                uint32 m_current_state;
+                float m_time;
+
+                animator_layer_instance() : m_current_state( 0 ), m_time( 0.0f ) {}
+                void set_state( uint32 state ) { m_current_state = state; }
+                uint32 get_state() const { return m_current_state; }
+                uint32 get_final_state() const
+                {
+                        if ( m_transitions.size() > 0 ) 
+                                return m_transitions.back().target;
+                        return m_current_state;
+                }
+                void add_transition( const animator_transition_data& data, uint32 source )
+                {
+                        if ( m_transitions.size() > 0 )
+                        {
+                                auto& last = m_transitions.back();
+                                if ( last.target == source && data.target == last.source )
+                                {
+                                        nv::swap( last.target, last.source );
+                                        last.time = last.duration - last.time;
+                                        return;
+                                }
+                        }
+                        m_transitions.push_back( animator_transition_instance( data, source ) );
+                }
+                void reset()
+                {
+                        m_transitions.clear();
+                        m_time = 0.0f;
+                }
+                void update( float dtime )
+                {
+                        if ( m_current_state != -1 )
+                        {
+                                float time = dtime;
+                                while ( m_transitions.size() > 0 )
+                                {
+                                        animator_transition_instance& tr = m_transitions.front();
+                                        m_current_state = tr.target;
+                                        tr.time += time;
+                                        if ( tr.time < tr.duration ) break;
+                                        time -= ( tr.time - tr.duration );
+                                        m_transitions.erase( m_transitions.begin() );
+                                }
+                                m_time += dtime;
+                        }
+                }
         };
 
@@ -77 +157 @@
                         m_pose_binding.prepare( pose_frame, bones );
                 }
-                const bone_transforms& get_bone_transforms() const { return m_bone_transforms; }
+                const bone_transforms< transform >& get_bone_transforms() const { return m_bone_transforms; }
                 const skeleton_binding& get_pose_binding() const
                 {
@@ -86 +166 @@
         protected:
                 skeleton_binding                        m_pose_binding;
-                bone_transforms                         m_bone_transforms;
+                bone_transforms< transform >            m_bone_transforms;
                 data_node_list                          m_bone_list;
         };
@@ -95 +175 @@
         public:
                 animator_instance() {}
-                void initialize( resource< animator_data > data, resource< animator_bind_data > bind_data )
-                {
-                        m_data = data;
-                        m_bind_data = bind_data;
-                }
-                bool is_valid() const { return m_data.is_valid() && m_bind_data.is_valid(); }
-                bool has_clip( shash64 id ) const
-                {
-                        if ( auto data = m_data.lock() )
-                                return data->has_clip( id );
+                void initialize( const animator_data* data )
+                {
+                        m_layers.clear();
+                        m_layers.resize( data->layers.size() );
+                        for ( uint32 i = 0; i < data->layers.size(); ++i )
+                        {
+                                m_layers[i].set_state( data->layers[i].def_state );
+                        }
+                }
+
+                const skeleton_transforms& get_transforms() const
+                {
+                        return m_transforms;
+                }
+
+                uint32 base_state() const
+                {
+                        // HACK
+                        if ( m_layers.size() > 1 && m_layers[0].m_transitions.size() < 1 ) return m_layers[0].get_state();
+                        return 0;
+                }
+                
+                void queue_event( const animator_data* data, shash64 name )
+                {
+                        for ( uint32 i = 0; i < m_layers.size(); ++i )
+                                // what about activating nonactive layers?
+                                if ( m_layers[i].m_current_state != -1 )
+                                {
+                                        uint32 last_state = m_layers[i].get_final_state();
+                                        const animator_state_data& state = data->layers[i].states[last_state];
+                                        auto it = state.transitions.find( name );
+                                        if ( it != state.transitions.end() )
+                                        {
+                                                m_layers[i].add_transition( it->second, last_state );
+                                        }
+                                }
+                }
+
+                void update( const animator_data* data, float dtime )
+                {
+                        for ( uint32 i = 0; i < m_layers.size(); ++i )
+                                m_layers[i].update( dtime );
+
+                        for ( uint32 i = 0; i < m_layers.size(); ++ i )
+                                if ( m_layers[i].m_current_state != -1 )
+                                {
+                                        if ( m_layers[i].m_transitions.size() > 0 )
+                                        {
+                                                animate_layer( data->layers[i], m_layers[i].m_transitions.front(), data->poses, m_layers[i].m_time );
+                                        }
+                                        else
+                                        {
+                                                const animator_layer_data& layer = data->layers[i];
+                                                const animator_state_data& state = layer.states[m_layers[i].m_current_state];
+                                                if ( state.poses.size() > 0 )
+                                                        animate_state( m_transforms, state, data->layers[i], data->poses, get_frame( state, m_layers[i].m_time ) );
+                                        }
+                                }
+
+                        m_transforms.delocalize( data->poses->get_tree() );
+                }
+
+                void reset()
+                {
+                        for ( uint32 i = 0; i < m_layers.size(); ++i )
+                                m_layers[i].reset();
+                }
+
+                void update_state_only( const animator_data* data, float dtime, uint32 layer_id, uint32 state_id )
+                {
+                        const animator_layer_data& layer = data->layers[layer_id];
+                        const animator_state_data& state = layer.states[state_id];
+                        m_layers[layer_id].update( dtime );
+                        if ( state.poses.size() > 0 )
+                                animate_state( m_transforms, state, layer, data->poses, get_frame( state, m_layers[layer_id].m_time ) );
+                        m_transforms.delocalize( data->poses->get_tree() );
+                }
+
+                void update_layer_only( const animator_data* data, float dtime, uint32 layer_id )
+                {
+                        const animator_layer_data& ldata     = data->layers[layer_id];
+                        const animator_layer_instance& linst = m_layers[layer_id];
+                        m_layers[layer_id].update( dtime );
+                        if ( m_layers[layer_id].m_transitions.size() > 0 )
+                        {
+                                animate_layer( ldata, linst.m_transitions.front(), data->poses, linst.m_time );
+                        }
                         else
-                                return false;
-                }
-                mat4 get_transform( uint32 idx ) const
-                {
-                        if ( idx < m_skeleton.size() ) return m_skeleton.transforms()[idx];
-                        return mat4();
-                }
-                const skeleton_instance& get_skeleton() const
-                {
-                        return m_skeleton;
-                }
-
-                sint16 get_bone_index( shash64 bone_name ) const
-                {
-                        if ( is_valid() )
-                        {
-                                auto data = m_bind_data.lock();
-                                sint16 id = data->get_bone_list().resolve( bone_name );
-                                return id;
-                        }
-                        return -1;
-                }
-
-                const mat4& get_bone_matrix( shash64 bone_name ) const
-                {
-                        if ( is_valid() )
-                        {
-                                auto data = m_bind_data.lock();
-                                sint16 id = data->get_bone_list().resolve( bone_name );
-                                if ( id >= 0 )
-                                {
-                                        return data->get_bone_list()[id].transform;
-                                }
-                        }
-                        return mat4();
-                }
-
-
-                void update( shash64 clip, uint32 time )
-                {
-                        if ( is_valid() )
-                        {
-                                auto data = m_data.lock();
-                                auto bind_data = m_bind_data.lock();
-                                const animator_clip_data* clip_data = data->get_clip( clip );
-
-                                if ( data->get_pose_data() )
-                                {
-                                        if ( clip_data )
-                                        {
-                                                auto pose_data = data->get_pose_data();
-                                                float fframe = clip_data->range.frame_from_ms_fps( time, 30 );
-
-                                                unsigned v1 = unsigned( fframe );
-                                                unsigned v2 = v1 + 1;
-                                                if ( v2 >= clip_data->range.end ) v2 = clip_data->range.start;
-
-                                                unsigned iv1 = v1 + clip_data->id;
-                                                unsigned iv2 = v2 + clip_data->id;
-
-                                                m_transforms.interpolate_slerp( pose_data->get( iv1 ), pose_data->get( iv2 ), fframe - v1 );
-                                                m_transforms.delocalize( pose_data->get_tree() );
-
-                                        }
-                                        m_skeleton.assign( m_transforms, bind_data->get_pose_binding(), bind_data->get_bone_transforms() );
-                                }
-                        }
-                }
+                        {
+                                const animator_state_data& state = ldata.states[linst.m_current_state];
+                                if ( state.poses.size() > 0 )
+                                        animate_state( m_transforms, state, ldata, data->poses, get_frame( state, linst.m_time ) );
+                        }
+                        m_transforms.delocalize( data->poses->get_tree() );
+                }
+
         protected:
-                resource< animator_data >      m_data;
-                resource< animator_bind_data > m_bind_data;
-                skeleton_transforms            m_transforms;
-                skeleton_instance              m_skeleton;
+
+                void animate_layer( const animator_layer_data& layer, const animator_transition_instance& transition, pose_data_set* pose_data, float t )
+                {
+                        const animator_state_data& base_state = layer.states[transition.source];
+                        if ( base_state.poses.size() > 0 )
+                                animate_state( m_transforms, base_state, layer, pose_data, get_frame( base_state, t ) );
+
+                        float trblend = 0.0f;
+                        if ( transition.duration > 0.0f )
+                        {
+                                trblend = math::clamp( transition.time / transition.duration, 0.0f, 1.0f );
+                                trblend = easing_eval( trblend, transition.easing );
+                        }
+
+                        const animator_state_data& state = layer.states[transition.target];
+                        if ( state.poses.size() > 0 )
+                                animate_state( m_transforms, state, layer, pose_data, get_frame( state, t ), true, trblend, transition.interp );
+                }
+
+                static float get_frame( const animator_state_data& state, float layer_time )
+                {
+                        uint32 fcount = state.poses.size();
+                        float fframe = 0.0f;
+                        if ( state.duration > nv::math::epsilon<float>() )
+                        {
+                                float fps = fcount / state.duration;
+                                float ctime = state.loop ? fmodf( layer_time, state.duration ) : min( layer_time, state.duration - 0.0001f );
+                                fframe = ctime * fps; 
+                        }
+                        return fframe;
+                }
+
+                static void animate_state( skeleton_transforms& transforms, const animator_state_data& state, const animator_layer_data& layer, const pose_data_set* pose_data, float fframe, bool do_blend = false, float blend = 0.0f, nv::interpolation binterp = interpolation::NONE )
+                {
+                        unsigned v1 = unsigned( fframe );
+                        unsigned v2 = v1 + 1;
+                        if ( v2 >= state.poses.size() ) v2 = state.loop ? 0 : state.poses.size() - 1;
+
+                        unsigned iv1 = state.poses[v1].pose;
+                        unsigned iv2 = state.poses[v2].pose;
+
+
+                        if ( iv1 == iv2 )
+                        {
+                                if ( do_blend )
+                                        transforms.interpolate( transforms, pose_data->get( iv1 ), blend, binterp, layer.mask_vector );
+                                else
+                                        transforms.assign( pose_data->get( iv1 ), layer.mask_vector );
+                        }
+                        else
+                        {
+                                if ( state.interp == interpolation::QUADRATIC || state.interp == interpolation::SQUADRATIC )
+                                {
+                                        unsigned s1 = v1 == 0 ? state.poses.size() - 1 : v1 - 1; 
+                                        unsigned s2 = v2 + 1;
+                                        if ( s2 >= state.poses.size() ) s2 = state.loop ? 0 : state.poses.size() - 1;
+                                        unsigned is1 = state.poses[s1].pose;
+                                        unsigned is2 = state.poses[s2].pose;
+                                        if ( do_blend )
+                                                transforms.blend( pose_data->get( is1 ), pose_data->get( iv1 ), pose_data->get( iv2 ), pose_data->get( is2 ), fframe - v1, state.interp, blend, binterp, layer.mask_vector );
+                                        else
+                                                transforms.interpolate( pose_data->get( is1 ), pose_data->get( iv1 ), pose_data->get( iv2 ), pose_data->get( is2 ), fframe - v1, state.interp, layer.mask_vector );
+                                }
+                                else
+                                {
+                                        if ( do_blend )
+                                                transforms.blend( pose_data->get( iv1 ), pose_data->get( iv2 ), fframe - v1, state.interp, blend, binterp, layer.mask_vector );
+                                        else
+                                                transforms.interpolate( pose_data->get( iv1 ), pose_data->get( iv2 ), fframe - v1, state.interp, layer.mask_vector );
+                                }       
+                        }
+                }
+
+                vector< animator_layer_instance > m_layers;
+                skeleton_transforms               m_transforms;
+
+
+        };
+
+        class animator_manager : public nv::lua_resource_manager< animator_data >
+        {
+        public:
+                explicit animator_manager( nv::string_table* strings = nullptr ) : m_strings( strings ) {}
+                virtual nv::string_view get_storage_name() const { return "animators"; }
+                virtual nv::string_view get_resource_name() const { return "animator"; }
+
+                nv::resource< animator_data > load_animator( const nv::string_view& id, nv::pose_data_set* poses = nullptr );
+                nv::resource< animator_data > create_animator( const nv::string_view& id, nv::pose_data_set* poses = nullptr );
+        protected:
+                virtual bool load_resource( nv::lua::table_guard& table, nv::shash64 id );
+                nv::resource< animator_data > load_animator( nv::lua::table_guard& table, nv::shash64 id, nv::pose_data_set* poses = nullptr );
+
+                nv::easing read_easing( nv::lua::table_guard& table );
+                void fill_mask_vector_rec( nv::vector< bool >& mask_vector, const nv::data_node_tree& tree, nv::uint32 id )
+                {
+                        mask_vector[id] = true;
+                        for ( auto child : tree.children( id ) )
+                                fill_mask_vector_rec( mask_vector, tree, child );
+                }
+                
+                nv::string_table* m_strings;
         };
 

trunk/nv/engine/material_manager.hh

@@ -51 +51 @@
         {
         public:
-                gpu_material_manager( context* context, material_manager* matmgr, image_manager* imgmgr )
-                        : m_context( context )
-                        , m_material_manager( matmgr )
-                        , m_image_manager( imgmgr )
-                {}
+                gpu_material_manager( context* context, material_manager* matmgr, image_manager* imgmgr );
         protected:
                 virtual bool load_resource( const string_view& id );
                 virtual void release( gpu_material* m );
         private:
+                texture           m_default;
                 context*          m_context;
                 material_manager* m_material_manager;

trunk/nv/engine/resource_system.hh

@@ -55 +55 @@
                 virtual string_view get_resource_name() const = 0;
                 virtual void clear() = 0;
-                void load_all();
+                void load_all( bool do_clear = true );
                 virtual bool load_resource( const string_view& id );
                 virtual ~lua_resource_manager_base() {}

trunk/nv/formats/assimp_loader.hh

@@ -34 +34 @@
         private:
                 bool is_node_animated();
-                void build_skeleton( vector< data_node_info >& skeleton, const void* node, int parent_id );
+                void build_skeleton( vector< data_node_info >& skeleton, const void* node, sint16 parent_id );
                 data_node_list* release_merged_bones();
                 void load_mesh_data( data_channel_set* data, size_t index, data_node_info& info );

trunk/nv/gfx/skeleton_instance.hh

@@ -48 +48 @@
                         return clamp_frame( ( ms * 0.001f ) * float( fps ) );
                 }
+
+                inline float frame_from_ms_fps( uint32 ms, float fps ) const
+                {
+                        return clamp_frame( ( ms * 0.001f ) * fps );
+                }
         };
 
+        template < typename Transform >
         class bone_transforms
         {
         public:
+                typedef Transform value_type;
+
                 bone_transforms() {}
-                void prepare( const data_node_list& bone_data );
+                void prepare( const data_node_list& bone_data )
+                {
+                        m_offsets.resize( bone_data.size() );
+                        for ( uint16 bi = 0; bi < bone_data.size(); ++bi )
+                                m_offsets[bi] = value_type( bone_data[bi].transform );
+                }
+
                 uint32 size() const { return m_offsets.size(); };
         protected:
-                dynamic_array< mat4 >   m_offsets;
+                dynamic_array< value_type >   m_offsets;
 
+                template < typename T >
                 friend class skeleton_instance;
         };
@@ -76 +91 @@
                 uint32                  m_bone_count;
 
+                template < typename T >
                 friend class skeleton_instance;
                 friend class skeleton_transforms;
@@ -90 +106 @@
                 void assign( const data_node_list* node_data );
                 void assign( const skeleton_transforms& other );
+                void assign( const skeleton_transforms& other, const array_view< bool >& mask );
 
-                void interpolate_linear( const skeleton_transforms& a, const skeleton_transforms& b, float t );
-                void interpolate_nlerp( const skeleton_transforms& a, const skeleton_transforms& b, float t );
-                void interpolate_slerp( const skeleton_transforms& a, const skeleton_transforms& b, float t );
-                void interpolate4( const skeleton_transforms& s1, const skeleton_transforms& v1, const skeleton_transforms& v2, const skeleton_transforms& s2, float t );
-                void interpolate_squad( const skeleton_transforms& s1, const skeleton_transforms& v1, const skeleton_transforms& v2, const skeleton_transforms& s2, float t );
-
-//              void animate( const mesh_nodes_data* node_data, float frame, bool local = false )
-//              {
-//                      if ( local )
-//                      {
-//                              animate_local( node_data, frame );
-//                              return;
-//                      }
-//                      if ( m_transforms.size() != node_data->size() )
-//                              m_transforms.resize( node_data->size() );
-//                      for ( uint32 n = 0; n < node_data->size(); ++n )
-//                              if ( node_data->get_info( n ).parent_id == -1 )
-//                                      animate_rec( node_data, frame, n, transform(), false );
-//              }
-                void blend_slerp( const skeleton_transforms& a, const skeleton_transforms& b, float t, float blend );
-
-//              void blend( const mesh_nodes_data* node_data, float frame, float blend, bool local = false )
-//              {
-//                      NV_ASSERT( m_transforms.size() == node_data->size(), "skeleton size wrong!" );
-//                      if ( local )
-//                      {
-//                              blend_local( node_data, frame, blend );
-//                              return;
-//                      }
-//                      for ( uint32 n = 0; n < node_data->size(); ++n )
-//                              if ( node_data->get_info( n ).parent_id == -1 )
-//                                      blend_rec( node_data, frame, n, transform(), false, blend );
-//              }
+                void interpolate( const skeleton_transforms& a, const skeleton_transforms& b, float t, interpolation i );
+                void interpolate( const skeleton_transforms& a, const skeleton_transforms& b, float t, interpolation i, const array_view< bool >& mask );
+                void interpolate( const skeleton_transforms& s1, const skeleton_transforms& v1, const skeleton_transforms& v2, const skeleton_transforms& s2, float t, interpolation i );
+                void interpolate( const skeleton_transforms& s1, const skeleton_transforms& v1, const skeleton_transforms& v2, const skeleton_transforms& s2, float t, interpolation i, const array_view< bool >& mask );
+                void blend( const skeleton_transforms& a, const skeleton_transforms& b, float t, interpolation i, float blend, interpolation bi );
+                void blend( const skeleton_transforms& a, const skeleton_transforms& b, float t, interpolation i, float blend, interpolation bi, const array_view< bool >& mask );
+                void blend( const skeleton_transforms& s1, const skeleton_transforms& v1, const skeleton_transforms& v2, const skeleton_transforms& s2, float t, interpolation i, float blend, interpolation bi );
+                void blend( const skeleton_transforms& s1, const skeleton_transforms& v1, const skeleton_transforms& v2, const skeleton_transforms& s2, float t, interpolation i, float blend, interpolation bi, const array_view< bool >& mask );
 
                 void delocalize( const data_node_tree& node_data )
@@ -134 +126 @@
                 void delocalize_rec( const data_node_tree& node_data, uint32 id, const transform& parent );
 
-//              void animate_rec( const mesh_nodes_data* node_data, float frame, uint32 id, const transform& parent, bool local );
-//              void blend_rec( const mesh_nodes_data* node_data, float frame, uint32 id, const transform& parent, bool local, float blend );
-//              void animate_local( const mesh_nodes_data* node_data, float frame );
-//              void blend_local( const mesh_nodes_data* node_data, float frame, float blend );
-
 //      protected:
                 dynamic_array< transform > m_transforms;
         };
 
+        template < typename Transform >
         class skeleton_instance
         {
         public:
+                typedef Transform value_type;
+
                 skeleton_instance() {}
-                const mat4* transforms() const { return m_matrix.data(); }
+                const mat4* xforms() const { return m_matrix.data(); }
                 size_t size() const { return m_matrix.size(); }
-                void assign( const skeleton_transforms& skeleton, const skeleton_binding& binding, const bone_transforms& bones );
-                void assign( const skeleton_transforms& skeleton, const bone_transforms& binding );
-                void assign( const bone_transforms& binding );
+                void assign( const skeleton_transforms& skeleton, const skeleton_binding& binding, const bone_transforms< value_type >& bones )
+                {
+                        if ( bones.size() != m_matrix.size() ) m_matrix.resize( bones.size() );
+                        const transform* transforms = skeleton.xforms();
+                        for ( uint32 n = 0; n < skeleton.size(); ++n )
+                        {
+                                sint16 bone_id = binding.m_indices[n];
+                                if ( bone_id >= 0 )
+                                {
+                                        //                      int too_complex;
+                                        //                      transform tr( bones.m_offsets[bone_id] );
+                                        //                      tr.set_orientation( normalize( tr.get_orientation() ) );
+                                        //                      m_matrix[bone_id] = ( transforms[n] * tr ).extract();
+                                        m_matrix[bone_id] = ( transforms[n] * bones.m_offsets[bone_id] ).extract();
+                                }
+                        }
+                }
+                void assign( const skeleton_transforms& skeleton, const bone_transforms< value_type >& bones )
+                {
+                        if ( bones.size() != m_matrix.size() ) m_matrix.resize( bones.size() );
+                        const transform* transforms = skeleton.xforms();
+                        for ( uint32 n = 0; n < skeleton.size(); ++n )
+                        {
+                                m_matrix[n] = ( transforms[n] * bones.m_offsets[n]  ).extract();
+                        }
+                }
+
+                void assign( const bone_transforms< value_type >& bones )
+                {
+                        if ( bones.size() != m_matrix.size() ) m_matrix.resize( bones.size() );
+                }
         protected:
 

trunk/nv/image/png_loader.hh

@@ -21 +21 @@
                 png_loader();
                 virtual bool get_info( stream&, image_format& format, ivec2& size );
+                virtual bool test( stream& );
                 virtual image_data* load( stream& );
                 virtual image_data* load( stream&, image_format format );

trunk/nv/interface/camera.hh

@@ -34 +34 @@
                 {
                         m_projection = math::perspective( math::radians( fov ), aspect, near, far );
+                        m_near = near;
+                        m_far  = far;
                 }
                 void set_ortho( f32 left, f32 right, f32 bottom, f32 top, f32 near = -1.0f, f32 far = 1.0f )
                 {
                         m_projection = math::ortho( left, right, bottom, top, near, far );
+                        m_near = near;
+                        m_far  = far;
                 }
                 const mat4& get_projection() const 
@@ -55 +59 @@
                         return m_direction;
                 }
+                float get_near() const { return m_near;  }
+                float get_far() const { return m_far; }
         private:
                 bool m_dirty;
@@ -61 +67 @@
                 mat4 m_projection;
                 mat4 m_view;
+                float m_near;
+                float m_far;
         };
 

trunk/nv/interface/device.hh

@@ -59 +59 @@
                 TEX_NORMAL   = 2,
                 TEX_GLOSS    = 3,
+                TEX_EMISSIVE = 4,
                 TEXTURE_0    = 0,
                 TEXTURE_1    = 1,
@@ -287 +288 @@
                 {
                         engine_uniform_factory_map& factory_map = get_uniform_factory();
+                        factory_map[ "nv_f_near"] = new engine_uniform_factory< engine_uniform_f_near >();
+                        factory_map[ "nv_f_far"]  = new engine_uniform_factory< engine_uniform_f_far >();
                         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 >();
@@ -316 +319 @@
                         factory_link_map[ "nv_t_normal"  ] = new engine_link_uniform_int<2>();
                         factory_link_map[ "nv_t_gloss"   ] = new engine_link_uniform_int<3>();
+                        factory_link_map[ "nv_t_emissive"] = new engine_link_uniform_int<4>();
                 }
                 void destroy_engine_uniforms()

trunk/nv/interface/image_data.hh

@@ -51 +51 @@
         public:
                 image_data( image_format format, ivec2 size, const uint8 * data ) 
-                        : m_format( format ), m_size( size ), m_data( nullptr ) { initialize( data ); }
+                        : m_format( format ), m_size( size ), m_data( nullptr )
+                {
+                        NV_ASSERT_ALWAYS( data, "Data = nullptr!" );
+                        initialize( data );
+                }
+                image_data( image_format format, ivec2 size )
+                        : m_format( format ), m_size( size ), m_data( nullptr )
+                {
+                        initialize( nullptr );
+                }
+                void fill( uint8 value = 0 )
+                {
+                        size_t bsize = static_cast<size_t>( m_size.x * m_size.y ) * get_depth();
+                        raw_fill_n( m_data, bsize, value );
+                }
                 uint8* release_data() { uint8* r = m_data; m_data = nullptr; return r; }
                 const uint8 * get_data()    const { return m_data; }
@@ -64 +78 @@
                         size_t bsize = static_cast<size_t>(m_size.x * m_size.y) * get_depth();
                         m_data = new uint8[ bsize ]; 
-                        raw_copy( data, data + bsize, m_data );
+                        if ( data )
+                                raw_copy( data, data + bsize, m_data );
                 }
 

trunk/nv/interface/image_loader.hh

@@ -25 +25 @@
         public:
                 virtual bool get_info( stream&, image_format& format, ivec2& size ) = 0;
+                virtual bool test( stream& ) = 0;
                 virtual image_data* load( stream& ) = 0;
                 virtual image_data* load( stream&, image_format format ) = 0;

trunk/nv/interface/uniform.hh

@@ -157 +157 @@
         typedef nv::unordered_map< string_view, engine_link_uniform_base* >    engine_link_uniform_factory_map;
 
+        class engine_uniform_f_near : public engine_uniform< float >
+        {
+        public:
+                engine_uniform_f_near( uniform_base* u ) : engine_uniform( u ) {}
+                virtual void set( const context*, const scene_state* s ) { m_uniform->set_value( s->get_camera().get_near() ); }
+        };
+
+        class engine_uniform_f_far : public engine_uniform< float >
+        {
+        public:
+                engine_uniform_f_far( uniform_base* u ) : engine_uniform( u ) {}
+                virtual void set( const context*, const scene_state* s ) { m_uniform->set_value( s->get_camera().get_far() ); }
+        };
+
         class engine_uniform_m_view : public engine_uniform< mat4 >
         {

trunk/nv/lua/lua_state.hh

@@ -298 +298 @@
                         bool has_field( string_view element );
                         shash64 get_string_hash_64( string_view element, uint64 defval = 0 );
+                        // remove this one
                         shash64 get_string( string_view element, string_table& table, uint64 defval = 0 );
+                        shash64 get_string( string_view element, string_table* table, uint64 defval = 0 );
                         const_string get_string( string_view element, string_view defval = string_view() );
                         string128 get_string128( string_view element, string_view defval = string_view() );

trunk/nv/stl/container/hash_table.hh

@@ -193 +193 @@
                                 m_bucket_count    = other.m_bucket_count;
                                 m_element_count   = other.m_element_count;
-                                m_max_load_factor = other.max_load_factor;
+                                m_max_load_factor = other.m_max_load_factor;
                         }
                         return *this;
@@ -619 +619 @@
                         {
                                 if ( base_type::rehash_check( 1 ) ) b = base_type::get_bucket_index( h );
-                                return insert_return_type( base_type::insert( b, h, ::nv::move(key), ::nv::forward< M >( obj ) ), true );
+                                return insert_return_type( base_type::insert( b, h, ::nv::move(key), ::nv::move< M >( obj ) ), true );
                         }
                         return insert_return_type( r, false );

trunk/nv/stl/hash_store.hh

@@ -104 +104 @@
                 {
                         insert_return_type result = base_type::try_insert( k, nv::forward<M>( obj ) );
-                        if ( !result.second ) result.first->second = obj;
+                        if ( !result.second ) result.first->second = nv::move(obj);
                         return result;
                 }

trunk/nv/stl/math/basic.hh

@@ -52 +52 @@
                                 typename T,
                                 typename Mix = T,
-                                bool MixBool = is_same< value_type_t<Mix>, bool >,
+                                bool MixBool = is_same< value_type_t<Mix>, bool >::value,
                                 bool TIsVector = is_vec<T>::value,
                                 bool MixIsVector = is_vec<Mix>::value >
@@ -274 +274 @@
                 }
 
+                template < typename T, typename enable_if< is_arithmetic<T>::value >::type* = nullptr >
+                constexpr T lerp( T a, T b, T m )
+                {
+                        return a + m * ( b - a );
+                }
+
+                template < typename T, typename enable_if< is_vec<T>::value >::type* = nullptr >
+                constexpr T lerp( const T& a, const T& b, value_type_t<T> m )
+                {
+                        return a + m * ( b - a );
+                }
+
                 template < typename T, typename enable_if< !is_vec<T>::value >::type* = nullptr >
                 constexpr T step( T edge, T x )

trunk/nv/stl/math/mat2.hh

@@ -287 +287 @@
 
                 template <typename T>
-                inline typename tmat2<T>::column_type operator*
-                        (
-                                const tmat2<T> & m,
-                                typename const tmat2<T>::row_type & v
-                                )
+                inline typename tmat2<T>::column_type operator* ( const tmat2<T> & m, const typename tmat2<T>::row_type & v )
                 {
                         return tvec2<T>(
@@ -299 +295 @@
 
                 template <typename T>
-                inline typename tmat2<T>::row_type operator*
-                        (
-                                typename const tmat2<T>::column_type & v,
-                                const tmat2<T> & m
-                                )
+                inline typename tmat2<T>::row_type operator* ( const typename tmat2<T>::column_type & v, const tmat2<T> & m )
                 {
                         return tvec2<T>(
@@ -337 +329 @@
 
                 template <typename T>
-                inline typename tmat2<T>::column_type operator/( const tmat2<T> & m, typename const tmat2<T>::row_type & v )
+                inline typename tmat2<T>::column_type operator/( const tmat2<T> & m, const typename tmat2<T>::row_type & v )
                 {
                         return detail::compute_inverse<T>( m ) * v;
@@ -343 +335 @@
 
                 template <typename T>
-                inline typename tmat2<T>::row_type operator/( typename const tmat2<T>::column_type & v, const tmat2<T> & m )
+                inline typename tmat2<T>::row_type operator/( const typename tmat2<T>::column_type & v, const tmat2<T> & m )
                 {
                         return v * detail::compute_inverse<T>( m );

trunk/nv/stl/math/mat3.hh

@@ -320 +320 @@
 
                 template <typename T>
-                inline typename tmat3<T>::column_type operator*( const tmat3<T> & m, typename const tmat3<T>::row_type & v )
+                inline typename tmat3<T>::column_type operator*( const tmat3<T> & m, const typename tmat3<T>::row_type & v )
                 {
                         return typename tmat3<T>::column_type(
@@ -329 +329 @@
 
                 template <typename T>
-                inline typename tmat3<T>::row_type operator*( typename const tmat3<T>::column_type & v, const tmat3<T> & m )
+                inline typename tmat3<T>::row_type operator*( const typename tmat3<T>::column_type & v, const tmat3<T> & m )
                 {
                         return typename tmat3<T>::row_type(
@@ -372 +372 @@
 
                 template <typename T>
-                inline typename tmat3<T>::column_type operator/( const tmat3<T> & m, typename const tmat3<T>::row_type & v )
+                inline typename tmat3<T>::column_type operator/( const tmat3<T> & m, const typename tmat3<T>::row_type & v )
                 {
                         return detail::compute_inverse<T>( m ) * v;
@@ -378 +378 @@
 
                 template <typename T>
-                inline typename tmat3<T>::row_type operator/( typename const tmat3<T>::column_type & v, const tmat3<T> & m )
+                inline typename tmat3<T>::row_type operator/( const typename tmat3<T>::column_type & v, const tmat3<T> & m )
                 {
                         return v * detail::compute_inverse<T>( m );

trunk/nv/stl/math/vec2.hh

@@ -98 +98 @@
                         {}
 
-                        inline tvec2<T> & tvec2<T>::operator+=( T scalar )
+                        inline tvec2<T> & operator+=( T scalar )
                         {
                                 this->x += static_cast<T>( scalar );

trunk/src/engine/material_manager.cc

@@ -12 +12 @@
 using namespace nv;
 
+
+nv::gpu_material_manager::gpu_material_manager( context* context, material_manager* matmgr, image_manager* imgmgr )
+        : m_context( context )
+        , m_material_manager( matmgr )
+        , m_image_manager( imgmgr )
+{
+        uint8 data[2 * 2 * 3];
+        nv::raw_fill_n( data, 2 * 2 * 3, 0 );
+        m_default = m_context->get_device()->create_texture( ivec2(2,2), nv::image_format( nv::RGB ), nv::sampler(), data );
+}
+
 bool gpu_material_manager::load_resource( const string_view& id )
 {
@@ -20 +31 @@
                 for ( uint32 i = 0; i < size( mat->paths ); ++i )
                         if ( !mat->paths[i].empty() )
+                        {
                                 if ( auto data = m_image_manager->get( mat->paths[i] ).lock() )
                                 {
                                         result->textures[i] = m_context->get_device()->create_texture( &*data, smp );
                                 }
+                        }
+
+                // HACK
+                for ( uint32 i = 0; i < 5; ++i )
+                        if ( result->textures[i].is_nil() )
+                                result->textures[i] = m_default;
+                        
                 add( id, result );
                 return true;
@@ -44 +63 @@
         m->paths[ TEX_SPECULAR ] = table.get_string128( "specular" );
         m->paths[ TEX_NORMAL ]   = table.get_string128( "normal" );
+        m->paths[ TEX_EMISSIVE ] = table.get_string128( "emissive" );
         m->paths[ TEX_GLOSS ]    = table.get_string128( "gloss" );
         add( id, m );

trunk/src/engine/resource_system.cc

@@ -23 +23 @@
 }
 
-void nv::lua_resource_manager_base::load_all()
+void nv::lua_resource_manager_base::load_all( bool do_clear )
 {
-        clear();
+        if ( do_clear ) clear();
         lua::table_guard table( m_lua, get_storage_name() );
         uint32 count = table.get_unsigned( "__counter" );

trunk/src/formats/assimp_loader.cc

@@ -133 +133 @@
         {
                 data_node_info info;
-                data_channel_set* data = data_channel_set_creator::create_set( 2 );
-                load_mesh_data( data, i, info );
-                m_meshes.push_back( data );
+                data_channel_set* mdata = data_channel_set_creator::create_set( 2 );
+                load_mesh_data( mdata, i, info );
+                m_meshes.push_back( mdata );
                 m_mesh_info.push_back( info );
         }
@@ -184 +184 @@
         int hack_for_node_anim;
         if ( is_node_animated() )
-                info.parent_id = index;
+                info.parent_id = sint16( index );
 
 
@@ -339 +339 @@
 }
 
-void nv::assimp_loader::build_skeleton( vector< data_node_info >& skeleton, const void* node, int parent_id )
+void nv::assimp_loader::build_skeleton( vector< data_node_info >& skeleton, const void* node, sint16 parent_id )
 {
         const aiNode* ainode = reinterpret_cast<const aiNode*>( node );
@@ -360 +360 @@
         info.parent_id = parent_id;
 
-        int this_id = skeleton.size();
+        sint16 this_id = sint16( skeleton.size() );
         skeleton.push_back( info );
         for ( unsigned i = 0; i < ainode->mNumChildren; ++i )
@@ -428 +428 @@
                 {
                         mat4 tr = nv::math::inverse( assimp_mat4_cast( m_data->node_by_name[bone_data[i].name]->mTransformation ) );
-                        bone_data[i].transform = tr * bone_data[bone_data[i].parent_id].transform;
+                        int pid = bone_data[i].parent_id;
+                        if ( pid != -1 )
+                                bone_data[i].transform = tr * bone_data[pid].transform;
+                        else
+                                bone_data[i].transform = tr;
                 }
 //              list->append( bone_data[i] );
@@ -449 +453 @@
         if ( scene->mRootNode == nullptr || scene->mAnimations == nullptr || scene->mAnimations[index] == nullptr) return nullptr;
 
-        const aiNode*      root = scene->mRootNode;
         const aiAnimation* anim = scene->mAnimations[index];
 
@@ -481 +484 @@
 }
 
-data_node_list* nv::assimp_loader::release_data_node_list( size_t index /*= 0 */ )
+data_node_list* nv::assimp_loader::release_data_node_list( size_t /*= 0 */ )
 {
         return release_merged_bones();

trunk/src/formats/nmd_loader.cc

@@ -261 +261 @@
         nmd_element_header pheader;
         pheader.type       = nv::nmd_type::POSES;
-        pheader.children   = poses.size();
+        pheader.children   = uint16( poses.size() );
         pheader.size       = sizeof( transform ) * poses.size() * ( poses.size() > 0 ? poses[0]->size() : 0 )
                                + sizeof( uint32 ) * poses.size();

trunk/src/gfx/skeleton_instance.cc

@@ -8 +8 @@
 
 #include "nv/core/profiler.hh"
+#include "nv/interface/interpolate.hh"
 
 void nv::skeleton_binding::assign( const skeleton_binding& other )
@@ -78 +79 @@
 }
 
-
-void nv::skeleton_instance::assign( const skeleton_transforms& skeleton, const skeleton_binding& binding, const bone_transforms& bones )
-{
-        if ( bones.size() != m_matrix.size() )
-                m_matrix.resize( bones.size() );
-        const transform* transforms = skeleton.xforms();
-        for ( uint32 n = 0; n < skeleton.size(); ++n )
-        {
-                sint16 bone_id = binding.m_indices[n];
-                if ( bone_id >= 0 )
-                {
-                        int too_complex;
-                        transform tr( bones.m_offsets[bone_id] );
-                        tr.set_orientation( normalize( tr.get_orientation() ) );
-                        m_matrix[bone_id] = ( transforms[n] * tr ).extract();
-                }
-        }
-}
-
-
-void nv::skeleton_instance::assign( const skeleton_transforms& skeleton, const bone_transforms& bones )
-{
-        if ( bones.size() != m_matrix.size() ) 
-                m_matrix.resize( bones.size() );
-        const transform* transforms = skeleton.xforms();
-        for ( uint32 n = 0; n < skeleton.size(); ++n )
-        {
-                transform tr( bones.m_offsets[n] );
-                tr.set_orientation( normalize( tr.get_orientation() ) );
-                m_matrix[n] = ( transforms[n] * tr ).extract();
-        //      m_matrix[n] = transforms[n].extract() * bones.m_offsets[n];
-        }
-}
-
-void nv::skeleton_instance::assign( const bone_transforms& bones )
-{
-        if ( bones.size() != m_matrix.size() )
-                m_matrix.resize( bones.size() );
-}
-
 void nv::skeleton_transforms::assign( const data_node_list* node_data )
 {
@@ -125 +86 @@
         for ( uint32 n = 0; n < node_data->size(); ++n )
         {
-                const data_node_info& info = (*node_data)[ n ];
-                m_transforms[n] = transform( info.transform );
+                m_transforms[n] = transform( ( *node_data )[n].transform );
         }
 }
 
-void nv::skeleton_transforms::interpolate_linear( const skeleton_transforms& a, const skeleton_transforms& b, float t )
+void nv::skeleton_transforms::assign( const skeleton_transforms& other, const array_view< bool >& mask )
+{
+        if ( m_transforms.size() != other.size() ) m_transforms.resize( other.size() );
+        if ( mask.size() == 0 )
+                m_transforms.assign( other.m_transforms );
+        else
+                for ( uint32 i = 0; i < other.size(); ++i )
+                        if ( mask[i] )
+                                m_transforms[i] = other.m_transforms[i];
+}
+
+void nv::skeleton_transforms::interpolate( const skeleton_transforms& a, const skeleton_transforms& b, float t, interpolation i )
+{
+        if ( m_transforms.size() != a.size() ) m_transforms.resize( a.size() );
+        ::nv::interpolate( m_transforms, t, i, a.m_transforms, b.m_transforms );
+}
+
+void nv::skeleton_transforms::interpolate( const skeleton_transforms& a, const skeleton_transforms& b, float t, interpolation i, const array_view< bool >& mask )
+{
+        if ( m_transforms.size() != a.size() ) m_transforms.resize( a.size() );
+        if ( mask.size() > 0 )
+                ::nv::interpolate( m_transforms, t, i, mask, a.m_transforms, b.m_transforms );
+        else
+                ::nv::interpolate( m_transforms, t, i, a.m_transforms, b.m_transforms );
+}
+
+void nv::skeleton_transforms::interpolate( const skeleton_transforms& s1, const skeleton_transforms& v1, const skeleton_transforms& v2, const skeleton_transforms& s2, float t, interpolation i )
+{
+        if ( m_transforms.size() != s1.size() ) m_transforms.resize( s1.size() );
+        ::nv::interpolate( m_transforms, t, i, s1.m_transforms, v1.m_transforms, v2.m_transforms, s2.m_transforms );
+}
+
+void nv::skeleton_transforms::interpolate( const skeleton_transforms& s1, const skeleton_transforms& v1, const skeleton_transforms& v2, const skeleton_transforms& s2, float t, interpolation i, const array_view< bool >& mask )
+{
+        if ( m_transforms.size() != s1.size() ) m_transforms.resize( s1.size() );
+        if ( mask.size() > 0 )
+                ::nv::interpolate( m_transforms, t, i, mask, s1.m_transforms, v1.m_transforms, v2.m_transforms, s2.m_transforms );
+        else
+                ::nv::interpolate( m_transforms, t, i, s1.m_transforms, v1.m_transforms, v2.m_transforms, s2.m_transforms );
+}
+
+void nv::skeleton_transforms::blend( const skeleton_transforms& a, const skeleton_transforms& b, float t, interpolation i, float blend, interpolation bi )
 {
         NV_ASSERT( a.size() == b.size(), "!!!" );
         if ( m_transforms.size() != a.size() )
                 m_transforms.resize( a.size() );
-        for ( uint32 n = 0; n < a.size(); ++n )
-        {
-                m_transforms[n] = transform(
-                        math::mix( a.m_transforms[n].get_position(), b.m_transforms[n].get_position(), t ),
-                        math::lerp( a.m_transforms[n].get_orientation(), b.m_transforms[n].get_orientation(), t )
-                        );
-        }
-
-//      if ( m_transforms.size() > 0 )
-//              m_transforms[0] = nv::interpolate( a.m_transforms[0], b.m_transforms[0], t, interpolation::SPHERICAL );
+        ::nv::interpolate( m_transforms, t, i, blend, bi, a.m_transforms, b.m_transforms );
 }
 
-void nv::skeleton_transforms::interpolate_nlerp( const skeleton_transforms& a, const skeleton_transforms& b, float t )
+void nv::skeleton_transforms::blend( const skeleton_transforms& a, const skeleton_transforms& b, float t, interpolation i, float blend, interpolation bi, const array_view< bool >& mask )
 {
         NV_ASSERT( a.size() == b.size(), "!!!" );
         if ( m_transforms.size() != a.size() )
                 m_transforms.resize( a.size() );
-
-        for ( uint32 n = 0; n < a.size(); ++n )
-        {
-                m_transforms[n] = transform(
-                        math::mix( a.m_transforms[n].get_position(), b.m_transforms[n].get_position(), t ),
-                        math::nlerp( a.m_transforms[n].get_orientation(), b.m_transforms[n].get_orientation(), t )
-                        );
-        }
+        if ( mask.size() > 0 )
+                ::nv::interpolate( m_transforms, t, i, blend, bi, mask, a.m_transforms, b.m_transforms );
+        else
+                ::nv::interpolate( m_transforms, t, i, blend, bi, a.m_transforms, b.m_transforms );
 }
 
-
-void nv::skeleton_transforms::interpolate_slerp( const skeleton_transforms& a, const skeleton_transforms& b, float t )
+void nv::skeleton_transforms::blend( const skeleton_transforms& s1, const skeleton_transforms& v1, const skeleton_transforms& v2, const skeleton_transforms& s2, float t, interpolation i, float blend, interpolation bi )
 {
-        NV_ASSERT( a.size() == b.size(), "!!!" );
-        if ( m_transforms.size() != a.size() )
-                m_transforms.resize( a.size() );
-        for ( uint32 n = 0; n < a.size(); ++n )
-        {
-                m_transforms[n] = nv::interpolate( a.m_transforms[n], b.m_transforms[n], t, interpolation::SPHERICAL );
-        }
+        if ( m_transforms.size() != s1.size() ) m_transforms.resize( s1.size() );
+        ::nv::interpolate( m_transforms, t, i, blend, bi, s1.m_transforms, v1.m_transforms, v2.m_transforms, s2.m_transforms );
 }
 
-void nv::skeleton_transforms::blend_slerp( const skeleton_transforms& a, const skeleton_transforms& b, float t, float blend )
+void nv::skeleton_transforms::blend( const skeleton_transforms& s1, const skeleton_transforms& v1, const skeleton_transforms& v2, const skeleton_transforms& s2, float t, interpolation i, float blend, interpolation bi, const array_view< bool >& mask )
 {
-        NV_ASSERT( a.size() == b.size(), "!!!" );
-        if ( m_transforms.size() != a.size() )
-                m_transforms.resize( a.size() );
-        for ( uint32 n = 0; n < a.size(); ++n )
-        {
-                transform tr    = nv::interpolate( a.m_transforms[n], b.m_transforms[n], t, interpolation::SPHERICAL );
-                m_transforms[n] = nv::interpolate( m_transforms[n], tr, blend, interpolation::SPHERICAL );
-        }
-}
-
-
-
-void nv::skeleton_transforms::interpolate4( const skeleton_transforms& s1, const skeleton_transforms& v1, const skeleton_transforms& v2, const skeleton_transforms& s2, float t )
-{
-        NV_ASSERT( s1.size() == s2.size(), "!!!" );
-        NV_ASSERT( v1.size() == v2.size(), "!!!" );
-        NV_ASSERT( s1.size() == v1.size(), "!!!" );
-        if ( m_transforms.size() != s1.size() )
-                m_transforms.resize( s1.size() );
-        float interp_squared = t*t;
-        float interp_cubed = interp_squared*t;
-        float weights[4];
-        weights[0] = 0.5f * ( -interp_cubed + 2.0f * interp_squared - t );
-        weights[1] = 0.5f * ( 3.0f * interp_cubed - 5.0f * interp_squared + 2.0f );
-        weights[2] = 0.5f * ( -3.0f * interp_cubed + 4.0f * interp_squared + t );
-        weights[3] = 0.5f * ( interp_cubed - interp_squared );
-
-        for ( uint32 n = 0; n < s1.size(); ++n )
-        {
-                quat qs1 = s1.m_transforms[n].get_orientation();
-                quat qs2 = s2.m_transforms[n].get_orientation();
-                quat qv1 = v1.m_transforms[n].get_orientation();
-                quat qv2 = v2.m_transforms[n].get_orientation();
-
-                float a = dot( qv1, qv2 ) > 0.0f ? 1.0f : -1.0f;
-
-                quat qr = weights[0] * qs1 
-                                + weights[1] * (a * qv1 )
-                                + weights[2] * qv2 
-                                + weights[3] * qs2;
-
-                qr = normalize( qr );
-
-                m_transforms[n] = transform(
-                        weights[0] * s1.m_transforms[n].get_position() +
-                        weights[1] * v1.m_transforms[n].get_position() +
-                        weights[2] * v2.m_transforms[n].get_position() +
-                        weights[3] * s2.m_transforms[n].get_position(),
-                        qr
-                );
-        }
-}
-
-
-void nv::skeleton_transforms::interpolate_squad( const skeleton_transforms& s1, const skeleton_transforms& v1, const skeleton_transforms& v2, const skeleton_transforms& s2, float t )
-{
-        NV_ASSERT( s1.size() == s2.size(), "!!!" );
-        NV_ASSERT( v1.size() == v2.size(), "!!!" );
-        NV_ASSERT( s1.size() == v1.size(), "!!!" );
-        if ( m_transforms.size() != s1.size() )
-                m_transforms.resize( s1.size() );
-
-        for ( uint32 n = 0; n < s1.size(); ++n )
-        {
-                nv::quat ss1 = s1.m_transforms[n].get_orientation();
-                nv::quat ss2 = s2.m_transforms[n].get_orientation();
-                nv::quat sv1 = v1.m_transforms[n].get_orientation();
-                nv::quat sv2 = v2.m_transforms[n].get_orientation();
-
-                nv::quat q = normalize( nv::math::squad(
-                        sv1, sv2,
-                        nv::math::intermediate( ss1, sv1, sv2 ),
-                        nv::math::intermediate( sv1, sv2, ss2 ),
-                        t ) );
-
-                m_transforms[n] = transform(
-                        mix( v1.m_transforms[n].get_position(), v2.m_transforms[n].get_position(), t ),
-                        q
-                        );
-        }
-        
+        if ( m_transforms.size() != s1.size() ) m_transforms.resize( s1.size() );
+        if ( mask.size() > 0 )
+                ::nv::interpolate( m_transforms, t, i, blend, bi, mask, s1.m_transforms, v1.m_transforms, v2.m_transforms, s2.m_transforms );
+        else
+                ::nv::interpolate( m_transforms, t, i, blend, bi, s1.m_transforms, v1.m_transforms, v2.m_transforms, s2.m_transforms );
 }
 
@@ -264 +170 @@
 }
 
-// void nv::skeleton_transforms::blend_local( const mesh_nodes_data* node_data, float frame, float blend )
-// {
-//      if ( m_transforms.size() != node_data->size() )
-//              m_transforms.resize( node_data->size() );
-//      for ( uint32 n = 0; n < node_data->size(); ++n )
-//      {
-//              const data_channel_set* node = ( *node_data )[n];
-//              int inefficient_store_key;
-// 
-//              transform tr = node->size() > 0 ? raw_channel_interpolator( node ).get< transform >( frame ) : transform( /*node->get_transform()*/ ); int confirm_that_not_needed;
-//              m_transforms[n] = nv::interpolate( m_transforms[n], tr, blend, interpolation::SPHERICAL );
-//      }
-// }
-// 
-// void nv::skeleton_transforms::animate_local( const mesh_nodes_data* node_data, float frame )
-// {
-//      if ( m_transforms.size() != node_data->size() )
-//              m_transforms.resize( node_data->size() );
-//      for ( uint32 n = 0; n < node_data->size(); ++n )
-//      {
-//              const data_channel_set* node = ( *node_data )[n];
-//              if ( node->size() > 0 )
-//              {
-//                      int inefficient_store_key;
-//                      m_transforms[n] = raw_channel_interpolator( node ).get< transform >( frame );
-//              }
-//      }
-// }
 
 void nv::skeleton_transforms::delocalize_rec( const data_node_tree& node_data, uint32 id, const transform& parent )
@@ -304 +182 @@
 }
 
-// void nv::skeleton_transforms::blend_rec( const mesh_nodes_data* node_data, float frame, uint32 id, const transform& parent, bool local, float blend )
-// {
-//      const data_channel_set* node = ( *node_data )[id];
-//      int confirm_that_not_needed;
-//      transform node_mat/*( node->get_transform() )*/;
-// 
-//      if ( node->size() > 0 )
-//      {
-//              int inefficient_store_key;
-// 
-//              raw_channel_interpolator interpolator( node );
-//              node_mat = interpolator.get< transform >( frame );
-//      }
-//      transform global_mat = parent * node_mat;
-//      m_transforms[id] = nv::interpolate( m_transforms[id], local ? node_mat : global_mat, blend, interpolation::SPHERICAL );
-//      for ( auto child : node_data->children( id ) )
-//      {
-//              blend_rec( node_data, frame, child, global_mat, local, blend );
-//      }
-// 
-// }
-// 
-// void nv::skeleton_transforms::animate_rec( const mesh_nodes_data* node_data, float frame, uint32 id, const transform& parent, bool local )
-// {
-//      const data_channel_set* node = ( *node_data )[id];
-//      transform node_mat;
-//      int inefficient_store_key;
-// 
-//      if ( node->size() > 0 )
-//              node_mat = raw_channel_interpolator( node ).get< transform >( frame );
-//      int confirm_that_not_needed;
-//      //      else
-//      //              node_mat = transform( node->get_transform() );
-//      transform global_mat = parent * node_mat;
-//      m_transforms[id] = local ? node_mat : global_mat;
-//      for ( auto child : node_data->children( id ) )
-//      {
-//              animate_rec( node_data, frame, child, global_mat, local );
-//      }
-// 
-// }
-
-void nv::bone_transforms::prepare( const data_node_list& bone_data )
-{
-        m_offsets.resize( bone_data.size() );
-
-        for ( nv::uint16 bi = 0; bi < bone_data.size(); ++bi )
-                m_offsets[bi] = bone_data[bi].transform;
-}

trunk/src/image/miniz.cc

@@ -813 +813 @@
         static void *def_alloc_func( void *opaque, size_t items, size_t size ) { (void)opaque, (void)items, (void)size; return MZ_MALLOC( items * size ); }
         static void def_free_func( void *opaque, void *address ) { (void)opaque, (void)address; MZ_FREE( address ); }
-        static void *def_realloc_func( void *opaque, void *address, size_t items, size_t size ) { (void)opaque, (void)address, (void)items, (void)size; return MZ_REALLOC( address, items * size ); }
+//      static void *def_realloc_func( void *opaque, void *address, size_t items, size_t size ) { (void)opaque, (void)address, (void)items, (void)size; return MZ_REALLOC( address, items * size ); }
 
         const char *mz_version( void )

trunk/src/image/png_loader.cc

@@ -665 +665 @@
 }
 
+
 static int stbi__unpremultiply_on_load = 0;
 static int stbi__de_iphone_flag = 0;
 
+/*
 static void stbi_set_unpremultiply_on_load( int flag_true_if_should_unpremultiply )
 {
@@ -677 +679 @@
         stbi__de_iphone_flag = flag_true_if_should_convert;
 }
+*/
 
 static void stbi__de_iphone( stbi__png *z )
@@ -1021 +1024 @@
 }
 
+bool nv::png_loader::test( stream& str )
+{
+        stbi__context s( &stbi__callbacks, (void *)&str );
+        return stbi__png_test( &s ) != 0;
+}
+
 image_data* nv::png_loader::load( stream& s )
 {

trunk/src/io/c_stream.cc

@@ -98 +98 @@
         if ( m_file != nullptr )
         {
-                return ::feof( reinterpret_cast<FILE*>( m_file ) );
+                return ::feof( reinterpret_cast<FILE*>( m_file ) ) != 0;
         }
+        return true;
 }

trunk/src/lua/lua_state.cc

@@ -194 +194 @@
                 str = lua_tolstring( m_state, -1, &l );
                 result = hash_string< uint64 >( str, l );
+                //NV_LOG_DEBUG( str );
         }
         lua_pop( m_state, 1 );
@@ -204 +205 @@
         size_t l = 0;
         const char* str = nullptr;
-        uint64 result = defval;
+        shash64 result = shash64( defval );
         if ( lua_type( m_state, -1 ) == LUA_TSTRING )
         {
                 str = lua_tolstring( m_state, -1, &l );
-                result = table.insert( string_view( str, l ) ).value();
-        }
-        lua_pop( m_state, 1 );
-        return shash64( result );
+                result = table.insert( string_view( str, l ) );
+        }
+        lua_pop( m_state, 1 );
+        return result;
+}
+
+nv::shash64 nv::lua::table_guard::get_string( string_view element, string_table* table, uint64 defval /*= 0 */ )
+{
+        lua_getfield( m_state, -1, element.data() );
+        size_t l = 0;
+        const char* str = nullptr;
+        shash64 result = shash64( defval );
+        if ( lua_type( m_state, -1 ) == LUA_TSTRING )
+        {
+                str = lua_tolstring( m_state, -1, &l );
+                string_view sv( str, l );
+                result = table ? table->insert( sv ) : shash64( sv );
+        }
+        lua_pop( m_state, 1 );
+        return result;
 }
 

trunk/src/sdl/sdl_window.cc

@@ -45 +45 @@
         }
 
-        //      NV_LOG( LOG_INFO, "Joystick count : " << SDL_NumJoysticks() );
-        //      SDL_Joystick* j = SDL_JoystickOpen(0);
-        //      if (j)
-        //      {
-        //              NV_LOG( LOG_INFO, "Joystick Name: " << SDL_JoystickNameForIndex(0) );
-        //              NV_LOG( LOG_INFO, "Joystick Number of Axes: " << SDL_JoystickNumAxes(j));
-        //              NV_LOG( LOG_INFO, "Joystick Number of Buttons: " << SDL_JoystickNumButtons(j));
-        //              NV_LOG( LOG_INFO, "Joystick Number of Balls: " << SDL_JoystickNumBalls(j));
-        //      }
+//      NV_LOG_INFO( "Joystick count : ", SDL_NumJoysticks() );
+//      SDL_Joystick* j = SDL_JoystickOpen(0);
+//      if ( j )
+//      {
+//              NV_LOG_INFO( "Joystick Name: ", SDL_JoystickNameForIndex( 0 ) );
+//              NV_LOG_INFO( "Joystick Number of Axes: ", SDL_JoystickNumAxes( j ) );
+//              NV_LOG_INFO( "Joystick Number of Buttons: ", SDL_JoystickNumButtons( j ) );
+//              NV_LOG_INFO( "Joystick Number of Balls: ", SDL_JoystickNumBalls( j ) );
+//      }
+
+        NV_LOG_INFO( "Joystick count : ", SDL_NumJoysticks() );
+        SDL_GameController *controller = NULL;
+        int controller_index = 0;
+        for ( int i = 0; i < SDL_NumJoysticks(); ++i )
+        {
+                if ( SDL_IsGameController( i ) )
+                {
+                        controller = SDL_GameControllerOpen( i );
+                        controller_index = i;
+                        if ( controller ) break;
+                        NV_LOG_ERROR( "Could not open gamecontroller ", i, ": ", SDL_GetError() );
+                }
+        }
+
+        if ( controller )
+        {
+                SDL_Joystick* j = SDL_GameControllerGetJoystick( controller );
+                NV_LOG_INFO( "Controller Name: ", SDL_GameControllerNameForIndex( controller_index ) );
+                NV_LOG_INFO( "Controller Number of Axes: ", SDL_JoystickNumAxes( j ) );
+                NV_LOG_INFO( "Controller Number of Buttons: ", SDL_JoystickNumButtons( j ) );
+                NV_LOG_INFO( "Controller Number of Balls: ", SDL_JoystickNumBalls( j ) );
+        }
+
+
 
         void* ctx_handle = SDL_GL_CreateContext( static_cast<SDL_Window*>( m_handle ) );