void Shader::LinkShaders() {
GLuint program_object_id = glCreateProgram();
GLint link_status;
assert(program_object_id != 0);
glAttachShader(program_object_id, this->vertex);
glAttachShader(program_object_id, this->fragment);
glLinkProgram(program_object_id);
glGetProgramiv(program_object_id, GL_LINK_STATUS, &link_status);
if (LOGGING_ON) {
DEBUG_LOG_WRITE_D(TAG, "Results of linking program:");
log_program_info_log(program_object_id);
}
assert(link_status != 0);
DEBUG_LOG_PRINT_D(TAG, "Results of linking program: %d %d", program_object_id ,this->GetProgram());
validate_program(program_object_id);
this->SetProgram(program_object_id);
//this->SetProgram(1000);
//this->program = program_object_id;
//this->program = 0;
}
void parse_command_line(const std::string &cmd,
std::string &my_program,
std::vector<std::string> &my_args,
std::string &my_stdin,
std::string &my_stdout,
std::string &my_stderr,
std::ofstream &logfile) {
std::stringstream ss(cmd);
std::string tmp;
bool bare_double_dash = false;
while (ss >> tmp) {
assert (tmp.size() >= 1);
// grab the program name
if (my_program == "") {
assert (my_args.size() == 0);
// program name
my_program = tmp;
validate_program(my_program);
}
// grab the arguments
else {
assert (my_program != "");
// look for the bare double dash
if (tmp == "--") {
assert (bare_double_dash == false);
bare_double_dash = true;
my_args.push_back(tmp);
}
// look for stdin/stdout/stderr
else if (tmp.size() >= 1 && tmp.substr(0,1) == "<") {
assert (my_stdin == "");
if (tmp.size() == 1) {
ss >> tmp; bool success = ss.good();
assert (success);
my_stdin = tmp;
} else {
my_stdin = tmp.substr(1,tmp.size()-1);
}
validate_filename(my_stdin);
}
/**
init will take a vertex shader file and fragment shader file, and then attempt to create a valid
shader program from these. It will also check for any shader compilation issues along the way.
*/
void Shader::init(const char *vsFile, const char *fsFile) {
if (inited) // If we have already initialized the shader
return;
inited = true; // Mark that we have initialized the shader
shader_vp = glCreateShader(GL_VERTEX_SHADER); // Create a vertex shader
shader_fp = glCreateShader(GL_FRAGMENT_SHADER); // Create a fragment shader
std::string vsText = text_file_read(vsFile); // Read in the vertex shader
std::string fsText = text_file_read(fsFile); // Read in the fragment shader
const char *vertexText = vsText.c_str();
const char *fragmentText = fsText.c_str();
if (vertexText == NULL) {
std::cout << "vertex shader shader file not found." << std::endl; // Output the error
return;
}
if (fragmentText == NULL) {
std::cout << "fragment shader file not found." << std::endl; // Output the error
return;
}
glShaderSource(shader_vp, 1, &vertexText, 0); // Set the source for the vertex shader to the loaded text
glCompileShader(shader_vp); // Compile the vertex shader
validate_shader(shader_vp, vsFile); // Validate the vertex shader
glShaderSource(shader_fp, 1, &fragmentText, 0); // Set the source for the fragment shader to the loaded text
glCompileShader(shader_fp); // Compile the fragment shader
validate_shader(shader_fp, fsFile); // Validate the fragment shader
shader_id = glCreateProgram(); // Create a GLSL program
glAttachShader(shader_id, shader_vp); // Attach a vertex shader to the program
glAttachShader(shader_id, shader_fp); // Attach the fragment shader to the program
glBindAttribLocation(shader_id, 0, "in_Position"); // Bind a constant attribute location for positions of vertices
glBindAttribLocation(shader_id, 1, "in_Color"); // Bind another constant attribute location, this time for color
glLinkProgram(shader_id); // Link the vertex and fragment shaders in the program
validate_program(shader_id); // Validate the shader program
}
void GLAPIENTRY
_mesa_ValidateProgramARB(GLhandleARB program)
{
GET_CURRENT_CONTEXT(ctx);
validate_program(ctx, program);
}
void MyView::
windowViewWillStart(std::shared_ptr<tygra::Window> window)
{
assert(scene_ != nullptr);
glEnable(GL_TEXTURE_2D);
//shadow maps
glGenTextures(1, &shadowMap_tex_);
glBindTexture(GL_TEXTURE_2D_ARRAY, shadowMap_tex_);
glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexImage3D(GL_TEXTURE_2D_ARRAY, 0, GL_DEPTH_COMPONENT16, 1024, 1024, 5, 0, GL_DEPTH_COMPONENT, GL_FLOAT, 0); //the 256 is number of layers, change this to number of shadow casting lights
glGenFramebuffers(1, &shadowMap_fbo_);
glBindFramebuffer(GL_FRAMEBUFFER, shadowMap_fbo_);
glFramebufferTexture(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, shadowMap_tex_, 0);
glDrawBuffer(GL_NONE); // No color buffer is drawn to.
check_fbo();
shadowMap_program_ = glCreateProgram();
GLuint fs = getFragmentShader("shadowMap_fs.glsl");
GLuint vs = getVertexShader("shadowMap_vs.glsl");
glAttachShader(shadowMap_program_, vs);
glDeleteShader(vs);
glAttachShader(shadowMap_program_, fs);
glDeleteShader(fs);
glLinkProgram(shadowMap_program_);
//test program
GLint link_status = 0;
glGetProgramiv(shadowMap_program_, GL_LINK_STATUS, &link_status);
if (link_status != GL_TRUE) {
const int string_length = 1024;
GLchar log[string_length] = "";
glGetProgramInfoLog(shadowMap_program_, string_length, NULL, log);
std::cerr << log << std::endl;
}
//ssma textures
glGenTextures(1, &albedo_tex);
glBindTexture(GL_TEXTURE_2D, albedo_tex);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA32F, SCREEN_WIDTH, SCREEN_HEIGHT, 0, GL_RGBA, GL_FLOAT, 0);
glGenTextures(1, &edge_tex);
glBindTexture(GL_TEXTURE_2D, edge_tex);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA32F, SCREEN_WIDTH, SCREEN_HEIGHT, 0, GL_RGBA, GL_FLOAT, 0);
glGenTextures(1, &blend_tex);
glBindTexture(GL_TEXTURE_2D, blend_tex);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA32F, SCREEN_WIDTH, SCREEN_HEIGHT, 0, GL_RGBA, GL_FLOAT, 0);
unsigned char* buffer = 0;
FILE* f = 0;
buffer = new unsigned char[1024 * 1024];
f = fopen((app_path + "smaa_area.raw").c_str(), "rb"); //rb stands for "read binary file"
if (!f)
{
std::cerr << "Couldn't open smaa_area.raw.\n";
exit(1);
}
fread(buffer, AREATEX_WIDTH * AREATEX_HEIGHT * 2, 1, f);
fclose(f);
f = 0;
glGenTextures(1, &area_tex);
glBindTexture(GL_TEXTURE_2D, area_tex);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RG8, (GLsizei)AREATEX_WIDTH, (GLsizei)AREATEX_HEIGHT, 0, GL_RG, GL_UNSIGNED_BYTE, buffer);
f = fopen((app_path + "smaa_search.raw").c_str(), "rb");
if (!f)
{
std::cerr << "Couldn't open smaa_search.raw.\n";
exit(1);
}
fread(buffer, SEARCHTEX_WIDTH * SEARCHTEX_HEIGHT, 1, f);
fclose(f);
f = 0;
glGenTextures(1, &search_tex);
glBindTexture(GL_TEXTURE_2D, search_tex);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexImage2D(GL_TEXTURE_2D, 0, GL_R8, (GLsizei)SEARCHTEX_WIDTH, (GLsizei)SEARCHTEX_HEIGHT, 0, GL_RED, GL_UNSIGNED_BYTE, buffer);
delete[] buffer;
get_opengl_error();
/*
* Initialize FBOs
*/
GLenum modes[] = { GL_COLOR_ATTACHMENT0 };
glGenFramebuffers(1, &albedo_fbo);
glBindFramebuffer(GL_FRAMEBUFFER, albedo_fbo);
glDrawBuffers(1, modes);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, albedo_tex, 0);
check_fbo();
glGenFramebuffers(1, &edge_fbo);
glBindFramebuffer(GL_FRAMEBUFFER, edge_fbo);
glDrawBuffers(1, modes);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, edge_tex, 0);
check_fbo();
glGenFramebuffers(1, &blend_fbo);
glBindFramebuffer(GL_FRAMEBUFFER, blend_fbo);
glDrawBuffers(1, modes);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, blend_tex, 0);
check_fbo();
glBindFramebuffer(GL_FRAMEBUFFER, 0);
glBindTexture(GL_TEXTURE_2D, 0);
get_opengl_error();
/*
* Set up shaders
*/
/*
* EDGE SHADER
*/
create_shader(&edge_vs, &edge_ps, &edge_shader);
//SET UNIFORMS
glUseProgram(edge_shader);
glUniform1i(glGetUniformLocation(edge_shader, "albedo_tex"), 0);
glUseProgram(0);
//VALIDATE
validate_program(edge_shader);
get_opengl_error();
/*
* BLEND SHADER
*/
create_shader(&blend_vs, &blend_ps, &blend_shader);
//SET UNIFORMS
glUseProgram(blend_shader);
glUniform1i(glGetUniformLocation(blend_shader, "edge_tex"), 0);
glUniform1i(glGetUniformLocation(blend_shader, "area_tex"), 1);
glUniform1i(glGetUniformLocation(blend_shader, "search_tex"), 2);
glUseProgram(0);
//VALIDATE
validate_program(blend_shader);
get_opengl_error();
/*
* NEIGHBORHOOD SHADER
*/
create_shader(&neighborhood_vs, &neighborhood_ps, &neighborhood_shader);
//SET UNIFORMS
glUseProgram(neighborhood_shader);
glUniform1i(glGetUniformLocation(neighborhood_shader, "albedo_tex"), 0);
glUniform1i(glGetUniformLocation(neighborhood_shader, "blend_tex"), 1);
glUseProgram(0);
//VALIDATE
validate_program(neighborhood_shader);
get_opengl_error();
//anything that is done once on load goes here
materialCount_ = scene_->getAllMaterials().size();
spotLightCount_ = scene_->getAllSpotLights().size();
pointLightCount_ = scene_->getAllPointLights().size();
directionalLightCount_ = scene_->getAllDirectionalLights().size();
loadShaders();
loadMeshes();
loadUniformBuffers();
glEnable(GL_CULL_FACE);
glClearColor(0.f, 0.f, 0.25f, 0.f);
//GBUFER TEXTURES
glGenTextures(1, &gbuffer_position_tex_);
glGenTextures(1, &gbuffer_normal_tex_);
glGenTextures(1, &gbuffer_matColour_tex_);
glGenFramebuffers(1, &lbuffer_fbo_);
glGenRenderbuffers(1, &lbuffer_colour_rbo_);
glGenFramebuffers(1, &gbuffer_fbo_);
glGenRenderbuffers(1, &gbuffer_depth_rbo_);
//only need to set this once
glUseProgram(shaderPrograms_[AMBIENT_LIGHT]);
GLuint ambient = glGetUniformLocation(shaderPrograms_[AMBIENT_LIGHT], "ambientLight");
glUniform3fv(ambient, 1, glm::value_ptr(scene_->getAmbientLightIntensity()));
}
void Program::validate() const
{
// #if DEBUG
validate_program(_program, _debug_name.c_str());
// #endif
}
