diff --git a/src/DebugTools/ForceRenderer.cpp b/src/DebugTools/ForceRenderer.cpp index 5ee1f2179..da72e3501 100644 --- a/src/DebugTools/ForceRenderer.cpp +++ b/src/DebugTools/ForceRenderer.cpp @@ -64,7 +64,7 @@ const std::array indices{{ } -template ForceRenderer::ForceRenderer(SceneGraph::AbstractBasicObject* object, const typename DimensionTraits::VectorType& forcePosition, const typename DimensionTraits::VectorType* force, ResourceKey options, SceneGraph::BasicDrawableGroup* drawables): SceneGraph::BasicDrawable(object, drawables), forcePosition(forcePosition), force(force), options(ResourceManager::instance()->get(options)) { +template ForceRenderer::ForceRenderer(SceneGraph::AbstractObject* object, const typename DimensionTraits::VectorType& forcePosition, const typename DimensionTraits::VectorType* force, ResourceKey options, SceneGraph::BasicDrawableGroup* drawables): SceneGraph::BasicDrawable(object, drawables), forcePosition(forcePosition), force(force), options(ResourceManager::instance()->get(options)) { /* Shader */ shader = ResourceManager::instance()->get>(shaderKey()); if(!shader) ResourceManager::instance()->set(shader.key(), new Shaders::Flat); diff --git a/src/DebugTools/ForceRenderer.h b/src/DebugTools/ForceRenderer.h index 3a40ec092..1b70c545c 100644 --- a/src/DebugTools/ForceRenderer.h +++ b/src/DebugTools/ForceRenderer.h @@ -117,7 +117,7 @@ template class MAGNUM_DEBUGTOOLS_EXPORT ForceRenderer: p * saved as reference to original vector and thus it must be available * for the whole lifetime of the renderer. */ - explicit ForceRenderer(SceneGraph::AbstractBasicObject* object, const typename DimensionTraits::VectorType& forcePosition, const typename DimensionTraits::VectorType* force, ResourceKey options = ResourceKey(), SceneGraph::BasicDrawableGroup* drawables = nullptr); + explicit ForceRenderer(SceneGraph::AbstractObject* object, const typename DimensionTraits::VectorType& forcePosition, const typename DimensionTraits::VectorType* force, ResourceKey options = ResourceKey(), SceneGraph::BasicDrawableGroup* drawables = nullptr); protected: void draw(const typename DimensionTraits::MatrixType& transformationMatrix, SceneGraph::AbstractBasicCamera* camera) override; diff --git a/src/DebugTools/ObjectRenderer.cpp b/src/DebugTools/ObjectRenderer.cpp index 94194bc4c..3f4573452 100644 --- a/src/DebugTools/ObjectRenderer.cpp +++ b/src/DebugTools/ObjectRenderer.cpp @@ -142,7 +142,7 @@ const std::array Renderer<3>::indices{{ } -template ObjectRenderer::ObjectRenderer(SceneGraph::AbstractBasicObject* object, ResourceKey options, SceneGraph::BasicDrawableGroup* drawables): SceneGraph::BasicDrawable(object, drawables), options(ResourceManager::instance()->get(options)) { +template ObjectRenderer::ObjectRenderer(SceneGraph::AbstractObject* object, ResourceKey options, SceneGraph::BasicDrawableGroup* drawables): SceneGraph::BasicDrawable(object, drawables), options(ResourceManager::instance()->get(options)) { /* Shader */ shader = ResourceManager::instance()->get>(Renderer::shader()); if(!shader) ResourceManager::instance()->set(shader.key(), new Shaders::VertexColor); diff --git a/src/DebugTools/ObjectRenderer.h b/src/DebugTools/ObjectRenderer.h index 7f86de227..eb92f723b 100644 --- a/src/DebugTools/ObjectRenderer.h +++ b/src/DebugTools/ObjectRenderer.h @@ -96,7 +96,7 @@ template class MAGNUM_DEBUGTOOLS_EXPORT ObjectRenderer: * * The renderer is automatically added to object's features. */ - explicit ObjectRenderer(SceneGraph::AbstractBasicObject* object, ResourceKey options = ResourceKey(), SceneGraph::BasicDrawableGroup* drawables = nullptr); + explicit ObjectRenderer(SceneGraph::AbstractObject* object, ResourceKey options = ResourceKey(), SceneGraph::BasicDrawableGroup* drawables = nullptr); protected: void draw(const typename DimensionTraits::MatrixType& transformationMatrix, SceneGraph::AbstractBasicCamera* camera) override; diff --git a/src/SceneGraph/AbstractCamera.h b/src/SceneGraph/AbstractCamera.h index e07f90bb2..52dc8b497 100644 --- a/src/SceneGraph/AbstractCamera.h +++ b/src/SceneGraph/AbstractCamera.h @@ -78,7 +78,7 @@ template class MAGNUM_SCENEGRAPH_EXPORT Abstrac * @brief Constructor * @param object Object holding the camera */ - explicit AbstractBasicCamera(AbstractBasicObject* object); + explicit AbstractBasicCamera(AbstractObject* object); virtual ~AbstractBasicCamera() = 0; diff --git a/src/SceneGraph/AbstractCamera.hpp b/src/SceneGraph/AbstractCamera.hpp index dbd368ba9..15f7d3fad 100644 --- a/src/SceneGraph/AbstractCamera.hpp +++ b/src/SceneGraph/AbstractCamera.hpp @@ -70,7 +70,7 @@ template typename DimensionTraits AbstractBasicCamera::AbstractBasicCamera(AbstractBasicObject* object): AbstractBasicFeature(object), _aspectRatioPolicy(AspectRatioPolicy::NotPreserved) { +template AbstractBasicCamera::AbstractBasicCamera(AbstractObject* object): AbstractBasicFeature(object), _aspectRatioPolicy(AspectRatioPolicy::NotPreserved) { AbstractBasicFeature::setCachedTransformations(CachedTransformation::InvertedAbsolute); } @@ -88,14 +88,14 @@ template void AbstractBasicCamera void AbstractBasicCamera::draw(BasicDrawableGroup& group) { - AbstractBasicObject* scene = AbstractBasicFeature::object()->scene(); + AbstractObject* scene = AbstractBasicFeature::object()->scene(); CORRADE_ASSERT(scene, "Camera::draw(): cannot draw when camera is not part of any scene", ); /* Compute camera matrix */ AbstractBasicFeature::object()->setClean(); /* Compute transformations of all objects in the group relative to the camera */ - std::vector*> objects(group.size()); + std::vector*> objects(group.size()); for(std::size_t i = 0; i != group.size(); ++i) objects[i] = group[i]->object(); std::vector::MatrixType> transformations = diff --git a/src/SceneGraph/AbstractFeature.h b/src/SceneGraph/AbstractFeature.h index 343b9b6bc..00e0ad57d 100644 --- a/src/SceneGraph/AbstractFeature.h +++ b/src/SceneGraph/AbstractFeature.h @@ -141,7 +141,7 @@ class TransformingFeature: public SceneGraph::AbstractFeature3D { }; @endcode If we take for example @ref Object "Object", it is -derived from @ref AbstractBasicObject "AbstractObject3D" and +derived from @ref AbstractObject "AbstractObject3D" and @ref BasicMatrixTransformation3D "MatrixTransformation3D", which is derived from @ref AbstractBasicTranslationRotationScaling3D "AbstractTranslationRotationScaling3D", which is derived from @ref AbstractBasicTranslationRotation3D "AbstractTranslationRotation3D", @@ -161,11 +161,11 @@ AbstractFeature.hpp implementation file to avoid linker errors. See also */ template class MAGNUM_SCENEGRAPH_EXPORT AbstractBasicFeature #ifndef DOXYGEN_GENERATING_OUTPUT -: private Containers::LinkedListItem, AbstractBasicObject> +: private Containers::LinkedListItem, AbstractObject> #endif { friend class Containers::LinkedList>; - friend class Containers::LinkedListItem, AbstractBasicObject>; + friend class Containers::LinkedListItem, AbstractObject>; template friend class Object; public: @@ -173,38 +173,38 @@ template class MAGNUM_SCENEGRAPH_EXPORT Abstrac * @brief Constructor * @param object %Object holding this feature */ - explicit AbstractBasicFeature(AbstractBasicObject* object); + explicit AbstractBasicFeature(AbstractObject* object); virtual ~AbstractBasicFeature() = 0; /** @brief %Object holding this feature */ - AbstractBasicObject* object() { - return Containers::LinkedListItem, AbstractBasicObject>::list(); + AbstractObject* object() { + return Containers::LinkedListItem, AbstractObject>::list(); } /** @overload */ - const AbstractBasicObject* object() const { - return Containers::LinkedListItem, AbstractBasicObject>::list(); + const AbstractObject* object() const { + return Containers::LinkedListItem, AbstractObject>::list(); } /** @brief Previous feature or `nullptr`, if this is first feature */ AbstractBasicFeature* previousFeature() { - return Containers::LinkedListItem, AbstractBasicObject>::previous(); + return Containers::LinkedListItem, AbstractObject>::previous(); } /** @overload */ const AbstractBasicFeature* previousFeature() const { - return Containers::LinkedListItem, AbstractBasicObject>::previous(); + return Containers::LinkedListItem, AbstractObject>::previous(); } /** @brief Next feature or `nullptr`, if this is last feature */ AbstractBasicFeature* nextFeature() { - return Containers::LinkedListItem, AbstractBasicObject>::next(); + return Containers::LinkedListItem, AbstractObject>::next(); } /** @overload */ const AbstractBasicFeature* nextFeature() const { - return Containers::LinkedListItem, AbstractBasicObject>::next(); + return Containers::LinkedListItem, AbstractObject>::next(); } /** diff --git a/src/SceneGraph/AbstractFeature.hpp b/src/SceneGraph/AbstractFeature.hpp index 27210fa1f..837aee192 100644 --- a/src/SceneGraph/AbstractFeature.hpp +++ b/src/SceneGraph/AbstractFeature.hpp @@ -32,7 +32,7 @@ namespace Magnum { namespace SceneGraph { -template AbstractBasicFeature::AbstractBasicFeature(AbstractBasicObject* object) { +template AbstractBasicFeature::AbstractBasicFeature(AbstractObject* object) { object->Containers::template LinkedList>::insert(this); } diff --git a/src/SceneGraph/AbstractGroupedFeature.h b/src/SceneGraph/AbstractGroupedFeature.h index 2d5efe8c9..4b45f4ff5 100644 --- a/src/SceneGraph/AbstractGroupedFeature.h +++ b/src/SceneGraph/AbstractGroupedFeature.h @@ -78,7 +78,7 @@ template class AbstractBasicGrou * Adds the feature to the object and to group, if specified. * @see FeatureGroup::add() */ - explicit AbstractBasicGroupedFeature(AbstractBasicObject* object, BasicFeatureGroup* group = nullptr): AbstractBasicFeature(object), _group(nullptr) { + explicit AbstractBasicGroupedFeature(AbstractObject* object, BasicFeatureGroup* group = nullptr): AbstractBasicFeature(object), _group(nullptr) { if(group) group->add(static_cast(this)); } diff --git a/src/SceneGraph/AbstractObject.h b/src/SceneGraph/AbstractObject.h index ee1c5e9ab..080515e06 100644 --- a/src/SceneGraph/AbstractObject.h +++ b/src/SceneGraph/AbstractObject.h @@ -25,7 +25,7 @@ */ /** @file - * @brief Class Magnum::SceneGraph::AbstractBasicObject, alias Magnum::SceneGraph::AbstractObject2D, Magnum::SceneGraph::AbstractObject3D + * @brief Class Magnum::SceneGraph::AbstractObject, alias Magnum::SceneGraph::AbstractBasicObject2D, Magnum::SceneGraph::AbstractBasicObject3D, typedef Magnum::SceneGraph::AbstractObject2D, Magnum::SceneGraph::AbstractObject3D */ #include @@ -54,15 +54,16 @@ for(AbstractFeature* feature = o->firstFeature(); feature; feature = feature->ne } @endcode -@see @ref AbstractObject2D, @ref AbstractObject3D +@see @ref AbstractBasicObject2D, @ref AbstractBasicObject3D, + @ref AbstractObject2D, @ref AbstractObject3D */ -template class MAGNUM_SCENEGRAPH_EXPORT AbstractBasicObject +template class MAGNUM_SCENEGRAPH_EXPORT AbstractObject #ifndef DOXYGEN_GENERATING_OUTPUT : private Containers::LinkedList> #endif { friend class Containers::LinkedList>; - friend class Containers::LinkedListItem, AbstractBasicObject>; + friend class Containers::LinkedListItem, AbstractObject>; friend class AbstractBasicFeature; public: @@ -72,8 +73,8 @@ template class MAGNUM_SCENEGRAPH_EXPORT Abstrac /** @brief Feature object type */ typedef AbstractBasicFeature FeatureType; - explicit AbstractBasicObject(); - virtual ~AbstractBasicObject(); + explicit AbstractObject(); + virtual ~AbstractObject(); /** @brief Whether this object has features */ bool hasFeatures() const { @@ -104,10 +105,10 @@ template class MAGNUM_SCENEGRAPH_EXPORT Abstrac * @brief %Scene * @return %Scene or `nullptr`, if the object is not part of any scene. */ - AbstractBasicObject* scene() { return doScene(); } + AbstractObject* scene() { return doScene(); } /** @overload */ - const AbstractBasicObject* scene() const { return doScene(); } + const AbstractObject* scene() const { return doScene(); } /** @{ @name Object transformation */ @@ -138,7 +139,7 @@ template class MAGNUM_SCENEGRAPH_EXPORT Abstrac * Object type, use typesafe Object::transformationMatrices() when * possible. */ - std::vector transformationMatrices(const std::vector*>& objects, const MatrixType& initialTransformationMatrix = MatrixType()) const { + std::vector transformationMatrices(const std::vector*>& objects, const MatrixType& initialTransformationMatrix = MatrixType()) const { return doTransformationMatrices(objects, initialTransformationMatrix); } @@ -157,7 +158,7 @@ template class MAGNUM_SCENEGRAPH_EXPORT Abstrac * @warning This function cannot check if all objects are of the same * Object type, use typesafe Object::setClean() when possible. */ - static void setClean(const std::vector*>& objects) { + static void setClean(const std::vector*>& objects) { if(objects.empty()) return; objects.front()->doSetClean(objects); } @@ -203,32 +204,64 @@ template class MAGNUM_SCENEGRAPH_EXPORT Abstrac /*@}*/ private: - virtual AbstractBasicObject* doScene() = 0; - virtual const AbstractBasicObject* doScene() const = 0; + virtual AbstractObject* doScene() = 0; + virtual const AbstractObject* doScene() const = 0; virtual MatrixType doTransformationMatrix() const = 0; virtual MatrixType doAbsoluteTransformationMatrix() const = 0; - virtual std::vector doTransformationMatrices(const std::vector*>& objects, const MatrixType& initialTransformationMatrix) const = 0; + virtual std::vector doTransformationMatrices(const std::vector*>& objects, const MatrixType& initialTransformationMatrix) const = 0; virtual bool doIsDirty() const = 0; virtual void doSetDirty() = 0; virtual void doSetClean() = 0; - virtual void doSetClean(const std::vector*>& objects) = 0; + virtual void doSetClean(const std::vector*>& objects) = 0; }; +#ifndef CORRADE_GCC46_COMPATIBILITY +/** +@brief Base object for two-dimensional scenes + +Convenience alternative to %AbstractObject<2, T>. See AbstractObject +for more information. +@note Not available on GCC < 4.7. Use %AbstractObject<2, T> instead. +@see @ref AbstractObject2D, @ref AbstractBasicObject3D +*/ +template using AbstractBasicObject2D = AbstractObject<2, T>; +#endif + /** @brief Base object for two-dimensional float scenes @see @ref AbstractObject3D */ -typedef AbstractBasicObject<2, Float> AbstractObject2D; +#ifndef CORRADE_GCC46_COMPATIBILITY +typedef AbstractBasicObject2D AbstractObject2D; +#else +typedef AbstractObject<2, Float> AbstractObject2D; +#endif + +#ifndef CORRADE_GCC46_COMPATIBILITY +/** +@brief Base object for three-dimensional scenes + +Convenience alternative to %AbstractObject<3, T>. See AbstractObject +for more information. +@note Not available on GCC < 4.7. Use %AbstractObject<3, T> instead. +@see AbstractObject2D +*/ +template using AbstractBasicObject3D = AbstractObject<3, T>; +#endif /** @brief Base object for three-dimensional float scenes @see @ref AbstractObject2D */ -typedef AbstractBasicObject<3, Float> AbstractObject3D; +#ifndef CORRADE_GCC46_COMPATIBILITY +typedef AbstractBasicObject3D AbstractObject3D; +#else +typedef AbstractObject<3, Float> AbstractObject3D; +#endif }} diff --git a/src/SceneGraph/Animable.h b/src/SceneGraph/Animable.h index 8d22714d7..1ebcdcdfa 100644 --- a/src/SceneGraph/Animable.h +++ b/src/SceneGraph/Animable.h @@ -154,7 +154,7 @@ template class MAGNUM_SCENEGRAPH_EXPORT BasicAn * adds the feature to the object and also to group, if specified. * @see setDuration(), setState(), setRepeated(), BasicAnimableGroup::add() */ - explicit BasicAnimable(AbstractBasicObject* object, BasicAnimableGroup* group = nullptr); + explicit BasicAnimable(AbstractObject* object, BasicAnimableGroup* group = nullptr); ~BasicAnimable(); diff --git a/src/SceneGraph/Animable.hpp b/src/SceneGraph/Animable.hpp index b34101bea..061e4f836 100644 --- a/src/SceneGraph/Animable.hpp +++ b/src/SceneGraph/Animable.hpp @@ -35,7 +35,7 @@ namespace Magnum { namespace SceneGraph { -template BasicAnimable::BasicAnimable(AbstractBasicObject* object, BasicAnimableGroup* group): AbstractBasicGroupedFeature, T>(object, group), _duration(0.0f), startTime(std::numeric_limits::infinity()), pauseTime(-std::numeric_limits::infinity()), previousState(AnimationState::Stopped), currentState(AnimationState::Stopped), _repeated(false), _repeatCount(0), repeats(0) {} +template BasicAnimable::BasicAnimable(AbstractObject* object, BasicAnimableGroup* group): AbstractBasicGroupedFeature, T>(object, group), _duration(0.0f), startTime(std::numeric_limits::infinity()), pauseTime(-std::numeric_limits::infinity()), previousState(AnimationState::Stopped), currentState(AnimationState::Stopped), _repeated(false), _repeatCount(0), repeats(0) {} template BasicAnimable::~BasicAnimable() {} diff --git a/src/SceneGraph/Camera2D.h b/src/SceneGraph/Camera2D.h index 02a935d1b..17dc1cf06 100644 --- a/src/SceneGraph/Camera2D.h +++ b/src/SceneGraph/Camera2D.h @@ -64,7 +64,7 @@ template class MAGNUM_SCENEGRAPH_EXPORT BasicCamera2D: public AbstractB * Sets orthographic projection to the default OpenGL cube (range @f$ [-1; 1] @f$ in all directions). * @see setProjection() */ - explicit BasicCamera2D(AbstractBasicObject<2, T>* object); + explicit BasicCamera2D(AbstractObject<2, T>* object); /** * @brief Set projection diff --git a/src/SceneGraph/Camera2D.hpp b/src/SceneGraph/Camera2D.hpp index 7de9807fd..16926a89d 100644 --- a/src/SceneGraph/Camera2D.hpp +++ b/src/SceneGraph/Camera2D.hpp @@ -35,7 +35,7 @@ using namespace std; namespace Magnum { namespace SceneGraph { -template BasicCamera2D::BasicCamera2D(AbstractBasicObject<2, T>* object): AbstractBasicCamera<2, T>(object) {} +template BasicCamera2D::BasicCamera2D(AbstractObject<2, T>* object): AbstractBasicCamera<2, T>(object) {} template BasicCamera2D* BasicCamera2D::setProjection(const Math::Vector2& size) { AbstractBasicCamera<2, T>::rawProjectionMatrix = Math::Matrix3::projection(size); diff --git a/src/SceneGraph/Camera3D.h b/src/SceneGraph/Camera3D.h index 77cba35a2..66e66158c 100644 --- a/src/SceneGraph/Camera3D.h +++ b/src/SceneGraph/Camera3D.h @@ -66,7 +66,7 @@ template class MAGNUM_SCENEGRAPH_EXPORT BasicCamera3D: public AbstractB * @brief Constructor * @param object %Object holding this feature */ - explicit BasicCamera3D(AbstractBasicObject<3, T>* object); + explicit BasicCamera3D(AbstractObject<3, T>* object); /** * @brief Set orthographic projection diff --git a/src/SceneGraph/Camera3D.hpp b/src/SceneGraph/Camera3D.hpp index 4cee4003b..81f15bfa0 100644 --- a/src/SceneGraph/Camera3D.hpp +++ b/src/SceneGraph/Camera3D.hpp @@ -33,7 +33,7 @@ namespace Magnum { namespace SceneGraph { -template BasicCamera3D::BasicCamera3D(AbstractBasicObject<3, T>* object): AbstractBasicCamera<3, T>(object), _near(T(0)), _far(T(0)) {} +template BasicCamera3D::BasicCamera3D(AbstractObject<3, T>* object): AbstractBasicCamera<3, T>(object), _near(T(0)), _far(T(0)) {} template BasicCamera3D* BasicCamera3D::setOrthographic(const Math::Vector2& size, T near, T far) { /** @todo Get near/far from the matrix */ diff --git a/src/SceneGraph/Drawable.h b/src/SceneGraph/Drawable.h index e5beac03f..ee9595e70 100644 --- a/src/SceneGraph/Drawable.h +++ b/src/SceneGraph/Drawable.h @@ -126,7 +126,7 @@ template class BasicDrawable: public AbstractBa * Adds the feature to the object and also to the group, if specified. * Otherwise you can use BasicDrawableGroup::add(). */ - explicit BasicDrawable(AbstractBasicObject* object, BasicDrawableGroup* drawables = nullptr): AbstractBasicGroupedFeature, T>(object, drawables) {} + explicit BasicDrawable(AbstractObject* object, BasicDrawableGroup* drawables = nullptr): AbstractBasicGroupedFeature, T>(object, drawables) {} /** * @brief Draw the object using given camera diff --git a/src/SceneGraph/Object.h b/src/SceneGraph/Object.h index 28de664cd..2698c5653 100644 --- a/src/SceneGraph/Object.h +++ b/src/SceneGraph/Object.h @@ -88,7 +88,7 @@ See @ref compilation-speedup-hpp for more information. @see Scene, AbstractFeature, AbstractTransformation, DebugTools::ObjectRenderer */ -template class MAGNUM_SCENEGRAPH_EXPORT Object: public AbstractBasicObject, public Transformation +template class MAGNUM_SCENEGRAPH_EXPORT Object: public AbstractObject, public Transformation #ifndef DOXYGEN_GENERATING_OUTPUT , private Containers::LinkedList>, private Containers::LinkedListItem, Object> #endif @@ -129,7 +129,7 @@ template class MAGNUM_SCENEGRAPH_EXPORT Object: public Abs * See @ref scenegraph-hierarchy for more information. */ - /** @copydoc AbstractBasicObject::scene() */ + /** @copydoc AbstractObject::scene() */ Scene* scene(); const Scene* scene() const; /**< @overload */ @@ -271,13 +271,13 @@ template class MAGNUM_SCENEGRAPH_EXPORT Object: public Abs /* `objects` passed by copy intentionally (to avoid copy internally) */ static void setClean(std::vector*> objects); - /** @copydoc AbstractBasicObject::isDirty() */ + /** @copydoc AbstractObject::isDirty() */ bool isDirty() const { return !!(flags & Flag::Dirty); } - /** @copydoc AbstractBasicObject::setDirty() */ + /** @copydoc AbstractObject::setDirty() */ void setDirty(); - /** @copydoc AbstractBasicObject::setClean() */ + /** @copydoc AbstractObject::setClean() */ void setClean(); /*@}*/ @@ -298,14 +298,14 @@ template class MAGNUM_SCENEGRAPH_EXPORT Object: public Abs return absoluteTransformationMatrix(); } - std::vector doTransformationMatrices(const std::vector*>& objects, const MatrixType& initialTransformationMatrix) const override final; + std::vector doTransformationMatrices(const std::vector*>& objects, const MatrixType& initialTransformationMatrix) const override final; typename Transformation::DataType MAGNUM_SCENEGRAPH_LOCAL computeJointTransformation(const std::vector*>& jointObjects, std::vector& jointTransformations, const std::size_t joint, const typename Transformation::DataType& initialTransformation) const; bool MAGNUM_SCENEGRAPH_LOCAL doIsDirty() const override final { return isDirty(); } void MAGNUM_SCENEGRAPH_LOCAL doSetDirty() override final { setDirty(); } void MAGNUM_SCENEGRAPH_LOCAL doSetClean() override final { setClean(); } - void doSetClean(const std::vector*>& objects) override final; + void doSetClean(const std::vector*>& objects) override final; void MAGNUM_SCENEGRAPH_LOCAL setClean(const typename Transformation::DataType& absoluteTransformation); diff --git a/src/SceneGraph/Object.hpp b/src/SceneGraph/Object.hpp index 1dd120ce5..0fa140ae6 100644 --- a/src/SceneGraph/Object.hpp +++ b/src/SceneGraph/Object.hpp @@ -38,8 +38,8 @@ namespace Magnum { namespace SceneGraph { -template AbstractBasicObject::AbstractBasicObject() {} -template AbstractBasicObject::~AbstractBasicObject() {} +template AbstractObject::AbstractObject() {} +template AbstractObject::~AbstractObject() {} template AbstractBasicTransformation::AbstractBasicTransformation() {} @@ -160,7 +160,7 @@ template void Object::setClean() { } } -template auto Object::doTransformationMatrices(const std::vector*>& objects, const MatrixType& initialTransformationMatrix) const -> std::vector { +template auto Object::doTransformationMatrices(const std::vector*>& objects, const MatrixType& initialTransformationMatrix) const -> std::vector { std::vector*> castObjects(objects.size()); for(std::size_t i = 0; i != objects.size(); ++i) /** @todo Ensure this doesn't crash, somehow */ @@ -322,7 +322,7 @@ template typename Transformation::DataType Object void Object::doSetClean(const std::vector*>& objects) { +template void Object::doSetClean(const std::vector*>& objects) { std::vector*> castObjects(objects.size()); for(std::size_t i = 0; i != objects.size(); ++i) /** @todo Ensure this doesn't crash, somehow */ diff --git a/src/SceneGraph/SceneGraph.h b/src/SceneGraph/SceneGraph.h index 255b02640..4dfb0a194 100644 --- a/src/SceneGraph/SceneGraph.h +++ b/src/SceneGraph/SceneGraph.h @@ -58,9 +58,16 @@ template using AbstractGroupedFeature2D = AbstractBasicGroupedFea template using AbstractGroupedFeature3D = AbstractBasicGroupedFeature<3, Derived, Float>; #endif -template class AbstractBasicObject; -typedef AbstractBasicObject<2, Float> AbstractObject2D; -typedef AbstractBasicObject<3, Float> AbstractObject3D; +template class AbstractObject; +#ifndef CORRADE_GCC46_COMPATIBILITY +template using AbstractBasicObject2D = AbstractObject<2, T>; +template using AbstractBasicObject3D = AbstractObject<3, T>; +typedef AbstractBasicObject2D AbstractObject2D; +typedef AbstractBasicObject3D AbstractObject3D; +#else +typedef AbstractObject<2, Float> AbstractObject2D; +typedef AbstractObject<3, Float> AbstractObject3D; +#endif enum class TransformationType: UnsignedByte; diff --git a/src/SceneGraph/instantiation.cpp b/src/SceneGraph/instantiation.cpp index 4c731c268..ab056b10c 100644 --- a/src/SceneGraph/instantiation.cpp +++ b/src/SceneGraph/instantiation.cpp @@ -37,8 +37,8 @@ namespace Magnum { namespace SceneGraph { #ifndef DOXYGEN_GENERATING_OUTPUT -template class MAGNUM_SCENEGRAPH_EXPORT AbstractBasicObject<2, Float>; -template class MAGNUM_SCENEGRAPH_EXPORT AbstractBasicObject<3, Float>; +template class MAGNUM_SCENEGRAPH_EXPORT AbstractObject<2, Float>; +template class MAGNUM_SCENEGRAPH_EXPORT AbstractObject<3, Float>; template class MAGNUM_SCENEGRAPH_EXPORT AbstractBasicTransformation<2, Float>; template class MAGNUM_SCENEGRAPH_EXPORT AbstractBasicTransformation<3, Float>; diff --git a/src/Shapes/AbstractShape.cpp b/src/Shapes/AbstractShape.cpp index baff8f03f..0c969964f 100644 --- a/src/Shapes/AbstractShape.cpp +++ b/src/Shapes/AbstractShape.cpp @@ -31,7 +31,7 @@ namespace Magnum { namespace Shapes { -template AbstractShape::AbstractShape(SceneGraph::AbstractBasicObject* object, ShapeGroup* group): SceneGraph::AbstractBasicGroupedFeature, Float>(object, group) { +template AbstractShape::AbstractShape(SceneGraph::AbstractObject* object, ShapeGroup* group): SceneGraph::AbstractBasicGroupedFeature, Float>(object, group) { this->setCachedTransformations(SceneGraph::CachedTransformation::Absolute); } diff --git a/src/Shapes/AbstractShape.h b/src/Shapes/AbstractShape.h index b980d9f60..b114ec23d 100644 --- a/src/Shapes/AbstractShape.h +++ b/src/Shapes/AbstractShape.h @@ -79,7 +79,7 @@ template class MAGNUM_SHAPES_EXPORT AbstractShape: publi * @param object Object holding this feature * @param group Group this shape belongs to */ - explicit AbstractShape(SceneGraph::AbstractBasicObject* object, ShapeGroup* group = nullptr); + explicit AbstractShape(SceneGraph::AbstractObject* object, ShapeGroup* group = nullptr); /** * @brief Shape group containing this shape diff --git a/src/Shapes/Shape.h b/src/Shapes/Shape.h index 05cd10172..6dbf612f2 100644 --- a/src/Shapes/Shape.h +++ b/src/Shapes/Shape.h @@ -75,17 +75,17 @@ template class Shape: public AbstractShape { * @param shape Shape * @param group Group this shape belongs to */ - explicit Shape(SceneGraph::AbstractBasicObject* object, const T& shape, ShapeGroup* group = nullptr): AbstractShape(object, group) { + explicit Shape(SceneGraph::AbstractObject* object, const T& shape, ShapeGroup* group = nullptr): AbstractShape(object, group) { Implementation::ShapeHelper::set(*this, shape); } /** @overload */ - explicit Shape(SceneGraph::AbstractBasicObject* object, T&& shape, ShapeGroup* group = nullptr): AbstractShape(object, group) { + explicit Shape(SceneGraph::AbstractObject* object, T&& shape, ShapeGroup* group = nullptr): AbstractShape(object, group) { Implementation::ShapeHelper::set(*this, std::move(shape)); } /** @overload */ - explicit Shape(SceneGraph::AbstractBasicObject* object, ShapeGroup* group = nullptr): AbstractShape(object, group) {} + explicit Shape(SceneGraph::AbstractObject* object, ShapeGroup* group = nullptr): AbstractShape(object, group) {} /** @brief Shape */ const T& shape() const { return _shape.shape; } diff --git a/src/Shapes/ShapeGroup.cpp b/src/Shapes/ShapeGroup.cpp index 226e7d15d..7c28e30dc 100644 --- a/src/Shapes/ShapeGroup.cpp +++ b/src/Shapes/ShapeGroup.cpp @@ -31,11 +31,11 @@ namespace Magnum { namespace Shapes { template void ShapeGroup::setClean() { /* Clean all objects */ if(!this->isEmpty()) { - std::vector*> objects(this->size()); + std::vector*> objects(this->size()); for(std::size_t i = 0; i != this->size(); ++i) objects[i] = (*this)[i]->object(); - SceneGraph::AbstractBasicObject::setClean(objects); + SceneGraph::AbstractObject::setClean(objects); } dirty = false;