CWE-ou-minkata/MOULOpenSourceClientPlugin/Plasma20/Sources/Plasma/FeatureLib/pfAnimation/plStereizer.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 <math.h>

#include "hsTypes.h"

#include "plStereizer.h"
#include "plLineFollowMod.h"

#include "../plMessage/plListenerMsg.h"
#include "plgDispatch.h"

#include "../pnSceneObject/plSceneObject.h"
#include "../pnSceneObject/plCoordinateInterface.h"

#include "hsFastMath.h"

#include "hsGeometry3.h"
#include "hsMatrix44.h"
#include "hsStream.h"

plStereizer::plStereizer()
:	fInitPos(0,0,0),
	fListPos(0,0,0),
	fListDirection(0,1.f,0),
	fListUp(0,0,1.f)
{
}

plStereizer::~plStereizer()
{
	if( !HasMaster() )
		plgDispatch::Dispatch()->UnRegisterForExactType(plListenerMsg::Index(), GetKey());
}

void plStereizer::Read(hsStream* stream, hsResMgr* mgr)
{
	plSingleModifier::Read(stream, mgr);

	fAmbientDist = stream->ReadSwapScalar();
	fTransition = stream->ReadSwapScalar();

	fMaxSepDist = stream->ReadSwapScalar();
	fMinSepDist = stream->ReadSwapScalar();

	fTanAng = stream->ReadSwapScalar();

	fInitPos.Read(stream);

	if( !HasMaster() )
		plgDispatch::Dispatch()->RegisterForExactType(plListenerMsg::Index(), GetKey());
}

void plStereizer::Write(hsStream* stream, hsResMgr* mgr)
{
	plSingleModifier::Write(stream, mgr);

	stream->WriteSwapScalar(fAmbientDist);
	stream->WriteSwapScalar(fTransition);

	stream->WriteSwapScalar(fMaxSepDist);
	stream->WriteSwapScalar(fMinSepDist);

	stream->WriteSwapScalar(fTanAng);

	fInitPos.Write(stream);
}

hsBool plStereizer::MsgReceive(plMessage* msg)
{
	plListenerMsg* listenMsg = plListenerMsg::ConvertNoRef(msg);
	if( listenMsg )
	{
		SetFromListenerMsg(listenMsg);
		return Stereize();
	}

	return plSingleModifier::MsgReceive(msg);
}

hsBool plStereizer::IEval(double secs, hsScalar del, UInt32 dirty)
{
	return false;
}

hsBool plStereizer::Stereize()
{
	plSceneObject* targ = GetTarget();
	if( !targ )
		return true;

	targ->FlushTransform();

	// Find distance to listener
	hsPoint3 pos = IGetUnStereoPos();
	hsVector3 posToList(&fListPos, &pos);
	hsScalar dist = posToList.Magnitude();

	// If distance less than ambient distance
	//		setup as pure ambient

	// Else if distance greater than ambient distance + transition
	//		setup as pure localized

	// Else
	//		Calc pure ambient position
	//		Calc pure localized position
	//		Interpolate between the two.
	if( dist <= fAmbientDist )
	{
		ISetNewPos(IGetAmbientPos());
	}
	else if( dist >= fAmbientDist + fTransition )
	{
		ISetNewPos(IGetLocalizedPos(posToList, dist));
	}
	else
	{
		hsPoint3 ambPos = IGetAmbientPos();
		hsPoint3 localizePos = IGetLocalizedPos(posToList, dist);

		hsPoint3 newPos(ambPos);
		newPos += (localizePos - ambPos) * ((dist - fAmbientDist) / fTransition);

		ISetNewPos(newPos);
	}

	return true;
}

