/*==LICENSE==*

CyanWorlds.com Engine - MMOG client, server and tools
Copyright (C) 2011  Cyan Worlds, Inc.

This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.

You can contact Cyan Worlds, Inc. by email legal@cyan.com
 or by snail mail at:
      Cyan Worlds, Inc.
      14617 N Newport Hwy
      Mead, WA   99021

*==LICENSE==*/
#include "hsTypes.h"
#include "hsTemplates.h"
#include "hsStream.h"
#include "hsResMgr.h"
#include "plGDispatch.h"
#include "../pnKeyedObject/plKey.h"
#include "../pnKeyedObject/plFixedKey.h"
#include "../pnSceneObject/plSceneObject.h"
#include "../plDrawable/plInstanceDrawInterface.h"
#include "../pnMessage/plRefMsg.h"
#include "../pnMessage/plPipeResMakeMsg.h"
#include "../pfMessage/plClothingMsg.h"
#include "../plMessage/plRenderMsg.h"
#include "../plGImage/plMipmap.h"
#include "../plPipeline/hsGDeviceRef.h"
#include "../plPipeline/plRenderTarget.h"
#include "plPipeline.h"
#include "plClothingLayout.h"
#include "plAvatarClothing.h"
#include "plClothingSDLModifier.h"
#include "../plGImage/hsCodecManager.h"
#include "../plAvatar/plArmatureMod.h"
#include "../plAvatar/plAvatarMgr.h"
#include "../plAvatar/plArmatureEffects.h"
#include "../pnNetCommon/plNetApp.h"
#include "../pnMessage/plSDLModifierMsg.h"
#include "../plMessage/plReplaceGeometryMsg.h"
#include "../plDrawable/plDrawableSpans.h"
#include "../plDrawable/plSharedMesh.h"
#include "../plDrawable/plMorphSequence.h"
#include "../plDrawable/plMorphSequenceSDLMod.h"
#include "../plDrawable/plSpaceTree.h"
#include "../plSurface/hsGMaterial.h"
#include "../plSurface/plLayer.h"
#include "../plMath/plRandom.h"
#include "../plSDL/plSDL.h"
#include "../plVault/plVault.h"
#include "../plResMgr/plKeyFinder.h"
#include "../plNetClientComm/plNetClientComm.h"


plClothingItem::plClothingItem() : fName(nil), fGroup(0), fTileset(0), fType(0), fSortOrder(0),
								   fDescription(nil), fCustomText(nil), fThumbnail(nil), 
								   fAccessory(nil), fAccessoryName(nil)
{	
	int i;
	fTextures.Reset();
	fElementNames.Reset();
	fElements.Reset();
	
	for (i = 0; i < 3; i++)
	{
		fDefaultTint1[i] = fDefaultTint2[i] = 255;
	}
	for (i = 0; i < kMaxNumLODLevels; i++)
		fMeshes[i] = nil;
}

plClothingItem::~plClothingItem()
{
	while (fElementNames.GetCount() > 0)
		delete [] fElementNames.Pop();

	while (fTextures.GetCount() > 0)
		delete [] fTextures.Pop();
	
	delete [] fName;
	delete [] fDescription;
	delete [] fCustomText;
	delete [] fAccessoryName;
}

hsBool plClothingItem::CanWearWith(plClothingItem *item)
{ 
	// For now, you can only wear one shirt, one pair of pants, etc.
	// Except accessories, of which you're allowed one per tileset.
	return ((item->fType != fType) || 
			(item->fType == plClothingMgr::kTypeAccessory && 
			 fType == plClothingMgr::kTypeAccessory));
			 //&& item->fTileset != fTileset));
}

hsBool plClothingItem::WearBefore(plClothingItem *item)
{
	// Accessories come last
	// Face comes first
	// Other stuff is arbitrary.

	int myPri;
	if (fType == plClothingMgr::kTypeFace)
		myPri = 0;
	else
		myPri = (fType == plClothingMgr::kTypeAccessory ? 2 : 1);

	int otherPri;
	if (item->fType == plClothingMgr::kTypeFace)
		otherPri = 0;
	else
		otherPri = (item->fType == plClothingMgr::kTypeAccessory ? 2 : 1);
	
	return myPri < otherPri;
}

hsBool plClothingItem::HasBaseAlpha()
{
	int i;
	for (i = 0; i < fElements.GetCount(); i++)
	{
		plMipmap *tex = fTextures[i][plClothingElement::kLayerBase];
//		if (tex && (tex->GetFlags() & (plMipmap::kAlphaBitFlag | plMipmap::kAlphaChannelFlag)))
		if (tex && (tex->GetFlags() & plMipmap::kAlphaChannelFlag))
			return true;
	}
	return false;
}

hsBool plClothingItem::HasSameMeshes(plClothingItem *other)
{
	int i;
	for (i = 0; i < kMaxNumLODLevels; i++)
		if (fMeshes[i] != other->fMeshes[i])
			return false;

	return true;
}

void plClothingItem::Read(hsStream *s, hsResMgr *mgr)
{
	hsKeyedObject::Read(s, mgr);

	fName = s->ReadSafeString();
	fGroup = s->ReadByte();
	fType = s->ReadByte();
	fTileset = s->ReadByte();
	fSortOrder = s->ReadByte();

	fCustomText = s->ReadSafeString();
	fDescription = s->ReadSafeString();
	if (s->ReadBool())
		mgr->ReadKeyNotifyMe(s, TRACKED_NEW plGenRefMsg(GetKey(), plRefMsg::kOnCreate, -1, -1), plRefFlags::kActiveRef); // thumbnail

	int tileCount = s->ReadSwap32();
	int i, j;
	for (i = 0; i < tileCount; i++)
	{
		fElementNames.Append(s->ReadSafeString());

		int layerCount = s->ReadByte();
		for (j = 0; j < layerCount; j++)
		{
			int layer = s->ReadByte();
			mgr->ReadKeyNotifyMe(s, TRACKED_NEW plElementRefMsg(GetKey(), plRefMsg::kOnCreate, i, -1, nil, layer), plRefFlags::kActiveRef); // texture
		}
	}

	for (i = 0; i < kMaxNumLODLevels; i++)
	{
		if (s->ReadBool())
			mgr->ReadKeyNotifyMe(s, TRACKED_NEW plGenRefMsg(GetKey(), plRefMsg::kOnCreate, i, -1), plRefFlags::kActiveRef); // shared mesh
	}

	fElements.SetCountAndZero(tileCount);
	if (plClothingMgr::GetClothingMgr())
	{
		plGenRefMsg *msg = TRACKED_NEW plGenRefMsg(plClothingMgr::GetClothingMgr()->GetKey(), plRefMsg::kOnCreate, -1, -1);
		hsgResMgr::ResMgr()->AddViaNotify(GetKey(), msg, plRefFlags::kActiveRef); 
	}
	mgr->ReadKeyNotifyMe(s, TRACKED_NEW plGenRefMsg(GetKey(), plRefMsg::kOnCreate, -1, -1), plRefFlags::kActiveRef); // forced accessory	

	for (i = 0; i < 3; i++)
	{
		fDefaultTint1[i] = s->ReadByte();
		fDefaultTint2[i] = s->ReadByte();
	}	
}

