ic
/
magnum-bindings
6
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
Browse Source

python: fix inconsistencies in bound Flat and Phong feature sets. 

Phong has instancing and texture transformation so Flat should have that
too. Also fixed a bunch of doc omissions; there's no need to bind the
POSITION attribute the hard way either.
pull/16/head
Vladimír Vondruš 4 years ago
parent
c2499fea34
commit
9b60dd30b0
5 changed files with 51 additions and 17 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. 14
      doc/python/conf.py
  2. 11
      doc/python/magnum.shaders.rst
  3. 6
      doc/python/pages/changelog.rst
  4. 32
      src/python/magnum/shaders.cpp
  5. 5
      src/python/magnum/test/test_shaders_gl.py

14
doc/python/conf.py
Unescape View File

@ -76,13 +76,17 @@ magnum.shaders.FlatGL2D.__annotations__ = {
'POSITION': magnum.gl.Attribute,
'TEXTURE_COORDINATES': magnum.gl.Attribute,
'COLOR3': magnum.gl.Attribute,
'COLOR4': magnum.gl.Attribute
'COLOR4': magnum.gl.Attribute,
'TRANSFORMATION_MATRIX': magnum.gl.Attribute,
'TEXTURE_OFFSET': magnum.gl.Attribute,
}
magnum.shaders.FlatGL3D.__annotations__ = {
'POSITION': magnum.gl.Attribute,
'TEXTURE_COORDINATES': magnum.gl.Attribute,
'COLOR3': magnum.gl.Attribute,
'COLOR4': magnum.gl.Attribute
'COLOR4': magnum.gl.Attribute,
'TRANSFORMATION_MATRIX': magnum.gl.Attribute,
'TEXTURE_OFFSET': magnum.gl.Attribute,
}
magnum.shaders.VertexColorGL2D.__annotations__ = {
'POSITION': magnum.gl.Attribute,
@ -98,9 +102,13 @@ magnum.shaders.PhongGL.__annotations__ = {
'POSITION': magnum.gl.Attribute,
'NORMAL': magnum.gl.Attribute,
'TANGENT': magnum.gl.Attribute,
'TANGENT4': magnum.gl.Attribute,
'BITANGENT': magnum.gl.Attribute,
'TEXTURE_COORDINATES': magnum.gl.Attribute,
'COLOR3': magnum.gl.Attribute,
'COLOR4': magnum.gl.Attribute
'COLOR4': magnum.gl.Attribute,
'TRANSFORMATION_MATRIX': magnum.gl.Attribute,
'TEXTURE_OFFSET': magnum.gl.Attribute,
}
# An extremely hacky way to remove noise for shader docs. It doesn't hide

11
doc/python/magnum.shaders.rst
Unescape View File

@ -28,12 +28,23 @@
:data TEXTURE_COORDINATES: 2D texture coordinates
:data COLOR3: Three-component vertex color
:data COLOR4: Four-component vertex color
:data TRANSFORMATION_MATRIX: (Instanced) transformation matrix
:data TEXTURE_OFFSET: (Instanced) texture offset
.. 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
:data TRANSFORMATION_MATRIX: (Instanced) transformation matrix
:data TEXTURE_OFFSET: (Instanced) texture offset
.. py:property:: magnum.shaders.FlatGL2D.texture_matrix
:raise AttributeError: If the shader was not created with
:ref:`Flags.TEXTURE_TRANSFORMATION`
.. py:property:: magnum.shaders.FlatGL3D.texture_matrix
:raise AttributeError: If the shader was not created with
:ref:`Flags.TEXTURE_TRANSFORMATION`
.. py:property:: magnum.shaders.FlatGL2D.alpha_mask
:raise AttributeError: If the shader was not created with

6
doc/python/pages/changelog.rst
Unescape View File

@ -56,8 +56,10 @@ Changelog
:ref:`gl.Renderer.set_blend_equation()` and related enums (see :gh:`mosra/magnum-bindings#9`)
- Exposed :ref:`gl.Renderer.Feature.CLIP_DISTANCEn <gl.Renderer.Feature.CLIP_DISTANCE0>`
values that are new since 2020.06
- Exposed new instancing, normal-mapping-related and lighting features in
:ref:`shaders.PhongGL`
- Exposed new instancing, texture transformation, normal-mapping-related and
lighting features in :ref:`shaders.PhongGL`
- Exposed new instancing and texture transformation features in
:ref:`shaders.FlatGL2D` and :ref:`shaders.FlatGL3D`
- Renamed all helper ``Python.h`` headers to ``PythonBindings.h`` to avoid
issues with shitty IDE indexers such as Eclipse, confusing these with
Python's ``<Python.h>``

32
src/python/magnum/shaders.cpp
Unescape View File

@ -46,9 +46,12 @@ namespace {
template<UnsignedInt dimensions> void flat(PyNonDestructibleClass<Shaders::FlatGL<dimensions>, GL::AbstractShaderProgram>& c) {
/* Attributes */
c.attr("POSITION") = GL::DynamicAttribute{typename Shaders::FlatGL<dimensions>::Position{}};
c.attr("TEXTURE_COORDINATES") = GL::DynamicAttribute{typename Shaders::FlatGL<dimensions>::TextureCoordinates{}};
c.attr("COLOR3") = GL::DynamicAttribute{typename Shaders::FlatGL<dimensions>::Color3{}};
c.attr("COLOR4") = GL::DynamicAttribute{typename Shaders::FlatGL<dimensions>::Color4{}};
c.attr("TRANSFORMATION_MATRIX") = GL::DynamicAttribute{typename Shaders::FlatGL<dimensions>::TransformationMatrix{}};
c.attr("TEXTURE_OFFSET") = GL::DynamicAttribute{typename Shaders::FlatGL<dimensions>::TextureOffset{}};
/* Methods */
c
@ -61,6 +64,14 @@ template<UnsignedInt dimensions> void flat(PyNonDestructibleClass<Shaders::FlatG
}, "Flags")
.def_property("transformation_projection_matrix", nullptr, &Shaders::FlatGL<dimensions>::setTransformationProjectionMatrix,
"Transformation and projection matrix")
.def_property("texture_matrix", nullptr, [](Shaders::FlatGL<dimensions>& self, const Matrix3& matrix) {
if(!(self.flags() & Shaders::FlatGL<dimensions>::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("color", nullptr, &Shaders::FlatGL<dimensions>::setColor, "Color")
.def_property("alpha_mask", nullptr, [](Shaders::FlatGL<dimensions>& self, Float mask) {
if(!(self.flags() & Shaders::FlatGL<dimensions>::Flag::AlphaMask)) {
@ -82,6 +93,7 @@ template<UnsignedInt dimensions> void flat(PyNonDestructibleClass<Shaders::FlatG
template<UnsignedInt dimensions> void vertexColor(PyNonDestructibleClass<Shaders::VertexColorGL<dimensions>, GL::AbstractShaderProgram>& c) {
/* Attributes */
c.attr("POSITION") = GL::DynamicAttribute{typename Shaders::VertexColorGL<dimensions>::Position{}};
c.attr("COLOR3") = GL::DynamicAttribute{typename Shaders::VertexColorGL<dimensions>::Color3{}};
c.attr("COLOR4") = GL::DynamicAttribute{typename Shaders::VertexColorGL<dimensions>::Color4{}};
@ -111,9 +123,7 @@ void shaders(py::module_& m) {
PyNonDestructibleClass<Shaders::FlatGL2D, GL::AbstractShaderProgram> flatGL2D{m,
"FlatGL2D", "2D flat OpenGL shader"};
PyNonDestructibleClass<Shaders::FlatGL3D, GL::AbstractShaderProgram> flatGL3D{m,
"FlatGL3D", "3D flat shader"};
flatGL2D.attr("POSITION") = GL::DynamicAttribute{Shaders::FlatGL2D::Position{}};
flatGL3D.attr("POSITION") = GL::DynamicAttribute{Shaders::FlatGL3D::Position{}};
"FlatGL3D", "3D flat OpenGL shader"};
/* 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
@ -122,8 +132,11 @@ void shaders(py::module_& m) {
flags
.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{})
.value("VERTEX_COLOR", Shaders::FlatGL2D::Flag::AlphaMask)
.value("TEXTURE_TRANSFORMATION", Shaders::FlatGL2D::Flag::TextureTransformation)
.value("INSTANCED_TRANSFORMATION", Shaders::FlatGL2D::Flag::InstancedTransformation)
.value("INSTANCED_TEXTURE_OFFSET", Shaders::FlatGL2D::Flag::InstancedTextureOffset)
.value("NONE", Shaders::FlatGL2D::Flag{})
/* TODO: OBJECT_ID, once multiple FB outputs and mapDraw is exposed */
;
flatGL3D.attr("Flags") = flags;
@ -132,17 +145,14 @@ void shaders(py::module_& m) {
flat(flatGL3D);
corrade::enumOperators(flags);
}
/* 2D/3D vertex color shader */
{
PyNonDestructibleClass<Shaders::VertexColorGL2D, GL::AbstractShaderProgram> vertexColorGL2D{m,
"VertexColorGL2D", "2D vertex color shader"};
"VertexColorGL2D", "2D vertex color OpenGL shader"};
PyNonDestructibleClass<Shaders::VertexColorGL3D, GL::AbstractShaderProgram> vertexColorGL3D{m,
"VertexColorGL3D", "3D vertex color shader"};
vertexColorGL2D.attr("POSITION") = GL::DynamicAttribute{Shaders::VertexColorGL2D::Position{}};
vertexColorGL3D.attr("POSITION") = GL::DynamicAttribute{Shaders::VertexColorGL3D::Position{}};
"VertexColorGL3D", "3D vertex color OpenGL shader"};
vertexColor(vertexColorGL2D);
vertexColor(vertexColorGL3D);
}
@ -150,7 +160,7 @@ void shaders(py::module_& m) {
/* Phong shader */
{
PyNonDestructibleClass<Shaders::PhongGL, GL::AbstractShaderProgram> phongGL{m,
"PhongGL", "Phong shader"};
"PhongGL", "Phong OpenGL 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{}};

5
src/python/magnum/test/test_shaders_gl.py
Unescape View File

@ -41,10 +41,11 @@ class FlatGL(GLTestCase):
self.assertEqual(b.flags, shaders.FlatGL3D.Flags.TEXTURED|shaders.FlatGL3D.Flags.ALPHA_MASK)
def test_uniforms_bindings(self):
a = shaders.FlatGL3D(shaders.FlatGL3D.Flags.TEXTURED|shaders.FlatGL3D.Flags.ALPHA_MASK)
a = shaders.FlatGL3D(shaders.FlatGL3D.Flags.TEXTURED|shaders.FlatGL3D.Flags.ALPHA_MASK|shaders.FlatGL3D.Flags.TEXTURE_TRANSFORMATION)
a.color = (0.5, 1.0, 0.9)
a.transformation_projection_matrix = Matrix4.translation(Vector3.x_axis())
a.alpha_mask = 0.3
a.texture_matrix = Matrix3()
texture = gl.Texture2D()
texture.set_storage(1, gl.TextureFormat.RGBA8, Vector2i(8))
@ -54,6 +55,8 @@ class FlatGL(GLTestCase):
a = shaders.FlatGL2D()
with self.assertRaisesRegex(AttributeError, "the shader was not created with alpha mask enabled"):
a.alpha_mask = 0.3
with self.assertRaisesRegex(AttributeError, "the shader was not created with texture transformation enabled"):
a.texture_matrix = Matrix3()
texture = gl.Texture2D()
with self.assertRaisesRegex(AttributeError, "the shader was not created with texturing enabled"):

Write Preview
Loading…
Cancel
Save