Multiple skins on a single model

static bool makeSkinPath(char* buffer, U32 bufferLength, const char* resourcePath,
                         const char* oldSkin, const char* oldRoot, const char* newRoot)
{
   bool replacedRoot = true;[b]
   dsize_t extraLen  = 0;[/b]

   dsize_t oldRootLen = 0;
   char* rootStart = NULL;

   if (oldRoot == NULL) {
      // Not doing any replacing.
      replacedRoot = false;
   }
   else {
      // See if original name has the old root in it.
      oldRootLen = dStrlen(oldRoot);
      AssertFatal((oldRootLen + 1) < bufferLength, "makeSkinPath: Error, skin root name too long");
      dStrcpy(buffer, oldRoot);[b]
      if (dStricmp(oldSkin, buffer)) {
         dStrcat(buffer, ".");
         extraLen = 1;
      }[/b]
      rootStart = dStrstr(oldSkin, buffer);
      if (rootStart == NULL) {
         replacedRoot = false;
      }
   }

   // Find out how long the total pathname will be.
   const dsize_t oldLen = dStrlen(oldSkin);
   dsize_t pathLen = 0;
   if (resourcePath != NULL) {
      pathLen = dStrlen(resourcePath);
   }
   if (replacedRoot) {
      const dsize_t newRootLen = dStrlen(newRoot);[b]
      AssertFatal((pathLen + extraLen + oldLen + newRootLen - oldRootLen) < bufferLength, "makeSkinPath: Error, pathname too long");[/b]
   }
   else {[b]
      AssertFatal((pathLen + extraLen + oldLen) < bufferLength, "makeSkinPath: Error, pathname too long");[/b]
   }

   // OK, now make the pathname.

   // Start with the resource path:
   if (resourcePath != NULL) {
      dStrcpy(buffer, resourcePath);
      dStrcat(buffer, "/");
   }
   else {
      buffer[0] = '[[4c88f18969195]]';
   }
   if (replacedRoot) {
      // Then the pre-root part of the old name:
      dsize_t rootStartPos = rootStart - oldSkin;
      if (rootStartPos != 0) {
         dStrncat(buffer, oldSkin, rootStartPos);
      }
      // Then the new root:
      dStrcat(buffer, newRoot);[b]
      if (extraLen > 0)
         dStrcat(buffer, ".");[/b]
      // Then the post-root part of the old name:[b]
      dStrcat(buffer, oldSkin + rootStartPos + oldRootLen + extraLen);[/b]
   }
   else {
      // Then the old name:
      dStrcat(buffer, oldSkin);
   }

   return replacedRoot;
}

if (stream->writeFlag(mask & SkinMask)) {
         if (!mShapeInstance) {
            stream->writeInt(0, 7); // 127 skins maximum 
         }
         else {
            Vector<const char*> *list = mShapeInstance->getReplacedSkinNames();
            stream->writeInt(list->size(), 7);
            for (int n = 0; n < list->size(); n++) {
               StringHandle tmp((*list)[n]);
               con->packStringHandleU(stream, tmp);
            }
         }

if (stream->readFlag()) {  // SkinMask
         int numSkins = stream->readInt(7);
         StringHandle sh;

         for (int n = 0; n < numSkins; n++) {
            sh = con->unpackStringHandleU(stream);
            mShapeInstance->reSkin(sh);
         }

         makeSkinHash(mSkinHash);
      }