Improved Node interface

Former-commit-id: cbc204748d8cf30771743f26270324dee6ada242

include/Nazara/Utility/Node.hpp

@@ -21,49 +21,46 @@ class NAZARA_API NzNode
 		NzNode(const NzNode& node);
 		virtual ~NzNode();
 
-		NzQuaternionf GetDerivedRotation() const;
+		bool GetInheritPosition() const;
-		NzVector3f GetDerivedScale() const;
-		NzVector3f GetDerivedTranslation() const;
 		bool GetInheritRotation() const;
 		bool GetInheritScale() const;
-		bool GetInheritTranslation() const;
+		NzVector3f GetInitialPosition() const;
 		NzQuaternionf GetInitialRotation() const;
 		NzVector3f GetInitialScale() const;
-		NzVector3f GetInitialTranslation() const;
 		const NzNode* GetParent() const;
-		NzQuaternionf GetRotation() const;
+		NzVector3f GetPosition(nzCoordSys coordSys = nzCoordSys_Global) const;
-		NzVector3f GetScale() const;
+		NzQuaternionf GetRotation(nzCoordSys coordSys = nzCoordSys_Global) const;
-		NzVector3f GetTranslation() const;
+		NzVector3f GetScale(nzCoordSys coordSys = nzCoordSys_Global) const;
 		const NzMatrix4f& GetTransformMatrix() const;
 
 		NzNode& Interpolate(const NzNode& nodeA, const NzNode& nodeB, float interpolation);
 
+		NzNode& Move(const NzVector3f& movement, nzCoordSys coordSys = nzCoordSys_Local);
+		NzNode& Move(float movementX, float movementY, float movementZ, nzCoordSys coordSys = nzCoordSys_Local);
+
 		NzNode& Rotate(const NzQuaternionf& rotation, nzCoordSys coordSys = nzCoordSys_Local);
 
 		NzNode& Scale(const NzVector3f& scale);
 		NzNode& Scale(float scale);
 		NzNode& Scale(float scaleX, float scaleY, float scaleZ);
 
-		NzNode& Translate(const NzVector3f& movement, nzCoordSys coordSys = nzCoordSys_Local);
-		NzNode& Translate(float movementX, float movementY, float movementZ, nzCoordSys coordSys = nzCoordSys_Local);
-
 		void SetInheritRotation(bool inheritRotation);
 		void SetInheritScale(bool inheritScale);
-		void SetInheritTranslation(bool inheritTranslation);
+		void SetInheritPosition(bool inheritPosition);
 		void SetInitialRotation(const NzQuaternionf& quat);
 		void SetInitialScale(const NzVector3f& scale);
 		void SetInitialScale(float scale);
 		void SetInitialScale(float scaleX, float scaleY, float scaleZ);
-		void SetInitialTranslation(const NzVector3f& translation);
+		void SetInitialPosition(const NzVector3f& translation);
-		void SetInitialTranslation(float translationX, float translationXY, float translationZ);
+		void SetInitialPosition(float translationX, float translationXY, float translationZ);
 		void SetParent(const NzNode* node = nullptr, bool keepDerived = false);
 		void SetParent(const NzNode& node, bool keepDerived = false);
+		void SetPosition(const NzVector3f& translation, nzCoordSys coordSys = nzCoordSys_Local);
+		void SetPosition(float translationX, float translationXY, float translationZ, nzCoordSys coordSys = nzCoordSys_Local);
 		void SetRotation(const NzQuaternionf& quat, nzCoordSys coordSys = nzCoordSys_Local);
 		void SetScale(const NzVector3f& scale, nzCoordSys coordSys = nzCoordSys_Local);
 		void SetScale(float scale, nzCoordSys coordSys = nzCoordSys_Local);
 		void SetScale(float scaleX, float scaleY, float scaleZ, nzCoordSys coordSys = nzCoordSys_Local);
-		void SetTranslation(const NzVector3f& translation, nzCoordSys coordSys = nzCoordSys_Local);
-		void SetTranslation(float translationX, float translationXY, float translationZ, nzCoordSys coordSys = nzCoordSys_Local);
 
 		NzNode& operator=(const NzNode& node);
 
@@ -80,17 +77,17 @@ class NAZARA_API NzNode
 		NzQuaternionf m_initialRotation;
 		NzQuaternionf m_rotation;
 		NzString m_name;
