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

Primitives: port tests and related tools away from MeshDataXD. 

Improving the tests a bit for trivial primitives to ensure the attribute
layouts are correct, not just counts.
pull/371/head
Vladimír Vondruš 6 years ago
parent
c8de337c06
commit
a68946df5b
16 changed files with 488 additions and 359 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 204
      doc/generated/primitives.cpp
  2. 15
      doc/generated/shaders.cpp
  3. 31
      src/Magnum/Primitives/Test/AxisTest.cpp
  4. 49
      src/Magnum/Primitives/Test/CapsuleTest.cpp
  5. 57
      src/Magnum/Primitives/Test/CircleTest.cpp
  6. 71
      src/Magnum/Primitives/Test/ConeTest.cpp
  7. 21
      src/Magnum/Primitives/Test/CrosshairTest.cpp
  8. 37
      src/Magnum/Primitives/Test/CubeTest.cpp
  9. 71
      src/Magnum/Primitives/Test/CylinderTest.cpp
  10. 68
      src/Magnum/Primitives/Test/GradientTest.cpp
  11. 39
      src/Magnum/Primitives/Test/GridTest.cpp
  12. 51
      src/Magnum/Primitives/Test/IcosphereTest.cpp
  13. 21
      src/Magnum/Primitives/Test/LineTest.cpp
  14. 40
      src/Magnum/Primitives/Test/PlaneTest.cpp
  15. 34
      src/Magnum/Primitives/Test/SquareTest.cpp
  16. 38
      src/Magnum/Primitives/Test/UVSphereTest.cpp

204
doc/generated/primitives.cpp
Unescape View File

