Changeset 516

Timestamp:

02/22/08 17:30:39 (11 months ago)

Author:

phill

Message:

o Lots of animation stuff.

Files:

• branches/morph-targets/libx42make/helpers.h (modified) (2 diffs)
• branches/morph-targets/libx42make/include/x42make-modelbuilder.h (modified) (8 diffs)
• branches/morph-targets/libx42make/modelbuilder-animation.cpp (modified) (4 diffs)
• branches/morph-targets/libx42make/modelbuilder-enumerators.cpp (modified) (2 diffs)
• branches/morph-targets/libx42make/modelbuilder-geometry.cpp (modified) (2 diffs)
• branches/morph-targets/libx42make/modelbuilder-influences.cpp (modified) (1 diff)
• branches/morph-targets/libx42make/modelbuilder-skeleton.cpp (modified) (1 diff)
• branches/morph-targets/libx42pp/include/x42math-angle.h (modified) (2 diffs)
• branches/morph-targets/x42view.net/Gui/DXPanel.Designer.cs (modified) (2 diffs)
• branches/morph-targets/x42view.net/Gui/MoveHelper.cs (modified) (1 diff)
• branches/morph-targets/x42view.net/Gui/TimeControl.Designer.cs (modified) (2 diffs)
• branches/morph-targets/x42view.net/Gui/TimeSlider.cs (modified) (1 diff)

branches/morph-targets/libx42make/helpers.h

@@ -107 +107 @@
-        struct equal
-        {
-
+ const
-                {
-                        return a == b;
@@ -116 +116 @@
-}
-
+template< typename T, typename Cmp >
+void ordered_insert( std::vector< T > &v,
+        const T &val, Cmp cmp, bool allow_duplicates = true )
+{
+        std::vector< T >::iterator pos =
+                std::upper_bound( v.begin(), v.end(), val, cmp );
+
+        if( !allow_duplicates )
+        {
+                if( pos > v.begin() )
+                {
+                        const T &vp = pos[-1];
+
+                        if( !cmp( vp, val ) && !cmp( val, vp ) )
+                                //neither is less, they are "equal"
+                                return;
+                }
+        }
+
+        v.insert( pos, val );
+}
+
+template< typename T >
+void ordered_insert( std::vector< T > &v,
+        const T &val, bool allow_duplicates = true )
+{
+        ordered_insert( v, val, std::less< T >(), allow_duplicates );
+}
+
+template< typename T >
+std::vector< uint > gather_frame_numbers( const std::vector< anim_track_elem< T > > &track )
+{
+        std::vector< uint > ret( track.size() );
+
+        for( size_t i = 0; i < track.size(); i++ )
+                ret[i] = track[i].frame;
+
+        return ret;
+}
+
-};
-};

branches/morph-targets/libx42make/include/x42make-modelbuilder.h

