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>
|
2018-09-22 00:22:40 +02:00
|
|
|
#include "common/assert.h"
|
2016-04-30 17:34:51 +02:00
|
|
|
#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;
|
2018-10-24 22:09:40 +02:00
|
|
|
bool OpenGLState::s_rgb_used;
|
2015-05-19 06:21:33 +02:00
|
|
|
OpenGLState::OpenGLState() {
|
|
|
|
// These all match default OpenGL values
|
2018-11-14 00:13:16 +01:00
|
|
|
geometry_shaders.enabled = false;
|
2018-10-24 22:09:40 +02:00
|
|
|
framebuffer_srgb.enabled = false;
|
2018-11-14 04:02:54 +01:00
|
|
|
multisample_control.alpha_to_coverage = false;
|
|
|
|
multisample_control.alpha_to_one = false;
|
2015-05-19 06:21:33 +02:00
|
|
|
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;
|
|
|
|
|
2018-10-26 01:04:13 +02:00
|
|
|
primitive_restart.enabled = false;
|
|
|
|
primitive_restart.index = 0;
|
2018-11-05 03:46:06 +01:00
|
|
|
for (auto& item : color_mask) {
|
|
|
|
item.red_enabled = GL_TRUE;
|
|
|
|
item.green_enabled = GL_TRUE;
|
|
|
|
item.blue_enabled = GL_TRUE;
|
|
|
|
item.alpha_enabled = GL_TRUE;
|
|
|
|
}
|
2015-05-19 06:21:33 +02:00
|
|
|
stencil.test_enabled = false;
|
2018-08-22 06:17:54 +02:00
|
|
|
auto reset_stencil = [](auto& config) {
|
|
|
|
config.test_func = GL_ALWAYS;
|
|
|
|
config.test_ref = 0;
|
|
|
|
config.test_mask = 0xFFFFFFFF;
|
|
|
|
config.write_mask = 0xFFFFFFFF;
|
|
|
|
config.action_depth_fail = GL_KEEP;
|
|
|
|
config.action_depth_pass = GL_KEEP;
|
|
|
|
config.action_stencil_fail = GL_KEEP;
|
|
|
|
};
|
|
|
|
reset_stencil(stencil.front);
|
|
|
|
reset_stencil(stencil.back);
|
2018-11-02 04:21:25 +01:00
|
|
|
for (auto& item : viewports) {
|
|
|
|
item.x = 0;
|
|
|
|
item.y = 0;
|
|
|
|
item.width = 0;
|
|
|
|
item.height = 0;
|
|
|
|
item.depth_range_near = 0.0f;
|
|
|
|
item.depth_range_far = 1.0f;
|
2018-11-14 00:13:16 +01:00
|
|
|
item.scissor.enabled = false;
|
|
|
|
item.scissor.x = 0;
|
|
|
|
item.scissor.y = 0;
|
|
|
|
item.scissor.width = 0;
|
|
|
|
item.scissor.height = 0;
|
2018-11-02 04:21:25 +01:00
|
|
|
}
|
|
|
|
for (auto& item : blend) {
|
|
|
|
item.enabled = true;
|
|
|
|
item.rgb_equation = GL_FUNC_ADD;
|
|
|
|
item.a_equation = GL_FUNC_ADD;
|
|
|
|
item.src_rgb_func = GL_ONE;
|
|
|
|
item.dst_rgb_func = GL_ZERO;
|
|
|
|
item.src_a_func = GL_ONE;
|
|
|
|
item.dst_a_func = GL_ZERO;
|
|
|
|
}
|
|
|
|
independant_blend.enabled = false;
|
|
|
|
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;
|
|
|
|
|
2017-08-17 09:46:59 +02:00
|
|
|
clip_distance = {};
|
2018-09-28 06:31:01 +02:00
|
|
|
|
|
|
|
point.size = 1;
|
2018-11-14 02:09:01 +01:00
|
|
|
fragment_color_clamp.enabled = false;
|
2018-11-27 00:31:44 +01:00
|
|
|
|
|
|
|
polygon_offset.fill_enable = false;
|
|
|
|
polygon_offset.line_enable = false;
|
|
|
|
polygon_offset.point_enable = false;
|
|
|
|
polygon_offset.factor = 0.0f;
|
|
|
|
polygon_offset.units = 0.0f;
|
|
|
|
polygon_offset.clamp = 0.0f;
|
2015-05-19 06:21:33 +02:00
|
|
|
}
|
|
|
|
|
2018-10-30 04:55:53 +01:00
|
|
|
void OpenGLState::ApplyDefaultState() {
|
|
|
|
glDisable(GL_FRAMEBUFFER_SRGB);
|
|
|
|
glDisable(GL_CULL_FACE);
|
|
|
|
glDisable(GL_DEPTH_TEST);
|
|
|
|
glDisable(GL_PRIMITIVE_RESTART);
|
|
|
|
glDisable(GL_STENCIL_TEST);
|
|
|
|
glEnable(GL_BLEND);
|
|
|
|
glDisable(GL_COLOR_LOGIC_OP);
|
|
|
|
glDisable(GL_SCISSOR_TEST);
|
|
|
|
}
|
|
|
|
|
|
|
|
void OpenGLState::ApplySRgb() const {
|
2018-10-24 22:09:40 +02:00
|
|
|
// sRGB
|
|
|
|
if (framebuffer_srgb.enabled != cur_state.framebuffer_srgb.enabled) {
|
|
|
|
if (framebuffer_srgb.enabled) {
|
|
|
|
// Track if sRGB is used
|
|
|
|
s_rgb_used = true;
|
|
|
|
glEnable(GL_FRAMEBUFFER_SRGB);
|
|
|
|
} else {
|
|
|
|
glDisable(GL_FRAMEBUFFER_SRGB);
|
|
|
|
}
|
|
|
|
}
|
2018-10-30 04:55:53 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
void OpenGLState::ApplyCulling() const {
|
2015-05-19 06:21:33 +02:00
|
|
|
// Culling
|
2018-10-30 04:55:53 +01:00
|
|
|
const bool cull_changed = cull.enabled != cur_state.cull.enabled;
|
|
|
|
if (cull_changed) {
|
2015-05-19 06:21:33 +02:00
|
|
|
if (cull.enabled) {
|
|
|
|
glEnable(GL_CULL_FACE);
|
|
|
|
} else {
|
|
|
|
glDisable(GL_CULL_FACE);
|
|
|
|
}
|
|
|
|
}
|
2018-10-30 04:55:53 +01:00
|
|
|
if (cull.enabled) {
|
|
|
|
if (cull_changed || cull.mode != cur_state.cull.mode) {
|
|
|
|
glCullFace(cull.mode);
|
|
|
|
}
|
2015-05-19 06:21:33 +02:00
|
|
|
|
2018-10-30 04:55:53 +01:00
|
|
|
if (cull_changed || cull.front_face != cur_state.cull.front_face) {
|
|
|
|
glFrontFace(cull.front_face);
|
|
|
|
}
|
2015-08-31 17:03:21 +02:00
|
|
|
}
|
2018-10-30 04:55:53 +01:00
|
|
|
}
|
2015-08-31 17:03:21 +02:00
|
|
|
|
2018-11-05 03:46:06 +01:00
|
|
|
void OpenGLState::ApplyColorMask() const {
|
2018-11-14 00:13:16 +01:00
|
|
|
if (GLAD_GL_ARB_viewport_array && independant_blend.enabled) {
|
2018-11-05 03:46:06 +01:00
|
|
|
for (size_t i = 0; i < Tegra::Engines::Maxwell3D::Regs::NumRenderTargets; i++) {
|
|
|
|
const auto& updated = color_mask[i];
|
|
|
|
const auto& current = cur_state.color_mask[i];
|
|
|
|
if (updated.red_enabled != current.red_enabled ||
|
|
|
|
updated.green_enabled != current.green_enabled ||
|
|
|
|
updated.blue_enabled != current.blue_enabled ||
|
|
|
|
updated.alpha_enabled != current.alpha_enabled) {
|
|
|
|
glColorMaski(static_cast<GLuint>(i), updated.red_enabled, updated.green_enabled,
|
|
|
|
updated.blue_enabled, updated.alpha_enabled);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
const auto& updated = color_mask[0];
|
|
|
|
const auto& current = cur_state.color_mask[0];
|
|
|
|
if (updated.red_enabled != current.red_enabled ||
|
|
|
|
updated.green_enabled != current.green_enabled ||
|
|
|
|
updated.blue_enabled != current.blue_enabled ||
|
|
|
|
updated.alpha_enabled != current.alpha_enabled) {
|
|
|
|
glColorMask(updated.red_enabled, updated.green_enabled, updated.blue_enabled,
|
|
|
|
updated.alpha_enabled);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-10-30 04:55:53 +01:00
|
|
|
void OpenGLState::ApplyDepth() const {
|
2015-05-19 06:21:33 +02:00
|
|
|
// Depth test
|
2018-10-30 04:55:53 +01:00
|
|
|
const bool depth_test_changed = depth.test_enabled != cur_state.depth.test_enabled;
|
|
|
|
if (depth_test_changed) {
|
2015-05-19 06:21:33 +02:00
|
|
|
if (depth.test_enabled) {
|
|
|
|
glEnable(GL_DEPTH_TEST);
|
|
|
|
} else {
|
|
|
|
glDisable(GL_DEPTH_TEST);
|
|
|
|
}
|
|
|
|
}
|
2018-10-30 04:55:53 +01:00
|
|
|
if (depth.test_enabled &&
|
|
|
|
(depth_test_changed || depth.test_func != cur_state.depth.test_func)) {
|
2015-05-19 06:21:33 +02:00
|
|
|
glDepthFunc(depth.test_func);
|
|
|
|
}
|
|
|
|
// Depth mask
|
|
|
|
if (depth.write_mask != cur_state.depth.write_mask) {
|
|
|
|
glDepthMask(depth.write_mask);
|
|
|
|
}
|
2018-10-30 04:55:53 +01:00
|
|
|
}
|
2018-10-26 00:39:57 +02:00
|
|
|
|
2018-10-30 04:55:53 +01:00
|
|
|
void OpenGLState::ApplyPrimitiveRestart() const {
|
|
|
|
const bool primitive_restart_changed =
|
|
|
|
primitive_restart.enabled != cur_state.primitive_restart.enabled;
|
|
|
|
if (primitive_restart_changed) {
|
2018-10-26 01:04:13 +02:00
|
|
|
if (primitive_restart.enabled) {
|
|
|
|
glEnable(GL_PRIMITIVE_RESTART);
|
|
|
|
} else {
|
|
|
|
glDisable(GL_PRIMITIVE_RESTART);
|
|
|
|
}
|
|
|
|
}
|
2018-10-30 04:55:53 +01:00
|
|
|
if (primitive_restart_changed ||
|
|
|
|
(primitive_restart.enabled &&
|
|
|
|
primitive_restart.index != cur_state.primitive_restart.index)) {
|
2018-10-26 01:04:13 +02:00
|
|
|
glPrimitiveRestartIndex(primitive_restart.index);
|
|
|
|
}
|
2018-10-30 04:55:53 +01:00
|
|
|
}
|
2018-10-26 01:04:13 +02:00
|
|
|
|
2018-10-30 04:55:53 +01:00
|
|
|
void OpenGLState::ApplyStencilTest() const {
|
|
|
|
const bool stencil_test_changed = stencil.test_enabled != cur_state.stencil.test_enabled;
|
|
|
|
if (stencil_test_changed) {
|
2015-05-19 06:21:33 +02:00
|
|
|
if (stencil.test_enabled) {
|
|
|
|
glEnable(GL_STENCIL_TEST);
|
|
|
|
} else {
|
|
|
|
glDisable(GL_STENCIL_TEST);
|
|
|
|
}
|
2015-05-25 20:34:09 +02:00
|
|
|
}
|
2018-10-30 04:55:53 +01:00
|
|
|
if (stencil.test_enabled) {
|
|
|
|
auto config_stencil = [stencil_test_changed](GLenum face, const auto& config,
|
|
|
|
const auto& prev_config) {
|
|
|
|
if (stencil_test_changed || config.test_func != prev_config.test_func ||
|
|
|
|
config.test_ref != prev_config.test_ref ||
|
|
|
|
config.test_mask != prev_config.test_mask) {
|
|
|
|
glStencilFuncSeparate(face, config.test_func, config.test_ref, config.test_mask);
|
|
|
|
}
|
|
|
|
if (stencil_test_changed || config.action_depth_fail != prev_config.action_depth_fail ||
|
|
|
|
config.action_depth_pass != prev_config.action_depth_pass ||
|
|
|
|
config.action_stencil_fail != prev_config.action_stencil_fail) {
|
|
|
|
glStencilOpSeparate(face, config.action_stencil_fail, config.action_depth_fail,
|
|
|
|
config.action_depth_pass);
|
|
|
|
}
|
|
|
|
if (config.write_mask != prev_config.write_mask) {
|
|
|
|
glStencilMaskSeparate(face, config.write_mask);
|
|
|
|
}
|
|
|
|
};
|
|
|
|
config_stencil(GL_FRONT, stencil.front, cur_state.stencil.front);
|
|
|
|
config_stencil(GL_BACK, stencil.back, cur_state.stencil.back);
|
|
|
|
}
|
|
|
|
}
|
2018-11-21 04:40:32 +01:00
|
|
|
// Viewport does not affects glClearBuffer so emulate viewport using scissor test
|
|
|
|
void OpenGLState::EmulateViewportWithScissor() {
|
|
|
|
auto& current = viewports[0];
|
|
|
|
if (current.scissor.enabled) {
|
|
|
|
const GLint left = std::max(current.x, current.scissor.x);
|
|
|
|
const GLint right =
|
|
|
|
std::max(current.x + current.width, current.scissor.x + current.scissor.width);
|
|
|
|
const GLint bottom = std::max(current.y, current.scissor.y);
|
|
|
|
const GLint top =
|
|
|
|
std::max(current.y + current.height, current.scissor.y + current.scissor.height);
|
|
|
|
current.scissor.x = std::max(left, 0);
|
|
|
|
current.scissor.y = std::max(bottom, 0);
|
|
|
|
current.scissor.width = std::max(right - left, 0);
|
|
|
|
current.scissor.height = std::max(top - bottom, 0);
|
|
|
|
} else {
|
|
|
|
current.scissor.enabled = true;
|
|
|
|
current.scissor.x = current.x;
|
|
|
|
current.scissor.y = current.y;
|
|
|
|
current.scissor.width = current.width;
|
|
|
|
current.scissor.height = current.height;
|
|
|
|
}
|
|
|
|
}
|
2018-10-30 04:55:53 +01:00
|
|
|
|
2018-11-02 04:21:25 +01:00
|
|
|
void OpenGLState::ApplyViewport() const {
|
2018-11-14 00:13:16 +01:00
|
|
|
if (GLAD_GL_ARB_viewport_array && geometry_shaders.enabled) {
|
|
|
|
for (GLuint i = 0; i < static_cast<GLuint>(Tegra::Engines::Maxwell3D::Regs::NumViewports);
|
|
|
|
i++) {
|
2018-11-02 04:21:25 +01:00
|
|
|
const auto& current = cur_state.viewports[i];
|
|
|
|
const auto& updated = viewports[i];
|
|
|
|
if (updated.x != current.x || updated.y != current.y ||
|
|
|
|
updated.width != current.width || updated.height != current.height) {
|
2018-11-21 04:40:32 +01:00
|
|
|
glViewportIndexedf(
|
|
|
|
i, static_cast<GLfloat>(updated.x), static_cast<GLfloat>(updated.y),
|
|
|
|
static_cast<GLfloat>(updated.width), static_cast<GLfloat>(updated.height));
|
2018-11-02 04:21:25 +01:00
|
|
|
}
|
|
|
|
if (updated.depth_range_near != current.depth_range_near ||
|
|
|
|
updated.depth_range_far != current.depth_range_far) {
|
|
|
|
glDepthRangeIndexed(i, updated.depth_range_near, updated.depth_range_far);
|
|
|
|
}
|
2018-11-14 00:13:16 +01:00
|
|
|
const bool scissor_changed = updated.scissor.enabled != current.scissor.enabled;
|
|
|
|
if (scissor_changed) {
|
|
|
|
if (updated.scissor.enabled) {
|
|
|
|
glEnablei(GL_SCISSOR_TEST, i);
|
|
|
|
} else {
|
|
|
|
glDisablei(GL_SCISSOR_TEST, i);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (updated.scissor.enabled &&
|
|
|
|
(scissor_changed || updated.scissor.x != current.scissor.x ||
|
|
|
|
updated.scissor.y != current.scissor.y ||
|
|
|
|
updated.scissor.width != current.scissor.width ||
|
|
|
|
updated.scissor.height != current.scissor.height)) {
|
|
|
|
glScissorIndexed(i, updated.scissor.x, updated.scissor.y, updated.scissor.width,
|
|
|
|
updated.scissor.height);
|
|
|
|
}
|
2018-11-02 04:21:25 +01:00
|
|
|
}
|
|
|
|
} else {
|
|
|
|
const auto& current = cur_state.viewports[0];
|
|
|
|
const auto& updated = viewports[0];
|
|
|
|
if (updated.x != current.x || updated.y != current.y || updated.width != current.width ||
|
|
|
|
updated.height != current.height) {
|
2018-11-21 04:40:32 +01:00
|
|
|
glViewport(updated.x, updated.y, updated.width, updated.height);
|
2018-11-02 04:21:25 +01:00
|
|
|
}
|
|
|
|
if (updated.depth_range_near != current.depth_range_near ||
|
|
|
|
updated.depth_range_far != current.depth_range_far) {
|
|
|
|
glDepthRange(updated.depth_range_near, updated.depth_range_far);
|
|
|
|
}
|
2018-11-14 00:13:16 +01:00
|
|
|
const bool scissor_changed = updated.scissor.enabled != current.scissor.enabled;
|
|
|
|
if (scissor_changed) {
|
|
|
|
if (updated.scissor.enabled) {
|
|
|
|
glEnable(GL_SCISSOR_TEST);
|
|
|
|
} else {
|
|
|
|
glDisable(GL_SCISSOR_TEST);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (updated.scissor.enabled && (scissor_changed || updated.scissor.x != current.scissor.x ||
|
|
|
|
updated.scissor.y != current.scissor.y ||
|
|
|
|
updated.scissor.width != current.scissor.width ||
|
|
|
|
updated.scissor.height != current.scissor.height)) {
|
|
|
|
glScissor(updated.scissor.x, updated.scissor.y, updated.scissor.width,
|
|
|
|
updated.scissor.height);
|
|
|
|
}
|
2018-11-02 04:21:25 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void OpenGLState::ApplyGlobalBlending() const {
|
|
|
|
const Blend& current = cur_state.blend[0];
|
|
|
|
const Blend& updated = blend[0];
|
|
|
|
const bool blend_changed = updated.enabled != current.enabled;
|
2018-10-30 04:55:53 +01:00
|
|
|
if (blend_changed) {
|
2018-11-02 04:21:25 +01:00
|
|
|
if (updated.enabled) {
|
2015-05-19 06:21:33 +02:00
|
|
|
glEnable(GL_BLEND);
|
|
|
|
} else {
|
|
|
|
glDisable(GL_BLEND);
|
|
|
|
}
|
|
|
|
}
|
2018-11-02 04:21:25 +01:00
|
|
|
if (!updated.enabled) {
|
|
|
|
return;
|
|
|
|
}
|
2018-11-18 07:44:48 +01:00
|
|
|
if (blend_changed || updated.src_rgb_func != current.src_rgb_func ||
|
|
|
|
updated.dst_rgb_func != current.dst_rgb_func || updated.src_a_func != current.src_a_func ||
|
|
|
|
updated.dst_a_func != current.dst_a_func) {
|
|
|
|
glBlendFuncSeparate(updated.src_rgb_func, updated.dst_rgb_func, updated.src_a_func,
|
|
|
|
updated.dst_a_func);
|
|
|
|
}
|
2018-11-02 04:21:25 +01:00
|
|
|
|
2018-11-18 07:44:48 +01:00
|
|
|
if (blend_changed || updated.rgb_equation != current.rgb_equation ||
|
|
|
|
updated.a_equation != current.a_equation) {
|
|
|
|
glBlendEquationSeparate(updated.rgb_equation, updated.a_equation);
|
2018-11-02 04:21:25 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-11-13 13:08:11 +01:00
|
|
|
void OpenGLState::ApplyTargetBlending(std::size_t target, bool force) const {
|
2018-11-02 04:21:25 +01:00
|
|
|
const Blend& updated = blend[target];
|
|
|
|
const Blend& current = cur_state.blend[target];
|
|
|
|
const bool blend_changed = updated.enabled != current.enabled || force;
|
|
|
|
if (blend_changed) {
|
|
|
|
if (updated.enabled) {
|
|
|
|
glEnablei(GL_BLEND, static_cast<GLuint>(target));
|
|
|
|
} else {
|
|
|
|
glDisablei(GL_BLEND, static_cast<GLuint>(target));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (!updated.enabled) {
|
|
|
|
return;
|
|
|
|
}
|
2018-11-18 07:44:48 +01:00
|
|
|
if (blend_changed || updated.src_rgb_func != current.src_rgb_func ||
|
|
|
|
updated.dst_rgb_func != current.dst_rgb_func || updated.src_a_func != current.src_a_func ||
|
|
|
|
updated.dst_a_func != current.dst_a_func) {
|
2018-11-18 01:28:14 +01:00
|
|
|
glBlendFuncSeparatei(static_cast<GLuint>(target), updated.src_rgb_func,
|
|
|
|
updated.dst_rgb_func, updated.src_a_func, updated.dst_a_func);
|
2018-11-18 07:44:48 +01:00
|
|
|
}
|
2015-05-19 06:21:33 +02:00
|
|
|
|
2018-11-18 07:44:48 +01:00
|
|
|
if (blend_changed || updated.rgb_equation != current.rgb_equation ||
|
|
|
|
updated.a_equation != current.a_equation) {
|
2018-11-18 01:28:14 +01:00
|
|
|
glBlendEquationSeparatei(static_cast<GLuint>(target), updated.rgb_equation,
|
|
|
|
updated.a_equation);
|
2018-11-02 04:21:25 +01:00
|
|
|
}
|
|
|
|
}
|
2015-05-19 06:21:33 +02:00
|
|
|
|
2018-11-02 04:21:25 +01:00
|
|
|
void OpenGLState::ApplyBlending() const {
|
|
|
|
if (independant_blend.enabled) {
|
|
|
|
for (size_t i = 0; i < Tegra::Engines::Maxwell3D::Regs::NumRenderTargets; i++) {
|
|
|
|
ApplyTargetBlending(i,
|
|
|
|
independant_blend.enabled != cur_state.independant_blend.enabled);
|
2018-10-30 04:55:53 +01:00
|
|
|
}
|
2018-11-02 04:21:25 +01:00
|
|
|
} else {
|
|
|
|
ApplyGlobalBlending();
|
|
|
|
}
|
|
|
|
if (blend_color.red != cur_state.blend_color.red ||
|
|
|
|
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);
|
2016-05-12 22:57:15 +02:00
|
|
|
}
|
2018-10-30 04:55:53 +01:00
|
|
|
}
|
2016-05-12 22:57:15 +02:00
|
|
|
|
2018-10-30 04:55:53 +01:00
|
|
|
void OpenGLState::ApplyLogicOp() const {
|
|
|
|
const bool logic_op_changed = logic_op.enabled != cur_state.logic_op.enabled;
|
|
|
|
if (logic_op_changed) {
|
2018-08-21 01:43:11 +02:00
|
|
|
if (logic_op.enabled) {
|
|
|
|
glEnable(GL_COLOR_LOGIC_OP);
|
|
|
|
} else {
|
|
|
|
glDisable(GL_COLOR_LOGIC_OP);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-10-30 04:55:53 +01:00
|
|
|
if (logic_op.enabled &&
|
|
|
|
(logic_op_changed || logic_op.operation != cur_state.logic_op.operation)) {
|
2018-08-21 01:43:11 +02:00
|
|
|
glLogicOp(logic_op.operation);
|
2015-05-26 00:39:03 +02:00
|
|
|
}
|
2018-10-30 04:55:53 +01:00
|
|
|
}
|
2015-05-26 00:39:03 +02:00
|
|
|
|
2018-11-27 00:31:44 +01:00
|
|
|
void OpenGLState::ApplyPolygonOffset() const {
|
|
|
|
|
|
|
|
const bool fill_enable_changed =
|
|
|
|
polygon_offset.fill_enable != cur_state.polygon_offset.fill_enable;
|
|
|
|
const bool line_enable_changed =
|
|
|
|
polygon_offset.line_enable != cur_state.polygon_offset.line_enable;
|
|
|
|
const bool point_enable_changed =
|
|
|
|
polygon_offset.point_enable != cur_state.polygon_offset.point_enable;
|
|
|
|
const bool factor_changed = polygon_offset.factor != cur_state.polygon_offset.factor;
|
|
|
|
const bool units_changed = polygon_offset.units != cur_state.polygon_offset.units;
|
|
|
|
const bool clamp_changed = polygon_offset.clamp != cur_state.polygon_offset.clamp;
|
|
|
|
|
|
|
|
if (fill_enable_changed) {
|
|
|
|
if (polygon_offset.fill_enable) {
|
|
|
|
glEnable(GL_POLYGON_OFFSET_FILL);
|
|
|
|
} else {
|
|
|
|
glDisable(GL_POLYGON_OFFSET_FILL);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (line_enable_changed) {
|
|
|
|
if (polygon_offset.line_enable) {
|
|
|
|
glEnable(GL_POLYGON_OFFSET_LINE);
|
|
|
|
} else {
|
|
|
|
glDisable(GL_POLYGON_OFFSET_LINE);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (point_enable_changed) {
|
|
|
|
if (polygon_offset.point_enable) {
|
|
|
|
glEnable(GL_POLYGON_OFFSET_POINT);
|
|
|
|
} else {
|
|
|
|
glDisable(GL_POLYGON_OFFSET_POINT);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if ((polygon_offset.fill_enable || polygon_offset.line_enable || polygon_offset.point_enable) &&
|
|
|
|
(factor_changed || units_changed || clamp_changed)) {
|
|
|
|
|
|
|
|
if (GLAD_GL_EXT_polygon_offset_clamp && polygon_offset.clamp != 0) {
|
|
|
|
glPolygonOffsetClamp(polygon_offset.factor, polygon_offset.units, polygon_offset.clamp);
|
|
|
|
} else {
|
|
|
|
glPolygonOffset(polygon_offset.factor, polygon_offset.units);
|
|
|
|
UNIMPLEMENTED_IF_MSG(polygon_offset.clamp != 0,
|
|
|
|
"Unimplemented Depth polygon offset clamp.");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-10-30 04:55:53 +01:00
|
|
|
void OpenGLState::ApplyTextures() const {
|
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];
|
|
|
|
|
2018-09-01 05:54:31 +02:00
|
|
|
if (texture_unit.texture != cur_state_texture_unit.texture) {
|
2018-07-20 07:04:32 +02:00
|
|
|
glActiveTexture(TextureUnits::MaxwellTexture(static_cast<int>(i)).Enum());
|
2018-09-01 05:54:31 +02:00
|
|
|
glBindTexture(texture_unit.target, texture_unit.texture);
|
2015-08-30 13:41:28 +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-09-01 05:54:31 +02:00
|
|
|
glTexParameteriv(texture_unit.target, GL_TEXTURE_SWIZZLE_RGBA, mask.data());
|
2018-06-07 01:26:41 +02:00
|
|
|
}
|
2015-05-19 06:21:33 +02:00
|
|
|
}
|
2018-10-30 04:55:53 +01:00
|
|
|
}
|
2015-05-19 06:21:33 +02:00
|
|
|
|
2018-10-30 04:55:53 +01:00
|
|
|
void OpenGLState::ApplySamplers() const {
|
|
|
|
bool has_delta{};
|
|
|
|
std::size_t first{}, last{};
|
|
|
|
std::array<GLuint, Tegra::Engines::Maxwell3D::Regs::NumTextureSamplers> samplers;
|
|
|
|
for (std::size_t i = 0; i < std::size(samplers); ++i) {
|
|
|
|
samplers[i] = texture_units[i].sampler;
|
|
|
|
if (samplers[i] != cur_state.texture_units[i].sampler) {
|
|
|
|
if (!has_delta) {
|
|
|
|
first = i;
|
|
|
|
has_delta = true;
|
2018-09-27 02:52:31 +02:00
|
|
|
}
|
2018-10-30 04:55:53 +01:00
|
|
|
last = i;
|
2018-09-27 02:52:31 +02:00
|
|
|
}
|
|
|
|
}
|
2018-10-30 04:55:53 +01:00
|
|
|
if (has_delta) {
|
|
|
|
glBindSamplers(static_cast<GLuint>(first), static_cast<GLsizei>(last - first + 1),
|
|
|
|
samplers.data());
|
|
|
|
}
|
|
|
|
}
|
2018-09-27 02:52:31 +02:00
|
|
|
|
2018-11-08 02:27:47 +01:00
|
|
|
void OpenGLState::ApplyFramebufferState() const {
|
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
|
|
|
}
|
2018-11-08 02:27:47 +01:00
|
|
|
}
|
2015-05-19 06:21:33 +02:00
|
|
|
|
2018-11-08 02:27:47 +01:00
|
|
|
void OpenGLState::ApplyVertexBufferState() const {
|
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);
|
|
|
|
}
|
2018-11-08 02:27:47 +01:00
|
|
|
}
|
2015-05-19 06:21:33 +02:00
|
|
|
|
2018-11-08 02:27:47 +01:00
|
|
|
void OpenGLState::Apply() const {
|
|
|
|
ApplyFramebufferState();
|
|
|
|
ApplyVertexBufferState();
|
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);
|
|
|
|
}
|
2017-08-17 09:46:59 +02:00
|
|
|
// Clip distance
|
2018-09-15 15:21:06 +02:00
|
|
|
for (std::size_t i = 0; i < clip_distance.size(); ++i) {
|
2017-08-17 09:46:59 +02:00
|
|
|
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
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2018-09-28 06:31:01 +02:00
|
|
|
// Point
|
|
|
|
if (point.size != cur_state.point.size) {
|
|
|
|
glPointSize(point.size);
|
|
|
|
}
|
2018-11-14 02:09:01 +01:00
|
|
|
if (GLAD_GL_ARB_color_buffer_float) {
|
|
|
|
if (fragment_color_clamp.enabled != cur_state.fragment_color_clamp.enabled) {
|
|
|
|
glClampColor(GL_CLAMP_FRAGMENT_COLOR_ARB,
|
|
|
|
fragment_color_clamp.enabled ? GL_TRUE : GL_FALSE);
|
|
|
|
}
|
|
|
|
}
|
2018-11-14 04:02:54 +01:00
|
|
|
if (multisample_control.alpha_to_coverage != cur_state.multisample_control.alpha_to_coverage) {
|
|
|
|
if (multisample_control.alpha_to_coverage) {
|
|
|
|
glEnable(GL_SAMPLE_ALPHA_TO_COVERAGE);
|
|
|
|
} else {
|
|
|
|
glDisable(GL_SAMPLE_ALPHA_TO_COVERAGE);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (multisample_control.alpha_to_one != cur_state.multisample_control.alpha_to_one) {
|
|
|
|
if (multisample_control.alpha_to_one) {
|
|
|
|
glEnable(GL_SAMPLE_ALPHA_TO_ONE);
|
|
|
|
} else {
|
|
|
|
glDisable(GL_SAMPLE_ALPHA_TO_ONE);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-11-05 03:46:06 +01:00
|
|
|
ApplyColorMask();
|
2018-11-02 04:21:25 +01:00
|
|
|
ApplyViewport();
|
2018-10-30 04:55:53 +01:00
|
|
|
ApplyStencilTest();
|
|
|
|
ApplySRgb();
|
|
|
|
ApplyCulling();
|
|
|
|
ApplyDepth();
|
|
|
|
ApplyPrimitiveRestart();
|
|
|
|
ApplyBlending();
|
|
|
|
ApplyLogicOp();
|
|
|
|
ApplyTextures();
|
|
|
|
ApplySamplers();
|
2018-11-27 00:31:44 +01:00
|
|
|
ApplyPolygonOffset();
|
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) {
|
2018-09-01 05:54:31 +02:00
|
|
|
if (unit.texture == 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
|