@ -76,8 +76,7 @@
#include <Magnum/Shaders/VertexColor.h>
#include <Magnum/Trade/AbstractImageConverter.h>
#include <Magnum/Trade/ImageData.h>
#include <Magnum/Trade/MeshData2D.h>
#include <Magnum/Trade/MeshData3D.h>
#include <Magnum/Trade/MeshData.h>
#include <Magnum/Trade/AbstractImporter.h>
using namespace Magnum;
@ -93,46 +92,46 @@ struct PrimitiveVisualizer: Platform::WindowlessApplication {
int exec() override;
std::pair<Trade::MeshData2D, std::string> axis2D();
std::pair<Trade::MeshData3D, std::string> axis3D();
std::pair<Trade::MeshData2D, std::string> capsule2DWireframe();
std::pair<Trade::MeshData2D, std::string> circle2DWireframe();
std::pair<Trade::MeshData2D, std::string> crosshair2D();
std::pair<Trade::MeshData2D, std::string> line2D();
std::pair<Trade::MeshData2D, std::string> squareWireframe();
std::pair<Trade::MeshData3D, std::string> capsule3DWireframe();
std::pair<Trade::MeshData3D, std::string> circle3DWireframe();
std::pair<Trade::MeshData3D, std::string> crosshair3D();
std::pair<Trade::MeshData3D, std::string> coneWireframe();
std::pair<Trade::MeshData3D, std::string> cubeWireframe();
std::pair<Trade::MeshData3D, std::string> cylinderWireframe();
std::pair<Trade::MeshData3D, std::string> grid3DWireframe();
std::pair<Trade::MeshData3D, std::string> line3D();
std::pair<Trade::MeshData3D, std::string> planeWireframe();
std::pair<Trade::MeshData3D, std::string> uvSphereWireframe();
std::pair<Trade::MeshData2D, std::string> circle2DSolid();
std::pair<Trade::MeshData2D, std::string> squareSolid();
std::pair<Trade::MeshData3D, std::string> capsule3DSolid();
std::pair<Trade::MeshData3D, std::string> circle3DSolid();
std::pair<Trade::MeshData3D, std::string> coneSolid();
std::pair<Trade::MeshData3D, std::string> cubeSolid();
std::pair<Trade::MeshData3D, std::string> cylinderSolid();
std::pair<Trade::MeshData3D, std::string> grid3DSolid();
std::pair<Trade::MeshData3D, std::string> icosphereSolid();
std::pair<Trade::MeshData3D, std::string> planeSolid();
std::pair<Trade::MeshData3D, std::string> uvSphereSolid();
std::pair<Trade::MeshData2D, std::string> gradient2D();
std::pair<Trade::MeshData2D, std::string> gradient2DHorizontal();
std::pair<Trade::MeshData2D, std::string> gradient2DVertical();
std::pair<Trade::MeshData3D, std::string> gradient3D();
std::pair<Trade::MeshData3D, std::string> gradient3DHorizontal();
std::pair<Trade::MeshData3D, std::string> gradient3DVertical();
std::pair<Trade::MeshData, std::string> axis2D();
std::pair<Trade::MeshData, std::string> axis3D();
std::pair<Trade::MeshData, std::string> capsule2DWireframe();
std::pair<Trade::MeshData, std::string> circle2DWireframe();
std::pair<Trade::MeshData, std::string> crosshair2D();
std::pair<Trade::MeshData, std::string> line2D();
std::pair<Trade::MeshData, std::string> squareWireframe();
std::pair<Trade::MeshData, std::string> capsule3DWireframe();
std::pair<Trade::MeshData, std::string> circle3DWireframe();
std::pair<Trade::MeshData, std::string> crosshair3D();
std::pair<Trade::MeshData, std::string> coneWireframe();
std::pair<Trade::MeshData, std::string> cubeWireframe();
std::pair<Trade::MeshData, std::string> cylinderWireframe();
std::pair<Trade::MeshData, std::string> grid3DWireframe();
std::pair<Trade::MeshData, std::string> line3D();
std::pair<Trade::MeshData, std::string> planeWireframe();
std::pair<Trade::MeshData, std::string> uvSphereWireframe();
std::pair<Trade::MeshData, std::string> circle2DSolid();
std::pair<Trade::MeshData, std::string> squareSolid();
std::pair<Trade::MeshData, std::string> capsule3DSolid();
std::pair<Trade::MeshData, std::string> circle3DSolid();
std::pair<Trade::MeshData, std::string> coneSolid();
std::pair<Trade::MeshData, std::string> cubeSolid();
std::pair<Trade::MeshData, std::string> cylinderSolid();
std::pair<Trade::MeshData, std::string> grid3DSolid();
std::pair<Trade::MeshData, std::string> icosphereSolid();
std::pair<Trade::MeshData, std::string> planeSolid();
std::pair<Trade::MeshData, std::string> uvSphereSolid();
std::pair<Trade::MeshData, std::string> gradient2D();
std::pair<Trade::MeshData, std::string> gradient2DHorizontal();
std::pair<Trade::MeshData, std::string> gradient2DVertical();
std::pair<Trade::MeshData, std::string> gradient3D();
std::pair<Trade::MeshData, std::string> gradient3DHorizontal();
std::pair<Trade::MeshData, std::string> gradient3DVertical();
};
namespace {
@ -191,7 +190,7 @@ int PrimitiveVisualizer::exec() {
multisampleFramebuffer.clear(GL::FramebufferClear::Color|GL::FramebufferClear::Depth);
std::string filename;
Containers::Optional<Trade::MeshData2D> data;
Containers::Optional<Trade::MeshData> data;
std::tie(data, filename) = (this->*fun)();
MeshTools::compile(*data).draw(shader);
@ -210,7 +209,7 @@ int PrimitiveVisualizer::exec() {
multisampleFramebuffer.clear(GL::FramebufferClear::Color|GL::FramebufferClear::Depth);
std::string filename;
Containers::Optional<Trade::MeshData3D> data;
Containers::Optional<Trade::MeshData> data;
std::tie(data, filename) = (this->*fun)();
MeshTools::compile(*data).draw(shader);
@ -235,7 +234,7 @@ int PrimitiveVisualizer::exec() {
multisampleFramebuffer.clear(GL::FramebufferClear::Color|GL::FramebufferClear::Depth);
std::string filename;
Containers::Optional<Trade::MeshData2D> data;
Containers::Optional<Trade::MeshData> data;
std::tie(data, filename) = (this->*fun)();
MeshTools::compile(*data).draw(shader);
@ -265,7 +264,7 @@ int PrimitiveVisualizer::exec() {
multisampleFramebuffer.clear(GL::FramebufferClear::Color|GL::FramebufferClear::Depth);
std::string filename;
Containers::Optional<Trade::MeshData3D> data;
Containers::Optional<Trade::MeshData> data;
std::tie(data, filename) = (this->*fun)();
MeshTools::compile(*data).draw(shader);
@ -299,18 +298,12 @@ int PrimitiveVisualizer::exec() {
multisampleFramebuffer.clear(GL::FramebufferClear::Color|GL::FramebufferClear::Depth);
std::string filename;
Containers::Optional<Trade::MeshData2D> data;
Containers::Optional<Trade::MeshData> data;
std::tie(data, filename) = (this->*fun)();
/* TODO: use MeshTools::compile() and MeshVisualizer2D once it exists */
GL::Buffer vertices;
vertices.setData(data->positions(0), GL::BufferUsage::StaticDraw);
GL::Mesh mesh;
mesh.addVertexBuffer(vertices, 0, Shaders::MeshVisualizer::Position{Shaders::MeshVisualizer::Position::Components::Two})
.setCount(data->positions(0).size())
.setPrimitive(data->primitive());
mesh.draw(flat)
/* TODO: use MeshVisualizer2D once it exists */
MeshTools::compile(*data)
.draw(flat)
.draw(wireframe2D);
GL::AbstractFramebuffer::blit(multisampleFramebuffer, framebuffer, framebuffer.viewport(), GL::FramebufferBlit::Color);
@ -349,7 +342,7 @@ int PrimitiveVisualizer::exec() {
multisampleFramebuffer.clear(GL::FramebufferClear::Color|GL::FramebufferClear::Depth);
std::string filename;
Containers::Optional<Trade::MeshData3D> data;
Containers::Optional<Trade::MeshData> data;
std::tie(data, filename) = (this->*fun)();
MeshTools::compile(*data)
@ -372,7 +365,7 @@ int PrimitiveVisualizer::exec() {
multisampleFramebuffer.clear(GL::FramebufferClear::Color|GL::FramebufferClear::Depth);
std::string filename;
Containers::Optional<Trade::MeshData2D> data;
Containers::Optional<Trade::MeshData> data;
std::tie(data, filename) = (this->*fun)();
MeshTools::compile(*data)
@ -395,7 +388,7 @@ int PrimitiveVisualizer::exec() {
multisampleFramebuffer.clear(GL::FramebufferClear::Color|GL::FramebufferClear::Depth);
std::string filename;
Containers::Optional<Trade::MeshData3D> data;
Containers::Optional<Trade::MeshData> data;
std::tie(data, filename) = (this->*fun)();
MeshTools::compile(*data)
@ -411,11 +404,11 @@ int PrimitiveVisualizer::exec() {
return 0;
}
std::pair<Trade::MeshData2D, std::string> PrimitiveVisualizer::axis2D() {
std::pair<Trade::MeshData, std::string> PrimitiveVisualizer::axis2D() {
return {Primitives::axis2D(), "axis2d.png"};
}
std::pair<Trade::MeshData2D, std::string> PrimitiveVisualizer::gradient2D() {
std::pair<Trade::MeshData, std::string> PrimitiveVisualizer::gradient2D() {
return {Primitives::gradient2D({1.0f, -2.0f}, 0x2f83cc_srgbf, {-1.0f, 2.0f}, 0x3bd267_srgbf), "gradient2d.png"};
}
@ -426,142 +419,147 @@ namespace {
const Color3 Gradient80Percent = Math::lerp(0x2f83cc_srgbf, 0x3bd267_srgbf, 0.8f);
}
std::pair<Trade::MeshData2D, std::string> PrimitiveVisualizer::gradient2DHorizontal() {
std::pair<Trade::MeshData, std::string> PrimitiveVisualizer::gradient2DHorizontal() {
return {Primitives::gradient2DHorizontal(Gradient20Percent, Gradient80Percent), "gradient2dhorizontal.png"};
}
std::pair<Trade::MeshData2D, std::string> PrimitiveVisualizer::gradient2DVertical() {
std::pair<Trade::MeshData, std::string> PrimitiveVisualizer::gradient2DVertical() {
/* End colors are 20%/80% blends of the above to match the range */
return {Primitives::gradient2DVertical(Gradient20Percent, Gradient80Percent), "gradient2dvertical.png"};
}
std::pair<Trade::MeshData3D, std::string> PrimitiveVisualizer::axis3D() {
std::pair<Trade::MeshData, std::string> PrimitiveVisualizer::axis3D() {
return {Primitives::axis3D(), "axis3d.png"};
}
std::pair<Trade::MeshData3D, std::string> PrimitiveVisualizer::gradient3D() {
std::pair<Trade::MeshData, std::string> PrimitiveVisualizer::gradient3D() {
return {Primitives::gradient3D({1.0f, -2.0f, -1.5f}, 0x2f83cc_srgbf, {-1.0f, 2.0f, -1.5f}, 0x3bd267_srgbf), "gradient3d.png"};
}
std::pair<Trade::MeshData3D, std::string> PrimitiveVisualizer::gradient3DHorizontal() {
std::pair<Trade::MeshData, std::string> PrimitiveVisualizer::gradient3DHorizontal() {
return {Primitives::gradient3DHorizontal(Gradient20Percent, Gradient80Percent), "gradient3dhorizontal.png"};
}
std::pair<Trade::MeshData3D, std::string> PrimitiveVisualizer::gradient3DVertical() {
std::pair<Trade::MeshData, std::string> PrimitiveVisualizer::gradient3DVertical() {
return {Primitives::gradient3DVertical(Gradient20Percent, Gradient80Percent), "gradient3dvertical.png"};
}
std::pair<Trade::MeshData2D, std::string> PrimitiveVisualizer::capsule2DWireframe() {
Trade::MeshData2D capsule = Primitives::capsule2DWireframe(8, 1, 0.75f);
MeshTools::transformPointsInPlace(Matrix3::scaling(Vector2{0.75f}), capsule.positions(0));
std::pair<Trade::MeshData, std::string> PrimitiveVisualizer::capsule2DWireframe() {
Trade::MeshData capsule = Primitives::capsule2DWireframe(8, 1, 0.75f);
MeshTools::transformPointsInPlace(Matrix3::scaling(Vector2{0.75f}),
capsule.mutableAttribute<Vector2>(Trade::MeshAttribute::Position));
return {std::move(capsule), "capsule2dwireframe.png"};
}
std::pair<Trade::MeshData2D, std::string> PrimitiveVisualizer::circle2DWireframe() {
std::pair<Trade::MeshData, std::string> PrimitiveVisualizer::circle2DWireframe() {
return {Primitives::circle2DWireframe(32), "circle2dwireframe.png"};
}
std::pair<Trade::MeshData2D, std::string> PrimitiveVisualizer::crosshair2D() {
std::pair<Trade::MeshData, std::string> PrimitiveVisualizer::crosshair2D() {
return {Primitives::crosshair2D(), "crosshair2d.png"};
}
std::pair<Trade::MeshData2D, std::string> PrimitiveVisualizer::line2D() {
Trade::MeshData2D line = Primitives::line2D();
MeshTools::transformPointsInPlace(Matrix3::translation(Vector2::xAxis(-1.0f))*Matrix3::scaling(Vector2::xScale(2.0f)), line.positions(0));
std::pair<Trade::MeshData, std::string> PrimitiveVisualizer::line2D() {
Trade::MeshData line = Primitives::line2D();
MeshTools::transformPointsInPlace(Matrix3::translation(Vector2::xAxis(-1.0f))*Matrix3::scaling(Vector2::xScale(2.0f)),
line.mutableAttribute<Vector2>(Trade::MeshAttribute::Position));
return {std::move(line), "line2d.png"};
}
std::pair<Trade::MeshData2D, std::string> PrimitiveVisualizer::squareWireframe() {
std::pair<Trade::MeshData, std::string> PrimitiveVisualizer::squareWireframe() {
return {Primitives::squareWireframe(), "squarewireframe.png"};
}
std::pair<Trade::MeshData3D, std::string> PrimitiveVisualizer::capsule3DWireframe() {
Trade::MeshData3D capsule = Primitives::capsule3DWireframe(8, 1, 16, 1.0f);
MeshTools::transformPointsInPlace(Matrix4::scaling(Vector3{0.75f}), capsule.positions(0));
std::pair<Trade::MeshData, std::string> PrimitiveVisualizer::capsule3DWireframe() {
Trade::MeshData capsule = Primitives::capsule3DWireframe(8, 1, 16, 1.0f);
MeshTools::transformPointsInPlace(Matrix4::scaling(Vector3{0.75f}),
capsule.mutableAttribute<Vector3>(Trade::MeshAttribute::Position));
return {std::move(capsule), "capsule3dwireframe.png"};
}
std::pair<Trade::MeshData3D, std::string> PrimitiveVisualizer::circle3DWireframe() {
std::pair<Trade::MeshData, std::string> PrimitiveVisualizer::circle3DWireframe() {
return {Primitives::circle3DWireframe(32), "circle3dwireframe.png"};
}
std::pair<Trade::MeshData3D, std::string> PrimitiveVisualizer::crosshair3D() {
std::pair<Trade::MeshData, std::string> PrimitiveVisualizer::crosshair3D() {
return {Primitives::crosshair3D(), "crosshair3d.png"};
}
std::pair<Trade::MeshData3D, std::string> PrimitiveVisualizer::coneWireframe() {
std::pair<Trade::MeshData, std::string> PrimitiveVisualizer::coneWireframe() {
return {Primitives::coneWireframe(32, 1.25f), "conewireframe.png"};
}
std::pair<Trade::MeshData3D, std::string> PrimitiveVisualizer::cubeWireframe() {
std::pair<Trade::MeshData, std::string> PrimitiveVisualizer::cubeWireframe() {
return {Primitives::cubeWireframe(), "cubewireframe.png"};
}
std::pair<Trade::MeshData3D, std::string> PrimitiveVisualizer::cylinderWireframe() {
std::pair<Trade::MeshData, std::string> PrimitiveVisualizer::cylinderWireframe() {
return {Primitives::cylinderWireframe(1, 32, 1.0f), "cylinderwireframe.png"};
}
std::pair<Trade::MeshData3D, std::string> PrimitiveVisualizer::grid3DWireframe() {
std::pair<Trade::MeshData, std::string> PrimitiveVisualizer::grid3DWireframe() {
return {Primitives::grid3DWireframe({5, 3}), "grid3dwireframe.png"};
}
std::pair<Trade::MeshData3D, std::string> PrimitiveVisualizer::line3D() {
Trade::MeshData3D line = Primitives::line3D();
MeshTools::transformPointsInPlace(Matrix4::translation(Vector3::xAxis(-1.0f))*Matrix4::scaling(Vector3::xScale(2.0f)), line.positions(0));
std::pair<Trade::MeshData, std::string> PrimitiveVisualizer::line3D() {
Trade::MeshData line = Primitives::line3D();
MeshTools::transformPointsInPlace(Matrix4::translation(Vector3::xAxis(-1.0f))*Matrix4::scaling(Vector3::xScale(2.0f)),
line.mutableAttribute<Vector3>(Trade::MeshAttribute::Position));
return {std::move(line), "line3d.png"};
}
std::pair<Trade::MeshData3D, std::string> PrimitiveVisualizer::planeWireframe() {
std::pair<Trade::MeshData, std::string> PrimitiveVisualizer::planeWireframe() {
return {Primitives::planeWireframe(), "planewireframe.png"};
}
std::pair<Trade::MeshData3D, std::string> PrimitiveVisualizer::uvSphereWireframe() {
std::pair<Trade::MeshData, std::string> PrimitiveVisualizer::uvSphereWireframe() {
return {Primitives::uvSphereWireframe(16, 32), "uvspherewireframe.png"};
}
std::pair<Trade::MeshData2D, std::string> PrimitiveVisualizer::circle2DSolid() {
std::pair<Trade::MeshData, std::string> PrimitiveVisualizer::circle2DSolid() {
return {Primitives::circle2DSolid(16), "circle2dsolid.png"};
}
std::pair<Trade::MeshData2D, std::string> PrimitiveVisualizer::squareSolid() {
std::pair<Trade::MeshData, std::string> PrimitiveVisualizer::squareSolid() {
return {Primitives::squareSolid(), "squaresolid.png"};
}
std::pair<Trade::MeshData3D, std::string> PrimitiveVisualizer::capsule3DSolid() {
Trade::MeshData3D capsule = Primitives::capsule3DSolid(4, 1, 12, 0.75f);
MeshTools::transformPointsInPlace(Matrix4::scaling(Vector3{0.75f}), capsule.positions(0));
std::pair<Trade::MeshData, std::string> PrimitiveVisualizer::capsule3DSolid() {
Trade::MeshData capsule = Primitives::capsule3DSolid(4, 1, 12, 0.75f);
MeshTools::transformPointsInPlace(Matrix4::scaling(Vector3{0.75f}),
capsule.mutableAttribute<Vector3>(Trade::MeshAttribute::Position));
return {std::move(capsule), "capsule3dsolid.png"};
}
std::pair<Trade::MeshData3D, std::string> PrimitiveVisualizer::circle3DSolid() {
std::pair<Trade::MeshData, std::string> PrimitiveVisualizer::circle3DSolid() {
return {Primitives::circle3DSolid(16), "circle3dsolid.png"};
}
std::pair<Trade::MeshData3D, std::string> PrimitiveVisualizer::coneSolid() {
std::pair<Trade::MeshData, std::string> PrimitiveVisualizer::coneSolid() {
return {Primitives::coneSolid(1, 12, 1.25f, Primitives::ConeFlag::CapEnd), "conesolid.png"};
}
std::pair<Trade::MeshData3D, std::string> PrimitiveVisualizer::cubeSolid() {
std::pair<Trade::MeshData, std::string> PrimitiveVisualizer::cubeSolid() {
return {Primitives::cubeSolid(), "cubesolid.png"};
}
std::pair<Trade::MeshData3D, std::string> PrimitiveVisualizer::cylinderSolid() {
std::pair<Trade::MeshData, std::string> PrimitiveVisualizer::cylinderSolid() {
return {Primitives::cylinderSolid(1, 12, 1.0f, Primitives::CylinderFlag::CapEnds), "cylindersolid.png"};
}
std::pair<Trade::MeshData3D, std::string> PrimitiveVisualizer::grid3DSolid() {
std::pair<Trade::MeshData, std::string> PrimitiveVisualizer::grid3DSolid() {
return {Primitives::grid3DSolid({5, 3}), "grid3dsolid.png"};
}
std::pair<Trade::MeshData3D, std::string> PrimitiveVisualizer::icosphereSolid() {
std::pair<Trade::MeshData, std::string> PrimitiveVisualizer::icosphereSolid() {
return {Primitives::icosphereSolid(1), "icospheresolid.png"};
}
std::pair<Trade::MeshData3D, std::string> PrimitiveVisualizer::planeSolid() {
std::pair<Trade::MeshData, std::string> PrimitiveVisualizer::planeSolid() {
return {Primitives::planeSolid(), "planesolid.png"};
}
std::pair<Trade::MeshData3D, std::string> PrimitiveVisualizer::uvSphereSolid() {
std::pair<Trade::MeshData, std::string> PrimitiveVisualizer::uvSphereSolid() {
return {Primitives::uvSphereSolid(8, 16), "uvspheresolid.png"};
}

15
doc/generated/shaders.cpp
Unescape View File

@ -66,8 +66,7 @@
#include <Magnum/Shaders/DistanceFieldVector.h>
#include <Magnum/Trade/AbstractImageConverter.h>
#include <Magnum/Trade/ImageData.h>
#include <Magnum/Trade/MeshData2D.h>
#include <Magnum/Trade/MeshData3D.h>
#include <Magnum/Trade/MeshData.h>
#include <Magnum/Trade/AbstractImporter.h>
using namespace Magnum;
@ -192,22 +191,22 @@ std::string ShaderVisualizer::flat() {
}
std::string ShaderVisualizer::vertexColor() {
Trade::MeshData3D sphere = Primitives::uvSphereSolid(32, 64);
Trade::MeshData sphere = Primitives::uvSphereSolid(32, 64);
/* Color vertices nearest to given position */
auto target = Vector3{2.0f, 2.0f, 7.0f}.normalized();
std::vector<Color3> colors;
colors.reserve(sphere.positions(0).size());
for(Vector3 position: sphere.positions(0))
colors.reserve(sphere.vertexCount());
for(Vector3 position: sphere.attribute<Vector3>(Trade::MeshAttribute::Position))
colors.push_back(Color3::fromHsv({Math::lerp(240.0_degf, 420.0_degf, Math::max(1.0f - (position - target).length(), 0.0f)), 0.85f, 0.666f}));
GL::Buffer vertices, indices;
vertices.setData(MeshTools::interleave(sphere.positions(0), colors), GL::BufferUsage::StaticDraw);
indices.setData(sphere.indices(), GL::BufferUsage::StaticDraw);
vertices.setData(MeshTools::interleave(sphere.attribute<Vector3>(Trade::MeshAttribute::Position), colors), GL::BufferUsage::StaticDraw);
indices.setData(sphere.indices<UnsignedInt>(), GL::BufferUsage::StaticDraw);
GL::Mesh mesh;
mesh.setPrimitive(GL::MeshPrimitive::Triangles)
.setCount(sphere.indices().size())
.setCount(sphere.indexCount())
.addVertexBuffer(vertices, 0,
Shaders::VertexColor3D::Position{},
Shaders::VertexColor3D::Color3{})

31
src/Magnum/Primitives/Test/AxisTest.cpp
Unescape View File

@ -28,8 +28,7 @@
#include "Magnum/Mesh.h"
#include "Magnum/Math/Color.h"
#include "Magnum/Primitives/Axis.h"
#include "Magnum/Trade/MeshData2D.h"
#include "Magnum/Trade/MeshData3D.h"
#include "Magnum/Trade/MeshData.h"
namespace Magnum { namespace Primitives { namespace Test { namespace {
@ -46,21 +45,33 @@ AxisTest::AxisTest() {
}
void AxisTest::twoDimensions() {
Trade::MeshData2D axis = Primitives::axis2D();
Trade::MeshData axis = Primitives::axis2D();
CORRADE_COMPARE(axis.primitive(), MeshPrimitive::Lines);
CORRADE_COMPARE(axis.indices().size(), 12);
CORRADE_COMPARE(axis.positions(0).size(), 8);
CORRADE_COMPARE(axis.colors(0).size(), 8);
CORRADE_VERIFY(axis.isIndexed());
CORRADE_COMPARE(axis.indexCount(), 12);
CORRADE_COMPARE(axis.vertexCount(), 8);
CORRADE_COMPARE(axis.attributeCount(), 2);
CORRADE_COMPARE(axis.indices<UnsignedShort>()[5], 3);
CORRADE_COMPARE(axis.attribute<Vector2>(Trade::MeshAttribute::Position)[3],
(Vector2{0.9f, -0.1f}));
CORRADE_COMPARE(axis.attribute<Color3>(Trade::MeshAttribute::Color)[6],
(Color3{0.0f, 1.0f, 0.0f}));
}
void AxisTest::threeDimensions() {
Trade::MeshData3D axis = Primitives::axis3D();
Trade::MeshData axis = Primitives::axis3D();
CORRADE_COMPARE(axis.primitive(), MeshPrimitive::Lines);
CORRADE_COMPARE(axis.indices().size(), 18);
CORRADE_COMPARE(axis.positions(0).size(), 12);
CORRADE_COMPARE(axis.colors(0).size(), 12);
CORRADE_VERIFY(axis.isIndexed());
CORRADE_COMPARE(axis.indexCount(), 18);
CORRADE_COMPARE(axis.vertexCount(), 12);
CORRADE_COMPARE(axis.attributeCount(), 2);
CORRADE_COMPARE(axis.indices<UnsignedShort>()[12], 8);
CORRADE_COMPARE(axis.attribute<Vector3>(Trade::MeshAttribute::Position)[6],
(Vector3{0.1f, 0.9f, 0.0f}));
CORRADE_COMPARE(axis.attribute<Color3>(Trade::MeshAttribute::Color)[4],
(Color3{0.0f, 1.0f, 0.0f}));
}
}}}}

49
src/Magnum/Primitives/Test/CapsuleTest.cpp
Unescape View File

@ -27,8 +27,7 @@
#include <Corrade/TestSuite/Compare/Container.h>
#include "Magnum/Math/Vector3.h"
#include "Magnum/Trade/MeshData2D.h"
#include "Magnum/Trade/MeshData3D.h"
#include "Magnum/Trade/MeshData.h"
#include "Magnum/Primitives/Capsule.h"
namespace Magnum { namespace Primitives { namespace Test { namespace {
@ -51,9 +50,13 @@ CapsuleTest::CapsuleTest() {
}
void CapsuleTest::wireframe2D() {
Trade::MeshData2D capsule = capsule2DWireframe(2, 4, 0.5f);
Trade::MeshData capsule = capsule2DWireframe(2, 4, 0.5f);
CORRADE_COMPARE_AS(capsule.positions(0), (std::vector<Vector2>{
CORRADE_COMPARE(capsule.primitive(), MeshPrimitive::Lines);
CORRADE_VERIFY(capsule.isIndexed());
CORRADE_COMPARE(capsule.attributeCount(), 1);
CORRADE_COMPARE_AS(capsule.attribute<Vector2>(Trade::MeshAttribute::Position), Containers::arrayView<Vector2>({
{0.0f, -1.5f},
{-0.707107f, -1.20711f},
@ -80,7 +83,7 @@ void CapsuleTest::wireframe2D() {
{0.0f, 1.5f}
}), TestSuite::Compare::Container);
CORRADE_COMPARE_AS(capsule.indices(), (std::vector<UnsignedInt>{
CORRADE_COMPARE_AS(capsule.indices<UnsignedInt>(), Containers::arrayView<UnsignedInt>({
0, 1, 0, 2,
1, 3, 2, 4,
@ -95,9 +98,13 @@ void CapsuleTest::wireframe2D() {
}
void CapsuleTest::solid3DWithoutTextureCoords() {
Trade::MeshData3D capsule = capsule3DSolid(2, 4, 3, 0.5f);
Trade::MeshData capsule = capsule3DSolid(2, 4, 3, 0.5f);
CORRADE_COMPARE(capsule.primitive(), MeshPrimitive::Triangles);
CORRADE_VERIFY(capsule.isIndexed());
CORRADE_COMPARE(capsule.attributeCount(), 2);
CORRADE_COMPARE_AS(capsule.positions(0), (std::vector<Vector3>{
CORRADE_COMPARE_AS(capsule.attribute<Vector3>(Trade::MeshAttribute::Position), Containers::arrayView<Vector3>({
{0.0f, -1.5f, 0.0f},
{0.0f, -1.20711f, 0.707107f},
@ -131,7 +138,7 @@ void CapsuleTest::solid3DWithoutTextureCoords() {
{0.0f, 1.5f, 0.0f}
}), TestSuite::Compare::Container);
CORRADE_COMPARE_AS(capsule.normals(0), (std::vector<Vector3>{
CORRADE_COMPARE_AS(capsule.attribute<Vector3>(Trade::MeshAttribute::Normal), Containers::arrayView<Vector3>({
{0.0f, -1.0f, 0.0f},
{0.0f, -0.707107f, 0.707107f},
@ -165,7 +172,7 @@ void CapsuleTest::solid3DWithoutTextureCoords() {
{0.0f, 1.0f, 0.0f}
}), TestSuite::Compare::Container);
CORRADE_COMPARE_AS(capsule.indices(), (std::vector<UnsignedInt>{
CORRADE_COMPARE_AS(capsule.indices<UnsignedInt>(), Containers::arrayView<UnsignedInt>({
0, 2, 1, 0, 3, 2, 0, 1, 3,
1, 2, 5, 1, 5, 4, 2, 3, 6, 2, 6, 5, 3, 1, 4, 3, 4, 6,
4, 5, 8, 4, 8, 7, 5, 6, 9, 5, 9, 8, 6, 4, 7, 6, 7, 9,
@ -178,9 +185,13 @@ void CapsuleTest::solid3DWithoutTextureCoords() {
}
void CapsuleTest::solid3DWithTextureCoords() {
Trade::MeshData3D capsule = capsule3DSolid(2, 2, 3, 0.5f, CapsuleTextureCoords::Generate);
Trade::MeshData capsule = capsule3DSolid(2, 2, 3, 0.5f, CapsuleTextureCoords::Generate);
CORRADE_COMPARE(capsule.primitive(), MeshPrimitive::Triangles);
CORRADE_VERIFY(capsule.isIndexed());
CORRADE_COMPARE(capsule.attributeCount(), 3);
CORRADE_COMPARE_AS(capsule.positions(0), (std::vector<Vector3>{
CORRADE_COMPARE_AS(capsule.attribute<Vector3>(Trade::MeshAttribute::Position), Containers::arrayView<Vector3>({
{0.0f, -1.5f, 0.0f},
{0.0f, -1.20711f, 0.707107f},
@ -211,7 +222,7 @@ void CapsuleTest::solid3DWithTextureCoords() {
{0.0f, 1.5f, 0.0f}
}), TestSuite::Compare::Container);
CORRADE_COMPARE_AS(capsule.textureCoords2D(0), (std::vector<Vector2>{
CORRADE_COMPARE_AS(capsule.attribute<Vector2>(Trade::MeshAttribute::TextureCoordinates), Containers::arrayView<Vector2>({
{0.5f, 0.0f},
{0.0f, 0.166667f},
@ -242,7 +253,7 @@ void CapsuleTest::solid3DWithTextureCoords() {
{0.5f, 1.0f}
}), TestSuite::Compare::Container);
CORRADE_COMPARE_AS(capsule.indices(), (std::vector<UnsignedInt>{
CORRADE_COMPARE_AS(capsule.indices<UnsignedInt>(), Containers::arrayView<UnsignedInt>({
0, 2, 1, 0, 3, 2, 0, 4, 3,
1, 2, 6, 1, 6, 5, 2, 3, 7, 2, 7, 6, 3, 4, 8, 3, 8, 7,
5, 6, 10, 5, 10, 9, 6, 7, 11, 6, 11, 10, 7, 8, 12, 7, 12, 11,
@ -253,9 +264,13 @@ void CapsuleTest::solid3DWithTextureCoords() {
}
void CapsuleTest::wireframe3D() {
Trade::MeshData3D capsule = capsule3DWireframe(2, 2, 8, 0.5f);
Trade::MeshData capsule = capsule3DWireframe(2, 2, 8, 0.5f);
CORRADE_COMPARE_AS(capsule.positions(0), (std::vector<Vector3>{
CORRADE_COMPARE(capsule.primitive(), MeshPrimitive::Lines);
CORRADE_VERIFY(capsule.isIndexed());
CORRADE_COMPARE(capsule.attributeCount(), 1);
CORRADE_COMPARE_AS(capsule.attribute<Vector3>(Trade::MeshAttribute::Position), Containers::arrayView<Vector3>({
{0.0f, -1.5f, 0.0f},
{0.0f, -1.20711f, 0.707107f},
@ -298,9 +313,7 @@ void CapsuleTest::wireframe3D() {
{0.0f, 1.5f, 0.0f}
}), TestSuite::Compare::Container);
CORRADE_COMPARE(capsule.normalArrayCount(), 0);
CORRADE_COMPARE_AS(capsule.indices(), (std::vector<UnsignedInt>{
CORRADE_COMPARE_AS(capsule.indices<UnsignedInt>(), Containers::arrayView<UnsignedInt>({
0, 1, 0, 2, 0, 3, 0, 4,
1, 5, 2, 6, 3, 7, 4, 8,
5, 9, 6, 10, 7, 11, 8, 12,

57
src/Magnum/Primitives/Test/CircleTest.cpp
Unescape View File

@ -29,8 +29,7 @@
#include "Magnum/Mesh.h"
#include "Magnum/Math/Vector3.h"
#include "Magnum/Primitives/Circle.h"
#include "Magnum/Trade/MeshData2D.h"
#include "Magnum/Trade/MeshData3D.h"
#include "Magnum/Trade/MeshData.h"
namespace Magnum { namespace Primitives { namespace Test { namespace {
@ -59,11 +58,12 @@ CircleTest::CircleTest() {
}
void CircleTest::solid2D() {
Trade::MeshData2D circle = Primitives::circle2DSolid(8);
Trade::MeshData circle = Primitives::circle2DSolid(8);
CORRADE_VERIFY(!circle.isIndexed());
CORRADE_COMPARE(circle.primitive(), MeshPrimitive::TriangleFan);
CORRADE_COMPARE_AS(circle.positions(0), (std::vector<Vector2>{
CORRADE_VERIFY(!circle.isIndexed());
CORRADE_COMPARE(circle.attributeCount(), 1);
CORRADE_COMPARE_AS(circle.attribute<Vector2>(Trade::MeshAttribute::Position), Containers::arrayView<Vector2>({
{ 0.0f, 0.0f},
{ 1.0f, 0.0f}, { Constants::sqrt2()/2.0f, Constants::sqrt2()/2.0f},
{ 0.0f, 1.0f}, {-Constants::sqrt2()/2.0f, Constants::sqrt2()/2.0f},
@ -71,15 +71,15 @@ void CircleTest::solid2D() {
{ 0.0f, -1.0f}, { Constants::sqrt2()/2.0f, -Constants::sqrt2()/2.0f},
{ 1.0f, 0.0f}
}), TestSuite::Compare::Container);
CORRADE_COMPARE(circle.textureCoords2DArrayCount(), 0);
}
void CircleTest::solid2DTextureCoords() {
Trade::MeshData2D circle = Primitives::circle2DSolid(8, Primitives::CircleTextureCoords::Generate);
Trade::MeshData circle = Primitives::circle2DSolid(8, Primitives::CircleTextureCoords::Generate);
CORRADE_VERIFY(!circle.isIndexed());
CORRADE_COMPARE(circle.primitive(), MeshPrimitive::TriangleFan);
CORRADE_COMPARE_AS(circle.positions(0), (std::vector<Vector2>{
CORRADE_VERIFY(!circle.isIndexed());
CORRADE_COMPARE(circle.attributeCount(), 2);
CORRADE_COMPARE_AS(circle.attribute<Vector2>(Trade::MeshAttribute::Position), Containers::arrayView<Vector2>({
{ 0.0f, 0.0f},
{ 1.0f, 0.0f}, { Constants::sqrt2()/2.0f, Constants::sqrt2()/2.0f},
{ 0.0f, 1.0f}, {-Constants::sqrt2()/2.0f, Constants::sqrt2()/2.0f},
@ -87,8 +87,7 @@ void CircleTest::solid2DTextureCoords() {
{ 0.0f, -1.0f}, { Constants::sqrt2()/2.0f, -Constants::sqrt2()/2.0f},
{ 1.0f, 0.0f}
}), TestSuite::Compare::Container);
CORRADE_COMPARE(circle.textureCoords2DArrayCount(), 1);
CORRADE_COMPARE_AS(circle.textureCoords2D(0), (std::vector<Vector2>{
CORRADE_COMPARE_AS(circle.attribute<Vector2>(Trade::MeshAttribute::TextureCoordinates), Containers::arrayView<Vector2>({
{0.5f, 0.5f},
{1.0f, 0.5f}, {0.5f + Constants::sqrt2()/4.0f, 0.5f + Constants::sqrt2()/4.0f},
{0.5f, 1.0f}, {0.5f - Constants::sqrt2()/4.0f, 0.5f + Constants::sqrt2()/4.0f},
@ -99,11 +98,12 @@ void CircleTest::solid2DTextureCoords() {
}
void CircleTest::solid3D() {
Trade::MeshData3D circle = Primitives::circle3DSolid(8);
Trade::MeshData circle = Primitives::circle3DSolid(8);
CORRADE_VERIFY(!circle.isIndexed());
CORRADE_COMPARE(circle.primitive(), MeshPrimitive::TriangleFan);
CORRADE_COMPARE_AS(circle.positions(0), (std::vector<Vector3>{
CORRADE_VERIFY(!circle.isIndexed());
CORRADE_COMPARE(circle.attributeCount(), 2);
CORRADE_COMPARE_AS(circle.attribute<Vector3>(Trade::MeshAttribute::Position), Containers::arrayView<Vector3>({
{ 0.0f, 0.0f, 0.0f},
{ 1.0f, 0.0f, 0.0f}, { Constants::sqrt2()/2.0f, Constants::sqrt2()/2.0f, 0.0f},
{ 0.0f, 1.0f, 0.0f}, {-Constants::sqrt2()/2.0f, Constants::sqrt2()/2.0f, 0.0f},
@ -111,7 +111,7 @@ void CircleTest::solid3D() {
{ 0.0f, -1.0f, 0.0f}, { Constants::sqrt2()/2.0f, -Constants::sqrt2()/2.0f, 0.0f},
{ 1.0f, 0.0f, 0.0f}
}), TestSuite::Compare::Container);
CORRADE_COMPARE_AS(circle.normals(0), (std::vector<Vector3>{
CORRADE_COMPARE_AS(circle.attribute<Vector3>(Trade::MeshAttribute::Normal), Containers::arrayView<Vector3>({
{ 0.0f, 0.0f, 1.0f},
{ 0.0f, 0.0f, 1.0f},
{ 0.0f, 0.0f, 1.0f},
@ -123,15 +123,15 @@ void CircleTest::solid3D() {
{ 0.0f, 0.0f, 1.0f},
{ 0.0f, 0.0f, 1.0f}
}), TestSuite::Compare::Container);
CORRADE_COMPARE(circle.textureCoords2DArrayCount(), 0);
}
void CircleTest::solid3DTextureCoords() {
Trade::MeshData3D circle = Primitives::circle3DSolid(8, Primitives::CircleTextureCoords::Generate);
Trade::MeshData circle = Primitives::circle3DSolid(8, Primitives::CircleTextureCoords::Generate);
CORRADE_VERIFY(!circle.isIndexed());
CORRADE_COMPARE(circle.primitive(), MeshPrimitive::TriangleFan);
CORRADE_COMPARE_AS(circle.positions(0), (std::vector<Vector3>{
CORRADE_VERIFY(!circle.isIndexed());
CORRADE_COMPARE(circle.attributeCount(), 3);
CORRADE_COMPARE_AS(circle.attribute<Vector3>(Trade::MeshAttribute::Position), Containers::arrayView<Vector3>({
{ 0.0f, 0.0f, 0.0f},
{ 1.0f, 0.0f, 0.0f}, { Constants::sqrt2()/2.0f, Constants::sqrt2()/2.0f, 0.0f},
{ 0.0f, 1.0f, 0.0f}, {-Constants::sqrt2()/2.0f, Constants::sqrt2()/2.0f, 0.0f},
@ -139,7 +139,7 @@ void CircleTest::solid3DTextureCoords() {
{ 0.0f, -1.0f, 0.0f}, { Constants::sqrt2()/2.0f, -Constants::sqrt2()/2.0f, 0.0f},
{ 1.0f, 0.0f, 0.0f}
}), TestSuite::Compare::Container);
CORRADE_COMPARE_AS(circle.normals(0), (std::vector<Vector3>{
CORRADE_COMPARE_AS(circle.attribute<Vector3>(Trade::MeshAttribute::Normal), Containers::arrayView<Vector3>({
{ 0.0f, 0.0f, 1.0f},
{ 0.0f, 0.0f, 1.0f},
{ 0.0f, 0.0f, 1.0f},
@ -151,8 +151,7 @@ void CircleTest::solid3DTextureCoords() {
{ 0.0f, 0.0f, 1.0f},
{ 0.0f, 0.0f, 1.0f}
}), TestSuite::Compare::Container);
CORRADE_COMPARE(circle.textureCoords2DArrayCount(), 1);
CORRADE_COMPARE_AS(circle.textureCoords2D(0), (std::vector<Vector2>{
CORRADE_COMPARE_AS(circle.attribute<Vector2>(Trade::MeshAttribute::TextureCoordinates), Containers::arrayView<Vector2>({
{0.5f, 0.5f},
{1.0f, 0.5f}, {0.5f + Constants::sqrt2()/4.0f, 0.5f + Constants::sqrt2()/4.0f},
{0.5f, 1.0f}, {0.5f - Constants::sqrt2()/4.0f, 0.5f + Constants::sqrt2()/4.0f},
@ -163,11 +162,12 @@ void CircleTest::solid3DTextureCoords() {
}
void CircleTest::wireframe2D() {
Trade::MeshData2D circle = Primitives::circle2DWireframe(8);
Trade::MeshData circle = Primitives::circle2DWireframe(8);
CORRADE_VERIFY(!circle.isIndexed());
CORRADE_COMPARE(circle.primitive(), MeshPrimitive::LineLoop);
CORRADE_COMPARE_AS(circle.positions(0), (std::vector<Vector2>{
CORRADE_VERIFY(!circle.isIndexed());
CORRADE_COMPARE(circle.attributeCount(), 1);
CORRADE_COMPARE_AS(circle.attribute<Vector2>(Trade::MeshAttribute::Position), Containers::arrayView<Vector2>({
{ 1.0f, 0.0f}, { Constants::sqrt2()/2.0f, Constants::sqrt2()/2.0f},
{ 0.0f, 1.0f}, {-Constants::sqrt2()/2.0f, Constants::sqrt2()/2.0f},
{-1.0f, 0.0f}, {-Constants::sqrt2()/2.0f, -Constants::sqrt2()/2.0f},
@ -176,11 +176,12 @@ void CircleTest::wireframe2D() {
}
void CircleTest::wireframe3D() {
Trade::MeshData3D circle = Primitives::circle3DWireframe(8);
Trade::MeshData circle = Primitives::circle3DWireframe(8);
CORRADE_VERIFY(!circle.isIndexed());
CORRADE_COMPARE(circle.primitive(), MeshPrimitive::LineLoop);
CORRADE_COMPARE_AS(circle.positions(0), (std::vector<Vector3>{
CORRADE_VERIFY(!circle.isIndexed());
CORRADE_COMPARE(circle.attributeCount(), 1);
CORRADE_COMPARE_AS(circle.attribute<Vector3>(Trade::MeshAttribute::Position), Containers::arrayView<Vector3>({
{ 1.0f, 0.0f, 0.0f}, { Constants::sqrt2()/2.0f, Constants::sqrt2()/2.0f, 0.0f},
{ 0.0f, 1.0f, 0.0f}, {-Constants::sqrt2()/2.0f, Constants::sqrt2()/2.0f, 0.0f},
{-1.0f, 0.0f, 0.0f}, {-Constants::sqrt2()/2.0f, -Constants::sqrt2()/2.0f, 0.0f},

71
src/Magnum/Primitives/Test/ConeTest.cpp
Unescape View File

@ -28,7 +28,7 @@
#include "Magnum/Math/Vector3.h"
#include "Magnum/Primitives/Cone.h"
#include "Magnum/Trade/MeshData3D.h"
#include "Magnum/Trade/MeshData.h"
namespace Magnum { namespace Primitives { namespace Test { namespace {
@ -51,9 +51,13 @@ ConeTest::ConeTest() {
}
void ConeTest::solidWithoutAnything() {
Trade::MeshData3D cone = coneSolid(2, 3, 1.0f);
Trade::MeshData cone = coneSolid(2, 3, 1.0f);
CORRADE_COMPARE_AS(cone.positions(0), (std::vector<Vector3>{
CORRADE_COMPARE(cone.primitive(), MeshPrimitive::Triangles);
CORRADE_VERIFY(cone.isIndexed());
CORRADE_COMPARE(cone.attributeCount(), 2);
CORRADE_COMPARE_AS(cone.attribute<Vector3>(Trade::MeshAttribute::Position), Containers::arrayView<Vector3>({
{0.0f, -1.0f, 1.0f}, /* 0 */
{0.866025f, -1.0f, -0.5f}, /* 1 */
{-0.866025f, -1.0f, -0.5f}, /* 2 */
@ -67,7 +71,7 @@ void ConeTest::solidWithoutAnything() {
{0.0f, 1.0f, 0.0f} /* 8 */
}), TestSuite::Compare::Container);
CORRADE_COMPARE_AS(cone.normals(0), (std::vector<Vector3>{
CORRADE_COMPARE_AS(cone.attribute<Vector3>(Trade::MeshAttribute::Normal), Containers::arrayView<Vector3>({
{0.0f, 0.447214f, 0.894427f}, /* 0 */
{0.774597f, 0.447214f, -0.447214f}, /* 1 */
{-0.774597f, 0.447214f, -0.447214f}, /* 2 */
@ -81,20 +85,22 @@ void ConeTest::solidWithoutAnything() {
{-0.774597f, 0.447214f, -0.447214f} /* 8 */
}), TestSuite::Compare::Container);
CORRADE_VERIFY(!cone.hasTextureCoords2D());
CORRADE_COMPARE_AS(cone.indices(), (std::vector<UnsignedInt>{
CORRADE_COMPARE_AS(cone.indices<UnsignedInt>(), Containers::arrayView<UnsignedInt>({
0, 1, 4, 0, 4, 3, 1, 2, 5, 1, 5, 4, 2, 0, 3, 2, 3, 5,
3, 4, 7, 3, 7, 6, 4, 5, 8, 4, 8, 7, 5, 3, 6, 5, 6, 8
}), TestSuite::Compare::Container);
}
void ConeTest::solidWithCaps() {
Trade::MeshData3D cone = coneSolid(2, 3, 1.0f, ConeFlag::CapEnd);
Trade::MeshData cone = coneSolid(2, 3, 1.0f, ConeFlag::CapEnd);
CORRADE_COMPARE(cone.primitive(), MeshPrimitive::Triangles);
CORRADE_VERIFY(cone.isIndexed());
CORRADE_COMPARE(cone.attributeCount(), 2);
/* Bottom ring duplicated because it has different normals, first vertex of
each ring duplicated because it has different texture coordinates */
CORRADE_COMPARE_AS(cone.positions(0), (std::vector<Vector3>{
CORRADE_COMPARE_AS(cone.attribute<Vector3>(Trade::MeshAttribute::Position), Containers::arrayView<Vector3>({
{0.0f, -1.0f, 0.0f}, /* 0 */
{0.0f, -1.0f, 1.0f}, /* 1 */
@ -114,7 +120,7 @@ void ConeTest::solidWithCaps() {
{0.0f, 1.0f, 0.0f}, /* 12 */
}), TestSuite::Compare::Container);
CORRADE_COMPARE_AS(cone.normals(0), (std::vector<Vector3>{
CORRADE_COMPARE_AS(cone.attribute<Vector3>(Trade::MeshAttribute::Normal), Containers::arrayView<Vector3>({
{0.0f, -1.0f, 0.0f}, /* 0 */
{0.0f, -1.0f, 0.0f}, /* 1 */
@ -134,11 +140,9 @@ void ConeTest::solidWithCaps() {
{-0.774597f, 0.447214f, -0.447214f}, /* 12 */
}), TestSuite::Compare::Container);
CORRADE_VERIFY(!cone.hasTextureCoords2D());
/* Faces of the caps and sides do not share any vertices due to different
normals */
CORRADE_COMPARE_AS(cone.indices(), (std::vector<UnsignedInt>{
CORRADE_COMPARE_AS(cone.indices<UnsignedInt>(), Containers::arrayView<UnsignedInt>({
0, 2, 1, 0, 3, 2, 0, 1, 3,
4, 5, 8, 4, 8, 7, 5, 6, 9, 5, 9, 8, 6, 4, 7, 6, 7, 9,
7, 8, 11, 7, 11, 10, 8, 9, 12, 8, 12, 11, 9, 7, 10, 9, 10, 12
@ -146,11 +150,15 @@ void ConeTest::solidWithCaps() {
}
void ConeTest::solidWithTextureCoords() {
Trade::MeshData3D cone = coneSolid(2, 3, 1.0f, ConeFlag::GenerateTextureCoords);
Trade::MeshData cone = coneSolid(2, 3, 1.0f, ConeFlag::GenerateTextureCoords);
CORRADE_COMPARE(cone.primitive(), MeshPrimitive::Triangles);
CORRADE_VERIFY(cone.isIndexed());
CORRADE_COMPARE(cone.attributeCount(), 3);
/* Bottom ring duplicated because it has different normals, first vertex of
each ring duplicated because it has different texture coordinates */
CORRADE_COMPARE_AS(cone.positions(0), (std::vector<Vector3>{
CORRADE_COMPARE_AS(cone.attribute<Vector3>(Trade::MeshAttribute::Position), Containers::arrayView<Vector3>({
{0.0f, -1.0f, 1.0f}, /* 0 */
{0.866025f, -1.0f, -0.5f}, /* 1 */
{-0.866025f, -1.0f, -0.5f}, /* 2 */
@ -167,7 +175,7 @@ void ConeTest::solidWithTextureCoords() {
{0.0f, 1.0f, 0.0f} /* 11 */
}), TestSuite::Compare::Container);
CORRADE_COMPARE_AS(cone.normals(0), (std::vector<Vector3>{
CORRADE_COMPARE_AS(cone.attribute<Vector3>(Trade::MeshAttribute::Normal), Containers::arrayView<Vector3>({
{0.0f, 0.447214f, 0.894427f}, /* 0 */
{0.774597f, 0.447214f, -0.447214f}, /* 1 */
{-0.774597f, 0.447214f, -0.447214f}, /* 2 */
@ -184,7 +192,7 @@ void ConeTest::solidWithTextureCoords() {
{0.0f, 0.447214f, 0.894427f} /* 11 */
}), TestSuite::Compare::Container);
CORRADE_COMPARE_AS(cone.textureCoords2D(0), (std::vector<Vector2>{
CORRADE_COMPARE_AS(cone.attribute<Vector2>(Trade::MeshAttribute::TextureCoordinates), Containers::arrayView<Vector2>({
{0.0f, 0.0f}, /* 0 */
{0.333333f, 0.0f}, /* 1 */
{0.666667f, 0.0f}, /* 2 */
@ -202,18 +210,22 @@ void ConeTest::solidWithTextureCoords() {
}), TestSuite::Compare::Container);
/* Each ring has an extra vertex for texture coords */
CORRADE_COMPARE_AS(cone.indices(), (std::vector<UnsignedInt>{
CORRADE_COMPARE_AS(cone.indices<UnsignedInt>(), Containers::arrayView<UnsignedInt>({
0, 1, 5, 0, 5, 4, 1, 2, 6, 1, 6, 5, 2, 3, 7, 2, 7, 6,
4, 5, 9, 4, 9, 8, 5, 6, 10, 5, 10, 9, 6, 7, 11, 6, 11, 10
}), TestSuite::Compare::Container);
}
void ConeTest::solidWithTextureCoordsAndCaps() {
Trade::MeshData3D cone = coneSolid(2, 3, 1.0f, ConeFlag::GenerateTextureCoords|ConeFlag::CapEnd);
Trade::MeshData cone = coneSolid(2, 3, 1.0f, ConeFlag::GenerateTextureCoords|ConeFlag::CapEnd);
CORRADE_COMPARE(cone.primitive(), MeshPrimitive::Triangles);
CORRADE_VERIFY(cone.isIndexed());
CORRADE_COMPARE(cone.attributeCount(), 3);
/* Bottom ring duplicated because it has different normals, first vertex of
each ring duplicated because it has different texture coordinates */
CORRADE_COMPARE_AS(cone.positions(0), (std::vector<Vector3>{
CORRADE_COMPARE_AS(cone.attribute<Vector3>(Trade::MeshAttribute::Position), Containers::arrayView<Vector3>({
{0.0f, -1.0f, 0.0f}, /* 0 */
{0.0f, -1.0f, 1.0f}, /* 1 */
@ -237,7 +249,7 @@ void ConeTest::solidWithTextureCoordsAndCaps() {
{0.0f, 1.0f, 0.0f} /* 16 */
}), TestSuite::Compare::Container);
CORRADE_COMPARE_AS(cone.normals(0), (std::vector<Vector3>{
CORRADE_COMPARE_AS(cone.attribute<Vector3>(Trade::MeshAttribute::Normal), Containers::arrayView<Vector3>({
{0.0f, -1.0f, 0.0f}, /* 0 */
{0.0f, -1.0f, 0.0f}, /* 1 */
@ -261,7 +273,7 @@ void ConeTest::solidWithTextureCoordsAndCaps() {
{0.0f, 0.447214f, 0.894427f} /* 16 */
}), TestSuite::Compare::Container);
CORRADE_COMPARE_AS(cone.textureCoords2D(0), (std::vector<Vector2>{
CORRADE_COMPARE_AS(cone.attribute<Vector2>(Trade::MeshAttribute::TextureCoordinates), Containers::arrayView<Vector2>({
{0.5f, 0.0f}, /* 0 */
{0.0f, 0.333333f}, /* 1 */
@ -287,7 +299,7 @@ void ConeTest::solidWithTextureCoordsAndCaps() {
/* Faces of the caps and sides do not share any vertices due to different
normals, each ring has an extra vertex for texture coords */
CORRADE_COMPARE_AS(cone.indices(), (std::vector<UnsignedInt>{
CORRADE_COMPARE_AS(cone.indices<UnsignedInt>(), Containers::arrayView<UnsignedInt>({
0, 2, 1, 0, 3, 2, 0, 4, 3,
5, 6, 10, 5, 10, 9, 6, 7, 11, 6, 11, 10, 7, 8, 12, 7, 12, 11,
9, 10, 14, 9, 14, 13, 10, 11, 15, 10, 15, 14, 11, 12, 16, 11, 16, 15
@ -295,9 +307,13 @@ void ConeTest::solidWithTextureCoordsAndCaps() {
}
void ConeTest::wireframe() {
Trade::MeshData3D cone = coneWireframe(8, 1.5f);
Trade::MeshData cone = coneWireframe(8, 1.5f);
CORRADE_COMPARE_AS(cone.positions(0), (std::vector<Vector3>{
CORRADE_COMPARE(cone.primitive(), MeshPrimitive::Lines);
CORRADE_VERIFY(cone.isIndexed());
CORRADE_COMPARE(cone.attributeCount(), 1);
CORRADE_COMPARE_AS(cone.attribute<Vector3>(Trade::MeshAttribute::Position), Containers::arrayView<Vector3>({
{0.0f, -1.5f, 1.0f}, /* 0 */
{1.0f, -1.5f, 0.0f}, /* 1 */
{0.0f, -1.5f, -1.0f}, /* 2 */
@ -310,10 +326,7 @@ void ConeTest::wireframe() {
{0.0f, 1.5f, 0.0f} /* 8 */
}), TestSuite::Compare::Container);
CORRADE_VERIFY(!cone.hasNormals());
CORRADE_VERIFY(!cone.hasTextureCoords2D());
CORRADE_COMPARE_AS(cone.indices(), (std::vector<UnsignedInt>{
CORRADE_COMPARE_AS(cone.indices<UnsignedInt>(), Containers::arrayView<UnsignedInt>({
0, 4, 1, 5, 2, 6, 3, 7,
4, 1, 5, 2, 6, 3, 7, 0,

21
src/Magnum/Primitives/Test/CrosshairTest.cpp
Unescape View File

@ -28,8 +28,7 @@
#include "Magnum/Mesh.h"
#include "Magnum/Math/Vector3.h"
#include "Magnum/Primitives/Crosshair.h"
#include "Magnum/Trade/MeshData2D.h"
#include "Magnum/Trade/MeshData3D.h"
#include "Magnum/Trade/MeshData.h"
namespace Magnum { namespace Primitives { namespace Test { namespace {
@ -46,19 +45,25 @@ CrosshairTest::CrosshairTest() {
}
void CrosshairTest::twoDimensions() {
Trade::MeshData2D crosshair = Primitives::crosshair2D();
Trade::MeshData crosshair = Primitives::crosshair2D();
CORRADE_VERIFY(!crosshair.isIndexed());
CORRADE_COMPARE(crosshair.primitive(), MeshPrimitive::Lines);
CORRADE_COMPARE(crosshair.positions(0).size(), 4);
CORRADE_VERIFY(!crosshair.isIndexed());
CORRADE_COMPARE(crosshair.vertexCount(), 4);
CORRADE_COMPARE(crosshair.attributeCount(), 1);
CORRADE_COMPARE(crosshair.attribute<Vector2>(Trade::MeshAttribute::Position)[3],
(Vector2{0.0f, 1.0f}));
}
void CrosshairTest::threeDimensions() {
Trade::MeshData3D crosshair = Primitives::crosshair3D();
Trade::MeshData crosshair = Primitives::crosshair3D();
CORRADE_VERIFY(!crosshair.isIndexed());
CORRADE_COMPARE(crosshair.primitive(), MeshPrimitive::Lines);
CORRADE_COMPARE(crosshair.positions(0).size(), 6);
CORRADE_VERIFY(!crosshair.isIndexed());
CORRADE_COMPARE(crosshair.vertexCount(), 6);
CORRADE_COMPARE(crosshair.attributeCount(), 1);
CORRADE_COMPARE(crosshair.attribute<Vector3>(Trade::MeshAttribute::Position)[4],
(Vector3{ 0.0f, 0.0f, -1.0f}));
}
}}}}

37
src/Magnum/Primitives/Test/CubeTest.cpp
Unescape View File

@ -28,7 +28,7 @@
#include "Magnum/Mesh.h"
#include "Magnum/Math/Vector3.h"
#include "Magnum/Primitives/Cube.h"
#include "Magnum/Trade/MeshData3D.h"
#include "Magnum/Trade/MeshData.h"
namespace Magnum { namespace Primitives { namespace Test { namespace {
@ -47,29 +47,42 @@ CubeTest::CubeTest() {
}
void CubeTest::solid() {
Trade::MeshData3D cube = Primitives::cubeSolid();
Trade::MeshData cube = Primitives::cubeSolid();
CORRADE_COMPARE(cube.primitive(), MeshPrimitive::Triangles);
CORRADE_COMPARE(cube.indices().size(), 36);
CORRADE_COMPARE(cube.positions(0).size(), 24);
CORRADE_COMPARE(cube.normals(0).size(), 24);
CORRADE_VERIFY(cube.isIndexed());
CORRADE_COMPARE(cube.indexCount(), 36);
CORRADE_COMPARE(cube.vertexCount(), 24);
CORRADE_COMPARE(cube.attributeCount(), 2);
CORRADE_COMPARE(cube.indices<UnsignedShort>()[17], 11);
CORRADE_COMPARE(cube.attribute<Vector3>(Trade::MeshAttribute::Position)[4],
(Vector3{1.0f, -1.0f, 1.0f}));
CORRADE_COMPARE(cube.attribute<Vector3>(Trade::MeshAttribute::Normal)[6],
(Vector3{1.0f, 0.0f, 0.0f}));
}
void CubeTest::solidStrip() {
Trade::MeshData3D cube = Primitives::cubeSolidStrip();
Trade::MeshData cube = Primitives::cubeSolidStrip();
CORRADE_VERIFY(!cube.isIndexed());
CORRADE_COMPARE(cube.primitive(), MeshPrimitive::TriangleStrip);
CORRADE_COMPARE(cube.positions(0).size(), 14);
CORRADE_COMPARE(cube.normalArrayCount(), 0);
CORRADE_VERIFY(!cube.isIndexed());
CORRADE_COMPARE(cube.vertexCount(), 14);
CORRADE_COMPARE(cube.attributeCount(), 1);
CORRADE_COMPARE(cube.attribute<Vector3>(Trade::MeshAttribute::Position)[4],
(Vector3{-1.0f, -1.0f, -1.0f}));
}
void CubeTest::wireframe() {
Trade::MeshData3D cube = Primitives::cubeWireframe();
Trade::MeshData cube = Primitives::cubeWireframe();
CORRADE_COMPARE(cube.primitive(), MeshPrimitive::Lines);
CORRADE_COMPARE(cube.indices().size(), 24);
CORRADE_COMPARE(cube.positions(0).size(), 8);
CORRADE_VERIFY(cube.isIndexed());
CORRADE_COMPARE(cube.indexCount(), 24);
CORRADE_COMPARE(cube.vertexCount(), 8);
CORRADE_COMPARE(cube.attributeCount(), 1);
CORRADE_COMPARE(cube.indices<UnsignedShort>()[5], 3);
CORRADE_COMPARE(cube.attribute<Vector3>(Trade::MeshAttribute::Position)[5],
(Vector3{1.0f, -1.0f, -1.0f}));
}
}}}}

71
src/Magnum/Primitives/Test/CylinderTest.cpp
Unescape View File

@ -28,7 +28,7 @@
#include "Magnum/Math/Vector3.h"
#include "Magnum/Primitives/Cylinder.h"
#include "Magnum/Trade/MeshData3D.h"
#include "Magnum/Trade/MeshData.h"
namespace Magnum { namespace Primitives { namespace Test { namespace {
@ -51,9 +51,13 @@ CylinderTest::CylinderTest() {
}
void CylinderTest::solidWithoutAnything() {
Trade::MeshData3D cylinder = cylinderSolid(2, 3, 1.5f);
Trade::MeshData cylinder = cylinderSolid(2, 3, 1.5f);
CORRADE_COMPARE_AS(cylinder.positions(0), (std::vector<Vector3>{
CORRADE_COMPARE(cylinder.primitive(), MeshPrimitive::Triangles);
CORRADE_VERIFY(cylinder.isIndexed());
CORRADE_COMPARE(cylinder.attributeCount(), 2);
CORRADE_COMPARE_AS(cylinder.attribute<Vector3>(Trade::MeshAttribute::Position), Containers::arrayView<Vector3>({
{0.0f, -1.5f, 1.0f}, /* 0 */
{0.866025f, -1.5f, -0.5f}, /* 1 */
{-0.866025f, -1.5f, -0.5f}, /* 2 */
@ -67,7 +71,7 @@ void CylinderTest::solidWithoutAnything() {
{-0.866025f, 1.5f, -0.5f} /* 8 */
}), TestSuite::Compare::Container);
CORRADE_COMPARE_AS(cylinder.normals(0), (std::vector<Vector3>{
CORRADE_COMPARE_AS(cylinder.attribute<Vector3>(Trade::MeshAttribute::Normal), Containers::arrayView<Vector3>({
{0.0f, 0.0f, 1.0f}, /* 0 */
{0.866025f, 0.0f, -0.5f}, /* 1 */
{-0.866025f, 0.0f, -0.5f}, /* 2 */
@ -81,20 +85,22 @@ void CylinderTest::solidWithoutAnything() {
{-0.866025f, 0.0f, -0.5f} /* 8 */
}), TestSuite::Compare::Container);
CORRADE_VERIFY(!cylinder.hasTextureCoords2D());
CORRADE_COMPARE_AS(cylinder.indices(), (std::vector<UnsignedInt>{
CORRADE_COMPARE_AS(cylinder.indices<UnsignedInt>(), Containers::arrayView<UnsignedInt>({
0, 1, 4, 0, 4, 3, 1, 2, 5, 1, 5, 4, 2, 0, 3, 2, 3, 5,
3, 4, 7, 3, 7, 6, 4, 5, 8, 4, 8, 7, 5, 3, 6, 5, 6, 8
}), TestSuite::Compare::Container);
}
void CylinderTest::solidWithCaps() {
Trade::MeshData3D cylinder = cylinderSolid(2, 3, 1.5f, CylinderFlag::CapEnds);
Trade::MeshData cylinder = cylinderSolid(2, 3, 1.5f, CylinderFlag::CapEnds);
CORRADE_COMPARE(cylinder.primitive(), MeshPrimitive::Triangles);
CORRADE_VERIFY(cylinder.isIndexed());
CORRADE_COMPARE(cylinder.attributeCount(), 2);
/* Bottom ring duplicated because it has different normals, first vertex of
each ring duplicated because it has different texture coordinates */
CORRADE_COMPARE_AS(cylinder.positions(0), (std::vector<Vector3>{
CORRADE_COMPARE_AS(cylinder.attribute<Vector3>(Trade::MeshAttribute::Position), Containers::arrayView<Vector3>({
{0.0f, -1.5f, 0.0f}, /* 0 */
{0.0f, -1.5f, 1.0f}, /* 1 */
@ -120,7 +126,7 @@ void CylinderTest::solidWithCaps() {
{0.0f, 1.5f, 0.0f} /* 16 */
}), TestSuite::Compare::Container);
CORRADE_COMPARE_AS(cylinder.normals(0), (std::vector<Vector3>{
CORRADE_COMPARE_AS(cylinder.attribute<Vector3>(Trade::MeshAttribute::Normal), Containers::arrayView<Vector3>({
{0.0f, -1.0f, 0.0f}, /* 0 */
{0.0f, -1.0f, 0.0f}, /* 1 */
@ -146,11 +152,9 @@ void CylinderTest::solidWithCaps() {
{0.0f, 1.0f, 0.0f}, /* 16 */
}), TestSuite::Compare::Container);
CORRADE_VERIFY(!cylinder.hasTextureCoords2D());
/* Faces of the caps and sides do not share any vertices due to different
normals */
CORRADE_COMPARE_AS(cylinder.indices(), (std::vector<UnsignedInt>{
CORRADE_COMPARE_AS(cylinder.indices<UnsignedInt>(), Containers::arrayView<UnsignedInt>({
0, 2, 1, 0, 3, 2, 0, 1, 3,
4, 5, 8, 4, 8, 7, 5, 6, 9, 5, 9, 8, 6, 4, 7, 6, 7, 9,
7, 8, 11, 7, 11, 10, 8, 9, 12, 8, 12, 11, 9, 7, 10, 9, 10, 12,
@ -159,11 +163,15 @@ void CylinderTest::solidWithCaps() {
}
void CylinderTest::solidWithTextureCoords() {
Trade::MeshData3D cylinder = cylinderSolid(2, 3, 1.5f, CylinderFlag::GenerateTextureCoords);
Trade::MeshData cylinder = cylinderSolid(2, 3, 1.5f, CylinderFlag::GenerateTextureCoords);
CORRADE_COMPARE(cylinder.primitive(), MeshPrimitive::Triangles);
CORRADE_VERIFY(cylinder.isIndexed());
CORRADE_COMPARE(cylinder.attributeCount(), 3);
/* First vertex of each ring duplicated because it has different texture
coordinates */
CORRADE_COMPARE_AS(cylinder.positions(0), (std::vector<Vector3>{
CORRADE_COMPARE_AS(cylinder.attribute<Vector3>(Trade::MeshAttribute::Position), Containers::arrayView<Vector3>({
{0.0f, -1.5f, 1.0f}, /* 0 */
{0.866025f, -1.5f, -0.5f}, /* 1 */
{-0.866025f, -1.5f, -0.5f}, /* 2 */
@ -180,7 +188,7 @@ void CylinderTest::solidWithTextureCoords() {
{0.0f, 1.5f, 1.0f}, /* 11 */
}), TestSuite::Compare::Container);
CORRADE_COMPARE_AS(cylinder.normals(0), (std::vector<Vector3>{
CORRADE_COMPARE_AS(cylinder.attribute<Vector3>(Trade::MeshAttribute::Normal), Containers::arrayView<Vector3>({
{0.0f, 0.0f, 1.0f}, /* 0 */
{0.866025f, 0.0f, -0.5f}, /* 1 */
{-0.866025f, 0.0f, -0.5f}, /* 2 */
@ -197,7 +205,7 @@ void CylinderTest::solidWithTextureCoords() {
{0.0f, 0.0f, 1.0f}, /* 11 */
}), TestSuite::Compare::Container);
CORRADE_COMPARE_AS(cylinder.textureCoords2D(0), (std::vector<Vector2>{
CORRADE_COMPARE_AS(cylinder.attribute<Vector2>(Trade::MeshAttribute::TextureCoordinates), Containers::arrayView<Vector2>({
{0.0f, 0.0f}, /* 0 */
{0.333333f, 0.0f}, /* 1 */
{0.666667f, 0.0f}, /* 2 */
@ -215,18 +223,22 @@ void CylinderTest::solidWithTextureCoords() {
}), TestSuite::Compare::Container);
/* Each ring has an extra vertex for texture coords */
CORRADE_COMPARE_AS(cylinder.indices(), (std::vector<UnsignedInt>{
CORRADE_COMPARE_AS(cylinder.indices<UnsignedInt>(), Containers::arrayView<UnsignedInt>({
0, 1, 5, 0, 5, 4, 1, 2, 6, 1, 6, 5, 2, 3, 7, 2, 7, 6,
4, 5, 9, 4, 9, 8, 5, 6, 10, 5, 10, 9, 6, 7, 11, 6, 11, 10
}), TestSuite::Compare::Container);
}
void CylinderTest::solidWithTextureCoordsAndCaps() {
Trade::MeshData3D cylinder = cylinderSolid(2, 3, 1.5f, CylinderFlag::GenerateTextureCoords|CylinderFlag::CapEnds);
Trade::MeshData cylinder = cylinderSolid(2, 3, 1.5f, CylinderFlag::GenerateTextureCoords|CylinderFlag::CapEnds);
CORRADE_COMPARE(cylinder.primitive(), MeshPrimitive::Triangles);
CORRADE_VERIFY(cylinder.isIndexed());
CORRADE_COMPARE(cylinder.attributeCount(), 3);
/* Bottom ring duplicated because it has different normals, first vertex of
each ring duplicated because it has different texture coordinates */
CORRADE_COMPARE_AS(cylinder.positions(0), (std::vector<Vector3>{
CORRADE_COMPARE_AS(cylinder.attribute<Vector3>(Trade::MeshAttribute::Position), Containers::arrayView<Vector3>({
{0.0f, -1.5f, 0.0f}, /* 0 */
{0.0f, -1.5f, 1.0f}, /* 1 */
@ -257,7 +269,7 @@ void CylinderTest::solidWithTextureCoordsAndCaps() {
{0.0f, 1.5f, 0.0f} /* 21 */
}), TestSuite::Compare::Container);
CORRADE_COMPARE_AS(cylinder.normals(0), (std::vector<Vector3>{
CORRADE_COMPARE_AS(cylinder.attribute<Vector3>(Trade::MeshAttribute::Normal), Containers::arrayView<Vector3>({
{0.0f, -1.0f, 0.0f}, /* 0 */
{0.0f, -1.0f, 0.0f}, /* 1 */
@ -288,7 +300,7 @@ void CylinderTest::solidWithTextureCoordsAndCaps() {
{0.0f, 1.0f, 0.0f}, /* 21 */
}), TestSuite::Compare::Container);
CORRADE_COMPARE_AS(cylinder.textureCoords2D(0), (std::vector<Vector2>{
CORRADE_COMPARE_AS(cylinder.attribute<Vector2>(Trade::MeshAttribute::TextureCoordinates), Containers::arrayView<Vector2>({
{0.5f, 0.0f}, /* 0 */
{0.0f, 0.2f}, /* 1 */
@ -321,7 +333,7 @@ void CylinderTest::solidWithTextureCoordsAndCaps() {
/* Faces of the caps and sides do not share any vertices due to different
normals, each ring has an extra vertex for texture coords */
CORRADE_COMPARE_AS(cylinder.indices(), (std::vector<UnsignedInt>{
CORRADE_COMPARE_AS(cylinder.indices<UnsignedInt>(), Containers::arrayView<UnsignedInt>({
0, 2, 1, 0, 3, 2, 0, 4, 3,
5, 6, 10, 5, 10, 9, 6, 7, 11, 6, 11, 10, 7, 8, 12, 7, 12, 11,
9, 10, 14, 9, 14, 13, 10, 11, 15, 10, 15, 14, 11, 12, 16, 11, 16, 15,
@ -330,9 +342,13 @@ void CylinderTest::solidWithTextureCoordsAndCaps() {
}
void CylinderTest::wireframe() {
Trade::MeshData3D cylinder = cylinderWireframe(2, 8, 0.5f);
Trade::MeshData cylinder = cylinderWireframe(2, 8, 0.5f);
CORRADE_COMPARE_AS(cylinder.positions(0), (std::vector<Vector3>{
CORRADE_COMPARE(cylinder.primitive(), MeshPrimitive::Lines);
CORRADE_VERIFY(cylinder.isIndexed());
CORRADE_COMPARE(cylinder.attributeCount(), 1);
CORRADE_COMPARE_AS(cylinder.attribute<Vector3>(Trade::MeshAttribute::Position), Containers::arrayView<Vector3>({
{0.0f, -0.5f, 1.0f}, /* 0 */
{1.0f, -0.5f, 0.0f}, /* 1 */
{0.0f, -0.5f, -1.0f}, /* 2 */
@ -361,10 +377,7 @@ void CylinderTest::wireframe() {
{-0.707107f, 0.5f, 0.707107f} /* 23 */
}), TestSuite::Compare::Container);
CORRADE_VERIFY(!cylinder.hasNormals());
CORRADE_VERIFY(!cylinder.hasTextureCoords2D());
CORRADE_COMPARE_AS(cylinder.indices(), (std::vector<UnsignedInt>{
CORRADE_COMPARE_AS(cylinder.indices<UnsignedInt>(), Containers::arrayView<UnsignedInt>({
0, 4, 1, 5, 2, 6, 3, 7,
4, 1, 5, 2, 6, 3, 7, 0,

68
src/Magnum/Primitives/Test/GradientTest.cpp
Unescape View File

@ -29,8 +29,7 @@
#include "Magnum/Mesh.h"
#include "Magnum/Math/Color.h"
#include "Magnum/Primitives/Gradient.h"
#include "Magnum/Trade/MeshData2D.h"
#include "Magnum/Trade/MeshData3D.h"
#include "Magnum/Trade/MeshData.h"
#include "Magnum/Primitives/Square.h"
#include "Magnum/Primitives/Plane.h"
@ -62,23 +61,30 @@ using namespace Magnum::Math::Literals;
void GradientTest::gradient2D() {
/* The corners sould have 0.2, 0.4, 0.6, 0.8 blends */
Trade::MeshData2D gradient = Primitives::gradient2D(
Trade::MeshData gradient = Primitives::gradient2D(
{-1.0f, 2.0f}, {0.2f, 0.6f, 1.0f},
{1.0f, -2.0f}, {0.4f, 1.0f, 0.0f});
CORRADE_COMPARE(gradient.primitive(), MeshPrimitive::TriangleStrip);
CORRADE_VERIFY(!gradient.isIndexed());
CORRADE_COMPARE(gradient.attributeCount(), 2);
/* Positions should be the same as for a square */
Trade::MeshData2D square = Primitives::squareSolid();
Trade::MeshData square = Primitives::squareSolid();
CORRADE_COMPARE(gradient.primitive(), square.primitive());
CORRADE_COMPARE_AS(gradient.positions(0), square.positions(0), TestSuite::Compare::Container);
CORRADE_COMPARE_AS(gradient.positions(0), (std::vector<Vector2>{
CORRADE_COMPARE_AS(
gradient.attribute<Vector2>(Trade::MeshAttribute::Position),
square.attribute<Vector2>(Trade::MeshAttribute::Position),
TestSuite::Compare::Container);
CORRADE_COMPARE_AS(gradient.attribute<Vector2>(Trade::MeshAttribute::Position), Containers::arrayView<Vector2>({
{ 1.0f, -1.0f}, /* Bottom right */
{ 1.0f, 1.0f}, /* Top right */
{-1.0f, -1.0f}, /* Bottom left */
{-1.0f, 1.0f} /* Top left */
}), TestSuite::Compare::Container);
CORRADE_COMPARE(gradient.colorArrayCount(), 1);
CORRADE_COMPARE_AS(gradient.colors(0), (std::vector<Color4>{
CORRADE_COMPARE_AS(gradient.attribute<Color4>(Trade::MeshAttribute::Color), Containers::arrayView<Color4>({
{0.36f, 0.92f, 0.2f}, /* 80% */
{0.28f, 0.76f, 0.6f}, /* 40% */
{0.32f, 0.84f, 0.4f}, /* 60% */
@ -87,10 +93,9 @@ void GradientTest::gradient2D() {
}
void GradientTest::gradient2DHorizontal() {
Trade::MeshData2D gradient = Primitives::gradient2DHorizontal(0xfabcde_srgbf, 0xdeab09_srgbf);
Trade::MeshData gradient = Primitives::gradient2DHorizontal(0xfabcde_srgbf, 0xdeab09_srgbf);
CORRADE_COMPARE(gradient.colorArrayCount(), 1);
CORRADE_COMPARE_AS(gradient.colors(0), (std::vector<Color4>{
CORRADE_COMPARE_AS(gradient.attribute<Color4>(Trade::MeshAttribute::Color), Containers::arrayView<Color4>({
0xdeab09_srgbf,
0xdeab09_srgbf,
0xfabcde_srgbf,
@ -99,10 +104,9 @@ void GradientTest::gradient2DHorizontal() {
}
void GradientTest::gradient2DVertical() {
Trade::MeshData2D gradient = Primitives::gradient2DVertical(0xfabcde_srgbf, 0xdeab09_srgbf);
Trade::MeshData gradient = Primitives::gradient2DVertical(0xfabcde_srgbf, 0xdeab09_srgbf);
CORRADE_COMPARE(gradient.colorArrayCount(), 1);
CORRADE_COMPARE_AS(gradient.colors(0), (std::vector<Color4>{
CORRADE_COMPARE_AS(gradient.attribute<Color4>(Trade::MeshAttribute::Color), Containers::arrayView<Color4>({
0xfabcde_srgbf,
0xdeab09_srgbf,
0xfabcde_srgbf,
@ -112,25 +116,37 @@ void GradientTest::gradient2DVertical() {
void GradientTest::gradient3D() {
/* The corners sould have 0.2, 0.4, 0.6, 0.8 blends */
Trade::MeshData3D gradient = Primitives::gradient3D(
Trade::MeshData gradient = Primitives::gradient3D(
{-1.0f, 2.0f, -1.5f}, {0.2f, 0.6f, 1.0f},
{1.0f, -2.0f, -1.5f}, {0.4f, 1.0f, 0.0f});
CORRADE_COMPARE(gradient.primitive(), MeshPrimitive::TriangleStrip);
CORRADE_VERIFY(!gradient.isIndexed());
CORRADE_COMPARE(gradient.attributeCount(), 3);
/* Positions should be the same as for a plane */
Trade::MeshData3D plane = Primitives::planeSolid();
Trade::MeshData plane = Primitives::planeSolid();
CORRADE_COMPARE(gradient.primitive(), plane.primitive());
CORRADE_COMPARE_AS(gradient.positions(0), plane.positions(0), TestSuite::Compare::Container);
CORRADE_COMPARE_AS(gradient.positions(0), (std::vector<Vector3>{
CORRADE_COMPARE_AS(
gradient.attribute<Vector3>(Trade::MeshAttribute::Position),
plane.attribute<Vector3>(Trade::MeshAttribute::Position),
TestSuite::Compare::Container);
CORRADE_COMPARE_AS(gradient.attribute<Vector3>(Trade::MeshAttribute::Position), Containers::arrayView<Vector3>({
{ 1.0f, -1.0f, 0.0f}, /* Bottom right */
{ 1.0f, 1.0f, 0.0f}, /* Top right */
{-1.0f, -1.0f, 0.0f}, /* Bottom left */
{-1.0f, 1.0f, 0.0f} /* Top left */
}), TestSuite::Compare::Container);
CORRADE_COMPARE(gradient.normalArrayCount(), 1);
CORRADE_COMPARE_AS(gradient.attribute<Vector3>(Trade::MeshAttribute::Normal), Containers::arrayView<Vector3>({
{0.0f, 0.0f, 1.0f},
{0.0f, 0.0f, 1.0f},
{0.0f, 0.0f, 1.0f},
{0.0f, 0.0f, 1.0f}
}), TestSuite::Compare::Container);
CORRADE_COMPARE(gradient.colorArrayCount(), 1);
CORRADE_COMPARE_AS(gradient.colors(0), (std::vector<Color4>{
CORRADE_COMPARE_AS(gradient.attribute<Color4>(Trade::MeshAttribute::Color), Containers::arrayView<Color4>({
{0.36f, 0.92f, 0.2f}, /* 80% */
{0.28f, 0.76f, 0.6f}, /* 40% */
{0.32f, 0.84f, 0.4f}, /* 60% */
@ -139,10 +155,9 @@ void GradientTest::gradient3D() {
}
void GradientTest::gradient3DHorizontal() {
Trade::MeshData3D gradient = Primitives::gradient3DHorizontal(0xfabcde_srgbf, 0xdeab09_srgbf);
Trade::MeshData gradient = Primitives::gradient3DHorizontal(0xfabcde_srgbf, 0xdeab09_srgbf);
CORRADE_COMPARE(gradient.colorArrayCount(), 1);
CORRADE_COMPARE_AS(gradient.colors(0), (std::vector<Color4>{
CORRADE_COMPARE_AS(gradient.attribute<Color4>(Trade::MeshAttribute::Color), Containers::arrayView<Color4>({
0xdeab09_srgbf,
0xdeab09_srgbf,
0xfabcde_srgbf,
@ -151,10 +166,9 @@ void GradientTest::gradient3DHorizontal() {
}
void GradientTest::gradient3DVertical() {
Trade::MeshData3D gradient = Primitives::gradient3DVertical(0xfabcde_srgbf, 0xdeab09_srgbf);
Trade::MeshData gradient = Primitives::gradient3DVertical(0xfabcde_srgbf, 0xdeab09_srgbf);
CORRADE_COMPARE(gradient.colorArrayCount(), 1);
CORRADE_COMPARE_AS(gradient.colors(0), (std::vector<Color4>{
CORRADE_COMPARE_AS(gradient.attribute<Color4>(Trade::MeshAttribute::Color), Containers::arrayView<Color4>({
0xfabcde_srgbf,
0xdeab09_srgbf,
0xfabcde_srgbf,

39
src/Magnum/Primitives/Test/GridTest.cpp
Unescape View File

@ -28,7 +28,7 @@
#include "Magnum/Math/Vector3.h"
#include "Magnum/Primitives/Grid.h"
#include "Magnum/Trade/MeshData3D.h"
#include "Magnum/Trade/MeshData.h"
namespace Magnum { namespace Primitives { namespace Test { namespace {
@ -47,9 +47,13 @@ GridTest::GridTest() {
}
void GridTest::solid3DWithoutAnything() {
Trade::MeshData3D grid = grid3DSolid({5, 3}, {});
Trade::MeshData grid = grid3DSolid({5, 3}, {});
CORRADE_COMPARE_AS(grid.positions(0), (std::vector<Vector3>{
CORRADE_COMPARE(grid.primitive(), MeshPrimitive::Triangles);
CORRADE_VERIFY(grid.isIndexed());
CORRADE_COMPARE(grid.attributeCount(), 1);
CORRADE_COMPARE_AS(grid.attribute<Vector3>(Trade::MeshAttribute::Position), Containers::arrayView<Vector3>({
{-1.0f, -1.0f, 0.0f},
{-0.666667f, -1.0f, 0.0f},
{-0.333333f, -1.0f, 0.0f},
@ -91,10 +95,7 @@ void GridTest::solid3DWithoutAnything() {
{1.0f, 1.0f, 0.0f}
}), TestSuite::Compare::Container);
CORRADE_COMPARE(grid.normalArrayCount(), 0);
CORRADE_COMPARE(grid.textureCoords2DArrayCount(), 0);
CORRADE_COMPARE_AS(grid.indices(), (std::vector<UnsignedInt>{
CORRADE_COMPARE_AS(grid.indices<UnsignedInt>(), Containers::arrayView<UnsignedInt>({
0, 8, 7, 0, 1, 8,
1, 9, 8, 1, 2, 9,
2, 10, 9, 2, 3, 10,
@ -126,9 +127,13 @@ void GridTest::solid3DWithoutAnything() {
}
void GridTest::solid3DWithNormalsAndTextureCoords() {
Trade::MeshData3D grid = grid3DSolid({5, 3}, GridFlag::GenerateNormals|GridFlag::GenerateTextureCoords);
Trade::MeshData grid = grid3DSolid({5, 3}, GridFlag::GenerateNormals|GridFlag::GenerateTextureCoords);
CORRADE_COMPARE_AS(grid.positions(0), (std::vector<Vector3>{
CORRADE_COMPARE(grid.primitive(), MeshPrimitive::Triangles);
CORRADE_VERIFY(grid.isIndexed());
CORRADE_COMPARE(grid.attributeCount(), 3);
CORRADE_COMPARE_AS(grid.attribute<Vector3>(Trade::MeshAttribute::Position), Containers::arrayView<Vector3>({
{-1.0f, -1.0f, 0.0f},
{-0.666667f, -1.0f, 0.0f},
{-0.333333f, -1.0f, 0.0f},
@ -170,7 +175,7 @@ void GridTest::solid3DWithNormalsAndTextureCoords() {
{1.0f, 1.0f, 0.0f}
}), TestSuite::Compare::Container);
CORRADE_COMPARE_AS(grid.normals(0), (std::vector<Vector3>{
CORRADE_COMPARE_AS(grid.attribute<Vector3>(Trade::MeshAttribute::Normal), Containers::arrayView<Vector3>({
{0.0f, 0.0f, 1.0f},
{0.0f, 0.0f, 1.0f},
{0.0f, 0.0f, 1.0f},
@ -212,7 +217,7 @@ void GridTest::solid3DWithNormalsAndTextureCoords() {
{0.0f, 0.0f, 1.0f},
}), TestSuite::Compare::Container);
CORRADE_COMPARE_AS(grid.textureCoords2D(0), (std::vector<Vector2>{
CORRADE_COMPARE_AS(grid.attribute<Vector2>(Trade::MeshAttribute::TextureCoordinates), Containers::arrayView<Vector2>({
{0.0f, 0.0f},
{0.166667f, 0.0f},
{0.333333f, 0.0f},
@ -254,7 +259,7 @@ void GridTest::solid3DWithNormalsAndTextureCoords() {
{1.0f, 1.0f}
}), TestSuite::Compare::Container);
CORRADE_COMPARE_AS(grid.indices(), (std::vector<UnsignedInt>{
CORRADE_COMPARE_AS(grid.indices<UnsignedInt>(), Containers::arrayView<UnsignedInt>({
0, 8, 7, 0, 1, 8,
1, 9, 8, 1, 2, 9,
2, 10, 9, 2, 3, 10,
@ -286,9 +291,13 @@ void GridTest::solid3DWithNormalsAndTextureCoords() {
}
void GridTest::wireframe3D() {
Trade::MeshData3D grid = grid3DWireframe({5, 3});
Trade::MeshData grid = grid3DWireframe({5, 3});
CORRADE_COMPARE(grid.primitive(), MeshPrimitive::Lines);
CORRADE_VERIFY(grid.isIndexed());
CORRADE_COMPARE(grid.attributeCount(), 1);
CORRADE_COMPARE_AS(grid.positions(0), (std::vector<Vector3>{
CORRADE_COMPARE_AS(grid.attribute<Vector3>(Trade::MeshAttribute::Position), Containers::arrayView<Vector3>({
{-1.0f, -1.0f, 0.0f},
{-0.666667f, -1.0f, 0.0f},
{-0.333333f, -1.0f, 0.0f},
@ -330,7 +339,7 @@ void GridTest::wireframe3D() {
{1.0f, 1.0f, 0.0f}
}), TestSuite::Compare::Container);
CORRADE_COMPARE_AS(grid.indices(), (std::vector<UnsignedInt>{
CORRADE_COMPARE_AS(grid.indices<UnsignedInt>(), Containers::arrayView<UnsignedInt>({
0, 1, 0, 7,
1, 2, 1, 8,
2, 3, 2, 9,

51
src/Magnum/Primitives/Test/IcosphereTest.cpp
Unescape View File

@ -28,7 +28,7 @@
#include "Magnum/Math/Vector3.h"
#include "Magnum/Primitives/Icosphere.h"
#include "Magnum/Trade/MeshData3D.h"
#include "Magnum/Trade/MeshData.h"
namespace Magnum { namespace Primitives { namespace Test { namespace {
@ -47,25 +47,30 @@ IcosphereTest::IcosphereTest() {
}
void IcosphereTest::count0() {
Trade::MeshData3D data = Primitives::icosphereSolid(0);
CORRADE_COMPARE(data.positionArrayCount(), 1);
CORRADE_COMPARE(data.normalArrayCount(), 1);
CORRADE_COMPARE(data.indices().size(), 60);
CORRADE_COMPARE(data.positions(0).size(), 12);
CORRADE_COMPARE(data.normals(0).size(), 12);
Trade::MeshData icosphere = Primitives::icosphereSolid(0);
CORRADE_COMPARE(icosphere.primitive(), MeshPrimitive::Triangles);
CORRADE_VERIFY(icosphere.isIndexed());
CORRADE_COMPARE(icosphere.indexCount(), 60);
CORRADE_COMPARE(icosphere.vertexCount(), 12);
CORRADE_COMPARE(icosphere.attributeCount(), 2);
CORRADE_COMPARE(icosphere.indices<UnsignedInt>()[18], 9);
CORRADE_COMPARE(icosphere.attribute<Vector3>(Trade::MeshAttribute::Position)[8],
(Vector3{-0.525731f, -0.850651f, 0.0f}));
CORRADE_COMPARE(icosphere.attribute<Vector3>(Trade::MeshAttribute::Normal)[8],
(Vector3{-0.525731f, -0.850651f, 0.0f}));
}
void IcosphereTest::data1() {
/* This also tests the subdivide() and removeDuplicates() mesh tools */
Trade::MeshData3D data = Primitives::icosphereSolid(1);
Trade::MeshData icosphere = Primitives::icosphereSolid(1);
CORRADE_COMPARE(data.positionArrayCount(), 1);
CORRADE_COMPARE(data.normalArrayCount(), 1);
CORRADE_COMPARE(icosphere.primitive(), MeshPrimitive::Triangles);
CORRADE_VERIFY(icosphere.isIndexed());
CORRADE_COMPARE(icosphere.attributeCount(), 2);
CORRADE_COMPARE_AS(data.indices(), (std::vector<UnsignedInt>{
CORRADE_COMPARE_AS(icosphere.indices<UnsignedInt>(), Containers::arrayView<UnsignedInt>({
12, 13, 14, 15, 16, 12, 17, 18, 19, 17, 20, 21, 22, 23, 24, 22, 25, 26,
27, 28, 29, 27, 30, 31, 32, 33, 34, 32, 35, 36, 37, 38, 39, 37, 40, 41,
13, 28, 25, 14, 24, 39, 19, 26, 31, 18, 40, 23, 16, 34, 29, 15, 38, 35,
@ -80,7 +85,8 @@ void IcosphereTest::data1() {
16, 29, 16, 7, 34, 29, 34, 9, 7, 15, 35, 15, 1, 38, 35, 38, 0, 3, 30,
20, 30, 9, 33, 20, 33, 8, 4, 21, 41, 21, 8, 36, 41, 36, 0}),
TestSuite::Compare::Container);
CORRADE_COMPARE_AS(data.positions(0), (std::vector<Vector3>{
CORRADE_COMPARE_AS(icosphere.attribute<Vector3>(Trade::MeshAttribute::Position), Containers::arrayView<Vector3>({
{0.0f, -0.525731f, 0.850651f},
{0.850651f, 0.0f, 0.525731f},
{0.850651f, 0.0f, -0.525731f},
@ -124,19 +130,20 @@ void IcosphereTest::data1() {
{-0.5f, 0.309017f, 0.809017f},
{-0.5f, -0.309017f, 0.809017f}}),
TestSuite::Compare::Container);
CORRADE_COMPARE_AS(data.normals(0), data.positions(0),
CORRADE_COMPARE_AS(
icosphere.attribute<Vector3>(Trade::MeshAttribute::Position),
icosphere.attribute<Vector3>(Trade::MeshAttribute::Normal),
TestSuite::Compare::Container);
}
void IcosphereTest::count2() {
Trade::MeshData3D data = Primitives::icosphereSolid(2);
CORRADE_COMPARE(data.positionArrayCount(), 1);
CORRADE_COMPARE(data.normalArrayCount(), 1);
Trade::MeshData icosphere = Primitives::icosphereSolid(2);
CORRADE_COMPARE(data.indices().size(), 960);
CORRADE_COMPARE(data.positions(0).size(), 162);
CORRADE_COMPARE(data.normals(0).size(), 162);
CORRADE_COMPARE(icosphere.primitive(), MeshPrimitive::Triangles);
CORRADE_VERIFY(icosphere.isIndexed());
CORRADE_COMPARE(icosphere.indexCount(), 960);
CORRADE_COMPARE(icosphere.vertexCount(), 162);
CORRADE_COMPARE(icosphere.attributeCount(), 2);
}
}}}}

21
src/Magnum/Primitives/Test/LineTest.cpp
Unescape View File

@ -28,8 +28,7 @@
#include "Magnum/Mesh.h"
#include "Magnum/Math/Vector3.h"
#include "Magnum/Primitives/Line.h"
#include "Magnum/Trade/MeshData2D.h"
#include "Magnum/Trade/MeshData3D.h"
#include "Magnum/Trade/MeshData.h"
namespace Magnum { namespace Primitives { namespace Test { namespace {
@ -46,19 +45,25 @@ LineTest::LineTest() {
}
void LineTest::twoDimensions() {
Trade::MeshData2D line = Primitives::line2D();
Trade::MeshData line = Primitives::line2D();
CORRADE_VERIFY(!line.isIndexed());
CORRADE_COMPARE(line.primitive(), MeshPrimitive::Lines);
CORRADE_COMPARE(line.positions(0).size(), 2);
CORRADE_VERIFY(!line.isIndexed());
CORRADE_COMPARE(line.vertexCount(), 2);
CORRADE_COMPARE(line.attributeCount(), 1);
CORRADE_COMPARE(line.attribute<Vector2>(Trade::MeshAttribute::Position)[1],
(Vector2{1.0f, 0.0f}));
}
void LineTest::threeDimensions() {
Trade::MeshData3D line = Primitives::line3D();
Trade::MeshData line = Primitives::line3D();
CORRADE_VERIFY(!line.isIndexed());
CORRADE_COMPARE(line.primitive(), MeshPrimitive::Lines);
CORRADE_COMPARE(line.positions(0).size(), 2);
CORRADE_VERIFY(!line.isIndexed());
CORRADE_COMPARE(line.vertexCount(), 2);
CORRADE_COMPARE(line.attributeCount(), 1);
CORRADE_COMPARE(line.attribute<Vector3>(Trade::MeshAttribute::Position)[1],
(Vector3{1.0f, 0.0f, 0.0f}));
}
}}}}

40
src/Magnum/Primitives/Test/PlaneTest.cpp
Unescape View File

@ -28,7 +28,7 @@
#include "Magnum/Mesh.h"
#include "Magnum/Math/Vector3.h"
#include "Magnum/Primitives/Plane.h"
#include "Magnum/Trade/MeshData3D.h"
#include "Magnum/Trade/MeshData.h"
namespace Magnum { namespace Primitives { namespace Test { namespace {
@ -47,32 +47,42 @@ PlaneTest::PlaneTest() {
}
void PlaneTest::solid() {
Trade::MeshData3D plane = Primitives::planeSolid();
Trade::MeshData plane = Primitives::planeSolid();
CORRADE_VERIFY(!plane.isIndexed());
CORRADE_COMPARE(plane.primitive(), MeshPrimitive::TriangleStrip);
CORRADE_COMPARE(plane.positions(0).size(), 4);
CORRADE_COMPARE(plane.normals(0).size(), 4);
CORRADE_COMPARE(plane.textureCoords2DArrayCount(), 0);
CORRADE_VERIFY(!plane.isIndexed());
CORRADE_COMPARE(plane.vertexCount(), 4);
CORRADE_COMPARE(plane.attributeCount(), 2);
CORRADE_COMPARE(plane.attribute<Vector3>(Trade::MeshAttribute::Position)[3],
(Vector3{-1.0f, 1.0f, 0.0f}));
CORRADE_COMPARE(plane.attribute<Vector3>(Trade::MeshAttribute::Normal)[2],
(Vector3{0.0f, 0.0f, 1.0f}));
}
void PlaneTest::solidTextured() {
Trade::MeshData3D plane = Primitives::planeSolid(Primitives::PlaneTextureCoords::Generate);
Trade::MeshData plane = Primitives::planeSolid(Primitives::PlaneTextureCoords::Generate);
CORRADE_VERIFY(!plane.isIndexed());
CORRADE_COMPARE(plane.primitive(), MeshPrimitive::TriangleStrip);
CORRADE_COMPARE(plane.positions(0).size(), 4);
CORRADE_COMPARE(plane.normals(0).size(), 4);
CORRADE_COMPARE(plane.textureCoords2DArrayCount(), 1);
CORRADE_COMPARE(plane.textureCoords2D(0).size(), 4);
CORRADE_VERIFY(!plane.isIndexed());
CORRADE_COMPARE(plane.vertexCount(), 4);
CORRADE_COMPARE(plane.attributeCount(), 3);
CORRADE_COMPARE(plane.attribute<Vector3>(Trade::MeshAttribute::Position)[3],
(Vector3{-1.0f, 1.0f, 0.0f}));
CORRADE_COMPARE(plane.attribute<Vector3>(Trade::MeshAttribute::Normal)[2],
(Vector3{0.0f, 0.0f, 1.0f}));
CORRADE_COMPARE(plane.attribute<Vector2>(Trade::MeshAttribute::TextureCoordinates)[1],
(Vector2{1.0f, 1.0f}));
}
void PlaneTest::wireframe() {
Trade::MeshData3D plane = Primitives::planeWireframe();
Trade::MeshData plane = Primitives::planeWireframe();
CORRADE_VERIFY(!plane.isIndexed());
CORRADE_COMPARE(plane.primitive(), MeshPrimitive::LineLoop);
CORRADE_COMPARE(plane.positions(0).size(), 4);
CORRADE_VERIFY(!plane.isIndexed());
CORRADE_COMPARE(plane.vertexCount(), 4);
CORRADE_COMPARE(plane.attributeCount(), 1);
CORRADE_COMPARE(plane.attribute<Vector3>(Trade::MeshAttribute::Position)[3],
(Vector3{-1.0f, 1.0f, 0.0f}));
}
}}}}

34
src/Magnum/Primitives/Test/SquareTest.cpp
Unescape View File

@ -28,7 +28,7 @@
#include "Magnum/Mesh.h"
#include "Magnum/Math/Vector2.h"
#include "Magnum/Primitives/Square.h"
#include "Magnum/Trade/MeshData2D.h"
#include "Magnum/Trade/MeshData.h"
namespace Magnum { namespace Primitives { namespace Test { namespace {
@ -47,30 +47,38 @@ SquareTest::SquareTest() {
}
void SquareTest::solid() {
Trade::MeshData2D square = Primitives::squareSolid();
Trade::MeshData square = Primitives::squareSolid();
CORRADE_VERIFY(!square.isIndexed());
CORRADE_COMPARE(square.primitive(), MeshPrimitive::TriangleStrip);
CORRADE_COMPARE(square.positions(0).size(), 4);
CORRADE_COMPARE(square.textureCoords2DArrayCount(), 0);
CORRADE_VERIFY(!square.isIndexed());
CORRADE_COMPARE(square.vertexCount(), 4);
CORRADE_COMPARE(square.attributeCount(), 1);
CORRADE_COMPARE(square.attribute<Vector2>(Trade::MeshAttribute::Position)[3],
(Vector2{-1.0f, 1.0f}));
}
void SquareTest::solidTextured() {
Trade::MeshData2D square = Primitives::squareSolid(Primitives::SquareTextureCoords::Generate);
Trade::MeshData square = Primitives::squareSolid(Primitives::SquareTextureCoords::Generate);
CORRADE_VERIFY(!square.isIndexed());
CORRADE_COMPARE(square.primitive(), MeshPrimitive::TriangleStrip);
CORRADE_COMPARE(square.positions(0).size(), 4);
CORRADE_COMPARE(square.textureCoords2DArrayCount(), 1);
CORRADE_COMPARE(square.textureCoords2D(0).size(), 4);
CORRADE_VERIFY(!square.isIndexed());
CORRADE_COMPARE(square.vertexCount(), 4);
CORRADE_COMPARE(square.attributeCount(), 2);
CORRADE_COMPARE(square.attribute<Vector2>(Trade::MeshAttribute::Position)[3],
(Vector2{-1.0f, 1.0f}));
CORRADE_COMPARE(square.attribute<Vector2>(Trade::MeshAttribute::TextureCoordinates)[1],
(Vector2{1.0f, 1.0f}));
}
void SquareTest::wireframe() {
Trade::MeshData2D square = Primitives::squareWireframe();
Trade::MeshData square = Primitives::squareWireframe();
CORRADE_VERIFY(!square.isIndexed());
CORRADE_COMPARE(square.primitive(), MeshPrimitive::LineLoop);
CORRADE_COMPARE(square.positions(0).size(), 4);
CORRADE_VERIFY(!square.isIndexed());
CORRADE_COMPARE(square.vertexCount(), 4);
CORRADE_COMPARE(square.attributeCount(), 1);
CORRADE_COMPARE(square.attribute<Vector2>(Trade::MeshAttribute::Position)[3],
(Vector2{-1.0f, 1.0f}));
}
}}}}

38
src/Magnum/Primitives/Test/UVSphereTest.cpp
Unescape View File

@ -28,7 +28,7 @@
#include "Magnum/Math/Vector3.h"
#include "Magnum/Primitives/UVSphere.h"
#include "Magnum/Trade/MeshData3D.h"
#include "Magnum/Trade/MeshData.h"
namespace Magnum { namespace Primitives { namespace Test { namespace {
@ -47,9 +47,13 @@ UVSphereTest::UVSphereTest() {
}
void UVSphereTest::solidWithoutTextureCoords() {
Trade::MeshData3D sphere = uvSphereSolid(3, 3);
Trade::MeshData sphere = uvSphereSolid(3, 3);
CORRADE_COMPARE_AS(sphere.positions(0), (std::vector<Vector3>{
CORRADE_COMPARE(sphere.primitive(), MeshPrimitive::Triangles);
CORRADE_VERIFY(sphere.isIndexed());
CORRADE_COMPARE(sphere.attributeCount(), 2);
CORRADE_COMPARE_AS(sphere.attribute<Vector3>(Trade::MeshAttribute::Position), Containers::arrayView<Vector3>({
{0.0f, -1.0f, 0.0f},
{0.0f, -0.5f, 0.866025f},
@ -63,7 +67,7 @@ void UVSphereTest::solidWithoutTextureCoords() {
{0.0f, 1.0f, 0.0f}
}), TestSuite::Compare::Container);
CORRADE_COMPARE_AS(sphere.normals(0), (std::vector<Vector3>{
CORRADE_COMPARE_AS(sphere.attribute<Vector3>(Trade::MeshAttribute::Normal), Containers::arrayView<Vector3>({
{0.0f, -1.0f, 0.0f},
{0.0f, -0.5f, 0.866025f},
@ -77,7 +81,7 @@ void UVSphereTest::solidWithoutTextureCoords() {
{0.0f, 1.0f, 0.0f}
}), TestSuite::Compare::Container);
CORRADE_COMPARE_AS(sphere.indices(), (std::vector<UnsignedInt>{
CORRADE_COMPARE_AS(sphere.indices<UnsignedInt>(), Containers::arrayView<UnsignedInt>({
0, 2, 1, 0, 3, 2, 0, 1, 3,
1, 2, 5, 1, 5, 4, 2, 3, 6, 2, 6, 5, 3, 1, 4, 3, 4, 6,
4, 5, 7, 5, 6, 7, 6, 4, 7
@ -85,9 +89,13 @@ void UVSphereTest::solidWithoutTextureCoords() {
}
void UVSphereTest::solidWithTextureCoords() {
Trade::MeshData3D sphere = uvSphereSolid(3, 3, UVSphereTextureCoords::Generate);
Trade::MeshData sphere = uvSphereSolid(3, 3, UVSphereTextureCoords::Generate);
CORRADE_COMPARE(sphere.primitive(), MeshPrimitive::Triangles);
CORRADE_VERIFY(sphere.isIndexed());
CORRADE_COMPARE(sphere.attributeCount(), 3);
CORRADE_COMPARE_AS(sphere.positions(0), (std::vector<Vector3>{
CORRADE_COMPARE_AS(sphere.attribute<Vector3>(Trade::MeshAttribute::Position), Containers::arrayView<Vector3>({
{0.0f, -1.0f, 0.0f},
{0.0f, -0.5f, 0.866025f},
@ -103,7 +111,7 @@ void UVSphereTest::solidWithTextureCoords() {
{0.0f, 1.0f, 0.0f}
}), TestSuite::Compare::Container);
CORRADE_COMPARE_AS(sphere.textureCoords2D(0), (std::vector<Vector2>{
CORRADE_COMPARE_AS(sphere.attribute<Vector2>(Trade::MeshAttribute::TextureCoordinates), Containers::arrayView<Vector2>({
{0.5f, 0.0f},
{0.0f, 0.333333f},
@ -119,7 +127,7 @@ void UVSphereTest::solidWithTextureCoords() {
{0.5f, 1.0f}
}), TestSuite::Compare::Container);
CORRADE_COMPARE_AS(sphere.indices(), (std::vector<UnsignedInt>{
CORRADE_COMPARE_AS(sphere.indices<UnsignedInt>(), Containers::arrayView<UnsignedInt>({
0, 2, 1, 0, 3, 2, 0, 4, 3,
1, 2, 6, 1, 6, 5, 2, 3, 7, 2, 7, 6, 3, 4, 8, 3, 8, 7,
5, 6, 9, 6, 7, 9, 7, 8, 9
@ -127,9 +135,13 @@ void UVSphereTest::solidWithTextureCoords() {
}
void UVSphereTest::wireframe() {
Trade::MeshData3D sphere = uvSphereWireframe(6, 8);
Trade::MeshData sphere = uvSphereWireframe(6, 8);
CORRADE_COMPARE_AS(sphere.positions(0), (std::vector<Vector3>{
CORRADE_COMPARE(sphere.primitive(), MeshPrimitive::Lines);
CORRADE_VERIFY(sphere.isIndexed());
CORRADE_COMPARE(sphere.attributeCount(), 1);
CORRADE_COMPARE_AS(sphere.attribute<Vector3>(Trade::MeshAttribute::Position), Containers::arrayView<Vector3>({
{0.0f, -1.0f, 0.0f},
{0.0f, -0.866025f, 0.5f},
@ -167,9 +179,7 @@ void UVSphereTest::wireframe() {
{0.0f, 1.0f, 0.0f}
}), TestSuite::Compare::Container);
CORRADE_COMPARE(sphere.normalArrayCount(), 0);
CORRADE_COMPARE_AS(sphere.indices(), (std::vector<UnsignedInt>{
CORRADE_COMPARE_AS(sphere.indices<UnsignedInt>(), Containers::arrayView<UnsignedInt>({
0, 1, 0, 2, 0, 3, 0, 4,
1, 5, 2, 6, 3, 7, 4, 8,

Write Preview
Loading…
Cancel
Save