ic
/
magnum
mirror of https://github.com/mosra/magnum.git
6
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

Adapted to Corrade changes. 

Allowing to instantiate Trade::AbstractImporter subclasses directly
without plugin manager.
pull/278/head
Vladimír Vondruš 13 years ago
parent
3251660f81
commit
231f3277ab
67 changed files with 526 additions and 522 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 4
      src/Math/Algorithms/Test/GaussJordanTest.cpp
  2. 4
      src/Math/Algorithms/Test/GramSchmidtTest.cpp
  3. 4
      src/Math/Algorithms/Test/SvdTest.cpp
  4. 8
      src/Math/Geometry/Test/DistanceTest.cpp
  5. 2
      src/Math/Geometry/Test/IntersectionTest.cpp
  6. 11
      src/Math/Geometry/Test/RectangleTest.cpp
  7. 10
      src/Math/Test/AngleTest.cpp
  8. 26
      src/Math/Test/BoolVectorTest.cpp
  9. 42
      src/Math/Test/ComplexTest.cpp
  10. 2
      src/Math/Test/ConstantsTest.cpp
  11. 38
      src/Math/Test/DualComplexTest.cpp
  12. 48
      src/Math/Test/DualQuaternionTest.cpp
  13. 20
      src/Math/Test/DualTest.cpp
  14. 38
      src/Math/Test/FunctionsTest.cpp
  15. 4
      src/Math/Test/MathTypeTraitsTest.cpp
  16. 40
      src/Math/Test/Matrix3Test.cpp
  17. 50
      src/Math/Test/Matrix4Test.cpp
  18. 24
      src/Math/Test/MatrixTest.cpp
  19. 60
      src/Math/Test/QuaternionTest.cpp
  20. 54
      src/Math/Test/RectangularMatrixTest.cpp
  21. 8
      src/Math/Test/SwizzleTest.cpp
  22. 16
      src/Math/Test/UnitTest.cpp
  23. 23
      src/Math/Test/Vector2Test.cpp
  24. 30
      src/Math/Test/Vector3Test.cpp
  25. 26
      src/Math/Test/Vector4Test.cpp
  26. 70
      src/Math/Test/VectorTest.cpp
  27. 31
      src/MeshTools/Test/CleanTest.cpp
  28. 4
      src/MeshTools/Test/CombineIndexedArraysTest.cpp
  29. 6
      src/MeshTools/Test/CompressIndicesTest.cpp
  30. 6
      src/MeshTools/Test/FlipNormalsTest.cpp
  31. 4
      src/MeshTools/Test/GenerateFlatNormalsTest.cpp
  32. 12
      src/MeshTools/Test/InterleaveTest.cpp
  33. 4
      src/MeshTools/Test/SubdivideTest.cpp
  34. 4
      src/MeshTools/Test/TipsifyTest.cpp
  35. 8
      src/MeshTools/Test/TransformTest.cpp
  36. 2
      src/Physics/Test/AbstractShapeTest.cpp
  37. 4
      src/Physics/Test/AxisAlignedBoxTest.cpp
  38. 2
      src/Physics/Test/BoxTest.cpp
  39. 4
      src/Physics/Test/CapsuleTest.cpp
  40. 2
      src/Physics/Test/LineTest.cpp
  41. 4
      src/Physics/Test/ObjectShapeTest.cpp
  42. 6
      src/Physics/Test/PlaneTest.cpp
  43. 2
      src/Physics/Test/PointTest.cpp
  44. 4
      src/Physics/Test/ShapeGroupTest.cpp
  45. 10
      src/Physics/Test/SphereTest.cpp
  46. 4
      src/Primitives/Test/CapsuleTest.cpp
  47. 4
      src/Primitives/Test/CylinderTest.cpp
  48. 4
      src/Primitives/Test/UVSphereTest.cpp
  49. 15
      src/SceneGraph/Test/AnimableTest.cpp
  50. 16
      src/SceneGraph/Test/CameraTest.cpp
  51. 20
      src/SceneGraph/Test/EuclideanMatrixTransformation2DTest.cpp
  52. 20
      src/SceneGraph/Test/EuclideanMatrixTransformation3DTest.cpp
  53. 22
      src/SceneGraph/Test/MatrixTransformation2DTest.cpp
  54. 22
      src/SceneGraph/Test/MatrixTransformation3DTest.cpp
  55. 18
      src/SceneGraph/Test/ObjectTest.cpp
  56. 4
      src/SceneGraph/Test/SceneTest.cpp
  57. 4
      src/Test/AbstractImageTest.cpp
  58. 28
      src/Test/AbstractShaderProgramTest.cpp
  59. 8
      src/Test/ArrayTest.cpp
  60. 24
      src/Test/ColorTest.cpp
  61. 8
      src/Test/MeshTest.cpp
  62. 16
      src/Test/ResourceManagerTest.cpp
  63. 6
      src/Test/SwizzleTest.cpp
  64. 8
      src/TextureTools/Test/AtlasTest.cpp
  65. 12
      src/Trade/AbstractImporter.h
  66. 2
      src/Trade/Test/ObjectData2DTest.cpp
  67. 2
      src/Trade/Test/ObjectData3DTest.cpp

4
src/Math/Algorithms/Test/GaussJordanTest.cpp
Unescape View File

