Changeset 382

Timestamp:

09/17/11 11:38:06 (8 months ago)

Author:

Carsten

Message:

Models: Added support for skins (alternative/additional sets of materials for the meshes of a model).

References #86.

Location:

cafu/trunk

Files:

• CaWE/ModelEditor/SceneView3D.cpp (modified) (3 diffs)
• Libs/Models/Loader.hpp (modified) (1 diff)
• Libs/Models/Loader_ase.hpp (modified) (1 diff)
• Libs/Models/Loader_assimp.hpp (modified) (1 diff)
• Libs/Models/Loader_cmdl.cpp (modified) (1 diff)
• Libs/Models/Loader_cmdl.hpp (modified) (1 diff)
• Libs/Models/Loader_fbx.cpp (modified) (1 diff)
• Libs/Models/Loader_fbx.hpp (modified) (1 diff)
• Libs/Models/Loader_lwo.hpp (modified) (1 diff)
• Libs/Models/Loader_md5.hpp (modified) (1 diff)
• Libs/Models/Loader_mdl.cpp (modified) (4 diffs)
• Libs/Models/Loader_mdl.hpp (modified) (3 diffs)
• Libs/Models/Model.hpp (modified) (3 diffs)
• Libs/Models/Model_cmdl.cpp (modified) (15 diffs)
• Libs/Models/Model_cmdl.hpp (modified) (6 diffs)
• Libs/Models/Model_dlod.cpp (modified) (1 diff)
• Libs/Models/Model_dlod.hpp (modified) (1 diff)
• Libs/Models/Model_dummy.cpp (modified) (1 diff)
• Libs/Models/Model_dummy.hpp (modified) (1 diff)
• Libs/Models/Model_mdl.cpp (modified) (1 diff)
• Libs/Models/Model_mdl.hpp (modified) (1 diff)
• Libs/Models/Model_proxy.cpp (modified) (1 diff)
• Libs/Models/Model_proxy.hpp (modified) (1 diff)

cafu/trunk/CaWE/ModelEditor/SceneView3D.cpp

@@ -104 +104 @@
     ModelT::TraceResultT Result;
 
-    if (m_Parent->GetModelDoc()->GetModel()->TraceRay(AnimSel.Size()==0 ? -1 : AnimSel[0], Anim.FrameNr, RayOrigin, RayDir, Result) && Result.Fraction<BestFraction)
+    if (m_Parent->GetModelDoc()->GetModel()->TraceRay(AnimSel.Size()==0 ? -1 : AnimSel[0], Anim.FrameNr, -1 /*SkinNr*/, RayOrigin, RayDir, Result) && Result.Fraction<BestFraction)
     {
         BestFraction=Result.Fraction;
@@ -388 +388 @@
     if (ScenePropGrid->m_Model_ShowMesh)
     {
-        Model->Draw(SequNr, Anim.FrameNr, 0.0f /*LodDist*/, (CafuModelT::SuperT*)NULL);
+        Model->Draw(SequNr, Anim.FrameNr, -1 /*SkinNr*/, 0.0f /*LodDist*/, (CafuModelT::SuperT*)NULL);
 
         for (unsigned long SmNr=0; SmNr<ModelDoc->GetSubmodels().Size(); SmNr++)
@@ -397 +397 @@
                 SM->GetJointsMap());
 
-            SM->GetSubmodel()->Draw(0, 0.0f, 0.0f /*LodDist*/, &Super);
+            SM->GetSubmodel()->Draw(0, 0.0f, -1 /*SkinNr*/, 0.0f /*LodDist*/, &Super);
         }
     }

cafu/trunk/Libs/Models/Loader.hpp

@@ -58 +58 @@
     /// Actually loads the file data into the appropriate parts of the Cafu model.
     virtual void Load(ArrayT<CafuModelT::JointT>& Joints, ArrayT<CafuModelT::MeshT>& Meshes, ArrayT<CafuModelT::AnimT>& Anims, MaterialManagerImplT& MaterialMan)=0;
+
+    /// Loads the skins of the Cafu model.
+    virtual void Load(ArrayT<CafuModelT::SkinT>& Skins, const MaterialManagerImplT& MaterialMan)=0;
 
     /// Loads the GUI fixtures of the Cafu model.

cafu/trunk/Libs/Models/Loader_ase.hpp

@@ -41 +41 @@
     bool UseGivenTS() const { return true; }
     void Load(ArrayT<CafuModelT::JointT>& Joints, ArrayT<CafuModelT::MeshT>& Meshes, ArrayT<CafuModelT::AnimT>& Anims, MaterialManagerImplT& MaterialMan);
