Changeset 453

Timestamp:

01/07/12 14:44:14 (5 months ago)

Author:

Carsten

Message:

Model code: This change extends and revises the AnimExpressionT class hierarchy,
so that our support for animation channels and animation blending is now complete!

This change is the "second half" of r452.
Upcoming changes will apply the new functionality to our application code, so that we can actually see the results.

Location:

cafu/trunk/Libs

Files:

• MaterialSystem/MaterialManagerImpl.hpp (modified) (1 diff)
• Models/AnimExpr.cpp (modified) (4 diffs)
• Models/AnimExpr.hpp (modified) (7 diffs)
• Models/AnimPose.cpp (modified) (5 diffs)
• Models/AnimPose.hpp (modified) (6 diffs)
• Templates/Pointer.hpp (added)

cafu/trunk/Libs/MaterialSystem/MaterialManagerImpl.hpp

@@ -53 +53 @@
 
     /// Returns whether the material with the given name is registered with the material manager,
-    /// i.e. if a call to <code>GetMaterial(MaterialName)</code> will return successfully.
+    /// i.e.\ if a call to <code>GetMaterial(MaterialName)</code> will return successfully.
     /// Use this to avoid warning messages to the console if the material is not registered.
     bool HasMaterial(const std::string& MaterialName) const;

cafu/trunk/Libs/Models/AnimExpr.cpp

@@ -24 +24 @@
 
 
+AnimExpressionT::AnimExpressionT(const CafuModelT& Model)
+    : m_Model(Model),
+      m_RefCount(0),
+      m_ChangeNum(0)
+{
+    UpdateChangeNum();
+}
+
+
+void AnimExpressionT::UpdateChangeNum()
+{
+    static unsigned int s_ChangeCount=0;
+
+    m_ChangeNum = ++s_ChangeCount;
+}
+
+
 /*************************/
 /*** AnimExprStandardT ***/
@@ -31 +48 @@
     : AnimExpressionT(Model),
       m_SequNr(SequNr),
-      m_FrameNr(FrameNr),
-      m_ChangeCount(1)      // The user code inits its own count with 0.
+      m_FrameNr(FrameNr)
 {
     NormalizeInput();
@@ -144 +160 @@
     NormalizeInput();
 
-    m_ChangeCount++;
+    UpdateChangeNum();
 }
 
@@ -155 +171 @@
     NormalizeInput();
 
