Changeset 400

Timestamp:

10/05/11 11:21:02 (8 months ago)

Author:

Carsten

Message:

Model support:
Separated the pose of a model from the definition of the model, encapsulating the pose in the newly introduced class AnimPoseT.

This is a preparatory step for completing the support of animation channels and animation blending, where a pose will be composed of possibly several animation sequences playing on different channels, and animation sequences that are blended into each other.

This change also improves the existing code and design, as separate concepts are now cleanly separated in code.
It also improves caching, because all cached data is encapsulated in AnimPoseT where it is up to the user code to share or reuse the data across models and/or video frames.

Location:

cafu/trunk

Files:

• CaWE/ModelEditor/ChildFrame.cpp (modified) (2 diffs)
• CaWE/ModelEditor/Commands/Add.cpp (modified) (2 diffs)
• CaWE/ModelEditor/Commands/Delete.cpp (modified) (6 diffs)
• CaWE/ModelEditor/Commands/Delete.hpp (modified) (1 diff)
• CaWE/ModelEditor/Commands/TransformJoint.cpp (modified) (2 diffs)
• CaWE/ModelEditor/ModelDocument.cpp (modified) (4 diffs)
• CaWE/ModelEditor/ModelDocument.hpp (modified) (4 diffs)
• CaWE/ModelEditor/ScenePropGrid.cpp (modified) (3 diffs)
• CaWE/ModelEditor/SceneView3D.cpp (modified) (8 diffs)
• Libs/Models/AnimPose.cpp (added)
• Libs/Models/AnimPose.hpp (added)
• Libs/Models/Loader_ase.cpp (modified) (3 diffs)
• Libs/Models/Loader_lwo.cpp (modified) (5 diffs)
• Libs/Models/Model_cmdl.cpp (modified) (6 diffs)
• Libs/Models/Model_cmdl.hpp (modified) (6 diffs)
• Libs/SConscript (modified) (1 diff)

cafu/trunk/CaWE/ModelEditor/ChildFrame.cpp

@@ -841 +841 @@
             m_ModelDoc->UpdateAllObservers_SelectionChanged(ANIM, OldSel, m_ModelDoc->GetSelection(ANIM));
 
-            m_ModelDoc->GetAnimState().FrameNr=0.0f;
+            m_ModelDoc->GetAnimState().Pose.SetFrameNr(0.0f);
             m_ModelDoc->UpdateAllObservers_AnimStateChanged();
             break;
@@ -852 +852 @@
             m_ModelDoc->UpdateAllObservers_SelectionChanged(ANIM, OldSel, m_ModelDoc->GetSelection(ANIM));
 
-            m_ModelDoc->GetAnimState().FrameNr=0.0f;
+            m_ModelDoc->GetAnimState().Pose.SetFrameNr(0.0f);
             m_ModelDoc->UpdateAllObservers_AnimStateChanged();
             break;

cafu/trunk/CaWE/ModelEditor/Commands/Add.cpp

@@ -103 +103 @@
 
     // Make sure that the draw cache is refreshed.
-    m_ModelDoc->GetModel()->m_Draw_CachedDataAtSequNr=-1234;
+    m_ModelDoc->GetAnimState().Pose.SetNeedsRecache();
 
     m_ModelDoc->UpdateAllObservers_Created(m_Type, Indices);
@@ -159 +159 @@
 
     // Make sure that the draw cache is refreshed.
-    m_ModelDoc->GetModel()->m_Draw_CachedDataAtSequNr=-1234;
+    m_ModelDoc->GetAnimState().Pose.SetNeedsRecache();
 
     m_ModelDoc->UpdateAllObservers_Deleted(m_Type, Indices);

cafu/trunk/CaWE/ModelEditor/Commands/Delete.cpp

@@ -88 +88 @@
                 MeshInfoT& MI=m_MeshInfos[m_MeshInfos.Size()-1];
 
-                MI.Mesh    =m_ModelDoc->GetModel()->GetMeshes()[i];
-                MI.DrawMesh=m_ModelDoc->GetModel()->m_Draw_Meshes[i];
+                MI.Mesh=m_ModelDoc->GetModel()->GetMeshes()[i];
 
                 for (unsigned long SkinNr=0; SkinNr<m_ModelDoc->GetModel()->GetSkins().Size(); SkinNr++)
