2015-05-19 06:21:33 +02:00
|
|
|
// Copyright 2015 Citra Emulator Project
|
|
|
|
// Licensed under GPLv2 or any later version
|
|
|
|
// Refer to the license.txt file included.
|
|
|
|
|
2018-04-20 04:36:48 +02:00
|
|
|
#include <iterator>
|
2016-04-30 17:34:51 +02:00
|
|
|
#include <glad/glad.h>
|
|
|
|
#include "common/logging/log.h"
|
2016-09-21 08:52:38 +02:00
|
|
|
#include "video_core/renderer_opengl/gl_state.h"
|
2016-04-30 17:34:51 +02:00
|
|
|
|
2018-08-21 10:18:27 +02:00
|
|
|
namespace OpenGL {
|
|
|
|
|
2015-05-19 06:21:33 +02:00
|
|
|
OpenGLState OpenGLState::cur_state;
|
|
|
|
|
|
|
|
OpenGLState::OpenGLState() {
|
|
|
|
// These all match default OpenGL values
|
|
|
|
cull.enabled = false;
|
|
|
|
cull.mode = GL_BACK;
|
2015-08-31 17:03:21 +02:00
|
|
|
cull.front_face = GL_CCW;
|
2015-05-19 06:21:33 +02:00
|
|
|
|
|
|
|
depth.test_enabled = false;
|
|
|
|
depth.test_func = GL_LESS;
|
|
|
|
depth.write_mask = GL_TRUE;
|
|
|
|
|
2015-05-29 03:41:37 +02:00
|
|
|
color_mask.red_enabled = GL_TRUE;
|
|
|
|
color_mask.green_enabled = GL_TRUE;
|
|
|
|
color_mask.blue_enabled = GL_TRUE;
|
|
|
|
color_mask.alpha_enabled = GL_TRUE;
|
|
|
|
|
2015-05-19 06:21:33 +02:00
|
|
|
stencil.test_enabled = false;
|
|
|
|
stencil.test_func = GL_ALWAYS;
|
|
|
|
stencil.test_ref = 0;
|
2016-11-27 18:30:03 +01:00
|
|
|
stencil.test_mask = 0xFF;
|
|
|
|
stencil.write_mask = 0xFF;
|
2015-08-20 17:11:09 +02:00
|
|
|
stencil.action_depth_fail = GL_KEEP;
|
|
|
|
stencil.action_depth_pass = GL_KEEP;
|
|
|
|
stencil.action_stencil_fail = GL_KEEP;
|
2015-05-19 06:21:33 +02:00
|
|
|
|
2018-03-19 22:05:15 +01:00
|
|
|
blend.enabled = true;
|
2016-05-12 22:57:15 +02:00
|
|
|
blend.rgb_equation = GL_FUNC_ADD;
|
|
|
|
blend.a_equation = GL_FUNC_ADD;
|
2015-05-19 06:21:33 +02:00
|
|
|
blend.src_rgb_func = GL_ONE;
|
|
|
|
blend.dst_rgb_func = GL_ZERO;
|
|
|
|
blend.src_a_func = GL_ONE;
|
|
|
|
blend.dst_a_func = GL_ZERO;
|
|
|
|
blend.color.red = 0.0f;
|
|
|
|
blend.color.green = 0.0f;
|
|
|
|
blend.color.blue = 0.0f;
|
|
|
|
blend.color.alpha = 0.0f;
|
|
|
|
|
2018-08-21 01:43:11 +02:00
|
|
|
logic_op.enabled = false;
|
|
|
|
logic_op.operation = GL_COPY;
|
2015-05-26 00:39:03 +02:00
|
|
|
|
2015-05-19 06:21:33 +02:00
|
|
|
for (auto& texture_unit : texture_units) {
|
2018-06-26 22:58:35 +02:00
|
|
|
texture_unit.Reset();
|
2016-02-26 01:12:38 +01:00
|
|
|
}
|
|
|
|
|
2016-04-17 00:57:57 +02:00
|
|
|
draw.read_framebuffer = 0;
|
|
|
|
draw.draw_framebuffer = 0;
|
2015-05-19 06:21:33 +02:00
|
|
|
draw.vertex_array = 0;
|
|
|
|
draw.vertex_buffer = 0;
|
2016-04-17 00:57:57 +02:00
|
|
|
draw.uniform_buffer = 0;
|
2015-05-19 06:21:33 +02:00
|
|
|
draw.shader_program = 0;
|
2018-03-19 22:05:15 +01:00
|
|
|
draw.program_pipeline = 0;
|
|
|
|
|
|
|
|
scissor.enabled = false;
|
|
|
|
scissor.x = 0;
|
|
|
|
scissor.y = 0;
|
|
|
|
scissor.width = 0;
|
|
|
|
scissor.height = 0;
|
|
|
|
|
|
|
|
viewport.x = 0;
|
|
|
|
viewport.y = 0;
|
|
|
|
viewport.width = 0;
|
|
|
|
viewport.height = 0;
|
2017-08-17 09:46:59 +02:00
|
|
|
|
|
|
|
clip_distance = {};
|
2015-05-19 06:21:33 +02:00
|
|
|
}
|
|
|
|
|
2016-04-17 00:57:57 +02:00
|
|
|
void OpenGLState::Apply() const {
|
2015-05-19 06:21:33 +02:00
|
|
|
// Culling
|
|
|
|
if (cull.enabled != cur_state.cull.enabled) {
|
|
|
|
if (cull.enabled) {
|
|
|
|
glEnable(GL_CULL_FACE);
|
|
|
|
} else {
|
|
|
|
glDisable(GL_CULL_FACE);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (cull.mode != cur_state.cull.mode) {
|
|
|
|
glCullFace(cull.mode);
|
|
|
|
}
|
|
|
|
|
2015-08-31 17:03:21 +02:00
|
|
|
if (cull.front_face != cur_state.cull.front_face) {
|
|
|
|
glFrontFace(cull.front_face);
|
|
|
|
}
|
|
|
|
|
2015-05-19 06:21:33 +02:00
|
|
|
// Depth test
|
|
|
|
if (depth.test_enabled != cur_state.depth.test_enabled) {
|
|
|
|
if (depth.test_enabled) {
|
|
|
|
glEnable(GL_DEPTH_TEST);
|
|
|
|
} else {
|
|
|
|
glDisable(GL_DEPTH_TEST);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (depth.test_func != cur_state.depth.test_func) {
|
|
|
|
glDepthFunc(depth.test_func);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Depth mask
|
|
|
|
if (depth.write_mask != cur_state.depth.write_mask) {
|
|
|
|
glDepthMask(depth.write_mask);
|
|
|
|
}
|
|
|
|
|
2015-05-29 03:41:37 +02:00
|
|
|
// Color mask
|
|
|
|
if (color_mask.red_enabled != cur_state.color_mask.red_enabled ||
|
2016-09-18 02:38:01 +02:00
|
|
|
color_mask.green_enabled != cur_state.color_mask.green_enabled ||
|
|
|
|
color_mask.blue_enabled != cur_state.color_mask.blue_enabled ||
|
|
|
|
color_mask.alpha_enabled != cur_state.color_mask.alpha_enabled) {
|
|
|
|
glColorMask(color_mask.red_enabled, color_mask.green_enabled, color_mask.blue_enabled,
|
|
|
|
color_mask.alpha_enabled);
|
2015-05-29 03:41:37 +02:00
|
|
|
}
|
|
|
|
|
2015-05-19 06:21:33 +02:00
|
|
|
// Stencil test
|
|
|
|
if (stencil.test_enabled != cur_state.stencil.test_enabled) {
|
|
|
|
if (stencil.test_enabled) {
|
|
|
|
glEnable(GL_STENCIL_TEST);
|
|
|
|
} else {
|
|
|
|
glDisable(GL_STENCIL_TEST);
|
|
|
|
}
|
2015-05-25 20:34:09 +02:00
|
|
|
}
|
2015-05-19 06:21:33 +02:00
|
|
|
|
|
|
|
if (stencil.test_func != cur_state.stencil.test_func ||
|
2016-09-18 02:38:01 +02:00
|
|
|
stencil.test_ref != cur_state.stencil.test_ref ||
|
|
|
|
stencil.test_mask != cur_state.stencil.test_mask) {
|
2015-05-19 06:21:33 +02:00
|
|
|
glStencilFunc(stencil.test_func, stencil.test_ref, stencil.test_mask);
|
|
|
|
}
|
|
|
|
|
2015-08-20 17:11:09 +02:00
|
|
|
if (stencil.action_depth_fail != cur_state.stencil.action_depth_fail ||
|
2016-09-18 02:38:01 +02:00
|
|
|
stencil.action_depth_pass != cur_state.stencil.action_depth_pass ||
|
|
|
|
stencil.action_stencil_fail != cur_state.stencil.action_stencil_fail) {
|
|
|
|
glStencilOp(stencil.action_stencil_fail, stencil.action_depth_fail,
|
|
|
|
stencil.action_depth_pass);
|
2015-08-20 17:11:09 +02:00
|
|
|
}
|
|
|
|
|
2015-05-19 06:21:33 +02:00
|
|
|
// Stencil mask
|
|
|
|
if (stencil.write_mask != cur_state.stencil.write_mask) {
|
|
|
|
glStencilMask(stencil.write_mask);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Blending
|
|
|
|
if (blend.enabled != cur_state.blend.enabled) {
|
|
|
|
if (blend.enabled) {
|
2018-08-21 01:43:11 +02:00
|
|
|
ASSERT(!logic_op.enabled);
|
2015-05-19 06:21:33 +02:00
|
|
|
glEnable(GL_BLEND);
|
|
|
|
} else {
|
|
|
|
glDisable(GL_BLEND);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (blend.color.red != cur_state.blend.color.red ||
|
2016-09-18 02:38:01 +02:00
|
|
|
blend.color.green != cur_state.blend.color.green ||
|
|
|
|
blend.color.blue != cur_state.blend.color.blue ||
|
|
|
|
blend.color.alpha != cur_state.blend.color.alpha) {
|
|
|
|
glBlendColor(blend.color.red, blend.color.green, blend.color.blue, blend.color.alpha);
|
2015-05-19 06:21:33 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
if (blend.src_rgb_func != cur_state.blend.src_rgb_func ||
|
2016-09-18 02:38:01 +02:00
|
|
|
blend.dst_rgb_func != cur_state.blend.dst_rgb_func ||
|
|
|
|
blend.src_a_func != cur_state.blend.src_a_func ||
|
|
|
|
blend.dst_a_func != cur_state.blend.dst_a_func) {
|
|
|
|
glBlendFuncSeparate(blend.src_rgb_func, blend.dst_rgb_func, blend.src_a_func,
|
|
|
|
blend.dst_a_func);
|
2015-05-19 06:21:33 +02:00
|
|
|
}
|
|
|
|
|
2016-05-12 22:57:15 +02:00
|
|
|
if (blend.rgb_equation != cur_state.blend.rgb_equation ||
|
2016-09-18 02:38:01 +02:00
|
|
|
blend.a_equation != cur_state.blend.a_equation) {
|
2016-05-12 22:57:15 +02:00
|
|
|
glBlendEquationSeparate(blend.rgb_equation, blend.a_equation);
|
|
|
|
}
|
|
|
|
|
2018-08-21 01:43:11 +02:00
|
|
|
// Logic Operation
|
|
|
|
if (logic_op.enabled != cur_state.logic_op.enabled) {
|
|
|
|
if (logic_op.enabled) {
|
|
|
|
ASSERT(!blend.enabled);
|
|
|
|
glEnable(GL_COLOR_LOGIC_OP);
|
|
|
|
} else {
|
|
|
|
glDisable(GL_COLOR_LOGIC_OP);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (logic_op.operation != cur_state.logic_op.operation) {
|
|
|
|
glLogicOp(logic_op.operation);
|
2015-05-26 00:39:03 +02:00
|
|
|
}
|
|
|
|
|
2015-05-19 06:21:33 +02:00
|
|
|
// Textures
|
2018-07-20 07:04:32 +02:00
|
|
|
for (std::size_t i = 0; i < std::size(texture_units); ++i) {
|
|
|
|
const auto& texture_unit = texture_units[i];
|
|
|
|
const auto& cur_state_texture_unit = cur_state.texture_units[i];
|
|
|
|
|
|
|
|
if (texture_unit.texture_2d != cur_state_texture_unit.texture_2d) {
|
|
|
|
glActiveTexture(TextureUnits::MaxwellTexture(static_cast<int>(i)).Enum());
|
|
|
|
glBindTexture(GL_TEXTURE_2D, texture_unit.texture_2d);
|
2015-08-30 13:41:28 +02:00
|
|
|
}
|
2018-07-20 07:04:32 +02:00
|
|
|
if (texture_unit.sampler != cur_state_texture_unit.sampler) {
|
|
|
|
glBindSampler(static_cast<GLuint>(i), texture_unit.sampler);
|
2015-05-19 06:21:33 +02:00
|
|
|
}
|
2018-06-07 01:26:41 +02:00
|
|
|
// Update the texture swizzle
|
2018-07-20 07:04:32 +02:00
|
|
|
if (texture_unit.swizzle.r != cur_state_texture_unit.swizzle.r ||
|
|
|
|
texture_unit.swizzle.g != cur_state_texture_unit.swizzle.g ||
|
|
|
|
texture_unit.swizzle.b != cur_state_texture_unit.swizzle.b ||
|
|
|
|
texture_unit.swizzle.a != cur_state_texture_unit.swizzle.a) {
|
|
|
|
std::array<GLint, 4> mask = {texture_unit.swizzle.r, texture_unit.swizzle.g,
|
|
|
|
texture_unit.swizzle.b, texture_unit.swizzle.a};
|
2018-06-07 01:26:41 +02:00
|
|
|
glTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_SWIZZLE_RGBA, mask.data());
|
|
|
|
}
|
2015-05-19 06:21:33 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
// Framebuffer
|
2016-04-17 00:57:57 +02:00
|
|
|
if (draw.read_framebuffer != cur_state.draw.read_framebuffer) {
|
|
|
|
glBindFramebuffer(GL_READ_FRAMEBUFFER, draw.read_framebuffer);
|
|
|
|
}
|
|
|
|
if (draw.draw_framebuffer != cur_state.draw.draw_framebuffer) {
|
|
|
|
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, draw.draw_framebuffer);
|
2015-05-19 06:21:33 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
// Vertex array
|
|
|
|
if (draw.vertex_array != cur_state.draw.vertex_array) {
|
|
|
|
glBindVertexArray(draw.vertex_array);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Vertex buffer
|
|
|
|
if (draw.vertex_buffer != cur_state.draw.vertex_buffer) {
|
|
|
|
glBindBuffer(GL_ARRAY_BUFFER, draw.vertex_buffer);
|
|
|
|
}
|
|
|
|
|
2015-11-10 17:58:53 +01:00
|
|
|
// Uniform buffer
|
|
|
|
if (draw.uniform_buffer != cur_state.draw.uniform_buffer) {
|
|
|
|
glBindBuffer(GL_UNIFORM_BUFFER, draw.uniform_buffer);
|
|
|
|
}
|
|
|
|
|
2015-05-19 06:21:33 +02:00
|
|
|
// Shader program
|
|
|
|
if (draw.shader_program != cur_state.draw.shader_program) {
|
|
|
|
glUseProgram(draw.shader_program);
|
|
|
|
}
|
|
|
|
|
2018-03-19 22:05:15 +01:00
|
|
|
// Program pipeline
|
|
|
|
if (draw.program_pipeline != cur_state.draw.program_pipeline) {
|
|
|
|
glBindProgramPipeline(draw.program_pipeline);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Scissor test
|
|
|
|
if (scissor.enabled != cur_state.scissor.enabled) {
|
|
|
|
if (scissor.enabled) {
|
|
|
|
glEnable(GL_SCISSOR_TEST);
|
|
|
|
} else {
|
|
|
|
glDisable(GL_SCISSOR_TEST);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (scissor.x != cur_state.scissor.x || scissor.y != cur_state.scissor.y ||
|
|
|
|
scissor.width != cur_state.scissor.width || scissor.height != cur_state.scissor.height) {
|
|
|
|
glScissor(scissor.x, scissor.y, scissor.width, scissor.height);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (viewport.x != cur_state.viewport.x || viewport.y != cur_state.viewport.y ||
|
|
|
|
viewport.width != cur_state.viewport.width ||
|
|
|
|
viewport.height != cur_state.viewport.height) {
|
|
|
|
glViewport(viewport.x, viewport.y, viewport.width, viewport.height);
|
|
|
|
}
|
|
|
|
|
2017-08-17 09:46:59 +02:00
|
|
|
// Clip distance
|
|
|
|
for (size_t i = 0; i < clip_distance.size(); ++i) {
|
|
|
|
if (clip_distance[i] != cur_state.clip_distance[i]) {
|
|
|
|
if (clip_distance[i]) {
|
2017-09-27 01:26:09 +02:00
|
|
|
glEnable(GL_CLIP_DISTANCE0 + static_cast<GLenum>(i));
|
2017-08-17 09:46:59 +02:00
|
|
|
} else {
|
2017-09-27 01:26:09 +02:00
|
|
|
glDisable(GL_CLIP_DISTANCE0 + static_cast<GLenum>(i));
|
2017-08-17 09:46:59 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-05-19 06:21:33 +02:00
|
|
|
cur_state = *this;
|
|
|
|
}
|
2015-08-06 04:22:06 +02:00
|
|
|
|
2018-06-26 22:58:35 +02:00
|
|
|
OpenGLState& OpenGLState::UnbindTexture(GLuint handle) {
|
2018-03-19 22:05:15 +01:00
|
|
|
for (auto& unit : texture_units) {
|
2016-04-17 00:57:57 +02:00
|
|
|
if (unit.texture_2d == handle) {
|
2018-06-26 22:58:35 +02:00
|
|
|
unit.Unbind();
|
2015-08-06 04:22:06 +02:00
|
|
|
}
|
|
|
|
}
|
2018-03-19 22:05:15 +01:00
|
|
|
return *this;
|
2015-08-06 04:22:06 +02:00
|
|
|
}
|
|
|
|
|
2018-03-19 22:05:15 +01:00
|
|
|
OpenGLState& OpenGLState::ResetSampler(GLuint handle) {
|
|
|
|
for (auto& unit : texture_units) {
|
2016-04-17 00:57:57 +02:00
|
|
|
if (unit.sampler == handle) {
|
2015-08-30 13:41:28 +02:00
|
|
|
unit.sampler = 0;
|
|
|
|
}
|
|
|
|
}
|
2018-03-19 22:05:15 +01:00
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
|
|
|
OpenGLState& OpenGLState::ResetProgram(GLuint handle) {
|
|
|
|
if (draw.shader_program == handle) {
|
|
|
|
draw.shader_program = 0;
|
|
|
|
}
|
|
|
|
return *this;
|
2015-08-30 13:41:28 +02:00
|
|
|
}
|
|
|
|
|
2018-03-19 22:05:15 +01:00
|
|
|
OpenGLState& OpenGLState::ResetPipeline(GLuint handle) {
|
|
|
|
if (draw.program_pipeline == handle) {
|
|
|
|
draw.program_pipeline = 0;
|
2015-08-06 04:22:06 +02:00
|
|
|
}
|
2018-03-19 22:05:15 +01:00
|
|
|
return *this;
|
2015-08-06 04:22:06 +02:00
|
|
|
}
|
|
|
|
|
2018-03-19 22:05:15 +01:00
|
|
|
OpenGLState& OpenGLState::ResetBuffer(GLuint handle) {
|
|
|
|
if (draw.vertex_buffer == handle) {
|
|
|
|
draw.vertex_buffer = 0;
|
2015-08-06 04:22:06 +02:00
|
|
|
}
|
2018-03-19 22:05:15 +01:00
|
|
|
if (draw.uniform_buffer == handle) {
|
|
|
|
draw.uniform_buffer = 0;
|
2015-11-10 17:58:53 +01:00
|
|
|
}
|
2018-03-19 22:05:15 +01:00
|
|
|
return *this;
|
2015-08-06 04:22:06 +02:00
|
|
|
}
|
|
|
|
|
2018-03-19 22:05:15 +01:00
|
|
|
OpenGLState& OpenGLState::ResetVertexArray(GLuint handle) {
|
|
|
|
if (draw.vertex_array == handle) {
|
|
|
|
draw.vertex_array = 0;
|
2015-08-06 04:22:06 +02:00
|
|
|
}
|
2018-03-19 22:05:15 +01:00
|
|
|
return *this;
|
2015-08-06 04:22:06 +02:00
|
|
|
}
|
|
|
|
|
2018-03-19 22:05:15 +01:00
|
|
|
OpenGLState& OpenGLState::ResetFramebuffer(GLuint handle) {
|
|
|
|
if (draw.read_framebuffer == handle) {
|
|
|
|
draw.read_framebuffer = 0;
|
2016-04-17 00:57:57 +02:00
|
|
|
}
|
2018-03-19 22:05:15 +01:00
|
|
|
if (draw.draw_framebuffer == handle) {
|
|
|
|
draw.draw_framebuffer = 0;
|
2015-08-06 04:22:06 +02:00
|
|
|
}
|
2018-03-19 22:05:15 +01:00
|
|
|
return *this;
|
2015-08-06 04:22:06 +02:00
|
|
|
}
|
2018-08-21 10:18:27 +02:00
|
|
|
|
|
|
|
} // namespace OpenGL
|