FCDocument/FCDTransform.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_TRANSFORM_H_
#define _FCD_TRANSFORM_H_

class FCDocument;
class FCDSceneNode;

#include "FCDocument/FCDObject.h"

class FCOLLADA_EXPORT FCDTransform : public FCDObject
{
public:
    enum Type
    {
        TRANSLATION, 
        ROTATION, 
        SCALE, 
        MATRIX, 
        LOOKAT, 
        SKEW 
    };

private:
    DeclareObjectType;
    FCDSceneNode* parent;

public:
    FCDTransform(FCDocument* document, FCDSceneNode* parent);

    virtual ~FCDTransform();

    FCDSceneNode* GetParent() { return parent; }
    const FCDSceneNode* GetParent() const { return parent; } 
    virtual FCDTransform* Clone(FCDSceneNode* newParent) = 0;

    virtual Type GetType() const = 0;

    virtual FMMatrix44 ToMatrix() const = 0;

    virtual bool IsAnimated() const = 0;

    virtual FCDAnimated* GetAnimated() = 0;

    virtual bool IsInverse(const FCDTransform* transform) const;

    virtual FUStatus LoadFromXML(xmlNode* transformNode) = 0;

    virtual xmlNode* WriteToXML(xmlNode* parentNode) const = 0;
};

class FCOLLADA_EXPORT FCDTTranslation : public FCDTransform
{
private:
    DeclareObjectType;
    FMVector3 translation;

public:
    FCDTTranslation(FCDocument* document, FCDSceneNode* parent);
    
    virtual ~FCDTTranslation();

    virtual Type GetType() const { return TRANSLATION; }

    inline FMVector3& GetTranslation() { return translation; }
    inline const FMVector3& GetTranslation() const { return translation; } 
    inline void SetTranslation(const FMVector3& _translation) { translation = _translation; }

    inline void SetTranslation(float x, float y, float z) { translation = FMVector3(x, y, z); }

    virtual FMMatrix44 ToMatrix() const;

    virtual bool IsAnimated() const;

    virtual FCDAnimated* GetAnimated();

    virtual bool IsInverse(const FCDTransform* transform) const;

    virtual FCDTransform* Clone(FCDSceneNode* newParent);

    virtual FUStatus LoadFromXML(xmlNode* translationNode);

    virtual xmlNode* WriteToXML(xmlNode* parentNode) const;
};

class FCOLLADA_EXPORT FCDTScale : public FCDTransform
{
private:
    DeclareObjectType;
    FMVector3 scale;

public:
    FCDTScale(FCDocument* document, FCDSceneNode* parent);

    virtual ~FCDTScale();

    virtual Type GetType() const { return SCALE; }

    FMVector3& GetScale() { return scale; }
    const FMVector3& GetScale() const { return scale; } 
    inline void SetScale(const FMVector3& _scale) { scale = _scale; }

    inline void SetScale(float x, float y, float z) { scale = FMVector3(x, y, z); }

    virtual FMMatrix44 ToMatrix() const;

    virtual bool IsAnimated() const;

    virtual FCDAnimated* GetAnimated();

    virtual FCDTransform* Clone(FCDSceneNode* newParent);

    virtual FUStatus LoadFromXML(xmlNode* scaleNode);

    virtual xmlNode* WriteToXML(xmlNode* parentNode) const;
};

class FCOLLADA_EXPORT FCDTRotation : public FCDTransform
{
private:
    DeclareObjectType;
    float angle;
    FMVector3 axis;

public:
    FCDTRotation(FCDocument* document, FCDSceneNode* parent);
    
    virtual ~FCDTRotation();

    virtual Type GetType() const { return ROTATION; }

    inline FMVector3& GetAxis() { return axis; }
    inline const FMVector3& GetAxis() const { return axis; } 
    inline void SetAxis(const FMVector3& _axis) { axis = _axis; }

    inline void SetAxis(float x, float y, float z) { axis = FMVector3(x, y, z); }

    inline float& GetAngle() { return angle; }
    inline const float& GetAngle() const { return angle; } 
    inline void SetAngle(float a) { angle = a; }

    inline void SetRotation(const FMVector3& _axis, float a) { axis = _axis; angle = a; }

    virtual FMMatrix44 ToMatrix() const;

    virtual bool IsAnimated() const;

    virtual FCDAnimated* GetAnimated();