@@ -158 +157 @@
     if (m_Type==MESH)
     {
+        if (m_Indices.Size() >= m_ModelDoc->GetModel()->GetMeshes().Size())
+        {
+            m_Message="Cannot delete all meshes -- at least one mesh must be left.";
+            return false;
+        }
+
         for (unsigned long GFixNr=0; GFixNr<m_ModelDoc->GetModel()->GetGuiFixtures().Size(); GFixNr++)
             for (unsigned int PointNr=0; PointNr<3; PointNr++)
@@ -183 +188 @@
             case MESH:
             {
-                m_ModelDoc->GetModel()->m_Meshes     .RemoveAtAndKeepOrder(i);
-                m_ModelDoc->GetModel()->m_Draw_Meshes.RemoveAtAndKeepOrder(i);
+                m_ModelDoc->GetModel()->m_Meshes.RemoveAtAndKeepOrder(i);
 
                 for (unsigned long SkinNr=0; SkinNr<m_ModelDoc->GetModel()->GetSkins().Size(); SkinNr++)
@@ -197 +201 @@
 
     // Make sure that the draw cache is refreshed.
-    m_ModelDoc->GetModel()->m_Draw_CachedDataAtSequNr=-1234;
+    m_ModelDoc->GetAnimState().Pose.SetNeedsRecache();
 
     m_ModelDoc->UpdateAllObservers_Deleted(m_Type, m_Indices);
@@ -226 +230 @@
                 const MeshInfoT& MI=m_MeshInfos[INr];
 
-                m_ModelDoc->GetModel()->m_Meshes     .InsertAt(i, MI.Mesh);
-                m_ModelDoc->GetModel()->m_Draw_Meshes.InsertAt(i, MI.DrawMesh);
+                m_ModelDoc->GetModel()->m_Meshes.InsertAt(i, MI.Mesh);
 
                 for (unsigned long SkinNr=0; SkinNr<m_ModelDoc->GetModel()->GetSkins().Size(); SkinNr++)
@@ -240 +243 @@
 
     // Make sure that the draw cache is refreshed.
-    m_ModelDoc->GetModel()->m_Draw_CachedDataAtSequNr=-1234;
+    m_ModelDoc->GetAnimState().Pose.SetNeedsRecache();
 
     m_ModelDoc->UpdateAllObservers_Created(m_Type, m_Indices);

cafu/trunk/CaWE/ModelEditor/Commands/Delete.hpp

@@ -54 +54 @@
         {
             CafuModelT::MeshT                Mesh;                  ///< The deleted mesh.
-            MatSys::MeshT                    DrawMesh;              ///< The draw mesh related to \c Mesh.
             ArrayT<MaterialT*>               SkinsMaterials;        ///< The material in each skin for this mesh.
             ArrayT<MatSys::RenderMaterialT*> SkinsRenderMaterials;  ///< The render material in each skin for this mesh.

cafu/trunk/CaWE/ModelEditor/Commands/TransformJoint.cpp

@@ -52 +52 @@
     // Make sure that the BB is updated and the draw cache is refreshed.
     m_ModelDoc->GetModel()->RecomputeBindPoseBB();
-    m_ModelDoc->GetModel()->m_Draw_CachedDataAtSequNr=-1234;
+    m_ModelDoc->GetAnimState().Pose.SetNeedsRecache();
 
     m_ModelDoc->UpdateAllObservers_JointChanged(m_JointNr);
@@ -71 +71 @@
     // Make sure that the BB is updated and the draw cache is refreshed.
     m_ModelDoc->GetModel()->RecomputeBindPoseBB();
-    m_ModelDoc->GetModel()->m_Draw_CachedDataAtSequNr=-1234;
+    m_ModelDoc->GetAnimState().Pose.SetNeedsRecache();
 
     m_ModelDoc->UpdateAllObservers_JointChanged(m_JointNr);

cafu/trunk/CaWE/ModelEditor/ModelDocument.cpp

@@ -40 +40 @@
 
 ModelEditor::ModelDocumentT::SubmodelT::SubmodelT(const wxString& fn, CafuModelT* sm, const ArrayT<unsigned int>& jm)
-    : m_Filename(fn), m_Submodel(sm), m_JointsMap(jm)
+    : m_Filename(fn),
+      m_Submodel(sm),
+      m_Pose(*sm, -1, 0.0f),
+      m_JointsMap(jm)
 {
 }
@@ -64 +67 @@
     : m_Model(LoadModel(FileName)),
       m_SequenceBB(m_Model->GetBB(-1, 0.0f)),
+      m_AnimState(*m_Model),
       m_Submodels(),
       m_Gui(new cf::GuiSys::GuiImplT("Win1=gui:new('WindowT'); gui:SetRootWindow(Win1); gui:activate(true); "
@@ -132 +136 @@
     if (Type==ANIM)
     {
+        m_AnimState.Pose.SetSequNr(m_Selection[ANIM].Size()==0 ? -1 : m_Selection[ANIM][0]);
+
         if (m_Selection[ANIM].Size()==0)
         {
@@ -224 +230 @@
 void ModelEditor::ModelDocumentT::AdvanceTime(float Time)
 {
-    if (m_Selection[ANIM].Size()>0 && Time*m_AnimState.Speed!=0.0f)
-    {
-        m_AnimState.FrameNr=m_Model->AdvanceFrameNr(m_Selection[ANIM][0], m_AnimState.FrameNr, Time*m_AnimState.Speed, m_AnimState.Loop);
+    if (Time*m_AnimState.Speed!=0.0f)
+    {
+        m_AnimState.Pose.Advance(Time*m_AnimState.Speed, m_AnimState.Loop);
     }
 }

cafu/trunk/CaWE/ModelEditor/ModelDocument.hpp

@@ -27 +27 @@
 #include "Math3D/BoundingBox.hpp"
 #include "Math3D/Vector3.hpp"
+#include "Models/AnimPose.hpp"
 #include "Templates/Array.hpp"
 #include "wx/wx.h"
@@ -63 +64 @@
             public:
 
-            AnimStateT()
-                : FrameNr(0.0f), Speed(1.0f), Loop(true) { }
+            AnimStateT(const CafuModelT& Model)
+                : Pose(Model), Speed(1.0f), Loop(true) { }
 
-            float FrameNr;  ///< The current frame number.
-            float Speed;    ///< The speed (relative to clock time) with which the animation is advanced, usually 0 for stop or 1 for playback.
-            bool  Loop;     ///< When playing the sequence, loop automatically when its end has been reached?
+            AnimPoseT Pose;     ///< The current pose of the model, as defined by sequence and frame number.
+            float     Speed;    ///< The speed (relative to clock time) with which the animation is advanced, usually 0 for stop or 1 for playback.
+            bool      Loop;     ///< When playing the sequence, loop automatically when its end has been reached?
         };
 
@@ -80 +81 @@
             const wxString&             GetFilename() const { return m_Filename; }
             const CafuModelT*           GetSubmodel() const { return m_Submodel; }
+            AnimPoseT&                  GetPose() { return m_Pose; }
             const ArrayT<unsigned int>& GetJointsMap() const { return m_JointsMap; }
 
@@ -87 +89 @@
             wxString             m_Filename;    ///< The filename of the submodel.
             CafuModelT*          m_Submodel;    ///< The submodel that is shown with the main model.
+            AnimPoseT            m_Pose;        ///< The pose of the submodel.
             ArrayT<unsigned int> m_JointsMap;   ///< Describes how the joints of the m_Submodel map to the joints of the m_Model super model.
 

cafu/trunk/CaWE/ModelEditor/ScenePropGrid.cpp

@@ -135 +135 @@
 
     wxPGProperty* AnimControlCat=Append(new wxPropertyCategory("Animation Control"));
-    m_AnimFrameNrProp=AppendIn(AnimControlCat, new wxFloatProperty("Frame No.", wxPG_LABEL, Anim.FrameNr));
+    m_AnimFrameNrProp=AppendIn(AnimControlCat, new wxFloatProperty("Frame No.", wxPG_LABEL, Anim.Pose.GetFrameNr()));
     m_AnimSpeedProp  =AppendIn(AnimControlCat, new wxFloatProperty("Speed", wxPG_LABEL, Anim.Speed));
     m_AnimLoopProp   =AppendIn(AnimControlCat, new wxBoolProperty("Loop", wxPG_LABEL, Anim.Loop));
@@ -218 +218 @@
     else if (PropName=="Model.Show Mesh")     m_Model_ShowMesh    =Prop->GetValue().GetBool();
     else if (PropName=="Model.Show Skeleton") m_Model_ShowSkeleton=Prop->GetValue().GetBool();
-    else if (PropName=="Frame No.") { AnimState.FrameNr=PropValueF; m_IsRecursiveSelfNotify=true; m_Parent->GetModelDoc()->UpdateAllObservers_AnimStateChanged(); m_IsRecursiveSelfNotify=false; }
-    else if (PropName=="Speed")     { AnimState.Speed  =PropValueF; m_IsRecursiveSelfNotify=true; m_Parent->GetModelDoc()->UpdateAllObservers_AnimStateChanged(); m_IsRecursiveSelfNotify=false; }
-    else if (PropName=="Loop")      { AnimState.Loop   =Prop->GetValue().GetBool(); m_IsRecursiveSelfNotify=true; m_Parent->GetModelDoc()->UpdateAllObservers_AnimStateChanged(); m_IsRecursiveSelfNotify=false; }
+    else if (PropName=="Frame No.") { AnimState.Pose.SetFrameNr(PropValueF); m_IsRecursiveSelfNotify=true; m_Parent->GetModelDoc()->UpdateAllObservers_AnimStateChanged(); m_IsRecursiveSelfNotify=false; }
+    else if (PropName=="Speed")     { AnimState.Speed=PropValueF; m_IsRecursiveSelfNotify=true; m_Parent->GetModelDoc()->UpdateAllObservers_AnimStateChanged(); m_IsRecursiveSelfNotify=false; }
+    else if (PropName=="Loop")      { AnimState.Loop =Prop->GetValue().GetBool(); m_IsRecursiveSelfNotify=true; m_Parent->GetModelDoc()->UpdateAllObservers_AnimStateChanged(); m_IsRecursiveSelfNotify=false; }
     else if (PropName=="Ambient Light Color")
     {
@@ -275 +275 @@
     const ModelDocumentT::AnimStateT& AnimState=m_Parent->GetModelDoc()->GetAnimState();
 
-    if (m_AnimFrameNrProp->GetValue().GetDouble()!=AnimState.FrameNr)
-        m_AnimFrameNrProp->SetValue(AnimState.FrameNr);
+    if (m_AnimFrameNrProp->GetValue().GetDouble()!=AnimState.Pose.GetFrameNr())
+        m_AnimFrameNrProp->SetValue(AnimState.Pose.GetFrameNr());
 
     if (m_AnimSpeedProp->GetValue().GetDouble()!=AnimState.Speed)

cafu/trunk/CaWE/ModelEditor/SceneView3D.cpp

@@ -101 +101 @@
 
     // Trace the ray against the model, which is a per-triangle accurate test.
-    const ModelDocumentT::AnimStateT& Anim   =ModelDoc->GetAnimState();
-    const ArrayT<unsigned int>&       AnimSel=ModelDoc->GetSelection(ANIM);
     ModelT::TraceResultT Result;
 
-    if (ModelDoc->GetModel()->TraceRay(AnimSel.Size()==0 ? -1 : AnimSel[0], Anim.FrameNr,
-        ModelDoc->GetSelSkinNr(), RayOrigin, RayDir, Result) && Result.Fraction<BestFraction)
+    if (ModelDoc->GetAnimState().Pose.TraceRay(ModelDoc->GetSelSkinNr(), RayOrigin, RayDir, Result) && Result.Fraction<BestFraction)
     {
         BestFraction=Result.Fraction;
@@ -164 +161 @@
             ModelDoc->UpdateAllObservers_SelectionChanged(ANIM, OldSel, ModelDoc->GetSelection(ANIM));
 
-            ModelDoc->GetAnimState().FrameNr=0.0f;
+            ModelDoc->GetAnimState().Pose.SetFrameNr(0.0f);
             ModelDoc->UpdateAllObservers_AnimStateChanged();
             break;
@@ -176 +173 @@
             ModelDoc->UpdateAllObservers_SelectionChanged(ANIM, OldSel, ModelDoc->GetSelection(ANIM));
 
-            ModelDoc->GetAnimState().FrameNr=0.0f;
+            ModelDoc->GetAnimState().Pose.SetFrameNr(0.0f);
             ModelDoc->UpdateAllObservers_AnimStateChanged();
             break;
@@ -237 +234 @@
     const Vector3fT      HitPos=TraceCameraRay(ScreenToClient(CE.GetPosition()), ModelTR);
     const CafuModelT*    Model=m_Parent->GetModelDoc()->GetModel();
+    const AnimPoseT&     Pose=m_Parent->GetModelDoc()->GetAnimState().Pose;
     unsigned int         BestVertexNr=0;
     bool                 HaveModelHit=false;
@@ -242 +240 @@
     if (ModelTR.Fraction>0.0f && ModelTR.MeshNr<Model->GetMeshes().Size() && ModelTR.TriNr<Model->GetMeshes()[ModelTR.MeshNr].Triangles.Size())
     {
-        float BestDist=0.0f;
-
-        for (unsigned int i=0; i<3; i++)
-        {
-            const unsigned int VertexNr=Model->GetMeshes()[ModelTR.MeshNr].Triangles[ModelTR.TriNr].VertexIdx[i];
-            const Vector3fT&   DrawPos =Model->GetMeshes()[ModelTR.MeshNr].Vertices[VertexNr].Draw_Pos;
-            const float        Dist    =length(DrawPos-HitPos);
-
-            if (i==0 || Dist<BestDist)
-            {
-                BestDist    =Dist;
-                BestVertexNr=VertexNr;
-            }
-        }
-
+        BestVertexNr=Pose.FindClosestVertex(ModelTR.MeshNr, ModelTR.TriNr, HitPos);
         HaveModelHit=true;
     }
@@ -383 +367 @@
 
     // Render the model.
-    const CafuModelT*                 Model  =ModelDoc->GetModel();
-    const ModelDocumentT::AnimStateT& Anim   =ModelDoc->GetAnimState();
-    const ArrayT<unsigned int>&       AnimSel=ModelDoc->GetSelection(ANIM);
-    const int                         SequNr =AnimSel.Size()==0 ? -1 : AnimSel[0];
+    const CafuModelT*                 Model=ModelDoc->GetModel();
+    const ModelDocumentT::AnimStateT& Anim =ModelDoc->GetAnimState();
 
     if (ScenePropGrid->m_Model_ShowMesh)
     {
-        Model->Draw(SequNr, Anim.FrameNr, ModelDoc->GetSelSkinNr(), 0.0f /*LodDist*/, (CafuModelT::SuperT*)NULL);
+        Anim.Pose.Draw(ModelDoc->GetSelSkinNr(), 0.0f /*LodDist*/);
 
         for (unsigned long SmNr=0; SmNr<ModelDoc->GetSubmodels().Size(); SmNr++)
         {
-            const ModelDocumentT::SubmodelT* SM=ModelDoc->GetSubmodels()[SmNr];
-            const CafuModelT::SuperT Super(
-                Model->GetDrawJointMatrices(SequNr, Anim.FrameNr),
+            ModelDocumentT::SubmodelT* SM=ModelDoc->GetSubmodels()[SmNr];
+            AnimPoseT&                 SmPose=SM->GetPose();
+
+            const AnimPoseT::SuperT Super(
+                Anim.Pose.GetJointMatrices(),
                 SM->GetJointsMap());
 
-            SM->GetSubmodel()->Draw(0, 0.0f, -1 /*SkinNr*/, 0.0f /*LodDist*/, &Super);
+            SmPose.SetSuper(&Super);
+            SmPose.Draw(-1 /*SkinNr*/, 0.0f /*LodDist*/);
+            SmPose.SetSuper(NULL);
         }
     }
@@ -407 +393 @@
     if (ScenePropGrid->m_Model_ShowSkeleton && MatSys::Renderer->GetCurrentRenderAction()==MatSys::RendererI::AMBIENT)
     {
-        RenderSkeleton(Model->GetJoints(), Model->GetDrawJointMatrices(SequNr, Anim.FrameNr), false);
+        RenderSkeleton(Model->GetJoints(), Anim.Pose.GetJointMatrices(), false);
 
         for (unsigned long SmNr=0; SmNr<ModelDoc->GetSubmodels().Size(); SmNr++)
         {
-            const ModelDocumentT::SubmodelT* SM=ModelDoc->GetSubmodels()[SmNr];
-            const CafuModelT::SuperT Super(
-                Model->GetDrawJointMatrices(SequNr, Anim.FrameNr),
+            ModelDocumentT::SubmodelT* SM=ModelDoc->GetSubmodels()[SmNr];
+            AnimPoseT&                 SmPose=SM->GetPose();
+
+            const AnimPoseT::SuperT Super(
+                Anim.Pose.GetJointMatrices(),
                 SM->GetJointsMap());
 
-            RenderSkeleton(SM->GetSubmodel()->GetJoints(), SM->GetSubmodel()->GetDrawJointMatrices(0, 0.0f, &Super), true);
+            SmPose.SetSuper(&Super);
+            RenderSkeleton(SM->GetSubmodel()->GetJoints(), SmPose.GetJointMatrices(), true);
+            SmPose.SetSuper(NULL);
         }
     }
@@ -435 +425 @@
                 if (!Model->IsVertexNrOK(GF, PointNr)) continue;
 
-                Points[PointNr]=Model->GetMeshes()[GF.Points[PointNr].MeshNr].Vertices[GF.Points[PointNr].VertexNr].Draw_Pos;
+                Points[PointNr]=Anim.Pose.GetVertexPos(GF.Points[PointNr].MeshNr, GF.Points[PointNr].VertexNr);
                 PointsOK|=(1 << PointNr);
             }

cafu/trunk/Libs/Models/Loader_ase.cpp

@@ -531 +531 @@
 
                     assert(CafuVertex.NumWeights==1);
-                    assert(Mesh.Weights[CafuVertex.FirstWeightIdx].Pos==CafuVertex.Draw_Pos);
-
-                    if (CafuVertex.Draw_Pos!=AseVertexPos) continue;
+                    assert(Mesh.Weights[CafuVertex.FirstWeightIdx].Pos==CafuVertex.gts_Pos);
+
+                    if (CafuVertex.gts_Pos!=AseVertexPos) continue;
                     if (CafuVertex.u!=GO.TexCoords[AseTri.IndTexCoords[i]].AsVectorOfFloat().x) continue;
                     if (CafuVertex.v!=GO.TexCoords[AseTri.IndTexCoords[i]].AsVectorOfFloat().y) continue;
 
-                    if (CafuVertex.Draw_Normal!=AseTri.Normals[i].AsVectorOfFloat()) continue;
-                    if (CafuVertex.Draw_Tangent!=AseTri.Tangents[i].AsVectorOfFloat()) continue;
-                    if (CafuVertex.Draw_BiNormal!=AseTri.BiNormals[i].AsVectorOfFloat()) continue;
+                    if (CafuVertex.gts_Normal!=AseTri.Normals[i].AsVectorOfFloat()) continue;
+                    if (CafuVertex.gts_Tangent!=AseTri.Tangents[i].AsVectorOfFloat()) continue;
+                    if (CafuVertex.gts_BiNormal!=AseTri.BiNormals[i].AsVectorOfFloat()) continue;
 
                     // This vertex meets all criteria - take it.
@@ -569 +569 @@
                     CafuVertex.FirstWeightIdx=WeightNr;
                     CafuVertex.NumWeights    =1;
-                    CafuVertex.Draw_Pos      =AseVertexPos;
-                    CafuVertex.Draw_Normal   =AseTri.Normals[i].AsVectorOfFloat();
-                    CafuVertex.Draw_Tangent  =AseTri.Tangents[i].AsVectorOfFloat();
-                    CafuVertex.Draw_BiNormal =AseTri.BiNormals[i].AsVectorOfFloat();
+                    CafuVertex.gts_Pos       =AseVertexPos;
+                    CafuVertex.gts_Normal    =AseTri.Normals[i].AsVectorOfFloat();
+                    CafuVertex.gts_Tangent   =AseTri.Tangents[i].AsVectorOfFloat();
+                    CafuVertex.gts_BiNormal  =AseTri.BiNormals[i].AsVectorOfFloat();
                 }
 
@@ -580 +580 @@
             }
 
-            CafuTri.Draw_Normal=AseTri.Normal.AsVectorOfFloat();
+            CafuTri.gts_Normal=AseTri.Normal.AsVectorOfFloat();
         }
 

cafu/trunk/Libs/Models/Loader_lwo.cpp

@@ -369 +369 @@
                     MeshVertex.NumWeights    =1;
 
-                    MeshVertex.Draw_Pos      =Mesh.Weights[PolyVert.index].Pos;     // Normally the base class code computes this, but we also have to pre-provide a proper value here for ComputeTangents().
-                    MeshVertex.Draw_Normal   =Vector3fT(PolyVert.norm);
-                 // MeshVertex.Draw_Tangent  =...;      // Set below to polygon average.
-                 // MeshVertex.Draw_BiNormal =...;      // Set below to polygon average.
+                    MeshVertex.gts_Pos      =Mesh.Weights[PolyVert.index].Pos;     // Normally the base class code computes this, but we also have to pre-provide a proper value here for ComputeTangents().
+                    MeshVertex.gts_Normal   =Vector3fT(PolyVert.norm);
+                 // MeshVertex.gts_Tangent  =...;      // Set below to polygon average.
+                 // MeshVertex.gts_BiNormal =...;      // Set below to polygon average.
 
                     WeightVerts[PolyVert.index].PushBack(MeshVertexNr);
@@ -395 +395 @@
                     Triangle.VertexIdx[2]=PolygonMeshVertices[VertexNr+1];
 
-                    Triangle.Draw_Normal=Vector3fT(Poly.norm);
+                    Triangle.gts_Normal=Vector3fT(Poly.norm);
 
 
@@ -415 +415 @@
                     // The vertex may be shared across multiple polygons, and we want to build the average over them.
                     // Therefore we only accumulate the tangents here, and normalize below.
-                    Vertex.Draw_Tangent +=myNormalize(Poly_Tangent);
-                    Vertex.Draw_BiNormal+=myNormalize(Poly_BiTangent);
+                    Vertex.gts_Tangent +=myNormalize(Poly_Tangent);
+                    Vertex.gts_BiNormal+=myNormalize(Poly_BiTangent);
                 }
             }
@@ -426 +426 @@
                 CafuModelT::MeshT::VertexT& Vertex=Mesh.Vertices[VertexNr];
 
-                Vertex.Draw_Tangent =myNormalize(Vertex.Draw_Tangent );
-                Vertex.Draw_BiNormal=myNormalize(Vertex.Draw_BiNormal);
+                Vertex.gts_Tangent =myNormalize(Vertex.gts_Tangent );
+                Vertex.gts_BiNormal=myNormalize(Vertex.gts_BiNormal);
             }
         }
@@ -446 +446 @@
     const CafuModelT::MeshT::VertexT&   V_1   =Mesh.Vertices[Tri.VertexIdx[1]];
     const CafuModelT::MeshT::VertexT&   V_2   =Mesh.Vertices[Tri.VertexIdx[2]];
-    const Vector3fT                     Edge01=V_1.Draw_Pos-V_0.Draw_Pos;
-    const Vector3fT                     Edge02=V_2.Draw_Pos-V_0.Draw_Pos;
+    const Vector3fT                     Edge01=V_1.gts_Pos-V_0.gts_Pos;
+    const Vector3fT                     Edge02=V_2.gts_Pos-V_0.gts_Pos;
 
     // Triangles are ordered CW for md5 models and CCW for ase models, so we write
     // Normal=VectorCross(Edge02, Edge01) for md5 models and Normal=VectorCross(Edge01, Edge02) for ase models.
-    // Tri.Draw_Normal=myNormalize(Edge02.cross(Edge01));
+    // Tri.gts_Normal=myNormalize(Edge02.cross(Edge01));
 
     // Understanding what's going on here is easy. The key statement is

cafu/trunk/Libs/Models/Model_cmdl.cpp

@@ -21 +21 @@
 
 #include "Model_cmdl.hpp"
+#include "AnimPose.hpp"     // Only for implementing the "old" ModelT interface methods.
 #include "Loader.hpp"
 #include "MaterialSystem/Material.hpp"
 #include "MaterialSystem/Renderer.hpp"
 #include "Math3D/BoundingBox.hpp"
-#include "Math3D/Pluecker.hpp"
 #include "Math3D/Quaternion.hpp"
 #include "String.hpp"
@@ -240 +240 @@
       m_MaterialMan(),
       m_UseGivenTangentSpace(Loader.UseGivenTS()),  // Should we use the fixed, given tangent space, or recompute it ourselves here?
-      m_BindPoseBB(Vector3fT()),                    // Re-initialized in InitMeshes() calling RecomputeBindPoseBB(), but start with a valid box anyways (e.g. for testing models that have a skeleton, but no mesh).
-      m_Draw_CachedDataAtSequNr(-1234),             // Just a random number that is unlikely to occur normally.
-      m_Draw_CachedDataAtFrameNr(-3.1415926f)       // Just a random number that is unlikely to occur normally.
+      m_BindPoseBB(Vector3fT())                     // Re-initialized in InitMeshes() calling RecomputeBindPoseBB(), but start with a valid box anyways (e.g. for testing models that have a skeleton, but no mesh).
 {
     // No matter the actual model file format (that is, even if the file format is not "cmdl"),
@@ -305 +303 @@
                 Skin.RenderMaterials[MatNr]=MatSys::Renderer->RegisterMaterial(Skin.Materials[MatNr]);
         }
-    }
-
-    // Allocate the cache space that is needed for drawing.
-    m_JointMatrices.PushBackEmpty(m_Joints.Size());
-    m_Draw_Meshes.PushBackEmpty(m_Meshes.Size());
-
-    for (unsigned long MeshNr=0; MeshNr<m_Meshes.Size(); MeshNr++)
-    {
-        m_Draw_Meshes[MeshNr].Type   =MatSys::MeshT::Triangles;
-     // m_Draw_Meshes[MeshNr].Winding=MatSys::MeshT::CW;    // CW is the default.
-        m_Draw_Meshes[MeshNr].Vertices.PushBackEmpty(m_Meshes[MeshNr].Triangles.Size()*3);
     }
 }
@@ -931 +918 @@
 
 
-static Vector3fT myNormalize(const Vector3fT& A)
-{
-    const float Length=length(A);
-
-    return (Length>0.000001f) ? A.GetScaled(1.0f/Length) : Vector3fT();
-}
-
-
-void CafuModelT::UpdateCachedDrawData(int SequenceNr, float FrameNr, const SuperT* Super) const
-{
-    // **************************************************************************************************************
-    //  Obtain a joints (bone) hierarchy for the desired frame FrameNr of the desired animation sequence SequenceNr.
-    //  The result will be a transformation matrix for each joint (bone).
-    // **************************************************************************************************************
-
-    if (SequenceNr==-1)
-    {
-        // Don't animate, just use the bind pose defined in the model file.
-        for (unsigned long JointNr=0; JointNr<m_Joints.Size(); JointNr++)
-        {
-            if (Super && Super->HasMatrix(JointNr))
-            {
-                m_JointMatrices[JointNr]=Super->GetMatrix(JointNr);
-                continue;
-            }
-
-            const JointT& J=m_Joints[JointNr];
-            const MatrixT RelMatrix(J.Pos, cf::math::QuaternionfT::FromXYZ(J.Qtr), J.Scale);
-
-            m_JointMatrices[JointNr]=(J.Parent==-1) ? RelMatrix : m_JointMatrices[J.Parent]*RelMatrix;
-        }
-    }
-    else
-    {
-        // SequenceNr is a valid index into m_Anims, so use that.
-        const AnimT& Anim=m_Anims[SequenceNr];
-        const int    Frame_0=int(FrameNr);                                          // If FrameNr == 17.83, then Frame_0 == 17
-        const float  Frame_f=FrameNr-Frame_0;                                       //                           Frame_f ==  0.83
-        const int    Frame_1=(Frame_0+1>=int(Anim.Frames.Size())) ? 0 : Frame_0+1;  //                           Frame_1 == 18
-
-        for (unsigned long JointNr=0; JointNr<m_Joints.Size(); JointNr++)
-        {
-            if (Super && Super->HasMatrix(JointNr))
-            {
-                m_JointMatrices[JointNr]=Super->GetMatrix(JointNr);
-                continue;
-            }
-
-            const AnimT::AnimJointT& AJ=Anim.AnimJoints[JointNr];
-            Vector3fT                Data_0[3]={ AJ.DefaultPos, AJ.DefaultQtr, AJ.DefaultScale };
-            Vector3fT                Data_1[3]={ AJ.DefaultPos, AJ.DefaultQtr, AJ.DefaultScale };
-
-            // Determine the position, quaternion and scale for Frame_0 and Frame_1.
-            unsigned int FlagCount=0;
-
-            for (int i=0; i<9; i++)
-            {
-                if ((AJ.Flags >> i) & 1)
-                {
-                    Data_0[i/3][i % 3]=Anim.Frames[Frame_0].AnimData[AJ.FirstDataIdx+FlagCount];
-                    Data_1[i/3][i % 3]=Anim.Frames[Frame_1].AnimData[AJ.FirstDataIdx+FlagCount];
-
-                    FlagCount++;
-                }
-            }
-
-            // Interpolate the position and quaternion according to the fraction Frame_f.
-            const Vector3fT              Pos  =Data_0[0]*(1.0f-Frame_f) + Data_1[0]*Frame_f;
-            const cf::math::QuaternionfT Quat =slerp(cf::math::QuaternionfT::FromXYZ(Data_0[1]), cf::math::QuaternionfT::FromXYZ(Data_1[1]), Frame_f);
-            const Vector3fT              Scale=Data_0[2]*(1.0f-Frame_f) + Data_1[2]*Frame_f;
-
-            // Compute the matrix that is relative to the parent bone, and finally obtain the absolute matrix for that bone!
-            const MatrixT RelMatrix(Pos, Quat, Scale);
-            const JointT& J=m_Joints[JointNr];
-
-            m_JointMatrices[JointNr]=(J.Parent==-1) ? RelMatrix : m_JointMatrices[J.Parent]*RelMatrix;
-        }
-    }
-
-
-    // *******************************************************************************************************************
-    //  The JointMatrices represent now the pose of the model at the desired frame number of the desired sequence number.
-    //  For all meshes do now compute the vertices according to their weights.
-    // *******************************************************************************************************************
-
-    for (unsigned long MeshNr=0; MeshNr<m_Meshes.Size(); MeshNr++)
-    {
-        MeshT& Mesh=m_Meshes[MeshNr];
-
-        for (unsigned long VertexNr=0; VertexNr<Mesh.Vertices.Size(); VertexNr++)
-        {
-            MeshT::VertexT& Vertex=Mesh.Vertices[VertexNr];
-
-            if (Vertex.GeoDups.Size()>0 && Vertex.GeoDups[0]<VertexNr)
-            {
-                // This vertex has a geometrically identical duplicate that has already been computed.
-                // Therefore, don't bother to recompute the same position again, just copy it from the duplicate.
-                Vertex.Draw_Pos=Mesh.Vertices[Vertex.GeoDups[0]].Draw_Pos;
-                continue;
-            }
-
-            if (Vertex.NumWeights==1)
-            {
-                const MeshT::WeightT& Weight=Mesh.Weights[Vertex.FirstWeightIdx];
-
-                Vertex.Draw_Pos=m_JointMatrices[Weight.JointIdx].Mul_xyz1(Weight.Pos);
-            }
-            else
-            {
-                Vertex.Draw_Pos=Vector3fT(0.0f, 0.0f, 0.0f);
-
-                for (unsigned int WeightNr=0; WeightNr<Vertex.NumWeights; WeightNr++)
-                {
-                    const MeshT::WeightT& Weight=Mesh.Weights[Vertex.FirstWeightIdx+WeightNr];
-
-                    Vertex.Draw_Pos+=m_JointMatrices[Weight.JointIdx].Mul_xyz1(Weight.Pos) * Weight.Weight;
-                }
-            }
-        }
-    }
-
-
-    // *******************************************************************************************
-    //  Compute the tangent-space basis vectors for all triangles and all vertices.
-    //  This is done by first computing the per-triangle axes and then having them enter
-    //  the relevant per-vertex averages as required (taking mirror corrections into account).
-    //  The per-triangle normal vectors are also kept for stencil shadow silhoutte determination.
-    // *******************************************************************************************
-
-    if (m_UseGivenTangentSpace)
-    {
-        assert(m_Anims.Size()==0);  // It doesn't make sense to have statically given tangent-space axes with *animated* geometry...
-        goto DoneComputingTS;
-    }
-
-    // For all vertices, zero the tangent-space vectors for the subsequent average accumulation.
-    for (unsigned long MeshNr=0; MeshNr<m_Meshes.Size(); MeshNr++)
-    {
-        MeshT& Mesh=m_Meshes[MeshNr];
-
-        for (unsigned long VertexNr=0; VertexNr<Mesh.Vertices.Size(); VertexNr++)
-        {
-            MeshT::VertexT& Vertex=Mesh.Vertices[VertexNr];
-
-            Vertex.Draw_Normal  =Vector3fT(0, 0, 0);
-            Vertex.Draw_Tangent =Vector3fT(0, 0, 0);
-            Vertex.Draw_BiNormal=Vector3fT(0, 0, 0);
-        }
-    }
-
-    // Compute the per-triangle tangent-space axes and distribute them over the relevant vertices appropriately.
-    for (unsigned long MeshNr=0; MeshNr<m_Meshes.Size(); MeshNr++)
-    {
-        MeshT& Mesh=m_Meshes[MeshNr];
-
-        for (unsigned long TriangleNr=0; TriangleNr<Mesh.Triangles.Size(); TriangleNr++)
-        {
-            MeshT::TriangleT&     Tri   =Mesh.Triangles[TriangleNr];
-            const MeshT::VertexT& V_0   =Mesh.Vertices[Tri.VertexIdx[0]];
-            const MeshT::VertexT& V_1   =Mesh.Vertices[Tri.VertexIdx[1]];
-            const MeshT::VertexT& V_2   =Mesh.Vertices[Tri.VertexIdx[2]];
-            const Vector3fT       Edge01=V_1.Draw_Pos-V_0.Draw_Pos;
-            const Vector3fT       Edge02=V_2.Draw_Pos-V_0.Draw_Pos;
-
-            // Triangles are ordered CW for md5 models and CCW for ase models, so we write
-            // Normal=VectorCross(Edge02, Edge01) for md5 models and Normal=VectorCross(Edge01, Edge02) for ase models.
-            Tri.Draw_Normal=myNormalize(Edge02.cross(Edge01));
-
-            // Understanding what's going on here is easy. The key statement is
-            // "The tangent vector is parallel to the direction of increasing S on a parametric surface."
-            // First, there is a short explanation in "The Cg Tutorial", chapter 8.
-            // Second, I have drawn a simple figure that leads to a simple 2x2 system of Gaussian equations, see my TechArchive.
-            const Vector3fT uv01=Vector3fT(V_1.u, V_1.v, 0.0f)-Vector3fT(V_0.u, V_0.v, 0.0f);
-            const Vector3fT uv02=Vector3fT(V_2.u, V_2.v, 0.0f)-Vector3fT(V_0.u, V_0.v, 0.0f);
-            const float     f   =uv01.x*uv02.y-uv01.y*uv02.x>0.0 ? 1.0f : -1.0f;
-
-            const Vector3fT Tri_Draw_Tangent =myNormalize(Edge02.GetScaled(-uv01.y*f) + Edge01.GetScaled(uv02.y*f));
-            const Vector3fT Tri_Draw_BiNormal=myNormalize(Edge02.GetScaled( uv01.x*f) - Edge01.GetScaled(uv02.x*f));
-
-
-            // Distribute the per-triangle tangent-space over the affected vertices.
-#if 1
-            const float Pi=3.14159265358979323846f;
-
-            const float c0=dot(myNormalize(Edge01), myNormalize(Edge02));
-            const float c1=dot(myNormalize(Edge01), myNormalize(V_1.Draw_Pos-V_2.Draw_Pos));
-
-            const float w0=(c0>=1.0f) ? 0.0f : ( (c0<=-1.0f) ? Pi : acos(c0) );
-            const float w1=(c1>=1.0f) ? 0.0f : ( (c1<=-1.0f) ? Pi : acos(c1) );
-
-            const float TriWeight[3]={ w0, w1, Pi-TriWeight[0]-TriWeight[1] };
-#else
-            const float TriWeight[3]={ 1.0f, 1.0f, 1.0f };
-#endif
-
-            for (int i=0; i<3; i++)
-            {
-                MeshT::VertexT& Vertex=Mesh.Vertices[Tri.VertexIdx[i]];
-
-                assert(Tri.Polarity==Vertex.Polarity);
-
-                Vertex.Draw_Normal  +=Tri.Draw_Normal*TriWeight[i];
-                Vertex.Draw_Tangent +=Tri_Draw_Tangent*TriWeight[i];
-                Vertex.Draw_BiNormal+=Tri_Draw_BiNormal*TriWeight[i];
-
-                for (unsigned long DupNr=0; DupNr<Vertex.GeoDups.Size(); DupNr++)
-                {
-                    MeshT::VertexT& DupVertex=Mesh.Vertices[Vertex.GeoDups[DupNr]];
-
-                    DupVertex.Draw_Normal  +=Tri.Draw_Normal*TriWeight[i];
-                    DupVertex.Draw_Tangent +=Tri_Draw_Tangent*(Tri.Polarity==DupVertex.Polarity ? TriWeight[i] : -TriWeight[i]);
-                    DupVertex.Draw_BiNormal+=Tri_Draw_BiNormal*TriWeight[i];
-                }
-            }
-        }
-    }
-
-    // Finally normalize the per-vertex tangent-space axes; this is quasi the "division" in the average computations.
-    for (unsigned long MeshNr=0; MeshNr<m_Meshes.Size(); MeshNr++)
-    {
-        MeshT& Mesh=m_Meshes[MeshNr];
-
-        for (unsigned long VertexNr=0; VertexNr<Mesh.Vertices.Size(); VertexNr++)
-        {
-            MeshT::VertexT& Vertex=Mesh.Vertices[VertexNr];
-
-            // Normalize the tangent-space axes.
-            Vertex.Draw_Normal  =myNormalize(Vertex.Draw_Normal  );
-            Vertex.Draw_Tangent =myNormalize(Vertex.Draw_Tangent );
-            Vertex.Draw_BiNormal=myNormalize(Vertex.Draw_BiNormal);
-        }
-    }
-
-    DoneComputingTS:
-
-
-    // ***************************************************************************************************************
-    //  Construct explicit MatSys::MeshT meshes now.
-    //  Note that this is very inefficient - we REALLY should work with index arrays! (and/or vertex buffer objects!)
-    // ***************************************************************************************************************
-
-    for (unsigned long MeshNr=0; MeshNr<m_Meshes.Size(); MeshNr++)
-    {
-        const MeshT& Mesh=m_Meshes[MeshNr];
-
-        for (unsigned long TriNr=0; TriNr<Mesh.Triangles.Size(); TriNr++)
-        {
-            for (unsigned long i=0; i<3; i++)
-            {
-                unsigned long VertexIdx=Mesh.Triangles[TriNr].VertexIdx[i];
-
-                m_Draw_Meshes[MeshNr].Vertices[TriNr*3+i].SetOrigin(Mesh.Vertices[VertexIdx].Draw_Pos.x, Mesh.Vertices[VertexIdx].Draw_Pos.y, Mesh.Vertices[VertexIdx].Draw_Pos.z);
-                m_Draw_Meshes[MeshNr].Vertices[TriNr*3+i].SetTextureCoord(Mesh.Vertices[VertexIdx].u, Mesh.Vertices[VertexIdx].v);
-                m_Draw_Meshes[MeshNr].Vertices[TriNr*3+i].SetNormal  (Mesh.Vertices[VertexIdx].Draw_Normal.x,   Mesh.Vertices[VertexIdx].Draw_Normal.y,   Mesh.Vertices[VertexIdx].Draw_Normal.z  );
-                m_Draw_Meshes[MeshNr].Vertices[TriNr*3+i].SetTangent (Mesh.Vertices[VertexIdx].Draw_Tangent.x,  Mesh.Vertices[VertexIdx].Draw_Tangent.y,  Mesh.Vertices[VertexIdx].Draw_Tangent.z );
-                m_Draw_Meshes[MeshNr].Vertices[TriNr*3+i].SetBiNormal(Mesh.Vertices[VertexIdx].Draw_BiNormal.x, Mesh.Vertices[VertexIdx].Draw_BiNormal.y, Mesh.Vertices[VertexIdx].Draw_BiNormal.z);
-            }
-        }
-    }
-}
-
-
-const ArrayT<MatrixT>& CafuModelT::GetDrawJointMatrices(int SequenceNr, float FrameNr, const SuperT* Super) const
-{
-    // SequenceNr==-1 means "use the bind pose from the model file only (no anim)".
-    if (SequenceNr>=int(m_Anims.Size())) SequenceNr=-1;
-    if (SequenceNr!=-1 && (m_Anims[SequenceNr].FPS<0.0 || m_Anims[SequenceNr].Frames.Size()==0)) SequenceNr=-1;
-    if (SequenceNr==-1) FrameNr=0.0;
-
-    // See Draw() for details.
-    if (m_Draw_CachedDataAtSequNr!=SequenceNr || m_Draw_CachedDataAtFrameNr!=FrameNr || Super!=NULL)
-    {
-        m_Draw_CachedDataAtSequNr =SequenceNr;
-        m_Draw_CachedDataAtFrameNr=FrameNr;
-
-        UpdateCachedDrawData(SequenceNr, FrameNr, Super);
-    }
-
-    return m_JointMatrices;
-}
-
-
 const MaterialT* CafuModelT::GetMaterial(unsigned long MeshNr, int SkinNr) const
 {
@@ -1247 +952 @@
 
 
-void CafuModelT::Draw(int SequenceNr, float FrameNr, int SkinNr, float /*LodDist*/, const SuperT* Super) const
-{
-    // SequenceNr==-1 means "use the bind pose from the model file only (no anim)".
-    if (SequenceNr>=int(m_Anims.Size())) SequenceNr=-1;
-    if (SequenceNr!=-1 && (m_Anims[SequenceNr].FPS<0.0 || m_Anims[SequenceNr].Frames.Size()==0)) SequenceNr=-1;
-    if (SequenceNr==-1) FrameNr=0.0;
-
-
-    // Do an early check whether the light and the sequence BBs intersect.
-    switch (MatSys::Renderer->GetCurrentRenderAction())
-    {
-        case MatSys::RendererI::AMBIENT:
-            break;
-
-        case MatSys::RendererI::LIGHTING:
-        case MatSys::RendererI::STENCILSHADOW:
-        {
-            const float                LightRadius=MatSys::Renderer->GetCurrentLightSourceRadius();
-            const Vector3T<float>      LightBox(LightRadius, LightRadius, LightRadius);
-            const Vector3T<float>      LightPosOLD(MatSys::Renderer->GetCurrentLightSourcePosition());
-            const BoundingBox3T<float> LightBB(LightPosOLD+LightBox, LightPosOLD-LightBox);
-
-            if (!LightBB.Intersects(GetBB(SequenceNr, FrameNr))) return;
-            break;
-        }
-    }
-
-
-    // The caching mechanism is really simple and works as follows:
-    // All data that does not depend on a frame or sequence number is precomputed and prepared once in the constructor.
-    // All data that is specific to a certain frame and sequence number is computed in UpdateCachedDrawData()
-    // and stored in member variables (those whose name begins with m_Draw_ or Draw_).
-    // If we are called again with the same frame and sequence numbers for which we have cached data in the last call,
-    // the data is simply re-used for drawing, skipping the expensive recomputations entirely.
-    // If the numbers are different, the cache data is recomputed and the reference frame and sequence numbers are updated.
-    //
-    // 1. To understand why this works well, consider first a scene with only a single animated model:
-    // First, we assume that the model will be drawn in the ambient pass plus for each light source in the stencil shadow and lighting pass.
-    // That is, assuming there are L light sources, this method is called 1+2*L times per frame with the same frame and sequence numbers.
-    // It's obvious that the first call for the ambient pass will come with different sequence or frame numbers than the
-    // previous call, as our model is animated. In this call the cache is recomputed, and it is obvious that for the 2*L subsequent
-    // calls for the stencil and lighting passes the frame and sequence numbers will be identical so that we can rely on the cached data.
-    // Thus, the computational effort with the cache is only 1/(1+2*L) of the amount without the cache.
-    //
-    // Note that we can ***NOT*** reasonably do any better by a more complex cache management (as is done in the ModelMdlT class).
-    // For example one might think that we might win something if we delay the computations of the tangent space in the ambient
-    // pass until a lighting pass occurs that actually needs the tangent space.
-    // First of all, this makes the cache management terribly complicated, see the ModelMdlT class for a scaring example.
-    // Even better, we may reasonably assume that we will need *all* cache data in each frame eventually (letztendlich) anyway,
-    // so that it is reasonable to compute it fully whenever the frame or sequence number changes.
-    // The only case where the assumption does not hold (and we could have saved computing something) is when no lightsource at all
-    // lights our model, and when also the ambient pass does not need the information (e.g. normal vectors for environment reflection mapping).
-    // As this is hopefully a rare case, we're doing pretty good.
-    // Border cases like outdoor terrains where animated player models are drawn only in the ambient pass should be addressed by dlod models.
-    //
-    // 2. Now consider a scene with multiple animated models that are all rendered by this single instance.
-    // Unfortunately, in this case our caching mechanism fails entirely: everything is recomputed on every call.
-    // In this case, several instances of the model should be created (if speed is important and space is dispensable).
-    // The fact that the Cafu Material System automatically shares rendering resources makes having multiple instances viable.
-    //
-    // 3. Finally, consider a scene with arbitrarily many non-animated models.
-    // As in this case the frame and sequence numbers are always identical for each call, the caching mechanism has maximum efficiency.
-    // All computations occur only once and then never again. This is the optimum cache utilization case.
-    if (m_Draw_CachedDataAtSequNr!=SequenceNr || m_Draw_CachedDataAtFrameNr!=FrameNr || Super!=NULL)
-    {
-        m_Draw_CachedDataAtSequNr =SequenceNr;
-        m_Draw_CachedDataAtFrameNr=FrameNr;
-
-        UpdateCachedDrawData(SequenceNr, FrameNr, Super);
-    }
-
-
-    switch (MatSys::Renderer->GetCurrentRenderAction())
-    {
-        case MatSys::RendererI::AMBIENT:
-        {
-            for (unsigned long MeshNr=0; MeshNr<m_Meshes.Size(); MeshNr++)
-            {
-                MatSys::Renderer->SetCurrentMaterial(GetRenderMaterial(MeshNr, SkinNr));
-                MatSys::Renderer->RenderMesh(m_Draw_Meshes[MeshNr]);
-
-#if 0
-                // Render the tangent space axes for each vertex.
-                static MaterialT SolidColorMaterial;
-                SolidColorMaterial.UseMeshColors=true;
-
-                static MatSys::MeshT TangentSpaceAxes(MatSys::MeshT::Lines);
-                TangentSpaceAxes.Vertices.Overwrite();
-
-                for (unsigned long VertexNr=0; VertexNr<m_Draw_Meshes[MeshNr].Vertices.Size(); VertexNr++)
-                {
-                    const float         scale=1.0f;
-                    const Vector3fT     Orig =Vector3fT(m_Draw_Meshes[MeshNr].Vertices[VertexNr].Origin);
-                    const Vector3fT     S_   =Vector3fT(m_Draw_Meshes[MeshNr].Vertices[VertexNr].Tangent);
-                    const Vector3fT     T_   =Vector3fT(m_Draw_Meshes[MeshNr].Vertices[VertexNr].BiNormal);
-                    const Vector3fT     N_   =Vector3fT(m_Draw_Meshes[MeshNr].Vertices[VertexNr].Normal);
-                    const float         col_ =m_Meshes[MeshNr].Triangles[VertexNr / 3].Polarity ? 0.5f : 0.0f;
-                    const unsigned long Ofs  =TangentSpaceAxes.Vertices.Size();
-
-                    TangentSpaceAxes.Vertices.PushBackEmpty(6);
-
-                    TangentSpaceAxes.Vertices[Ofs+0].SetOrigin(Orig);
-                    TangentSpaceAxes.Vertices[Ofs+0].SetColor(1, col_, col_);
-                    TangentSpaceAxes.Vertices[Ofs+1].SetOrigin(Orig+S_*scale);
-                    TangentSpaceAxes.Vertices[Ofs+1].SetColor(1, col_, col_);
-
-                    TangentSpaceAxes.Vertices[Ofs+2].SetOrigin(Orig);
-                    TangentSpaceAxes.Vertices[Ofs+2].SetColor(col_, 1, col_);
-                    TangentSpaceAxes.Vertices[Ofs+3].SetOrigin(Orig+T_*scale);
-                    TangentSpaceAxes.Vertices[Ofs+3].SetColor(col_, 1, col_);
-
-                    TangentSpaceAxes.Vertices[Ofs+4].SetOrigin(Orig);
-                    TangentSpaceAxes.Vertices[Ofs+4].SetColor(col_, col_, 1);
-                    TangentSpaceAxes.Vertices[Ofs+5].SetOrigin(Orig+N_*scale);
-                    TangentSpaceAxes.Vertices[Ofs+5].SetColor(col_, col_, 1);
-                }
-
-                MatSys::RenderMaterialT* SolidColorRenderMat=MatSys::Renderer->RegisterMaterial(&SolidColorMaterial);
-
-                MatSys::Renderer->SetCurrentMaterial(SolidColorRenderMat);
-                MatSys::Renderer->RenderMesh(TangentSpaceAxes);
-
-                MatSys::Renderer->FreeMaterial(SolidColorRenderMat);
-
-                // FIXME! Rendering the stencil shadows uses the same material as the ambient pass does!
-                // (The call to FreeMaterial() above implies that no material is being set, and thus without this line,
-                //  no stencil shadows get rendered!)
-                MatSys::Renderer->SetCurrentMaterial(m_Meshes[MeshNr].RenderMaterial);
-#endif
-            }
-            break;
-        }
-
-        case MatSys::RendererI::LIGHTING:
-        {
-            for (unsigned long MeshNr=0; MeshNr<m_Meshes.Size(); MeshNr++)
-            {
-                MatSys::Renderer->SetCurrentMaterial(GetRenderMaterial(MeshNr, SkinNr));
-                MatSys::Renderer->RenderMesh(m_Draw_Meshes[MeshNr]);
-            }
-            break;
-        }
-
-        case MatSys::RendererI::STENCILSHADOW:
-        {
-            const Vector3fT LightPos(MatSys::Renderer->GetCurrentLightSourcePosition());
-
-            for (unsigned long MeshNr=0; MeshNr<m_Meshes.Size(); MeshNr++)
-            {
-                const MeshT&     Mesh   =m_Meshes[MeshNr];
-                const MaterialT* MeshMat=GetMaterial(MeshNr, SkinNr);
-
-                if (MeshMat==NULL || MeshMat->NoShadows) continue;
-
-                static ArrayT<bool> TriangleIsFrontFacing;
-                if (TriangleIsFrontFacing.Size()<Mesh.Triangles.Size())
-                    TriangleIsFrontFacing.PushBackEmpty(Mesh.Triangles.Size()-TriangleIsFrontFacing.Size());
-
-                for (unsigned long TriNr=0; TriNr<Mesh.Triangles.Size(); TriNr++)
-                {
-                    const MeshT::TriangleT& Tri=Mesh.Triangles[TriNr];
-                    const float             Dot=(LightPos-Mesh.Vertices[Tri.VertexIdx[0]].Draw_Pos).dot(Tri.Draw_Normal);
-
-                    TriangleIsFrontFacing[TriNr]=Dot>0;
-                }
-
-
-                // Note that we have to cull the following polygons wrt. the *VIEWER* (not the light source)!
-                static MatSys::MeshT MeshSilhouette(MatSys::MeshT::Quads);  // The default winding order is "CW".
-                MeshSilhouette.Vertices.Overwrite();
-
-                for (unsigned long TriNr=0; TriNr<Mesh.Triangles.Size(); TriNr++)
-                {
-                    if (!TriangleIsFrontFacing[TriNr]) continue;
-
-                    // This triangle is front-facing wrt. the light source.
-                    const MeshT::TriangleT& Tri=Mesh.Triangles[TriNr];
-
-                    for (unsigned long EdgeNr=0; EdgeNr<3; EdgeNr++)
-                    {
-                        // If an edge has no (-1) or more than one (-2) neighbours, make it a silhouette edge.
-                        const bool IsSilhouetteEdge=(Tri.NeighbIdx[EdgeNr]<0) ? true : !TriangleIsFrontFacing[Tri.NeighbIdx[EdgeNr]];
-
-                        if (IsSilhouetteEdge)
-                        {
-                            // The neighbour at edge 'EdgeNr' is back-facing (or non-existant), so we have found a possible silhouette edge.
-                            const unsigned long v1=EdgeNr;
-                            const unsigned long v2=(EdgeNr+1) % 3;
-                            const Vector3fT     LA=Mesh.Vertices[Tri.VertexIdx[v1]].Draw_Pos-LightPos;
-                            const Vector3fT     LB=Mesh.Vertices[Tri.VertexIdx[v2]].Draw_Pos-LightPos;
-
-                            MeshSilhouette.Vertices.PushBackEmpty(4);
-
-                            const unsigned long MeshSize=MeshSilhouette.Vertices.Size();
-
-                            MeshSilhouette.Vertices[MeshSize-4].SetOrigin(Mesh.Vertices[Tri.VertexIdx[v2]].Draw_Pos);
-                            MeshSilhouette.Vertices[MeshSize-3].SetOrigin(Mesh.Vertices[Tri.VertexIdx[v1]].Draw_Pos);
-                            MeshSilhouette.Vertices[MeshSize-2].SetOrigin(LA, 0.0);
-                            MeshSilhouette.Vertices[MeshSize-1].SetOrigin(LB, 0.0);
-                        }
-                    }
-                }
-
-                MatSys::Renderer->RenderMesh(MeshSilhouette);
-
-
-                static MatSys::MeshT MeshCaps(MatSys::MeshT::Triangles);    // The default winding order is "CW".
-                MeshCaps.Vertices.Overwrite();
-
-                for (unsigned long TriNr=0; TriNr<Mesh.Triangles.Size(); TriNr++)
-                {
-                    if (!TriangleIsFrontFacing[TriNr]) continue;
-
-                    // This triangle is front-facing wrt. the light source.
-                    const MeshT::TriangleT& Tri=Mesh.Triangles[TriNr];
-
-                    MeshCaps.Vertices.PushBackEmpty(6);
-
-                    const unsigned long MeshSize=MeshCaps.Vertices.Size();
-
-                    // Render the occluder (front-facing wrt. the light source).
-                    const Vector3fT& A=Mesh.Vertices[Tri.VertexIdx[0]].Draw_Pos;
-                    const Vector3fT& B=Mesh.Vertices[Tri.VertexIdx[1]].Draw_Pos;
-                    const Vector3fT& C=Mesh.Vertices[Tri.VertexIdx[2]].Draw_Pos;
-
-                    MeshCaps.Vertices[MeshSize-6].SetOrigin(A);
-                    MeshCaps.Vertices[MeshSize-5].SetOrigin(B);
-                    MeshCaps.Vertices[MeshSize-4].SetOrigin(C);
-
-                    // Render the occluder (back-facing wrt. the light source).
-                    const Vector3fT LA=A-LightPos;
-                    const Vector3fT LB=B-LightPos;
-                    const Vector3fT LC=C-LightPos;
-
-                    MeshCaps.Vertices[MeshSize-3].SetOrigin(LC, 0.0);
-                    MeshCaps.Vertices[MeshSize-2].SetOrigin(LB, 0.0);
-                    MeshCaps.Vertices[MeshSize-1].SetOrigin(LA, 0.0);
-                }
-
-                MatSys::Renderer->RenderMesh(MeshCaps);
-            }
-
-            break;
-        }
-    }
-}
-
-
 void CafuModelT::Draw(int SequenceNr, float FrameNr, float LodDist, const ModelT* /*SubModel*/) const
 {
-    Draw(SequenceNr, FrameNr, -1 /*default skin*/, LodDist, (SuperT*)NULL);
+    AnimPoseT Pose(*this, SequenceNr, FrameNr);     // TODO: This is reconstructed on each call -- no caching at all!
+
+    Pose.Draw(-1 /*default skin*/, LodDist);
 }
 
@@ -1574 +1033 @@
 bool CafuModelT::TraceRay(int SequenceNr, float FrameNr, int SkinNr, const Vector3fT& RayOrigin, const Vector3fT& RayDir, TraceResultT& Result) const
 {
-    float Fraction=0.0f;
-
-    // If we miss the bounding-box, then we miss all the triangles as well.
-    if (!GetBB(SequenceNr, FrameNr).TraceRay(RayOrigin, RayDir, Fraction)) return false;
-
-    // Call this method to update the draw structures according to SequenceNr and FrameNr.
-    GetDrawJointMatrices(SequenceNr, FrameNr);
-
-    for (unsigned long MeshNr=0; MeshNr<m_Meshes.Size(); MeshNr++)
-    {
-        const MeshT&     Mesh   =m_Meshes[MeshNr];
-        const MaterialT* MeshMat=GetMaterial(MeshNr, SkinNr);
-
-        // If the ClipFlags don't match the ClipMask, this polygon doesn't interfere with the trace.
-        if (!MeshMat) continue;
-        // if ((MeshMat->ClipFlags & ClipMask)==0) continue;
-
-        for (unsigned long TriNr=0; TriNr<Mesh.Triangles.Size(); TriNr++)
-        {
-            // This code is a modification of the code in CollisionModelStaticT::PolygonT::TraceRay(),
-            // see there for details and additional information.
-            using namespace cf::math;
-            const MeshT::TriangleT& Tri=Mesh.Triangles[TriNr];
-
-            const Vector3fT& A=Mesh.Vertices[Tri.VertexIdx[0]].Draw_Pos;
-            const Vector3fT& B=Mesh.Vertices[Tri.VertexIdx[1]].Draw_Pos;
-            const Vector3fT& C=Mesh.Vertices[Tri.VertexIdx[2]].Draw_Pos;
-
-            const PlueckerfT R=PlueckerfT::CreateFromRay(RayOrigin, RayDir);
-
-            // We use Pluecker coordinates for the orientation tests.
-            // Note that Christer Ericson has shown in his blog at http://realtimecollisiondetection.net/blog/?p=13
-            // that scalar triple products (Spatprodukte) are equivalent and could be used as well.  ;-)
-            if (!MeshMat->TwoSided)
-            {
-                if (R*PlueckerfT::CreateFromLine(A, B) >= 0) continue;
-                if (R*PlueckerfT::CreateFromLine(B, C) >= 0) continue;
-                if (R*PlueckerfT::CreateFromLine(C, A) >= 0) continue;
-            }
-            else
-            {
-                int Count=0;
-
-                // Should not change Count if result == 0...
-                Count+=(R*PlueckerfT::CreateFromLine(A, B) >= 0) ? -1 : 1;
-                Count+=(R*PlueckerfT::CreateFromLine(B, C) >= 0) ? -1 : 1;
-                Count+=(R*PlueckerfT::CreateFromLine(C, A) >= 0) ? -1 : 1;
-
-                if (Count!=-3 && Count!=3) continue;
-            }
-
-            // The "aperture" test passed, now compute the fraction at which RayDir intersects the triangle plane.
-            const float Nenner=dot(Tri.Draw_Normal, RayDir);
-
-            if (Nenner==0) continue;                            // If Nenner==0, then RayDir is parallel to the triangle plane (no intersection).
-            assert(MeshMat->TwoSided || Nenner<0);              // If the material is single sided, then Nenner<0, a consequence of the Pluecker tests above.
-
-            const float Dist=dot(Tri.Draw_Normal, RayOrigin-A); // The distance of RayOrigin to the triangle plane.
-            const float F   =-(Dist-0.03125f)/Nenner;
-
-            // The intersection is only valid in the positive direction of RayDir.
-            if (F<0) continue;
-
-            // Hit the triangle!
-            Result.Fraction=F;
-            Result.Normal  =(Nenner<0) ? Tri.Draw_Normal : -Tri.Draw_Normal;    // Handle two-sided materials properly.
-            Result.Material=MeshMat;
-            Result.MeshNr  =MeshNr;
-            Result.TriNr   =TriNr;
-            return true;
-        }
-    }
-
-    return false;
+    AnimPoseT Pose(*this, SequenceNr, FrameNr);     // TODO: This is reconstructed on each call -- no caching at all!
+
+    return Pose.TraceRay(SkinNr, RayOrigin, RayDir, Result);
 }
 

cafu/trunk/Libs/Models/Model_cmdl.hpp

@@ -83 +83 @@
             bool         Polarity;      ///< True if this triangle has positive polarity (texture is not mirrored), or false if it has negative polarity (texture is mirrored, SxT points inward).
 
-            Vector3fT    Draw_Normal;   ///< The draw normal for this triangle, required for the shadow-silhouette determination.
+            Vector3fT    gts_Normal;    ///< The draw normal for this triangle, required for the shadow-silhouette determination.
         };
 
@@ -97 +97 @@
             ArrayT<unsigned int> GeoDups;       ///< This array contains the indices of vertices that are geometrical duplicates of this vertex, see AreVerticesGeoDups() for more information. The indices are stored in increasing order, and do *not* include the index of "this" vertex. Note that from the presence of GeoDups in a cmdl/md5 file we can *not* conclude that a break in the smoothing was intended by the modeller. Cylindrically wrapping seams are one counter-example.
 
-            Vector3fT            Draw_Pos;      ///< Position of this vertex.
-            Vector3fT            Draw_Normal;   ///< Vertex normal.
-            Vector3fT            Draw_Tangent;  ///< Vertex tangent.
-            Vector3fT            Draw_BiNormal; ///< Vertex binormal.
+            Vector3fT            gts_Pos;       ///< Position of this vertex.
+            Vector3fT            gts_Normal;    ///< Vertex normal.
+            Vector3fT            gts_Tangent;   ///< Vertex tangent.
+            Vector3fT            gts_BiNormal;  ///< Vertex binormal.
         };
 
