Skip to content

Commit

Permalink
working basic version of templated shader lib
Browse files Browse the repository at this point in the history
  • Loading branch information
@jmacey
jmacey committed May 30, 2023
1 parent 2a2843b commit f6c4788
Show file tree
Hide file tree
Showing 5 changed files with 249 additions and 90 deletions.
1 change: 1 addition & 0 deletions CMakeLists.txt
View file
Original file line number Diff line number Diff line change
Expand Up @@ -151,6 +151,7 @@ set(HEADERS
${CMAKE_SOURCE_DIR}/include/ngl/NCCAPointBake.h
${CMAKE_SOURCE_DIR}/include/ngl/Shader.h
${CMAKE_SOURCE_DIR}/include/ngl/ShaderProgram.h
${CMAKE_SOURCE_DIR}/include/ngl/ShaderProgram.inl
${CMAKE_SOURCE_DIR}/include/ngl/Plane.h
${CMAKE_SOURCE_DIR}/include/ngl/AABB.h
${CMAKE_SOURCE_DIR}/include/ngl/Vec3.h
Expand Down
174 changes: 169 additions & 5 deletions include/ngl/ShaderProgram.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -26,7 +26,8 @@
#include <string_view>
#include <unordered_map>
#include <vector>

#include <iostream>
#include <cassert>
//----------------------------------------------------------------------------------------------------------------------
/// @class ShaderProgram "ShaderProgram.h"
/// @brief This class contains a single ShaderProgram which may have many
Expand Down Expand Up @@ -116,6 +117,148 @@ class NGL_DLLEXPORT ShaderProgram
/// method written by Richard Southern.
//----------------------------------------------------------------------------------------------------------------------
void printProperties() const noexcept;

template< typename Ts>
bool setRegisteredUniform(std::string_view _varname ,Ts &&arg ) const noexcept
{
auto uniform = m_registeredUniforms.find(_varname.data());
if(uniform != m_registeredUniforms.end())
{
if constexpr (std::is_same<Ts,float&>::value )
{
glUniform1f(uniform->second.loc, arg);
return true;
} // end of float
else if constexpr (std::is_same<Ts,int&>::value )
{
glUniform1i(uniform->second.loc, arg);
return true;
}// end of int
else if constexpr(std::is_same<Ts,Mat2&>::value)
{
glUniformMatrix2fv(uniform->second.loc, 1, GL_FALSE, &arg.m_openGL[0]);
return true;
} // end of mat2

else if constexpr(std::is_same<Ts,Mat3&>::value)
{
glUniformMatrix3fv(uniform->second.loc, 1, GL_FALSE, &arg.m_openGL[0]);
return true;
} // end of mat3
else if constexpr(std::is_same<Ts,Mat4&>::value)
{
glUniformMatrix4fv(uniform->second.loc, 1, GL_FALSE, &arg.m_openGL[0]);
return true;
} // end of mat4
else if constexpr(std::is_same<Ts,glm::mat2&>::value)
{
glUniformMatrix2fv(uniform->second.loc, 1, GL_FALSE, &arg[0][0]);
return true;
} // end of glmmat2
else if constexpr(std::is_same<Ts,glm::mat3&>::value)
{
glUniformMatrix3fv(uniform->second.loc, 1, GL_FALSE, &arg[0][0]);
return true;
} // end of glmmat3
else if constexpr(std::is_same<Ts,glm::mat4&>::value)
{
glUniformMatrix4fv(uniform->second.loc, 1, GL_FALSE, &arg[0][0]);
return true;
} // end of glmmat2




else if constexpr(std::is_same<Ts,Vec2&>::value)
{
glUniform2f(uniform->second.loc,arg.m_x,arg.m_y);
return true;

}
else if constexpr(std::is_same<Ts,Vec3&>::value)
{
glUniform3f(uniform->second.loc,arg.m_x,arg.m_y,arg.m_z);
return true;
}
else if constexpr(std::is_same<Ts,Vec4&>::value)
{
glUniform4f(uniform->second.loc,arg.m_x,arg.m_y,arg.m_z,arg.m_w);
return true;
}
}
else
{
ngl::NGLMessage::addWarning(fmt::format("Uniform {0} Not found in Shader {1}", _varname, m_programName));
return false;
}
return false;
}


template< typename... Ts>
bool setRegisteredUniform(std::string_view _varname ,Ts &&...args ) const noexcept
{
auto uniform = m_registeredUniforms.find(_varname.data());
// make sure we have a valid shader
if(uniform != m_registeredUniforms.end())
{
if constexpr (std::conjunction_v<std::is_same<float&, Ts>...>)
{
if constexpr (sizeof...(args) == 2)
{
auto values =std::forward_as_tuple(args...);
glUniform2f(uniform->second.loc,std::get<0>(values),std::get<1>(values));
return true;
}
else if constexpr (sizeof...(args) == 3)
{
auto values = std::forward_as_tuple(args...);
glUniform3f(uniform->second.loc,std::get<0>(values),std::get<1>(values),std::get<2>(values));
return true;
}
else if constexpr (sizeof...(args) == 4)
{
auto values = std::forward_as_tuple(args...);
glUniform4f(uniform->second.loc,std::get<0>(values),std::get<1>(values),std::get<2>(values),std::get<3>(values));
return true;
}
else
{
ngl::NGLMessage::addWarning(fmt::format("Uniform {0} Not found in Shader {1}", _varname, m_programName));
return false;
}
} // end float values
else if constexpr (std::conjunction_v<std::is_same<int&, Ts>...>)
{
if constexpr (sizeof...(args) == 2)
{
auto values =std::forward_as_tuple(args...);
glUniform2i(uniform->second.loc,std::get<0>(values),std::get<1>(values));
return true;
}
else if constexpr (sizeof...(args) == 3)
{
auto values = std::forward_as_tuple(args...);
glUniform3i(uniform->second.loc,std::get<0>(values),std::get<1>(values),std::get<2>(values));
return true;
}
else if constexpr (sizeof...(args) == 4)
{
auto values = std::forward_as_tuple(args...);
glUniform4i(uniform->second.loc,std::get<0>(values),std::get<1>(values),std::get<2>(values),std::get<3>(values));
return true;
}
else
{
ngl::NGLMessage::addWarning(fmt::format("Uniform {0} Not found in Shader {1}", _varname, m_programName));

return false;
}
}
}
return false;
}

//----------------------------------------------------------------------------------------------------------------------
/// @name Set uniform argument values from the argument name
//----------------------------------------------------------------------------------------------------------------------
Expand All @@ -124,7 +267,7 @@ class NGL_DLLEXPORT ShaderProgram
/// @param _varname - name of the uniform variable
/// @param _v0 - new value for the variable
//----------------------------------------------------------------------------------------------------------------------
bool setRegisteredUniform1f(std::string_view _varname, float _v0) const noexcept;
//bool setRegisteredUniform1f(std::string_view _varname, float _v0) const noexcept;
bool getRegisteredUniform1f(std::string_view _varname, float &o_v0) const noexcept;

//----------------------------------------------------------------------------------------------------------------------
Expand All @@ -133,7 +276,7 @@ class NGL_DLLEXPORT ShaderProgram
/// @param _v0 - new value for the variable
/// @param _v1 - new value for the variable
//----------------------------------------------------------------------------------------------------------------------
bool setRegisteredUniform2f(std::string_view _varname, float _v0, float _v1) const noexcept;
//bool setRegisteredUniform2f(std::string_view _varname, float _v0, float _v1) const noexcept;
bool getRegisteredUniform2f(std::string_view _varname, float &o_v0, float &o_v1) const noexcept;

//----------------------------------------------------------------------------------------------------------------------
Expand All @@ -143,7 +286,7 @@ class NGL_DLLEXPORT ShaderProgram
/// @param _v1 - new value for the variable
/// @param _v2 - new value for the variable
//----------------------------------------------------------------------------------------------------------------------
bool setRegisteredUniform3f(std::string_view _varname, float _v0, float _v1, float _v2) const noexcept;
//bool setRegisteredUniform3f(std::string_view _varname, float _v0, float _v1, float _v2) const noexcept;
bool getRegisteredUniform3f(std::string_view _varname, float &_v0, float &_v1, float &_v2) const noexcept;
//----------------------------------------------------------------------------------------------------------------------
/// @brief sets the registered uniform to a single float
Expand All @@ -153,7 +296,7 @@ class NGL_DLLEXPORT ShaderProgram
/// @param _v2 - new value for the variable
/// @param _v3 - new value for the variable
/////----------------------------------------------------------------------------------------------------------------------
bool setRegisteredUniform4f(std::string_view _varname, float _v0, float _v1, float _v2, float _v3) const noexcept;
// bool setRegisteredUniform4f(std::string_view _varname, float _v0, float _v1, float _v2, float _v3) const noexcept;
bool getRegisteredUniform4f(std::string_view _varname, float &_v0, float &_v1, float &_v2, float &o_v3) const noexcept;
//----------------------------------------------------------------------------------------------------------------------
/// @brief sets the registered uniform to a single int
Expand Down Expand Up @@ -355,6 +498,27 @@ class NGL_DLLEXPORT ShaderProgram
bool m_active = false;
//----------------------------------------------------------------------------------------------------------------------
};

