documentation/3.0.0/Shader_8hpp_source.html

//

// SFML - Simple and Fast Multimedia Library

// Copyright (C) 2007-2024 Laurent Gomila (laurent@sfml-dev.org)

//

// This software is provided 'as-is', without any express or implied warranty.

// In no event will the authors be held liable for any damages arising from the use of this software.

//

// Permission is granted to anyone to use this software for any purpose,

// including commercial applications, and to alter it and redistribute it freely,

// subject to the following restrictions:

//

// 1. The origin of this software must not be misrepresented;

//    you must not claim that you wrote the original software.

//    If you use this software in a product, an acknowledgment

//    in the product documentation would be appreciated but is not required.

//

// 2. Altered source versions must be plainly marked as such,

//    and must not be misrepresented as being the original software.

//

// 3. This notice may not be removed or altered from any source distribution.

//


#pragma once


// Headers

#include <SFML/Graphics/Export.hpp>


#include <SFML/Graphics/Glsl.hpp>


#include <SFML/Window/GlResource.hpp>


#include <filesystem>

#include <string>

#include <string_view>

#include <unordered_map>


#include <cstddef>


namespace sf

{

class InputStream;

class Texture;


class SFML_GRAPHICS_API Shader : GlResource

{

public:


    enum class Type

    {

        Vertex,

        Geometry,

        Fragment

    };


    struct CurrentTextureType

    {

    };


    // NOLINTNEXTLINE(readability-identifier-naming)

    static inline CurrentTextureType CurrentTexture;


    Shader() = default;


    ~Shader();


    Shader(const Shader&) = delete;


    Shader& operator=(const Shader&) = delete;


    Shader(Shader&& source) noexcept;


    Shader& operator=(Shader&& right) noexcept;


    Shader(const std::filesystem::path& filename, Type type);


    Shader(const std::filesystem::path& vertexShaderFilename, const std::filesystem::path& fragmentShaderFilename);


    Shader(const std::filesystem::path& vertexShaderFilename,

           const std::filesystem::path& geometryShaderFilename,

           const std::filesystem::path& fragmentShaderFilename);


    Shader(std::string_view shader, Type type);


    Shader(std::string_view vertexShader, std::string_view fragmentShader);


    Shader(std::string_view vertexShader, std::string_view geometryShader, std::string_view fragmentShader);


    Shader(InputStream& stream, Type type);


    Shader(InputStream& vertexShaderStream, InputStream& fragmentShaderStream);


    Shader(InputStream& vertexShaderStream, InputStream& geometryShaderStream, InputStream& fragmentShaderStream);


    [[nodiscard]] bool loadFromFile(const std::filesystem::path& filename, Type type);


    [[nodiscard]] bool loadFromFile(const std::filesystem::path& vertexShaderFilename,

                                    const std::filesystem::path& fragmentShaderFilename);


    [[nodiscard]] bool loadFromFile(const std::filesystem::path& vertexShaderFilename,

                                    const std::filesystem::path& geometryShaderFilename,

                                    const std::filesystem::path& fragmentShaderFilename);


    [[nodiscard]] bool loadFromMemory(std::string_view shader, Type type);


    [[nodiscard]] bool loadFromMemory(std::string_view vertexShader, std::string_view fragmentShader);


    [[nodiscard]] bool loadFromMemory(std::string_view vertexShader,

                                      std::string_view geometryShader,

                                      std::string_view fragmentShader);


    [[nodiscard]] bool loadFromStream(InputStream& stream, Type type);


    [[nodiscard]] bool loadFromStream(InputStream& vertexShaderStream, InputStream& fragmentShaderStream);


    [[nodiscard]] bool loadFromStream(InputStream& vertexShaderStream,

                                      InputStream& geometryShaderStream,

                                      InputStream& fragmentShaderStream);


    void setUniform(const std::string& name, float x);


    void setUniform(const std::string& name, Glsl::Vec2 vector);


    void setUniform(const std::string& name, const Glsl::Vec3& vector);


    void setUniform(const std::string& name, const Glsl::Vec4& vector);


    void setUniform(const std::string& name, int x);


    void setUniform(const std::string& name, Glsl::Ivec2 vector);


