void Shader::PrintLog(char* label, GLint obj)
{
int infoLogLength = 0;
int maxLength;
if (glIsShader(obj)) {
glGetShaderiv(obj, GL_INFO_LOG_LENGTH, &maxLength);
} else {
glGetProgramiv(obj, GL_INFO_LOG_LENGTH, &maxLength);
}
char* infoLog = new char[maxLength];
if (glIsShader(obj)) {
glGetShaderInfoLog(obj, maxLength, &infoLogLength, infoLog);
} else {
glGetProgramInfoLog(obj, maxLength, &infoLogLength, infoLog);
}
if (infoLogLength > 0) {
std::ofstream fout("log.txt");
fout << label << infoLog << std::endl;
fout.close();
// TODO: Replace with a console log
}
delete infoLog;
}
void print_log(GLuint object) {
GLint log_length = 0;
if (glIsShader(object)) {
glGetShaderiv(object, GL_INFO_LOG_LENGTH, &log_length);
}
else if (glIsProgram(object)) {
glGetProgramiv(object, GL_INFO_LOG_LENGTH, &log_length);
}
else {
fprintf(stderr, "printlog: Not a shader or a program\n");
return;
}
char* log = (char*) malloc(log_length);
if (glIsShader(object)) {
glGetShaderInfoLog(object, log_length, NULL, log);
}
else if (glIsProgram(object)) {
glGetProgramInfoLog(object, log_length, NULL, log);
}
fprintf(stderr, "%s", log);
free(log);
}
void PipelineProgram::Clean(bool shadersOnly) {
if (glIsShader(this->vertex->ID)) {
glDetachShader(this->ID, this->vertex->ID);
glDeleteShader(this->vertex->ID);
}
if (glIsShader(this->tesselationControl->ID)) {
glDetachShader(this->ID, this->tesselationControl->ID);
glDeleteShader(this->tesselationControl->ID);
}
if (glIsShader(this->tesselationEvaluation->ID)) {
glDetachShader(this->ID, this->tesselationEvaluation->ID);
glDeleteShader(this->tesselationEvaluation->ID);
}
if (glIsShader(this->geometry->ID)) {
glDetachShader(this->ID, this->geometry->ID);
glDeleteShader(this->geometry->ID);
}
if (glIsShader(this->fragment->ID)) {
glDetachShader(this->ID, this->fragment->ID);
glDeleteShader(this->fragment->ID);
}
if (!shadersOnly) {
if (glIsProgram(this->ID)) {
glDeleteProgram(this->ID);
}
}
}
void ShaderManager::ItlPrintShaderLog(GLuint nGLShaderOrShaderProgram)
{
int iLogLength = 0,
iMaximalLength = 0;
// get maximum length of log
if(glIsShader(nGLShaderOrShaderProgram))
glGetShaderiv(nGLShaderOrShaderProgram, GL_INFO_LOG_LENGTH, &iMaximalLength);
else
glGetProgramiv(nGLShaderOrShaderProgram, GL_INFO_LOG_LENGTH, &iMaximalLength);
// create buffer for messages
char *szInfoLog = new char[iMaximalLength];
// get log messages
if (glIsShader(nGLShaderOrShaderProgram))
glGetShaderInfoLog(nGLShaderOrShaderProgram, iMaximalLength, &iLogLength, szInfoLog);
else
glGetProgramInfoLog(nGLShaderOrShaderProgram, iMaximalLength, &iLogLength, szInfoLog);
// print log messages
if (iLogLength > 1)
Logger::error() << "Shader messages: \n" << szInfoLog << Logger::endl;
// delete buffer
delete[] szInfoLog;
}
void Scene::directIllumination()
{
float eye[3];
float eyedir[3];
float up[3] = {0.0, 1.0, 0.0};
view->getEye(eye);
view->getCenter(eyedir);
drawAtPoint(eye, eyedir, up, directFBOID, windWidth, windHeight);
//glutSwapBuffers();
glIsShader(999);
//std::cin.get();
//glClear(GL_COLOR_BUFFER_BIT);
//glFlush();
// glutSwapBuffers();
//std::cin.get();
//Helpers::getGLErrors("End of directIllumination");
drawAtPoint(eye, eyedir, up, directFBOID, windWidth, windHeight);
//glutSwapBuffers();
glIsShader(999);//debug
}
void Shader::DeleteShader()
{
if (glIsProgram(shaderProgram)) {
if (glIsShader(vertexID)) {
GLCHECKER(glDetachShader(shaderProgram, vertexID));
GLCHECKER(glDeleteShader(vertexID));
// std::cout << "Shader Destroyed: " << shader << std::endl;
}
if (glIsShader(fragmentID)) {
GLCHECKER(glDetachShader(shaderProgram, fragmentID));
GLCHECKER(glDeleteShader(fragmentID));
// std::cout << "Shader Destroyed: " << shader << std::endl;
}
//if (glIsShader(geometryID)) {
// glDetachShader(shaderProgram, geometryID);
// glDeleteShader(geometryID);
// // std::cout << "Shader Destroyed: " << shader << std::endl;
// }
// else std::cout << "Shader Not Found: " << shader << std::endl;
}
// else std::cout << "Shader Program Object Not Found: " << shaderProgram << std::endl;
if (glIsProgram(shaderProgram)) {
GLCHECKER(glDeleteProgram(shaderProgram));
// std::cout << "Shader Program Destroyed: " << *shaderProgram << std::endl;
shaderProgram = 0;
}
// else std::cout << "Shader Program Object Not Found: " << *shaderProgram << std::endl;
}
static void
Init(void)
{
static const char *fragShaderText =
"void main() {\n"
" gl_FragColor = vec4(1.0,0.0,0.0,1.0);\n"
"}\n";
static const char *vertShaderText =
"void main() {\n"
" gl_Position = gl_Vertex;\n"
"}\n";
if (!ShadersSupported())
exit(1);
fragShader = CompileShaderText(GL_FRAGMENT_SHADER, fragShaderText);
vertShader = CompileShaderText(GL_VERTEX_SHADER, vertShaderText);
program = LinkShaders(vertShader, fragShader);
glUseProgram(program);
assert(glGetError() == 0);
glClearColor(0.3f, 0.3f, 0.3f, 1.0f);
printf("GL_RENDERER = %s\n",(const char *) glGetString(GL_RENDERER));
assert(glIsProgram(program));
assert(glIsShader(fragShader));
assert(glIsShader(vertShader));
glColor3f(1, 0, 0);
}
static void
Init(void)
{
if (!ShadersSupported())
exit(1);
vertShader = CompileShaderText(GL_VERTEX_SHADER, VertShaderText);
fragShader = CompileShaderText(GL_FRAGMENT_SHADER, FragShaderText);
program = LinkShaders(vertShader, fragShader);
glUseProgram(program);
SetUniformValues(program, Uniforms);
PrintUniforms(Uniforms);
assert(glGetError() == 0);
glClearColor(0.4f, 0.4f, 0.8f, 0.0f);
printf("GL_RENDERER = %s\n",(const char *) glGetString(GL_RENDERER));
assert(glIsProgram(program));
assert(glIsShader(fragShader));
assert(glIsShader(vertShader));
glColor3f(1, 0, 0);
}
bool GLProgram::_checkStatus(GLuint obj)
{
GLint status = static_cast<GLint>(GL_FALSE), len = 0;
if(glIsShader(obj) == GL_TRUE)
{
glGetShaderiv(obj, GL_COMPILE_STATUS, &status);
}
else if(glIsProgram(obj) == GL_TRUE)
{
glGetProgramiv(obj, GL_LINK_STATUS, &status);
}
if(status == static_cast<GLint>(GL_TRUE))
{
_log = "";
}
else
{
// Set log
if(glIsShader(obj) == GL_TRUE)
{
glGetShaderiv(obj, GL_INFO_LOG_LENGTH, &len);
if (len > 0)
{
GLchar* l = new GLchar[len];
glGetShaderInfoLog(obj, len, NULL, l);
_log = l;
delete[] l;
}
}
else if(glIsProgram(obj) == GL_TRUE)
{
glGetProgramiv(obj, GL_INFO_LOG_LENGTH, &len);
if (len > 0)
{
GLchar* l = new GLchar[len];
glGetProgramInfoLog(obj, len, NULL, l);
_log = l;
delete[] l;
}
}
}
return status;
}
void ClearShaderObject(GLhandleARB GLSL_PO,GLhandleARB Attach_VS,GLhandleARB Attach_TC,GLhandleARB Attach_TE,GLhandleARB Attach_GS,GLhandleARB Attach_PS)
{
if(glIsProgram(GLSL_PO)!=GL_FALSE)
{
if(glIsShader(Attach_VS)!=GL_FALSE){ glDetachObjectARB(GLSL_PO,Attach_VS);}
if(glIsShader(Attach_TC)!=GL_FALSE){ glDetachObjectARB(GLSL_PO,Attach_TC);}
if(glIsShader(Attach_TE)!=GL_FALSE){ glDetachObjectARB(GLSL_PO,Attach_TE);}
if(glIsShader(Attach_GS)!=GL_FALSE){ glDetachObjectARB(GLSL_PO,Attach_GS);}
if(glIsShader(Attach_PS)!=GL_FALSE){ glDetachObjectARB(GLSL_PO,Attach_PS);}
glDeleteObjectARB(GLSL_PO);
}
}
static bool glslIsValid(GLuint obj)
{
const bool isShader = glIsShader(obj);
assert(glIsShader(obj) || glIsProgram(obj));
GLint compiled;
if (isShader)
glGetShaderiv(obj, GL_COMPILE_STATUS, &compiled);
else
glGetProgramiv(obj, GL_LINK_STATUS, &compiled);
return compiled;
}
)delim";
TEST_F(ShaderTest, testShader)
{
GLuint shaderId;
try
{
// Test compilation of valid shader
QS::Shader goodShader(goodShaderSource, GL_VERTEX_SHADER);
EXPECT_EQ(GL_TRUE, glIsShader(goodShader.getShader()));
// Test converstion operator
shaderId = goodShader;
EXPECT_EQ(GL_TRUE, glIsShader(shaderId));
EXPECT_EQ(shaderId, goodShader.getShader());
}
catch(const std::exception &exception)
{
FAIL() << exception.what();
}
catch (...)
{
FAIL();
}
// Test that object destruction deletes the shader.
EXPECT_EQ(GL_FALSE, glIsShader(shaderId));
// Test that errors are caught and the right exception type is thrown.
try
{
QS::Shader badShader(badShaderSource, GL_VERTEX_SHADER);
FAIL() << "Unexpectedly didn't throw exception.";
}
catch (const std::logic_error &exception)
{
EXPECT_STREQ("Failed to compile shader. Errors: (0) : "
"error C0000: syntax error, unexpected $end, "
"expecting \"::\" at token \"<EOF>\"\n",
exception.what());
}
catch (...)
{
FAIL();
}
// Test other types of shader.
EXPECT_NO_THROW(QS::Shader(goodShaderSource, GL_FRAGMENT_SHADER));
EXPECT_NO_THROW(QS::Shader(goodShaderSource, GL_TESS_CONTROL_SHADER));
EXPECT_NO_THROW(QS::Shader(goodShaderSource, GL_TESS_EVALUATION_SHADER));
EXPECT_NO_THROW(QS::Shader(goodShaderSource, GL_GEOMETRY_SHADER));
}
static void CheckStatus( GLuint obj ) {
GLint status = GL_FALSE, len = 10;
if( glIsShader(obj) ) glGetShaderiv ( obj, GL_COMPILE_STATUS, & status );
if( glIsProgram(obj) ) glGetProgramiv( obj, GL_LINK_STATUS, & status );
if( status == GL_TRUE ) return;
if( glIsShader(obj) ) glGetShaderiv ( obj, GL_INFO_LOG_LENGTH, & len );
if( glIsProgram(obj) ) glGetProgramiv( obj, GL_INFO_LOG_LENGTH, & len );
std::vector< char > log( len, 'X' );
if( glIsShader(obj) ) glGetShaderInfoLog ( obj, len, NULL, &log[0] );
if( glIsProgram(obj) ) glGetProgramInfoLog( obj, len, NULL, &log[0] );
std::cerr << & log[0] << std::endl;
exit( -1 );
}
Shader::Shader(const unsigned int vertex_program, const unsigned int fragment_program, const unsigned int geometry_program) : name("") {
if(!glIsShader(vertex_program)) {
throw Exceptions::InvalidVertexShaderException(vertex_program);
}
if(!glIsShader(fragment_program)) {
throw Exceptions::InvalidFragmentShaderException(fragment_program);
}
if(geometry_program != 0 && !glIsShader(geometry_program)) {
throw Exceptions::InvalidGeometryShaderException(geometry_program);
}
program_object = glCreateProgram();
glAttachShader(program_object, vertex_program);
glAttachShader(program_object, fragment_program);
if(geometry_program != 0)
glAttachShader(program_object, geometry_program);
glLinkProgram(program_object);
int is_linked = 0;
glGetProgramiv(program_object, GL_LINK_STATUS, &is_linked);
if(!is_linked)
{
int max_length = 0;
glGetProgramiv(program_object, GL_INFO_LOG_LENGTH, &max_length);
std::vector<char> info_log(max_length);
glGetProgramInfoLog(program_object, max_length, &max_length, &info_log[0]);
std::string output(info_log.begin(), info_log.end());
LOG(ERROR)<<output;
glDeleteProgram(program_object);
throw Exceptions::InvalidShaderProgramException(program_object);
}
if(!glIsProgram(program_object)) {
throw Exceptions::InvalidShaderProgramException(program_object);
}
int count = 0;
glGetProgramiv(program_object, GL_ACTIVE_UNIFORMS, &count);
for(int i = 0; i < count; i++) {
int name_length;
int arr_size;
GLenum type;
GLchar name[64];
glGetActiveUniform(program_object, i, 64, &name_length, &arr_size, &type, name);
int location = glGetUniformLocation(program_object, name);
name_to_location[std::string(name)] = location;
name_to_type[std::string(name)] = type;
LOG(INFO)<<"Uniform found: "<<name<<" Location: "<<location;
}
}
static void createProgram(const char *vertProgFile,
const char *fragProgFile)
{
GLuint fragShader = 0, vertShader = 0;
program = glCreateProgram();
if (vertProgFile) {
vertShader = glCreateShader(GL_VERTEX_SHADER);
readShader(vertShader, vertProgFile);
glAttachShader(program, vertShader);
}
if (fragProgFile) {
fragShader = glCreateShader(GL_FRAGMENT_SHADER);
readShader(fragShader, fragProgFile);
glAttachShader(program, fragShader);
}
glLinkProgram(program);
checkLink(program);
glUseProgram(program);
assert(glIsProgram(program));
assert(glIsShader(fragShader));
assert(glIsShader(vertShader));
checkError(__LINE__);
{ /*texture*/
GLuint texLoc = glGetUniformLocationARB(program, "srcTex");
glUniform1iARB(texLoc, 0);
}
{ /*setup offsets */
float offsets[] = { 1.0 / texture.width, 1.0 / texture.height,
0.0 , 1.0 / texture.height,
-1.0 / texture.width, 1.0 / texture.height,
1.0 / texture.width, 0.0,
0.0 , 0.0,
-1.0 / texture.width, 0.0,
1.0 / texture.width, -1.0 / texture.height,
0.0 , -1.0 / texture.height,
-1.0 / texture.width, -1.0 / texture.height
};
GLuint offsetLoc = glGetUniformLocationARB(program, "Offset");
glUniform2fv(offsetLoc, 9, offsets);
}
setupConvolution();
checkError(__LINE__);
}
ShaderProgram::~ShaderProgram() {
glGetError();
if (glIsShader(m_vertex_shader_id)) {
glDeleteShader(m_vertex_shader_id);
CHECK_ERROR("ShaderProgram::~ShaderProgram", "glDeleteShader(m_vertex_shader_id)");
}
if (glIsShader(m_fragment_shader_id)) {
glDeleteShader(m_fragment_shader_id);
CHECK_ERROR("ShaderProgram::~ShaderProgram", "glDeleteShader(m_fragment_shader_id)");
}
if (glIsProgram(m_program_id)) {
glDeleteProgram(m_program_id);
CHECK_ERROR("ShaderProgram::~ShaderProgram", "glDeleteProgram()");
}
}
std::string getShaderLog(GLuint shader)
{
if (!glIsShader(shader))
{
throw std::runtime_error("Passed ID is not a shader.");
}
int infoLogLength = 0;
int maxLength = 0;
glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &maxLength);
char* infoLog = new char[maxLength];
glGetShaderInfoLog(shader, maxLength, &infoLogLength, infoLog);
if (infoLogLength > 0)
{
std::string log{ infoLog };
delete[] infoLog;
return log;
}
else
{
return{ "" };
}
}
void Shader::printShaderLog(GLuint shader)
{
//Make sure name is shader
if (glIsShader(shader))
{
//Shader log length
int infoLogLength = 0;
int maxLength = infoLogLength;
//Get info string length
glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &maxLength);
//Allocate string
char* infoLog = new char[maxLength];
//Get info log
glGetShaderInfoLog(shader, maxLength, &infoLogLength, infoLog);
if (infoLogLength > 0)
{
//Print Log
printf("%s\n", infoLog);
}
//Deallocate string
delete[] infoLog;
}
else
{
printf("Name %d is not a shader\n", shader);
}
}
void printShaderLog( GLuint shader )
{
int infoLogLength = 0;
int maxLength;
char *infoLog;
//Make sure name is shader
if( glIsShader( shader ) )
{
//Shader log length
maxLength = infoLogLength;
//Get info string length
glGetShaderiv( shader, GL_INFO_LOG_LENGTH, &maxLength );
//Allocate string
infoLog = (char*)malloc(sizeof(char)*maxLength);
//Get info log
glGetShaderInfoLog( shader, maxLength, &infoLogLength, infoLog );
if( infoLogLength > 0 )
{
//Print Log
printf( "%s\n", infoLog );
}
//Deallocate string
free(infoLog);
}
else
{
printf( "Name %d is not a shader\n", shader );
}
}
/** * Writes errors/information messages to stdout. * Gets the InfoLogARB of hObject and messages it. * \param hObject - a handle to the object. * \param bProgram - if true, hObject is a program object, otherwise it is a shader object. * \return true: InfoLogARB non-empty and GLSLPROGRAM_STRICT defined OR only warning, false otherwise * \author <a href="mailto:[email protected]">Jens Schneider</a> * \date Aug.2004 */ bool GLSLProgram::WriteInfoLog(const char* shaderdesc, GLuint hObject, bool bProgram) { // Check for errors GLint iLength; if (bProgram) glGetProgramiv(hObject,GL_INFO_LOG_LENGTH,&iLength); else glGetShaderiv(hObject,GL_INFO_LOG_LENGTH,&iLength); GLboolean bAtMostWarnings=true; if (iLength>1) { char *pcLogInfo=new char[iLength]; if (bProgram) { glGetProgramInfoLog(hObject,iLength,&iLength,pcLogInfo); bAtMostWarnings=glIsProgram(hObject); } else { glGetShaderInfoLog(hObject,iLength,&iLength,pcLogInfo); bAtMostWarnings=glIsShader(hObject); } if (bAtMostWarnings) { WARNING(shaderdesc); WARNING(pcLogInfo); delete[] pcLogInfo; return false; } else { T_ERROR(shaderdesc); T_ERROR(pcLogInfo); delete[] pcLogInfo; #ifdef GLSLPROGRAM_STRICT return true; #endif } } return !bool(bAtMostWarnings==GL_TRUE); // error occured? }
void _glcompiler_error(GLint shader)
{
int len, i;
char* log;
if (!glIsShader(shader))
{
printf("Not a shader object\n");
return;
}
glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &len);
if (len >= 0 && len < 300000)
{
log = (char*) malloc(len + 1);
glGetShaderInfoLog(shader, len, &i, log);
log[len] = 0;
LOG(LOG_ERROR, "COMPILE ERROR: %s \n", log);
free(log);
}
else
{
printf("Failed to get GLES2 compile error. len was %d\n", len);
}
}
virtual ShaderMedia *load(const File &file, bool force = false)
{
GLuint id = 0;
GLint compileStatus = GL_TRUE;
if (file.getExtension() == "vert")
id = glCreateShader(GL_VERTEX_SHADER);
else if (file.getExtension() == "pix")
id = glCreateShader(GL_FRAGMENT_SHADER);
if (id == 0 || !glIsShader(id))
throw LoadingFailed(file.getFullName(), "ShaderLoader failed to create shader.");
const std::string source = file.getFileContent();
const char *sourceChar = source.c_str();
glShaderSource(id, 1, &sourceChar, NULL);
glCompileShader(id);
glGetShaderiv(id, GL_COMPILE_STATUS, &compileStatus);
if (compileStatus != GL_TRUE)
{
GLint l;
glGetShaderiv(id, GL_INFO_LOG_LENGTH, &l);
std::string log(l + 1, '\0');
glGetShaderInfoLog(id, l, &l, &log[0]);
std::cout << std::endl << log;
throw LoadingFailed(file.getFullName(), "ShaderLoader failed to compile shader.\n");
}
return new ShaderMedia(id, file.getFileName(), force);
}
GLuint GLWidget::build_shader(const GLchar *shader_source, GLenum type)
{
GLuint shader = glCreateShader(type);
if (!shader || !glIsShader(shader)) {
return 0;
}
qDebug()<<"GLWidget::build_shader shader: "<<shader<<" glIsShader: "<<glIsShader(shader)
<<" 20: "<<glIsShader(20);
glShaderSource(shader, 1, &shader_source, 0);
glCompileShader(shader);
GLint status;
glGetShaderiv(shader, GL_COMPILE_STATUS, &status);
if (status != GL_TRUE) {
}
return status == GL_TRUE ? shader : 0;
}
static PyObject* py_glIsShader(PyObject *, PyObject *args) {
CHECK_ARG_COUNT(args, 1);
Uint shader(PyTuple_GetItem(args, 0));
PyObject *rv = (glIsShader(shader) == GL_TRUE ? Py_True : Py_False);
Py_INCREF(rv);
return rv;
}
static bool
make_egl_current_and_test(EGLDisplay *dpy, EGLContext ctx)
{
const char *string;
GLuint shader;
bool pass = true;
eglMakeCurrent(dpy, NULL, NULL, ctx);
if (!epoxy_is_desktop_gl()) {
fputs("Claimed to be desktop\n", stderr);
pass = false;
}
if (epoxy_gl_version() < 20) {
fprintf(stderr, "Claimed to be GL version %d\n",
epoxy_gl_version());
pass = false;
}
string = (const char *)glGetString(GL_VERSION);
printf("GL version: %s\n", string);
shader = glCreateShader(GL_FRAGMENT_SHADER);
pass = glIsShader(shader);
return pass;
}
void Shader::Delete() {
if (glIsShader(_shaderObject)) {
glDeleteShader(_shaderObject);
CHECK_GL_ERROR;
}
_shaderObject = 0;
}
ShaderElement::~ShaderElement()
{
if (glIsShader(_shaderId) == GL_TRUE)
{
glDeleteShader(_shaderId);
}
}
Shader(GLenum type, const std::string &filename, const std::string &defines) {
RefCountedPtr<FileSystem::FileData> code = FileSystem::gameDataFiles.ReadFile(filename);
if (!code.Valid())
Error("Could not load %s", filename.c_str());
// Load some common code
RefCountedPtr<FileSystem::FileData> attributesCode = FileSystem::gameDataFiles.ReadFile("shaders/opengl/attributes.glsl");
assert(attributesCode.Valid());
RefCountedPtr<FileSystem::FileData> logzCode = FileSystem::gameDataFiles.ReadFile("shaders/opengl/logz.glsl");
assert(logzCode.Valid());
RefCountedPtr<FileSystem::FileData> libsCode = FileSystem::gameDataFiles.ReadFile("shaders/opengl/lib.glsl");
assert(libsCode.Valid());
AppendSource(s_glslVersion);
AppendSource(defines.c_str());
if (type == GL_VERTEX_SHADER) {
AppendSource("#define VERTEX_SHADER\n");
} else {
AppendSource("#define FRAGMENT_SHADER\n");
}
AppendSource(attributesCode->AsStringRange().StripUTF8BOM());
AppendSource(logzCode->AsStringRange().StripUTF8BOM());
AppendSource(libsCode->AsStringRange().StripUTF8BOM());
AppendSource(code->AsStringRange().StripUTF8BOM());
#if 0
static bool s_bDumpShaderSource = true;
if (s_bDumpShaderSource) {
const char SHADER_OUT_DIR_NAME[] = "shaders";
const char SHADER_OGL_OUT_DIR_NAME[] = "shaders/opengl";
FileSystem::userFiles.MakeDirectory(SHADER_OUT_DIR_NAME);
FileSystem::userFiles.MakeDirectory(SHADER_OGL_OUT_DIR_NAME);
const std::string outFilename(FileSystem::GetUserDir() + "/" + filename);
FILE *tmp = fopen(outFilename.c_str(), "wb");
if(tmp) {
Output("%s", filename);
for( Uint32 i=0; i<blocks.size(); i++ ) {
const char *block = blocks[i];
const GLint sizes = block_sizes[i];
if(block && sizes>0) {
fprintf(tmp, "%.*s", sizes, block);
}
}
fclose(tmp);
} else {
Output("Could not open file %s", outFilename.c_str());
}
}
#endif
shader = glCreateShader(type);
if(glIsShader(shader)!=GL_TRUE)
throw ShaderException();
Compile(shader);
// CheckGLSL may use OS::Warning instead of Error so the game may still (attempt to) run
if (!check_glsl_errors(filename.c_str(), shader))
throw ShaderException();
};
const bool GPUQuery::isShader(const GLuint shader)
{
const bool is(glIsShader(shader) == GL_TRUE);
if(!is)
glGetError();
return is;
}
GC3Dboolean GraphicsContext3D::isShader(Platform3DObject shader)
{
if (!shader)
return GL_FALSE;
makeContextCurrent();
return glIsShader(shader);
}