-    m_ChangeCount++;
-}
+    UpdateChangeNum();
+}
+
+
+/***********************/
+/*** AnimExprFilterT ***/
+/***********************/
+
+namespace
+{
+    unsigned int FindChannelByName(const CafuModelT& Model, const std::string& ChannelName)
+    {
+        unsigned int ChannelNr;
+
+        for (ChannelNr=0; ChannelNr<Model.GetChannels().Size(); ChannelNr++)
+            if (ChannelName == Model.GetChannels()[ChannelNr].Name)
+                return ChannelNr;
+
+        return ChannelNr;
+    }
+}
+
+
+AnimExprFilterT::AnimExprFilterT(const CafuModelT& Model, IntrusivePtrT<AnimExpressionT> SubExpr, unsigned int ChannelNr)
+    : AnimExpressionT(Model),
+      m_SubExpr(SubExpr),
+      m_ChannelNr(ChannelNr)
+{
+}
+
+
+AnimExprFilterT::AnimExprFilterT(const CafuModelT& Model, IntrusivePtrT<AnimExpressionT> SubExpr, const std::string& ChannelName)
+    : AnimExpressionT(Model),
+      m_SubExpr(SubExpr),
+      m_ChannelNr(FindChannelByName(Model, ChannelName))
+{
+}
+
+
+void AnimExprFilterT::ReInit(IntrusivePtrT<AnimExpressionT> SubExpr, unsigned int ChannelNr)
+{
+    if (m_SubExpr==SubExpr && m_ChannelNr==ChannelNr) return;
+
+    m_SubExpr  =SubExpr;
+    m_ChannelNr=ChannelNr;
+
+    UpdateChangeNum();
+}
+
+
+unsigned int AnimExprFilterT::GetChangeNum() const
+{
+    return std::max(GetChangeNum(), m_SubExpr->GetChangeNum());
+}
+
+
+void AnimExprFilterT::GetData(unsigned int JointNr, float& Weight, Vector3fT& Pos, cf::math::QuaternionfT& Quat, Vector3fT& Scale) const
+{
+    Weight=0.0f;
+
+    if (m_ChannelNr >= GetModel().GetChannels().Size() || GetModel().GetChannels()[m_ChannelNr].IsMember(JointNr))
+    {
+        m_SubExpr->GetData(JointNr, Weight, Pos, Quat, Scale);
+    }
+}
+
+
+/************************/
+/*** AnimExprCombineT ***/
+/************************/
+
+AnimExprCombineT::AnimExprCombineT(const CafuModelT& Model, IntrusivePtrT<AnimExpressionT> A, IntrusivePtrT<AnimExpressionT> B)
+    : AnimExpressionT(Model),
+      m_A(A),
+      m_B(B)
+{
+}
+
+
+void AnimExprCombineT::ReInit(IntrusivePtrT<AnimExpressionT> A, IntrusivePtrT<AnimExpressionT> B)
+{
+    if (m_A==A && m_B==B) return;
+
+    m_A=A;
+    m_B=B;
+
+    UpdateChangeNum();
+}
+
+
+unsigned int AnimExprCombineT::GetChangeNum() const
+{
+    return std::max(GetChangeNum(),
+                    std::max(m_A->GetChangeNum(), m_B->GetChangeNum()));
+}
+
+
+void AnimExprCombineT::GetData(unsigned int JointNr, float& Weight, Vector3fT& Pos, cf::math::QuaternionfT& Quat, Vector3fT& Scale) const
+{
+    m_A->GetData(JointNr, Weight, Pos, Quat, Scale);
+
+    float                  WeightB;
+    Vector3fT              PosB;
+    cf::math::QuaternionfT QuatB;
+    Vector3fT              ScaleB;
+
+    // Pick the expression with the largest weight.
+    m_B->GetData(JointNr, WeightB, PosB, QuatB, ScaleB);
+
+    if (WeightB > Weight)
+    {
+        Weight = WeightB;
+        Pos    = PosB;
+        Quat   = QuatB;
+        Scale  = ScaleB;
+    }
+}
+
+
+void AnimExprCombineT::AdvanceTime(float Time, bool ForceLoop)
+{
+    m_A->AdvanceTime(Time, ForceLoop);
+    m_B->AdvanceTime(Time, ForceLoop);
+}
+
+
+/**********************/
+/*** AnimExprBlendT ***/
+/**********************/
+
+AnimExprBlendT::AnimExprBlendT(const CafuModelT& Model, IntrusivePtrT<AnimExpressionT> A, IntrusivePtrT<AnimExpressionT> B, float Duration)
+    : AnimExpressionT(Model),
+      m_A(A),
+      m_B(B),
+      m_Duration(Duration),
+      m_Frac(0.0f)
+{
+}
+
+
+void AnimExprBlendT::ReInit(IntrusivePtrT<AnimExpressionT> A, IntrusivePtrT<AnimExpressionT> B, float Duration)
+{
+    m_A=A;
+    m_B=B;
+    m_Duration=Duration;
+    m_Frac=0.0f;
+
+    UpdateChangeNum();
+}
+
+
+unsigned int AnimExprBlendT::GetChangeNum() const
+{
+    return std::max(GetChangeNum(),
+                    std::max(m_A->GetChangeNum(), m_B->GetChangeNum()));
+}
+
+
+void AnimExprBlendT::GetData(unsigned int JointNr, float& Weight, Vector3fT& Pos, cf::math::QuaternionfT& Quat, Vector3fT& Scale) const
+{
+    float                  w[2];
+    Vector3fT              p[2];
+    cf::math::QuaternionfT q[2];
+    Vector3fT              s[2];
+
+    if (m_Frac <= 0.0f)
+    {
+        m_A->GetData(JointNr, Weight, Pos, Quat, Scale);
+        return;
+    }
+
+    if (m_Frac >= 1.0f)
+    {
+        m_B->GetData(JointNr, Weight, Pos, Quat, Scale);
+        return;
+    }
+
+    m_A->GetData(JointNr, w[0], p[0], q[0], s[0]);
+    m_B->GetData(JointNr, w[1], p[1], q[1], s[1]);
+
+    const float f0 = 1.0f - m_Frac;
+    const float f1 = m_Frac;
+
+    Weight = w[0]*f0 + w[1]*f1;
+    Pos    = p[0]*f0 + p[1]*f1;
+    Quat   = slerp(q[0], q[1], f0);   // slerp() is why we cannot have generic "add" and "mul" AnimExpressionT's.
+    Scale  = s[0]*f0 + s[1]*f1;
+}
+
+
+void AnimExprBlendT::AdvanceTime(float Time, bool ForceLoop)
+{
+    // Advance the blend fraction.
+    if (m_Duration < 0.001f)
+    {
+        m_Frac = 1.0f;
+    }
+    else
+    {
+        m_Frac += Time/m_Duration;
+    }
+
+    m_Frac = std::min(m_Frac, 1.0f);
+
+
+    // Advance the sub-expressions.
+    if (m_Frac < 1.0f)
+    {
+        m_A->AdvanceTime(Time, ForceLoop);
+    }
+    else
+    {
+        m_A=NULL;   // m_A is unused now that m_Frac >= 1.0.
+    }
+
+    m_B->AdvanceTime(Time, ForceLoop);
+
+
+    UpdateChangeNum();
+}
+
+
+/*********************/
+/*** AnimExprPoolT ***/
+/*********************/
+
+void AnimExprPoolT::FlattenUnused()
+{
+    for (unsigned int AENr=0; AENr<m_Filter.Size(); AENr++)
+        if (m_Filter[AENr]->GetRefCount()==1)
+            m_Filter[AENr]->ReInit(NULL, 0);
+
+    for (unsigned int AENr=0; AENr<m_Combine.Size(); AENr++)
+        if (m_Combine[AENr]->GetRefCount()==1)
+            m_Combine[AENr]->ReInit(NULL, NULL);
+
+    for (unsigned int AENr=0; AENr<m_Blend.Size(); AENr++)
+        if (m_Blend[AENr]->GetRefCount()==1)
+            m_Blend[AENr]->ReInit(NULL, NULL, 0.0f);
+}
+
+
+IntrusivePtrT<AnimExprStandardT> AnimExprPoolT::GetStandard(int SequNr, float FrameNr)
+{
+    FlattenUnused();
+
+    for (unsigned int AENr=0; AENr<m_Standard.Size(); AENr++)
+    {
+        if (m_Standard[AENr]->GetRefCount()==1)
+        {
+            m_Standard[AENr]->SetSequNr(SequNr);
+            m_Standard[AENr]->SetFrameNr(FrameNr);
+
+            return m_Standard[AENr];
+        }
+    }
+
+    IntrusivePtrT<AnimExprStandardT> NewAE(new AnimExprStandardT(m_Model, SequNr, FrameNr));
+    m_Standard.PushBack(NewAE);
+
+    return NewAE;
+}
+
+
+IntrusivePtrT<AnimExprFilterT> AnimExprPoolT::GetFilter(IntrusivePtrT<AnimExpressionT> SubExpr, unsigned int ChannelNr)
+{
+    FlattenUnused();
+
+    for (unsigned int AENr=0; AENr<m_Filter.Size(); AENr++)
+    {
+        if (m_Filter[AENr]->GetRefCount()==1)
+        {
+            m_Filter[AENr]->ReInit(SubExpr, ChannelNr);
+
+            return m_Filter[AENr];
+        }
+    }
+
+    IntrusivePtrT<AnimExprFilterT> NewAE(new AnimExprFilterT(m_Model, SubExpr, ChannelNr));
+    m_Filter.PushBack(NewAE);
+
+    return NewAE;
+}
+
+
+IntrusivePtrT<AnimExprFilterT> AnimExprPoolT::GetFilter(IntrusivePtrT<AnimExpressionT> SubExpr, const std::string& ChannelName)
+{
+    return GetFilter(SubExpr, FindChannelByName(m_Model, ChannelName));
+}
+
+
+IntrusivePtrT<AnimExprCombineT> AnimExprPoolT::GetCombine(IntrusivePtrT<AnimExpressionT> A, IntrusivePtrT<AnimExpressionT> B)
+{
+    FlattenUnused();
+
+    for (unsigned int AENr=0; AENr<m_Combine.Size(); AENr++)
+    {
+        if (m_Combine[AENr]->GetRefCount()==1)
+        {
+            m_Combine[AENr]->ReInit(A, B);
+
+            return m_Combine[AENr];
+        }
+    }
+
+    IntrusivePtrT<AnimExprCombineT> NewAE(new AnimExprCombineT(m_Model, A, B));
+    m_Combine.PushBack(NewAE);
+
+    return NewAE;
+}
+
+
+IntrusivePtrT<AnimExprBlendT> AnimExprPoolT::GetBlend(IntrusivePtrT<AnimExpressionT> A, IntrusivePtrT<AnimExpressionT> B, float Duration)
+{
+    FlattenUnused();
+
+    for (unsigned int AENr=0; AENr<m_Blend.Size(); AENr++)
+    {
+        if (m_Blend[AENr]->GetRefCount()==1)
+        {
+            m_Blend[AENr]->ReInit(A, B, Duration);
+
+            return m_Blend[AENr];
+        }
+    }
+
+    IntrusivePtrT<AnimExprBlendT> NewAE(new AnimExprBlendT(m_Model, A, B, Duration));
+    m_Blend.PushBack(NewAE);
+
+    return NewAE;
+}