    void setUniform(const std::string& name, const Glsl::Ivec3& vector);


    void setUniform(const std::string& name, const Glsl::Ivec4& vector);


    void setUniform(const std::string& name, bool x);


    void setUniform(const std::string& name, Glsl::Bvec2 vector);


    void setUniform(const std::string& name, const Glsl::Bvec3& vector);


    void setUniform(const std::string& name, const Glsl::Bvec4& vector);


    void setUniform(const std::string& name, const Glsl::Mat3& matrix);


    void setUniform(const std::string& name, const Glsl::Mat4& matrix);


    void setUniform(const std::string& name, const Texture& texture);


    void setUniform(const std::string& name, const Texture&& texture) = delete;


    void setUniform(const std::string& name, CurrentTextureType);


    void setUniformArray(const std::string& name, const float* scalarArray, std::size_t length);


    void setUniformArray(const std::string& name, const Glsl::Vec2* vectorArray, std::size_t length);


    void setUniformArray(const std::string& name, const Glsl::Vec3* vectorArray, std::size_t length);


    void setUniformArray(const std::string& name, const Glsl::Vec4* vectorArray, std::size_t length);


    void setUniformArray(const std::string& name, const Glsl::Mat3* matrixArray, std::size_t length);


    void setUniformArray(const std::string& name, const Glsl::Mat4* matrixArray, std::size_t length);


    [[nodiscard]] unsigned int getNativeHandle() const;


    static void bind(const Shader* shader);


    [[nodiscard]] static bool isAvailable();


    [[nodiscard]] static bool isGeometryAvailable();


private:

    [[nodiscard]] bool compile(std::string_view vertexShaderCode,

                               std::string_view geometryShaderCode,

                               std::string_view fragmentShaderCode);


    void bindTextures() const;


    int getUniformLocation(const std::string& name);


    struct UniformBinder;


    // Types

    using TextureTable = std::unordered_map<int, const Texture*>;

    using UniformTable = std::unordered_map<std::string, int>;


    // Member data

    unsigned int m_shaderProgram{};

    int          m_currentTexture{-1};

    TextureTable m_textures;

    UniformTable m_uniforms;

};


} // namespace sf


GlResource.hpp

Glsl.hpp

Export.hpp

SFML_GRAPHICS_API
#define SFML_GRAPHICS_API
Definition Graphics/Export.hpp:42

sf::GlResource::GlResource
GlResource()
Default constructor.

sf::InputStream
Abstract class for custom file input streams.
Definition InputStream.hpp:46

sf::Shader::setUniformArray
void setUniformArray(const std::string &name, const Glsl::Mat4 *matrixArray, std::size_t length)
Specify values for mat4[] array uniform.

sf::Shader::bind
static void bind(const Shader *shader)
Bind a shader for rendering.

sf::Shader::operator=
Shader & operator=(Shader &&right) noexcept
Move assignment.

sf::Shader::Shader
Shader(InputStream &stream, Type type)
Construct from a shader stream.

sf::Shader::Shader
Shader(const std::filesystem::path &vertexShaderFilename, const std::filesystem::path &geometryShaderFilename, const std::filesystem::path &fragmentShaderFilename)
Construct from vertex, geometry and fragment shader files.

sf::Shader::Shader
Shader(Shader &&source) noexcept
Move constructor.

sf::Shader::loadFromStream
bool loadFromStream(InputStream &stream, Type type)
Load the vertex, geometry or fragment shader from a custom stream.

sf::Shader::loadFromFile
bool loadFromFile(const std::filesystem::path &vertexShaderFilename, const std::filesystem::path &geometryShaderFilename, const std::filesystem::path &fragmentShaderFilename)
Load the vertex, geometry and fragment shaders from files.

sf::Shader::setUniform
void setUniform(const std::string &name, const Glsl::Ivec4 &vector)
Specify value for ivec4 uniform.

sf::Shader::loadFromStream
bool loadFromStream(InputStream &vertexShaderStream, InputStream &fragmentShaderStream)
Load both the vertex and fragment shaders from custom streams.

sf::Shader::operator=
Shader & operator=(const Shader &)=delete
Deleted copy assignment.

