Changeset 401

Timestamp:

10/06/11 10:50:23 (8 months ago)

Author:

Carsten

Message:

Model support: Better member and variable names in AnimPoseT code.

Location:

cafu/trunk/Libs/Models

Files:

• AnimPose.cpp (modified) (31 diffs)
• AnimPose.hpp (modified) (2 diffs)

cafu/trunk/Libs/Models/AnimPose.cpp

@@ -32 +32 @@
     : m_Model(Model),
       m_SequNr(SequNr),
+      m_FrameNr(FrameNr),
       m_Super(NULL),
-      m_FrameNr(FrameNr),
       m_NeedsRecache(true),
       m_BoundingBox()
@@ -131 +131 @@
         case MatSys::RendererI::AMBIENT:
         {
-            for (unsigned long MeshNr=0; MeshNr<m_Meshes.Size(); MeshNr++)
+            for (unsigned long MeshNr=0; MeshNr<m_Draw_Meshes.Size(); MeshNr++)
             {
                 MatSys::Renderer->SetCurrentMaterial(m_Model.GetRenderMaterial(MeshNr, SkinNr));
@@ -190 +190 @@
         case MatSys::RendererI::LIGHTING:
         {
-            for (unsigned long MeshNr=0; MeshNr<m_Meshes.Size(); MeshNr++)
+            for (unsigned long MeshNr=0; MeshNr<m_Draw_Meshes.Size(); MeshNr++)
             {
                 MatSys::Renderer->SetCurrentMaterial(m_Model.GetRenderMaterial(MeshNr, SkinNr));
@@ -200 +200 @@
         case MatSys::RendererI::STENCILSHADOW:
         {
-            const Vector3fT LightPos(MatSys::Renderer->GetCurrentLightSourcePosition());
-
-            for (unsigned long MeshNr=0; MeshNr<m_Meshes.Size(); MeshNr++)
-            {
-                const CafuModelT::MeshT& Mesh    =m_Model.GetMeshes()[MeshNr];
-                const AnimPoseT::MeshT&  PoseMesh=m_Meshes[MeshNr];
-                const MaterialT*         MeshMat =m_Model.GetMaterial(MeshNr, SkinNr);
+            typedef CafuModelT::MeshT MeshT;
+
+            const ArrayT<MeshT>& Meshes=m_Model.GetMeshes();
+            const Vector3fT      LightPos(MatSys::Renderer->GetCurrentLightSourcePosition());
+
+            for (unsigned long MeshNr=0; MeshNr<Meshes.Size(); MeshNr++)
+            {
+                const MeshT&     Mesh    =Meshes[MeshNr];
+                const MeshInfoT& MeshInfo=m_MeshInfos[MeshNr];
+                const MaterialT* MeshMat =m_Model.GetMaterial(MeshNr, SkinNr);
 
                 if (MeshMat==NULL || MeshMat->NoShadows) continue;
@@ -216 +219 @@
                 for (unsigned long TriNr=0; TriNr<Mesh.Triangles.Size(); TriNr++)
                 {
-                    const CafuModelT::MeshT::TriangleT& Tri    =Mesh.Triangles[TriNr];
-                    const AnimPoseT::MeshT::TriangleT&  PoseTri=PoseMesh.Triangles[TriNr];
-
-                    const float Dot=(LightPos-PoseMesh.Vertices[Tri.VertexIdx[0]].Draw_Pos).dot(PoseTri.Draw_Normal);
+                    const MeshT::TriangleT&     Tri    =Mesh.Triangles[TriNr];
+                    const MeshInfoT::TriangleT& TriInfo=MeshInfo.Triangles[TriNr];
+
+                    const float Dot=(LightPos-MeshInfo.Vertices[Tri.VertexIdx[0]].Pos).dot(TriInfo.Normal);
 
                     TriangleIsFrontFacing[TriNr]=Dot>0;
@@ -234 +237 @@
 
                     // This triangle is front-facing wrt. the light source.
-                    const CafuModelT::MeshT::TriangleT& Tri=Mesh.Triangles[TriNr];
+                    const MeshT::TriangleT& Tri=Mesh.Triangles[TriNr];
 
                     for (unsigned long EdgeNr=0; EdgeNr<3; EdgeNr++)
@@ -246 +249 @@
                             const unsigned long v1=EdgeNr;
                             const unsigned long v2=(EdgeNr+1) % 3;
-                            const Vector3fT     LA=PoseMesh.Vertices[Tri.VertexIdx[v1]].Draw_Pos-LightPos;
-                            const Vector3fT     LB=PoseMesh.Vertices[Tri.VertexIdx[v2]].Draw_Pos-LightPos;
+                            const Vector3fT     LA=MeshInfo.Vertices[Tri.VertexIdx[v1]].Pos-LightPos;
+                            const Vector3fT     LB=MeshInfo.Vertices[Tri.VertexIdx[v2]].Pos-LightPos;
 
                             MeshSilhouette.Vertices.PushBackEmpty(4);
@@ -253 +256 @@
                             const unsigned long MeshSize=MeshSilhouette.Vertices.Size();
 
-                            MeshSilhouette.Vertices[MeshSize-4].SetOrigin(PoseMesh.Vertices[Tri.VertexIdx[v2]].Draw_Pos);
-                            MeshSilhouette.Vertices[MeshSize-3].SetOrigin(PoseMesh.Vertices[Tri.VertexIdx[v1]].Draw_Pos);
+                            MeshSilhouette.Vertices[MeshSize-4].SetOrigin(MeshInfo.Vertices[Tri.VertexIdx[v2]].Pos);
+                            MeshSilhouette.Vertices[MeshSize-3].SetOrigin(MeshInfo.Vertices[Tri.VertexIdx[v1]].Pos);
                             MeshSilhouette.Vertices[MeshSize-2].SetOrigin(LA, 0.0);
                             MeshSilhouette.Vertices[MeshSize-1].SetOrigin(LB, 0.0);
@@ -279 +282 @@
 
                     // Render the occluder (front-facing wrt. the light source).
-                    const Vector3fT& A=PoseMesh.Vertices[Tri.VertexIdx[0]].Draw_Pos;
-                    const Vector3fT& B=PoseMesh.Vertices[Tri.VertexIdx[1]].Draw_Pos;
-                    const Vector3fT& C=PoseMesh.Vertices[Tri.VertexIdx[2]].Draw_Pos;
+                    const Vector3fT& A=MeshInfo.Vertices[Tri.VertexIdx[0]].Pos;
+                    const Vector3fT& B=MeshInfo.Vertices[Tri.VertexIdx[1]].Pos;
+                    const Vector3fT& C=MeshInfo.Vertices[Tri.VertexIdx[2]].Pos;
 
                     MeshCaps.Vertices[MeshSize-6].SetOrigin(A);
@@ -308 +311 @@
 bool AnimPoseT::TraceRay(int SkinNr, const Vector3fT& RayOrigin, const Vector3fT& RayDir, ModelT::TraceResultT& Result) const
 {
+    Recache();
+
+    // If we miss the bounding-box, then we miss all the triangles as well.
     float Fraction=0.0f;
-
-    Recache();
-
-    // If we miss the bounding-box, then we miss all the triangles as well.
     if (!GetBB().TraceRay(RayOrigin, RayDir, Fraction)) return false;
 
-    for (unsigned long MeshNr=0; MeshNr<m_Meshes.Size(); MeshNr++)
-    {
-        const CafuModelT::MeshT& Mesh    =m_Model.GetMeshes()[MeshNr];
-        const MeshT&             DrawMesh=m_Meshes[MeshNr];
-        const MaterialT*         MeshMat =m_Model.GetMaterial(MeshNr, SkinNr);
+    typedef CafuModelT::MeshT MeshT;
+
+    const ArrayT<MeshT>& Meshes=m_Model.GetMeshes();
+
+    for (unsigned long MeshNr=0; MeshNr<Meshes.Size(); MeshNr++)
+    {
+        const MeshT&     Mesh    =Meshes[MeshNr];
+        const MeshInfoT& MeshInfo=m_MeshInfos[MeshNr];
+        const MaterialT* MeshMat =m_Model.GetMaterial(MeshNr, SkinNr);
 
         // If the ClipFlags don't match the ClipMask, this polygon doesn't interfere with the trace.
@@ -330 +336 @@
             // see there for details and additional information.
             using namespace cf::math;
-            const CafuModelT::MeshT::TriangleT& Tri    =Mesh.Triangles[TriNr];
-            const AnimPoseT::MeshT::TriangleT&  DrawTri=DrawMesh.Triangles[TriNr];
-
-            const Vector3fT& A=DrawMesh.Vertices[Tri.VertexIdx[0]].Draw_Pos;
-            const Vector3fT& B=DrawMesh.Vertices[Tri.VertexIdx[1]].Draw_Pos;
-            const Vector3fT& C=DrawMesh.Vertices[Tri.VertexIdx[2]].Draw_Pos;
+            const MeshT::TriangleT&     Tri    =Mesh.Triangles[TriNr];
+            const MeshInfoT::TriangleT& TriInfo=MeshInfo.Triangles[TriNr];
+
+            const Vector3fT& A=MeshInfo.Vertices[Tri.VertexIdx[0]].Pos;
+            const Vector3fT& B=MeshInfo.Vertices[Tri.VertexIdx[1]].Pos;
+            const Vector3fT& C=MeshInfo.Vertices[Tri.VertexIdx[2]].Pos;
 
             const PlueckerfT R=PlueckerfT::CreateFromRay(RayOrigin, RayDir);
@@ -361 +367 @@
 
             // The "aperture" test passed, now compute the fraction at which RayDir intersects the triangle plane.
-            const float Nenner=dot(DrawTri.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(DrawTri.Draw_Normal, RayOrigin-A); // The distance of RayOrigin to the triangle plane.
+            const float Nenner=dot(TriInfo.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(TriInfo.Normal, RayOrigin-A);  // The distance of RayOrigin to the triangle plane.
             const float F   =-(Dist-0.03125f)/Nenner;
 
@@ -374 +380 @@
             // Hit the triangle!
             Result.Fraction=F;
-            Result.Normal  =(Nenner<0) ? DrawTri.Draw_Normal : -DrawTri.Draw_Normal;    // Handle two-sided materials properly.
+            Result.Normal  =(Nenner<0) ? TriInfo.Normal : -TriInfo.Normal;  // Handle two-sided materials properly.
             Result.Material=MeshMat;
             Result.MeshNr  =MeshNr;
@@ -396 +402 @@
     {
         const unsigned int VertexNr=m_Model.GetMeshes()[MeshNr].Triangles[TriNr].VertexIdx[i];
-        const Vector3fT&   DrawPos =m_Meshes[MeshNr].Vertices[VertexNr].Draw_Pos;
+        const Vector3fT&   DrawPos =m_MeshInfos[MeshNr].Vertices[VertexNr].Pos;
         const float        Dist    =length(DrawPos-P);
 
@@ -414 +420 @@
     Recache();
 
-    return m_Meshes[MeshNr].Vertices[VertexNr].Draw_Pos;
+    return m_MeshInfos[MeshNr].Vertices[VertexNr].Pos;
 }
 
@@ -464 +470 @@
     }
 
-    if (m_Meshes.Size()!=m_Model.GetMeshes().Size())
-    {
-        m_Meshes.Overwrite();
-        m_Meshes.PushBackEmptyExact(m_Model.GetMeshes().Size());
+    if (m_MeshInfos.Size()!=m_Model.GetMeshes().Size())
+    {
+        m_MeshInfos.Overwrite();
+        m_MeshInfos.PushBackEmptyExact(m_Model.GetMeshes().Size());
     }
 
@@ -481 +487 @@
         const CafuModelT::MeshT& Mesh=m_Model.GetMeshes()[MeshNr];
 
-        if (m_Meshes[MeshNr].Vertices.Size()!=Mesh.Vertices.Size())
-        {
-            m_Meshes[MeshNr].Vertices.Overwrite();
-            m_Meshes[MeshNr].Vertices.PushBackEmptyExact(Mesh.Vertices.Size());
-        }
-
-        if (m_Meshes[MeshNr].Triangles.Size()!=Mesh.Triangles.Size())
-        {
-            m_Meshes[MeshNr].Triangles.Overwrite();
-            m_Meshes[MeshNr].Triangles.PushBackEmptyExact(Mesh.Triangles.Size());
+        if (m_MeshInfos[MeshNr].Vertices.Size()!=Mesh.Vertices.Size())
+        {
+            m_MeshInfos[MeshNr].Vertices.Overwrite();
+            m_MeshInfos[MeshNr].Vertices.PushBackEmptyExact(Mesh.Vertices.Size());
+        }
+
+        if (m_MeshInfos[MeshNr].Triangles.Size()!=Mesh.Triangles.Size())
+        {
+            m_MeshInfos[MeshNr].Triangles.Overwrite();
+            m_MeshInfos[MeshNr].Triangles.PushBackEmptyExact(Mesh.Triangles.Size());
         }
 
@@ -519 +525 @@
 void AnimPoseT::UpdateData() const
 {
-    const int     SequenceNr=m_SequNr;
-    const float   FrameNr   =m_FrameNr;
-    const SuperT* Super     =m_Super;
-    const bool m_UseGivenTangentSpace=m_Model.GetUseGivenTS();
-
-    const ArrayT<CafuModelT::JointT>& m_Joints=m_Model.GetJoints();
-    const ArrayT<CafuModelT::AnimT>&  m_Anims =m_Model.GetAnims();
     typedef CafuModelT::JointT JointT;
-    typedef CafuModelT::AnimT AnimT;
+    typedef CafuModelT::MeshT  MeshT;
+    typedef CafuModelT::AnimT  AnimT;
+
+    const ArrayT<JointT>& Joints=m_Model.GetJoints();
+    const ArrayT<MeshT>&  Meshes=m_Model.GetMeshes();
+    const ArrayT<AnimT>&  Anims =m_Model.GetAnims();
 
 
     // **************************************************************************************************************
-    //  Obtain a joints (bone) hierarchy for the desired frame FrameNr of the desired animation sequence SequenceNr.
+    //  Obtain a joints (bone) hierarchy for the desired frame m_FrameNr of the desired animation sequence m_SequNr.
     //  The result will be a transformation matrix for each joint (bone).
     // **************************************************************************************************************
 
-    if (SequenceNr==-1)
+    if (m_SequNr==-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);
+        for (unsigned long JointNr=0; JointNr<Joints.Size(); JointNr++)
+        {
+            if (m_Super && m_Super->HasMatrix(JointNr))
+            {
+                m_JointMatrices[JointNr]=m_Super->GetMatrix(JointNr);
                 continue;
             }
 
-            const JointT& J=m_Joints[JointNr];
+            const JointT& J=Joints[JointNr];
             const MatrixT RelMatrix(J.Pos, cf::math::QuaternionfT::FromXYZ(J.Qtr), J.Scale);
 
@@ -554 +558 @@
     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);
+        // m_SequNr is a valid index into Anims, so use that.
+        const AnimT& Anim=Anims[m_SequNr];
+        const int    Frame_0=int(m_FrameNr);                                        // If m_FrameNr == 17.83, then Frame_0 == 17
+        const float  Frame_f=m_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<Joints.Size(); JointNr++)
+        {
+            if (m_Super && m_Super->HasMatrix(JointNr))
+            {
+                m_JointMatrices[JointNr]=m_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 };
+
+            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.
@@ -593 +598 @@
             // 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];
+            const JointT& J=Joints[JointNr];
 
             m_JointMatrices[JointNr]=(J.Parent==-1) ? RelMatrix : m_JointMatrices[J.Parent]*RelMatrix;
@@ -605 +610 @@
     // *******************************************************************************************************************
 
-    for (unsigned long MeshNr=0; MeshNr<m_Meshes.Size(); MeshNr++)
-    {
-        const CafuModelT::MeshT& Mesh=m_Model.GetMeshes()[MeshNr];
-        MeshT& DrawMesh=m_Meshes[MeshNr];
+    for (unsigned long MeshNr=0; MeshNr<Meshes.Size(); MeshNr++)
+    {
+        const MeshT& Mesh    =Meshes[MeshNr];
+        MeshInfoT&   MeshInfo=m_MeshInfos[MeshNr];
 
         for (unsigned long VertexNr=0; VertexNr<Mesh.Vertices.Size(); VertexNr++)
         {
-            const CafuModelT::MeshT::VertexT& Vertex=Mesh.Vertices[VertexNr];
-            MeshT::VertexT& DrawVertex=DrawMesh.Vertices[VertexNr];
+            const MeshT::VertexT& Vertex    =Mesh.Vertices[VertexNr];
+            MeshInfoT::VertexT&   VertexInfo=MeshInfo.Vertices[VertexNr];
 
             if (Vertex.GeoDups.Size()>0 && Vertex.GeoDups[0]<VertexNr)
@@ -619 +624 @@
                 // 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.
-                DrawVertex.Draw_Pos=DrawMesh.Vertices[Vertex.GeoDups[0]].Draw_Pos;
+                VertexInfo.Pos=MeshInfo.Vertices[Vertex.GeoDups[0]].Pos;
                 continue;
             }
@@ -625 +630 @@
             if (Vertex.NumWeights==1)
             {
-                const CafuModelT::MeshT::WeightT& Weight=Mesh.Weights[Vertex.FirstWeightIdx];
-
-                DrawVertex.Draw_Pos=m_JointMatrices[Weight.JointIdx].Mul_xyz1(Weight.Pos);
+                const MeshT::WeightT& Weight=Mesh.Weights[Vertex.FirstWeightIdx];
+
+                VertexInfo.Pos=m_JointMatrices[Weight.JointIdx].Mul_xyz1(Weight.Pos);
             }
             else
             {
-                DrawVertex.Draw_Pos=Vector3fT(0.0f, 0.0f, 0.0f);
+                VertexInfo.Pos=Vector3fT(0.0f, 0.0f, 0.0f);
 
                 for (unsigned int WeightNr=0; WeightNr<Vertex.NumWeights; WeightNr++)
                 {
-                    const CafuModelT::MeshT::WeightT& Weight=Mesh.Weights[Vertex.FirstWeightIdx+WeightNr];
-
-                    DrawVertex.Draw_Pos+=m_JointMatrices[Weight.JointIdx].Mul_xyz1(Weight.Pos) * Weight.Weight;
+                    const MeshT::WeightT& Weight=Mesh.Weights[Vertex.FirstWeightIdx+WeightNr];
+
+                    VertexInfo.Pos+=m_JointMatrices[Weight.JointIdx].Mul_xyz1(Weight.Pos) * Weight.Weight;
                 }
             }
@@ -651 +656 @@
     // *******************************************************************************************
 
-    if (m_UseGivenTangentSpace)
-    {
-        assert(m_Anims.Size()==0);  // It doesn't make sense to have statically given tangent-space axes with *animated* geometry...
+    if (m_Model.GetUseGivenTS())
+    {
+        assert(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);
+    for (unsigned long MeshNr=0; MeshNr<Meshes.Size(); MeshNr++)
+    {
+        MeshInfoT& MeshInfo=m_MeshInfos[MeshNr];
+
+        for (unsigned long VertexNr=0; VertexNr<MeshInfo.Vertices.Size(); VertexNr++)
+        {
+            MeshInfoT::VertexT& VertexInfo=MeshInfo.Vertices[VertexNr];
+
+            VertexInfo.Normal  =Vector3fT(0, 0, 0);
+            VertexInfo.Tangent =Vector3fT(0, 0, 0);
+            VertexInfo.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++)
-    {
-        const CafuModelT::MeshT& Mesh=m_Model.GetMeshes()[MeshNr];
-        MeshT& DrawMesh=m_Meshes[MeshNr];
+    for (unsigned long MeshNr=0; MeshNr<Meshes.Size(); MeshNr++)
+    {
+        const MeshT& Mesh    =Meshes[MeshNr];
+        MeshInfoT&   MeshInfo=m_MeshInfos[MeshNr];
 
         for (unsigned long TriangleNr=0; TriangleNr<Mesh.Triangles.Size(); TriangleNr++)
         {
-            const CafuModelT::MeshT::TriangleT& Tri=Mesh.Triangles[TriangleNr];
-            const CafuModelT::MeshT::VertexT&   V_0=Mesh.Vertices[Tri.VertexIdx[0]];
-            const CafuModelT::MeshT::VertexT&   V_1=Mesh.Vertices[Tri.VertexIdx[1]];
-            const CafuModelT::MeshT::VertexT&   V_2=Mesh.Vertices[Tri.VertexIdx[2]];
-
-            MeshT::TriangleT& DrawTri=DrawMesh.Triangles[TriangleNr];
-            MeshT::VertexT&   DrawV_0=DrawMesh.Vertices[Tri.VertexIdx[0]];
-            MeshT::VertexT&   DrawV_1=DrawMesh.Vertices[Tri.VertexIdx[1]];
-            MeshT::VertexT&   DrawV_2=DrawMesh.Vertices[Tri.VertexIdx[2]];
-
-            const Vector3fT Edge01=DrawV_1.Draw_Pos-DrawV_0.Draw_Pos;
-            const Vector3fT Edge02=DrawV_2.Draw_Pos-DrawV_0.Draw_Pos;
+            const 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]];
+
+            MeshInfoT::TriangleT&   TriInfo=MeshInfo.Triangles[TriangleNr];
+            MeshInfoT::VertexT&     V_0Info=MeshInfo.Vertices[Tri.VertexIdx[0]];
+            MeshInfoT::VertexT&     V_1Info=MeshInfo.Vertices[Tri.VertexIdx[1]];
+            MeshInfoT::VertexT&     V_2Info=MeshInfo.Vertices[Tri.VertexIdx[2]];
+
+            const Vector3fT         Edge01=V_1Info.Pos-V_0Info.Pos;
+            const Vector3fT         Edge02=V_2Info.Pos-V_0Info.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.
-            DrawTri.Draw_Normal=myNormalize(Edge02.cross(Edge01));
+            TriInfo.Normal=myNormalize(Edge02.cross(Edge01));
 
             // Understanding what's going on here is easy. The key statement is
@@ -705 +710 @@
             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));
+            const Vector3fT TriInfo_Draw_Tangent =myNormalize(Edge02.GetScaled(-uv01.y*f) + Edge01.GetScaled(uv02.y*f));
+            const Vector3fT TriInfo_Draw_BiNormal=myNormalize(Edge02.GetScaled( uv01.x*f) - Edge01.GetScaled(uv02.x*f));
 
 
@@ -714 +719 @@
 
             const float c0=dot(myNormalize(Edge01), myNormalize(Edge02));
-            const float c1=dot(myNormalize(Edge01), myNormalize(DrawV_1.Draw_Pos-DrawV_2.Draw_Pos));
+            const float c1=dot(myNormalize(Edge01), myNormalize(V_1Info.Pos-V_2Info.Pos));
 
             const float w0=(c0>=1.0f) ? 0.0f : ( (c0<=-1.0f) ? Pi : acos(c0) );
@@ -726 +731 @@
             for (int i=0; i<3; i++)
             {
-                const CafuModelT::MeshT::VertexT& Vertex=Mesh.Vertices[Tri.VertexIdx[i]];
-                MeshT::VertexT& DrawVertex=DrawMesh.Vertices[Tri.VertexIdx[i]];
+                const MeshT::VertexT& Vertex    =Mesh.Vertices[Tri.VertexIdx[i]];
+                MeshInfoT::VertexT&   VertexInfo=MeshInfo.Vertices[Tri.VertexIdx[i]];
 
                 assert(Tri.Polarity==Vertex.Polarity);
 
-                DrawVertex.Draw_Normal  +=DrawTri.Draw_Normal*TriWeight[i];
-                DrawVertex.Draw_Tangent +=Tri_Draw_Tangent*TriWeight[i];
-                DrawVertex.Draw_BiNormal+=Tri_Draw_BiNormal*TriWeight[i];
+                VertexInfo.Normal  +=TriInfo.Normal*TriWeight[i];
+                VertexInfo.Tangent +=TriInfo_Draw_Tangent*TriWeight[i];
+                VertexInfo.BiNormal+=TriInfo_Draw_BiNormal*TriWeight[i];
 
                 for (unsigned long DupNr=0; DupNr<Vertex.GeoDups.Size(); DupNr++)
                 {
-                    const CafuModelT::MeshT::VertexT& DupVertex=Mesh.Vertices[Vertex.GeoDups[DupNr]];
-                    MeshT::VertexT&                   DrawDupVertex=DrawMesh.Vertices[Vertex.GeoDups[DupNr]];
-
-                    DrawDupVertex.Draw_Normal  +=DrawTri.Draw_Normal*TriWeight[i];
-                    DrawDupVertex.Draw_Tangent +=Tri_Draw_Tangent*(Tri.Polarity==DupVertex.Polarity ? TriWeight[i] : -TriWeight[i]);
-                    DrawDupVertex.Draw_BiNormal+=Tri_Draw_BiNormal*TriWeight[i];
+                    const MeshT::VertexT& DupVertex    =Mesh.Vertices[Vertex.GeoDups[DupNr]];
+                    MeshInfoT::VertexT&   DupVertexInfo=MeshInfo.Vertices[Vertex.GeoDups[DupNr]];
+
+                    DupVertexInfo.Normal  +=TriInfo.Normal*TriWeight[i];
+                    DupVertexInfo.Tangent +=TriInfo_Draw_Tangent*(Tri.Polarity==DupVertex.Polarity ? TriWeight[i] : -TriWeight[i]);
+                    DupVertexInfo.BiNormal+=TriInfo_Draw_BiNormal*TriWeight[i];
                 }
             }
@@ -749 +754 @@
 
     // 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];
+    for (unsigned long MeshNr=0; MeshNr<Meshes.Size(); MeshNr++)
+    {
+        MeshInfoT& MeshInfo=m_MeshInfos[MeshNr];
+
+        for (unsigned long VertexNr=0; VertexNr<MeshInfo.Vertices.Size(); VertexNr++)
+        {
+            MeshInfoT::VertexT& VertexInfo=MeshInfo.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);
+            VertexInfo.Normal  =myNormalize(VertexInfo.Normal  );
+            VertexInfo.Tangent =myNormalize(VertexInfo.Tangent );
+            VertexInfo.BiNormal=myNormalize(VertexInfo.BiNormal);
         }
     }
@@ -772 +777 @@
     // ***************************************************************************************************************
 
-    for (unsigned long MeshNr=0; MeshNr<m_Meshes.Size(); MeshNr++)
-    {
-        const CafuModelT::MeshT& Mesh    =m_Model.GetMeshes()[MeshNr];
-        const AnimPoseT::MeshT&  DrawMesh=m_Meshes[MeshNr];
+    for (unsigned long MeshNr=0; MeshNr<Meshes.Size(); MeshNr++)
+    {
+        const MeshT&     Mesh    =Meshes[MeshNr];
+        const MeshInfoT& MeshInfo=m_MeshInfos[MeshNr];
 
         for (unsigned long TriNr=0; TriNr<Mesh.Triangles.Size(); TriNr++)
@@ -781 +786 @@
             for (unsigned long i=0; i<3; i++)
             {
-                unsigned long VertexIdx=Mesh.Triangles[TriNr].VertexIdx[i];
-                const MeshT::VertexT& DrawVertex=DrawMesh.Vertices[VertexIdx];
-
-                m_Draw_Meshes[MeshNr].Vertices[TriNr*3+i].SetOrigin(DrawVertex.Draw_Pos.x, DrawVertex.Draw_Pos.y, DrawVertex.Draw_Pos.z);
+                const unsigned long       VertexIdx =Mesh.Triangles[TriNr].VertexIdx[i];
+                const MeshInfoT::VertexT& VertexInfo=MeshInfo.Vertices[VertexIdx];
+
+                m_Draw_Meshes[MeshNr].Vertices[TriNr*3+i].SetOrigin(VertexInfo.Pos.x, VertexInfo.Pos.y, VertexInfo.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  (DrawVertex.Draw_Normal.x,   DrawVertex.Draw_Normal.y,   DrawVertex.Draw_Normal.z  );
-                m_Draw_Meshes[MeshNr].Vertices[TriNr*3+i].SetTangent (DrawVertex.Draw_Tangent.x,  DrawVertex.Draw_Tangent.y,  DrawVertex.Draw_Tangent.z );
-                m_Draw_Meshes[MeshNr].Vertices[TriNr*3+i].SetBiNormal(DrawVertex.Draw_BiNormal.x, DrawVertex.Draw_BiNormal.y, DrawVertex.Draw_BiNormal.z);
+                m_Draw_Meshes[MeshNr].Vertices[TriNr*3+i].SetNormal  (VertexInfo.Normal.x,   VertexInfo.Normal.y,   VertexInfo.Normal.z  );
+                m_Draw_Meshes[MeshNr].Vertices[TriNr*3+i].SetTangent (VertexInfo.Tangent.x,  VertexInfo.Tangent.y,  VertexInfo.Tangent.z );
+                m_Draw_Meshes[MeshNr].Vertices[TriNr*3+i].SetBiNormal(VertexInfo.BiNormal.x, VertexInfo.BiNormal.y, VertexInfo.BiNormal.z);
             }
         }
@@ -800 +805 @@
     m_BoundingBox=BoundingBox3fT();
 
-    for (unsigned long MeshNr=0; MeshNr<m_Meshes.Size(); MeshNr++)
-    {
-        const MeshT& DrawMesh=m_Meshes[MeshNr];
-
-        for (unsigned long VertexNr=0; VertexNr<DrawMesh.Vertices.Size(); VertexNr++)
-            m_BoundingBox+=DrawMesh.Vertices[VertexNr].Draw_Pos;
+    for (unsigned long MeshNr=0; MeshNr<Meshes.Size(); MeshNr++)
+    {
+        const MeshInfoT& MeshInfo=m_MeshInfos[MeshNr];
+
+        for (unsigned long VertexNr=0; VertexNr<MeshInfo.Vertices.Size(); VertexNr++)
+            m_BoundingBox+=MeshInfo.Vertices[VertexNr].Pos;
     }
 }

cafu/trunk/Libs/Models/AnimPose.hpp

@@ -133 +133 @@
 
     /// The instances of this struct parallel and augment the \c CafuModelT::MeshT instances in the related \c CafuModelT.
-    struct MeshT
+    struct MeshInfoT
     {
         struct TriangleT
         {
-            Vector3fT Draw_Normal;      ///< The normal vector of this triangle, required for the shadow-silhouette determination.
+            Vector3fT Normal;       ///< The normal vector of this triangle, required for the shadow-silhouette determination.
         };
 
         struct VertexT
         {
-            Vector3fT Draw_Pos;         ///< The spatial position of this vertex.
-            Vector3fT Draw_Normal;      ///< The tangent-space normal   vector of this vertex.
-            Vector3fT Draw_Tangent;     ///< The tangent-space tangent  vector of this vertex.
-            Vector3fT Draw_BiNormal;    ///< The tangent-space binormal vector of this vertex.
+            Vector3fT Pos;          ///< The spatial position of this vertex.
+            Vector3fT Normal;       ///< The tangent-space normal   vector of this vertex.
+            Vector3fT Tangent;      ///< The tangent-space tangent  vector of this vertex.
+            Vector3fT BiNormal;     ///< The tangent-space binormal vector of this vertex.
         };
 
@@ -158 +158 @@
     void Recache() const;
 
-    const CafuModelT&     m_Model;
-    int                   m_SequNr;             ///< The animation sequence number at which we have computed the cache data.
-    float                 m_FrameNr;            ///< The animation frame    number at which we have computed the cache data.
-    const SuperT*         m_Super;
- // 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.
+    int                           m_SequNr;             ///< The animation sequence number at which we have computed the cache data.
+    float                         m_FrameNr;            ///< The animation frame    number at which we have computed the cache data.
+    const SuperT*                 m_Super;
+ // 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.)
 
     mutable bool                  m_NeedsRecache;       ///< wird auf 'true' gesetzt wann immer SetSequ(), SetFrameNr() oder AdvanceAll() o.ä. aufgerufen wird, übernimmt m_Draw_CachedDataAt*Nr Funktionalität.
     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<MeshT>         m_Meshes;
-    mutable ArrayT<MatSys::MeshT> m_Draw_Meshes;        ///< The draw meshes resulting from m_JointMatrices.
-    mutable BoundingBox3fT        m_BoundingBox;
+    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.
 };