Changeset 486 for trunk


Ignore:
Timestamp:
02/24/16 18:47:54 (9 years ago)
Author:
epyon
Message:
  • mass update once again...
Location:
trunk
Files:
5 added
31 edited

Legend:

Unmodified
Added
Removed

  • trunk/nv.lua

    r484 r486  
    117117                if _ACTION == "gmake-clang" then
    118118                        buildoptions {
    119                                 "-std=c++11",
     119                                "-std=c++1z",
    120120--                                -- on Mac OS X don't try to use old stdc++
    121121--                                "-stdlib=libc++",
    122122                                "-Weverything",
     123                                -- math is so much easier with these
     124                                "-Wno-gnu-anonymous-struct",
     125                                "-Wno-nested-anon-types",
    123126                                -- obviously we don't care about C++98 compatibility
    124127                                "-Wno-c++98-compat",

  • trunk/nv/base/common.hh

    r471 r486  
    266266        constexpr T narrow_cast( const U& a )
    267267        {
     268                NV_MSVC_SUPRESS( 4806 );
    268269                return static_cast<T>( a & static_cast<T>( -1 ) );
    269270        }

  • trunk/nv/core/transform.hh

    r485 r486  
    1717        {
    1818        public:
     19                typedef float value_type;
     20
    1921                transform() {}
    2022                explicit transform( const vec3& a_position ) : m_position( a_position ) {}
    … …  
    106108        template <> struct type_to_enum< transform > { static const datatype type = TRANSFORM; };
    107109
     110        namespace math
     111        {
     112
     113                inline transform lerp( const transform& a, const transform& b, float value )
     114                {
     115                        return transform(
     116                                math::lerp( a.get_position(), b.get_position(), value ),
     117                                math::lerp( a.get_orientation(), b.get_orientation(), value )
     118                                );
     119                }
     120
     121        }
     122
    108123}
    109124

  • trunk/nv/engine/animation.hh

    r485 r486  
    1717#include <nv/core/resource.hh>
    1818#include <nv/interface/mesh_data.hh>
     19#include <nv/interface/easing.hh>
    1920#include <nv/gfx/skeleton_instance.hh>
    2021#include <nv/gfx/poses.hh>
     22#include <nv/engine/resource_system.hh>
    2123
    2224namespace nv
    2325{
    2426        class animator_bind_data;
    25         class animator_data;
     27        struct animator_data;
    2628}
    2729
    … …  
    3335{
    3436
    35         struct animator_clip_data
    36         {
    37                 uint32      id;
    38                 frame_range range;
    39         };
    40 
    41         class animator_data
     37        struct animator_pose_data
     38        {
     39                uint32 pose;
     40                // float  time;
     41                //      float      easing_data[4];
     42        };
     43
     44        struct animator_transition_data
     45        {
     46                uint32        target;
     47                float         duration;
     48                interpolation interp;
     49                easing        easing;
     50        };
     51
     52        typedef hash_store< shash64, animator_transition_data > animator_transition_table;
     53
     54        struct animator_state_data
     55        {
     56                shash64                      name;
     57                uint32                       base_pose;
     58                vector< animator_pose_data > poses;
     59                bool                         loop;
     60                float                        duration;
     61                interpolation                interp;
     62                animator_transition_table    transitions;
     63        };
     64
     65        struct animator_layer_data
     66        {
     67                shash64 name;
     68                sint32  def_state;
     69                sint32  mask;
     70                vector< bool >                mask_vector;
     71                vector< animator_state_data > states;
     72        };
     73
     74        struct animator_data
     75        {
     76                vector< animator_layer_data > layers;
     77                pose_data_set*                poses;
     78        };
     79
     80        struct animator_transition_instance : animator_transition_data
     81        {
     82                uint32        source;
     83                float         time;
     84
     85                animator_transition_instance() {}
     86
     87                animator_transition_instance( const animator_transition_data& data, uint32 source )
     88                        : animator_transition_data( data ), source( source ), time( 0.0f )
     89                {
     90
     91                }
     92        };
     93
     94        class animator_layer_instance
    4295        {
    4396        public:
    44                 animator_data( pose_data_set* data ) : m_data( data ) {}
    45                 //
    46                 pose_data_set* get_pose_data() { return m_data;  }
    47                 const pose_data_set* get_pose_data() const { return m_data; }
    48 
    49                 const animator_clip_data* get_clip( shash64 name ) const
    50                 {
    51                         auto it = m_clip_data.find( name );
    52                         return ( it != m_clip_data.end() ? &it->second : nullptr );
    53                 }
    54                 bool has_clip( shash64 name ) const
    55                 {
    56                         auto it = m_clip_data.find( name );
    57                         return it != m_clip_data.end();
    58                 }
    59                 void add_clip( shash64 name, animator_clip_data&& entry )
    60                 {
    61                         m_clip_data.assign( name, entry );
    62                 }
    63         protected:
    64                 pose_data_set* m_data;
    65                 hash_store< shash64, animator_clip_data > m_clip_data;
     97                vector< animator_transition_instance > m_transitions;
     98                uint32 m_current_state;
     99                float m_time;
     100
     101                animator_layer_instance() : m_current_state( 0 ), m_time( 0.0f ) {}
     102                void set_state( uint32 state ) { m_current_state = state; }
     103                uint32 get_state() const { return m_current_state; }
     104                uint32 get_final_state() const
     105                {
     106                        if ( m_transitions.size() > 0 )
     107                                return m_transitions.back().target;
     108                        return m_current_state;
     109                }
     110                void add_transition( const animator_transition_data& data, uint32 source )
     111                {
     112                        if ( m_transitions.size() > 0 )
     113                        {
     114                                auto& last = m_transitions.back();
     115                                if ( last.target == source && data.target == last.source )
     116                                {
     117                                        nv::swap( last.target, last.source );
     118                                        last.time = last.duration - last.time;
     119                                        return;
     120                                }
     121                        }
     122                        m_transitions.push_back( animator_transition_instance( data, source ) );
     123                }
     124                void reset()
     125                {
     126                        m_transitions.clear();
     127                        m_time = 0.0f;
     128                }
     129                void update( float dtime )
     130                {
     131                        if ( m_current_state != -1 )
     132                        {
     133                                float time = dtime;
     134                                while ( m_transitions.size() > 0 )
     135                                {
     136                                        animator_transition_instance& tr = m_transitions.front();
     137                                        m_current_state = tr.target;
     138                                        tr.time += time;
     139                                        if ( tr.time < tr.duration ) break;
     140                                        time -= ( tr.time - tr.duration );
     141                                        m_transitions.erase( m_transitions.begin() );
     142                                }
     143                                m_time += dtime;
     144                        }
     145                }
    66146        };
    67147
    … …  
    77157                        m_pose_binding.prepare( pose_frame, bones );
    78158                }
    79                 const bone_transforms& get_bone_transforms() const { return m_bone_transforms; }
     159                const bone_transforms< transform >& get_bone_transforms() const { return m_bone_transforms; }
    80160                const skeleton_binding& get_pose_binding() const
    81161                {
    … …  
    86166        protected:
    87167                skeleton_binding                        m_pose_binding;
    88                 bone_transforms                         m_bone_transforms;
     168                bone_transforms< transform >            m_bone_transforms;
    89169                data_node_list                          m_bone_list;
    90170        };
    … …  
    95175        public:
    96176                animator_instance() {}
    97                 void initialize( resource< animator_data > data, resource< animator_bind_data > bind_data )
    98                 {
    99                         m_data = data;
    100                         m_bind_data = bind_data;
    101                 }
    102                 bool is_valid() const { return m_data.is_valid() && m_bind_data.is_valid(); }
    103                 bool has_clip( shash64 id ) const
    104                 {
    105                         if ( auto data = m_data.lock() )
    106                                 return data->has_clip( id );
     177                void initialize( const animator_data* data )
     178                {
     179                        m_layers.clear();
     180                        m_layers.resize( data->layers.size() );
     181                        for ( uint32 i = 0; i < data->layers.size(); ++i )
     182                        {
     183                                m_layers[i].set_state( data->layers[i].def_state );
     184                        }
     185                }
     186
     187                const skeleton_transforms& get_transforms() const
     188                {
     189                        return m_transforms;
     190                }
     191
     192                uint32 base_state() const
     193                {
     194                        // HACK
     195                        if ( m_layers.size() > 1 && m_layers[0].m_transitions.size() < 1 ) return m_layers[0].get_state();
     196                        return 0;
     197                }
     198               
     199                void queue_event( const animator_data* data, shash64 name )
     200                {
     201                        for ( uint32 i = 0; i < m_layers.size(); ++i )
     202                                // what about activating nonactive layers?
     203                                if ( m_layers[i].m_current_state != -1 )
     204                                {
     205                                        uint32 last_state = m_layers[i].get_final_state();
     206                                        const animator_state_data& state = data->layers[i].states[last_state];
     207                                        auto it = state.transitions.find( name );
     208                                        if ( it != state.transitions.end() )
     209                                        {
     210                                                m_layers[i].add_transition( it->second, last_state );
     211                                        }
     212                                }
     213                }
     214
     215                void update( const animator_data* data, float dtime )
     216                {
     217                        for ( uint32 i = 0; i < m_layers.size(); ++i )
     218                                m_layers[i].update( dtime );
     219
     220                        for ( uint32 i = 0; i < m_layers.size(); ++ i )
     221                                if ( m_layers[i].m_current_state != -1 )
     222                                {
     223                                        if ( m_layers[i].m_transitions.size() > 0 )
     224                                        {
     225                                                animate_layer( data->layers[i], m_layers[i].m_transitions.front(), data->poses, m_layers[i].m_time );
     226                                        }
     227                                        else
     228                                        {
     229                                                const animator_layer_data& layer = data->layers[i];
     230                                                const animator_state_data& state = layer.states[m_layers[i].m_current_state];
     231                                                if ( state.poses.size() > 0 )
     232                                                        animate_state( m_transforms, state, data->layers[i], data->poses, get_frame( state, m_layers[i].m_time ) );
     233                                        }
     234                                }
     235
     236                        m_transforms.delocalize( data->poses->get_tree() );
     237                }
     238
     239                void reset()
     240                {
     241                        for ( uint32 i = 0; i < m_layers.size(); ++i )
     242                                m_layers[i].reset();
     243                }
     244
     245                void update_state_only( const animator_data* data, float dtime, uint32 layer_id, uint32 state_id )
     246                {
     247                        const animator_layer_data& layer = data->layers[layer_id];
     248                        const animator_state_data& state = layer.states[state_id];
     249                        m_layers[layer_id].update( dtime );
     250                        if ( state.poses.size() > 0 )
     251                                animate_state( m_transforms, state, layer, data->poses, get_frame( state, m_layers[layer_id].m_time ) );
     252                        m_transforms.delocalize( data->poses->get_tree() );
     253                }
     254
     255                void update_layer_only( const animator_data* data, float dtime, uint32 layer_id )
     256                {
     257                        const animator_layer_data& ldata     = data->layers[layer_id];
     258                        const animator_layer_instance& linst = m_layers[layer_id];
     259                        m_layers[layer_id].update( dtime );
     260                        if ( m_layers[layer_id].m_transitions.size() > 0 )
     261                        {
     262                                animate_layer( ldata, linst.m_transitions.front(), data->poses, linst.m_time );
     263                        }
    107264                        else
    108                                 return false;
    109                 }
    110                 mat4 get_transform( uint32 idx ) const
    111                 {
    112                         if ( idx < m_skeleton.size() ) return m_skeleton.transforms()[idx];
    113                         return mat4();
    114                 }
    115                 const skeleton_instance& get_skeleton() const
    116                 {
    117                         return m_skeleton;
    118                 }
    119 
    120                 sint16 get_bone_index( shash64 bone_name ) const
    121                 {
    122                         if ( is_valid() )
    123                         {
    124                                 auto data = m_bind_data.lock();
    125                                 sint16 id = data->get_bone_list().resolve( bone_name );
    126                                 return id;
    127                         }
    128                         return -1;
    129                 }
    130 
    131                 const mat4& get_bone_matrix( shash64 bone_name ) const
    132                 {
    133                         if ( is_valid() )
    134                         {
    135                                 auto data = m_bind_data.lock();
    136                                 sint16 id = data->get_bone_list().resolve( bone_name );
    137                                 if ( id >= 0 )
    138                                 {
    139                                         return data->get_bone_list()[id].transform;
    140                                 }
    141                         }
    142                         return mat4();
    143                 }
    144 
    145 
    146                 void update( shash64 clip, uint32 time )
    147                 {
    148                         if ( is_valid() )
    149                         {
    150                                 auto data = m_data.lock();
    151                                 auto bind_data = m_bind_data.lock();
    152                                 const animator_clip_data* clip_data = data->get_clip( clip );
    153 
    154                                 if ( data->get_pose_data() )
    155                                 {
    156                                         if ( clip_data )
    157                                         {
    158                                                 auto pose_data = data->get_pose_data();
    159                                                 float fframe = clip_data->range.frame_from_ms_fps( time, 30 );
    160 
    161                                                 unsigned v1 = unsigned( fframe );
    162                                                 unsigned v2 = v1 + 1;
    163                                                 if ( v2 >= clip_data->range.end ) v2 = clip_data->range.start;
    164 
    165                                                 unsigned iv1 = v1 + clip_data->id;
    166                                                 unsigned iv2 = v2 + clip_data->id;
    167 
    168                                                 m_transforms.interpolate_slerp( pose_data->get( iv1 ), pose_data->get( iv2 ), fframe - v1 );
    169                                                 m_transforms.delocalize( pose_data->get_tree() );
    170 
    171                                         }
    172                                         m_skeleton.assign( m_transforms, bind_data->get_pose_binding(), bind_data->get_bone_transforms() );
    173                                 }
    174                         }
    175                 }
     265                        {
     266                                const animator_state_data& state = ldata.states[linst.m_current_state];
     267                                if ( state.poses.size() > 0 )
     268                                        animate_state( m_transforms, state, ldata, data->poses, get_frame( state, linst.m_time ) );
     269                        }
     270                        m_transforms.delocalize( data->poses->get_tree() );
     271                }
     272
    176273        protected:
    177                 resource< animator_data >      m_data;
    178                 resource< animator_bind_data > m_bind_data;
    179                 skeleton_transforms            m_transforms;
    180                 skeleton_instance              m_skeleton;
     274
     275                void animate_layer( const animator_layer_data& layer, const animator_transition_instance& transition, pose_data_set* pose_data, float t )
     276                {
     277                        const animator_state_data& base_state = layer.states[transition.source];
     278                        if ( base_state.poses.size() > 0 )
     279                                animate_state( m_transforms, base_state, layer, pose_data, get_frame( base_state, t ) );
     280
     281                        float trblend = 0.0f;
     282                        if ( transition.duration > 0.0f )
     283                        {
     284                                trblend = math::clamp( transition.time / transition.duration, 0.0f, 1.0f );
     285                                trblend = easing_eval( trblend, transition.easing );
     286                        }
     287
     288                        const animator_state_data& state = layer.states[transition.target];
     289                        if ( state.poses.size() > 0 )
     290                                animate_state( m_transforms, state, layer, pose_data, get_frame( state, t ), true, trblend, transition.interp );
     291                }
     292
     293                static float get_frame( const animator_state_data& state, float layer_time )
     294                {
     295                        uint32 fcount = state.poses.size();
     296                        float fframe = 0.0f;
     297                        if ( state.duration > nv::math::epsilon<float>() )
     298                        {
     299                                float fps = fcount / state.duration;
     300                                float ctime = state.loop ? fmodf( layer_time, state.duration ) : min( layer_time, state.duration - 0.0001f );
     301                                fframe = ctime * fps;
     302                        }
     303                        return fframe;
     304                }
     305
     306                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 )
     307                {
     308                        unsigned v1 = unsigned( fframe );
     309                        unsigned v2 = v1 + 1;
     310                        if ( v2 >= state.poses.size() ) v2 = state.loop ? 0 : state.poses.size() - 1;
     311
     312                        unsigned iv1 = state.poses[v1].pose;
     313                        unsigned iv2 = state.poses[v2].pose;
     314
     315
     316                        if ( iv1 == iv2 )
     317                        {
     318                                if ( do_blend )
     319                                        transforms.interpolate( transforms, pose_data->get( iv1 ), blend, binterp, layer.mask_vector );
     320                                else
     321                                        transforms.assign( pose_data->get( iv1 ), layer.mask_vector );
     322                        }
     323                        else
     324                        {
     325                                if ( state.interp == interpolation::QUADRATIC || state.interp == interpolation::SQUADRATIC )
     326                                {
     327                                        unsigned s1 = v1 == 0 ? state.poses.size() - 1 : v1 - 1;
     328                                        unsigned s2 = v2 + 1;
     329                                        if ( s2 >= state.poses.size() ) s2 = state.loop ? 0 : state.poses.size() - 1;
     330                                        unsigned is1 = state.poses[s1].pose;
     331                                        unsigned is2 = state.poses[s2].pose;
     332                                        if ( do_blend )
     333                                                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 );
     334                                        else
     335                                                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 );
     336                                }
     337                                else
     338                                {
     339                                        if ( do_blend )
     340                                                transforms.blend( pose_data->get( iv1 ), pose_data->get( iv2 ), fframe - v1, state.interp, blend, binterp, layer.mask_vector );
     341                                        else
     342                                                transforms.interpolate( pose_data->get( iv1 ), pose_data->get( iv2 ), fframe - v1, state.interp, layer.mask_vector );
     343                                }       
     344                        }
     345                }
     346
     347                vector< animator_layer_instance > m_layers;
     348                skeleton_transforms               m_transforms;
     349
     350
     351        };
     352
     353        class animator_manager : public nv::lua_resource_manager< animator_data >
     354        {
     355        public:
     356                explicit animator_manager( nv::string_table* strings = nullptr ) : m_strings( strings ) {}
     357                virtual nv::string_view get_storage_name() const { return "animators"; }
     358                virtual nv::string_view get_resource_name() const { return "animator"; }
     359
     360                nv::resource< animator_data > load_animator( const nv::string_view& id, nv::pose_data_set* poses = nullptr );
     361                nv::resource< animator_data > create_animator( const nv::string_view& id, nv::pose_data_set* poses = nullptr );
     362        protected:
     363                virtual bool load_resource( nv::lua::table_guard& table, nv::shash64 id );
     364                nv::resource< animator_data > load_animator( nv::lua::table_guard& table, nv::shash64 id, nv::pose_data_set* poses = nullptr );
     365
     366                nv::easing read_easing( nv::lua::table_guard& table );
     367                void fill_mask_vector_rec( nv::vector< bool >& mask_vector, const nv::data_node_tree& tree, nv::uint32 id )
     368                {
     369                        mask_vector[id] = true;
     370                        for ( auto child : tree.children( id ) )
     371                                fill_mask_vector_rec( mask_vector, tree, child );
     372                }
     373               
     374                nv::string_table* m_strings;
    181375        };
    182376

  • trunk/nv/engine/material_manager.hh

    r484 r486  
    5151        {
    5252        public:
    53                 gpu_material_manager( context* context, material_manager* matmgr, image_manager* imgmgr )
    54                         : m_context( context )
    55                         , m_material_manager( matmgr )
    56                         , m_image_manager( imgmgr )
    57                 {}
     53                gpu_material_manager( context* context, material_manager* matmgr, image_manager* imgmgr );
    5854        protected:
    5955                virtual bool load_resource( const string_view& id );
    6056                virtual void release( gpu_material* m );
    6157        private:
     58                texture           m_default;
    6259                context*          m_context;
    6360                material_manager* m_material_manager;

  • trunk/nv/engine/resource_system.hh

    r484 r486  
    5555                virtual string_view get_resource_name() const = 0;
    5656                virtual void clear() = 0;
    57                 void load_all();
     57                void load_all( bool do_clear = true );
    5858                virtual bool load_resource( const string_view& id );
    5959                virtual ~lua_resource_manager_base() {}

  • trunk/nv/formats/assimp_loader.hh

    r485 r486  
    3434        private:
    3535                bool is_node_animated();
    36                 void build_skeleton( vector< data_node_info >& skeleton, const void* node, int parent_id );
     36                void build_skeleton( vector< data_node_info >& skeleton, const void* node, sint16 parent_id );
    3737                data_node_list* release_merged_bones();
    3838                void load_mesh_data( data_channel_set* data, size_t index, data_node_info& info );

  • trunk/nv/gfx/skeleton_instance.hh

    r485 r486  
    4848                        return clamp_frame( ( ms * 0.001f ) * float( fps ) );
    4949                }
     50
     51                inline float frame_from_ms_fps( uint32 ms, float fps ) const
     52                {
     53                        return clamp_frame( ( ms * 0.001f ) * fps );
     54                }
    5055        };
    5156
     57        template < typename Transform >
    5258        class bone_transforms
    5359        {
    5460        public:
     61                typedef Transform value_type;
     62
    5563                bone_transforms() {}
    56                 void prepare( const data_node_list& bone_data );
     64                void prepare( const data_node_list& bone_data )
     65                {
     66                        m_offsets.resize( bone_data.size() );
     67                        for ( uint16 bi = 0; bi < bone_data.size(); ++bi )
     68                                m_offsets[bi] = value_type( bone_data[bi].transform );
     69                }
     70
    5771                uint32 size() const { return m_offsets.size(); };
    5872        protected:
    59                 dynamic_array< mat4 >   m_offsets;
     73                dynamic_array< value_type >   m_offsets;
    6074
     75                template < typename T >
    6176                friend class skeleton_instance;
    6277        };
    … …  
    7691                uint32                  m_bone_count;
    7792
     93                template < typename T >
    7894                friend class skeleton_instance;
    7995                friend class skeleton_transforms;
    … …  
    90106                void assign( const data_node_list* node_data );
    91107                void assign( const skeleton_transforms& other );
     108                void assign( const skeleton_transforms& other, const array_view< bool >& mask );
    92109
    93                 void interpolate_linear( const skeleton_transforms& a, const skeleton_transforms& b, float t );
    94                 void interpolate_nlerp( const skeleton_transforms& a, const skeleton_transforms& b, float t );
    95                 void interpolate_slerp( const skeleton_transforms& a, const skeleton_transforms& b, float t );
    96                 void interpolate4( const skeleton_transforms& s1, const skeleton_transforms& v1, const skeleton_transforms& v2, const skeleton_transforms& s2, float t );
    97                 void interpolate_squad( const skeleton_transforms& s1, const skeleton_transforms& v1, const skeleton_transforms& v2, const skeleton_transforms& s2, float t );
    98 
    99 //              void animate( const mesh_nodes_data* node_data, float frame, bool local = false )
    100 //              {
    101 //                      if ( local )
    102 //                      {
    103 //                              animate_local( node_data, frame );
    104 //                              return;
    105 //                      }
    106 //                      if ( m_transforms.size() != node_data->size() )
    107 //                              m_transforms.resize( node_data->size() );
    108 //                      for ( uint32 n = 0; n < node_data->size(); ++n )
    109 //                              if ( node_data->get_info( n ).parent_id == -1 )
    110 //                                      animate_rec( node_data, frame, n, transform(), false );
    111 //              }
    112                 void blend_slerp( const skeleton_transforms& a, const skeleton_transforms& b, float t, float blend );
    113 
    114 //              void blend( const mesh_nodes_data* node_data, float frame, float blend, bool local = false )
    115 //              {
    116 //                      NV_ASSERT( m_transforms.size() == node_data->size(), "skeleton size wrong!" );
    117 //                      if ( local )
    118 //                      {
    119 //                              blend_local( node_data, frame, blend );
    120 //                              return;
    121 //                      }
    122 //                      for ( uint32 n = 0; n < node_data->size(); ++n )
    123 //                              if ( node_data->get_info( n ).parent_id == -1 )
    124 //                                      blend_rec( node_data, frame, n, transform(), false, blend );
    125 //              }
     110                void interpolate( const skeleton_transforms& a, const skeleton_transforms& b, float t, interpolation i );
     111                void interpolate( const skeleton_transforms& a, const skeleton_transforms& b, float t, interpolation i, const array_view< bool >& mask );
     112                void interpolate( const skeleton_transforms& s1, const skeleton_transforms& v1, const skeleton_transforms& v2, const skeleton_transforms& s2, float t, interpolation i );
     113                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 );
     114                void blend( const skeleton_transforms& a, const skeleton_transforms& b, float t, interpolation i, float blend, interpolation bi );
     115                void blend( const skeleton_transforms& a, const skeleton_transforms& b, float t, interpolation i, float blend, interpolation bi, const array_view< bool >& mask );
     116                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 );
     117                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 );
    126118
    127119                void delocalize( const data_node_tree& node_data )
    … …  
    134126                void delocalize_rec( const data_node_tree& node_data, uint32 id, const transform& parent );
    135127
    136 //              void animate_rec( const mesh_nodes_data* node_data, float frame, uint32 id, const transform& parent, bool local );
    137 //              void blend_rec( const mesh_nodes_data* node_data, float frame, uint32 id, const transform& parent, bool local, float blend );
    138 //              void animate_local( const mesh_nodes_data* node_data, float frame );
    139 //              void blend_local( const mesh_nodes_data* node_data, float frame, float blend );
    140 
    141128//      protected:
    142129                dynamic_array< transform > m_transforms;
    143130        };
    144131
     132        template < typename Transform >
    145133        class skeleton_instance
    146134        {
    147135        public:
     136                typedef Transform value_type;
     137
    148138                skeleton_instance() {}
    149                 const mat4* transforms() const { return m_matrix.data(); }
     139                const mat4* xforms() const { return m_matrix.data(); }
    150140                size_t size() const { return m_matrix.size(); }
    151                 void assign( const skeleton_transforms& skeleton, const skeleton_binding& binding, const bone_transforms& bones );
    152                 void assign( const skeleton_transforms& skeleton, const bone_transforms& binding );
    153                 void assign( const bone_transforms& binding );
     141                void assign( const skeleton_transforms& skeleton, const skeleton_binding& binding, const bone_transforms< value_type >& bones )
     142                {
     143                        if ( bones.size() != m_matrix.size() ) m_matrix.resize( bones.size() );
     144                        const transform* transforms = skeleton.xforms();
     145                        for ( uint32 n = 0; n < skeleton.size(); ++n )
     146                        {
     147                                sint16 bone_id = binding.m_indices[n];
     148                                if ( bone_id >= 0 )
     149                                {
     150                                        //                      int too_complex;
     151                                        //                      transform tr( bones.m_offsets[bone_id] );
     152                                        //                      tr.set_orientation( normalize( tr.get_orientation() ) );
     153                                        //                      m_matrix[bone_id] = ( transforms[n] * tr ).extract();
     154                                        m_matrix[bone_id] = ( transforms[n] * bones.m_offsets[bone_id] ).extract();
     155                                }
     156                        }
     157                }
     158                void assign( const skeleton_transforms& skeleton, const bone_transforms< value_type >& bones )
     159                {
     160                        if ( bones.size() != m_matrix.size() ) m_matrix.resize( bones.size() );
     161                        const transform* transforms = skeleton.xforms();
     162                        for ( uint32 n = 0; n < skeleton.size(); ++n )
     163                        {
     164                                m_matrix[n] = ( transforms[n] * bones.m_offsets[n]  ).extract();
     165                        }
     166                }
     167
     168                void assign( const bone_transforms< value_type >& bones )
     169                {
     170                        if ( bones.size() != m_matrix.size() ) m_matrix.resize( bones.size() );
     171                }
    154172        protected:
    155173

  • trunk/nv/image/png_loader.hh

    r484 r486  
    2121                png_loader();
    2222                virtual bool get_info( stream&, image_format& format, ivec2& size );
     23                virtual bool test( stream& );
    2324                virtual image_data* load( stream& );
    2425                virtual image_data* load( stream&, image_format format );

  • trunk/nv/interface/camera.hh

    r472 r486  
    3434                {
    3535                        m_projection = math::perspective( math::radians( fov ), aspect, near, far );
     36                        m_near = near;
     37                        m_far  = far;
    3638                }
    3739                void set_ortho( f32 left, f32 right, f32 bottom, f32 top, f32 near = -1.0f, f32 far = 1.0f )
    3840                {
    3941                        m_projection = math::ortho( left, right, bottom, top, near, far );
     42                        m_near = near;
     43                        m_far  = far;
    4044                }
    4145                const mat4& get_projection() const
    … …  
    5559                        return m_direction;
    5660                }
     61                float get_near() const { return m_near;  }
     62                float get_far() const { return m_far; }
    5763        private:
    5864                bool m_dirty;
    … …  
    6167                mat4 m_projection;
    6268                mat4 m_view;
     69                float m_near;
     70                float m_far;
    6371        };
    6472

  • trunk/nv/interface/device.hh

    r485 r486  
    5959                TEX_NORMAL   = 2,
    6060                TEX_GLOSS    = 3,
     61                TEX_EMISSIVE = 4,
    6162                TEXTURE_0    = 0,
    6263                TEXTURE_1    = 1,
    … …  
    287288                {
    288289                        engine_uniform_factory_map& factory_map = get_uniform_factory();
     290                        factory_map[ "nv_f_near"] = new engine_uniform_factory< engine_uniform_f_near >();
     291                        factory_map[ "nv_f_far"]  = new engine_uniform_factory< engine_uniform_f_far >();
    289292                        factory_map[ "nv_m_view" ]          = new engine_uniform_factory< engine_uniform_m_view >();
    290293                        factory_map[ "nv_m_view_inv" ]      = new engine_uniform_factory< engine_uniform_m_view_inv >();
    … …  
    316319                        factory_link_map[ "nv_t_normal"  ] = new engine_link_uniform_int<2>();
    317320                        factory_link_map[ "nv_t_gloss"   ] = new engine_link_uniform_int<3>();
     321                        factory_link_map[ "nv_t_emissive"] = new engine_link_uniform_int<4>();
    318322                }
    319323                void destroy_engine_uniforms()

  • trunk/nv/interface/image_data.hh

    r472 r486  
    5151        public:
    5252                image_data( image_format format, ivec2 size, const uint8 * data )
    53                         : m_format( format ), m_size( size ), m_data( nullptr ) { initialize( data ); }
     53                        : m_format( format ), m_size( size ), m_data( nullptr )
     54                {
     55                        NV_ASSERT_ALWAYS( data, "Data = nullptr!" );
     56                        initialize( data );
     57                }
     58                image_data( image_format format, ivec2 size )
     59                        : m_format( format ), m_size( size ), m_data( nullptr )
     60                {
     61                        initialize( nullptr );
     62                }
     63                void fill( uint8 value = 0 )
     64                {
     65                        size_t bsize = static_cast<size_t>( m_size.x * m_size.y ) * get_depth();
     66                        raw_fill_n( m_data, bsize, value );
     67                }
    5468                uint8* release_data() { uint8* r = m_data; m_data = nullptr; return r; }
    5569                const uint8 * get_data()    const { return m_data; }
    … …  
    6478                        size_t bsize = static_cast<size_t>(m_size.x * m_size.y) * get_depth();
    6579                        m_data = new uint8[ bsize ];
    66                         raw_copy( data, data + bsize, m_data );
     80                        if ( data )
     81                                raw_copy( data, data + bsize, m_data );
    6782                }
    6883

  • trunk/nv/interface/image_loader.hh

    r484 r486  
    2525        public:
    2626                virtual bool get_info( stream&, image_format& format, ivec2& size ) = 0;
     27                virtual bool test( stream& ) = 0;
    2728                virtual image_data* load( stream& ) = 0;
    2829                virtual image_data* load( stream&, image_format format ) = 0;

  • trunk/nv/interface/uniform.hh

    r472 r486  
    157157        typedef nv::unordered_map< string_view, engine_link_uniform_base* >    engine_link_uniform_factory_map;
    158158
     159        class engine_uniform_f_near : public engine_uniform< float >
     160        {
     161        public:
     162                engine_uniform_f_near( uniform_base* u ) : engine_uniform( u ) {}
     163                virtual void set( const context*, const scene_state* s ) { m_uniform->set_value( s->get_camera().get_near() ); }
     164        };
     165
     166        class engine_uniform_f_far : public engine_uniform< float >
     167        {
     168        public:
     169                engine_uniform_f_far( uniform_base* u ) : engine_uniform( u ) {}
     170                virtual void set( const context*, const scene_state* s ) { m_uniform->set_value( s->get_camera().get_far() ); }
     171        };
     172
    159173        class engine_uniform_m_view : public engine_uniform< mat4 >
    160174        {

  • trunk/nv/lua/lua_state.hh

    r445 r486  
    298298                        bool has_field( string_view element );
    299299                        shash64 get_string_hash_64( string_view element, uint64 defval = 0 );
     300                        // remove this one
    300301                        shash64 get_string( string_view element, string_table& table, uint64 defval = 0 );
     302                        shash64 get_string( string_view element, string_table* table, uint64 defval = 0 );
    301303                        const_string get_string( string_view element, string_view defval = string_view() );
    302304                        string128 get_string128( string_view element, string_view defval = string_view() );

  • trunk/nv/stl/container/hash_table.hh

    r432 r486  
    193193                                m_bucket_count    = other.m_bucket_count;
    194194                                m_element_count   = other.m_element_count;
    195                                 m_max_load_factor = other.max_load_factor;
     195                                m_max_load_factor = other.m_max_load_factor;
    196196                        }
    197197                        return *this;
    … …  
    619619                        {
    620620                                if ( base_type::rehash_check( 1 ) ) b = base_type::get_bucket_index( h );
    621                                 return insert_return_type( base_type::insert( b, h, ::nv::move(key), ::nv::forward< M >( obj ) ), true );
     621                                return insert_return_type( base_type::insert( b, h, ::nv::move(key), ::nv::move< M >( obj ) ), true );
    622622                        }
    623623                        return insert_return_type( r, false );

  • trunk/nv/stl/hash_store.hh

    r433 r486  
    104104                {
    105105                        insert_return_type result = base_type::try_insert( k, nv::forward<M>( obj ) );
    106                         if ( !result.second ) result.first->second = obj;
     106                        if ( !result.second ) result.first->second = nv::move(obj);
    107107                        return result;
    108108                }

  • trunk/nv/stl/math/basic.hh

    r471 r486  
    5252                                typename T,
    5353                                typename Mix = T,
    54                                 bool MixBool = is_same< value_type_t<Mix>, bool >,
     54                                bool MixBool = is_same< value_type_t<Mix>, bool >::value,
    5555                                bool TIsVector = is_vec<T>::value,
    5656                                bool MixIsVector = is_vec<Mix>::value >
    … …  
    274274                }
    275275
     276                template < typename T, typename enable_if< is_arithmetic<T>::value >::type* = nullptr >
     277                constexpr T lerp( T a, T b, T m )
     278                {
     279                        return a + m * ( b - a );
     280                }
     281
     282                template < typename T, typename enable_if< is_vec<T>::value >::type* = nullptr >
     283                constexpr T lerp( const T& a, const T& b, value_type_t<T> m )
     284                {
     285                        return a + m * ( b - a );
     286                }
     287
    276288                template < typename T, typename enable_if< !is_vec<T>::value >::type* = nullptr >
    277289                constexpr T step( T edge, T x )

  • trunk/nv/stl/math/mat2.hh

    r471 r486  
    287287
    288288                template <typename T>
    289                 inline typename tmat2<T>::column_type operator*
    290                         (
    291                                 const tmat2<T> & m,
    292                                 typename const tmat2<T>::row_type & v
    293                                 )
     289                inline typename tmat2<T>::column_type operator* ( const tmat2<T> & m, const typename tmat2<T>::row_type & v )
    294290                {
    295291                        return tvec2<T>(
    … …  
    299295
    300296                template <typename T>
    301                 inline typename tmat2<T>::row_type operator*
    302                         (
    303                                 typename const tmat2<T>::column_type & v,
    304                                 const tmat2<T> & m
    305                                 )
     297                inline typename tmat2<T>::row_type operator* ( const typename tmat2<T>::column_type & v, const tmat2<T> & m )
    306298                {
    307299                        return tvec2<T>(
    … …  
    337329
    338330                template <typename T>
    339                 inline typename tmat2<T>::column_type operator/( const tmat2<T> & m, typename const tmat2<T>::row_type & v )
     331                inline typename tmat2<T>::column_type operator/( const tmat2<T> & m, const typename tmat2<T>::row_type & v )
    340332                {
    341333                        return detail::compute_inverse<T>( m ) * v;
    … …  
    343335
    344336                template <typename T>
    345                 inline typename tmat2<T>::row_type operator/( typename const tmat2<T>::column_type & v, const tmat2<T> & m )
     337                inline typename tmat2<T>::row_type operator/( const typename tmat2<T>::column_type & v, const tmat2<T> & m )
    346338                {
    347339                        return v * detail::compute_inverse<T>( m );

  • trunk/nv/stl/math/mat3.hh

    r471 r486  
    320320
    321321                template <typename T>
    322                 inline typename tmat3<T>::column_type operator*( const tmat3<T> & m, typename const tmat3<T>::row_type & v )
     322                inline typename tmat3<T>::column_type operator*( const tmat3<T> & m, const typename tmat3<T>::row_type & v )
    323323                {
    324324                        return typename tmat3<T>::column_type(
    … …  
    329329
    330330                template <typename T>
    331                 inline typename tmat3<T>::row_type operator*( typename const tmat3<T>::column_type & v, const tmat3<T> & m )
     331                inline typename tmat3<T>::row_type operator*( const typename tmat3<T>::column_type & v, const tmat3<T> & m )
    332332                {
    333333                        return typename tmat3<T>::row_type(
    … …  
    372372
    373373                template <typename T>
    374                 inline typename tmat3<T>::column_type operator/( const tmat3<T> & m, typename const tmat3<T>::row_type & v )
     374                inline typename tmat3<T>::column_type operator/( const tmat3<T> & m, const typename tmat3<T>::row_type & v )
    375375                {
    376376                        return detail::compute_inverse<T>( m ) * v;
    … …  
    378378
    379379                template <typename T>
    380                 inline typename tmat3<T>::row_type operator/( typename const tmat3<T>::column_type & v, const tmat3<T> & m )
     380                inline typename tmat3<T>::row_type operator/( const typename tmat3<T>::column_type & v, const tmat3<T> & m )
    381381                {
    382382                        return v * detail::compute_inverse<T>( m );

  • trunk/nv/stl/math/vec2.hh

    r471 r486  
    9898                        {}
    9999
    100                         inline tvec2<T> & tvec2<T>::operator+=( T scalar )
     100                        inline tvec2<T> & operator+=( T scalar )
    101101                        {
    102102                                this->x += static_cast<T>( scalar );

  • trunk/src/engine/material_manager.cc

    r485 r486  
    1212using namespace nv;
    1313
     14
     15nv::gpu_material_manager::gpu_material_manager( context* context, material_manager* matmgr, image_manager* imgmgr )
     16        : m_context( context )
     17        , m_material_manager( matmgr )
     18        , m_image_manager( imgmgr )
     19{
     20        uint8 data[2 * 2 * 3];
     21        nv::raw_fill_n( data, 2 * 2 * 3, 0 );
     22        m_default = m_context->get_device()->create_texture( ivec2(2,2), nv::image_format( nv::RGB ), nv::sampler(), data );
     23}
     24
    1425bool gpu_material_manager::load_resource( const string_view& id )
    1526{
    … …  
    2031                for ( uint32 i = 0; i < size( mat->paths ); ++i )
    2132                        if ( !mat->paths[i].empty() )
     33                        {
    2234                                if ( auto data = m_image_manager->get( mat->paths[i] ).lock() )
    2335                                {
    2436                                        result->textures[i] = m_context->get_device()->create_texture( &*data, smp );
    2537                                }
     38                        }
     39
     40                // HACK
     41                for ( uint32 i = 0; i < 5; ++i )
     42                        if ( result->textures[i].is_nil() )
     43                                result->textures[i] = m_default;
     44                       
    2645                add( id, result );
    2746                return true;
    … …  
    4463        m->paths[ TEX_SPECULAR ] = table.get_string128( "specular" );
    4564        m->paths[ TEX_NORMAL ]   = table.get_string128( "normal" );
     65        m->paths[ TEX_EMISSIVE ] = table.get_string128( "emissive" );
    4666        m->paths[ TEX_GLOSS ]    = table.get_string128( "gloss" );
    4767        add( id, m );

  • trunk/src/engine/resource_system.cc

    r485 r486  
    2323}
    2424
    25 void nv::lua_resource_manager_base::load_all()
     25void nv::lua_resource_manager_base::load_all( bool do_clear )
    2626{
    27         clear();
     27        if ( do_clear ) clear();
    2828        lua::table_guard table( m_lua, get_storage_name() );
    2929        uint32 count = table.get_unsigned( "__counter" );

  • trunk/src/formats/assimp_loader.cc

    r485 r486  
    133133        {
    134134                data_node_info info;
    135                 data_channel_set* data = data_channel_set_creator::create_set( 2 );
    136                 load_mesh_data( data, i, info );
    137                 m_meshes.push_back( data );
     135                data_channel_set* mdata = data_channel_set_creator::create_set( 2 );
     136                load_mesh_data( mdata, i, info );
     137                m_meshes.push_back( mdata );
    138138                m_mesh_info.push_back( info );
    139139        }
    … …  
    184184        int hack_for_node_anim;
    185185        if ( is_node_animated() )
    186                 info.parent_id = index;
     186                info.parent_id = sint16( index );
    187187
    188188
    … …  
    339339}
    340340
    341 void nv::assimp_loader::build_skeleton( vector< data_node_info >& skeleton, const void* node, int parent_id )
     341void nv::assimp_loader::build_skeleton( vector< data_node_info >& skeleton, const void* node, sint16 parent_id )
    342342{
    343343        const aiNode* ainode = reinterpret_cast<const aiNode*>( node );
    … …  
    360360        info.parent_id = parent_id;
    361361
    362         int this_id = skeleton.size();
     362        sint16 this_id = sint16( skeleton.size() );
    363363        skeleton.push_back( info );
    364364        for ( unsigned i = 0; i < ainode->mNumChildren; ++i )
    … …  
    428428                {
    429429                        mat4 tr = nv::math::inverse( assimp_mat4_cast( m_data->node_by_name[bone_data[i].name]->mTransformation ) );
    430                         bone_data[i].transform = tr * bone_data[bone_data[i].parent_id].transform;
     430                        int pid = bone_data[i].parent_id;
     431                        if ( pid != -1 )
     432                                bone_data[i].transform = tr * bone_data[pid].transform;
     433                        else
     434                                bone_data[i].transform = tr;
    431435                }
    432436//              list->append( bone_data[i] );
    … …  
    449453        if ( scene->mRootNode == nullptr || scene->mAnimations == nullptr || scene->mAnimations[index] == nullptr) return nullptr;
    450454
    451         const aiNode*      root = scene->mRootNode;
    452455        const aiAnimation* anim = scene->mAnimations[index];
    453456
    … …  
    481484}
    482485
    483 data_node_list* nv::assimp_loader::release_data_node_list( size_t index /*= 0 */ )
     486data_node_list* nv::assimp_loader::release_data_node_list( size_t /*= 0 */ )
    484487{
    485488        return release_merged_bones();

  • trunk/src/formats/nmd_loader.cc

    r485 r486  
    261261        nmd_element_header pheader;
    262262        pheader.type       = nv::nmd_type::POSES;
    263         pheader.children   = poses.size();
     263        pheader.children   = uint16( poses.size() );
    264264        pheader.size       = sizeof( transform ) * poses.size() * ( poses.size() > 0 ? poses[0]->size() : 0 )
    265265                               + sizeof( uint32 ) * poses.size();

  • trunk/src/gfx/skeleton_instance.cc

    r485 r486  
    88
    99#include "nv/core/profiler.hh"
     10#include "nv/interface/interpolate.hh"
    1011
    1112void nv::skeleton_binding::assign( const skeleton_binding& other )
    … …  
    7879}
    7980
    80 
    81 void nv::skeleton_instance::assign( const skeleton_transforms& skeleton, const skeleton_binding& binding, const bone_transforms& bones )
    82 {
    83         if ( bones.size() != m_matrix.size() )
    84                 m_matrix.resize( bones.size() );
    85         const transform* transforms = skeleton.xforms();
    86         for ( uint32 n = 0; n < skeleton.size(); ++n )
    87         {
    88                 sint16 bone_id = binding.m_indices[n];
    89                 if ( bone_id >= 0 )
    90                 {
    91                         int too_complex;
    92                         transform tr( bones.m_offsets[bone_id] );
    93                         tr.set_orientation( normalize( tr.get_orientation() ) );
    94                         m_matrix[bone_id] = ( transforms[n] * tr ).extract();
    95                 }
    96         }
    97 }
    98 
    99 
    100 void nv::skeleton_instance::assign( const skeleton_transforms& skeleton, const bone_transforms& bones )
    101 {
    102         if ( bones.size() != m_matrix.size() )
    103                 m_matrix.resize( bones.size() );
    104         const transform* transforms = skeleton.xforms();
    105         for ( uint32 n = 0; n < skeleton.size(); ++n )
    106         {
    107                 transform tr( bones.m_offsets[n] );
    108                 tr.set_orientation( normalize( tr.get_orientation() ) );
    109                 m_matrix[n] = ( transforms[n] * tr ).extract();
    110         //      m_matrix[n] = transforms[n].extract() * bones.m_offsets[n];
    111         }
    112 }
    113 
    114 void nv::skeleton_instance::assign( const bone_transforms& bones )
    115 {
    116         if ( bones.size() != m_matrix.size() )
    117                 m_matrix.resize( bones.size() );
    118 }
    119 
    12081void nv::skeleton_transforms::assign( const data_node_list* node_data )
    12182{
    … …  
    12586        for ( uint32 n = 0; n < node_data->size(); ++n )
    12687        {
    127                 const data_node_info& info = (*node_data)[ n ];
    128                 m_transforms[n] = transform( info.transform );
     88                m_transforms[n] = transform( ( *node_data )[n].transform );
    12989        }
    13090}
    13191
    132 void nv::skeleton_transforms::interpolate_linear( const skeleton_transforms& a, const skeleton_transforms& b, float t )
     92void nv::skeleton_transforms::assign( const skeleton_transforms& other, const array_view< bool >& mask )
     93{
     94        if ( m_transforms.size() != other.size() ) m_transforms.resize( other.size() );
     95        if ( mask.size() == 0 )
     96                m_transforms.assign( other.m_transforms );
     97        else
     98                for ( uint32 i = 0; i < other.size(); ++i )
     99                        if ( mask[i] )
     100                                m_transforms[i] = other.m_transforms[i];
     101}
     102
     103void nv::skeleton_transforms::interpolate( const skeleton_transforms& a, const skeleton_transforms& b, float t, interpolation i )
     104{
     105        if ( m_transforms.size() != a.size() ) m_transforms.resize( a.size() );
     106        ::nv::interpolate( m_transforms, t, i, a.m_transforms, b.m_transforms );
     107}
     108
     109void nv::skeleton_transforms::interpolate( const skeleton_transforms& a, const skeleton_transforms& b, float t, interpolation i, const array_view< bool >& mask )
     110{
     111        if ( m_transforms.size() != a.size() ) m_transforms.resize( a.size() );
     112        if ( mask.size() > 0 )
     113                ::nv::interpolate( m_transforms, t, i, mask, a.m_transforms, b.m_transforms );
     114        else
     115                ::nv::interpolate( m_transforms, t, i, a.m_transforms, b.m_transforms );
     116}
     117
     118void nv::skeleton_transforms::interpolate( const skeleton_transforms& s1, const skeleton_transforms& v1, const skeleton_transforms& v2, const skeleton_transforms& s2, float t, interpolation i )
     119{
     120        if ( m_transforms.size() != s1.size() ) m_transforms.resize( s1.size() );
     121        ::nv::interpolate( m_transforms, t, i, s1.m_transforms, v1.m_transforms, v2.m_transforms, s2.m_transforms );
     122}
     123
     124void 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 )
     125{
     126        if ( m_transforms.size() != s1.size() ) m_transforms.resize( s1.size() );
     127        if ( mask.size() > 0 )
     128                ::nv::interpolate( m_transforms, t, i, mask, s1.m_transforms, v1.m_transforms, v2.m_transforms, s2.m_transforms );
     129        else
     130                ::nv::interpolate( m_transforms, t, i, s1.m_transforms, v1.m_transforms, v2.m_transforms, s2.m_transforms );
     131}
     132
     133void nv::skeleton_transforms::blend( const skeleton_transforms& a, const skeleton_transforms& b, float t, interpolation i, float blend, interpolation bi )
    133134{
    134135        NV_ASSERT( a.size() == b.size(), "!!!" );
    135136        if ( m_transforms.size() != a.size() )
    136137                m_transforms.resize( a.size() );
    137         for ( uint32 n = 0; n < a.size(); ++n )
    138         {
    139                 m_transforms[n] = transform(
    140                         math::mix( a.m_transforms[n].get_position(), b.m_transforms[n].get_position(), t ),
    141                         math::lerp( a.m_transforms[n].get_orientation(), b.m_transforms[n].get_orientation(), t )
    142                         );
    143         }
    144 
    145 //      if ( m_transforms.size() > 0 )
    146 //              m_transforms[0] = nv::interpolate( a.m_transforms[0], b.m_transforms[0], t, interpolation::SPHERICAL );
     138        ::nv::interpolate( m_transforms, t, i, blend, bi, a.m_transforms, b.m_transforms );
    147139}
    148140
    149 void nv::skeleton_transforms::interpolate_nlerp( const skeleton_transforms& a, const skeleton_transforms& b, float t )
     141void 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 )
    150142{
    151143        NV_ASSERT( a.size() == b.size(), "!!!" );
    152144        if ( m_transforms.size() != a.size() )
    153145                m_transforms.resize( a.size() );
    154 
    155         for ( uint32 n = 0; n < a.size(); ++n )
    156         {
    157                 m_transforms[n] = transform(
    158                         math::mix( a.m_transforms[n].get_position(), b.m_transforms[n].get_position(), t ),
    159                         math::nlerp( a.m_transforms[n].get_orientation(), b.m_transforms[n].get_orientation(), t )
    160                         );
    161         }
     146        if ( mask.size() > 0 )
     147                ::nv::interpolate( m_transforms, t, i, blend, bi, mask, a.m_transforms, b.m_transforms );
     148        else
     149                ::nv::interpolate( m_transforms, t, i, blend, bi, a.m_transforms, b.m_transforms );
    162150}
    163151
    164 
    165 void nv::skeleton_transforms::interpolate_slerp( const skeleton_transforms& a, const skeleton_transforms& b, float t )
     152void 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 )
    166153{
    167         NV_ASSERT( a.size() == b.size(), "!!!" );
    168         if ( m_transforms.size() != a.size() )
    169                 m_transforms.resize( a.size() );
    170         for ( uint32 n = 0; n < a.size(); ++n )
    171         {
    172                 m_transforms[n] = nv::interpolate( a.m_transforms[n], b.m_transforms[n], t, interpolation::SPHERICAL );
    173         }
     154        if ( m_transforms.size() != s1.size() ) m_transforms.resize( s1.size() );
     155        ::nv::interpolate( m_transforms, t, i, blend, bi, s1.m_transforms, v1.m_transforms, v2.m_transforms, s2.m_transforms );
    174156}
    175157
    176 void nv::skeleton_transforms::blend_slerp( const skeleton_transforms& a, const skeleton_transforms& b, float t, float blend )
     158void 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 )
    177159{
    178         NV_ASSERT( a.size() == b.size(), "!!!" );
    179         if ( m_transforms.size() != a.size() )
    180                 m_transforms.resize( a.size() );
    181         for ( uint32 n = 0; n < a.size(); ++n )
    182         {
    183                 transform tr    = nv::interpolate( a.m_transforms[n], b.m_transforms[n], t, interpolation::SPHERICAL );
    184                 m_transforms[n] = nv::interpolate( m_transforms[n], tr, blend, interpolation::SPHERICAL );
    185         }
    186 }
    187 
    188 
    189 
    190 void nv::skeleton_transforms::interpolate4( const skeleton_transforms& s1, const skeleton_transforms& v1, const skeleton_transforms& v2, const skeleton_transforms& s2, float t )
    191 {
    192         NV_ASSERT( s1.size() == s2.size(), "!!!" );
    193         NV_ASSERT( v1.size() == v2.size(), "!!!" );
    194         NV_ASSERT( s1.size() == v1.size(), "!!!" );
    195         if ( m_transforms.size() != s1.size() )
    196                 m_transforms.resize( s1.size() );
    197         float interp_squared = t*t;
    198         float interp_cubed = interp_squared*t;
    199         float weights[4];
    200         weights[0] = 0.5f * ( -interp_cubed + 2.0f * interp_squared - t );
    201         weights[1] = 0.5f * ( 3.0f * interp_cubed - 5.0f * interp_squared + 2.0f );
    202         weights[2] = 0.5f * ( -3.0f * interp_cubed + 4.0f * interp_squared + t );
    203         weights[3] = 0.5f * ( interp_cubed - interp_squared );
    204 
    205         for ( uint32 n = 0; n < s1.size(); ++n )
    206         {
    207                 quat qs1 = s1.m_transforms[n].get_orientation();
    208                 quat qs2 = s2.m_transforms[n].get_orientation();
    209                 quat qv1 = v1.m_transforms[n].get_orientation();
    210                 quat qv2 = v2.m_transforms[n].get_orientation();
    211 
    212                 float a = dot( qv1, qv2 ) > 0.0f ? 1.0f : -1.0f;
    213 
    214                 quat qr = weights[0] * qs1
    215                                 + weights[1] * (a * qv1 )
    216                                 + weights[2] * qv2
    217                                 + weights[3] * qs2;
    218 
    219                 qr = normalize( qr );
    220 
    221                 m_transforms[n] = transform(
    222                         weights[0] * s1.m_transforms[n].get_position() +
    223                         weights[1] * v1.m_transforms[n].get_position() +
    224                         weights[2] * v2.m_transforms[n].get_position() +
    225                         weights[3] * s2.m_transforms[n].get_position(),
    226                         qr
    227                 );
    228         }
    229 }
    230 
    231 
    232 void nv::skeleton_transforms::interpolate_squad( const skeleton_transforms& s1, const skeleton_transforms& v1, const skeleton_transforms& v2, const skeleton_transforms& s2, float t )
    233 {
    234         NV_ASSERT( s1.size() == s2.size(), "!!!" );
    235         NV_ASSERT( v1.size() == v2.size(), "!!!" );
    236         NV_ASSERT( s1.size() == v1.size(), "!!!" );
    237         if ( m_transforms.size() != s1.size() )
    238                 m_transforms.resize( s1.size() );
    239 
    240         for ( uint32 n = 0; n < s1.size(); ++n )
    241         {
    242                 nv::quat ss1 = s1.m_transforms[n].get_orientation();
    243                 nv::quat ss2 = s2.m_transforms[n].get_orientation();
    244                 nv::quat sv1 = v1.m_transforms[n].get_orientation();
    245                 nv::quat sv2 = v2.m_transforms[n].get_orientation();
    246 
    247                 nv::quat q = normalize( nv::math::squad(
    248                         sv1, sv2,
    249                         nv::math::intermediate( ss1, sv1, sv2 ),
    250                         nv::math::intermediate( sv1, sv2, ss2 ),
    251                         t ) );
    252 
    253                 m_transforms[n] = transform(
    254                         mix( v1.m_transforms[n].get_position(), v2.m_transforms[n].get_position(), t ),
    255                         q
    256                         );
    257         }
    258        
     160        if ( m_transforms.size() != s1.size() ) m_transforms.resize( s1.size() );
     161        if ( mask.size() > 0 )
     162                ::nv::interpolate( m_transforms, t, i, blend, bi, mask, s1.m_transforms, v1.m_transforms, v2.m_transforms, s2.m_transforms );
     163        else
     164                ::nv::interpolate( m_transforms, t, i, blend, bi, s1.m_transforms, v1.m_transforms, v2.m_transforms, s2.m_transforms );
    259165}
    260166
    … …  
    264170}
    265171
    266 // void nv::skeleton_transforms::blend_local( const mesh_nodes_data* node_data, float frame, float blend )
    267 // {
    268 //      if ( m_transforms.size() != node_data->size() )
    269 //              m_transforms.resize( node_data->size() );
    270 //      for ( uint32 n = 0; n < node_data->size(); ++n )
    271 //      {
    272 //              const data_channel_set* node = ( *node_data )[n];
    273 //              int inefficient_store_key;
    274 //
    275 //              transform tr = node->size() > 0 ? raw_channel_interpolator( node ).get< transform >( frame ) : transform( /*node->get_transform()*/ ); int confirm_that_not_needed;
    276 //              m_transforms[n] = nv::interpolate( m_transforms[n], tr, blend, interpolation::SPHERICAL );
    277 //      }
    278 // }
    279 //
    280 // void nv::skeleton_transforms::animate_local( const mesh_nodes_data* node_data, float frame )
    281 // {
    282 //      if ( m_transforms.size() != node_data->size() )
    283 //              m_transforms.resize( node_data->size() );
    284 //      for ( uint32 n = 0; n < node_data->size(); ++n )
    285 //      {
    286 //              const data_channel_set* node = ( *node_data )[n];
    287 //              if ( node->size() > 0 )
    288 //              {
    289 //                      int inefficient_store_key;
    290 //                      m_transforms[n] = raw_channel_interpolator( node ).get< transform >( frame );
    291 //              }
    292 //      }
    293 // }
    294172
    295173void nv::skeleton_transforms::delocalize_rec( const data_node_tree& node_data, uint32 id, const transform& parent )
    … …  
    304182}
    305183
    306 // void nv::skeleton_transforms::blend_rec( const mesh_nodes_data* node_data, float frame, uint32 id, const transform& parent, bool local, float blend )
    307 // {
    308 //      const data_channel_set* node = ( *node_data )[id];
    309 //      int confirm_that_not_needed;
    310 //      transform node_mat/*( node->get_transform() )*/;
    311 //
    312 //      if ( node->size() > 0 )
    313 //      {
    314 //              int inefficient_store_key;
    315 //
    316 //              raw_channel_interpolator interpolator( node );
    317 //              node_mat = interpolator.get< transform >( frame );
    318 //      }
    319 //      transform global_mat = parent * node_mat;
    320 //      m_transforms[id] = nv::interpolate( m_transforms[id], local ? node_mat : global_mat, blend, interpolation::SPHERICAL );
    321 //      for ( auto child : node_data->children( id ) )
    322 //      {
    323 //              blend_rec( node_data, frame, child, global_mat, local, blend );
    324 //      }
    325 //
    326 // }
    327 //
    328 // void nv::skeleton_transforms::animate_rec( const mesh_nodes_data* node_data, float frame, uint32 id, const transform& parent, bool local )
    329 // {
    330 //      const data_channel_set* node = ( *node_data )[id];
    331 //      transform node_mat;
    332 //      int inefficient_store_key;
    333 //
    334 //      if ( node->size() > 0 )
    335 //              node_mat = raw_channel_interpolator( node ).get< transform >( frame );
    336 //      int confirm_that_not_needed;
    337 //      //      else
    338 //      //              node_mat = transform( node->get_transform() );
    339 //      transform global_mat = parent * node_mat;
    340 //      m_transforms[id] = local ? node_mat : global_mat;
    341 //      for ( auto child : node_data->children( id ) )
    342 //      {
    343 //              animate_rec( node_data, frame, child, global_mat, local );
    344 //      }
    345 //
    346 // }
    347 
    348 void nv::bone_transforms::prepare( const data_node_list& bone_data )
    349 {
    350         m_offsets.resize( bone_data.size() );
    351 
    352         for ( nv::uint16 bi = 0; bi < bone_data.size(); ++bi )
    353                 m_offsets[bi] = bone_data[bi].transform;
    354 }

  • trunk/src/image/miniz.cc

    r484 r486  
    813813        static void *def_alloc_func( void *opaque, size_t items, size_t size ) { (void)opaque, (void)items, (void)size; return MZ_MALLOC( items * size ); }
    814814        static void def_free_func( void *opaque, void *address ) { (void)opaque, (void)address; MZ_FREE( address ); }
    815         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 ); }
     815//      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 ); }
    816816
    817817        const char *mz_version( void )

  • trunk/src/image/png_loader.cc

    r484 r486  
    665665}
    666666
     667
    667668static int stbi__unpremultiply_on_load = 0;
    668669static int stbi__de_iphone_flag = 0;
    669670
     671/*
    670672static void stbi_set_unpremultiply_on_load( int flag_true_if_should_unpremultiply )
    671673{
    … …  
    677679        stbi__de_iphone_flag = flag_true_if_should_convert;
    678680}
     681*/
    679682
    680683static void stbi__de_iphone( stbi__png *z )
    … …  
    10211024}
    10221025
     1026bool nv::png_loader::test( stream& str )
     1027{
     1028        stbi__context s( &stbi__callbacks, (void *)&str );
     1029        return stbi__png_test( &s ) != 0;
     1030}
     1031
    10231032image_data* nv::png_loader::load( stream& s )
    10241033{

  • trunk/src/io/c_stream.cc

    r484 r486  
    9898        if ( m_file != nullptr )
    9999        {
    100                 return ::feof( reinterpret_cast<FILE*>( m_file ) );
     100                return ::feof( reinterpret_cast<FILE*>( m_file ) ) != 0;
    101101        }
     102        return true;
    102103}

  • trunk/src/lua/lua_state.cc

    r440 r486  
    194194                str = lua_tolstring( m_state, -1, &l );
    195195                result = hash_string< uint64 >( str, l );
     196                //NV_LOG_DEBUG( str );
    196197        }
    197198        lua_pop( m_state, 1 );
    … …  
    204205        size_t l = 0;
    205206        const char* str = nullptr;
    206         uint64 result = defval;
     207        shash64 result = shash64( defval );
    207208        if ( lua_type( m_state, -1 ) == LUA_TSTRING )
    208209        {
    209210                str = lua_tolstring( m_state, -1, &l );
    210                 result = table.insert( string_view( str, l ) ).value();
    211         }
    212         lua_pop( m_state, 1 );
    213         return shash64( result );
     211                result = table.insert( string_view( str, l ) );
     212        }
     213        lua_pop( m_state, 1 );
     214        return result;
     215}
     216
     217nv::shash64 nv::lua::table_guard::get_string( string_view element, string_table* table, uint64 defval /*= 0 */ )
     218{
     219        lua_getfield( m_state, -1, element.data() );
     220        size_t l = 0;
     221        const char* str = nullptr;
     222        shash64 result = shash64( defval );
     223        if ( lua_type( m_state, -1 ) == LUA_TSTRING )
     224        {
     225                str = lua_tolstring( m_state, -1, &l );
     226                string_view sv( str, l );
     227                result = table ? table->insert( sv ) : shash64( sv );
     228        }
     229        lua_pop( m_state, 1 );
     230        return result;
    214231}
    215232

  • trunk/src/sdl/sdl_window.cc

    r440 r486  
    4545        }
    4646
    47         //      NV_LOG( LOG_INFO, "Joystick count : " << SDL_NumJoysticks() );
    48         //      SDL_Joystick* j = SDL_JoystickOpen(0);
    49         //      if (j)
    50         //      {
    51         //              NV_LOG( LOG_INFO, "Joystick Name: " << SDL_JoystickNameForIndex(0) );
    52         //              NV_LOG( LOG_INFO, "Joystick Number of Axes: " << SDL_JoystickNumAxes(j));
    53         //              NV_LOG( LOG_INFO, "Joystick Number of Buttons: " << SDL_JoystickNumButtons(j));
    54         //              NV_LOG( LOG_INFO, "Joystick Number of Balls: " << SDL_JoystickNumBalls(j));
    55         //      }
     47//      NV_LOG_INFO( "Joystick count : ", SDL_NumJoysticks() );
     48//      SDL_Joystick* j = SDL_JoystickOpen(0);
     49//      if ( j )
     50//      {
     51//              NV_LOG_INFO( "Joystick Name: ", SDL_JoystickNameForIndex( 0 ) );
     52//              NV_LOG_INFO( "Joystick Number of Axes: ", SDL_JoystickNumAxes( j ) );
     53//              NV_LOG_INFO( "Joystick Number of Buttons: ", SDL_JoystickNumButtons( j ) );
     54//              NV_LOG_INFO( "Joystick Number of Balls: ", SDL_JoystickNumBalls( j ) );
     55//      }
     56
     57        NV_LOG_INFO( "Joystick count : ", SDL_NumJoysticks() );
     58        SDL_GameController *controller = NULL;
     59        int controller_index = 0;
     60        for ( int i = 0; i < SDL_NumJoysticks(); ++i )
     61        {
     62                if ( SDL_IsGameController( i ) )
     63                {
     64                        controller = SDL_GameControllerOpen( i );
     65                        controller_index = i;
     66                        if ( controller ) break;
     67                        NV_LOG_ERROR( "Could not open gamecontroller ", i, ": ", SDL_GetError() );
     68                }
     69        }
     70
     71        if ( controller )
     72        {
     73                SDL_Joystick* j = SDL_GameControllerGetJoystick( controller );
     74                NV_LOG_INFO( "Controller Name: ", SDL_GameControllerNameForIndex( controller_index ) );
     75                NV_LOG_INFO( "Controller Number of Axes: ", SDL_JoystickNumAxes( j ) );
     76                NV_LOG_INFO( "Controller Number of Buttons: ", SDL_JoystickNumButtons( j ) );
     77                NV_LOG_INFO( "Controller Number of Balls: ", SDL_JoystickNumBalls( j ) );
     78        }
     79
     80
    5681
    5782        void* ctx_handle = SDL_GL_CreateContext( static_cast<SDL_Window*>( m_handle ) );
Note: See TracChangeset for help on using the changeset viewer.