void plClothingItem::Write(hsStream *s, hsResMgr *mgr)
{
	hsKeyedObject::Write(s, mgr);
	int i, j;

	s->WriteSafeString(fName);
	s->WriteByte(fGroup);
	s->WriteByte(fType);
	s->WriteByte(fTileset);
	s->WriteByte(fSortOrder);

	s->WriteSafeString(fCustomText);
	s->WriteSafeString(fDescription);
	s->WriteBool(fThumbnail != nil);
	if (fThumbnail != nil)
		mgr->WriteKey(s, fThumbnail->GetKey());

	UInt32 texSkip = 0;
	for (i = 0; i < fTextures.GetCount(); i++)
		if (fTextures[i] == nil)
			texSkip++;

	s->WriteSwap32(fTextures.GetCount() - texSkip);
	for (i = 0; i < fTextures.GetCount(); i++)
	{
		if (fTextures[i] == nil)
			continue;

		s->WriteSafeString(fElementNames.Get(i));

		int layerCount = 0;
		for (j = 0; j < plClothingElement::kLayerMax; j++)
		{
			// Run through once to get the count of valid layers
			if (fTextures[i][j] != nil)
				layerCount++;
		}

		s->WriteByte(layerCount);
		for (j = 0; j < plClothingElement::kLayerMax; j++)
		{
			if (fTextures[i][j] != nil)
			{
				s->WriteByte(j);
				mgr->WriteKey(s, fTextures[i][j]->GetKey());
			}
		}
		
	}
	
	for (i = 0; i < kMaxNumLODLevels; i++)
	{
		s->WriteBool(fMeshes[i] != nil);
		if (fMeshes[i] != nil)
			mgr->WriteKey(s, fMeshes[i]->GetKey());
	}

	// EXPORT ONLY
	plKey accessoryKey = nil;
	if (fAccessoryName)
	{
		char strBuf[512];
		sprintf(strBuf, "CItm_%s", fAccessoryName);
		accessoryKey = plKeyFinder::Instance().StupidSearch("GlobalClothing", nil, plClothingItem::Index(), strBuf);
		if (accessoryKey == nil)
		{
			sprintf(strBuf, "Couldn't find accessory \"%s\". It won't show at runtime.", fAccessoryName);
			hsMessageBox(strBuf, GetKeyName(), hsMessageBoxNormal);
		}
	}
	mgr->WriteKey(s, accessoryKey);
	
	for (i = 0; i < 3; i++)
	{
		s->WriteByte(fDefaultTint1[i]);
		s->WriteByte(fDefaultTint2[i]);
	}
}

hsBool plClothingItem::MsgReceive(plMessage* msg)
{
	plElementRefMsg *eMsg = plElementRefMsg::ConvertNoRef(msg);
	if (eMsg)
	{
		plMipmap *tex = plMipmap::ConvertNoRef(eMsg->GetRef());
		if (tex)
		{
			if( eMsg->GetContext() & (plRefMsg::kOnCreate|plRefMsg::kOnRequest|plRefMsg::kOnReplace) )
			{
				if (fTextures.GetCount() <= eMsg->fWhich)
					fTextures.ExpandAndZero(eMsg->fWhich + 1);
				if (fElementNames.GetCount() <= eMsg->fWhich)
					fElementNames.ExpandAndZero(eMsg->fWhich + 1);
				
				if (fElementNames.Get(eMsg->fWhich) == nil)
					fElementNames.Set(eMsg->fWhich, hsStrcpy(eMsg->fElementName));
				if (fTextures.Get(eMsg->fWhich) == nil)
				{
					plMipmap **layers = TRACKED_NEW plMipmap*[plClothingElement::kLayerMax];
					int i;
					for (i = 0; i < plClothingElement::kLayerMax; i++)
						layers[i] = nil;
					fTextures.Set(eMsg->fWhich, layers);
				}

				fTextures.Get(eMsg->fWhich)[eMsg->fLayer] = tex;
			}
			else if( eMsg->GetContext() & (plRefMsg::kOnDestroy|plRefMsg::kOnRemove) )
			{
				fTextures.Get(eMsg->fWhich)[eMsg->fLayer] = nil;
			}
			return true;
		}
	}
	
	plGenRefMsg *refMsg = plGenRefMsg::ConvertNoRef(msg);
	if (refMsg)
	{
		plSharedMesh *mesh = plSharedMesh::ConvertNoRef(refMsg->GetRef());
		if (mesh)
		{
			if (refMsg->fWhich >= 0 && refMsg->fWhich < kMaxNumLODLevels)
			{
				if( refMsg->GetContext() & (plRefMsg::kOnCreate|plRefMsg::kOnRequest|plRefMsg::kOnReplace) )
					fMeshes[refMsg->fWhich] = mesh;
				else if( refMsg->GetContext() & (plRefMsg::kOnDestroy|plRefMsg::kOnRemove) )
					fMeshes[refMsg->fWhich] = nil;
			}
			return true;
		}

		plMipmap *thumbnail = plMipmap::ConvertNoRef(refMsg->GetRef());
		if (thumbnail)
		{
			if( refMsg->GetContext() & (plRefMsg::kOnCreate|plRefMsg::kOnRequest|plRefMsg::kOnReplace) )
				fThumbnail = thumbnail;
			else if( refMsg->GetContext() & (plRefMsg::kOnDestroy|plRefMsg::kOnRemove) )
				fThumbnail = nil;
			return true;
		}

		plClothingItem *accessory = plClothingItem::ConvertNoRef(refMsg->GetRef());
		if (accessory)
		{
			if( refMsg->GetContext() & (plRefMsg::kOnCreate|plRefMsg::kOnRequest|plRefMsg::kOnReplace) )
				fAccessory = accessory;
			else if( refMsg->GetContext() & (plRefMsg::kOnDestroy|plRefMsg::kOnRemove) )
				fAccessory = nil;
			return true;
		}		
	}

	return hsKeyedObject::MsgReceive(msg);
}

/////////////////////////////////////////////////////////////////////////////

hsBool plClosetItem::IsMatch(plClosetItem *other)
{
	return (fItem == other->fItem && fOptions.IsMatch(&other->fOptions));
}

/////////////////////////////////////////////////////////////////////////////

plClothingBase::plClothingBase() : fName(nil), fBaseTexture(nil), fLayoutName(nil) {}

plClothingBase::~plClothingBase()
{
	delete [] fName;
	delete [] fLayoutName;
}

void plClothingBase::Read(hsStream* s, hsResMgr* mgr)
{
	hsKeyedObject::Read(s, mgr);

	fName = s->ReadSafeString();
	if (s->ReadBool())
		mgr->ReadKeyNotifyMe(s, TRACKED_NEW plGenRefMsg(GetKey(), plRefMsg::kOnCreate, -1, -1), plRefFlags::kActiveRef);
	fLayoutName = s->ReadSafeString();
}

void plClothingBase::Write(hsStream* s, hsResMgr* mgr)
{
	hsKeyedObject::Write(s, mgr);

	s->WriteSafeString(fName);
	s->WriteBool(fBaseTexture != nil);
	if (fBaseTexture != nil)
		mgr->WriteKey(s, fBaseTexture->GetKey());
	s->WriteSafeString(fLayoutName);
}

hsBool plClothingBase::MsgReceive(plMessage* msg)
{
	plGenRefMsg *refMsg = plGenRefMsg::ConvertNoRef(msg);
	if (refMsg)
	{
		if( refMsg->GetContext() & (plRefMsg::kOnCreate|plRefMsg::kOnRequest|plRefMsg::kOnReplace) )
		{
			fBaseTexture = plMipmap::ConvertNoRef(refMsg->GetRef());
		}
		else if( refMsg->GetContext() & (plRefMsg::kOnDestroy|plRefMsg::kOnRemove) )
		{
			fBaseTexture = nil;
		}
		return true;
	}

	return hsKeyedObject::MsgReceive(msg);
}


/////////////////////////////////////////////////////////////////////////////

plClothingOutfit::plClothingOutfit() : 
	fTargetLayer(nil), fBase(nil), fGroup(0), fAvatar(nil), fSynchClients(false), fMaterial(nil), fVaultSaveEnabled(true), fMorphsInitDone(false)
{
	fSkinTint.Set(1.f, 0.84, 0.71, 1.f);
	fItems.Reset();
	int i;
	for (i = 0; i < plClothingLayout::kMaxTileset; i++)
		fDirtyItems.SetBit(i);

	for (i = 0; i < plClothingElement::kLayerSkinLast - plClothingElement::kLayerSkinFirst; i++)
		fSkinBlends[i] = 0.f;
}

plClothingOutfit::~plClothingOutfit()
{
	fItems.Reset();
	while (fOptions.GetCount() > 0)
		delete fOptions.Pop();
	plgDispatch::Dispatch()->UnRegisterForExactType(plPreResourceMsg::Index(), GetKey());
}

void plClothingOutfit::AddItem(plClothingItem *item, hsBool update /* = true */, hsBool broadcast /* = true */, hsBool netForce /* = false */)
{
	if (fItems.Find(item) != fItems.kMissingIndex)
		return;

	plClothingMsg *msg = TRACKED_NEW plClothingMsg();
	msg->AddReceiver(GetKey());
	msg->AddCommand(plClothingMsg::kAddItem);
	msg->fItemKey = item->GetKey();
	if (broadcast)
		msg->SetBCastFlag(plMessage::kNetPropagate);
	if ( netForce )
	{
		// also doesn't make much sense to not net propagate netForced messages
		msg->SetBCastFlag(plMessage::kNetPropagate);
		msg->SetBCastFlag(plMessage::kNetForce);
	}

	if (update)
		msg->AddCommand(plClothingMsg::kUpdateTexture);

	plgDispatch::MsgSend(msg);
}