+    void Load(ArrayT<CafuModelT::SkinT>& Skins, const MaterialManagerImplT& MaterialMan) { }
     void Load(ArrayT<CafuModelT::GuiFixtureT>& GuiFixtures, ArrayT<CafuModelT::GuiLocT>& GuiLocs);
 

cafu/trunk/Libs/Models/Loader_assimp.hpp

@@ -45 +45 @@
     bool UseGivenTS() const;
     void Load(ArrayT<CafuModelT::JointT>& Joints, ArrayT<CafuModelT::MeshT>& Meshes, ArrayT<CafuModelT::AnimT>& Anims, MaterialManagerImplT& MaterialMan);
+    void Load(ArrayT<CafuModelT::SkinT>& Skins, const MaterialManagerImplT& MaterialMan) { }
     void Load(ArrayT<CafuModelT::GuiFixtureT>& GuiFixtures, ArrayT<CafuModelT::GuiLocT>& GuiLocs) { }
 

cafu/trunk/Libs/Models/Loader_cmdl.cpp

@@ -393 +393 @@
 
 
+void LoaderCafuT::Load(ArrayT<CafuModelT::SkinT>& Skins, const MaterialManagerImplT& MaterialMan)
+{
+    // Read the skins.
+    lua_getglobal(m_LuaState, "Skins");
+    {
+        Skins.Overwrite();
+        Skins.PushBackEmptyExact(lua_objlen_ul(m_LuaState, -1));
+
+        for (unsigned long SkinNr=0; SkinNr<Skins.Size(); SkinNr++)
+        {
+            CafuModelT::SkinT& Skin=Skins[SkinNr];
+
+            lua_rawgeti(m_LuaState, -1, SkinNr+1);
+            {
+                lua_getfield(m_LuaState, -1, "name");
+                {
+                    const char* Name=lua_tostring(m_LuaState, -1);
+                    Skin.Name=Name ? Name : "Skin";
+                }
+                lua_pop(m_LuaState, 1);
+
+                lua_getfield(m_LuaState, -1, "materials");
+                {
+                    const unsigned long NumMats=lua_objlen_ul(m_LuaState, -1);
+
+                    Skin.Materials.PushBackEmptyExact(NumMats);
+                    Skin.RenderMaterials.PushBackEmptyExact(NumMats);
+
+                    for (unsigned int c=0; c<NumMats; c++)
+                    {
+                        lua_rawgeti(m_LuaState, -1, c+1);
+                        {
+                            const char*       s=lua_tostring(m_LuaState, -1);
+                            const std::string MatName=s ? s : "";
+
+                            Skin.Materials[c]      =(s!="") ? MaterialMan.GetMaterial(MatName) : NULL;
+                            Skin.RenderMaterials[c]=NULL;
+                        }
+                        lua_pop(m_LuaState, 1);
+                    }
+                }
+                lua_pop(m_LuaState, 1);
+            }
+            lua_pop(m_LuaState, 1);
+        }
+    }
+    lua_pop(m_LuaState, 1);
+}
+
+
 void LoaderCafuT::Load(ArrayT<CafuModelT::GuiFixtureT>& GuiFixtures, ArrayT<CafuModelT::GuiLocT>& GuiLocs)
 {

cafu/trunk/Libs/Models/Loader_cmdl.hpp

@@ -44 +44 @@
     bool UseGivenTS() const;
     void Load(ArrayT<CafuModelT::JointT>& Joints, ArrayT<CafuModelT::MeshT>& Meshes, ArrayT<CafuModelT::AnimT>& Anims, MaterialManagerImplT& MaterialMan);
+    void Load(ArrayT<CafuModelT::SkinT>& Skins, const MaterialManagerImplT& MaterialMan);
     void Load(ArrayT<CafuModelT::GuiFixtureT>& GuiFixtures, ArrayT<CafuModelT::GuiLocT>& GuiLocs);
 

cafu/trunk/Libs/Models/Loader_fbx.cpp

@@ -831 +831 @@
 
 
+void LoaderFbxT::Load(ArrayT<CafuModelT::SkinT>& Skins, const MaterialManagerImplT& MaterialMan)
+{
+    // TODO...
+}
+
+
 void LoaderFbxT::Load(ArrayT<CafuModelT::GuiFixtureT>& GuiFixtures, ArrayT<CafuModelT::GuiLocT>& GuiLocs)
 {

cafu/trunk/Libs/Models/Loader_fbx.hpp

@@ -42 +42 @@
     bool UseGivenTS() const;
     void Load(ArrayT<CafuModelT::JointT>& Joints, ArrayT<CafuModelT::MeshT>& Meshes, ArrayT<CafuModelT::AnimT>& Anims, MaterialManagerImplT& MaterialMan);
+    void Load(ArrayT<CafuModelT::SkinT>& Skins, const MaterialManagerImplT& MaterialMan);
     void Load(ArrayT<CafuModelT::GuiFixtureT>& GuiFixtures, ArrayT<CafuModelT::GuiLocT>& GuiLocs);
 

cafu/trunk/Libs/Models/Loader_lwo.hpp

@@ -38 +38 @@
     bool UseGivenTS() const { return true; }
     void Load(ArrayT<CafuModelT::JointT>& Joints, ArrayT<CafuModelT::MeshT>& Meshes, ArrayT<CafuModelT::AnimT>& Anims, MaterialManagerImplT& MaterialMan);
+    void Load(ArrayT<CafuModelT::SkinT>& Skins, const MaterialManagerImplT& MaterialMan) { }
     void Load(ArrayT<CafuModelT::GuiFixtureT>& GuiFixtures, ArrayT<CafuModelT::GuiLocT>& GuiLocs) { }
 

cafu/trunk/Libs/Models/Loader_md5.hpp

@@ -40 +40 @@
     bool UseGivenTS() const;
     void Load(ArrayT<CafuModelT::JointT>& Joints, ArrayT<CafuModelT::MeshT>& Meshes, ArrayT<CafuModelT::AnimT>& Anims, MaterialManagerImplT& MaterialMan);
+    void Load(ArrayT<CafuModelT::SkinT>& Skins, const MaterialManagerImplT& MaterialMan) { }
     void Load(ArrayT<CafuModelT::GuiFixtureT>& GuiFixtures, ArrayT<CafuModelT::GuiLocT>& GuiLocs) { }
 };

cafu/trunk/Libs/Models/Loader_mdl.cpp

@@ -202 +202 @@
     // For clarity and better readibility, break the loading into three separate functions.
     Load(Joints);
-    Load(Meshes);
+    Load(Meshes, m_MeshSkinRef);
     Load(Anims);
 }