//#include "ngl//ShaderProgram.inl"
/*
template bool ShaderProgram::setRegisteredUniform<float>(std::string_view _varname ,float && ) const noexcept;
template bool ShaderProgram::setRegisteredUniform<float,float>(std::string_view _varname ,float && ,float &&) const noexcept;
template bool ShaderProgram::setRegisteredUniform<float,float,float>(std::string_view _varname ,float &&, float &&,float && ) const noexcept;
template bool ShaderProgram::setRegisteredUniform<float,float,float,float>(std::string_view _varname ,float &&, float &&,float &&, float && ) const noexcept;
template bool ShaderProgram::setRegisteredUniform<int>(std::string_view _varname ,int && ) const noexcept;
template bool ShaderProgram::setRegisteredUniform<int,int>(std::string_view _varname ,int && ,int &&) const noexcept;
template bool ShaderProgram::setRegisteredUniform<int,int,int>(std::string_view _varname ,int &&, int &&,int && ) const noexcept;
template bool ShaderProgram::setRegisteredUniform<int,int,int,int>(std::string_view _varname ,int &&, int &&,int &&, int && ) const noexcept;
template bool ShaderProgram::setRegisteredUniform<ngl::Vec2>(std::string_view _varname ,ngl::Vec2 && ) const noexcept;
template bool ShaderProgram::setRegisteredUniform<ngl::Vec3>(std::string_view _varname ,ngl::Vec3 && ) const noexcept;
template bool ShaderProgram::setRegisteredUniform<ngl::Vec4>(std::string_view _varname ,ngl::Vec4 && ) const noexcept;
template bool ShaderProgram::setRegisteredUniform<ngl::Mat2>(std::string_view _varname ,ngl::Mat2 && ) const noexcept;
template bool ShaderProgram::setRegisteredUniform<ngl::Mat3>(std::string_view _varname ,ngl::Mat3 && ) const noexcept;
template bool ShaderProgram::setRegisteredUniform<ngl::Mat4>(std::string_view _varname ,ngl::Mat4 && ) const noexcept;
*/
} // namespace ngl
#endif
//----------------------------------------------------------------------------------------------------------------------
Expand Down
30 changes: 15 additions & 15 deletions src/ShaderLib.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -806,7 +806,7 @@ void ShaderLib::printProperties() noexcept

