Magnum::Shaders::PhongGL class new in Git master

#include <Magnum/Shaders/PhongGL.h>

Colored rendering

Common mesh setup:

struct {
    Vector3 position;
    Vector3 normal;
} vertices[]{
    …
};

GL::Mesh mesh;
mesh.addVertexBuffer(GL::Buffer{vertices}, 0,
        Shaders::PhongGL::Position{},
        Shaders::PhongGL::Normal{})
    .setCount(Containers::arraySize(vertices));

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::PhongGL shader;
shader.setDiffuseColor(0x2f83cc_rgbf)
    .setShininess(200.0f)
    .setTransformationMatrix(transformationMatrix)
    .setNormalMatrix(transformationMatrix.normalMatrix())
    .setProjectionMatrix(projectionMatrix)
    .draw(mesh);

Textured rendering

If you want to use textures, you need to provide also the TextureCoordinates attribute. Pass appropriate Flag combination to Configuration::setFlags() and then at render time don't forget to also call appropriate subset of bindAmbientTexture(), bindDiffuseTexture() and bindSpecularTexture() (or the combined bindTextures()). The texture is multiplied by the color, which is by default set to fully opaque white for enabled textures. Mesh setup with a diffuse and a specular texture:

struct {
    Vector3 position;
    Vector3 normal;
    Vector2 textureCoordinates;
} vertices[]{
    …
};

GL::Mesh mesh;
mesh.addVertexBuffer(GL::Buffer{vertices}, 0,
        Shaders::PhongGL::Position{},
        Shaders::PhongGL::Normal{},
        Shaders::PhongGL::TextureCoordinates{})
    .setCount(Containers::arraySize(vertices));

Common rendering setup:

Matrix4 transformationMatrix, projectionMatrix;
GL::Texture2D diffuseTexture, specularTexture;

Shaders::PhongGL shader{Shaders::PhongGL::Configuration{}
    .setFlags(Shaders::PhongGL::Flag::DiffuseTexture|
              Shaders::PhongGL::Flag::SpecularTexture)};
shader.bindTextures(nullptr, &diffuseTexture, &specularTexture, nullptr)
    .setTransformationMatrix(transformationMatrix)
    .setNormalMatrix(transformationMatrix.normalMatrix())
    .setProjectionMatrix(projectionMatrix)
    .draw(mesh);

If Flag::TextureArrays is enabled, pass GL::Texture2DArray instances instead of GL::Texture2D. By default layer 0 is used, call setTextureLayer() to pick a different texture array layer.

Light specification

By default, the shader provides a single directional "fill" light, coming from the center of the camera. With Configuration::setLightCount() you can specify how many lights you want, and then control light parameters using setLightPositions(), setLightColors(), setLightSpecularColors() and setLightRanges(). Light positions are specified as four-component vectors, the last component distinguishing between directional and point lights.

• Point lights are specified with camera-relative position and the last component set to 1.0f together with setLightRanges() describing the attenuation. The range corresponds to the Trade::LightData::range() and the attenuation is calculated as the following — see Attenuation calculation for more information:

  If you use Constants::inf() as a range (which is also the default), the equation reduces down to a simple inverse square:

• Directional lights are specified with a camera-relative direction to the light with the last component set to 0.0f — which effectively makes — and are not affected by values from setLightRanges() in any way:

Light color and intensity, corresponding to Trade::LightData::color() and Trade::LightData::intensity(), is meant to be multiplied together and passed to setLightColors() and setLightSpecularColors().

The following example shows a three-light setup with one dim directional light shining from the top and two stronger but range-limited point lights:

Matrix4 directionalLight, pointLight1, pointLight2; // camera-relative

Shaders::PhongGL shader{Shaders::PhongGL::Configuration{}
    .setLightCount(3)};
shader
    .setLightPositions({Vector4{directionalLight.up(), 0.0f},
                        Vector4{pointLight1.translation(), 1.0f},
                        Vector4{pointLight2.translation(), 1.0f}})
    .setLightColors({0xf0f0ff_srgbf*0.1f,
                     0xff8080_srgbf*10.0f,
                     0x80ff80_srgbf*10.0f})
    .setLightColors(…)
    .setLightRanges({Constants::inf(),
                     2.0f,
                     2.0f});

Trade::LightData ambientLight = …;

Shaders::PhongGL shader{Shaders::PhongGL::Configuration{}
    .setFlags(Shaders::PhongGL::Flag::AmbientTexture|…)};
