SceneGraph: Solved default template parameter conflicts.

Using header with forward declarations, containing declarations for all
classes with default parameters. The classes themselves don't have the
defaults.

This also allows users to more conveniently forward-declare instead of
digging in sources and writing the declarations on their own.

doc/compilation-speedup.dox

@@ -14,6 +14,11 @@ floating-point vectors and matrices like @ref Vector3 and @ref Matrix4, but to
 actually use any of them, you have to include the respective header, e.g.
 Math/Vector3.h.
 
+You are encouraged to use forward declarations also in your code. However, for
+some types it can be too cumbersome -- e.g. too many template parameters,
+typedefs etc. In this case a header with forward declarations is usually
+available: see SceneGraph/SceneGraph.h for example.
+
 @section compilation-speedup-templates Templates
 
 Many things in %Magnum are templated to allow handling of various types and

src/SceneGraph/AbstractCamera.h

@@ -27,14 +27,6 @@
 
 namespace Magnum { namespace SceneGraph {
 
-template<std::uint8_t, class> class Drawable;
-template<std::uint8_t, class, class> class FeatureGroup;
-#ifndef MAGNUM_GCC46_COMPATIBILITY
-template<std::uint8_t dimensions, class T = GLfloat> using DrawableGroup = FeatureGroup<dimensions, Drawable<dimensions, T>, T>;
-#else
-template<std::uint8_t, class> class DrawableGroup;
-#endif
-
 /** @relates AbstractCamera
 @brief Camera aspect ratio policy
 
@@ -72,7 +64,12 @@ file to avoid linker errors. See also relevant sections in
 
 @see Drawable, DrawableGroup, AbstractCamera2D, AbstractCamera3D
 */
-template<std::uint8_t dimensions, class T = GLfloat> class SCENEGRAPH_EXPORT AbstractCamera: public AbstractFeature<dimensions, T> {
+#ifndef DOXYGEN_GENERATING_OUTPUT
+template<std::uint8_t dimensions, class T>
+#else
+template<std::uint8_t dimensions, class T = GLfloat>
+#endif
+class SCENEGRAPH_EXPORT AbstractCamera: public AbstractFeature<dimensions, T> {
     public:
         /**
          * @brief Constructor
@@ -200,12 +197,6 @@ template<class T = GLfloat> using AbstractCamera3D = AbstractCamera<3, T>;
 typedef AbstractCamera<3, T = GLfloat> AbstractCamera3D;
 #endif
 
-/* Make implementers' life easier */
-#ifndef MAGNUM_GCC46_COMPATIBILITY
-template<class T = GLfloat> using DrawableGroup2D = DrawableGroup<2, T>;
-template<class T = GLfloat> using DrawableGroup3D = DrawableGroup<3, T>;
-#endif
-
 }}
 
 #endif

src/SceneGraph/AbstractFeature.h

@@ -114,10 +114,11 @@ which is automatically extracted from the pointer in our constructor.
 
 @see AbstractFeature2D, AbstractFeature3D
 */
+#ifndef DOXYGEN_GENERATING_OUTPUT
+template<std::uint8_t dimensions, class T> class AbstractFeature: private Corrade::Containers::LinkedListItem<AbstractFeature<dimensions, T>, AbstractObject<dimensions, T>>
+#else
 template<std::uint8_t dimensions, class T = GLfloat> class AbstractFeature
-    #ifndef DOXYGEN_GENERATING_OUTPUT
+#endif
-    : private Corrade::Containers::LinkedListItem<AbstractFeature<dimensions, T>, AbstractObject<dimensions, T>>
-    #endif
 {
     friend class Corrade::Containers::LinkedList<AbstractFeature<dimensions, T>>;
     friend class Corrade::Containers::LinkedListItem<AbstractFeature<dimensions, T>, AbstractObject<dimensions, T>>;

src/SceneGraph/AbstractGroupedFeature.h

@@ -47,7 +47,12 @@ typedef SceneGraph::FeatureGroup3D<Drawable> DrawableGroup;
 @see AbstractGroupedFeature2D, AbstractGroupedFeature3D, FeatureGroup,
     FeatureGroup2D, FeatureGroup3D
 */
-template<std::uint8_t dimensions, class Derived, class T = GLfloat> class AbstractGroupedFeature: public AbstractFeature<dimensions, T> {
+#ifndef DOXYGEN_GENERATING_OUTPUT
+template<std::uint8_t dimensions, class Derived, class T>
+#else
+template<std::uint8_t dimensions, class Derived, class T = GLfloat>
+#endif
+class AbstractGroupedFeature: public AbstractFeature<dimensions, T> {
     friend class FeatureGroup<dimensions, Derived, T>;
 
     public:
@@ -123,12 +128,6 @@ template<class Derived, class T = GLfloat> using AbstractGroupedFeature3D = Abst
 typedef AbstractGroupedFeature<3, Derived, T = GLfloat> AbstractGroupedFeature3D;
 #endif
 
-/* Make implementers' life easier */
-#ifndef MAGNUM_GCC46_COMPATIBILITY
-template<class Feature, class T = GLfloat> using FeatureGroup2D = FeatureGroup<2, Feature, T>;
-template<class Feature, class T = GLfloat> using FeatureGroup3D = FeatureGroup<3, Feature, T>;
-#endif
-
 }}
 
 #endif

src/SceneGraph/AbstractObject.h

@@ -22,14 +22,12 @@
 #include <Containers/LinkedList.h>
 
 #include "DimensionTraits.h"
-#include "Magnum.h"
+#include "SceneGraph.h"
 
 #include "magnumCompatibility.h"
 
 namespace Magnum { namespace SceneGraph {
 
-template<std::uint8_t, class> class AbstractFeature;
-
 /**
 @brief Base for objects
 
@@ -39,10 +37,11 @@ instead. See also @ref scenegraph for more information.
 
 @see AbstractObject2D, AbstractObject3D
 */
+#ifndef DOXYGEN_GENERATING_OUTPUT
+template<std::uint8_t dimensions, class T> class AbstractObject: private Corrade::Containers::LinkedList<AbstractFeature<dimensions, T>>
+#else
 template<std::uint8_t dimensions, class T = GLfloat> class AbstractObject
-    #ifndef DOXYGEN_GENERATING_OUTPUT
+#endif
-    : private Corrade::Containers::LinkedList<AbstractFeature<dimensions, T>>
-    #endif
 {
     friend class Corrade::Containers::LinkedList<AbstractFeature<dimensions, T>>;
     friend class Corrade::Containers::LinkedListItem<AbstractFeature<dimensions, T>, AbstractObject<dimensions, T>>;

src/SceneGraph/AbstractTransformation.h

@@ -21,13 +21,11 @@
 
 #include <vector>
 
-#include "Magnum.h"
 #include "DimensionTraits.h"
+#include "SceneGraph.h"
 
 namespace Magnum { namespace SceneGraph {
 
-template<class> class Object;
-
 /**
 @brief Base for transformations
 
@@ -43,7 +41,12 @@ When sublassing, you have to:
 
 @see AbstractTransformation2D, AbstractTransformation3D
 */
-template<std::uint8_t dimensions, class T = GLfloat> class AbstractTransformation {
+#ifndef DOXYGEN_GENERATING_OUTPUT
+template<std::uint8_t dimensions, class T>
+#else
+template<std::uint8_t dimensions, class T = GLfloat>
+#endif
+class AbstractTransformation {
     public:
         /** @brief Underlying floating-point type */
         typedef T Type;

src/SceneGraph/AbstractTranslationRotation2D.h

@@ -28,7 +28,12 @@ namespace Magnum { namespace SceneGraph {
 
 @see AbstractTranslationRotation3D
 */
-template<class T = GLfloat> class AbstractTranslationRotation2D: public AbstractTransformation<2, T> {
+#ifndef DOXYGEN_GENERATING_OUTPUT
+template<class T>
+#else
+template<class T = GLfloat>
+#endif
+class AbstractTranslationRotation2D: public AbstractTransformation<2, T> {
     public:
         /**
          * @brief Translate object

src/SceneGraph/AbstractTranslationRotation3D.h

@@ -29,7 +29,12 @@ namespace Magnum { namespace SceneGraph {
 
 @see AbstractTranslationRotation2D
 */
-template<class T = GLfloat> class AbstractTranslationRotation3D: public AbstractTransformation<3, T> {
+#ifndef DOXYGEN_GENERATING_OUTPUT
+template<class T>
+#else
+template<class T = GLfloat>
+#endif
+class AbstractTranslationRotation3D: public AbstractTransformation<3, T> {
     public:
         /**
          * @brief Translate object

src/SceneGraph/AbstractTranslationRotationScaling2D.h

@@ -28,7 +28,12 @@ namespace Magnum { namespace SceneGraph {
 
 @see AbstractTranslationRotationScaling2D
 */
-template<class T = GLfloat> class AbstractTranslationRotationScaling2D: public AbstractTranslationRotation2D<T> {
+#ifndef DOXYGEN_GENERATING_OUTPUT
+template<class T>
+#else
+template<class T = GLfloat>
+#endif
+class AbstractTranslationRotationScaling2D: public AbstractTranslationRotation2D<T> {
     public:
         /**
          * @brief Scale object

src/SceneGraph/AbstractTranslationRotationScaling3D.h

@@ -28,7 +28,12 @@ namespace Magnum { namespace SceneGraph {
 
 @see AbstractTranslationRotationScaling2D
 */
-template<class T = GLfloat> class AbstractTranslationRotationScaling3D: public AbstractTranslationRotation3D<T> {
+#ifndef DOXYGEN_GENERATING_OUTPUT
+template<class T>
+#else
+template<class T = GLfloat>
+#endif
+class AbstractTranslationRotationScaling3D: public AbstractTranslationRotation3D<T> {
     public:
         /**
          * @brief Scale object

src/SceneGraph/CMakeLists.txt

@@ -22,6 +22,7 @@ set(MagnumSceneGraph_HEADERS
     Object.h
     Object.hpp
     Scene.h
+    SceneGraph.h
 
     magnumSceneGraphVisibility.h)
 add_library(MagnumSceneGraphObjects OBJECT ${MagnumSceneGraph_SRCS})

src/SceneGraph/Camera2D.h

@@ -38,7 +38,12 @@ avoid linker errors. See @ref compilation-speedup-hpp for more information.
 
 @see Camera3D, Drawable, DrawableGroup
 */
-template<class T = GLfloat> class SCENEGRAPH_EXPORT Camera2D: public AbstractCamera<2, T> {
+#ifndef DOXYGEN_GENERATING_OUTPUT
+template<class T>
+#else
+template<class T = GLfloat>
+#endif
+class SCENEGRAPH_EXPORT Camera2D: public AbstractCamera<2, T> {
     public:
         /**
          * @brief Constructor

src/SceneGraph/Camera3D.h

@@ -43,7 +43,12 @@ avoid linker errors. See @ref compilation-speedup-hpp for more information.
 
 @see Camera2D, Drawable, DrawableGroup
 */
-template<class T = GLfloat> class SCENEGRAPH_EXPORT Camera3D: public AbstractCamera<3, T> {
+#ifndef DOXYGEN_GENERATING_OUTPUT
+template<class T>
+#else
+template<class T = GLfloat>
+#endif
+class SCENEGRAPH_EXPORT Camera3D: public AbstractCamera<3, T> {
     public:
         /**
          * @brief Constructor

src/SceneGraph/Drawable.h

@@ -23,14 +23,6 @@
 
 namespace Magnum { namespace SceneGraph {
 
-template<std::uint8_t, class> class AbstractCamera;
-template<std::uint8_t, class> class Drawable;
-#ifndef MAGNUM_GCC46_COMPATIBILITY
-template<std::uint8_t dimensions, class T = GLfloat> using DrawableGroup = FeatureGroup<dimensions, Drawable<dimensions, T>, T>;
-#else
-template<std::uint8_t, class> class DrawableGroup;
-#endif
-
 /**
 @brief %Drawable
 
@@ -85,7 +77,12 @@ void MyApplication::drawEvent() {
 
 @see Drawable2D, Drawable3D, DrawableGroup2D, DrawableGroup3D
 */
-template<std::uint8_t dimensions, class T = GLfloat> class Drawable: public AbstractGroupedFeature<dimensions, Drawable<dimensions, T>, T> {
+#ifndef DOXYGEN_GENERATING_OUTPUT
+template<std::uint8_t dimensions, class T>
+#else
+template<std::uint8_t dimensions, class T = GLfloat>
+#endif
+class Drawable: public AbstractGroupedFeature<dimensions, Drawable<dimensions, T>, T> {
     public:
         /** @copydoc AbstractGroupedFeature::AbstractGroupedFeature() */
         inline Drawable(AbstractObject<dimensions, T>* object, DrawableGroup<dimensions, T>* group = nullptr): AbstractGroupedFeature<dimensions, Drawable<dimensions, T>, T>(object, group) {}
@@ -145,7 +142,12 @@ See Drawable for more information.
 #if !defined(MAGNUM_GCC46_COMPATIBILITY) && !defined(DOXYGEN_GENERATING_OUTPUT)
 template<std::uint8_t dimensions, class T = GLfloat> using DrawableGroup = FeatureGroup<dimensions, Drawable<dimensions, T>, T>;
 #else
-template<std::uint8_t dimensions, class T = GLfloat> class DrawableGroup: public FeatureGroup<dimensions, Drawable<dimensions, T>, T> {};
+#ifndef DOXYGEN_GENERATING_OUTPUT
+template<std::uint8_t dimensions, class T>
+#else
+template<std::uint8_t dimensions, class T = GLfloat>
+#endif
+class DrawableGroup: public FeatureGroup<dimensions, Drawable<dimensions, T>, T> {};
 #endif
 
 /**
@@ -182,12 +184,6 @@ template<class T = GLfloat> using DrawableGroup3D = DrawableGroup<3, T>;
 typedef DrawableGroup<3, T = GLfloat> DrawableGroup3D;
 #endif
 
-/* Make implementers' life easier */
-#ifndef MAGNUM_GCC46_COMPATIBILITY
-template<class T = GLfloat> using AbstractCamera2D = AbstractCamera<2, T>;
-template<class T = GLfloat> using AbstractCamera3D = AbstractCamera<3, T>;
-#endif
-
 }}
 
 #endif

src/SceneGraph/FeatureGroup.h

@@ -19,24 +19,26 @@
  * @brief Class Magnum::SceneGraph::FeatureGroup, alias Magnum::SceneGraph::FeatureGroup2D, Magnum::SceneGraph::FeatureGroup3D
  */
 
-#include <cstdint>
 #include <algorithm>
 #include <vector>
 #include <Utility/Debug.h>
 
-#include "Magnum.h"
+#include "SceneGraph.h"
 
 namespace Magnum { namespace SceneGraph {
 
-template<std::uint8_t, class, class T> class AbstractGroupedFeature;
-
 /**
 @brief Group of features
 
 See AbstractGroupedFeature for more information.
 @see FeatureGroup2D, FeatureGroup3D
 */
-template<std::uint8_t dimensions, class Feature, class T = GLfloat> class FeatureGroup {
+#ifndef DOXYGEN_GENERATING_OUTPUT
+template<std::uint8_t dimensions, class Feature, class T>
+#else
+template<std::uint8_t dimensions, class Feature, class T = GLfloat>
+#endif
+class FeatureGroup {
     friend class AbstractGroupedFeature<dimensions, Feature, T>;
 
     public:

src/SceneGraph/MatrixTransformation2D.h

@@ -30,7 +30,12 @@ namespace Magnum { namespace SceneGraph {
 
 @see MatrixTransformation3D
 */
-template<class T = GLfloat> class MatrixTransformation2D: public AbstractTranslationRotationScaling2D<T> {
+#ifndef DOXYGEN_GENERATING_OUTPUT
+template<class T>
+#else
+template<class T = GLfloat>
+#endif
+class MatrixTransformation2D: public AbstractTranslationRotationScaling2D<T> {
     public:
         /** @brief Transformation matrix type */
         typedef typename DimensionTraits<2, T>::MatrixType DataType;

src/SceneGraph/MatrixTransformation3D.h

@@ -30,7 +30,12 @@ namespace Magnum { namespace SceneGraph {
 
 @see MatrixTransformation2D
 */
-template<class T = GLfloat> class MatrixTransformation3D: public AbstractTranslationRotationScaling3D<T> {
+#ifndef DOXYGEN_GENERATING_OUTPUT
+template<class T>
+#else
+template<class T = GLfloat>
+#endif
+class MatrixTransformation3D: public AbstractTranslationRotationScaling3D<T> {
     public:
         /** @brief Transformation matrix type */
         typedef typename DimensionTraits<3, T>::MatrixType DataType;

src/SceneGraph/Object.h

@@ -28,8 +28,6 @@
 
 namespace Magnum { namespace SceneGraph {
 
-template<class Transformation> class Scene;
-
 #ifndef DOXYGEN_GENERATING_OUTPUT
 namespace Implementation {
     enum class ObjectFlag: std::uint8_t {

src/SceneGraph/SceneGraph.h

@@ -0,0 +1,94 @@
+#ifndef Magnum_SceneGraph_SceneGraph_h
+#define Magnum_SceneGraph_SceneGraph_h
+/*
+    Copyright © 2010, 2011, 2012 Vladimír Vondruš <mosra@centrum.cz>
+
+    This file is part of Magnum.
+
+    Magnum is free software: you can redistribute it and/or modify
+    it under the terms of the GNU Lesser General Public License version 3
+    only, as published by the Free Software Foundation.
+
+    Magnum 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 Lesser General Public License version 3 for more details.
+*/
+
+/** @file
+ * @brief Forward declarations for Magnum::SceneGraph namespace
+ */
+
+#include <cstdint>
+
+#include "Magnum.h"
+
+namespace Magnum { namespace SceneGraph {
+
+template<std::uint8_t dimensions, class T = GLfloat> class AbstractCamera;
+#ifndef MAGNUM_GCC46_COMPATIBILITY
+template<class T = GLfloat> using AbstractCamera2D = AbstractCamera<2, T>;
+template<class T = GLfloat> using AbstractCamera3D = AbstractCamera<3, T>;
+#endif
+
+template<std::uint8_t dimensions, class T = GLfloat> class AbstractFeature;
+#ifndef MAGNUM_GCC46_COMPATIBILITY
+template<class T = GLfloat> using AbstractFeature2D = AbstractFeature<2, T>;
+template<class T = GLfloat> using AbstractFeature3D = AbstractFeature<3, T>;
+#endif
+
+template<std::uint8_t dimensions, class Derived, class T = GLfloat> class AbstractGroupedFeature;
+#ifndef MAGNUM_GCC46_COMPATIBILITY
+template<class Derived, class T = GLfloat> using AbstractGroupedFeature2D = AbstractGroupedFeature<2, Derived, T>;
+template<class Derived, class T = GLfloat> using AbstractGroupedFeature3D = AbstractGroupedFeature<3, Derived, T>;
+#endif
+
+template<std::uint8_t dimensions, class T = GLfloat> class AbstractObject;
+#ifndef MAGNUM_GCC46_COMPATIBILITY
+template<class T = GLfloat> using AbstractObject2D = AbstractObject<2, T>;
+template<class T = GLfloat> using AbstractObject3D = AbstractObject<3, T>;
+#endif
+
+template<std::uint8_t dimensions, class T = GLfloat> class AbstractTransformation;
+#ifndef MAGNUM_GCC46_COMPATIBILITY
+template<class T = GLfloat> using AbstractTransformation2D = AbstractTransformation<2, T>;
+template<class T = GLfloat> using AbstractTransformation3D = AbstractTransformation<3, T>;
+#endif
+
+template<class T = GLfloat> class AbstractTranslationRotation2D;
+template<class T = GLfloat> class AbstractTranslationRotation3D;
+template<class T = GLfloat> class AbstractTranslationRotationScaling2D;
+template<class T = GLfloat> class AbstractTranslationRotationScaling3D;
+
+template<class T = GLfloat> class Camera2D;
+template<class T = GLfloat> class Camera3D;
+
+template<std::uint8_t dimensions, class T = GLfloat> class Drawable;
+#ifndef MAGNUM_GCC46_COMPATIBILITY
+template<class T = GLfloat> using Drawable2D = Drawable<2, T>;
+template<class T = GLfloat> using Drawable3D = Drawable<3, T>;
+#endif
+
+template<std::uint8_t dimensions, class Feature, class T = GLfloat> class FeatureGroup;
+#ifndef MAGNUM_GCC46_COMPATIBILITY
+template<class Feature, class T = GLfloat> using FeatureGroup2D = FeatureGroup<2, Feature, T>;
+template<class Feature, class T = GLfloat> using FeatureGroup3D = FeatureGroup<3, Feature, T>;
+#endif
+
+#ifndef MAGNUM_GCC46_COMPATIBILITY
+template<std::uint8_t dimensions, class T = GLfloat> using DrawableGroup = FeatureGroup<dimensions, Drawable<dimensions, T>, T>;
+template<class T = GLfloat> using DrawableGroup2D = DrawableGroup<2, T>;
+template<class T = GLfloat> using DrawableGroup3D = DrawableGroup<3, T>;
+#else
+template<std::uint8_t dimensions, class T = GLfloat> class DrawableGroup;
+#endif
+
+template<class T = GLfloat> class MatrixTransformation2D;
+template<class T = GLfloat> class MatrixTransformation3D;
+
+template<class Transformation> class Object;
+template<class Transformation> class Scene;
+
+}}
+
+#endif