From cef2a19b078d25472e1af1b8d9b1f53214d93cca Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Vladim=C3=ADr=20Vondru=C5=A1?= <mosra@centrum.cz>
Date: Sun, 16 Sep 2012 00:56:43 +0200
Subject: [PATCH] Moved template list of SceneGraph objects into traits class.

Beside better readability it is now more future proof, as objects with
double types etc. and new templated types can be added more easily.
---
 src/SceneGraph/Camera.cpp | 28 +++++++-------
 src/SceneGraph/Camera.h   | 32 ++++++++--------
 src/SceneGraph/Object.cpp | 16 ++++----
 src/SceneGraph/Object.h   | 79 +++++++++++++++++++++++++++++----------
 src/SceneGraph/Scene.h    | 20 +++++-----
 5 files changed, 108 insertions(+), 67 deletions(-)

diff --git a/src/SceneGraph/Camera.cpp b/src/SceneGraph/Camera.cpp
index b73cb61d2..5e5693261 100644
--- a/src/SceneGraph/Camera.cpp
+++ b/src/SceneGraph/Camera.cpp
@@ -45,40 +45,40 @@ template Matrix4 aspectRatioFix<Matrix4>(AspectRatioPolicy, const Vector2&, cons
 }
 #endif
 
-template<class MatrixType, class VectorType, class ObjectType, class SceneType, class CameraType> Camera<MatrixType, VectorType, ObjectType, SceneType, CameraType>::Camera(ObjectType* parent): ObjectType(parent), _aspectRatioPolicy(AspectRatioPolicy::NotPreserved) {}
+template<size_t dimensions> Camera<dimensions>::Camera(typename Object<dimensions>::ObjectType* parent): Object<dimensions>::ObjectType(parent), _aspectRatioPolicy(AspectRatioPolicy::NotPreserved) {}
 
