From 38d56059e2805d3898af4611d3ce7aac88798e2a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Vladim=C3=ADr=20Vondru=C5=A1?= Date: Mon, 23 Mar 2020 12:08:47 +0100 Subject: [PATCH] python: adapt to changes in the Primitives library. Again without keeping backwards compatibility, sorry. --- src/python/magnum/primitives.cpp | 82 +++++++++++++++-------- src/python/magnum/test/test_primitives.py | 27 ++++---- 2 files changed, 69 insertions(+), 40 deletions(-) diff --git a/src/python/magnum/primitives.cpp b/src/python/magnum/primitives.cpp index cd235bb..a13f95d 100644 --- a/src/python/magnum/primitives.cpp +++ b/src/python/magnum/primitives.cpp @@ -55,55 +55,77 @@ void primitives(py::module& m) { py::module::import("magnum.trade"); #endif - py::enum_{m, "CapsuleTextureCoords", "Whether to generate capsule texture coordinates"} - .value("DONT_GENERATE", Primitives::CapsuleTextureCoords::DontGenerate) - .value("GENERATE", Primitives::CapsuleTextureCoords::Generate); - - py::enum_{m, "CircleTextureCoords", "Whether to generate circle texture coordinates"} - .value("DONT_GENERATE", Primitives::CircleTextureCoords::DontGenerate) - .value("GENERATE", Primitives::CircleTextureCoords::Generate); + py::enum_ capsuleFlags{m, "CapsuleFlags", "Capsule flags"}; + capsuleFlags.value("TEXTURE_COORDINATES", Primitives::CapsuleFlag::TextureCoordinates) + .value("TANGENTS", Primitives::CapsuleFlag::Tangents) + .value("NONE", Primitives::CapsuleFlag{}); + corrade::enumOperators(capsuleFlags); + + py::enum_ circle2DFlags{m, "Circle2DFlags", "2D circle flags"}; + circle2DFlags.value("TEXTURE_COORDINATES", Primitives::Circle2DFlag::TextureCoordinates) + .value("NONE", Primitives::Circle2DFlag{}); + corrade::enumOperators(circle2DFlags); + + py::enum_ circle3DFlags{m, "Circle3DFlags", "3D circle flags"}; + circle3DFlags.value("TEXTURE_COORDINATES", Primitives::Circle3DFlag::TextureCoordinates) + .value("TANGENTS", Primitives::Circle3DFlag::Tangents) + .value("NONE", Primitives::Circle3DFlag{}); + corrade::enumOperators(circle3DFlags); py::enum_ coneFlags{m, "ConeFlags", "Cone flags"}; - coneFlags.value("GENERATE_TEXTURE_COORDS", Primitives::ConeFlag::GenerateTextureCoords) + coneFlags.value("TEXTURE_COORDINATES", Primitives::ConeFlag::TextureCoordinates) + .value("TANGENTS", Primitives::ConeFlag::Tangents) .value("CAP_END", Primitives::ConeFlag::CapEnd) .value("NONE", Primitives::ConeFlag{}); corrade::enumOperators(coneFlags); py::enum_ cylinderFlags{m, "CylinderFlags", "Cylinder flags"}; - cylinderFlags.value("GENERATE_TEXTURE_COORDS", Primitives::CylinderFlag::GenerateTextureCoords) + cylinderFlags.value("TEXTURE_COORDINATES", Primitives::CylinderFlag::TextureCoordinates) .value("CAP_ENDS", Primitives::CylinderFlag::CapEnds) .value("NONE", Primitives::CylinderFlag{}); corrade::enumOperators(cylinderFlags); py::enum_ gridFlags{m, "GridFlags", "Grid flags"}; - gridFlags.value("GENERATE_TEXTURE_COORDS", Primitives::GridFlag::GenerateTextureCoords) - .value("GENERATE_NORMALS", Primitives::GridFlag::GenerateNormals) + gridFlags.value("TEXTURE_COORDINATES", Primitives::GridFlag::TextureCoordinates) + .value("NORMALS", Primitives::GridFlag::Normals) + .value("TANGENTS", Primitives::GridFlag::Tangents) .value("NONE", Primitives::GridFlag{}); corrade::enumOperators(gridFlags); - py::enum_{m, "PlaneTextureCoords", "Whether to generate plane texture coordinates"} - .value("DONT_GENERATE", Primitives::PlaneTextureCoords::DontGenerate) - .value("GENERATE", Primitives::PlaneTextureCoords::Generate); + py::enum_ planeFlags{m, "PlaneFlags", "Plane flags"}; + planeFlags.value("TEXTURE_COORDINATES", Primitives::PlaneFlag::TextureCoordinates) + .value("TANGENTS", Primitives::PlaneFlag::Tangents) + .value("NONE", Primitives::PlaneFlag{}); + corrade::enumOperators(planeFlags); - py::enum_{m, "SquareTextureCoords", "Whether to generate square texture coordinates"} - .value("DONT_GENERATE", Primitives::SquareTextureCoords::DontGenerate) - .value("GENERATE", Primitives::SquareTextureCoords::Generate); + py::enum_ squareFlags{m, "SquareFlags", "Square flags"}; + squareFlags.value("TEXTURE_COORDINATES", Primitives::SquareFlag::TextureCoordinates) + .value("NONE", Primitives::SquareFlag{}); + corrade::enumOperators(squareFlags); - py::enum_{m, "UVSphereTextureCoords", "Whether to generate UV sphere texture coordinates"} - .value("DONT_GENERATE", Primitives::UVSphereTextureCoords::DontGenerate) - .value("GENERATE", Primitives::UVSphereTextureCoords::Generate); + py::enum_ uvSphereFlags{m, "UVSphereFlags", "UV sphere flags"}; + uvSphereFlags.value("TEXTURE_COORDINATES", Primitives::UVSphereFlag::TextureCoordinates) + .value("TANGENTS", Primitives::UVSphereFlag::Tangents) + .value("NONE", Primitives::UVSphereFlag{}); + corrade::enumOperators(uvSphereFlags); m .def("axis2d", Primitives::axis2D, "2D axis") .def("axis3d", Primitives::axis3D, "3D axis") .def("capsule2d_wireframe", Primitives::capsule2DWireframe, "Wireframe 2D capsule", py::arg("hemisphere_rings"), py::arg("cylinder_rings"), py::arg("half_length")) - .def("capsule3d_solid", Primitives::capsule3DSolid, "Solid 3D capsule", py::arg("hemisphere_rings"), py::arg("cylinder_rings"), py::arg("segments"), py::arg("half_length"), py::arg("texture_coords") = Primitives::CapsuleTextureCoords::DontGenerate) + .def("capsule3d_solid", [](UnsignedInt hemisphereRings, UnsignedInt cylinderRings, UnsignedInt segments, Float halfLength, Primitives::CapsuleFlag flags) { + return Primitives::capsule3DSolid(hemisphereRings, cylinderRings, segments, halfLength, flags); + }, "Solid 3D capsule", py::arg("hemisphere_rings"), py::arg("cylinder_rings"), py::arg("segments"), py::arg("half_length"), py::arg("flags") = Primitives::CapsuleFlag{}) .def("capsule3d_wireframe", Primitives::capsule3DWireframe, "Wireframe 3D capsule", py::arg("hemisphere_rings"), py::arg("cylinder_rings"), py::arg("segments"), py::arg("half_length")) - .def("circle2d_solid", Primitives::circle2DSolid, "Solid 2D circle", py::arg("segments"), py::arg("texture_coords") = Primitives::CircleTextureCoords::DontGenerate) + .def("circle2d_solid", [](UnsignedInt segments, Primitives::Circle2DFlag flags) { + return Primitives::circle2DSolid(segments, flags); + }, "Solid 2D circle", py::arg("segments"), py::arg("flags") = Primitives::Circle2DFlag{}) .def("circle2d_wireframe", Primitives::circle2DWireframe, "Wireframe 2D circle", py::arg("segments")) - .def("circle3d_solid", Primitives::circle3DSolid, "Solid 3D circle", py::arg("segments"), py::arg("texture_coords") = Primitives::CircleTextureCoords::DontGenerate) + .def("circle3d_solid", [](UnsignedInt segments, Primitives::Circle3DFlag flags) { + return Primitives::circle3DSolid(segments, flags); + }, "Solid 3D circle", py::arg("segments"), py::arg("flags") = Primitives::Circle3DFlag{}) .def("circle3d_wireframe", Primitives::circle3DWireframe, "Wireframe 3D circle", py::arg("segments")) .def("cone_solid", [](UnsignedInt rings, UnsignedInt segments, Float halfLength, Primitives::ConeFlag flags) { @@ -132,7 +154,7 @@ void primitives(py::module& m) { .def("grid3d_solid", [](const Vector2i& subdivisions, Primitives::GridFlag flags) { return Primitives::grid3DSolid(subdivisions, flags); - }, "Solid 3D grid", py::arg("subdivisions"), py::arg("flags") = Primitives::GridFlag::GenerateNormals) + }, "Solid 3D grid", py::arg("subdivisions"), py::arg("flags") = Primitives::GridFlag::Normals) .def("grid3d_wireframe", Primitives::grid3DWireframe, "Wireframe 3D grid") .def("icosphere_solid", Primitives::icosphereSolid, py::arg("subdivisions")) @@ -142,13 +164,19 @@ void primitives(py::module& m) { .def("line3d", static_cast(Primitives::line3D), "3D line", py::arg("a"), py::arg("b")) .def("line3d", static_cast(Primitives::line3D), "3D line in an identity transformation") - .def("plane_solid", Primitives::planeSolid, "Solid 3D plane", py::arg("texture_coords") = Primitives::PlaneTextureCoords::DontGenerate) + .def("plane_solid", [](Primitives::PlaneFlag flags) { + return Primitives::planeSolid(flags); + }, "Solid 3D plane", py::arg("flags") = Primitives::PlaneFlag{}) .def("plane_wireframe", Primitives::planeWireframe, "Wireframe 3D plane") - .def("square_solid", Primitives::squareSolid, "Solid 2D square", py::arg("texture_coords") = Primitives::SquareTextureCoords::DontGenerate) + .def("square_solid", [](Primitives::SquareFlag flags) { + return Primitives::squareSolid(flags); + }, "Solid 2D square", py::arg("flags") = Primitives::SquareFlag{}) .def("square_wireframe", Primitives::squareWireframe, "Wireframe 2D square") - .def("uv_sphere_solid", Primitives::uvSphereSolid, "Solid 3D UV sphere", py::arg("rings"), py::arg("segments"), py::arg("texture_coords") = Primitives::UVSphereTextureCoords::DontGenerate) + .def("uv_sphere_solid", [](UnsignedInt rings, UnsignedInt segments, Primitives::UVSphereFlag flags) { + return Primitives::uvSphereSolid(rings, segments, flags); + }, "Solid 3D UV sphere", py::arg("rings"), py::arg("segments"), py::arg("flags") = Primitives::UVSphereFlag{}) .def("uv_sphere_wireframe", Primitives::uvSphereWireframe, "Wireframe 3D UV sphere", py::arg("rings"), py::arg("segments")); } diff --git a/src/python/magnum/test/test_primitives.py b/src/python/magnum/test/test_primitives.py index 5730698..d7e523c 100644 --- a/src/python/magnum/test/test_primitives.py +++ b/src/python/magnum/test/test_primitives.py @@ -48,10 +48,10 @@ class Capsule(unittest.TestCase): self.assertEqual(a.attribute_count, 1) def test_3d_solid(self): - a = primitives.capsule3d_solid(3, 3, 10, 2.0, primitives.CapsuleTextureCoords.GENERATE) + a = primitives.capsule3d_solid(3, 3, 10, 2.0, primitives.CapsuleFlags.TEXTURE_COORDINATES|primitives.CapsuleFlags.TANGENTS) self.assertEqual(a.primitive, MeshPrimitive.TRIANGLES) self.assertTrue(a.is_indexed) - self.assertEqual(a.attribute_count, 3) + self.assertEqual(a.attribute_count, 4) b = primitives.capsule3d_solid(3, 3, 10, 2.0) self.assertEqual(b.primitive, MeshPrimitive.TRIANGLES) @@ -65,7 +65,7 @@ class Capsule(unittest.TestCase): class Circle(unittest.TestCase): def test_2d_solid(self): - a = primitives.circle2d_solid(5, primitives.CircleTextureCoords.GENERATE) + a = primitives.circle2d_solid(5, primitives.Circle2DFlags.TEXTURE_COORDINATES) self.assertEqual(a.primitive, MeshPrimitive.TRIANGLE_FAN) self.assertFalse(a.is_indexed) self.assertEqual(a.attribute_count, 2) @@ -81,10 +81,10 @@ class Circle(unittest.TestCase): self.assertFalse(a.is_indexed) def test_3d_solid(self): - a = primitives.circle3d_solid(5, primitives.CircleTextureCoords.GENERATE) + a = primitives.circle3d_solid(5, primitives.Circle3DFlags.TEXTURE_COORDINATES|primitives.Circle3DFlags.TANGENTS) self.assertEqual(a.primitive, MeshPrimitive.TRIANGLE_FAN) self.assertFalse(a.is_indexed) - self.assertEqual(a.attribute_count, 3) + self.assertEqual(a.attribute_count, 4) b = primitives.circle3d_solid(5) self.assertEqual(b.primitive, MeshPrimitive.TRIANGLE_FAN) @@ -98,7 +98,7 @@ class Circle(unittest.TestCase): class Cone(unittest.TestCase): def test_solid(self): - a = primitives.cone_solid(5, 7, 7.1, primitives.ConeFlags.GENERATE_TEXTURE_COORDS|primitives.ConeFlags.CAP_END) + a = primitives.cone_solid(5, 7, 7.1, primitives.ConeFlags.TEXTURE_COORDINATES|primitives.ConeFlags.CAP_END) self.assertEqual(a.primitive, MeshPrimitive.TRIANGLES) self.assertTrue(a.is_indexed) self.assertEqual(a.attribute_count, 3) @@ -142,7 +142,7 @@ class Cube(unittest.TestCase): class Cylinder(unittest.TestCase): def test_solid(self): - a = primitives.cylinder_solid(7, 12, 0.2, primitives.CylinderFlags.GENERATE_TEXTURE_COORDS|primitives.CylinderFlags.CAP_ENDS) + a = primitives.cylinder_solid(7, 12, 0.2, primitives.CylinderFlags.TEXTURE_COORDINATES|primitives.CylinderFlags.CAP_ENDS) self.assertEqual(a.primitive, MeshPrimitive.TRIANGLES) self.assertTrue(a.is_indexed) self.assertEqual(a.attribute_count, 3) @@ -196,9 +196,10 @@ class Gradient(unittest.TestCase): class Grid(unittest.TestCase): def test_solid(self): - a = primitives.grid3d_solid((4, 5)) + a = primitives.grid3d_solid((4, 5), primitives.GridFlags.NORMALS|primitives.GridFlags.TANGENTS) self.assertEqual(a.primitive, MeshPrimitive.TRIANGLES) self.assertTrue(a.is_indexed) + self.assertEqual(a.attribute_count, 3) def test_wireframe(self): a = primitives.grid3d_wireframe((2, 7)) @@ -234,10 +235,10 @@ class Line(unittest.TestCase): class Plane(unittest.TestCase): def test_solid(self): - a = primitives.plane_solid(primitives.PlaneTextureCoords.GENERATE) + a = primitives.plane_solid(primitives.PlaneFlags.TEXTURE_COORDINATES|primitives.PlaneFlags.TANGENTS) self.assertEqual(a.primitive, MeshPrimitive.TRIANGLE_STRIP) self.assertFalse(a.is_indexed) - self.assertEqual(a.attribute_count, 3) + self.assertEqual(a.attribute_count, 4) b = primitives.plane_solid() self.assertEqual(b.primitive, MeshPrimitive.TRIANGLE_STRIP) @@ -251,7 +252,7 @@ class Plane(unittest.TestCase): class Square(unittest.TestCase): def test_solid(self): - a = primitives.square_solid(primitives.SquareTextureCoords.GENERATE) + a = primitives.square_solid(primitives.SquareFlags.TEXTURE_COORDINATES) self.assertEqual(a.primitive, MeshPrimitive.TRIANGLE_STRIP) self.assertFalse(a.is_indexed) self.assertEqual(a.attribute_count, 2) @@ -268,10 +269,10 @@ class Square(unittest.TestCase): class UVSphere(unittest.TestCase): def test_solid(self): - a = primitives.uv_sphere_solid(3, 7, primitives.UVSphereTextureCoords.GENERATE) + a = primitives.uv_sphere_solid(3, 7, primitives.UVSphereFlags.TEXTURE_COORDINATES|primitives.UVSphereFlags.TANGENTS) self.assertEqual(a.primitive, MeshPrimitive.TRIANGLES) self.assertTrue(a.is_indexed) - self.assertEqual(a.attribute_count, 3) + self.assertEqual(a.attribute_count, 4) b = primitives.uv_sphere_solid(3, 7) self.assertEqual(b.primitive, MeshPrimitive.TRIANGLES)