CWE-ou-minkata/Sources/Plasma/PubUtilLib/plInterp/plController.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 HSCONTROLLER_inc
#define HSCONTROLLER_inc

#include "HeadSpin.h"
#include "pnFactory/plCreatable.h"
#include "hsColorRGBA.h"
#include "hsKeys.h"
#include "hsTemplates.h"

class hsResMgr;

struct hsScaleValue;
struct hsScalarKey;
struct hsPoint3Key;
struct hsScalarTriple;
struct hsMatrix33;
struct hsMatrix44;
class hsQuat;
class hsAffineParts;
class plScalarCurve;
class plAnimTimeConvert;
class plCompoundController;

//
//////////////////////////////////////////////////////////////
// base controller class.
// Controllers correspond to Max controllers.
// Some are leaf controllers which actually have keys, these can also have
// multiple ease and multiplier controllers.
// Some are compound controllers, which just contain other (leaf) controllers.
// Leaf controllers have lists of keys (or plCurves which are just wrappers for
// the lists of keys).
//

class plControllerCacheInfo
{
public:
    UInt8 fNumSubControllers;   
    plControllerCacheInfo **fSubControllers;

    UInt32 fKeyIndex;
    plAnimTimeConvert *fAtc;

    plControllerCacheInfo();
    ~plControllerCacheInfo();

    void SetATC(plAnimTimeConvert *atc);
};

//
//////////////////////////////////////////////////////////////
// defines base methods
//
class plController : public plCreatable
{
public:
    CLASSNAME_REGISTER( plController );
    GETINTERFACE_ANY( plController, plCreatable );

    virtual void Interp(hsScalar time, hsScalar* result, plControllerCacheInfo *cache = nil) const {}
    virtual void Interp(hsScalar time, hsScalarTriple* result, plControllerCacheInfo *cache = nil) const {}
    virtual void Interp(hsScalar time, hsScaleValue* result, plControllerCacheInfo *cache = nil) const {}
    virtual void Interp(hsScalar time, hsQuat* result, plControllerCacheInfo *cache = nil) const {}
    virtual void Interp(hsScalar time, hsMatrix33* result, plControllerCacheInfo *cache = nil) const {}
    virtual void Interp(hsScalar time, hsMatrix44* result, plControllerCacheInfo *cache = nil) const {}
    virtual void Interp(hsScalar time, hsColorRGBA* result, plControllerCacheInfo *cache = nil) const {}
    virtual void Interp(hsScalar time, hsAffineParts* parts, plControllerCacheInfo *cache = nil) const {}

    virtual plControllerCacheInfo* CreateCache() const { return nil; } // Caller must handle deleting the pointer.
    virtual hsScalar GetLength() const = 0;
    virtual void GetKeyTimes(hsTArray<hsScalar> &keyTimes) const = 0;
    virtual hsBool AllKeysMatch() const = 0;

    // Checks each of our subcontrollers (if we have any) and deletes any that
    // are nothing but matching keys. Returns true if this controller itself
    // is redundant.
    virtual hsBool PurgeRedundantSubcontrollers() = 0;
};

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

class plLeafController : public plController 
{
    friend class plCompoundController;

protected:
    UInt8 fType;
    void *fKeys; // Need to pay attend to fType to determine what these actually are
    UInt32 fNumKeys;
    mutable UInt32 fLastKeyIdx;

public:
    plLeafController() : fType(hsKeyFrame::kUnknownKeyFrame), fKeys(nil), fNumKeys(0), fLastKeyIdx(0) {}
    virtual ~plLeafController();

    CLASSNAME_REGISTER( plLeafController );
    GETINTERFACE_ANY( plLeafController, plController );