    virtual bool IsInverse(const FCDTransform* transform) const;

    virtual FCDTransform* Clone(FCDSceneNode* newParent);

    virtual FUStatus LoadFromXML(xmlNode* rotationNode);

    virtual xmlNode* WriteToXML(xmlNode* parentNode) const;
};

class FCOLLADA_EXPORT FCDTMatrix : public FCDTransform
{
private:
    DeclareObjectType;
    FMMatrix44 transform;

public:
    FCDTMatrix(FCDocument* document, FCDSceneNode* parent);

    virtual ~FCDTMatrix();
    
    virtual Type GetType() const { return MATRIX; }

    FMMatrix44& GetTransform() { return transform; }
    const FMMatrix44& GetTransform() const { return transform; } 
    inline void SetTransform(const FMMatrix44& mx) { transform = mx; }

    virtual FMMatrix44 ToMatrix() const { return transform; }

    virtual bool IsAnimated() const;

    virtual FCDAnimated* GetAnimated();

    virtual FCDTransform* Clone(FCDSceneNode* newParent);

    virtual FUStatus LoadFromXML(xmlNode* matrixNode);

    virtual xmlNode* WriteToXML(xmlNode* parentNode) const;
};

class FCOLLADA_EXPORT FCDTLookAt : public FCDTransform
{
private:
    DeclareObjectType;
    FMVector3 position;
    FMVector3 target;
    FMVector3 up;

public:
    FCDTLookAt(FCDocument* document, FCDSceneNode* parent);

    virtual ~FCDTLookAt();

    virtual Type GetType() const { return LOOKAT; }

    FMVector3& GetPosition() { return position; }
    const FMVector3& GetPosition() const { return position; } 
    inline void SetPosition(const FMVector3& pos) { position = pos; }

    inline void SetPosition(float x, float y, float z) { position = FMVector3(x, y, z); }

    FMVector3& GetTarget() { return target; }
    const FMVector3& GetTarget() const { return target; } 
    inline void SetTarget(const FMVector3& _target) { target = _target; }

    inline void SetTarget(float x, float y, float z) { target = FMVector3(x, y, z); }

    FMVector3& GetUp() { return up; }
    const FMVector3& GetUp() const { return up; } 
    inline void SetUp(const FMVector3& _up) { up = _up; }

    inline void SetUp(float x, float y, float z) { up = FMVector3(x, y, z); }

    virtual FMMatrix44 ToMatrix() const;

    virtual bool IsAnimated() const;

    virtual FCDAnimated* GetAnimated();

    virtual FCDTransform* Clone(FCDSceneNode* newParent);

    virtual FUStatus LoadFromXML(xmlNode* lookAtNode);

    virtual xmlNode* WriteToXML(xmlNode* parentNode) const;
};

class FCOLLADA_EXPORT FCDTSkew : public FCDTransform
{
private:
    DeclareObjectType;
    FMVector3 rotateAxis;
    FMVector3 aroundAxis;
    float angle;

public:
    FCDTSkew(FCDocument* document, FCDSceneNode* parent);

    virtual ~FCDTSkew();

    virtual Type GetType() const { return SKEW; }

    const FMVector3& GetRotateAxis() const { return rotateAxis; }

    inline void SetRotateAxis(const FMVector3& axis) { rotateAxis = axis; }

    const FMVector3& GetAroundAxis() const { return aroundAxis; }

    inline void SetAroundAxis(const FMVector3& axis) { aroundAxis = axis; }

    const float& GetAngle() { return angle; }

    inline void SetAngle(float _angle) { angle = _angle; }

    virtual FMMatrix44 ToMatrix() const;

    virtual bool IsAnimated() const;

    virtual FCDAnimated* GetAnimated();

    virtual FCDTransform* Clone(FCDSceneNode* newParent);

    virtual FUStatus LoadFromXML(xmlNode* skewNode);

    virtual xmlNode* WriteToXML(xmlNode* parentNode) const;
};

class FCOLLADA_EXPORT FCDTFactory
{
private:
    FCDTFactory() {} // Static class: do not instantiate.

public:
    static FCDTransform* CreateTransform(FCDocument* document, FCDSceneNode* parent, FCDTransform::Type type);

    static FCDTransform* CreateTransform(FCDocument* document, FCDSceneNode* parent, xmlNode* node);
};

#endif // _FR_TRANSFORM_H_

---