CWE-ou-minkata/MOULOpenSourceClientPlugin/Plasma20/Sources/Plasma/PubUtilLib/plAvatar/plScalarChannel.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 PLSCALARCHANNEL_INC
#define PLSCALARCHANNEL_INC

/////////////////////////////////////////////////////////////////////////////////////////
//
// INCLUDES
//
/////////////////////////////////////////////////////////////////////////////////////////
// base
#include "plAGChannel.h"
#include "plAGApplicator.h"

/////////////////////////////////////////////////////////////////////////////////////////
//
// FORWARDS
//
/////////////////////////////////////////////////////////////////////////////////////////
class plController;
class plAnimTimeConvert;
class plSimpleStateVariable;
class plControllerCacheInfo;

/////////////////////////////////////////////////////////////////////////////////////////
//
// DEFINITIONS
//
/////////////////////////////////////////////////////////////////////////////////////////

//////////////////
// PLSCALARCHANNEL
//////////////////
// an animation channel that outputs a scalar value
class plScalarChannel : public plAGChannel
{
protected:
	hsScalar fResult;

public:
	plScalarChannel();
	virtual ~plScalarChannel();

	// AG PROTOCOL
	virtual const hsScalar & Value(double time, hsBool peek = false);
	virtual void Value(hsScalar &result, double time, hsBool peek = false);

	// combine it (allocates combine object)
	virtual plAGChannel * MakeCombine(plAGChannel * channelB);

	// blend it (allocates blend object)
	virtual plAGChannel * MakeBlend(plAGChannel * channelB, plScalarChannel * channelBias, int blendPriority);

	// const eval at time zero
	virtual plAGChannel * MakeZeroState();
	
	// make a timeScale instance
	virtual plAGChannel * MakeTimeScale(plScalarChannel *timeSource);

	// PLASMA PROTOCOL
	CLASSNAME_REGISTER( plScalarChannel );
	GETINTERFACE_ANY( plScalarChannel, plAGChannel );
};

///////////////////
// PLSCALARCONSTANT
///////////////////
// A scalar source that just keeps handing out the same value
class plScalarConstant : public plScalarChannel
{
public:
	plScalarConstant();
	plScalarConstant(hsScalar value);
	virtual ~plScalarConstant();

	void Set(hsScalar value) { fResult = value; }
	hsScalar Get() { return fResult; }

	// PLASMA PROTOCOL
	CLASSNAME_REGISTER( plScalarConstant );
	GETINTERFACE_ANY( plScalarConstant, plScalarChannel );

	void Read(hsStream *stream, hsResMgr *mgr);
	void Write(hsStream *stream, hsResMgr *mgr);
};


////////////////////
// PLSCALARTIMESCALE
////////////////////
// Adapts the time scale before passing it to the next channel in line.
// Use to instance animations while allowing each instance to run at different speeds.
class plScalarTimeScale : public plScalarChannel
{
protected:
	plScalarChannel *fTimeSource;
	plScalarChannel *fChannelIn;

public:
	plScalarTimeScale();
	plScalarTimeScale(plScalarChannel *channel, plScalarChannel *timeSource);
	virtual ~plScalarTimeScale();

	virtual hsBool IsStoppedAt(double time);
	virtual const hsScalar & Value(double time, hsBool peek = false);
	virtual plAGChannel * Detach(plAGChannel * channel);

	// PLASMA PROTOCOL
	CLASSNAME_REGISTER( plScalarTimeScale );
	GETINTERFACE_ANY( plScalarTimeScale, plScalarChannel );
};

////////////////
// PLSCALARBLEND
////////////////
// blends two scalars into one with weighting
class plScalarBlend : public plScalarChannel
{
protected:
	plScalarChannel * fChannelA;
	plScalarChannel * fChannelB;
	plScalarChannel * fChannelBias;
	
public:
	// xTORs
	plScalarBlend();
	plScalarBlend(plScalarChannel * channelA, plScalarChannel * channelB, plScalarChannel * channelBias);
	virtual ~plScalarBlend();

	// SPECIFICS
	const plScalarChannel * GetChannelA() const { return fChannelA; }
	void SetChannelA(plScalarChannel * channel) { fChannelA = channel; }

	const plScalarChannel * GetChannelB() const { return fChannelB; }
	void SetChannelB(plScalarChannel * channel) { fChannelB = channel; }

	const plScalarChannel * GetChannelBias() const { return fChannelBias; }
	void SetChannelBias(plScalarChannel * channel) { fChannelBias = channel; }

	virtual hsBool IsStoppedAt(double time);

	// AG PROTOCOL
	virtual const hsScalar & Value(double time, hsBool peek = false);
	
	// remove the specified channel from our graph
	virtual plAGChannel * Detach(plAGChannel * channel);
	
	// PLASMA PROTOCOL
	CLASSNAME_REGISTER( plScalarBlend );
	GETINTERFACE_ANY( plScalarBlend, plScalarChannel );
};