cafu/trunk/Libs/Models/AnimExpr.hpp

@@ -24 +24 @@
 
 #include "Math3D/Quaternion.hpp"
+#include "Templates/Array.hpp"
+#include "Templates/Pointer.hpp"
 
 
@@ -29 +31 @@
 
 
+/// Animation expressions describe the "skeleton pose" of a model.
+///
+/// They are used as an input to AnimPoseT instances, which use the "skeleton pose" expressed by an anim
+/// expression in order to derive the "full pose", including meshes and other features such as collision
+/// detection.
+/// In other words, AnimPoseT's refer to an AnimExpressionT for the "configuration" of its pose.
+///
+/// AnimExpressionT's can be hierarchically composed, just like mathematical expressions,
+/// which is in fact their strongest and most important feature.
+/// They are also very easy and care-free to use and have very good performance, because when obtained
+/// from an AnimExprPoolT, the pool minimizes both the number of instances as well as the penalties from
+/// memory allocations and deletes.
 class AnimExpressionT
 {
     public:
 
-    /// The constructor.        TODO: Make protected, so that only derived classes can use it?
-    AnimExpressionT(const CafuModelT& Model) : m_Model(Model) { }
+    /// The constructor.
+    /// (It's ok to have this in "public" instead of "protected": we have pure virtual methods as well.)
+    AnimExpressionT(const CafuModelT& Model);
 
     /// The (virtual) destructor.
@@ -41 +56 @@
     /// Returns the model that this is an anim expression for.
     const CafuModelT& GetModel() const { return m_Model; }
+
+    /// Returns the number of IntrusivePtrT<>'s that currently refer to this anim expression.
+    /// This is especially useful for the implementation of "pools" of AnimExpressionT's,
+    /// so that the pool implementation can learn if this instance is available for being re-used.
+    unsigned int GetRefCount() const { return m_RefCount; }
 
     /// Returns a number that changes whenever this expression changes,
@@ -46 +66 @@
     /// This is the case for example after every call to AdvanceTime() with a nonzero Time,
     /// or when a sub-expression has been modified (e.g. got a new sequence number assigned).
-    /// The caller can use this number in order to control refreshes of its mesh caches.
-    virtual unsigned int GetChangeCount() const=0;
+    /// The caller can use this number in order to control updates of its mesh caches.
+    virtual unsigned int GetChangeNum() const { return m_ChangeNum; }
 
     /// For the joint with the given JointNr, this function returns
@@ -58 +78 @@
 
 
-    private:
+    protected:
+
+    void UpdateChangeNum();
+
+
+    private:
+
+    template<class T> friend class IntrusivePtrT;
 
     AnimExpressionT(const AnimExpressionT&);        ///< Use of the Copy    Constructor is not allowed.
     void operator = (const AnimExpressionT&);       ///< Use of the Assignment Operator is not allowed.
 
-    const CafuModelT& m_Model;  ///< The related model that this is an anim expression for.
+    const CafuModelT& m_Model;      ///< The related model that this is an anim expression for.
+    unsigned int      m_RefCount;   ///< How many IntrusivePtrT<>'s currently refer to this anim expression?
+    unsigned int      m_ChangeNum;  ///< Changes whenever the data returned by GetData() changes.
 };
 