bool ShaderLib::setUniform(std::string_view _paramName, Real _v0) noexcept
{
return m_shaderPrograms[m_currentShader]->setRegisteredUniform1f(_paramName.data(), _v0);
return m_shaderPrograms[m_currentShader]->setRegisteredUniform(_paramName.data(), _v0);
}

bool ShaderLib::getUniform(std::string_view _paramName, Real &o_v0) noexcept
Expand Down Expand Up @@ -861,17 +861,17 @@ bool ShaderLib::getUniform(std::string_view _paramName, ngl::Vec4 &o_v) noexcept

bool ShaderLib::setUniform(std::string_view _paramName, Real _v0, Real _v1) noexcept
{
return m_shaderPrograms[m_currentShader]->setRegisteredUniform2f(_paramName.data(), _v0, _v1);
return m_shaderPrograms[m_currentShader]->setRegisteredUniform(_paramName.data(), _v0, _v1);
}

bool ShaderLib::setUniform(std::string_view _paramName, Real _v0, Real _v1, Real _v2) noexcept
{
return m_shaderPrograms[m_currentShader]->setRegisteredUniform3f(_paramName.data(), _v0, _v1, _v2);
return m_shaderPrograms[m_currentShader]->setRegisteredUniform(_paramName.data(), _v0, _v1, _v2);
}

bool ShaderLib::setUniform(std::string_view _paramName, Real _v0, Real _v1, Real _v2, Real _v3) noexcept
{
return m_shaderPrograms[m_currentShader]->setRegisteredUniform4f(_paramName.data(), _v0, _v1, _v2, _v3);
return m_shaderPrograms[m_currentShader]->setRegisteredUniform(_paramName.data(), _v0, _v1, _v2, _v3);
}

