python: add generic MeshPrimitive and MeshIndexType enums.

src/python/magnum/__init__.py

@@ -51,5 +51,7 @@ __all__ = [
     'Matrix4x2d', 'Matrix4x3d', 'Matrix4x4d',
     'Matrix3', 'Matrix4', 'Matrix3d', 'Matrix4d',
 
-    'Quaternion', 'Quaterniond'
+    'Quaternion', 'Quaterniond',
+
+    'MeshPrimitive', 'MeshIndexType'
 ]

src/python/magnum/gl.cpp

@@ -25,6 +25,7 @@
 
 #include <pybind11/pybind11.h>
 #include <Corrade/Containers/ArrayView.h>
+#include <Corrade/Utility/FormatStl.h>
 #include <Magnum/GL/AbstractShaderProgram.h>
 #include <Magnum/GL/Attribute.h>
 #include <Magnum/GL/Buffer.h>
@@ -40,6 +41,7 @@ namespace magnum { namespace {
 
 struct PyMesh: GL::Mesh {
     explicit PyMesh(GL::MeshPrimitive primitive): GL::Mesh(primitive) {}
+    explicit PyMesh(MeshPrimitive primitive): GL::Mesh(primitive) {}
 
     std::vector<py::object> buffers;
 };
@@ -219,9 +221,16 @@ void gl(py::module& m) {
 
     py::class_<PyMesh>{m, "Mesh", "Mesh"}
         .def(py::init<GL::MeshPrimitive>(), "Constructor", py::arg("primitive") = GL::MeshPrimitive::Triangles)
+        .def(py::init<MeshPrimitive>(), "Constructor")
         .def_property_readonly("id", &GL::Mesh::id, "OpenGL vertex array ID")
-        .def_property("primitive", &GL::Mesh::primitive, static_cast<GL::Mesh&(GL::Mesh::*)(GL::MeshPrimitive)>(&GL::Mesh::setPrimitive), "Primitive type")
-        /** @todo generic primitive overload */
+        .def_property("primitive", &GL::Mesh::primitive,
+            [](PyMesh& self, py::object primitive) {
+                if(py::isinstance<MeshPrimitive>(primitive))
+                    self.setPrimitive(py::cast<MeshPrimitive>(primitive));
+                else if(py::isinstance<GL::MeshPrimitive>(primitive))
+                    self.setPrimitive(py::cast<GL::MeshPrimitive>(primitive));
+                else throw py::type_error{Utility::formatString("expected MeshPrimitive or gl.MeshPrimitive, got {}", std::string(py::str{primitive.get_type()}))};
+            }, "Primitive type")
         /* Have to use a lambda because it returns GL::Mesh which is not
            tracked (unlike PyMesh) */
         .def_property("count", &GL::Mesh::count, [](PyMesh& self, UnsignedInt count) {

src/python/magnum/magnum.cpp

@@ -24,14 +24,37 @@
 */
 
 #include <pybind11/pybind11.h>
+#include <Magnum/Mesh.h>
 
 #include "magnum/bootstrap.h"
 
 namespace py = pybind11;
 
+namespace magnum { namespace {
+
+void magnum(py::module& m) {
+    py::enum_<MeshPrimitive>{m, "MeshPrimitive", "Mesh primitive type"}
+        .value("POINTS", MeshPrimitive::Points)
+        .value("LINES", MeshPrimitive::Lines)
+        .value("LINE_LOOP", MeshPrimitive::LineLoop)
+        .value("LINE_STRIP", MeshPrimitive::LineStrip)
+        .value("TRIANGLES", MeshPrimitive::Triangles)
+        .value("TRIANGLE_STRIP", MeshPrimitive::TriangleStrip)
+        .value("TRIANGLE_FAN", MeshPrimitive::TriangleFan);
+
+    py::enum_<MeshIndexType>{m, "MeshIndexType", "Mesh index type"}
+        .value("UNSIGNED_BYTE", MeshIndexType::UnsignedByte)
+        .value("UNSIGNED_SHORT", MeshIndexType::UnsignedShort)
+        .value("UNSIGNED_INT", MeshIndexType::UnsignedInt);
+}
+
+}}
+
 PYBIND11_MODULE(_magnum, m) {
     m.doc() = "Root Magnum module";
 
+    magnum::magnum(m);
+
     py::module math = m.def_submodule("math");
     magnum::math(m, math);
 }

src/python/magnum/test/test_gl_gl.py

@@ -30,6 +30,7 @@ import unittest
 # be run
 from . import GLTestCase, setUpModule
 
+from magnum import *
 from magnum import gl
 
 class Buffer(GLTestCase):
@@ -53,9 +54,30 @@ class DefaultFramebuffer(GLTestCase):
 
 class Mesh(GLTestCase):
     def test_init(self):
-        a = gl.Mesh(gl.MeshPrimitive.LINE_LOOP)
+        a = gl.Mesh()
+        b = gl.Mesh(gl.MeshPrimitive.LINE_LOOP)
+        c = gl.Mesh(MeshPrimitive.LINES)
         self.assertNotEqual(a.id, 0)
-        self.assertEqual(a.primitive, gl.MeshPrimitive.LINE_LOOP)
+        self.assertNotEqual(b.id, 0)
+        self.assertNotEqual(c.id, 0)
+        self.assertEqual(a.primitive, gl.MeshPrimitive.TRIANGLES)
+        self.assertEqual(b.primitive, gl.MeshPrimitive.LINE_LOOP)
+        self.assertEqual(c.primitive, gl.MeshPrimitive.LINES)
+
+    def test_set_primitive(self):
+        a = gl.Mesh()
+
+        a.primitive = gl.MeshPrimitive.TRIANGLE_STRIP
+        self.assertEqual(a.primitive, gl.MeshPrimitive.TRIANGLE_STRIP)
+
+        a.primitive = MeshPrimitive.POINTS
+        self.assertEqual(a.primitive, gl.MeshPrimitive.POINTS)
+
+    def test_set_primitive_invalid(self):
+        a = gl.Mesh()
+
+        with self.assertRaisesRegex(TypeError, "expected MeshPrimitive or gl.MeshPrimitive, got <class 'str'>"):
+            a.primitive = "ahaha"
 
     def test_set_count(self):
         a = gl.Mesh()