Shader.hpp

Go to the documentation of this file.

//
// 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