suyu/src/video_core/renderer_opengl/gl_shader_cache.cpp

// Copyright 2018 yuzu Emulator Project
// Licensed under GPLv2 or any later version
// Refer to the license.txt file included.

#include <atomic>
#include <functional>
#include <mutex>
#include <optional>
#include <string>
#include <thread>
#include <unordered_set>

#include "common/alignment.h"
#include "common/assert.h"
#include "common/logging/log.h"
#include "common/scope_exit.h"
#include "core/core.h"
#include "core/frontend/emu_window.h"
#include "video_core/engines/kepler_compute.h"
#include "video_core/engines/maxwell_3d.h"
#include "video_core/engines/shader_type.h"
#include "video_core/memory_manager.h"
#include "video_core/renderer_opengl/gl_rasterizer.h"
#include "video_core/renderer_opengl/gl_resource_manager.h"
#include "video_core/renderer_opengl/gl_shader_cache.h"
#include "video_core/renderer_opengl/gl_state_tracker.h"
#include "video_core/shader_cache.h"
#include "video_core/shader_notify.h"

namespace OpenGL {

Shader::Shader() = default;

Shader::~Shader() = default;

ShaderCacheOpenGL::ShaderCacheOpenGL(RasterizerOpenGL& rasterizer_,
                                     Core::Frontend::EmuWindow& emu_window_, Tegra::GPU& gpu_,
                                     Tegra::Engines::Maxwell3D& maxwell3d_,
                                     Tegra::Engines::KeplerCompute& kepler_compute_,
                                     Tegra::MemoryManager& gpu_memory_, const Device& device_)
    : ShaderCache{rasterizer_}, emu_window{emu_window_}, gpu{gpu_}, gpu_memory{gpu_memory_},
      maxwell3d{maxwell3d_}, kepler_compute{kepler_compute_}, device{device_} {}

ShaderCacheOpenGL::~ShaderCacheOpenGL() = default;

} // namespace OpenGL
renderer_opengl: Implement a new shader cache. 2018-08-23 23:30:27 +02:00			`// Copyright 2018 yuzu Emulator Project`
			`// Licensed under GPLv2 or any later version`
			`// Refer to the license.txt file included.`

gl_shader_cache: Rework shader cache and remove post-specializations Instead of pre-specializing shaders and then post-specializing them, drop the later and only "specialize" the shader while decoding it. 2020-02-26 20:13:47 +01:00			`#include <atomic>`
			`#include <functional>`
gl_shader_cache: Use shared contexts to build shaders in parallel 2019-04-06 22:59:56 +02:00			`#include <mutex>`
gl_shader_decompiler: Move entries to a separate function 2019-09-25 04:34:18 +02:00			`#include <optional>`
			`#include <string>`