@@ -120 +120 @@
-        uint                            frame;
-        T                                       value;
+
+        anim_track_elem()
+        {
+        }
+        anim_track_elem( uint frame, const T &value )
+                : frame( frame ), value( value )
+        {
+        }
-};
-
@@ -175 +183 @@
-        void require_world();
-
+        void offset_world( const ::x42::math::affine &offset );
+        void offset_local( const ::x42::math::affine &offset );
+
+        void resample_tracks( const std::vector< uint > &frames );
+
-        void clean_tracks();
+
+        void make_scale_uniform();
-
-private:
@@ -209 +224 @@
-        animation_tolerances    tight_tolerances;
-
-
+
+
-
-        bone_ptr                                parent() const { return _parent; }
@@ -233 +249 @@
-                loose_tolerances( animation_tolerances::inherit_defaults() ),
-                tight_tolerances( animation_tolerances::inherit_defaults() ),
-
+, no_remove( false )
-        {
-                anim_tracks.owner = this;
@@ -315 +331 @@
-        influence_ptr influence() const { return _influence; }
-        float weight() const { return _weight; }
+
+        bool is_empty() const { return !_influence || _weight == 0; }
-
-private:
@@ -424 +442 @@
-        std::string             surface_name;
-        std::string             material_name;
-
+
+
+
-
-private:
@@ -499 +519 @@
-        void begin_skeleton_update();
-        void end_skeleton_update();
+
+        void apply_root_scale( const ::x42::math::vec3 &pos_ofs, const ::x42::math::quat &rot_ofs,
+                const ::x42::math::vec3 &inner_scale_ofs, const ::x42::math::vec3 &outer_scale_ofs );
-
-        //unbinds all vertices from influence
@@ -508 +531 @@
-        //unbinds all vertices from old_influence and binds them to new_influence with the same weight, then removes old_influence
-        void rebind_and_remove_influence( const influence_ptr &old_influence, const influence_ptr &new_influence );
+        //rebinds vertices such that only one influence out of each set of equivalent influences is in use
+        void rebind_duplicate_influences();
-
-        void unbind_weak_influences( float min_weight, bool renormalize_weights = true );

branches/morph-targets/libx42make/modelbuilder-animation.cpp

@@ -57 +57 @@
-}
-
+template< typename T >
+T sample_track( const std::vector< anim_track_elem< T > > &track, float frame )
+{
+        if( !track.size() )
+                return T();
+
+        if( track[0].frame > frame )
+                return track[0].value;
+
+        for( uint i = 1; i < track.size(); i++ )
+        {
+                if( track[i].frame >= frame )
+                {
+                        const anim_track_elem< T > &s = track[i - 1];
+                        const anim_track_elem< T > &e = track[i];
+
+                        float t = (float)(frame - s.frame) / (float)(e.frame - s.frame);
+                        return interp_elem( s.value, e.value, t );
+                }
+        }
+
+        return track[track.size() - 1].value;
+}
+
+template< typename T >
+std::vector< anim_track_elem< T > > resample_track(
+        const std::vector< anim_track_elem< T > > &track,
+        const std::vector< uint > &frames )
+{
+        std::vector< anim_track_elem< T > > ret( frames.size() );
+
+        for( size_t i = 0; i < ret.size(); i++ )
+        {
+                ret[i].frame = frames[i];
+                ret[i].value = sample_track( track, (float)frames[i] );
+        }
+
+        return ret;
+}
+
-inline float compute_delta( const vec3 &s, const vec3 &e, float t, const vec3 &m )
-{
@@ -343 +383 @@
-}
-
+void animation_tracks::offset_world( const affine &offset )
+{
+        require_world();
+
+        for( size_t i = 0; i < world_matrices.size(); i++ )
+                world_matrices[i].value = offset * world_matrices[i].value;
+
+        local_matrices.clear();
+        position.clear();
+        rotation.clear();
+        scale.clear();
+}
+
+void animation_tracks::offset_local( const affine &offset )
+{
+        require_local();
+
+        for( size_t i = 0; i < local_matrices.size(); i++ )
+                local_matrices[i].value = offset * local_matrices[i].value;
+
+        world_matrices.clear();
+        position.clear();
+        rotation.clear();
+        scale.clear();
+}
+
+void animation_tracks::resample_tracks( const std::vector< uint > &frames )
+{
+        require_tracks();
+
+        std::vector< vec3_track_elem > new_pos = resample_track( position, frames );
+        std::vector< quat_track_elem > new_rot = resample_track( rotation, frames );
+        std::vector< vec3_track_elem > new_scale = resample_track( scale, frames );
+
+        std::swap( position, new_pos );
+        std::swap( rotation, new_rot );
+        std::swap( scale, new_scale );
+}
+
-void animation_tracks::clean_tracks()
-{
@@ -376 +455 @@
-}
-
+void animation_tracks::make_scale_uniform()
+{
+        require_tracks();
+
+        for( size_t i = 0; i < scale.size(); i++ )
+        {
+                vec3 &v = scale[i].value;
+
+                float mid = (v.x + v.y + v.z) / 3.0F;
+
+                v = vec3c( mid ); 
+        }
+}
+
-/*
-        class model_builder
@@ -401 +494 @@
-}
-
+void model_builder::apply_root_scale( const vec3 &pos_ofs, const quat &rot_ofs,
+        const vec3 &inner_scale_ofs, const vec3 &outer_scale_ofs )
+{
+        if( !_frame_count )
+                throw error( "Frame range not initialized." );
+
+        std::vector< uint > frames;
+        if( bones.size() )
+        {
+                const animation_tracks &anim_trks = bones[0]->anim_tracks;
+
+                if( anim_trks.world_matrices.size() )
+                        frames = gather_frame_numbers( anim_trks.world_matrices );
+                else if( anim_trks.local_matrices.size() )
+                        frames = gather_frame_numbers( anim_trks.local_matrices );
+                else if( anim_trks.position.size() )
+                        frames = gather_frame_numbers( anim_trks.position );
+        }
+
+        if( !frames.size() )
+        {
+                frames.resize( _frame_count );
+                for( size_t i = 0; i < _frame_count; i++ )
+                {
+                        frames[i] = (uint)i;
+                }
+        }
+
+        begin_bone_update();
+
+        bone_ptr root = create_bone( "root-offset" );
+
+        root->_anim_group = 0;
+        root->flags = bone_flags::none;
+        root->static_bone_hint = true;
+
+        root->anim_tracks.position.push_back(
+                vec3_track_elem( _frame_count - 1, pos_ofs ) );
+        root->anim_tracks.rotation.push_back(
+                quat_track_elem( _frame_count - 1, rot_ofs ) );
+        root->anim_tracks.scale.push_back(
+                vec3_track_elem( _frame_count - 1, inner_scale_ofs * outer_scale_ofs ) );
+
+        root->anim_tracks.resample_tracks( frames );
+
+        root->anim_tracks.require_world();
+        const affine &offset = root->anim_tracks.world_matrices[0].value;
+
+        for( size_t i = 0; i < bones.size(); i++ )
+        {
+                bone_ptr b = bones[i];
+
+                if( !b->_parent )
+                        b->_parent = root;
+
+                if( b->anim_tracks.world_matrices.size() )
+                        b->anim_tracks.offset_world( offset );
+        }
+
+        for( size_t i = 0; i < influences.size(); i++ )
+        {
+                influence_ptr inf = influences[i];
+
+                if( !inf->_bone )
+                        inf->_bone = root;
+        }
+
+        affine inv_scale =
+        { {
+                { 1.0F / inner_scale_ofs.x, 0, 0 },
+                { 0, 1.0F / inner_scale_ofs.y, 0 },
+                { 0, 0, 1.0F / inner_scale_ofs.z },
+                { 0, 0, 0 }
+        } };
+
+        for( size_t i = 0; i < tags.size(); i++ )
+        {
+                tag_ptr tag = tags[i];
+
+                if( !tag->_bone )
+                        tag->_bone = root;
+
+                tag->matrix = inv_scale * tag->matrix;
+        }
+
+        root->anim_tracks.require_world();
+
+        end_bone_update();
+}
+
-};
-};

branches/morph-targets/libx42make/modelbuilder-enumerators.cpp

@@ -150 +150 @@
-        for( ; ; )
-        {
-roup_g
+
-                        return true;
-
@@ -174 +174 @@
-                throw error();
-
-roup_g
+
-}
-

branches/morph-targets/libx42make/modelbuilder-geometry.cpp

@@ -372 +372 @@
-
-/*
+        class group
+*/
+
+std::vector< influence_ptr > group::get_influences() const
+{
+        std::vector< influence_ptr > ret;
+
+        for( size_t i = 0; i < geometry.weights.size(); i++ )
+        {
+                const vertex_weights &weights = geometry.weights[i];
+
+                for( size_t j = 0; j < vertex_weights::max_weights; j++ )
+                {
+                        const vertex_weight &wt = weights[i];
+
+                        if( !wt.is_empty() )
+                                ordered_insert( ret, wt.influence(), false );
+                }
+        }
+
+        struct influence_cmp
+        {
+                bool operator() ( const influence_ptr &a, const influence_ptr &b ) const
+                {
+                        return a->index() < b->index();
+                }
+        };
+
+        std::sort( ret.begin(), ret.end(), influence_cmp() );
+
+        return ret;
+}
+
+/*
-        class model_builder
-*/
@@ -379 +413 @@
-        for( group_enumerator iter( *this ); iter.next(); )
-        {
-roup_g
+
-        }
-}