@@ -239 +239 @@
 
 
-    /// This struct describes information about a parent or "super" model whose skeleton pose should be used when rendering this model.
-    /// For example, a player model can act as the super model for a weapon, so that the skeleton of the weapon is copied from the
-    /// player model in order to align the weapon with the hands of the player.
-    struct SuperT
-    {
-        /// The constructor.
-        /// @param Matrices_   The draw matrices of the super model.
-        /// @param Map_        Describes how our joints map to the joints of the super model.
-        ///                    If <tt>Map_[i]</tt> is not a valid index into \c Matrices_, then our joint \c i has no match in the skeleton of the super model.
-        SuperT(const ArrayT<MatrixT>& Matrices_, const ArrayT<unsigned int>& Map_) : Matrices(Matrices_), Map(Map_) { }
-
-        /// Has our joint \c JointNr a correspondence in the super model?
-        bool HasMatrix(unsigned long JointNr) const { return Map[JointNr] < Matrices.Size(); }
-
-        /// For our joint \c JointNr, return the corresponding matrix from the super model.
-        /// Only call this if HasMatrix(JointNr) returns \c true.
-        const MatrixT& GetMatrix(unsigned long JointNr) const { return Matrices[Map[JointNr]]; }
-
-        const ArrayT<MatrixT>&      Matrices;   ///< The draw matrices of the super model.
-        const ArrayT<unsigned int>& Map;        ///< Describes how our joints map to the joints of the super model. If <tt>Map[i]</tt> is not a valid index into \c Matrices, then our joint \c i has no match in the skeleton of the super model.
-    };
-
-
     /// The constructor. Creates a new Cafu model from a file as directed by the given model loader.
     /// @param Loader   The model loader that actually imports the file and fills in the model data.
