blender/source/gameengine/SceneGraph/SG_Spatial.h
Campbell Barton 14d33b3c1f BGE guardedalloc, Uses WITH_CXX_GUARDEDALLOC but gives a string to MEM_mallocN for better tracking memory usage.
* off by default.
* new/delete are at the bottom of each class
* python BGE objects have the new/delete in the Py_Header macro.
2009-08-18 15:37:31 +00:00

296 lines
6.2 KiB
C++

/**
* $Id$
*
* ***** 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, 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;
/**
* SG_Spatial contains spatial information (local & world position, rotation
* and scaling) for a Scene graph node.
* It also contains a link to the node's parent.
*/
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;
}
/**
* Define the realtionship this node has with it's parent
* node. You should pass an unshared instance of an SG_ParentRelation
* allocated on the heap to this method. Ownership of this
* instance is assumed by this class.
* You may call this function several times in the lifetime
* of a node to change the relationship dynamically.
* You must call this method before the first call to UpdateSpatialData().
* An assertion willl be fired at run-time in debug if this is not
* the case.
* The relation is activated only if no controllers of this object
* updated the coordinates of the child.
*/
void
SetParentRelation(
SG_ParentRelation *relation
);
SG_ParentRelation * GetParentRelation()
{
return m_parent_relation;
}
/**
* Apply a translation relative to the current position.
* if local then the translation is assumed to be in the
* local coordinates of this object. If not then the translation
* is assumed to be in global coordinates. In this case
* you must provide a pointer to the parent of this object if it
* exists otherwise if there is no parent set it to NULL
*/
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);
}
/**
* Bounding box functions.
*/
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;
/**
* Protected constructor this class is not
* designed for direct instantiation
*/
SG_Spatial(
void* clientobj,
void* clientinfo,
SG_Callbacks& callbacks
);
SG_Spatial(
const SG_Spatial& other
);
virtual ~SG_Spatial();
/**
* Update the world coordinates of this spatial node. This also informs
* any controllers to update this object.
*/
bool
UpdateSpatialData(
const SG_Spatial *parent,
double time,
bool& parentUpdated
);
#ifdef WITH_CXX_GUARDEDALLOC
public:
void *operator new( unsigned int num_bytes) { return MEM_mallocN(num_bytes, "GE:SG_Spatial"); }
void operator delete( void *mem ) { MEM_freeN(mem); }
#endif
};
#endif //__SG_SPATIAL_H