-		mutable NzVector3f m_derivedTranslation;
+		mutable NzVector3f m_derivedPosition;
 		mutable NzVector3f m_derivedScale;
+		NzVector3f m_initialPosition;
 		NzVector3f m_initialScale;
-		NzVector3f m_initialTranslation;
+		NzVector3f m_position;
 		NzVector3f m_scale;
-		NzVector3f m_translation;
 		const NzNode* m_parent;
 		mutable bool m_derivedUpdated;
+		bool m_inheritPosition;
 		bool m_inheritRotation;
 		bool m_inheritScale;
-		bool m_inheritTranslation;
 		mutable bool m_matrixUpdated;
 };
 

include/Nazara/Utility/Sequence.hpp

@@ -22,8 +22,8 @@ struct NzSequence
 struct NzSequenceJoint
 {
 	NzQuaternionf rotation;
+	NzVector3f position;
 	NzVector3f scale;
-	NzVector3f translation;
 };
 
 #endif // NAZARA_SEQUENCE_HPP

src/Nazara/3D/Light.cpp

@@ -96,12 +96,12 @@ void NzLight::Apply(unsigned int i) const
 			break;
 
 		case nzLightType_Point:
-			shader->SendVector(parameters1Location, NzVector4f(m_derivedTranslation, m_attenuation));
+			shader->SendVector(parameters1Location, NzVector4f(m_derivedPosition, m_attenuation));
 			shader->SendVector(parameters2Location, NzVector4f(1.f/m_radius, 0.f, 0.f, 0.f));
 			break;
 
 		case nzLightType_Spot:
-			shader->SendVector(parameters1Location, NzVector4f(m_derivedTranslation, m_attenuation));
+			shader->SendVector(parameters1Location, NzVector4f(m_derivedPosition, m_attenuation));
 			shader->SendVector(parameters2Location, NzVector4f(m_derivedRotation * NzVector3f::Forward(), 1.f/m_radius));
 			shader->SendVector(parameters3Location, NzVector2f(std::cos(NzDegreeToRadian(m_innerAngle)), std::cos(NzDegreeToRadian(m_outerAngle))));
 			break;

src/Nazara/Renderer/DebugDrawer.cpp

@@ -182,10 +182,10 @@ void NzDebugDrawer::Draw(const NzSkeleton* skeleton)
 		const NzNode* parent = joint->GetParent();
 		if (parent)
 		{
-			vertex->position = joint->GetDerivedTranslation();
+			vertex->position = joint->GetPosition();
 			vertex++;
 
-			vertex->position = parent->GetDerivedTranslation();
+			vertex->position = parent->GetPosition();
 			vertex++;
 
 			vertexCount += 2;

src/Nazara/Utility/Animation.cpp

@@ -148,9 +148,9 @@ void NzAnimation::AnimateSkeleton(NzSkeleton* targetSkeleton, unsigned int frame
 		NzSequenceJoint& sequenceJointA = m_impl->sequenceJoints[frameA*m_impl->jointCount + i];
 		NzSequenceJoint& sequenceJointB = m_impl->sequenceJoints[frameB*m_impl->jointCount + i];
 
+		joint->SetPosition(NzVector3f::Lerp(sequenceJointA.position, sequenceJointB.position, interpolation));
 		joint->SetRotation(NzQuaternionf::Slerp(sequenceJointA.rotation, sequenceJointB.rotation, interpolation));
 		joint->SetScale(NzVector3f::Lerp(sequenceJointA.scale, sequenceJointB.scale, interpolation));
-		joint->SetTranslation(NzVector3f::Lerp(sequenceJointA.translation, sequenceJointB.translation, interpolation));
 	}
 }
 

src/Nazara/Utility/Loaders/MD5Anim/Parser.cpp

@@ -228,16 +228,18 @@ bool NzMD5AnimParser::Parse(NzAnimation* animation)
 			NzSequenceJoint& sequenceJoint = sequenceJoints[j*jointCount + i];
 
 			if (parent >= 0)
+			{
+				sequenceJoint.position = m_frames[j].joints[i].pos;
 				sequenceJoint.rotation = m_frames[j].joints[i].orient;
+			}
 			else