@@ -282 +259 @@
     const ArrayT<ChannelT>&     GetChannels() const { return m_Channels; }
 
-    /// This method returns the set of drawing matrices (one per joint) at the given sequence and frame number.
-    const ArrayT<MatrixT>& GetDrawJointMatrices(int SequenceNr, float FrameNr, const SuperT* Super=NULL) const;
-
-    /// The new method to draw the model.
-    /// @param SequenceNr   The number of the animation sequence to use, -1 for the bind pose.
-    /// @param FrameNr      The frame number in the animation sequence to render to model at.
-    /// @param SkinNr       The skin to render the model with, -1 for the default skin.
-    /// @param LodDist      The distance to the camera for reducing the level-of-detail (currently unused).
-    /// @param Super        Information about a parent or "super" model whose skeleton pose should be used when rendering this model.
-    void Draw(int SequenceNr, float FrameNr, int SkinNr, float LodDist, const SuperT* Super=NULL) const;
-
     /// Returns the proper material for the given mesh in the given skin.
     const MaterialT* GetMaterial(unsigned long MeshNr, int SkinNr) const;
+
+    /// Returns the proper render material for the given mesh in the given skin.
+    MatSys::RenderMaterialT* GetRenderMaterial(unsigned long MeshNr, int SkinNr) const;
 
     /// Determines if <tt>GF.Points[PointNr].MeshNr</tt> is a valid index into this model.