    void Interp(hsScalar time, hsScalar* result, plControllerCacheInfo *cache = nil) const;
    void Interp(hsScalar time, hsScalarTriple* result, plControllerCacheInfo *cache = nil) const;
    void Interp(hsScalar time, hsScaleValue* result, plControllerCacheInfo *cache = nil) const;
    void Interp(hsScalar time, hsQuat* result, plControllerCacheInfo *cache = nil) const;
    void Interp(hsScalar time, hsMatrix33* result, plControllerCacheInfo *cache = nil) const;
    void Interp(hsScalar time, hsMatrix44* result, plControllerCacheInfo *cache = nil) const;
    void Interp(hsScalar time, hsColorRGBA* result, plControllerCacheInfo *cache = nil) const;

    virtual plControllerCacheInfo* CreateCache() const;
    hsScalar GetLength() const;
    UInt32 GetStride() const;

    hsPoint3Key *GetPoint3Key(UInt32 i) const;
    hsBezPoint3Key *GetBezPoint3Key(UInt32 i) const;
    hsScalarKey *GetScalarKey(UInt32 i) const;
    hsBezScalarKey *GetBezScalarKey(UInt32 i) const;
    hsScaleKey *GetScaleKey(UInt32 i) const;
    hsBezScaleKey *GetBezScaleKey(UInt32 i) const;
    hsQuatKey *GetQuatKey(UInt32 i) const;
    hsCompressedQuatKey32 *GetCompressedQuatKey32(UInt32 i) const;
    hsCompressedQuatKey64 *GetCompressedQuatKey64(UInt32 i) const;
    hsG3DSMaxKeyFrame *Get3DSMaxKey(UInt32 i) const;
    hsMatrix33Key *GetMatrix33Key(UInt32 i) const;
    hsMatrix44Key *GetMatrix44Key(UInt32 i) const;

    UInt8 GetType() const { return fType; }
    UInt32 GetNumKeys() const { return fNumKeys; }
    void *GetKeyBuffer() const { return fKeys; }
    void GetKeyTimes(hsTArray<hsScalar> &keyTimes) const;
    void AllocKeys(UInt32 n, UInt8 type);
    void QuickScalarController(int numKeys, hsScalar* times, hsScalar* values, UInt32 valueStrides);
    hsBool AllKeysMatch() const;
    hsBool PurgeRedundantSubcontrollers();

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


////////////////////////////////////////////////////////////////////////////////
// NON-LEAF (container) CONTROLLERS
////////////////////////////////////////////////////////////////////////////////
//

class plCompoundController : public plController
{
private:
    plController* fXController;
    plController* fYController;
    plController* fZController;

public:
    plCompoundController(); // allocs leaf controllers
    ~plCompoundController();

    CLASSNAME_REGISTER( plCompoundController );
    GETINTERFACE_ANY( plCompoundController, plController );

    void Interp(hsScalar time, hsQuat* result, plControllerCacheInfo *cache = nil) const;
    void Interp(hsScalar time, hsScalarTriple* result, plControllerCacheInfo *cache = nil) const;
    void Interp(hsScalar time, hsAffineParts* parts, plControllerCacheInfo *cache = nil) const;
    void Interp(hsScalar time, hsColorRGBA* result, plControllerCacheInfo *cache = nil) const;

    plControllerCacheInfo* CreateCache() const;
    plController *GetXController() const { return fXController; }
    plController *GetYController() const { return fYController; }
    plController *GetZController() const { return fZController; }
    plController *GetPosController() const { return fXController; }
    plController *GetRotController() const { return fYController; }
    plController *GetScaleController() const { return fZController; }
    plController *GetController(Int32 i) const;
    hsScalar GetLength() const;
    void GetKeyTimes(hsTArray<hsScalar> &keyTimes) const;
    hsBool AllKeysMatch() const;
    hsBool PurgeRedundantSubcontrollers();

    void SetXController(plController *c) { delete fXController; fXController = c; }
    void SetYController(plController *c) { delete fYController; fYController = c; }
    void SetZController(plController *c) { delete fZController; fZController = c; }
    void SetPosController(plController *c) { delete fXController; fXController = c; }
    void SetRotController(plController *c) { delete fYController; fYController = c; }
    void SetScaleController(plController *c) { delete fZController; fZController = c; }
    void SetController(Int32 i, plController* c);

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

#endif