void plStereizer::ISetNewPos(const hsPoint3& newPos)
{
	hsMatrix44 l2w = GetTarget()->GetLocalToWorld();
	hsMatrix44 w2l = GetTarget()->GetWorldToLocal();

	l2w.NotIdentity();
	l2w.fMap[0][3] = newPos[0];
	l2w.fMap[1][3] = newPos[1];
	l2w.fMap[2][3] = newPos[2];

	hsPoint3 invPos = -newPos;

	w2l.fMap[0][3] = ((hsVector3*)&w2l.fMap[0][0])->InnerProduct(invPos);
	w2l.fMap[1][3] = ((hsVector3*)&w2l.fMap[1][0])->InnerProduct(invPos);
	w2l.fMap[2][3] = ((hsVector3*)&w2l.fMap[2][0])->InnerProduct(invPos);

	IGetTargetCoordinateInterface(0)->SetTransform(l2w, w2l);
}

void plStereizer::SetFromListenerMsg(const plListenerMsg* listMsg)
{
	fListPos = listMsg->GetPosition();
	fListDirection = listMsg->GetDirection();
	fListUp = listMsg->GetUp();
}

hsPoint3 plStereizer::IGetAmbientPos() const
{
	hsPoint3 pos = fListPos;
	hsVector3 axOut = fListDirection % fListUp;
	hsFastMath::NormalizeAppr(axOut);
	if( IsLeftChannel() )
		axOut *= -fMinSepDist;
	else
		axOut *= fMinSepDist;

	pos += axOut;

	return pos;
}

hsPoint3 plStereizer::IGetLocalizedPos(const hsVector3& posToList, hsScalar distToList) const
{
	hsPoint3 pos = IGetUnStereoPos();

	hsVector3 axOut(-posToList.fY, posToList.fX, 0);
	hsFastMath::NormalizeAppr(axOut);

	hsScalar distOut = distToList * fTanAng;
	if( distOut > fMaxSepDist )
		distOut = fMaxSepDist;
	else if( distOut < fMinSepDist )
		distOut = fMinSepDist;
	if( IsLeftChannel() )
		distOut = -distOut;

	axOut *= distOut;

	pos += axOut;

	return pos;
}

void plStereizer::SetSepAngle(hsScalar rads)
{
	fTanAng = hsScalar(tan(rads));
}

hsScalar plStereizer::GetSepAngle() const
{
	return atan(fTanAng);
}

hsPoint3 plStereizer::IGetUnStereoPos() const
{
	return GetWorldInitPos();
}

void plStereizer::SetWorldInitPos(const hsPoint3& pos)
{
	plCoordinateInterface* parent = IGetParent();
	if( parent )
		fInitPos = parent->GetWorldToLocal() * pos;
	else
		fInitPos = pos;
}

hsPoint3 plStereizer::GetWorldInitPos() const
{
	plCoordinateInterface* parent = IGetParent();
	if( parent )
		return parent->GetLocalToWorld() * fInitPos;

	return fInitPos;
}

plCoordinateInterface* plStereizer::IGetParent() const
{
	plCoordinateInterface* coord = IGetTargetCoordinateInterface(0);
	if( coord )
	{
		return coord->GetParent();
	}
	return nil;
}

// Note that (along with it's many other hacky defects), this
// will go down in flames if there are two potential masters.
// Of course, two line follow mods doesn't really make sense
// now anyway, but the point is that this is a simplified placeholder 
// to get the job done. If and when a need is shown for sequencing of
// modifiers, this should be updated to follow that protocol. But
// the rationale is that one simple example of a need for sequencing
// doesn't give enough basis to decide what that protocol should be.
// Or in simpler terms, I want to do it one way, Brice wants to do
// it another, and since either would work for this, we're waiting
// for a tie breaker case that gives one way or the other an advantage.
hsBool plStereizer::CheckForMaster()
{
	ISetHasMaster(false);
	plSceneObject* targ = GetTarget();
	if( !targ )
		return false;

	int n = targ->GetNumModifiers();
	int i;
	for( i = 0; i < n; i++ )
	{
		plLineFollowMod* line = plLineFollowMod::ConvertNoRef(IGetTargetModifier(0, i));
		if( line )
		{
			ISetHasMaster(true);
			line->AddStereizer(GetKey());

			return true;
		}
	}
	return false;
}