Hiding Meshes

This is based heavily on Justin Mette's resource.
The big difference is I'm hiding/showing the meshes themselves, and not the nodes (skeleton). The main use is to simulate Raven's Ghoul system, wherein 3-4 models are used to represent hundreds of possibilities. This way, your model can contain a standard torso, a torso with platemail, a torso with chainmail, etc. All torsos are skinned the same, on one model. When loading the character, you turn off all meshes but one. When the player puts on a piece of armor, you can then turn off the standard torso, and turn on the armored one.

Available script methods are:
ModelDump() Runs TSDump, giving some somewhat useful info on a given model.
SkinOnList() Lists all visible skins(meshes)
SkinOffList() Lists all hidden skins(meshes)
SkinOn(name) Makes the named mesh visible
SkinOff(name) Makes the named mesh hidden

Basic usage:
1734.SkinOff(StandardLegs);
1734.SkinOn(ArmoredLegs);

Notes:
Using comments here is very important, as TSE is going to be all over this. Merging later will probably be a nightmare without knowing what you've added.

On to the code....

[b]tsShapeInstance.h[/b]
[i]   struct MeshObjectInstance : ObjectInstance
   {[/i]
     bool forceHidden;    ///< part of SkinOn()

[b]tsShapeInstance.cc[/b]
[i]void TSShapeInstance::buildInstanceData(TSShape * _shape, bool loadMaterials)[/i]
......
[i]      else
         objInst->meshList = NULL;

      objInst->object = obj;[/i]
      objInst->forceHidden = false;    // part of SkinOn()

[b]tsAnimate.cc[/b]
[i]void TSShapeInstance::animateVisibility(S32 ss)[/i]
.....
[i]   S32 a = mShape->subShapeFirstObject[ss];
   S32 b = a + mShape->subShapeNumObjects[ss];[/i]
   for (int x=a; x<b; x++) {  // changed from i to x, 
                              // as i is used to make italics in these codeblocks
     if(mMeshObjects[x].forceHidden)      // part of SkinOn()
        mMeshObjects[x].visible = 0.0;
     else if (beenSet.test(x))
         mMeshObjects[x].visible = 1.0;
   }

[b]ShapeBase.h[/b]
[i]class ShapeBase : public GameBase[/i]
....
[i]public:[/i]
   Vector<S32> mHiddenMeshes;    ///< Part of SkinOn()
....
[i] protected:[/i]

   void updateHiddenMeshes(); ///< part of SkinOn()
   
[i]   /// @name Damage[/i]
....
[i]   /// Returns the current damage state.
   DamageState getDamageState() { return mDamageState; }
[/i]
   /// Returns true if the mesh is hidden
   bool isHiddenMesh(S32 node);  // checks mHiddenMeshes array, part of SkinOn() 

   /// part of SkinOn()
   void SkinOffList();
   void SkinOnList();
   void ModelDump();
[i]
   /// Returns true if the object is destroyed.
[/i]
[i]// Network state masks
enum ShapeBaseMasks {[/i]
HideMeshMask    = Parent::NextFreeMask << 7,

[b]ShapeBase.cc[/b]
[i]U32 ShapeBase::packUpdate(NetConnection *con, U32 mask, BitStream *stream)[/i]
...
[i]for(i = 0; i < MaxMountedImages; i++)         
     if(!mMountedImageList[i ].dataBlock)
             mask &= ~(ImageMaskN << i); [/i]     // mask off mesh visibility if nothing to update
      if(mHiddenMeshes.size() == 0)
      mask &= ~HideMeshMask;


[i]U32 ShapeBase::packUpdate(NetConnection *con, U32 mask, BitStream *stream){[/i]
...
[i]   if(!stream->writeFlag(mask & (NameMask | DamageMask | SoundMask | ThreadMask |      ImageMask | CloakMask | MountedMask[/i] | HideMeshMask)[i]))
      return retMask;[/i]
...
[i]   // Group some of the uncommon stuff together.
   if (stream->writeFlag(mask & (NameMask | ShieldMask | CloakMask | InvincibleMask [/i] | HideMeshMask[i]))) {[/i]
...
[i]   if (stream->writeFlag(mask & InvincibleMask)) {
         stream->write(mInvincibleTime);
         stream->write(mInvincibleSpeed);
      }[/i]      
      if (stream->writeFlag(mask & HideMeshMask)) {
         stream->writeInt(mHiddenMeshes.size(), 8);
         for(int x = 0; x < mHiddenMeshes.size(); x++)
            stream->writeInt(mHiddenMeshes[x], 8);
      }

...

[i]void ShapeBase::unpackUpdate(NetConnection *con, BitStream *stream)[/i]
...
[i]      setupInvincibleEffect(time, speed);
      }   [/i]
      if (stream->readFlag()) { // HideMeshMask
        mHiddenMeshes.clear();
        int count = stream->readInt(8);
        for(int x = 0; x < count; x++)
          mHiddenMeshes.push_back(stream->readInt(8));
        updateHiddenMeshes();
      }

void ShapeBase::updateHiddenMeshes() {
   if(!mShapeInstance)
     return;
   int s = mShapeInstance->mMeshObjects.size();
   for(int x = 0; x < s; x++)
   {
      S32 nodeIndex = mShapeInstance->mMeshObjects[x].object->nodeIndex;
      F32 visible = 1.0;
      if(isHiddenMesh(nodeIndex))
         visible = 0.0;
      mShapeInstance->mMeshObjects[x].visible = visible;
      mShapeInstance->mMeshObjects[x].forceHidden = (visible == 0.0);
   }
}

bool ShapeBase::isHiddenMesh(S32 node)
{
   for(int x = 0; x < mHiddenMeshes.size(); x++)
      if(mHiddenMeshes[x] == node)
         return true;
   return false;
}

//--------------------------------------------------------------------------
// methods used with SkinOn()

ConsoleMethod(ShapeBase, ModelDump, void, 2, 2, "Dump known info on a model")
{
   object->ModelDump();
}

void ShapeBase::ModelDump()
{
   //A little bit of test info on the layout of the model
   FileStream st;   
   st.open("Model.dump", FileStream::ReadWrite);
   if ((st.getStatus() == Stream::Ok) || (st.getStatus() == Stream::EOS))
      if (mShapeInstance)
         mShapeInstance->dump(st);
      else
         Con::errorf("No shapeinstance");
   else
      Con::errorf("Error opening dump file");
}

ConsoleMethod( ShapeBase, SkinOffList, void, 2, 2, "List all skins(meshes) not visible")
{
   object->SkinOffList();
}

void ShapeBase::SkinOffList()
{
   
   for (int i=0; i<mShapeInstance->getShape()->objects.size(); i++)
   {
      if (mShapeInstance->getShape()->objects[i].nodeIndex<0) // must be a skin
      {
         const char * skinName = "";
         S32 nameIndex = mShapeInstance->getShape()->objects[i].nameIndex;         
         if (nameIndex>=0 && isHiddenMesh(nameIndex)) 
         {
            skinName = mShapeInstance->getShape()->getName(nameIndex);
            Con::errorf("%s ", skinName);
         }
      }
   }
}

ConsoleMethod( ShapeBase, SkinOnList, void, 2, 2, "List all skins(meshes) visible")
{
      object->SkinOnList();
}

void ShapeBase::SkinOnList()
{
   
   for (int i=0; i<mShapeInstance->getShape()->objects.size(); i++)
   {
      if (mShapeInstance->getShape()->objects[i].nodeIndex<0) // must be a skin
      {
         const char * skinName = "";
         S32 nameIndex = mShapeInstance->getShape()->objects[i].nameIndex;         
         if (nameIndex>=0 && !isHiddenMesh(nameIndex)) 
         {
            skinName = mShapeInstance->getShape()->getName(nameIndex);
            Con::errorf("%s ", skinName);
         }
      }
   }
}

ConsoleMethod( ShapeBase, SkinOff, void, 3, 3, "(string meshname)")
{
   S32 i;
   TSShape const* mShape = object->getShape();

   if (argv[2] != '[[4fc733dd1b7b2]]') {
      for (i=0; i< mShape->objects.size(); i++)
      {
         if (mShape->objects[i].nodeIndex<0) // must be a skin
         {  
            S32 nameIndex = mShape->objects[i].nameIndex;
            if (nameIndex>=0) {               
               if (dStricmp(argv[2], mShape->getName(nameIndex)) == 0) {
                  for(int x = 0; x < object->mHiddenMeshes.size(); x++) {
                     if(object->mHiddenMeshes[x] == nameIndex) {
                        Con::errorf("SkinOff(): Mesh %s already hidden", argv[2]);
                        return;
                     }
                  }
                  object->mHiddenMeshes.push_back(nameIndex);
                  object->setMaskBits(ShapeBase::HideMeshMask);
                  return;
               }
            }
         }
      }
      Con::errorf("SkinOff(): Unable to hide mesh %s.", argv[2]);
   } 
}


ConsoleMethod( ShapeBase, SkinOn, void, 3, 3, "(string meshname)")
{
   S32 i;
   TSShape const* mShape = object->getShape();

   if (argv[2] != '[[4fc733dd1b7b2]]') {
      // look for the node in our hidden mesh array   
      // if we find it, erase it and flag that the array has changed   
      for(int x = 0; x < object->mHiddenMeshes.size(); x++) {
         if (dStricmp(argv[2], mShape->getName(object->mHiddenMeshes[x])) == 0)
         {
            object->mHiddenMeshes.erase(x);
            object->setMaskBits(ShapeBase::HideMeshMask);
            return;
         }
      }
      Con::errorf("SkinOn(): Couldn't find %s in the array. Possibly not hidden?", argv[2]);
   }
}
// End of SkinOn() methods