Dynamic changeable player textures

[b]struct PlayerData: public ShapeBaseData {[/b]
....
   StringTableEntry  baseTextureName;
....
}

[b]class Player: public ShapeBase {[/b]
....

  // Make a list of the slots that can change here
  // You define where the coordiates are in the constructor
   enum LayerNames
   {
	chest,
	legs,
	hands,
	feet
   };

   enum TextureLayersConsts
   {
              TEXTURELAYERS = 10
   };

   enum MaskBits {
    ....
	  layerTextureMask  = Parent::NextFreeMask << 7, // <-- Replace 7 with your next free mask #
    ....
   };
	        TextureHandle     texture;
		StringTableEntry  layerTextureName[TEXTURELAYERS];
		Point2I                 pointsList[TEXTURELAYERS];
		F32                      rotationList[TEXTURELAYERS];
	        static bool           blit(GBitmap* src, GBitmap* dst, Point2I pt, F32 rot );
                void	                 setLayerTexture(U32 layer, const char* texture);
                bool                     generateTexture();

....
}

[b]PlayerData::PlayerData()[/b]
{
   baseTextureName = NULL;
   ....
}

[b]void PlayerData::initPersistFields()[/b]
{
   addField("baseTexture",   TypeString,   Offset(baseTextureName,     PlayerData));
   ....
}

[b]void PlayerData::packData(BitStream* stream)[/b]
{
   Parent::packData(stream);

   stream->writeString( baseTextureName );
   ....
}

[b]void PlayerData::unpackData(BitStream* stream)[/b]
{
   Parent::unpackData(stream);

   baseTextureName = stream->readSTString();
   ....
}

[b]Player::Player()[/b]
{
   for( U32 i = 0; i < TEXTURELAYERS; i++ )
   {
     pointsList[i].set( -1, -1 );
   }
   dMemset( layerTextureName, NULL, sizeof( layerTextureName ) );
   
   // Set the offset here for each slot.
   // For example here the chest texture will be pasted in at 440, 450
   // and the legs will be at 100, 50
   pointsList[chest].set(440 , 450);
   pointsList[legs].set(100 , 50);

   texture = NULL;
   ....
}

[b]ConsoleMethod( Player, setLayerTexture, void, 4, 4, "")[/b]
{
	object->setLayerTexture(dAtoi(argv[2]), argv[3]);
}

[b]void Player::setLayerTexture(U32 layer, const char* textureName)[/b]
{
	char textureFullName[128];
	dSprintf(textureFullName, sizeof(textureFullName), "starter.fps/data/shapes/player/%s", textureName);
	GBitmap* bitmap = (GBitmap*)ResourceManager->loadInstance( textureFullName );
	if(!bitmap)
		return;

	if(layer < 0 || layer > TEXTURELAYERS)
		return;

	layerTextureName[layer] = StringTable->insert(textureFullName);
	//Con::printf("SETLAYER TO: %s", layerTextureName[layer]);
	setMaskBits(layerTextureMask);
}

[b]bool Player::blit(GBitmap* base, GBitmap* layer, Point2I pt, F32 rot )[/b]
{
	
  const U32 halfWidth  = 0; //layer->getWidth() / 2;
  const U32 halfHeight = 0; //layer->getHeight() / 2;
  
  // TODO: add condition to check to make sure it is ok with rotation taken into account
  if( pt.x + halfWidth > base->getWidth() ||
      pt.x - halfWidth < 0 ||
      pt.y + halfHeight > base->getHeight() ||
      pt.y - halfHeight < 0 
    )
    return false;
  //Con::printf("Blitting base X %i Y %i", base->getWidth(), base->getHeight());
  for ( U32 w = 0; w < layer->getWidth(); w++ )
    for ( U32 h = 0; h < layer->getHeight(); h++ )
    {
      U8* basePixel;

      if( rot == 0 )
      {
        basePixel = base->getAddress( pt.x - halfWidth + w, pt.y - halfHeight + h );
      }
      else
      {
        F32 angle = mDegToRad( rot );

        const S32 x = (S32)(((S32)w - (S32)halfWidth)*cos(angle) - ((S32)h - (S32)halfHeight)*sin(angle)) + pt.x;
        const S32 y = (S32)(((S32)w - (S32)halfWidth)*sin(angle) + ((S32)h - (S32)halfHeight)*cos(angle)) + pt.y;

        basePixel = base->getAddress(x,y);
      }

      U8* layerPixel = layer->getAddress( w, h );

      const float alpha = layerPixel[3]/255.0;
      
      basePixel[0] = (U8)(alpha*layerPixel[0] + (1-alpha)*basePixel[0]);
      basePixel[1] = (U8)(alpha*layerPixel[1] + (1-alpha)*basePixel[1]);
      basePixel[2] = (U8)(alpha*layerPixel[2] + (1-alpha)*basePixel[2]);
    }

  return true;
}

