/*==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 "plOccluder.h"
#include "hsStream.h"
#include "plOccluderProxy.h"
#include "plDrawable/plDrawableGenerator.h"
#include "plSurface/hsGMaterial.h"
#include "plSurface/plLayerInterface.h"
#include "plSurface/plLayer.h"
#include "pnMessage/plNodeRefMsg.h"
#include "pnKeyedObject/plKey.h"
#include "hsResMgr.h"
#include "plgDispatch.h"
#include "plVisRegion.h"
#include "plVisMgr.h"

plOccluder::plOccluder()
:	fSceneNode(nil)
{
	fProxyGen = TRACKED_NEW plOccluderProxy;
	fProxyGen->Init(this);

	fVisSet.SetBit(0);
}

plOccluder::~plOccluder()
{
	delete fProxyGen;
}

hsBool plOccluder::MsgReceive(plMessage* msg)
{
	plGenRefMsg* refMsg = plGenRefMsg::ConvertNoRef(msg);
	if( refMsg )
	{
		switch( refMsg->fType )
		{
		case kRefVisRegion:
			if( refMsg->GetContext() & (plRefMsg::kOnCreate|plRefMsg::kOnRequest|plRefMsg::kOnReplace) )
			{
				IAddVisRegion(plVisRegion::ConvertNoRef(refMsg->GetRef()));
			}
			else
			{
				IRemoveVisRegion(plVisRegion::ConvertNoRef(refMsg->GetRef()));
			}
			return true;
		default:
			break;
		}

	}
	return plObjInterface::MsgReceive(msg);
}

void plOccluder::IAddVisRegion(plVisRegion* reg)
{
	if( reg )
	{
		int idx = fVisRegions.Find(reg);
		if( fVisRegions.kMissingIndex == idx )
		{
			fVisRegions.Append(reg);
			if( reg->GetProperty(plVisRegion::kIsNot) )
				fVisNot.SetBit(reg->GetIndex());
			else
			{
				fVisSet.SetBit(reg->GetIndex());
				if( reg->ReplaceNormal() )
					fVisSet.ClearBit(plVisMgr::kNormal);
			}
		}
	}
}

void plOccluder::IRemoveVisRegion(plVisRegion* reg)
{
	if( reg )
	{
		int idx = fVisRegions.Find(reg);
		if( fVisRegions.kMissingIndex != idx )
		{
			fVisRegions.Remove(idx);
			if( reg->GetProperty(plVisRegion::kIsNot) )
				fVisNot.ClearBit(reg->GetIndex());
			else
				fVisSet.ClearBit(reg->GetIndex());
		}
	}
}

plDrawableSpans* plOccluder::CreateProxy(hsGMaterial* mat, hsTArray<UInt32>& idx, plDrawableSpans* addTo)
{
	hsTArray<hsPoint3>		pos;
	hsTArray<hsVector3>		norm;
	hsTArray<hsColorRGBA>	color;
	hsTArray<UInt16>		tris;

	plLayer* lay = plLayer::ConvertNoRef(mat->GetLayer(0)->BottomOfStack());
	if( lay )
		lay->SetMiscFlags(lay->GetMiscFlags() & ~hsGMatState::kMiscTwoSided);

	const hsTArray<plCullPoly>& polys = GetLocalPolyList();
	int i;
	for( i = 0; i < polys.GetCount(); i++ )
	{
		hsColorRGBA col;
		if( polys[i].IsHole() )
			col.Set(0,0,0,1.f);
		else
			col.Set(1.f, 1.f, 1.f, 1.f);

		int triStart = tris.GetCount();

		int idx0 = pos.GetCount();
		pos.Append(polys[i].fVerts[0]);
		norm.Append(polys[i].fNorm);
		color.Append(col);
		pos.Append(polys[i].fVerts[1]);
		norm.Append(polys[i].fNorm);
		color.Append(col);
		int j;
		for( j = 2; j < polys[i].fVerts.GetCount(); j++ )
		{
			int idxCurr = pos.GetCount();
			pos.Append(polys[i].fVerts[j]);
			norm.Append(polys[i].fNorm);
			color.Append(col);
			tris.Append(idx0);
			tris.Append(idxCurr-1);
			tris.Append(idxCurr);
		}
#if 1
		if( polys[i].IsTwoSided() )
		{
			int n = tris.GetCount();
			while( --n >= triStart )
			{
				int idx = tris[n];
				tris.Append(idx);
			}
		}
#endif
	}
	return plDrawableGenerator::GenerateDrawable(pos.GetCount(), 
										pos.AcquireArray(),
										norm.AcquireArray(),
										nil, 0,
										color.AcquireArray(),
										true,
										nil,
										tris.GetCount(),
										tris.AcquireArray(),
										mat,
										GetLocalToWorld(),
										true,
										&idx,
										addTo);
}

void plOccluder::SetTransform(const hsMatrix44& l2w, const hsMatrix44& w2l)
{
// Commenting out the following asserts. Although they are fundamentally correct, 
//essentially identity matrices which aren't so flagged (because of numerical
// precision) are triggering bogus asserts. mf
//	hsAssert(l2w.fFlags & hsMatrix44::kIsIdent, "Non-identity transform to non-movable Occluder");
//	hsAssert(w2l.fFlags & hsMatrix44::kIsIdent, "Non-identity transform to non-movable Occluder");
}

const hsMatrix44& plOccluder::GetLocalToWorld() const
{
	return hsMatrix44::IdentityMatrix();
}

const hsMatrix44& plOccluder::GetWorldToLocal() const
{
	return hsMatrix44::IdentityMatrix();
}

void plOccluder::ComputeFromPolys()
{
	IComputeBounds();
	IComputeSurfaceArea();
}

void plOccluder::IComputeBounds()
{
	fWorldBounds.MakeEmpty();

	const hsTArray<plCullPoly>& polys = GetLocalPolyList();
	int i;
	for( i =0 ; i < polys.GetCount(); i++ )
	{
		int j;
		for( j = 0; j < polys[i].fVerts.GetCount(); j++ )
			fWorldBounds.Union(&polys[i].fVerts[j]);
	}
}

hsScalar plOccluder::IComputeSurfaceArea()
{
	hsScalar area = 0;
	const hsTArray<plCullPoly>& polys = GetLocalPolyList();
	int i;
	for( i =0 ; i < polys.GetCount(); i++ )
	{
		int j;
		for( j = 2; j < polys[i].fVerts.GetCount(); j++ )
		{
			area += (hsVector3(&polys[i].fVerts[j], &polys[i].fVerts[j-2]) % hsVector3(&polys[i].fVerts[j-1], &polys[i].fVerts[j-2])).Magnitude();
		}
	}
	area *= 0.5f;

	return fPriority = area;
}

void plOccluder::SetPolyList(const hsTArray<plCullPoly>& list)
{
	UInt16 n = list.GetCount();
	fPolys.SetCount(n);
	int i;
	for( i = 0; i < n; i++ )
		fPolys[i] = list[i];
}

void plOccluder::ISetSceneNode(plKey node)
{
	if( fSceneNode != node )
	{
		if( node )
		{
			plNodeRefMsg* refMsg = TRACKED_NEW plNodeRefMsg(node, plRefMsg::kOnCreate, -1, plNodeRefMsg::kOccluder);
			hsgResMgr::ResMgr()->AddViaNotify(GetKey(), refMsg, plRefFlags::kPassiveRef);
		}
		if( fSceneNode )
		{
			fSceneNode->Release(GetKey());
		}
		fSceneNode = node;
	}
}

void plOccluder::Read(hsStream* s, hsResMgr* mgr)
{
	plObjInterface::Read(s, mgr);

	fWorldBounds.Read(s);
	fPriority = s->ReadSwapScalar();

	hsTArray<plCullPoly>& localPolys = IGetLocalPolyList();
	UInt16 n = s->ReadSwap16();
	localPolys.SetCount(n);
	int i;
	for( i = 0; i < n; i++ )
		localPolys[i].Read(s, mgr);

	plKey nodeKey = mgr->ReadKey(s);
	ISetSceneNode(nodeKey);

	n = s->ReadSwap16();
	fVisRegions.SetCountAndZero(n);
	for( i = 0; i < n; i++ )
		mgr->ReadKeyNotifyMe(s, TRACKED_NEW plGenRefMsg(GetKey(), plRefMsg::kOnCreate, 0, kRefVisRegion), plRefFlags::kActiveRef);
}

void plOccluder::Write(hsStream* s, hsResMgr* mgr)
{
	plObjInterface::Write(s, mgr);

	fWorldBounds.Write(s);
	s->WriteSwapScalar(fPriority);

	const hsTArray<plCullPoly>& localPolys = IGetLocalPolyList();
	s->WriteSwap16(localPolys.GetCount());
	int i;
	for( i = 0; i < localPolys.GetCount(); i++ )
		localPolys[i].Write(s, mgr);

	mgr->WriteKey(s, fSceneNode);

	s->WriteSwap16(fVisRegions.GetCount());
	for( i = 0; i < fVisRegions.GetCount(); i++ )
		mgr->WriteKey(s, fVisRegions[i]);
}

plMobileOccluder::plMobileOccluder()
{
	fLocalToWorld.Reset();
	fWorldToLocal.Reset();
}

plMobileOccluder::~plMobileOccluder()
{
}

void plMobileOccluder::IComputeBounds()
{
	plOccluder::IComputeBounds();
	fLocalBounds = fWorldBounds;
	fWorldBounds.Transform(&fLocalToWorld);
}

void plMobileOccluder::SetTransform(const hsMatrix44& l2w, const hsMatrix44& w2l)
{
	fLocalToWorld = l2w;
	fWorldToLocal = w2l;

	if( fPolys.GetCount() != fOrigPolys.GetCount() )
		fPolys.SetCount(fOrigPolys.GetCount());

	int i;
	for( i = 0; i < fPolys.GetCount(); i++ )
		fOrigPolys[i].Transform(l2w, w2l, fPolys[i]);

	if( fProxyGen )
		fProxyGen->SetTransform(l2w, w2l);
}

void plMobileOccluder::SetPolyList(const hsTArray<plCullPoly>& list)
{
	UInt16 n = list.GetCount();
	fOrigPolys.SetCount(n);
	fPolys.SetCount(n);

	int i;
	for( i = 0; i < n; i++ )
	{
		fPolys[i] = fOrigPolys[i] = list[i];
	}
}

void plMobileOccluder::Read(hsStream* s, hsResMgr* mgr)
{
	plOccluder::Read(s, mgr);

	fLocalToWorld.Read(s);
	fWorldToLocal.Read(s);

	fLocalBounds.Read(s);

	fPolys.SetCount(fOrigPolys.GetCount());

	SetTransform(fLocalToWorld, fWorldToLocal);
}

void plMobileOccluder::Write(hsStream* s, hsResMgr* mgr)
{
	plOccluder::Write(s, mgr);

	fLocalToWorld.Write(s);
	fWorldToLocal.Write(s);

	fLocalBounds.Write(s);
}

void plMobileOccluder::ComputeFromPolys()
{
	SetTransform(fLocalToWorld, fWorldToLocal);
	plOccluder::ComputeFromPolys();
}