+			{
+				sequenceJoint.position = rotationQuat * m_frames[j].joints[i].pos;
 				sequenceJoint.rotation = rotationQuat * m_frames[j].joints[i].orient;
+			}
 
 			sequenceJoint.scale = NzVector3f(1.f, 1.f, 1.f);
 
-			if (parent >= 0)
-				sequenceJoint.translation = m_frames[j].joints[i].pos;
-			else
-				sequenceJoint.translation = rotationQuat * m_frames[j].joints[i].pos;
 		}
 	}
 

src/Nazara/Utility/Node.cpp

@@ -8,15 +8,15 @@
 NzNode::NzNode() :
 m_initialRotation(NzQuaternionf::Identity()),
 m_rotation(NzQuaternionf::Identity()),
+m_initialPosition(NzVector3f::Zero()),
 m_initialScale(NzVector3f(1.f, 1.f, 1.f)),
-m_initialTranslation(NzVector3f::Zero()),
+m_position(NzVector3f::Zero()),
 m_scale(NzVector3f(1.f, 1.f, 1.f)),
-m_translation(NzVector3f::Zero()),
 m_parent(nullptr),
 m_derivedUpdated(false),
+m_inheritPosition(true),
 m_inheritRotation(true),
 m_inheritScale(true),
-m_inheritTranslation(true),
 m_matrixUpdated(false)
 {
 }
@@ -24,15 +24,15 @@ m_matrixUpdated(false)
 NzNode::NzNode(const NzNode& node) :
 m_initialRotation(node.m_initialRotation),
 m_rotation(node.m_rotation),
+m_initialPosition(node.m_initialPosition),
 m_initialScale(node.m_initialScale),
-m_initialTranslation(node.m_initialTranslation),
+m_position(node.m_position),
 m_scale(node.m_scale),
-m_translation(node.m_translation),
 m_parent(node.m_parent),
 m_derivedUpdated(false),
+m_inheritPosition(node.m_inheritPosition),
 m_inheritRotation(node.m_inheritRotation),
 m_inheritScale(node.m_inheritScale),
-m_inheritTranslation(node.m_inheritTranslation),
 m_matrixUpdated(false)
 {
 	if (m_parent)
@@ -48,28 +48,9 @@ NzNode::~NzNode()
 		m_parent->RemoveChild(this);
 }
 
-NzQuaternionf NzNode::GetDerivedRotation() const
+bool NzNode::GetInheritPosition() const
 {
-	if (!m_derivedUpdated)
+	return m_inheritPosition;
-		UpdateDerived();
-
-	return m_derivedRotation;
-}
-
-NzVector3f NzNode::GetDerivedScale() const
-{
-	if (!m_derivedUpdated)
-		UpdateDerived();
-
-	return m_derivedScale;
-}
-
-NzVector3f NzNode::GetDerivedTranslation() const
-{
-	if (!m_derivedUpdated)
-		UpdateDerived();
-
-	return m_derivedTranslation;
 }
 
 bool NzNode::GetInheritRotation() const
@@ -82,9 +63,9 @@ bool NzNode::GetInheritScale() const
 	return m_inheritScale;
 }
 
-bool NzNode::GetInheritTranslation() const
+NzVector3f NzNode::GetInitialPosition() const
 {
-	return m_inheritTranslation;
+	return m_initialPosition;
 }
 
 NzQuaternionf NzNode::GetInitialRotation() const
@@ -97,29 +78,63 @@ NzVector3f NzNode::GetInitialScale() const
 	return m_initialScale;
 }
 
-NzVector3f NzNode::GetInitialTranslation() const
-{
-	return m_initialTranslation;
-}
-
 const NzNode* NzNode::GetParent() const
 {
 	return m_parent;
 }
 
-NzQuaternionf NzNode::GetRotation() const
+NzVector3f NzNode::GetPosition(nzCoordSys coordSys) const
 {
+	switch (coordSys)
+	{
+		case nzCoordSys_Global:
+			if (!m_derivedUpdated)
+				UpdateDerived();
+
+			return m_derivedPosition;
+
+		case nzCoordSys_Local:
+			return m_position;
+	}
+
+	NazaraError("Coordinate system out of enum (0x" + NzString::Number(coordSys, 16) + ')');
+	return NzVector3f();
+}
+
+NzQuaternionf NzNode::GetRotation(nzCoordSys coordSys) const
+{
+	switch (coordSys)
+	{
+		case nzCoordSys_Global:
+			if (!m_derivedUpdated)
+				UpdateDerived();
+
+			return m_derivedRotation;
+
+		case nzCoordSys_Local:
 			return m_rotation;
+	}
+
+	NazaraError("Coordinate system out of enum (0x" + NzString::Number(coordSys, 16) + ')');
+	return NzQuaternionf();
 }
 