void plClothingOutfit::ForceUpdate(bool retry)
{
	plClothingMsg *msg = TRACKED_NEW plClothingMsg();	
	msg->AddCommand(plClothingMsg::kUpdateTexture);
	if (retry)
		msg->AddCommand(plClothingMsg::kRetry);		// force a resend
	msg->Send(GetKey());
}

void plClothingOutfit::RemoveItem(plClothingItem *item, hsBool update /* = true */, hsBool netForce /* = false */)
{
	if (fItems.Find(item) == fItems.kMissingIndex)
		return;

	plClothingMsg *msg = TRACKED_NEW plClothingMsg();
	msg->AddReceiver(GetKey());
	msg->AddCommand(plClothingMsg::kRemoveItem);
	msg->SetBCastFlag(plMessage::kNetPropagate);
	if ( netForce )
		msg->SetBCastFlag(plMessage::kNetForce);
	msg->fItemKey = item->GetKey();
	if (update)
		msg->AddCommand(plClothingMsg::kUpdateTexture);

	plgDispatch::MsgSend(msg);
}

void plClothingOutfit::TintItem(plClothingItem *item, hsScalar red, hsScalar green, hsScalar blue,
								hsBool update /* = true */, hsBool broadcast /* = true */, hsBool netForce /* = false */,
								hsBool retry /* = true */, UInt8 layer /* = kLayerTint1 */)
{
	plClothingMsg *msg = TRACKED_NEW plClothingMsg();
	msg->AddReceiver(GetKey());
	msg->AddCommand(plClothingMsg::kTintItem);
	msg->fItemKey = item->GetKey();
	msg->fColor.Set(red, green, blue, 1.f);
	msg->fLayer = layer;
	if (broadcast)
		msg->SetBCastFlag(plMessage::kNetPropagate);
	if (netForce)
	{
		msg->SetBCastFlag(plMessage::kNetPropagate);
		msg->SetBCastFlag(plMessage::kNetForce);
	}
	if (update)
		msg->AddCommand(plClothingMsg::kUpdateTexture);
	if (retry)
		msg->AddCommand(plClothingMsg::kRetry);
	plgDispatch::MsgSend(msg);
}

void plClothingOutfit::TintSkin(hsScalar red, hsScalar green, hsScalar blue,
								hsBool update /* = true */, hsBool broadcast /* = true */)
{
	plClothingMsg *msg = TRACKED_NEW plClothingMsg();
	msg->AddReceiver(GetKey());
	msg->AddCommand(plClothingMsg::kTintSkin);
	msg->fColor.Set(red, green, blue, 1.f);
	if (broadcast)
		msg->SetBCastFlag(plMessage::kNetPropagate);
	if (update)
		msg->AddCommand(plClothingMsg::kUpdateTexture);
	
	plgDispatch::MsgSend(msg);
}

void plClothingOutfit::MorphItem(plClothingItem *item, UInt8 layer, UInt8 delta, hsScalar weight,
								 hsBool retry /* = true */)
{
	plClothingMsg *msg = TRACKED_NEW plClothingMsg();
	msg->AddReceiver(GetKey());
	msg->AddCommand(plClothingMsg::kMorphItem);
	msg->fItemKey = item->GetKey();
	msg->fLayer = layer;
	msg->fDelta = delta;
	msg->fWeight = weight;
	if (retry)
		msg->AddCommand(plClothingMsg::kRetry);
	plgDispatch::MsgSend(msg);
}

void plClothingOutfit::SetAge(hsScalar age, hsBool update /* = true */, hsBool broadcast /* = true */)
{
	SetSkinBlend(age, plClothingElement::kLayerSkinBlend1, update, broadcast);
}

void plClothingOutfit::SetSkinBlend(hsScalar blend, UInt8 layer, hsBool update /* = true */, hsBool broadcast /* = true */)
{
	plClothingMsg *msg = TRACKED_NEW plClothingMsg();
	msg->AddReceiver(GetKey());
	msg->AddCommand(plClothingMsg::kBlendSkin);
	msg->fLayer = layer;
	msg->fColor.Set(1.f, 1.f, 1.f, blend);
	if (broadcast)
		msg->SetBCastFlag(plMessage::kNetPropagate);
	if (update)
		msg->AddCommand(plClothingMsg::kUpdateTexture);
	
	plgDispatch::MsgSend(msg);
}

hsScalar plClothingOutfit::GetSkinBlend(UInt8 layer)
{
	if (layer >= plClothingElement::kLayerSkinBlend1 && layer <= plClothingElement::kLayerSkinLast)
		return fSkinBlends[layer - plClothingElement::kLayerSkinBlend1];

	return 0;
}
	
void plClothingOutfit::IAddItem(plClothingItem *item)
{
	if (item->fGroup != fGroup)
	{
		// Trying to wear clothing from the wrong group, remove the ref.
		GetKey()->Release(item->GetKey());
		return;
	}

	if (fItems.Find(item) == fItems.kMissingIndex)
	{
		// Remove any other item we have that can't be worn with this
		int i;
		for (i = fItems.GetCount() - 1; i >= 0; i--)
		{
			if (!item->CanWearWith(fItems[i]))
			{
				plClothingItem *goner = fItems[i];
				if (goner->fAccessory)
				{
					GetKey()->Release(goner->fAccessory->GetKey());
					IRemoveItem(goner->fAccessory);
				}
				GetKey()->Release(goner->GetKey());
				IRemoveItem(goner); // Can't wait for the ref message to process				
			}
		}
	
		for (i = 0; i < fItems.GetCount(); i++)
		{
			if (item->WearBefore(fItems[i]))
				break;
		}
		fItems.Insert(i, item);
		plClothingItemOptions *op = TRACKED_NEW plClothingItemOptions;
		fOptions.Insert(i, op);
		IInstanceSharedMeshes(item);
		fDirtyItems.SetBit(item->fTileset);
		
		// A bit of hackage for bare feet sound effects.
		if (item->fType == plClothingMgr::kTypeLeftFoot)
		{
			plArmatureEffectsMgr *mgr = fAvatar->GetArmatureEffects();
			plArmatureEffectFootSound *soundEffect = nil;
			int num = mgr->GetNumEffects();
			int i;

			for (i = 0; i < num; i++)
			{
				if (soundEffect = plArmatureEffectFootSound::ConvertNoRef(mgr->GetEffect(i)))
					break;
			}
			
			if (soundEffect)
			{
				if (!strcmp(item->fName, "03_MLFoot04_01") || !strcmp(item->fName, "03_FLFoot04_01"))
					soundEffect->SetFootType(plArmatureEffectFootSound::kFootTypeBare);
				else
					soundEffect->SetFootType(plArmatureEffectFootSound::kFootTypeShoe);
			}
		}
	}	
}

void plClothingOutfit::IRemoveItem(plClothingItem *item)
{
	// We may just be removing the ref...
	UInt32 index = fItems.Find(item);
	if (index != fItems.kMissingIndex)
	{
		fItems.Remove(index);
		delete fOptions.Get(index);
		fOptions.Remove(index);
		IRemoveSharedMeshes(item);
		fDirtyItems.SetBit(item->fTileset);
	}
}

hsBool plClothingOutfit::ITintItem(plClothingItem *item, hsColorRGBA color, UInt8 layer)
{
	UInt32 index = fItems.Find(item);
	if (index != fItems.kMissingIndex)
	{
		if (layer == plClothingElement::kLayerTint1)
			fOptions[index]->fTint1 = color;
		if (layer == plClothingElement::kLayerTint2)
			fOptions[index]->fTint2 = color;
		fDirtyItems.SetBit(item->fTileset);

		if (fItems[index]->fAccessory)
		{
			plClothingItem *acc = fItems[index]->fAccessory;
			UInt32 accIndex = fItems.Find(acc);
			if (accIndex != fItems.kMissingIndex)
			{
				if (layer == plClothingElement::kLayerTint1)
					fOptions[accIndex]->fTint1 = color;
				if (layer == plClothingElement::kLayerTint2)
					fOptions[accIndex]->fTint2 = color;
				fDirtyItems.SetBit(acc->fTileset);
			}				
		}
		return true;
	}
	
	return false;		
}

