ic
/
magnum
mirror of https://github.com/mosra/magnum.git
6
0
Fork 0
Code Issues Projects Releases Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
938 Commits
21 Branches
19 Tags
70 MiB
Tree: 10e64d2d27
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '10e64d2d27'
${ noResults }
magnum/src/AbstractShaderProgram.h

831 lines
40 KiB
Raw Normal View History Unescape

Classes for compiling and using shaders.
16 years ago
#ifndef Magnum_AbstractShaderProgram_h
#define Magnum_AbstractShaderProgram_h
/*
Happy New Year.
15 years ago
Copyright © 2010, 2011, 2012 Vladimír Vondruš <mosra@centrum.cz>
Classes for compiling and using shaders.
16 years ago
This file is part of Magnum.
Magnum is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License version 3
only, as published by the Free Software Foundation.
Magnum is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License version 3 for more details.
*/
/** @file
* @brief Class Magnum::AbstractShaderProgram
*/
Using EXT_direct_state_access/ARB_separate_shader_objects for uniforms. Also explicitly calling use() on default (non-DSA) setUniform() implementation. Because of that, it is now possible to conveniently call use() at the end, instead of at the beginning of uniform setting chain, for example: // before shader->use(); shader->setTransformation(transformation) ->setProjection(projection) ->setColor(color); // now shader->setTransformation(transformation) ->setProjection(projection) ->setColor(color) ->use(); Note that you still have to explicitly call use(), because if DSA is available, no use() is called explicitly on any setUniform(). If DSA is not available, use() is called on first setUniform() and subsequent calls have no negative performance impacts.
14 years ago
#include <cstdint>
#include <string>
Classes for compiling and using shaders.
16 years ago
Reduced #includes in headers. Magnum.h now doesn't include anything except OpenGL headers, thus changes in Math library don't trigger recompilation of everything, but only of things really depending on it. Math constants moved to separate file for similar reasons, de-inlined some functions to remove the need for some #includes.
14 years ago
#include "Magnum.h"
#include "magnumVisibility.h"
Classes for compiling and using shaders.
16 years ago
namespace Magnum {
Using EXT_direct_state_access/ARB_separate_shader_objects for uniforms. Also explicitly calling use() on default (non-DSA) setUniform() implementation. Because of that, it is now possible to conveniently call use() at the end, instead of at the beginning of uniform setting chain, for example: // before shader->use(); shader->setTransformation(transformation) ->setProjection(projection) ->setColor(color); // now shader->setTransformation(transformation) ->setProjection(projection) ->setColor(color) ->use(); Note that you still have to explicitly call use(), because if DSA is available, no use() is called explicitly on any setUniform(). If DSA is not available, use() is called on first setUniform() and subsequent calls have no negative performance impacts.
14 years ago
namespace Math {
template<std::size_t, std::size_t, class> class RectangularMatrix;
template<std::size_t, class> class Matrix;
template<std::size_t, class> class Vector;
}
class Context;
Reduced #includes in headers. Magnum.h now doesn't include anything except OpenGL headers, thus changes in Math library don't trigger recompilation of everything, but only of things really depending on it. Math constants moved to separate file for similar reasons, de-inlined some functions to remove the need for some #includes.
14 years ago
class Shader;
Revert "Documentation: organizing the classes into "modules"." It only caused another maintenance burden and was confusing to users. Now when scene graph is in SceneGraph namespace there is no need for another grouping. Namespaces are (and should be) sufficient. This reverts commit 79945ab6fce4bf0b53faab1d2f694f4cd934d562. Conflicts: src/BufferedImage.h src/BufferedTexture.h src/Framebuffer.h src/Query.h src/SceneGraph/Scene.h
14 years ago
/**
Classes for compiling and using shaders.
16 years ago
@brief Base class for shaders
Clarified required GL versions for shader attribute binding. Also updated section names to follow coding style.
14 years ago
@section AbstractShaderProgram-subclassing Subclassing workflow
Deprecating AbstractShaderProgram::bind*Location(). Preferred workflow is to specify attribute location explicitly in the shader. The functions remains here as some old Intel systems don't support the required extension ARB_explicit_attrib_location (and it's not in GL 3.0 either). Also updated and fixed the documentation. Function bindAttribute() was renamed to bindAttributeLocation() to be consistent with bindFragmentDataLocation(). PhongShader now uses explicit attribute location.
14 years ago
Classes for compiling and using shaders.
16 years ago
This class is designed to be used via subclassing. Subclasses define these
functions and properties:
Mesh rework, part 1: better vertex attribute management. * Instead of "binding attributes" the user now "adds vertex buffer". It corresponds better with what OpenGL itself does. * Vertex buffers now must be managed by the user. * Shader attributes are now static const members instead of typedefs to allow more convenient add*VertexBuffer*() calls.
14 years ago
- <strong>%Attribute definitions</strong> with location and type for
configuring meshes, for example:
Classes for compiling and using shaders.
16 years ago
@code
Mesh rework, part 1: better vertex attribute management. * Instead of "binding attributes" the user now "adds vertex buffer". It corresponds better with what OpenGL itself does. * Vertex buffers now must be managed by the user. * Shader attributes are now static const members instead of typedefs to allow more convenient add*VertexBuffer*() calls.
14 years ago
static const Attribute<0, Point3D> Position;
static const Attribute<1, Vector3> Normal;
static const Attribute<2, Vector2> TextureCoordinates;
Reworked binding of textures to shaders. According to OpenGL specification the sampler uniform takes only texture layer and not any particular texture. In OpenGL 4.2 it is possible to explicitly specify desired texture layer in the uniform, so I suppose it's desired to have shader with fixed texture layers and on the other hand be able to bind texture to any layer, not only one -- the exact opposite of how it was in Magnum before. The shader should now specify in its public API which texture is on which layer and explicitly set the layer uniforms upon construction. All setUniform() functions taking textures as argument were thus removed, as they confuse things a lot. The textures now have bind() function which takes layer as argument, so it's now sufficient to only bind the texture before drawing the mesh without messing with sampler uniform.
14 years ago
@endcode
Added AbstractShaderProgram::bindFragmentDataLocationIndexed().
14 years ago
@todoc Output attribute location (for bindFragmentDataLocationIndexed(),
referenced also from Framebuffer::mapDefaultForDraw() / Framebuffer::mapForDraw())
Doc++ * Grouping lengthy documentation into "Feature overview" page. * Link only to example index, where all the disclaimers are. * Also minor documentation updates.
14 years ago
Reworked binding of textures to shaders. According to OpenGL specification the sampler uniform takes only texture layer and not any particular texture. In OpenGL 4.2 it is possible to explicitly specify desired texture layer in the uniform, so I suppose it's desired to have shader with fixed texture layers and on the other hand be able to bind texture to any layer, not only one -- the exact opposite of how it was in Magnum before. The shader should now specify in its public API which texture is on which layer and explicitly set the layer uniforms upon construction. All setUniform() functions taking textures as argument were thus removed, as they confuse things a lot. The textures now have bind() function which takes layer as argument, so it's now sufficient to only bind the texture before drawing the mesh without messing with sampler uniform.
14 years ago
- **Layers for texture uniforms** to which the textures will be bound before
rendering, for example:
@code
static const GLint DiffuseTextureLayer = 0;
static const GLint SpecularTextureLayer = 1;
Deprecated uniformLocation() in favor of GL 4.3 explicit uniform location.
14 years ago
@endcode
- **Uniform locations** for setting uniform data (see below) (private
constants), for example:
@code
Updated and simplified AbstractShaderProgram documentation.
14 years ago
static const GLint TransformationUniform = 0;
static const GLint ProjectionUniform = 1;
Deprecated uniformLocation() in favor of GL 4.3 explicit uniform location.
14 years ago
static const GLint DiffuseTextureUniform = 2;
static const GLint SpecularTextureUniform = 3;
Classes for compiling and using shaders.
16 years ago
@endcode
Deprecating AbstractShaderProgram::bind*Location(). Preferred workflow is to specify attribute location explicitly in the shader. The functions remains here as some old Intel systems don't support the required extension ARB_explicit_attrib_location (and it's not in GL 3.0 either). Also updated and fixed the documentation. Function bindAttribute() was renamed to bindAttributeLocation() to be consistent with bindFragmentDataLocation(). PhongShader now uses explicit attribute location.
14 years ago
- **Constructor**, which attaches particular shaders, links the program and
gets uniform locations, for example:
Better documentation for AbstractShaderProgram.
15 years ago
@code
Reworked binding of textures to shaders. According to OpenGL specification the sampler uniform takes only texture layer and not any particular texture. In OpenGL 4.2 it is possible to explicitly specify desired texture layer in the uniform, so I suppose it's desired to have shader with fixed texture layers and on the other hand be able to bind texture to any layer, not only one -- the exact opposite of how it was in Magnum before. The shader should now specify in its public API which texture is on which layer and explicitly set the layer uniforms upon construction. All setUniform() functions taking textures as argument were thus removed, as they confuse things a lot. The textures now have bind() function which takes layer as argument, so it's now sufficient to only bind the texture before drawing the mesh without messing with sampler uniform.
14 years ago
MyShader() {
// Load shaders from file and attach them to the program
Better ability to create portable shaders. Now the #version string is added from Shader class itself, making it possible to do workarounds for older versions more conveniently. As a consequence, #version must not be part of shader source anymore.
14 years ago
attachShader(Shader::fromFile(Version::430, Shader::Type::Vertex, "PhongShader.vert"));
attachShader(Shader::fromFile(Version::430, Shader::Type::Fragment, "PhongShader.frag"));
Reworked binding of textures to shaders. According to OpenGL specification the sampler uniform takes only texture layer and not any particular texture. In OpenGL 4.2 it is possible to explicitly specify desired texture layer in the uniform, so I suppose it's desired to have shader with fixed texture layers and on the other hand be able to bind texture to any layer, not only one -- the exact opposite of how it was in Magnum before. The shader should now specify in its public API which texture is on which layer and explicitly set the layer uniforms upon construction. All setUniform() functions taking textures as argument were thus removed, as they confuse things a lot. The textures now have bind() function which takes layer as argument, so it's now sufficient to only bind the texture before drawing the mesh without messing with sampler uniform.
14 years ago
// Link
link();
}
Better documentation for AbstractShaderProgram.
15 years ago
@endcode
Reworked binding of textures to shaders. According to OpenGL specification the sampler uniform takes only texture layer and not any particular texture. In OpenGL 4.2 it is possible to explicitly specify desired texture layer in the uniform, so I suppose it's desired to have shader with fixed texture layers and on the other hand be able to bind texture to any layer, not only one -- the exact opposite of how it was in Magnum before. The shader should now specify in its public API which texture is on which layer and explicitly set the layer uniforms upon construction. All setUniform() functions taking textures as argument were thus removed, as they confuse things a lot. The textures now have bind() function which takes layer as argument, so it's now sufficient to only bind the texture before drawing the mesh without messing with sampler uniform.
14 years ago
- **Uniform setting functions**, which will provide public interface for
Updated and simplified AbstractShaderProgram documentation.
14 years ago
protected setUniform() functions. For usability purposes you can implement
also method chaining. Example:
Classes for compiling and using shaders.
16 years ago
@code
Updated and simplified AbstractShaderProgram documentation.
14 years ago
MyShader* setTransformation(const Matrix4& matrix) {
setUniform(TransformationUniform, matrix);
return this;
Better documentation for AbstractShaderProgram.
15 years ago
}
Updated and simplified AbstractShaderProgram documentation.
14 years ago
MyShader* setProjection(const Matrix4& matrix) {
setUniform(ProjectionUniform, matrix);
return this;
Reworked binding of textures to shaders. According to OpenGL specification the sampler uniform takes only texture layer and not any particular texture. In OpenGL 4.2 it is possible to explicitly specify desired texture layer in the uniform, so I suppose it's desired to have shader with fixed texture layers and on the other hand be able to bind texture to any layer, not only one -- the exact opposite of how it was in Magnum before. The shader should now specify in its public API which texture is on which layer and explicitly set the layer uniforms upon construction. All setUniform() functions taking textures as argument were thus removed, as they confuse things a lot. The textures now have bind() function which takes layer as argument, so it's now sufficient to only bind the texture before drawing the mesh without messing with sampler uniform.
14 years ago
}
Classes for compiling and using shaders.
16 years ago
@endcode
Clarified required GL versions for shader attribute binding. Also updated section names to follow coding style.
14 years ago
@subsection AbstractShaderProgram-attribute-location Binding attribute location
Deprecating AbstractShaderProgram::bind*Location(). Preferred workflow is to specify attribute location explicitly in the shader. The functions remains here as some old Intel systems don't support the required extension ARB_explicit_attrib_location (and it's not in GL 3.0 either). Also updated and fixed the documentation. Function bindAttribute() was renamed to bindAttributeLocation() to be consistent with bindFragmentDataLocation(). PhongShader now uses explicit attribute location.
14 years ago
The preferred workflow is to specify attribute location for vertex shader
input attributes and fragment shader output attributes explicitly in the
shader code, e.g.:
@code
Mention required version/extension in shader code.
14 years ago
#version 330
// or #extension GL_ARB_explicit_attrib_location: enable
Don't confuse vertices and vertex positions. Mesh consists of vertices, each vertex has position, texture coordinate, color, normal, etc.
14 years ago
layout(location = 0) in vec4 position;
Deprecating AbstractShaderProgram::bind*Location(). Preferred workflow is to specify attribute location explicitly in the shader. The functions remains here as some old Intel systems don't support the required extension ARB_explicit_attrib_location (and it's not in GL 3.0 either). Also updated and fixed the documentation. Function bindAttribute() was renamed to bindAttributeLocation() to be consistent with bindFragmentDataLocation(). PhongShader now uses explicit attribute location.
14 years ago
layout(location = 1) in vec3 normal;
Mesh rework, part 1: better vertex attribute management. * Instead of "binding attributes" the user now "adds vertex buffer". It corresponds better with what OpenGL itself does. * Vertex buffers now must be managed by the user. * Shader attributes are now static const members instead of typedefs to allow more convenient add*VertexBuffer*() calls.
14 years ago
layout(location = 2) in vec2 textureCoordinates;
Deprecating AbstractShaderProgram::bind*Location(). Preferred workflow is to specify attribute location explicitly in the shader. The functions remains here as some old Intel systems don't support the required extension ARB_explicit_attrib_location (and it's not in GL 3.0 either). Also updated and fixed the documentation. Function bindAttribute() was renamed to bindAttributeLocation() to be consistent with bindFragmentDataLocation(). PhongShader now uses explicit attribute location.
14 years ago
@endcode
Added AbstractShaderProgram::bindFragmentDataLocationIndexed().
14 years ago
Similarly for ouput attributes, you can also specify blend equation color
index for them (see Framebuffer::BlendFunction for more information about
using color input index):
@code
layout(location = 0, index = 0) out vec4 color;
layout(location = 1, index = 1) out vec4 ambient;
@endcode
Clarified required GL versions for shader attribute binding. Also updated section names to follow coding style.
14 years ago
@requires_gl (for explicit input attribute location instead of using
bindAttributeLocation())
Unsigned uniforms and retrievable hint supported in OpenGL ES 3.0.
14 years ago
@requires_gl (for using bindFragmentDataLocation() /
bindFragmentDataLocationIndexed())
Clarified required GL versions for shader attribute binding. Also updated section names to follow coding style.
14 years ago
@requires_gl30 Extension @extension{EXT,gpu_shader4} (for using
bindFragmentDataLocation())
Added AbstractShaderProgram::bindFragmentDataLocationIndexed().
14 years ago
@requires_gl33 Extension @extension{ARB,blend_func_extended} (for using
bindFragmentDataLocationIndexed())
Deprecating AbstractShaderProgram::bind*Location(). Preferred workflow is to specify attribute location explicitly in the shader. The functions remains here as some old Intel systems don't support the required extension ARB_explicit_attrib_location (and it's not in GL 3.0 either). Also updated and fixed the documentation. Function bindAttribute() was renamed to bindAttributeLocation() to be consistent with bindFragmentDataLocation(). PhongShader now uses explicit attribute location.
14 years ago
@requires_gl33 Extension @extension{ARB,explicit_attrib_location} (for
explicit attribute location instead of using bindAttributeLocation())
Unsigned uniforms and retrievable hint supported in OpenGL ES 3.0.
14 years ago
@requires_gles30 (no extension providing this functionality) (for explicit
input and output attribute location)
Added function to bind fragment data locations.
14 years ago
Deprecating AbstractShaderProgram::bind*Location(). Preferred workflow is to specify attribute location explicitly in the shader. The functions remains here as some old Intel systems don't support the required extension ARB_explicit_attrib_location (and it's not in GL 3.0 either). Also updated and fixed the documentation. Function bindAttribute() was renamed to bindAttributeLocation() to be consistent with bindFragmentDataLocation(). PhongShader now uses explicit attribute location.
14 years ago
If you don't have the required extension, you can use functions bindAttributeLocation()
Added AbstractShaderProgram::bindFragmentDataLocationIndexed().
14 years ago
and bindFragmentDataLocation() / bindFragmentDataLocationIndexed() between
attaching the shaders and linking the program:
Added function to bind fragment data locations.
14 years ago
@code
Deprecating AbstractShaderProgram::bind*Location(). Preferred workflow is to specify attribute location explicitly in the shader. The functions remains here as some old Intel systems don't support the required extension ARB_explicit_attrib_location (and it's not in GL 3.0 either). Also updated and fixed the documentation. Function bindAttribute() was renamed to bindAttributeLocation() to be consistent with bindFragmentDataLocation(). PhongShader now uses explicit attribute location.
14 years ago
// Shaders attached...
Mesh rework, part 1: better vertex attribute management. * Instead of "binding attributes" the user now "adds vertex buffer". It corresponds better with what OpenGL itself does. * Vertex buffers now must be managed by the user. * Shader attributes are now static const members instead of typedefs to allow more convenient add*VertexBuffer*() calls.
14 years ago
bindAttributeLocation(Position.Location, "position");
bindAttributeLocation(Normal.Location, "normal");
bindAttributeLocation(TextureCoords.Location, "textureCoordinates");
Deprecating AbstractShaderProgram::bind*Location(). Preferred workflow is to specify attribute location explicitly in the shader. The functions remains here as some old Intel systems don't support the required extension ARB_explicit_attrib_location (and it's not in GL 3.0 either). Also updated and fixed the documentation. Function bindAttribute() was renamed to bindAttributeLocation() to be consistent with bindFragmentDataLocation(). PhongShader now uses explicit attribute location.
14 years ago
Added AbstractShaderProgram::bindFragmentDataLocationIndexed().
14 years ago
bindFragmentDataLocationIndexed(0, 0, "color");
bindFragmentDataLocationIndexed(1, 1, "ambient");
Deprecating AbstractShaderProgram::bind*Location(). Preferred workflow is to specify attribute location explicitly in the shader. The functions remains here as some old Intel systems don't support the required extension ARB_explicit_attrib_location (and it's not in GL 3.0 either). Also updated and fixed the documentation. Function bindAttribute() was renamed to bindAttributeLocation() to be consistent with bindFragmentDataLocation(). PhongShader now uses explicit attribute location.
14 years ago
// Link...
Added function to bind fragment data locations.
14 years ago
@endcode
Deprecated uniformLocation() in favor of GL 4.3 explicit uniform location.
14 years ago
@subsection AbstractShaderProgram-uniform-location Uniform locations
The preferred workflow is to specify uniform locations directly in the shader
code, e.g.:
@code
#version 430
// or #extension GL_ARB_explicit_uniform_location: enable
Updated and simplified AbstractShaderProgram documentation.
14 years ago
layout(location = 0) uniform mat4 transformation;
layout(location = 1) uniform mat4 projection;
Deprecated uniformLocation() in favor of GL 4.3 explicit uniform location.
14 years ago
@endcode
@requires_gl (for explicit uniform location instead of using uniformLocation())
@requires_gl43 Extension @extension{ARB,explicit_uniform_location} (for
explicit uniform location instead of using uniformLocation())
If you don't have the required extension, you can get uniform location using
uniformLocation() after linking stage:
@code
Updated and simplified AbstractShaderProgram documentation.
14 years ago
GLint transformationUniform = uniformLocation("transformation");
GLint projectionUniform = uniformLocation("projection");
Deprecated uniformLocation() in favor of GL 4.3 explicit uniform location.
14 years ago
@endcode
Clarified required GL versions for shader attribute binding. Also updated section names to follow coding style.
14 years ago
@subsection AbstractShaderProgram-texture-layer Binding texture layer uniforms
Reworked binding of textures to shaders. According to OpenGL specification the sampler uniform takes only texture layer and not any particular texture. In OpenGL 4.2 it is possible to explicitly specify desired texture layer in the uniform, so I suppose it's desired to have shader with fixed texture layers and on the other hand be able to bind texture to any layer, not only one -- the exact opposite of how it was in Magnum before. The shader should now specify in its public API which texture is on which layer and explicitly set the layer uniforms upon construction. All setUniform() functions taking textures as argument were thus removed, as they confuse things a lot. The textures now have bind() function which takes layer as argument, so it's now sufficient to only bind the texture before drawing the mesh without messing with sampler uniform.
14 years ago
The preferred workflow is to specify texture layers directly in the shader
code, e.g.:
@code
Mention required version/extension in shader code.
14 years ago
#version 420
// or #extension GL_ARB_shading_language_420pack: enable
Reworked binding of textures to shaders. According to OpenGL specification the sampler uniform takes only texture layer and not any particular texture. In OpenGL 4.2 it is possible to explicitly specify desired texture layer in the uniform, so I suppose it's desired to have shader with fixed texture layers and on the other hand be able to bind texture to any layer, not only one -- the exact opposite of how it was in Magnum before. The shader should now specify in its public API which texture is on which layer and explicitly set the layer uniforms upon construction. All setUniform() functions taking textures as argument were thus removed, as they confuse things a lot. The textures now have bind() function which takes layer as argument, so it's now sufficient to only bind the texture before drawing the mesh without messing with sampler uniform.
14 years ago
layout(binding = 0) uniform sampler2D diffuseTexture;
layout(binding = 1) uniform sampler2D specularTexture;
@endcode
Port to OpenGL ES 2. Desktop OpenGL and OpenGL ES 2 support can be switched using CMake TARGET_GLES option. All functionality not supported in ES is marked in documentation. If targetting OpenGL ES, GLES2/gl2.h is included instead of GLEW. Mesh class now uses VAOs only in desktop OpenGL, in ES the buffers are bound on each draw call.
14 years ago
@requires_gl (for explicit texture layer binding instead of using
setUniform(GLint, GLint))
Reworked binding of textures to shaders. According to OpenGL specification the sampler uniform takes only texture layer and not any particular texture. In OpenGL 4.2 it is possible to explicitly specify desired texture layer in the uniform, so I suppose it's desired to have shader with fixed texture layers and on the other hand be able to bind texture to any layer, not only one -- the exact opposite of how it was in Magnum before. The shader should now specify in its public API which texture is on which layer and explicitly set the layer uniforms upon construction. All setUniform() functions taking textures as argument were thus removed, as they confuse things a lot. The textures now have bind() function which takes layer as argument, so it's now sufficient to only bind the texture before drawing the mesh without messing with sampler uniform.
14 years ago
@requires_gl42 Extension @extension{ARB,shading_language_420pack} (for explicit
texture layer binding instead of using setUniform(GLint, GLint))
If you don't have the required extension (or if you want to change the layer
later), you can set the texture layer uniform using setUniform(GLint, GLint):
@code
use();
Deprecated uniformLocation() in favor of GL 4.3 explicit uniform location.
14 years ago
setUniform(DiffuseTextureUniform, DiffuseTextureLayer);
setUniform(SpecularTextureUniform, SpecularTextureLayer);
Reworked binding of textures to shaders. According to OpenGL specification the sampler uniform takes only texture layer and not any particular texture. In OpenGL 4.2 it is possible to explicitly specify desired texture layer in the uniform, so I suppose it's desired to have shader with fixed texture layers and on the other hand be able to bind texture to any layer, not only one -- the exact opposite of how it was in Magnum before. The shader should now specify in its public API which texture is on which layer and explicitly set the layer uniforms upon construction. All setUniform() functions taking textures as argument were thus removed, as they confuse things a lot. The textures now have bind() function which takes layer as argument, so it's now sufficient to only bind the texture before drawing the mesh without messing with sampler uniform.
14 years ago
@endcode
Clarified required GL versions for shader attribute binding. Also updated section names to follow coding style.
14 years ago
@section AbstractShaderProgram-rendering-workflow Rendering workflow
Deprecating AbstractShaderProgram::bind*Location(). Preferred workflow is to specify attribute location explicitly in the shader. The functions remains here as some old Intel systems don't support the required extension ARB_explicit_attrib_location (and it's not in GL 3.0 either). Also updated and fixed the documentation. Function bindAttribute() was renamed to bindAttributeLocation() to be consistent with bindFragmentDataLocation(). PhongShader now uses explicit attribute location.
14 years ago
Mesh rework, part 1: better vertex attribute management. * Instead of "binding attributes" the user now "adds vertex buffer". It corresponds better with what OpenGL itself does. * Vertex buffers now must be managed by the user. * Shader attributes are now static const members instead of typedefs to allow more convenient add*VertexBuffer*() calls.
14 years ago
Basic workflow with %AbstractShaderProgram subclasses is to instance the class
and configuring attribute binding in meshes (see @ref Mesh-configuration "Mesh documentation"
for more information) at the beginning, then in draw event setting uniforms
and marking the shader for use, binding required textures to their respective
layers using AbstractTexture::bind(GLint) and calling Mesh::draw(). Example:
Reworked binding of textures to shaders. According to OpenGL specification the sampler uniform takes only texture layer and not any particular texture. In OpenGL 4.2 it is possible to explicitly specify desired texture layer in the uniform, so I suppose it's desired to have shader with fixed texture layers and on the other hand be able to bind texture to any layer, not only one -- the exact opposite of how it was in Magnum before. The shader should now specify in its public API which texture is on which layer and explicitly set the layer uniforms upon construction. All setUniform() functions taking textures as argument were thus removed, as they confuse things a lot. The textures now have bind() function which takes layer as argument, so it's now sufficient to only bind the texture before drawing the mesh without messing with sampler uniform.
14 years ago
@code
Updated and simplified AbstractShaderProgram documentation.
14 years ago
shader->setTransformation(transformation)
->setProjection(projection)
->use();
diffuseTexture->bind(MyShader::DiffuseTextureLayer);
specularTexture->bind(MyShader::SpecularTextureLayer);
mesh.draw();
Reworked binding of textures to shaders. According to OpenGL specification the sampler uniform takes only texture layer and not any particular texture. In OpenGL 4.2 it is possible to explicitly specify desired texture layer in the uniform, so I suppose it's desired to have shader with fixed texture layers and on the other hand be able to bind texture to any layer, not only one -- the exact opposite of how it was in Magnum before. The shader should now specify in its public API which texture is on which layer and explicitly set the layer uniforms upon construction. All setUniform() functions taking textures as argument were thus removed, as they confuse things a lot. The textures now have bind() function which takes layer as argument, so it's now sufficient to only bind the texture before drawing the mesh without messing with sampler uniform.
14 years ago
@endcode
Support for all remaining uniform vector types, except arrays.
14 years ago
Documented internal shader program state tracking.
14 years ago
@section AbstractShaderProgram-performance-optimization Performance optimizations
The engine tracks currently used shader program to avoid unnecessary calls to
@fn_gl{UseProgram}.
If extension @extension{ARB,separate_shader_objects} or
Mesh rework, part 1: better vertex attribute management. * Instead of "binding attributes" the user now "adds vertex buffer". It corresponds better with what OpenGL itself does. * Vertex buffers now must be managed by the user. * Shader attributes are now static const members instead of typedefs to allow more convenient add*VertexBuffer*() calls.
14 years ago
@extension{EXT,direct_state_access} is available, uniform setting functions
use DSA functions to avoid unnecessary calls to @fn_gl{UseProgram}. See
setUniform(GLint, GLfloat) documentation for more information.
Documented internal shader program state tracking.
14 years ago
To achieve least state changes, set all uniforms in one run -- method chaining
comes in handy.
Support for all remaining uniform vector types, except arrays.
14 years ago
@todo Uniform arrays support
Classes for compiling and using shaders.
16 years ago
*/
Added dllimport/dllexport macros for Windows builds.
14 years ago
class MAGNUM_EXPORT AbstractShaderProgram {
Using EXT_direct_state_access/ARB_separate_shader_objects for uniforms. Also explicitly calling use() on default (non-DSA) setUniform() implementation. Because of that, it is now possible to conveniently call use() at the end, instead of at the beginning of uniform setting chain, for example: // before shader->use(); shader->setTransformation(transformation) ->setProjection(projection) ->setColor(color); // now shader->setTransformation(transformation) ->setProjection(projection) ->setColor(color) ->use(); Note that you still have to explicitly call use(), because if DSA is available, no use() is called explicitly on any setUniform(). If DSA is not available, use() is called on first setUniform() and subsequent calls have no negative performance impacts.
14 years ago
friend class Context;
C++11 (move semantics) compatible class copy/move disabling. Not using macro this time, as some classes could want only to disable either copy or move and with macros this would become unintuitive and error-prone.
15 years ago
AbstractShaderProgram(const AbstractShaderProgram& other) = delete;
AbstractShaderProgram(AbstractShaderProgram&& other) = delete;
AbstractShaderProgram& operator=(const AbstractShaderProgram& other) = delete;
AbstractShaderProgram& operator=(AbstractShaderProgram&& other) = delete;
Classes for compiling and using shaders.
16 years ago
public:
Type-safe shader attributes. Now the data type is part of attribute definition, so user doesn't have to guess / look up what data should be there when binding with Mesh::bindAttribute().
14 years ago
/**
* @brief Base struct for attribute location and type
*
Use the right type for attribute binding location.
14 years ago
* See @ref AbstractShaderProgram-subclassing or Mesh::bindAttribute()
Type-safe shader attributes. Now the data type is part of attribute definition, so user doesn't have to guess / look up what data should be there when binding with Mesh::bindAttribute().
14 years ago
* for an example.
Added TODOs for easily implementable things.
14 years ago
*
@todo++
14 years ago
* @todo Support for BGRA attribute type (OpenGL 3.2, @extension{ARB,vertex_array_bgra})
Type-safe shader attributes. Now the data type is part of attribute definition, so user doesn't have to guess / look up what data should be there when binding with Mesh::bindAttribute().
14 years ago
*/
Use the right type for attribute binding location.
14 years ago
template<GLuint i, class T> struct Attribute {
static const GLuint Location = i; /**< Location to which the attribute is bound */
Documentation updates, "markdownization". All HTML code and Doxygen shortcuts such as @c, @b and @em are now rewritten using Markdown syntax, which makes it more readable. Also updated Doxyfile. Doxygen 1.8 at least is required to generate the documentation now.
14 years ago
typedef T Type; /**< %Attribute type */
Type-safe shader attributes. Now the data type is part of attribute definition, so user doesn't have to guess / look up what data should be there when binding with Mesh::bindAttribute().
14 years ago
};
Create and delete shaders and programs only on construction/destruction. Also inlined some simple functions, updated documentation.
14 years ago
/**
* @brief Constructor
*
* Creates one OpenGL shader program.
Links to documentation of related gl*() function. Each function touching OpenGL now has list of all related functions touching OpenGL.
14 years ago
* @see @fn_gl{CreateProgram}
Create and delete shaders and programs only on construction/destruction. Also inlined some simple functions, updated documentation.
14 years ago
*/
inline AbstractShaderProgram(): state(Initialized) {
Refactoring of internal OpenGL object names.
14 years ago
_id = glCreateProgram();
Create and delete shaders and programs only on construction/destruction. Also inlined some simple functions, updated documentation.
14 years ago
}
Classes for compiling and using shaders.
16 years ago
/**
* @brief Destructor
*
Create and delete shaders and programs only on construction/destruction. Also inlined some simple functions, updated documentation.
14 years ago
* Deletes associated OpenGL shader program.
Links to documentation of related gl*() function. Each function touching OpenGL now has list of all related functions touching OpenGL.
14 years ago
* @see @fn_gl{DeleteProgram}
Classes for compiling and using shaders.
16 years ago
*/
Disable instantiation of all Abstract* classes. For classes which already have pure virtual functions instantiation is not allowed, but for other there needs to be at least one pure virtual method: the destructor. Pure virtual functions actually can have implementations, but they must be called explicitly. Destructors are called explicitly, so for them it works.
14 years ago
virtual ~AbstractShaderProgram() = 0;
Classes for compiling and using shaders.
16 years ago
/**
Using EXT_direct_state_access/ARB_separate_shader_objects for uniforms. Also explicitly calling use() on default (non-DSA) setUniform() implementation. Because of that, it is now possible to conveniently call use() at the end, instead of at the beginning of uniform setting chain, for example: // before shader->use(); shader->setTransformation(transformation) ->setProjection(projection) ->setColor(color); // now shader->setTransformation(transformation) ->setProjection(projection) ->setColor(color) ->use(); Note that you still have to explicitly call use(), because if DSA is available, no use() is called explicitly on any setUniform(). If DSA is not available, use() is called on first setUniform() and subsequent calls have no negative performance impacts.
14 years ago
* @brief Use shader for rendering
Classes for compiling and using shaders.
16 years ago
* @return False if the program wasn't successfully linked, true
* otherwise.
Links to documentation of related gl*() function. Each function touching OpenGL now has list of all related functions touching OpenGL.
14 years ago
*
* @see @fn_gl{UseProgram}
Classes for compiling and using shaders.
16 years ago
*/
bool use();
protected:
Support for setting shader program parameters. Updated call order documentation to be more precise.
14 years ago
/**
Less verbose program parameter setters. In future there might be functions which take values other than GL_TRUE and GL_FALSE and this approach would be unsustainable.
14 years ago
* @brief Allow retrieving program binary
Support for setting shader program parameters. Updated call order documentation to be more precise.
14 years ago
*
Links to documentation of related gl*() function. Each function touching OpenGL now has list of all related functions touching OpenGL.
14 years ago
* Initially disabled.
Less verbose program parameter setters. In future there might be functions which take values other than GL_TRUE and GL_FALSE and this approach would be unsustainable.
14 years ago
* @note This function should be called after attachShader() calls and
* before link().
Links to documentation of related gl*() function. Each function touching OpenGL now has list of all related functions touching OpenGL.
14 years ago
* @see @fn_gl{ProgramParameter} with @def_gl{PROGRAM_BINARY_RETRIEVABLE_HINT}
* @requires_gl
* @requires_gl41 Extension @extension{ARB,get_program_binary}
Unsigned uniforms and retrievable hint supported in OpenGL ES 3.0.
14 years ago
* @requires_gles30 (no extension providing this functionality)
Support for setting shader program parameters. Updated call order documentation to be more precise.
14 years ago
*/
Less verbose program parameter setters. In future there might be functions which take values other than GL_TRUE and GL_FALSE and this approach would be unsustainable.
14 years ago
inline void setRetrievableBinary(bool enabled) {
Refactoring of internal OpenGL object names.
14 years ago
glProgramParameteri(_id, GL_PROGRAM_BINARY_RETRIEVABLE_HINT, enabled ? GL_TRUE : GL_FALSE);
Less verbose program parameter setters. In future there might be functions which take values other than GL_TRUE and GL_FALSE and this approach would be unsustainable.
14 years ago
}
Support for setting shader program parameters. Updated call order documentation to be more precise.
14 years ago
Unsigned uniforms and retrievable hint supported in OpenGL ES 3.0.
14 years ago
#ifndef MAGNUM_TARGET_GLES
Support for setting shader program parameters. Updated call order documentation to be more precise.
14 years ago
/**
Less verbose program parameter setters. In future there might be functions which take values other than GL_TRUE and GL_FALSE and this approach would be unsustainable.
14 years ago
* @brief Allow the program to be bound to individual pipeline stages
Support for setting shader program parameters. Updated call order documentation to be more precise.
14 years ago
*
Links to documentation of related gl*() function. Each function touching OpenGL now has list of all related functions touching OpenGL.
14 years ago
* Initially disabled.
Support for setting shader program parameters. Updated call order documentation to be more precise.
14 years ago
* @note This function should be called after attachShader() calls and
* before link().
Links to documentation of related gl*() function. Each function touching OpenGL now has list of all related functions touching OpenGL.
14 years ago
* @see @fn_gl{ProgramParameter} with @def_gl{PROGRAM_SEPARABLE}
* @requires_gl
* @requires_gl41 Extension @extension{ARB,separate_shader_objects}
Support for setting shader program parameters. Updated call order documentation to be more precise.
14 years ago
*/
Less verbose program parameter setters. In future there might be functions which take values other than GL_TRUE and GL_FALSE and this approach would be unsustainable.
14 years ago
inline void setSeparable(bool enabled) {
Refactoring of internal OpenGL object names.
14 years ago
glProgramParameteri(_id, GL_PROGRAM_SEPARABLE, enabled ? GL_TRUE : GL_FALSE);
Support for setting shader program parameters. Updated call order documentation to be more precise.
14 years ago
}
Port to OpenGL ES 2. Desktop OpenGL and OpenGL ES 2 support can be switched using CMake TARGET_GLES option. All functionality not supported in ES is marked in documentation. If targetting OpenGL ES, GLES2/gl2.h is included instead of GLEW. Mesh class now uses VAOs only in desktop OpenGL, in ES the buffers are bound on each draw call.
14 years ago
#endif
Support for setting shader program parameters. Updated call order documentation to be more precise.
14 years ago
Classes for compiling and using shaders.
16 years ago
/**
* @brief Load shader
* @return False if the shader wasn't successfully compiled, true
* otherwise.
*
* Compiles the shader, if it is not already, and prepares it for
* linking.
Links to documentation of related gl*() function. Each function touching OpenGL now has list of all related functions touching OpenGL.
14 years ago
* @see Shader::compile(), @fn_gl{AttachShader}
Classes for compiling and using shaders.
16 years ago
*/
Move semantic for Shader class. The class is now created always on the stack, so the user doesn't have to delete it explicitly. It's now possible to write less verbose shader code, instead of three lines before: Shader* s = Shader::fromFile(Shader::Fragment, "Shader.frag"); attachShader(s); // ... delete s; It's now only one: attachShader(Shader::fromFile(Shader::Fragment, "Shader.frag"));
14 years ago
bool attachShader(Shader& shader);
Links to documentation of related gl*() function. Each function touching OpenGL now has list of all related functions touching OpenGL.
14 years ago
/** @overload */
Move semantic for Shader class. The class is now created always on the stack, so the user doesn't have to delete it explicitly. It's now possible to write less verbose shader code, instead of three lines before: Shader* s = Shader::fromFile(Shader::Fragment, "Shader.frag"); attachShader(s); // ... delete s; It's now only one: attachShader(Shader::fromFile(Shader::Fragment, "Shader.frag"));
14 years ago
inline bool attachShader(Shader&& shader) {
return attachShader(shader);
}
Classes for compiling and using shaders.
16 years ago
/**
* @brief Bind attribute to given location
* @param location Location
* @param name Attribute name
*
Doc++
14 years ago
* Binds attribute to location which is used later for binding vertex
* buffers.
Support for setting shader program parameters. Updated call order documentation to be more precise.
14 years ago
* @note This function should be called after attachShader() calls and
* before link().
Deprecating AbstractShaderProgram::bind*Location(). Preferred workflow is to specify attribute location explicitly in the shader. The functions remains here as some old Intel systems don't support the required extension ARB_explicit_attrib_location (and it's not in GL 3.0 either). Also updated and fixed the documentation. Function bindAttribute() was renamed to bindAttributeLocation() to be consistent with bindFragmentDataLocation(). PhongShader now uses explicit attribute location.
14 years ago
* @deprecated Preferred usage is to specify attribute location
* explicitly in the shader instead of using this function. See
Clarified required GL versions for shader attribute binding. Also updated section names to follow coding style.
14 years ago
* @ref AbstractShaderProgram-attribute-location "class documentation"
Deprecating AbstractShaderProgram::bind*Location(). Preferred workflow is to specify attribute location explicitly in the shader. The functions remains here as some old Intel systems don't support the required extension ARB_explicit_attrib_location (and it's not in GL 3.0 either). Also updated and fixed the documentation. Function bindAttribute() was renamed to bindAttributeLocation() to be consistent with bindFragmentDataLocation(). PhongShader now uses explicit attribute location.
14 years ago
* for more information.
Links to documentation of related gl*() function. Each function touching OpenGL now has list of all related functions touching OpenGL.
14 years ago
* @see @fn_gl{BindAttribLocation}
Classes for compiling and using shaders.
16 years ago
*/
Deprecating AbstractShaderProgram::bind*Location(). Preferred workflow is to specify attribute location explicitly in the shader. The functions remains here as some old Intel systems don't support the required extension ARB_explicit_attrib_location (and it's not in GL 3.0 either). Also updated and fixed the documentation. Function bindAttribute() was renamed to bindAttributeLocation() to be consistent with bindFragmentDataLocation(). PhongShader now uses explicit attribute location.
14 years ago
void bindAttributeLocation(GLuint location, const std::string& name);
Classes for compiling and using shaders.
16 years ago
Port to OpenGL ES 2. Desktop OpenGL and OpenGL ES 2 support can be switched using CMake TARGET_GLES option. All functionality not supported in ES is marked in documentation. If targetting OpenGL ES, GLES2/gl2.h is included instead of GLEW. Mesh class now uses VAOs only in desktop OpenGL, in ES the buffers are bound on each draw call.
14 years ago
#ifndef MAGNUM_TARGET_GLES
Added function to bind fragment data locations.
14 years ago
/**
Added AbstractShaderProgram::bindFragmentDataLocationIndexed().
14 years ago
* @brief Bind fragment data to given location and color input index
Added function to bind fragment data locations.
14 years ago
* @param location Location
* @param name Fragment output variable name
Added AbstractShaderProgram::bindFragmentDataLocationIndexed().
14 years ago
* @param index Blend equation color input index (`0` or `1`)
Added function to bind fragment data locations.
14 years ago
*
Added AbstractShaderProgram::bindFragmentDataLocationIndexed().
14 years ago
* Binds fragment data to location which is used later for framebuffer
* operations. See also Framebuffer::BlendFunction for more
* information about using color input index.
Support for setting shader program parameters. Updated call order documentation to be more precise.
14 years ago
* @note This function should be called after attachShader() calls and
* before link().
Deprecating AbstractShaderProgram::bind*Location(). Preferred workflow is to specify attribute location explicitly in the shader. The functions remains here as some old Intel systems don't support the required extension ARB_explicit_attrib_location (and it's not in GL 3.0 either). Also updated and fixed the documentation. Function bindAttribute() was renamed to bindAttributeLocation() to be consistent with bindFragmentDataLocation(). PhongShader now uses explicit attribute location.
14 years ago
* @deprecated Preferred usage is to specify attribute location
* explicitly in the shader instead of using this function. See
Clarified required GL versions for shader attribute binding. Also updated section names to follow coding style.
14 years ago
* @ref AbstractShaderProgram-attribute-location "class documentation"
Deprecating AbstractShaderProgram::bind*Location(). Preferred workflow is to specify attribute location explicitly in the shader. The functions remains here as some old Intel systems don't support the required extension ARB_explicit_attrib_location (and it's not in GL 3.0 either). Also updated and fixed the documentation. Function bindAttribute() was renamed to bindAttributeLocation() to be consistent with bindFragmentDataLocation(). PhongShader now uses explicit attribute location.
14 years ago
* for more information.
Links to documentation of related gl*() function. Each function touching OpenGL now has list of all related functions touching OpenGL.
14 years ago
* @see @fn_gl{BindFragDataLocationIndexed}
* @requires_gl
* @requires_gl33 Extension @extension{ARB,blend_func_extended}
Added AbstractShaderProgram::bindFragmentDataLocationIndexed().
14 years ago
*/
void bindFragmentDataLocationIndexed(GLuint location, GLuint index, const std::string& name);
/**
* @brief Bind fragment data to given location and first color input index
* @param location Location
* @param name Fragment output variable name
*
* The same as bindFragmentDataLocationIndexed(), but with `index` set
* to `0`.
Links to documentation of related gl*() function. Each function touching OpenGL now has list of all related functions touching OpenGL.
14 years ago
* @see @fn_gl{BindFragDataLocation}
Port to OpenGL ES 2. Desktop OpenGL and OpenGL ES 2 support can be switched using CMake TARGET_GLES option. All functionality not supported in ES is marked in documentation. If targetting OpenGL ES, GLES2/gl2.h is included instead of GLEW. Mesh class now uses VAOs only in desktop OpenGL, in ES the buffers are bound on each draw call.
14 years ago
* @requires_gl
Links to required extensions in documentation. Fixed a few typos in extension names, fixed BPTC texture compression typos. Removed redundant EXT_framebuffer_object from functions as the Framebuffer class itself has it.
14 years ago
* @requires_gl30 Extension @extension{EXT,gpu_shader4}
Added function to bind fragment data locations.
14 years ago
*/
void bindFragmentDataLocation(GLuint location, const std::string& name);
Port to OpenGL ES 2. Desktop OpenGL and OpenGL ES 2 support can be switched using CMake TARGET_GLES option. All functionality not supported in ES is marked in documentation. If targetting OpenGL ES, GLES2/gl2.h is included instead of GLEW. Mesh class now uses VAOs only in desktop OpenGL, in ES the buffers are bound on each draw call.
14 years ago
#endif
Added function to bind fragment data locations.
14 years ago
Classes for compiling and using shaders.
16 years ago
/**
* @brief Link the shader
*
* Binds previously specified attributes to given indexes and links the
* shader program together.
Links to documentation of related gl*() function. Each function touching OpenGL now has list of all related functions touching OpenGL.
14 years ago
* @see @fn_gl{LinkProgram}, @fn_gl{GetProgram} with
* @def_gl{LINK_STATUS}, @fn_gl{GetProgramInfoLog}
Classes for compiling and using shaders.
16 years ago
*/
void link();
/**
* @brief Get uniform location
* @param name Uniform name
*
* @note This function should be called after link().
Deprecated uniformLocation() in favor of GL 4.3 explicit uniform location.
14 years ago
* @deprecated Preferred usage is to specify uniform location
* explicitly in the shader instead of using this function. See
* @ref AbstractShaderProgram-uniform-location "class documentation"
* for more information.
Links to documentation of related gl*() function. Each function touching OpenGL now has list of all related functions touching OpenGL.
14 years ago
* @see @fn_gl{GetUniformLocation}
Classes for compiling and using shaders.
16 years ago
*/
GLint uniformLocation(const std::string& name);
/**
* @brief Set uniform value
* @param location Uniform location (see uniformLocation())
* @param value Value
*
Using EXT_direct_state_access/ARB_separate_shader_objects for uniforms. Also explicitly calling use() on default (non-DSA) setUniform() implementation. Because of that, it is now possible to conveniently call use() at the end, instead of at the beginning of uniform setting chain, for example: // before shader->use(); shader->setTransformation(transformation) ->setProjection(projection) ->setColor(color); // now shader->setTransformation(transformation) ->setProjection(projection) ->setColor(color) ->use(); Note that you still have to explicitly call use(), because if DSA is available, no use() is called explicitly on any setUniform(). If DSA is not available, use() is called on first setUniform() and subsequent calls have no negative performance impacts.
14 years ago
* If neither @extension{ARB,separate_shader_objects} nor
Documented internal shader program state tracking.
14 years ago
* @extension{EXT,direct_state_access} is available, the shader is
* marked for use before the operation.
* @see @fn_gl{UseProgram}, @fn_gl{Uniform} or `glProgramUniform()`
* from @extension{ARB,separate_shader_objects}/@extension{EXT,direct_state_access}.
Classes for compiling and using shaders.
16 years ago
*/
Support for all remaining uniform vector types, except arrays.
14 years ago
inline void setUniform(GLint location, GLfloat value) {
Using EXT_direct_state_access/ARB_separate_shader_objects for uniforms. Also explicitly calling use() on default (non-DSA) setUniform() implementation. Because of that, it is now possible to conveniently call use() at the end, instead of at the beginning of uniform setting chain, for example: // before shader->use(); shader->setTransformation(transformation) ->setProjection(projection) ->setColor(color); // now shader->setTransformation(transformation) ->setProjection(projection) ->setColor(color) ->use(); Note that you still have to explicitly call use(), because if DSA is available, no use() is called explicitly on any setUniform(). If DSA is not available, use() is called on first setUniform() and subsequent calls have no negative performance impacts.
14 years ago
(this->*uniform1fImplementation)(location, value);
Support for all remaining uniform vector types, except arrays.
14 years ago
}
/** @copydoc setUniform(GLint, GLfloat) */
Using EXT_direct_state_access/ARB_separate_shader_objects for uniforms. Also explicitly calling use() on default (non-DSA) setUniform() implementation. Because of that, it is now possible to conveniently call use() at the end, instead of at the beginning of uniform setting chain, for example: // before shader->use(); shader->setTransformation(transformation) ->setProjection(projection) ->setColor(color); // now shader->setTransformation(transformation) ->setProjection(projection) ->setColor(color) ->use(); Note that you still have to explicitly call use(), because if DSA is available, no use() is called explicitly on any setUniform(). If DSA is not available, use() is called on first setUniform() and subsequent calls have no negative performance impacts.
14 years ago
inline void setUniform(GLint location, const Math::Vector<2, GLfloat>& value) {
(this->*uniform2fvImplementation)(location, value);
Support for all remaining uniform vector types, except arrays.
14 years ago
}
/** @copydoc setUniform(GLint, GLfloat) */
Using EXT_direct_state_access/ARB_separate_shader_objects for uniforms. Also explicitly calling use() on default (non-DSA) setUniform() implementation. Because of that, it is now possible to conveniently call use() at the end, instead of at the beginning of uniform setting chain, for example: // before shader->use(); shader->setTransformation(transformation) ->setProjection(projection) ->setColor(color); // now shader->setTransformation(transformation) ->setProjection(projection) ->setColor(color) ->use(); Note that you still have to explicitly call use(), because if DSA is available, no use() is called explicitly on any setUniform(). If DSA is not available, use() is called on first setUniform() and subsequent calls have no negative performance impacts.
14 years ago
inline void setUniform(GLint location, const Math::Vector<3, GLfloat>& value) {
(this->*uniform3fvImplementation)(location, value);
Support for all remaining uniform vector types, except arrays.
14 years ago
}
/** @copydoc setUniform(GLint, GLfloat) */
Using EXT_direct_state_access/ARB_separate_shader_objects for uniforms. Also explicitly calling use() on default (non-DSA) setUniform() implementation. Because of that, it is now possible to conveniently call use() at the end, instead of at the beginning of uniform setting chain, for example: // before shader->use(); shader->setTransformation(transformation) ->setProjection(projection) ->setColor(color); // now shader->setTransformation(transformation) ->setProjection(projection) ->setColor(color) ->use(); Note that you still have to explicitly call use(), because if DSA is available, no use() is called explicitly on any setUniform(). If DSA is not available, use() is called on first setUniform() and subsequent calls have no negative performance impacts.
14 years ago
inline void setUniform(GLint location, const Math::Vector<4, GLfloat>& value) {
(this->*uniform4fvImplementation)(location, value);
Support for all remaining uniform vector types, except arrays.
14 years ago
}
/** @copydoc setUniform(GLint, GLfloat) */
Classes for compiling and using shaders.
16 years ago
inline void setUniform(GLint location, GLint value) {
Using EXT_direct_state_access/ARB_separate_shader_objects for uniforms. Also explicitly calling use() on default (non-DSA) setUniform() implementation. Because of that, it is now possible to conveniently call use() at the end, instead of at the beginning of uniform setting chain, for example: // before shader->use(); shader->setTransformation(transformation) ->setProjection(projection) ->setColor(color); // now shader->setTransformation(transformation) ->setProjection(projection) ->setColor(color) ->use(); Note that you still have to explicitly call use(), because if DSA is available, no use() is called explicitly on any setUniform(). If DSA is not available, use() is called on first setUniform() and subsequent calls have no negative performance impacts.
14 years ago
(this->*uniform1iImplementation)(location, value);
Classes for compiling and using shaders.
16 years ago
}
Minor documentation fixes.
14 years ago
/** @copydoc setUniform(GLint, GLfloat) */
Using EXT_direct_state_access/ARB_separate_shader_objects for uniforms. Also explicitly calling use() on default (non-DSA) setUniform() implementation. Because of that, it is now possible to conveniently call use() at the end, instead of at the beginning of uniform setting chain, for example: // before shader->use(); shader->setTransformation(transformation) ->setProjection(projection) ->setColor(color); // now shader->setTransformation(transformation) ->setProjection(projection) ->setColor(color) ->use(); Note that you still have to explicitly call use(), because if DSA is available, no use() is called explicitly on any setUniform(). If DSA is not available, use() is called on first setUniform() and subsequent calls have no negative performance impacts.
14 years ago
inline void setUniform(GLint location, const Math::Vector<2, GLint>& value) {
(this->*uniform2ivImplementation)(location, value);
Support for all remaining uniform vector types, except arrays.
14 years ago
}
Minor documentation fixes.
14 years ago
/** @copydoc setUniform(GLint, GLfloat) */
Using EXT_direct_state_access/ARB_separate_shader_objects for uniforms. Also explicitly calling use() on default (non-DSA) setUniform() implementation. Because of that, it is now possible to conveniently call use() at the end, instead of at the beginning of uniform setting chain, for example: // before shader->use(); shader->setTransformation(transformation) ->setProjection(projection) ->setColor(color); // now shader->setTransformation(transformation) ->setProjection(projection) ->setColor(color) ->use(); Note that you still have to explicitly call use(), because if DSA is available, no use() is called explicitly on any setUniform(). If DSA is not available, use() is called on first setUniform() and subsequent calls have no negative performance impacts.
14 years ago
inline void setUniform(GLint location, const Math::Vector<3, GLint>& value) {
(this->*uniform3ivImplementation)(location, value);
Support for all remaining uniform vector types, except arrays.
14 years ago
}
Minor documentation fixes.
14 years ago
/** @copydoc setUniform(GLint, GLfloat) */
Using EXT_direct_state_access/ARB_separate_shader_objects for uniforms. Also explicitly calling use() on default (non-DSA) setUniform() implementation. Because of that, it is now possible to conveniently call use() at the end, instead of at the beginning of uniform setting chain, for example: // before shader->use(); shader->setTransformation(transformation) ->setProjection(projection) ->setColor(color); // now shader->setTransformation(transformation) ->setProjection(projection) ->setColor(color) ->use(); Note that you still have to explicitly call use(), because if DSA is available, no use() is called explicitly on any setUniform(). If DSA is not available, use() is called on first setUniform() and subsequent calls have no negative performance impacts.
14 years ago
inline void setUniform(GLint location, const Math::Vector<4, GLint>& value) {
(this->*uniform4ivImplementation)(location, value);
Support for all remaining uniform vector types, except arrays.
14 years ago
}
Added TODOs for easily implementable things.
14 years ago
Documented required OpenGL version for some functionality. The requirements are cross-referenced to dedicated page, similarly to TODO and bug lists. Also updated / improved documentation for some texture / image formats.
14 years ago
/**
Minor documentation fixes.
14 years ago
* @copydoc setUniform(GLint, GLfloat)
Links to required extensions in documentation. Fixed a few typos in extension names, fixed BPTC texture compression typos. Removed redundant EXT_framebuffer_object from functions as the Framebuffer class itself has it.
14 years ago
* @requires_gl30 Extension @extension{EXT,gpu_shader4}
Unsigned uniforms and retrievable hint supported in OpenGL ES 3.0.
14 years ago
* @requires_gles30 (no extension providing this functionality)
Documented required OpenGL version for some functionality. The requirements are cross-referenced to dedicated page, similarly to TODO and bug lists. Also updated / improved documentation for some texture / image formats.
14 years ago
*/
Support for all remaining uniform vector types, except arrays.
14 years ago
inline void setUniform(GLint location, GLuint value) {
Using EXT_direct_state_access/ARB_separate_shader_objects for uniforms. Also explicitly calling use() on default (non-DSA) setUniform() implementation. Because of that, it is now possible to conveniently call use() at the end, instead of at the beginning of uniform setting chain, for example: // before shader->use(); shader->setTransformation(transformation) ->setProjection(projection) ->setColor(color); // now shader->setTransformation(transformation) ->setProjection(projection) ->setColor(color) ->use(); Note that you still have to explicitly call use(), because if DSA is available, no use() is called explicitly on any setUniform(). If DSA is not available, use() is called on first setUniform() and subsequent calls have no negative performance impacts.
14 years ago
(this->*uniform1uiImplementation)(location, value);
Classes for compiling and using shaders.
16 years ago
}
Support for all remaining uniform vector types, except arrays.
14 years ago
/**
Minor documentation fixes.
14 years ago
* @copydoc setUniform(GLint, GLfloat)
Links to required extensions in documentation. Fixed a few typos in extension names, fixed BPTC texture compression typos. Removed redundant EXT_framebuffer_object from functions as the Framebuffer class itself has it.
14 years ago
* @requires_gl30 Extension @extension{EXT,gpu_shader4}
Unsigned uniforms and retrievable hint supported in OpenGL ES 3.0.
14 years ago
* @requires_gles30 (no extension providing this functionality)
Support for all remaining uniform vector types, except arrays.
14 years ago
*/
Using EXT_direct_state_access/ARB_separate_shader_objects for uniforms. Also explicitly calling use() on default (non-DSA) setUniform() implementation. Because of that, it is now possible to conveniently call use() at the end, instead of at the beginning of uniform setting chain, for example: // before shader->use(); shader->setTransformation(transformation) ->setProjection(projection) ->setColor(color); // now shader->setTransformation(transformation) ->setProjection(projection) ->setColor(color) ->use(); Note that you still have to explicitly call use(), because if DSA is available, no use() is called explicitly on any setUniform(). If DSA is not available, use() is called on first setUniform() and subsequent calls have no negative performance impacts.
14 years ago
inline void setUniform(GLint location, const Math::Vector<2, GLuint>& value) {
(this->*uniform2uivImplementation)(location, value);
Possibility to set Vector2 uniform.
14 years ago
}
Support for all remaining uniform vector types, except arrays.
14 years ago
/**
Minor documentation fixes.
14 years ago
* @copydoc setUniform(GLint, GLfloat)
Links to required extensions in documentation. Fixed a few typos in extension names, fixed BPTC texture compression typos. Removed redundant EXT_framebuffer_object from functions as the Framebuffer class itself has it.
14 years ago
* @requires_gl30 Extension @extension{EXT,gpu_shader4}
Unsigned uniforms and retrievable hint supported in OpenGL ES 3.0.
14 years ago
* @requires_gles30 (no extension providing this functionality)
Support for all remaining uniform vector types, except arrays.
14 years ago
*/
Using EXT_direct_state_access/ARB_separate_shader_objects for uniforms. Also explicitly calling use() on default (non-DSA) setUniform() implementation. Because of that, it is now possible to conveniently call use() at the end, instead of at the beginning of uniform setting chain, for example: // before shader->use(); shader->setTransformation(transformation) ->setProjection(projection) ->setColor(color); // now shader->setTransformation(transformation) ->setProjection(projection) ->setColor(color) ->use(); Note that you still have to explicitly call use(), because if DSA is available, no use() is called explicitly on any setUniform(). If DSA is not available, use() is called on first setUniform() and subsequent calls have no negative performance impacts.
14 years ago
inline void setUniform(GLint location, const Math::Vector<3, GLuint>& value) {
(this->*uniform3uivImplementation)(location, value);
Classes for compiling and using shaders.
16 years ago
}
Support for all remaining uniform vector types, except arrays.
14 years ago
/**
Minor documentation fixes.
14 years ago
* @copydoc setUniform(GLint, GLfloat)
Links to required extensions in documentation. Fixed a few typos in extension names, fixed BPTC texture compression typos. Removed redundant EXT_framebuffer_object from functions as the Framebuffer class itself has it.
14 years ago
* @requires_gl30 Extension @extension{EXT,gpu_shader4}
Unsigned uniforms and retrievable hint supported in OpenGL ES 3.0.
14 years ago
* @requires_gles30 (no extension providing this functionality)
Support for all remaining uniform vector types, except arrays.
14 years ago
*/
Using EXT_direct_state_access/ARB_separate_shader_objects for uniforms. Also explicitly calling use() on default (non-DSA) setUniform() implementation. Because of that, it is now possible to conveniently call use() at the end, instead of at the beginning of uniform setting chain, for example: // before shader->use(); shader->setTransformation(transformation) ->setProjection(projection) ->setColor(color); // now shader->setTransformation(transformation) ->setProjection(projection) ->setColor(color) ->use(); Note that you still have to explicitly call use(), because if DSA is available, no use() is called explicitly on any setUniform(). If DSA is not available, use() is called on first setUniform() and subsequent calls have no negative performance impacts.
14 years ago
inline void setUniform(GLint location, const Math::Vector<4, GLuint>& value) {
(this->*uniform4uivImplementation)(location, value);
Classes for compiling and using shaders.
16 years ago
}
Added setUniform() for doubles. I knew it did exist, but the manuals said otherwise.
14 years ago
#ifndef MAGNUM_TARGET_GLES
/**
* @copydoc setUniform(GLint, GLfloat)
* @requires_gl40 Extension @extension{ARB,gpu_shader_fp64}
* @requires_gl Only floats are available in OpenGL ES.
*/
inline void setUniform(GLint location, GLdouble value) {
Using EXT_direct_state_access/ARB_separate_shader_objects for uniforms. Also explicitly calling use() on default (non-DSA) setUniform() implementation. Because of that, it is now possible to conveniently call use() at the end, instead of at the beginning of uniform setting chain, for example: // before shader->use(); shader->setTransformation(transformation) ->setProjection(projection) ->setColor(color); // now shader->setTransformation(transformation) ->setProjection(projection) ->setColor(color) ->use(); Note that you still have to explicitly call use(), because if DSA is available, no use() is called explicitly on any setUniform(). If DSA is not available, use() is called on first setUniform() and subsequent calls have no negative performance impacts.
14 years ago
(this->*uniform1dImplementation)(location, value);
Added setUniform() for doubles. I knew it did exist, but the manuals said otherwise.
14 years ago
}
/**
* @copydoc setUniform(GLint, GLfloat)
* @requires_gl40 Extension @extension{ARB,gpu_shader_fp64}
* @requires_gl Only floats are available in OpenGL ES.
*/
Using EXT_direct_state_access/ARB_separate_shader_objects for uniforms. Also explicitly calling use() on default (non-DSA) setUniform() implementation. Because of that, it is now possible to conveniently call use() at the end, instead of at the beginning of uniform setting chain, for example: // before shader->use(); shader->setTransformation(transformation) ->setProjection(projection) ->setColor(color); // now shader->setTransformation(transformation) ->setProjection(projection) ->setColor(color) ->use(); Note that you still have to explicitly call use(), because if DSA is available, no use() is called explicitly on any setUniform(). If DSA is not available, use() is called on first setUniform() and subsequent calls have no negative performance impacts.
14 years ago
inline void setUniform(GLint location, const Math::Vector<2, GLdouble>& value) {
(this->*uniform2dvImplementation)(location, value);
Added setUniform() for doubles. I knew it did exist, but the manuals said otherwise.
14 years ago
}
/**
* @copydoc setUniform(GLint, GLfloat)
* @requires_gl40 Extension @extension{ARB,gpu_shader_fp64}
* @requires_gl Only floats are available in OpenGL ES.
*/
Using EXT_direct_state_access/ARB_separate_shader_objects for uniforms. Also explicitly calling use() on default (non-DSA) setUniform() implementation. Because of that, it is now possible to conveniently call use() at the end, instead of at the beginning of uniform setting chain, for example: // before shader->use(); shader->setTransformation(transformation) ->setProjection(projection) ->setColor(color); // now shader->setTransformation(transformation) ->setProjection(projection) ->setColor(color) ->use(); Note that you still have to explicitly call use(), because if DSA is available, no use() is called explicitly on any setUniform(). If DSA is not available, use() is called on first setUniform() and subsequent calls have no negative performance impacts.
14 years ago
inline void setUniform(GLint location, const Math::Vector<3, GLdouble>& value) {
(this->*uniform3dvImplementation)(location, value);
Added setUniform() for doubles. I knew it did exist, but the manuals said otherwise.
14 years ago
}
/**
* @copydoc setUniform(GLint, GLfloat)
* @requires_gl40 Extension @extension{ARB,gpu_shader_fp64}
* @requires_gl Only floats are available in OpenGL ES.
*/
Using EXT_direct_state_access/ARB_separate_shader_objects for uniforms. Also explicitly calling use() on default (non-DSA) setUniform() implementation. Because of that, it is now possible to conveniently call use() at the end, instead of at the beginning of uniform setting chain, for example: // before shader->use(); shader->setTransformation(transformation) ->setProjection(projection) ->setColor(color); // now shader->setTransformation(transformation) ->setProjection(projection) ->setColor(color) ->use(); Note that you still have to explicitly call use(), because if DSA is available, no use() is called explicitly on any setUniform(). If DSA is not available, use() is called on first setUniform() and subsequent calls have no negative performance impacts.
14 years ago
inline void setUniform(GLint location, const Math::Vector<4, GLdouble>& value) {
(this->*uniform4dvImplementation)(location, value);
Added setUniform() for doubles. I knew it did exist, but the manuals said otherwise.
14 years ago
}
#endif
Minor documentation fixes.
14 years ago
/** @copydoc setUniform(GLint, GLfloat) */
Using EXT_direct_state_access/ARB_separate_shader_objects for uniforms. Also explicitly calling use() on default (non-DSA) setUniform() implementation. Because of that, it is now possible to conveniently call use() at the end, instead of at the beginning of uniform setting chain, for example: // before shader->use(); shader->setTransformation(transformation) ->setProjection(projection) ->setColor(color); // now shader->setTransformation(transformation) ->setProjection(projection) ->setColor(color) ->use(); Note that you still have to explicitly call use(), because if DSA is available, no use() is called explicitly on any setUniform(). If DSA is not available, use() is called on first setUniform() and subsequent calls have no negative performance impacts.
14 years ago
inline void setUniform(GLint location, const Math::Matrix<2, GLfloat>& value) {
(this->*uniformMatrix2fvImplementation)(location, value);
Using only RectangularMatrix in setUniform(), added remaining setters. Shader implementations now have to include Vector, Matrix and Color classes on their own.
14 years ago
}
Minor documentation fixes.
14 years ago
/** @copydoc setUniform(GLint, GLfloat) */
Using EXT_direct_state_access/ARB_separate_shader_objects for uniforms. Also explicitly calling use() on default (non-DSA) setUniform() implementation. Because of that, it is now possible to conveniently call use() at the end, instead of at the beginning of uniform setting chain, for example: // before shader->use(); shader->setTransformation(transformation) ->setProjection(projection) ->setColor(color); // now shader->setTransformation(transformation) ->setProjection(projection) ->setColor(color) ->use(); Note that you still have to explicitly call use(), because if DSA is available, no use() is called explicitly on any setUniform(). If DSA is not available, use() is called on first setUniform() and subsequent calls have no negative performance impacts.
14 years ago
inline void setUniform(GLint location, const Math::Matrix<3, GLfloat>& value) {
(this->*uniformMatrix3fvImplementation)(location, value);
Added Matrix3 specialization (will be needed for normals, lighting etc.).
16 years ago
}
Minor documentation fixes.
14 years ago
/** @copydoc setUniform(GLint, GLfloat) */
Using EXT_direct_state_access/ARB_separate_shader_objects for uniforms. Also explicitly calling use() on default (non-DSA) setUniform() implementation. Because of that, it is now possible to conveniently call use() at the end, instead of at the beginning of uniform setting chain, for example: // before shader->use(); shader->setTransformation(transformation) ->setProjection(projection) ->setColor(color); // now shader->setTransformation(transformation) ->setProjection(projection) ->setColor(color) ->use(); Note that you still have to explicitly call use(), because if DSA is available, no use() is called explicitly on any setUniform(). If DSA is not available, use() is called on first setUniform() and subsequent calls have no negative performance impacts.
14 years ago
inline void setUniform(GLint location, const Math::Matrix<4, GLfloat>& value) {
(this->*uniformMatrix4fvImplementation)(location, value);
Classes for compiling and using shaders.
16 years ago
}
Using only RectangularMatrix in setUniform(), added remaining setters. Shader implementations now have to include Vector, Matrix and Color classes on their own.
14 years ago
/**
Minor documentation fixes.
14 years ago
* @copydoc setUniform(GLint, GLfloat)
Using only RectangularMatrix in setUniform(), added remaining setters. Shader implementations now have to include Vector, Matrix and Color classes on their own.
14 years ago
* @requires_gles30 (no extension providing this functionality)
*/
inline void setUniform(GLint location, const Math::RectangularMatrix<2, 3, GLfloat>& value) {
Using EXT_direct_state_access/ARB_separate_shader_objects for uniforms. Also explicitly calling use() on default (non-DSA) setUniform() implementation. Because of that, it is now possible to conveniently call use() at the end, instead of at the beginning of uniform setting chain, for example: // before shader->use(); shader->setTransformation(transformation) ->setProjection(projection) ->setColor(color); // now shader->setTransformation(transformation) ->setProjection(projection) ->setColor(color) ->use(); Note that you still have to explicitly call use(), because if DSA is available, no use() is called explicitly on any setUniform(). If DSA is not available, use() is called on first setUniform() and subsequent calls have no negative performance impacts.
14 years ago
(this->*uniformMatrix2x3fvImplementation)(location, value);
Using only RectangularMatrix in setUniform(), added remaining setters. Shader implementations now have to include Vector, Matrix and Color classes on their own.
14 years ago
}
/**
Minor documentation fixes.
14 years ago
* @copydoc setUniform(GLint, GLfloat)
Using only RectangularMatrix in setUniform(), added remaining setters. Shader implementations now have to include Vector, Matrix and Color classes on their own.
14 years ago
* @requires_gles30 (no extension providing this functionality)
*/
inline void setUniform(GLint location, const Math::RectangularMatrix<3, 2, GLfloat>& value) {
Using EXT_direct_state_access/ARB_separate_shader_objects for uniforms. Also explicitly calling use() on default (non-DSA) setUniform() implementation. Because of that, it is now possible to conveniently call use() at the end, instead of at the beginning of uniform setting chain, for example: // before shader->use(); shader->setTransformation(transformation) ->setProjection(projection) ->setColor(color); // now shader->setTransformation(transformation) ->setProjection(projection) ->setColor(color) ->use(); Note that you still have to explicitly call use(), because if DSA is available, no use() is called explicitly on any setUniform(). If DSA is not available, use() is called on first setUniform() and subsequent calls have no negative performance impacts.
14 years ago
(this->*uniformMatrix3x2fvImplementation)(location, value);
Using only RectangularMatrix in setUniform(), added remaining setters. Shader implementations now have to include Vector, Matrix and Color classes on their own.
14 years ago
}
/**
Minor documentation fixes.
14 years ago
* @copydoc setUniform(GLint, GLfloat)
Using only RectangularMatrix in setUniform(), added remaining setters. Shader implementations now have to include Vector, Matrix and Color classes on their own.
14 years ago
* @requires_gles30 (no extension providing this functionality)
*/
inline void setUniform(GLint location, const Math::RectangularMatrix<2, 4, GLfloat>& value) {
Using EXT_direct_state_access/ARB_separate_shader_objects for uniforms. Also explicitly calling use() on default (non-DSA) setUniform() implementation. Because of that, it is now possible to conveniently call use() at the end, instead of at the beginning of uniform setting chain, for example: // before shader->use(); shader->setTransformation(transformation) ->setProjection(projection) ->setColor(color); // now shader->setTransformation(transformation) ->setProjection(projection) ->setColor(color) ->use(); Note that you still have to explicitly call use(), because if DSA is available, no use() is called explicitly on any setUniform(). If DSA is not available, use() is called on first setUniform() and subsequent calls have no negative performance impacts.
14 years ago
(this->*uniformMatrix2x4fvImplementation)(location, value);
Using only RectangularMatrix in setUniform(), added remaining setters. Shader implementations now have to include Vector, Matrix and Color classes on their own.
14 years ago
}
/**
Minor documentation fixes.
14 years ago
* @copydoc setUniform(GLint, GLfloat)
Using only RectangularMatrix in setUniform(), added remaining setters. Shader implementations now have to include Vector, Matrix and Color classes on their own.
14 years ago
* @requires_gles30 (no extension providing this functionality)
*/
inline void setUniform(GLint location, const Math::RectangularMatrix<4, 2, GLfloat>& value) {
Using EXT_direct_state_access/ARB_separate_shader_objects for uniforms. Also explicitly calling use() on default (non-DSA) setUniform() implementation. Because of that, it is now possible to conveniently call use() at the end, instead of at the beginning of uniform setting chain, for example: // before shader->use(); shader->setTransformation(transformation) ->setProjection(projection) ->setColor(color); // now shader->setTransformation(transformation) ->setProjection(projection) ->setColor(color) ->use(); Note that you still have to explicitly call use(), because if DSA is available, no use() is called explicitly on any setUniform(). If DSA is not available, use() is called on first setUniform() and subsequent calls have no negative performance impacts.
14 years ago
(this->*uniformMatrix4x2fvImplementation)(location, value);
Using only RectangularMatrix in setUniform(), added remaining setters. Shader implementations now have to include Vector, Matrix and Color classes on their own.
14 years ago
}
/**
Minor documentation fixes.
14 years ago
* @copydoc setUniform(GLint, GLfloat)
Using only RectangularMatrix in setUniform(), added remaining setters. Shader implementations now have to include Vector, Matrix and Color classes on their own.
14 years ago
* @requires_gles30 (no extension providing this functionality)
*/
inline void setUniform(GLint location, const Math::RectangularMatrix<3, 4, GLfloat>& value) {
Using EXT_direct_state_access/ARB_separate_shader_objects for uniforms. Also explicitly calling use() on default (non-DSA) setUniform() implementation. Because of that, it is now possible to conveniently call use() at the end, instead of at the beginning of uniform setting chain, for example: // before shader->use(); shader->setTransformation(transformation) ->setProjection(projection) ->setColor(color); // now shader->setTransformation(transformation) ->setProjection(projection) ->setColor(color) ->use(); Note that you still have to explicitly call use(), because if DSA is available, no use() is called explicitly on any setUniform(). If DSA is not available, use() is called on first setUniform() and subsequent calls have no negative performance impacts.
14 years ago
(this->*uniformMatrix3x4fvImplementation)(location, value);
Using only RectangularMatrix in setUniform(), added remaining setters. Shader implementations now have to include Vector, Matrix and Color classes on their own.
14 years ago
}
/**
Minor documentation fixes.
14 years ago
* @copydoc setUniform(GLint, GLfloat)
Using only RectangularMatrix in setUniform(), added remaining setters. Shader implementations now have to include Vector, Matrix and Color classes on their own.
14 years ago
* @requires_gles30 (no extension providing this functionality)
*/
inline void setUniform(GLint location, const Math::RectangularMatrix<4, 3, GLfloat>& value) {
Using EXT_direct_state_access/ARB_separate_shader_objects for uniforms. Also explicitly calling use() on default (non-DSA) setUniform() implementation. Because of that, it is now possible to conveniently call use() at the end, instead of at the beginning of uniform setting chain, for example: // before shader->use(); shader->setTransformation(transformation) ->setProjection(projection) ->setColor(color); // now shader->setTransformation(transformation) ->setProjection(projection) ->setColor(color) ->use(); Note that you still have to explicitly call use(), because if DSA is available, no use() is called explicitly on any setUniform(). If DSA is not available, use() is called on first setUniform() and subsequent calls have no negative performance impacts.
14 years ago
(this->*uniformMatrix4x3fvImplementation)(location, value);
Using only RectangularMatrix in setUniform(), added remaining setters. Shader implementations now have to include Vector, Matrix and Color classes on their own.
14 years ago
}
Added setUniform() for doubles. I knew it did exist, but the manuals said otherwise.
14 years ago
#ifndef MAGNUM_TARGET_GLES
/**
* @copydoc setUniform(GLint, GLfloat)
* @requires_gl40 Extension @extension{ARB,gpu_shader_fp64}
* @requires_gl Only floats are available in OpenGL ES.
*/
Using EXT_direct_state_access/ARB_separate_shader_objects for uniforms. Also explicitly calling use() on default (non-DSA) setUniform() implementation. Because of that, it is now possible to conveniently call use() at the end, instead of at the beginning of uniform setting chain, for example: // before shader->use(); shader->setTransformation(transformation) ->setProjection(projection) ->setColor(color); // now shader->setTransformation(transformation) ->setProjection(projection) ->setColor(color) ->use(); Note that you still have to explicitly call use(), because if DSA is available, no use() is called explicitly on any setUniform(). If DSA is not available, use() is called on first setUniform() and subsequent calls have no negative performance impacts.
14 years ago
inline void setUniform(GLint location, const Math::Matrix<2, GLdouble>& value) {
(this->*uniformMatrix2dvImplementation)(location, value);
Added setUniform() for doubles. I knew it did exist, but the manuals said otherwise.
14 years ago
}
/**
* @copydoc setUniform(GLint, GLfloat)
* @requires_gl40 Extension @extension{ARB,gpu_shader_fp64}
* @requires_gl Only floats are available in OpenGL ES.
*/
Using EXT_direct_state_access/ARB_separate_shader_objects for uniforms. Also explicitly calling use() on default (non-DSA) setUniform() implementation. Because of that, it is now possible to conveniently call use() at the end, instead of at the beginning of uniform setting chain, for example: // before shader->use(); shader->setTransformation(transformation) ->setProjection(projection) ->setColor(color); // now shader->setTransformation(transformation) ->setProjection(projection) ->setColor(color) ->use(); Note that you still have to explicitly call use(), because if DSA is available, no use() is called explicitly on any setUniform(). If DSA is not available, use() is called on first setUniform() and subsequent calls have no negative performance impacts.
14 years ago
inline void setUniform(GLint location, const Math::Matrix<3, GLdouble>& value) {
(this->*uniformMatrix3dvImplementation)(location, value);
Added setUniform() for doubles. I knew it did exist, but the manuals said otherwise.
14 years ago
}
/**
* @copydoc setUniform(GLint, GLfloat)
* @requires_gl40 Extension @extension{ARB,gpu_shader_fp64}
* @requires_gl Only floats are available in OpenGL ES.
*/
Using EXT_direct_state_access/ARB_separate_shader_objects for uniforms. Also explicitly calling use() on default (non-DSA) setUniform() implementation. Because of that, it is now possible to conveniently call use() at the end, instead of at the beginning of uniform setting chain, for example: // before shader->use(); shader->setTransformation(transformation) ->setProjection(projection) ->setColor(color); // now shader->setTransformation(transformation) ->setProjection(projection) ->setColor(color) ->use(); Note that you still have to explicitly call use(), because if DSA is available, no use() is called explicitly on any setUniform(). If DSA is not available, use() is called on first setUniform() and subsequent calls have no negative performance impacts.
14 years ago
inline void setUniform(GLint location, const Math::Matrix<4, GLdouble>& value) {
(this->*uniformMatrix4dvImplementation)(location, value);
Added setUniform() for doubles. I knew it did exist, but the manuals said otherwise.
14 years ago
}
/**
* @copydoc setUniform(GLint, GLfloat)
* @requires_gl40 Extension @extension{ARB,gpu_shader_fp64}
* @requires_gl Only floats are available in OpenGL ES.
*/
inline void setUniform(GLint location, const Math::RectangularMatrix<2, 3, GLdouble>& value) {
Using EXT_direct_state_access/ARB_separate_shader_objects for uniforms. Also explicitly calling use() on default (non-DSA) setUniform() implementation. Because of that, it is now possible to conveniently call use() at the end, instead of at the beginning of uniform setting chain, for example: // before shader->use(); shader->setTransformation(transformation) ->setProjection(projection) ->setColor(color); // now shader->setTransformation(transformation) ->setProjection(projection) ->setColor(color) ->use(); Note that you still have to explicitly call use(), because if DSA is available, no use() is called explicitly on any setUniform(). If DSA is not available, use() is called on first setUniform() and subsequent calls have no negative performance impacts.
14 years ago
(this->*uniformMatrix2x3dvImplementation)(location, value);
Added setUniform() for doubles. I knew it did exist, but the manuals said otherwise.
14 years ago
}
/**
* @copydoc setUniform(GLint, GLfloat)
* @requires_gl40 Extension @extension{ARB,gpu_shader_fp64}
* @requires_gl Only floats are available in OpenGL ES.
*/
inline void setUniform(GLint location, const Math::RectangularMatrix<3, 2, GLdouble>& value) {
Using EXT_direct_state_access/ARB_separate_shader_objects for uniforms. Also explicitly calling use() on default (non-DSA) setUniform() implementation. Because of that, it is now possible to conveniently call use() at the end, instead of at the beginning of uniform setting chain, for example: // before shader->use(); shader->setTransformation(transformation) ->setProjection(projection) ->setColor(color); // now shader->setTransformation(transformation) ->setProjection(projection) ->setColor(color) ->use(); Note that you still have to explicitly call use(), because if DSA is available, no use() is called explicitly on any setUniform(). If DSA is not available, use() is called on first setUniform() and subsequent calls have no negative performance impacts.
14 years ago
(this->*uniformMatrix3x2dvImplementation)(location, value);
Added setUniform() for doubles. I knew it did exist, but the manuals said otherwise.
14 years ago
}
/**
* @copydoc setUniform(GLint, GLfloat)
* @requires_gl40 Extension @extension{ARB,gpu_shader_fp64}
* @requires_gl Only floats are available in OpenGL ES.
*/
inline void setUniform(GLint location, const Math::RectangularMatrix<2, 4, GLdouble>& value) {
Using EXT_direct_state_access/ARB_separate_shader_objects for uniforms. Also explicitly calling use() on default (non-DSA) setUniform() implementation. Because of that, it is now possible to conveniently call use() at the end, instead of at the beginning of uniform setting chain, for example: // before shader->use(); shader->setTransformation(transformation) ->setProjection(projection) ->setColor(color); // now shader->setTransformation(transformation) ->setProjection(projection) ->setColor(color) ->use(); Note that you still have to explicitly call use(), because if DSA is available, no use() is called explicitly on any setUniform(). If DSA is not available, use() is called on first setUniform() and subsequent calls have no negative performance impacts.
14 years ago
(this->*uniformMatrix2x4dvImplementation)(location, value);
Added setUniform() for doubles. I knew it did exist, but the manuals said otherwise.
14 years ago
}
/**
* @copydoc setUniform(GLint, GLfloat)
* @requires_gl40 Extension @extension{ARB,gpu_shader_fp64}
* @requires_gl Only floats are available in OpenGL ES.
*/
inline void setUniform(GLint location, const Math::RectangularMatrix<4, 2, GLdouble>& value) {
Using EXT_direct_state_access/ARB_separate_shader_objects for uniforms. Also explicitly calling use() on default (non-DSA) setUniform() implementation. Because of that, it is now possible to conveniently call use() at the end, instead of at the beginning of uniform setting chain, for example: // before shader->use(); shader->setTransformation(transformation) ->setProjection(projection) ->setColor(color); // now shader->setTransformation(transformation) ->setProjection(projection) ->setColor(color) ->use(); Note that you still have to explicitly call use(), because if DSA is available, no use() is called explicitly on any setUniform(). If DSA is not available, use() is called on first setUniform() and subsequent calls have no negative performance impacts.
14 years ago
(this->*uniformMatrix4x2dvImplementation)(location, value);
Added setUniform() for doubles. I knew it did exist, but the manuals said otherwise.
14 years ago
}
/**
* @copydoc setUniform(GLint, GLfloat)
* @requires_gl40 Extension @extension{ARB,gpu_shader_fp64}
* @requires_gl Only floats are available in OpenGL ES.
*/
inline void setUniform(GLint location, const Math::RectangularMatrix<3, 4, GLdouble>& value) {
Using EXT_direct_state_access/ARB_separate_shader_objects for uniforms. Also explicitly calling use() on default (non-DSA) setUniform() implementation. Because of that, it is now possible to conveniently call use() at the end, instead of at the beginning of uniform setting chain, for example: // before shader->use(); shader->setTransformation(transformation) ->setProjection(projection) ->setColor(color); // now shader->setTransformation(transformation) ->setProjection(projection) ->setColor(color) ->use(); Note that you still have to explicitly call use(), because if DSA is available, no use() is called explicitly on any setUniform(). If DSA is not available, use() is called on first setUniform() and subsequent calls have no negative performance impacts.
14 years ago
(this->*uniformMatrix3x4dvImplementation)(location, value);
Added setUniform() for doubles. I knew it did exist, but the manuals said otherwise.
14 years ago
}
/**
* @copydoc setUniform(GLint, GLfloat)
* @requires_gl40 Extension @extension{ARB,gpu_shader_fp64}
* @requires_gl Only floats are available in OpenGL ES.
*/
inline void setUniform(GLint location, const Math::RectangularMatrix<4, 3, GLdouble>& value) {
Using EXT_direct_state_access/ARB_separate_shader_objects for uniforms. Also explicitly calling use() on default (non-DSA) setUniform() implementation. Because of that, it is now possible to conveniently call use() at the end, instead of at the beginning of uniform setting chain, for example: // before shader->use(); shader->setTransformation(transformation) ->setProjection(projection) ->setColor(color); // now shader->setTransformation(transformation) ->setProjection(projection) ->setColor(color) ->use(); Note that you still have to explicitly call use(), because if DSA is available, no use() is called explicitly on any setUniform(). If DSA is not available, use() is called on first setUniform() and subsequent calls have no negative performance impacts.
14 years ago
(this->*uniformMatrix4x3dvImplementation)(location, value);
Added setUniform() for doubles. I knew it did exist, but the manuals said otherwise.
14 years ago
}
#endif
Classes for compiling and using shaders.
16 years ago
private:
enum State {
Initialized,
Linked,
Failed
};
Don't export private symbols.
14 years ago
static void MAGNUM_LOCAL initializeContextBasedFunctionality(Context* context);
Using EXT_direct_state_access/ARB_separate_shader_objects for uniforms. Also explicitly calling use() on default (non-DSA) setUniform() implementation. Because of that, it is now possible to conveniently call use() at the end, instead of at the beginning of uniform setting chain, for example: // before shader->use(); shader->setTransformation(transformation) ->setProjection(projection) ->setColor(color); // now shader->setTransformation(transformation) ->setProjection(projection) ->setColor(color) ->use(); Note that you still have to explicitly call use(), because if DSA is available, no use() is called explicitly on any setUniform(). If DSA is not available, use() is called on first setUniform() and subsequent calls have no negative performance impacts.
14 years ago
typedef void(AbstractShaderProgram::*Uniform1fImplementation)(GLint, GLfloat);
typedef void(AbstractShaderProgram::*Uniform2fvImplementation)(GLint, const Math::Vector<2, GLfloat>&);
typedef void(AbstractShaderProgram::*Uniform3fvImplementation)(GLint, const Math::Vector<3, GLfloat>&);
typedef void(AbstractShaderProgram::*Uniform4fvImplementation)(GLint, const Math::Vector<4, GLfloat>&);
typedef void(AbstractShaderProgram::*Uniform1iImplementation)(GLint, GLint);
typedef void(AbstractShaderProgram::*Uniform2ivImplementation)(GLint, const Math::Vector<2, GLint>&);
typedef void(AbstractShaderProgram::*Uniform3ivImplementation)(GLint, const Math::Vector<3, GLint>&);
typedef void(AbstractShaderProgram::*Uniform4ivImplementation)(GLint, const Math::Vector<4, GLint>&);
typedef void(AbstractShaderProgram::*Uniform1uiImplementation)(GLint, GLuint);
typedef void(AbstractShaderProgram::*Uniform2uivImplementation)(GLint, const Math::Vector<2, GLuint>&);
typedef void(AbstractShaderProgram::*Uniform3uivImplementation)(GLint, const Math::Vector<3, GLuint>&);
typedef void(AbstractShaderProgram::*Uniform4uivImplementation)(GLint, const Math::Vector<4, GLuint>&);
#ifndef MAGNUM_TARGET_GLES
typedef void(AbstractShaderProgram::*Uniform1dImplementation)(GLint, GLdouble);
typedef void(AbstractShaderProgram::*Uniform2dvImplementation)(GLint, const Math::Vector<2, GLdouble>&);
typedef void(AbstractShaderProgram::*Uniform3dvImplementation)(GLint, const Math::Vector<3, GLdouble>&);
typedef void(AbstractShaderProgram::*Uniform4dvImplementation)(GLint, const Math::Vector<4, GLdouble>&);
#endif
void MAGNUM_LOCAL uniformImplementationDefault(GLint location, GLfloat value);
void MAGNUM_LOCAL uniformImplementationDefault(GLint location, const Math::Vector<2, GLfloat>& value);
void MAGNUM_LOCAL uniformImplementationDefault(GLint location, const Math::Vector<3, GLfloat>& value);
void MAGNUM_LOCAL uniformImplementationDefault(GLint location, const Math::Vector<4, GLfloat>& value);
void MAGNUM_LOCAL uniformImplementationDefault(GLint location, GLint value);
void MAGNUM_LOCAL uniformImplementationDefault(GLint location, const Math::Vector<2, GLint>& value);
void MAGNUM_LOCAL uniformImplementationDefault(GLint location, const Math::Vector<3, GLint>& value);
void MAGNUM_LOCAL uniformImplementationDefault(GLint location, const Math::Vector<4, GLint>& value);
void MAGNUM_LOCAL uniformImplementationDefault(GLint location, GLuint value);
void MAGNUM_LOCAL uniformImplementationDefault(GLint location, const Math::Vector<2, GLuint>& value);
void MAGNUM_LOCAL uniformImplementationDefault(GLint location, const Math::Vector<3, GLuint>& value);
void MAGNUM_LOCAL uniformImplementationDefault(GLint location, const Math::Vector<4, GLuint>& value);
#ifndef MAGNUM_TARGET_GLES
void MAGNUM_LOCAL uniformImplementationDefault(GLint location, GLdouble value);
void MAGNUM_LOCAL uniformImplementationDefault(GLint location, const Math::Vector<2, GLdouble>& value);
void MAGNUM_LOCAL uniformImplementationDefault(GLint location, const Math::Vector<3, GLdouble>& value);
void MAGNUM_LOCAL uniformImplementationDefault(GLint location, const Math::Vector<4, GLdouble>& value);
#endif
void MAGNUM_LOCAL uniformImplementationDSA(GLint location, GLfloat value);
void MAGNUM_LOCAL uniformImplementationDSA(GLint location, const Math::Vector<2, GLfloat>& value);
void MAGNUM_LOCAL uniformImplementationDSA(GLint location, const Math::Vector<3, GLfloat>& value);
void MAGNUM_LOCAL uniformImplementationDSA(GLint location, const Math::Vector<4, GLfloat>& value);
void MAGNUM_LOCAL uniformImplementationDSA(GLint location, GLint value);
void MAGNUM_LOCAL uniformImplementationDSA(GLint location, const Math::Vector<2, GLint>& value);
void MAGNUM_LOCAL uniformImplementationDSA(GLint location, const Math::Vector<3, GLint>& value);
void MAGNUM_LOCAL uniformImplementationDSA(GLint location, const Math::Vector<4, GLint>& value);
void MAGNUM_LOCAL uniformImplementationDSA(GLint location, GLuint value);
void MAGNUM_LOCAL uniformImplementationDSA(GLint location, const Math::Vector<2, GLuint>& value);
void MAGNUM_LOCAL uniformImplementationDSA(GLint location, const Math::Vector<3, GLuint>& value);
void MAGNUM_LOCAL uniformImplementationDSA(GLint location, const Math::Vector<4, GLuint>& value);
#ifndef MAGNUM_TARGET_GLES
void MAGNUM_LOCAL uniformImplementationDSA(GLint location, GLdouble value);
void MAGNUM_LOCAL uniformImplementationDSA(GLint location, const Math::Vector<2, GLdouble>& value);
void MAGNUM_LOCAL uniformImplementationDSA(GLint location, const Math::Vector<3, GLdouble>& value);
void MAGNUM_LOCAL uniformImplementationDSA(GLint location, const Math::Vector<4, GLdouble>& value);
#endif
static Uniform1fImplementation uniform1fImplementation;
static Uniform2fvImplementation uniform2fvImplementation;
static Uniform3fvImplementation uniform3fvImplementation;
static Uniform4fvImplementation uniform4fvImplementation;
static Uniform1iImplementation uniform1iImplementation;
static Uniform2ivImplementation uniform2ivImplementation;
static Uniform3ivImplementation uniform3ivImplementation;
static Uniform4ivImplementation uniform4ivImplementation;
static Uniform1uiImplementation uniform1uiImplementation;
static Uniform2uivImplementation uniform2uivImplementation;
static Uniform3uivImplementation uniform3uivImplementation;
static Uniform4uivImplementation uniform4uivImplementation;
#ifndef MAGNUM_TARGET_GLES
static Uniform1dImplementation uniform1dImplementation;
static Uniform2dvImplementation uniform2dvImplementation;
static Uniform3dvImplementation uniform3dvImplementation;
static Uniform4dvImplementation uniform4dvImplementation;
#endif
typedef void(AbstractShaderProgram::*UniformMatrix2fvImplementation)(GLint, const Math::Matrix<2, GLfloat>&);
typedef void(AbstractShaderProgram::*UniformMatrix3fvImplementation)(GLint, const Math::Matrix<3, GLfloat>&);
typedef void(AbstractShaderProgram::*UniformMatrix4fvImplementation)(GLint, const Math::Matrix<4, GLfloat>&);
typedef void(AbstractShaderProgram::*UniformMatrix2x3fvImplementation)(GLint, const Math::RectangularMatrix<2, 3, GLfloat>&);
typedef void(AbstractShaderProgram::*UniformMatrix3x2fvImplementation)(GLint, const Math::RectangularMatrix<3, 2, GLfloat>&);
typedef void(AbstractShaderProgram::*UniformMatrix2x4fvImplementation)(GLint, const Math::RectangularMatrix<2, 4, GLfloat>&);
typedef void(AbstractShaderProgram::*UniformMatrix4x2fvImplementation)(GLint, const Math::RectangularMatrix<4, 2, GLfloat>&);
typedef void(AbstractShaderProgram::*UniformMatrix3x4fvImplementation)(GLint, const Math::RectangularMatrix<3, 4, GLfloat>&);
typedef void(AbstractShaderProgram::*UniformMatrix4x3fvImplementation)(GLint, const Math::RectangularMatrix<4, 3, GLfloat>&);
#ifndef MAGNUM_TARGET_GLES
typedef void(AbstractShaderProgram::*UniformMatrix2dvImplementation)(GLint, const Math::Matrix<2, GLdouble>&);
typedef void(AbstractShaderProgram::*UniformMatrix3dvImplementation)(GLint, const Math::Matrix<3, GLdouble>&);
typedef void(AbstractShaderProgram::*UniformMatrix4dvImplementation)(GLint, const Math::Matrix<4, GLdouble>&);
typedef void(AbstractShaderProgram::*UniformMatrix2x3dvImplementation)(GLint, const Math::RectangularMatrix<2, 3, GLdouble>&);
typedef void(AbstractShaderProgram::*UniformMatrix3x2dvImplementation)(GLint, const Math::RectangularMatrix<3, 2, GLdouble>&);
typedef void(AbstractShaderProgram::*UniformMatrix2x4dvImplementation)(GLint, const Math::RectangularMatrix<2, 4, GLdouble>&);
typedef void(AbstractShaderProgram::*UniformMatrix4x2dvImplementation)(GLint, const Math::RectangularMatrix<4, 2, GLdouble>&);
typedef void(AbstractShaderProgram::*UniformMatrix3x4dvImplementation)(GLint, const Math::RectangularMatrix<3, 4, GLdouble>&);
typedef void(AbstractShaderProgram::*UniformMatrix4x3dvImplementation)(GLint, const Math::RectangularMatrix<4, 3, GLdouble>&);
#endif
void MAGNUM_LOCAL uniformImplementationDefault(GLint location, const Math::Matrix<2, GLfloat>& value);
void MAGNUM_LOCAL uniformImplementationDefault(GLint location, const Math::Matrix<3, GLfloat>& value);
void MAGNUM_LOCAL uniformImplementationDefault(GLint location, const Math::Matrix<4, GLfloat>& value);
void MAGNUM_LOCAL uniformImplementationDefault(GLint location, const Math::RectangularMatrix<2, 3, GLfloat>& value);
void MAGNUM_LOCAL uniformImplementationDefault(GLint location, const Math::RectangularMatrix<3, 2, GLfloat>& value);
void MAGNUM_LOCAL uniformImplementationDefault(GLint location, const Math::RectangularMatrix<2, 4, GLfloat>& value);
void MAGNUM_LOCAL uniformImplementationDefault(GLint location, const Math::RectangularMatrix<4, 2, GLfloat>& value);
void MAGNUM_LOCAL uniformImplementationDefault(GLint location, const Math::RectangularMatrix<3, 4, GLfloat>& value);
void MAGNUM_LOCAL uniformImplementationDefault(GLint location, const Math::RectangularMatrix<4, 3, GLfloat>& value);
#ifndef MAGNUM_TARGET_GLES
void MAGNUM_LOCAL uniformImplementationDefault(GLint location, const Math::Matrix<2, GLdouble>& value);
void MAGNUM_LOCAL uniformImplementationDefault(GLint location, const Math::Matrix<3, GLdouble>& value);
void MAGNUM_LOCAL uniformImplementationDefault(GLint location, const Math::Matrix<4, GLdouble>& value);
void MAGNUM_LOCAL uniformImplementationDefault(GLint location, const Math::RectangularMatrix<2, 3, GLdouble>& value);
void MAGNUM_LOCAL uniformImplementationDefault(GLint location, const Math::RectangularMatrix<3, 2, GLdouble>& value);
void MAGNUM_LOCAL uniformImplementationDefault(GLint location, const Math::RectangularMatrix<2, 4, GLdouble>& value);
void MAGNUM_LOCAL uniformImplementationDefault(GLint location, const Math::RectangularMatrix<4, 2, GLdouble>& value);
void MAGNUM_LOCAL uniformImplementationDefault(GLint location, const Math::RectangularMatrix<3, 4, GLdouble>& value);
void MAGNUM_LOCAL uniformImplementationDefault(GLint location, const Math::RectangularMatrix<4, 3, GLdouble>& value);
#endif
void MAGNUM_LOCAL uniformImplementationDSA(GLint location, const Math::Matrix<2, GLfloat>& value);
void MAGNUM_LOCAL uniformImplementationDSA(GLint location, const Math::Matrix<3, GLfloat>& value);
void MAGNUM_LOCAL uniformImplementationDSA(GLint location, const Math::Matrix<4, GLfloat>& value);
void MAGNUM_LOCAL uniformImplementationDSA(GLint location, const Math::RectangularMatrix<2, 3, GLfloat>& value);
void MAGNUM_LOCAL uniformImplementationDSA(GLint location, const Math::RectangularMatrix<3, 2, GLfloat>& value);
void MAGNUM_LOCAL uniformImplementationDSA(GLint location, const Math::RectangularMatrix<2, 4, GLfloat>& value);
void MAGNUM_LOCAL uniformImplementationDSA(GLint location, const Math::RectangularMatrix<4, 2, GLfloat>& value);
void MAGNUM_LOCAL uniformImplementationDSA(GLint location, const Math::RectangularMatrix<3, 4, GLfloat>& value);
void MAGNUM_LOCAL uniformImplementationDSA(GLint location, const Math::RectangularMatrix<4, 3, GLfloat>& value);
#ifndef MAGNUM_TARGET_GLES
void MAGNUM_LOCAL uniformImplementationDSA(GLint location, const Math::Matrix<2, GLdouble>& value);
void MAGNUM_LOCAL uniformImplementationDSA(GLint location, const Math::Matrix<3, GLdouble>& value);
void MAGNUM_LOCAL uniformImplementationDSA(GLint location, const Math::Matrix<4, GLdouble>& value);
void MAGNUM_LOCAL uniformImplementationDSA(GLint location, const Math::RectangularMatrix<2, 3, GLdouble>& value);
void MAGNUM_LOCAL uniformImplementationDSA(GLint location, const Math::RectangularMatrix<3, 2, GLdouble>& value);
void MAGNUM_LOCAL uniformImplementationDSA(GLint location, const Math::RectangularMatrix<2, 4, GLdouble>& value);
void MAGNUM_LOCAL uniformImplementationDSA(GLint location, const Math::RectangularMatrix<4, 2, GLdouble>& value);
void MAGNUM_LOCAL uniformImplementationDSA(GLint location, const Math::RectangularMatrix<3, 4, GLdouble>& value);
void MAGNUM_LOCAL uniformImplementationDSA(GLint location, const Math::RectangularMatrix<4, 3, GLdouble>& value);
#endif
static UniformMatrix2fvImplementation uniformMatrix2fvImplementation;
static UniformMatrix3fvImplementation uniformMatrix3fvImplementation;
static UniformMatrix4fvImplementation uniformMatrix4fvImplementation;
static UniformMatrix2x3fvImplementation uniformMatrix2x3fvImplementation;
static UniformMatrix3x2fvImplementation uniformMatrix3x2fvImplementation;
static UniformMatrix2x4fvImplementation uniformMatrix2x4fvImplementation;
static UniformMatrix4x2fvImplementation uniformMatrix4x2fvImplementation;
static UniformMatrix3x4fvImplementation uniformMatrix3x4fvImplementation;
static UniformMatrix4x3fvImplementation uniformMatrix4x3fvImplementation;
#ifndef MAGNUM_TARGET_GLES
static UniformMatrix2dvImplementation uniformMatrix2dvImplementation;
static UniformMatrix3dvImplementation uniformMatrix3dvImplementation;
static UniformMatrix4dvImplementation uniformMatrix4dvImplementation;
static UniformMatrix2x3dvImplementation uniformMatrix2x3dvImplementation;
static UniformMatrix3x2dvImplementation uniformMatrix3x2dvImplementation;
static UniformMatrix2x4dvImplementation uniformMatrix2x4dvImplementation;
static UniformMatrix4x2dvImplementation uniformMatrix4x2dvImplementation;
static UniformMatrix3x4dvImplementation uniformMatrix3x4dvImplementation;
static UniformMatrix4x3dvImplementation uniformMatrix4x3dvImplementation;
#endif
Refactoring of internal OpenGL object names.
14 years ago
GLuint _id;
Classes for compiling and using shaders.
16 years ago
State state;
};
}
#endif