bool ShaderLib::setUniform(std::string_view _paramName, GLint _v0) noexcept
Expand Down Expand Up @@ -923,22 +923,22 @@ bool ShaderLib::getUniform(std::string_view _paramName, GLint &o_v0,GLint &o_v1,

bool ShaderLib::setUniform(std::string_view _paramName, Vec2 _v0) noexcept
{
return m_shaderPrograms[m_currentShader]->setRegisteredUniform2f(_paramName.data(), _v0.m_x, _v0.m_y);
return m_shaderPrograms[m_currentShader]->setRegisteredUniform(_paramName.data(), _v0.m_x, _v0.m_y);
}

bool ShaderLib::setUniform(std::string_view _paramName, Vec3 _v0) noexcept
{
return m_shaderPrograms[m_currentShader]->setRegisteredUniform3f(_paramName.data(), _v0.m_x, _v0.m_y, _v0.m_z);
return m_shaderPrograms[m_currentShader]->setRegisteredUniform(_paramName.data(), _v0.m_x, _v0.m_y, _v0.m_z);
}

bool ShaderLib::setUniform(std::string_view _paramName, Vec4 _v0) noexcept
{
return m_shaderPrograms[m_currentShader]->setRegisteredUniform4f(_paramName.data(), _v0.m_x, _v0.m_y, _v0.m_z, _v0.m_w);
return m_shaderPrograms[m_currentShader]->setRegisteredUniform(_paramName.data(), _v0.m_x, _v0.m_y, _v0.m_z, _v0.m_w);
}

bool ShaderLib::setUniform(std::string_view _paramName, Mat2 _v0) noexcept
{
return m_shaderPrograms[m_currentShader]->setRegisteredUniformMatrix2fv(_paramName.data(), 1, GL_FALSE, _v0.openGL());
return m_shaderPrograms[m_currentShader]->setRegisteredUniform(_paramName.data(), _v0);
}

bool ShaderLib::getUniform(std::string_view _paramName, ngl::Mat2 &o_v) noexcept
Expand All @@ -948,7 +948,7 @@ bool ShaderLib::getUniform(std::string_view _paramName, ngl::Mat2 &o_v) noexcept

bool ShaderLib::setUniform(std::string_view _paramName, Mat3 _v0) noexcept
{
return m_shaderPrograms[m_currentShader]->setRegisteredUniformMatrix3fv(_paramName.data(), 1, GL_FALSE, _v0.openGL());
return m_shaderPrograms[m_currentShader]->setRegisteredUniform(_paramName.data(), _v0);
}

bool ShaderLib::getUniform(std::string_view _paramName, ngl::Mat3 &o_v) noexcept
Expand All @@ -964,31 +964,31 @@ bool ShaderLib::getUniform(std::string_view _paramName, ngl::Mat4 &o_v) noexcept
#ifdef USEGLM
bool ShaderLib::setUniform(std::string_view _paramName, glm::vec2 _v0) noexcept
{
return m_shaderPrograms[m_currentShader]->setRegisteredUniform2f(_paramName.data(), _v0.x, _v0.y);
return m_shaderPrograms[m_currentShader]->setRegisteredUniform(_paramName.data(), _v0.x, _v0.y);
}

bool ShaderLib::setUniform(std::string_view _paramName, glm::vec3 _v0) noexcept
{
return m_shaderPrograms[m_currentShader]->setRegisteredUniform3f(_paramName.data(), _v0.x, _v0.y, _v0.z);
return m_shaderPrograms[m_currentShader]->setRegisteredUniform(_paramName.data(), _v0.x, _v0.y, _v0.z);
}

bool ShaderLib::setUniform(std::string_view _paramName, glm::vec4 _v0) noexcept
{
return m_shaderPrograms[m_currentShader]->setRegisteredUniform4f(_paramName.data(), _v0.x, _v0.y, _v0.z, _v0.w);
return m_shaderPrograms[m_currentShader]->setRegisteredUniform(_paramName.data(), _v0.x, _v0.y, _v0.z, _v0.w);
}

bool ShaderLib::setUniform(std::string_view _paramName, glm::mat3 _v0) noexcept
{
return m_shaderPrograms[m_currentShader]->setRegisteredUniformMatrix3fv(_paramName.data(), 1, GL_FALSE, &_v0[0][0]);
return m_shaderPrograms[m_currentShader]->setRegisteredUniform(_paramName.data(), _v0);
}
bool ShaderLib::setUniform(std::string_view _paramName, glm::mat4 _v0) noexcept
{
return m_shaderPrograms[m_currentShader]->setRegisteredUniformMatrix4fv(_paramName.data(), 1, GL_FALSE, &_v0[0][0]);
return m_shaderPrograms[m_currentShader]->setRegisteredUniform(_paramName.data(), _v0);
}

bool ShaderLib::setUniform(std::string_view _paramName, glm::mat2 _v0) noexcept
{
return m_shaderPrograms[m_currentShader]->setRegisteredUniformMatrix2fv(_paramName.data(), 1, GL_FALSE, &_v0[0][0]);
return m_shaderPrograms[m_currentShader]->setRegisteredUniform(_paramName.data(), _v0);
}

#endif
Expand Down
Loading

0 comments on commit f6c4788

Please sign in to comment.