template<UnsignedInt dimensions>
Magnum::Shaders::Flat class

Flat shader.

Draws the whole mesh with given color or texture. For a colored mesh you need to provide the Position attribute in your triangle mesh. By default, the shader renders the mesh with a white color in an identity transformation. Use setTransformationProjectionMatrix(), setColor() and others to configure the shader.

If you want to use a texture, you need to provide also TextureCoordinates attribute. Pass Flag::Textured to the constructor and then at render time don't forget to bind also the texture via bindTexture(). The texture is multipled by the color, which is by default set to 0xffffffff_rgbaf.

For coloring the texture based on intensity you can use the Vector shader.

Image

Example usage

Colored mesh

Common mesh setup:

struct Vertex {
    Vector3 position;
};
Vertex data[60]{
    //...
};

GL::Buffer vertices;
vertices.setData(data, GL::BufferUsage::StaticDraw);

GL::Mesh mesh;
mesh.addVertexBuffer(vertices, 0, Shaders::Flat3D::Position{})
    // ...
    ;

Common rendering setup:

Matrix4 transformationMatrix = Matrix4::translation(Vector3::zAxis(-5.0f));
Matrix4 projectionMatrix = Matrix4::perspectiveProjection(35.0_degf, 1.0f, 0.001f, 100.0f);

Shaders::Flat3D shader;
shader.setColor(0x2f83cc_rgbf)
    .setTransformationProjectionMatrix(projectionMatrix*transformationMatrix);

mesh.draw(shader);

Textured mesh

Common mesh setup:

struct Vertex {
    Vector3 position;
    Vector2 textureCoordinates;
};
Vertex data[60]{
    // ...
};

GL::Buffer vertices;
vertices.setData(data, GL::BufferUsage::StaticDraw);

GL::Mesh mesh;
mesh.addVertexBuffer(vertices, 0,
    Shaders::Flat3D::Position{},
    Shaders::Flat3D::TextureCoordinates{})
    // ...
    ;

Common rendering setup:

Matrix4 transformationMatrix, projectionMatrix;
GL::Texture2D texture;

Shaders::Flat3D shader{Shaders::Flat3D::Flag::Textured};
shader.setTransformationProjectionMatrix(projectionMatrix*transformationMatrix)
    .bindTexture(texture);

mesh.draw(shader);

Alpha blending and masking

Enable Flag::AlphaMask and tune setAlphaMask() for simple binary alpha-masked drawing that doesn't require depth sorting or blending enabled. Note that this feature is implemented using the GLSL discard operation which is known to have considerable performance impact on some platforms. With proper depth sorting and blending you'll usually get much better performance and output quality.

Base classes

class Magnum::GL::AbstractShaderProgram
Base for shader program implementations.

Public types

enum class Flag: UnsignedByte { Textured = 1 << 0, AlphaMask = 1 << 1 }
Flag.
using Position = Generic<dimensions>::Position
Vertex position.
using TextureCoordinates = Generic<dimensions>::TextureCoordinates
2D texture coordinates
using Flags = Containers::EnumSet<Flag>
Flags.

Constructors, destructors, conversion operators

Flat(Flags flags = {}) explicit
Constructor.
Flat(NoCreateT) explicit noexcept
Construct without creating the underlying OpenGL object.
Flat(const Flat<dimensions>&) deleted
Copying is not allowed.
Flat(Flat<dimensions>&&) noexcept defaulted
Move constructor.

Public functions

auto operator=(const Flat<dimensions>&) -> Flat<dimensions>& deleted
Copying is not allowed.
auto operator=(Flat<dimensions>&&) noexcept -> Flat<dimensions>& defaulted
Move assignment.
auto flags() const -> Flags
Flags.
auto setTransformationProjectionMatrix(const MatrixTypeFor<dimensions, Float>& matrix) -> Flat<dimensions>&
Set transformation and projection matrix.
auto setColor(const Color4& color) -> Flat<dimensions>&
Set color.
auto bindTexture(GL::Texture2D& texture) -> Flat<dimensions>&
Bind a color texture.
auto setAlphaMask(Float mask) -> Flat<dimensions>&
Set alpha mask value.
auto setTexture(GL::Texture2D& texture) -> Flat<dimensions>& deprecated
Bind a color texture.

