bool ShaderLibrary::getMaterialShaders(string shader_list_name, Shader *&vertex_shader, Shader *&pixel_shader, bool no_light, bool no_gi, bool const_tex_coord) {
ShaderList *shader_list=getShaderList(shader_list_name);
if (shader_list) {
ShaderSet *shader_set=shader_list->getShaderSet();
if (shader_set) {
// Pixel Shader
string pixel_shader_name=shader_set->getPixelShaderName();
if (no_light) pixel_shader_name += "_NoLight";
if (no_gi) pixel_shader_name += "_NoGI";
if (const_tex_coord) pixel_shader_name += "_ConstTexCoord";
pixel_shader = getPixelShader(pixel_shader_name);
// Vertex Shader
string vertex_shader_name = shader_set->getVertexShaderName();
if (const_tex_coord) vertex_shader_name += "_ConstTexCoord";
if (vertex_shader_name.size()) {
vertex_shader = getVertexShader(vertex_shader_name);
}
return true;
}
}
return false;
}
void MyView::addShaderProgram(SHADER_TYPE type, std::string vsFile, std::string fsFile){
GLuint program, fs, vs;
program = glCreateProgram();
fs = getFragmentShader(fsFile);
vs = getVertexShader(vsFile);
glAttachShader(program, vs);
glDeleteShader(vs);
glAttachShader(program, fs);
//for (int i = 0; i < fragmentOutputs.size(); i++){
// glBindFragDataLocation(program, i, fragmentOutputs[i].c_str());
//}
glDeleteShader(fs);
glLinkProgram(program);
//test program
GLint link_status = 0;
glGetProgramiv(program, GL_LINK_STATUS, &link_status);
if (link_status != GL_TRUE) {
const int string_length = 1024;
GLchar log[string_length] = "";
glGetProgramInfoLog(program, string_length, NULL, log);
std::cerr << log << std::endl;
}
shaderPrograms_[type] = program;
}
void GLSLProgram::setTransformFeedbackVaryings(const std::vector<String>& nameStrings)
{
// Get program object ID.
GLuint programId;
if (Root::getSingleton().getRenderSystem()->getCapabilities()->hasCapability(RSC_SEPARATE_SHADER_OBJECTS))
{
//TODO include tessellation stages
GLSLShader* glslGpuProgram = getGeometryShader();
if (!glslGpuProgram)
glslGpuProgram = getVertexShader();
programId = glslGpuProgram->getGLProgramHandle();
// force re-link
GpuProgramManager::getSingleton().removeMicrocodeFromCache(glslGpuProgram->_getHash());
glslGpuProgram->setLinked(false);
}
else
{
programId = getGLProgramHandle();
// force re-link
GpuProgramManager::getSingleton().removeMicrocodeFromCache(getCombinedHash());
}
mLinked = false;
// Convert to const char * for GL
std::vector<const char*> names;
for (uint e = 0; e < nameStrings.size(); e++)
{
names.push_back(nameStrings[e].c_str());
}
// TODO replace glTransformFeedbackVaryings with in-shader specification (GL 4.4)
OGRE_CHECK_GL_ERROR(glTransformFeedbackVaryings(programId, nameStrings.size(), &names[0],
GL_INTERLEAVED_ATTRIBS));
#if OGRE_DEBUG_MODE
activate();
// Check if varyings were successfully set.
GLchar Name[64];
GLsizei Length(0);
GLsizei Size(0);
GLenum Type(0);
// bool Validated = false;
for (size_t i = 0; i < nameStrings.size(); i++)
{
OGRE_CHECK_GL_ERROR(
glGetTransformFeedbackVarying(programId, i, 64, &Length, &Size, &Type, Name));
LogManager::getSingleton().stream() << "Varying " << i << ": " << Name << " " << Length
<< " " << Size << " " << Type;
// Validated = (Size == 1) && (Type == GL_FLOAT_VEC3);
// std::cout << Validated << " " << GL_FLOAT_VEC3 << std::endl;
}
#endif
}
const unsigned int ShaderCache::getVertexShader(const tinyxml2::XMLElement* element, const DeviceManager& deviceManager)
{
VertexShader shader;
shader.deserialise(element);
unsigned int resourceName = hashString(getResourceNameFromFileName(shader.getFileName()));
if (getVertexShader(resourceName) == nullptr)
{
if (shader.createShader(deviceManager))
{
m_vertexShaders.emplace(VertexShaderHandle(resourceName, shader));
}
}
return resourceName;
}
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()));
}
