BTH/axyz
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Merge remote-tracking branch 'origin/master' into Rendering

Browse Source 
# Conflicts:
#	src/Engine/Editor/EditorSystem.cpp
#	src/Engine/Rendering/PickingPass.cpp
#	src/Game/Game.cpp
This commit is contained in:
viktorljung
2015-12-17 11:17:58 +01:00
parent 0f1b06f74e 1a9b765d47
commit aeca1dec18
20 changed files with 540 additions and 199 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/Engine/Rendering/DrawScenePassState.cpp
+1 -1
View File
@@ -4,7 +4,7 @@
DrawScenePassState::DrawScenePassState()
{
GLERROR("---");
BindBuffer(0);
BindFramebuffer(0);
GLERROR("---");
Enable(GL_DEPTH_TEST);
Enable(GL_CULL_FACE);
src/Engine/Rendering/ImGuiRenderPass.cpp
+2 -37
View File
@@ -69,29 +69,8 @@ void ImGuiRenderPass::Draw()
ImDrawData* draw_data = ImGui::GetDrawData();
// Backup GL state
GLint last_program; glGetIntegerv(GL_CURRENT_PROGRAM, &last_program);
GLint last_texture; glGetIntegerv(GL_TEXTURE_BINDING_2D, &last_texture);
GLint last_array_buffer; glGetIntegerv(GL_ARRAY_BUFFER_BINDING, &last_array_buffer);
GLint last_element_array_buffer; glGetIntegerv(GL_ELEMENT_ARRAY_BUFFER_BINDING, &last_element_array_buffer);
GLint last_vertex_array; glGetIntegerv(GL_VERTEX_ARRAY_BINDING, &last_vertex_array);
GLint last_blend_src; glGetIntegerv(GL_BLEND_SRC, &last_blend_src);
GLint last_blend_dst; glGetIntegerv(GL_BLEND_DST, &last_blend_dst);
GLint last_blend_equation_rgb; glGetIntegerv(GL_BLEND_EQUATION_RGB, &last_blend_equation_rgb);
GLint last_blend_equation_alpha; glGetIntegerv(GL_BLEND_EQUATION_ALPHA, &last_blend_equation_alpha);
GLint last_viewport[4]; glGetIntegerv(GL_VIEWPORT, last_viewport);
GLboolean last_enable_blend = glIsEnabled(GL_BLEND);
GLboolean last_enable_cull_face = glIsEnabled(GL_CULL_FACE);
GLboolean last_enable_depth_test = glIsEnabled(GL_DEPTH_TEST);
GLboolean last_enable_scissor_test = glIsEnabled(GL_SCISSOR_TEST);
// Setup render state: alpha-blending enabled, no face culling, no depth testing, scissor enabled
glEnable(GL_BLEND);
glBlendEquation(GL_FUNC_ADD);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glDisable(GL_CULL_FACE);
glDisable(GL_DEPTH_TEST);
glEnable(GL_SCISSOR_TEST);
// Set up render state
ImGuiRenderState state;
glActiveTexture(GL_TEXTURE0);
// Handle cases of screen coordinates != from framebuffer coordinates (e.g. retina displays)
@@ -134,20 +113,6 @@ void ImGuiRenderPass::Draw()
}
}
// Restore modified GL state
glUseProgram(last_program);
glBindTexture(GL_TEXTURE_2D, last_texture);
glBindBuffer(GL_ARRAY_BUFFER, last_array_buffer);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, last_element_array_buffer);
glBindVertexArray(last_vertex_array);
glBlendEquationSeparate(last_blend_equation_rgb, last_blend_equation_alpha);
glBlendFunc(last_blend_src, last_blend_dst);
if (last_enable_blend) glEnable(GL_BLEND); else glDisable(GL_BLEND);
if (last_enable_cull_face) glEnable(GL_CULL_FACE); else glDisable(GL_CULL_FACE);
if (last_enable_depth_test) glEnable(GL_DEPTH_TEST); else glDisable(GL_DEPTH_TEST);
if (last_enable_scissor_test) glEnable(GL_SCISSOR_TEST); else glDisable(GL_SCISSOR_TEST);
glViewport(last_viewport[0], last_viewport[1], (GLsizei)last_viewport[2], (GLsizei)last_viewport[3]);
// Start next frame
newFrame();
}
src/Engine/Rendering/PickingPass.cpp
+16 -14
View File
@@ -48,26 +48,31 @@ void PickingPass::Draw(RenderQueueCollection& rq)
m_PickingColorsToEntity.clear();
PickingPassState* state = new PickingPassState(m_PickingBuffer.GetHandle());
int r = 1;
int r = 0;
int g = 0;
//TODO: Render: Add code for more jobs than modeljobs.
GLuint ShaderHandle = m_PickingProgram->GetHandle();
m_PickingProgram->Bind();
std::map<EntityID, glm::vec2> entityColors;
for (auto &job : rq.Forward) {
auto modelJob = std::dynamic_pointer_cast<ModelJob>(job);
if (modelJob) {
//---------------
//TODO: Renderer: IMPORTANT: Fixa detta så det inte loopar igenom listan varje frame.
//---------------
int pickColor[2] = { r, g };
for (auto i : m_PickingColorsToEntity) {
if (modelJob->Entity == i.second) {
pickColor[0] = i.first.x;
pickColor[1] = i.first.y;
r -= 1;
auto color = entityColors.find(modelJob->Entity);
if (color != entityColors.end()) {
pickColor[0] = color->second[0];
pickColor[1] = color->second[1];
} else {
entityColors[modelJob->Entity] = glm::vec2(pickColor[0], pickColor[1]);
if (r + 10 > 255) {
r = 0;
g += 1;
} else {
r += 1;
}
}
m_PickingColorsToEntity[glm::vec2(pickColor[0], pickColor[1])] = modelJob->Entity;
@@ -78,11 +83,6 @@ void PickingPass::Draw(RenderQueueCollection& rq)
glBindVertexArray(modelJob->Model->VAO);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, modelJob->Model->ElementBuffer);
glDrawElementsBaseVertex(GL_TRIANGLES, modelJob->EndIndex - modelJob->StartIndex + 1, GL_UNSIGNED_INT, nullptr, modelJob->StartIndex);
r += 1;
if (r > 255) {
r = 0;
g += 1;
}
}
}
m_PickingBuffer.Unbind();
@@ -101,6 +101,8 @@ void PickingPass::Draw(RenderQueueCollection& rq)
&m_PickingColorsToEntity);*/
//m_EventBroker->Publish(pickEvent);
delete state;
}
void PickingPass::GenerateTexture(GLuint* texture, GLenum wrapping, GLenum filtering, glm::vec2 dimensions, GLint internalFormat, GLint format, GLenum type) const
src/Engine/Rendering/PickingPassState.cpp
+1 -1
View File
@@ -4,7 +4,7 @@
PickingPassState::PickingPassState(GLuint frameBuffer)
{
GLERROR("---2");
BindBuffer(frameBuffer);
BindFramebuffer(frameBuffer);
GLERROR("---3");
Enable(GL_DEPTH_TEST);
Enable(GL_CULL_FACE);
src/Engine/Rendering/RenderState.cpp
+67 -78
View File
@@ -1,110 +1,99 @@
#include "Rendering/RenderState.h"
RenderState::RenderState()
bool RenderState::Enable(GLenum cap)
{
}
bool RenderState::Enable(GLenum GLEnable)
{
if(glIsEnabled(GLEnable))
{
if (glIsEnabled(cap)) {
return false;
}
m_Enables.push_back(GLEnable);
glEnable(GLEnable);
if (GLERROR("RenderState::Enable"))
{
return false;
}
return true;
m_ResetFunctions.push_back(std::bind(glDisable, cap));
glEnable(cap);
return !GLERROR("RenderState::Enable");
}
bool RenderState::CullFace(GLenum GLCullFace)
bool RenderState::Disable(GLenum cap)
{
if(!glIsEnabled(GL_CULL_FACE))
{
if (!glIsEnabled(cap)) {
return false;
}
m_ResetFunctions.push_back(std::bind(glEnable, cap));
glDisable(cap);
return !GLERROR("RenderState::Disable");
}
bool RenderState::CullFace(GLenum mode)
{
if (!glIsEnabled(GL_CULL_FACE)) {
LOG_ERROR("Setting GL_CULL_FACE without enabling it.");
return false;
}
GLint a;
glGetIntegerv(GL_CULL_FACE_MODE, &a);
if(a != GL_BACK)
{
//LOG_INFO("Setting Cullface to back, unessesary since this is already default.");
glCullFace(GLCullFace);
}
if (GLERROR("RenderState::CullFace"))
{
return false;
}
return true;
GLint original;
glGetIntegerv(GL_CULL_FACE_MODE, &original);
m_ResetFunctions.push_back(std::bind(glCullFace, original));
glCullFace(mode);
return !GLERROR("RenderState::CullFace");
}
bool RenderState::ClearColor(glm::vec4 color)
{
glGetFloatv(GL_COLOR_CLEAR_VALUE, &m_preClearColor[0]);
GLfloat original[4];
glGetFloatv(GL_COLOR_CLEAR_VALUE, &original[0]);
m_ResetFunctions.push_back(std::bind(glClearColor, original[0], original[1], original[2], original[3]));
glClearColor(color.r, color.g, color.b, color.a);
if (GLERROR("RenderState::ClearColor")) {
return false;
}
return true;
return !GLERROR("RenderState::ClearColor");
}
bool RenderState::Clear(GLbitfield mask)
{
glClear(mask);
if (GLERROR("RenderState::Clear")) {
return false;
}
return true;
return !GLERROR("RenderState::Clear");
}
bool RenderState::BindBuffer(GLint buffer)
bool RenderState::BindFramebuffer(GLint framebuffer)
{
glGetIntegerv(GL_FRAMEBUFFER_BINDING, &m_preBuffer);
if (buffer == m_preBuffer)
{
return true;
}
glBindFramebuffer(GL_FRAMEBUFFER, buffer);
if (GLERROR("RenderState::BindBuffer"))
{
printf("BufferID: %i\npreBufferID: %i\n", buffer, m_preBuffer);
return false;
}
return true;
GLint originalRead;
glGetIntegerv(GL_READ_FRAMEBUFFER_BINDING, &originalRead);
GLint originalDraw;
glGetIntegerv(GL_DRAW_FRAMEBUFFER_BINDING, &originalDraw);
m_ResetFunctions.push_back([originalRead, originalDraw]() {
glBindFramebuffer(GL_READ_FRAMEBUFFER, originalRead);
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, originalDraw);
});
glBindFramebuffer(GL_FRAMEBUFFER, framebuffer);
return !GLERROR("RenderState::BindBuffer");
}
bool RenderState::BlendEquation(GLenum mode)
{
GLint originalRGB;
glGetIntegerv(GL_BLEND_EQUATION_RGB, &originalRGB);
GLint originalAlpha;
glGetIntegerv(GL_BLEND_EQUATION_ALPHA, &originalAlpha);
m_ResetFunctions.push_back(std::bind(glBlendEquationSeparate, originalRGB, originalAlpha));
glBlendEquation(mode);
return !GLERROR("RenderState::BlendEquation");
}
bool RenderState::BlendFunc(GLenum sfactor, GLenum dfactor)
{
GLint originalSrcRGB;
glGetIntegerv(GL_BLEND_SRC_RGB, &originalSrcRGB);
GLint originalSrcAlpha;
glGetIntegerv(GL_BLEND_SRC_ALPHA, &originalSrcAlpha);
GLint originalDestRGB;
glGetIntegerv(GL_BLEND_DST_RGB, &originalDestRGB);
GLint originalDestAlpha;
glGetIntegerv(GL_BLEND_DST_ALPHA, &originalDestAlpha);
m_ResetFunctions.push_back(std::bind(glBlendFuncSeparate, originalSrcRGB, originalSrcAlpha, originalDestRGB, originalDestAlpha));
glBlendFunc(sfactor, dfactor);
return !GLERROR("RenderState::BlendFunc");
}
RenderState::~RenderState()
{
GLERROR("RenderState::~RenderState Pre");
GLint n_buffer = -1;
glGetIntegerv(GL_FRAMEBUFFER_BINDING, &n_buffer);
//Set cullface to default
if (glIsEnabled(GL_CULL_FACE)) {
glCullFace(GL_BACK);
for (auto& f : m_ResetFunctions) {
f();
}
GLERROR("RenderState::~RenderState glCullFace");
//Set color to default
glClearColor(m_preClearColor[0], m_preClearColor[1], m_preClearColor[2], m_preClearColor[3]);
GLERROR("RenderState::~RenderState glClearColor");
//Disable Enables
for (auto i : m_Enables)
{
glDisable(i);
}
GLERROR("RenderState::~RenderState glDisable");
if(m_preBuffer != 0)
{
glBindFramebuffer(GL_FRAMEBUFFER, 0);
}
m_Enables.clear();
GLERROR("RenderState::~RenderState glBindFramebuffer");
}
src/Engine/Rendering/Renderer.cpp
-2
View File
@@ -101,8 +101,6 @@ void Renderer::Draw(RenderQueueCollection& rq)
//CullLights();
glClearColor(255.f / 255, 163.f / 255, 176.f / 255, 1.f);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
m_DrawScenePass->Draw(rq);
GLERROR("Renderer::Draw m_DrawScenePass->Draw");