You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

369 lines
12 KiB

/*==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 PLMATRIXCHANNEL_INC
#define PLMATRIXCHANNEL_INC
// local
#include "plScalarChannel.h"
// global
#include "hsTypes.h" // you need types to include Matrix
#include "hsMatrix44.h"
#include "plTransform/hsAffineParts.h"
// local prototypes
class plQuatChannel;
class plPointChannel;
// external prototypes
class plController;
class hsAffineParts;
class plAnimTimeConvert;
class plMatrixChannelApplicator;
class plControllerCacheInfo;
//////////////////
// PLMATRIXCHANNEL
//////////////////
// an animation channel that outputs matrices
class plMatrixChannel : public plAGChannel
{
protected:
hsMatrix44 fResult;
hsAffineParts fAP;
public:
plMatrixChannel();
virtual ~plMatrixChannel();
// AG PROTOCOL
virtual const hsMatrix44 & Value(double time, bool peek = false);
virtual void Value(hsMatrix44 &matrix, double time, bool peek = false);
virtual const hsAffineParts & AffineValue(double time, bool 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);
virtual plAGPinType GetPinType() { return kAGPinTransform; };
virtual void Dump(int indent, bool optimized, double time);
// PLASMA PROTOCOL
CLASSNAME_REGISTER( plMatrixChannel );
GETINTERFACE_ANY( plMatrixChannel, plAGChannel );
};
///////////////////
// PLMATRIXCONSTANT
///////////////////
// A matrix source that just keeps handing out the same value
class plMatrixConstant : public plMatrixChannel
{
public:
plMatrixConstant();
plMatrixConstant(const hsMatrix44 &value);
virtual ~plMatrixConstant();
void Set(const hsMatrix44 &value);
// PLASMA PROTOCOL
CLASSNAME_REGISTER( plMatrixConstant );
GETINTERFACE_ANY( plMatrixConstant, plMatrixChannel );
virtual void Write(hsStream *stream, hsResMgr *mgr);
virtual void Read(hsStream *s, hsResMgr *mgr);
};
////////////////////
// PLMATRIXTIMESCALE
////////////////////
// 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 plMatrixTimeScale : public plMatrixChannel
{
protected:
plScalarChannel *fTimeSource;
plMatrixChannel *fChannelIn;
public:
plMatrixTimeScale();
plMatrixTimeScale(plMatrixChannel *channel, plScalarChannel *timeSource);
virtual ~plMatrixTimeScale();
virtual hsBool IsStoppedAt(double time);
virtual const hsMatrix44 & Value(double time, bool peek = false);
virtual const hsAffineParts & AffineValue(double time, bool peek = false);
virtual plAGChannel * Detach(plAGChannel * channel);
virtual void Dump(int indent, bool optimized, double time);
// PLASMA PROTOCOL
CLASSNAME_REGISTER( plMatrixTimeScale );
GETINTERFACE_ANY( plMatrixTimeScale, plMatrixChannel );
};
////////////////
// PLMATRIXBLEND
////////////////
// blends two matrices into one with weighting
class plMatrixBlend : public plMatrixChannel
{
protected:
plMatrixChannel * fChannelA;
plMatrixChannel * fOptimizedA;
plMatrixChannel * fChannelB;
plMatrixChannel * fOptimizedB;
plScalarChannel * fChannelBias;
int fPriority;
public:
// xTORs
plMatrixBlend();
plMatrixBlend(plMatrixChannel * channelA, plMatrixChannel * channelB, plScalarChannel * channelBias, int priority);
virtual ~plMatrixBlend();
virtual plAGChannel * plMatrixBlend::MakeBlend(plAGChannel *newChannel, plScalarChannel *channelBias, int blendPriority);
// you cannot blend on top of a channel that has higher priority than you do.
virtual UInt16 GetPriority();
// SPECIFICS
const plMatrixChannel * GetChannelA() const { return fChannelA; }
void SetChannelA(plMatrixChannel * channel) { fChannelA = channel; }
const plMatrixChannel * GetChannelB() const { return fChannelB; }
void SetChannelB(plMatrixChannel * channel) { fChannelB = channel; }
const plScalarChannel * GetChannelBias() const { return fChannelBias; }
void SetChannelBias(plScalarChannel * channel) { fChannelBias = channel; }
//virtual void SetBlend(float blend) { fBlend = blend; };
//virtual float GetBlend() { return fBlend; };
virtual hsBool IsStoppedAt(double time);
// AG PROTOCOL
virtual const hsMatrix44 & Value(double time, bool peek = false);
virtual const hsAffineParts & AffineValue(double time, bool peek = false);
// remove the specified channel from our graph
virtual plAGChannel * Detach(plAGChannel * channel);
virtual void Dump(int indent, bool optimized, double time);
plAGChannel *plMatrixBlend::Optimize(double time);
// PLASMA PROTOCOL
CLASSNAME_REGISTER( plMatrixBlend );
GETINTERFACE_ANY( plMatrixBlend, plMatrixChannel );
};
/////////////////////
// PLMATRIXCONTROLLER
/////////////////////
// converts a plController-style animation into a plMatrixChannel
class plMatrixControllerChannel : public plMatrixChannel
{
protected:
plController *fController;
public:
// xTORs
plMatrixControllerChannel();
plMatrixControllerChannel(plController *controller, hsAffineParts *parts);
virtual ~plMatrixControllerChannel();
// AG PROTOCOL
virtual const hsAffineParts & AffineValue(double time, bool peek = false);
virtual const hsAffineParts & AffineValue(double time, bool peek, plControllerCacheInfo *cache);
virtual const hsMatrix44 & Value(double time, bool peek = false);
virtual const hsMatrix44 & Value(double time, bool peek, plControllerCacheInfo *cache);
virtual plAGChannel * MakeCacheChannel(plAnimTimeConvert *atc);
virtual void Dump(int indent, bool optimized, double time);
// PLASMA PROTOCOL
// rtti
CLASSNAME_REGISTER( plMatrixControllerChannel );
GETINTERFACE_ANY( plMatrixControllerChannel, plMatrixChannel );
// persistence
virtual void Write(hsStream *stream, hsResMgr *mgr);
virtual void Read(hsStream *s, hsResMgr *mgr);
};
/////////////////////////////////
// PLMATRIXCONTROLLERCACHECHANNEL
/////////////////////////////////
// Same as plMatrixController, but with caching info
class plMatrixControllerCacheChannel : public plMatrixChannel
{
protected:
plControllerCacheInfo *fCache;
plMatrixControllerChannel *fControllerChannel;
public:
plMatrixControllerCacheChannel();
plMatrixControllerCacheChannel(plMatrixControllerChannel *channel, plControllerCacheInfo *cache);
virtual ~plMatrixControllerCacheChannel();
virtual const hsMatrix44 & Value(double time, bool peek = false);
virtual const hsAffineParts & AffineValue(double time, bool peek = false);
virtual plAGChannel * Detach(plAGChannel * channel);
// PLASMA PROTOCOL
CLASSNAME_REGISTER( plMatrixControllerCacheChannel );
GETINTERFACE_ANY( plMatrixControllerCacheChannel, plMatrixChannel );
// Created at runtime only, so no Read/Write
};
/////////////////////
// PLQUATPOINTCOMBINE
/////////////////////
// combines a quaternion and a point into a matrix
class plQuatPointCombine : public plMatrixChannel
{
protected:
plQuatChannel *fQuatChannel;
plPointChannel *fPointChannel;
public:
// xTORs
plQuatPointCombine();
plQuatPointCombine(plQuatChannel *quatChannel, plPointChannel *pointChannel);
virtual ~plQuatPointCombine();
// SPECIFICS
const plQuatChannel * GetQuatChannel() const { return fQuatChannel; }
void SetQuatChannel(plQuatChannel * channel) { fQuatChannel = channel; }
plPointChannel * GetPointChannel() const { return fPointChannel; }
void SetPointChannel(plPointChannel * channel) { fPointChannel = channel; }
// AG PROTOCOL
virtual const hsMatrix44 & Value(double time);
virtual const hsAffineParts & AffineValue(double time);
// remove the specified channel from our graph
virtual plAGChannel * Detach(plAGChannel * channel);
// PLASMA PROTOCOL
CLASSNAME_REGISTER( plQuatPointCombine );
GETINTERFACE_ANY( plQuatPointCombine, plMatrixChannel );
};
/////////////////////
//
// Applicator classes
class plMatrixChannelApplicator : public plAGApplicator
{
protected:
virtual void IApply(const plAGModifier *mod, double time);
public:
CLASSNAME_REGISTER( plMatrixChannelApplicator );
GETINTERFACE_ANY( plMatrixChannelApplicator, plAGApplicator );
virtual hsBool CanCombine(plAGApplicator *app) { return false; }
virtual plAGPinType GetPinType() { return kAGPinTransform; }
};
// PLMATRIXDELAYEDCORRECTIONAPPLICATOR
// Used for blending in sudden location changes due to synch messages.
// This app tacks on a correction to the l2p transform
// (so l2p is set as animL2P*correction)
// interpolating this to the identity matrix over time.
class plMatrixDelayedCorrectionApplicator : public plMatrixChannelApplicator
{
protected:
hsAffineParts fCorAP; // AP of the correction.
double fDelayStart; // Start time of the delayed correction
// apply our animation * our correction to the node
virtual void IApply(const plAGModifier *mod, double time);
public:
plMatrixDelayedCorrectionApplicator() : fDelayStart(-1000.f), fIgnoreNextCorrection(true) { fCorAP.Reset(); }
CLASSNAME_REGISTER( plMatrixDelayedCorrectionApplicator );
GETINTERFACE_ANY( plMatrixDelayedCorrectionApplicator, plMatrixChannelApplicator );
void SetCorrection(hsMatrix44 &correction);
virtual hsBool AutoDelete() { return false; } // should we remove it when its input channel is gone?
// applicator arbitration...
virtual plAGPinType GetPinType() { return kAGPinTransform; }
virtual hsBool CanBlend(plAGApplicator *app);
hsBool fIgnoreNextCorrection;
static const hsScalar fDelayLength; // static var for now.
};
// PLMATRIXDIFFERENCEAPP
// Each frame, this guy takes the difference between his current value
// and his last value and applies that to the current world
// transform of the target.
// You could also call it the Temporal Matrix Difference Applicator,
// but that sucks to type.
class plMatrixDifferenceApp : public plMatrixChannelApplicator
{
public:
/** Forget the previous cached transform and start again */
void Reset(double time);
/** Should this applicator be automatically removed when its channel goes away? */
virtual hsBool AutoDelete() { return false; }
// applicator arbitration
virtual plAGPinType GetPinType() { return kAGPinTransform; }
virtual hsBool CanBlend(plAGApplicator *app);
CLASSNAME_REGISTER(plMatrixDifferenceApp);
GETINTERFACE_ANY(plMatrixDifferenceApp, plMatrixChannelApplicator);
protected:
virtual void IApply(const plAGModifier *mod, double time);
hsMatrix44 fLastL2A; // local to animation space
hsMatrix44 fLastA2L; // animation space to local
bool fNew; // true if we haven't cached anything yet
};
#endif