diff --git a/src/DebugTools/ForceRenderer.cpp b/src/DebugTools/ForceRenderer.cpp index da72e3501..c5357f9dd 100644 --- a/src/DebugTools/ForceRenderer.cpp +++ b/src/DebugTools/ForceRenderer.cpp @@ -64,7 +64,7 @@ const std::array indices{{ } -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)) { +template ForceRenderer::ForceRenderer(SceneGraph::AbstractObject* object, const typename DimensionTraits::VectorType& forcePosition, const typename DimensionTraits::VectorType* force, ResourceKey options, SceneGraph::DrawableGroup* drawables): SceneGraph::Drawable(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); @@ -94,7 +94,7 @@ template ForceRenderer::ForceRenderer(SceneG ResourceManager::instance()->set(this->mesh.key(), mesh, ResourceDataState::Final, ResourcePolicy::Manual); } -template void ForceRenderer::draw(const typename DimensionTraits::MatrixType& transformationMatrix, SceneGraph::AbstractBasicCamera* camera) { +template void ForceRenderer::draw(const typename DimensionTraits::MatrixType& transformationMatrix, SceneGraph::AbstractCamera* camera) { shader->setTransformationProjectionMatrix(camera->projectionMatrix()*Implementation::forceRendererTransformation(transformationMatrix.transformPoint(forcePosition), *force)*DimensionTraits::MatrixType::scaling(typename DimensionTraits::VectorType(options->scale()))) ->setColor(options->color()) ->use(); diff --git a/src/DebugTools/ForceRenderer.h b/src/DebugTools/ForceRenderer.h index 1b70c545c..9dacd0986 100644 --- a/src/DebugTools/ForceRenderer.h +++ b/src/DebugTools/ForceRenderer.h @@ -101,7 +101,7 @@ new DebugTools::ForceRenderer2D(object, {0.3f, 1.5f, -0.7f}, &force, "my", debug @see ForceRenderer2D, ForceRenderer3D */ -template class MAGNUM_DEBUGTOOLS_EXPORT ForceRenderer: public SceneGraph::BasicDrawable { +template class MAGNUM_DEBUGTOOLS_EXPORT ForceRenderer: public SceneGraph::Drawable { public: /** * @brief Constructor @@ -117,10 +117,10 @@ 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::AbstractObject* 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::DrawableGroup* drawables = nullptr); protected: - void draw(const typename DimensionTraits::MatrixType& transformationMatrix, SceneGraph::AbstractBasicCamera* camera) override; + void draw(const typename DimensionTraits::MatrixType& transformationMatrix, SceneGraph::AbstractCamera* camera) override; private: const typename DimensionTraits::VectorType forcePosition; diff --git a/src/DebugTools/ObjectRenderer.cpp b/src/DebugTools/ObjectRenderer.cpp index 3f4573452..834ce60db 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::AbstractObject* object, ResourceKey options, SceneGraph::BasicDrawableGroup* drawables): SceneGraph::BasicDrawable(object, drawables), options(ResourceManager::instance()->get(options)) { +template ObjectRenderer::ObjectRenderer(SceneGraph::AbstractObject* object, ResourceKey options, SceneGraph::DrawableGroup* drawables): SceneGraph::Drawable(object, drawables), options(ResourceManager::instance()->get(options)) { /* Shader */ shader = ResourceManager::instance()->get>(Renderer::shader()); if(!shader) ResourceManager::instance()->set(shader.key(), new Shaders::VertexColor); @@ -173,7 +173,7 @@ template ObjectRenderer::ObjectRenderer(Scen ResourceManager::instance()->set(this->mesh.key(), mesh, ResourceDataState::Final, ResourcePolicy::Manual); } -template void ObjectRenderer::draw(const typename DimensionTraits::MatrixType& transformationMatrix, SceneGraph::AbstractBasicCamera* camera) { +template void ObjectRenderer::draw(const typename DimensionTraits::MatrixType& transformationMatrix, SceneGraph::AbstractCamera* camera) { shader->setTransformationProjectionMatrix(camera->projectionMatrix()*transformationMatrix*DimensionTraits::MatrixType::scaling(typename DimensionTraits::VectorType(options->size()))) ->use(); diff --git a/src/DebugTools/ObjectRenderer.h b/src/DebugTools/ObjectRenderer.h index eb92f723b..cfc48c73e 100644 --- a/src/DebugTools/ObjectRenderer.h +++ b/src/DebugTools/ObjectRenderer.h @@ -84,7 +84,7 @@ new DebugTools::ObjectRenderer2D(object, "my", debugDrawables); @see ObjectRenderer2D, ObjectRenderer3D */ -template class MAGNUM_DEBUGTOOLS_EXPORT ObjectRenderer: public SceneGraph::BasicDrawable { +template class MAGNUM_DEBUGTOOLS_EXPORT ObjectRenderer: public SceneGraph::Drawable { public: /** * @brief Constructor @@ -96,10 +96,10 @@ template class MAGNUM_DEBUGTOOLS_EXPORT ObjectRenderer: * * The renderer is automatically added to object's features. */ - explicit ObjectRenderer(SceneGraph::AbstractObject* object, ResourceKey options = ResourceKey(), SceneGraph::BasicDrawableGroup* drawables = nullptr); + explicit ObjectRenderer(SceneGraph::AbstractObject* object, ResourceKey options = ResourceKey(), SceneGraph::DrawableGroup* drawables = nullptr); protected: - void draw(const typename DimensionTraits::MatrixType& transformationMatrix, SceneGraph::AbstractBasicCamera* camera) override; + void draw(const typename DimensionTraits::MatrixType& transformationMatrix, SceneGraph::AbstractCamera* camera) override; private: Resource options; diff --git a/src/DebugTools/ShapeRenderer.cpp b/src/DebugTools/ShapeRenderer.cpp index 52cf39947..1c36ff272 100644 --- a/src/DebugTools/ShapeRenderer.cpp +++ b/src/DebugTools/ShapeRenderer.cpp @@ -97,7 +97,7 @@ template<> void createDebugMesh(ShapeRenderer<3>* renderer, const Shapes::Implem } -template ShapeRenderer::ShapeRenderer(Shapes::AbstractShape* shape, ResourceKey options, SceneGraph::BasicDrawableGroup* drawables): SceneGraph::BasicDrawable(shape->object(), drawables), options(ResourceManager::instance()->get(options)) { +template ShapeRenderer::ShapeRenderer(Shapes::AbstractShape* shape, ResourceKey options, SceneGraph::DrawableGroup* drawables): SceneGraph::Drawable(shape->object(), drawables), options(ResourceManager::instance()->get(options)) { Implementation::createDebugMesh(this, Shapes::Implementation::getAbstractShape(shape)); } @@ -105,7 +105,7 @@ template ShapeRenderer::~ShapeRenderer() { for(auto i: renderers) delete i; } -template void ShapeRenderer::draw(const typename DimensionTraits::MatrixType&, SceneGraph::AbstractBasicCamera* camera) { +template void ShapeRenderer::draw(const typename DimensionTraits::MatrixType&, SceneGraph::AbstractCamera* camera) { typename DimensionTraits::MatrixType projectionMatrix = camera->projectionMatrix()*camera->cameraMatrix(); for(auto i: renderers) i->draw(options, projectionMatrix); } diff --git a/src/DebugTools/ShapeRenderer.h b/src/DebugTools/ShapeRenderer.h index 9c8e0eaf1..d3af6f438 100644 --- a/src/DebugTools/ShapeRenderer.h +++ b/src/DebugTools/ShapeRenderer.h @@ -138,7 +138,7 @@ new DebugTools::ShapeRenderer2D(shape, "red", debugDrawables); @see ShapeRenderer2D, ShapeRenderer3D */ -template class MAGNUM_DEBUGTOOLS_EXPORT ShapeRenderer: public SceneGraph::BasicDrawable { +template class MAGNUM_DEBUGTOOLS_EXPORT ShapeRenderer: public SceneGraph::Drawable { friend void Implementation::createDebugMesh<>(ShapeRenderer*, const Shapes::Implementation::AbstractShape*); public: @@ -154,13 +154,13 @@ template class MAGNUM_DEBUGTOOLS_EXPORT ShapeRenderer: p * @p shape must be available for the whole lifetime of the renderer * and if it is group, it must not change its internal structure. */ - explicit ShapeRenderer(Shapes::AbstractShape* shape, ResourceKey options = ResourceKey(), SceneGraph::BasicDrawableGroup* drawables = nullptr); + explicit ShapeRenderer(Shapes::AbstractShape* shape, ResourceKey options = ResourceKey(), SceneGraph::DrawableGroup* drawables = nullptr); ~ShapeRenderer(); protected: /** @todoc Remove Float when Doxygen properly treats this as override */ - void draw(const typename DimensionTraits::MatrixType& transformationMatrix, SceneGraph::AbstractBasicCamera* camera) override; + void draw(const typename DimensionTraits::MatrixType& transformationMatrix, SceneGraph::AbstractCamera* camera) override; private: Resource options; diff --git a/src/SceneGraph/AbstractCamera.h b/src/SceneGraph/AbstractCamera.h index e7e71fb25..c504986dd 100644 --- a/src/SceneGraph/AbstractCamera.h +++ b/src/SceneGraph/AbstractCamera.h @@ -25,7 +25,7 @@ */ /** @file - * @brief Class Magnum::SceneGraph::AbstractBasicCamera, enum Magnum::SceneGraph::AspectRatioPolicy, typedef Magnum::SceneGraph::AbstractCamera2D, Magnum::SceneGraph::AbstractCamera3D + * @brief Class Magnum::SceneGraph::AbstractCamera, enum Magnum::SceneGraph::AspectRatioPolicy, alias Magnum::SceneGraph::AbstractBasicCamera2D, Magnum::SceneGraph::AbstractBasicCamera3D, typedef Magnum::SceneGraph::AbstractCamera2D, Magnum::SceneGraph::AbstractCamera3D */ #include "Math/Matrix3.h" @@ -39,7 +39,7 @@ namespace Magnum { namespace SceneGraph { /** @brief Camera aspect ratio policy -@see AbstractBasicCamera::setAspectRatioPolicy() +@see AbstractCamera::setAspectRatioPolicy() */ enum class AspectRatioPolicy: UnsignedByte { NotPreserved, /**< Don't preserve aspect ratio (default) */ @@ -55,7 +55,8 @@ namespace Implementation { @brief Base for cameras See Drawable documentation for more information. This class is not directly -instantiatable, use Camera2D or Camera3D subclasses instead. +instantiatable, use @ref BasicCamera2D or @ref BasicCamera3D subclasses +instead. @section AbstractCamera-explicit-specializations Explicit template specializations @@ -67,20 +68,21 @@ relevant sections in @ref Camera3D-explicit-specializations "Camera3D" class documentation or @ref compilation-speedup-hpp for more information. - - @ref AbstractBasicCamera "AbstractBasicCamera<2, Float>" - - @ref AbstractBasicCamera "AbstractBasicCamera<3, Float>" + - @ref AbstractCamera "AbstractCamera<2, Float>" + - @ref AbstractCamera "AbstractCamera<3, Float>" -@see AbstractCamera2D, AbstractCamera3D, @ref scenegraph, Drawable, DrawableGroup +@see @ref scenegraph, @ref AbstractBasicCamera2D, @ref AbstractBasicCamera3D, + @ref Drawable, @ref DrawableGroup */ -template class MAGNUM_SCENEGRAPH_EXPORT AbstractBasicCamera: public AbstractFeature { +template class MAGNUM_SCENEGRAPH_EXPORT AbstractCamera: public AbstractFeature { public: /** * @brief Constructor * @param object Object holding the camera */ - explicit AbstractBasicCamera(AbstractObject* object); + explicit AbstractCamera(AbstractObject* object); - virtual ~AbstractBasicCamera() = 0; + virtual ~AbstractCamera() = 0; /** @brief Aspect ratio policy */ AspectRatioPolicy aspectRatioPolicy() const { return _aspectRatioPolicy; } @@ -89,7 +91,7 @@ template class MAGNUM_SCENEGRAPH_EXPORT Abstrac * @brief Set aspect ratio policy * @return Pointer to self (for method chaining) */ - AbstractBasicCamera* setAspectRatioPolicy(AspectRatioPolicy policy); + AbstractCamera* setAspectRatioPolicy(AspectRatioPolicy policy); /** * @brief Camera matrix @@ -138,7 +140,7 @@ template class MAGNUM_SCENEGRAPH_EXPORT Abstrac * * Draws given group of drawables. */ - virtual void draw(BasicDrawableGroup& group); + virtual void draw(DrawableGroup& group); protected: /** Recalculates camera matrix */ @@ -162,19 +164,51 @@ template class MAGNUM_SCENEGRAPH_EXPORT Abstrac Vector2i _viewport; }; +#ifndef CORRADE_GCC46_COMPATIBILITY +/** +@brief Base camera for two-dimensional scenes + +Convenience alternative to %AbstractCamera<2, T>. See AbstractCamera +for more information. +@note Not available on GCC < 4.7. Use %AbstractCamera<2, T> instead. +@see @ref AbstractCamera2D, @ref AbstractBasicCamera3D +*/ +template using AbstractBasicCamera2D = AbstractCamera<2, T>; +#endif + /** @brief Base camera for two-dimensional float scenes -@see AbstractCamera3D +@see @ref AbstractCamera3D +*/ +#ifndef CORRADE_GCC46_COMPATIBILITY +typedef AbstractBasicCamera2D AbstractCamera2D; +#else +typedef AbstractCamera<2, Float> AbstractCamera2D; +#endif + +#ifndef CORRADE_GCC46_COMPATIBILITY +/** +@brief Base camera for three-dimensional scenes + +Convenience alternative to %AbstractCamera<3, T>. See AbstractCamera +for more information. +@note Not available on GCC < 4.7. Use %AbstractCamera<3, T> instead. +@see @ref AbstractCamera3D, @ref AbstractBasicCamera2D */ -typedef AbstractBasicCamera<2, Float> AbstractCamera2D; +template using AbstractBasicCamera3D = AbstractCamera<3, T>; +#endif /** @brief Base camera for three-dimensional float scenes -@see AbstractBasicCamera2D +@see @ref AbstractCamera2D */ -typedef AbstractBasicCamera<3, Float> AbstractCamera3D; +#ifndef CORRADE_GCC46_COMPATIBILITY +typedef AbstractBasicCamera3D AbstractCamera3D; +#else +typedef AbstractCamera<3, Float> AbstractCamera3D; +#endif }} diff --git a/src/SceneGraph/AbstractCamera.hpp b/src/SceneGraph/AbstractCamera.hpp index 91d7ed59a..413cc4b86 100644 --- a/src/SceneGraph/AbstractCamera.hpp +++ b/src/SceneGraph/AbstractCamera.hpp @@ -70,24 +70,24 @@ template typename DimensionTraits AbstractBasicCamera::AbstractBasicCamera(AbstractObject* object): AbstractFeature(object), _aspectRatioPolicy(AspectRatioPolicy::NotPreserved) { +template AbstractCamera::AbstractCamera(AbstractObject* object): AbstractFeature(object), _aspectRatioPolicy(AspectRatioPolicy::NotPreserved) { AbstractFeature::setCachedTransformations(CachedTransformation::InvertedAbsolute); } -template AbstractBasicCamera::~AbstractBasicCamera() {} +template AbstractCamera::~AbstractCamera() {} -template AbstractBasicCamera* AbstractBasicCamera::setAspectRatioPolicy(AspectRatioPolicy policy) { +template AbstractCamera* AbstractCamera::setAspectRatioPolicy(AspectRatioPolicy policy) { _aspectRatioPolicy = policy; fixAspectRatio(); return this; } -template void AbstractBasicCamera::setViewport(const Vector2i& size) { +template void AbstractCamera::setViewport(const Vector2i& size) { _viewport = size; fixAspectRatio(); } -template void AbstractBasicCamera::draw(BasicDrawableGroup& group) { +template void AbstractCamera::draw(DrawableGroup& group) { AbstractObject* scene = AbstractFeature::object()->scene(); CORRADE_ASSERT(scene, "Camera::draw(): cannot draw when camera is not part of any scene", ); diff --git a/src/SceneGraph/Camera2D.h b/src/SceneGraph/Camera2D.h index 17dc1cf06..991a6b8e5 100644 --- a/src/SceneGraph/Camera2D.h +++ b/src/SceneGraph/Camera2D.h @@ -1,5 +1,5 @@ -#ifndef Magnum_SceneGraph_BasicCamera2D_h -#define Magnum_SceneGraph_BasicCamera2D_h +#ifndef Magnum_SceneGraph_Camera2D_h +#define Magnum_SceneGraph_Camera2D_h /* This file is part of Magnum. @@ -39,7 +39,7 @@ See Drawable documentation for introduction. The camera by default displays OpenGL unit cube `[(-1, -1, -1); (1, 1, 1)]` and doesn't do any aspect ratio correction. Common setup example: @code -SceneGraph::BasicCamera2D* camera = new SceneGraph::BasicCamera2D(&cameraObject); +SceneGraph::Camera2D* camera = new SceneGraph::Camera2D(&cameraObject); camera->setProjection({4.0f/3.0f, 1.0f}) ->setAspectRatioPolicy(SceneGraph::AspectRatioPolicy::Extend); @endcode @@ -47,15 +47,16 @@ camera->setProjection({4.0f/3.0f, 1.0f}) @section Camera2D-explicit-specializations Explicit template specializations The following specialization are explicitly compiled into SceneGraph library. -For other specializations (e.g. using Double type) you have to use -BasicCamera2D.hpp implementation file to avoid linker errors. See -@ref compilation-speedup-hpp for more information. +For other specializations (e.g. using Double type) you have to use Camera2D.hpp +implementation file to avoid linker errors. See @ref compilation-speedup-hpp +for more information. - @ref BasicCamera2D "BasicCamera2D" -@see @ref Camera2D, @ref scenegraph, @ref BasicCamera3D, @ref BasicDrawable, @ref BasicDrawableGroup +@see @ref scenegraph, @ref Camera2D, @ref BasicCamera3D, @ref Drawable, + @ref DrawableGroup */ -template class MAGNUM_SCENEGRAPH_EXPORT BasicCamera2D: public AbstractBasicCamera<2, T> { +template class MAGNUM_SCENEGRAPH_EXPORT BasicCamera2D: public AbstractCamera<2, T> { public: /** * @brief Constructor @@ -78,7 +79,7 @@ template class MAGNUM_SCENEGRAPH_EXPORT BasicCamera2D: public AbstractB /* Overloads to remove WTF-factor from method chaining order */ #ifndef DOXYGEN_GENERATING_OUTPUT BasicCamera2D* setAspectRatioPolicy(AspectRatioPolicy policy) { - AbstractBasicCamera<2, T>::setAspectRatioPolicy(policy); + AbstractCamera<2, T>::setAspectRatioPolicy(policy); return this; } #endif diff --git a/src/SceneGraph/Camera2D.hpp b/src/SceneGraph/Camera2D.hpp index 16926a89d..94b785770 100644 --- a/src/SceneGraph/Camera2D.hpp +++ b/src/SceneGraph/Camera2D.hpp @@ -33,14 +33,16 @@ using namespace std; +/** @todo Use AbstractBasicCamera2D when support for GCC 4.6 is dropped (also in header) */ + namespace Magnum { namespace SceneGraph { -template BasicCamera2D::BasicCamera2D(AbstractObject<2, T>* object): AbstractBasicCamera<2, T>(object) {} +template BasicCamera2D::BasicCamera2D(AbstractObject<2, T>* object): AbstractCamera<2, T>(object) {} template BasicCamera2D* BasicCamera2D::setProjection(const Math::Vector2& size) { - AbstractBasicCamera<2, T>::rawProjectionMatrix = Math::Matrix3::projection(size); + AbstractCamera<2, T>::rawProjectionMatrix = Math::Matrix3::projection(size); - AbstractBasicCamera<2, T>::fixAspectRatio(); + AbstractCamera<2, T>::fixAspectRatio(); return this; } diff --git a/src/SceneGraph/Camera3D.h b/src/SceneGraph/Camera3D.h index 66e66158c..0a8cb2b0d 100644 --- a/src/SceneGraph/Camera3D.h +++ b/src/SceneGraph/Camera3D.h @@ -44,7 +44,7 @@ See Drawable documentation for introduction. The camera by default displays OpenGL unit cube `[(-1, -1, -1); (1, 1, 1)]` with orthographic projection and doesn't do any aspect ratio correction. Common setup example: @code -SceneGraph::BasicCamera3D* camera = new SceneGraph::BasicCamera3D(&cameraObject); +SceneGraph::Camera3D* camera = new SceneGraph::Camera3D(&cameraObject); camera->setPerspective({}, 0.001f, 100.0f) ->setAspectRatioPolicy(SceneGraph::AspectRatioPolicy::Extend); @endcode @@ -52,15 +52,16 @@ camera->setPerspective({}, 0.001f, 100.0f) @section Camera3D-explicit-specializations Explicit template specializations The following specialization are explicitly compiled into SceneGraph library. -For other specializations (e.g. using Double type) you have to use -BasicCamera3D.hpp implementation file to avoid linker errors. See -@ref compilation-speedup-hpp for more information. +For other specializations (e.g. using Double type) you have to use Camera3D.hpp +implementation file to avoid linker errors. See @ref compilation-speedup-hpp +for more information. - @ref BasicCamera3D "BasicCamera3D" -@see @ref Camera3D, @ref scenegraph, @ref BasicCamera2D, @ref BasicDrawable, @ref BasicDrawableGroup +@see @ref scenegraph, @ref Camera3D, @ref BasicCamera2D, @ref Drawable, + @ref DrawableGroup */ -template class MAGNUM_SCENEGRAPH_EXPORT BasicCamera3D: public AbstractBasicCamera<3, T> { +template class MAGNUM_SCENEGRAPH_EXPORT BasicCamera3D: public AbstractCamera<3, T> { public: /** * @brief Constructor @@ -111,7 +112,7 @@ template class MAGNUM_SCENEGRAPH_EXPORT BasicCamera3D: public AbstractB /* Overloads to remove WTF-factor from method chaining order */ #ifndef DOXYGEN_GENERATING_OUTPUT BasicCamera3D* setAspectRatioPolicy(AspectRatioPolicy policy) { - AbstractBasicCamera<3, T>::setAspectRatioPolicy(policy); + AbstractCamera<3, T>::setAspectRatioPolicy(policy); return this; } #endif diff --git a/src/SceneGraph/Camera3D.hpp b/src/SceneGraph/Camera3D.hpp index 81f15bfa0..73fd88b53 100644 --- a/src/SceneGraph/Camera3D.hpp +++ b/src/SceneGraph/Camera3D.hpp @@ -31,17 +31,19 @@ #include "AbstractCamera.hpp" #include "Camera3D.h" +/** @todo Use AbstractBasicCamera3D when support for GCC 4.6 is dropped (also in header) */ + namespace Magnum { namespace SceneGraph { -template BasicCamera3D::BasicCamera3D(AbstractObject<3, T>* object): AbstractBasicCamera<3, T>(object), _near(T(0)), _far(T(0)) {} +template BasicCamera3D::BasicCamera3D(AbstractObject<3, T>* object): AbstractCamera<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 */ _near = near; _far = far; - AbstractBasicCamera<3, T>::rawProjectionMatrix = Math::Matrix4::orthographicProjection(size, near, far); - AbstractBasicCamera<3, T>::fixAspectRatio(); + AbstractCamera<3, T>::rawProjectionMatrix = Math::Matrix4::orthographicProjection(size, near, far); + AbstractCamera<3, T>::fixAspectRatio(); return this; } @@ -50,8 +52,8 @@ template BasicCamera3D* BasicCamera3D::setPerspective(const Math: _near = near; _far = far; - AbstractBasicCamera<3, T>::rawProjectionMatrix = Math::Matrix4::perspectiveProjection(size, near, far); - AbstractBasicCamera<3, T>::fixAspectRatio(); + AbstractCamera<3, T>::rawProjectionMatrix = Math::Matrix4::perspectiveProjection(size, near, far); + AbstractCamera<3, T>::fixAspectRatio(); return this; } @@ -60,8 +62,8 @@ template BasicCamera3D* BasicCamera3D::setPerspective(Math::Rad::rawProjectionMatrix = Math::Matrix4::perspectiveProjection(fov, aspectRatio, near, far); - AbstractBasicCamera<3, T>::fixAspectRatio(); + AbstractCamera<3, T>::rawProjectionMatrix = Math::Matrix4::perspectiveProjection(fov, aspectRatio, near, far); + AbstractCamera<3, T>::fixAspectRatio(); return this; } diff --git a/src/SceneGraph/Drawable.h b/src/SceneGraph/Drawable.h index c67a22bae..1678d1ff4 100644 --- a/src/SceneGraph/Drawable.h +++ b/src/SceneGraph/Drawable.h @@ -25,7 +25,7 @@ */ /** @file - * @brief Class Magnum::SceneGraph::BasicDrawable, Magnum::SceneGraph::BasicDrawableGroup, typedef Magnum::SceneGraph::Drawable2D, Magnum::SceneGraph::Drawable3D, Magnum::SceneGraph::DrawableGroup2D, Magnum::SceneGraph::DrawableGroup3D + * @brief Class Magnum::SceneGraph::Drawable, Magnum::SceneGraph::DrawableGroup, alias Magnum::SceneGraph::BasicDrawable2D, Magnum::SceneGraph::BasicDrawable3D, Magnum::SceneGraph::BasicDrawableGroup2D, Magnum::SceneGraph::BasicDrawableGroup3D, typedef Magnum::SceneGraph::Drawable2D, Magnum::SceneGraph::Drawable3D, Magnum::SceneGraph::DrawableGroup2D, Magnum::SceneGraph::DrawableGroup3D */ #include "AbstractGroupedFeature.h" @@ -35,7 +35,7 @@ namespace Magnum { namespace SceneGraph { /** @brief %Drawable -Adds drawing function to the object. Each Drawable is part of some DrawableGroup +Adds drawing function to the object. Each %Drawable is part of some DrawableGroup and the whole group is drawn with particular camera using AbstractCamera::draw(). @section Drawable-usage Usage @@ -60,8 +60,8 @@ class DrawableObject: public Object3D, SceneGraph::Drawable3D { @endcode Then you add these objects to your scene and some drawable group and transform -them as you like. You can also use BasicDrawableGroup::add() and -BasicDrawableGroup::remove(). +them as you like. You can also use DrawableGroup::add() and +DrawableGroup::remove(). @code Scene3D scene; SceneGraph::DrawableGroup3D drawables; @@ -78,7 +78,7 @@ The last thing you need is Camera attached to some object (thus using its transformation) and with it you can perform drawing in your draw event implementation. See Camera2D and Camera3D documentation for more information. @code -Camera3D<> camera(&cameraObject); +Camera3D camera(&cameraObject); void MyApplication::drawEvent() { camera.draw(drawables); @@ -114,9 +114,10 @@ void MyApplication::drawEvent() { } @endcode -@see Drawable2D, Drawable3D, @ref scenegraph, DrawableGroup2D, DrawableGroup3D +@see @ref scenegraph, @ref BasicDrawable2D, @ref BasicDrawable3D, + @ref Drawable2D, @ref Drawable3D, @ref DrawableGroup */ -template class BasicDrawable: public AbstractGroupedFeature, T> { +template class Drawable: public AbstractGroupedFeature, T> { public: /** * @brief Constructor @@ -124,9 +125,9 @@ template class BasicDrawable: public AbstractGr * @param drawables Group this drawable belongs to * * Adds the feature to the object and also to the group, if specified. - * Otherwise you can use BasicDrawableGroup::add(). + * Otherwise you can use DrawableGroup::add(). */ - explicit BasicDrawable(AbstractObject* object, BasicDrawableGroup* drawables = nullptr): AbstractGroupedFeature, T>(object, drawables) {} + explicit Drawable(AbstractObject* object, DrawableGroup* drawables = nullptr): AbstractGroupedFeature, T>(object, drawables) {} /** * @brief Draw the object using given camera @@ -136,48 +137,113 @@ template class BasicDrawable: public AbstractGr * * Projection matrix can be retrieved from AbstractCamera::projectionMatrix(). */ - virtual void draw(const typename DimensionTraits::MatrixType& transformationMatrix, AbstractBasicCamera* camera) = 0; + virtual void draw(const typename DimensionTraits::MatrixType& transformationMatrix, AbstractCamera* camera) = 0; }; +#ifndef CORRADE_GCC46_COMPATIBILITY +/** +@brief %Drawable for two-dimensional scenes + +Convenience alternative to %Drawable<2, T>. See Drawable for more +information. +@note Not available on GCC < 4.7. Use %Drawable<2, T> instead. +@see @ref Drawable2D, @ref BasicDrawable3D +*/ +template using BasicDrawable2D = Drawable<2, T>; +#endif + +/** +@brief %Drawable for two-dimensional float scenes + +@see @ref Drawable3D +*/ +#ifndef CORRADE_GCC46_COMPATIBILITY +typedef BasicDrawable2D Drawable2D; +#else +typedef Drawable<2, Float> Drawable2D; +#endif + +#ifndef CORRADE_GCC46_COMPATIBILITY /** -@brief Two-dimensional drawable for float scenes +@brief %Drawable for three-dimensional scenes -@see Drawable3D +Convenience alternative to %Drawable<3, T>. See Drawable for more +information. +@note Not available on GCC < 4.7. Use %Drawable<3, T> instead. +@see @ref Drawable3D, @ref BasicDrawable3D */ -typedef BasicDrawable<2, Float> Drawable2D; +template using BasicDrawable3D = Drawable<3, T>; +#endif /** -@brief Three-dimensional drawable for float scenes +@brief %Drawable for three-dimensional float scenes -@see Drawable2D +@see @ref Drawable2D */ -typedef BasicDrawable<3, Float> Drawable3D; +#ifndef CORRADE_GCC46_COMPATIBILITY +typedef BasicDrawable3D Drawable3D; +#else +typedef Drawable<3, Float> Drawable3D; +#endif /** @brief Group of drawables -See Drawable for more information. -@see @ref scenegraph, DrawableGroup2D, DrawableGroup3D +See @ref Drawable for more information. +@see @ref scenegraph, @ref BasicDrawableGroup2D, @ref BasicDrawableGroup3D, + @ref DrawableGroup2D, @ref DrawableGroup3D */ #ifndef CORRADE_GCC46_COMPATIBILITY -template using BasicDrawableGroup = FeatureGroup, T>; +template using DrawableGroup = FeatureGroup, T>; #else -template class BasicDrawableGroup: public FeatureGroup, T> {}; +template class DrawableGroup: public FeatureGroup, T> {}; #endif +#ifndef CORRADE_GCC46_COMPATIBILITY +/** +@brief Group of drawables for two-dimensional scenes + +Convenience alternative to %DrawableGroup<2, T>. See Drawable for +more information. +@note Not available on GCC < 4.7. Use %Drawable<2, T> instead. +@see @ref DrawableGroup2D, @ref BasicDrawableGroup3D +*/ +template using BasicDrawableGroup2D = DrawableGroup<2, T>; +#endif + +/** +@brief Group of drawables for two-dimensional float scenes + +@see @ref DrawableGroup3D +*/ +#ifndef CORRADE_GCC46_COMPATIBILITY +typedef BasicDrawableGroup2D DrawableGroup2D; +#else +typedef DrawableGroup<2, Float> DrawableGroup2D; +#endif + +#ifndef CORRADE_GCC46_COMPATIBILITY /** -@brief Group of two-dimensional drawables for float scenes +@brief Group of drawables for three-dimensional scenes -@see DrawableGroup3D +Convenience alternative to %DrawableGroup<3, T>. See Drawable for +more information. +@note Not available on GCC < 4.7. Use %Drawable<3, T> instead. +@see @ref DrawableGroup3D, @ref BasicDrawableGroup2D */ -typedef BasicDrawableGroup<2, Float> DrawableGroup2D; +template using BasicDrawableGroup3D = DrawableGroup<3, T>; +#endif /** -@brief Group of three-dimensional drawables for float scenes +@brief Group of drawables for three-dimensional float scenes -@see DrawableGroup2D +@see @ref DrawableGroup2D */ -typedef BasicDrawableGroup<3, Float> DrawableGroup3D; +#ifndef CORRADE_GCC46_COMPATIBILITY +typedef BasicDrawableGroup3D DrawableGroup3D; +#else +typedef DrawableGroup<3, Float> DrawableGroup3D; +#endif }} diff --git a/src/SceneGraph/SceneGraph.h b/src/SceneGraph/SceneGraph.h index cb520efe7..fa5ec383b 100644 --- a/src/SceneGraph/SceneGraph.h +++ b/src/SceneGraph/SceneGraph.h @@ -38,9 +38,16 @@ namespace Magnum { namespace SceneGraph { #ifndef DOXYGEN_GENERATING_OUTPUT enum class AspectRatioPolicy: UnsignedByte; -template class AbstractBasicCamera; -typedef AbstractBasicCamera<2, Float> AbstractCamera2D; -typedef AbstractBasicCamera<3, Float> AbstractCamera3D; +template class AbstractCamera; +#ifndef CORRADE_GCC46_COMPATIBILITY +template using AbstractBasicCamera2D = AbstractCamera<2, T>; +template using AbstractBasicCamera3D = AbstractCamera<3, T>; +typedef AbstractBasicCamera2D AbstractCamera2D; +typedef AbstractBasicCamera3D AbstractCamera3D; +#else +typedef AbstractCamera<2, Float> AbstractCamera2D; +typedef AbstractCamera<3, Float> AbstractCamera3D; +#endif /* Enum CachedTransformation and CachedTransformations used only directly */ @@ -128,9 +135,13 @@ template class BasicCamera3D; typedef BasicCamera2D Camera2D; typedef BasicCamera3D Camera3D; -template class BasicDrawable; -typedef BasicDrawable<2, Float> Drawable2D; -typedef BasicDrawable<3, Float> Drawable3D; +template class Drawable; +#ifndef CORRADE_GCC46_COMPATIBILITY +template using BasicDrawable2D = Drawable<2, T>; +template using BasicDrawable3D = Drawable<3, T>; +typedef BasicDrawable2D Drawable2D; +typedef BasicDrawable3D Drawable3D; +#endif template class BasicDualComplexTransformation; template class BasicDualQuaternionTransformation; @@ -146,12 +157,16 @@ template using FeatureGroup3D = BasicFeatureGroup3D using BasicDrawableGroup = FeatureGroup, T>; +template using DrawableGroup = FeatureGroup, T>; +template using BasicDrawableGroup2D = DrawableGroup<2, T>; +template using BasicDrawableGroup3D = DrawableGroup<3, T>; +typedef BasicDrawableGroup2D DrawableGroup2D; +typedef BasicDrawableGroup3D DrawableGroup3D; #else -template class BasicDrawableGroup; +template class DrawableGroup; +typedef DrawableGroup<2, Float> DrawableGroup2D; +typedef DrawableGroup<3, Float> DrawableGroup3D; #endif -typedef BasicDrawableGroup<2, Float> DrawableGroup2D; -typedef BasicDrawableGroup<3, Float> DrawableGroup3D; template class BasicMatrixTransformation2D; template class BasicMatrixTransformation3D; diff --git a/src/SceneGraph/instantiation.cpp b/src/SceneGraph/instantiation.cpp index 75ae63633..5e4565cb4 100644 --- a/src/SceneGraph/instantiation.cpp +++ b/src/SceneGraph/instantiation.cpp @@ -47,8 +47,8 @@ template class MAGNUM_SCENEGRAPH_EXPORT AbstractFeature<3, Float>; template class MAGNUM_SCENEGRAPH_EXPORT AbstractFeatureGroup<2, Float>; template class MAGNUM_SCENEGRAPH_EXPORT AbstractFeatureGroup<3, Float>; -template class AbstractBasicCamera<2, Float>; -template class AbstractBasicCamera<3, Float>; +template class AbstractCamera<2, Float>; +template class AbstractCamera<3, Float>; template class MAGNUM_SCENEGRAPH_EXPORT BasicCamera2D; template class MAGNUM_SCENEGRAPH_EXPORT BasicCamera3D;