SG_Spatial.h

Go to the documentation of this file.

/*
 * ***** BEGIN GPL LICENSE BLOCK *****
 *
 * 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 2
 * 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, write to the Free Software Foundation,
 * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 *
 * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
 * All rights reserved.
 *
 * The Original Code is: all of this file.
 *
 * Contributor(s): none yet.
 *
 * ***** END GPL LICENSE BLOCK *****
 */

#ifndef __SG_SPATIAL_H
#define __SG_SPATIAL_H

#include <MT_Vector3.h>
#include <MT_Point3.h>
#include <MT_Matrix3x3.h> // or Quaternion later ?
#include "SG_IObject.h"
#include "SG_BBox.h"
#include "SG_ParentRelation.h"


class SG_Node;
class SG_ParentRelation;

class SG_Spatial : public SG_IObject
{

protected:
    MT_Point3       m_localPosition;
    MT_Matrix3x3        m_localRotation;
    MT_Vector3      m_localScaling;

    MT_Point3       m_worldPosition;
    MT_Matrix3x3        m_worldRotation;
    MT_Vector3      m_worldScaling;
    
    SG_ParentRelation * m_parent_relation;
    
    SG_BBox         m_bbox;
    MT_Scalar       m_radius;
    bool            m_modified;
    bool            m_ogldirty;     // true if the openGL matrix for this object must be recomputed

public:
    inline void ClearModified() 
    { 
        m_modified = false; 
        m_ogldirty = true;
    }
    inline void SetModified()
    {
        m_modified = true;
        ActivateScheduleUpdateCallback();
    }
    inline void ClearDirty()
    {
        m_ogldirty = false;
    }
        void
    SetParentRelation(
        SG_ParentRelation *relation
    );
    
    SG_ParentRelation * GetParentRelation()
    {
        return m_parent_relation;
    }




        void
    RelativeTranslate(
        const MT_Vector3& trans,
        const SG_Spatial *parent,
        bool local
    );

    void SetLocalPosition(const MT_Point3& trans)
    {
        m_localPosition = trans;
        SetModified();
    }

    void SetWorldPosition(const MT_Point3& trans)
    {
        m_worldPosition = trans;
    }

    
        void                
    RelativeRotate(
        const MT_Matrix3x3& rot,
        bool local
    );

    void SetLocalOrientation(const MT_Matrix3x3& rot)
    {
        m_localRotation = rot;
        SetModified();
    }

    // rot is arrange like openGL matrix
    void SetLocalOrientation(const float* rot)
    {
        m_localRotation.setValue(rot);
        SetModified();
    }

    void SetWorldOrientation(const MT_Matrix3x3& rot) 
    {
        m_worldRotation = rot;
    }

    void RelativeScale(const MT_Vector3& scale)
    {
        m_localScaling = m_localScaling * scale;
        SetModified();
    }

    void SetLocalScale(const MT_Vector3& scale)
    {
        m_localScaling = scale;
        SetModified();
    }

    void SetWorldScale(const MT_Vector3& scale)
    { 
        m_worldScaling = scale;
    }

    const MT_Point3& GetLocalPosition() const   
    {
        return m_localPosition;
    }

    const MT_Matrix3x3& GetLocalOrientation() const 
    {
        return m_localRotation;
    }

    const MT_Vector3& GetLocalScale() const
    {
        return m_localScaling;
    }

    const MT_Point3& GetWorldPosition() const   
    {
        return m_worldPosition;
    }

    const MT_Matrix3x3& GetWorldOrientation() const 
    {
        return m_worldRotation;
    }

    const MT_Vector3& GetWorldScaling() const   
    {
        return m_worldScaling;
    }

    void SetWorldFromLocalTransform()
    {
        m_worldPosition= m_localPosition;
        m_worldScaling= m_localScaling;
        m_worldRotation= m_localRotation;
    }



    MT_Transform GetWorldTransform() const;

    bool    ComputeWorldTransforms(const SG_Spatial *parent, bool& parentUpdated)
    {
        return m_parent_relation->UpdateChildCoordinates(this,parent,parentUpdated);
    }


    SG_BBox& BBox()
    {
        return m_bbox;
    }

    void SetBBox(SG_BBox& bbox)
    {
        m_bbox = bbox;
    }


    bool inside(const MT_Point3 &point) const;
    void getBBox(MT_Point3 *box) const;
    void getAABBox(MT_Point3 *box) const;
    
    MT_Scalar Radius() const { return m_radius; }
    void SetRadius(MT_Scalar radius) { m_radius = radius; }
    bool IsModified() { return m_modified; }
    bool IsDirty() { return m_ogldirty; }
    
protected:
    friend class SG_Controller;
    friend class KX_BoneParentRelation;
    friend class KX_VertexParentRelation;
    friend class KX_SlowParentRelation;
    friend class KX_NormalParentRelation;
    
    SG_Spatial(
        void* clientobj,
        void* clientinfo,
        SG_Callbacks& callbacks
    );

    SG_Spatial(
        const SG_Spatial& other
    );


    virtual ~SG_Spatial();

        bool 
    UpdateSpatialData(
        const SG_Spatial *parent,
        double time,
        bool& parentUpdated
    );


#ifdef WITH_CXX_GUARDEDALLOC
public:
    void *operator new(size_t num_bytes) { return MEM_mallocN(num_bytes, "GE:SG_Spatial"); }
    void operator delete( void *mem ) { MEM_freeN(mem); }
#endif
};

#endif //__SG_SPATIAL_H