////////////////////////////
// PLSCALARCONTROLLERCHANNEL
////////////////////////////
// converts a plController-style animation into a plScalarChannel
class plScalarControllerChannel : public plScalarChannel
{
protected:
	plController *fController;
	
public:
	// xTORs
	plScalarControllerChannel();
	plScalarControllerChannel(plController *controller);
	virtual ~plScalarControllerChannel();
	
	// AG PROTOCOL
	virtual const hsScalar & Value(double time, hsBool peek = false);
	virtual const hsScalar & Value(double time, hsBool peek, plControllerCacheInfo *cache);
	
	virtual plAGChannel *plScalarControllerChannel::MakeCacheChannel(plAnimTimeConvert *atc);
		
	// PLASMA PROTOCOL
	// rtti
	CLASSNAME_REGISTER( plScalarControllerChannel );
	GETINTERFACE_ANY( plScalarControllerChannel, plScalarChannel );
	
	// persistence
	virtual void Write(hsStream *stream, hsResMgr *mgr);
	virtual void Read(hsStream *s, hsResMgr *mgr);
};

/////////////////////////////////
// PLSCALARCONTROLLERCACHECHANNEL
/////////////////////////////////
// Same as plScalarController, but with caching info
class plScalarControllerCacheChannel : public plScalarChannel
{
protected:
	plControllerCacheInfo *fCache;
	plScalarControllerChannel *fControllerChannel;
	
public:
	plScalarControllerCacheChannel();
	plScalarControllerCacheChannel(plScalarControllerChannel *channel, plControllerCacheInfo *cache);
	virtual ~plScalarControllerCacheChannel();
	
	virtual const hsScalar & Value(double time, bool peek = false);
	
	virtual plAGChannel * Detach(plAGChannel * channel);
	
	// PLASMA PROTOCOL
	CLASSNAME_REGISTER( plScalarControllerCacheChannel );
	GETINTERFACE_ANY( plScalarControllerCacheChannel, plScalarChannel );
	
	// Created at runtime only, so no Read/Write
};

////////////////////
// PLATCChannel
////////////////////
// Channel interface for a plAnimTimeConvert object
class plATCChannel : public plScalarChannel
{
protected:
	plAnimTimeConvert *fConvert;

public:
	plATCChannel();
	plATCChannel(plAnimTimeConvert *convert);
	virtual ~plATCChannel();

	virtual hsBool IsStoppedAt(double time);
	virtual const hsScalar & Value(double time, hsBool peek = false);

	// PLASMA PROTOCOL
	CLASSNAME_REGISTER( plATCChannel );
	GETINTERFACE_ANY( plATCChannel, plScalarChannel );
};

////////////////////
// PLSCALARSDLCHANNEL
////////////////////
// Returns the value of an SDL scalar variable
class plScalarSDLChannel : public plScalarChannel
{
protected:
	plSimpleStateVariable *fVar;
	hsScalar fLength;

public:
	plScalarSDLChannel();
	plScalarSDLChannel(hsScalar length);
	virtual ~plScalarSDLChannel();

	virtual hsBool IsStoppedAt(double time);
	virtual const hsScalar & Value(double time, hsBool peek = false);

	void SetVar(plSimpleStateVariable *var) { fVar = var; }

	// PLASMA PROTOCOL
	CLASSNAME_REGISTER( plScalarSDLChannel );
	GETINTERFACE_ANY( plScalarSDLChannel, plScalarChannel );
};


////////////////////////////
// 
// Channel Applicator classes

class plScalarChannelApplicator : public plAGApplicator
{
protected:
	virtual void IApply(const plAGModifier *mod, double time);

public:
	CLASSNAME_REGISTER( plScalarChannelApplicator );
	GETINTERFACE_ANY( plScalarChannelApplicator, plAGApplicator );
};

class plSpotInnerApplicator : public plAGApplicator
{
protected:
	virtual void IApply(const plAGModifier *mod, double time);

public:
	CLASSNAME_REGISTER( plSpotInnerApplicator );
	GETINTERFACE_ANY( plSpotInnerApplicator, plAGApplicator );
};

class plSpotOuterApplicator : public plAGApplicator
{
protected:
	virtual void IApply(const plAGModifier *mod, double time);

public:
	CLASSNAME_REGISTER( plSpotOuterApplicator );
	GETINTERFACE_ANY( plSpotOuterApplicator, plAGApplicator );
};

class plOmniApplicator : public plAGApplicator
{
protected:
	virtual void IApply(const plAGModifier *mod, double time);

public:
	CLASSNAME_REGISTER( plOmniApplicator );
	GETINTERFACE_ANY( plOmniApplicator, plAGApplicator );
};

class plOmniSqApplicator : public plAGApplicator
{
protected:
	virtual void IApply(const plAGModifier *mod, double time);

public:
	CLASSNAME_REGISTER( plOmniSqApplicator );
	GETINTERFACE_ANY( plOmniSqApplicator, plAGApplicator );
};

class plOmniCutoffApplicator : public plAGApplicator
{
protected:
	virtual void IApply(const plAGModifier *mod, double time);

public:
	CLASSNAME_REGISTER( plOmniCutoffApplicator );
	GETINTERFACE_ANY( plOmniCutoffApplicator, plAGApplicator );
};


#endif