[b]bool Player::generateTexture()[/b]
{
	if(!isGhost())
		return false;
  GBitmap* baseBitmap;
  
  if( mDataBlock->baseTextureName )
  {

    baseBitmap = (GBitmap*)ResourceManager->loadInstance( mDataBlock->baseTextureName );
   
    if( baseBitmap == NULL )
    {
      Con::errorf(ConsoleLogEntry::General, "TextureLayersData(%s)::onAdd: baseTextureName (%s) invalid file", getName(), mDataBlock->baseTextureName);
      return false;
    }

    if( baseBitmap->getFormat() != GBitmap::RGB )
    {
      Con::errorf(ConsoleLogEntry::General, "TextureLayersData(%s)::onAdd: baseTextureName (%s) not RGB", getName(), mDataBlock->baseTextureName);
      return false;
    }
  }
  else
  {
    Con::errorf(ConsoleLogEntry::General, "TextureLayersData(%s)::onAdd: baseTextureName invalid", getName());
    return false;
  }

    for( U32 i = 0; i < TEXTURELAYERS; i++ )
  {
    if( layerTextureName[i] != NULL )
    {
      GBitmap* layerBitmap = (GBitmap*)ResourceManager->loadInstance( layerTextureName[i] );

      if( layerBitmap == NULL )
      {
        Con::errorf(ConsoleLogEntry::General, "TextureLayersData(%s)::onAdd: layerTextureName (%s) invalid file", getName(), layerTextureName[i]);
        continue;
      }

      if( layerBitmap->getFormat() != GBitmap::RGBA )
      {
        Con::errorf(ConsoleLogEntry::General, "TextureLayersData(%s)::onAdd: layerTextureName (%s) not RGBA", getName(), layerTextureName[i]);
        continue;
      }

      if( !blit( baseBitmap, layerBitmap, pointsList[i], rotationList[i] ) )
      {
        Con::errorf(ConsoleLogEntry::General, "TextureLayersData(%s)::onAdd: unable to blit layerTextureName (%s)", getName(), layerTextureName[i]);
        continue;
      }
      
      delete layerBitmap;
    }
  }
  texture.set(NULL,baseBitmap,BitmapTexture); 
  return true;
}

[b]U32 Player::packUpdate(NetConnection *con, U32 mask, BitStream *stream)[/b]
{
    U32 retMask = Parent::packUpdate(con, mask, stream);

	if(stream->writeFlag(mask & layerTextureMask))
	{
		for(int x = 0; x < TEXTURELAYERS; x++)
		{
			stream->writeString(layerTextureName[x]);
			//Con::printf("WRITING TEX #%i TO %s", x, layerTextureName[x]);
		}
	}
        ....
}

[b]void Player::unpackUpdate(NetConnection *con, BitStream *stream)[/b]
{
    Parent::unpackUpdate(con,stream);

	if(stream->readFlag())
	{
		for(int x = 0; x < TEXTURELAYERS; x++)
		{
			layerTextureName[x] = stream->readSTString();
			//Con::printf("SET TEX #%i TO %s", x, layerTextureName[x]);
		}
		if(isProperlyAdded())
			generateTexture();
	}
      ....
}

[b]void Player::renderImage(SceneState* state, SceneRenderImage* image)[/b]
{
      ....
      if(texture)
            mShapeInstance->setOverrideTexture(texture);

      mShapeInstance->setupFog(fogAmount,state->getFogColor());
      mShapeInstance->animate();
      mShapeInstance->render();
     
       if(texture)
	  mShapeInstance->clearOverrideTexture();
       ....
}

%slotNumber = 1;
    %textureName = "pants.png";
    %player.setLayerTexture(%slotNumber, %textureName);