Changeset 511

Timestamp:

02/20/08 11:45:25 (11 months ago)

Author:

phill

Message:

o More work on the skeleton related classes.

Files:

• branches/morph-targets/libx42make/include/x42make-modelbuilder.h (modified) (8 diffs)
• branches/morph-targets/libx42make/local.h (modified) (1 diff)
• branches/morph-targets/libx42make/modelbuilder-geometry.cpp (modified) (2 diffs)
• branches/morph-targets/libx42make/modelbuilder-skeleton.cpp (modified) (5 diffs)

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

@@ -98 +98 @@
-typedef ::boost::intrusive_ptr< const influence > const_influence_ptr;
-
+class tag;
+typedef ::boost::intrusive_ptr< tag > tag_ptr;
+typedef ::boost::intrusive_ptr< const tag > const_tag_ptr;
+
-class group;
-typedef ::boost::intrusive_ptr< group > group_ptr;
@@ -187 +191 @@
-private:
-        model_builder                   *owner;
-
-        size_t                                  _index;
-
@@ -209 +212 @@
-{
-public:
-        bone_ptr                        bone;
-        ::x42::math::affine     matrix;
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
-
-        friend class model_builder;
@@ -222 +234 @@
-public:
-        std::string                     name;
-        bone_ptr                        bone;
-        ::x42::math::affine     matrix;
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
-
-        friend class model_builder;
@@ -275 +296 @@
-
-        void add( const vertex_weight &weight, bool renormalize_weights = true );
+        void remove( size_t index, bool renormalize_weights = true );
-        void normalize_weights();
-
@@ -281 +303 @@
-
-        size_t count() const;
-int index ) {
-int index ) const {
+size_t index ) { if( index >= max_weights ) throw error();
+size_t index ) const { if( index >= max_weights ) throw error();
-
-private:
@@ -382 +404 @@
-{
-public:
-
-
-
-
-
+
+
+
+
+
+
+
-
-        model_builder()
-                : loose_tolerances( animation_tolerances::loose_defaults() ),
-                tight_tolerances( animation_tolerances::tight_defaults() ),
-
+, _influence_update_count( 0 ), _tag_update_count( 0 )
-        {
-        }
@@ -399 +423 @@
-
-        bone_ptr create_bone( const std::string &name = std::string(), const bone_ptr &parent = bone_ptr() );
+        influence_ptr create_influence( const bone_ptr &bone = bone_ptr(), const ::x42::math::affine &matrix = ::x42::math::affinei() );
+        tag_ptr create_tag( const std::string &name = std::string(), const bone_ptr &bone = bone_ptr(), const ::x42::math::affine &matrix = ::x42::math::affinei() );
-
-        void begin_bone_update(); //suspends bone validation and sorting
-        void end_bone_update(); //resumes bone validation and sorting
-
+        void begin_influence_update();
+        void end_influence_update();
+
+        void begin_tag_update();
+        void end_tag_update();
+
+        void begin_skeleton_update();
+        void end_skeleton_update();
+
-private:
-        int _bone_update_count;
+        int _influence_update_count;
+        int _tag_update_count;
+
+        void validate_bone_prop( const bone_ptr &bone ) const;
-
-        void validate_bone_parent( bone *bone, const bone_ptr &new_parent ) const;
-        void validate_bone_anim_group( bone *bone, uint new_anim_group ) const;
-
-        void notify_bone_parent( bone *bone );
-        void notify_bone_anim_group( bone *bone );
-
-        void validate_bones();
-        void sort_bones();
-
+        void validate_influence_bone( influence *influence, const bone_ptr &new_bone ) const;
+        void notify_influence_bone( influence *influence );
+        void validate_influences();
+
+        void validate_tag_bone( tag *tag, const bone_ptr &new_bone );
+        void notify_tag_bone( tag *tag );
+        void validate_tags();
+
-        friend class bone;
+        friend class influence;
+        friend class tag;
-};
-

branches/morph-targets/libx42make/local.h

@@ -48 +48 @@
-#include "batcher.h"
-
+#define null NULL
+
-#ifdef assert
-#undef assert

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

@@ -34 +34 @@
-void vertex_weights::add( const vertex_weight &weight, bool renormalize_weights )
-{
+        struct wt_cmp
+        {
+                bool operator() ( const vertex_weight &a, const vertex_weight &b )
+                {
+                        return a._weight > b._weight;
+                }
+        };
+
+        for( size_t i = 0; i < max_weights; i++ )
+        {
+                if( _weights[i]._influence == weight._influence )
+                {
+                        //duplicate influences just accumulate
+                        vertex_weight tmp( weight._influence, _weights[i]._weight + weight._weight );
+
+                        //remove and re-add to get it in the right spot
+                        remove( i, false );
+                        add( tmp, renormalize_weights );
+
+                        return;
+                }
+        }
+
+        //insert into correct position
-        size_t ins_pos;
-        for( ins_pos = 0; ins_pos < max_weights; ins_pos++ )
@@ -48 +72 @@
-
-        _weights[ins_pos] = weight;
+
+        if( renormalize_weights )
+                normalize_weights();
+}
+
+void vertex_weights::remove( size_t index, bool renormalize_weights )
+{
+        if( index >= max_weights )
+                return;
+
+        for( size_t i = max_weights - 1; i > index; i-- )
+                _weights[i - 1] = _weights[i];
+
+        _weights[max_weights - 1] = vertex_weight();
-
-        if( renormalize_weights )

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

@@ -51 +51 @@
-
-/*
+        class influence
+*/
+
+void influence::bone( const bone_ptr &new_bone )
+{
+        owner->validate_influence_bone( this, new_bone );
+
+        _bone = new_bone;
+
+        owner->notify_influence_bone( this );
+}
+
+/*
+        class tag
+*/
+
+void tag::bone( const bone_ptr &new_bone )
+{
+        owner->validate_tag_bone( this, new_bone );
+
+        _bone = new_bone;
+
+        owner->notify_tag_bone( this );
+}
+
+/*
-        class model_builder
-*/
-
+void model_builder::validate_bone_prop( const bone_ptr &bone ) const
+{
+        if( !bone )
+                return;
+
+        if( bone->owner != this )
+                throw validation_error( "Bone parent belongs to another model_builder." );
+}
+
+void model_builder::begin_skeleton_update()
+{
+        begin_bone_update();
+        begin_influence_update();
+        begin_tag_update();
+}
+
+void model_builder::end_skeleton_update()
+{
+        end_tag_update();
+        try
+        {
+                end_influence_update();
+                try
+                {
+                        end_bone_update();
+                }
+                catch( ... )
+                {
+                        begin_influence_update();
+                        throw;
+                }
+        }
+        catch( ... )
+        {
+                begin_tag_update();
+                throw;
+        }
+}
+
-void model_builder::begin_bone_update()
-{
@@ -62 +127 @@
-{
-        if( !_bone_update_count )
-std::exception
-
-!--_bone_update_count
+error
+
+_bone_update_count == 1
-        {
-                validate_bones();
-                sort_bones();
-        }
+
+        _bone_update_count--;
-}
-
-bone_ptr model_builder::create_bone( const std::string &name, const bone_ptr &parent )
-{
+        validate_bone_parent( null, parent );
+
-        bone_ptr ret( new bone( this ) );
-
@@ -90 +159 @@
-                return;
-
+        validate_bone_prop( new_parent );
+
+        if( !bone )
+                //validating a parent for a new bone, done
+                return;
+        
-        //check if this would cause a cycle
-        for( bone_ptr p = new_parent; p; p = p->_parent )
@@ -137 +212 @@
-                }
-
-.get()
+
-                validate_bone_anim_group( b.get(), b->_anim_group );
-
@@ -199 +274 @@
-}
-
+void model_builder::begin_influence_update()
+{
+        _influence_update_count++;
+}
+
+void model_builder::end_influence_update()
+{
+        if( !_influence_update_count )
+                throw error();
+
+        if( _influence_update_count == 1 )
+        {
+                validate_influences();
+        }
+
+        _influence_update_count--;
+}
+
+influence_ptr model_builder::create_influence( const bone_ptr &bone, const affine &matrix )
+{
+        validate_influence_bone( null, bone );
+
+        influence_ptr ret( new influence( this ) );
+
+        ret->_bone = bone;
+        ret->matrix = matrix;
+
+        ret->_index = influences.size();
+        influences.push_back( ret );
+
+        return ret;
+}
+
+void model_builder::validate_influence_bone( influence * /* influence */, const bone_ptr &new_bone ) const
+{
+        if( _influence_update_count )
+                return;
+
+        validate_bone_prop( new_bone );
+}
+
+void model_builder::notify_influence_bone( influence * /* influence */ )
+{
+}
+
+void model_builder::validate_influences()
+{
+        if( _influence_update_count )
+                return;
+
+        for( size_t i = 0; i < influences.size(); i++ )
+        {
+                validate_influence_bone( influences[i].get(), influences[i]->_bone );
+        }
+}
+
+void model_builder::begin_tag_update()
+{
+        _tag_update_count++;
+}
+
+void model_builder::end_tag_update()
+{
+        if( !_tag_update_count )
+                throw error();
+
+        if( _tag_update_count == 1 )
+        {
+                validate_tags();
+        }
+
+        _tag_update_count--;
+}
+
+void model_builder::validate_tag_bone( tag * /* tag */, const bone_ptr &new_bone )
+{
+        if( _tag_update_count )
+                return;
+
+        validate_bone_prop( new_bone );
+}
+
+void model_builder::notify_tag_bone( tag * /* tag */ )
+{
+}
+
+void model_builder::validate_tags()
+{
+        if( _tag_update_count )
+                return;
+}
+
+tag_ptr model_builder::create_tag( const std::string &name, const bone_ptr &bone, const affine &matrix )
+{
+        validate_tag_bone( null, bone );
+
+        tag_ptr ret( new tag( this ) );
+
+        ret->_bone = bone;
+        ret->name = name;
+        ret->matrix = matrix;
+
+        ret->_index = tags.size();
+        tags.push_back( ret );
+
+        return ret;
+}
+
+
-};
-};