1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
|
// Copyright 2014 Dolphin Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
#pragma once
#include <map>
#include <memory>
#include <string>
#include <vector>
#include "Common/CommonTypes.h"
#include "Common/MathUtil.h"
#include "Common/Timer.h"
#include "VideoCommon/TextureConfig.h"
class AbstractPipeline;
class AbstractShader;
class AbstractTexture;
class AbstractFramebuffer;
namespace VideoCommon
{
class ShaderIncluder;
class PostProcessingConfiguration
{
public:
// User defined post process
struct ConfigurationOption
{
enum class OptionType
{
Bool = 0,
Float,
Integer,
};
bool m_bool_value = false;
std::vector<float> m_float_values;
std::vector<s32> m_integer_values;
std::vector<float> m_float_min_values;
std::vector<s32> m_integer_min_values;
std::vector<float> m_float_max_values;
std::vector<s32> m_integer_max_values;
std::vector<float> m_float_step_values;
std::vector<s32> m_integer_step_values;
OptionType m_type = OptionType::Bool;
std::string m_gui_name;
std::string m_option_name;
std::string m_dependent_option;
bool m_dirty = false;
};
using ConfigMap = std::map<std::string, ConfigurationOption>;
PostProcessingConfiguration();
virtual ~PostProcessingConfiguration();
// Loads the configuration with a shader
// If the argument is "" the class will load the shader from the g_activeConfig option.
// Returns the loaded shader source from file
void LoadShader(const std::string& shader);
void LoadDefaultShader();
void SaveOptionsConfiguration();
const std::string& GetShader() const { return m_current_shader; }
const std::string& GetShaderCode() const { return m_current_shader_code; }
ShaderIncluder* GetShaderIncluder() { return m_shader_includer.get(); }
bool IsDirty() const { return m_any_options_dirty; }
void SetDirty(bool dirty) { m_any_options_dirty = dirty; }
bool HasOptions() const { return m_options.size() > 0; }
const ConfigMap& GetOptions() const { return m_options; }
ConfigMap& GetOptions() { return m_options; }
const ConfigurationOption& GetOption(const std::string& option) { return m_options[option]; }
// For updating option's values
void SetOptionf(const std::string& option, int index, float value);
void SetOptioni(const std::string& option, int index, s32 value);
void SetOptionb(const std::string& option, bool value);
private:
bool m_any_options_dirty = false;
std::unique_ptr<ShaderIncluder> m_shader_includer;
std::string m_current_shader;
std::string m_current_shader_code;
ConfigMap m_options;
void LoadOptions(const std::string& code);
void LoadOptionsConfiguration();
};
class PostProcessing
{
public:
PostProcessing();
virtual ~PostProcessing();
static std::vector<std::string> GetShaderList();
static std::vector<std::string> GetPassiveShaderList();
static std::vector<std::string> GetAnaglyphShaderList();
PostProcessingConfiguration* GetConfig() { return &m_config; }
bool Initialize(AbstractTextureFormat format);
void RecompileShader();
void RecompilePipeline();
void BlitFromTexture(const MathUtil::Rectangle<int>& dst, const MathUtil::Rectangle<int>& src,
const AbstractTexture* src_tex, int src_layer = -1);
bool IsColorCorrectionActive() const;
bool NeedsIntermediaryBuffer() const;
protected:
std::string GetUniformBufferHeader(bool user_post_process) const;
std::string GetHeader(bool user_post_process) const;
std::string GetFooter() const;
bool CompileVertexShader();
bool CompilePixelShader();
bool CompilePipeline();
size_t CalculateUniformsSize(bool user_post_process) const;
void FillUniformBuffer(const MathUtil::Rectangle<int>& src, const AbstractTexture* src_tex,
int src_layer, const MathUtil::Rectangle<int>& dst,
const MathUtil::Rectangle<int>& wnd, u8* buffer, bool user_post_process,
bool intermediary_buffer);
// Timer for determining our time value
Common::Timer m_timer;
// Dolphin fixed post process:
PostProcessingConfiguration::ConfigMap m_default_options;
std::unique_ptr<AbstractShader> m_default_vertex_shader;
std::unique_ptr<AbstractShader> m_default_pixel_shader;
std::unique_ptr<AbstractPipeline> m_default_pipeline;
std::unique_ptr<AbstractFramebuffer> m_intermediary_frame_buffer;
std::unique_ptr<AbstractTexture> m_intermediary_color_texture;
std::vector<u8> m_default_uniform_staging_buffer;
// User post process:
PostProcessingConfiguration m_config;
std::unique_ptr<AbstractShader> m_vertex_shader;
std::unique_ptr<AbstractShader> m_pixel_shader;
std::unique_ptr<AbstractPipeline> m_pipeline;
std::vector<u8> m_uniform_staging_buffer;
AbstractTextureFormat m_framebuffer_format = AbstractTextureFormat::Undefined;
};
} // namespace VideoCommon
|
