int shader_log(GLuint shader, const char *name)
{
shader_debug("=== %s ===\n", name);
GLint status = 0;
glGetShaderiv(shader, GL_COMPILE_STATUS, &status);
if(status == GL_FALSE) {
shader_error("Compilation of %s failed\n", name);
}
GLint len = 0;
glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &len);
if(len > 0) {
GLchar *msg = (GLchar *) malloc(len);
glGetShaderInfoLog(shader, len, &len, msg);
/* TODO: readline() and output for each line */
if(status == GL_FALSE) {
shader_error("%s", msg);
} else {
shader_debug("%s", msg);
}
free(msg);
}
if(status == GL_FALSE) {
glDeleteShader(shader);
return SHADER_COMPILE_ERROR;
}
return SHADER_OK;
}
GLuint create_program(GLuint vertex_shader, GLuint fragment_shader) {
if (vertex_shader == 0 || fragment_shader == 0) {
if(vertex_shader == 0) {
fputs("Received NULL vertex shader", stderr);
}
if(fragment_shader == 0) {
fputs("Received NULL fragment shader", stderr);
}
exit(1);
}
// Link the program
printf("Linking program\n");
GLuint ProgramID = glCreateProgram();
glAttachShader(ProgramID, vertex_shader);
glAttachShader(ProgramID, fragment_shader);
glLinkProgram(ProgramID);
// Check the program
GLint compile_ok = GL_FALSE;
glGetProgramiv(ProgramID, GL_LINK_STATUS, &compile_ok);
if (compile_ok == GL_FALSE) {
fprintf(stderr, "Failed to link: ");
shader_error(ProgramID);
exit(1);
}
glDeleteShader(vertex_shader);
glDeleteShader(fragment_shader);
return ProgramID;
}
/**
* Compile the shader from file 'filename', with error handling
*/
GLuint create_shader(const char* filename, GLenum type) {
GLuint shader = glCreateShader(type);
char const * source = read_file(filename);
if (source == NULL) {
fprintf(stderr, "Error opening %s: ", filename);
perror("");
return 0;
}
glShaderSource(shader, 1, &source, NULL);
glCompileShader(shader);
free((char*) source);
GLint compile_ok = GL_FALSE;
glGetShaderiv(shader, GL_COMPILE_STATUS, &compile_ok);
if (compile_ok == GL_FALSE) {
fprintf(stderr, "%s: ", filename);
shader_error(shader);
glDeleteShader(shader);
return 0;
}
printf("Shader '%s' compiled successfully\n", filename);
return shader;
}
static GLboolean brwProgramStringNotify( GLcontext *ctx,
GLenum target,
struct gl_program *prog )
{
struct brw_context *brw = brw_context(ctx);
int i;
if (target == GL_FRAGMENT_PROGRAM_ARB) {
struct gl_fragment_program *fprog = (struct gl_fragment_program *) prog;
struct brw_fragment_program *newFP = brw_fragment_program(fprog);
const struct brw_fragment_program *curFP =
brw_fragment_program_const(brw->fragment_program);
if (fprog->FogOption) {
_mesa_append_fog_code(ctx, fprog);
fprog->FogOption = GL_NONE;
}
if (newFP == curFP)
brw->state.dirty.brw |= BRW_NEW_FRAGMENT_PROGRAM;
newFP->id = brw->program_id++;
newFP->isGLSL = brw_wm_is_glsl(fprog);
}
else if (target == GL_VERTEX_PROGRAM_ARB) {
struct gl_vertex_program *vprog = (struct gl_vertex_program *) prog;
struct brw_vertex_program *newVP = brw_vertex_program(vprog);
const struct brw_vertex_program *curVP =
brw_vertex_program_const(brw->vertex_program);
if (newVP == curVP)
brw->state.dirty.brw |= BRW_NEW_VERTEX_PROGRAM;
if (newVP->program.IsPositionInvariant) {
_mesa_insert_mvp_code(ctx, &newVP->program);
}
newVP->id = brw->program_id++;
/* Also tell tnl about it:
*/
_tnl_program_string(ctx, target, prog);
}
/* Reject programs with subroutines, which are totally broken at the moment
* (all program flows return when any program flow returns, and
* the VS also hangs if a function call calls a function.
*
* See piglit glsl-{vs,fs}-functions-[23] tests.
*/
for (i = 0; i < prog->NumInstructions; i++) {
if (prog->Instructions[i].Opcode == OPCODE_CAL) {
shader_error(ctx, prog,
"i965 driver doesn't yet support uninlined function "
"calls. Move to using a single return statement at "
"the end of the function to work around it.");
return GL_FALSE;
}
}
return GL_TRUE;
}
void ShaderProgram::check_shader_compilation(GLuint shader_id){
GLint result = GL_FALSE;
int log_length;
glGetShaderiv(shader_id, GL_COMPILE_STATUS, &result);
glGetShaderiv(shader_id, GL_INFO_LOG_LENGTH, &log_length);
std::vector<GLchar> shader_error((log_length > 1) ? log_length : 1);
glGetShaderInfoLog(shader_id, log_length, NULL, &shader_error[0]);
std::cout << &shader_error[0] << std::endl;
}
struct uniform* shader_uniform_create(struct shader *s, const char *name)
{
int index = shader_uniform_idx_next(s);
if (index < 0) {
shader_error("UNIFORMS_MAX reached\n");
return SHADER_UNIFORMS_MAX_ERROR;
}
struct uniform *u = (struct uniform *) malloc(sizeof(struct uniform));
if (u == NULL) {
shader_error("Out of memory");
return SHADER_OOM_ERROR;
}
strcpy(u->name, name);
s->uniforms[index] = u;
return u;
}
void checkShaderError(const std::string& fileName, sgl::SGL_HRESULT err)
{
switch(err)
{
case sgl::SGLERR_FILE_NOT_FOUND:
throw file_error(AUTO_LOGGER, "Couldn't find file: " + fileName);
case sgl::SGLERR_INVALID_CALL:
throw shader_error(AUTO_LOGGER, fileName + ":" + sglGetErrorMsg() );
default:
return;
}
}
shader_program::shader_program(const std::string &vsrc, const std::string &fsrc)
: program_object_(0)
, vertex_object_(0)
, fragment_object_(0)
, block_()
, attr_color_mod_(0)
, attr_submerge_(0)
, attr_effects_(0)
, uni_overlay_(0)
, overlay_image_()
, refcount_(new unsigned(1))
{
vertex_object_ = GPU_LoadShader(GPU_VERTEX_SHADER, vsrc.c_str());
if (!vertex_object_) {
throw shader_error("Failed to compile vertex shader");
}
fragment_object_ = GPU_LoadShader(GPU_FRAGMENT_SHADER, fsrc.c_str());
if (!fragment_object_) {
throw shader_error("Failed to compile fragment shader");
}
program_object_ = GPU_LinkShaders(vertex_object_, fragment_object_);
if (!program_object_) {
throw shader_error("Failed to link shader program");
}
attr_color_mod_ = GPU_GetAttributeLocation(program_object_,
"vert_color_mod");
attr_submerge_ = GPU_GetAttributeLocation(program_object_,
"vert_submerge");
attr_effects_ = GPU_GetAttributeLocation(program_object_,
"vert_effects");
uni_overlay_ = GPU_GetUniformLocation(program_object_, "overlay");
set_color_mod(0, 0, 0, 0);
set_submerge(0);
set_effects(0);
}
int shader_program_log(GLuint program, const char *name)
{
shader_debug("=== %s ===\n", name);
GLint status = 0;
glGetProgramiv(program, GL_LINK_STATUS, &status);
if(status == GL_FALSE) {
shader_error("Link failed\n");
}
GLint len = 0;
glGetProgramiv(program, GL_INFO_LOG_LENGTH, &len);
if(len > 0) {
GLchar *msg = (GLchar *) malloc(len);
glGetProgramInfoLog(program, len, &len, msg);
/* TODO: readline() and output for each line */
if(status == GL_FALSE) {
shader_error("%s", msg);
} else {
shader_debug("%s", msg);
}
free(msg);
}
GLint uniforms = 0;
glGetProgramiv(program, GL_ACTIVE_UNIFORMS, &uniforms);
shader_debug("%d active uniforms\n", uniforms);
if(status == GL_FALSE) {
return SHADER_LINK_ERROR;
}
return SHADER_OK;
}
static GLboolean brwProgramStringNotify( struct gl_context *ctx,
GLenum target,
struct gl_program *prog )
{
struct brw_context *brw = brw_context(ctx);
int i;
if (target == GL_FRAGMENT_PROGRAM_ARB) {
struct gl_fragment_program *fprog = (struct gl_fragment_program *) prog;
struct brw_fragment_program *newFP = brw_fragment_program(fprog);
const struct brw_fragment_program *curFP =
brw_fragment_program_const(brw->fragment_program);
struct gl_shader_program *shader_program;
if (newFP == curFP)
brw->state.dirty.brw |= BRW_NEW_FRAGMENT_PROGRAM;
newFP->id = brw->program_id++;
/* Don't reject fragment shaders for their Mesa IR state when we're
* using the new FS backend.
*/
shader_program = _mesa_lookup_shader_program(ctx, prog->Id);
if (shader_program
&& shader_program->_LinkedShaders[MESA_SHADER_FRAGMENT]) {
return GL_TRUE;
}
}
else if (target == GL_VERTEX_PROGRAM_ARB) {
struct gl_vertex_program *vprog = (struct gl_vertex_program *) prog;
struct brw_vertex_program *newVP = brw_vertex_program(vprog);
const struct brw_vertex_program *curVP =
brw_vertex_program_const(brw->vertex_program);
if (newVP == curVP)
brw->state.dirty.brw |= BRW_NEW_VERTEX_PROGRAM;
if (newVP->program.IsPositionInvariant) {
_mesa_insert_mvp_code(ctx, &newVP->program);
}
newVP->id = brw->program_id++;
/* Also tell tnl about it:
*/
_tnl_program_string(ctx, target, prog);
}
/* Reject programs with subroutines, which are totally broken at the moment
* (all program flows return when any program flow returns, and
* the VS also hangs if a function call calls a function.
*
* See piglit glsl-{vs,fs}-functions-[23] tests.
*/
for (i = 0; i < prog->NumInstructions; i++) {
struct prog_instruction *inst = prog->Instructions + i;
int r;
if (prog->Instructions[i].Opcode == OPCODE_CAL) {
shader_error(ctx, prog,
"i965 driver doesn't yet support uninlined function "
"calls. Move to using a single return statement at "
"the end of the function to work around it.\n");
return GL_FALSE;
}
if (prog->Instructions[i].Opcode == OPCODE_RET) {
shader_error(ctx, prog,
"i965 driver doesn't yet support \"return\" "
"from main().\n");
return GL_FALSE;
}
for (r = 0; r < _mesa_num_inst_src_regs(inst->Opcode); r++) {
if (prog->Instructions[i].SrcReg[r].RelAddr &&
prog->Instructions[i].SrcReg[r].File == PROGRAM_INPUT) {
shader_error(ctx, prog,
"Variable indexing of shader inputs unsupported\n");
return GL_FALSE;
}
}
if (target == GL_FRAGMENT_PROGRAM_ARB &&
prog->Instructions[i].DstReg.RelAddr &&
prog->Instructions[i].DstReg.File == PROGRAM_OUTPUT) {
shader_error(ctx, prog,
"Variable indexing of FS outputs unsupported\n");
return GL_FALSE;
}
if (target == GL_FRAGMENT_PROGRAM_ARB) {
if ((prog->Instructions[i].DstReg.RelAddr &&
prog->Instructions[i].DstReg.File == PROGRAM_TEMPORARY) ||
(prog->Instructions[i].SrcReg[0].RelAddr &&
prog->Instructions[i].SrcReg[0].File == PROGRAM_TEMPORARY) ||
(prog->Instructions[i].SrcReg[1].RelAddr &&
prog->Instructions[i].SrcReg[1].File == PROGRAM_TEMPORARY) ||
(prog->Instructions[i].SrcReg[2].RelAddr &&
prog->Instructions[i].SrcReg[2].File == PROGRAM_TEMPORARY)) {
shader_error(ctx, prog,
"Variable indexing of variable arrays in the FS "
"unsupported\n");
return GL_FALSE;
}
}
}
return GL_TRUE;
}
