CWE-ou-minkata/MOULOpenSourceClientPlugin/Plasma20/Sources/Plasma/FeatureLib/pfAnimation/plLineFollowMod.h

/*==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==*/

#ifndef plLineFollowMod_inc
#define plLineFollowMod_inc

#include "../pnModifier/plMultiModifier.h"
#include "hsGeometry3.h"
#include "hsMatrix44.h"

class plAnimPath;
class plSceneObject;
class plStereizer;
class plListenerMsg;

class plLineFollowMod : public plMultiModifier
{
public:
	enum FollowMode {
		kFollowObject,
		kFollowListener,
		kFollowCamera,
		kFollowLocalAvatar,
	};
	enum RefType {
		kRefParent,
		kRefObject,
		kRefStereizer
	};

	
	enum {
		kNone			= 0x0,
		kFullMatrix		= 0x1,
		kOffsetFeet		= 0x2,
		kOffsetAng		= 0x4,
		kOffset			= kOffsetFeet | kOffsetAng,
		kOffsetClamp	= 0x8,
		kForceToLine	= 0x10,
		kSpeedClamp		= 0x20,
		kSearchPosPop	= 0x40	// Temp flag, gets set every time the target pops in position
	};
protected:
	FollowMode			fFollowMode;
	UInt16				fFollowFlags;

	plAnimPath*			fPath;
	plSceneObject*		fPathParent;

	plSceneObject*		fRefObj;

	mutable	hsPoint3	fSearchPos;

	hsTArray<plStereizer*>		fStereizers;

	hsScalar			fTanOffset;
	hsScalar			fOffset;
	hsScalar			fOffsetClamp;
	hsScalar			fSpeedClamp;

	virtual hsBool IEval(double secs, hsScalar del, UInt32 dirty);
	
	virtual hsBool		IGetSearchPos();
	virtual void		ISetTargetTransform(int iTarg, const hsMatrix44& tgtXfm);
	virtual void		ISetPathTransform();

	virtual hsBool		IGetTargetTransform(hsPoint3& searchPos, hsMatrix44& tgtXfm);
	virtual hsBool		IOffsetTargetTransform(hsMatrix44& tgtXfm);
	virtual hsMatrix44	ISpeedClamp(plCoordinateInterface* ci, const hsMatrix44& unclTgtXfm);
	hsMatrix44			IInterpMatrices(const hsMatrix44& m0, const hsMatrix44& m1, hsScalar parm);
	void				ICheckForPop(const hsPoint3& oldPos, const hsPoint3& newPos);

	void				ISetupStereizers(const plListenerMsg* listMsg);

	void IUnRegister();
	void IRegister();

public:

	plLineFollowMod();
	~plLineFollowMod();

	CLASSNAME_REGISTER( plLineFollowMod );
	GETINTERFACE_ANY( plLineFollowMod, plMultiModifier );
	
	virtual void Read(hsStream* stream, hsResMgr* mgr);
	virtual void Write(hsStream* stream, hsResMgr* mgr);

	// Export time stuff
	void				SetPath(plAnimPath* path);
	const plAnimPath*	GetPath() const { return fPath; }

	void				SetFollowMode(FollowMode f);
	FollowMode			GetFollowMode() const { return fFollowMode; }

	hsBool				HasOffsetFeet() const { return 0 != (fFollowFlags & kOffsetFeet); }
	hsBool				HasOffsetDegrees() const { return 0 != (fFollowFlags & kOffsetAng); }
	hsBool				HasOffset() const { return 0 != (fFollowFlags & kOffset); }
	hsBool				HasOffsetClamp() const { return 0 != (fFollowFlags & kOffsetClamp); }
	hsBool				HasSpeedClamp() const { return 0 != (fFollowFlags & kSpeedClamp); }

	void				SetOffsetFeet(hsScalar f);
	hsScalar			GetOffsetFeet() const { return fOffset; }

	void				SetOffsetDegrees(hsScalar f);
	hsScalar			GetOffsetDegrees() const { return hsScalarRadToDeg(fOffset); }

	void				SetOffsetClamp(hsScalar f);
	hsScalar			GetOffsetClamp() const { return fOffsetClamp; }

	void				SetForceToLine(hsBool on);
	hsBool				GetForceToLine() const { return 0 != (fFollowFlags & kForceToLine); }

	void				SetSpeedClamp(hsScalar feetPerSec);
	hsScalar			GetSpeedClamp() const { return fSpeedClamp; }

	hsBool				MsgReceive(plMessage* msg);

	virtual void AddTarget(plSceneObject* so);
	virtual void RemoveTarget(plSceneObject* so); 

	void		AddStereizer(const plKey& sterKey);
	void		RemoveStereizer(const plKey& sterKey);
};


class plRailCameraMod : public plLineFollowMod
{

public:

	plRailCameraMod();
	~plRailCameraMod();

	CLASSNAME_REGISTER( plRailCameraMod );
	GETINTERFACE_ANY( plRailCameraMod, plLineFollowMod );
	
	void Init() { fCurrentTime = -1; } // twiddle ourselves so we get ready to go...
	hsPoint3 GetGoal(double secs, hsScalar speed);

protected:
	
	virtual void		ISetTargetTransform(int iTarg, const hsMatrix44& tgtXfm) {fDesiredMatrix = tgtXfm;}
	virtual hsBool		IGetTargetTransform(hsPoint3& searchPos, hsMatrix44& tgtXfm);
	
	hsMatrix44	fDesiredMatrix;
	hsScalar	fCurrentTime;
	hsScalar	fTargetTime;
	hsPoint3	fGoal;
	hsBool		fFarthest;
};
#endif // plLineFollowMod_inc