-template<class MatrixType, class VectorType, class ObjectType, class SceneType, class CameraType> CameraType* Camera<MatrixType, VectorType, ObjectType, SceneType, CameraType>::setAspectRatioPolicy(AspectRatioPolicy policy) {
+template<size_t dimensions> typename Object<dimensions>::CameraType* Camera<dimensions>::setAspectRatioPolicy(AspectRatioPolicy policy) {
     _aspectRatioPolicy = policy;
     fixAspectRatio();
-    return static_cast<CameraType*>(this);
+    return static_cast<typename Object<dimensions>::CameraType*>(this);
 }
 
-template<class MatrixType, class VectorType, class ObjectType, class SceneType, class CameraType> void Camera<MatrixType, VectorType, ObjectType, SceneType, CameraType>::setViewport(const Math::Vector2<GLsizei>& size) {
+template<size_t dimensions> void Camera<dimensions>::setViewport(const Math::Vector2<GLsizei>& size) {
     _viewport = size;
     fixAspectRatio();
 }
 
-template<class MatrixType, class VectorType, class ObjectType, class SceneType, class CameraType> void Camera<MatrixType, VectorType, ObjectType, SceneType, CameraType>::clean(const MatrixType& absoluteTransformation) {
-    ObjectType::clean(absoluteTransformation);
+template<size_t dimensions> void Camera<dimensions>::clean(const typename Object<dimensions>::MatrixType& absoluteTransformation) {
+    Object<dimensions>::ObjectType::clean(absoluteTransformation);
 
     _cameraMatrix = absoluteTransformation.inverted();
 }
 
-template<class MatrixType, class VectorType, class ObjectType, class SceneType, class CameraType> void Camera<MatrixType, VectorType, ObjectType, SceneType, CameraType>::draw() {
-    SceneType* s = this->scene();
+template<size_t dimensions> void Camera<dimensions>::draw() {
+    typename Object<dimensions>::SceneType* s = this->scene();
     CORRADE_ASSERT(s, "Camera: cannot draw without camera attached to scene", );
 
     /* Recursively draw child objects */
     drawChildren(s, cameraMatrix());
 }
 
-template<class MatrixType, class VectorType, class ObjectType, class SceneType, class CameraType> void Camera<MatrixType, VectorType, ObjectType, SceneType, CameraType>::drawChildren(ObjectType* object, const MatrixType& transformationMatrix) {
-    for(ObjectType* i = object->firstChild(); i; i = i->nextSibling()) {
+template<size_t dimensions> void Camera<dimensions>::drawChildren(typename Object<dimensions>::ObjectType* object, const typename Object<dimensions>::MatrixType& transformationMatrix) {
+    for(typename Object<dimensions>::ObjectType* i = object->firstChild(); i; i = i->nextSibling()) {
         /* Transformation matrix for the object */
-        MatrixType matrix = transformationMatrix*i->transformation();
+        typename Object<dimensions>::MatrixType matrix = transformationMatrix*i->transformation();
 
         /* Draw the object and its children */
-        i->draw(matrix, static_cast<CameraType*>(this));
+        i->draw(matrix, static_cast<typename Object<dimensions>::CameraType*>(this));
         drawChildren(i, matrix);
     }
 }
@@ -128,7 +128,7 @@ Camera3D* Camera3D::setPerspective(GLfloat fov, GLfloat near, GLfloat far) {
 }
 
 /* Explicitly instantiate the templates */
-template class Camera<Matrix3, Vector2, Object2D, Scene2D, Camera2D>;
-template class Camera<Matrix4, Vector3, Object3D, Scene3D, Camera3D>;
+template class Camera<2>;
+template class Camera<3>;
 
 }}
diff --git a/src/SceneGraph/Camera.h b/src/SceneGraph/Camera.h
index a335beb77..d4541ed1e 100644
--- a/src/SceneGraph/Camera.h
+++ b/src/SceneGraph/Camera.h
@@ -49,7 +49,7 @@ namespace Implementation {
 /**
 @brief %Camera object
  */
-template<class MatrixType, class VectorType, class ObjectType, class SceneType, class CameraType> class SCENEGRAPH_EXPORT Camera: public ObjectType {
+template<size_t dimensions> class SCENEGRAPH_EXPORT Camera: public Object<dimensions>::ObjectType {
     public:
         /**
          * @brief Aspect ratio policy
@@ -67,7 +67,7 @@ template<class MatrixType, class VectorType, class ObjectType, class SceneType,
         #endif
 
         /** @copydoc Object::Object */
-        Camera(ObjectType* parent = nullptr);
+        Camera(typename Object<dimensions>::ObjectType* parent = nullptr);
 
         /** @brief Aspect ratio policy */
         inline AspectRatioPolicy aspectRatioPolicy() const { return _aspectRatioPolicy; }
@@ -76,7 +76,7 @@ template<class MatrixType, class VectorType, class ObjectType, class SceneType,
          * @brief Set aspect ratio policy
          * @return Pointer to self (for method chaining)
          */
-        CameraType* setAspectRatioPolicy(AspectRatioPolicy policy);
+        typename Object<dimensions>::CameraType* setAspectRatioPolicy(AspectRatioPolicy policy);
 
         /**
          * @brief Camera matrix
@@ -84,7 +84,7 @@ template<class MatrixType, class VectorType, class ObjectType, class SceneType,
          * Camera matrix describes world position relative to the camera and is
          * applied as first.
          */
-        inline MatrixType cameraMatrix() {
+        inline typename Object<dimensions>::MatrixType cameraMatrix() {
             this->setClean();
             return _cameraMatrix;
         }
@@ -96,7 +96,7 @@ template<class MatrixType, class VectorType, class ObjectType, class SceneType,
          * as last.
          * @see projectionSize()
          */
-        inline MatrixType projectionMatrix() const { return _projectionMatrix; }
+        inline typename Object<dimensions>::MatrixType projectionMatrix() const { return _projectionMatrix; }
 
         /**
          * @brief Size of (near) XY plane in current projection
@@ -127,41 +127,41 @@ template<class MatrixType, class VectorType, class ObjectType, class SceneType,
          */
         virtual void draw();
 
-        using ObjectType::draw; /* Don't hide Object's draw() */
+        using Object<dimensions>::ObjectType::draw; /* Don't hide Object's draw() */
 
     protected:
         /**
          * Recalculates camera matrix.
          */
-        void clean(const MatrixType& absoluteTransformation);
+        void clean(const typename Object<dimensions>::MatrixType& absoluteTransformation);
 
         /**
          * @brief Draw object children
          *
          * Recursively draws all children of the object.
          */
-        void drawChildren(ObjectType* object, const MatrixType& transformationMatrix);
+        void drawChildren(typename Object<dimensions>::ObjectType* object, const typename Object<dimensions>::MatrixType& transformationMatrix);
 
         #ifndef DOXYGEN_GENERATING_OUTPUT
         inline void fixAspectRatio() {
-            _projectionMatrix = Implementation::aspectRatioFix<MatrixType>(_aspectRatioPolicy, {rawProjectionMatrix[0].x(), rawProjectionMatrix[1].y()}, _viewport)*rawProjectionMatrix;
+            _projectionMatrix = Implementation::aspectRatioFix<typename Object<dimensions>::MatrixType>(_aspectRatioPolicy, {rawProjectionMatrix[0].x(), rawProjectionMatrix[1].y()}, _viewport)*rawProjectionMatrix;
         }
 
-        MatrixType rawProjectionMatrix;
+        typename Object<dimensions>::MatrixType rawProjectionMatrix;
         AspectRatioPolicy _aspectRatioPolicy;
         #endif
 
     private:
-        MatrixType _projectionMatrix;
-        MatrixType _cameraMatrix;
+        typename Object<dimensions>::MatrixType _projectionMatrix;
+        typename Object<dimensions>::MatrixType _cameraMatrix;
 
         Math::Vector2<GLsizei> _viewport;
 };
 
 #ifndef DOXYGEN_GENERATING_OUTPUT
 /* These templates are instantiated in source file */
-extern template class SCENEGRAPH_EXPORT Camera<Matrix3, Vector2, Object2D, Scene2D, Camera2D>;
-extern template class SCENEGRAPH_EXPORT Camera<Matrix4, Vector3, Object3D, Scene3D, Camera3D>;
+extern template class SCENEGRAPH_EXPORT Camera<2>;
+extern template class SCENEGRAPH_EXPORT Camera<3>;
 
 namespace Implementation {
     template<> class Camera<2> {
@@ -180,7 +180,7 @@ namespace Implementation {
 #endif
 
 /** @brief %Camera for two-dimensional scenes */
-class SCENEGRAPH_EXPORT Camera2D: public Camera<Matrix3, Vector2, Object2D, Scene2D, Camera2D> {
+class SCENEGRAPH_EXPORT Camera2D: public Camera<2> {
     public:
         /**
          * @brief Constructor
@@ -203,7 +203,7 @@ class SCENEGRAPH_EXPORT Camera2D: public Camera<Matrix3, Vector2, Object2D, Scen
 };
 
 /** @brief %Camera for three-dimensional scenes */
-class SCENEGRAPH_EXPORT Camera3D: public Camera<Matrix4, Vector3, Object3D, Scene3D, Camera3D> {
+class SCENEGRAPH_EXPORT Camera3D: public Camera<3> {
     public:
         /**
          * @brief Constructor
diff --git a/src/SceneGraph/Object.cpp b/src/SceneGraph/Object.cpp
index f3de86b1c..5b437a14e 100644
--- a/src/SceneGraph/Object.cpp
+++ b/src/SceneGraph/Object.cpp
@@ -25,7 +25,7 @@ using namespace Magnum::Math;
 
 namespace Magnum { namespace SceneGraph {
 
-template<class MatrixType, class VectorType, class ObjectType, class SceneType, class CameraType> ObjectType* Object<MatrixType, VectorType, ObjectType, SceneType, CameraType>::setParent(ObjectType* parent) {
+template<size_t dimensions> typename Object<dimensions>::ObjectType* Object<dimensions>::setParent(ObjectType* parent) {
     /* Skip if nothing to do or this is scene */
     if(this->parent() == parent || isScene()) return static_cast<ObjectType*>(this);
 
@@ -49,7 +49,7 @@ template<class MatrixType, class VectorType, class ObjectType, class SceneType,
     return static_cast<ObjectType*>(this);
 }
 
-template<class MatrixType, class VectorType, class ObjectType, class SceneType, class CameraType> MatrixType Object<MatrixType, VectorType, ObjectType, SceneType, CameraType>::absoluteTransformation(CameraType* camera) {
+template<size_t dimensions> typename Object<dimensions>::MatrixType Object<dimensions>::absoluteTransformation(CameraType* camera) {
     /* Shortcut for absolute transformation of camera relative to itself */
     if(camera == this) return MatrixType();
 
@@ -77,7 +77,7 @@ template<class MatrixType, class VectorType, class ObjectType, class SceneType,
     return t;
 }
 
-template<class MatrixType, class VectorType, class ObjectType, class SceneType, class CameraType> SceneType* Object<MatrixType, VectorType, ObjectType, SceneType, CameraType>::scene() {
+template<size_t dimensions> typename Object<dimensions>::SceneType* Object<dimensions>::scene() {
     /* Goes up the family tree until it finds object which is parent of itself
        (that's the scene) */
     ObjectType* p = parent();
@@ -89,7 +89,7 @@ template<class MatrixType, class VectorType, class ObjectType, class SceneType,
     return nullptr;
 }
 
-template<class MatrixType, class VectorType, class ObjectType, class SceneType, class CameraType> ObjectType* Object<MatrixType, VectorType, ObjectType, SceneType, CameraType>::setTransformation(const MatrixType& transformation) {
+template<size_t dimensions> typename Object<dimensions>::ObjectType* Object<dimensions>::setTransformation(const MatrixType& transformation) {
     /* Setting transformation is forbidden for the scene */
     /** @todo Assert for this? */
     if(isScene()) return static_cast<ObjectType*>(this);
@@ -99,7 +99,7 @@ template<class MatrixType, class VectorType, class ObjectType, class SceneType,
     return static_cast<ObjectType*>(this);
 }
 
-template<class MatrixType, class VectorType, class ObjectType, class SceneType, class CameraType> void Object<MatrixType, VectorType, ObjectType, SceneType, CameraType>::setDirty() {
+template<size_t dimensions> void Object<dimensions>::setDirty() {
     /* The object (and all its children) are already dirty, nothing to do */
     if(dirty) return;
 
@@ -110,7 +110,7 @@ template<class MatrixType, class VectorType, class ObjectType, class SceneType,
         i->setDirty();
 }
 
-template<class MatrixType, class VectorType, class ObjectType, class SceneType, class CameraType> void Object<MatrixType, VectorType, ObjectType, SceneType, CameraType>::setClean() {
+template<size_t dimensions> void Object<dimensions>::setClean() {
     /* The object (and all its parents) are already clean, nothing to do */
     if(!dirty) return;
 
@@ -141,7 +141,7 @@ template<class MatrixType, class VectorType, class ObjectType, class SceneType,
 }
 
 /* Explicitly instantiate the templates */
-template class Object<Matrix3, Vector2, Object2D, Scene2D, Camera2D>;
-template class Object<Matrix4, Vector3, Object3D, Scene3D, Camera3D>;
+template class Object<2>;
+template class Object<3>;
 
 }}
diff --git a/src/SceneGraph/Object.h b/src/SceneGraph/Object.h
index 33afb906a..4890ee622 100644
--- a/src/SceneGraph/Object.h
+++ b/src/SceneGraph/Object.h
@@ -28,6 +28,38 @@
 
 namespace Magnum { namespace SceneGraph {
 
+class Camera2D;
+class Camera3D;
+class Object2D;
+class Object3D;
+template<size_t dimensions> class Scene;
+typedef Scene<2> Scene2D;
+typedef Scene<3> Scene3D;
+
+#ifndef DOXYGEN_GENERATING_OUTPUT
+namespace Implementation {
+    template<size_t dimensions> struct ObjectDimensionTraits {};
+
+    template<> struct ObjectDimensionTraits<2> {
+        static const size_t Dimensions = 2;
+        typedef Vector2 VectorType;
+        typedef Matrix3 MatrixType;
+        typedef Object2D ObjectType;
+        typedef Camera2D CameraType;
+        typedef Scene2D SceneType;
+    };
+
+    template<> struct ObjectDimensionTraits<3> {
+        static const size_t Dimensions = 3;
+        typedef Vector3 VectorType;
+        typedef Matrix4 MatrixType;
+        typedef Object3D ObjectType;
+        typedef Camera3D CameraType;
+        typedef Scene3D SceneType;
+    };
+}
+#endif
+
 /**
 @todo User-specified Object implementation:
 - for front-to-back sorting, LoD changes etc.
@@ -44,15 +76,32 @@ namespace Magnum { namespace SceneGraph {
  * @todo Transform transformation when changing parent, so the object stays in
  * place.
  */
-template<class MatrixType, class VectorType, class ObjectType, class SceneType, class CameraType> class SCENEGRAPH_EXPORT Object: public Corrade::Containers::LinkedList<ObjectType>, public Corrade::Containers::LinkedListItem<ObjectType, ObjectType> {
+template<size_t dimensions> class SCENEGRAPH_EXPORT Object: public Corrade::Containers::LinkedList<typename Implementation::ObjectDimensionTraits<dimensions>::ObjectType>, public Corrade::Containers::LinkedListItem<typename Implementation::ObjectDimensionTraits<dimensions>::ObjectType, typename Implementation::ObjectDimensionTraits<dimensions>::ObjectType> {
     #ifndef DOXYGEN_GENERATING_OUTPUT
-    Object(const Object<MatrixType, VectorType, ObjectType, SceneType, CameraType>& other) = delete;
-    Object(Object<MatrixType, VectorType, ObjectType, SceneType, CameraType>&& other) = delete;
-    Object<MatrixType, VectorType, ObjectType, SceneType, CameraType>& operator=(const Object<MatrixType, VectorType, ObjectType, SceneType, CameraType>& other) = delete;
-    Object<MatrixType, VectorType, ObjectType, SceneType, CameraType>& operator=(Object<MatrixType, VectorType, ObjectType, SceneType, CameraType>&& other) = delete;
+    Object(const Object<dimensions>& other) = delete;
+    Object(Object<dimensions>&& other) = delete;
+    Object<dimensions>& operator=(const Object<dimensions>& other) = delete;
+    Object<dimensions>& operator=(Object<dimensions>&& other) = delete;
     #endif
 
     public:
+        static const size_t Dimensions = dimensions; /**< @brief %Object dimension count */
+
+        /** @brief %Vector type for given dimension count */
+        typedef typename Implementation::ObjectDimensionTraits<Dimensions>::VectorType VectorType;
+
+        /** @brief %Matrix type for given dimension count */
+        typedef typename Implementation::ObjectDimensionTraits<Dimensions>::MatrixType MatrixType;
+
+        /** @brief %Object type for given dimension count */
+        typedef typename Implementation::ObjectDimensionTraits<Dimensions>::ObjectType ObjectType;
+
+        /** @brief %Camera type for given dimension count */
+        typedef typename Implementation::ObjectDimensionTraits<Dimensions>::CameraType CameraType;
+
+        /** @brief %Scene type for given dimension count */
+        typedef typename Implementation::ObjectDimensionTraits<Dimensions>::SceneType SceneType;
+
         /**
          * @brief Constructor
          * @param parent    Parent object
@@ -261,25 +310,17 @@ template<class MatrixType, class VectorType, class ObjectType, class SceneType,
 };
 
 /* Implementations for inline functions with unused parameters */
-template<class MatrixType, class VectorType, class ObjectType, class SceneType, class CameraType> inline void Object<MatrixType, VectorType, ObjectType, SceneType, CameraType>::draw(const MatrixType&, CameraType*) {}
-template<class MatrixType, class VectorType, class ObjectType, class SceneType, class CameraType> inline void Object<MatrixType, VectorType, ObjectType, SceneType, CameraType>::clean(const MatrixType&) { dirty = false; }
-
-class Camera2D;
-class Camera3D;
-class Object2D;
-class Object3D;
-template<class MatrixType, class VectorType, class ObjectType, class CameraType> class Scene;
-typedef Scene<Matrix3, Vector2, Object2D, Camera2D> Scene2D;
-typedef Scene<Matrix4, Vector3, Object3D, Camera3D> Scene3D;
+template<size_t dimensions> inline void Object<dimensions>::draw(const MatrixType&, CameraType*) {}
+template<size_t dimensions> inline void Object<dimensions>::clean(const MatrixType&) { dirty = false; }
 
 #ifndef DOXYGEN_GENERATING_OUTPUT
 /* These templates are instantiated in source file */
-extern template class SCENEGRAPH_EXPORT Object<Matrix3, Vector2, Object2D, Scene2D, Camera2D>;
-extern template class SCENEGRAPH_EXPORT Object<Matrix4, Vector3, Object3D, Scene3D, Camera3D>;
+extern template class SCENEGRAPH_EXPORT Object<2>;
+extern template class SCENEGRAPH_EXPORT Object<3>;
 #endif
 
 /** @brief Two-dimensional object */
-class SCENEGRAPH_EXPORT Object2D: public Object<Matrix3, Vector2, Object2D, Scene2D, Camera2D> {
+class SCENEGRAPH_EXPORT Object2D: public Object<2> {
     public:
         /** @copydoc Object::Object */
         inline Object2D(Object2D* parent = nullptr): Object(parent) {}
@@ -330,7 +371,7 @@ class SCENEGRAPH_EXPORT Object2D: public Object<Matrix3, Vector2, Object2D, Scen
 };
 
 /** @brief Three-dimensional object */
-class SCENEGRAPH_EXPORT Object3D: public Object<Matrix4, Vector3, Object3D, Scene3D, Camera3D> {
+class SCENEGRAPH_EXPORT Object3D: public Object<3> {
     public:
         /** @copydoc Object::Object */
         inline Object3D(Object3D* parent = nullptr): Object(parent) {}
diff --git a/src/SceneGraph/Scene.h b/src/SceneGraph/Scene.h
index 2fd2e6fe9..9874f40c4 100644
--- a/src/SceneGraph/Scene.h
+++ b/src/SceneGraph/Scene.h
@@ -24,30 +24,30 @@
 namespace Magnum { namespace SceneGraph {
 
 /** @brief %Scene */
-template<class MatrixType, class VectorType, class ObjectType, class CameraType> class SCENEGRAPH_EXPORT Scene: public ObjectType {
+template<size_t dimensions> class SCENEGRAPH_EXPORT Scene: public Object<dimensions>::ObjectType {
     public:
         /** @copydoc Object::isScene() */
         inline bool isScene() const { return true; }
 
         /** @todo Some deleted functions belong only to Scene2D, some only to Scene3D - what to do? */
         #ifndef DOXYGEN_GENERATING_OUTPUT
-        void setParent(ObjectType* parent) = delete;
-        void setTransformation(const MatrixType& transformation) = delete;
-        void multiplyTransformation(const MatrixType& transformation, typename ObjectType::Transformation type = ObjectType::Transformation::Global) = delete;
-        void translate(const VectorType& vec, typename ObjectType::Transformation type = ObjectType::Transformation::Global) = delete;
-        void scale(const VectorType& vec, typename ObjectType::Transformation type = ObjectType::Transformation::Global) = delete;
-        void rotate(GLfloat angle, const VectorType& vec, typename ObjectType::Transformation type = ObjectType::Transformation::Global) = delete;
+        void setParent(typename Object<dimensions>::ObjectType* parent) = delete;
+        void setTransformation(const typename Object<dimensions>::MatrixType& transformation) = delete;
+        void multiplyTransformation(const typename Object<dimensions>::MatrixType& transformation, typename Object<dimensions>::Transformation type = Object<dimensions>::Transformation::Global) = delete;
+        void translate(const typename Object<dimensions>::VectorType& vec, typename Object<dimensions>::Transformation type = Object<dimensions>::Transformation::Global) = delete;
+        void scale(const typename Object<dimensions>::VectorType& vec, typename Object<dimensions>::Transformation type = Object<dimensions>::Transformation::Global) = delete;
+        void rotate(GLfloat angle, const typename Object<dimensions>::VectorType& vec, typename Object<dimensions>::Transformation type = Object<dimensions>::Transformation::Global) = delete;
         #endif
 
     private:
-        inline void draw(const MatrixType&, CameraType*) {}
+        inline void draw(const typename Object<dimensions>::MatrixType&, typename Object<dimensions>::CameraType*) {}
 };
 
 /** @brief Two-dimensional scene */
-typedef Scene<Matrix3, Vector2, Object2D, Camera2D> Scene2D;
+typedef Scene<2> Scene2D;
 
 /** @brief Three-dimensional scene */
-typedef Scene<Matrix4, Vector3, Object3D, Camera3D> Scene3D;
+typedef Scene<3> Scene3D;
 
 }}