void Shader::load(const std::string &_name ) noexcept
{
// see if we already have some source attached
if(!m_source.empty())
{
msg->addWarning("deleting existing source code\n");
m_source.clear();
}
std::ifstream shaderSource(_name.data());
if (!shaderSource.is_open())
{
msg->addError(fmt::format("File not found {0}",_name.data()));
exit(EXIT_FAILURE);
}
// now read in the data
m_source = std::string((std::istreambuf_iterator<char>(shaderSource)), std::istreambuf_iterator<char>());
shaderSource.close();
// glShaderSource needs null terminated const char *
m_source+='\0';
m_originalSource=m_source;
const char* data=m_source.c_str();
glShaderSource(m_shaderHandle , 1, &data,nullptr);
m_compiled=false;
if (m_debugState == true)
{
printInfoLog(m_shaderHandle);
}
}
std::shared_ptr<Opengl::RenderEffect>& ResourceManager::makeEffect(const std::string& name) {
if (this->effectCache.find(name) == this->effectCache.end()) {
Logger::getInstance().log(Logger::LOG_INFO, "Loading shader `%s'", name.c_str());
std::fstream file(name.c_str(), std::ios::binary | std::ios::in);
if (!file.good()) {
Logger::getInstance().log(Logger::LOG_ERROR, "Cannot open file `%s'", name.c_str());
return this->effectCache["nullptr"];
}
file.seekg(0, std::ios::end);
int sourceLength = file.tellg();
std::unique_ptr<char[]> shaderSource(new char[sourceLength + 1]);
shaderSource[sourceLength] = '\0';
file.seekg(0, std::ios::beg);
file.read(shaderSource.get(), sourceLength);
file.close();
this->insertEffect(name, shaderSource.get());
}
return this->effectCache[name];
}
void Shader::load( std::string _name ) noexcept
{
// see if we already have some source attached
if(m_source.empty())
{
std::cerr<<"deleting existing source code\n";
m_source.clear();
}
std::ifstream shaderSource(_name.c_str());
if (!shaderSource.is_open())
{
std::cerr<<"File not found "<<_name.c_str()<<"\n";
//exit(EXIT_FAILURE);
}
// now read in the data
m_source = std::string((std::istreambuf_iterator<char>(shaderSource)), std::istreambuf_iterator<char>());
shaderSource.close();
// glShaderSource needs null terminated const char *
m_source+='\0';
const char* data=m_source.c_str();
glShaderSource(m_shaderHandle , 1, &data,NULL);
m_compiled=false;
if (m_debugState == true)
{
printInfoLog(m_shaderHandle);
}
}
/*virtual*/
std::string
HdSceneDelegate::GetDisplacementShaderSource(SdfPath const &shaderId)
{
std::string shaderSource(
"vec4 displacementShader(int index, vec4 Peye, vec3 Neye, vec4 patchCoord) {\n"
" return Peye;\n"
"}\n"
);
return shaderSource;
}
void GLProgram::printSource() const
{
GL::Int maxAttachedShaders = 0;
gl::GetProgramiv(m_Handle, GL::ATTACHED_SHADERS, &maxAttachedShaders);
std::vector<GL::UInt> shaders(static_cast<size_t>(maxAttachedShaders));
GL::Sizei numAttachedShaders = 0;
gl::GetAttachedShaders(m_Handle, maxAttachedShaders, &numAttachedShaders, shaders.data());
std::stringstream ss;
for (auto shader : shaders) {
GL::Int type = 0;
gl::GetShaderiv(shader, GL::SHADER_TYPE, &type);
ss << "// " << GL::Enum(type) << '\n';
GL::Int bufferLength = 0;
gl::GetShaderiv(shader, GL::SHADER_SOURCE_LENGTH, &bufferLength);
std::vector<char> shaderSource(static_cast<size_t>(bufferLength));
GL::Sizei sourceLength = 0;
gl::GetShaderSource(shader, bufferLength, &sourceLength, shaderSource.data());
const char* p = shaderSource.data();
const char* end = p + sourceLength;
bool printLineNumber = true;
int lineNumber = 0;
for (; p < end; ++p) {
if (printLineNumber) {
ss << std::setw(4) << ++lineNumber << std::setw(0) << ": ";
printLineNumber = false;
}
ss << *p;
if (*p == '\n')
printLineNumber = true;
}
if (end > p && end[-1] != '\n')
ss << '\n';
}
std::string source = ss.str();
size_t length = source.length();
if (length > 0 && source[length - 1] == '\n')
source.resize(length - 1);
Z_LOG(source);
}
GLuint PagShaderProgram::compileShader(QString name, GLenum type)
{
QFileInfo shaderName(name);
if (!shaderName.exists())
{
//qDebug() << "No existe el shader source: " << name;
return 0;
}
std::string shaderString;
QFile shaderSource(name);
if (!shaderSource.open(QIODevice::ReadOnly))
{
qDebug() << "No se puede abrir el archivo " << name;
return 0;
}
shaderString = (std::string)shaderSource.readAll();
shaderSource.close();
GLuint shaderHandler = glCreateShader(type);
if (shaderHandler == 0) {
qDebug() << "No se puede crear el shader object";
return 0;
}
const char *c_str = shaderString.c_str();
glShaderSource(shaderHandler, 1, &c_str, NULL);
glCompileShader(shaderHandler);
GLint compileResult;
glGetShaderiv(shaderHandler,GL_COMPILE_STATUS, &compileResult);
if (compileResult == GL_FALSE) {
qDebug() << "Error al compilar el shader: " << name;
GLint logLen = 0;
glGetShaderiv(shaderHandler, GL_INFO_LOG_LENGTH, &logLen);
if (logLen > 0) {
char * log = new char[logLen];
GLint written = 0;
glGetShaderInfoLog(shaderHandler,logLen,&written, log);
qDebug() << log << endl;
delete [] log;
}
}
return shaderHandler;
}
//GLSL shader creation (of a certain type, vertex shader, fragment shader oe geometry shader)
GLuint createShaderFromString(const char *shaderString, const char *filepath, GLuint shaderType, GLuint shaderID)
{
if(0 == shaderID){
shaderID = glCreateShader(shaderType);
}
std::string fileName(filepath);
if (fileName.empty()){
fileName = "./__defaultGLSL__.glsl";
}
std::string shaderSource(shaderString);
try{
//include files are processed in a recursive way, no worry!!
shaderSource = manageIncludes(shaderSource, fileName);
//Define global macros
std::map<string, string>::iterator itr;
for( itr = shadersMacroMap.begin(); itr != shadersMacroMap.end(); itr++){
const char *macro = itr->first.c_str();
const char *value = itr->second.c_str();
defineMacro(shaderSource, macro, value);
}
//Passing shader source code to GL
//Source used for "shaderID" shader, there is only "1" source code and
//the string is NULL terminated (no sizes passed)
//std::cout << shaderSource;
const char *src = shaderSource.c_str();
glShaderSource(shaderID, 1, &src, NULL);
glCompileShader(shaderID);
//check GL runtime error
GLenum error;
while ((error = glGetError() ) != GL_NO_ERROR){
const char* format = "GL error at file %s, line %d: %s\n";
fprintf (stderr, format, __FILE__, __LINE__, gluErrorString(error));
shaderID = 0;
}
}
catch(...){
glDeleteShader(shaderID);
shaderID = 0;
}
return shaderID;
}
int main(int argc, char** argv)
{
if (argc != 3)
{
std::cerr << "syntax: ShaderImporter {input fullpath} {output fullpath without extension}" << std::endl;
return 1;
}
std::cout << "input: " << argv[1] << " output: " << argv[2] << std::endl;
std::ifstream file(argv[1], std::ios::binary | std::ios::ate);
auto fileLength = file.tellg();
if (fileLength <= 0)
{
std::cerr << "unable to read file " << argv[1] << std::endl;
return 1;
}
std::string shaderSource(static_cast<unsigned int>(fileLength), '0');
file.seekg(0, std::ios::beg);
file.read(&shaderSource[0], fileLength);
file.close();
if (shaderSource.find("main_vertex") != std::string::npos)
{
importShader(argv[1], std::string(argv[2]) + ".cvs", "/Emain_vertex", "/Tvs_5_0");
}
if (shaderSource.find("main_geometry") != std::string::npos)
{
importShader(argv[1], std::string(argv[2]) + ".cgs", "/Emain_geometry", "/Tgs_5_0");
}
if (shaderSource.find("main_pixel") != std::string::npos)
{
importShader(argv[1], std::string(argv[2]) + ".cps", "/Emain_pixel", "/Tps_5_0");
}
return 0;
}
GLuint loadShader(char const *fname, GLenum shaderType, bool *errorFlagPtr) {
std::ifstream fileStream(fname);
std::stringstream buffer;
buffer << fileStream.rdbuf();
std::string shaderSource(buffer.str());
GLuint shaderId = glCreateShader(shaderType);
const GLchar * const shaderSourceCStr = shaderSource.c_str();
glShaderSource(shaderId, 1, &shaderSourceCStr, nullptr);
glCompileShader(shaderId);
*errorFlagPtr = checkShaderCompileStatus(shaderId);
if(*errorFlagPtr) {
glDeleteShader(shaderId);
return 0;
}
return shaderId;
}
/** @brief Function builds test's GLSL program.
* If succeded, the program will be set to be used.
*
* @note The function may throw if unexpected error has occured.
*/
void TextureCubeMapArrayETC2Support::prepareProgram()
{
/* Shortcut for GL functionality */
const glw::Functions& gl = m_context.getRenderContext().getFunctions();
struct Shader
{
glw::GLchar const* const source;
glw::GLenum const type;
glw::GLuint id;
} shader[] = { { s_vertex_shader, GL_VERTEX_SHADER, 0 }, { s_fragment_shader, GL_FRAGMENT_SHADER, 0 } };
bool programPreparationFailed = false;
glw::GLuint const shader_count = sizeof(shader) / sizeof(shader[0]);
/* Create program. */
m_program = gl.createProgram();
GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateProgram call failed.");
/* Shader compilation. */
for (glw::GLuint i = 0; i < shader_count; ++i)
{
if (DE_NULL != shader[i].source)
{
shader[i].id = gl.createShader(shader[i].type);
GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateShader call failed.");
gl.attachShader(m_program, shader[i].id);
GLU_EXPECT_NO_ERROR(gl.getError(), "glAttachShader call failed.");
glu::ContextType contextType = m_context.getRenderContext().getType();
glu::GLSLVersion glslVersion = glu::getContextTypeGLSLVersion(contextType);
std::string shaderSource(glu::getGLSLVersionDeclaration(glslVersion));
shaderSource += shader[i].source;
const char* source = shaderSource.c_str();
gl.shaderSource(shader[i].id, 1, &source, NULL);
GLU_EXPECT_NO_ERROR(gl.getError(), "glShaderSource call failed.");
gl.compileShader(shader[i].id);
GLU_EXPECT_NO_ERROR(gl.getError(), "glCompileShader call failed.");
glw::GLint status = GL_FALSE;
gl.getShaderiv(shader[i].id, GL_COMPILE_STATUS, &status);
GLU_EXPECT_NO_ERROR(gl.getError(), "glGetShaderiv call failed.");
if (GL_FALSE == status)
{
glw::GLint log_size = 0;
gl.getShaderiv(shader[i].id, GL_INFO_LOG_LENGTH, &log_size);
GLU_EXPECT_NO_ERROR(gl.getError(), "glGetShaderiv call failed.");
glw::GLchar* log_text = new glw::GLchar[log_size];
gl.getShaderInfoLog(shader[i].id, log_size, NULL, &log_text[0]);
m_context.getTestContext().getLog() << tcu::TestLog::Message << "Shader compilation error, log:\n"
<< log_text << "\n"
<< "Shader source code:\n"
<< shaderSource << "\n"
<< tcu::TestLog::EndMessage;
delete[] log_text;
GLU_EXPECT_NO_ERROR(gl.getError(), "glGetShaderInfoLog call failed.");
programPreparationFailed = true;
break;
}
}
}
if (programPreparationFailed)
{
if (m_program)
{
gl.deleteProgram(m_program);
m_program = 0;
}
}
else
{
/* Link. */
gl.linkProgram(m_program);
GLU_EXPECT_NO_ERROR(gl.getError(), "glLlinkProgram call failed.");
glw::GLint status = GL_FALSE;
gl.getProgramiv(m_program, GL_LINK_STATUS, &status);
if (GL_TRUE == status)
{
for (glw::GLuint i = 0; i < shader_count; ++i)
{
if (shader[i].id)
{
gl.detachShader(m_program, shader[i].id);
GLU_EXPECT_NO_ERROR(gl.getError(), "glDetachShader call failed.");
}
}
}
else
{
glw::GLint log_size = 0;
gl.getProgramiv(m_program, GL_INFO_LOG_LENGTH, &log_size);
GLU_EXPECT_NO_ERROR(gl.getError(), "glGetProgramiv call failed.");
glw::GLchar* log_text = new glw::GLchar[log_size];
gl.getProgramInfoLog(m_program, log_size, NULL, &log_text[0]);
m_context.getTestContext().getLog() << tcu::TestLog::Message << "Program linkage has failed due to:\n"
<< log_text << "\n"
<< tcu::TestLog::EndMessage;
delete[] log_text;
GLU_EXPECT_NO_ERROR(gl.getError(), "glGetProgramInfoLog call failed.");
programPreparationFailed = true;
}
}
for (glw::GLuint i = 0; i < shader_count; ++i)
{
if (0 != shader[i].id)
{
gl.deleteShader(shader[i].id);
shader[i].id = 0;
}
}
if (m_program)
{
glw::GLint textureSampler = gl.getUniformLocation(m_program, "texture_sampler");
GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation call failed.");
gl.useProgram(m_program);
GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram call failed.");
gl.uniform1i(textureSampler, 0);
GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i call failed.");
}
else
TCU_FAIL("Failed to prepare program");
}
