diff --git a/doc/python/magnum.shaders.rst b/doc/python/magnum.shaders.rst index 9e14627..edd8e83 100644 --- a/doc/python/magnum.shaders.rst +++ b/doc/python/magnum.shaders.rst @@ -23,43 +23,43 @@ DEALINGS IN THE SOFTWARE. .. -.. py:class:: magnum.shaders.Flat2D +.. py:class:: magnum.shaders.FlatGL2D :data POSITION: Vertex position :data TEXTURE_COORDINATES: 2D texture coordinates :data COLOR3: Three-component vertex color :data COLOR4: Four-component vertex color -.. py:class:: magnum.shaders.Flat3D +.. py:class:: magnum.shaders.FlatGL3D :data POSITION: Vertex position :data TEXTURE_COORDINATES: 2D texture coordinates :data COLOR3: Three-component vertex color :data COLOR4: Four-component vertex color -.. py:property:: magnum.shaders.Flat2D.alpha_mask +.. py:property:: magnum.shaders.FlatGL2D.alpha_mask :raise AttributeError: If the shader was not created with :ref:`Flags.ALPHA_MASK` -.. py:property:: magnum.shaders.Flat3D.alpha_mask +.. py:property:: magnum.shaders.FlatGL3D.alpha_mask :raise AttributeError: If the shader was not created with :ref:`Flags.ALPHA_MASK` -.. py:function:: magnum.shaders.Flat2D.bind_texture +.. py:function:: magnum.shaders.FlatGL2D.bind_texture :raise AttributeError: If the shader was not created with :ref:`Flags.TEXTURED` -.. py:function:: magnum.shaders.Flat3D.bind_texture +.. py:function:: magnum.shaders.FlatGL3D.bind_texture :raise AttributeError: If the shader was not created with :ref:`Flags.TEXTURED` -.. py:class:: magnum.shaders.VertexColor2D +.. py:class:: magnum.shaders.VertexColorGL2D :data POSITION: Vertex position :data COLOR3: Three-component vertex color :data COLOR4: Four-component vertex color -.. py:class:: magnum.shaders.VertexColor3D +.. py:class:: magnum.shaders.VertexColorGL3D :data POSITION: Vertex position :data COLOR3: Three-component vertex color :data COLOR4: Four-component vertex color -.. py:class:: magnum.shaders.Phong +.. py:class:: magnum.shaders.PhongGL :data POSITION: Vertex position :data NORMAL: Normal direction :data TANGENT: Tangent direction @@ -72,36 +72,35 @@ :data NORMAL_MATRIX: (Instanced) normal matrix :data TEXTURE_OFFSET: (Instanced) texture offset -.. py:property:: magnum.shaders.Phong.normal_texture_scale +.. py:property:: magnum.shaders.PhongGL.normal_texture_scale :raise AttributeError: If the shader was not created with :ref:`Flags.NORMAL_TEXTURE` -.. py:property:: magnum.shaders.Phong.alpha_mask +.. py:property:: magnum.shaders.PhongGL.alpha_mask :raise AttributeError: If the shader was not created with :ref:`Flags.ALPHA_MASK` -.. py:property:: magnum.shaders.Phong.texture_matrix +.. py:property:: magnum.shaders.PhongGL.texture_matrix :raise AttributeError: If the shader was not created with :ref:`Flags.TEXTURE_TRANSFORMATION` -.. py:property:: magnum.shaders.Phong.light_positions +.. py:property:: magnum.shaders.PhongGL.light_positions :raise ValueError: If list length is different from :ref:`light_count` -.. py:property:: magnum.shaders.Phong.light_colors +.. py:property:: magnum.shaders.PhongGL.light_colors :raise ValueError: If list length is different from :ref:`light_count` -.. py:property:: magnum.shaders.Phong.light_ranges +.. py:property:: magnum.shaders.PhongGL.light_ranges :raise ValueError: If list length is different from :ref:`light_count` -.. py:function:: magnum.shaders.Phong.bind_ambient_texture +.. py:function:: magnum.shaders.PhongGL.bind_ambient_texture :raise AttributeError: If the shader was not created with :ref:`Flags.AMBIENT_TEXTURE` -.. py:function:: magnum.shaders.Phong.bind_diffuse_texture +.. py:function:: magnum.shaders.PhongGL.bind_diffuse_texture :raise AttributeError: If the shader was not created with :ref:`Flags.DIFFUSE_TEXTURE` -.. py:function:: magnum.shaders.Phong.bind_specular_texture +.. py:function:: magnum.shaders.PhongGL.bind_specular_texture :raise AttributeError: If the shader was not created with :ref:`Flags.SPECULAR_TEXTURE` -.. py:function:: magnum.shaders.Phong.bind_normal_texture +.. py:function:: magnum.shaders.PhongGL.bind_normal_texture :raise AttributeError: If the shader was not created with :ref:`Flags.NORMAL_TEXTURE` -.. py:function:: magnum.shaders.Phong.bind_textures +.. py:function:: magnum.shaders.PhongGL.bind_textures :raise AttributeError: If the shader was not created with any of :ref:`Flags.AMBIENT_TEXTURE`, :ref:`Flags.DIFFUSE_TEXTURE`, :ref:`Flags.SPECULAR_TEXTURE` or :ref:`Flags.NORMAL_TEXTURE` - diff --git a/doc/python/pages/changelog.rst b/doc/python/pages/changelog.rst index fa62f53..5e0de88 100644 --- a/doc/python/pages/changelog.rst +++ b/doc/python/pages/changelog.rst @@ -44,7 +44,7 @@ Changelog - Exposed :ref:`gl.Renderer.Feature.CLIP_DISTANCEn ` values that are new since 2020.06 - Exposed new instancing, normal-mapping-related and lighting features in - :ref:`shaders.Phong` + :ref:`shaders.PhongGL` - Renamed all helper ``Python.h`` headers to ``PythonBindings.h`` to avoid issues with shitty IDE indexers such as Eclipse, confusing these with Python's ```` diff --git a/src/python/magnum/shaders.cpp b/src/python/magnum/shaders.cpp index 95c021c..745fda7 100644 --- a/src/python/magnum/shaders.cpp +++ b/src/python/magnum/shaders.cpp @@ -31,9 +31,9 @@ #include #include #include -#include -#include -#include +#include +#include +#include #include "Corrade/PythonBindings.h" @@ -48,34 +48,34 @@ template void anyShader(PyNonDestructibleClass(&GL::AbstractShaderProgram::draw), "Draw a mesh"); } -template void flat(PyNonDestructibleClass, GL::AbstractShaderProgram>& c) { +template void flat(PyNonDestructibleClass, GL::AbstractShaderProgram>& c) { /* Attributes */ - c.attr("TEXTURE_COORDINATES") = GL::DynamicAttribute{typename Shaders::Flat::TextureCoordinates{}}; - c.attr("COLOR3") = GL::DynamicAttribute{typename Shaders::Flat::Color3{}}; - c.attr("COLOR4") = GL::DynamicAttribute{typename Shaders::Flat::Color4{}}; + c.attr("TEXTURE_COORDINATES") = GL::DynamicAttribute{typename Shaders::FlatGL::TextureCoordinates{}}; + c.attr("COLOR3") = GL::DynamicAttribute{typename Shaders::FlatGL::Color3{}}; + c.attr("COLOR4") = GL::DynamicAttribute{typename Shaders::FlatGL::Color4{}}; /* Methods */ c - .def(py::init::Flag>(), "Constructor", - py::arg("flags") = typename Shaders::Flat::Flag{}) + .def(py::init::Flag>(), "Constructor", + py::arg("flags") = typename Shaders::FlatGL::Flag{}) /* Using lambdas to avoid method chaining getting into signatures */ - .def_property_readonly("flags", [](Shaders::Flat& self) { - return typename Shaders::Flat::Flag(UnsignedByte(self.flags())); + .def_property_readonly("flags", [](Shaders::FlatGL& self) { + return typename Shaders::FlatGL::Flag(UnsignedByte(self.flags())); }, "Flags") - .def_property("transformation_projection_matrix", nullptr, &Shaders::Flat::setTransformationProjectionMatrix, + .def_property("transformation_projection_matrix", nullptr, &Shaders::FlatGL::setTransformationProjectionMatrix, "Transformation and projection matrix") - .def_property("color", nullptr, &Shaders::Flat::setColor, "Color") - .def_property("alpha_mask", nullptr, [](Shaders::Flat& self, Float mask) { - if(!(self.flags() & Shaders::Flat::Flag::AlphaMask)) { + .def_property("color", nullptr, &Shaders::FlatGL::setColor, "Color") + .def_property("alpha_mask", nullptr, [](Shaders::FlatGL& self, Float mask) { + if(!(self.flags() & Shaders::FlatGL::Flag::AlphaMask)) { PyErr_SetString(PyExc_AttributeError, "the shader was not created with alpha mask enabled"); throw py::error_already_set{}; } self.setAlphaMask(mask); }, "Alpha mask") - .def("bind_texture", [](Shaders::Flat& self, GL::Texture2D& texture) { - if(!(self.flags() & Shaders::Flat::Flag::Textured)) { + .def("bind_texture", [](Shaders::FlatGL& self, GL::Texture2D& texture) { + if(!(self.flags() & Shaders::FlatGL::Flag::Textured)) { PyErr_SetString(PyExc_AttributeError, "the shader was not created with texturing enabled"); throw py::error_already_set{}; } @@ -86,10 +86,10 @@ template void flat(PyNonDestructibleClass void vertexColor(PyNonDestructibleClass, GL::AbstractShaderProgram>& c) { +template void vertexColor(PyNonDestructibleClass, GL::AbstractShaderProgram>& c) { /* Attributes */ - c.attr("COLOR3") = GL::DynamicAttribute{typename Shaders::VertexColor::Color3{}}; - c.attr("COLOR4") = GL::DynamicAttribute{typename Shaders::VertexColor::Color4{}}; + c.attr("COLOR3") = GL::DynamicAttribute{typename Shaders::VertexColorGL::Color3{}}; + c.attr("COLOR4") = GL::DynamicAttribute{typename Shaders::VertexColorGL::Color4{}}; /* Methods */ c @@ -97,7 +97,7 @@ template void vertexColor(PyNonDestructibleClass::setTransformationProjectionMatrix, + .def_property("transformation_projection_matrix", nullptr, &Shaders::VertexColorGL::setTransformationProjectionMatrix, "Transformation and projection matrix"); anyShader(c); @@ -116,28 +116,28 @@ void shaders(py::module_& m) { /* 2D/3D flat shader */ { - PyNonDestructibleClass flat2D{m, - "Flat2D", "2D flat shader"}; - PyNonDestructibleClass flat3D{m, - "Flat3D", "3D flat shader"}; - flat2D.attr("POSITION") = GL::DynamicAttribute{Shaders::Flat2D::Position{}}; - flat3D.attr("POSITION") = GL::DynamicAttribute{Shaders::Flat3D::Position{}}; + PyNonDestructibleClass flatGL2D{m, + "FlatGL2D", "2D flat OpenGL shader"}; + PyNonDestructibleClass flatGL3D{m, + "FlatGL3D", "3D flat shader"}; + flatGL2D.attr("POSITION") = GL::DynamicAttribute{Shaders::FlatGL2D::Position{}}; + flatGL3D.attr("POSITION") = GL::DynamicAttribute{Shaders::FlatGL3D::Position{}}; /* The flags are currently the same type for both 2D and 3D and pybind doesn't want to have a single type registered twice, so doing it this way instead */ - py::enum_ flags{flat2D, "Flags", "Flags"}; + py::enum_ flags{flatGL2D, "Flags", "Flags"}; flags - .value("TEXTURED", Shaders::Flat2D::Flag::Textured) - .value("ALPHA_MASK", Shaders::Flat2D::Flag::AlphaMask) - .value("VERTEX_COLOR", Shaders::Flat3D::Flag::AlphaMask) - .value("NONE", Shaders::Flat3D::Flag{}) + .value("TEXTURED", Shaders::FlatGL2D::Flag::Textured) + .value("ALPHA_MASK", Shaders::FlatGL2D::Flag::AlphaMask) + .value("VERTEX_COLOR", Shaders::FlatGL3D::Flag::AlphaMask) + .value("NONE", Shaders::FlatGL3D::Flag{}) /* TODO: OBJECT_ID, once multiple FB outputs and mapDraw is exposed */ ; - flat3D.attr("Flags") = flags; + flatGL3D.attr("Flags") = flags; - flat(flat2D); - flat(flat3D); + flat(flatGL2D); + flat(flatGL3D); corrade::enumOperators(flags); @@ -145,79 +145,79 @@ void shaders(py::module_& m) { /* 2D/3D vertex color shader */ { - PyNonDestructibleClass vertexColor2D{m, - "VertexColor2D", "2D vertex color shader"}; - PyNonDestructibleClass vertexColor3D{m, - "VertexColor3D", "3D vertex color shader"}; - vertexColor2D.attr("POSITION") = GL::DynamicAttribute{Shaders::VertexColor2D::Position{}}; - vertexColor3D.attr("POSITION") = GL::DynamicAttribute{Shaders::VertexColor3D::Position{}}; - vertexColor(vertexColor2D); - vertexColor(vertexColor3D); + PyNonDestructibleClass vertexColorGL2D{m, + "VertexColorGL2D", "2D vertex color shader"}; + PyNonDestructibleClass vertexColorGL3D{m, + "VertexColorGL3D", "3D vertex color shader"}; + vertexColorGL2D.attr("POSITION") = GL::DynamicAttribute{Shaders::VertexColorGL2D::Position{}}; + vertexColorGL3D.attr("POSITION") = GL::DynamicAttribute{Shaders::VertexColorGL3D::Position{}}; + vertexColor(vertexColorGL2D); + vertexColor(vertexColorGL3D); } /* Phong shader */ { - PyNonDestructibleClass phong{m, - "Phong", "Phong shader"}; - phong.attr("POSITION") = GL::DynamicAttribute{Shaders::Phong::Position{}}; - phong.attr("NORMAL") = GL::DynamicAttribute{Shaders::Phong::Normal{}}; - phong.attr("TANGENT") = GL::DynamicAttribute{Shaders::Phong::Tangent{}}; - phong.attr("TANGENT4") = GL::DynamicAttribute{Shaders::Phong::Tangent4{}}; - phong.attr("BITANGENT") = GL::DynamicAttribute{Shaders::Phong::Bitangent{}}; - phong.attr("TEXTURE_COORDINATES") = GL::DynamicAttribute{Shaders::Phong::TextureCoordinates{}}; - phong.attr("COLOR3") = GL::DynamicAttribute{Shaders::Phong::Color3{}}; - phong.attr("COLOR4") = GL::DynamicAttribute{Shaders::Phong::Color4{}}; + PyNonDestructibleClass phongGL{m, + "PhongGL", "Phong shader"}; + phongGL.attr("POSITION") = GL::DynamicAttribute{Shaders::PhongGL::Position{}}; + phongGL.attr("NORMAL") = GL::DynamicAttribute{Shaders::PhongGL::Normal{}}; + phongGL.attr("TANGENT") = GL::DynamicAttribute{Shaders::PhongGL::Tangent{}}; + phongGL.attr("TANGENT4") = GL::DynamicAttribute{Shaders::PhongGL::Tangent4{}}; + phongGL.attr("BITANGENT") = GL::DynamicAttribute{Shaders::PhongGL::Bitangent{}}; + phongGL.attr("TEXTURE_COORDINATES") = GL::DynamicAttribute{Shaders::PhongGL::TextureCoordinates{}}; + phongGL.attr("COLOR3") = GL::DynamicAttribute{Shaders::PhongGL::Color3{}}; + phongGL.attr("COLOR4") = GL::DynamicAttribute{Shaders::PhongGL::Color4{}}; /* TODO: OBJECT_ID attribute, once multiple FB outputs and mapDraw is exposed */ - phong.attr("TRANSFORMATION_MATRIX") = GL::DynamicAttribute{Shaders::Phong::TransformationMatrix{}}; - phong.attr("NORMAL_MATRIX") = GL::DynamicAttribute{Shaders::Phong::NormalMatrix{}}; - phong.attr("TEXTURE_OFFSET") = GL::DynamicAttribute{Shaders::Phong::TextureOffset{}}; + phongGL.attr("TRANSFORMATION_MATRIX") = GL::DynamicAttribute{Shaders::PhongGL::TransformationMatrix{}}; + phongGL.attr("NORMAL_MATRIX") = GL::DynamicAttribute{Shaders::PhongGL::NormalMatrix{}}; + phongGL.attr("TEXTURE_OFFSET") = GL::DynamicAttribute{Shaders::PhongGL::TextureOffset{}}; - py::enum_ flags{phong, "Flags", "Flags"}; + py::enum_ flags{phongGL, "Flags", "Flags"}; flags - .value("AMBIENT_TEXTURE", Shaders::Phong::Flag::AmbientTexture) - .value("DIFFUSE_TEXTURE", Shaders::Phong::Flag::DiffuseTexture) - .value("SPECULAR_TEXTURE", Shaders::Phong::Flag::SpecularTexture) - .value("NORMAL_TEXTURE", Shaders::Phong::Flag::NormalTexture) - .value("ALPHA_MASK", Shaders::Phong::Flag::AlphaMask) - .value("VERTEX_COLOR", Shaders::Phong::Flag::VertexColor) - .value("BITANGENT", Shaders::Phong::Flag::Bitangent) - .value("TEXTURE_TRANSFORMATION", Shaders::Phong::Flag::TextureTransformation) + .value("AMBIENT_TEXTURE", Shaders::PhongGL::Flag::AmbientTexture) + .value("DIFFUSE_TEXTURE", Shaders::PhongGL::Flag::DiffuseTexture) + .value("SPECULAR_TEXTURE", Shaders::PhongGL::Flag::SpecularTexture) + .value("NORMAL_TEXTURE", Shaders::PhongGL::Flag::NormalTexture) + .value("ALPHA_MASK", Shaders::PhongGL::Flag::AlphaMask) + .value("VERTEX_COLOR", Shaders::PhongGL::Flag::VertexColor) + .value("BITANGENT", Shaders::PhongGL::Flag::Bitangent) + .value("TEXTURE_TRANSFORMATION", Shaders::PhongGL::Flag::TextureTransformation) /* TODO: OBJECT_ID, once multiple FB outputs and mapDraw is exposed */ - .value("INSTANCED_TRANSFORMATION", Shaders::Phong::Flag::InstancedTransformation) - .value("INSTANCED_TEXTURE_OFFSET", Shaders::Phong::Flag::InstancedTextureOffset) - .value("NONE", Shaders::Phong::Flag{}) + .value("INSTANCED_TRANSFORMATION", Shaders::PhongGL::Flag::InstancedTransformation) + .value("INSTANCED_TEXTURE_OFFSET", Shaders::PhongGL::Flag::InstancedTextureOffset) + .value("NONE", Shaders::PhongGL::Flag{}) ; corrade::enumOperators(flags); - phong - .def(py::init(), "Constructor", - py::arg("flags") = Shaders::Phong::Flag{}, + phongGL + .def(py::init(), "Constructor", + py::arg("flags") = Shaders::PhongGL::Flag{}, py::arg("light_count") = 1) - .def_property_readonly("flags", [](Shaders::Phong& self) { - return Shaders::Phong::Flag(UnsignedShort(self.flags())); + .def_property_readonly("flags", [](Shaders::PhongGL& self) { + return Shaders::PhongGL::Flag(UnsignedShort(self.flags())); }, "Flags") - .def_property_readonly("light_count", &Shaders::Phong::lightCount, + .def_property_readonly("light_count", &Shaders::PhongGL::lightCount, "Light count") .def_property("ambient_color", nullptr, - &Shaders::Phong::setAmbientColor, "Ambient color") + &Shaders::PhongGL::setAmbientColor, "Ambient color") .def_property("diffuse_color", nullptr, - &Shaders::Phong::setDiffuseColor, "Diffuse color") + &Shaders::PhongGL::setDiffuseColor, "Diffuse color") .def_property("specular_color", nullptr, - &Shaders::Phong::setSpecularColor, "Specular color") + &Shaders::PhongGL::setSpecularColor, "Specular color") .def_property("shininess", nullptr, - &Shaders::Phong::setShininess, "Shininess") - .def_property("normal_texture_scale", nullptr, [](Shaders::Phong& self, Float scale) { - if(!(self.flags() & Shaders::Phong::Flag::NormalTexture)) { + &Shaders::PhongGL::setShininess, "Shininess") + .def_property("normal_texture_scale", nullptr, [](Shaders::PhongGL& self, Float scale) { + if(!(self.flags() & Shaders::PhongGL::Flag::NormalTexture)) { PyErr_SetString(PyExc_AttributeError, "the shader was not created with normal texture enabled"); throw py::error_already_set{}; } self.setNormalTextureScale(scale); }, "Normal texture scale") - .def_property("alpha_mask", nullptr, [](Shaders::Phong& self, Float mask) { - if(!(self.flags() & Shaders::Phong::Flag::AlphaMask)) { + .def_property("alpha_mask", nullptr, [](Shaders::PhongGL& self, Float mask) { + if(!(self.flags() & Shaders::PhongGL::Flag::AlphaMask)) { PyErr_SetString(PyExc_AttributeError, "the shader was not created with alpha mask enabled"); throw py::error_already_set{}; } @@ -225,20 +225,20 @@ void shaders(py::module_& m) { self.setAlphaMask(mask); }, "Alpha mask") .def_property("transformation_matrix", nullptr, - &Shaders::Phong::setTransformationMatrix, "Transformation matrix") + &Shaders::PhongGL::setTransformationMatrix, "Transformation matrix") .def_property("normal_matrix", nullptr, - &Shaders::Phong::setNormalMatrix, "Normal matrix") + &Shaders::PhongGL::setNormalMatrix, "Normal matrix") .def_property("projection_matrix", nullptr, - &Shaders::Phong::setProjectionMatrix, "Projection matrix") - .def_property("texture_matrix", nullptr, [](Shaders::Phong& self, const Matrix3& matrix) { - if(!(self.flags() & Shaders::Phong::Flag::TextureTransformation)) { + &Shaders::PhongGL::setProjectionMatrix, "Projection matrix") + .def_property("texture_matrix", nullptr, [](Shaders::PhongGL& self, const Matrix3& matrix) { + if(!(self.flags() & Shaders::PhongGL::Flag::TextureTransformation)) { PyErr_SetString(PyExc_AttributeError, "the shader was not created with texture transformation enabled"); throw py::error_already_set{}; } self.setTextureMatrix(matrix); }, "Texture matrix") - .def_property("light_positions", nullptr, [](Shaders::Phong& self, const std::vector& positions) { + .def_property("light_positions", nullptr, [](Shaders::PhongGL& self, const std::vector& positions) { if(positions.size() != self.lightCount()) { PyErr_Format(PyExc_ValueError, "expected %u items but got %u", self.lightCount(), UnsignedInt(positions.size())); throw py::error_already_set{}; @@ -246,7 +246,7 @@ void shaders(py::module_& m) { self.setLightPositions(positions); }, "Light positions") - .def_property("light_colors", nullptr, [](Shaders::Phong& self, const std::vector& colors) { + .def_property("light_colors", nullptr, [](Shaders::PhongGL& self, const std::vector& colors) { if(colors.size() != self.lightCount()) { PyErr_Format(PyExc_ValueError, "expected %u items but got %u", self.lightCount(), UnsignedInt(colors.size())); throw py::error_already_set{}; @@ -254,7 +254,7 @@ void shaders(py::module_& m) { self.setLightColors(colors); }, "Light colors") - .def_property("light_specular_colors", nullptr, [](Shaders::Phong& self, const std::vector& colors) { + .def_property("light_specular_colors", nullptr, [](Shaders::PhongGL& self, const std::vector& colors) { if(colors.size() != self.lightCount()) { PyErr_Format(PyExc_ValueError, "expected %u items but got %u", self.lightCount(), UnsignedInt(colors.size())); throw py::error_already_set{}; @@ -262,7 +262,7 @@ void shaders(py::module_& m) { self.setLightSpecularColors(colors); }, "Light specular colors") - .def_property("light_ranges", nullptr, [](Shaders::Phong& self, const std::vector& ranges) { + .def_property("light_ranges", nullptr, [](Shaders::PhongGL& self, const std::vector& ranges) { if(ranges.size() != self.lightCount()) { PyErr_Format(PyExc_ValueError, "expected %u items but got %u", self.lightCount(), UnsignedInt(ranges.size())); throw py::error_already_set{}; @@ -271,40 +271,40 @@ void shaders(py::module_& m) { self.setLightRanges(ranges); }, "Light ranges") - .def("bind_ambient_texture", [](Shaders::Phong& self, GL::Texture2D& texture) { - if(!(self.flags() & Shaders::Phong::Flag::AmbientTexture)) { + .def("bind_ambient_texture", [](Shaders::PhongGL& self, GL::Texture2D& texture) { + if(!(self.flags() & Shaders::PhongGL::Flag::AmbientTexture)) { PyErr_SetString(PyExc_AttributeError, "the shader was not created with ambient texture enabled"); throw py::error_already_set{}; } self.bindAmbientTexture(texture); }, "Bind an ambient texture") - .def("bind_diffuse_texture", [](Shaders::Phong& self, GL::Texture2D& texture) { - if(!(self.flags() & Shaders::Phong::Flag::DiffuseTexture)) { + .def("bind_diffuse_texture", [](Shaders::PhongGL& self, GL::Texture2D& texture) { + if(!(self.flags() & Shaders::PhongGL::Flag::DiffuseTexture)) { PyErr_SetString(PyExc_AttributeError, "the shader was not created with diffuse texture enabled"); throw py::error_already_set{}; } self.bindDiffuseTexture(texture); }, "Bind a diffuse texture") - .def("bind_specular_texture", [](Shaders::Phong& self, GL::Texture2D& texture) { - if(!(self.flags() & Shaders::Phong::Flag::SpecularTexture)) { + .def("bind_specular_texture", [](Shaders::PhongGL& self, GL::Texture2D& texture) { + if(!(self.flags() & Shaders::PhongGL::Flag::SpecularTexture)) { PyErr_SetString(PyExc_AttributeError, "the shader was not created with specular texture enabled"); throw py::error_already_set{}; } self.bindSpecularTexture(texture); }, "Bind a specular texture") - .def("bind_normal_texture", [](Shaders::Phong& self, GL::Texture2D& texture) { - if(!(self.flags() & Shaders::Phong::Flag::NormalTexture)) { + .def("bind_normal_texture", [](Shaders::PhongGL& self, GL::Texture2D& texture) { + if(!(self.flags() & Shaders::PhongGL::Flag::NormalTexture)) { PyErr_SetString(PyExc_AttributeError, "the shader was not created with normal texture enabled"); throw py::error_already_set{}; } self.bindNormalTexture(texture); }, "Bind a normal texture") - .def("bind_textures", [](Shaders::Phong& self, GL::Texture2D* ambient, GL::Texture2D* diffuse, GL::Texture2D* specular, GL::Texture2D* normal) { - if(!(self.flags() & (Shaders::Phong::Flag::AmbientTexture|Shaders::Phong::Flag::DiffuseTexture|Shaders::Phong::Flag::SpecularTexture|Shaders::Phong::Flag::NormalTexture))) { + .def("bind_textures", [](Shaders::PhongGL& self, GL::Texture2D* ambient, GL::Texture2D* diffuse, GL::Texture2D* specular, GL::Texture2D* normal) { + if(!(self.flags() & (Shaders::PhongGL::Flag::AmbientTexture|Shaders::PhongGL::Flag::DiffuseTexture|Shaders::PhongGL::Flag::SpecularTexture|Shaders::PhongGL::Flag::NormalTexture))) { PyErr_SetString(PyExc_AttributeError, "the shader was not created with any textures enabled"); throw py::error_already_set{}; } @@ -313,7 +313,7 @@ void shaders(py::module_& m) { }, "Bind textures", py::arg("ambient") = nullptr, py::arg("diffuse") = nullptr, py::arg("specular") = nullptr, py::arg("normal") = nullptr) ; - anyShader(phong); + anyShader(phongGL); } } diff --git a/src/python/magnum/test/test_shaders_gl.py b/src/python/magnum/test/test_shaders_gl.py index 506c88f..760d8ea 100644 --- a/src/python/magnum/test/test_shaders_gl.py +++ b/src/python/magnum/test/test_shaders_gl.py @@ -32,16 +32,16 @@ from . import GLTestCase, setUpModule from magnum import * from magnum import gl, shaders -class Flat(GLTestCase): +class FlatGL(GLTestCase): def test_init(self): - a = shaders.Flat3D() - self.assertEqual(a.flags, shaders.Flat3D.Flags.NONE) + a = shaders.FlatGL3D() + self.assertEqual(a.flags, shaders.FlatGL3D.Flags.NONE) - b = shaders.Flat3D(shaders.Flat3D.Flags.TEXTURED|shaders.Flat3D.Flags.ALPHA_MASK) - self.assertEqual(b.flags, shaders.Flat3D.Flags.TEXTURED|shaders.Flat3D.Flags.ALPHA_MASK) + b = shaders.FlatGL3D(shaders.FlatGL3D.Flags.TEXTURED|shaders.FlatGL3D.Flags.ALPHA_MASK) + self.assertEqual(b.flags, shaders.FlatGL3D.Flags.TEXTURED|shaders.FlatGL3D.Flags.ALPHA_MASK) def test_uniforms_bindings(self): - a = shaders.Flat3D(shaders.Flat3D.Flags.TEXTURED|shaders.Flat3D.Flags.ALPHA_MASK) + a = shaders.FlatGL3D(shaders.FlatGL3D.Flags.TEXTURED|shaders.FlatGL3D.Flags.ALPHA_MASK) a.color = (0.5, 1.0, 0.9) a.transformation_projection_matrix = Matrix4.translation(Vector3.x_axis()) a.alpha_mask = 0.3 @@ -51,7 +51,7 @@ class Flat(GLTestCase): a.bind_texture(texture) def test_uniforms_bindings_errors(self): - a = shaders.Flat2D() + a = shaders.FlatGL2D() with self.assertRaisesRegex(AttributeError, "the shader was not created with alpha mask enabled"): a.alpha_mask = 0.3 @@ -59,33 +59,33 @@ class Flat(GLTestCase): with self.assertRaisesRegex(AttributeError, "the shader was not created with texturing enabled"): a.bind_texture(texture) -class VertexColor(GLTestCase): +class VertexColorGL(GLTestCase): def test_init(self): - a = shaders.VertexColor2D() - b = shaders.VertexColor3D() + a = shaders.VertexColorGL2D() + b = shaders.VertexColorGL3D() def test_uniforms(self): - a = shaders.VertexColor2D() + a = shaders.VertexColorGL2D() a.transformation_projection_matrix = ( Matrix3.translation(Vector2.x_axis())@ Matrix3.rotation(Deg(35.0))) -class Phong(GLTestCase): +class PhongGL(GLTestCase): def test_init(self): - a = shaders.Phong() - self.assertEqual(a.flags, shaders.Phong.Flags.NONE) + a = shaders.PhongGL() + self.assertEqual(a.flags, shaders.PhongGL.Flags.NONE) self.assertEqual(a.light_count, 1) - b = shaders.Phong(shaders.Phong.Flags.DIFFUSE_TEXTURE|shaders.Phong.Flags.ALPHA_MASK) - self.assertEqual(b.flags, shaders.Phong.Flags.DIFFUSE_TEXTURE|shaders.Phong.Flags.ALPHA_MASK) + b = shaders.PhongGL(shaders.PhongGL.Flags.DIFFUSE_TEXTURE|shaders.PhongGL.Flags.ALPHA_MASK) + self.assertEqual(b.flags, shaders.PhongGL.Flags.DIFFUSE_TEXTURE|shaders.PhongGL.Flags.ALPHA_MASK) self.assertEqual(b.light_count, 1) - c = shaders.Phong(shaders.Phong.Flags.NONE, 3) - self.assertEqual(c.flags, shaders.Phong.Flags.NONE) + c = shaders.PhongGL(shaders.PhongGL.Flags.NONE, 3) + self.assertEqual(c.flags, shaders.PhongGL.Flags.NONE) self.assertEqual(c.light_count, 3) def test_uniforms_bindings(self): - a = shaders.Phong(shaders.Phong.Flags.ALPHA_MASK|shaders.Phong.Flags.AMBIENT_TEXTURE|shaders.Phong.Flags.DIFFUSE_TEXTURE|shaders.Phong.Flags.SPECULAR_TEXTURE|shaders.Phong.Flags.NORMAL_TEXTURE|shaders.Phong.Flags.TEXTURE_TRANSFORMATION, 2) + a = shaders.PhongGL(shaders.PhongGL.Flags.ALPHA_MASK|shaders.PhongGL.Flags.AMBIENT_TEXTURE|shaders.PhongGL.Flags.DIFFUSE_TEXTURE|shaders.PhongGL.Flags.SPECULAR_TEXTURE|shaders.PhongGL.Flags.NORMAL_TEXTURE|shaders.PhongGL.Flags.TEXTURE_TRANSFORMATION, 2) a.diffuse_color = (0.5, 1.0, 0.9) a.transformation_matrix = Matrix4.translation(Vector3.x_axis()) a.projection_matrix = Matrix4.zero_init() @@ -106,7 +106,7 @@ class Phong(GLTestCase): a.bind_textures(ambient=texture, diffuse=texture, specular=texture, normal=texture) def test_uniforms_bindings_errors(self): - a = shaders.Phong() + a = shaders.PhongGL() with self.assertRaisesRegex(AttributeError, "the shader was not created with normal texture enabled"): a.normal_texture_scale = 0.3 with self.assertRaisesRegex(AttributeError, "the shader was not created with alpha mask enabled"):