ShaderUnmanaged.hpp

#ifndef RAYLIB_CPP_INCLUDE_UNMANAGEDSHADER_HPP_
#define RAYLIB_CPP_INCLUDE_UNMANAGEDSHADER_HPP_
 
#include "./raylib-cpp-utils.hpp"
#include "./raylib.hpp"
 
#include <rlgl.h>
#include <string>
 
namespace raylib {
 
class ShaderUnmanaged : public ::Shader {
public:
    ShaderUnmanaged() : ::Shader{rlGetShaderIdDefault(), rlGetShaderLocsDefault()} {}
 
    ShaderUnmanaged(const ::Shader& shader) : ::Shader(shader) { }
 
    ShaderUnmanaged(unsigned int id, int* locs = nullptr) : ::Shader{id, locs} {}
 
    ShaderUnmanaged(const std::string& vsFileName, const std::string& fsFileName) {
        set(::LoadShader(vsFileName.c_str(), fsFileName.c_str()));
    }
    ShaderUnmanaged(const char* vsFileName, const char* fsFileName) { set(::LoadShader(vsFileName, fsFileName)); }
 
    static ::Shader Load(const std::string& vsFileName, const std::string& fsFileName) {
        return ::LoadShader(vsFileName.c_str(), fsFileName.c_str());
    }
    static ::Shader Load(const char* vsFileName, const char* fsFileName) {
        return ::LoadShader(vsFileName, fsFileName);
    }
 
    static ::Shader LoadFromMemory(const std::string& vsCode, const std::string& fsCode) {
        return ::LoadShaderFromMemory(vsCode.c_str(), fsCode.c_str());
    }
    static ::Shader LoadFromMemory(const char* vsCode, const char* fsCode) {
        return ::LoadShaderFromMemory(vsCode, fsCode);
    }
 
    GETTER(unsigned int, Id, id)
    GETTER(int*, Locs, locs)
 
    ShaderUnmanaged& operator=(const ::Shader& shader) {
        set(shader);
        return *this;
    }
 
    ShaderUnmanaged& BeginMode() {
        ::BeginShaderMode(*this);
        return *this;
    }
 
    ShaderUnmanaged& EndMode() {
        ::EndShaderMode();
        return *this;
    }
 
    [[nodiscard]] int GetLocation(const std::string& uniformName) const { return ::GetShaderLocation(*this, uniformName.c_str()); }
 
    [[nodiscard]] int GetLocationAttrib(const std::string& attribName) const {
        return ::GetShaderLocationAttrib(*this, attribName.c_str());
    }
 
    ShaderUnmanaged& SetValue(int uniformLoc, const void* value, int uniformType) {
        ::SetShaderValue(*this, uniformLoc, value, uniformType);
        return *this;
    }
 
    ShaderUnmanaged& SetValue(int uniformLoc, const void* value, int uniformType, int count) {
        ::SetShaderValueV(*this, uniformLoc, value, uniformType, count);
        return *this;
    }
 
    ShaderUnmanaged& SetValue(int uniformLoc, const ::Matrix& mat) {
        ::SetShaderValueMatrix(*this, uniformLoc, mat);
        return *this;
    }
 
    ShaderUnmanaged& SetValue(int uniformLoc, const ::Texture2D& texture) {
        ::SetShaderValueTexture(*this, uniformLoc, texture);
        return *this;
    }
 
    [[nodiscard]] bool IsValid() const { return ::IsShaderValid(*this); }
protected:
    void set(const ::Shader& shader) {
        id = shader.id;
        locs = shader.locs;
    }
};
} // namespace raylib
 
using RShaderUnmanaged = raylib::ShaderUnmanaged;
 
#endif // RAYLIB_CPP_INCLUDE_UNMANAGEDSHADER_HPP_