hsColorRGBA plClothingOutfit::GetItemTint(plClothingItem *item, UInt8 layer /* = kLayerTint1 */) const
{
	if (layer >= plClothingElement::kLayerSkinFirst &&
		layer <= plClothingElement::kLayerSkinLast)
		return fSkinTint;
	
	UInt32 index = fItems.Find(item);
	if (index != fItems.kMissingIndex)
	{
		if (layer == plClothingElement::kLayerTint1)
			return fOptions[index]->fTint1;
		if (layer == plClothingElement::kLayerTint2)
			return fOptions[index]->fTint2;
	}
	
	hsColorRGBA color;
	color.Set(1.f, 1.f, 1.f, 1.f);
	return color;
}

hsBool plClothingOutfit::IMorphItem(plClothingItem *item, UInt8 layer, UInt8 delta, hsScalar weight)
{
	UInt32 index = fItems.Find(item);
	if (index != fItems.kMissingIndex)
	{
		int i;
		for (i = 0; i < fAvatar->GetNumLOD(); i++)
		{
			if (item->fMeshes[i]->fMorphSet == nil)
				continue;

			const plSceneObject *so = fAvatar->GetClothingSO(i);
			if (!so)
				continue;

			plMorphSequence *seq = const_cast<plMorphSequence*>(plMorphSequence::ConvertNoRef(so->GetModifierByType(plMorphSequence::Index())));
			plKey meshKey = item->fMeshes[i]->GetKey();

			// Lower LOD objects don't have all the morphs, so check if this one is in range.
			if (seq && layer < seq->GetNumLayers(meshKey) && delta < seq->GetNumDeltas(layer, meshKey))
				seq->SetWeight(layer, delta, weight, meshKey);
		}
		return true;
	}
	
	return false;		
}

void plClothingOutfit::Read(hsStream* s, hsResMgr* mgr)
{
	plSynchedObject::Read(s, mgr);

	fGroup = s->ReadByte();
	mgr->ReadKeyNotifyMe(s, TRACKED_NEW plGenRefMsg(GetKey(), plRefMsg::kOnCreate, -1, -1), plRefFlags::kActiveRef); // plClothingBase	

	if (fGroup != plClothingMgr::kClothingBaseNoOptions)
	{
		mgr->ReadKeyNotifyMe(s, TRACKED_NEW plGenRefMsg(GetKey(), plRefMsg::kOnCreate, -1, -1), plRefFlags::kActiveRef); // target layer
		mgr->ReadKeyNotifyMe(s, TRACKED_NEW plGenRefMsg(GetKey(), plRefMsg::kOnCreate, -1, -1), plRefFlags::kActiveRef); // material	
	}
	plgDispatch::Dispatch()->RegisterForExactType(plPreResourceMsg::Index(), GetKey());
	//ReadItems(s, mgr, false);
}

void plClothingOutfit::Write(hsStream* s, hsResMgr* mgr)
{
	plSynchedObject::Write(s, mgr);

	s->WriteByte(fGroup);
	mgr->WriteKey(s, fBase->GetKey());
	
	if (fGroup != plClothingMgr::kClothingBaseNoOptions)
	{
		mgr->WriteKey(s, fTargetLayer->GetKey());
		mgr->WriteKey(s, fMaterial->GetKey());
	}
	//WriteItems(s, mgr);
}

void plClothingOutfit::StripAccessories()
{
	int i;
	for (i = fItems.GetCount() - 1; i >= 0; i--)
	{
		if (fItems[i]->fType == plClothingMgr::kTypeAccessory)
		{
			GetKey()->Release(fItems[i]->GetKey());
			IRemoveItem(fItems[i]);
		}
	}
}

void plClothingOutfit::IHandleMorphSDR(plStateDataRecord *sdr)
{
	plSimpleStateVariable *lodVar = sdr->FindVar(plMorphSequenceSDLMod::kStrTargetID);
	if (!lodVar)
		return;

	UInt8 lod;
	lodVar->Get(&lod);

	const plSceneObject *so = fAvatar->GetClothingSO(lod);
	if (!so)
		return;

	plMorphSequenceSDLMod *morph = const_cast<plMorphSequenceSDLMod*>(plMorphSequenceSDLMod::ConvertNoRef(so->GetModifierByType(plMorphSequenceSDLMod::Index())));
	if (morph)
		morph->SetCurrentStateFrom(sdr);
}

void plClothingOutfit::ReadFromVault()
{
	SetupMorphSDL();

	WearDefaultClothing();

	RelVaultNode * rvn;
	if (nil == (rvn = VaultGetAvatarOutfitFolderIncRef()))
		return;

	ARRAY(RelVaultNode*) nodes;
	rvn->GetChildNodesIncRef(plVault::kNodeType_SDL, 1, &nodes);	

	for (unsigned i = 0; i < nodes.Count(); ++i) {
		VaultSDLNode sdl(nodes[i]);
		if (sdl.sdlDataLen) {
			hsRAMStream ram;
			ram.Write(sdl.sdlDataLen, sdl.sdlData);
			ram.Rewind();
			
			char *	sdlRecName = nil;
			int		sdlRecVersion;
			plStateDataRecord::ReadStreamHeader(&ram, &sdlRecName, &sdlRecVersion);
			plStateDescriptor * desc = plSDLMgr::GetInstance()->FindDescriptor(sdlRecName, sdlRecVersion);
			if (desc) {
				plStateDataRecord * sdlDataRec = TRACKED_NEW plStateDataRecord(desc);
				if (sdlDataRec->Read(&ram, 0)) {
					if (!strcmp(sdlRecName, kSDLMorphSequence))
						IHandleMorphSDR(sdlDataRec);
					else
						plClothingSDLModifier::HandleSingleSDR(sdlDataRec, this);
				}
				delete sdlDataRec;				
			}
			delete [] sdlRecName;
		}
		nodes[i]->DecRef();
	}
	
	fSynchClients = true; // set true if the next synch should be bcast
	ForceUpdate(true);
	
	rvn->DecRef();
}

void plClothingOutfit::SaveCustomizations(hsBool retry /* = true */)
{
	plClothingMsg *msg = TRACKED_NEW plClothingMsg();
	msg->AddReceiver(GetKey());
	msg->AddCommand(plClothingMsg::kSaveCustomizations);
	if (retry)
		msg->AddCommand(plClothingMsg::kRetry);

	msg->Send();
}

void plClothingOutfit::WriteToVault()
{
	if (!fVaultSaveEnabled)
		return;

	RelVaultNode * rvn;
	if (nil == (rvn = VaultGetAvatarOutfitFolderIncRef()))
		return;

	ARRAY(plStateDataRecord*) SDRs;
	
	plStateDataRecord clothingSDR(kSDLClothing);
	fAvatar->GetClothingSDLMod()->PutCurrentStateIn(&clothingSDR);
	plSDStateVariable * clothesStateDesc = clothingSDR.FindSDVar(plClothingSDLModifier::kStrWardrobe);

	for (unsigned i = 0; i < clothesStateDesc->GetCount(); ++i)
		SDRs.Add(clothesStateDesc->GetStateDataRecord(i));

	plSDStateVariable * appearanceStateDesc = clothingSDR.FindSDVar(plClothingSDLModifier::kStrAppearance); // for skin tint
	SDRs.Add(appearanceStateDesc->GetStateDataRecord(0));
	
	WriteToVault(SDRs);
	rvn->DecRef();
}

