Merge pull request #3046 from ReinUsesLisp/clean-gl-state
gl_state: Miscellaneous clean up
This commit is contained in:
commit
2382bbe3ac
3 changed files with 156 additions and 291 deletions
|
@ -68,8 +68,6 @@ RasterizerOpenGL::RasterizerOpenGL(Core::System& system, Core::Frontend::EmuWind
|
||||||
ScreenInfo& info)
|
ScreenInfo& info)
|
||||||
: texture_cache{system, *this, device}, shader_cache{*this, system, emu_window, device},
|
: texture_cache{system, *this, device}, shader_cache{*this, system, emu_window, device},
|
||||||
system{system}, screen_info{info}, buffer_cache{*this, system, STREAM_BUFFER_SIZE} {
|
system{system}, screen_info{info}, buffer_cache{*this, system, STREAM_BUFFER_SIZE} {
|
||||||
OpenGLState::ApplyDefaultState();
|
|
||||||
|
|
||||||
shader_program_manager = std::make_unique<GLShader::ProgramManager>();
|
shader_program_manager = std::make_unique<GLShader::ProgramManager>();
|
||||||
state.draw.shader_program = 0;
|
state.draw.shader_program = 0;
|
||||||
state.Apply();
|
state.Apply();
|
||||||
|
|
|
@ -2,6 +2,7 @@
|
||||||
// Licensed under GPLv2 or any later version
|
// Licensed under GPLv2 or any later version
|
||||||
// Refer to the license.txt file included.
|
// Refer to the license.txt file included.
|
||||||
|
|
||||||
|
#include <algorithm>
|
||||||
#include <iterator>
|
#include <iterator>
|
||||||
#include <glad/glad.h>
|
#include <glad/glad.h>
|
||||||
#include "common/assert.h"
|
#include "common/assert.h"
|
||||||
|
@ -69,147 +70,29 @@ void Enable(GLenum cap, GLuint index, bool enable) {
|
||||||
}
|
}
|
||||||
|
|
||||||
void Enable(GLenum cap, bool& current_value, bool new_value) {
|
void Enable(GLenum cap, bool& current_value, bool new_value) {
|
||||||
if (UpdateValue(current_value, new_value))
|
if (UpdateValue(current_value, new_value)) {
|
||||||
Enable(cap, new_value);
|
Enable(cap, new_value);
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
void Enable(GLenum cap, GLuint index, bool& current_value, bool new_value) {
|
void Enable(GLenum cap, GLuint index, bool& current_value, bool new_value) {
|
||||||
if (UpdateValue(current_value, new_value))
|
if (UpdateValue(current_value, new_value)) {
|
||||||
Enable(cap, index, new_value);
|
Enable(cap, index, new_value);
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
} // namespace
|
} // Anonymous namespace
|
||||||
|
|
||||||
OpenGLState::OpenGLState() {
|
OpenGLState::OpenGLState() = default;
|
||||||
// These all match default OpenGL values
|
|
||||||
framebuffer_srgb.enabled = false;
|
|
||||||
|
|
||||||
multisample_control.alpha_to_coverage = false;
|
|
||||||
multisample_control.alpha_to_one = false;
|
|
||||||
|
|
||||||
cull.enabled = false;
|
|
||||||
cull.mode = GL_BACK;
|
|
||||||
cull.front_face = GL_CCW;
|
|
||||||
|
|
||||||
depth.test_enabled = false;
|
|
||||||
depth.test_func = GL_LESS;
|
|
||||||
depth.write_mask = GL_TRUE;
|
|
||||||
|
|
||||||
primitive_restart.enabled = false;
|
|
||||||
primitive_restart.index = 0;
|
|
||||||
|
|
||||||
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;
|
|
||||||
}
|
|
||||||
|
|
||||||
const auto ResetStencil = [](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;
|
|
||||||
};
|
|
||||||
stencil.test_enabled = false;
|
|
||||||
ResetStencil(stencil.front);
|
|
||||||
ResetStencil(stencil.back);
|
|
||||||
|
|
||||||
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;
|
|
||||||
item.scissor.enabled = false;
|
|
||||||
item.scissor.x = 0;
|
|
||||||
item.scissor.y = 0;
|
|
||||||
item.scissor.width = 0;
|
|
||||||
item.scissor.height = 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
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;
|
|
||||||
|
|
||||||
logic_op.enabled = false;
|
|
||||||
logic_op.operation = GL_COPY;
|
|
||||||
|
|
||||||
draw.read_framebuffer = 0;
|
|
||||||
draw.draw_framebuffer = 0;
|
|
||||||
draw.vertex_array = 0;
|
|
||||||
draw.shader_program = 0;
|
|
||||||
draw.program_pipeline = 0;
|
|
||||||
|
|
||||||
clip_distance = {};
|
|
||||||
|
|
||||||
point.size = 1;
|
|
||||||
|
|
||||||
fragment_color_clamp.enabled = false;
|
|
||||||
|
|
||||||
depth_clamp.far_plane = false;
|
|
||||||
depth_clamp.near_plane = false;
|
|
||||||
|
|
||||||
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;
|
|
||||||
|
|
||||||
alpha_test.enabled = false;
|
|
||||||
alpha_test.func = GL_ALWAYS;
|
|
||||||
alpha_test.ref = 0.0f;
|
|
||||||
}
|
|
||||||
|
|
||||||
void OpenGLState::SetDefaultViewports() {
|
void OpenGLState::SetDefaultViewports() {
|
||||||
for (auto& item : viewports) {
|
viewports.fill(Viewport{});
|
||||||
item.x = 0;
|
|
||||||
item.y = 0;
|
|
||||||
item.width = 0;
|
|
||||||
item.height = 0;
|
|
||||||
item.depth_range_near = 0.0f;
|
|
||||||
item.depth_range_far = 1.0f;
|
|
||||||
item.scissor.enabled = false;
|
|
||||||
item.scissor.x = 0;
|
|
||||||
item.scissor.y = 0;
|
|
||||||
item.scissor.width = 0;
|
|
||||||
item.scissor.height = 0;
|
|
||||||
}
|
|
||||||
|
|
||||||
depth_clamp.far_plane = false;
|
depth_clamp.far_plane = false;
|
||||||
depth_clamp.near_plane = false;
|
depth_clamp.near_plane = false;
|
||||||
}
|
}
|
||||||
|
|
||||||
void OpenGLState::ApplyDefaultState() {
|
void OpenGLState::ApplyFramebufferState() {
|
||||||
glEnable(GL_BLEND);
|
|
||||||
glDisable(GL_FRAMEBUFFER_SRGB);
|
|
||||||
glDisable(GL_CULL_FACE);
|
|
||||||
glDisable(GL_DEPTH_TEST);
|
|
||||||
glDisable(GL_PRIMITIVE_RESTART);
|
|
||||||
glDisable(GL_STENCIL_TEST);
|
|
||||||
glDisable(GL_COLOR_LOGIC_OP);
|
|
||||||
glDisable(GL_SCISSOR_TEST);
|
|
||||||
}
|
|
||||||
|
|
||||||
void OpenGLState::ApplyFramebufferState() const {
|
|
||||||
if (UpdateValue(cur_state.draw.read_framebuffer, draw.read_framebuffer)) {
|
if (UpdateValue(cur_state.draw.read_framebuffer, draw.read_framebuffer)) {
|
||||||
glBindFramebuffer(GL_READ_FRAMEBUFFER, draw.read_framebuffer);
|
glBindFramebuffer(GL_READ_FRAMEBUFFER, draw.read_framebuffer);
|
||||||
}
|
}
|
||||||
|
@ -218,52 +101,52 @@ void OpenGLState::ApplyFramebufferState() const {
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
void OpenGLState::ApplyVertexArrayState() const {
|
void OpenGLState::ApplyVertexArrayState() {
|
||||||
if (UpdateValue(cur_state.draw.vertex_array, draw.vertex_array)) {
|
if (UpdateValue(cur_state.draw.vertex_array, draw.vertex_array)) {
|
||||||
glBindVertexArray(draw.vertex_array);
|
glBindVertexArray(draw.vertex_array);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
void OpenGLState::ApplyShaderProgram() const {
|
void OpenGLState::ApplyShaderProgram() {
|
||||||
if (UpdateValue(cur_state.draw.shader_program, draw.shader_program)) {
|
if (UpdateValue(cur_state.draw.shader_program, draw.shader_program)) {
|
||||||
glUseProgram(draw.shader_program);
|
glUseProgram(draw.shader_program);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
void OpenGLState::ApplyProgramPipeline() const {
|
void OpenGLState::ApplyProgramPipeline() {
|
||||||
if (UpdateValue(cur_state.draw.program_pipeline, draw.program_pipeline)) {
|
if (UpdateValue(cur_state.draw.program_pipeline, draw.program_pipeline)) {
|
||||||
glBindProgramPipeline(draw.program_pipeline);
|
glBindProgramPipeline(draw.program_pipeline);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
void OpenGLState::ApplyClipDistances() const {
|
void OpenGLState::ApplyClipDistances() {
|
||||||
for (std::size_t i = 0; i < clip_distance.size(); ++i) {
|
for (std::size_t i = 0; i < clip_distance.size(); ++i) {
|
||||||
Enable(GL_CLIP_DISTANCE0 + static_cast<GLenum>(i), cur_state.clip_distance[i],
|
Enable(GL_CLIP_DISTANCE0 + static_cast<GLenum>(i), cur_state.clip_distance[i],
|
||||||
clip_distance[i]);
|
clip_distance[i]);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
void OpenGLState::ApplyPointSize() const {
|
void OpenGLState::ApplyPointSize() {
|
||||||
if (UpdateValue(cur_state.point.size, point.size)) {
|
if (UpdateValue(cur_state.point.size, point.size)) {
|
||||||
glPointSize(point.size);
|
glPointSize(point.size);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
void OpenGLState::ApplyFragmentColorClamp() const {
|
void OpenGLState::ApplyFragmentColorClamp() {
|
||||||
if (UpdateValue(cur_state.fragment_color_clamp.enabled, fragment_color_clamp.enabled)) {
|
if (UpdateValue(cur_state.fragment_color_clamp.enabled, fragment_color_clamp.enabled)) {
|
||||||
glClampColor(GL_CLAMP_FRAGMENT_COLOR_ARB,
|
glClampColor(GL_CLAMP_FRAGMENT_COLOR_ARB,
|
||||||
fragment_color_clamp.enabled ? GL_TRUE : GL_FALSE);
|
fragment_color_clamp.enabled ? GL_TRUE : GL_FALSE);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
void OpenGLState::ApplyMultisample() const {
|
void OpenGLState::ApplyMultisample() {
|
||||||
Enable(GL_SAMPLE_ALPHA_TO_COVERAGE, cur_state.multisample_control.alpha_to_coverage,
|
Enable(GL_SAMPLE_ALPHA_TO_COVERAGE, cur_state.multisample_control.alpha_to_coverage,
|
||||||
multisample_control.alpha_to_coverage);
|
multisample_control.alpha_to_coverage);
|
||||||
Enable(GL_SAMPLE_ALPHA_TO_ONE, cur_state.multisample_control.alpha_to_one,
|
Enable(GL_SAMPLE_ALPHA_TO_ONE, cur_state.multisample_control.alpha_to_one,
|
||||||
multisample_control.alpha_to_one);
|
multisample_control.alpha_to_one);
|
||||||
}
|
}
|
||||||
|
|
||||||
void OpenGLState::ApplyDepthClamp() const {
|
void OpenGLState::ApplyDepthClamp() {
|
||||||
if (depth_clamp.far_plane == cur_state.depth_clamp.far_plane &&
|
if (depth_clamp.far_plane == cur_state.depth_clamp.far_plane &&
|
||||||
depth_clamp.near_plane == cur_state.depth_clamp.near_plane) {
|
depth_clamp.near_plane == cur_state.depth_clamp.near_plane) {
|
||||||
return;
|
return;
|
||||||
|
@ -276,7 +159,7 @@ void OpenGLState::ApplyDepthClamp() const {
|
||||||
Enable(GL_DEPTH_CLAMP, depth_clamp.far_plane || depth_clamp.near_plane);
|
Enable(GL_DEPTH_CLAMP, depth_clamp.far_plane || depth_clamp.near_plane);
|
||||||
}
|
}
|
||||||
|
|
||||||
void OpenGLState::ApplySRgb() const {
|
void OpenGLState::ApplySRgb() {
|
||||||
if (cur_state.framebuffer_srgb.enabled == framebuffer_srgb.enabled)
|
if (cur_state.framebuffer_srgb.enabled == framebuffer_srgb.enabled)
|
||||||
return;
|
return;
|
||||||
cur_state.framebuffer_srgb.enabled = framebuffer_srgb.enabled;
|
cur_state.framebuffer_srgb.enabled = framebuffer_srgb.enabled;
|
||||||
|
@ -287,7 +170,7 @@ void OpenGLState::ApplySRgb() const {
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
void OpenGLState::ApplyCulling() const {
|
void OpenGLState::ApplyCulling() {
|
||||||
Enable(GL_CULL_FACE, cur_state.cull.enabled, cull.enabled);
|
Enable(GL_CULL_FACE, cur_state.cull.enabled, cull.enabled);
|
||||||
|
|
||||||
if (UpdateValue(cur_state.cull.mode, cull.mode)) {
|
if (UpdateValue(cur_state.cull.mode, cull.mode)) {
|
||||||
|
@ -299,7 +182,12 @@ void OpenGLState::ApplyCulling() const {
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
void OpenGLState::ApplyColorMask() const {
|
void OpenGLState::ApplyColorMask() {
|
||||||
|
if (!dirty.color_mask) {
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
dirty.color_mask = false;
|
||||||
|
|
||||||
for (std::size_t i = 0; i < Maxwell::NumRenderTargets; ++i) {
|
for (std::size_t i = 0; i < Maxwell::NumRenderTargets; ++i) {
|
||||||
const auto& updated = color_mask[i];
|
const auto& updated = color_mask[i];
|
||||||
auto& current = cur_state.color_mask[i];
|
auto& current = cur_state.color_mask[i];
|
||||||
|
@ -314,7 +202,7 @@ void OpenGLState::ApplyColorMask() const {
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
void OpenGLState::ApplyDepth() const {
|
void OpenGLState::ApplyDepth() {
|
||||||
Enable(GL_DEPTH_TEST, cur_state.depth.test_enabled, depth.test_enabled);
|
Enable(GL_DEPTH_TEST, cur_state.depth.test_enabled, depth.test_enabled);
|
||||||
|
|
||||||
if (cur_state.depth.test_func != depth.test_func) {
|
if (cur_state.depth.test_func != depth.test_func) {
|
||||||
|
@ -328,7 +216,7 @@ void OpenGLState::ApplyDepth() const {
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
void OpenGLState::ApplyPrimitiveRestart() const {
|
void OpenGLState::ApplyPrimitiveRestart() {
|
||||||
Enable(GL_PRIMITIVE_RESTART, cur_state.primitive_restart.enabled, primitive_restart.enabled);
|
Enable(GL_PRIMITIVE_RESTART, cur_state.primitive_restart.enabled, primitive_restart.enabled);
|
||||||
|
|
||||||
if (cur_state.primitive_restart.index != primitive_restart.index) {
|
if (cur_state.primitive_restart.index != primitive_restart.index) {
|
||||||
|
@ -337,7 +225,12 @@ void OpenGLState::ApplyPrimitiveRestart() const {
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
void OpenGLState::ApplyStencilTest() const {
|
void OpenGLState::ApplyStencilTest() {
|
||||||
|
if (!dirty.stencil_state) {
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
dirty.stencil_state = false;
|
||||||
|
|
||||||
Enable(GL_STENCIL_TEST, cur_state.stencil.test_enabled, stencil.test_enabled);
|
Enable(GL_STENCIL_TEST, cur_state.stencil.test_enabled, stencil.test_enabled);
|
||||||
|
|
||||||
const auto ConfigStencil = [](GLenum face, const auto& config, auto& current) {
|
const auto ConfigStencil = [](GLenum face, const auto& config, auto& current) {
|
||||||
|
@ -366,7 +259,7 @@ void OpenGLState::ApplyStencilTest() const {
|
||||||
ConfigStencil(GL_BACK, stencil.back, cur_state.stencil.back);
|
ConfigStencil(GL_BACK, stencil.back, cur_state.stencil.back);
|
||||||
}
|
}
|
||||||
|
|
||||||
void OpenGLState::ApplyViewport() const {
|
void OpenGLState::ApplyViewport() {
|
||||||
for (GLuint i = 0; i < static_cast<GLuint>(Maxwell::NumViewports); ++i) {
|
for (GLuint i = 0; i < static_cast<GLuint>(Maxwell::NumViewports); ++i) {
|
||||||
const auto& updated = viewports[i];
|
const auto& updated = viewports[i];
|
||||||
auto& current = cur_state.viewports[i];
|
auto& current = cur_state.viewports[i];
|
||||||
|
@ -403,7 +296,7 @@ void OpenGLState::ApplyViewport() const {
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
void OpenGLState::ApplyGlobalBlending() const {
|
void OpenGLState::ApplyGlobalBlending() {
|
||||||
const Blend& updated = blend[0];
|
const Blend& updated = blend[0];
|
||||||
Blend& current = cur_state.blend[0];
|
Blend& current = cur_state.blend[0];
|
||||||
|
|
||||||
|
@ -427,7 +320,7 @@ void OpenGLState::ApplyGlobalBlending() const {
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
void OpenGLState::ApplyTargetBlending(std::size_t target, bool force) const {
|
void OpenGLState::ApplyTargetBlending(std::size_t target, bool force) {
|
||||||
const Blend& updated = blend[target];
|
const Blend& updated = blend[target];
|
||||||
Blend& current = cur_state.blend[target];
|
Blend& current = cur_state.blend[target];
|
||||||
|
|
||||||
|
@ -451,7 +344,12 @@ void OpenGLState::ApplyTargetBlending(std::size_t target, bool force) const {
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
void OpenGLState::ApplyBlending() const {
|
void OpenGLState::ApplyBlending() {
|
||||||
|
if (!dirty.blend_state) {
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
dirty.blend_state = false;
|
||||||
|
|
||||||
if (independant_blend.enabled) {
|
if (independant_blend.enabled) {
|
||||||
const bool force = independant_blend.enabled != cur_state.independant_blend.enabled;
|
const bool force = independant_blend.enabled != cur_state.independant_blend.enabled;
|
||||||
for (std::size_t target = 0; target < Maxwell::NumRenderTargets; ++target) {
|
for (std::size_t target = 0; target < Maxwell::NumRenderTargets; ++target) {
|
||||||
|
@ -470,7 +368,7 @@ void OpenGLState::ApplyBlending() const {
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
void OpenGLState::ApplyLogicOp() const {
|
void OpenGLState::ApplyLogicOp() {
|
||||||
Enable(GL_COLOR_LOGIC_OP, cur_state.logic_op.enabled, logic_op.enabled);
|
Enable(GL_COLOR_LOGIC_OP, cur_state.logic_op.enabled, logic_op.enabled);
|
||||||
|
|
||||||
if (UpdateValue(cur_state.logic_op.operation, logic_op.operation)) {
|
if (UpdateValue(cur_state.logic_op.operation, logic_op.operation)) {
|
||||||
|
@ -478,7 +376,12 @@ void OpenGLState::ApplyLogicOp() const {
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
void OpenGLState::ApplyPolygonOffset() const {
|
void OpenGLState::ApplyPolygonOffset() {
|
||||||
|
if (!dirty.polygon_offset) {
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
dirty.polygon_offset = false;
|
||||||
|
|
||||||
Enable(GL_POLYGON_OFFSET_FILL, cur_state.polygon_offset.fill_enable,
|
Enable(GL_POLYGON_OFFSET_FILL, cur_state.polygon_offset.fill_enable,
|
||||||
polygon_offset.fill_enable);
|
polygon_offset.fill_enable);
|
||||||
Enable(GL_POLYGON_OFFSET_LINE, cur_state.polygon_offset.line_enable,
|
Enable(GL_POLYGON_OFFSET_LINE, cur_state.polygon_offset.line_enable,
|
||||||
|
@ -499,7 +402,7 @@ void OpenGLState::ApplyPolygonOffset() const {
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
void OpenGLState::ApplyAlphaTest() const {
|
void OpenGLState::ApplyAlphaTest() {
|
||||||
Enable(GL_ALPHA_TEST, cur_state.alpha_test.enabled, alpha_test.enabled);
|
Enable(GL_ALPHA_TEST, cur_state.alpha_test.enabled, alpha_test.enabled);
|
||||||
if (UpdateTie(std::tie(cur_state.alpha_test.func, cur_state.alpha_test.ref),
|
if (UpdateTie(std::tie(cur_state.alpha_test.func, cur_state.alpha_test.ref),
|
||||||
std::tie(alpha_test.func, alpha_test.ref))) {
|
std::tie(alpha_test.func, alpha_test.ref))) {
|
||||||
|
@ -507,19 +410,19 @@ void OpenGLState::ApplyAlphaTest() const {
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
void OpenGLState::ApplyTextures() const {
|
void OpenGLState::ApplyTextures() {
|
||||||
if (const auto update = UpdateArray(cur_state.textures, textures)) {
|
if (const auto update = UpdateArray(cur_state.textures, textures)) {
|
||||||
glBindTextures(update->first, update->second, textures.data() + update->first);
|
glBindTextures(update->first, update->second, textures.data() + update->first);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
void OpenGLState::ApplySamplers() const {
|
void OpenGLState::ApplySamplers() {
|
||||||
if (const auto update = UpdateArray(cur_state.samplers, samplers)) {
|
if (const auto update = UpdateArray(cur_state.samplers, samplers)) {
|
||||||
glBindSamplers(update->first, update->second, samplers.data() + update->first);
|
glBindSamplers(update->first, update->second, samplers.data() + update->first);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
void OpenGLState::ApplyImages() const {
|
void OpenGLState::ApplyImages() {
|
||||||
if (const auto update = UpdateArray(cur_state.images, images)) {
|
if (const auto update = UpdateArray(cur_state.images, images)) {
|
||||||
glBindImageTextures(update->first, update->second, images.data() + update->first);
|
glBindImageTextures(update->first, update->second, images.data() + update->first);
|
||||||
}
|
}
|
||||||
|
@ -535,32 +438,20 @@ void OpenGLState::Apply() {
|
||||||
ApplyPointSize();
|
ApplyPointSize();
|
||||||
ApplyFragmentColorClamp();
|
ApplyFragmentColorClamp();
|
||||||
ApplyMultisample();
|
ApplyMultisample();
|
||||||
if (dirty.color_mask) {
|
|
||||||
ApplyColorMask();
|
ApplyColorMask();
|
||||||
dirty.color_mask = false;
|
|
||||||
}
|
|
||||||
ApplyDepthClamp();
|
ApplyDepthClamp();
|
||||||
ApplyViewport();
|
ApplyViewport();
|
||||||
if (dirty.stencil_state) {
|
|
||||||
ApplyStencilTest();
|
ApplyStencilTest();
|
||||||
dirty.stencil_state = false;
|
|
||||||
}
|
|
||||||
ApplySRgb();
|
ApplySRgb();
|
||||||
ApplyCulling();
|
ApplyCulling();
|
||||||
ApplyDepth();
|
ApplyDepth();
|
||||||
ApplyPrimitiveRestart();
|
ApplyPrimitiveRestart();
|
||||||
if (dirty.blend_state) {
|
|
||||||
ApplyBlending();
|
ApplyBlending();
|
||||||
dirty.blend_state = false;
|
|
||||||
}
|
|
||||||
ApplyLogicOp();
|
ApplyLogicOp();
|
||||||
ApplyTextures();
|
ApplyTextures();
|
||||||
ApplySamplers();
|
ApplySamplers();
|
||||||
ApplyImages();
|
ApplyImages();
|
||||||
if (dirty.polygon_offset) {
|
|
||||||
ApplyPolygonOffset();
|
ApplyPolygonOffset();
|
||||||
dirty.polygon_offset = false;
|
|
||||||
}
|
|
||||||
ApplyAlphaTest();
|
ApplyAlphaTest();
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
|
@ -5,168 +5,146 @@
|
||||||
#pragma once
|
#pragma once
|
||||||
|
|
||||||
#include <array>
|
#include <array>
|
||||||
|
#include <type_traits>
|
||||||
#include <glad/glad.h>
|
#include <glad/glad.h>
|
||||||
#include "video_core/engines/maxwell_3d.h"
|
#include "video_core/engines/maxwell_3d.h"
|
||||||
|
|
||||||
namespace OpenGL {
|
namespace OpenGL {
|
||||||
|
|
||||||
namespace TextureUnits {
|
|
||||||
|
|
||||||
struct TextureUnit {
|
|
||||||
GLint id;
|
|
||||||
constexpr GLenum Enum() const {
|
|
||||||
return static_cast<GLenum>(GL_TEXTURE0 + id);
|
|
||||||
}
|
|
||||||
};
|
|
||||||
|
|
||||||
constexpr TextureUnit MaxwellTexture(int unit) {
|
|
||||||
return TextureUnit{unit};
|
|
||||||
}
|
|
||||||
|
|
||||||
constexpr TextureUnit LightingLUT{3};
|
|
||||||
constexpr TextureUnit FogLUT{4};
|
|
||||||
constexpr TextureUnit ProcTexNoiseLUT{5};
|
|
||||||
constexpr TextureUnit ProcTexColorMap{6};
|
|
||||||
constexpr TextureUnit ProcTexAlphaMap{7};
|
|
||||||
constexpr TextureUnit ProcTexLUT{8};
|
|
||||||
constexpr TextureUnit ProcTexDiffLUT{9};
|
|
||||||
|
|
||||||
} // namespace TextureUnits
|
|
||||||
|
|
||||||
class OpenGLState {
|
class OpenGLState {
|
||||||
public:
|
public:
|
||||||
struct {
|
struct {
|
||||||
bool enabled; // GL_FRAMEBUFFER_SRGB
|
bool enabled = false; // GL_FRAMEBUFFER_SRGB
|
||||||
} framebuffer_srgb;
|
} framebuffer_srgb;
|
||||||
|
|
||||||
struct {
|
struct {
|
||||||
bool alpha_to_coverage; // GL_ALPHA_TO_COVERAGE
|
bool alpha_to_coverage = false; // GL_ALPHA_TO_COVERAGE
|
||||||
bool alpha_to_one; // GL_ALPHA_TO_ONE
|
bool alpha_to_one = false; // GL_ALPHA_TO_ONE
|
||||||
} multisample_control;
|
} multisample_control;
|
||||||
|
|
||||||
struct {
|
struct {
|
||||||
bool enabled; // GL_CLAMP_FRAGMENT_COLOR_ARB
|
bool enabled = false; // GL_CLAMP_FRAGMENT_COLOR_ARB
|
||||||
} fragment_color_clamp;
|
} fragment_color_clamp;
|
||||||
|
|
||||||
struct {
|
struct {
|
||||||
bool far_plane;
|
bool far_plane = false;
|
||||||
bool near_plane;
|
bool near_plane = false;
|
||||||
} depth_clamp; // GL_DEPTH_CLAMP
|
} depth_clamp; // GL_DEPTH_CLAMP
|
||||||
|
|
||||||
struct {
|
struct {
|
||||||
bool enabled; // GL_CULL_FACE
|
bool enabled = false; // GL_CULL_FACE
|
||||||
GLenum mode; // GL_CULL_FACE_MODE
|
GLenum mode = GL_BACK; // GL_CULL_FACE_MODE
|
||||||
GLenum front_face; // GL_FRONT_FACE
|
GLenum front_face = GL_CCW; // GL_FRONT_FACE
|
||||||
} cull;
|
} cull;
|
||||||
|
|
||||||
struct {
|
struct {
|
||||||
bool test_enabled; // GL_DEPTH_TEST
|
bool test_enabled = false; // GL_DEPTH_TEST
|
||||||
GLenum test_func; // GL_DEPTH_FUNC
|
GLboolean write_mask = GL_TRUE; // GL_DEPTH_WRITEMASK
|
||||||
GLboolean write_mask; // GL_DEPTH_WRITEMASK
|
GLenum test_func = GL_LESS; // GL_DEPTH_FUNC
|
||||||
} depth;
|
} depth;
|
||||||
|
|
||||||
struct {
|
struct {
|
||||||
bool enabled;
|
bool enabled = false;
|
||||||
GLuint index;
|
GLuint index = 0;
|
||||||
} primitive_restart; // GL_PRIMITIVE_RESTART
|
} primitive_restart; // GL_PRIMITIVE_RESTART
|
||||||
|
|
||||||
struct ColorMask {
|
struct ColorMask {
|
||||||
GLboolean red_enabled;
|
GLboolean red_enabled = GL_TRUE;
|
||||||
GLboolean green_enabled;
|
GLboolean green_enabled = GL_TRUE;
|
||||||
GLboolean blue_enabled;
|
GLboolean blue_enabled = GL_TRUE;
|
||||||
GLboolean alpha_enabled;
|
GLboolean alpha_enabled = GL_TRUE;
|
||||||
};
|
};
|
||||||
std::array<ColorMask, Tegra::Engines::Maxwell3D::Regs::NumRenderTargets>
|
std::array<ColorMask, Tegra::Engines::Maxwell3D::Regs::NumRenderTargets>
|
||||||
color_mask; // GL_COLOR_WRITEMASK
|
color_mask; // GL_COLOR_WRITEMASK
|
||||||
struct {
|
struct {
|
||||||
bool test_enabled; // GL_STENCIL_TEST
|
bool test_enabled = false; // GL_STENCIL_TEST
|
||||||
struct {
|
struct {
|
||||||
GLenum test_func; // GL_STENCIL_FUNC
|
GLenum test_func = GL_ALWAYS; // GL_STENCIL_FUNC
|
||||||
GLint test_ref; // GL_STENCIL_REF
|
GLint test_ref = 0; // GL_STENCIL_REF
|
||||||
GLuint test_mask; // GL_STENCIL_VALUE_MASK
|
GLuint test_mask = 0xFFFFFFFF; // GL_STENCIL_VALUE_MASK
|
||||||
GLuint write_mask; // GL_STENCIL_WRITEMASK
|
GLuint write_mask = 0xFFFFFFFF; // GL_STENCIL_WRITEMASK
|
||||||
GLenum action_stencil_fail; // GL_STENCIL_FAIL
|
GLenum action_stencil_fail = GL_KEEP; // GL_STENCIL_FAIL
|
||||||
GLenum action_depth_fail; // GL_STENCIL_PASS_DEPTH_FAIL
|
GLenum action_depth_fail = GL_KEEP; // GL_STENCIL_PASS_DEPTH_FAIL
|
||||||
GLenum action_depth_pass; // GL_STENCIL_PASS_DEPTH_PASS
|
GLenum action_depth_pass = GL_KEEP; // GL_STENCIL_PASS_DEPTH_PASS
|
||||||
} front, back;
|
} front, back;
|
||||||
} stencil;
|
} stencil;
|
||||||
|
|
||||||
struct Blend {
|
struct Blend {
|
||||||
bool enabled; // GL_BLEND
|
bool enabled = false; // GL_BLEND
|
||||||
GLenum rgb_equation; // GL_BLEND_EQUATION_RGB
|
GLenum rgb_equation = GL_FUNC_ADD; // GL_BLEND_EQUATION_RGB
|
||||||
GLenum a_equation; // GL_BLEND_EQUATION_ALPHA
|
GLenum a_equation = GL_FUNC_ADD; // GL_BLEND_EQUATION_ALPHA
|
||||||
GLenum src_rgb_func; // GL_BLEND_SRC_RGB
|
GLenum src_rgb_func = GL_ONE; // GL_BLEND_SRC_RGB
|
||||||
GLenum dst_rgb_func; // GL_BLEND_DST_RGB
|
GLenum dst_rgb_func = GL_ZERO; // GL_BLEND_DST_RGB
|
||||||
GLenum src_a_func; // GL_BLEND_SRC_ALPHA
|
GLenum src_a_func = GL_ONE; // GL_BLEND_SRC_ALPHA
|
||||||
GLenum dst_a_func; // GL_BLEND_DST_ALPHA
|
GLenum dst_a_func = GL_ZERO; // GL_BLEND_DST_ALPHA
|
||||||
};
|
};
|
||||||
std::array<Blend, Tegra::Engines::Maxwell3D::Regs::NumRenderTargets> blend;
|
std::array<Blend, Tegra::Engines::Maxwell3D::Regs::NumRenderTargets> blend;
|
||||||
|
|
||||||
struct {
|
struct {
|
||||||
bool enabled;
|
bool enabled = false;
|
||||||
} independant_blend;
|
} independant_blend;
|
||||||
|
|
||||||
struct {
|
struct {
|
||||||
GLclampf red;
|
GLclampf red = 0.0f;
|
||||||
GLclampf green;
|
GLclampf green = 0.0f;
|
||||||
GLclampf blue;
|
GLclampf blue = 0.0f;
|
||||||
GLclampf alpha;
|
GLclampf alpha = 0.0f;
|
||||||
} blend_color; // GL_BLEND_COLOR
|
} blend_color; // GL_BLEND_COLOR
|
||||||
|
|
||||||
struct {
|
struct {
|
||||||
bool enabled; // GL_LOGIC_OP_MODE
|
bool enabled = false; // GL_LOGIC_OP_MODE
|
||||||
GLenum operation;
|
GLenum operation = GL_COPY;
|
||||||
} logic_op;
|
} logic_op;
|
||||||
|
|
||||||
std::array<GLuint, Tegra::Engines::Maxwell3D::Regs::NumTextureSamplers> textures{};
|
std::array<GLuint, Tegra::Engines::Maxwell3D::Regs::NumTextureSamplers> textures = {};
|
||||||
std::array<GLuint, Tegra::Engines::Maxwell3D::Regs::NumTextureSamplers> samplers{};
|
std::array<GLuint, Tegra::Engines::Maxwell3D::Regs::NumTextureSamplers> samplers = {};
|
||||||
std::array<GLuint, Tegra::Engines::Maxwell3D::Regs::NumImages> images{};
|
std::array<GLuint, Tegra::Engines::Maxwell3D::Regs::NumImages> images = {};
|
||||||
|
|
||||||
struct {
|
struct {
|
||||||
GLuint read_framebuffer; // GL_READ_FRAMEBUFFER_BINDING
|
GLuint read_framebuffer = 0; // GL_READ_FRAMEBUFFER_BINDING
|
||||||
GLuint draw_framebuffer; // GL_DRAW_FRAMEBUFFER_BINDING
|
GLuint draw_framebuffer = 0; // GL_DRAW_FRAMEBUFFER_BINDING
|
||||||
GLuint vertex_array; // GL_VERTEX_ARRAY_BINDING
|
GLuint vertex_array = 0; // GL_VERTEX_ARRAY_BINDING
|
||||||
GLuint shader_program; // GL_CURRENT_PROGRAM
|
GLuint shader_program = 0; // GL_CURRENT_PROGRAM
|
||||||
GLuint program_pipeline; // GL_PROGRAM_PIPELINE_BINDING
|
GLuint program_pipeline = 0; // GL_PROGRAM_PIPELINE_BINDING
|
||||||
} draw;
|
} draw;
|
||||||
|
|
||||||
struct viewport {
|
struct Viewport {
|
||||||
GLint x;
|
GLint x = 0;
|
||||||
GLint y;
|
GLint y = 0;
|
||||||
GLint width;
|
GLint width = 0;
|
||||||
GLint height;
|
GLint height = 0;
|
||||||
GLfloat depth_range_near; // GL_DEPTH_RANGE
|
GLfloat depth_range_near = 0.0f; // GL_DEPTH_RANGE
|
||||||
GLfloat depth_range_far; // GL_DEPTH_RANGE
|
GLfloat depth_range_far = 1.0f; // GL_DEPTH_RANGE
|
||||||
struct {
|
struct {
|
||||||
bool enabled; // GL_SCISSOR_TEST
|
bool enabled = false; // GL_SCISSOR_TEST
|
||||||
GLint x;
|
GLint x = 0;
|
||||||
GLint y;
|
GLint y = 0;
|
||||||
GLsizei width;
|
GLsizei width = 0;
|
||||||
GLsizei height;
|
GLsizei height = 0;
|
||||||
} scissor;
|
} scissor;
|
||||||
};
|
};
|
||||||
std::array<viewport, Tegra::Engines::Maxwell3D::Regs::NumViewports> viewports;
|
std::array<Viewport, Tegra::Engines::Maxwell3D::Regs::NumViewports> viewports;
|
||||||
|
|
||||||
struct {
|
struct {
|
||||||
float size; // GL_POINT_SIZE
|
float size = 1.0f; // GL_POINT_SIZE
|
||||||
} point;
|
} point;
|
||||||
|
|
||||||
struct {
|
struct {
|
||||||
bool point_enable;
|
bool point_enable = false;
|
||||||
bool line_enable;
|
bool line_enable = false;
|
||||||
bool fill_enable;
|
bool fill_enable = false;
|
||||||
GLfloat units;
|
GLfloat units = 0.0f;
|
||||||
GLfloat factor;
|
GLfloat factor = 0.0f;
|
||||||
GLfloat clamp;
|
GLfloat clamp = 0.0f;
|
||||||
} polygon_offset;
|
} polygon_offset;
|
||||||
|
|
||||||
struct {
|
struct {
|
||||||
bool enabled; // GL_ALPHA_TEST
|
bool enabled = false; // GL_ALPHA_TEST
|
||||||
GLenum func; // GL_ALPHA_TEST_FUNC
|
GLenum func = GL_ALWAYS; // GL_ALPHA_TEST_FUNC
|
||||||
GLfloat ref; // GL_ALPHA_TEST_REF
|
GLfloat ref = 0.0f; // GL_ALPHA_TEST_REF
|
||||||
} alpha_test;
|
} alpha_test;
|
||||||
|
|
||||||
std::array<bool, 8> clip_distance; // GL_CLIP_DISTANCE
|
std::array<bool, 8> clip_distance = {}; // GL_CLIP_DISTANCE
|
||||||
|
|
||||||
OpenGLState();
|
OpenGLState();
|
||||||
|
|
||||||
|
@ -179,34 +157,31 @@ public:
|
||||||
/// Apply this state as the current OpenGL state
|
/// Apply this state as the current OpenGL state
|
||||||
void Apply();
|
void Apply();
|
||||||
|
|
||||||
void ApplyFramebufferState() const;
|
void ApplyFramebufferState();
|
||||||
void ApplyVertexArrayState() const;
|
void ApplyVertexArrayState();
|
||||||
void ApplyShaderProgram() const;
|
void ApplyShaderProgram();
|
||||||
void ApplyProgramPipeline() const;
|
void ApplyProgramPipeline();
|
||||||
void ApplyClipDistances() const;
|
void ApplyClipDistances();
|
||||||
void ApplyPointSize() const;
|
void ApplyPointSize();
|
||||||
void ApplyFragmentColorClamp() const;
|
void ApplyFragmentColorClamp();
|
||||||
void ApplyMultisample() const;
|
void ApplyMultisample();
|
||||||
void ApplySRgb() const;
|
void ApplySRgb();
|
||||||
void ApplyCulling() const;
|
void ApplyCulling();
|
||||||
void ApplyColorMask() const;
|
void ApplyColorMask();
|
||||||
void ApplyDepth() const;
|
void ApplyDepth();
|
||||||
void ApplyPrimitiveRestart() const;
|
void ApplyPrimitiveRestart();
|
||||||
void ApplyStencilTest() const;
|
void ApplyStencilTest();
|
||||||
void ApplyViewport() const;
|
void ApplyViewport();
|
||||||
void ApplyTargetBlending(std::size_t target, bool force) const;
|
void ApplyTargetBlending(std::size_t target, bool force);
|
||||||
void ApplyGlobalBlending() const;
|
void ApplyGlobalBlending();
|
||||||
void ApplyBlending() const;
|
void ApplyBlending();
|
||||||
void ApplyLogicOp() const;
|
void ApplyLogicOp();
|
||||||
void ApplyTextures() const;
|
void ApplyTextures();
|
||||||
void ApplySamplers() const;
|
void ApplySamplers();
|
||||||
void ApplyImages() const;
|
void ApplyImages();
|
||||||
void ApplyDepthClamp() const;
|
void ApplyDepthClamp();
|
||||||
void ApplyPolygonOffset() const;
|
void ApplyPolygonOffset();
|
||||||
void ApplyAlphaTest() const;
|
void ApplyAlphaTest();
|
||||||
|
|
||||||
/// Set the initial OpenGL state
|
|
||||||
static void ApplyDefaultState();
|
|
||||||
|
|
||||||
/// Resets any references to the given resource
|
/// Resets any references to the given resource
|
||||||
OpenGLState& UnbindTexture(GLuint handle);
|
OpenGLState& UnbindTexture(GLuint handle);
|
||||||
|
@ -253,5 +228,6 @@ private:
|
||||||
bool color_mask;
|
bool color_mask;
|
||||||
} dirty{};
|
} dirty{};
|
||||||
};
|
};
|
||||||
|
static_assert(std::is_trivially_copyable_v<OpenGLState>);
|
||||||
|
|
||||||
} // namespace OpenGL
|
} // namespace OpenGL
|
||||||
|
|
Loading…
Reference in a new issue