-NzVector3f NzNode::GetScale() const
+NzVector3f NzNode::GetScale(nzCoordSys coordSys) const
 {
+	switch (coordSys)
+	{
+		case nzCoordSys_Global:
+			if (!m_derivedUpdated)
+				UpdateDerived();
+
+			return m_derivedScale;
+
+		case nzCoordSys_Local:
 			return m_scale;
-}
+	}
 
-NzVector3f NzNode::GetTranslation() const
+	NazaraError("Coordinate system out of enum (0x" + NzString::Number(coordSys, 16) + ')');
-{
+	return NzVector3f();
-	return m_translation;
 }
 
 const NzMatrix4f& NzNode::GetTransformMatrix() const
@@ -132,14 +147,47 @@ const NzMatrix4f& NzNode::GetTransformMatrix() const
 
 NzNode& NzNode::Interpolate(const NzNode& nodeA, const NzNode& nodeB, float interpolation)
 {
+	m_position = NzVector3f::Lerp(nodeA.m_position, nodeB.m_position, interpolation);
 	m_rotation = NzQuaternionf::Slerp(nodeA.m_rotation, nodeB.m_rotation, interpolation);
 	m_scale = NzVector3f::Lerp(nodeA.m_scale, nodeB.m_scale, interpolation);
-	m_translation = NzVector3f::Lerp(nodeA.m_translation, nodeB.m_translation, interpolation);
 
 	Invalidate();
 	return *this;
 }
 
+NzNode& NzNode::Move(const NzVector3f& movement, nzCoordSys coordSys)
+{
+	switch (coordSys)
+	{
+		case nzCoordSys_Global:
+		{
+			if (m_parent)
+			{
+				if (!m_parent->m_derivedUpdated)
+					m_parent->UpdateDerived();
+
+				m_position += (m_parent->m_derivedRotation.GetInverse() * movement) / m_parent->m_derivedPosition; // Compensation
+			}
+			else
+				m_position += movement; // Rien n'affecte le node
+
+			break;
+		}
+
+		case nzCoordSys_Local:
+			m_position += m_scale * (m_rotation * movement);
+			break;
+	}
+
+	Invalidate();
+	return *this;
+}
+
+NzNode& NzNode::Move(float moveX, float moveY, float moveZ, nzCoordSys coordSys)
+{
+	return Move(NzVector3f(moveX, moveY, moveZ), coordSys);
+}
+
 NzNode& NzNode::Rotate(const NzQuaternionf& rotation, nzCoordSys coordSys)
 {
 	// Évitons toute mauvaise surprise ..
@@ -194,32 +242,14 @@ NzNode& NzNode::Scale(float scaleX, float scaleY, float scaleZ)
 	return *this;
 }
 
-NzNode& NzNode::Translate(const NzVector3f& movement, nzCoordSys coordSys)
+void NzNode::SetInheritPosition(bool inheritPosition)
 {
-	switch (coordSys)
+	if (m_inheritPosition != inheritPosition)
 	{
-		case nzCoordSys_Global:
+		m_inheritPosition = inheritPosition;
-		{
-			if (m_parent)
-				m_translation += (m_parent->GetDerivedRotation().GetInverse() * movement) / m_parent->GetDerivedScale(); // Compensation
-			else
-				m_translation += movement; // Rien n'affecte le node
-
-			break;
-		}
-
-		case nzCoordSys_Local:
-			m_translation += m_scale * (m_rotation * movement);
-			break;
-	}
 
 		Invalidate();
-	return *this;
+	}
-}
-
-NzNode& NzNode::Translate(float moveX, float moveY, float moveZ, nzCoordSys coordSys)
-{
-	return Translate(NzVector3f(moveX, moveY, moveZ), coordSys);
 }
 
 void NzNode::SetInheritRotation(bool inheritRotation)
@@ -244,14 +274,18 @@ void NzNode::SetInheritScale(bool inheritScale)
 	}
 }
 
