mirrors/yuzu
2
1
Fork 0
mirror of https://github.com/yuzu-emu/yuzu.git synced 2024-07-04 23:31:19 +01:00
Code Issues Releases Activity

Merge pull request #3046 from ReinUsesLisp/clean-gl-state

Browse source 
gl_state: Miscellaneous clean up
This commit is contained in:
bunnei 2019-10-29 22:50:04 -04:00 committed by GitHub
commit 2382bbe3ac
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
3 changed files with 156 additions and 291 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
src/video_core/renderer_opengl/gl_rasterizer.cpp
View file

@ -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();

223
src/video_core/renderer_opengl/gl_state.cpp
View file

@ -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();
} }

222
src/video_core/renderer_opengl/gl_state.h
View file

@ -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