@@ -234 +234 @@
 
 
-void LoaderHL1mdlT::Load(ArrayT<CafuModelT::MeshT>& Meshes) const
+void LoaderHL1mdlT::Load(ArrayT<CafuModelT::MeshT>& Meshes, ArrayT<int>& MeshSkinRef) const
 {
     // This is configurable with BodyNr and SkinNr, but at this time we always take the defaults (index 0 each).
@@ -292 +292 @@
                     Weight.Pos     =Vector3fT(StudioVertices[VertexNr]);
                 }
+
+                MeshSkinRef.PushBack(StudioMesh.SkinRef);
             }
 
@@ -524 +526 @@
     // TODO: Sequ.LinearMovement ?
 }
+
+
+void LoaderHL1mdlT::Load(ArrayT<CafuModelT::SkinT>& Skins, const MaterialManagerImplT& MaterialMan)
+{
+    const short* SkinRefs0=(short*)((char*)StudioTextureHeader+StudioTextureHeader->SkinIndex);
+
+    if (StudioTextureHeader->NumSkinFamilies <= 1) return;
+    Skins.PushBackEmptyExact(StudioTextureHeader->NumSkinFamilies - 1);
+
+    // Start with SkinNr=1, because the materials of the first (default) skin are kept directly in the mesh definitions.
+    for (int SkinNr=1; SkinNr<StudioTextureHeader->NumSkinFamilies; SkinNr++)
+    {
+        const short*       SkinRefs=((short*)((char*)StudioTextureHeader+StudioTextureHeader->SkinIndex)) + SkinNr*StudioTextureHeader->NumSkinRef;
+        CafuModelT::SkinT& Skin    =Skins[SkinNr-1];
+
+        for (unsigned long MeshNr=0; MeshNr<m_MeshSkinRef.Size(); MeshNr++)
+        {
+            const int msr=m_MeshSkinRef[MeshNr];
+
+            Skin.Materials.PushBack(SkinRefs0[msr]==SkinRefs[msr] ? NULL : m_Materials[SkinRefs[msr]]);
+            Skin.RenderMaterials.PushBack(NULL);
+        }
+    }
+}

cafu/trunk/Libs/Models/Loader_mdl.hpp

