Browse Source

Merge branch 'master' into compatibility

Conflicts:
	src/Physics/Implementation/DebugRenderer.h
Vladimír Vondruš 14 years ago
parent
commit
223a9a4a6d
  1. 2
      src/AbstractTexture.h
  2. 2
      src/CMakeLists.txt
  3. 14
      src/Color.h
  4. 32
      src/Context.cpp
  5. 80
      src/Context.h
  6. 2
      src/CubeMapTexture.h
  7. 2
      src/CubeMapTextureArray.h
  8. 48
      src/DebugMarker.cpp
  9. 60
      src/DebugMarker.h
  10. 7
      src/Extensions.h
  11. 4
      src/Framebuffer.h
  12. 4
      src/Magnum.h
  13. 2
      src/Mesh.h
  14. 2
      src/Physics/AbstractShape.h
  15. 4
      src/Physics/AxisAlignedBox.cpp
  16. 18
      src/Physics/AxisAlignedBox.h
  17. 2
      src/Physics/Box.cpp
  18. 12
      src/Physics/Box.h
  19. 8
      src/Physics/Capsule.cpp
  20. 18
      src/Physics/Capsule.h
  21. 4
      src/Physics/DebugDrawResourceManager.h
  22. 2
      src/Physics/Implementation/AbstractDebugRenderer.h
  23. 2
      src/Physics/Implementation/AbstractShapeRenderer.h
  24. 2
      src/Physics/Implementation/AxisAlignedBoxRenderer.cpp
  25. 2
      src/Physics/Implementation/BoxRenderer.cpp
  26. 2
      src/Physics/Implementation/BoxRenderer.h
  27. 2
      src/Physics/Implementation/DebugRenderer.h
  28. 6
      src/Physics/Line.cpp
  29. 18
      src/Physics/Line.h
  30. 2
      src/Physics/LineSegment.h
  31. 2
      src/Physics/ObjectShape.cpp
  32. 2
      src/Physics/Plane.h
  33. 4
      src/Physics/Point.cpp
  34. 12
      src/Physics/Point.h
  35. 2
      src/Physics/ShapeGroup.cpp
  36. 2
      src/Physics/ShapeGroup.h
  37. 6
      src/Physics/Sphere.cpp
  38. 12
      src/Physics/Sphere.h
  39. 41
      src/Platform/Sdl2Application.cpp
  40. 8
      src/Platform/Sdl2Application.h
  41. 95
      src/Primitives/Cube.cpp
  42. 3
      src/Primitives/Cube.h
  43. 16
      src/SceneGraph/Test/ObjectTest.cpp
  44. 6
      src/Shaders/FlatShader.h
  45. 8
      src/Shaders/PhongShader.h
  46. 6
      src/Shaders/VertexColorShader.h
  47. 2
      src/Texture.h

2
src/AbstractTexture.h