-void NzNode::SetInheritTranslation(bool inheritTranslation)
+void NzNode::SetInitialPosition(const NzVector3f& position)
 {
-	if (m_inheritTranslation != inheritTranslation)
+	m_initialPosition = position;
-	{
+
-		m_inheritTranslation = inheritTranslation;
+	Invalidate();
+}
+
+void NzNode::SetInitialPosition(float positionX, float positionY, float positionZ)
+{
+	m_initialPosition.Set(positionX, positionY, positionZ);
 
 	Invalidate();
-	}
 }
 
 void NzNode::SetInitialRotation(const NzQuaternionf& rotation)
@@ -283,20 +317,6 @@ void NzNode::SetInitialScale(float scaleX, float scaleY, float scaleZ)
 	Invalidate();
 }
 
-void NzNode::SetInitialTranslation(const NzVector3f& translation)
-{
-	m_initialTranslation = translation;
-
-	Invalidate();
-}
-
-void NzNode::SetInitialTranslation(float translationX, float translationY, float translationZ)
-{
-	m_initialTranslation.Set(translationX, translationY, translationZ);
-
-	Invalidate();
-}
-
 void NzNode::SetParent(const NzNode* node, bool keepDerived)
 {
 	if (m_parent == node)
@@ -316,7 +336,7 @@ void NzNode::SetParent(const NzNode* node, bool keepDerived)
 
 		SetRotation(m_derivedRotation, nzCoordSys_Global);
 		SetScale(m_derivedScale, nzCoordSys_Global);
-		SetTranslation(m_derivedTranslation, nzCoordSys_Global);
+		SetPosition(m_derivedPosition, nzCoordSys_Global);
 	}
 	else
 	{
@@ -336,6 +356,35 @@ void NzNode::SetParent(const NzNode& node, bool keepDerived)
 	SetParent(&node, keepDerived);
 }
 