shader
    .setAmbientColor(ambientColor + ambientLight.color()*ambientLight.intensity())
    .bindAmbientTexture(diffuseTexture)
    .bindDiffuseTexture(diffuseTexture);

Alpha blending and masking

Alpha / transparency is supported by the shader implicitly, but to have it working on the framebuffer, you need to enable GL::Renderer::Feature::Blending and set up the blending function. See GL::Renderer::setBlendFunction() for details.

To avoid specular highlights on transparent areas, specular alpha should be always set to 0.0f. On the other hand, non-zero specular alpha can be for example used to render transparent materials which are still expected to have specular highlights such as glass or soap bubbles.

An alternative is to 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.

For general alpha-masked drawing you need to provide an ambient texture with alpha channel and set alpha channel of the diffuse/specular color to 0.0f so only ambient alpha will be taken into account. If you have a diffuse texture combined with the alpha mask, you can use that texture for both ambient and diffuse part and then separate the alpha like this:

Shaders::PhongGL shader{Shaders::PhongGL::Configuration{}
    .setFlags(Shaders::PhongGL::Flag::AmbientTexture|
              Shaders::PhongGL::Flag::DiffuseTexture)};
shader.bindTextures(&diffuseAlphaTexture, &diffuseAlphaTexture, nullptr, nullptr)
    .setAmbientColor(0x000000ff_rgbaf)
    .setDiffuseColor(Color4{diffuseRgb, 0.0f})
    .setSpecularColor(Color4{specularRgb, 0.0f});

Normal mapping

If you want to use normal textures, enable Flag::NormalTexture and call bindNormalTexture(). In addition you need to supply per-vertex tangent and bitangent direction:

• either using a four-component Tangent4 attribute, where the sign of the fourth component defines handedness of tangent basis, as described in Trade::MeshAttribute::Tangent;
• or a using pair of three-component Tangent and Bitangent attributes together with enabling Flag::Bitangent

If you supply just a three-component Tangent attribute and no bitangents, the shader will implicitly assume the fourth component to be 1.0f, forming a right-handed tangent space. This is a valid optimization when you have full control over the bitangent orientation, but won't work with general meshes.

The strength of the effect can be controlled by setNormalTextureScale(). See Trade::MaterialAttribute::NormalTextureScale for a description of the factor is used.

Object ID output

The shader supports writing object ID to the framebuffer for object picking or other annotation purposes. Enable it using Flag::ObjectId and set up an integer buffer attached to the ObjectIdOutput attachment. If you have a batch of meshes with different object IDs, enable Flag::InstancedObjectId and supply per-vertex IDs to the ObjectId attribute. The object ID can be also supplied from an integer texture bound via bindObjectIdTexture() if Flag::ObjectIdTexture is enabled. The output will contain a sum of the per-vertex ID, texture ID and ID coming from setObjectId().

The functionality is practically the same as in the FlatGL shader, see its documentation for more information and usage example.

Skinning

To render skinned meshes, bind up to two sets of up to four-component joint ID and weight attributes to JointIds / SecondaryJointIds and Weights / SecondaryWeights, set an appropriate joint count and per-vertex primary and secondary joint count in Configuration::setJointCount() and upload appropriate joint matrices with setJointMatrices(). The usage is similar for all shaders, see Skinning for an example.

To avoid having to compile multiple shader variants for different joint matrix counts, set the maximum used joint count in Configuration::setJointCount() and then upload just a prefix via setJointMatrices(). Similarly, to avoid multiple variants for different per-vertex joint counts, enable Flag::DynamicPerVertexJointCount, set the maximum per-vertex joint count in Configuration::setJointCount() and then adjust the actual per-draw joint count with setPerVertexJointCount().

Instanced rendering

Enabling Flag::InstancedTransformation will turn the shader into an instanced one. It'll take per-instance transformation and normal matrix from the TransformationMatrix and NormalMatrix attributes, applying those before the matrix set by setTransformationMatrix() and setNormalMatrix(). Besides that, Flag::VertexColor (and the Color3 / Color4) attributes can work as both per-vertex and per-instance, and for texturing it's possible to have per-instance texture offset taken from TextureOffset when Flag::InstancedTextureOffset is enabled (similarly to transformation, applied before setTextureMatrix()). The snippet below shows adding a buffer with per-instance transformation to a mesh — note how a normal matrix attribute has to be populated and supplied as well to ensure lighting works:

