Object3d.h

Go to the documentation of this file.

//========================================================================
// Copyright (c) 2003-2011 Anael Seghezzi <www.maratis3d.com>
// Copyright (c) 2014-2015 Yannick Pflanzer <www.neo-engine.de>
//
// This software is provided 'as-is', without any express or implied
// warranty. In no event will the authors be held liable for any damages
// arising from the use of this software.
//
// Permission is granted to anyone to use this software for any purpose,
// including commercial applications, and to alter it and redistribute it
// freely, subject to the following restrictions:
//
// 1. The origin of this software must not be misrepresented; you must not
//    claim that you wrote the original software. If you use this software
//    in a product, an acknowledgment in the product documentation would
//    be appreciated but is not required.
//
// 2. Altered source versions must be plainly marked as such, and must not
//    be misrepresented as being the original software.
//
// 3. This notice may not be removed or altered from any source
//    distribution.
//
//========================================================================

#ifndef __OBJECT3D_H
#define __OBJECT3D_H

namespace Neo
{

class NEO_ENGINE_EXPORT Object3d
{
public:

    // constructor
    Object3d(void);

    // destructor
    virtual ~Object3d(void);

    // copy constructor
    Object3d(const Object3d & object);

protected:

    String m_name;

    Vector3 m_position;

    Vector3 m_scale;

    Quaternion m_rotation;

    Matrix4x4 m_matrix;

    vector<Object3d*> m_children;

    // Attributes
    #if __cplusplus >= 201103L
        typedef unordered_map<string, NeoVariable>::iterator AttributeIterator ;
        unordered_map <string, NeoVariable> m_attributes;
    #else
        typedef map<string, NeoVariable>::iterator AttributeIterator;
        map <string, NeoVariable> m_attributes;
    #endif

    // properties
    bool m_isActive;
    bool m_isVisible;
    bool m_needToUpdate;

    unsigned long m_id;

    // linking
    Object3d * m_parent;

    vector <Behavior *> m_behaviors;

public:
    // Definition of some additional data
    class AdditionalData {};

private:

    AdditionalData* m_additionalData;

    void removeChild(Object3d* child);

protected:

    void clearObject3d(void);

public:

    AdditionalData* getAdditionalData() { return m_additionalData; }
    void setAdditionalData(AdditionalData* d) { m_additionalData = d; }

    void updateMatrix(void);

    void computeLocalMatrix(void);

    inline Matrix4x4 *  getMatrix(void){ return &m_matrix; }

    void unlinkChildren(void);

    void computeChildrenMatrices(void);

    inline void setAttribute(const char* name, NeoVariable variable)
    {
        m_attributes[name] = variable;
    }

    inline NeoVariable getAttribute(const char* name)
    {
        return m_attributes[name];
    };

    Vector3 getUniformRotatedVector(const Vector3 & vector);

    inline Vector3 getInverseRotatedVector(const Vector3& vector) const
    {
        return m_matrix.getInverseRotatedVector3(vector);
    }

    inline Vector3 getRotatedVector(const Vector3& vector) const
    {
        return m_matrix.getRotatedVector3(vector);
    }

    inline Vector3 getInversePosition(const Vector3& position) const
    {
        return m_matrix.getInverse() * position;
    }

    inline Vector3 getTransformedVector(const Vector3& vector) const
    {
        return m_matrix * vector;
    }

    void setPosition(const Vector3& position);

    inline void translate(const Vector3& vec, bool local = false)
    {
        m_position += (local ? (vec + getTransformedVector(vec)) : vec);
        m_needToUpdate = true;
    }

    inline void rotate(const Vector3& axis, float angle, bool local = false)
    {
        addAxisAngleRotation((local) ? (getInverseRotatedVector(axis)) : axis,
                             angle);
    }

    inline Vector3 getTransformedPosition(void) const
    {
        return Vector3(m_matrix.entries[12], m_matrix.entries[13],
                       m_matrix.entries[14]);
    }

    inline Vector3 getPosition(void) const { return m_position; }

    void setEulerRotation(const Vector3& euler);

    void setAxisAngleRotation(const Vector3& axis, float angle);

    void addAxisAngleRotation(const Vector3& axis, float angle);

    void setRotation(const Quaternion& rotation);

    inline Vector3 getTransformedRotation(void) const
    {
        return m_matrix.getEulerAngles();
    }

    inline Vector3 getEulerRotation(void) const
    {
        return m_rotation.getEulerAngles();
    }

    inline Quaternion getRotation(void) const { return m_rotation; }

    void setScale(const Vector3& scale);

    inline Vector3 getTransformedScale(void) const
    {
        return m_matrix.getScale();
    }

    inline Vector3 getScale(void) const { return m_scale; }

    void linkTo(Object3d* parent);

    void unLink(void);

    inline void setParent(Object3d* object) { m_parent = object; }

    inline void addChild(Object3d* child) { m_children.push_back(child); }

    inline bool hasParent(void) { return (m_parent != NULL); }

    inline unsigned int getChildrenNumber(void) { return m_children.size(); }

    inline Object3d* getParent(void) { return m_parent; }

    inline Object3d* getChild(unsigned int id) { return m_children[id]; }

    unsigned long getId() { return m_id; }

    void setId(unsigned long id) { m_id = id; }

    void updateBehaviors(void);

    void drawBehaviors(void);

    void deleteBehavior(unsigned int id);

    void invertBehavior(unsigned int idA, unsigned int idB);

    void changeBehavior(unsigned int id, Behavior* behavior);

    inline void addBehavior(Behavior* behavior)
    {
        m_behaviors.push_back(behavior);
    }

    inline unsigned int getBehaviorsNumber(void) { return m_behaviors.size(); }

    inline Behavior* getBehavior(unsigned int id) { return m_behaviors[id]; }

    inline bool needToUpdate(void) { return m_needToUpdate; }

    virtual void setActive(bool active) { m_isActive = active; }

    inline bool isActive(void) { return m_isActive; }

    inline void setVisible(bool visible) { m_isVisible = visible; }

    inline bool isVisible(void) { return m_isVisible; }

    virtual void updateVisibility(OCamera* camera) {}

    void setName(const char* name);

    inline const char* getName(void) { return m_name.getSafeString(); }

    virtual int getType(void) { return OBJECT3D; }

    virtual void update(void);
};
}

#endif