+void NzNode::SetPosition(const NzVector3f& position, nzCoordSys coordSys)
+{
+	switch (coordSys)
+	{
+		case nzCoordSys_Global:
+			if (m_parent && m_inheritPosition)
+			{
+				if (!m_parent->m_derivedUpdated)
+					m_parent->UpdateDerived();
+
+				m_position = (m_parent->m_derivedRotation.GetConjugate()*(position - m_parent->m_derivedPosition))/m_parent->m_derivedScale - m_initialPosition;
+			}
+			else
+				m_position = position - m_initialPosition;
+			break;
+
+		case nzCoordSys_Local:
+			m_position = position;
+			break;
+	}
+
+	Invalidate();
+}
+
+void NzNode::SetPosition(float positionX, float positionY, float positionZ, nzCoordSys coordSys)
+{
+	SetPosition(NzVector3f(positionX, positionY, positionZ), coordSys);
+}
+
 void NzNode::SetRotation(const NzQuaternionf& rotation, nzCoordSys coordSys)
 {
 	// Évitons toute mauvaise surprise ..
@@ -345,10 +394,9 @@ void NzNode::SetRotation(const NzQuaternionf& rotation, nzCoordSys coordSys)
 	switch (coordSys)
 	{
 		case nzCoordSys_Global:
-		{
 			if (m_parent && m_inheritRotation)
 			{
-				NzQuaternionf rot(m_initialRotation * m_parent->GetDerivedRotation());
+				NzQuaternionf rot(m_initialRotation * m_parent->GetRotation());
 
 				m_rotation = rot.GetInverse() * q; ///FIXME: Vérifier si le résultat est correct
 				m_rotation.Normalize();
@@ -357,7 +405,6 @@ void NzNode::SetRotation(const NzQuaternionf& rotation, nzCoordSys coordSys)
 				m_rotation = q;
 
 			break;
-		}
 
 		case nzCoordSys_Local:
 			m_rotation = q;
@@ -372,13 +419,11 @@ void NzNode::SetScale(const NzVector3f& scale, nzCoordSys coordSys)
 	switch (coordSys)
 	{
 		case nzCoordSys_Global:
-		{
 			if (m_parent && m_inheritScale)
-				m_scale = scale / (m_initialScale * m_parent->GetDerivedScale());
+				m_scale = scale / (m_initialScale * m_parent->GetScale());
 			else
 				m_scale = scale / m_initialScale;
 			break;
-		}
 
 		case nzCoordSys_Local:
 			m_scale = scale;
@@ -398,47 +443,16 @@ void NzNode::SetScale(float scaleX, float scaleY, float scaleZ, nzCoordSys coord
 	SetScale(NzVector3f(scaleX, scaleY, scaleZ), coordSys);
 }
 
-void NzNode::SetTranslation(const NzVector3f& translation, nzCoordSys coordSys)
-{
-	switch (coordSys)
-	{
-		case nzCoordSys_Global:
-		{
-			if (m_parent && m_inheritTranslation)
-			{
-				if (!m_parent->m_derivedUpdated)
-					m_parent->UpdateDerived();
-
-				m_translation = (m_parent->m_derivedRotation.GetConjugate()*(translation - m_parent->m_derivedTranslation))/m_parent->m_derivedScale - m_initialTranslation;
-			}
-			else
-				m_translation = translation - m_initialTranslation;
-			break;
-		}
-
-		case nzCoordSys_Local:
-			m_translation = translation;
-			break;
-	}
-
-	Invalidate();
-}
-
-void NzNode::SetTranslation(float translationX, float translationY, float translationZ, nzCoordSys coordSys)
-{
-	SetTranslation(NzVector3f(translationX, translationY, translationZ), coordSys);
-}
-
 NzNode& NzNode::operator=(const NzNode& node)
 {
 	SetParent(node.m_parent);
 
+	m_inheritPosition = node.m_inheritPosition;
 	m_inheritRotation = node.m_inheritRotation;
 	m_inheritScale = node.m_inheritScale;
-	m_inheritTranslation = node.m_inheritTranslation;
+	m_position = node.m_position;
 	m_rotation = node.m_rotation;
 	m_scale = node.m_scale;
-	m_translation = node.m_translation;
 
 	Invalidate();
 
@@ -483,6 +497,11 @@ void NzNode::UpdateDerived() const
 		if (!m_parent->m_derivedUpdated)
 			m_parent->UpdateDerived();
 
+		if (m_inheritPosition)
+			m_derivedPosition = m_parent->m_derivedRotation*(m_parent->m_derivedScale * (m_initialPosition + m_position)) + m_parent->m_derivedPosition;
+		else
+			m_derivedPosition = m_initialPosition + m_position;
+
 		if (m_inheritRotation)
 		{
 			m_derivedRotation = m_initialRotation * m_parent->m_derivedRotation * m_rotation;
@@ -494,17 +513,12 @@ void NzNode::UpdateDerived() const
 		m_derivedScale = m_initialScale * m_scale;
 		if (m_inheritScale)
 			m_derivedScale *= m_parent->m_derivedScale;
-
-		if (m_inheritTranslation)
-			m_derivedTranslation = m_parent->m_derivedRotation*(m_parent->m_derivedScale * (m_initialTranslation + m_translation)) + m_parent->m_derivedTranslation;
-		else
-			m_derivedTranslation = m_initialTranslation + m_translation;
 	}
 	else
 	{
+		m_derivedPosition = m_initialPosition + m_position;
 		m_derivedRotation = m_initialRotation * m_rotation;
 		m_derivedScale = m_initialScale * m_scale;
-		m_derivedTranslation = m_initialTranslation + m_translation;
 	}
 
 	m_derivedUpdated = true;
@@ -515,7 +529,7 @@ void NzNode::UpdateMatrix() const
 	if (!m_derivedUpdated)
 		UpdateDerived();
 
-	m_transformMatrix.MakeTransform(m_derivedTranslation, m_derivedScale, m_derivedRotation);
+	m_transformMatrix.MakeTransform(m_derivedPosition, m_derivedScale, m_derivedRotation);
 
 	m_matrixUpdated = true;
 }

src/Nazara/Utility/Skeleton.cpp

@@ -64,7 +64,7 @@ const NzAxisAlignedBox& NzSkeleton::GetAABB() const
 	if (m_impl->aabb.IsNull())
 	{
 		for (unsigned int i = 0; i < m_impl->joints.size(); ++i)
-			m_impl->aabb.ExtendTo(m_impl->joints[i].GetDerivedTranslation());
+			m_impl->aabb.ExtendTo(m_impl->joints[i].GetPosition());
 	}
 
 	return m_impl->aabb;