@@ -74 +103 @@
 
     // Implementations and overrides for base class methods.
-    virtual unsigned int GetChangeCount() const { return m_ChangeCount; }
     virtual void GetData(unsigned int JointNr, float& Weight, Vector3fT& Pos, cf::math::QuaternionfT& Quat, Vector3fT& Scale) const;
     virtual void AdvanceTime(float Time, bool ForceLoop=false);
@@ -97 +125 @@
     void NormalizeInput();
 
-    int          m_SequNr;      ///< The animation sequence number.
-    float        m_FrameNr;     ///< The frame number in the sequence.
-    unsigned int m_ChangeCount; ///< Changes whenever the data returned by GetData() might have changed.
+    int   m_SequNr;     ///< The animation sequence number.
+    float m_FrameNr;    ///< The frame number in the sequence.
+};
+
+
+/// Filters the result of another expression by a "channel".
+class AnimExprFilterT : public AnimExpressionT
+{
+    public:
+
+    AnimExprFilterT(const CafuModelT& Model, IntrusivePtrT<AnimExpressionT> SubExpr, unsigned int ChannelNr);
+    AnimExprFilterT(const CafuModelT& Model, IntrusivePtrT<AnimExpressionT> SubExpr, const std::string& ChannelName);
+
+    /// Re-initializes this anim expression, so that it can be re-used with different parameters (on the same model).
+    void ReInit(IntrusivePtrT<AnimExpressionT> SubExpr, unsigned int ChannelNr);
+
+    // Implementations and overrides for base class methods.
+    virtual unsigned int GetChangeNum() const;
+    virtual void GetData(unsigned int JointNr, float& Weight, Vector3fT& Pos, cf::math::QuaternionfT& Quat, Vector3fT& Scale) const;
+    virtual void AdvanceTime(float Time, bool ForceLoop=false) { m_SubExpr->AdvanceTime(Time, ForceLoop); }
+
+
+    private:
+
+    IntrusivePtrT<AnimExpressionT> m_SubExpr;
+    unsigned int                   m_ChannelNr;
+};
+
+
+class AnimExprCombineT : public AnimExpressionT
+{
+    public:
+
+    AnimExprCombineT(const CafuModelT& Model, IntrusivePtrT<AnimExpressionT> A, IntrusivePtrT<AnimExpressionT> B);
+
+    /// Re-initializes this anim expression, so that it can be re-used with different parameters (on the same model).
+    void ReInit(IntrusivePtrT<AnimExpressionT> A, IntrusivePtrT<AnimExpressionT> B);
+
+    // Implementations and overrides for base class methods.
+    virtual unsigned int GetChangeNum() const;
+    virtual void GetData(unsigned int JointNr, float& Weight, Vector3fT& Pos, cf::math::QuaternionfT& Quat, Vector3fT& Scale) const;
+    virtual void AdvanceTime(float Time, bool ForceLoop=false);
+
+
+    private:
+
+    IntrusivePtrT<AnimExpressionT> m_A;
+    IntrusivePtrT<AnimExpressionT> m_B;
+};
+
+
+class AnimExprBlendT : public AnimExpressionT
+{
+    public:
+
+    AnimExprBlendT(const CafuModelT& Model, IntrusivePtrT<AnimExpressionT> A, IntrusivePtrT<AnimExpressionT> B, float Duration);
+
+    /// Re-initializes this anim expression, so that it can be re-used with different parameters (on the same model).
+    /// Note that resetting \c A, \c B or \c Duration individually is not possible, because the implementation
+    /// may prune and drop \c A when the blend is complete.
+    void ReInit(IntrusivePtrT<AnimExpressionT> A, IntrusivePtrT<AnimExpressionT> B, float Duration);
+
+    // Implementations and overrides for base class methods.
+    virtual unsigned int GetChangeNum() const;
+    virtual void GetData(unsigned int JointNr, float& Weight, Vector3fT& Pos, cf::math::QuaternionfT& Quat, Vector3fT& Scale) const;
+    virtual void AdvanceTime(float Time, bool ForceLoop=false);
+
+
+    private:
+
+    IntrusivePtrT<AnimExpressionT> m_A;
+    IntrusivePtrT<AnimExpressionT> m_B;
+    float                          m_Duration;
+    float                          m_Frac;
+};
+
+
+class AnimExprPoolT
+{
+    public:
+
+    AnimExprPoolT(const CafuModelT& Model) : m_Model(Model) { }
+
+    // These methods mimic the ctors of the anim expression classes.
+    IntrusivePtrT<AnimExprStandardT> GetStandard(int SequNr, float FrameNr);
+    IntrusivePtrT<AnimExprFilterT>   GetFilter(IntrusivePtrT<AnimExpressionT> SubExpr, unsigned int ChannelNr);
+    IntrusivePtrT<AnimExprFilterT>   GetFilter(IntrusivePtrT<AnimExpressionT> SubExpr, const std::string& ChannelName);
+    IntrusivePtrT<AnimExprCombineT>  GetCombine(IntrusivePtrT<AnimExpressionT> A, IntrusivePtrT<AnimExpressionT> B);
+    IntrusivePtrT<AnimExprBlendT>    GetBlend(IntrusivePtrT<AnimExpressionT> A, IntrusivePtrT<AnimExpressionT> B, float Duration);
+
+
+    private:
+
+    /// This function makes sure that anim expressions that are unused don't keep pointers
+    /// to subexpressions, such that the subexpressions are available as unused as well.
+    void FlattenUnused();
+
+    const CafuModelT&                          m_Model;     ///< The related model that this is an anim expression pool for.
+    ArrayT< IntrusivePtrT<AnimExprStandardT> > m_Standard;
+    ArrayT< IntrusivePtrT<AnimExprFilterT> >   m_Filter;
+    ArrayT< IntrusivePtrT<AnimExprCombineT> >  m_Combine;
+    ArrayT< IntrusivePtrT<AnimExprBlendT> >    m_Blend;
 };
 