Enum documentation

template<UnsignedInt dimensions>
enum class Magnum::Shaders::Flat<dimensions>::Flag: UnsignedByte

Flag.

Enumerators
Textured

Multiply color with a texture.

AlphaMask

Enable alpha masking. If the combined fragment color has an alpha less than the value specified with setAlphaMask(), given fragment is discarded.

This uses the discard operation which is known to have considerable performance impact on some platforms. While useful for cheap alpha masking that doesn't require depth sorting, with proper depth sorting and blending you'll usually get much better performance and output quality.

Typedef documentation

template<UnsignedInt dimensions>
typedef Generic<dimensions>::Position Magnum::Shaders::Flat<dimensions>::Position

Vertex position.

Generic attribute, Vector2 in 2D, Vector3 in 3D.

template<UnsignedInt dimensions>
typedef Generic<dimensions>::TextureCoordinates Magnum::Shaders::Flat<dimensions>::TextureCoordinates

2D texture coordinates

Generic attribute, Vector2. Used only if Flag::Textured is set.

template<UnsignedInt dimensions>
typedef Containers::EnumSet<Flag> Magnum::Shaders::Flat<dimensions>::Flags

Flags.

Function documentation

template<UnsignedInt dimensions>
Magnum::Shaders::Flat<dimensions>::Flat(Flags flags = {}) explicit

Constructor.

Parameters
flags Flags

template<UnsignedInt dimensions>
Magnum::Shaders::Flat<dimensions>::Flat(NoCreateT) explicit noexcept

Construct without creating the underlying OpenGL object.

The constructed instance is equivalent to moved-from state. Useful in cases where you will overwrite the instance later anyway. Move another object over it to make it useful.

This function can be safely used for constructing (and later destructing) objects even without any OpenGL context being active.

template<UnsignedInt dimensions>
Flat<dimensions>& Magnum::Shaders::Flat<dimensions>::setTransformationProjectionMatrix(const MatrixTypeFor<dimensions, Float>& matrix)

Set transformation and projection matrix.

Returns Reference to self (for method chaining)

Initial value is an identity matrix.

template<UnsignedInt dimensions>
Flat<dimensions>& Magnum::Shaders::Flat<dimensions>::setColor(const Color4& color)

Set color.

Returns Reference to self (for method chaining)

If Flag::Textured is set, initial value is 0xffffffff_rgbaf and the color will be multiplied with texture.

template<UnsignedInt dimensions>
Flat<dimensions>& Magnum::Shaders::Flat<dimensions>::bindTexture(GL::Texture2D& texture)

Bind a color texture.

Returns Reference to self (for method chaining)

Expects that the shader was created with Flag::Textured enabled.

template<UnsignedInt dimensions>
Flat<dimensions>& Magnum::Shaders::Flat<dimensions>::setAlphaMask(Float mask)

Set alpha mask value.

Returns Reference to self (for method chaining)

Expects that the shader was created with Flag::AlphaMask enabled. Fragments with alpha values smaller than the mask value will be discarded. Initial value is 0.5f. See the flag documentation for further information.

template<UnsignedInt dimensions>
Flat<dimensions>& Magnum::Shaders::Flat<dimensions>::setTexture(GL::Texture2D& texture)

Bind a color texture.

template<UnsignedInt dimensions> template<UnsignedInt dimensions>
Debug& operator<<(Debug& debug, Flat<dimensions>::Flag value)

Debug output operator.

template<UnsignedInt dimensions> template<UnsignedInt dimensions>
Debug& operator<<(Debug& debug, Flat<dimensions>::Flags value)

Debug output operator.