@@ -46 +46 @@
     bool UseGivenTS() const;
     void Load(ArrayT<CafuModelT::JointT>& Joints, ArrayT<CafuModelT::MeshT>& Meshes, ArrayT<CafuModelT::AnimT>& Anims, MaterialManagerImplT& MaterialMan);
+    void Load(ArrayT<CafuModelT::SkinT>& Skins, const MaterialManagerImplT& MaterialMan);
     void Load(ArrayT<CafuModelT::GuiFixtureT>& GuiFixtures, ArrayT<CafuModelT::GuiLocT>& GuiLocs) { }
 
@@ -52 +53 @@
 
     void Load(ArrayT<CafuModelT::JointT>& Joints) const;
-    void Load(ArrayT<CafuModelT::MeshT>& Meshes) const;
+    void Load(ArrayT<CafuModelT::MeshT>& Meshes, ArrayT<int>& MeshSkinRef) const;
     void Load(ArrayT<CafuModelT::AnimT>& Anims) const;
 
@@ -59 +60 @@
     ArrayT< ArrayT<char> > AnimationData;   ///< Animation data ("demand loaded sequences").
     ArrayT<MaterialT*>     m_Materials;     ///< The MatSys materials used in the model.
+    ArrayT<int>            m_MeshSkinRef;   ///< For each mesh, the original StudioMeshT::SkinRef number.
 
     // Convenient abbreviations into the above data arrays.

cafu/trunk/Libs/Models/Model.hpp

@@ -44 +44 @@
         TraceResultT(float Fraction_=0.0f) : Fraction(Fraction_), Material(NULL), MeshNr(-1), TriNr(-1) { }
 
-        float        Fraction;  ///< The scalar along RayDir at which the hit occurred (RayOrigin + RayDir*Fraction).
-        Vector3fT    Normal;    ///< This is the normal vector of the hit surface.
-        MaterialT*   Material;  ///< The material at the point of impact. Can be NULL, e.g. when an edge (i.e. a bevel plane) was hit or the material is not available.
-        unsigned int MeshNr;    ///< The number of the hit mesh. Can be -1 (that is, \emph{larger} then the number of meshes in the model) if the hit mesh cannot be determined.
-        unsigned int TriNr;     ///< The number of the hit triangle in the hit mesh. Can be -1 (that is, \emph{larger} then the number of triangles in the mesh) if the hit triangle cannot be determined.
+        float            Fraction;  ///< The scalar along RayDir at which the hit occurred (RayOrigin + RayDir*Fraction).
+        Vector3fT        Normal;    ///< This is the normal vector of the hit surface.
+        const MaterialT* Material;  ///< The material at the point of impact. Can be NULL, e.g. when an edge (i.e. a bevel plane) was hit or the material is not available.
+        unsigned int     MeshNr;    ///< The number of the hit mesh. Can be -1 (that is, \emph{larger} then the number of meshes in the model) if the hit mesh cannot be determined.
+        unsigned int     TriNr;     ///< The number of the hit triangle in the hit mesh. Can be -1 (that is, \emph{larger} then the number of triangles in the mesh) if the hit triangle cannot be determined.
     };
 
@@ -98 +98 @@
     /// @param SequenceNr  The animation sequence at which the ray should be traced.
     /// @param FrameNr     The animation frame at which the ray should be traced.
+    /// @param SkinNr      The skin to use for the trace, use -1 for the default skin.
     /// @param RayOrigin   The point in model space where the ray starts.
     /// @param RayDir      A unit vector in model space that describes the direction the ray extends to.
@@ -103 +104 @@
     ///
     /// @returns true if the ray hit the model, false otherwise. When the model was hit, additional details are returned via the Result parameter.
-    virtual bool TraceRay(int SequenceNr, float FrameNr, const Vector3fT& RayOrigin, const Vector3fT& RayDir, TraceResultT& Result) const=0;
+    virtual bool TraceRay(int SequenceNr, float FrameNr, int SkinNr, const Vector3fT& RayOrigin, const Vector3fT& RayDir, TraceResultT& Result) const=0;
 
     // Returns the number of frames of sequence SequenceNr. Useful for non-repeating (e.g. death) sequences.

cafu/trunk/Libs/Models/Model_cmdl.cpp

@@ -232 +232 @@
     // Have the model loader load the model file.
     Loader.Load(m_Joints, m_Meshes, m_Anims, m_MaterialMan);
+    Loader.Load(m_Skins, m_MaterialMan);
     Loader.Load(m_GuiFixtures, m_GuiLocs);
     Loader.Postprocess(m_Meshes);