void plClothingOutfit::WriteToVault(const ARRAY(plStateDataRecord*) & SDRs)
{
	// We'll hit this case when the server asks us to save state for NPCs.
	if (fAvatar->GetTarget(0) != plNetClientApp::GetInstance()->GetLocalPlayer())
		return;

	RelVaultNode * rvn;
	if (nil == (rvn = VaultGetAvatarOutfitFolderIncRef()))
		return;
		
	ARRAY(plStateDataRecord*)	morphs;

	// Gather morph SDRs	
	hsTArray<const plMorphSequence*> morphsSDRs;
	plMorphSequence::FindMorphMods(fAvatar->GetTarget(0), morphsSDRs);
	for (unsigned i = 0; i < morphsSDRs.GetCount(); ++i) {
		for (unsigned j = 0; j < fAvatar->GetNumLOD(); j++) {
			if (fAvatar->GetClothingSO(j) == morphsSDRs[i]->GetTarget(0)) {
				plStateDataRecord * morphSDR = TRACKED_NEW plStateDataRecord(kSDLMorphSequence);
				plSimpleStateVariable * lodVar = morphSDR->FindVar(plMorphSequenceSDLMod::kStrTargetID);
				if (lodVar)
					lodVar->Set((int)j);

				morphsSDRs[i]->GetSDLMod()->PutCurrentStateIn(morphSDR);
				morphs.Add(morphSDR);
			}
		}
	}
	
	ARRAY(RelVaultNode*) templates;
	ARRAY(RelVaultNode*) actuals;
	ARRAY(RelVaultNode*) nodes;

	// Get all existing clothing SDRs
	rvn->GetChildNodesIncRef(plVault::kNodeType_SDL, 1, &nodes);	// REF: Find

	const ARRAY(plStateDataRecord*) * arrs[] = {
		&SDRs,
		&morphs,
	};
	for (unsigned arrIdx = 0; arrIdx < arrsize(arrs); ++arrIdx) {
		const ARRAY(plStateDataRecord*) * arr = arrs[arrIdx];
		
		// Write all SDL to to the outfit folder, reusing existing nodes and creating new ones as necessary
		for (unsigned i = 0; i < arr->Count(); ++i) {
			RelVaultNode * node;
			if (nodes.Count()) {
				node = nodes[0];
				nodes.DeleteUnordered(0);
				node->IncRef();	// REF: Work
				node->DecRef();	// REF: Find
			}
			else {
				RelVaultNode * templateNode = NEWZERO(RelVaultNode);
				templateNode->SetNodeType(plVault::kNodeType_SDL);
				templates.Add(templateNode);
				node = templateNode;
				node->IncRef();	// REF: Create
				node->IncRef();	// REF: Work
			}

			VaultSDLNode sdl(node);
			sdl.SetStateDataRecord((*arr)[i], 0);
			node->DecRef();		// REF: Work
		}
	}
		
	// Delete any leftover nodes
	{ for (unsigned i = 0; i < nodes.Count(); ++i) {
		VaultDeleteNode(nodes[i]->nodeId);
		nodes[i]->DecRef();	// REF: Array
	}}
	
	// Create actual new nodes from their templates
	{ for (unsigned i = 0; i < templates.Count(); ++i) {
		ENetError result;
		if (RelVaultNode * actual = VaultCreateNodeAndWaitIncRef(templates[i], &result)) {
			actuals.Add(actual);
		}
		templates[i]->DecRef();	// REF: Create
	}}

	// Add new nodes to outfit folder
	{ for (unsigned i = 0; i < actuals.Count(); ++i) {
		VaultAddChildNodeAndWait(rvn->nodeId, actuals[i]->nodeId, NetCommGetPlayer()->playerInt);
		actuals[i]->DecRef();	// REF: Create
	}}

	// Cleanup morph SDRs
	{for (unsigned i = 0; i < morphs.Count(); ++i) {
		DEL(morphs[i]);
	}}
	
	rvn->DecRef();
}

// XXX HACK. DON'T USE (this function exists for the temp console command Clothing.SwapClothTexHACK)
void plClothingOutfit::DirtyTileset(int tileset)
{
	fDirtyItems.SetBit(tileset);
	ForceUpdate(true);
}

void plClothingOutfit::IUpdate()
{
	//GenerateTexture();
	fAvatar->RefreshTree();
	DirtySynchState(kSDLClothing, 0);
	
	plArmatureMod * avMod = plAvatarMgr::GetInstance()->GetLocalAvatar();
	hsAssert(avMod,"plArmatureMod not found for local player");
	if (avMod->GetClothingOutfit()==this)
	{
		// Let the GUI know we changed clothes
		plClothingUpdateBCMsg *BCMsg = TRACKED_NEW plClothingUpdateBCMsg();
		BCMsg->SetSender(GetKey());
		plgDispatch::MsgSend(BCMsg);
	}
}

void plClothingOutfit::WearDefaultClothing()
{
	StripAccessories();
	
	plClothingMgr *cMgr = plClothingMgr::GetClothingMgr();
	hsTArray<plClothingItem *>items;
	cMgr->GetItemsByGroup(fGroup, items);

	// Wear one thing of each type
	UInt32 i, j;
	for (i = 0; i < plClothingMgr::kMaxType; i++)
	{
		if (i == plClothingMgr::kTypeAccessory)
			continue;

		for (j = 0; j < items.GetCount(); j++)
		{
			if (items[j]->fType == i)
			{
				AddItem(items[j], false, false);
				if (i == plClothingMgr::kTypeHair || i == plClothingMgr::kTypeFace)
				{	
					// Hair tint color
					TintItem(items[j], 0.5, 0.3, 0.2, false, false);
				}
				else
				{
					TintItem(items[j], items[j]->fDefaultTint1[0] / 255.f, items[j]->fDefaultTint1[1] / 255.f,
							 items[j]->fDefaultTint1[2] / 255.f, false, false);
				}

				// Everyone can tint layer 2. Go nuts!
				TintItem(items[j], items[j]->fDefaultTint2[0] / 255.f, items[j]->fDefaultTint2[1] / 255.f,
						 items[j]->fDefaultTint2[2] / 255.f, false, false, false, true, plClothingElement::kLayerTint2);					
				break;
			}
		}
	}
}

void plClothingOutfit::WearDefaultClothingType(UInt32 clothingType)
{
	plClothingMgr *cMgr = plClothingMgr::GetClothingMgr();
	hsTArray<plClothingItem *> items;
	cMgr->GetItemsByGroup(fGroup, items);

	UInt32 i;
	for (i=0; i<items.GetCount(); i++)
	{
		if (items[i]->fType == clothingType)
		{
			AddItem(items[i], false, false);
			if (clothingType == plClothingMgr::kTypeHair || clothingType == plClothingMgr::kTypeFace)
			{
				// Hair tint color
				TintItem(items[i], 0.5, 0.3, 0.2, false, false);
			}
			else
			{
				TintItem(items[i], items[i]->fDefaultTint1[0] / 255.f, items[i]->fDefaultTint1[1] / 255.f,
						 items[i]->fDefaultTint1[2] / 255.f, false, false);
			}

			// Everyone can tint layer 2. Go nuts!
			TintItem(items[i], items[i]->fDefaultTint2[0] / 255.f, items[i]->fDefaultTint2[1] / 255.f,
					 items[i]->fDefaultTint2[2] / 255.f, false, false, false, true, plClothingElement::kLayerTint2);
			break;
		}
	}
}

void plClothingOutfit::WearMaintainerOutfit()
{
	fVaultSaveEnabled = false;

	WearDefaultClothing();
	plClothingItem *item;
	
	if (fGroup == plClothingMgr::kClothingBaseMale)
	{
		item = plClothingMgr::GetClothingMgr()->FindItemByName("03_MHAcc_SuitHelmet");
		if (item)
			AddItem(item, false, false);
		item = plClothingMgr::GetClothingMgr()->FindItemByName("03_MLHand_Suit");
		if (item)
			AddItem(item, false, false);
		item = plClothingMgr::GetClothingMgr()->FindItemByName("03_MRHand_Suit");
		if (item)
			AddItem(item, false, false);
		item = plClothingMgr::GetClothingMgr()->FindItemByName("03_MTorso_Suit");
		if (item)
			AddItem(item, false, false);
		item = plClothingMgr::GetClothingMgr()->FindItemByName("03_MLegs_Suit");
		if (item)
			AddItem(item, false, false);
		item = plClothingMgr::GetClothingMgr()->FindItemByName("03_MLFoot_Suit");
		if (item)
			AddItem(item, false, false);
		item = plClothingMgr::GetClothingMgr()->FindItemByName("03_MRFoot_Suit");
		if (item)
			AddItem(item, false, false);
	}
	else if (fGroup == plClothingMgr::kClothingBaseFemale)
	{
		item = plClothingMgr::GetClothingMgr()->FindItemByName("03_FHair_SuitHelmet");
		if (item)
			AddItem(item, false, false);
		item = plClothingMgr::GetClothingMgr()->FindItemByName("03_FLHand_Suit");
		if (item)
			AddItem(item, false, false);
		item = plClothingMgr::GetClothingMgr()->FindItemByName("03_FRHand_Suit");
		if (item)
			AddItem(item, false, false);
		item = plClothingMgr::GetClothingMgr()->FindItemByName("03_FTorso_Suit");
		if (item)
			AddItem(item, false, false);
		item = plClothingMgr::GetClothingMgr()->FindItemByName("03_FLegs_Suit");
		if (item)
			AddItem(item, false, false);
		item = plClothingMgr::GetClothingMgr()->FindItemByName("03_FLFoot_Suit");
		if (item)
			AddItem(item, false, false);
		item = plClothingMgr::GetClothingMgr()->FindItemByName("03_FRFoot_Suit");
		if (item)
			AddItem(item, false, false);
	}
	
	fSynchClients = true;
	ForceUpdate(true);
}