cafu/trunk/Libs/Models/AnimPose.cpp

@@ -30 +30 @@
 
 
+AnimPoseT::AnimPoseT(const CafuModelT& Model, IntrusivePtrT<AnimExpressionT> AnimExpr)
+    : m_Model(Model),
+      m_AnimExpr(AnimExpr),
+      m_SuperPose(NULL),
+      m_DlodPose(NULL),
+      m_RecacheCount(0),
+      m_BoundingBox()
+{
+    if (m_Model.GetDlodModel())
+    {
+        // Recursively create the chain of dlod poses matching the chain of dlod models.
+        // Note that all dlod poses share the *SAME* AnimExpr as the top-most pose!
+        m_DlodPose = new AnimPoseT(*m_Model.GetDlodModel(), m_AnimExpr);
+    }
+}
+
+
 AnimPoseT::AnimPoseT(const CafuModelT& Model, int SequNr, float FrameNr)
     : m_Model(Model),
-      m_AnimExpr(NULL),
+      m_AnimExpr(new AnimExprStandardT(m_Model, SequNr, FrameNr)),
       m_SuperPose(NULL),
-      m_DlodPose(m_Model.GetDlodModel() ? new AnimPoseT(*m_Model.GetDlodModel(), SequNr, FrameNr) : NULL),  // Recursively create the chain of dlod poses matching the chain of dlod models.
+      m_DlodPose(m_Model.GetDlodModel() ? new AnimPoseT(*m_Model.GetDlodModel(), m_AnimExpr) : NULL),  // Recursively create the chain of dlod poses matching the chain of dlod models.
       m_RecacheCount(0),
       m_BoundingBox()
 {
-    m_AnimExpr=new AnimExprStandardT(m_Model, SequNr, FrameNr);
 }
 
