178 lines
4.5 KiB
C++
178 lines
4.5 KiB
C++
/* -----------------------------------------------------------------------------
|
|
GSFramework
|
|
Copyright 2001-2013 Emmanuel Julien. All Rights Reserved.
|
|
----------------------------------------------------------------------------- */
|
|
|
|
|
|
#ifndef __NITEM__
|
|
#define __NITEM__
|
|
|
|
|
|
#include "math/matrix3.h"
|
|
#include "math/matrix4.h"
|
|
#include "math/quaternion.h"
|
|
#include "data/registry.h"
|
|
#include "memory/bit_field.h"
|
|
|
|
|
|
namespace GS {
|
|
class MinMax;
|
|
class Frustum;
|
|
|
|
namespace Core {
|
|
struct ResourceFactories;
|
|
class Item;
|
|
|
|
typedef List <Item *> ItemList;
|
|
|
|
/*!
|
|
@short Common properties to light/object and camera.
|
|
|
|
This class describe a location and orientation in space.
|
|
The position is described as a vector.
|
|
@see nVector.
|
|
|
|
Items can be parented to form a hierarchy where each child inherits its
|
|
parent transformation.
|
|
@see SetParent().
|
|
|
|
@author Emmanuel Julien (ejulien@gsworks.fr)
|
|
*/
|
|
class Item
|
|
{
|
|
public:
|
|
|
|
#define ItemFlagNone 0
|
|
|
|
#define ItemFlagHasTarget (1 << 0)
|
|
#define ItemFlagInvisible (1 << 1)
|
|
#define ItemFlagInheritPositionOnly (1 << 2)
|
|
|
|
#define ItemFlagLocalMatrixDirty (1 << 3)
|
|
#define ItemFlagWorldMatrixDirty (1 << 4)
|
|
#define ItemFlagInverseWorldMatrixDirty (1 << 5)
|
|
#define ItemFlagRotationMatrixDirty (1 << 6)
|
|
|
|
#define ItemFlagBoneHint (1 << 16)
|
|
|
|
private:
|
|
|
|
Math::rOrder rorder; ///< Euler rotation order.
|
|
Vector4 position, ///< Position.
|
|
rotation, ///< Orientation as 3 Euler angles.
|
|
scale; ///< Scale.
|
|
|
|
Matrix3 rotation_matrix;
|
|
|
|
protected:
|
|
|
|
Item *parent; ///< Parent item. The item will inherit all of its parent motion.
|
|
ItemList children;
|
|
|
|
Matrix4 local_matrix, ///< Local matrix.
|
|
prv_matrix, ///< Previous world matrix.
|
|
matrix, ///< World matrix.
|
|
imatrix; ///< Inverse world matrix.
|
|
Matrix4 pivot_matrix; ///< Offset matrix.
|
|
|
|
/// Compute world local matrix.
|
|
void ComputeLocalMatrix();
|
|
/// Compute world hierarchy matrix.
|
|
virtual void ComputeMatrix();
|
|
/// Compute world inverse matrix.
|
|
void ComputeInverseMatrix();
|
|
|
|
public:
|
|
|
|
NPLACEMENT_NEW(Item3d)
|
|
|
|
Registry registry;
|
|
|
|
virtual void SetParent(Item * = 0);
|
|
const ItemList &GetChildren() const { return children; }
|
|
Item *GetParent() const { return parent; }
|
|
|
|
void MarkTransformationDirty(bool children_only = false);
|
|
void MarkWorldTransformationDirty();
|
|
|
|
const Vector4 &GetPosition() const;
|
|
void SetPosition(const Vector4 &);
|
|
|
|
void SetRotation(const Vector4 &);
|
|
void SetRotation(const Quaternion &);
|
|
void SetRotation(const Matrix3 &);
|
|
const Vector4 &GetRotation() const;
|
|
|
|
void SetScale(const Vector4 &);
|
|
const Vector4 &GetScale() const;
|
|
|
|
void SetPivot(const Matrix4 &);
|
|
const Matrix4 &GetPivot() const;
|
|
|
|
Matrix4 GetMatrixNoPivot();
|
|
void SetMatrix(const Matrix4 &);
|
|
|
|
const Matrix4 &GetPreviousMatrix() const;
|
|
void SetPreviousMatrix(const Matrix4 &);
|
|
const Matrix4 &GetLocalMatrix();
|
|
|
|
const Matrix4 &GetMatrix();
|
|
const Matrix4 &GetMatrix() const { return matrix; }
|
|
|
|
const Matrix4 &GetInverseMatrix();
|
|
const Matrix4 &GetInverseMatrix() const { return imatrix; }
|
|
|
|
const Matrix3 &GetRotationMatrix();
|
|
const Matrix3 &GetRotationMatrix() const { return rotation_matrix; }
|
|
|
|
BitField item_flags;
|
|
Vector4 target; ///< Target position.
|
|
|
|
/// Is this item linked to a given item?
|
|
bool IsLinkedTo(Item *);
|
|
|
|
/// Set item position in world space (taking account of parent transformations).
|
|
void OffsetWorldPosition(const Vector4 &);
|
|
|
|
/// Transfer a 4x4 matrix to item position/scale and rotation components.
|
|
void SnapshotTransformation(const Matrix4 &, bool parent_space = false, bool only_matrix = false);
|
|
|
|
/*!
|
|
@short Set item target location.
|
|
|
|
@note When a target location exists the item align its local Z
|
|
axis (0,0,1} so that it always point towards the target
|
|
location.
|
|
*/
|
|
void SetTarget(const Vector4 * = 0);
|
|
void SetTarget(const Vector4 &v) { SetTarget(&v); }
|
|
Vector4 GetTarget() { return target; }
|
|
|
|
float opacity; ///< Item opacity.
|
|
|
|
void SetRotationOrder(Math::rOrder);
|
|
Math::rOrder GetRotationOrder() const { return rorder; }
|
|
|
|
/// Compute the item axis-aligned bounding box.
|
|
virtual void ComputeLocalMinMax(MinMax &) const;
|
|
|
|
void *mitem; ///< Managed item.
|
|
|
|
/// Setup item render data.
|
|
virtual void RenderSetup(ResourceFactories * = 0) = 0;
|
|
|
|
bool FromMetaTag(NML::Tag &);
|
|
NML::Tag *AsMetaTag() const;
|
|
|
|
Item();
|
|
virtual ~Item();
|
|
};
|
|
|
|
typedef Item * pItem;
|
|
|
|
} // Core
|
|
} // GS
|
|
|
|
|
|
#endif // __NITEM__
|