@ -31,8 +31,8 @@ typedef RectangularMatrix<4, 4, Float> Matrix4;
typedef Vector<4, Float> Vector4; typedef Vector<4, Float> Vector4;
GaussJordanTest::GaussJordanTest() { GaussJordanTest::GaussJordanTest() {
addTests(&GaussJordanTest::singular, addTests({&GaussJordanTest::singular,
&GaussJordanTest::invert); &GaussJordanTest::invert});
} }
void GaussJordanTest::singular() { void GaussJordanTest::singular() {

4
src/Math/Algorithms/Test/GramSchmidtTest.cpp
Unescape View File

@ -31,8 +31,8 @@ typedef RectangularMatrix<3, 3, Float> Matrix3;
typedef Vector<3, Float> Vector3; typedef Vector<3, Float> Vector3;
GramSchmidtTest::GramSchmidtTest() { GramSchmidtTest::GramSchmidtTest() {
addTests(&GramSchmidtTest::orthogonalize, addTests({&GramSchmidtTest::orthogonalize,
&GramSchmidtTest::orthonormalize); &GramSchmidtTest::orthonormalize});
} }
void GramSchmidtTest::orthogonalize() { void GramSchmidtTest::orthogonalize() {

4
src/Math/Algorithms/Test/SvdTest.cpp
Unescape View File

@ -50,8 +50,8 @@ constexpr static Matrix5x8d a(
static const Vector5d expected(std::sqrt(1248.0), 0.0, 20.0, std::sqrt(384.0), 0.0); static const Vector5d expected(std::sqrt(1248.0), 0.0, 20.0, std::sqrt(384.0), 0.0);
SvdTest::SvdTest() { SvdTest::SvdTest() {
addTests(&SvdTest::testDouble, addTests({&SvdTest::testDouble,
&SvdTest::testFloat); &SvdTest::testFloat});
} }
void SvdTest::testDouble() { void SvdTest::testDouble() {

8
src/Math/Geometry/Test/DistanceTest.cpp
Unescape View File

@ -36,10 +36,10 @@ typedef Math::Vector3<Float> Vector3;
typedef Math::Constants<Float> Constants; typedef Math::Constants<Float> Constants;
DistanceTest::DistanceTest() { DistanceTest::DistanceTest() {
addTests(&DistanceTest::linePoint2D, addTests({&DistanceTest::linePoint2D,
&DistanceTest::linePoint3D, &DistanceTest::linePoint3D,
&DistanceTest::lineSegmentPoint2D, &DistanceTest::lineSegmentPoint2D,
&DistanceTest::lineSegmentPoint3D); &DistanceTest::lineSegmentPoint3D});
} }
void DistanceTest::linePoint2D() { void DistanceTest::linePoint2D() {

2
src/Math/Geometry/Test/IntersectionTest.cpp
Unescape View File

@ -30,7 +30,7 @@ class IntersectionTest: public Corrade::TestSuite::Tester {
typedef Math::Vector3<Float> Vector3; typedef Math::Vector3<Float> Vector3;
IntersectionTest::IntersectionTest() { IntersectionTest::IntersectionTest() {
addTests(&IntersectionTest::planeLine); addTests({&IntersectionTest::planeLine});
} }
void IntersectionTest::planeLine() { void IntersectionTest::planeLine() {

11
src/Math/Geometry/Test/RectangleTest.cpp
Unescape View File

@ -37,11 +37,12 @@ typedef Geometry::Rectangle<Int> Rectanglei;
typedef Vector2<Int> Vector2i; typedef Vector2<Int> Vector2i;
RectangleTest::RectangleTest() { RectangleTest::RectangleTest() {
addTests(&RectangleTest::access, addTests({&RectangleTest::access,
&RectangleTest::compare, &RectangleTest::compare,
&RectangleTest::construct, &RectangleTest::construct,
&RectangleTest::size, &RectangleTest::size,
&RectangleTest::debug);
&RectangleTest::debug});
} }
void RectangleTest::access() { void RectangleTest::access() {

10
src/Math/Test/AngleTest.cpp
Unescape View File

@ -38,12 +38,12 @@ typedef Math::Deg<Double> Degd;
typedef Math::Rad<Double> Radd; typedef Math::Rad<Double> Radd;
AngleTest::AngleTest() { AngleTest::AngleTest() {
addTests(&AngleTest::construct, addTests({&AngleTest::construct,
&AngleTest::literals, &AngleTest::literals,
&AngleTest::conversion, &AngleTest::conversion,
&AngleTest::debugDeg, &AngleTest::debugDeg,
&AngleTest::debugRad); &AngleTest::debugRad});
} }
void AngleTest::construct() { void AngleTest::construct() {

26
src/Math/Test/BoolVectorTest.cpp
Unescape View File

@ -50,23 +50,23 @@ static_assert(BoolVector<17>::DataSize == 3, "Improper DataSize");
typedef Math::BoolVector<19> BoolVector19; typedef Math::BoolVector<19> BoolVector19;
BoolVectorTest::BoolVectorTest() { BoolVectorTest::BoolVectorTest() {
addTests(&BoolVectorTest::constructDefault, addTests({&BoolVectorTest::constructDefault,
&BoolVectorTest::constructOneValue, &BoolVectorTest::constructOneValue,
&BoolVectorTest::constructOneElement, &BoolVectorTest::constructOneElement,
&BoolVectorTest::data, &BoolVectorTest::data,
&BoolVectorTest::constExpressions, &BoolVectorTest::constExpressions,
&BoolVectorTest::compare, &BoolVectorTest::compare,
&BoolVectorTest::compareUndefined, &BoolVectorTest::compareUndefined,
&BoolVectorTest::all, &BoolVectorTest::all,
&BoolVectorTest::none, &BoolVectorTest::none,
&BoolVectorTest::any, &BoolVectorTest::any,
&BoolVectorTest::bitInverse, &BoolVectorTest::bitInverse,
&BoolVectorTest::bitAndOrXor, &BoolVectorTest::bitAndOrXor,
&BoolVectorTest::debug); &BoolVectorTest::debug});
} }
void BoolVectorTest::constructDefault() { void BoolVectorTest::constructDefault() {

42
src/Math/Test/ComplexTest.cpp
Unescape View File

@ -55,33 +55,33 @@ class ComplexTest: public Corrade::TestSuite::Tester {
}; };
ComplexTest::ComplexTest() { ComplexTest::ComplexTest() {
addTests(&ComplexTest::construct, addTests({&ComplexTest::construct,
&ComplexTest::constructDefault, &ComplexTest::constructDefault,
&ComplexTest::constructFromVector, &ComplexTest::constructFromVector,
&ComplexTest::compare, &ComplexTest::compare,
&ComplexTest::constExpressions, &ComplexTest::constExpressions,
&ComplexTest::addSubtract, &ComplexTest::addSubtract,
&ComplexTest::negated, &ComplexTest::negated,
&ComplexTest::multiplyDivideScalar, &ComplexTest::multiplyDivideScalar,
&ComplexTest::multiply, &ComplexTest::multiply,
&ComplexTest::dot, &ComplexTest::dot,
&ComplexTest::dotSelf, &ComplexTest::dotSelf,
&ComplexTest::length, &ComplexTest::length,
&ComplexTest::normalized, &ComplexTest::normalized,
&ComplexTest::conjugated, &ComplexTest::conjugated,
&ComplexTest::inverted, &ComplexTest::inverted,
&ComplexTest::invertedNormalized, &ComplexTest::invertedNormalized,
&ComplexTest::angle, &ComplexTest::angle,
&ComplexTest::rotation, &ComplexTest::rotation,
&ComplexTest::matrix, &ComplexTest::matrix,
&ComplexTest::transformVector, &ComplexTest::transformVector,
&ComplexTest::debug); &ComplexTest::debug});
} }
typedef Math::Deg<Float> Deg; typedef Math::Deg<Float> Deg;

2
src/Math/Test/ConstantsTest.cpp
Unescape View File

@ -28,7 +28,7 @@ class ConstantsTest: public Corrade::TestSuite::Tester {
}; };
ConstantsTest::ConstantsTest() { ConstantsTest::ConstantsTest() {
addTests(&ConstantsTest::constants); addTests({&ConstantsTest::constants});
} }
void ConstantsTest::constants() { void ConstantsTest::constants() {

38
src/Math/Test/DualComplexTest.cpp
Unescape View File

@ -61,31 +61,31 @@ typedef Math::Matrix3<Float> Matrix3;
typedef Math::Vector2<Float> Vector2; typedef Math::Vector2<Float> Vector2;
DualComplexTest::DualComplexTest() { DualComplexTest::DualComplexTest() {
addTests(&DualComplexTest::construct, addTests({&DualComplexTest::construct,
&DualComplexTest::constructDefault, &DualComplexTest::constructDefault,
&DualComplexTest::constructFromVector, &DualComplexTest::constructFromVector,
&DualComplexTest::constExpressions, &DualComplexTest::constExpressions,
&DualComplexTest::multiply, &DualComplexTest::multiply,
&DualComplexTest::lengthSquared, &DualComplexTest::lengthSquared,
&DualComplexTest::length, &DualComplexTest::length,
&DualComplexTest::normalized, &DualComplexTest::normalized,
&DualComplexTest::complexConjugated, &DualComplexTest::complexConjugated,
&DualComplexTest::dualConjugated, &DualComplexTest::dualConjugated,
&DualComplexTest::conjugated, &DualComplexTest::conjugated,
&DualComplexTest::inverted, &DualComplexTest::inverted,
&DualComplexTest::invertedNormalized, &DualComplexTest::invertedNormalized,
&DualComplexTest::rotation, &DualComplexTest::rotation,
&DualComplexTest::translation, &DualComplexTest::translation,
&DualComplexTest::combinedTransformParts, &DualComplexTest::combinedTransformParts,
&DualComplexTest::matrix, &DualComplexTest::matrix,
&DualComplexTest::transformPoint, &DualComplexTest::transformPoint,
&DualComplexTest::debug); &DualComplexTest::debug});
} }
void DualComplexTest::construct() { void DualComplexTest::construct() {

48
src/Math/Test/DualQuaternionTest.cpp
Unescape View File

@ -59,30 +59,30 @@ typedef Math::Quaternion<Float> Quaternion;
typedef Math::Vector3<Float> Vector3; typedef Math::Vector3<Float> Vector3;
DualQuaternionTest::DualQuaternionTest() { DualQuaternionTest::DualQuaternionTest() {
addTests(&DualQuaternionTest::construct, addTests({&DualQuaternionTest::construct,
&DualQuaternionTest::constructDefault, &DualQuaternionTest::constructDefault,
&DualQuaternionTest::constructFromVector, &DualQuaternionTest::constructFromVector,
&DualQuaternionTest::constExpressions, &DualQuaternionTest::constExpressions,
&DualQuaternionTest::lengthSquared, &DualQuaternionTest::lengthSquared,
&DualQuaternionTest::length, &DualQuaternionTest::length,
&DualQuaternionTest::normalized, &DualQuaternionTest::normalized,
&DualQuaternionTest::quaternionConjugated, &DualQuaternionTest::quaternionConjugated,
&DualQuaternionTest::dualConjugated, &DualQuaternionTest::dualConjugated,
&DualQuaternionTest::conjugated, &DualQuaternionTest::conjugated,
&DualQuaternionTest::inverted, &DualQuaternionTest::inverted,
&DualQuaternionTest::invertedNormalized, &DualQuaternionTest::invertedNormalized,
&DualQuaternionTest::rotation, &DualQuaternionTest::rotation,
&DualQuaternionTest::translation, &DualQuaternionTest::translation,
&DualQuaternionTest::combinedTransformParts, &DualQuaternionTest::combinedTransformParts,
&DualQuaternionTest::matrix, &DualQuaternionTest::matrix,
&DualQuaternionTest::transformPoint, &DualQuaternionTest::transformPoint,
&DualQuaternionTest::transformPointNormalized, &DualQuaternionTest::transformPointNormalized,
&DualQuaternionTest::debug); &DualQuaternionTest::debug});
} }
void DualQuaternionTest::construct() { void DualQuaternionTest::construct() {

20
src/Math/Test/DualTest.cpp
Unescape View File

@ -43,20 +43,20 @@ class DualTest: public Corrade::TestSuite::Tester {
typedef Math::Dual<Float> Dual; typedef Math::Dual<Float> Dual;
DualTest::DualTest() { DualTest::DualTest() {
addTests(&DualTest::construct, addTests({&DualTest::construct,
&DualTest::constructDefault, &DualTest::constructDefault,
&DualTest::compare, &DualTest::compare,
&DualTest::constExpressions, &DualTest::constExpressions,
&DualTest::addSubtract, &DualTest::addSubtract,
&DualTest::negated, &DualTest::negated,
&DualTest::multiplyDivide, &DualTest::multiplyDivide,
&DualTest::conjugated, &DualTest::conjugated,
&DualTest::sqrt, &DualTest::sqrt,
&DualTest::debug); &DualTest::debug});
} }
void DualTest::construct() { void DualTest::construct() {

38
src/Math/Test/FunctionsTest.cpp
Unescape View File

@ -54,25 +54,25 @@ typedef Math::Vector3<Byte> Vector3b;
typedef Math::Vector3<Int> Vector3i; typedef Math::Vector3<Int> Vector3i;
FunctionsTest::FunctionsTest() { FunctionsTest::FunctionsTest() {
addTests(&FunctionsTest::min, addTests({&FunctionsTest::min,
&FunctionsTest::max, &FunctionsTest::max,
&FunctionsTest::abs, &FunctionsTest::abs,
&FunctionsTest::sqrt, &FunctionsTest::sqrt,
&FunctionsTest::clamp, &FunctionsTest::clamp,
&FunctionsTest::lerp, &FunctionsTest::lerp,
&FunctionsTest::normalizeUnsigned, &FunctionsTest::normalizeUnsigned,
&FunctionsTest::normalizeSigned, &FunctionsTest::normalizeSigned,
&FunctionsTest::denormalizeUnsigned, &FunctionsTest::denormalizeUnsigned,
&FunctionsTest::denormalizeSigned, &FunctionsTest::denormalizeSigned,
&FunctionsTest::renormalizeUnsinged, &FunctionsTest::renormalizeUnsinged,
&FunctionsTest::renormalizeSinged, &FunctionsTest::renormalizeSinged,
&FunctionsTest::normalizeTypeDeduction, &FunctionsTest::normalizeTypeDeduction,
&FunctionsTest::pow, &FunctionsTest::pow,
&FunctionsTest::log, &FunctionsTest::log,
&FunctionsTest::log2, &FunctionsTest::log2,
&FunctionsTest::trigonometric); &FunctionsTest::trigonometric});
} }
void FunctionsTest::min() { void FunctionsTest::min() {

4
src/Math/Test/MathTypeTraitsTest.cpp
Unescape View File

@ -33,8 +33,8 @@ class MathTypeTraitsTest: public Corrade::TestSuite::Tester {
}; };
MathTypeTraitsTest::MathTypeTraitsTest() { MathTypeTraitsTest::MathTypeTraitsTest() {
addTests(&MathTypeTraitsTest::equalsIntegral, addTests({&MathTypeTraitsTest::equalsIntegral,
&MathTypeTraitsTest::equalsFloatingPoint); &MathTypeTraitsTest::equalsFloatingPoint});
} }
void MathTypeTraitsTest::equalsIntegral() { void MathTypeTraitsTest::equalsIntegral() {

40
src/Math/Test/Matrix3Test.cpp
Unescape View File

@ -54,26 +54,26 @@ typedef Math::Matrix<2, Float> Matrix2;
typedef Math::Vector2<Float> Vector2; typedef Math::Vector2<Float> Vector2;
Matrix3Test::Matrix3Test() { Matrix3Test::Matrix3Test() {
addTests(&Matrix3Test::construct, addTests({&Matrix3Test::construct,
&Matrix3Test::constructIdentity, &Matrix3Test::constructIdentity,
&Matrix3Test::constructZero, &Matrix3Test::constructZero,
&Matrix3Test::constructConversion, &Matrix3Test::constructConversion,
&Matrix3Test::constructCopy, &Matrix3Test::constructCopy,
&Matrix3Test::translation, &Matrix3Test::translation,
&Matrix3Test::scaling, &Matrix3Test::scaling,
&Matrix3Test::rotation, &Matrix3Test::rotation,
&Matrix3Test::reflection, &Matrix3Test::reflection,
&Matrix3Test::projection, &Matrix3Test::projection,
&Matrix3Test::fromParts, &Matrix3Test::fromParts,
&Matrix3Test::rotationScalingPart, &Matrix3Test::rotationScalingPart,
&Matrix3Test::rotationPart, &Matrix3Test::rotationPart,
&Matrix3Test::vectorParts, &Matrix3Test::vectorParts,
&Matrix3Test::invertedEuclidean, &Matrix3Test::invertedEuclidean,
&Matrix3Test::transform, &Matrix3Test::transform,
&Matrix3Test::debug, &Matrix3Test::debug,
&Matrix3Test::configuration); &Matrix3Test::configuration});
} }
void Matrix3Test::construct() { void Matrix3Test::construct() {

50
src/Math/Test/Matrix4Test.cpp
Unescape View File

@ -60,31 +60,31 @@ typedef Math::Matrix<3, Float> Matrix3;
typedef Math::Vector3<Float> Vector3; typedef Math::Vector3<Float> Vector3;
Matrix4Test::Matrix4Test() { Matrix4Test::Matrix4Test() {
addTests(&Matrix4Test::construct, addTests({&Matrix4Test::construct,
&Matrix4Test::constructIdentity, &Matrix4Test::constructIdentity,
&Matrix4Test::constructZero, &Matrix4Test::constructZero,
&Matrix4Test::constructConversion, &Matrix4Test::constructConversion,
&Matrix4Test::constructCopy, &Matrix4Test::constructCopy,
&Matrix4Test::translation, &Matrix4Test::translation,
&Matrix4Test::scaling, &Matrix4Test::scaling,
&Matrix4Test::rotation, &Matrix4Test::rotation,
&Matrix4Test::rotationX, &Matrix4Test::rotationX,
&Matrix4Test::rotationY, &Matrix4Test::rotationY,
&Matrix4Test::rotationZ, &Matrix4Test::rotationZ,
&Matrix4Test::reflection, &Matrix4Test::reflection,
&Matrix4Test::orthographicProjection, &Matrix4Test::orthographicProjection,
&Matrix4Test::perspectiveProjection, &Matrix4Test::perspectiveProjection,
&Matrix4Test::perspectiveProjectionFov, &Matrix4Test::perspectiveProjectionFov,
&Matrix4Test::fromParts, &Matrix4Test::fromParts,
&Matrix4Test::rotationScalingPart, &Matrix4Test::rotationScalingPart,
&Matrix4Test::rotationPart, &Matrix4Test::rotationPart,
&Matrix4Test::vectorParts, &Matrix4Test::vectorParts,
&Matrix4Test::invertedEuclidean, &Matrix4Test::invertedEuclidean,
&Matrix4Test::transform, &Matrix4Test::transform,
&Matrix4Test::debug, &Matrix4Test::debug,
&Matrix4Test::configuration); &Matrix4Test::configuration});
} }
void Matrix4Test::construct() { void Matrix4Test::construct() {

24
src/Math/Test/MatrixTest.cpp
Unescape View File

@ -48,18 +48,18 @@ typedef Vector<4, Int> Vector4i;
typedef Vector<3, Float> Vector3; typedef Vector<3, Float> Vector3;
MatrixTest::MatrixTest() { MatrixTest::MatrixTest() {
addTests(&MatrixTest::construct, addTests({&MatrixTest::construct,
&MatrixTest::constructIdentity, &MatrixTest::constructIdentity,
&MatrixTest::constructZero, &MatrixTest::constructZero,
&MatrixTest::constructConversion, &MatrixTest::constructConversion,
&MatrixTest::constructCopy, &MatrixTest::constructCopy,
&MatrixTest::trace, &MatrixTest::trace,
&MatrixTest::ij, &MatrixTest::ij,
&MatrixTest::determinant, &MatrixTest::determinant,
&MatrixTest::inverted, &MatrixTest::inverted,
&MatrixTest::debug, &MatrixTest::debug,
&MatrixTest::configuration); &MatrixTest::configuration});
} }
void MatrixTest::construct() { void MatrixTest::construct() {

60
src/Math/Test/QuaternionTest.cpp
Unescape View File

@ -66,36 +66,36 @@ typedef Math::Vector3<Float> Vector3;
typedef Math::Vector4<Float> Vector4; typedef Math::Vector4<Float> Vector4;
QuaternionTest::QuaternionTest() { QuaternionTest::QuaternionTest() {
addTests(&QuaternionTest::construct, addTests({&QuaternionTest::construct,
&QuaternionTest::constructDefault, &QuaternionTest::constructDefault,
&QuaternionTest::constructFromVector, &QuaternionTest::constructFromVector,
&QuaternionTest::compare, &QuaternionTest::compare,
&QuaternionTest::constExpressions, &QuaternionTest::constExpressions,
&QuaternionTest::addSubtract, &QuaternionTest::addSubtract,
&QuaternionTest::negated, &QuaternionTest::negated,
&QuaternionTest::multiplyDivideScalar, &QuaternionTest::multiplyDivideScalar,
&QuaternionTest::multiply, &QuaternionTest::multiply,
&QuaternionTest::dot, &QuaternionTest::dot,
&QuaternionTest::dotSelf, &QuaternionTest::dotSelf,
&QuaternionTest::length, &QuaternionTest::length,
&QuaternionTest::normalized, &QuaternionTest::normalized,
&QuaternionTest::conjugated, &QuaternionTest::conjugated,
&QuaternionTest::inverted, &QuaternionTest::inverted,
&QuaternionTest::invertedNormalized, &QuaternionTest::invertedNormalized,
&QuaternionTest::rotation, &QuaternionTest::rotation,
&QuaternionTest::angle, &QuaternionTest::angle,
&QuaternionTest::matrix, &QuaternionTest::matrix,
&QuaternionTest::lerp, &QuaternionTest::lerp,
&QuaternionTest::slerp, &QuaternionTest::slerp,
&QuaternionTest::transformVector, &QuaternionTest::transformVector,
&QuaternionTest::transformVectorNormalized, &QuaternionTest::transformVectorNormalized,
&QuaternionTest::debug); &QuaternionTest::debug});
} }
void QuaternionTest::construct() { void QuaternionTest::construct() {

54
src/Math/Test/RectangularMatrixTest.cpp
Unescape View File

@ -64,33 +64,33 @@ typedef Vector<2, Float> Vector2;
typedef Vector<2, Int> Vector2i; typedef Vector<2, Int> Vector2i;
RectangularMatrixTest::RectangularMatrixTest() { RectangularMatrixTest::RectangularMatrixTest() {
addTests(&RectangularMatrixTest::construct, addTests({&RectangularMatrixTest::construct,
&RectangularMatrixTest::constructDefault, &RectangularMatrixTest::constructDefault,
&RectangularMatrixTest::constructConversion, &RectangularMatrixTest::constructConversion,
&RectangularMatrixTest::constructFromData, &RectangularMatrixTest::constructFromData,
&RectangularMatrixTest::constructFromDiagonal, &RectangularMatrixTest::constructFromDiagonal,
&RectangularMatrixTest::constructCopy, &RectangularMatrixTest::constructCopy,
&RectangularMatrixTest::data, &RectangularMatrixTest::data,
&RectangularMatrixTest::compare, &RectangularMatrixTest::compare,
&RectangularMatrixTest::negative, &RectangularMatrixTest::negative,
&RectangularMatrixTest::addSubtract, &RectangularMatrixTest::addSubtract,
&RectangularMatrixTest::multiplyDivide, &RectangularMatrixTest::multiplyDivide,
&RectangularMatrixTest::multiply, &RectangularMatrixTest::multiply,
&RectangularMatrixTest::transposed, &RectangularMatrixTest::transposed,
&RectangularMatrixTest::diagonal, &RectangularMatrixTest::diagonal,
&RectangularMatrixTest::sum, &RectangularMatrixTest::sum,
&RectangularMatrixTest::product, &RectangularMatrixTest::product,
&RectangularMatrixTest::min, &RectangularMatrixTest::min,
&RectangularMatrixTest::minAbs, &RectangularMatrixTest::minAbs,
&RectangularMatrixTest::max, &RectangularMatrixTest::max,
&RectangularMatrixTest::maxAbs, &RectangularMatrixTest::maxAbs,
&RectangularMatrixTest::debug, &RectangularMatrixTest::debug,
&RectangularMatrixTest::configuration); &RectangularMatrixTest::configuration});
} }
void RectangularMatrixTest::construct() { void RectangularMatrixTest::construct() {

8
src/Math/Test/SwizzleTest.cpp
Unescape View File

@ -32,10 +32,10 @@ class SwizzleTest: public Corrade::TestSuite::Tester {
typedef Vector<4, Int> Vector4i; typedef Vector<4, Int> Vector4i;
SwizzleTest::SwizzleTest() { SwizzleTest::SwizzleTest() {
addTests(&SwizzleTest::components, addTests({&SwizzleTest::components,
&SwizzleTest::constants, &SwizzleTest::constants,
&SwizzleTest::sizes, &SwizzleTest::sizes,
&SwizzleTest::constExpressions); &SwizzleTest::constExpressions});
} }
void SwizzleTest::components() { void SwizzleTest::components() {

16
src/Math/Test/UnitTest.cpp
Unescape View File

@ -34,14 +34,14 @@ class UnitTest: public Corrade::TestSuite::Tester {
}; };
UnitTest::UnitTest() { UnitTest::UnitTest() {
addTests(&UnitTest::construct, addTests({&UnitTest::construct,
&UnitTest::constructDefault, &UnitTest::constructDefault,
&UnitTest::constructConversion, &UnitTest::constructConversion,
&UnitTest::compare, &UnitTest::compare,
&UnitTest::negated, &UnitTest::negated,
&UnitTest::addSubtract, &UnitTest::addSubtract,
&UnitTest::multiplyDivide); &UnitTest::multiplyDivide});
} }
template<class> struct Sec_; template<class> struct Sec_;

23
src/Math/Test/Vector2Test.cpp
Unescape View File

@ -43,17 +43,18 @@ typedef Math::Vector2<Float> Vector2;
typedef Math::Vector2<Int> Vector2i; typedef Math::Vector2<Int> Vector2i;
Vector2Test::Vector2Test() { Vector2Test::Vector2Test() {
addTests(&Vector2Test::construct, addTests({&Vector2Test::construct,
&Vector2Test::constructDefault, &Vector2Test::constructDefault,
&Vector2Test::constructOneValue, &Vector2Test::constructOneValue,
&Vector2Test::constructConversion, &Vector2Test::constructConversion,
&Vector2Test::constructCopy, &Vector2Test::constructCopy,
&Vector2Test::access, &Vector2Test::access,
&Vector2Test::axes, &Vector2Test::axes,
&Vector2Test::scales, &Vector2Test::scales,
&Vector2Test::debug,
&Vector2Test::configuration); &Vector2Test::debug,
&Vector2Test::configuration});
} }
void Vector2Test::construct() { void Vector2Test::construct() {

30
src/Math/Test/Vector3Test.cpp
Unescape View File

@ -47,21 +47,21 @@ typedef Math::Vector3<Int> Vector3i;
typedef Math::Vector2<Float> Vector2; typedef Math::Vector2<Float> Vector2;
Vector3Test::Vector3Test() { Vector3Test::Vector3Test() {
addTests(&Vector3Test::construct, addTests({&Vector3Test::construct,
&Vector3Test::constructDefault, &Vector3Test::constructDefault,
&Vector3Test::constructOneValue, &Vector3Test::constructOneValue,
&Vector3Test::constructParts, &Vector3Test::constructParts,
&Vector3Test::constructConversion, &Vector3Test::constructConversion,
&Vector3Test::constructCopy, &Vector3Test::constructCopy,
&Vector3Test::access, &Vector3Test::access,
&Vector3Test::cross, &Vector3Test::cross,
&Vector3Test::axes, &Vector3Test::axes,
&Vector3Test::scales, &Vector3Test::scales,
&Vector3Test::twoComponent, &Vector3Test::twoComponent,
&Vector3Test::debug, &Vector3Test::debug,
&Vector3Test::configuration); &Vector3Test::configuration});
} }
void Vector3Test::construct() { void Vector3Test::construct() {

26
src/Math/Test/Vector4Test.cpp
Unescape View File

@ -46,19 +46,19 @@ typedef Math::Vector3<Float> Vector3;
typedef Math::Vector2<Float> Vector2; typedef Math::Vector2<Float> Vector2;
Vector4Test::Vector4Test() { Vector4Test::Vector4Test() {
addTests(&Vector4Test::construct, addTests({&Vector4Test::construct,
&Vector4Test::constructDefault, &Vector4Test::constructDefault,
&Vector4Test::constructOneValue, &Vector4Test::constructOneValue,
&Vector4Test::constructParts, &Vector4Test::constructParts,
&Vector4Test::constructConversion, &Vector4Test::constructConversion,
&Vector4Test::constructCopy, &Vector4Test::constructCopy,
&Vector4Test::access, &Vector4Test::access,
&Vector4Test::threeComponent, &Vector4Test::threeComponent,
&Vector4Test::twoComponent, &Vector4Test::twoComponent,
&Vector4Test::debug, &Vector4Test::debug,
&Vector4Test::configuration); &Vector4Test::configuration});
} }
void Vector4Test::construct() { void Vector4Test::construct() {

70
src/Math/Test/VectorTest.cpp
Unescape View File

@ -68,41 +68,41 @@ typedef Vector<4, Float> Vector4;
typedef Vector<4, Int> Vector4i; typedef Vector<4, Int> Vector4i;
VectorTest::VectorTest() { VectorTest::VectorTest() {
addTests(&VectorTest::construct, addTests({&VectorTest::construct,
&VectorTest::constructFromData, &VectorTest::constructFromData,
&VectorTest::constructDefault, &VectorTest::constructDefault,
&VectorTest::constructOneValue, &VectorTest::constructOneValue,
&VectorTest::constructOneComponent, &VectorTest::constructOneComponent,
&VectorTest::constructConversion, &VectorTest::constructConversion,
&VectorTest::constructCopy, &VectorTest::constructCopy,
&VectorTest::data, &VectorTest::data,
&VectorTest::negative, &VectorTest::negative,
&VectorTest::addSubtract, &VectorTest::addSubtract,
&VectorTest::multiplyDivide, &VectorTest::multiplyDivide,
&VectorTest::multiplyDivideComponentWise, &VectorTest::multiplyDivideComponentWise,
&VectorTest::compare, &VectorTest::compare,
&VectorTest::compareComponentWise, &VectorTest::compareComponentWise,
&VectorTest::dot, &VectorTest::dot,
&VectorTest::dotSelf, &VectorTest::dotSelf,
&VectorTest::length, &VectorTest::length,
&VectorTest::normalized, &VectorTest::normalized,
&VectorTest::sum, &VectorTest::sum,
&VectorTest::product, &VectorTest::product,
&VectorTest::min, &VectorTest::min,
&VectorTest::minAbs, &VectorTest::minAbs,
&VectorTest::max, &VectorTest::max,
&VectorTest::maxAbs, &VectorTest::maxAbs,
&VectorTest::projected, &VectorTest::projected,
&VectorTest::projectedOntoNormalized, &VectorTest::projectedOntoNormalized,
&VectorTest::angle, &VectorTest::angle,
&VectorTest::debug, &VectorTest::debug,
&VectorTest::configuration); &VectorTest::configuration});
} }
void VectorTest::construct() { void VectorTest::construct() {

31
src/MeshTools/Test/CleanTest.cpp
Unescape View File

@ -24,27 +24,26 @@ class CleanTest: public Corrade::TestSuite::Tester {
CleanTest(); CleanTest();
void cleanMesh(); void cleanMesh();
};
class Vector1 {
public:
static const std::size_t Size = 1;
typedef Int Type;
Vector1(): data(0) {}
Vector1(Type i): data(i) {}
Type operator[](std::size_t) const { return data; }
Type& operator[](std::size_t) { return data; }
bool operator==(Vector1 i) const { return i.data == data; }
Vector1 operator-(Vector1 i) const { return data-i.data; }
private: private:
class Vector1 { Type data;
public:
static const std::size_t Size = 1;
typedef Int Type;
Vector1(): data(0) {}
Vector1(Type i): data(i) {}
Type operator[](std::size_t) const { return data; }
Type& operator[](std::size_t) { return data; }
bool operator==(Vector1 i) const { return i.data == data; }
Vector1 operator-(Vector1 i) const { return data-i.data; }
private:
Type data;
};
}; };
CleanTest::CleanTest() { CleanTest::CleanTest() {
addTests(&CleanTest::cleanMesh); addTests({&CleanTest::cleanMesh});
} }
void CleanTest::cleanMesh() { void CleanTest::cleanMesh() {

4
src/MeshTools/Test/CombineIndexedArraysTest.cpp
Unescape View File

@ -30,8 +30,8 @@ class CombineIndexedArraysTest: public Corrade::TestSuite::Tester {
}; };
CombineIndexedArraysTest::CombineIndexedArraysTest() { CombineIndexedArraysTest::CombineIndexedArraysTest() {
addTests(&CombineIndexedArraysTest::wrongIndexCount, addTests({&CombineIndexedArraysTest::wrongIndexCount,
&CombineIndexedArraysTest::combine); &CombineIndexedArraysTest::combine});
} }
void CombineIndexedArraysTest::wrongIndexCount() { void CombineIndexedArraysTest::wrongIndexCount() {

6
src/MeshTools/Test/CompressIndicesTest.cpp
Unescape View File

@ -32,9 +32,9 @@ class CompressIndicesTest: public Corrade::TestSuite::Tester {
}; };
CompressIndicesTest::CompressIndicesTest() { CompressIndicesTest::CompressIndicesTest() {
addTests(&CompressIndicesTest::compressChar, addTests({&CompressIndicesTest::compressChar,
&CompressIndicesTest::compressShort, &CompressIndicesTest::compressShort,
&CompressIndicesTest::compressInt); &CompressIndicesTest::compressInt});
} }
void CompressIndicesTest::compressChar() { void CompressIndicesTest::compressChar() {

6
src/MeshTools/Test/FlipNormalsTest.cpp
Unescape View File

@ -31,9 +31,9 @@ class FlipNormalsTest: public Corrade::TestSuite::Tester {
}; };
FlipNormalsTest::FlipNormalsTest() { FlipNormalsTest::FlipNormalsTest() {
addTests(&FlipNormalsTest::wrongIndexCount, addTests({&FlipNormalsTest::wrongIndexCount,
&FlipNormalsTest::flipFaceWinding, &FlipNormalsTest::flipFaceWinding,
&FlipNormalsTest::flipNormals); &FlipNormalsTest::flipNormals});
} }
void FlipNormalsTest::wrongIndexCount() { void FlipNormalsTest::wrongIndexCount() {

4
src/MeshTools/Test/GenerateFlatNormalsTest.cpp
Unescape View File

@ -30,8 +30,8 @@ class GenerateFlatNormalsTest: public Corrade::TestSuite::Tester {
}; };
GenerateFlatNormalsTest::GenerateFlatNormalsTest() { GenerateFlatNormalsTest::GenerateFlatNormalsTest() {
addTests(&GenerateFlatNormalsTest::wrongIndexCount, addTests({&GenerateFlatNormalsTest::wrongIndexCount,
&GenerateFlatNormalsTest::generate); &GenerateFlatNormalsTest::generate});
} }
void GenerateFlatNormalsTest::wrongIndexCount() { void GenerateFlatNormalsTest::wrongIndexCount() {

12
src/MeshTools/Test/InterleaveTest.cpp
Unescape View File

@ -37,12 +37,12 @@ class InterleaveTest: public Corrade::TestSuite::Tester {
}; };
InterleaveTest::InterleaveTest() { InterleaveTest::InterleaveTest() {
addTests(&InterleaveTest::attributeCount, addTests({&InterleaveTest::attributeCount,
&InterleaveTest::attributeCountGaps, &InterleaveTest::attributeCountGaps,
&InterleaveTest::stride, &InterleaveTest::stride,
&InterleaveTest::strideGaps, &InterleaveTest::strideGaps,
&InterleaveTest::write, &InterleaveTest::write,
&InterleaveTest::writeGaps); &InterleaveTest::writeGaps});
} }
void InterleaveTest::attributeCount() { void InterleaveTest::attributeCount() {

4
src/MeshTools/Test/SubdivideTest.cpp
Unescape View File

@ -49,8 +49,8 @@ class SubdivideTest: public Corrade::TestSuite::Tester {
}; };
SubdivideTest::SubdivideTest() { SubdivideTest::SubdivideTest() {
addTests(&SubdivideTest::wrongIndexCount, addTests({&SubdivideTest::wrongIndexCount,
&SubdivideTest::subdivide); &SubdivideTest::subdivide});
} }
void SubdivideTest::wrongIndexCount() { void SubdivideTest::wrongIndexCount() {

4
src/MeshTools/Test/TipsifyTest.cpp
Unescape View File

@ -70,8 +70,8 @@ TipsifyTest::TipsifyTest(): indices{
16, 17, 18 16, 17, 18
}, vertexCount(19) { }, vertexCount(19) {
addTests(&TipsifyTest::buildAdjacency, addTests({&TipsifyTest::buildAdjacency,
&TipsifyTest::tipsify); &TipsifyTest::tipsify});
} }
void TipsifyTest::buildAdjacency() { void TipsifyTest::buildAdjacency() {

8
src/MeshTools/Test/TransformTest.cpp
Unescape View File

@ -34,11 +34,11 @@ class TransformTest: public Corrade::TestSuite::Tester {
}; };
TransformTest::TransformTest() { TransformTest::TransformTest() {
addTests(&TransformTest::transformVectors2D, addTests({&TransformTest::transformVectors2D,
&TransformTest::transformVectors3D, &TransformTest::transformVectors3D,
&TransformTest::transformPoints2D, &TransformTest::transformPoints2D,
&TransformTest::transformPoints3D); &TransformTest::transformPoints3D});
} }
/* GCC < 4.7 doesn't like constexpr here, don't know why */ /* GCC < 4.7 doesn't like constexpr here, don't know why */

2
src/Physics/Test/AbstractShapeTest.cpp
Unescape View File

@ -28,7 +28,7 @@ class AbstractShapeTest: public Corrade::TestSuite::Tester {
}; };
AbstractShapeTest::AbstractShapeTest() { AbstractShapeTest::AbstractShapeTest() {
addTests(&AbstractShapeTest::debug); addTests({&AbstractShapeTest::debug});
} }
void AbstractShapeTest::debug() { void AbstractShapeTest::debug() {

4
src/Physics/Test/AxisAlignedBoxTest.cpp
Unescape View File

@ -32,8 +32,8 @@ class AxisAlignedBoxTest: public Corrade::TestSuite::Tester, ShapeTestBase {
}; };
AxisAlignedBoxTest::AxisAlignedBoxTest() { AxisAlignedBoxTest::AxisAlignedBoxTest() {
addTests(&AxisAlignedBoxTest::applyTransformation, addTests({&AxisAlignedBoxTest::applyTransformation,
&AxisAlignedBoxTest::collisionPoint); &AxisAlignedBoxTest::collisionPoint});
} }
void AxisAlignedBoxTest::applyTransformation() { void AxisAlignedBoxTest::applyTransformation() {

2
src/Physics/Test/BoxTest.cpp
Unescape View File

@ -28,7 +28,7 @@ class BoxTest: public Corrade::TestSuite::Tester {
}; };
BoxTest::BoxTest() { BoxTest::BoxTest() {
addTests(&BoxTest::applyTransformation); addTests({&BoxTest::applyTransformation});
} }
void BoxTest::applyTransformation() { void BoxTest::applyTransformation() {

4
src/Physics/Test/CapsuleTest.cpp
Unescape View File

@ -31,8 +31,8 @@ class CapsuleTest: public Corrade::TestSuite::Tester, ShapeTestBase {
}; };
CapsuleTest::CapsuleTest() { CapsuleTest::CapsuleTest() {
addTests(&CapsuleTest::applyTransformation, addTests({&CapsuleTest::applyTransformation,
&CapsuleTest::collisionPoint); &CapsuleTest::collisionPoint});
} }
void CapsuleTest::applyTransformation() { void CapsuleTest::applyTransformation() {

2
src/Physics/Test/LineTest.cpp
Unescape View File

@ -28,7 +28,7 @@ class LineTest: public Corrade::TestSuite::Tester {
}; };
LineTest::LineTest() { LineTest::LineTest() {
addTests(&LineTest::applyTransformation); addTests({&LineTest::applyTransformation});
} }
void LineTest::applyTransformation() { void LineTest::applyTransformation() {

4
src/Physics/Test/ObjectShapeTest.cpp
Unescape View File

@ -36,8 +36,8 @@ typedef SceneGraph::Scene<SceneGraph::MatrixTransformation3D<>> Scene3D;
typedef SceneGraph::Object<SceneGraph::MatrixTransformation3D<>> Object3D; typedef SceneGraph::Object<SceneGraph::MatrixTransformation3D<>> Object3D;
ObjectShapeTest::ObjectShapeTest() { ObjectShapeTest::ObjectShapeTest() {
addTests(&ObjectShapeTest::clean, addTests({&ObjectShapeTest::clean,
&ObjectShapeTest::firstCollision); &ObjectShapeTest::firstCollision});
} }
void ObjectShapeTest::clean() { void ObjectShapeTest::clean() {

6
src/Physics/Test/PlaneTest.cpp
Unescape View File

@ -31,9 +31,9 @@ class PlaneTest: public Corrade::TestSuite::Tester, ShapeTestBase {
}; };
PlaneTest::PlaneTest() { PlaneTest::PlaneTest() {
addTests(&PlaneTest::applyTransformation, addTests({&PlaneTest::applyTransformation,
&PlaneTest::collisionLine, &PlaneTest::collisionLine,
&PlaneTest::collisionLineSegment); &PlaneTest::collisionLineSegment});
} }
void PlaneTest::applyTransformation() { void PlaneTest::applyTransformation() {

2
src/Physics/Test/PointTest.cpp
Unescape View File

@ -28,7 +28,7 @@ class PointTest: public Corrade::TestSuite::Tester {
}; };
PointTest::PointTest() { PointTest::PointTest() {
addTests(&PointTest::applyTransformation); addTests({&PointTest::applyTransformation});
} }
void PointTest::applyTransformation() { void PointTest::applyTransformation() {

4
src/Physics/Test/ShapeGroupTest.cpp
Unescape View File

@ -31,8 +31,8 @@ class ShapeGroupTest: public Corrade::TestSuite::Tester {
}; };
ShapeGroupTest::ShapeGroupTest() { ShapeGroupTest::ShapeGroupTest() {
addTests(&ShapeGroupTest::copy, addTests({&ShapeGroupTest::copy,
&ShapeGroupTest::reference); &ShapeGroupTest::reference});
} }
void ShapeGroupTest::copy() { void ShapeGroupTest::copy() {

10
src/Physics/Test/SphereTest.cpp
Unescape View File

@ -33,11 +33,11 @@ class SphereTest: public Corrade::TestSuite::Tester, ShapeTestBase {
}; };
SphereTest::SphereTest() { SphereTest::SphereTest() {
addTests(&SphereTest::applyTransformation, addTests({&SphereTest::applyTransformation,
&SphereTest::collisionPoint, &SphereTest::collisionPoint,
&SphereTest::collisionLine, &SphereTest::collisionLine,
&SphereTest::collisionLineSegment, &SphereTest::collisionLineSegment,
&SphereTest::collisionSphere); &SphereTest::collisionSphere});
} }
void SphereTest::applyTransformation() { void SphereTest::applyTransformation() {

4
src/Primitives/Test/CapsuleTest.cpp
Unescape View File

@ -35,8 +35,8 @@ class CapsuleTest: public Corrade::TestSuite::Tester {
}; };
CapsuleTest::CapsuleTest() { CapsuleTest::CapsuleTest() {
addTests(&CapsuleTest::withoutTextureCoords, addTests({&CapsuleTest::withoutTextureCoords,
&CapsuleTest::withTextureCoords); &CapsuleTest::withTextureCoords});
} }
void CapsuleTest::withoutTextureCoords() { void CapsuleTest::withoutTextureCoords() {

4
src/Primitives/Test/CylinderTest.cpp
Unescape View File

@ -32,8 +32,8 @@ class CylinderTest: public Corrade::TestSuite::Tester {
}; };
CylinderTest::CylinderTest() { CylinderTest::CylinderTest() {
addTests(&CylinderTest::withoutAnything, addTests({&CylinderTest::withoutAnything,
&CylinderTest::withTextureCoordsAndCaps); &CylinderTest::withTextureCoordsAndCaps});
} }
void CylinderTest::withoutAnything() { void CylinderTest::withoutAnything() {

4
src/Primitives/Test/UVSphereTest.cpp
Unescape View File

@ -32,8 +32,8 @@ class UVSphereTest: public Corrade::TestSuite::Tester {
}; };
UVSphereTest::UVSphereTest() { UVSphereTest::UVSphereTest() {
addTests(&UVSphereTest::withoutTextureCoords, addTests({&UVSphereTest::withoutTextureCoords,
&UVSphereTest::withTextureCoords); &UVSphereTest::withTextureCoords});
} }
void UVSphereTest::withoutTextureCoords() { void UVSphereTest::withoutTextureCoords() {

15
src/SceneGraph/Test/AnimableTest.cpp
Unescape View File

@ -39,13 +39,14 @@ class AnimableTest: public Corrade::TestSuite::Tester {
typedef SceneGraph::Object<SceneGraph::MatrixTransformation3D<>> Object3D; typedef SceneGraph::Object<SceneGraph::MatrixTransformation3D<>> Object3D;
AnimableTest::AnimableTest() { AnimableTest::AnimableTest() {
addTests(&AnimableTest::state, addTests({&AnimableTest::state,
&AnimableTest::step, &AnimableTest::step,
&AnimableTest::duration, &AnimableTest::duration,
&AnimableTest::repeat, &AnimableTest::repeat,
&AnimableTest::stop, &AnimableTest::stop,
&AnimableTest::pause, &AnimableTest::pause,
&AnimableTest::debug);
&AnimableTest::debug});
} }
void AnimableTest::state() { void AnimableTest::state() {

16
src/SceneGraph/Test/CameraTest.cpp
Unescape View File

@ -46,14 +46,14 @@ typedef SceneGraph::Camera2D<> Camera2D;
typedef SceneGraph::Camera3D<> Camera3D; typedef SceneGraph::Camera3D<> Camera3D;
CameraTest::CameraTest() { CameraTest::CameraTest() {
addTests(&CameraTest::fixAspectRatio, addTests({&CameraTest::fixAspectRatio,
&CameraTest::defaultProjection2D, &CameraTest::defaultProjection2D,
&CameraTest::defaultProjection3D, &CameraTest::defaultProjection3D,
&CameraTest::projectionSize2D, &CameraTest::projectionSize2D,
&CameraTest::projectionSizeOrthographic, &CameraTest::projectionSizeOrthographic,
&CameraTest::projectionSizePerspective, &CameraTest::projectionSizePerspective,
&CameraTest::projectionSizeViewport, &CameraTest::projectionSizeViewport,
&CameraTest::draw); &CameraTest::draw});
} }
void CameraTest::fixAspectRatio() { void CameraTest::fixAspectRatio() {

20
src/SceneGraph/Test/EuclideanMatrixTransformation2DTest.cpp
Unescape View File

@ -40,16 +40,16 @@ class EuclideanMatrixTransformation2DTest: public Corrade::TestSuite::Tester {
}; };
EuclideanMatrixTransformation2DTest::EuclideanMatrixTransformation2DTest() { EuclideanMatrixTransformation2DTest::EuclideanMatrixTransformation2DTest() {
addTests(&EuclideanMatrixTransformation2DTest::fromMatrix, addTests({&EuclideanMatrixTransformation2DTest::fromMatrix,
&EuclideanMatrixTransformation2DTest::toMatrix, &EuclideanMatrixTransformation2DTest::toMatrix,
&EuclideanMatrixTransformation2DTest::compose, &EuclideanMatrixTransformation2DTest::compose,
&EuclideanMatrixTransformation2DTest::inverted, &EuclideanMatrixTransformation2DTest::inverted,
&EuclideanMatrixTransformation2DTest::setTransformation, &EuclideanMatrixTransformation2DTest::setTransformation,
&EuclideanMatrixTransformation2DTest::translate, &EuclideanMatrixTransformation2DTest::translate,
&EuclideanMatrixTransformation2DTest::rotate, &EuclideanMatrixTransformation2DTest::rotate,
&EuclideanMatrixTransformation2DTest::reflect, &EuclideanMatrixTransformation2DTest::reflect,
&EuclideanMatrixTransformation2DTest::normalizeRotation); &EuclideanMatrixTransformation2DTest::normalizeRotation});
} }
void EuclideanMatrixTransformation2DTest::fromMatrix() { void EuclideanMatrixTransformation2DTest::fromMatrix() {

20
src/SceneGraph/Test/EuclideanMatrixTransformation3DTest.cpp
Unescape View File

@ -40,16 +40,16 @@ class EuclideanMatrixTransformation3DTest: public Corrade::TestSuite::Tester {
}; };
EuclideanMatrixTransformation3DTest::EuclideanMatrixTransformation3DTest() { EuclideanMatrixTransformation3DTest::EuclideanMatrixTransformation3DTest() {
addTests(&EuclideanMatrixTransformation3DTest::fromMatrix, addTests({&EuclideanMatrixTransformation3DTest::fromMatrix,
&EuclideanMatrixTransformation3DTest::toMatrix, &EuclideanMatrixTransformation3DTest::toMatrix,
&EuclideanMatrixTransformation3DTest::compose, &EuclideanMatrixTransformation3DTest::compose,
&EuclideanMatrixTransformation3DTest::inverted, &EuclideanMatrixTransformation3DTest::inverted,
&EuclideanMatrixTransformation3DTest::setTransformation, &EuclideanMatrixTransformation3DTest::setTransformation,
&EuclideanMatrixTransformation3DTest::translate, &EuclideanMatrixTransformation3DTest::translate,
&EuclideanMatrixTransformation3DTest::rotate, &EuclideanMatrixTransformation3DTest::rotate,
&EuclideanMatrixTransformation3DTest::reflect, &EuclideanMatrixTransformation3DTest::reflect,
&EuclideanMatrixTransformation3DTest::normalizeRotation); &EuclideanMatrixTransformation3DTest::normalizeRotation});
} }
void EuclideanMatrixTransformation3DTest::fromMatrix() { void EuclideanMatrixTransformation3DTest::fromMatrix() {

22
src/SceneGraph/Test/MatrixTransformation2DTest.cpp
Unescape View File

@ -41,17 +41,17 @@ class MatrixTransformation2DTest: public Corrade::TestSuite::Tester {
}; };
MatrixTransformation2DTest::MatrixTransformation2DTest() { MatrixTransformation2DTest::MatrixTransformation2DTest() {
addTests(&MatrixTransformation2DTest::fromMatrix, addTests({&MatrixTransformation2DTest::fromMatrix,
&MatrixTransformation2DTest::toMatrix, &MatrixTransformation2DTest::toMatrix,
&MatrixTransformation2DTest::compose, &MatrixTransformation2DTest::compose,
&MatrixTransformation2DTest::inverted, &MatrixTransformation2DTest::inverted,
&MatrixTransformation2DTest::setTransformation, &MatrixTransformation2DTest::setTransformation,
&MatrixTransformation2DTest::transform, &MatrixTransformation2DTest::transform,
&MatrixTransformation2DTest::translate, &MatrixTransformation2DTest::translate,
&MatrixTransformation2DTest::rotate, &MatrixTransformation2DTest::rotate,
&MatrixTransformation2DTest::scale, &MatrixTransformation2DTest::scale,
&MatrixTransformation2DTest::reflect); &MatrixTransformation2DTest::reflect});
} }
void MatrixTransformation2DTest::fromMatrix() { void MatrixTransformation2DTest::fromMatrix() {

22
src/SceneGraph/Test/MatrixTransformation3DTest.cpp
Unescape View File

@ -41,17 +41,17 @@ class MatrixTransformation3DTest: public Corrade::TestSuite::Tester {
}; };
MatrixTransformation3DTest::MatrixTransformation3DTest() { MatrixTransformation3DTest::MatrixTransformation3DTest() {
addTests(&MatrixTransformation3DTest::fromMatrix, addTests({&MatrixTransformation3DTest::fromMatrix,
&MatrixTransformation3DTest::toMatrix, &MatrixTransformation3DTest::toMatrix,
&MatrixTransformation3DTest::compose, &MatrixTransformation3DTest::compose,
&MatrixTransformation3DTest::inverted, &MatrixTransformation3DTest::inverted,
&MatrixTransformation3DTest::setTransformation, &MatrixTransformation3DTest::setTransformation,
&MatrixTransformation3DTest::transform, &MatrixTransformation3DTest::transform,
&MatrixTransformation3DTest::translate, &MatrixTransformation3DTest::translate,
&MatrixTransformation3DTest::rotate, &MatrixTransformation3DTest::rotate,
&MatrixTransformation3DTest::scale, &MatrixTransformation3DTest::scale,
&MatrixTransformation3DTest::reflect); &MatrixTransformation3DTest::reflect});
} }
void MatrixTransformation3DTest::fromMatrix() { void MatrixTransformation3DTest::fromMatrix() {

18
src/SceneGraph/Test/ObjectTest.cpp
Unescape View File

@ -54,15 +54,15 @@ class CachingObject: public Object3D, AbstractFeature<3> {
}; };
ObjectTest::ObjectTest() { ObjectTest::ObjectTest() {
addTests(&ObjectTest::parenting, addTests({&ObjectTest::parenting,
&ObjectTest::scene, &ObjectTest::scene,
&ObjectTest::absoluteTransformation, &ObjectTest::absoluteTransformation,
&ObjectTest::transformations, &ObjectTest::transformations,
&ObjectTest::transformationsRelative, &ObjectTest::transformationsRelative,
&ObjectTest::transformationsOrphan, &ObjectTest::transformationsOrphan,
&ObjectTest::transformationsDuplicate, &ObjectTest::transformationsDuplicate,
&ObjectTest::setClean, &ObjectTest::setClean,
&ObjectTest::bulkSetClean); &ObjectTest::bulkSetClean});
} }
void ObjectTest::parenting() { void ObjectTest::parenting() {

4
src/SceneGraph/Test/SceneTest.cpp
Unescape View File

@ -32,8 +32,8 @@ typedef SceneGraph::Scene<SceneGraph::MatrixTransformation3D<Float>> Scene3D;
typedef SceneGraph::Object<SceneGraph::MatrixTransformation3D<Float>> Object3D; typedef SceneGraph::Object<SceneGraph::MatrixTransformation3D<Float>> Object3D;
SceneTest::SceneTest() { SceneTest::SceneTest() {
addTests(&SceneTest::transformation, addTests({&SceneTest::transformation,
&SceneTest::parent); &SceneTest::parent});
} }
void SceneTest::transformation() { void SceneTest::transformation() {

4
src/Test/AbstractImageTest.cpp
Unescape View File

@ -29,8 +29,8 @@ class AbstractImageTest: public Corrade::TestSuite::Tester {
}; };
AbstractImageTest::AbstractImageTest() { AbstractImageTest::AbstractImageTest() {
addTests(&AbstractImageTest::debugFormat, addTests({&AbstractImageTest::debugFormat,
&AbstractImageTest::debugType); &AbstractImageTest::debugType});
} }
void AbstractImageTest::debugFormat() { void AbstractImageTest::debugFormat() {

28
src/Test/AbstractShaderProgramTest.cpp
Unescape View File

@ -40,20 +40,20 @@ class AbstractShaderProgramTest: public Corrade::TestSuite::Tester {
}; };
AbstractShaderProgramTest::AbstractShaderProgramTest() { AbstractShaderProgramTest::AbstractShaderProgramTest() {
addTests(&AbstractShaderProgramTest::attributeScalar, addTests({&AbstractShaderProgramTest::attributeScalar,
&AbstractShaderProgramTest::attributeScalarInt, &AbstractShaderProgramTest::attributeScalarInt,
&AbstractShaderProgramTest::attributeScalarUnsignedInt, &AbstractShaderProgramTest::attributeScalarUnsignedInt,
&AbstractShaderProgramTest::attributeScalarDouble, &AbstractShaderProgramTest::attributeScalarDouble,
&AbstractShaderProgramTest::attributeVector, &AbstractShaderProgramTest::attributeVector,
&AbstractShaderProgramTest::attributeVectorInt, &AbstractShaderProgramTest::attributeVectorInt,
&AbstractShaderProgramTest::attributeVectorUnsignedInt, &AbstractShaderProgramTest::attributeVectorUnsignedInt,
&AbstractShaderProgramTest::attributeVectorDouble, &AbstractShaderProgramTest::attributeVectorDouble,
&AbstractShaderProgramTest::attributeVector4, &AbstractShaderProgramTest::attributeVector4,
&AbstractShaderProgramTest::attributeVectorBGRA, &AbstractShaderProgramTest::attributeVectorBGRA,
&AbstractShaderProgramTest::attributeMatrix, &AbstractShaderProgramTest::attributeMatrix,
&AbstractShaderProgramTest::attributeMatrixDouble); &AbstractShaderProgramTest::attributeMatrixDouble});
} }
void AbstractShaderProgramTest::attributeScalar() { void AbstractShaderProgramTest::attributeScalar() {

8
src/Test/ArrayTest.cpp
Unescape View File

@ -34,10 +34,10 @@ typedef Magnum::Array2D<int> Array2D;
typedef Magnum::Array3D<int> Array3D; typedef Magnum::Array3D<int> Array3D;
ArrayTest::ArrayTest() { ArrayTest::ArrayTest() {
addTests(&ArrayTest::construct, addTests({&ArrayTest::construct,
&ArrayTest::constexprConstruct, &ArrayTest::constexprConstruct,
&ArrayTest::equality, &ArrayTest::equality,
&ArrayTest::access); &ArrayTest::access});
} }
void ArrayTest::construct() { void ArrayTest::construct() {

24
src/Test/ColorTest.cpp
Unescape View File

@ -49,22 +49,22 @@ typedef Magnum::Color3<Float> Color3f;
typedef Magnum::Color4<Float> Color4f; typedef Magnum::Color4<Float> Color4f;
ColorTest::ColorTest() { ColorTest::ColorTest() {
addTests(&ColorTest::access, addTests({&ColorTest::access,
&ColorTest::fromHue, &ColorTest::fromHue,
&ColorTest::fromSaturation, &ColorTest::fromSaturation,
&ColorTest::fromValue, &ColorTest::fromValue,
&ColorTest::hue, &ColorTest::hue,
&ColorTest::saturation, &ColorTest::saturation,
&ColorTest::value, &ColorTest::value,
&ColorTest::hsv, &ColorTest::hsv,
&ColorTest::hsvOverflow, &ColorTest::hsvOverflow,
&ColorTest::hsvAlpha, &ColorTest::hsvAlpha,
&ColorTest::debug, &ColorTest::debug,
&ColorTest::configuration); &ColorTest::configuration});
} }
void ColorTest::access() { void ColorTest::access() {

8
src/Test/MeshTest.cpp
Unescape View File

@ -32,10 +32,10 @@ class MeshTest: public Corrade::TestSuite::Tester {
}; };
MeshTest::MeshTest() { MeshTest::MeshTest() {
addTests(&MeshTest::debugPrimitive, addTests({&MeshTest::debugPrimitive,
&MeshTest::debugIndexType, &MeshTest::debugIndexType,
&MeshTest::configurationPrimitive, &MeshTest::configurationPrimitive,
&MeshTest::configurationIndexType); &MeshTest::configurationIndexType});
} }
void MeshTest::debugPrimitive() { void MeshTest::debugPrimitive() {

16
src/Test/ResourceManagerTest.cpp
Unescape View File

@ -62,14 +62,14 @@ class IntResourceLoader: public AbstractResourceLoader<Int> {
size_t Data::count = 0; size_t Data::count = 0;
ResourceManagerTest::ResourceManagerTest() { ResourceManagerTest::ResourceManagerTest() {
addTests(&ResourceManagerTest::state, addTests({&ResourceManagerTest::state,
&ResourceManagerTest::stateFallback, &ResourceManagerTest::stateFallback,
&ResourceManagerTest::stateDisallowed, &ResourceManagerTest::stateDisallowed,
&ResourceManagerTest::basic, &ResourceManagerTest::basic,
&ResourceManagerTest::residentPolicy, &ResourceManagerTest::residentPolicy,
&ResourceManagerTest::referenceCountedPolicy, &ResourceManagerTest::referenceCountedPolicy,
&ResourceManagerTest::manualPolicy, &ResourceManagerTest::manualPolicy,
&ResourceManagerTest::loader); &ResourceManagerTest::loader});
} }
void ResourceManagerTest::state() { void ResourceManagerTest::state() {

6
src/Test/SwizzleTest.cpp
Unescape View File

@ -29,9 +29,9 @@ class SwizzleTest: public Corrade::TestSuite::Tester {
}; };
SwizzleTest::SwizzleTest() { SwizzleTest::SwizzleTest() {
addTests(&SwizzleTest::rgba, addTests({&SwizzleTest::rgba,
&SwizzleTest::type, &SwizzleTest::type,
&SwizzleTest::defaultType); &SwizzleTest::defaultType});
} }
void SwizzleTest::rgba() { void SwizzleTest::rgba() {

8
src/TextureTools/Test/AtlasTest.cpp
Unescape View File

@ -32,10 +32,10 @@ class AtlasTest: public Corrade::TestSuite::Tester {
}; };
AtlasTest::AtlasTest() { AtlasTest::AtlasTest() {
addTests(&AtlasTest::create, addTests({&AtlasTest::create,
&AtlasTest::createPadding, &AtlasTest::createPadding,
&AtlasTest::createEmpty, &AtlasTest::createEmpty,
&AtlasTest::createTooSmall); &AtlasTest::createTooSmall});
} }
void AtlasTest::create() { void AtlasTest::create() {

12
src/Trade/AbstractImporter.h
Unescape View File

@ -20,7 +20,7 @@
*/ */
#include <Containers/EnumSet.h> #include <Containers/EnumSet.h>
#include <PluginManager/Plugin.h> #include <PluginManager/AbstractPlugin.h>
#include "Trade/Trade.h" #include "Trade/Trade.h"
@ -44,7 +44,7 @@ be done in data parsing functions, because the user might want to import only
some data. This is obviously not the case for single-data formats like images, some data. This is obviously not the case for single-data formats like images,
as the file contains all data user wants to import. as the file contains all data user wants to import.
*/ */
class MAGNUM_EXPORT AbstractImporter: public Corrade::PluginManager::Plugin { class MAGNUM_EXPORT AbstractImporter: public Corrade::PluginManager::AbstractPlugin {
PLUGIN_INTERFACE("cz.mosra.magnum.Trade.AbstractImporter/0.2") PLUGIN_INTERFACE("cz.mosra.magnum.Trade.AbstractImporter/0.2")
public: public:
@ -61,9 +61,11 @@ class MAGNUM_EXPORT AbstractImporter: public Corrade::PluginManager::Plugin {
/** @brief Set of features supported by this importer */ /** @brief Set of features supported by this importer */
typedef Corrade::Containers::EnumSet<Feature, int> Features; typedef Corrade::Containers::EnumSet<Feature, int> Features;
/** @brief Constructor */ /** @brief Default constructor */
/* GCC 4.6 can't handle {} as default parameter */ inline explicit AbstractImporter() = default;
inline explicit AbstractImporter(Corrade::PluginManager::AbstractPluginManager* manager = nullptr, const std::string& plugin = std::string()): Plugin(manager, plugin) {}
/** @brief Plugin manager constructor */
inline explicit AbstractImporter(Corrade::PluginManager::AbstractPluginManager* manager, std::string plugin): AbstractPlugin(manager, std::move(plugin)) {}
/** @brief Features supported by this importer */ /** @brief Features supported by this importer */
virtual Features features() const = 0; virtual Features features() const = 0;

2
src/Trade/Test/ObjectData2DTest.cpp
Unescape View File

@ -28,7 +28,7 @@ class ObjectData2DTest: public Corrade::TestSuite::Tester {
}; };
ObjectData2DTest::ObjectData2DTest() { ObjectData2DTest::ObjectData2DTest() {
addTests(&ObjectData2DTest::debug); addTests({&ObjectData2DTest::debug});
} }
void ObjectData2DTest::debug() { void ObjectData2DTest::debug() {

2
src/Trade/Test/ObjectData3DTest.cpp
Unescape View File

@ -28,7 +28,7 @@ class ObjectData3DTest: public Corrade::TestSuite::Tester {
}; };
ObjectData3DTest::ObjectData3DTest() { ObjectData3DTest::ObjectData3DTest() {
addTests(&ObjectData3DTest::debug); addTests({&ObjectData3DTest::debug});
} }
void ObjectData3DTest::debug() { void ObjectData3DTest::debug() {

Write Preview
Loading…
Cancel
Save