branches/morph-targets/libx42make/modelbuilder-influences.cpp

@@ -150 +150 @@
-}
-
+void model_builder::rebind_duplicate_influences()
+{
+        std::vector< size_t > use_counts = count_influence_uses();
+
+        for( size_t i = influences.size(); i--; )
+        {
+                if( !use_counts[i] )
+                        //affects nothing, don't care
+                        continue;
+
+                influence_ptr ii = influences[i];
+
+                for( size_t j = i; j--; )
+                {
+                        if( !use_counts[j] )
+                                //affects nothing, don't care
+                                continue;
+
+                        influence_ptr ij = influences[j];
+
+                        if( ii->_bone != ij->_bone )
+                                //not equal, next
+                                continue;
+
+                        if( !equal( ii->matrix, ij->matrix, 1e-2F ) )
+                                //not equal enough, next
+                                continue;
+
+                        /*
+                                Favor keeping the bigger one.
+
+                                ToDo: fix this code so it correctly handles cases
+                                where more than two influences are equivalent.
+                        */
+
+                        if( use_counts[i] > use_counts[j] )
+                        {
+                                rebind_influence( ij, ii );
+
+                                use_counts[i] += use_counts[j];
+                                use_counts[j] = 0;
+                        }
+                        else
+                        {
+                                rebind_influence( ii, ij );
+
+                                use_counts[j] += use_counts[i];
+                                use_counts[i] = 0;
+
+                                break; //stop comparing to this one
+                        }
+                }
+        }
+}
+
-void model_builder::erase_influence( const influence_ptr &influence )
-{

branches/morph-targets/libx42make/modelbuilder-skeleton.cpp

@@ -138 +138 @@
-        ret->_anim_group = parent ? parent->_anim_group : 0;
-
+        sort_bones();
+
-        return ret;
-}