@ -677,7 +677,7 @@ class MAGNUM_EXPORT AbstractTexture {
* with @def_gl{TEXTURE_BORDER_COLOR}
* @requires_gl Texture border is not available in OpenGL ES.
*/
inline AbstractTexture* setBorderColor(const Color4<GLfloat>& color) {
inline AbstractTexture* setBorderColor(const Color4<>& color) {
(this->*parameterfvImplementation)(GL_TEXTURE_BORDER_COLOR, color.data());
return this;
}

2
src/CMakeLists.txt

@ -24,6 +24,7 @@ set(Magnum_SRCS
AbstractShaderProgram.cpp
Buffer.cpp
Context.cpp
DebugMarker.cpp
Framebuffer.cpp
Image.cpp
IndexedMesh.cpp
@ -63,6 +64,7 @@ set(Magnum_HEADERS
Color.h
Context.h
CubeMapTexture.h
DebugMarker.h
DimensionTraits.h
Extensions.h
Framebuffer.h

14
src/Color.h

@ -145,7 +145,12 @@ range @f$ [0.0, 1.0] @f$.
*/
/* Not using template specialization because some internal functions are
impossible to explicitly instantiate */
template<class T> class Color3: public Math::Vector3<T> {
#ifndef DOXYGEN_GENERATING_OUTPUT
template<class T>
#else
template<class T = GLfloat>
#endif
class Color3: public Math::Vector3<T> {
public:
/** @brief Corresponding floating-point type for HSV computation */
typedef typename Math::MathTypeTraits<T>::FloatingPointType FloatingPointType;
@ -291,7 +296,12 @@ See Color3 for more information.
*/
/* Not using template specialization because some internal functions are
impossible to explicitly instantiate */
template<class T> class Color4: public Math::Vector4<T> {
#ifndef DOXYGEN_GENERATING_OUTPUT
template<class T>
#else
template<class T = GLfloat>
#endif
class Color4: public Math::Vector4<T> {
public:
/** @copydoc Color3::FloatingPointType */
typedef typename Color3<T>::FloatingPointType FloatingPointType;

32
src/Context.cpp

@ -27,18 +27,47 @@
#include "IndexedMesh.h"
#include "Mesh.h"
#include "Implementation/State.h"
#include "DebugMarker.h"
using namespace std;
namespace Magnum {
Debug operator<<(Debug debug, Version value) {
switch(value) {
#define _c(value, string) case Version::value: return debug << string;
_c(None, "None")
#ifndef MAGNUM_TARGET_GLES
_c(GL210, "OpenGL 2.1")
_c(GL300, "OpenGL 3.0")
_c(GL310, "OpenGL 3.1")
_c(GL320, "OpenGL 3.2")
_c(GL330, "OpenGL 3.3")
_c(GL400, "OpenGL 4.0")
_c(GL410, "OpenGL 4.1")
_c(GL420, "OpenGL 4.2")
_c(GL430, "OpenGL 4.3")
#else
_c(GLES200, "OpenGL ES 2.0")
_c(GLES300, "OpenGL ES 3.0")
#endif
#undef _c
}
return debug << "Invalid";
}
const std::vector<Extension>& Extension::extensions(Version version) {
#define _extension(prefix, vendor, extension) \
{Extensions::prefix::vendor::extension::Index, Extensions::prefix::vendor::extension::requiredVersion(), Extensions::prefix::vendor::extension::coreVersion(), Extensions::prefix::vendor::extension::string()}
static const std::vector<Extension> empty;
#ifndef MAGNUM_TARGET_GLES
static const std::vector<Extension> extensions{
_extension(GL,EXT,texture_filter_anisotropic)};
_extension(GL,AMD,vertex_shader_layer),
_extension(GL,AMD,shader_trinary_minmax),
_extension(GL,EXT,texture_filter_anisotropic),
_extension(GL,EXT,direct_state_access),
_extension(GL,GREMEDY,string_marker)};
static const std::vector<Extension> extensions300{
_extension(GL,APPLE,flush_buffer_range),
_extension(GL,APPLE,vertex_array_object),
@ -248,6 +277,7 @@ Context::Context() {
#ifndef MAGNUM_TARGET_GLES
BufferedTexture::initializeContextBasedFunctionality(this);
#endif
DebugMarker::initializeContextBasedFunctionality(this);
IndexedMesh::initializeContextBasedFunctionality(this);
Mesh::initializeContextBasedFunctionality(this);
}

80
src/Context.h

@ -16,7 +16,7 @@
*/
/** @file
* @brief Enum Version, class Magnum::Context, Magnum::Extension
* @brief Enum Version, class Magnum::Context, Magnum::Extension, macro MAGNUM_ASSERT_VERSION_SUPPORTED(), MAGNUM_ASSERT_EXTENSION_SUPPORTED()
*/
#include <bitset>
@ -34,9 +34,13 @@ namespace Implementation {
}
#endif
/** @brief OpenGL version */
/**
@brief OpenGL version
@see Context, MAGNUM_ASSERT_VERSION_SUPPORTED()
*/
enum class Version: GLint {
None = 0, /**< @brief Unspecified */
None = 0xFFFF, /**< @brief Unspecified */
#ifndef MAGNUM_TARGET_GLES
GL210 = 210, /**< @brief OpenGL 2.1 / GLSL 1.20 */
GL300 = 300, /**< @brief OpenGL 3.0 / GLSL 1.30 */
@ -76,6 +80,9 @@ enum class Version: GLint {
#endif
};
/** @debugoperator{Magnum::Context} */
Debug MAGNUM_EXPORT operator<<(Debug debug, Version value);
/**
@brief Run-time information about OpenGL extension
@ -197,7 +204,7 @@ class MAGNUM_EXPORT Context {
/**
* @brief Whether given OpenGL version is supported
*
* @see supportedVersion()
* @see supportedVersion(), MAGNUM_ASSERT_VERSION_SUPPORTED()
*/
inline bool isVersionSupported(Version version) const {
#ifndef CORRADE_GCC44_COMPATIBILITY
@ -236,7 +243,8 @@ class MAGNUM_EXPORT Context {
* }
* @endcode
*
* @see isExtensionSupported(const Extension&) const
* @see isExtensionSupported(const Extension&) const,
* MAGNUM_ASSERT_EXTENSION_SUPPORTED()
*/
template<class T> inline bool isExtensionSupported() const {
return isVersionSupported(T::coreVersion()) || (isVersionSupported(T::requiredVersion()) && extensionStatus[T::Index]);
@ -249,7 +257,8 @@ class MAGNUM_EXPORT Context {
* hardware, but for general usage prefer isExtensionSupported() const,
* as it does most operations in compile time.
*
* @see supportedExtensions(), Extension::extensions()
* @see supportedExtensions(), Extension::extensions(),
* MAGNUM_ASSERT_EXTENSION_SUPPORTED()
*/
inline bool isExtensionSupported(const Extension& extension) const {
return isVersionSupported(extension._coreVersion) || (isVersionSupported(extension._requiredVersion) && extensionStatus[extension._index]);
@ -272,6 +281,65 @@ class MAGNUM_EXPORT Context {
Implementation::State* _state;
};
/** @hideinitializer
@brief Assert that given OpenGL version is supported
@param version Version
Useful for initial checks on availability of required features.
By default, if assertion fails, an message is printed to error output and the
application exits with value `-3`. If `CORRADE_NO_ASSERT` is defined, this
macro does nothing. Example usage:
@code
MAGNUM_ASSERT_VERSION_SUPPORTED(Version::GL330);
@endcode
@see @ref Magnum::Context::isVersionSupported() "Context::isVersionSupported()",
MAGNUM_ASSERT_EXTENSION_SUPPORTED(), CORRADE_ASSERT(),
CORRADE_INTERNAL_ASSERT()
*/
#ifdef CORRADE_NO_ASSERT
#define MAGNUM_ASSERT_VERSION_SUPPORTED(version) do {} while(0)
#else
#define MAGNUM_ASSERT_VERSION_SUPPORTED(version) \
do { \
if(!Context::current()->isVersionSupported(version)) { \
Corrade::Utility::Error() << "Magnum: required version" << version << "is not supported"; \
exit(-3); \
} \
} while(0)
#endif
/** @hideinitializer
@brief Assert that given OpenGL extension is supported
@param extension Extension name (from @ref Magnum::Extensions "Extensions"
namespace)
Useful for initial checks on availability of required features.
By default, if assertion fails, an message is printed to error output and the
application exits with value `-3`. If `CORRADE_NO_ASSERT` is defined, this
macro does nothing. Example usage:
@code
MAGNUM_ASSERT_EXTENSION_SUPPORTED(Extensions::GL::ARB::geometry_shader4);
@endcode
@see @ref Magnum::Context::isExtensionSupported() "Context::isExtensionSupported()",
MAGNUM_ASSERT_VERSION_SUPPORTED(), CORRADE_ASSERT(),
CORRADE_INTERNAL_ASSERT()
*/
#ifdef CORRADE_NO_ASSERT
#define MAGNUM_ASSERT_EXTENSION_SUPPORTED(extension) do {} while(0)
#else
#define MAGNUM_ASSERT_EXTENSION_SUPPORTED(extension) \
do { \
if(!Context::current()->isExtensionSupported<extension>()) { \
Corrade::Utility::Error() << "Magnum: required extension" << extension::string() << "is not supported"; \
exit(-3); \
} \
} while(0)
#endif
}
#endif

2
src/CubeMapTexture.h

@ -121,7 +121,7 @@ class CubeMapTexture: public AbstractTexture {
return this;
}
#ifndef MAGNUM_TARGET_GLES
inline CubeMapTexture* setBorderColor(const Color4<GLfloat>& color) {
inline CubeMapTexture* setBorderColor(const Color4<>& color) {
AbstractTexture::setBorderColor(color);
return this;
}

2
src/CubeMapTextureArray.h

@ -133,7 +133,7 @@ class CubeMapTextureArray: public AbstractTexture {
AbstractTexture::setMagnificationFilter(filter);
return this;
}
inline CubeMapTextureArray* setBorderColor(const Color4<GLfloat>& color) {
inline CubeMapTextureArray* setBorderColor(const Color4<>& color) {
AbstractTexture::setBorderColor(color);
return this;
}

48
src/DebugMarker.cpp

@ -0,0 +1,48 @@
/*
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.
*/
#include "DebugMarker.h"
#include <Utility/Debug.h>
#include "Context.h"
#include "Extensions.h"
namespace Magnum {
DebugMarker::MarkImplementation DebugMarker::markImplementation = &DebugMarker::markImplementationDefault;
void DebugMarker::initializeContextBasedFunctionality(Context* context) {
if(context->isExtensionSupported<Extensions::GL::GREMEDY::string_marker>()) {
Debug() << "DebugMarker: using" << Extensions::GL::GREMEDY::string_marker::string() << "features";
markImplementation = &DebugMarker::markImplementationDebugger;
}
}
void DebugMarker::markImplementationDefault(const std::string&) {}
void DebugMarker::markImplementationDebugger(const std::string& string) {
/** @todo Re-enable when extension wrangler is available for ES */
#ifndef MAGNUM_TARGET_GLES
glStringMarkerGREMEDY(string.length(), string.c_str());
#else
#if 0
glInsertEventMarkerEXT(string.length(), string.c_str());
#endif
#endif
}
}

60
src/DebugMarker.h

@ -0,0 +1,60 @@
#ifndef Magnum_DebugMarker_h
#define Magnum_DebugMarker_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 Class Magnum::DebugMarker
*/
#include <string>
#include "Magnum.h"
#include "magnumVisibility.h"
namespace Magnum {
/**
@brief Debug marker
Allows putting debug marker into OpenGL command stream for use with various
debuggers, such as ApiTrace or gDEBugger.
@requires_extension %Extension @extension{GREMEDY,string_marker}. If not
available, this class does nothing.
@requires_es_extension %Extension @es_extension{EXT,debug_marker}. If not
available, this class does nothing.
*/
class MAGNUM_EXPORT DebugMarker {
friend class Context;
public:
/** @brief Put string mark into OpenGL command stream */
inline static void mark(const std::string& string) {
markImplementation(string);
}
private:
static void MAGNUM_LOCAL initializeContextBasedFunctionality(Context* context);
typedef void(*MarkImplementation)(const std::string&);
static MAGNUM_LOCAL void markImplementationDefault(const std::string& string);
static MAGNUM_LOCAL void markImplementationDebugger(const std::string& string);
static MarkImplementation markImplementation;
};
}
#endif

7
src/Extensions.h

@ -33,6 +33,8 @@ and string(), but these structs are better suited for compile-time decisions
rather than Extension instances. See Context::isExtensionSupported() for
example usage.
@see MAGNUM_ASSERT_EXTENSION_SUPPORTED()
@todo Manual indices for extensions, this has gaps
@todo Unhide ES2_compatibility, ES3_compatibility on ES
@todo Add ES and GL 4.3 extensions
@ -48,6 +50,9 @@ namespace Extensions {
constexpr static Version coreVersion() { return Version::_coreVersion; } \
constexpr static const char* string() { return #prefix "_" #vendor "_" #extension; } \
};
/* IMPORTANT: don't forget to add new extensions also in Context.cpp */
namespace GL {
#line 1
namespace AMD {
@ -133,6 +138,8 @@ namespace GL {
_extension(GL,EXT,transform_feedback, GL210, GL300) // #352
_extension(GL,EXT,direct_state_access, GL210, None) // #353
_extension(GL,EXT,texture_snorm, GL300, GL310) // #365
} namespace GREMEDY {
_extension(GL,GREMEDY,string_marker, GL210, None) // #311
} namespace INTEL {
/* INTEL_map_texture not supported */ // #429
} namespace NV {

4
src/Framebuffer.h

@ -165,7 +165,7 @@ class MAGNUM_EXPORT Framebuffer {
* Initial value is `{0.0f, 0.0f, 0.0f, 1.0f}`.
* @see @fn_gl{ClearColor}
*/
inline static void setClearColor(const Color4<GLfloat>& color) {
inline static void setClearColor(const Color4<>& color) {
glClearColor(color.r(), color.g(), color.b(), color.a());
}
@ -631,7 +631,7 @@ class MAGNUM_EXPORT Framebuffer {
* @attention You have to enable blending with setFeature() first.
* @see @fn_gl{BlendColor}
*/
inline static void setBlendColor(const Color4<GLfloat>& color) {
inline static void setBlendColor(const Color4<>& color) {
glBlendColor(color.r(), color.g(), color.b(), color.a());
}

4
src/Magnum.h

@ -114,8 +114,8 @@ typedef BufferedImage<3> BufferedImage3D;
class BufferedTexture;
#endif
template<class> class Color3;
template<class> class Color4;
template<class = GLfloat> class Color3;
template<class = GLfloat> class Color4;
#ifndef CORRADE_GCC45_COMPATIBILITY
enum class Version: GLint;

2
src/Mesh.h

@ -83,7 +83,7 @@ component ordering (e.g. directly from @ref Trade::TgaImporter "TGA file"):
@code
class MyShader: public AbstractShaderProgram {
public:
typedef Attribute<1, Color4<GLfloat>> Color;
typedef Attribute<1, Color4<>> Color;
// ...
};

2
src/Physics/AbstractShape.h

@ -105,7 +105,7 @@ template<std::uint8_t dimensions> class PHYSICS_EXPORT AbstractShape {
* Applies transformation to user-defined shape properties and caches
* them for later usage in collision detection.
*/
virtual void applyTransformation(const typename DimensionTraits<dimensions, GLfloat>::MatrixType& transformation) = 0;
virtual void applyTransformation(const typename DimensionTraits<dimensions>::MatrixType& transformation) = 0;
/**
* @brief Detect collision with other shape

4
src/Physics/AxisAlignedBox.cpp

@ -20,8 +20,8 @@
namespace Magnum { namespace Physics {
template<std::uint8_t dimensions> void AxisAlignedBox<dimensions>::applyTransformation(const typename DimensionTraits<dimensions, GLfloat>::MatrixType& transformation) {
_transformedPosition = (transformation*typename DimensionTraits<dimensions, GLfloat>::PointType(_position)).vector();
template<std::uint8_t dimensions> void AxisAlignedBox<dimensions>::applyTransformation(const typename DimensionTraits<dimensions>::MatrixType& transformation) {
_transformedPosition = (transformation*typename DimensionTraits<dimensions>::PointType(_position)).vector();
_transformedSize = transformation.rotationScaling()*_size;
}

18
src/Physics/AxisAlignedBox.h

@ -34,44 +34,44 @@ namespace Magnum { namespace Physics {
template<std::uint8_t dimensions> class PHYSICS_EXPORT AxisAlignedBox: public AbstractShape<dimensions> {
public:
/** @brief Constructor */
inline AxisAlignedBox(const typename DimensionTraits<dimensions, GLfloat>::VectorType& position, const typename DimensionTraits<dimensions, GLfloat>::VectorType& size): _position(position), _transformedPosition(position), _size(size), _transformedSize(size) {}
inline AxisAlignedBox(const typename DimensionTraits<dimensions>::VectorType& position, const typename DimensionTraits<dimensions>::VectorType& size): _position(position), _transformedPosition(position), _size(size), _transformedSize(size) {}
inline typename AbstractShape<dimensions>::Type type() const override {
return AbstractShape<dimensions>::Type::AxisAlignedBox;
}
void applyTransformation(const typename DimensionTraits<dimensions, GLfloat>::MatrixType& transformation) override;
void applyTransformation(const typename DimensionTraits<dimensions>::MatrixType& transformation) override;
/** @brief Position */
inline typename DimensionTraits<dimensions, GLfloat>::VectorType position() const {
inline typename DimensionTraits<dimensions>::VectorType position() const {
return _position;
}
/** @brief Set position */
inline void setPosition(const typename DimensionTraits<dimensions, GLfloat>::VectorType& position) {
inline void setPosition(const typename DimensionTraits<dimensions>::VectorType& position) {
_position = position;
}
/** @brief Size */
inline typename DimensionTraits<dimensions, GLfloat>::VectorType size() const { return _size; }
inline typename DimensionTraits<dimensions>::VectorType size() const { return _size; }
/** @brief Set size */
inline void setSize(const typename DimensionTraits<dimensions, GLfloat>::VectorType& size) {
inline void setSize(const typename DimensionTraits<dimensions>::VectorType& size) {
_size = size;
}
/** @brief Transformed position */
inline typename DimensionTraits<dimensions, GLfloat>::VectorType transformedPosition() const {
inline typename DimensionTraits<dimensions>::VectorType transformedPosition() const {
return _transformedPosition;
}
/** @brief Transformed size */
inline typename DimensionTraits<dimensions, GLfloat>::VectorType transformedSize() const {
inline typename DimensionTraits<dimensions>::VectorType transformedSize() const {
return _transformedSize;
}
private:
Math::Vector<dimensions, GLfloat> _position, _transformedPosition,
typename DimensionTraits<dimensions>::VectorType _position, _transformedPosition,
_size, _transformedSize;
};

2
src/Physics/Box.cpp

@ -20,7 +20,7 @@
namespace Magnum { namespace Physics {
template<std::uint8_t dimensions> void Box<dimensions>::applyTransformation(const typename DimensionTraits<dimensions, GLfloat>::MatrixType& transformation) {
template<std::uint8_t dimensions> void Box<dimensions>::applyTransformation(const typename DimensionTraits<dimensions>::MatrixType& transformation) {
_transformedTransformation = (transformation*_transformation);
}

12
src/Physics/Box.h

@ -36,31 +36,31 @@ namespace Magnum { namespace Physics {
template<std::uint8_t dimensions> class PHYSICS_EXPORT Box: public AbstractShape<dimensions> {
public:
/** @brief Constructor */
inline Box(const typename DimensionTraits<dimensions, GLfloat>::MatrixType& transformation): _transformation(transformation), _transformedTransformation(transformation) {}
inline Box(const typename DimensionTraits<dimensions>::MatrixType& transformation): _transformation(transformation), _transformedTransformation(transformation) {}
inline typename AbstractShape<dimensions>::Type type() const override {
return AbstractShape<dimensions>::Type::Box;
}
void applyTransformation(const typename DimensionTraits<dimensions, GLfloat>::MatrixType& transformation) override;
void applyTransformation(const typename DimensionTraits<dimensions>::MatrixType& transformation) override;
/** @brief Transformation */
inline typename DimensionTraits<dimensions, GLfloat>::MatrixType transformation() const {
inline typename DimensionTraits<dimensions>::MatrixType transformation() const {
return _transformation;
}
/** @brief Set transformation */
inline void setTransformation(const typename DimensionTraits<dimensions, GLfloat>::MatrixType& transformation) {
inline void setTransformation(const typename DimensionTraits<dimensions>::MatrixType& transformation) {
_transformation = transformation;
}
/** @brief Transformed transformation */
inline typename DimensionTraits<dimensions, GLfloat>::MatrixType transformedTransformation() const {
inline typename DimensionTraits<dimensions>::MatrixType transformedTransformation() const {
return _transformedTransformation;
}
private:
Math::Matrix<dimensions+1, GLfloat> _transformation,
typename DimensionTraits<dimensions>::MatrixType _transformation,
_transformedTransformation;
};

8
src/Physics/Capsule.cpp

@ -27,10 +27,10 @@ using namespace Magnum::Math::Geometry;
namespace Magnum { namespace Physics {
template<std::uint8_t dimensions> void Capsule<dimensions>::applyTransformation(const typename DimensionTraits<dimensions, GLfloat>::MatrixType& transformation) {
_transformedA = (transformation*typename DimensionTraits<dimensions, GLfloat>::PointType(_a)).vector();
_transformedB = (transformation*typename DimensionTraits<dimensions, GLfloat>::PointType(_b)).vector();
float scaling = (transformation.rotationScaling()*typename DimensionTraits<dimensions, GLfloat>::VectorType(1/Math::Constants<float>::sqrt3())).length();
template<std::uint8_t dimensions> void Capsule<dimensions>::applyTransformation(const typename DimensionTraits<dimensions>::MatrixType& transformation) {
_transformedA = (transformation*typename DimensionTraits<dimensions>::PointType(_a)).vector();
_transformedB = (transformation*typename DimensionTraits<dimensions>::PointType(_b)).vector();
float scaling = (transformation.rotationScaling()*typename DimensionTraits<dimensions>::VectorType(1/Math::Constants<float>::sqrt3())).length();
_transformedRadius = scaling*_radius;
}

18
src/Physics/Capsule.h

@ -37,33 +37,33 @@ applying transformation, the scale factor is averaged from all axes.
template<std::uint8_t dimensions> class PHYSICS_EXPORT Capsule: public AbstractShape<dimensions> {
public:
/** @brief Constructor */
inline Capsule(const typename DimensionTraits<dimensions, GLfloat>::VectorType& a, const typename DimensionTraits<dimensions, GLfloat>::VectorType& b, float radius): _a(a), _transformedA(a), _b(b), _transformedB(b), _radius(radius), _transformedRadius(radius) {}
inline Capsule(const typename DimensionTraits<dimensions>::VectorType& a, const typename DimensionTraits<dimensions>::VectorType& b, float radius): _a(a), _transformedA(a), _b(b), _transformedB(b), _radius(radius), _transformedRadius(radius) {}
inline typename AbstractShape<dimensions>::Type type() const override {
return AbstractShape<dimensions>::Type::Capsule;
}
void applyTransformation(const typename DimensionTraits<dimensions, GLfloat>::MatrixType& transformation) override;
void applyTransformation(const typename DimensionTraits<dimensions>::MatrixType& transformation) override;
bool collides(const AbstractShape<dimensions>* other) const override;
/** @brief Start point */
inline typename DimensionTraits<dimensions, GLfloat>::VectorType a() const {
inline typename DimensionTraits<dimensions>::VectorType a() const {
return _a;
}
/** @brief End point */
inline typename DimensionTraits<dimensions, GLfloat>::VectorType b() const {
inline typename DimensionTraits<dimensions>::VectorType b() const {
return _a;
}
/** @brief Set start point */
inline void setA(const typename DimensionTraits<dimensions, GLfloat>::VectorType& a) {
inline void setA(const typename DimensionTraits<dimensions>::VectorType& a) {
_a = a;
}
/** @brief Set end point */
inline void setB(const typename DimensionTraits<dimensions, GLfloat>::VectorType& b) {
inline void setB(const typename DimensionTraits<dimensions>::VectorType& b) {
_b = b;
}
@ -74,12 +74,12 @@ template<std::uint8_t dimensions> class PHYSICS_EXPORT Capsule: public AbstractS
inline void setRadius(float radius) { _radius = radius; }
/** @brief Transformed first point */
inline typename DimensionTraits<dimensions, GLfloat>::VectorType transformedA() const {
inline typename DimensionTraits<dimensions>::VectorType transformedA() const {
return _transformedA;
}
/** @brief Transformed second point */
inline typename DimensionTraits<dimensions, GLfloat>::VectorType transformedB() const {
inline typename DimensionTraits<dimensions>::VectorType transformedB() const {
return _transformedB;
}
@ -95,7 +95,7 @@ template<std::uint8_t dimensions> class PHYSICS_EXPORT Capsule: public AbstractS
bool operator%(const Sphere<dimensions>& other) const;
private:
Math::Vector<dimensions, GLfloat> _a, _transformedA,
typename DimensionTraits<dimensions>::VectorType _a, _transformedA,
_b, _transformedB;
float _radius, _transformedRadius;
};

4
src/Physics/DebugDrawResourceManager.h

@ -37,7 +37,7 @@ namespace Magnum {
#ifndef DOXYGEN_GENERATING_OUTPUT
namespace Physics { namespace Implementation {
struct Options {
Color3<GLfloat> color;
Color3<> color;
};
template<std::uint8_t> class DebugRenderer;
}}
@ -86,7 +86,7 @@ class PHYSICS_EXPORT DebugDrawResourceManager: public ResourceManager<AbstractSh
#ifdef DOXYGEN_GENERATING_OUTPUT
/** @brief %Options */
struct Options {
Color3<GLfloat> color; /**< @brief Color */
Color3<> color; /**< @brief Color */
};
#else
typedef Implementation::Options Options;

2
src/Physics/Implementation/AbstractDebugRenderer.h

@ -38,7 +38,7 @@ template<std::uint8_t dimensions> class AbstractDebugRenderer {
virtual ~AbstractDebugRenderer();
virtual void draw(Resource<Options>& options, const typename DimensionTraits<dimensions>::MatrixType& transformationMatrix, SceneGraph::AbstractCamera<dimensions, GLfloat>* camera) = 0;
virtual void draw(Resource<Options>& options, const typename DimensionTraits<dimensions>::MatrixType& transformationMatrix, SceneGraph::AbstractCamera<dimensions>* camera) = 0;
protected:
Resource<AbstractShaderProgram, Shaders::FlatShader<dimensions>> shader;

2
src/Physics/Implementation/AbstractShapeRenderer.h

@ -38,7 +38,7 @@ template<std::uint8_t dimensions> class AbstractShapeRenderer {
virtual ~AbstractShapeRenderer();
virtual void draw(Resource<Options>& options, const typename DimensionTraits<dimensions>::MatrixType& transformationMatrix, SceneGraph::AbstractCamera<dimensions, GLfloat>* camera) = 0;
virtual void draw(Resource<Options>& options, const typename DimensionTraits<dimensions>::MatrixType& transformationMatrix, SceneGraph::AbstractCamera<dimensions>* camera) = 0;
protected:
Resource<AbstractShaderProgram, Shaders::FlatShader<dimensions>> shader;

2
src/Physics/Implementation/AxisAlignedBoxRenderer.cpp

@ -22,7 +22,7 @@
namespace Magnum { namespace Physics { namespace Implementation {
template<std::uint8_t dimensions> void AxisAlignedBoxRenderer<dimensions>::draw(Resource<Options>& options, const typename DimensionTraits<dimensions, GLfloat>::MatrixType&, typename SceneGraph::AbstractCamera<dimensions>* camera) {
template<std::uint8_t dimensions> void AxisAlignedBoxRenderer<dimensions>::draw(Resource<Options>& options, const typename DimensionTraits<dimensions>::MatrixType&, typename SceneGraph::AbstractCamera<dimensions>* camera) {
typename DimensionTraits<dimensions>::MatrixType transformation =
DimensionTraits<dimensions>::MatrixType::translation(axisAlignedBox.transformedPosition())*
DimensionTraits<dimensions>::MatrixType::scaling(axisAlignedBox.transformedSize());

2
src/Physics/Implementation/BoxRenderer.cpp

@ -22,7 +22,7 @@
namespace Magnum { namespace Physics { namespace Implementation {
template<std::uint8_t dimensions> void BoxRenderer<dimensions>::draw(Resource<Options>& options, const typename DimensionTraits<dimensions, GLfloat>::MatrixType&, typename SceneGraph::AbstractCamera<dimensions>* camera) {
template<std::uint8_t dimensions> void BoxRenderer<dimensions>::draw(Resource<Options>& options, const typename DimensionTraits<dimensions>::MatrixType&, typename SceneGraph::AbstractCamera<dimensions>* camera) {
this->shader->setTransformationProjection(camera->projectionMatrix()*camera->cameraMatrix()*box.transformedTransformation())
->setColor(options->color)
->use();

2
src/Physics/Implementation/BoxRenderer.h

@ -27,7 +27,7 @@ template<std::uint8_t dimensions> class BoxRenderer: public AbstractBoxRenderer<
public:
inline BoxRenderer(Box<dimensions>& box): box(box) {}
void draw(Resource<Options>& options, const typename DimensionTraits<dimensions>::MatrixType& transformation, typename SceneGraph::AbstractCamera<dimensions, GLfloat>* camera) override;
void draw(Resource<Options>& options, const typename DimensionTraits<dimensions>::MatrixType& transformation, typename SceneGraph::AbstractCamera<dimensions>* camera) override;
private:
Box<dimensions>& box;

2
src/Physics/Implementation/DebugRenderer.h

@ -45,7 +45,7 @@ template<std::uint8_t dimensions> class DebugRenderer: public SceneGraph::Drawab
renderers.push_back(renderer);
}
inline void draw(const typename DimensionTraits<dimensions>::MatrixType& transformationMatrix, SceneGraph::AbstractCamera<dimensions, GLfloat>* camera) override {
inline void draw(const typename DimensionTraits<dimensions>::MatrixType& transformationMatrix, SceneGraph::AbstractCamera<dimensions>* camera) override {
for(auto it = renderers.begin(); it != renderers.end(); ++it)
(*it)->draw(options, transformationMatrix, camera);
}

6
src/Physics/Line.cpp

@ -20,9 +20,9 @@
namespace Magnum { namespace Physics {
template<std::uint8_t dimensions> void Line<dimensions>::applyTransformation(const typename DimensionTraits<dimensions, GLfloat>::MatrixType& transformation) {
_transformedA = (transformation*typename DimensionTraits<dimensions, GLfloat>::PointType(_a)).vector();
_transformedB = (transformation*typename DimensionTraits<dimensions, GLfloat>::PointType(_b)).vector();
template<std::uint8_t dimensions> void Line<dimensions>::applyTransformation(const typename DimensionTraits<dimensions>::MatrixType& transformation) {
_transformedA = (transformation*typename DimensionTraits<dimensions>::PointType(_a)).vector();
_transformedB = (transformation*typename DimensionTraits<dimensions>::PointType(_b)).vector();
}
/* Explicitly instantiate the templates */

18
src/Physics/Line.h

@ -35,46 +35,46 @@ namespace Magnum { namespace Physics {
template<std::uint8_t dimensions> class PHYSICS_EXPORT Line: public AbstractShape<dimensions> {
public:
/** @brief Constructor */
inline Line(const typename DimensionTraits<dimensions, GLfloat>::VectorType& a, const typename DimensionTraits<dimensions, GLfloat>::VectorType& b): _a(a), _transformedA(a), _b(b), _transformedB(b) {}
inline Line(const typename DimensionTraits<dimensions>::VectorType& a, const typename DimensionTraits<dimensions>::VectorType& b): _a(a), _transformedA(a), _b(b), _transformedB(b) {}
inline typename AbstractShape<dimensions>::Type type() const override {
return AbstractShape<dimensions>::Type::Line;
}
void applyTransformation(const typename DimensionTraits<dimensions, GLfloat>::MatrixType& transformation) override;
void applyTransformation(const typename DimensionTraits<dimensions>::MatrixType& transformation) override;
/** @brief First point */
inline typename DimensionTraits<dimensions, GLfloat>::VectorType a() const {
inline typename DimensionTraits<dimensions>::VectorType a() const {
return _a;
}
/** @brief Second point */
inline typename DimensionTraits<dimensions, GLfloat>::VectorType b() const {
inline typename DimensionTraits<dimensions>::VectorType b() const {
return _a;
}
/** @brief Set first point */
inline void setA(const typename DimensionTraits<dimensions, GLfloat>::VectorType& a) {
inline void setA(const typename DimensionTraits<dimensions>::VectorType& a) {
_a = a;
}
/** @brief Set second point */
inline void setB(const typename DimensionTraits<dimensions, GLfloat>::VectorType& b) {
inline void setB(const typename DimensionTraits<dimensions>::VectorType& b) {
_b = b;
}
/** @brief Transformed first point */
inline typename DimensionTraits<dimensions, GLfloat>::VectorType transformedA() const {
inline typename DimensionTraits<dimensions>::VectorType transformedA() const {
return _transformedA;
}
/** @brief Transformed second point */
inline typename DimensionTraits<dimensions, GLfloat>::VectorType transformedB() const {
inline typename DimensionTraits<dimensions>::VectorType transformedB() const {
return _transformedB;
}
private:
Math::Vector<dimensions, GLfloat> _a, _transformedA,
typename DimensionTraits<dimensions>::VectorType _a, _transformedA,
_b, _transformedB;
};

2
src/Physics/LineSegment.h

@ -31,7 +31,7 @@ namespace Magnum { namespace Physics {
template<std::uint8_t dimensions> class LineSegment: public Line<dimensions> {
public:
/** @brief Constructor */
inline LineSegment(const typename DimensionTraits<dimensions, GLfloat>::VectorType& a, const typename DimensionTraits<dimensions, GLfloat>::VectorType& b): Line<dimensions>(a, b) {}
inline LineSegment(const typename DimensionTraits<dimensions>::VectorType& a, const typename DimensionTraits<dimensions>::VectorType& b): Line<dimensions>(a, b) {}
inline typename AbstractShape<dimensions>::Type type() const override {
return AbstractShape<dimensions>::Type::LineSegment;

2
src/Physics/ObjectShape.cpp

@ -36,7 +36,7 @@ template<uint8_t dimensions> void ObjectShape<dimensions>::markDirty() {
group()->setDirty();
}
template<uint8_t dimensions> void ObjectShape<dimensions>::clean(const typename DimensionTraits<dimensions, GLfloat>::MatrixType& absoluteTransformation) {
template<uint8_t dimensions> void ObjectShape<dimensions>::clean(const typename DimensionTraits<dimensions>::MatrixType& absoluteTransformation) {
if(_shape) _shape->applyTransformation(absoluteTransformation);
}

2
src/Physics/Plane.h

@ -39,7 +39,7 @@ class PHYSICS_EXPORT Plane: public AbstractShape<3> {
void applyTransformation(const Matrix4& transformation) override;
bool collides(const AbstractShape<3>* other) const override;
#else
void applyTransformation(const typename DimensionTraits<dimensions, GLfloat>::MatrixType& transformation) override;
void applyTransformation(const typename DimensionTraits<dimensions>::MatrixType& transformation) override;
bool collides(const AbstractShape* other) const override;
#endif

4
src/Physics/Point.cpp

@ -20,8 +20,8 @@
namespace Magnum { namespace Physics {
template<std::uint8_t dimensions> void Point<dimensions>::applyTransformation(const typename DimensionTraits<dimensions, GLfloat>::MatrixType& transformation) {
_transformedPosition = (transformation*typename DimensionTraits<dimensions, GLfloat>::PointType(_position)).vector();
template<std::uint8_t dimensions> void Point<dimensions>::applyTransformation(const typename DimensionTraits<dimensions>::MatrixType& transformation) {
_transformedPosition = (transformation*typename DimensionTraits<dimensions>::PointType(_position)).vector();
}
template class Point<2>;

12
src/Physics/Point.h

@ -34,31 +34,31 @@ namespace Magnum { namespace Physics {
template<std::uint8_t dimensions> class PHYSICS_EXPORT Point: public AbstractShape<dimensions> {
public:
/** @brief Constructor */
inline Point(const typename DimensionTraits<dimensions, GLfloat>::VectorType& position): _position(position), _transformedPosition(position) {}
inline Point(const typename DimensionTraits<dimensions>::VectorType& position): _position(position), _transformedPosition(position) {}
inline typename AbstractShape<dimensions>::Type type() const override {
return AbstractShape<dimensions>::Type::Point;
}
void applyTransformation(const typename DimensionTraits<dimensions, GLfloat>::MatrixType& transformation) override;
void applyTransformation(const typename DimensionTraits<dimensions>::MatrixType& transformation) override;
/** @brief Position */
inline typename DimensionTraits<dimensions, GLfloat>::VectorType position() const {
inline typename DimensionTraits<dimensions>::VectorType position() const {
return _position;
}
/** @brief Set position */
inline void setPosition(const typename DimensionTraits<dimensions, GLfloat>::VectorType& position) {
inline void setPosition(const typename DimensionTraits<dimensions>::VectorType& position) {
_position = position;
}
/** @brief Transformed position */
inline typename DimensionTraits<dimensions, GLfloat>::VectorType transformedPosition() const {
inline typename DimensionTraits<dimensions>::VectorType transformedPosition() const {
return _transformedPosition;
}
private:
Math::Vector<dimensions, GLfloat> _position, _transformedPosition;
typename DimensionTraits<dimensions>::VectorType _position, _transformedPosition;
};
/** @brief Two-dimensional point */

2
src/Physics/ShapeGroup.cpp

@ -43,7 +43,7 @@ template<std::uint8_t dimensions> ShapeGroup<dimensions>& ShapeGroup<dimensions>
return *this;
}
template<std::uint8_t dimensions> void ShapeGroup<dimensions>::applyTransformation(const typename DimensionTraits<dimensions, GLfloat>::MatrixType& transformation) {
template<std::uint8_t dimensions> void ShapeGroup<dimensions>::applyTransformation(const typename DimensionTraits<dimensions>::MatrixType& transformation) {
if(a) a->applyTransformation(transformation);
if(b) b->applyTransformation(transformation);
}

2
src/Physics/ShapeGroup.h

@ -105,7 +105,7 @@ template<std::uint8_t dimensions> class PHYSICS_EXPORT ShapeGroup: public Abstra
return AbstractShape<dimensions>::Type::ShapeGroup;
}
void applyTransformation(const typename DimensionTraits<dimensions, GLfloat>::MatrixType& transformation) override;
void applyTransformation(const typename DimensionTraits<dimensions>::MatrixType& transformation) override;
bool collides(const AbstractShape<dimensions>* other) const override;

6
src/Physics/Sphere.cpp

@ -28,7 +28,7 @@ using namespace Magnum::Math::Geometry;
namespace Magnum { namespace Physics {
namespace {
template<std::uint8_t dimensions> static typename DimensionTraits<dimensions, GLfloat>::VectorType unitVector();
template<std::uint8_t dimensions> static typename DimensionTraits<dimensions>::VectorType unitVector();
template<> inline Vector2 unitVector<2>() {
return Vector2(1/Math::Constants<float>::sqrt2());
@ -39,8 +39,8 @@ namespace {
}
}
template<std::uint8_t dimensions> void Sphere<dimensions>::applyTransformation(const typename DimensionTraits<dimensions, GLfloat>::MatrixType& transformation) {
_transformedPosition = (transformation*typename DimensionTraits<dimensions, GLfloat>::PointType(_position)).vector();
template<std::uint8_t dimensions> void Sphere<dimensions>::applyTransformation(const typename DimensionTraits<dimensions>::MatrixType& transformation) {
_transformedPosition = (transformation*typename DimensionTraits<dimensions>::PointType(_position)).vector();
float scaling = (transformation.rotationScaling()*unitVector<dimensions>()).length();
_transformedRadius = scaling*_radius;
}

12
src/Physics/Sphere.h

@ -37,23 +37,23 @@ applying transformation, the scale factor is averaged from all axes.
template<std::uint8_t dimensions> class PHYSICS_EXPORT Sphere: public AbstractShape<dimensions> {
public:
/** @brief Constructor */
inline Sphere(const typename DimensionTraits<dimensions, GLfloat>::VectorType& position, float radius): _position(position), _transformedPosition(position), _radius(radius), _transformedRadius(radius) {}
inline Sphere(const typename DimensionTraits<dimensions>::VectorType& position, float radius): _position(position), _transformedPosition(position), _radius(radius), _transformedRadius(radius) {}
inline typename AbstractShape<dimensions>::Type type() const override {
return AbstractShape<dimensions>::Type::Sphere;
}
void applyTransformation(const typename DimensionTraits<dimensions, GLfloat>::MatrixType& transformation) override;
void applyTransformation(const typename DimensionTraits<dimensions>::MatrixType& transformation) override;
bool collides(const AbstractShape<dimensions>* other) const override;
/** @brief Position */
inline typename DimensionTraits<dimensions, GLfloat>::VectorType position() const {
inline typename DimensionTraits<dimensions>::VectorType position() const {
return _position;
}
/** @brief Set position */
inline void setPosition(const typename DimensionTraits<dimensions, GLfloat>::VectorType& position) {
inline void setPosition(const typename DimensionTraits<dimensions>::VectorType& position) {
_position = position;
}
@ -64,7 +64,7 @@ template<std::uint8_t dimensions> class PHYSICS_EXPORT Sphere: public AbstractSh
inline void setRadius(float radius) { _radius = radius; }
/** @brief Transformed position */
inline typename DimensionTraits<dimensions, GLfloat>::VectorType transformedPosition() const {
inline typename DimensionTraits<dimensions>::VectorType transformedPosition() const {
return _transformedPosition;
}
@ -86,7 +86,7 @@ template<std::uint8_t dimensions> class PHYSICS_EXPORT Sphere: public AbstractSh
bool operator%(const Sphere<dimensions>& other) const;
private:
Math::Vector<dimensions, GLfloat> _position,
typename DimensionTraits<dimensions>::VectorType _position,
_transformedPosition;
float _radius, _transformedRadius;
};

41
src/Platform/Sdl2Application.cpp

@ -20,16 +20,30 @@
namespace Magnum { namespace Platform {
namespace {
/*
* Fix up the modifiers -- we want >= operator to work properly on Shift,
* Ctrl, Alt, but SDL generates different event for left / right keys, thus
* (modifiers >= Shift) would pass only if both left and right were pressed,
* which is usually not what the developers wants.
*/
Sdl2Application::InputEvent::Modifiers fixedModifiers(Uint16 mod) {
Sdl2Application::InputEvent::Modifiers modifiers(static_cast<Sdl2Application::InputEvent::Modifier>(mod));
if(modifiers & Sdl2Application::InputEvent::Modifier::Shift) modifiers |= Sdl2Application::InputEvent::Modifier::Shift;
if(modifiers & Sdl2Application::InputEvent::Modifier::Ctrl) modifiers |= Sdl2Application::InputEvent::Modifier::Ctrl;
if(modifiers & Sdl2Application::InputEvent::Modifier::Alt) modifiers |= Sdl2Application::InputEvent::Modifier::Alt;
return modifiers;
}
}
Sdl2Application::Sdl2Application(int, char**, const std::string& name, const Math::Vector2<GLsizei>& size): _redraw(true) {
if(SDL_Init(SDL_INIT_VIDEO) < 0) {
Error() << "Cannot initialize SDL.";
exit(1);
}
/* Request OpenGL 3.2 */
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 3);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 2);
/* Enable double buffering and 24bt depth buffer */
SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 24);
@ -85,20 +99,7 @@ int Sdl2Application::exec() {
case SDL_KEYDOWN:
case SDL_KEYUP: {
/*
* Fix up the modifiers -- we want >= operator to work
* properly on Shift, Ctrl, Alt, but SDL generates
* different event for left / right keys, thus
* (modifiers >= Shift) would pass only if both left and
* right were pressed, which is usually not what the
* developers wants.
*/
InputEvent::Modifiers modifiers(static_cast<InputEvent::Modifier>(event.key.keysym.mod));
if(modifiers & InputEvent::Modifier::Shift) modifiers |= InputEvent::Modifier::Shift;
if(modifiers & InputEvent::Modifier::Ctrl) modifiers |= InputEvent::Modifier::Ctrl;
if(modifiers & InputEvent::Modifier::Alt) modifiers |= InputEvent::Modifier::Alt;
KeyEvent e(static_cast<KeyEvent::Key>(event.key.keysym.sym), modifiers);
KeyEvent e(static_cast<KeyEvent::Key>(event.key.keysym.sym), fixedModifiers(event.key.keysym.mod));
event.type == SDL_KEYDOWN ? keyPressEvent(e) : keyReleaseEvent(e);
break;
}
@ -143,13 +144,13 @@ void Sdl2Application::setMouseLocked(bool enabled) {
Sdl2Application::InputEvent::Modifiers Sdl2Application::MouseEvent::modifiers() {
if(modifiersLoaded) return _modifiers;
modifiersLoaded = true;
return _modifiers = static_cast<Modifier>(SDL_GetModState());
return _modifiers = fixedModifiers(SDL_GetModState());
}
Sdl2Application::InputEvent::Modifiers Sdl2Application::MouseMoveEvent::modifiers() {
if(modifiersLoaded) return _modifiers;
modifiersLoaded = true;
return _modifiers = static_cast<Modifier>(SDL_GetModState());
return _modifiers = fixedModifiers(SDL_GetModState());
}
}}

8
src/Platform/Sdl2Application.h

@ -37,8 +37,9 @@ namespace Platform {
/** @nosubgrouping
@brief SDL2 application
Application using [Simple DirectMedia Layer](www.libsdl.org/). Supports
keyboard and mouse handling.
Application using [Simple DirectMedia Layer](www.libsdl.org/). Centered
non-resizable window with double-buffered OpenGL context and 24bit depth
buffer. Supports keyboard and mouse handling.
@section Sdl2Application-usage Usage
@ -65,9 +66,6 @@ class Sdl2Application {
* @param argv Arguments of `main()` function
* @param title Window title
* @param size Window size
*
* Creates centered non-resizable window with double-buffered
* OpenGL 3.2 context with 24bit depth buffer.
*/
Sdl2Application(int argc, char** argv, const std::string& title = "Magnum SDL2 application", const Math::Vector2<GLsizei>& size = Math::Vector2<GLsizei>(800, 600));

95
src/Primitives/Cube.cpp

@ -21,30 +21,91 @@ using namespace std;
namespace Magnum { namespace Primitives {
Cube::Cube(): MeshData3D("", Mesh::Primitive::Triangles, new vector<uint32_t>{
0, 2, 1,
2, 3, 1,
1, 3, 5,
3, 7, 5,
5, 7, 4,
7, 6, 4,
4, 6, 0,
6, 2, 0,
2, 7, 3,
2, 6, 7,
4, 1, 5,
4, 0, 1
}, {new vector<Point3D>}, {new vector<Vector3>{
Cube::Cube(): MeshData3D("", Mesh::Primitive::Triangles, nullptr, {new vector<Point3D>{
{-1.0f, -1.0f, 1.0f},
{ 1.0f, -1.0f, 1.0f},
{ 1.0f, 1.0f, 1.0f}, /* +Z */
{-1.0f, -1.0f, 1.0f},
{ 1.0f, 1.0f, 1.0f},
{-1.0f, 1.0f, 1.0f},
{ 1.0f, -1.0f, 1.0f},
{ 1.0f, -1.0f, -1.0f},
{ 1.0f, 1.0f, -1.0f}, /* +X */
{ 1.0f, -1.0f, 1.0f},
{ 1.0f, 1.0f, -1.0f},
{ 1.0f, 1.0f, 1.0f},
{-1.0f, 1.0f, 1.0f},
{ 1.0f, 1.0f, 1.0f},
{ 1.0f, 1.0f, -1.0f}, /* +Y */
{-1.0f, 1.0f, 1.0f},
{ 1.0f, 1.0f, -1.0f},
{-1.0f, 1.0f, -1.0f},
{ 1.0f, -1.0f, -1.0f},
{-1.0f, -1.0f, -1.0f},
{-1.0f, 1.0f, -1.0f}, /* -Z */
{ 1.0f, -1.0f, -1.0f},
{-1.0f, 1.0f, -1.0f},
{ 1.0f, 1.0f, -1.0f},
{-1.0f, -1.0f, 1.0f},
{-1.0f, -1.0f, -1.0f},
{ 1.0f, -1.0f, -1.0f},
{ 1.0f, -1.0f, 1.0f}, /* -Y */
{-1.0f, -1.0f, -1.0f},
{ 1.0f, -1.0f, 1.0f},
{-1.0f, -1.0f, 1.0f},
{-1.0f, -1.0f, -1.0f},
{-1.0f, -1.0f, 1.0f},
{-1.0f, 1.0f, 1.0f}, /* -X */
{-1.0f, -1.0f, -1.0f},
{-1.0f, 1.0f, 1.0f},
{ 1.0f, 1.0f, 1.0f}
{-1.0f, 1.0f, -1.0f}
}}, {new vector<Vector3>{
{ 0.0f, 0.0f, 1.0f},
{ 0.0f, 0.0f, 1.0f},
{ 0.0f, 0.0f, 1.0f}, /* +Z */
{ 0.0f, 0.0f, 1.0f},
{ 0.0f, 0.0f, 1.0f},
{ 0.0f, 0.0f, 1.0f},
{ 1.0f, 0.0f, 0.0f},
{ 1.0f, 0.0f, 0.0f},
{ 1.0f, 0.0f, 0.0f}, /* +X */
{ 1.0f, 0.0f, 0.0f},
{ 1.0f, 0.0f, 0.0f},
{ 1.0f, 0.0f, 0.0f},
{ 0.0f, 1.0f, 0.0f},
{ 0.0f, 1.0f, 0.0f},
{ 0.0f, 1.0f, 0.0f}, /* +Y */
{ 0.0f, 1.0f, 0.0f},
{ 0.0f, 1.0f, 0.0f},
{ 0.0f, 1.0f, 0.0f},
{ 0.0f, 0.0f, -1.0f},
{ 0.0f, 0.0f, -1.0f},
{ 0.0f, 0.0f, -1.0f}, /* -Z */
{ 0.0f, 0.0f, -1.0f},
{ 0.0f, 0.0f, -1.0f},
{ 0.0f, 0.0f, -1.0f},
{ 0.0f, -1.0f, 0.0f},
{ 0.0f, -1.0f, 0.0f},
{ 0.0f, -1.0f, 0.0f}, /* -Y */
{ 0.0f, -1.0f, 0.0f},
{ 0.0f, -1.0f, 0.0f},
{ 0.0f, -1.0f, 0.0f},
{-1.0f, 0.0f, 0.0f},
{-1.0f, 0.0f, 0.0f},
{-1.0f, 0.0f, 0.0f}, /* -X */
{-1.0f, 0.0f, 0.0f},
{-1.0f, 0.0f, 0.0f},
{-1.0f, 0.0f, 0.0f}
}}, {}) {
positions(0)->assign(normals(0)->begin(), normals(0)->end());
}
}}

3
src/Primitives/Cube.h

@ -26,8 +26,7 @@ namespace Magnum { namespace Primitives {
/**
@brief 3D cube primitive
Indexed triangle mesh with smooth normals.
@todo Does anyone EVER want smooth normals on a cube?!
2x2x2 cube. Non-indexed triangle mesh with flat normals.
*/
class Cube: public Trade::MeshData3D {
public:

16
src/SceneGraph/Test/ObjectTest.cpp

@ -27,12 +27,12 @@ CORRADE_TEST_MAIN(Magnum::SceneGraph::Test::ObjectTest)
namespace Magnum { namespace SceneGraph { namespace Test {
typedef SceneGraph::Object<SceneGraph::MatrixTransformation3D<GLfloat>> Object3D;
typedef SceneGraph::Scene<SceneGraph::MatrixTransformation3D<GLfloat>> Scene3D;
typedef SceneGraph::Object<SceneGraph::MatrixTransformation3D<>> Object3D;
typedef SceneGraph::Scene<SceneGraph::MatrixTransformation3D<>> Scene3D;
class CachingObject: public Object3D, AbstractFeature<3, GLfloat> {
class CachingObject: public Object3D, AbstractFeature<3> {
public:
inline CachingObject(Object3D* parent = nullptr): Object3D(parent), AbstractFeature<3, GLfloat>(this) {
inline CachingObject(Object3D* parent = nullptr): Object3D(parent), AbstractFeature<3>(this) {
setCachedTransformations(CachedTransformation::Absolute);
}
@ -189,9 +189,9 @@ void ObjectTest::transformations() {
void ObjectTest::setClean() {
Scene3D scene;
class CachingFeature: public AbstractFeature<3, GLfloat> {
class CachingFeature: public AbstractFeature<3> {
public:
CachingFeature(AbstractObject<3, GLfloat>* object): AbstractFeature<3, GLfloat>(object) {
CachingFeature(AbstractObject<3>* object): AbstractFeature<3>(object) {
setCachedTransformations(CachedTransformation::Absolute);
}
@ -202,9 +202,9 @@ void ObjectTest::setClean() {
}
};
class CachingInvertedFeature: public AbstractFeature<3, GLfloat> {
class CachingInvertedFeature: public AbstractFeature<3> {
public:
CachingInvertedFeature(AbstractObject<3, GLfloat>* object): AbstractFeature<3, GLfloat>(object) {
CachingInvertedFeature(AbstractObject<3>* object): AbstractFeature<3>(object) {
setCachedTransformations(CachedTransformation::InvertedAbsolute);
}

6
src/Shaders/FlatShader.h

@ -38,7 +38,7 @@ Draws whole mesh with one color.
template<std::uint8_t dimensions> class SHADERS_EXPORT FlatShader: public AbstractShaderProgram {
public:
/** @brief Vertex position */
typedef Attribute<0, typename DimensionTraits<dimensions, GLfloat>::PointType> Position;
typedef Attribute<0, typename DimensionTraits<dimensions>::PointType> Position;
FlatShader();
@ -46,7 +46,7 @@ template<std::uint8_t dimensions> class SHADERS_EXPORT FlatShader: public Abstra
* @brief Set transformation and projection matrix
* @return Pointer to self (for method chaining)
*/
FlatShader<dimensions>* setTransformationProjection(const typename DimensionTraits<dimensions, GLfloat>::MatrixType& matrix) {
FlatShader<dimensions>* setTransformationProjection(const typename DimensionTraits<dimensions>::MatrixType& matrix) {
setUniform(transformationProjectionUniform, matrix);
return this;
}
@ -55,7 +55,7 @@ template<std::uint8_t dimensions> class SHADERS_EXPORT FlatShader: public Abstra
* @brief Set color
* @return Pointer to self (for method chaining)
*/
FlatShader<dimensions>* setColor(const Color3<GLfloat>& color) {
FlatShader<dimensions>* setColor(const Color3<>& color) {
setUniform(colorUniform, color);
return this;
}

8
src/Shaders/PhongShader.h

@ -46,7 +46,7 @@ class SHADERS_EXPORT PhongShader: public AbstractShaderProgram {
*
* If not set, default value is `(0.0f, 0.0f, 0.0f)`.
*/
inline PhongShader* setAmbientColor(const Color3<GLfloat>& color) {
inline PhongShader* setAmbientColor(const Color3<>& color) {
setUniform(ambientColorUniform, color);
return this;
}
@ -55,7 +55,7 @@ class SHADERS_EXPORT PhongShader: public AbstractShaderProgram {
* @brief Set diffuse color
* @return Pointer to self (for method chaining)
*/
inline PhongShader* setDiffuseColor(const Color3<GLfloat>& color) {
inline PhongShader* setDiffuseColor(const Color3<>& color) {
setUniform(diffuseColorUniform, color);
return this;
}
@ -66,7 +66,7 @@ class SHADERS_EXPORT PhongShader: public AbstractShaderProgram {
*
* If not set, default value is `(1.0f, 1.0f, 1.0f)`.
*/
inline PhongShader* setSpecularColor(const Color3<GLfloat>& color) {
inline PhongShader* setSpecularColor(const Color3<>& color) {
setUniform(specularColorUniform, color);
return this;
}
@ -117,7 +117,7 @@ class SHADERS_EXPORT PhongShader: public AbstractShaderProgram {
*
* If not set, default value is `(1.0f, 1.0f, 1.0f)`.
*/
inline PhongShader* setLightColor(const Color3<GLfloat>& color) {
inline PhongShader* setLightColor(const Color3<>& color) {
setUniform(lightColorUniform, color);
return this;
}

6
src/Shaders/VertexColorShader.h

@ -38,10 +38,10 @@ Draws vertex-colored mesh.
template<std::uint8_t dimensions> class SHADERS_EXPORT VertexColorShader: public AbstractShaderProgram {
public:
/** @brief Vertex position */
typedef Attribute<0, typename DimensionTraits<dimensions, GLfloat>::PointType> Position;
typedef Attribute<0, typename DimensionTraits<dimensions>::PointType> Position;
/** @brief Vertex color */
typedef Attribute<1, Math::Point2D<GLfloat>> Color;
typedef Attribute<1, Color3<>> Color;
VertexColorShader();
@ -49,7 +49,7 @@ template<std::uint8_t dimensions> class SHADERS_EXPORT VertexColorShader: public
* @brief Set transformation and projection
* @return Pointer to self (for method chaining)
*/
inline VertexColorShader<dimensions>* setTransformationProjection(const typename DimensionTraits<dimensions, GLfloat>::MatrixType& matrix) {
inline VertexColorShader<dimensions>* setTransformationProjection(const typename DimensionTraits<dimensions>::MatrixType& matrix) {
setUniform(transformationProjectionUniform, matrix);
return this;
}

2
src/Texture.h

@ -203,7 +203,7 @@ template<std::uint8_t dimensions> class Texture: public AbstractTexture {
return this;
}
#ifndef MAGNUM_TARGET_GLES
inline Texture<Dimensions>* setBorderColor(const Color4<GLfloat>& color) {
inline Texture<Dimensions>* setBorderColor(const Color4<>& color) {
AbstractTexture::setBorderColor(color);
return this;
}

Loading…
Cancel
Save