struct {
    Matrix4 transformation;
    Matrix3x3 normal;
} instanceData[] {
    {Matrix4::translation({1.0f, 2.0f, 0.0f})*Matrix4::rotationX(90.0_degf), {}},
    {Matrix4::translation({2.0f, 1.0f, 0.0f})*Matrix4::rotationY(90.0_degf), {}},
    {Matrix4::translation({3.0f, 0.0f, 1.0f})*Matrix4::rotationZ(90.0_degf), {}},
    …
};
for(auto& instance: instanceData)
    instance.normal = instance.transformation.normalMatrix();

mesh.setInstanceCount(Containers::arraySize(instanceData))
    .addVertexBufferInstanced(GL::Buffer{instanceData}, 1, 0,
        Shaders::PhongGL::TransformationMatrix{},
        Shaders::PhongGL::NormalMatrix{});

For instanced skinning the joint buffer is assumed to contain joint transformations for all instances. By default all instances use the same joint transformations, seting setPerInstanceJointCount() will cause the shader to offset the per-vertex joint IDs with gl_InstanceID*perInstanceJointCount.

Uniform buffers

See Using uniform buffers for a high-level overview that applies to all shaders. In this particular case, the shader needs a separate ProjectionUniform3D and TransformationUniform3D buffer bound with bindProjectionBuffer() and bindTransformationBuffer(), respectively, lights are supplied via a PhongLightUniform buffer bound with bindLightBuffer(). To maximize use of the limited uniform buffer memory, materials are supplied separately in a PhongMaterialUniform buffer bound with bindMaterialBuffer() and then referenced via materialId from a PhongDrawUniform bound with bindDrawBuffer(); for optional texture transformation a per-draw TextureTransformationUniform buffer bound with bindTextureTransformationBuffer() can be supplied as well. A uniform buffer setup equivalent to the colored case at the top, with one default light, would look like this:

GL::Buffer projectionUniform, lightUniform, materialUniform,
    transformationUniform, drawUniform;
projectionUniform.setData({
    Shaders::ProjectionUniform3D{}
        .setProjectionMatrix(projectionMatrix)
});
lightUniform.setData({
    Shaders::PhongLightUniform{}
});
materialUniform.setData({
    Shaders::PhongMaterialUniform{}
        .setDiffuseColor(0x2f83cc_rgbf)
        .setShininess(200.0f)
});
transformationUniform.setData({
    Shaders::TransformationUniform3D{}
        .setTransformationMatrix(transformationMatrix)
});
drawUniform.setData({
    Shaders::PhongDrawUniform{}
        .setNormalMatrix(transformationMatrix.normalMatrix())
        .setMaterialId(0)
});

Shaders::PhongGL shader{Shaders::PhongGL::Configuration{}
    .setFlags(Shaders::PhongGL::Flag::UniformBuffers)};
shader
    .bindProjectionBuffer(projectionUniform)
    .bindLightBuffer(lightUniform)
    .bindMaterialBuffer(materialUniform)
    .bindTransformationBuffer(transformationUniform)
    .bindDrawBuffer(drawUniform)
    .draw(mesh);

When uniform buffers with Flag::TextureArrays are used, Flag::TextureTransformation has to be enabled as well in order to supply the texture layer using TextureTransformationUniform::layer.

For a multidraw workflow enable Flag::MultiDraw (and possibly Flag::TextureArrays) and supply desired light, material and draw count via Configuration::setLightCount(), setMaterialCount() and setDrawCount(). For every draw then specify material references and texture offsets/layers. With Flag::LightCulling it's also possible to perform per-draw light culling by supplying a subrange into the PhongLightUniform array using PhongDrawUniform::lightOffset and lightCount. Besides that, the usage is similar for all shaders, see Multidraw and reducing driver overhead for an example.

For skinning, joint matrices are supplied via a TransformationUniform3D buffer bound with bindJointBuffer(). In an instanced scenario the per-instance joint count is supplied via PhongDrawUniform::perInstanceJointCount, a per-draw joint offset for the multidraw scenario is supplied via PhongDrawUniform::jointOffset. Altogether for a particular draw, each per-vertex joint ID is offset with gl_InstanceID*perInstanceJointCount + jointOffset. The setPerVertexJointCount() stays as an immediate uniform in the UBO and multidraw scenario as well, as it is tied to a particular mesh layout and thus doesn't need to vary per draw.

Base classes

class Magnum::GL::AbstractShaderProgram

Base for shader program implementations.

Derived classes

class Magnum::Shaders::PhongGL::CompileState new in Git master

Asynchronous compilation state.

Public types

class CompileState new in Git master

Asynchronous compilation state.