void plClothingOutfit::RemoveMaintainerOutfit()
{
	ReadFromVault();

	fVaultSaveEnabled = true;
}

static plRandom sRandom;

void plClothingOutfit::WearRandomOutfit()
{
	plClothingMgr *cMgr = plClothingMgr::GetClothingMgr();
	hsTArray<plClothingItem *>items;

	// Wear one thing of each type
	UInt32 i, j;
	for (i = 0; i < plClothingMgr::kMaxType; i++)
	{
		if (i == plClothingMgr::kTypeAccessory)
			continue;

		items.Reset();
		cMgr->GetItemsByGroupAndType(fGroup, (UInt8)i, items);
		j = (UInt32)(sRandom.RandZeroToOne() * items.GetCount());

		hsScalar r1 = sRandom.RandZeroToOne();
		hsScalar g1 = sRandom.RandZeroToOne();
		hsScalar b1 = sRandom.RandZeroToOne();
		hsScalar r2 = sRandom.RandZeroToOne();
		hsScalar g2 = sRandom.RandZeroToOne();
		hsScalar b2 = sRandom.RandZeroToOne();

		AddItem(items[j], false, false);
		TintItem(items[j], r1, g1, b1, false, false, false, true, 1);
		TintItem(items[j], r2, g2, b2, false, false, false, true, 2);

		plClothingItem *match = cMgr->GetLRMatch(items[j]);
		if (match)
		{
			AddItem(match, false, false);
			TintItem(match, r1, g1, b1, false, false, false, true, 1);
			TintItem(match, r2, g2, b2, false, false, false, true, 2);
		}
	}
	TintSkin(sRandom.RandZeroToOne(), sRandom.RandZeroToOne(), sRandom.RandZeroToOne());
}

hsBool plClothingOutfit::ReadItems(hsStream* s, hsResMgr* mgr, hsBool broadcast /* = true */)
{
	hsBool result = true;
	UInt32 numItems = s->ReadSwap32();
	int i;
	for (i = 0; i < numItems; i++)
	{
		plKey key = mgr->ReadKey( s );
		hsColorRGBA color;
		hsColorRGBA color2;
		color.Read(s);
		color2.Read(s);
		
		// Make sure to read everything in before hitting this and possibly skipping to
		// the next item, lest we disrupt the stream.
		if( key == nil )
		{
			hsAssert( false, "Nil item in plClothingOutfit::ReadItems(). The vault probably contains a key with a plLocation that's moved since then. Tsk, tsk." );
			result = false;
			continue;
		}

		plClothingItem *item = plClothingItem::ConvertNoRef( key->GetObjectPtr() );
		AddItem(item, false, broadcast); 
		TintItem(item, color.r, color.g, color.b, false, broadcast, false, true, plClothingElement::kLayerTint1);
		TintItem(item, color2.r, color2.g, color2.b, false, broadcast, false, true, plClothingElement::kLayerTint2);
	}

	return result;
}

void plClothingOutfit::WriteItems(hsStream *s, hsResMgr *mgr)
{
	s->WriteSwap32(fItems.GetCount());
	int i;
	for (i = 0; i < fItems.GetCount(); i++)
	{
		mgr->WriteKey(s, fItems.Get(i)->GetKey());
		fOptions.Get(i)->fTint1.Write(s);
		fOptions.Get(i)->fTint2.Write(s);
	}
}

hsBool plClothingOutfit::MsgReceive(plMessage* msg)
{
	plPreResourceMsg *preMsg = plPreResourceMsg::ConvertNoRef(msg);
	if (preMsg)
	{
		if (fAvatar && fGroup != plClothingMgr::kClothingBaseNoOptions)
		{
			plDrawable *spans = fAvatar->FindDrawable();
			const hsBounds3Ext &bnds = spans->GetWorldBounds();
			if (bnds.GetType() == kBoundsNormal)
			{
				// This is a bit hacky... The drawable code has just run through and updated
				// each span's bounds (see plDrawableSpans::IUpdateMatrixPaletteBoundsHack())
				// but not the world bounds for the entire drawable. So we tell the space tree
				// to refresh. However, the pageTreeMgr would then get confused because the
				// space tree is no longer dirty (see plPageTreeMgr::IRefreshTree()), 
				// causing the avatar to only draw if the origin is in view. 
				// So we just force it dirty, and everyone's happy.
				spans->GetSpaceTree()->Refresh();
				spans->GetSpaceTree()->MakeDirty();

				// Where were we? Oh yeah... if this avatar is in view it needs a texture. Tell
				// the pipeline.
				if (preMsg->Pipeline()->TestVisibleWorld(spans->GetSpaceTree()->GetWorldBounds()))
					preMsg->Pipeline()->SubmitClothingOutfit(this);				
			}
		}
	}
 
	plGenRefMsg *refMsg = plGenRefMsg::ConvertNoRef(msg);
	if (refMsg)
	{
		plLayer *layer = plLayer::ConvertNoRef(refMsg->GetRef());
		if (layer)
		{
			if (refMsg->GetContext() & (plRefMsg::kOnCreate|plRefMsg::kOnRequest|plRefMsg::kOnReplace) )
				fTargetLayer = layer;
			else if( refMsg->GetContext() & (plRefMsg::kOnDestroy|plRefMsg::kOnRemove) )
				fTargetLayer = nil;
			
			return true;
		}
		plClothingItem *item = plClothingItem::ConvertNoRef(refMsg->GetRef());
		if (item)
		{
			if( refMsg->GetContext() & (plRefMsg::kOnCreate|plRefMsg::kOnRequest) )
			{
				IAddItem(item);
			}
			else if( refMsg->GetContext() & (plRefMsg::kOnDestroy|plRefMsg::kOnRemove) )
			{
				IRemoveItem(item);
			}
			return true;
		}
		plClothingBase *base = plClothingBase::ConvertNoRef(refMsg->GetRef());
		if (base)
		{
			if( refMsg->GetContext() & (plRefMsg::kOnCreate|plRefMsg::kOnRequest|plRefMsg::kOnReplace) )
				fBase = base;
			else if( refMsg->GetContext() & (plRefMsg::kOnDestroy|plRefMsg::kOnRemove) )
				fBase = nil;
			
			return true;		
		}
		
		hsGMaterial *mat = hsGMaterial::ConvertNoRef(refMsg->GetRef());
		if (mat)
		{
			if( refMsg->GetContext() & (plRefMsg::kOnCreate|plRefMsg::kOnRequest|plRefMsg::kOnReplace) )
				fMaterial = mat;
			else if( refMsg->GetContext() & (plRefMsg::kOnDestroy|plRefMsg::kOnRemove) )
				fMaterial = nil;
		}
	}

	// For now: Adding an item fires off a notify, and the item won't get added until the ref message
	// is processed, BUT we need to make sure that task doesn't require any more messages (like the
	// trickling of chains of AddViaNotifies), so that other messages received after it (like tint
	// commands) just have to check a kRetry flag, resend the message, and be confident that the item
	// will be present by the time their resent message is handled.
	// 
	// Should we ever handle AddViaNotify in a separate thread, this will blow up. (Ok, we'll just have
	// bugs about the characters not having the right clothings options visible. No explosions.)

	plClothingMsg *cMsg = plClothingMsg::ConvertNoRef(msg);
	if (cMsg)
	{
		if (cMsg->GetCommand(plClothingMsg::kAddItem))
		{
			plGenRefMsg *msg = TRACKED_NEW plGenRefMsg(GetKey(), plRefMsg::kOnCreate, -1, -1);
			hsgResMgr::ResMgr()->AddViaNotify(cMsg->fItemKey, msg, plRefFlags::kActiveRef);
			plClothingItem *accessory = plClothingItem::ConvertNoRef(cMsg->fItemKey->GetObjectPtr())->fAccessory;
			if (accessory)
			{
				plGenRefMsg *msg = TRACKED_NEW plGenRefMsg(GetKey(), plRefMsg::kOnCreate, -1, -1);
				hsgResMgr::ResMgr()->AddViaNotify(accessory->GetKey(), msg, plRefFlags::kActiveRef);
			}				
		}
		if (cMsg->GetCommand(plClothingMsg::kRemoveItem))
		{
			plClothingItem *item = plClothingItem::ConvertNoRef(cMsg->fItemKey->GetObjectPtr());
			if (item && item->fType == plClothingMgr::kTypeAccessory)
				GetKey()->Release(cMsg->fItemKey);
		}
		if (cMsg->GetCommand(plClothingMsg::kTintItem))
		{	
			if (!ITintItem(plClothingItem::ConvertNoRef(cMsg->fItemKey->GetObjectPtr()), cMsg->fColor, cMsg->fLayer) &&
				cMsg->GetCommand(plClothingMsg::kRetry))
			{
				// We failed to tint because we're not yet wearing the item.
				// However, the kRetry flag is set, so we fire another tint command off

				TintItem(plClothingItem::ConvertNoRef(cMsg->fItemKey->GetObjectPtr()), 
						 cMsg->fColor.r, cMsg->fColor.g, cMsg->fColor.b,
						 cMsg->GetCommand(plClothingMsg::kUpdateTexture), false, false, false, cMsg->fLayer);
				return true;
			}
		}
		if (cMsg->GetCommand(plClothingMsg::kMorphItem))
		{
			if (cMsg->GetCommand(plClothingMsg::kRetry))
				MorphItem(plClothingItem::ConvertNoRef(cMsg->fItemKey->GetObjectPtr()), cMsg->fLayer, cMsg->fDelta, cMsg->fWeight, false);
			else
				IMorphItem(plClothingItem::ConvertNoRef(cMsg->fItemKey->GetObjectPtr()), cMsg->fLayer, cMsg->fDelta, cMsg->fWeight);
		}

		if (cMsg->GetCommand(plClothingMsg::kTintSkin))
		{
			fSkinTint = cMsg->fColor;
			int i, j;
			for (i = 0; i < fItems.GetCount(); i++)
				for (j = 0; j < fItems[i]->fElements.GetCount(); j++)
					if (fItems[i]->fTextures[j][plClothingElement::kLayerSkin] != nil)
						fDirtyItems.SetBit(fItems[i]->fTileset);
		}

		if (cMsg->GetCommand(plClothingMsg::kBlendSkin))
		{
			hsScalar blend = cMsg->fColor.a;
			if (blend > 1.f)
				blend = 1.f;
			if (blend < 0.f)
				blend = 0.f;
			if (cMsg->fLayer >= plClothingElement::kLayerSkinBlend1 &&
				cMsg->fLayer <= plClothingElement::kLayerSkinBlend6)
			{
				fSkinBlends[cMsg->fLayer - plClothingElement::kLayerSkinBlend1] = blend;
			
				int i, j;
				for (i = 0; i < fItems.GetCount(); i++)
					for (j = 0; j < fItems[i]->fElements.GetCount(); j++)
						if (fItems[i]->fTextures[j][cMsg->fLayer] != nil)
							fDirtyItems.SetBit(fItems[i]->fTileset);
			}
		}
		if (cMsg->GetCommand(plClothingMsg::kSaveCustomizations))
		{
			if (cMsg->GetCommand(plClothingMsg::kRetry))
				SaveCustomizations(false);
			else
				WriteToVault();
		}

		// Make sure to check for an update last
		if (cMsg->GetCommand(plClothingMsg::kUpdateTexture))
		{
			// If kUpdateTexture was not the only command, we need to resend the update
			// as a solo command, so that it happens after any other AddViaNotify messages
			if (cMsg->ResendUpdate())
			{
				plClothingMsg *update = TRACKED_NEW plClothingMsg();
				update->AddReceiver(GetKey());
				update->AddCommand(plClothingMsg::kUpdateTexture);
				plgDispatch::MsgSend(update);
			}
			else
				IUpdate();
		}
		return true;
	}

	return hsKeyedObject::MsgReceive(msg);
}