sf::Shader::isGeometryAvailable
static bool isGeometryAvailable()
Tell whether or not the system supports geometry shaders.

sf::Shader::~Shader
~Shader()
Destructor.

sf::Shader::Shader
Shader(const std::filesystem::path &filename, Type type)
Construct from a shader file.

sf::Shader::loadFromFile
bool loadFromFile(const std::filesystem::path &filename, Type type)
Load the vertex, geometry or fragment shader from a file.

sf::Shader::setUniformArray
void setUniformArray(const std::string &name, const Glsl::Mat3 *matrixArray, std::size_t length)
Specify values for mat3[] array uniform.

sf::Shader::setUniform
void setUniform(const std::string &name, Glsl::Vec2 vector)
Specify value for vec2 uniform.

sf::Shader::setUniformArray
void setUniformArray(const std::string &name, const float *scalarArray, std::size_t length)
Specify values for float[] array uniform.

sf::Shader::setUniform
void setUniform(const std::string &name, const Texture &texture)
Specify a texture as sampler2D uniform.

sf::Shader::loadFromFile
bool loadFromFile(const std::filesystem::path &vertexShaderFilename, const std::filesystem::path &fragmentShaderFilename)
Load both the vertex and fragment shaders from files.

sf::Shader::setUniform
void setUniform(const std::string &name, Glsl::Bvec2 vector)
Specify value for bvec2 uniform.

sf::Shader::loadFromMemory
bool loadFromMemory(std::string_view vertexShader, std::string_view fragmentShader)
Load both the vertex and fragment shaders from source codes in memory.

sf::Shader::Shader
Shader(InputStream &vertexShaderStream, InputStream &fragmentShaderStream)
Construct from vertex and fragment shader streams.

sf::Shader::setUniform
void setUniform(const std::string &name, const Glsl::Ivec3 &vector)
Specify value for ivec3 uniform.

sf::Shader::setUniform
void setUniform(const std::string &name, Glsl::Ivec2 vector)
Specify value for ivec2 uniform.

sf::Shader::loadFromStream
bool loadFromStream(InputStream &vertexShaderStream, InputStream &geometryShaderStream, InputStream &fragmentShaderStream)
Load the vertex, geometry and fragment shaders from custom streams.

sf::Shader::Shader
Shader(const Shader &)=delete
Deleted copy constructor.

sf::Shader::setUniformArray
void setUniformArray(const std::string &name, const Glsl::Vec4 *vectorArray, std::size_t length)
Specify values for vec4[] array uniform.

sf::Shader::setUniform
void setUniform(const std::string &name, const Glsl::Vec3 &vector)
Specify value for vec3 uniform.

sf::Shader::setUniform
void setUniform(const std::string &name, const Glsl::Bvec3 &vector)
Specify value for bvec3 uniform.

sf::Shader::setUniform
void setUniform(const std::string &name, CurrentTextureType)
Specify current texture as sampler2D uniform.

sf::Shader::setUniformArray
void setUniformArray(const std::string &name, const Glsl::Vec2 *vectorArray, std::size_t length)
Specify values for vec2[] array uniform.

sf::Shader::Shader
Shader()=default
Default constructor.

sf::Shader::setUniform
void setUniform(const std::string &name, const Glsl::Vec4 &vector)
Specify value for vec4 uniform.

sf::Shader::setUniform
void setUniform(const std::string &name, float x)
Specify value for float uniform.

sf::Shader::setUniform
void setUniform(const std::string &name, const Glsl::Mat3 &matrix)
Specify value for mat3 matrix.

sf::Shader::getNativeHandle
unsigned int getNativeHandle() const
Get the underlying OpenGL handle of the shader.

sf::Shader::Shader
Shader(std::string_view vertexShader, std::string_view fragmentShader)
Construct from vertex and fragment shaders in memory.

sf::Shader::CurrentTexture
static CurrentTextureType CurrentTexture
Represents the texture of the object being drawn.
Definition Shader.hpp:85

sf::Shader::setUniform
void setUniform(const std::string &name, const Glsl::Bvec4 &vector)
Specify value for bvec4 uniform.