@@ -240 +241 @@
     InitMeshes();
 
-    // Allocate the render materials.
+    // Allocate the render materials for the meshes (the default skin).
     for (unsigned long MeshNr=0; MeshNr<m_Meshes.Size(); MeshNr++)
     {
@@ -247 +248 @@
         assert(Mesh.RenderMaterial==NULL);
         Mesh.RenderMaterial=MatSys::Renderer!=NULL ? MatSys::Renderer->RegisterMaterial(Mesh.Material) : NULL;
+    }
+
+    // Allocate the render materials for the skins.
+    for (unsigned long SkinNr=0; SkinNr<m_Skins.Size(); SkinNr++)
+    {
+        SkinT& Skin=m_Skins[SkinNr];
+
+        assert(Skin.Materials.Size()==m_Meshes.Size());
+        assert(Skin.Materials.Size()==Skin.RenderMaterials.Size());
+
+        for (unsigned long MatNr=0; MatNr<Skin.Materials.Size(); MatNr++)
+        {
+            assert(Skin.RenderMaterials[MatNr]==NULL);
+
+            if (Skin.Materials[MatNr]!=NULL && MatSys::Renderer!=NULL)
+                Skin.RenderMaterials[MatNr]=MatSys::Renderer->RegisterMaterial(Skin.Materials[MatNr]);
+        }
     }
 
@@ -266 +284 @@
     if (MatSys::Renderer==NULL) return;
 
+    // Free all render materials used in skins.
+    for (unsigned long SkinNr=0; SkinNr<m_Skins.Size(); SkinNr++)
+        for (unsigned long MatNr=0; MatNr<m_Skins[SkinNr].RenderMaterials.Size(); MatNr++)
+            MatSys::Renderer->FreeMaterial(m_Skins[SkinNr].RenderMaterials[MatNr]);
+
+    // Free all render materials used in the meshes (the default skin).
     for (unsigned long MeshNr=0; MeshNr<m_Meshes.Size(); MeshNr++)
         MatSys::Renderer->FreeMaterial(m_Meshes[MeshNr].RenderMaterial);
@@ -756 +780 @@
 
 
+    // *** Write the skins. ***
+    OutStream << "\nSkins=\n{\n";
+
+    for (unsigned long SkinNr=0; SkinNr<m_Skins.Size(); SkinNr++)
+    {
+        const SkinT& Skin=m_Skins[SkinNr];
+
+        OutStream << "\t{\n"
+                  << "\t\tname=\"" << Skin.Name << "\";\n"
+                  << "\t\tmaterials={ ";
+
+        for (unsigned long MatNr=0; MatNr<Skin.Materials.Size(); MatNr++)
+        {
+            OutStream << "\"";
+            if (Skin.Materials[MatNr]!=NULL) OutStream << Skin.Materials[MatNr]->Name;
+            OutStream << "\"";
+            if (MatNr+1 < Skin.Materials.Size()) OutStream << ", ";
+        }
+
+        OutStream << " };\n"
+                  << "\t},\n";
+    }
+
+    OutStream << "}\n";
+
+
     // *** Write the GUI fixtures. ***
     OutStream << "\nGuiFixtures=\n{\n";