//
// TESTING SDL
// Send clothing sendState msg to object's plClothingSDLModifier
//
hsBool plClothingOutfit::DirtySynchState(const char* SDLStateName, UInt32 synchFlags)
{
	plSynchEnabler ps(true);	// make sure synching is enabled, since this happens during load
	synchFlags |= plSynchedObject::kForceFullSend;	// TEMP
	if (fSynchClients)
		synchFlags |= plSynchedObject::kBCastToClients;
	fSynchClients=false;
	hsAssert(fAvatar, "nil fAvatar");
	return fAvatar->GetTarget(0)->DirtySynchState(SDLStateName, synchFlags);
}

// Note: Currently the word "instance" is a lie. We just copy. In the future
// we'll be good about this, but I wanted to get it working first.
void plClothingOutfit::IInstanceSharedMeshes(plClothingItem *item)
{
	if (fAvatar)
		fAvatar->ValidateMesh();

	hsBool partialSort = item->fCustomText && strstr(item->fCustomText, "NeedsSort");
	int i;
	for (i = 0; i < plClothingItem::kMaxNumLODLevels; i++)
	{
		const plSceneObject *so = fAvatar->GetClothingSO(i);
		if (so != nil && item->fMeshes[i] != nil)
		{
			plInstanceDrawInterface *idi = const_cast<plInstanceDrawInterface*>(plInstanceDrawInterface::ConvertNoRef(so->GetDrawInterface()));
			if (idi)
				idi->AddSharedMesh(item->fMeshes[i], fMaterial, !item->HasBaseAlpha(), i, partialSort);
		}
	}
}

void plClothingOutfit::IRemoveSharedMeshes(plClothingItem *item)
{	
	if (fAvatar == nil)
		return;

	int i;
	for (i = 0; i < plClothingItem::kMaxNumLODLevels; i++)
	{
		const plSceneObject *so = fAvatar->GetClothingSO(i);
		if (so != nil && item->fMeshes[i] != nil)
		{
			plInstanceDrawInterface *idi = const_cast<plInstanceDrawInterface*>(plInstanceDrawInterface::ConvertNoRef(so->GetDrawInterface()));
			if (idi)
				idi->RemoveSharedMesh(item->fMeshes[i]);			
		}
	}
}

void plClothingOutfit::SetupMorphSDL()
{
	if (!fMorphsInitDone)
	{
		hsTArray<const plMorphSequence*> morphs;
		plMorphSequence::FindMorphMods(fAvatar->GetTarget(0), morphs);
		for (unsigned i = 0; i < morphs.GetCount(); ++i)
		{
			for (unsigned j = 0; j < fAvatar->GetNumLOD(); j++)
			{
				if (fAvatar->GetClothingSO(j) == morphs[i]->GetTarget(0))
				{
					plMorphSequenceSDLMod* morph = morphs[i]->GetSDLMod();
					if (morph)
						morph->SetIsAvatar(true);
				}
			}
		}

		fMorphsInitDone = true;
	}
}


/////////////////////////////////////////////////////////////////////////////

const char *plClothingMgr::GroupStrings[] = 
{
	"Male Clothing",
	"Female Clothing",
	"(No Clothing Options)"
};

const char *plClothingMgr::TypeStrings[] =
{
	"Pants",
	"Shirt",
	"LeftHand",
	"RightHand",
	"Face",
	"Hair",
	"LeftFoot",
	"RightFoot",
	"Accessory"
};

plClothingMgr *plClothingMgr::fInstance = nil;

plClothingMgr::plClothingMgr()
{
	fLayouts.Reset();
	fItems.Reset();
}

plClothingMgr::~plClothingMgr()
{
	while (fElements.GetCount() > 0)
		delete fElements.Pop();
	while (fLayouts.GetCount() > 0)
		delete fLayouts.Pop();
	while (fItems.GetCount() > 0)
		delete fItems.Pop();
}

plClothingLayout *plClothingMgr::GetLayout(char *name)
{
	int i;
	for (i = 0; i < fLayouts.GetCount(); i++)
	{
		if (!strcmp(fLayouts.Get(i)->fName, name))
			return fLayouts.Get(i);
	}
	return nil;
}

plClothingElement *plClothingMgr::FindElementByName(char *name)
{
	int i;
	for (i = 0; i < fElements.GetCount(); i++)
	{
		if (!strcmp(fElements.Get(i)->fName, name))
			return fElements.Get(i);
	}
	return nil;	
}

