void Shader::buildProgram(sh *vtx, sh *frg)
{
GLint status;
GLchar *vtxSourceString = NULL, *frgSourceString = NULL;
float glLanguageVersion;
sscanf_s((char *)glGetString(GL_SHADING_LANGUAGE_VERSION), "%f", &glLanguageVersion);
GLuint version = static_cast<GLuint>(100 * glLanguageVersion);
const GLsizei versionStringSize = sizeof("#version 123\n");
program_handle = glCreateProgram();
vtxSourceString = (char*)malloc(vtx->byteSize + versionStringSize);
frgSourceString = (char*)malloc(frg->byteSize + versionStringSize);
sprintf(vtxSourceString, "#version %d\n%s", version, vtx->string);
sprintf(frgSourceString, "#version %d\n%s", version, frg->string);
GLuint vtxShader = glCreateShader(GL_VERTEX_SHADER);
glShaderSource(vtxShader, 1, (const GLchar **)&(vtxSourceString), NULL);
glCompileShader(vtxShader);
status = checkCompileError(vtxShader);
if (status == 0) {
printf("Failed to compile vtx shader:\n%s\n", vtxSourceString);
return;
}
GLuint frgShader = glCreateShader(GL_FRAGMENT_SHADER);
glShaderSource(frgShader, 1, (const GLchar **)&(frgSourceString), NULL);
glCompileShader(frgShader);
status = checkCompileError(frgShader);
if (status == 0) {
printf("Failed to compile frg shader:\n%s\n", frgSourceString);
return;
}
free(vtxSourceString);
vtxSourceString = NULL;
free(frgSourceString);
frgSourceString = NULL;
glAttachShader(program_handle, vtxShader);
glDeleteShader(vtxShader);
glAttachShader(program_handle, frgShader);
glDeleteShader(frgShader);
linkProgram();
}
GLuint GLSLProgram::compileProgram(const char *vsource, const char *fsource) {
GLuint vertShader = glCreateShader(GL_VERTEX_SHADER); // create shader
GLuint fragShader = glCreateShader(GL_FRAGMENT_SHADER); // create shader
glShaderSource(vertShader, 1, &vsource, NULL);
glShaderSource(fragShader, 1, &fsource, NULL);
// compile vertex program
glCompileShader(vertShader);
if (!checkCompileError(vertShader, GL_VERTEX_SHADER)) {
LOGI("Faild to compile Vertex Shader");
return 0;
}
glCompileShader(fragShader);
if (!checkCompileError(fragShader, GL_FRAGMENT_SHADER)) {
LOGI("Faild to compile Fragment Shader");
return 0;
}
GLuint program = glCreateProgram();
// program attack shader
glAttachShader(program, vertShader);
glAttachShader(program, fragShader);
// upload program
glLinkProgram(program);
GLint success = 0;
glGetProgramiv(program, GL_LINK_STATUS, &success);
if (!success) {
GLint bufLength = 0;
glGetProgramiv(program, GL_INFO_LOG_LENGTH, &bufLength);
char *buf = new char[bufLength];
glGetProgramInfoLog(program, bufLength, NULL, buf);
LOGI("Cound not link program:\n%s\n", buf);
delete [] buf;
}
// delete shader
glDeleteShader(vertShader);
glDeleteShader(fragShader);
LOGI("Program Create Success");
return program;
}
bool PythonScript::compile(bool outputInfo) {
if (outputInfo)
LogInfo("Compiling script");
Py_XDECREF(BYTE_CODE);
byteCode_ = Py_CompileString(source_.c_str(), filename_.c_str(), Py_file_input);
isCompileNeeded_ = !checkCompileError();
if (isCompileNeeded_) {
Py_XDECREF(BYTE_CODE);
byteCode_ = nullptr;
}
return !isCompileNeeded_;
}
bool ShaderManager::checkAllCompileError(QString *o_log)
{
GLint isAllCompiled = GL_TRUE;
QString temp_log;
std::vector <std::string> shaderPrograms = {m_data.m_vert, m_data.m_frag};
// Iterate between vertex and fragment shaders to check compile errors
for (auto shaderProg: shaderPrograms)
{
GLint isCompiled = checkCompileError(shaderProg, &temp_log);
if (!isCompiled)
{
o_log->append(QString("%1:\n").arg(shaderProg.c_str()));
o_log->append(temp_log);
}
if (isCompiled == GL_FALSE)
isAllCompiled = isCompiled;
}
return isAllCompiled;
}
