FCDocument/FCDAnimated.h

Go to the documentation of this file.

/*
    Copyright (C) 2005-2006 Feeling Software Inc.
    MIT License: http://www.opensource.org/licenses/mit-license.php
*/
/*
    Based on the FS Import classes:
    Copyright (C) 2005-2006 Feeling Software Inc
    Copyright (C) 2005-2006 Autodesk Media Entertainment
    MIT License: http://www.opensource.org/licenses/mit-license.php
*/

#ifndef _FCD_ANIMATED_H_
#define _FCD_ANIMATED_H_

#include "FCDocument/FCDObject.h"

class FCDocument;
class FCDAnimated;
class FCDAnimationCurve;
class FCDAnimationChannel;
class FCDAnimationMultiCurve;

typedef vector<float*> FloatPtrList; 
typedef vector<FCDAnimationCurve*> FCDAnimationCurveList; 
typedef vector<FCDAnimationChannel*> FCDAnimationChannelList; 
typedef vector<FCDAnimated*> FCDAnimatedList; 
class FCOLLADA_EXPORT FCDAnimated : public FCDObject
{
private:
    DeclareObjectType;

protected:
    FloatPtrList values;

    StringList qualifiers; 

    FCDAnimationCurveList curves; 

    int32 arrayElement;

    string pointer; 

public:
    FCDAnimated(FCDocument* document, size_t valueCount);

    virtual ~FCDAnimated();

    inline size_t GetValueCount() const { return values.size(); }

    inline FCDAnimationCurve* GetCurve(size_t index) { FUAssert(index < GetValueCount(), return NULL); return curves.at(index); }
    inline const FCDAnimationCurve* GetCurve(size_t index) const { FUAssert(index < GetValueCount(), return NULL); return curves.at(index); } 
    inline FCDAnimationCurveList& GetCurves() { return curves; }
    inline const FCDAnimationCurveList& GetCurves() const { return curves; } 
    bool SetCurve(size_t index, FCDAnimationCurve* curve);

    bool RemoveCurve(size_t index);

    inline float* GetValue(size_t index) { FUAssert(index < GetValueCount(), return NULL); return values.at(index); }
    inline const float* GetValue(size_t index) const { FUAssert(index < GetValueCount(), return NULL); return values.at(index); } 
    inline const string& GetQualifier(size_t index) const;

    float* FindValue(const string& qualifier);
    const float* FindValue(const string& qualifier) const; 
    inline FCDAnimationCurve* FindCurve(const char* qualifier) { return GetCurve(FindQualifier(qualifier)); }
    inline FCDAnimationCurve* FindCurve(const string& qualifier) { return FindCurve(qualifier.c_str()); } 
    inline const FCDAnimationCurve* FindCurve(const char* qualifier) const { return GetCurve(FindQualifier(qualifier)); } 
    inline const FCDAnimationCurve* FindCurve(const string& qualifier) const { return FindCurve(qualifier.c_str()); } 
    inline FCDAnimationCurve* FindCurve(const float* value) { return GetCurve(FindValue(value)); }
    inline const FCDAnimationCurve* FindCurve(const float* value) const { return GetCurve(FindValue(value)); } 
    size_t FindQualifier(const char* qualifier) const;
    inline size_t FindQualifier(const string& qualifier) const { return FindQualifier(qualifier.c_str()); } 
    size_t FindValue(const float* value) const;

    inline int32 GetArrayElement() const { return arrayElement; }

    inline void SetArrayElement(int32 index) { arrayElement = index; }

    bool HasCurve() const;

    FCDAnimationMultiCurve* CreateMultiCurve() const;

    static FCDAnimationMultiCurve* CreateMultiCurve(const FCDAnimatedList& toMerge);

    void Evaluate(float time);

    static FCDAnimated* Clone(FCDocument* document, const float* animatedValue, FloatPtrList& newAnimatedValues);

    FCDAnimated* Clone(FCDocument* document);

    const string& GetTargetPointer() const { return pointer; }

    bool Link(xmlNode* node);

    bool ProcessChannels(FCDAnimationChannelList& channels);
};

class FCOLLADA_EXPORT FCDAnimatedFloat : public FCDAnimated
{
private:
    DeclareObjectType;