sf::Shader::setUniform
void setUniform(const std::string &name, const Glsl::Mat4 &matrix)
Specify value for mat4 matrix.

sf::Shader::setUniform
void setUniform(const std::string &name, const Texture &&texture)=delete
Disallow setting from a temporary texture.

sf::Shader::isAvailable
static bool isAvailable()
Tell whether or not the system supports shaders.

sf::Shader::loadFromMemory
bool loadFromMemory(std::string_view shader, Type type)
Load the vertex, geometry or fragment shader from a source code in memory.

sf::Shader::setUniform
void setUniform(const std::string &name, int x)
Specify value for int uniform.

sf::Shader::setUniformArray
void setUniformArray(const std::string &name, const Glsl::Vec3 *vectorArray, std::size_t length)
Specify values for vec3[] array uniform.

sf::Shader::Shader
Shader(std::string_view vertexShader, std::string_view geometryShader, std::string_view fragmentShader)
Construct from vertex, geometry and fragment shaders in memory.

sf::Shader::Shader
Shader(std::string_view shader, Type type)
Construct from shader in memory.

sf::Shader::Shader
Shader(InputStream &vertexShaderStream, InputStream &geometryShaderStream, InputStream &fragmentShaderStream)
Construct from vertex, geometry and fragment shader streams.

sf::Shader::setUniform
void setUniform(const std::string &name, bool x)
Specify value for bool uniform.

sf::Shader::Shader
Shader(const std::filesystem::path &vertexShaderFilename, const std::filesystem::path &fragmentShaderFilename)
Construct from vertex and fragment shader files.

sf::Shader::loadFromMemory
bool loadFromMemory(std::string_view vertexShader, std::string_view geometryShader, std::string_view fragmentShader)
Load the vertex, geometry and fragment shaders from source codes in memory.

sf::Shader::Type
Type
Types of shaders.
Definition Shader.hpp:61

sf::Shader::Type::Fragment
@ Fragment
Fragment (pixel) shader.
Definition Shader.hpp:64

sf::Shader::Type::Vertex
@ Vertex
Vertex shader
Definition Shader.hpp:62

sf::Shader::Type::Geometry
@ Geometry
Geometry shader.
Definition Shader.hpp:63

sf::Texture
Image living on the graphics card that can be used for drawing.
Definition Texture.hpp:56

sf::Glsl::Mat3
ImplementationDefined Mat3
3x3 float matrix (mat3 in GLSL)
Definition Glsl.hpp:152

sf::Glsl::Ivec2
Vector2< int > Ivec2
2D int vector (ivec2 in GLSL)
Definition Glsl.hpp:67

sf::Glsl::Vec3
Vector3< float > Vec3
3D float vector (vec3 in GLSL)
Definition Glsl.hpp:79

sf::Glsl::Ivec4
ImplementationDefined Ivec4
4D int vector (ivec4 in GLSL)
Definition Glsl.hpp:121

sf::Glsl::Vec2
Vector2< float > Vec2
2D float vector (vec2 in GLSL)
Definition Glsl.hpp:61

sf::Glsl::Bvec2
Vector2< bool > Bvec2
2D bool vector (bvec2 in GLSL)
Definition Glsl.hpp:73

sf::Glsl::Ivec3
Vector3< int > Ivec3
3D int vector (ivec3 in GLSL)
Definition Glsl.hpp:85

sf::Glsl::Bvec3
Vector3< bool > Bvec3
3D bool vector (bvec3 in GLSL)
Definition Glsl.hpp:91

sf::Glsl::Vec4
ImplementationDefined Vec4
4D float vector (vec4 in GLSL)
Definition Glsl.hpp:107

sf::Glsl::Mat4
ImplementationDefined Mat4
4x4 float matrix (mat4 in GLSL)
Definition Glsl.hpp:178

sf::Glsl::Bvec4
ImplementationDefined Bvec4
4D bool vector (bvec4 in GLSL)
Definition Glsl.hpp:127

sf
Definition AudioResource.hpp:36

sf::Shader::CurrentTextureType
Special type that can be passed to setUniform(), and that represents the texture of the object being ...
Definition Shader.hpp:75