CWE-ou-minkata/MOULOpenSourceClientPlugin/Plasma20/Sources/Plasma/PubUtilLib/plAvatar/plSwimRegion.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 "hsGeometry3.h"
#include "hsResMgr.h"

#include "plPhysicalControllerCore.h"
#include "plSwimRegion.h"
#include "plArmatureMod.h"

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

	fDownBuoyancy = s->ReadSwapScalar();
	fUpBuoyancy = s->ReadSwapScalar();
	fMaxUpwardVel = s->ReadSwapScalar();
}

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

	s->WriteSwapScalar(fDownBuoyancy);
	s->WriteSwapScalar(fUpBuoyancy);
	s->WriteSwapScalar(fMaxUpwardVel);
}

void plSwimRegionInterface::GetCurrent(plPhysicalControllerCore *physical, hsVector3 &linearResult, hsScalar &angularResult, hsScalar elapsed)
{
	linearResult.Set(0.f, 0.f, 0.f);
	angularResult = 0.f;
}

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

plSwimCircularCurrentRegion::plSwimCircularCurrentRegion() : 
	fCurrentSO(nil), 
	fRotation(0.f), 
	fPullNearDistSq(1.f),
	fPullNearVel(0.f),
	fPullFarDistSq(1.f),
	fPullFarVel(0.f)
{
}

void plSwimCircularCurrentRegion::Read(hsStream* stream, hsResMgr* mgr)
{
	plSwimRegionInterface::Read(stream, mgr);
	
	fRotation = stream->ReadSwapScalar();
	fPullNearDistSq = stream->ReadSwapScalar();
	fPullNearVel = stream->ReadSwapScalar();
	fPullFarDistSq = stream->ReadSwapScalar();
	fPullFarVel = stream->ReadSwapScalar();
	mgr->ReadKeyNotifyMe(stream, TRACKED_NEW plGenRefMsg(GetKey(), plRefMsg::kOnCreate, -1, -1), plRefFlags::kActiveRef); // currentSO		
}

void plSwimCircularCurrentRegion::Write(hsStream* stream, hsResMgr* mgr)
{
	plSwimRegionInterface::Write(stream, mgr);
	
	stream->WriteSwapScalar(fRotation);
	stream->WriteSwapScalar(fPullNearDistSq);
	stream->WriteSwapScalar(fPullNearVel);
	stream->WriteSwapScalar(fPullFarDistSq);
	stream->WriteSwapScalar(fPullFarVel);
	mgr->WriteKey(stream, fCurrentSO);
}

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

	return plSwimRegionInterface::MsgReceive(msg);
}

void plSwimCircularCurrentRegion::GetCurrent(plPhysicalControllerCore *physical, hsVector3 &linearResult, hsScalar &angularResult, hsScalar elapsed)
{
	if (elapsed <= 0.f || fCurrentSO == nil || GetProperty(kDisable))
	{
		linearResult.Set(0.f, 0.f, 0.f);
		angularResult = 0.f;
		return;
	}

	hsPoint3 center, pos;
	center.Set(&fCurrentSO->GetLocalToWorld().GetTranslate());

	plKey worldKey = physical->GetSubworld();
	if (worldKey)
	{
		plSceneObject* so = plSceneObject::ConvertNoRef(worldKey->ObjectIsLoaded());
		center = so->GetWorldToLocal() * center;
	}

	center.fZ = 0.f; // Just doing 2D

	physical->GetPositionSim(pos);
	
	hsBool applyPull = true;
	hsVector3 pos2Center(center.fX - pos.fX, center.fY - pos.fY, 0.f);
	hsScalar pullVel;
	hsScalar distSq = pos2Center.MagnitudeSquared();
	if (distSq < .5)
	{
		// Don't want to pull us too close to the center, or we
		// get this annoying jitter.
		pullVel = 0.f;
	}
	else if (distSq <= fPullNearDistSq)
		pullVel = fPullNearVel;
	else if (distSq >= fPullFarDistSq)
		pullVel = fPullFarVel;
	else
		pullVel = fPullNearVel + (fPullFarVel - fPullNearVel) * (distSq - fPullNearDistSq) / (fPullFarDistSq - fPullNearDistSq);

	hsVector3 pull = pos2Center;
	pull.Normalize();
	linearResult.Set(pull.fY, -pull.fX, pull.fZ);
	
	pull *= pullVel;
	linearResult *= fRotation;
	linearResult += pull;

	hsVector3 v1 = linearResult * elapsed - pos2Center;
	hsVector3 v2 = -pos2Center;
	hsScalar invCos = v1.InnerProduct(v2) / v1.Magnitude() / v2.Magnitude();
	if (invCos > 1)
		invCos = 1;
	if (invCos < -1)
		invCos = -1;
	angularResult = hsACosine(invCos) / elapsed;

// 	hsAssert(real_finite(linearResult.fX) &&
// 			 real_finite(linearResult.fY) &&
// 			 real_finite(linearResult.fZ) &&
// 			 real_finite(angularResult), "Bad water current computation.");	
}	

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

