//Called to update the display.
//You should call glutSwapBuffers after all of your rendering to display what you rendered.
//If you need continuous updates of the screen, call glutPostRedisplay() at the end of the function.
void display()
{
glClearColor(0.0f, 0.5f, 0.3f, 0.0f);
glClear(GL_COLOR_BUFFER_BIT);
glActiveTexture(GL_TEXTURE0 + g_gammaRampTextureUnit);
glBindTexture(GL_TEXTURE_2D, g_textures[g_useGammaCorrect[0] ? 1 : 0]);
glBindSampler(g_gammaRampTextureUnit, g_samplerObj);
glBindVertexArray(g_vao);
glUseProgram(g_noGammaProgram);
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
glBindTexture(GL_TEXTURE_2D, g_textures[g_useGammaCorrect[1] ? 1 : 0]);
glUseProgram(g_gammaProgram);
glDrawArrays(GL_TRIANGLE_STRIP, 4, 4);
glBindVertexArray(0);
glUseProgram(0);
glActiveTexture(GL_TEXTURE0 + g_gammaRampTextureUnit);
glBindTexture(GL_TEXTURE_2D, 0);
glBindSampler(g_gammaRampTextureUnit, 0);
glutSwapBuffers();
}
void GraphicsSubsystem::drawPlane(const Plane &plane, const std::string &textureName)
{
int planepr = shaders["plane"];
glUseProgram(shaders["plane"]);
glm::mat4 modelToWorld = plane.getModelToWorldMat();
glm::mat3 normMatrix = glm::mat3(glm::transpose(glm::inverse(worldToCam * modelToWorld)));
glUniformMatrix3fv(programUniforms[planepr]["normalModelToCameraMatrix"], 1, GL_FALSE, glm::value_ptr(normMatrix));
glUniformMatrix4fv(programUniforms[planepr]["modelToWorldMatrix"], 1, GL_FALSE, glm::value_ptr(modelToWorld));
glUniformMatrix4fv(programUniforms[planepr]["modelToLightToClipMatrix"], NUMBER_OF_LIGHTS, GL_FALSE, glm::value_ptr(modelLightWorldClip[0]));
glm::vec2 textureScale = plane.getTextureScale();
glUniform2f(programUniforms[planepr]["textureScale"], textureScale.x, textureScale.y);
glUniform2f(programUniforms[planepr]["shadowTexSize"], windowSize.x, windowSize.y);
glUniform1i(programUniforms[planepr]["colorTexture"], texUnits[textureName]);
for (int i = 0; i < NUMBER_OF_LIGHTS; i++)
{
glActiveTexture(GL_TEXTURE0 + shadowTexUnit[i]);
glBindTexture(GL_TEXTURE_2D, shadowMapTextures[i]);
}
glActiveTexture(GL_TEXTURE0 + texUnits[textureName]);
glBindTexture(GL_TEXTURE_2D, textures[textureName]);
glBindSampler(texUnits[textureName], sampler);
plane.draw();
glBindSampler(texUnits[textureName], 0);
glBindTexture(GL_TEXTURE_2D, 0);
glUseProgram(0);
}
GLUSboolean display(GLUSfloat time)
{
glClearColor(0.75f, 0.75f, 1.0f, 1.0f);
glClearDepth(1.0f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
g_camTimer.Update(time);
float cyclicAngle = g_camTimer.GetAlpha() * 6.28f;
float hOffset = cosf(cyclicAngle) * 0.25f;
float vOffset = sinf(cyclicAngle) * 0.25f;
GLfloat modelViewMatrix[16];
glusMatrix4x4LookAtf(modelViewMatrix ,
hOffset, 1.0f, -64.0f,
hOffset, -5.0f + vOffset, -44.0f,
0.0f, 1.0f, 0.0f);
glUseProgram(g_program.program);
glUniformMatrix4fv(g_program.modelViewUnif, 1, GL_FALSE, modelViewMatrix);
glActiveTexture(GL_TEXTURE0 + g_colorTexUnit);
glBindTexture(GL_TEXTURE_2D, g_useMipmapTexture ? g_mipmapTestTexture : g_checkerTexture);
glBindSampler(g_colorTexUnit, g_samplers[g_currSampler]);
Mesh *mesh = g_drawCorridor ? g_pCorridor : g_pPlane;
mesh->render("tex");
glBindSampler(g_colorTexUnit, 0);
glBindTexture(GL_TEXTURE_2D, 0);
glUseProgram(0);
return GLUS_TRUE;
}
void GraphicsSubsystem::drawBall(const Sphere &ball)
{
GLuint ballpr = shaders["ball"];
glUseProgram(ballpr);
glm::mat4 modelToWorld = ball.getModelToWorldMat();
glm::mat3 normWorldMatrix = glm::mat3(glm::transpose(glm::inverse(modelToWorld)));
glm::mat3 normCamMatrix = glm::mat3(glm::transpose(glm::inverse(worldToCam * modelToWorld)));
glUniformMatrix4fv(programUniforms[ballpr]["modelToWorldMatrix"], 1, GL_FALSE, glm::value_ptr(modelToWorld));
glUniformMatrix3fv(programUniforms[ballpr]["normalModelToWorldMatrix"], 1, GL_FALSE, glm::value_ptr(normWorldMatrix));
glUniformMatrix3fv(programUniforms[ballpr]["normalModelToCameraMatrix"], 1, GL_FALSE, glm::value_ptr(normCamMatrix));
glm::mat4 worldToLightMatrix = glm::scale(glm::mat4(1.0), glm::vec3(IBLscale));
glm::mat3 worldToLightITMatrix = glm::mat3(glm::transpose(glm::inverse(worldToLightMatrix)));
glUniformMatrix4fv(programUniforms[ballpr]["worldToLightMatrix"], 1, GL_FALSE, glm::value_ptr(worldToLightMatrix));
glUniformMatrix3fv(programUniforms[ballpr]["worldToLightITMatrix"], 1, GL_FALSE, glm::value_ptr(worldToLightITMatrix));
glUniform3f(programUniforms[ballpr]["camPos"], camPos.x, camPos.y, camPos.z);
glActiveTexture(GL_TEXTURE0 + texUnits["roomBall"]);
glBindTexture(GL_TEXTURE_CUBE_MAP, textures["roomBall"]);
glActiveTexture(GL_TEXTURE0 + texUnits["ball"]);
glBindTexture(GL_TEXTURE_2D, textures["ball"]);
glBindSampler(texUnits["ball"], sampler);
ball.draw();
glBindSampler(texUnits["ball"], 0);
glBindTexture(GL_TEXTURE_CUBE_MAP, 0);
glBindTexture(GL_TEXTURE_2D, 0);
glUseProgram(0);
}
bool render()
{
glm::vec2 WindowSize(this->getWindowSize());
glm::mat4 Projection = glm::perspective(glm::pi<float>() * 0.25f, WindowSize.x / WindowSize.y, 0.1f, 1000.0f);
glm::mat4 Model = glm::mat4(1.0f);
glm::mat4 MVP = Projection * this->view() * Model;
glViewport(0, 0, static_cast<GLsizei>(WindowSize.x), static_cast<GLsizei>(WindowSize.y));
glClearBufferfv(GL_COLOR, 0, &glm::vec4(1.0f, 0.5f, 0.0f, 1.0f)[0]);
glUseProgram(ProgramName);
glUniformMatrix4fv(UniformMVP, 1, GL_FALSE, &MVP[0][0]);
glUniform1i(UniformDiffuseRGB, 0);
glUniform1i(UniformDiffuseBGR, 1);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, TextureName[texture::RGB]);
glBindSampler(0, SamplerName);
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_2D, TextureName[texture::BGR]);
glBindSampler(1, SamplerName);
glBindVertexArray(VertexArrayName);
glDrawElementsInstancedBaseVertex(GL_TRIANGLES, ElementCount, GL_UNSIGNED_INT, nullptr, 1, 0);
return true;
}
/// Sampler ///
void Context::bindSampler( int unit, const StrongRef<Sampler>& sampler )
{
if(sampler)
glBindSampler(unit, sampler->handle());
else
glBindSampler(unit, 0);
m_Samplers[unit] = sampler;
}
virtual void bindMaterial(Material *m) override
{
material_ = m;
glActiveTexture(GL_TEXTURE0+0);
material_->bindTexture();
glBindSampler(0, material_->textures_.front()->id_);
glActiveTexture(GL_TEXTURE0+2);
shadowTex_->bind();
glBindSampler(2, shadowTex_->id_);
}
void init(void)
{
glClearColor(0.3, 0.3, 0.3, 1);
glGenVertexArrays(1, &vao_quad);
glBindVertexArray(vao_quad);
#define N 30
GLfloat vertices[4][4] = {
{ -0.90, -0.90, 0, N },
{ 0.90, -0.90, N, N },
{ -0.90, 0.90, 0, 0 },
{ 0.90, 0.90, N, 0 },
};
glGenBuffers(1, &buf_quad);
glBindBuffer(GL_ARRAY_BUFFER, buf_quad);
glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
GLuint h_prog = build_program_from_files("quad_tex_mipmap.vert", "quad_tex_mipmap.frag");
glUseProgram(h_prog);
glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, sizeof(GLfloat)*4, BUFFER_OFFSET(0));
glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, sizeof(GLfloat)*4, BUFFER_OFFSET(sizeof(GLfloat)*2));
glEnableVertexAttribArray(0);
glEnableVertexAttribArray(1);
glm::mat4 M = glm::rotate(glm::mat4(1.0f), -85.0f, glm::vec3(1.0f, 0.0f, 0.0f));
glm::mat4 V = glm::translate(glm::mat4(1.0f), glm::vec3(0.0f, 0.0f, -1.0f));
glm::mat4 P = glm::perspective(45.0f, 1.0f, 0.1f, 5.0f);
glUniformMatrix4fv(glGetUniformLocation(h_prog, "MVP"), 1, GL_FALSE, glm::value_ptr(P*V*M));
glUniform4f(glGetUniformLocation(h_prog, "color"), 1, 1, .5, .5);
glUniform1i(glGetUniformLocation(h_prog, "tex"), 4);
glEnable(GL_CULL_FACE);
load_textures();
glGenSamplers(1, &sampler);
glSamplerParameteri(sampler, GL_TEXTURE_WRAP_S, GL_REPEAT);
glSamplerParameteri(sampler, GL_TEXTURE_WRAP_T, GL_REPEAT);
// glSamplerParameteri(sampler, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glSamplerParameteri(sampler, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
// glSamplerParameteri(sampler, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
// glSamplerParameteri(sampler, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_NEAREST);
// glSamplerParameteri(sampler, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_NEAREST);
// glSamplerParameteri(sampler, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_LINEAR);
glSamplerParameteri(sampler, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
glBindSampler(3, sampler);
glBindSampler(4, sampler);
}
void Clouds::renderClouds(const Vector3& lightDir, const Matrix4& viewMatrix)
{
// render clouds
//renderClouds(lightDir, view);
renderingShader->useProgram();
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ibo_cloudParticleRendering);
glBindVertexArray(vao_cloudParticleBuffer_Read);
// light settings
glUniformMatrix4fv(renderingShaderUniformIndex_lightViewProjection, 1, false, lightViewProjection);
glUniform4fv(renderingShaderUniformIndex_LightDistancePlane_norm, 1, lightDistancePlane_Norm);
glUniform3fv(renderingShaderUniformIndex_LightDirection, 1, (-lightDir).transformNormal(viewMatrix)); // need direction TO light
glBindSampler(1, linearSampler_noMipMaps);
glBindSampler(2, linearSampler_noMipMaps);
// textures
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, noiseTexture); // noise is always on 0; the FOM textures are on 1 and 2
glBindSampler(0, linearSampler_MipMaps);
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_2D, fourierOpacityMap_Textures[0][0]);
glActiveTexture(GL_TEXTURE2);
glBindTexture(GL_TEXTURE_2D, fourierOpacityMap_Textures[0][1]);
// blending
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
// buffers
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ibo_cloudParticleRendering);
glBindVertexArray(vao_cloudParticleBuffer_Read);
glDrawElements(GL_POINTS, numParticlesRender, GL_UNSIGNED_SHORT, 0);
// reset stuff
glBindVertexArray(0);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
glDisable(GL_BLEND);
// reset textures
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, 0);
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_2D, 0);
glActiveTexture(GL_TEXTURE2);
glBindTexture(GL_TEXTURE_2D, 0);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
}
////////////////////////////////////////////////////////////////////////////////
// SoftShadowsRenderer::initRendering()
////////////////////////////////////////////////////////////////////////////////
void SoftShadowsRenderer::initRendering()
{
GLint depthBits;
glGetIntegerv(GL_DEPTH_BITS, &depthBits);
LOGI("depth bits = %d\n", depthBits);
// Setup the eye's view parameters
initCamera(
NvCameraXformType::MAIN,
nv::vec3f(-0.644995f, 0.614183f, 0.660632f) * 1.5f, // position
nv::vec3f(0.0f, 0.0f, 0.0f)); // look at point
// Setup the light's view parameters
initCamera(
NvCameraXformType::SECONDARY,
nv::vec3f(3.57088f, 6.989f, 5.19698f) * 1.5f, // position
nv::vec3f(0.0f, 0.0f, 0.0f)); // look at point
// Generate the samplers
glGenSamplers(5, m_samplers);
CHECK_GL_ERROR();
for (GLuint unit = 0; unit < NumTextureUnits; ++unit)
{
glBindSampler(unit, m_samplers[unit]);
}
// Create resources
createShadowMap();
createGeometry();
createTextures();
createShaders();
// Set states that don't change
glEnable(GL_DEPTH_TEST);
glEnable(GL_CULL_FACE);
glDepthFunc(GL_LESS);
glCullFace(GL_BACK);
glDisable(GL_BLEND);
glClearColor(
m_backgroundColor.x,
m_backgroundColor.y,
m_backgroundColor.z,
m_backgroundColor.w);
glClearDepthf(1.0f);
for (GLuint unit = 0; unit < NumTextureUnits; ++unit)
{
glBindSampler(unit, 0);
}
}
void display()
{
// Compute the MVP (Model View Projection matrix)
glm::mat4 Projection = glm::perspective(45.0f, 4.0f / 3.0f, 0.1f, 1000.0f);
glm::mat4 ViewTranslate = glm::translate(glm::mat4(1.0f), glm::vec3(0.0f, 0.0f, -Window.TranlationCurrent.y));
glm::mat4 ViewRotateX = glm::rotate(ViewTranslate, Window.RotationCurrent.y, glm::vec3(1.f, 0.f, 0.f));
glm::mat4 View = glm::rotate(ViewRotateX, Window.RotationCurrent.x, glm::vec3(0.f, 1.f, 0.f));
glm::mat4 Model = glm::mat4(1.0f);
glm::mat4 MVP = Projection * View * Model;
glViewport(0, 0, Window.Size.x, Window.Size.y);
glClearBufferfv(GL_COLOR, 0, &glm::vec4(1.0f, 0.5f, 0.0f, 1.0f)[0]);
// Bind the program for use
glUseProgram(ProgramName);
glUniformMatrix4fv(UniformMVP, 1, GL_FALSE, &MVP[0][0]);
glUniform1i(UniformDiffuseA, 0);
glUniform1i(UniformDiffuseB, 1);
glUniform4f(UniformColor, 1.0f, 0.5f, 0.0f, 1.0f);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, TextureName);
glBindSampler(0, SamplerBName);
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_2D, TextureName);
glBindSampler(1, SamplerAName);
glBindVertexArray(VertexArrayName);
{
fprintf(stdout, "Validate\n");
glValidateProgram(ProgramName);
GLint Result = GL_FALSE;
glGetProgramiv(ProgramName, GL_VALIDATE_STATUS, &Result);
int InfoLogLength;
glGetProgramiv(ProgramName, GL_INFO_LOG_LENGTH, &InfoLogLength);
std::vector<char> Buffer(std::max(InfoLogLength, int(1)));
glGetProgramInfoLog(ProgramName, InfoLogLength, NULL, &Buffer[0]);
fprintf(stdout, "%s\n", &Buffer[0]);
}
glDrawArraysInstanced(GL_TRIANGLES, 0, VertexCount, 1);
glf::checkError("display");
glf::swapBuffers();
}
void display()
{
glm::mat4 Projection = glm::ortho(-1.0f, 1.0f, 1.0f,-1.0f, 1.0f, -1.0f);
glm::mat4 View = glm::mat4(1.0f);
glm::mat4 Model = glm::mat4(1.0f);
glm::mat4 MVP = Projection * View * Model;
glProgramUniformMatrix4fv(ProgramName[LAYERING], UniformMVP[LAYERING], 1, GL_FALSE, &MVP[0][0]);
glProgramUniformMatrix4fv(ProgramName[IMAGE_2D], UniformMVP[IMAGE_2D], 1, GL_FALSE, &MVP[0][0]);
glProgramUniform1i(ProgramName[IMAGE_2D], UniformDiffuse, 0);
// Pass 1
{
glBindSampler(0, 0);
glBindFramebuffer(GL_FRAMEBUFFER, FramebufferName);
glViewportIndexedf(0, 0, 0, float(FRAMEBUFFER_SIZE.x), float(FRAMEBUFFER_SIZE.y));
glUseProgram(ProgramName[LAYERING]);
glBindVertexArray(VertexArrayName[LAYERING]);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, BufferName[BUFFER_ELEMENT]);
glDrawElementsInstancedBaseVertex(GL_TRIANGLES, ElementCount, GL_UNSIGNED_SHORT, NULL, 1, 0);
}
// Pass 2
{
glBindFramebuffer(GL_FRAMEBUFFER, 0);
glUseProgram(ProgramName[IMAGE_2D]);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D_ARRAY, TextureColorbufferName);
glBindSampler(0, SamplerName);
glBindVertexArray(VertexArrayName[IMAGE_2D]);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, BufferName[BUFFER_ELEMENT]);
for(int i = 0; i < 4; ++i)
{
glProgramUniform1i(ProgramName[IMAGE_2D], UniformLayer, i);
glViewportIndexedfv(0, &glm::vec4(Viewport[i])[0]);
glDrawElementsInstancedBaseVertex(GL_TRIANGLES, ElementCount, GL_UNSIGNED_SHORT, NULL, 1, 0);
}
}
glf::checkError("display");
glf::swapBuffers();
}
bool render()
{
glm::vec2 WindowSize(this->getWindowSize());
{
glBindBuffer(GL_UNIFORM_BUFFER, BufferName[buffer::TRANSFORM]);
glm::mat4* Pointer = (glm::mat4*)glMapBufferRange(
GL_UNIFORM_BUFFER, 0, sizeof(glm::mat4),
GL_MAP_WRITE_BIT | GL_MAP_INVALIDATE_BUFFER_BIT);
glm::mat4 Projection = glm::perspectiveFov(glm::pi<float>() * 0.25f, WindowSize.x, WindowSize.y, 0.1f, 100.0f);
glm::mat4 Model = glm::mat4(1.0f);
*Pointer = Projection * this->view() * Model;
glUnmapBuffer(GL_UNIFORM_BUFFER);
}
// Render
glClearTexImage(TextureName[texture::COLORBUFFER], 0, GL_RGBA, GL_FLOAT, &glm::vec4(1.0f, 0.5f, 0.0f, 1.0f)[0]);
glViewportIndexedf(0, 0, 0, WindowSize.x * this->Supersampling, WindowSize.y * this->Supersampling);
glBindFramebuffer(GL_FRAMEBUFFER, FramebufferName);
glBindSampler(0, this->SamplerName[pipeline::RENDER]);
glBindVertexArray(this->VertexArrayName[pipeline::RENDER]);
glBindProgramPipeline(PipelineName[pipeline::RENDER]);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, TextureName[texture::DIFFUSE]);
glBindImageTexture(semantic::image::DIFFUSE, TextureName[texture::COLORBUFFER], 0, GL_FALSE, 0, GL_WRITE_ONLY, GL_RGBA8);
glBindBufferBase(GL_UNIFORM_BUFFER, semantic::uniform::TRANSFORM0, BufferName[buffer::TRANSFORM]);
glBindBufferBase(GL_SHADER_STORAGE_BUFFER, semantic::storage::VERTEX, BufferName[buffer::VERTEX]);
glDrawElementsInstancedBaseVertexBaseInstance(GL_TRIANGLES, ElementCount, GL_UNSIGNED_SHORT, 0, 1, 0, 0);
// Splash
glViewportIndexedf(0, 0, 0, WindowSize.x, WindowSize.y);
glBindFramebuffer(GL_FRAMEBUFFER, 0);
glBindSampler(0, this->SamplerName[pipeline::SPLASH]);
glBindVertexArray(this->VertexArrayName[pipeline::SPLASH]);
glBindProgramPipeline(PipelineName[pipeline::SPLASH]);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, TextureName[texture::COLORBUFFER]);
glDrawArraysInstancedBaseInstance(GL_TRIANGLES, 0, 3, 1, 0);
return true;
}
bool render()
{
glm::vec2 WindowSize(this->getWindowSize());
{
glBindBuffer(GL_UNIFORM_BUFFER, BufferName[buffer::TRANSFORM]);
glm::mat4* Pointer = (glm::mat4*)glMapBufferRange(
GL_UNIFORM_BUFFER, 0, sizeof(glm::mat4),
GL_MAP_WRITE_BIT | GL_MAP_INVALIDATE_BUFFER_BIT);
glm::mat4 Projection = glm::perspective(glm::pi<float>() * 0.25f, WindowSize.x / WindowSize.y, 0.1f, 100.0f);
glm::mat4 Model = glm::mat4(1.0f);
*Pointer = Projection * this->view() * Model;
// Make sure the uniform buffer is uploaded
glUnmapBuffer(GL_UNIFORM_BUFFER);
}
glViewportIndexedf(0, 0, 0, WindowSize.x, WindowSize.y);
glClearBufferfv(GL_COLOR, 0, &glm::vec4(1.0f)[0]);
glUseProgram(ProgramName);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D_ARRAY, TextureName);
glBindSampler(0, SamplerName);
glBindBufferBase(GL_UNIFORM_BUFFER, semantic::uniform::TRANSFORM0, BufferName[buffer::TRANSFORM]);
glBindVertexArray(VertexArrayName);
glDrawArraysInstancedBaseInstance(GL_TRIANGLES, 0, VertexCount, 15, 0);
return true;
}
void SamplerCache::SetSamplerState(int stage, const TexMode0& tm0, const TexMode1& tm1, bool custom_tex)
{
// TODO: can this go somewhere else?
if (m_last_max_anisotropy != g_ActiveConfig.iMaxAnisotropy)
{
m_last_max_anisotropy = g_ActiveConfig.iMaxAnisotropy;
Clear();
}
Params params(tm0, tm1);
// take equivalent forced linear when bForceFiltering
if (g_ActiveConfig.bForceFiltering)
{
params.tm0.min_filter |= 0x4;
params.tm0.mag_filter |= 0x1;
}
// custom textures may have higher resolution, so disable the max_lod
if (custom_tex)
{
params.tm1.max_lod = 255;
}
// TODO: Should keep a circular buffer for each stage of recently used samplers.
auto& active_sampler = m_active_samplers[stage];
if (active_sampler.first != params || !active_sampler.second.sampler_id)
{
// Active sampler does not match parameters (or is invalid), bind the proper one.
active_sampler.first = params;
active_sampler.second = GetEntry(params);
glBindSampler(stage, active_sampler.second.sampler_id);
}
}
bool render()
{
glm::vec2 WindowSize(this->getWindowSize());
static int FrameIndex = 0;
// Bind shared objects
glViewportIndexedf(0, 0, 0, WindowSize.x, WindowSize.y);
glBindSampler(0, SamplerName);
glBindVertexArray(VertexArrayName);
// Update a colorbuffer bound as a framebuffer attachement and as a texture
glBindFramebuffer(GL_FRAMEBUFFER, FramebufferName);
glBindProgramPipeline(PipelineName[pipeline::UPDATE]);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, FrameIndex ? TextureName[texture::COLORBUFFER] : TextureName[texture::DIFFUSE]);
glMemoryBarrier(GL_TEXTURE_UPDATE_BARRIER_BIT | GL_TEXTURE_FETCH_BARRIER_BIT);
glDrawArraysInstancedBaseInstance(GL_TRIANGLES, 0, VertexCount, 1, 0);
// Blit to framebuffer
glBindFramebuffer(GL_FRAMEBUFFER, 0);
glBindProgramPipeline(PipelineName[pipeline::BLIT]);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, TextureName[texture::COLORBUFFER]);
glMemoryBarrier(GL_TEXTURE_UPDATE_BARRIER_BIT);
glDrawArraysInstancedBaseInstance(GL_TRIANGLES, 0, VertexCount, 1, 0);
FrameIndex = (FrameIndex + 1) % 256;
return true;
}
void renderFBO()
{
glm::mat4 Perspective = glm::perspective(glm::pi<float>() * 0.25f, float(FRAMEBUFFER_SIZE.x) / FRAMEBUFFER_SIZE.y, 0.1f, 100.0f);
glm::mat4 Model = glm::scale(glm::mat4(1.0f), glm::vec3(1, -1, 1));
glm::mat4 MVP = Perspective * this->view() * Model;
glEnable(GL_DEPTH_TEST);
glUseProgram(ProgramName[program::THROUGH]);
glUniform1i(UniformDiffuse[program::THROUGH], 0);
glUniformMatrix4fv(UniformMVP[program::THROUGH], 1, GL_FALSE, &MVP[0][0]);
glViewport(0, 0, FRAMEBUFFER_SIZE.x, FRAMEBUFFER_SIZE.y);
glBindFramebuffer(GL_FRAMEBUFFER, FramebufferName);
float Depth(1.0f);
glClearBufferfv(GL_DEPTH, 0, &Depth);
glClearBufferfv(GL_COLOR, 0, &glm::vec4(1.0f, 0.5f, 0.0f, 1.0f)[0]);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, TextureName[texture::DIFFUSE]);
glBindSampler(0, SamplerName);
glBindVertexArray(VertexArrayName);
glDrawArraysInstanced(GL_TRIANGLES, 0, VertexCount, 5);
glDisable(GL_DEPTH_TEST);
this->checkError("renderFBO");
}
void renderFB(GLuint Texture2DName)
{
glm::mat4 Perspective = glm::perspective(45.0f, float(Window.Size.x) / Window.Size.y, 0.1f, 100.0f);
glm::mat4 ViewTranslate = glm::translate(glm::mat4(1.0f), glm::vec3(0.0f, 0.0f, -Window.TranlationCurrent.y * 2.0));
glm::mat4 ViewRotateX = glm::rotate(ViewTranslate, Window.RotationCurrent.y, glm::vec3(1.f, 0.f, 0.f));
glm::mat4 View = glm::rotate(ViewRotateX, Window.RotationCurrent.x, glm::vec3(0.f, 1.f, 0.f));
glm::mat4 Model = glm::mat4(1.0f);
glm::mat4 MVP = Perspective * View * Model;
glProgramUniformMatrix4fv(ProgramName[program::VERTEX], UniformMVP, 1, GL_FALSE, &MVP[0][0]);
glViewportIndexedfv(0, &glm::vec4(0, 0, Window.Size.x, Window.Size.y)[0]);
glBindFramebuffer(GL_FRAMEBUFFER, 0);
glClearBufferfv(GL_COLOR, 0, &glm::vec4(0.0f, 0.0f, 0.0f, 1.0f)[0]);
glBindMultiTextureEXT(GL_TEXTURE0, GL_TEXTURE_2D, Texture2DName);
glBindSampler(0, SamplerName);
glBindVertexArray(VertexArrayName);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, BufferName[buffer::ELEMENT]);
glDrawElementsInstancedBaseVertex(GL_TRIANGLES, ElementCount, GL_UNSIGNED_SHORT, NULL, 1, 0);
glf::checkError("renderFB");
}
void graphics_state_flush_samplers() {
static bool samplers_generated = false;
static GLuint sampler_ids[8];
if (!samplers_generated) {
glGenSamplers(8, sampler_ids);
samplers_generated = true;
}
for (size_t i = 0; i < 8; i++) {
const auto sampler = samplers[i];
const GLuint gt = get_texture_peer(sampler.texture);
glActiveTexture(GL_TEXTURE0 + i);
glBindTexture(GL_TEXTURE_2D, gt);
if (gt == 0) continue; // texture doesn't exist skip updating the sampler
const GLuint sampler_id = sampler_ids[i];
glBindSampler(i, sampler_id);
glSamplerParameteri(sampler_id, GL_TEXTURE_WRAP_R, sampler.wrapu?GL_REPEAT:GL_CLAMP_TO_EDGE);
glSamplerParameteri(sampler_id, GL_TEXTURE_WRAP_S, sampler.wrapv?GL_REPEAT:GL_CLAMP_TO_EDGE);
glSamplerParameteri(sampler_id, GL_TEXTURE_WRAP_T, sampler.wrapw?GL_REPEAT:GL_CLAMP_TO_EDGE);
// Default to interpolation disabled, for some reason textures do that by default but not samplers.
glSamplerParameteri(sampler_id, GL_TEXTURE_MIN_FILTER, sampler.interpolate?GL_LINEAR:GL_NEAREST);
glSamplerParameteri(sampler_id, GL_TEXTURE_MAG_FILTER, sampler.interpolate?GL_LINEAR:GL_NEAREST);
}
}
///=====================================================
///
///=====================================================
void EngineAndrew::Material::Render(int vaoID, int indexBufferID, int numIndeces, GLenum indecesDataType /*= GL_UNSIGNED_INT*/) const{
assert(m_programID != 0);
assert(m_samplerID != 0);
assert(!m_vertexAttributes.empty());
glUseProgram(m_programID);
GLCheckError();
glBindVertexArray(vaoID);
for (std::vector<IndexedTexture>::const_iterator textureIter = m_textures.cbegin(); textureIter != m_textures.cend(); ++textureIter){
const Texture* texture = textureIter->m_texture;
glActiveTexture(GL_TEXTURE0 + textureIter->m_textureIndex);
glBindTexture(GL_TEXTURE_2D, texture->GetPlatformHandle());
glBindSampler(textureIter->m_textureIndex, m_samplerID);
GLCheckError();
}
for (Uniforms::const_iterator uniformIter = m_uniforms.cbegin(); uniformIter != m_uniforms.cend(); ++uniformIter){
const Uniform * const& uniform = *uniformIter;
uniform->BindData();
}
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, indexBufferID);
glDrawElements(m_baseShape, numIndeces, indecesDataType, nullptr);
GLCheckError();
}
void bind(GLenum target)
{
m_Target = target;
glBindSampler(m_iSamplerUnit,m_iSamplerID);
glActiveTexture(m_CurrentTexture);
glBindTexture(m_Target,id());
}
bool GLMeshRenderer::ProgramBindTexture(GLint textureID, unsigned int textureHandle)
{
glActiveTexture(GL_TEXTURE0 + textureID);
glBindTexture(GL_TEXTURE_2D, textureHandle);
glBindSampler(textureID, m_material.m_sampler.m_samplerID);
return true;
}
void CTexture::SetFiltering(int a_tfMagnification, int a_tfMinification)
{
glBindSampler(0, uiSampler);
// Set magnification filter
if(a_tfMagnification == TEXTURE_FILTER_MAG_NEAREST)
glSamplerParameteri(uiSampler, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
else if(a_tfMagnification == TEXTURE_FILTER_MAG_BILINEAR)
glSamplerParameteri(uiSampler, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
// Set minification filter
if(a_tfMinification == TEXTURE_FILTER_MIN_NEAREST)
glSamplerParameteri(uiSampler, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
else if(a_tfMinification == TEXTURE_FILTER_MIN_BILINEAR)
glSamplerParameteri(uiSampler, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
else if(a_tfMinification == TEXTURE_FILTER_MIN_NEAREST_MIPMAP)
glSamplerParameteri(uiSampler, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_NEAREST);
else if(a_tfMinification == TEXTURE_FILTER_MIN_BILINEAR_MIPMAP)
glSamplerParameteri(uiSampler, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_NEAREST);
else if(a_tfMinification == TEXTURE_FILTER_MIN_TRILINEAR)
glSamplerParameteri(uiSampler, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
tfMinification = a_tfMinification;
tfMagnification = a_tfMagnification;
}
void Node::Render(GLint texLoc, GLint matLoc)
{
transform_global = transform_local;
if (m_Mesh != 0 && m_Texture != 0)
{
//m_Shader->BindShader();
glUniformMatrix4fv(matLoc, 1, GL_FALSE, glm::gtc::type_ptr::value_ptr(transform_global));
glUniform1i(texLoc, m_Texture->getUnit());
CheckOpenGLError("passing uniform in node");
glActiveTexture(GL_TEXTURE0 + m_Texture->getUnit());
glBindTexture(GL_TEXTURE_2D, m_Texture->getID());
glBindSampler(m_Texture->getUnit(), m_Texture->getSampler());
CheckOpenGLError("binding texture in node");
m_Mesh->draw();
glBindTexture(GL_TEXTURE_2D, 0);
//m_Shader->UnBindShader();
}
for (GLuint i = 0; i < m_children.size(); i++)
{
m_children[i]->Render(texLoc, matLoc, transform_global);
CheckOpenGLError("render children in node");
}
}
bool render()
{
glm::vec2 WindowSize(this->getWindowSize());
glViewportIndexedf(0, 0, 0, WindowSize.x, WindowSize.y);
glBindVertexArray(this->VertexArrayName);
glBindSampler(0, this->SamplerName);
// Render
glBindFramebuffer(GL_FRAMEBUFFER, FramebufferName);
glClearBufferfv(GL_COLOR, 0, &glm::vec4(1.0f, 0.5f, 0.0f, 1.0f)[0]);
glBindProgramPipeline(PipelineName[pipeline::RENDER]);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, TextureName[texture::DIFFUSE]);
glBindImageTexture(semantic::image::DIFFUSE, TextureName[texture::COLORBUFFER], 0, GL_FALSE, 0, GL_WRITE_ONLY, GL_RGBA8);
glDrawArraysInstancedBaseInstance(GL_TRIANGLES, 0, 3, 1, 0);
// Splash
glBindFramebuffer(GL_FRAMEBUFFER, 0);
glBindProgramPipeline(PipelineName[pipeline::SPLASH]);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, TextureName[texture::COLORBUFFER]);
glDrawArraysInstancedBaseInstance(GL_TRIANGLES, 0, 3, 1, 0);
return true;
}
bool render()
{
glm::vec2 WindowSize(this->getWindowSize());
{
glBindBuffer(GL_UNIFORM_BUFFER, BufferName[buffer::TRANSFORM]);
glm::mat4* Pointer = (glm::mat4*)glMapBufferRange(
GL_UNIFORM_BUFFER, 0, sizeof(glm::mat4),
GL_MAP_WRITE_BIT | GL_MAP_INVALIDATE_BUFFER_BIT);
//glm::mat4 Projection = glm::perspectiveFov(glm::pi<float>() * 0.25f, 640.f, 480.f, 0.1f, 100.0f);
glm::mat4 Projection = glm::perspective(glm::pi<float>() * 0.25f, WindowSize.x / WindowSize.y, 0.1f, 100.0f);
glm::mat4 Model = glm::mat4(1.0f);
*Pointer = Projection * this->view() * Model;
// Make sure the uniform buffer is uploaded
glUnmapBuffer(GL_UNIFORM_BUFFER);
}
glBindFramebuffer(GL_FRAMEBUFFER, 0);
glBindProgramPipeline(PipelineName[pipeline::SPLASH]);
glActiveTexture(GL_TEXTURE0);
glBindVertexArray(VertexArrayName);
glBindTexture(GL_TEXTURE_2D, TextureName[texture::DIFFUSE]);
glBindSampler(0, SamplerName);
glDrawArraysInstancedBaseInstance(GL_TRIANGLES, 0, 3, 1, 0);
return true;
}
void display()
{
// Compute the MVP (Model View Projection matrix)
glm::mat4 Projection = glm::perspective(45.0f, 4.0f / 3.0f, 0.1f, 100.0f);
glm::mat4 ViewTranslate = glm::translate(glm::mat4(1.0f), glm::vec3(0.0f, 0.0f, -Window.TranlationCurrent.y));
glm::mat4 ViewRotateX = glm::rotate(ViewTranslate, Window.RotationCurrent.y, glm::vec3(1.f, 0.f, 0.f));
glm::mat4 View = glm::rotate(ViewRotateX, Window.RotationCurrent.x, glm::vec3(0.f, 1.f, 0.f));
glm::mat4 Model = glm::mat4(1.0f);
glm::mat4 MVP = Projection * View * Model;
glViewport(0, 0, Window.Size.x, Window.Size.y);
glClearBufferfv(GL_COLOR, 0, &glm::vec4(1.0f, 0.5f, 0.0f, 1.0f)[0]);
// Bind the program for use
glUseProgram(ProgramName);
glUniformMatrix4fv(UniformMVP, 1, GL_FALSE, &MVP[0][0]);
glUniform1i(UniformDiffuse, 0);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D_ARRAY, Texture2DArrayName);
glBindSampler(0, SamplerName);
glBindVertexArray(VertexArrayName);
glDrawArraysInstanced(GL_TRIANGLES, 0, VertexCount, 2);
glf::checkError("display");
glf::swapBuffers();
}
void OpenGLEngine::EnableSamplers (Shader const* shader, GLuint program)
{
auto const samplers = shader->GetData (SamplerState::shaderLookUp);
for (auto sampler = samplers.begin (); sampler != samplers.end (); sampler ++)
{
if (sampler->object)
{
std::shared_ptr<OGLSamplerState> oglSampler = std::static_pointer_cast<OGLSamplerState> (Bind (sampler->object));
if (oglSampler)
{
auto location = sampler->bindPoint;
int unit = m_TextureUnitMap.AskConnectionUnit (program, location);
glBindSampler (unit, oglSampler->GetOGLDrawObject());
}
else
{
fprintf (stderr, "The enable samplers method in OpenGLEngine failed, because the binding of the object failed.\n");
}
}
else
{
fprintf (stderr, "The enable samplers method in OpenGLEngine failed, because the object in the buffer is null.\n");
}
}
}
void ReplayRenderWidget::paintGL()
{
// Set up some needed GL state
glColorMaski(0, GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
glDisablei(GL_BLEND, 0);
glDisable(GL_DEPTH_TEST);
glDisable(GL_STENCIL_TEST);
glDisable(GL_SCISSOR_TEST);
glDisable(GL_CULL_FACE);
// Clear screen
glClearColor(0.6f, 0.2f, 0.2f, 1.0f);
glClear(GL_COLOR_BUFFER_BIT);
// Draw displays
// Setup screen draw shader
glBindVertexArray(mVertArray);
glBindVertexBuffer(0, mVertBuffer, 0, 4 * sizeof(GLfloat));
glBindProgramPipeline(mPipeline);
// Draw screen quad
glBindSampler(0, mSampler);
glBindTextureUnit(0, mTvBuffer);
glDrawArrays(GL_TRIANGLES, 0, 6);
}
void Node::Render(GLint texLoc, GLint matLoc, GLint normalMatLoc, glm::mat4 viewMat)
{
transform_global = transform_local;
if (m_Mesh != 0 && m_Texture != 0)
{
glm::mat3 normalMatrix(viewMat * transform_global);
glm::inverseTranspose(normalMatrix);
glUniformMatrix3fv(normalMatLoc, 1, GL_FALSE, glm::gtc::type_ptr::value_ptr(normalMatrix));
CheckOpenGLError("passing normalMat in root node");
glUniformMatrix4fv(matLoc, 1, GL_FALSE, glm::gtc::type_ptr::value_ptr(transform_global));
glUniform1i(texLoc, m_Texture->getUnit());
CheckOpenGLError("passing uniforms in root node");
glActiveTexture(GL_TEXTURE0 + m_Texture->getUnit());
glBindTexture(GL_TEXTURE_2D, m_Texture->getID());
glBindSampler(m_Texture->getUnit(), m_Texture->getSampler());
CheckOpenGLError("binding texture in root node");
m_Mesh->draw();
glBindTexture(GL_TEXTURE_2D, 0);
}
for (GLuint i = 0; i < m_children.size(); i++)
{
m_children[i]->Render(texLoc, matLoc, transform_global, normalMatLoc, viewMat);
CheckOpenGLError("render children in node");
}
}