void plClothingMgr::AddItemsToCloset(hsTArray<plClosetItem> &items)
{
	RelVaultNode * rvn = VaultGetAvatarClosetFolderIncRef();
	if (!rvn)
		return;
		
	hsTArray<plClosetItem> closet;
	GetClosetItems(closet);
	
	ARRAY(RelVaultNode*)	templates;
	
	for (unsigned i = 0; i < items.GetCount(); ++i) {
		bool match = false;
		for (unsigned j = 0; j < closet.GetCount(); ++j) {
			if (closet[j].IsMatch(&items[i]))
			{
				match = true;
				break;
			}
		}
		
		if (match)
			continue;

		plStateDataRecord rec(plClothingSDLModifier::GetClothingItemSDRName());
		plClothingSDLModifier::PutSingleItemIntoSDR(&items[i], &rec);
		
		RelVaultNode * templateNode = NEWZERO(RelVaultNode);
		templateNode->IncRef();
		templateNode->SetNodeType(plVault::kNodeType_SDL);
		
		VaultSDLNode sdl(templateNode);
		sdl.SetStateDataRecord(&rec);

		templates.Add(templateNode);
	}
	
	for (unsigned i = 0; i < templates.Count(); ++i) {
		ENetError result;
		if (RelVaultNode * actual = VaultCreateNodeAndWaitIncRef(templates[i], &result)) {
			VaultAddChildNodeAndWait(
				rvn->nodeId,
				actual->nodeId,
				NetCommGetPlayer()->playerInt
			);
			actual->DecRef(); // REF: Create
		}
		templates[i]->DecRef(); // REF: Create
	}
	
	rvn->DecRef();
}

void plClothingMgr::GetClosetItems(hsTArray<plClosetItem> &out)
{
	RelVaultNode * rvn = VaultGetAvatarClosetFolderIncRef();
	if (!rvn)
		return;

	ARRAY(RelVaultNode*)	nodes;
	rvn->GetChildNodesIncRef(plVault::kNodeType_SDL, 1, &nodes);
	out.SetCount(nodes.Count());
	
	for (unsigned i = 0; i < nodes.Count(); ++i) {
		VaultSDLNode sdl(nodes[i]);
		plStateDataRecord * rec = NEWZERO(plStateDataRecord);
		if (sdl.GetStateDataRecord(rec, 0))
			plClothingSDLModifier::HandleSingleSDR(rec, nil, &out[i]);
		DEL(rec);
	}

	if (out.GetCount()) {
		for (int i = out.GetCount() - 1; i >= 0; i--) {
			if (out[i].fItem == nil)
				out.Remove(i);
		}
	}
	
	rvn->DecRef();
}	

void plClothingMgr::GetAllWithSameMesh(plClothingItem *item, hsTArray<plClothingItem*> &out)
{
	int i;
	for (i = 0; i < fItems.GetCount(); i++)
	{
		if (item->HasSameMeshes(fItems[i]))
			out.Append(fItems[i]);
	}
}

// Yes, it's a lame n^2 function. Show me that we have enough items for it
// to matter and I'll speed it up.
void plClothingMgr::FilterUniqueMeshes(hsTArray<plClothingItem*> &items)
{
	int i, j;
	for (i = items.GetCount() - 1; i >= 1; i--)
	{
		for (j = i - 1; j >= 0; j--)
		{
			if (items[i]->HasSameMeshes(items[j]))
			{
				items.Remove(i);
				break;
			}
		}
	}
}

plClothingItem *plClothingMgr::FindItemByName(const char *name)
{
	if (!name)
		return nil;
	
	int i;
	for (i = 0; i < fItems.GetCount(); i++)
	{
		plClothingItem* item = fItems.Get(i);
		if (!strcmp(item->fName, name))
			return item;
	}
	return nil;
}

void plClothingMgr::GetItemsByGroup(UInt8 group, hsTArray<plClothingItem*> &out)
{
	int i;
	for (i = 0; i < fItems.GetCount(); i++)
	{
		if (fItems.Get(i)->fGroup == group)
			out.Append(fItems.Get(i));
	}
}

void plClothingMgr::GetItemsByGroupAndType(UInt8 group, UInt8 type, hsTArray<plClothingItem*> &out)
{
	int i;
	for (i = 0; i < fItems.GetCount(); i++)
	{
		if (fItems.Get(i)->fGroup == group && fItems.Get(i)->fType == type)
			out.Append(fItems.Get(i));
	}
}

plClothingItem *plClothingMgr::GetLRMatch(plClothingItem *item)
{
	int i;
	for (i = 0; i < fItems.GetCount(); i++)
	{
		if (IsLRMatch(item, fItems[i]))
			return fItems[i];
	}

	// Couldn't find one.
	return nil;
}

hsBool plClothingMgr::IsLRMatch(plClothingItem *item1, plClothingItem *item2)
{
	if (!item1 || !item2)
		return false;

	switch (item1->fType)
	{
	case kTypeLeftHand:
		if (item2->fType != kTypeRightHand) return false;
		break;
	case kTypeRightHand:
		if (item2->fType != kTypeLeftHand) return false;
		break;
	case kTypeLeftFoot:
		if (item2->fType != kTypeRightFoot) return false;
		break;
	case kTypeRightFoot:
		if (item2->fType != kTypeLeftFoot) return false;
		break;
	default:
		// if its not a matching kinda item, then there can be no match
		return false;
	}

	// Types check out fine, now compare textures
	if (item1->fTextures.GetCount() != item2->fTextures.GetCount()) return false;

	int i, j;
	for (i = 0; i < item1->fTextures.GetCount(); i++)
	{
		for (j = 0; j < plClothingElement::kLayerMax; j++)
			if (item1->fTextures[i][j] != item2->fTextures[i][j])
				return false;
	}

	// Finally... we're not our own match
	return item1 != item2;
}

void plClothingMgr::Init()
{
	fInstance = TRACKED_NEW plClothingMgr;
	fInstance->RegisterAs(kClothingMgr_KEY);
	fInstance->IInit();
}

void plClothingMgr::IInit()
{
	plClothingElement::GetElements(fElements);
	plClothingLayout *layout = TRACKED_NEW plClothingLayout("BasicHuman", 1024);
	layout->fElements.Append(FindElementByName("shirt-chest"));
	layout->fElements.Append(FindElementByName("shirt-sleeve"));
	layout->fElements.Append(FindElementByName("face"));
	layout->fElements.Append(FindElementByName("eyeball"));
	layout->fElements.Append(FindElementByName("shoe-top"));
	layout->fElements.Append(FindElementByName("shoe-bottom"));
	layout->fElements.Append(FindElementByName("pants"));
	layout->fElements.Append(FindElementByName("hand-LOD"));
	layout->fElements.Append(FindElementByName("hand-square"));
	layout->fElements.Append(FindElementByName("hand-wide"));
	
	fLayouts.Append(layout);
}

void plClothingMgr::DeInit()
{
	if (fInstance)
	{
		fInstance->UnRegisterAs(kClothingMgr_KEY);
		fInstance = nil;
	}
}	

hsBool plClothingMgr::MsgReceive(plMessage* msg)
{
	plGenRefMsg *refMsg = plGenRefMsg::ConvertNoRef(msg);
	if (refMsg)
	{
		plClothingItem *item = plClothingItem::ConvertNoRef(refMsg->GetRef());
		if (item)
		{
			if( refMsg->GetContext() & (plRefMsg::kOnCreate) )
			{
				IAddItem(item);
			}
			else if( refMsg->GetContext() & (plRefMsg::kOnDestroy|plRefMsg::kOnRemove) )
			{
				fItems.RemoveItem(item);
			}
			return true;
		}
	}

	return hsKeyedObject::MsgReceive(msg);
}

void plClothingMgr::IAddItem(plClothingItem *item)
{
	hsBool allFound = true;
	int i, j;
	for (i = 0; i < item->fElementNames.GetCount(); i++)
	{
		for (j = 0; j < fElements.GetCount(); j++)
		{	
			if (!strcmp(item->fElementNames.Get(i), fElements.Get(j)->fName))
			{
				item->fElements.Set(i, fElements.Get(j));
				break;
			}
		}
		if (j >= fElements.GetCount())
		{
			allFound = false;
			break;
		}
	}

	if (allFound)
	{
		for (i = 0; i < fItems.GetCount(); i++)
		{
			if (fItems[i]->fSortOrder >= item->fSortOrder)
				break;
		}
		fItems.InsertAtIndex(i, item);
	}
	else
		hsAssert(false, "Couldn't match all elements of added clothing item.");
}

void plClothingMgr::ChangeAvatar(char *name)
{
	plAvatarMgr::GetInstance()->UnLoadLocalPlayer();
	plAvatarMgr::GetInstance()->LoadPlayer(name, nil);
}