@@ -45 +61 @@
 {
     delete m_DlodPose;
-    delete m_AnimExpr;
+}
+
+
+void AnimPoseT::SetAnimExpr(IntrusivePtrT<AnimExpressionT> AnimExpr)
+{
+    for (AnimPoseT* Pose=this; Pose; Pose=Pose->m_DlodPose)
+    {
+        Pose->m_AnimExpr = AnimExpr;
+    }
 }
 
@@ -399 +423 @@
 void AnimPoseT::Recache() const
 {
-    if (!m_SuperPose && m_RecacheCount==m_AnimExpr->GetChangeCount()) return;
+    if (!m_SuperPose && m_RecacheCount==m_AnimExpr->GetChangeNum()) return;
 
     SyncDimensions();
@@ -414 +438 @@
     //     y();
 
-    m_RecacheCount=m_AnimExpr->GetChangeCount();
-}
-
-
-int   AnimPoseT::GetSequNr() const { return dynamic_cast<AnimExprStandardT*>(m_AnimExpr)->GetSequNr(); }
-float AnimPoseT::GetFrameNr() const { return dynamic_cast<AnimExprStandardT*>(m_AnimExpr)->GetFrameNr(); }
+    m_RecacheCount=m_AnimExpr->GetChangeNum();
+}
+
+
+int   AnimPoseT::GetSequNr() const
+{
+    return dynamic_cast<const AnimExprStandardT*>(&*m_AnimExpr)->GetSequNr();
+}
+
+
+float AnimPoseT::GetFrameNr() const
+{
+    return dynamic_cast<const AnimExprStandardT*>(&*m_AnimExpr)->GetFrameNr();
+}
 
 
 void AnimPoseT::SetSequNr(int SequNr)
 {
-    dynamic_cast<AnimExprStandardT*>(m_AnimExpr)->SetSequNr(SequNr);
+    dynamic_cast<AnimExprStandardT*>(&*m_AnimExpr)->SetSequNr(SequNr);
 
     // Recursively update the chain of dlod poses.
@@ -433 +465 @@
 void AnimPoseT::SetFrameNr(float FrameNr)
 {
-    dynamic_cast<AnimExprStandardT*>(m_AnimExpr)->SetFrameNr(FrameNr);
+    dynamic_cast<AnimExprStandardT*>(&*m_AnimExpr)->SetFrameNr(FrameNr);
 
     // Recursively update the chain of dlod poses.

cafu/trunk/Libs/Models/AnimPose.hpp

@@ -23 +23 @@
 #define _CAFU_MODEL_ANIM_POSE_HPP_
 
-#include "Templates/Array.hpp"
+#include "AnimExpr.hpp"
 #include "MaterialSystem/Mesh.hpp"
 #include "Math3D/BoundingBox.hpp"
@@ -29 +29 @@
 
 
-class AnimExpressionT;
 class CafuModelT;
 class MaterialT;
@@ -36 +35 @@
 /// This class describes a specific pose of an associated model.
 ///
-/// A pose is defined by a set of animation sequences at given frame numbers for given channels,
-/// whose combined application to the model yields all data that is relevant for further actions
+/// A pose is defined (or "configured") by an AnimExpressionT instance
+/// whose application to the model yields all data that is relevant for further actions
 /// on the model in that pose, such as rendering, tracing rays, collision detection, etc.
 ///
-/// The data that is derived from the set of input tuples (sequence, frame number, channel)
-/// is cached within the pose instance. It comprises:
+/// The data that is derived from the anim expression is cached within the pose instance.
+/// It comprises:
 ///   - the transformation matrices for each joint in the skeleton,
 ///   - the MatSys render meshes for each mesh,
@@ -48 +47 @@
 /// the representation of a model (the \c CafuModelT instance).
 /// As a consequence, AnimPoseT instances should be shared whenever there are multiple users
-/// (such as "static detail model" entity instances) that all show the same model in the same
-/// pose.
+/// (such as "static detail model" entity instances) that all show the same model in the same pose.
 class AnimPoseT
 {
@@ -89 +87 @@
 
     /// The constructor.
+    AnimPoseT(const CafuModelT& Model, IntrusivePtrT<AnimExpressionT> AnimExpr);
+
+    /// The constructor.
     AnimPoseT(const CafuModelT& Model, int SequNr=-1, float FrameNr=0.0f);
 
     /// The destructor.
     ~AnimPoseT();
+
+    /// Sets a new anim expression to use for this pose.
+    ///
+    /// \param AnimExpr   The new anim expression to use for this pose.
+    void SetAnimExpr(IntrusivePtrT<AnimExpressionT> AnimExpr);
 
     int GetSequNr() const;
@@ -172 +178 @@
     void Recache() const;
 
-    const CafuModelT&             m_Model;          ///< The related model that this is a pose for.
-    AnimExpressionT*              m_AnimExpr;       ///< The expression that describes the animation state of the joints for which we have computed the cache data.
-    const AnimPoseT*              m_SuperPose;
-    AnimPoseT*                    m_DlodPose;       ///< The next pose in the chain of dlod poses matching the chain of dlod models.
- // ArrayT<...>                   m_Def;            ///< Array of { channel, sequence, framenr, (forceloop), blendweight } tuples.
- // bool                          m_DoCache;        ///< Cache the computed data? (Set to true by the user if he want to re-use this instance.)
+    const CafuModelT&              m_Model;         ///< The related model that this is a pose for.
+    IntrusivePtrT<AnimExpressionT> m_AnimExpr;      ///< The expression that describes the skeleton pose for which we have computed the cache data.
+    const AnimPoseT*               m_SuperPose;
+    AnimPoseT*                     m_DlodPose;      ///< The next pose in the chain of dlod poses matching the chain of dlod models.
 
-    mutable unsigned int          m_RecacheCount;   ///< Used to detect if the m_AnimExpr has changed, so that our matrices, meshes etc. can be recached.
-    mutable ArrayT<MatrixT>       m_JointMatrices;  ///< The transformation matrices that represent the pose of the skeleton at the given animation sequence and frame number.
-    mutable ArrayT<MeshInfoT>     m_MeshInfos;      ///< Additional data for each mesh in m_Model.
-    mutable ArrayT<MatSys::MeshT> m_Draw_Meshes;    ///< The draw meshes resulting from the m_JointMatrices.
-    mutable BoundingBox3fT        m_BoundingBox;    ///< The bounding-box for the model in this pose.
+    mutable unsigned int           m_RecacheCount;  ///< Used to detect if the m_AnimExpr has changed, so that our matrices, meshes etc. can be recached.
+    mutable ArrayT<MatrixT>        m_JointMatrices; ///< The transformation matrices that represent the pose of the skeleton at the given animation sequence and frame number.
+    mutable ArrayT<MeshInfoT>      m_MeshInfos;     ///< Additional data for each mesh in m_Model.
+    mutable ArrayT<MatSys::MeshT>  m_Draw_Meshes;   ///< The draw meshes resulting from the m_JointMatrices.
+    mutable BoundingBox3fT         m_BoundingBox;   ///< The bounding-box for the model in this pose.
 };