    // Don't build directly, use the Create function instead
    FCDAnimatedFloat(FCDocument* document, float* value, int32 arrayElement);

public:
    static FCDAnimatedFloat* Create(FCDocument* document, float* value, int32 arrayElement=-1);

    static FCDAnimatedFloat* Create(FCDocument* document, xmlNode* node, float* value, int32 arrayElement=-1);

    static FCDAnimated* Clone(FCDocument* document, const float* oldValue, float* newValue);
};

class FCOLLADA_EXPORT FCDAnimatedPoint3 : public FCDAnimated
{
private:
    DeclareObjectType;

    // Don't build directly, use the Create function instead
    FCDAnimatedPoint3(FCDocument* document, FMVector3* value, int32 arrayElement);

public:
    static FCDAnimatedPoint3* Create(FCDocument* document, FMVector3* value, int32 arrayElement=-1);

    static FCDAnimatedPoint3* Create(FCDocument* document, xmlNode* node, FMVector3* value, int32 arrayElement=-1);

    static FCDAnimated* Clone(FCDocument* document, const FMVector3* oldValue, FMVector3* newValue);
};

class FCOLLADA_EXPORT FCDAnimatedColor : public FCDAnimated
{
private:
    DeclareObjectType;

    // Don't build directly, use the Create function instead
    FCDAnimatedColor(FCDocument* document, FMVector3* value, int32 arrayElement);

public:
    static FCDAnimatedColor* Create(FCDocument* document, FMVector3* value, int32 arrayElement=-1);

    static FCDAnimatedColor* Create(FCDocument* document, xmlNode* node, FMVector3* value, int32 arrayElement=-1);

    static FCDAnimated* Clone(FCDocument* document, const FMVector3* oldValue, FMVector3* newValue);
};

class FCOLLADA_EXPORT FCDAnimatedAngle : public FCDAnimated
{
private:
    DeclareObjectType;

    // Don't build directly, use the Create function instead
    FCDAnimatedAngle(FCDocument* document, float* value, int32 arrayElement);

public:
    static FCDAnimatedAngle* Create(FCDocument* document, float* value, int32 arrayElement=-1);

    static FCDAnimatedAngle* Create(FCDocument* document, xmlNode* node, float* value, int32 arrayElement=-1);

    static FCDAnimated* Clone(FCDocument* document, const float* oldValue, float* newValue);
};

class FCOLLADA_EXPORT FCDAnimatedAngleAxis : public FCDAnimated
{
private:
    DeclareObjectType;

    // Don't build directly, use the Create function instead
    FCDAnimatedAngleAxis(FCDocument* document, FMVector3* axis, float* angle, int32 arrayElement);

public:
    static FCDAnimatedAngleAxis* Create(FCDocument* document, FMVector3* value, float* angle, int32 arrayElement=-1);

    static FCDAnimatedAngleAxis* Create(FCDocument* document, xmlNode* node, FMVector3* axis, float* angle, int32 arrayElement=-1);

    static FCDAnimated* Clone(FCDocument* document, const float* oldAngle, FMVector3* newAxis, float* newAngle);
};

class FCOLLADA_EXPORT FCDAnimatedMatrix : public FCDAnimated
{
private:
    DeclareObjectType;

    // Don't build directly, use the Create function instead
    FCDAnimatedMatrix(FCDocument* document, FMMatrix44* value, int32 arrayElement);

public:
    static FCDAnimatedMatrix* Create(FCDocument* document, FMMatrix44* value, int32 arrayElement=-1);

    static FCDAnimatedMatrix* Create(FCDocument* document, xmlNode* node, FMMatrix44* value, int32 arrayElement=-1);

    static FCDAnimated* Clone(FCDocument* document, const FMMatrix44* oldMx, FMMatrix44* newMx);
};

class FCOLLADA_EXPORT FCDAnimatedCustom : public FCDAnimated
{
private:
    DeclareObjectType;
    float dummy;

    // Don't build directly, use the Create function instead
    FCDAnimatedCustom(FCDocument* document);

    bool Link(xmlNode* node);

public:
    static FCDAnimatedCustom* Create(FCDocument* document);

    static FCDAnimatedCustom* Create(FCDocument* document, xmlNode* node);

    const float& GetDummy() const { return dummy; }
};

#endif // _FCD_ANIMATED_H_

---