@@ -329 +298 @@
     friend class ModelEditor::CommandUpdateGuiFixtureT;
 
-    void RecomputeBindPoseBB();                                                             ///< Recomputes the bounding box for the model in bind pose (stored in m_BindPoseBB).
-    void InitMeshes();                                                                      ///< An auxiliary method for the constructors.
-    void UpdateCachedDrawData(int SequenceNr, float FrameNr, const SuperT* Super) const;    ///< A private auxiliary method.
-    MatSys::RenderMaterialT* GetRenderMaterial(unsigned long MeshNr, int SkinNr) const;     ///< Returns the proper render material for the given mesh in the given skin.
-
+    void RecomputeBindPoseBB();                     ///< Recomputes the bounding box for the model in bind pose (stored in m_BindPoseBB).
+    void InitMeshes();                              ///< An auxiliary method for the constructors.
 
     const std::string     m_FileName;               ///< File name of this model.   TODO: Remove!?!
     MaterialManagerImplT  m_MaterialMan;            ///< The material manager for the materials that are used with the meshes of this model.
     ArrayT<JointT>        m_Joints;                 ///< Array of joints of this model.
-    mutable ArrayT<MeshT> m_Meshes;                 ///< Array of (sub)meshes of this model.
+    ArrayT<MeshT>         m_Meshes;                 ///< Array of (sub)meshes of this model.
     ArrayT<SkinT>         m_Skins;                  ///< Array of additional/alternative skins for this model.
     ArrayT<GuiFixtureT>   m_GuiFixtures;            ///< Array of GUI fixtures in the model.