gl_shader_cache: Use shared contexts to build shaders in parallel 2019-04-06 22:59:56 +02:00			`#include <thread>`
gl_shader_decompiler: Move entries to a separate function 2019-09-25 04:34:18 +02:00			`#include <unordered_set>`
gl_shader_cache: Rework shader cache and remove post-specializations Instead of pre-specializing shaders and then post-specializing them, drop the later and only "specialize" the shader while decoding it. 2020-02-26 20:13:47 +01:00
gl_shader_cache: Specialize shared memory size Shared memory was being declared with an undefined size. Specialize from guest GPU parameters the compute shader's shared memory size. 2019-11-13 03:39:45 +01:00			`#include "common/alignment.h"`
renderer_opengl: Implement a new shader cache. 2018-08-23 23:30:27 +02:00			`#include "common/assert.h"`
gl_shader_cache: Specialize shared memory size Shared memory was being declared with an undefined size. Specialize from guest GPU parameters the compute shader's shared memory size. 2019-11-13 03:39:45 +01:00			`#include "common/logging/log.h"`
gl_shader_cache: Use shared contexts to build shaders in parallel 2019-04-06 22:59:56 +02:00			`#include "common/scope_exit.h"`
renderer_opengl: Implement a new shader cache. 2018-08-23 23:30:27 +02:00			`#include "core/core.h"`
gl_shader_cache: Use shared contexts to build shaders in parallel 2019-04-06 22:59:56 +02:00			`#include "core/frontend/emu_window.h"`
Shader_Cache: setup connection of ConstBufferLocker 2019-09-23 21:40:58 +02:00			`#include "video_core/engines/kepler_compute.h"`
renderer_opengl: Implement a new shader cache. 2018-08-23 23:30:27 +02:00			`#include "video_core/engines/maxwell_3d.h"`
video_core: Unify ProgramType and ShaderStage into ShaderType 2019-11-18 22:35:21 +01:00			`#include "video_core/engines/shader_type.h"`
video_core/texures/texture: Remove unnecessary includes Nothing in this header relies on common_funcs or the memory manager. This gets rid of reliance on indirect inclusions in the OpenGL caches. 2019-04-06 05:59:54 +02:00			`#include "video_core/memory_manager.h"`
rasterizer_cache: Remove reliance on the System singleton Rather than have a transparent dependency, we can make it explicit in the interface. This also gets rid of the need to put the core include in a header. 2018-11-08 12:08:00 +01:00			`#include "video_core/renderer_opengl/gl_rasterizer.h"`
gl_shader_util: Use std::string_view instead of star pointer This allows us passing any type of string and hinting the length of the string to the OpenGL driver. 2020-08-24 02:23:54 +02:00			`#include "video_core/renderer_opengl/gl_resource_manager.h"`
renderer_opengl: Implement a new shader cache. 2018-08-23 23:30:27 +02:00			`#include "video_core/renderer_opengl/gl_shader_cache.h"`
gl_state_tracker: Implement dirty flags for clip distances and shaders 2019-12-29 06:03:05 +01:00			`#include "video_core/renderer_opengl/gl_state_tracker.h"`
gl_shader_cache: Use generic shader cache Trivially port the generic shader cache to OpenGL. 2020-05-23 01:55:38 +02:00			`#include "video_core/shader_cache.h"`
async shaders 2020-07-10 05:36:38 +02:00			`#include "video_core/shader_notify.h"`
renderer_opengl: Implement a new shader cache. 2018-08-23 23:30:27 +02:00
			`namespace OpenGL {`

shader: Remove old shader management 2021-02-17 00:52:12 +01:00			`Shader::Shader() = default;`
gl_shader_cache: Rework shader cache and remove post-specializations Instead of pre-specializing shaders and then post-specializing them, drop the later and only "specialize" the shader while decoding it. 2020-02-26 20:13:47 +01:00
gl_shader_cache: Use generic shader cache Trivially port the generic shader cache to OpenGL. 2020-05-23 01:55:38 +02:00			`Shader::~Shader() = default;`
gl_shader_cache: Rework shader cache and remove post-specializations Instead of pre-specializing shaders and then post-specializing them, drop the later and only "specialize" the shader while decoding it. 2020-02-26 20:13:47 +01:00
video_core: Resolve more variable shadowing scenarios pt.3 Cleans out the rest of the occurrences of variable shadowing and makes any further occurrences of shadowing compiler errors. 2020-12-05 17:40:14 +01:00			`ShaderCacheOpenGL::ShaderCacheOpenGL(RasterizerOpenGL& rasterizer_,`
video_core: Remove all Core::System references in renderer Now that the GPU is initialized when video backends are initialized, it's no longer needed to query components once the game is running: it can be done when yuzu is booting. This allows us to pass components between constructors and in the process remove all Core::System references in the video backend. 2020-06-12 02:24:45 +02:00			`Core::Frontend::EmuWindow& emu_window_, Tegra::GPU& gpu_,`
			`Tegra::Engines::Maxwell3D& maxwell3d_,`
			`Tegra::Engines::KeplerCompute& kepler_compute_,`
			`Tegra::MemoryManager& gpu_memory_, const Device& device_)`
video_core: Resolve more variable shadowing scenarios pt.3 Cleans out the rest of the occurrences of variable shadowing and makes any further occurrences of shadowing compiler errors. 2020-12-05 17:40:14 +01:00			`: ShaderCache{rasterizer_}, emu_window{emu_window_}, gpu{gpu_}, gpu_memory{gpu_memory_},`
			`maxwell3d{maxwell3d_}, kepler_compute{kepler_compute_}, device{device_} {}`
gl_shader_cache: Use generic shader cache Trivially port the generic shader cache to OpenGL. 2020-05-23 01:55:38 +02:00
			`ShaderCacheOpenGL::~ShaderCacheOpenGL() = default;`
gl_shader_cache: Refactor to support disk shader cache 2019-01-14 04:58:15 +01:00
Re added new lines at the end of files 2019-04-23 23:19:28 +02:00			`} // namespace OpenGL`