class Configuration new in Git master

Configuration.

enum (anonymous): UnsignedInt { ColorOutput = GenericGL3D::ColorOutput new in 2019.10, ObjectIdOutput = GenericGL3D::ObjectIdOutput new in 2019.10 }

enum class Flag: UnsignedInt { AmbientTexture = 1 << 0, DiffuseTexture = 1 << 1, SpecularTexture = 1 << 2, NormalTexture = 1 << 4 new in 2019.10, AlphaMask = 1 << 3, VertexColor = 1 << 5 new in 2019.10, DoubleSided = 1 << 20 new in Git master, Bitangent = 1 << 11 new in Git master, TextureTransformation = 1 << 6 new in 2020.06, ObjectId = 1 << 7 new in 2019.10, InstancedObjectId = (1 << 8)|ObjectId new in 2020.06, ObjectIdTexture = (1 << 17)|ObjectId new in Git master, InstancedTransformation = 1 << 9 new in 2020.06, InstancedTextureOffset = (1 << 10)|TextureTransformation new in 2020.06, UniformBuffers = 1 << 12 new in Git master, ShaderStorageBuffers = UniformBuffers|(1 << 19) new in Git master, MultiDraw = UniformBuffers|(1 << 13) new in Git master, TextureArrays = 1 << 14 new in Git master, LightCulling = 1 << 15 new in Git master, NoSpecular = 1 << 16 new in Git master, DynamicPerVertexJointCount = 1 << 18 new in Git master }

Flag.

using Position = GenericGL3D::Position

Vertex position.

using Normal = GenericGL3D::Normal

Normal direction.

using Tangent = GenericGL3D::Tangent new in 2019.10

Tangent direction.

using Tangent4 = GenericGL3D::Tangent4 new in Git master

Tangent direction with a bitangent sign.

using Bitangent = GenericGL3D::Bitangent new in Git master

Bitangent direction.

using TextureCoordinates = GenericGL3D::TextureCoordinates

2D texture coordinates

using Color3 = GenericGL3D::Color3 new in 2019.10

Three-component vertex color.

using Color4 = GenericGL3D::Color4 new in 2019.10

Four-component vertex color.

using JointIds = GenericGL3D::JointIds new in Git master

Joint ids.

using Weights = GenericGL3D::Weights new in Git master

Weights.

using SecondaryJointIds = GenericGL3D::SecondaryJointIds new in Git master

Secondary joint ids.

using SecondaryWeights = GenericGL3D::SecondaryWeights new in Git master

Secondary weights.

using ObjectId = GenericGL3D::ObjectId new in 2020.06

(Instanced) object ID

using TransformationMatrix = GenericGL3D::TransformationMatrix new in 2020.06

(Instanced) transformation matrix

using NormalMatrix = GenericGL3D::NormalMatrix new in 2020.06

(Instanced) normal matrix

using TextureOffset = GenericGL3D::TextureOffset new in 2020.06

(Instanced) texture offset

using TextureOffsetLayer = GenericGL3D::TextureOffsetLayer new in Git master

(Instanced) texture offset and layer

using Flags = Containers::EnumSet<Flag>

Flags.

Public static functions

static auto compile(const Configuration& configuration = Configuration{}) -> CompileState new in Git master

Compile asynchronously.

static auto compile(Flags flags, UnsignedInt lightCount = 1) -> CompileState deprecated in Git master

Compile asynchronously.

static auto compile(Flags flags, UnsignedInt lightCount, UnsignedInt materialCount, UnsignedInt drawCount) -> CompileState deprecated in Git master

Compile for a multi-draw scenario asynchronously.

Constructors, destructors, conversion operators

PhongGL(const Configuration& configuration = Configuration{}) explicit new in Git master

Constructor.

PhongGL(Flags flags, UnsignedInt lightCount = 1) deprecated in Git master explicit

Constructor.

PhongGL(Flags flags, UnsignedInt lightCount, UnsignedInt materialCount, UnsignedInt drawCount) deprecated in Git master explicit

Construct for a multi-draw scenario.

PhongGL(CompileState&& state) explicit new in Git master

Finalize an asynchronous compilation.

PhongGL(NoCreateT) explicit noexcept

Construct without creating the underlying OpenGL object.

PhongGL(const PhongGL&) deleted

Copying is not allowed.

PhongGL(PhongGL&&) defaulted noexcept

Move constructor.

Public functions

auto operator=(const PhongGL&) -> PhongGL& deleted

Copying is not allowed.