@@ -1094 +1144 @@
 
 
-void CafuModelT::Draw(int SequenceNr, float FrameNr, float /*LodDist*/, const SuperT* Super) const
+const MaterialT* CafuModelT::GetMaterial(unsigned long MeshNr, int SkinNr) const
+{
+    assert(MeshNr<m_Meshes.Size());
+
+    if (SkinNr<0 || SkinNr>=int(m_Skins.Size()))
+        return m_Meshes[MeshNr].Material;
+
+    if (MeshNr>=m_Skins[SkinNr].Materials.Size())
+        return m_Meshes[MeshNr].Material;
+
+    if (!m_Skins[SkinNr].Materials[MeshNr])
+        return m_Meshes[MeshNr].Material;
+
+    return m_Skins[SkinNr].Materials[MeshNr];
+}
+
+
+MatSys::RenderMaterialT* CafuModelT::GetRenderMaterial(unsigned long MeshNr, int SkinNr) const
+{
+    assert(MeshNr<m_Meshes.Size());
+
+    if (SkinNr<0 || SkinNr>=int(m_Skins.Size()))
+        return m_Meshes[MeshNr].RenderMaterial;
+
+    if (MeshNr>=m_Skins[SkinNr].RenderMaterials.Size())
+        return m_Meshes[MeshNr].RenderMaterial;
+
+    if (!m_Skins[SkinNr].RenderMaterials[MeshNr])
+        return m_Meshes[MeshNr].RenderMaterial;
+
+    return m_Skins[SkinNr].RenderMaterials[MeshNr];
+}
+
+
+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)".
@@ -1172 +1256 @@
             for (unsigned long MeshNr=0; MeshNr<m_Meshes.Size(); MeshNr++)
             {
-                MatSys::Renderer->SetCurrentMaterial(m_Meshes[MeshNr].RenderMaterial);
+                MatSys::Renderer->SetCurrentMaterial(GetRenderMaterial(MeshNr, SkinNr));
                 MatSys::Renderer->RenderMesh(m_Draw_Meshes[MeshNr]);
 
@@ -1231 +1315 @@
             for (unsigned long MeshNr=0; MeshNr<m_Meshes.Size(); MeshNr++)
             {
-                MatSys::Renderer->SetCurrentMaterial(m_Meshes[MeshNr].RenderMaterial);
+                MatSys::Renderer->SetCurrentMaterial(GetRenderMaterial(MeshNr, SkinNr));
                 MatSys::Renderer->RenderMesh(m_Draw_Meshes[MeshNr]);
             }
@@ -1243 +1327 @@
             for (unsigned long MeshNr=0; MeshNr<m_Meshes.Size(); MeshNr++)
             {
-                const MeshT& Mesh=m_Meshes[MeshNr];
-
-                if (Mesh.Material==NULL || Mesh.Material->NoShadows) continue;
+                const MeshT&     Mesh   =m_Meshes[MeshNr];
+                const MaterialT* MeshMat=GetMaterial(MeshNr, SkinNr);
+
+                if (MeshMat==NULL || MeshMat->NoShadows) continue;
 
                 static ArrayT<bool> TriangleIsFrontFacing;
@@ -1343 +1428 @@
 void CafuModelT::Draw(int SequenceNr, float FrameNr, float LodDist, const ModelT* /*SubModel*/) const
 {
-    Draw(SequenceNr, FrameNr, LodDist, (SuperT*)NULL);
+    Draw(SequenceNr, FrameNr, -1 /*default skin*/, LodDist, (SuperT*)NULL);
 }
 
@@ -1418 +1503 @@
 
 
-bool CafuModelT::TraceRay(int SequenceNr, float FrameNr, const Vector3fT& RayOrigin, const Vector3fT& RayDir, TraceResultT& Result) const
+bool CafuModelT::TraceRay(int SequenceNr, float FrameNr, int SkinNr, const Vector3fT& RayOrigin, const Vector3fT& RayDir, TraceResultT& Result) const
 {
     float Fraction=0.0f;
@@ -1430 +1515 @@
     for (unsigned long MeshNr=0; MeshNr<m_Meshes.Size(); MeshNr++)
     {
-        const MeshT& Mesh=m_Meshes[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 (!Mesh.Material) continue;
-        // if ((Mesh.Material->ClipFlags & ClipMask)==0) continue;
+        if (!MeshMat) continue;
+        // if ((MeshMat->ClipFlags & ClipMask)==0) continue;
 
         for (unsigned long TriNr=0; TriNr<Mesh.Triangles.Size(); TriNr++)
@@ -1452 +1538 @@
             // 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 (!Mesh.Material->TwoSided)
+            if (!MeshMat->TwoSided)
             {
                 if (R*PlueckerfT::CreateFromLine(A, B) >= 0) continue;
@@ -1474 +1560 @@
 
             if (Nenner==0) continue;                            // If Nenner==0, then RayDir is parallel to the triangle plane (no intersection).
-            assert(Mesh.Material->TwoSided || Nenner<0);        // If material is single sided, then Nenner<0, a consequence of the Pluecker tests above.
+            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.
@@ -1485 +1571 @@
             Result.Fraction=F;
             Result.Normal  =(Nenner<0) ? Tri.Draw_Normal : -Tri.Draw_Normal;    // Handle two-sided materials properly.
-            Result.Material=Mesh.Material;
+            Result.Material=MeshMat;
             Result.MeshNr  =MeshNr;
             Result.TriNr   =TriNr;

cafu/trunk/Libs/Models/Model_cmdl.hpp

@@ -166 +166 @@
 
 
+    /// This struct describes additional/alternative skins for this model.
+    struct SkinT
+    {
+        std::string                      Name;              ///< The name of this skin.
+        ArrayT<MaterialT*>               Materials;         ///< For each mesh \c m, <tt>Materials[m]</tt> is the material for the mesh in this skin. If <tt>Materials[m]</tt> is NULL, the material of the default skin is used.
+        ArrayT<MatSys::RenderMaterialT*> RenderMaterials;   ///< Analogous to \c Materials, these are the (possibly NULL) render materials for the meshes in this skin.
+    };
+
+
     /// This struct defines how and where a GUI can be fixed to the model.
     /// The GUI rectangle is defined by three points: the origin, the x-axis endpoint, and the y-axis endpoint, numbered 0, 1 and 2.
@@ -239 +248 @@
     const ArrayT<MeshT>&        GetMeshes() const { return m_Meshes; }
     const ArrayT<AnimT>&        GetAnims() const { return m_Anims; }
+    const ArrayT<SkinT>&        GetSkins() const { return m_Skins; }
     const ArrayT<GuiFixtureT>&  GetGuiFixtures() const { return m_GuiFixtures; }
 
@@ -247 +257 @@
     /// @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, float LodDist, const SuperT* Super=NULL) const;
+    void Draw(int SequenceNr, float FrameNr, int SkinNr, float LodDist, const SuperT* Super=NULL) const;
 
     /// Determines if <tt>GF.Points[PointNr].MeshNr</tt> is a valid index into this model.
@@ -264 +275 @@
     unsigned int       GetNrOfSequences() const;
     BoundingBox3fT     GetBB(int SequenceNr, float FrameNr) const;
-    bool               TraceRay(int SequenceNr, float FrameNr, const Vector3fT& RayOrigin, const Vector3fT& RayDir, TraceResultT& Result) const;
+    bool               TraceRay(int SequenceNr, float FrameNr, int SkinNr, const Vector3fT& RayOrigin, const Vector3fT& RayDir, TraceResultT& Result) const;
  // float              GetNrOfFrames(int SequenceNr) const;
     float              AdvanceFrameNr(int SequenceNr, float FrameNr, float DeltaTime, bool Loop=true) const;
@@ -286 +297 @@
     void InitMeshes();                                                                      ///< An auxiliary method for the constructors.
     void UpdateCachedDrawData(int SequenceNr, float FrameNr, const SuperT* Super) const;    ///< A private auxiliary method.
+    const MaterialT* GetMaterial(unsigned long MeshNr, int SkinNr) const;                   ///< Returns the proper material for the given mesh in the given skin.
+    MatSys::RenderMaterialT* GetRenderMaterial(unsigned long MeshNr, int SkinNr) const;     ///< Returns the proper render material for the given mesh in the given skin.
 
 
@@ -293 +306 @@
     mutable ArrayT<MeshT> m_Meshes;                 ///< Array of (sub)meshes of this model.
     ArrayT<AnimT>         m_Anims;                  ///< Array of animations of this model.
+    ArrayT<SkinT>         m_Skins;                  ///< Array of additional/alternative skins for this model.
 
     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).

cafu/trunk/Libs/Models/Model_dlod.cpp

@@ -118 +118 @@
 
 
-bool ModelDlodT::TraceRay(int SequenceNr, float FrameNr, const Vector3fT& RayOrigin, const Vector3fT& RayDir, TraceResultT& Result) const
+bool ModelDlodT::TraceRay(int SequenceNr, float FrameNr, int SkinNr, const Vector3fT& RayOrigin, const Vector3fT& RayDir, TraceResultT& Result) const
 {
     // for (unsigned long LodModelNr=0; LodModelNr<LodModels.Size(); LodModelNr++)
     //     if (LodDist>=LodStartRanges[LodModelNr] && LodDist<LodEndRanges[LodModelNr])
-    //         return LodModels[LodModelNr].TraceRay(SequenceNr, FrameNr, RayOrigin, RayDir, Result);
+    //         return LodModels[LodModelNr].TraceRay(SequenceNr, FrameNr, SkinNr, RayOrigin, RayDir, Result);
     //
     // return false;
-    return LodModels[0].TraceRay(SequenceNr, FrameNr, RayOrigin, RayDir, Result);
+    return LodModels[0].TraceRay(SequenceNr, FrameNr, SkinNr, RayOrigin, RayDir, Result);
 }
 

cafu/trunk/Libs/Models/Model_dlod.hpp

@@ -47 +47 @@
     unsigned int       GetNrOfSequences() const;
     BoundingBox3fT     GetBB(int SequenceNr, float FrameNr) const;
-    bool               TraceRay(int SequenceNr, float FrameNr, const Vector3fT& RayOrigin, const Vector3fT& RayDir, TraceResultT& Result) const;
+    bool               TraceRay(int SequenceNr, float FrameNr, int SkinNr, const Vector3fT& RayOrigin, const Vector3fT& RayDir, TraceResultT& Result) const;
  // float              GetNrOfFrames(int SequenceNr) const;
     float              AdvanceFrameNr(int SequenceNr, float FrameNr, float DeltaTime, bool Loop=true) const;

cafu/trunk/Libs/Models/Model_dummy.cpp

@@ -73 +73 @@
 
 
-bool ModelDummyT::TraceRay(int SequenceNr, float FrameNr, const Vector3fT& RayOrigin, const Vector3fT& RayDir, TraceResultT& Result) const
+bool ModelDummyT::TraceRay(int SequenceNr, float FrameNr, int SkinNr, const Vector3fT& RayOrigin, const Vector3fT& RayDir, TraceResultT& Result) const
 {
     float Fraction=0.0f;

cafu/trunk/Libs/Models/Model_dummy.hpp

@@ -45 +45 @@
     unsigned int       GetNrOfSequences() const;
     BoundingBox3fT     GetBB(int SequenceNr, float FrameNr) const;
-    bool               TraceRay(int SequenceNr, float FrameNr, const Vector3fT& RayOrigin, const Vector3fT& RayDir, TraceResultT& Result) const;
+    bool               TraceRay(int SequenceNr, float FrameNr, int SkinNr, const Vector3fT& RayOrigin, const Vector3fT& RayDir, TraceResultT& Result) const;
  // float              GetNrOfFrames(int SequenceNr) const;
     float              AdvanceFrameNr(int SequenceNr, float FrameNr, float DeltaTime, bool Loop=true) const;

cafu/trunk/Libs/Models/Model_mdl.cpp

@@ -1575 +1575 @@
 
 
-bool ModelMdlT::TraceRay(int SequenceNr, float FrameNr, const Vector3fT& RayOrigin, const Vector3fT& RayDir, TraceResultT& Result) const
+bool ModelMdlT::TraceRay(int SequenceNr, float FrameNr, int SkinNr, const Vector3fT& RayOrigin, const Vector3fT& RayDir, TraceResultT& Result) const
 {
     return false;

cafu/trunk/Libs/Models/Model_mdl.hpp

@@ -125 +125 @@
     unsigned int       GetNrOfSequences() const;
     BoundingBox3fT     GetBB(int SequenceNr, float FrameNr) const;
-    bool               TraceRay(int SequenceNr, float FrameNr, const Vector3fT& RayOrigin, const Vector3fT& RayDir, TraceResultT& Result) const;
+    bool               TraceRay(int SequenceNr, float FrameNr, int SkinNr, const Vector3fT& RayOrigin, const Vector3fT& RayDir, TraceResultT& Result) const;
  // float              GetNrOfFrames(int SequenceNr) const;
     float              AdvanceFrameNr(int SequenceNr, float FrameNr, float DeltaTime, bool Loop=true) const;

cafu/trunk/Libs/Models/Model_proxy.cpp

@@ -242 +242 @@
 
 
-bool ModelProxyT::TraceRay(int SequenceNr, float FrameNr, const Vector3fT& RayOrigin, const Vector3fT& RayDir, TraceResultT& Result) const
-{
-    return ModelPool[PoolIndex]->TraceRay(SequenceNr, FrameNr, RayOrigin, RayDir, Result);
+bool ModelProxyT::TraceRay(int SequenceNr, float FrameNr, int SkinNr, const Vector3fT& RayOrigin, const Vector3fT& RayDir, TraceResultT& Result) const
+{
+    return ModelPool[PoolIndex]->TraceRay(SequenceNr, FrameNr, SkinNr, RayOrigin, RayDir, Result);
 }
 

cafu/trunk/Libs/Models/Model_proxy.hpp

@@ -61 +61 @@
     unsigned int       GetNrOfSequences() const;
     BoundingBox3fT     GetBB(int SequenceNr, float FrameNr) const;
-    bool               TraceRay(int SequenceNr, float FrameNr, const Vector3fT& RayOrigin, const Vector3fT& RayDir, TraceResultT& Result) const;
+    bool               TraceRay(int SequenceNr, float FrameNr, int SkinNr, const Vector3fT& RayOrigin, const Vector3fT& RayDir, TraceResultT& Result) const;
  // float              GetNrOfFrames(int SequenceNr) const;
     float              AdvanceFrameNr(int SequenceNr, float FrameNr, float DeltaTime, bool Loop=true) const;