notsoyuzu
/
yuzu-mainline
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
yuzu-mainline/src/video_core/CMakeLists.txt

274 lines
9.2 KiB
CMake
Raw Normal View History

video_core/host_shaders: Add CMake integration for string shaders Add the necessary CMake code to copy the contents in a string source shader (GLSL or GLASM) to a header file then consumed by video_core files. This allows editting GLSL in its own files without having to maintain them in source files. For now, only OpenGL presentation shaders are moved, but we can add GLASM presentation shaders and static SPIR-V generation through glslangValidator in the future.
2020-08-23 20:28:15 -04:00
add_subdirectory(host_shaders)
nvdec: Implement VA-API hardware video acceleration (#6713) * nvdec: VA-API * Verify formatting * Forgot a semicolon for Windows * Clarify comment about AV_PIX_FMT_NV12 * Fix assert log spam from missing negation * vic: Remove forgotten debug code * Address lioncash's review * Mention VA-API is Intel/AMD * Address v1993's review * Hopefully fix CMakeLists style this time * vic: Improve cache locality * vic: Fix off-by-one error * codec: Async * codec: Forgot the GetValue() * nvdec: Address ameerj's review * codec: Fallback to CPU without VA-API support * cmake: Address lat9nq's review * cmake: Make VA-API optional * vaapi: Multiple GPU * Apply suggestions from code review Co-authored-by: Ameer J <52414509+ameerj@users.noreply.github.com> * nvdec: Address ameerj's review * codec: Use anonymous instead of static * nvdec: Remove enum and fix memory leak * nvdec: Address ameerj's review * codec: Remove preparation for threading Co-authored-by: Ameer J <52414509+ameerj@users.noreply.github.com>
2021-08-03 23:43:11 -04:00
if(LIBVA_FOUND)
set_source_files_properties(command_classes/codecs/codec.cpp
PROPERTIES COMPILE_DEFINITIONS LIBVA_FOUND=1)
endif()
CMakeLists: Derive the source directory grouping from targets themselves Removes the need to store to separate SRC and HEADER variables, and then construct the target in most cases.
2018-01-17 19:37:34 -05:00
add_library(video_core STATIC
buffer_cache/buffer_base: Add a range tracking buffer container It keeps track of the modified CPU and GPU ranges on a CPU page granularity, notifying the given rasterizer about state changes in the tracking behavior of the buffer. Use a small vector optimization to store buffers smaller than 256 KiB locally instead of using free store memory allocations.
2020-12-30 16:37:31 -05:00
buffer_cache/buffer_base.h
video_core: Reimplement the buffer cache Reimplement the buffer cache using cached bindings and page level granularity for modification tracking. This also drops the usage of shared pointers and virtual functions from the cache. - Bindings are cached, allowing to skip work when the game changes few bits between draws. - OpenGL Assembly shaders no longer copy when a region has been modified from the GPU to emulate constant buffers, instead GL_EXT_memory_object is used to alias sub-buffers within the same allocation. - OpenGL Assembly shaders stream constant buffer data using glProgramBufferParametersIuivNV, from NV_parameter_buffer_object. In theory this should save one hash table resolve inside the driver compared to glBufferSubData. - A new OpenGL stream buffer is implemented based on fences for drivers that are not Nvidia's proprietary, due to their low performance on partial glBufferSubData calls synchronized with 3D rendering (that some games use a lot). - Most optimizations are shared between APIs now, allowing Vulkan to cache more bindings than before, skipping unnecesarry work. This commit adds the necessary infrastructure to use Vulkan object from OpenGL. Overall, it improves performance and fixes some bugs present on the old cache. There are still some edge cases hit by some games that harm performance on some vendors, this are planned to be fixed in later commits.
2021-01-16 18:48:58 -05:00
buffer_cache/buffer_cache.cpp
Video_Core: Implement a new Buffer Cache
2019-07-19 10:50:40 -04:00
buffer_cache/buffer_cache.h
video_core: NVDEC Implementation This commit aims to implement the NVDEC (Nvidia Decoder) functionality, with video frame decoding being handled by the FFmpeg library. The process begins with Ioctl commands being sent to the NVDEC and VIC (Video Image Composer) emulated devices. These allocate the necessary GPU buffers for the frame data, along with providing information on the incoming video data. A Submit command then signals the GPU to process and decode the frame data. To decode the frame, the respective codec's header must be manually composed from the information provided by NVDEC, then sent with the raw frame data to the ffmpeg library. Currently, H264 and VP9 are supported, with VP9 having some minor artifacting issues related mainly to the reference frame composition in its uncompressed header. Async GPU is not properly implemented at the moment. Co-Authored-By: David <25727384+ogniK5377@users.noreply.github.com>
2020-10-26 23:07:36 -04:00
cdma_pusher.cpp
cdma_pusher.h
command_classes/codecs/codec.cpp
command_classes/codecs/codec.h
command_classes/codecs/h264.cpp
command_classes/codecs/h264.h
command_classes/codecs/vp9.cpp
command_classes/codecs/vp9.h
command_classes/codecs/vp9_types.h
command_classes/host1x.cpp
command_classes/host1x.h
command_classes/nvdec.cpp
command_classes/nvdec.h
command_classes/nvdec_common.h
command_classes/sync_manager.cpp
command_classes/sync_manager.h
command_classes/vic.cpp
command_classes/vic.h
video_core/compatible_formats: Table to test if two formats are legal to view or copy Add a flat table to test if it's legal to create a texture view between two formats or copy betweem them. This table is based on ARB_copy_image and ARB_texture_view. Copies are more permissive than views.
2020-06-26 18:22:29 -04:00
compatible_formats.cpp
compatible_formats.h
video_core: Add a delayed destruction ring abstraction
2020-12-30 00:06:22 -05:00
delayed_destruction_ring.h
dirty_flags: Deduplicate code between OpenGL and Vulkan
2020-02-20 23:56:00 -05:00
dirty_flags.cpp
video_core: Reintroduce dirty flags infrastructure
2019-12-26 20:14:10 -05:00
dirty_flags.h
gpu: Rewrite GPU command list processing with DmaPusher class. - More accurate impl., fixes Undertale (among other games).
2018-11-23 23:20:56 -05:00
dma_pusher.cpp
dma_pusher.h
video_core/engines: Move ConstBufferInfo out of Maxwell3D
2019-05-31 16:33:21 -04:00
engines/const_buffer_info.h
Clang Format and Documentation.
2020-04-28 13:53:47 -04:00
engines/engine_interface.h
Revamp Kepler Memory to use a subegine to manage uploads
2019-04-22 18:50:56 -04:00
engines/engine_upload.cpp
engines/engine_upload.h
GPU: Added a command processor to decode the GPU pushbuffers and forward the commands to their respective engines.
2018-02-11 21:34:20 -05:00
engines/fermi_2d.cpp
engines/fermi_2d.h
kepler_compute: Fixup assert and rename engines When I originally added the compute assert I used the wrong documentation. This addresses that. The dispatch register was tested with homebrew against hardware and is triggered by some games (e.g. Super Mario Odyssey). What exactly is missing to get a valid program bound by this engine requires more investigation.
2019-01-22 18:49:31 -05:00
engines/kepler_compute.cpp
engines/kepler_compute.h
GPU: Basic implementation of the Kepler Inline Memory engine (p2mf). This engine writes data from a FIFO register into the configured address.
2018-09-08 16:58:20 -04:00
engines/kepler_memory.cpp
engines/kepler_memory.h
GPU: Added a command processor to decode the GPU pushbuffers and forward the commands to their respective engines.
2018-02-11 21:34:20 -05:00
engines/maxwell_3d.cpp
engines/maxwell_3d.h
GPU: Partially implemented the Maxwell DMA engine. Only tiled->linear and linear->tiled copies that aren't offsetted are supported for now. Queries are not supported. Swizzled copies are not supported.
2018-06-10 18:02:33 -04:00
engines/maxwell_dma.cpp
engines/maxwell_dma.h
video_core: gpu: Refactor out synchronous/asynchronous GPU implementations. - We must always use a GPU thread now, even with synchronous GPU.
2020-12-12 01:26:14 -05:00
framebuffer_config.h
Implement macro JIT
2020-05-29 00:53:27 -04:00
macro/macro.cpp
macro/macro.h
Macro HLE support
2020-06-04 11:42:19 -04:00
macro/macro_hle.cpp
macro/macro_hle.h
Implement macro JIT
2020-05-29 00:53:27 -04:00
macro/macro_interpreter.cpp
macro/macro_interpreter.h
macro/macro_jit_x64.cpp
macro/macro_jit_x64.h
GPU: Implement a Fence Manager.
2020-02-17 19:19:26 -05:00
fence_manager.h
GPU: Move the GPU's class constructor and destructors to a cpp file. This should reduce recompile times when editing the Maxwell3D register structure.
2018-03-18 16:15:05 -04:00
gpu.cpp
Make a GPU class in VideoCore to contain the GPU state. Also moved the GPU MemoryManager class to video_core since it makes more sense for it to be there.
2018-02-11 23:44:12 -05:00
gpu.h
gpu: Move command processing to another thread.
2019-01-23 22:17:55 -05:00
gpu_thread.cpp
gpu_thread.h
Make a GPU class in VideoCore to contain the GPU state. Also moved the GPU MemoryManager class to video_core since it makes more sense for it to be there.
2018-02-11 23:44:12 -05:00
memory_manager.cpp
memory_manager.h
query_cache: Abstract OpenGL implementation Abstract the current OpenGL implementation into the VideoCommon namespace and reimplement it on top of that. Doing this avoids repeating code and logic in the Vulkan implementation.
2020-02-11 14:02:41 -05:00
query_cache.h
rasterizer_accelerated: Add intermediary for GPU rasterizers Add an intermediary class that implements common functions across GPU accelerated rasterizers. This avoids code repetition on different backends.
2019-10-27 02:40:08 -04:00
rasterizer_accelerated.cpp
rasterizer_accelerated.h
renderer_gl: Port boilerplate rasterizer code over from Citra.
2018-03-19 23:00:59 -04:00
rasterizer_interface.h
CMakeLists: Derive the source directory grouping from targets themselves Removes the need to store to separate SRC and HEADER variables, and then construct the target in most cases.
2018-01-17 19:37:34 -05:00
renderer_base.cpp
renderer_base.h
renderer_opengl: Implement a buffer cache. The idea of this cache is to avoid redundant uploads. So we are going to cache the uploaded buffers within the stream_buffer and just reuse the old pointers. The next step is to implement a VBO cache on GPU memory, but for now, I want to check the overhead of the cache management. Fetching the buffer over PCI-E should be quite fast.
2018-08-28 18:27:03 -04:00
renderer_opengl/gl_buffer_cache.cpp
video_core/CMakeLists: Add missing gl_buffer_cache.h Without this, the header file won't show up by default within IDEs such as Visual Studio.
2018-09-06 14:49:49 -04:00
renderer_opengl/gl_buffer_cache.h
gl_shader_cache: Rename Program abstractions into Pipeline
2021-05-25 17:58:28 -04:00
renderer_opengl/gl_compute_pipeline.cpp
renderer_opengl/gl_compute_pipeline.h
gl_device: Implement interface and add uniform offset alignment
2019-04-10 14:56:12 -04:00
renderer_opengl/gl_device.cpp
renderer_opengl/gl_device.h
GPU: Implement a Fence Manager.
2020-02-17 19:19:26 -05:00
renderer_opengl/gl_fence_manager.cpp
renderer_opengl/gl_fence_manager.h
gl_shader_cache: Rename Program abstractions into Pipeline
2021-05-25 17:58:28 -04:00
renderer_opengl/gl_graphics_pipeline.cpp
renderer_opengl/gl_graphics_pipeline.h
renderer_gl: Port boilerplate rasterizer code over from Citra.
2018-03-19 23:00:59 -04:00
renderer_opengl/gl_rasterizer.cpp
renderer_opengl/gl_rasterizer.h
gl_resource_manager: Split implementations in .cpp file. Those implementations are quite costly, so there is no need to inline them to the caller. Ressource deletion is often a performance bug, so in this way, we support to add breakpoints to them.
2018-11-06 04:40:49 -05:00
renderer_opengl/gl_resource_manager.cpp
CMakeLists: Derive the source directory grouping from targets themselves Removes the need to store to separate SRC and HEADER variables, and then construct the target in most cases.
2018-01-17 19:37:34 -05:00
renderer_opengl/gl_resource_manager.h
renderer_opengl: Implement a new shader cache.
2018-08-23 17:30:27 -04:00
renderer_opengl/gl_shader_cache.cpp
renderer_opengl/gl_shader_cache.h
renderer_opengl: Add gl_shader_manager class.
2018-04-07 05:12:38 -04:00
renderer_opengl/gl_shader_manager.cpp
renderer_opengl/gl_shader_manager.h
gl_shader_cache: Implement async shaders
2021-06-14 21:06:29 -04:00
renderer_opengl/gl_shader_context.h
CMakeLists: Derive the source directory grouping from targets themselves Removes the need to store to separate SRC and HEADER variables, and then construct the target in most cases.
2018-01-17 19:37:34 -05:00
renderer_opengl/gl_shader_util.cpp
renderer_opengl/gl_shader_util.h
gl_rasterizer: Remove dirty flags
2019-12-25 15:02:17 -05:00
renderer_opengl/gl_state_tracker.cpp
renderer_opengl/gl_state_tracker.h
renderer_gl: Port over gl_stream_buffer module from Citra.
2018-03-19 17:10:59 -04:00
renderer_opengl/gl_stream_buffer.cpp
renderer_opengl/gl_stream_buffer.h
gl_texture_cache: Initial implementation
2019-04-11 16:14:55 -04:00
renderer_opengl/gl_texture_cache.cpp
renderer_opengl/gl_texture_cache.h
texture_cache: Split templates out
2021-08-05 09:52:30 -04:00
renderer_opengl/gl_texture_cache_templates.cpp
maxwell_3d: Slow implementation of passed samples (query 21) Implements GL_SAMPLES_PASSED by waiting immediately for queries.
2019-07-27 18:40:10 -04:00
renderer_opengl/gl_query_cache.cpp
renderer_opengl/gl_query_cache.h
maxwell_to_gl: Add module and function for decoding VertexType.
2018-03-24 21:09:30 -04:00
renderer_opengl/maxwell_to_gl.h
CMakeLists: Derive the source directory grouping from targets themselves Removes the need to store to separate SRC and HEADER variables, and then construct the target in most cases.
2018-01-17 19:37:34 -05:00
renderer_opengl/renderer_opengl.cpp
renderer_opengl/renderer_opengl.h
video_core: Rewrite the texture cache The current texture cache has several points that hurt maintainability and performance. It's easy to break unrelated parts of the cache when doing minor changes. The cache can easily forget valuable information about the cached textures by CPU writes or simply by its normal usage.The current texture cache has several points that hurt maintainability and performance. It's easy to break unrelated parts of the cache when doing minor changes. The cache can easily forget valuable information about the cached textures by CPU writes or simply by its normal usage. This commit aims to address those issues.
2020-12-30 00:25:23 -05:00
renderer_opengl/util_shaders.cpp
renderer_opengl/util_shaders.h
renderer_vulkan/blit_image.cpp
renderer_vulkan/blit_image.h
cmake: Always enable Vulkan Removes the unnecesary burden of maintaining separate #ifdef paths and allows us sharing generic Vulkan code across APIs.
2020-12-24 18:22:07 -05:00
renderer_vulkan/fixed_pipeline_state.cpp
renderer_vulkan/fixed_pipeline_state.h
renderer_vulkan/maxwell_to_vk.cpp
renderer_vulkan/maxwell_to_vk.h
shader: Add partial rasterizer integration
2021-03-19 18:28:31 -04:00
renderer_vulkan/pipeline_helper.h
renderer_vulkan: Add setting to log pipeline statistics Use VK_KHR_pipeline_executable_properties when enabled and available to log statistics about the pipeline cache in a game. For example, this is on Turing GPUs when generating a pipeline cache from Super Smash Bros. Ultimate: Average pipeline statistics ========================================== Code size: 6433.167 Register count: 32.939 More advanced results could be presented, at the moment it's just an average of all 3D and compute pipelines.
2021-07-27 18:15:32 -04:00
renderer_vulkan/pipeline_statistics.cpp
renderer_vulkan/pipeline_statistics.h
cmake: Always enable Vulkan Removes the unnecesary burden of maintaining separate #ifdef paths and allows us sharing generic Vulkan code across APIs.
2020-12-24 18:22:07 -05:00
renderer_vulkan/renderer_vulkan.h
renderer_vulkan/renderer_vulkan.cpp
renderer_vulkan/vk_blit_screen.cpp
renderer_vulkan/vk_blit_screen.h
renderer_vulkan/vk_buffer_cache.cpp
renderer_vulkan/vk_buffer_cache.h
renderer_vulkan/vk_command_pool.cpp
renderer_vulkan/vk_command_pool.h
renderer_vulkan/vk_compute_pass.cpp
renderer_vulkan/vk_compute_pass.h
renderer_vulkan/vk_compute_pipeline.cpp
renderer_vulkan/vk_compute_pipeline.h
renderer_vulkan/vk_descriptor_pool.cpp
renderer_vulkan/vk_descriptor_pool.h
renderer_vulkan/vk_fence_manager.cpp
renderer_vulkan/vk_fence_manager.h
shader: Add partial rasterizer integration
2021-03-19 18:28:31 -04:00
renderer_vulkan/vk_graphics_pipeline.cpp
renderer_vulkan/vk_graphics_pipeline.h
cmake: Always enable Vulkan Removes the unnecesary burden of maintaining separate #ifdef paths and allows us sharing generic Vulkan code across APIs.
2020-12-24 18:22:07 -05:00
renderer_vulkan/vk_master_semaphore.cpp
renderer_vulkan/vk_master_semaphore.h
renderer_vulkan/vk_pipeline_cache.cpp
renderer_vulkan/vk_pipeline_cache.h
renderer_vulkan/vk_query_cache.cpp
renderer_vulkan/vk_query_cache.h
renderer_vulkan/vk_rasterizer.cpp
renderer_vulkan/vk_rasterizer.h
shader: Add partial rasterizer integration
2021-03-19 18:28:31 -04:00
renderer_vulkan/vk_render_pass_cache.cpp
renderer_vulkan/vk_render_pass_cache.h
cmake: Always enable Vulkan Removes the unnecesary burden of maintaining separate #ifdef paths and allows us sharing generic Vulkan code across APIs.
2020-12-24 18:22:07 -05:00
renderer_vulkan/vk_resource_pool.cpp
renderer_vulkan/vk_resource_pool.h
renderer_vulkan/vk_scheduler.cpp
renderer_vulkan/vk_scheduler.h
renderer_vulkan/vk_shader_util.cpp
renderer_vulkan/vk_shader_util.h
renderer_vulkan/vk_staging_buffer_pool.cpp
renderer_vulkan/vk_staging_buffer_pool.h
renderer_vulkan/vk_state_tracker.cpp
renderer_vulkan/vk_state_tracker.h
renderer_vulkan/vk_swapchain.cpp
renderer_vulkan/vk_swapchain.h
renderer_vulkan/vk_texture_cache.cpp
renderer_vulkan/vk_texture_cache.h
texture_cache: Split templates out
2021-08-05 09:52:30 -04:00
renderer_vulkan/vk_texture_cache_templates.cpp
cmake: Always enable Vulkan Removes the unnecesary burden of maintaining separate #ifdef paths and allows us sharing generic Vulkan code across APIs.
2020-12-24 18:22:07 -05:00
renderer_vulkan/vk_update_descriptor.cpp
renderer_vulkan/vk_update_descriptor.h
shader: Move pipeline cache logic to separate files Move code to separate files to be able to reuse it from OpenGL. This greatly simplifies the pipeline cache logic on Vulkan. Transform feedback state is not yet abstracted and it's still intrusively stored inside vk_pipeline_cache. It will be moved when needed on OpenGL.
2021-04-26 02:53:26 -04:00
shader_cache.cpp
shader_cache: Implement a generic shader cache Implement a generic shader cache for fast lookups and invalidations. Invalidations are cheap but expensive when a shader is invalidated. Use two mutexes instead of one to avoid locking invalidations for lookups and vice versa. When a shader has to be removed, lookups are locked as expected.
2020-05-22 19:53:27 -04:00
shader_cache.h
shader: Move pipeline cache logic to separate files Move code to separate files to be able to reuse it from OpenGL. This greatly simplifies the pipeline cache logic on Vulkan. Transform feedback state is not yet abstracted and it's still intrusively stored inside vk_pipeline_cache. It will be moved when needed on OpenGL.
2021-04-26 02:53:26 -04:00
shader_environment.cpp
shader_environment.h
async shaders
2020-07-09 23:36:38 -04:00
shader_notify.cpp
shader_notify.h
video_core: Move surface declarations out of gl_rasterizer_cache
2018-10-28 21:14:25 -04:00
surface.cpp
surface.h
video_core: Rewrite the texture cache The current texture cache has several points that hurt maintainability and performance. It's easy to break unrelated parts of the cache when doing minor changes. The cache can easily forget valuable information about the cached textures by CPU writes or simply by its normal usage.The current texture cache has several points that hurt maintainability and performance. It's easy to break unrelated parts of the cache when doing minor changes. The cache can easily forget valuable information about the cached textures by CPU writes or simply by its normal usage. This commit aims to address those issues.
2020-12-30 00:25:23 -05:00
texture_cache/accelerated_swizzle.cpp
texture_cache/accelerated_swizzle.h
texture_cache/decode_bc4.cpp
texture_cache/decode_bc4.h
texture_cache/descriptor_table.h
texture_cache/formatter.cpp
texture_cache/formatter.h
texture_cache: Use a table instead of switch for texture formats Use a large flat array to look up texture formats. This allows us to properly implement formats with different component types. It should also be faster.
2019-11-09 01:26:30 -05:00
texture_cache/format_lookup_table.cpp
texture_cache/format_lookup_table.h
video_core: Rewrite the texture cache The current texture cache has several points that hurt maintainability and performance. It's easy to break unrelated parts of the cache when doing minor changes. The cache can easily forget valuable information about the cached textures by CPU writes or simply by its normal usage.The current texture cache has several points that hurt maintainability and performance. It's easy to break unrelated parts of the cache when doing minor changes. The cache can easily forget valuable information about the cached textures by CPU writes or simply by its normal usage. This commit aims to address those issues.
2020-12-30 00:25:23 -05:00
texture_cache/image_base.cpp
texture_cache/image_base.h
texture_cache/image_info.cpp
texture_cache/image_info.h
texture_cache/image_view_base.cpp
texture_cache/image_view_base.h
texture_cache/image_view_info.cpp
texture_cache/image_view_info.h
texture_cache/render_targets.h
texture_cache/samples_helper.h
texture_cache/slot_vector.h
texture_cache: Split texture cache into different files
2019-04-24 15:35:54 -04:00
texture_cache/texture_cache.h
texture_cache: Split templates out
2021-08-05 09:52:30 -04:00
texture_cache/texture_cache_templates.h
video_core: Rewrite the texture cache The current texture cache has several points that hurt maintainability and performance. It's easy to break unrelated parts of the cache when doing minor changes. The cache can easily forget valuable information about the cached textures by CPU writes or simply by its normal usage.The current texture cache has several points that hurt maintainability and performance. It's easy to break unrelated parts of the cache when doing minor changes. The cache can easily forget valuable information about the cached textures by CPU writes or simply by its normal usage. This commit aims to address those issues.
2020-12-30 00:25:23 -05:00
texture_cache/types.h
texture_cache/util.cpp
texture_cache/util.h
gl_rasterizer: Implement texture format ASTC_2D_4X4.
2018-06-17 23:50:44 -04:00
textures/astc.h
textures: Reintroduce CPU ASTC decoder Users may want to fall back to the CPU ASTC texture decoder due to hangs and crashes that may be caused by keeping the GPU under compute heavy loads for extended periods of time. This is especially the case in games such as Astral Chain which make extensive use of ASTC textures.
2021-06-13 15:15:08 -04:00
textures/astc.cpp
GPU: Preliminary work for texture decoding.
2018-03-19 19:00:29 -04:00
textures/decoders.cpp
textures/decoders.h
video_core/texture: Use a LUT to convert sRGB texture borders This is a reversed look up table extracted from https://gist.github.com/rygorous/2203834#file-gistfile1-cpp-L41-L62 that is used in https://github.com/devkitPro/deko3d/blob/04d4e9e587fa3dc5447b43d273bc45f440226e41/source/maxwell/tsc_generate.cpp#L38 Games usually bind 0xFD expecting a float texture border of 1.0f. The conversion previous to this commit was multiplying the uint8 sRGB texture border color by 255. This is close to 1.0f but when that difference matters, some graphical glitches appear. This look up table is manually changed in the edges, clamping towards 0.0f and 1.0f. While we are at it, move this logic to its own translation unit.
2020-04-07 19:38:14 -04:00
textures/texture.cpp
GPU: Preliminary work for texture decoding.
2018-03-19 19:00:29 -04:00
textures/texture.h
video_core: Abstract transform feedback translation utility
2021-05-21 16:19:35 -04:00
transform_feedback.cpp
transform_feedback.h
CMakeLists: Derive the source directory grouping from targets themselves Removes the need to store to separate SRC and HEADER variables, and then construct the target in most cases.
2018-01-17 19:37:34 -05:00
video_core.cpp
video_core.h
renderer_vulkan: Create debug callback on separate file and throw Initialize debug callbacks (messenger) from a separate file. This allows sharing code with different backends. Change our Vulkan error handling to use exceptions instead of error codes, simplifying the initialization process.
2020-12-25 00:01:13 -05:00
vulkan_common/vulkan_debug_callback.cpp
vulkan_common/vulkan_debug_callback.h
renderer_vulkan: Move device abstraction to vulkan_common
2020-12-25 23:19:46 -05:00
vulkan_common/vulkan_device.cpp
vulkan_common/vulkan_device.h
renderer_vulkan: Move instance initialization to a separate file Simplify Vulkan's backend initialization code by moving it to a separate file, allowing us to initialize a Vulkan instance from different backends.
2020-12-24 20:05:48 -05:00
vulkan_common/vulkan_instance.cpp
vulkan_common/vulkan_instance.h
vulkan_common: Move dynamic library load to a separate file Allows us to initialize a Vulkan dynamic library from different backends without duplicating code.
2020-12-24 19:24:34 -05:00
vulkan_common/vulkan_library.cpp
vulkan_common/vulkan_library.h
vulkan_common: Move allocator to the common directory Allow using the abstraction from the OpenGL backend.
2021-01-03 16:17:57 -05:00
vulkan_common/vulkan_memory_allocator.cpp
vulkan_common/vulkan_memory_allocator.h
renderer_vulkan: Initialize surface in separate file Move surface initialization code to a separate file. It's unlikely to use this code outside of Vulkan, but keeping platform-specific code (Win32, Xlib, Wayland) in its own translation unit keeps things cleaner.
2020-12-25 00:14:15 -05:00
vulkan_common/vulkan_surface.cpp
vulkan_common/vulkan_surface.h
vulkan_common: Rename renderer_vulkan/wrapper.h to vulkan_common/vulkan_wrapper.h Allows sharing Vulkan wrapper code between different rendering backends.
2020-12-24 19:30:11 -05:00
vulkan_common/vulkan_wrapper.cpp
vulkan_common/vulkan_wrapper.h
renderer_vulkan/nsight_aftermath_tracker: Move to vulkan_common
2020-12-25 23:26:52 -05:00
vulkan_common/nsight_aftermath_tracker.cpp
vulkan_common/nsight_aftermath_tracker.h
CMakeLists: Derive the source directory grouping from targets themselves Removes the need to store to separate SRC and HEADER variables, and then construct the target in most cases.
2018-01-17 19:37:34 -05:00
)
added video_core project to solution
2014-04-05 16:04:25 -04:00
CMakeLists: Derive the source directory grouping from targets themselves Removes the need to store to separate SRC and HEADER variables, and then construct the target in most cases.
2018-01-17 19:37:34 -05:00
create_target_directory_groups(video_core)
CMake cleanup Several cleanups to the buildsystem: - Do better factoring of common libs between platforms. - Add support to building on Windows. - Remove Qt4 support. - Re-sort file lists and add missing headers.
2014-08-23 21:22:05 -04:00
CMake: Correct inter-module dependencies and library visibility Modules didn't correctly define their dependencies before, which relied on the frontends implicitly including every module for linking to succeed. Also changed every target_link_libraries call to specify visibility of dependencies to avoid leaking definitions to dependents when not necessary.
2017-05-27 21:26:55 -04:00
target_link_libraries(video_core PUBLIC common core)
shader_recompiler,video_core: Cleanup some GCC and Clang errors Mostly fixing unused *, implicit conversion, braced scalar init, fpermissive, and some others. Some Clang errors likely remain in video_core, and std::ranges is still a pertinent issue in shader_recompiler shader_recompiler: cmake: Force bracket depth to 1024 on Clang Increases the maximum fold expression depth thread_worker: Include condition_variable Don't use list initializers in control flow Co-authored-by: ReinUsesLisp <reinuseslisp@airmail.cc>
2021-04-05 22:25:22 -04:00
target_link_libraries(video_core PUBLIC glad shader_recompiler xbyak)
renderer_vulkan: Integrate Nvidia Nsight Aftermath on Windows Adds optional support for Nsight Aftermath. It is enabled through ENABLE_NSIGHT_AFTERMATH in cmake. A path to the SDK has to be provided by the environment variable NSIGHT_AFTERMATH_SDK. Nsight Aftermath allows an application to generate "minidumps" of the GPU state when a device loss happens. By analysing these on Nsight we can know what a game was doing and why it triggered a device loss. The dump is generated inside %APPDATA%\yuzu\log\gpucrash and this directory is deleted every time a new instance is initialized with Nsight enabled. To enable it on yuzu there has a to be a driver and device capable of running Nsight Aftermath on Vulkan. That means only Turing based GPUs on the latest stable driver, beta drivers won't work for now. It is manually enabled in Configuration>Debug>Enable Graphics Debugging because when using all debugging capabilities there is a runtime cost.
2020-03-30 04:21:59 -04:00
CMake: Implement YUZU_USE_BUNDLED_FFMPEG For Linux, instructs CMake to use the FFmpeg submodule in externals. This is HEAVILY based on our usage of the late Unicorn. Minimal change to MSVC as it uses the yuzu-emu/ext-windows-bin. MinGW now targets the same ext-windows-bin libraries as MSVC for FFmpeg. Adds FFMPEG_LIBRARIES to WIN32 and simplifies video_core/CMakeLists.txt a bit.
2021-02-05 13:45:10 -05:00
if (YUZU_USE_BUNDLED_FFMPEG AND NOT WIN32)
add_dependencies(video_core ffmpeg-build)
video_core: NVDEC Implementation This commit aims to implement the NVDEC (Nvidia Decoder) functionality, with video frame decoding being handled by the FFmpeg library. The process begins with Ioctl commands being sent to the NVDEC and VIC (Video Image Composer) emulated devices. These allocate the necessary GPU buffers for the frame data, along with providing information on the incoming video data. A Submit command then signals the GPU to process and decode the frame data. To decode the frame, the respective codec's header must be manually composed from the information provided by NVDEC, then sent with the raw frame data to the ffmpeg library. Currently, H264 and VP9 are supported, with VP9 having some minor artifacting issues related mainly to the reference frame composition in its uncompressed header. Async GPU is not properly implemented at the moment. Co-Authored-By: David <25727384+ogniK5377@users.noreply.github.com>
2020-10-26 23:07:36 -04:00
endif()
CMake: Port citra-emu/citra FindFFmpeg.cmake Also renames related CMake variables to match both the Find*FFmpeg* and variables defined within the file. Fixes odd errors produced by the old FindFFmpeg. Citra's FindFFmpeg is slightly modified here: adds Citra's copyright at the beginning, renames FFmpeg_INCLUDES to FFmpeg_INCLUDE_DIR, disables a few components in _FFmpeg_ALL_COMPONENTS, and adds the missing avutil component to the comment above.
2021-02-05 15:39:19 -05:00
target_include_directories(video_core PRIVATE ${FFmpeg_INCLUDE_DIR})
target_link_libraries(video_core PRIVATE ${FFmpeg_LIBRARIES})
CMake: Implement YUZU_USE_BUNDLED_FFMPEG For Linux, instructs CMake to use the FFmpeg submodule in externals. This is HEAVILY based on our usage of the late Unicorn. Minimal change to MSVC as it uses the yuzu-emu/ext-windows-bin. MinGW now targets the same ext-windows-bin libraries as MSVC for FFmpeg. Adds FFMPEG_LIBRARIES to WIN32 and simplifies video_core/CMakeLists.txt a bit.
2021-02-05 13:45:10 -05:00
video_core/host_shaders: Add CMake integration for string shaders Add the necessary CMake code to copy the contents in a string source shader (GLSL or GLASM) to a header file then consumed by video_core files. This allows editting GLSL in its own files without having to maintain them in source files. For now, only OpenGL presentation shaders are moved, but we can add GLASM presentation shaders and static SPIR-V generation through glslangValidator in the future.
2020-08-23 20:28:15 -04:00
add_dependencies(video_core host_shaders)
target_include_directories(video_core PRIVATE ${HOST_SHADERS_INCLUDE})
cmake: Always enable Vulkan Removes the unnecesary burden of maintaining separate #ifdef paths and allows us sharing generic Vulkan code across APIs.
2020-12-24 18:22:07 -05:00
target_include_directories(video_core PRIVATE sirit ../../externals/Vulkan-Headers/include)
target_link_libraries(video_core PRIVATE sirit)
video_core: Treat implicit conversions as errors
2019-11-08 15:14:21 -05:00
renderer_vulkan: Integrate Nvidia Nsight Aftermath on Windows Adds optional support for Nsight Aftermath. It is enabled through ENABLE_NSIGHT_AFTERMATH in cmake. A path to the SDK has to be provided by the environment variable NSIGHT_AFTERMATH_SDK. Nsight Aftermath allows an application to generate "minidumps" of the GPU state when a device loss happens. By analysing these on Nsight we can know what a game was doing and why it triggered a device loss. The dump is generated inside %APPDATA%\yuzu\log\gpucrash and this directory is deleted every time a new instance is initialized with Nsight enabled. To enable it on yuzu there has a to be a driver and device capable of running Nsight Aftermath on Vulkan. That means only Turing based GPUs on the latest stable driver, beta drivers won't work for now. It is manually enabled in Configuration>Debug>Enable Graphics Debugging because when using all debugging capabilities there is a runtime cost.
2020-03-30 04:21:59 -04:00
if (ENABLE_NSIGHT_AFTERMATH)
if (NOT DEFINED ENV{NSIGHT_AFTERMATH_SDK})
video_core/cmake: Properly generate fatal errors on Aftermath Fix "message(ERROR ..." to "message(FATAL_ERROR ..." to properly stop cmake when Nsight Aftermath can't be configured.
2021-01-23 02:15:27 -05:00
message(FATAL_ERROR "Environment variable NSIGHT_AFTERMATH_SDK has to be provided")
renderer_vulkan: Integrate Nvidia Nsight Aftermath on Windows Adds optional support for Nsight Aftermath. It is enabled through ENABLE_NSIGHT_AFTERMATH in cmake. A path to the SDK has to be provided by the environment variable NSIGHT_AFTERMATH_SDK. Nsight Aftermath allows an application to generate "minidumps" of the GPU state when a device loss happens. By analysing these on Nsight we can know what a game was doing and why it triggered a device loss. The dump is generated inside %APPDATA%\yuzu\log\gpucrash and this directory is deleted every time a new instance is initialized with Nsight enabled. To enable it on yuzu there has a to be a driver and device capable of running Nsight Aftermath on Vulkan. That means only Turing based GPUs on the latest stable driver, beta drivers won't work for now. It is manually enabled in Configuration>Debug>Enable Graphics Debugging because when using all debugging capabilities there is a runtime cost.
2020-03-30 04:21:59 -04:00
endif()
if (NOT WIN32)
video_core/cmake: Properly generate fatal errors on Aftermath Fix "message(ERROR ..." to "message(FATAL_ERROR ..." to properly stop cmake when Nsight Aftermath can't be configured.
2021-01-23 02:15:27 -05:00
message(FATAL_ERROR "Nsight Aftermath doesn't support non-Windows platforms")
renderer_vulkan: Integrate Nvidia Nsight Aftermath on Windows Adds optional support for Nsight Aftermath. It is enabled through ENABLE_NSIGHT_AFTERMATH in cmake. A path to the SDK has to be provided by the environment variable NSIGHT_AFTERMATH_SDK. Nsight Aftermath allows an application to generate "minidumps" of the GPU state when a device loss happens. By analysing these on Nsight we can know what a game was doing and why it triggered a device loss. The dump is generated inside %APPDATA%\yuzu\log\gpucrash and this directory is deleted every time a new instance is initialized with Nsight enabled. To enable it on yuzu there has a to be a driver and device capable of running Nsight Aftermath on Vulkan. That means only Turing based GPUs on the latest stable driver, beta drivers won't work for now. It is manually enabled in Configuration>Debug>Enable Graphics Debugging because when using all debugging capabilities there is a runtime cost.
2020-03-30 04:21:59 -04:00
endif()
target_compile_definitions(video_core PRIVATE HAS_NSIGHT_AFTERMATH)
target_include_directories(video_core PRIVATE "$ENV{NSIGHT_AFTERMATH_SDK}/include")
endif()
video_core: Treat implicit conversions as errors
2019-11-08 15:14:21 -05:00
if (MSVC)
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 11:40:14 -05:00
target_compile_options(video_core PRIVATE
video_core: Enforce C4242
2021-06-28 03:53:52 -04:00
/we4242 # 'identifier': conversion from 'type1' to 'type2', possible loss of data
/we4244 # 'conversion': conversion from 'type1' to 'type2', possible loss of data
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 11:40:14 -05:00
/we4456 # Declaration of 'identifier' hides previous local declaration
/we4457 # Declaration of 'identifier' hides function parameter
/we4458 # Declaration of 'identifier' hides class member
/we4459 # Declaration of 'identifier' hides global declaration
)
video_core: Treat implicit conversions as errors
2019-11-08 15:14:21 -05:00
else()
video_core: Enforce -Wunused-variable and -Wunused-but-set-variable
2020-10-02 20:19:35 -04:00
target_compile_options(video_core PRIVATE
-Werror=conversion
-Wno-error=sign-conversion
video_core: Enforce -Wredundant-move and -Wpessimizing-move Silence three warnings and make them errors to avoid introducing more in the future.
2020-10-28 01:25:40 -04:00
-Werror=pessimizing-move
-Werror=redundant-move
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 11:40:14 -05:00
-Werror=shadow
video_core: Enforce -Werror=type-limits Silences one warning and avoids introducing more in the future.
2020-10-28 01:31:30 -04:00
-Werror=type-limits
video_core: Conditially activate relevant compiler warnings These compiler flags aren't shared with clang, so specifying these flags unconditionally can lead to a bit of warning spam. While we're in the area, we can also enable -Wunused-but-set-parameter given this is almost always a bug.
2020-10-20 19:24:28 -04:00
$<$<CXX_COMPILER_ID:GNU>:-Werror=class-memaccess>
$<$<CXX_COMPILER_ID:GNU>:-Werror=unused-but-set-parameter>
$<$<CXX_COMPILER_ID:GNU>:-Werror=unused-but-set-variable>
video_core: Enforce -Wunused-variable and -Wunused-but-set-variable
2020-10-02 20:19:35 -04:00
)
video_core: Treat implicit conversions as errors
2019-11-08 15:14:21 -05:00
endif()