branches/morph-targets/libx42pp/include/x42math-angle.h

@@ -29 +29 @@
-*/
-
+namespace x42
+{
+namespace math
+{
+
-struct angle
-{
@@ -48 +53 @@
-inline angle degs( float deg_val ) { angle ret = { deg_val * (3.14159265358979323846F / 180.0F) }; return ret; }
-
+};
+};
+
-#endif

branches/morph-targets/x42view.net/Gui/DXPanel.Designer.cs

@@ -51 +51 @@
-                private void InitializeComponent()
-                {
-l
+
-                        this.SuspendLayout();
-                        // 
@@ -64 +64 @@
-                #endregion
-
-l
+
-        }
-}

branches/morph-targets/x42view.net/Gui/MoveHelper.cs

@@ -26 +26 @@
-using System.Windows.Forms;
-
-l
+
-{
-

branches/morph-targets/x42view.net/Gui/TimeControl.Designer.cs

@@ -48 +48 @@
-                        this.tips = new System.Windows.Forms.ToolTip( this.components );
-                        this.nudCurrTime = new System.Windows.Forms.NumericUpDown();
-l
+
-                        this.groupBox1 = new System.Windows.Forms.GroupBox();
-                        this.nudFrameRate = new System.Windows.Forms.NumericUpDown();
@@ -223 +223 @@
-                #endregion
-
-l
+
-                private System.Windows.Forms.Timer animTime;
-                private System.Windows.Forms.Button btnPlay;

branches/morph-targets/x42view.net/Gui/TimeSlider.cs

@@ -26 +26 @@
-using System.Windows.Forms;
-
-l
+
-{
-