plSwimStraightCurrentRegion::plSwimStraightCurrentRegion() : 
	fCurrentSO(nil), 
	fNearDist(1.f),
	fNearVel(0.f),
	fFarDist(1.f),
	fFarVel(0.f)
{
}

void plSwimStraightCurrentRegion::Read(hsStream* stream, hsResMgr* mgr)
{
	plSwimRegionInterface::Read(stream, mgr);
	
	fNearDist = stream->ReadSwapScalar();
	fNearVel = stream->ReadSwapScalar();
	fFarDist = stream->ReadSwapScalar();
	fFarVel = stream->ReadSwapScalar();
	mgr->ReadKeyNotifyMe(stream, TRACKED_NEW plGenRefMsg(GetKey(), plRefMsg::kOnCreate, -1, -1), plRefFlags::kActiveRef); // currentSO		
}

void plSwimStraightCurrentRegion::Write(hsStream* stream, hsResMgr* mgr)
{
	plSwimRegionInterface::Write(stream, mgr);
	
	stream->WriteSwapScalar(fNearDist);
	stream->WriteSwapScalar(fNearVel);
	stream->WriteSwapScalar(fFarDist);
	stream->WriteSwapScalar(fFarVel);
	mgr->WriteKey(stream, fCurrentSO);
}

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

	return plSwimRegionInterface::MsgReceive(msg);
}

void plSwimStraightCurrentRegion::GetCurrent(plPhysicalControllerCore *physical, hsVector3 &linearResult, hsScalar &angularResult, hsScalar elapsed)
{
	angularResult = 0.f;

	if (elapsed <= 0.f || GetProperty(kDisable))
	{
		linearResult.Set(0.f, 0.f, 0.f);
		return;
	}

	hsPoint3 center, pos;
	hsVector3 current = fCurrentSO->GetLocalToWorld() * hsVector3(0.f, 1.f, 0.f);
	center.Set(&fCurrentSO->GetLocalToWorld().GetTranslate());
	physical->GetPositionSim(pos);

	plKey worldKey = physical->GetSubworld();
	if (worldKey)
	{
		plSceneObject* so = plSceneObject::ConvertNoRef(worldKey->ObjectIsLoaded());
		hsMatrix44 w2l = so->GetWorldToLocal();
		center = w2l * center;
		current = w2l * current;
	}

	hsVector3 pos2Center(center.fX - pos.fX, center.fY - pos.fY, 0.f);
	hsScalar dist = current.InnerProduct(pos - center);
	hsScalar pullVel;
	
	if (dist <= fNearDist)
		pullVel = fNearVel;
	else if (dist >= fFarDist)
		pullVel = fFarVel;
	else
		pullVel = fNearVel + (fFarVel - fNearVel) * (dist - fNearDist) / (fFarDist - fNearDist);

	linearResult = current * pullVel;
}