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.
1018 lines
27 KiB
1018 lines
27 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/>. |
|
|
|
Additional permissions under GNU GPL version 3 section 7 |
|
|
|
If you modify this Program, or any covered work, by linking or |
|
combining it with any of RAD Game Tools Bink SDK, Autodesk 3ds Max SDK, |
|
NVIDIA PhysX SDK, Microsoft DirectX SDK, OpenSSL library, Independent |
|
JPEG Group JPEG library, Microsoft Windows Media SDK, or Apple QuickTime SDK |
|
(or a modified version of those libraries), |
|
containing parts covered by the terms of the Bink SDK EULA, 3ds Max EULA, |
|
PhysX SDK EULA, DirectX SDK EULA, OpenSSL and SSLeay licenses, IJG |
|
JPEG Library README, Windows Media SDK EULA, or QuickTime SDK EULA, the |
|
licensors of this Program grant you additional |
|
permission to convey the resulting work. Corresponding Source for a |
|
non-source form of such a combination shall include the source code for |
|
the parts of OpenSSL and IJG JPEG Library used as well as that of the covered |
|
work. |
|
|
|
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==*/ |
|
|
|
///////////////////////////////////////////////////////////////////////////////////////// |
|
// |
|
// INCLUDES |
|
// |
|
///////////////////////////////////////////////////////////////////////////////////////// |
|
|
|
// havok (must be first) |
|
//#include <hkmath/quaternion.h> |
|
//#include <hkmath/quaternion.h> |
|
|
|
// singular |
|
#include "plMatrixChannel.h" |
|
|
|
// local |
|
#include "plQuatChannel.h" |
|
#include "plPointChannel.h" |
|
|
|
// global |
|
#include "hsResMgr.h" |
|
#include "plProfile.h" |
|
#include "hsTimer.h" |
|
|
|
// other |
|
#include "../pnSceneObject/plDrawInterface.h" |
|
#include "../pnSceneObject/plSimulationInterface.h" |
|
#include "../pnSceneObject/plCoordinateInterface.h" |
|
#include "../pnSceneObject/plAudioInterface.h" |
|
#include "../plInterp/plController.h" |
|
#include "../plInterp/plAnimTimeConvert.h" |
|
#include "../plInterp/hsInterp.h" |
|
#include "../plTransform/hsAffineParts.h" |
|
|
|
///////////////////////////////////////////////////////////////////////////////////////// |
|
// |
|
// PROFILING GIBBLIES |
|
// |
|
///////////////////////////////////////////////////////////////////////////////////////// |
|
|
|
plProfile_Extern(AffineValue); |
|
plProfile_Extern(AffineInterp); |
|
plProfile_Extern(AffineBlend); |
|
plProfile_Extern(AffineCompose); |
|
plProfile_Extern(MatrixApplicator); |
|
|
|
///////////////////////////////////////////////////////////////////////////////////////// |
|
// |
|
// plMatrixChannel |
|
// |
|
///////////////////////////////////////////////////////////////////////////////////////// |
|
|
|
// ctor -------------------------- |
|
// ----- |
|
plMatrixChannel::plMatrixChannel() |
|
: plAGChannel() |
|
{ |
|
} |
|
|
|
// dtor --------------------------- |
|
// ----- |
|
plMatrixChannel::~plMatrixChannel() |
|
{ |
|
} |
|
|
|
// Value -------------------------------------------------------- |
|
// ------ |
|
const hsMatrix44 & plMatrixChannel::Value(double time, bool peek) |
|
{ |
|
return fResult; |
|
} |
|
|
|
// AffineValue ----------------------------------------------------------- |
|
// ------------ |
|
const hsAffineParts & plMatrixChannel::AffineValue(double time, bool peek) |
|
{ |
|
return fAP; |
|
} |
|
|
|
// Value -------------------------------------------------------------- |
|
// ------ |
|
void plMatrixChannel::Value(hsMatrix44 &matrix, double time, bool peek) |
|
{ |
|
matrix = Value(time); |
|
} |
|
|
|
// MakeCombine ----------------------------------------------- |
|
// ------------ |
|
plAGChannel * plMatrixChannel::MakeCombine(plAGChannel *other) |
|
{ |
|
return nil; |
|
} |
|
|
|
// MakeBlend --------------------------------------------------- |
|
// ---------- |
|
plAGChannel * plMatrixChannel::MakeBlend(plAGChannel * channelB, |
|
plScalarChannel * channelBias, |
|
int blendPriority) |
|
{ |
|
plMatrixChannel * matChanB = plMatrixChannel::ConvertNoRef(channelB); |
|
plAGChannel * result = this; // if the blend fails, we keep our position in the graph |
|
|
|
if (matChanB) |
|
{ |
|
result = TRACKED_NEW plMatrixBlend(this, matChanB, channelBias, blendPriority); |
|
} |
|
return result; |
|
} |
|
|
|
// MakeZeroState ----------------------------- |
|
// -------------- |
|
plAGChannel * plMatrixChannel::MakeZeroState() |
|
{ |
|
return TRACKED_NEW plMatrixConstant(Value(0)); |
|
} |
|
|
|
// MakeTimeScale -------------------------------------------------------- |
|
// -------------- |
|
plAGChannel * plMatrixChannel::MakeTimeScale(plScalarChannel *timeSource) |
|
{ |
|
return TRACKED_NEW plMatrixTimeScale(this, timeSource); |
|
} |
|
|
|
// Dump ------------------------------------------- |
|
// ----- |
|
void plMatrixChannel::Dump(int indent, bool optimized, double time) |
|
{ |
|
std::string indentStr; |
|
for(int i = 0; i < indent; i++) |
|
{ |
|
indentStr += "- "; |
|
} |
|
hsStatusMessageF("%s matChan<%s>", indentStr.c_str(), fName); |
|
} |
|
|
|
///////////////////////////////////////////////////////////////////////////////////////// |
|
// |
|
// plMatrixConstant |
|
// |
|
///////////////////////////////////////////////////////////////////////////////////////// |
|
|
|
// ctor ---------------------------- |
|
// ----- |
|
plMatrixConstant::plMatrixConstant() |
|
: plMatrixChannel() |
|
{ |
|
} |
|
|
|
plMatrixConstant::~plMatrixConstant() |
|
{ |
|
} |
|
|
|
plMatrixConstant::plMatrixConstant(const hsMatrix44 &value) |
|
{ |
|
Set(value); |
|
} |
|
|
|
void plMatrixConstant::Set(const hsMatrix44 &value) |
|
{ |
|
fResult = value; |
|
|
|
gemAffineParts gemParts1; |
|
decomp_affine(value.fMap, &gemParts1); |
|
AP_SET(fAP, gemParts1); |
|
} |
|
|
|
void plMatrixConstant::Write(hsStream *stream, hsResMgr *mgr) |
|
{ |
|
plMatrixChannel::Write(stream, mgr); |
|
fAP.Write(stream); |
|
} |
|
|
|
void plMatrixConstant::Read(hsStream *stream, hsResMgr *mgr) |
|
{ |
|
plMatrixChannel::Read(stream, mgr); |
|
fAP.Read(stream); |
|
fAP.ComposeMatrix(&fResult); |
|
} |
|
|
|
///////////////////////////////////////////////////////////////////////////////////////// |
|
// |
|
// plMatrixTimeScale |
|
// |
|
// Insert into the graph when you need to change the speed or direction of time |
|
// Also serves as a handy instancing node, since it just passes its data through. |
|
// |
|
///////////////////////////////////////////////////////////////////////////////////////// |
|
|
|
// ctor ------------------------------ |
|
// ----- |
|
plMatrixTimeScale::plMatrixTimeScale() |
|
: plMatrixChannel(), fTimeSource(nil), fChannelIn(nil) |
|
{ |
|
} |
|
|
|
// ctor ------------------------------------------------------------------------ |
|
// ----- |
|
plMatrixTimeScale::plMatrixTimeScale(plMatrixChannel *channel, |
|
plScalarChannel *timeSource) |
|
: fChannelIn(channel), |
|
fTimeSource(timeSource) |
|
{ |
|
} |
|
|
|
// dtor ------------------------------- |
|
// ----- |
|
plMatrixTimeScale::~plMatrixTimeScale() |
|
{ |
|
} |
|
|
|
// IsStoppedAt ---------------------------- |
|
// ------------ |
|
hsBool plMatrixTimeScale::IsStoppedAt(double time) |
|
{ |
|
return fTimeSource->IsStoppedAt(time); |
|
} |
|
|
|
// Value ---------------------------------------------------------- |
|
// ------ |
|
const hsMatrix44 & plMatrixTimeScale::Value(double time, bool peek) |
|
{ |
|
fResult = fChannelIn->Value(fTimeSource->Value(time, peek), peek); |
|
|
|
return fResult; |
|
} |
|
|
|
const hsAffineParts & plMatrixTimeScale::AffineValue(double time, bool peek) |
|
{ |
|
fAP = fChannelIn->AffineValue(fTimeSource->Value(time, peek), peek); |
|
return fAP; |
|
} |
|
|
|
// Detach ---------------------------------------------------- |
|
// ------- |
|
plAGChannel * plMatrixTimeScale::Detach(plAGChannel * detach) |
|
{ |
|
plAGChannel *result = this; |
|
|
|
// HAVE to recurse on the incoming channel in case there are cycles; |
|
// even if we're detaching this node it might also be further upstream |
|
fChannelIn = plMatrixChannel::ConvertNoRef(fChannelIn->Detach(detach)); |
|
|
|
// If you delete a timescale, it is not replaced with its upstream node; |
|
// it's just gone. |
|
if(!fChannelIn || detach == this) |
|
result = nil; |
|
|
|
if(result != this) |
|
delete this; |
|
|
|
return result; |
|
} |
|
|
|
// Dump --------------------------------------------- |
|
// ----- |
|
void plMatrixTimeScale::Dump(int indent, bool optimized, double time) |
|
{ |
|
std::string indentStr; |
|
for(int i = 0; i < indent; i++) |
|
{ |
|
indentStr += "- "; |
|
} |
|
hsStatusMessageF("%s matTimeScale <%s> at time <%f>", indentStr.c_str(), fName, fTimeSource->Value(time, true)); |
|
fChannelIn->Dump(indent + 1, optimized, time); |
|
|
|
} |
|
|
|
|
|
///////////////////////////////////////////////////////////////////////////////////////// |
|
// |
|
// plMatrixBlend |
|
// |
|
///////////////////////////////////////////////////////////////////////////////////////// |
|
|
|
// ctor ---------------------- |
|
// ----- |
|
plMatrixBlend::plMatrixBlend() |
|
: fChannelA(nil), |
|
fChannelB(nil), |
|
fChannelBias(nil) |
|
{ |
|
} |
|
|
|
// ctor ---------------------------------------------------------------------------- |
|
// ----- |
|
plMatrixBlend::plMatrixBlend(plMatrixChannel * channelA, plMatrixChannel * channelB, |
|
plScalarChannel * channelBias, int priority) |
|
: fChannelA(channelA), |
|
fOptimizedA(channelA), |
|
fChannelB(channelB), |
|
fOptimizedB(channelB), |
|
fChannelBias(channelBias), |
|
fPriority(priority) |
|
{ |
|
} |
|
|
|
// dtor ----------------------- |
|
// ----- |
|
plMatrixBlend::~plMatrixBlend() |
|
{ |
|
fChannelA = nil; |
|
fChannelB = nil; |
|
fChannelBias = nil; |
|
} |
|
|
|
// MakeBlend -------------------------------------------------- |
|
// ---------- |
|
plAGChannel * plMatrixBlend::MakeBlend(plAGChannel *newChannel, |
|
plScalarChannel *channelBias, |
|
int blendPriority) |
|
{ |
|
plMatrixChannel * newMatChan = plMatrixChannel::ConvertNoRef(newChannel); |
|
plAGChannel *result = this; |
|
int effectiveBlendPriority = (blendPriority == -1 ? fPriority : blendPriority); |
|
|
|
if(newMatChan) |
|
{ |
|
if(effectiveBlendPriority >= fPriority) |
|
{ |
|
// if the new channel has higher priority, just do it. |
|
result = plMatrixChannel::MakeBlend(newMatChan, channelBias, effectiveBlendPriority); |
|
} else { |
|
// we're higher priority: pass to our upstream channel |
|
fChannelA = plMatrixChannel::ConvertNoRef(fChannelA->MakeBlend(newChannel, channelBias, blendPriority)); |
|
hsAssert(fChannelA, "MakeBlend returned non-matrix channel."); |
|
// ask our upstream channel to do the blend: it can't be atop us |
|
// this request will get recursively delegated until the priorities work. |
|
} |
|
} |
|
return result; |
|
} |
|
|
|
UInt16 plMatrixBlend::GetPriority() { |
|
return fPriority; |
|
} |
|
|
|
hsBool plMatrixBlend::IsStoppedAt(double time) |
|
{ |
|
hsScalar blend = fChannelBias->Value(time); |
|
if (blend == 0) |
|
return fChannelA->IsStoppedAt(time); |
|
if (blend == 1) |
|
return fChannelB->IsStoppedAt(time); |
|
|
|
return (fChannelA->IsStoppedAt(time) && fChannelB->IsStoppedAt(time)); |
|
} |
|
|
|
// Value ------------------------------------------------------ |
|
// ------ |
|
const hsMatrix44 & plMatrixBlend::Value(double time, bool peek) |
|
{ |
|
const hsAffineParts &parts = AffineValue(time, peek); |
|
|
|
plProfile_BeginTiming(AffineCompose); |
|
parts.ComposeMatrix(&fResult); |
|
plProfile_EndTiming(AffineCompose); |
|
return fResult; |
|
} |
|
|
|
// AffineValue --------------------------------------------------------- |
|
// ------------ |
|
const hsAffineParts & plMatrixBlend::AffineValue(double time, bool peek) |
|
{ |
|
const hsScalar &blend = fChannelBias->Value(time); |
|
if(blend == 0) { |
|
return fOptimizedA->AffineValue(time, peek); |
|
} else { |
|
if(blend == 1) { |
|
return fOptimizedB->AffineValue(time, peek); |
|
} else { |
|
const hsAffineParts &apA = fChannelA->AffineValue(time, peek); |
|
const hsAffineParts &apB = fChannelB->AffineValue(time, peek); |
|
|
|
plProfile_BeginTiming(AffineBlend); |
|
hsInterp::LinInterp(&apA, &apB, blend, &fAP); |
|
plProfile_EndTiming(AffineBlend); |
|
} |
|
} |
|
return fAP; |
|
} |
|
|
|
// Detach ---------------------------------------------- |
|
// ------- |
|
plAGChannel * plMatrixBlend::Detach(plAGChannel *remove) |
|
{ |
|
plAGChannel *result = this; |
|
|
|
// it's possible that the incoming channel could reside down *all* of our |
|
// branches (it's a graph, not a tree,) so we always pass down all limbs |
|
fChannelBias = plScalarChannel::ConvertNoRef(fChannelBias->Detach(remove)); |
|
fChannelA = plMatrixChannel::ConvertNoRef(fChannelA->Detach(remove)); |
|
fChannelB = plMatrixChannel::ConvertNoRef(fChannelB->Detach(remove)); |
|
|
|
if(!fChannelBias) |
|
result = fChannelA; |
|
else if(fChannelA && !fChannelB) |
|
result = fChannelA; |
|
else if(fChannelB && !fChannelA) |
|
result = fChannelB; |
|
else if(!fChannelA && !fChannelB) |
|
result = nil; |
|
|
|
if(result != this) |
|
delete this; |
|
|
|
return result; |
|
} |
|
|
|
// Optimize ------------------------------------- |
|
// --------- |
|
plAGChannel *plMatrixBlend::Optimize(double time) |
|
{ |
|
fOptimizedA = (plMatrixChannel *)fChannelA->Optimize(time); |
|
fOptimizedB = (plMatrixChannel *)fChannelB->Optimize(time); |
|
hsScalar blend = fChannelBias->Value(time); |
|
if(blend == 0.0f) |
|
return fOptimizedA; |
|
if(blend == 1.0f) |
|
return fOptimizedB; |
|
else |
|
return this; |
|
} |
|
|
|
// Dump ----------------------------------------- |
|
// ----- |
|
void plMatrixBlend::Dump(int indent, bool optimized, double time) |
|
{ |
|
std::string indentStr; |
|
for(int i = 0; i < indent; i++) |
|
{ |
|
indentStr += "- "; |
|
} |
|
hsStatusMessageF("%s matBlend<%s>, bias:<%f>", indentStr.c_str(), fName, fChannelBias->Value(time, true)); |
|
if(optimized) |
|
{ |
|
fOptimizedB->Dump(indent + 1, optimized, time); |
|
fOptimizedA->Dump(indent + 1, optimized, time); |
|
} else { |
|
fChannelB->Dump(indent + 1, optimized, time); |
|
fChannelA->Dump(indent + 1, optimized, time); |
|
} |
|
} |
|
|
|
///////////////////////////////////////////////////////////////////////////////////////// |
|
// |
|
// plMatrixControllerChannel |
|
// |
|
///////////////////////////////////////////////////////////////////////////////////////// |
|
|
|
// ctor ---------------------------------------------- |
|
// ----- |
|
plMatrixControllerChannel::plMatrixControllerChannel() |
|
: plMatrixChannel(), fController(nil) |
|
{ |
|
} |
|
|
|
// ctor --------------------------------------------------------------- |
|
// ----- |
|
plMatrixControllerChannel::plMatrixControllerChannel(plController *controller, |
|
hsAffineParts *parts) |
|
: fController(controller) |
|
{ |
|
fAP = *parts; |
|
} |
|
|
|
// dtor ----------------------------------------------- |
|
// ----- |
|
plMatrixControllerChannel::~plMatrixControllerChannel() |
|
{ |
|
if(fController) { |
|
delete fController; |
|
fController = nil; |
|
} |
|
} |
|
|
|
// Value ------------------------------------------------------------------ |
|
// ------ |
|
const hsMatrix44 & plMatrixControllerChannel::Value(double time, bool peek) |
|
{ |
|
return Value(time, peek, nil); |
|
} |
|
|
|
// Value ------------------------------------------------------------------ |
|
// ------ |
|
const hsMatrix44 & plMatrixControllerChannel::Value(double time, bool peek, |
|
plControllerCacheInfo *cache) |
|
{ |
|
plProfile_BeginTiming(AffineInterp); |
|
fController->Interp((hsScalar)time, &fAP, cache); |
|
plProfile_EndTiming(AffineInterp); |
|
|
|
plProfile_BeginTiming(AffineCompose); |
|
fAP.ComposeMatrix(&fResult); |
|
plProfile_EndTiming(AffineCompose); |
|
return fResult; |
|
} |
|
|
|
// AffineValue --------------------------------------------------------------------- |
|
// ------------ |
|
const hsAffineParts & plMatrixControllerChannel::AffineValue(double time, bool peek) |
|
{ |
|
return AffineValue(time, peek, nil); |
|
} |
|
|
|
// AffineValue --------------------------------------------------------------------- |
|
// ------------ |
|
const hsAffineParts & plMatrixControllerChannel::AffineValue(double time, bool peek, |
|
plControllerCacheInfo *cache) |
|
{ |
|
plProfile_BeginTiming(AffineInterp); |
|
fController->Interp((hsScalar)time, &fAP, cache); |
|
plProfile_EndTiming(AffineInterp); |
|
return fAP; |
|
} |
|
|
|
// MakeCacheChannel ------------------------------------------------------------ |
|
// ----------------- |
|
plAGChannel *plMatrixControllerChannel::MakeCacheChannel(plAnimTimeConvert *atc) |
|
{ |
|
plControllerCacheInfo *cache = fController->CreateCache(); |
|
cache->SetATC(atc); |
|
return TRACKED_NEW plMatrixControllerCacheChannel(this, cache); |
|
} |
|
|
|
void plMatrixControllerChannel::Dump(int indent, bool optimized, double time) |
|
{ |
|
std::string indentStr; |
|
for(int i = 0; i < indent; i++) |
|
{ |
|
indentStr += "- "; |
|
} |
|
hsStatusMessageF("%s MatController<%s>", indentStr.c_str(), fName); |
|
} |
|
|
|
// Write ------------------------------------------------------------- |
|
// ------ |
|
void plMatrixControllerChannel::Write(hsStream *stream, hsResMgr *mgr) |
|
{ |
|
plMatrixChannel::Write(stream, mgr); |
|
|
|
hsAssert(fController, "Trying to write plMatrixControllerChannel with nil controller. File will not be importable."); |
|
mgr->WriteCreatable(stream, fController); |
|
|
|
fAP.Write(stream); |
|
} |
|
|
|
// Read ------------------------------------------------------------- |
|
// ------ |
|
void plMatrixControllerChannel::Read(hsStream *stream, hsResMgr *mgr) |
|
{ |
|
plMatrixChannel::Read(stream, mgr); |
|
|
|
fController = plController::ConvertNoRef(mgr->ReadCreatable(stream)); |
|
|
|
fAP.Read(stream); |
|
} |
|
|
|
///////////////////////////////// |
|
// PLMATRIXCONTROLLERCACHECHANNEL |
|
///////////////////////////////// |
|
|
|
// CTOR |
|
plMatrixControllerCacheChannel::plMatrixControllerCacheChannel() |
|
: plMatrixChannel(), fControllerChannel(nil), fCache(nil) |
|
{ |
|
} |
|
|
|
// CTOR(name, controller) |
|
plMatrixControllerCacheChannel::plMatrixControllerCacheChannel(plMatrixControllerChannel *controller, plControllerCacheInfo *cache) |
|
: fControllerChannel(controller), fCache(cache) |
|
{ |
|
} |
|
|
|
// ~DTOR() |
|
plMatrixControllerCacheChannel::~plMatrixControllerCacheChannel() |
|
{ |
|
delete fCache; |
|
fControllerChannel = nil; |
|
} |
|
|
|
// VALUE(time) |
|
const hsMatrix44 & plMatrixControllerCacheChannel::Value(double time, bool peek) |
|
{ |
|
return fControllerChannel->Value(time, peek, fCache); |
|
} |
|
|
|
const hsAffineParts & plMatrixControllerCacheChannel::AffineValue(double time, bool peek) |
|
{ |
|
return fControllerChannel->AffineValue(time, peek, fCache); |
|
} |
|
|
|
// DETACH |
|
plAGChannel * plMatrixControllerCacheChannel::Detach(plAGChannel * detach) |
|
{ |
|
plAGChannel *result = this; |
|
|
|
fControllerChannel = |
|
plMatrixControllerChannel::ConvertNoRef(fControllerChannel->Detach(detach)); |
|
|
|
if(detach == this) |
|
result = fControllerChannel; |
|
|
|
if(!fControllerChannel) |
|
result = nil; |
|
|
|
if(result != this) |
|
delete this; |
|
|
|
return result; |
|
} |
|
|
|
///////////////////// |
|
// PLQUATPOINTCOMBINE |
|
///////////////////// |
|
|
|
// CTOR |
|
plQuatPointCombine::plQuatPointCombine() |
|
: fQuatChannel(nil), fPointChannel(nil) |
|
{ |
|
} |
|
|
|
// CTOR |
|
plQuatPointCombine::plQuatPointCombine(plQuatChannel *quatChannel, plPointChannel *pointChannel) |
|
: fQuatChannel(quatChannel), |
|
fPointChannel(pointChannel) |
|
{ |
|
} |
|
|
|
// DTOR |
|
plQuatPointCombine::~plQuatPointCombine() |
|
{ |
|
if(fQuatChannel) { |
|
//XXX delete fQuatChannel; |
|
fQuatChannel = nil; |
|
} |
|
if(fPointChannel) { |
|
//XXX delete fPointChannel; |
|
fPointChannel = nil; |
|
} |
|
} |
|
|
|
// VALUE(time) |
|
const hsMatrix44 & plQuatPointCombine::Value(double time) |
|
{ |
|
if(fQuatChannel) |
|
{ |
|
const hsQuat &quat = fQuatChannel->Value(time); |
|
quat.MakeMatrix(&fResult); |
|
} else { |
|
fResult.Reset(); |
|
} |
|
if(fPointChannel) |
|
{ |
|
const hsPoint3 &point = fPointChannel->Value(time); |
|
fResult.SetTranslate(&point); |
|
} |
|
return fResult; |
|
} |
|
|
|
const hsAffineParts & plQuatPointCombine::AffineValue(double time) |
|
{ |
|
// XXX Lame hack to get things to compile for now. |
|
// Will fix when we actually start using this channel type. |
|
gemAffineParts gemParts1; |
|
decomp_affine(Value(time).fMap, &gemParts1); |
|
AP_SET(fAP, gemParts1); |
|
|
|
return fAP; |
|
} |
|
|
|
// DETACH |
|
plAGChannel * plQuatPointCombine::Detach(plAGChannel *channel) |
|
{ |
|
hsAssert(this != channel, "Can't detach combiners or blenders directly. Detach sub-channels instead."); |
|
if(this != channel) |
|
{ |
|
// *** check the types on the replacement channels to make sure they're compatible |
|
fQuatChannel = (plQuatChannel *)fQuatChannel->Detach(channel); |
|
fPointChannel = (plPointChannel *)fPointChannel->Detach(channel); |
|
} |
|
return this; |
|
} |
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////// |
|
// |
|
// PLMATRIXCHANNELAPPLICATOR |
|
// |
|
/////////////////////////////////////////////////////////////////////////////////////////// |
|
|
|
// IAPPLY |
|
void plMatrixChannelApplicator::IApply(const plAGModifier *mod, double time) |
|
{ |
|
if(fChannel) |
|
{ |
|
plMatrixChannel *matChan = plMatrixChannel::ConvertNoRef(fChannel); |
|
|
|
if(matChan) |
|
{ |
|
hsMatrix44 inverse; |
|
|
|
plProfile_BeginTiming(AffineValue); |
|
const hsAffineParts &ap = matChan->AffineValue(time); |
|
plProfile_EndTiming(AffineValue); |
|
|
|
hsMatrix44 result; |
|
|
|
plProfile_BeginTiming(AffineCompose); |
|
ap.ComposeMatrix(&result); |
|
ap.ComposeInverseMatrix(&inverse); |
|
//result.GetInverse(&inverse); |
|
plProfile_EndTiming(AffineCompose); |
|
|
|
plProfile_BeginTiming(MatrixApplicator); |
|
plCoordinateInterface *CI = IGetCI(mod); |
|
CI->SetLocalToParent(result, inverse); |
|
plProfile_EndTiming(MatrixApplicator); |
|
} |
|
} |
|
} |
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////// |
|
// |
|
// plMatrixDelayedCorrectionApplicator |
|
// |
|
/////////////////////////////////////////////////////////////////////////////////////////// |
|
|
|
const hsScalar plMatrixDelayedCorrectionApplicator::fDelayLength = 1.f; // seconds |
|
|
|
void plMatrixDelayedCorrectionApplicator::SetCorrection(hsMatrix44 &cor) |
|
{ |
|
if (fIgnoreNextCorrection) |
|
{ |
|
// We want the first correction we get from an avatar to be |
|
// instantaneous, otherwise they float over from (0, 0, 0). |
|
fIgnoreNextCorrection = false; |
|
return; |
|
} |
|
|
|
// decomp_affine seems to always give us the smaller angle quaternion, |
|
// which looks right visually when we interp. If certain cases become |
|
// visually annoying, we can check and adjust things here. |
|
gemAffineParts gemParts1; |
|
decomp_affine(cor.fMap, &gemParts1); |
|
AP_SET(fCorAP, gemParts1); |
|
|
|
fDelayStart = hsTimer::GetSysSeconds(); |
|
} |
|
|
|
|
|
// CANBLEND |
|
hsBool plMatrixDelayedCorrectionApplicator::CanBlend(plAGApplicator *app) |
|
{ |
|
plMatrixChannelApplicator *matChannelApp = plMatrixChannelApplicator::ConvertNoRef(app); |
|
|
|
if( plMatrixChannelApplicator::ConvertNoRef(app) ) |
|
{ |
|
return true; |
|
} |
|
return false; |
|
} |
|
|
|
// IAPPLY |
|
void plMatrixDelayedCorrectionApplicator::IApply(const plAGModifier *mod, double time) |
|
{ |
|
if(fChannel) |
|
{ |
|
if(fEnabled) |
|
{ |
|
plMatrixChannel *matChan = plMatrixChannel::ConvertNoRef(fChannel); |
|
hsAssert(matChan, "Invalid channel given to plMatrixChannelApplicator"); |
|
|
|
plProfile_BeginTiming(MatrixApplicator); |
|
plCoordinateInterface *CI = IGetCI(mod); |
|
const hsMatrix44 &animResult = matChan->Value(time); |
|
hsMatrix44 localResult; |
|
hsMatrix44 localInverse; |
|
|
|
if (time < fDelayStart + fDelayLength) |
|
{ |
|
hsAffineParts identAP; |
|
identAP.Reset(); |
|
hsAffineParts interpAP; |
|
hsMatrix44 interpResult; |
|
|
|
hsScalar blend = (hsScalar)((time - fDelayStart) / fDelayLength); |
|
hsInterp::LinInterp(&fCorAP, &identAP, blend, &interpAP); |
|
interpAP.ComposeMatrix(&interpResult); |
|
|
|
localResult = interpResult * animResult; |
|
localResult.GetInverse(&localInverse); |
|
CI->SetLocalToParent(localResult, localInverse); |
|
} |
|
else |
|
{ |
|
animResult.GetInverse(&localInverse); |
|
CI->SetLocalToParent(animResult, localInverse); |
|
} |
|
plProfile_EndTiming(MatrixApplicator); |
|
} |
|
} |
|
} |
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////// |
|
// |
|
// PLMATRIXDIFFERENCEAPPLICATOR |
|
// |
|
/////////////////////////////////////////////////////////////////////////////////////////// |
|
|
|
// Reset ------------------------------------- |
|
// ------ |
|
void plMatrixDifferenceApp::Reset(double time) |
|
{ |
|
hsAssert(fChannel,"Missing input channel when resetting."); |
|
if(fChannel) |
|
{ |
|
plMatrixChannel *matChan = plMatrixChannel::ConvertNoRef(fChannel); |
|
hsAssert(matChan, "Invalid channel given to plMatrixChannelApplicator"); |
|
if(matChan) |
|
{ |
|
hsMatrix44 L2A, A2L; |
|
const hsAffineParts &ap = matChan->AffineValue(time); |
|
ap.ComposeMatrix(&L2A); // what comes out of AffineValue is a local-to-animation |
|
ap.ComposeInverseMatrix(&A2L); |
|
|
|
fLastA2L = A2L; |
|
fLastL2A = L2A; |
|
} |
|
} |
|
} |
|
|
|
// CanBlend ----------------------------------------------- |
|
// --------- |
|
hsBool plMatrixDifferenceApp::CanBlend(plAGApplicator *app) |
|
{ |
|
plMatrixChannelApplicator *matChannelApp = plMatrixChannelApplicator::ConvertNoRef(app); |
|
|
|
if( plMatrixChannelApplicator::ConvertNoRef(app) ) |
|
{ |
|
return true; |
|
} |
|
return false; |
|
} |
|
|
|
// *** move this somewhere real |
|
bool CompareMatrices2(const hsMatrix44 &matA, const hsMatrix44 &matB, float tolerance) |
|
{ |
|
bool c00 = fabs(matA.fMap[0][0] - matB.fMap[0][0]) < tolerance; |
|
bool c01 = fabs(matA.fMap[0][1] - matB.fMap[0][1]) < tolerance; |
|
bool c02 = fabs(matA.fMap[0][2] - matB.fMap[0][2]) < tolerance; |
|
bool c03 = fabs(matA.fMap[0][3] - matB.fMap[0][3]) < tolerance; |
|
|
|
bool c10 = fabs(matA.fMap[1][0] - matB.fMap[1][0]) < tolerance; |
|
bool c11 = fabs(matA.fMap[1][1] - matB.fMap[1][1]) < tolerance; |
|
bool c12 = fabs(matA.fMap[1][2] - matB.fMap[1][2]) < tolerance; |
|
bool c13 = fabs(matA.fMap[1][3] - matB.fMap[1][3]) < tolerance; |
|
|
|
bool c20 = fabs(matA.fMap[2][0] - matB.fMap[2][0]) < tolerance; |
|
bool c21 = fabs(matA.fMap[2][1] - matB.fMap[2][1]) < tolerance; |
|
bool c22 = fabs(matA.fMap[2][2] - matB.fMap[2][2]) < tolerance; |
|
bool c23 = fabs(matA.fMap[2][3] - matB.fMap[2][3]) < tolerance; |
|
|
|
bool c30 = fabs(matA.fMap[3][0] - matB.fMap[3][0]) < tolerance; |
|
bool c31 = fabs(matA.fMap[3][1] - matB.fMap[3][1]) < tolerance; |
|
bool c32 = fabs(matA.fMap[3][2] - matB.fMap[3][2]) < tolerance; |
|
bool c33 = fabs(matA.fMap[3][3] - matB.fMap[3][3]) < tolerance; |
|
|
|
return c00 && c01 && c02 && c03 && c11 && c12 && c13 && c20 && c21 && c22 && c23 && c30 && c31 && c32 && c33; |
|
} |
|
|
|
// IAPPLY |
|
void plMatrixDifferenceApp::IApply(const plAGModifier *mod, double time) |
|
{ |
|
plMatrixChannel *matChan = plMatrixChannel::ConvertNoRef(fChannel); |
|
hsAssert(matChan, "Invalid channel given to plMatrixChannelApplicator"); |
|
hsMatrix44 L2A, A2L; |
|
|
|
const hsAffineParts &ap = matChan->AffineValue(time); |
|
|
|
plProfile_BeginTiming(AffineCompose); |
|
ap.ComposeMatrix(&L2A); // what comes out of AffineValue is a local-to-animation |
|
ap.ComposeInverseMatrix(&A2L); |
|
plProfile_EndTiming(AffineCompose); |
|
|
|
plProfile_BeginTiming(MatrixApplicator); |
|
if(fNew) // if it's new, there's no previous frame to diff against; |
|
{ // cache the current and don't do anything |
|
fLastA2L = A2L; |
|
fLastL2A = L2A; |
|
|
|
fNew = false; |
|
} else { |
|
if( ! CompareMatrices2(fLastA2L, A2L, .0001f) && ! CompareMatrices2(fLastL2A, L2A, .0001f)) |
|
{ |
|
plCoordinateInterface *CI = IGetCI(mod); |
|
|
|
hsMatrix44 l2p = CI->GetLocalToParent(); |
|
hsMatrix44 p2l = CI->GetParentToLocal(); |
|
|
|
hsMatrix44 prev2Cur = fLastA2L * L2A; // previous to current in local space |
|
hsMatrix44 cur2Prev = A2L * fLastL2A; // current to previous in local space |
|
|
|
hsMatrix44 newL2P = l2p * prev2Cur; |
|
hsMatrix44 newP2L = cur2Prev * p2l; |
|
|
|
CI->SetLocalToParent(newL2P, newP2L); |
|
CI->FlushTransform(); |
|
|
|
fLastL2A = L2A; |
|
fLastA2L = A2L; |
|
} |
|
} |
|
plProfile_EndTiming(MatrixApplicator); |
|
} |
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////// |
|
// |
|
// PLIK2APPLICATOR |
|
// |
|
/////////////////////////////////////////////////////////////////////////////////////////// |
|
|
|
/** A two-bone IK applicator. |
|
*/ |
|
class plIK2Applicator : public plMatrixChannelApplicator |
|
{ |
|
public: |
|
|
|
// The latest time we were asked to evaluate. We won't actually do the evaluation |
|
// until the other bone is asked as well. |
|
double GetUpdateTime(); |
|
|
|
void SetIsEndEffector(bool status); |
|
bool GetIsEndEffector(); |
|
|
|
void SetTarget(hsPoint3 &worldPoint); |
|
|
|
private: |
|
virtual void IApply(const plAGModifier *mod, double time); |
|
void ISolve(); |
|
// The other bone involved in the IK solution |
|
plIK2Applicator *fOtherBone; |
|
// The latest time we were asked to evaluate. We won't actually run our |
|
// process until the other guy is asked to evaluate the same time. |
|
double fUpdateTime; |
|
|
|
hsPoint3 fTarget; |
|
bool fIsEndEffector; |
|
}; |
|
|
|
// GetUpdateTime --------------- |
|
double plIK2Applicator::GetUpdateTime() |
|
{ |
|
return fUpdateTime; |
|
} |
|
|
|
void plIK2Applicator::SetIsEndEffector(bool status) |
|
{ |
|
fIsEndEffector = status; |
|
} |
|
|
|
bool plIK2Applicator::GetIsEndEffector() |
|
{ |
|
return fIsEndEffector; |
|
} |
|
|
|
void plIK2Applicator::IApply(const plAGModifier *mod, double time) |
|
{ |
|
fUpdateTime = time; |
|
if(time == fOtherBone->GetUpdateTime()) |
|
{ |
|
// we're both up-to-date: go ahead and solve |
|
ISolve(); |
|
} |
|
} |
|
|
|
void plIK2Applicator::ISolve() |
|
{ |
|
|
|
} |