auto operator=(PhongGL&&) -> PhongGL& defaulted noexcept

Move assignment.

auto flags() const -> Flags

Flags.

auto lightCount() const -> UnsignedInt

Light count.

auto perDrawLightCount() const -> UnsignedInt new in Git master

Per-draw light count.

auto jointCount() const -> UnsignedInt new in Git master

Joint count.

auto perVertexJointCount() const -> UnsignedInt new in Git master

Per-vertex joint count.

auto secondaryPerVertexJointCount() const -> UnsignedInt new in Git master

Secondary per-vertex joint count.

auto materialCount() const -> UnsignedInt new in Git master

Material count.

auto drawCount() const -> UnsignedInt new in Git master

Draw count.

auto setPerVertexJointCount(UnsignedInt count, UnsignedInt secondaryCount = 0) -> PhongGL& new in Git master

Set dynamic per-vertex skinning joint count.

Uniform setters

Used only if Flag::UniformBuffers is not set.

auto setAmbientColor(const Magnum::Color4& color) -> PhongGL&

Set ambient color.

auto setDiffuseColor(const Magnum::Color4& color) -> PhongGL&

Set diffuse color.

auto setNormalTextureScale(Float scale) -> PhongGL& new in Git master

Set normal texture scale.

auto setSpecularColor(const Magnum::Color4& color) -> PhongGL&

Set specular color.

auto setShininess(Float shininess) -> PhongGL&

Set shininess.

auto setAlphaMask(Float mask) -> PhongGL&

Set alpha mask value.

auto setObjectId(UnsignedInt id) -> PhongGL&

Set object ID.

auto setTransformationMatrix(const Matrix4& matrix) -> PhongGL&

Set transformation matrix.

auto setNormalMatrix(const Matrix3x3& matrix) -> PhongGL&

Set normal matrix.

auto setProjectionMatrix(const Matrix4& matrix) -> PhongGL&

Set projection matrix.

auto setTextureMatrix(const Matrix3& matrix) -> PhongGL& new in 2020.06

Set texture coordinate transformation matrix.

auto setTextureLayer(UnsignedInt layer) -> PhongGL& new in Git master

Set texture array layer.

auto setLightPositions(Containers::ArrayView<const Vector4> positions) -> PhongGL& new in Git master

Set light positions.

auto setLightPositions(std::initializer_list<Vector4> positions) -> PhongGL& new in Git master

auto setLightPositions(Containers::ArrayView<const Vector3> positions) -> PhongGL& deprecated in Git master

Set light positions.

auto setLightPositions(std::initializer_list<Vector3> positions) -> PhongGL& deprecated in Git master

auto setLightPosition(UnsignedInt id, const Vector4& position) -> PhongGL& new in Git master

Set position for given light.

auto setLightPosition(UnsignedInt id, const Vector3& position) -> PhongGL& deprecated in Git master

Set position for given light.

auto setLightPosition(const Vector3& position) -> PhongGL& deprecated in Git master

Set light position.

auto setLightColors(Containers::ArrayView<const Magnum::Color3> colors) -> PhongGL& new in Git master

Set light colors.

auto setLightColors(std::initializer_list<Magnum::Color3> colors) -> PhongGL& new in Git master

auto setLightColors(Containers::ArrayView<const Magnum::Color4> colors) -> PhongGL& deprecated in Git master

Set light colors.

auto setLightColors(std::initializer_list<Magnum::Color4> colors) -> PhongGL& deprecated in Git master

auto setLightColor(UnsignedInt id, const Magnum::Color3& color) -> PhongGL& new in Git master

Set color for given light.

auto setLightColor(UnsignedInt id, const Magnum::Color4& color) -> PhongGL& deprecated in Git master

Set color for given light.

auto setLightColor(const Magnum::Color4& color) -> PhongGL& deprecated in Git master

Set light color.

auto setLightSpecularColors(Containers::ArrayView<const Magnum::Color3> colors) -> PhongGL& new in Git master

Set light specular colors.

auto setLightSpecularColors(std::initializer_list<Magnum::Color3> colors) -> PhongGL& new in Git master

auto setLightSpecularColor(UnsignedInt id, const Magnum::Color3& color) -> PhongGL& new in Git master

Set specular color for given light.

auto setLightRanges(Containers::ArrayView<const Float> ranges) -> PhongGL& new in Git master

Set light attenuation ranges.

auto setLightRanges(std::initializer_list<Float> ranges) -> PhongGL& new in Git master

auto setLightRange(UnsignedInt id, Float range) -> PhongGL& new in Git master