@@ -347 +313 @@
     const bool            m_UseGivenTangentSpace;   ///< Whether this model should use the fixed, given tangent space that was loaded from the model file, or it the tangent space is dynamically recomputed (useful for animated models).
  // const bool            m_CastShadows;            ///< Should this model cast shadows?
-    BoundingBox3fT        m_BindPoseBB;             ///< The bounding-box for the base pose of the model.
-
-
-    // Members for caching the data that is required for drawing the model at a given animation sequence and frame.
-    mutable int                   m_Draw_CachedDataAtSequNr;    ///< The animation sequence number at which we have computed the cache data.
-    mutable float                 m_Draw_CachedDataAtFrameNr;   ///< The animation frame    number at which we have computed the cache data.
-
-    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<MatSys::MeshT> m_Draw_Meshes;                ///< The draw meshes resulting from m_JointMatrices.
+    BoundingBox3fT        m_BindPoseBB;             ///< [REMOVE???] The bounding-box for the base pose of the model.
 };
 

cafu/trunk/Libs/SConscript

@@ -14 +14 @@
                     MapFile.cpp
                     Models/Loader.cpp Models/Loader_ase.cpp Models/Loader_cmdl.cpp Models/Loader_lwo.cpp Models/Loader_md5.cpp
-                    Models/Loader_mdl.cpp
+                    Models/Loader_mdl.cpp Models/AnimPose.cpp
                     Models/Model_cmdl.cpp Models/Model_dlod.cpp Models/Model_dummy.cpp Models/Model_mdl.cpp Models/Model_proxy.cpp
                     Network/Network.cpp ParticleEngine/ParticleEngineMS.cpp PlatformAux.cpp Terrain/Terrain.cpp