CWE-ou-minkata/MOULOpenSourceClientPlugin/Plasma20/Sources/Plasma/PubUtilLib/plDrawable/plProxyGen.cpp

/*==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 "plProxyGen.h"

#include "../plSurface/hsGMaterial.h"
#include "../plSurface/plLayer.h"
#include "../plDrawable/plDrawableSpans.h"
#include "../plDrawable/plDrawableGenerator.h"
#include "../pnMessage/plProxyDrawMsg.h"
#include "../pnKeyedObject/plKey.h"
#include "../pnMessage/plRefMsg.h"
#include "../pnMessage/plNodeRefMsg.h"
#include "plgDispatch.h"
#include "hsResMgr.h"

static hsTArray<plDrawableSpans*>	fProxyDrawables;
static hsTArray<hsGMaterial*>	fProxyMaterials;
static UInt32					fProxyKeyCounter = 0;

plProxyGen::plProxyGen(const hsColorRGBA& amb, const hsColorRGBA& dif, hsScalar opac)
:	fProxyMsgType(0),
	fProxyDraw(nil),
	fProxyMat(nil)
{
	fAmbient = amb;
	fColor = dif;
	fAmbient.a = opac;
}

plProxyGen::~plProxyGen()
{
	if( fProxyDraw )
		GetKey()->Release(fProxyDraw->GetKey());
	if( fProxyMat )
		GetKey()->Release(fProxyMat->GetKey());
}

void plProxyGen::Init(const hsKeyedObject* owner)
{
	if( !GetKey() )
	{
		char buff[256];
		plLocation loc;
		if( owner->GetKey() )
		{
			sprintf(buff, "%s_%s_%d_%d", owner->GetKey()->GetName(), "ProxyGen", owner->GetKey()->GetUoid().GetClonePlayerID(), fProxyKeyCounter++);
			loc = owner->GetKey()->GetUoid().GetLocation();
		}
		else
		{
			sprintf( buff, "ProxyGen%d", fProxyKeyCounter++ );
			loc = plLocation::kGlobalFixedLoc;
		}

		hsgResMgr::ResMgr()->NewKey( buff, this, loc );

		plgDispatch::Dispatch()->RegisterForExactType(plProxyDrawMsg::Index(), GetKey());
	}

}

UInt32 plProxyGen::IGetDrawableType() const
{
	switch( fProxyMsgType & plProxyDrawMsg::kAllTypes )
	{
	case plProxyDrawMsg::kLight:
		return plDrawable::kLightProxy;
	case plProxyDrawMsg::kPhysical:
		return plDrawable::kPhysicalProxy;
	case plProxyDrawMsg::kOccluder:
		return plDrawable::kOccluderProxy;
	case plProxyDrawMsg::kAudible:
		return plDrawable::kAudibleProxy;
	case plProxyDrawMsg::kCoordinate:
		return plDrawable::kCoordinateProxy;
	case plProxyDrawMsg::kCamera:
		return plDrawable::kCameraProxy;
	}
	hsAssert(false, "Unknown proxy type");
	return plDrawable::kGenericProxy;
}

UInt32 plProxyGen::IGetProxyIndex() const
{
	plKey sceneNode = IGetNode();
	UInt32 drawType = IGetDrawableType();

	int firstNil = -1;
	int firstMatch = -1;
	int i;
	for( i = 0; i < fProxyDrawables.GetCount(); i++ )
	{
		if( fProxyDrawables[i] )
		{
			if( (fProxyDrawables[i]->GetType() & drawType)
				&&(fProxyDrawables[i]->GetSceneNode() == sceneNode) )
			{
				return i;
			}
		}
		else if( firstNil < 0 )
			firstNil = i;
	}
	if( firstNil < 0 )
		firstNil = fProxyDrawables.GetCount();
	fProxyDrawables.ExpandAndZero(firstNil+1);

	return firstNil;
}

hsGMaterial* plProxyGen::IMakeProxyMaterial() const
{
	const hsColorRGBA& amb = fAmbient;
	const hsColorRGBA& dif = fColor;
	hsScalar opac = fAmbient.a;

	hsGMaterial* retVal = TRACKED_NEW hsGMaterial();

	char buff[256];
	if( GetKey()->GetName() )
		sprintf(buff, "%s_%s", GetKey()->GetName(), "Material");
	else
		strcpy(buff, "ProxyMaterial");
	hsgResMgr::ResMgr()->NewKey( buff, retVal, GetKey() ? GetKey()->GetUoid().GetLocation() : plLocation::kGlobalFixedLoc );

	plLayer *lay = retVal->MakeBaseLayer();
	lay->SetRuntimeColor(dif);
	lay->SetPreshadeColor(dif);
	lay->SetAmbientColor(amb);
	lay->SetOpacity(opac);
	if( opac < 1.f )
	{
		lay->SetBlendFlags(lay->GetBlendFlags() | hsGMatState::kBlendAlpha);
		lay->SetMiscFlags(hsGMatState::kMiscTwoSided);
		lay->SetZFlags(hsGMatState::kZNoZWrite);
	}

	return retVal;
}

hsGMaterial* plProxyGen::IFindProxyMaterial() const
{
	for (int i = 0; i < fProxyMaterials.GetCount(); i++)
	{
		hsGMaterial* mat = fProxyMaterials[i];
		if (!mat)
			continue;

		plLayer* lay = plLayer::ConvertNoRef(mat->GetLayer(0));
		if (lay &&
			lay->GetAmbientColor() == fAmbient &&
			lay->GetRuntimeColor() == fColor &&
			lay->GetOpacity() == fAmbient.a)
			return mat;
	}

	return nil;
}

hsGMaterial* plProxyGen::IGetProxyMaterial() const
{
	// If we already have a material, return that
	if (fProxyMat)
		return fProxyMat;

	// If there's one existing (for another proxy) that is setup the same as ours, use that
	hsGMaterial* mat = IFindProxyMaterial();
	if (mat)
		return mat;

	// Have to make a new one
	mat = IMakeProxyMaterial();
	fProxyMaterials.Append(mat);
	return mat;
}

void plProxyGen::IGenerateProxy()
{
	if( !IGetNode() )
		return;

	UInt32 idx = IGetProxyIndex();

	hsGMaterial* mat = IGetProxyMaterial();
	hsAssert(mat, "Failed to create proxy material");

	hsBool onCreate = !fProxyDrawables[idx];

	fProxyIndex.SetCount(0);
	fProxyDrawables[idx] = ICreateProxy(mat, fProxyIndex, fProxyDrawables[idx]);

	if( fProxyDrawables[idx] && !fProxyDrawables[idx]->GetKey() )
	{
		char buff[256];
		if( GetKey()->GetName() )
			sprintf(buff, "%s_%s", GetKey()->GetName(), "ProxyDrawable");
		else
			strcpy(buff, "ProxyDrawable");

		hsgResMgr::ResMgr()->NewKey( buff, fProxyDrawables[ idx ], GetKey() ? GetKey()->GetUoid().GetLocation() : plLocation::kGlobalFixedLoc );
	}

	if( fProxyDrawables[idx] )
	{
		fProxyDrawables[idx]->SetType(IGetDrawableType());

		IApplyProxy(idx);

		plGenRefMsg* msg = TRACKED_NEW plGenRefMsg(GetKey(), plRefMsg::kOnRequest, idx, 0);
		hsgResMgr::ResMgr()->AddViaNotify(mat->GetKey(), msg, plRefFlags::kActiveRef);
		fProxyMat = mat;

		plNodeRefMsg* refMsg = TRACKED_NEW plNodeRefMsg( GetKey(), plNodeRefMsg::kOnRequest, (Int8)idx, plNodeRefMsg::kDrawable );
		hsgResMgr::ResMgr()->AddViaNotify(fProxyDrawables[idx]->GetKey(), refMsg, plRefFlags::kActiveRef);
		fProxyDraw = fProxyDrawables[idx];
	}
}

//// IApplyProxy
// Add our proxy to our scenenode for rendering.
void plProxyGen::IApplyProxy(UInt32 idx) const
{
	if( fProxyDrawables[idx] && IGetNode() && (fProxyDrawables[idx]->GetSceneNode() != IGetNode()) )
	{
		fProxyDrawables[idx]->SetSceneNode(IGetNode());
	}
}

//// IRemoveProxy
// Remove our proxy from our scenenode.
void plProxyGen::IRemoveProxy(UInt32 idx) const
{
	if( fProxyDrawables[idx] )
	{
		fProxyDrawables[idx]->SetSceneNode(nil);
	}
}

/// Destroy the proxy. Duh.
void plProxyGen::IDestroyProxy()
{
	if( fProxyDraw )
	{
		if( fProxyDraw->GetSceneNode() )
			fProxyDraw->SetSceneNode(nil);
		GetKey()->Release(fProxyDraw->GetKey());
		fProxyDraw = nil;
	}
	if( fProxyMat )
	{
		GetKey()->Release(fProxyMat->GetKey());
		fProxyMat = nil;
	}
	fProxyDrawables.Reset();
	fProxyMaterials.Reset();
}

hsBool plProxyGen::MsgReceive(plMessage* msg)
{
	plProxyDrawMsg* pDraw = plProxyDrawMsg::ConvertNoRef(msg);
	if( pDraw && (pDraw->GetProxyFlags() & IGetProxyMsgType()) )
	{
		if( pDraw->GetProxyFlags() & plProxyDrawMsg::kCreate )
		{
			if( fProxyDraw == nil )
				IGenerateProxy();
		}
		else if( pDraw->GetProxyFlags() & plProxyDrawMsg::kDestroy )
		{
			if( fProxyDraw != nil )
				IDestroyProxy();
		}
		else if( pDraw->GetProxyFlags() & plProxyDrawMsg::kToggle )
		{
			if( fProxyDraw == nil )
				IGenerateProxy();
			else
				IDestroyProxy();
		}
		return true;
	}
	plNodeRefMsg* nodeRef = plNodeRefMsg::ConvertNoRef(msg);
	if( nodeRef )
	{
		if( nodeRef->GetContext() & (plRefMsg::kOnDestroy | plRefMsg::kOnRemove) )
		{
			if( nodeRef->fWhich < fProxyDrawables.GetCount() )
				fProxyDrawables[nodeRef->fWhich] = nil;
		}
		return true;
	}
	plGenRefMsg* genMsg = plGenRefMsg::ConvertNoRef(msg);
	if( genMsg )
	{
		if( genMsg->GetContext() & (plRefMsg::kOnDestroy | plRefMsg::kOnRemove) )
		{
			if( genMsg->fWhich < fProxyMaterials.GetCount() )
				fProxyMaterials[genMsg->fWhich] = nil;
		}
		return true;
	}

	return hsKeyedObject::MsgReceive(msg);
}


void plProxyGen::SetTransform(const hsMatrix44& l2w, const hsMatrix44& w2l)
{
	UInt32 idx = IGetProxyIndex();
	if( fProxyDrawables[idx] )
	{
		int i;
		for( i = 0; i < fProxyIndex.GetCount(); i++ )
			fProxyDrawables[idx]->SetTransform(fProxyIndex[i], l2w, w2l);
	}
}

void plProxyGen::SetDisable(hsBool on)
{
	UInt32 idx = IGetProxyIndex();
	if( fProxyDrawables[idx] )
	{
		int i;
		for( i = 0; i < fProxyIndex.GetCount(); i++ )
			fProxyDrawables[idx]->SetNativeProperty(fProxyIndex[i], plDrawable::kPropNoDraw, on);
	}
}