Set attenuation range for given light.

auto setJointMatrices(Containers::ArrayView<const Matrix4> matrices) -> PhongGL& new in Git master

Set joint matrices.

auto setJointMatrices(std::initializer_list<Matrix4> matrices) -> PhongGL& new in Git master

auto setJointMatrix(UnsignedInt id, const Matrix4& matrix) -> PhongGL& new in Git master

Set joint matrix for given joint.

auto setPerInstanceJointCount(UnsignedInt count) -> PhongGL& new in Git master

Set per-instance joint count.

Uniform / shader storage buffer binding and related uniform setters

Used if Flag::UniformBuffers is set.

auto setDrawOffset(UnsignedInt offset) -> PhongGL& new in Git master

Set a draw offset.

auto bindProjectionBuffer(GL::Buffer& buffer) -> PhongGL& new in Git master

Bind a projection uniform / shader storage buffer.

auto bindProjectionBuffer(GL::Buffer& buffer, GLintptr offset, GLsizeiptr size) -> PhongGL& new in Git master

auto bindTransformationBuffer(GL::Buffer& buffer) -> PhongGL& new in Git master

Bind a transformation uniform / shader storage buffer.

auto bindTransformationBuffer(GL::Buffer& buffer, GLintptr offset, GLsizeiptr size) -> PhongGL& new in Git master

auto bindDrawBuffer(GL::Buffer& buffer) -> PhongGL& new in Git master

Bind a draw uniform / shader storage buffer.

auto bindDrawBuffer(GL::Buffer& buffer, GLintptr offset, GLsizeiptr size) -> PhongGL& new in Git master

auto bindTextureTransformationBuffer(GL::Buffer& buffer) -> PhongGL& new in Git master

Bind a texture transformation uniform / shader storage buffer.

auto bindTextureTransformationBuffer(GL::Buffer& buffer, GLintptr offset, GLsizeiptr size) -> PhongGL& new in Git master

auto bindMaterialBuffer(GL::Buffer& buffer) -> PhongGL& new in Git master

Bind a material uniform / shader storage buffer.

auto bindMaterialBuffer(GL::Buffer& buffer, GLintptr offset, GLsizeiptr size) -> PhongGL& new in Git master

auto bindLightBuffer(GL::Buffer& buffer) -> PhongGL& new in Git master

Bind a light uniform / shader storage buffer.

auto bindLightBuffer(GL::Buffer& buffer, GLintptr offset, GLsizeiptr size) -> PhongGL& new in Git master

auto bindJointBuffer(GL::Buffer& buffer) -> PhongGL& new in Git master

Bind a joint matrix uniform / shader storage buffer.

auto bindJointBuffer(GL::Buffer& buffer, GLintptr offset, GLsizeiptr size) -> PhongGL& new in Git master

Texture binding

auto bindAmbientTexture(GL::Texture2D& texture) -> PhongGL&

Bind an ambient texture.

auto bindAmbientTexture(GL::Texture2DArray& texture) -> PhongGL& new in Git master

Bind an ambient array texture.

auto bindDiffuseTexture(GL::Texture2D& texture) -> PhongGL&

Bind a diffuse texture.

auto bindDiffuseTexture(GL::Texture2DArray& texture) -> PhongGL& new in Git master

Bind a diffuse array texture.

auto bindSpecularTexture(GL::Texture2D& texture) -> PhongGL&

Bind a specular texture.

auto bindSpecularTexture(GL::Texture2DArray& texture) -> PhongGL& new in Git master

Bind a specular array texture.

auto bindNormalTexture(GL::Texture2D& texture) -> PhongGL& new in 2019.10

Bind a normal texture.

auto bindNormalTexture(GL::Texture2DArray& texture) -> PhongGL& new in Git master

Bind a normal array texture.

auto bindObjectIdTexture(GL::Texture2D& texture) -> PhongGL& new in Git master

Bind an object ID texture.

auto bindObjectIdTexture(GL::Texture2DArray& texture) -> PhongGL& new in Git master

Bind an object ID array texture.

auto bindTextures(GL::Texture2D* ambient, GL::Texture2D* diffuse, GL::Texture2D* specular, GL::Texture2D* normal = nullptr) -> PhongGL&

Bind textures.

Related

auto operator<<(Debug& debug, PhongGL::Flag value) -> Debug&

Debug output operator.

auto operator<<(Debug& debug, PhongGL::Flags value) -> Debug&

Debug output operator.

Enum documentation

Typedef documentation

Function documentation