* common: Add thread pool from yuzu
* Is really useful for asynchronous operations like shader compilation and custom textures, will be used in following PRs
* core: Improve ImageInterface
* Provide a default implementation so frontends don't have to duplicate code registering the lodepng version
* Add a dds version too which we will use in the next commit
* rasterizer_cache: Rewrite custom textures
* There's just too much to talk about here, look at the PR description for more details
* rasterizer_cache: Implement basic pack configuration file
* custom_tex_manager: Flip dumped textures
* custom_tex_manager: Optimize custom texture hashing
* If no convertions are needed then we can hash the decoded data directly removing the needed for duplicate decode
* custom_tex_manager: Implement asynchronous texture loading
* The file loading and decoding is offloaded into worker threads, while the upload itself still occurs in the main thread to avoid having to manage shared contexts
* Address review comments
* custom_tex_manager: Introduce custom material support
* video_core: Move custom textures to separate directory
* Also split the files to make the code cleaner
* gl_texture_runtime: Generate mipmaps for material
* custom_tex_manager: Prevent memory overflow when preloading
* externals: Add dds-ktx as submodule
* string_util: Return vector from SplitString
* No code benefits from passing it as an argument
* custom_textures: Use json config file
* gl_rasterizer: Only bind material for unit 0
* Address review comments
* rasterizer_cache: Remove custom texture code
* It's a hacky buggy mess, will be reimplemented later when the cache is in a better state
* rasterizer_cache: Refactor surface upload/download
* Switch to the texture_codec header which was written as part of the vulkan backend by steveice and me
* Move most of the upload logic to the rasterizer cache and out of the surface object
* Scaled uploads/downloads have been disabled for now since they require more runtime infrastructure
* rasterizer_cache: Refactor runtime interface
* Remove aspect enum which is the same as SurfaceType
* Replace Subresource with specific structures for each operation (blit/copy/clear). This mimics moderns APIs vulkan much better
* Pass the surface to the runtime instead of the texture
* Implement CopyTextures with glCopyImageSubData which is available on 4.3 and gles.
This function also has an overload for cubes which will be removed later.
* rasterizer_cache: Move texture allocation to the runtime
* renderer_opengl: Remove TextureDownloaderES
* It's overly compilcated and unused at the moment. Will be replaced with a simple compute shader in a later commit
* rasterizer_cache: Split CachedSurface
* This commit splits CachedSurface into two classes, SurfaceBase which contains the backend agnostic functions and Surface which is the opengl specific part
* For now the cache uses the opengl surface directly and there are a few ugly casts with watchers, those will be taken care of when the template convertion and watcher removal are added respectively
* rasterizer_cache: Move reinterpreters to the runtime
* rasterizer_cache: Move some pixel format function to the cpp file
* rasterizer_cache: Common texture acceleration functions
* They don't contain any backend specific code so they shouldn't be duplicated
* rasterizer_cache: Remove BlitSurfaces
* It's better to prefer copy/blit in the caller anyway
* rasterizer_cache: Only allocate needed levels
* rasterizer_cache: Move texture runtime out of common dir
* Also shorten the util header filename
* surface_params: Cleanup code
* Add more comments, organize it a bit etc
* rasterizer_cache: Move texture filtering to the runtime
* rasterizer_cache: Move to VideoCore
* renderer_opengl: Reimplement scaled uploads/downloads
* Instead of looking up for temporary textures, each allocation now contains both a scaled and unscaled handle
This allows the scale operations to be done inside the surface object itself and improves performance in general
* In particular the scaled download code has been expanded to use ARB_get_texture_sub_image when possible
which is faster and more convenient than glReadPixels. The latter is still relevant for OpenGLES though.
* Finally allocations are now given a handy debug name that can be viewed from renderdoc.
* rasterizer_cache: Remove global state
* gl_rasterizer: Abstract common draw operations to Framebuffer
* This also allows to cache framebuffer objects instead of always swapping the textures, something that particularly benefits mali gpus
* rasterizer_cache: Implement multi-level surfaces
* With this commit the cache can now directly upload and use mipmaps
without needing to sync them with watchers. By using native mimaps
directly this also adds support for mipmap for cube
* Texture cubes have also been updated to drop the watcher requirement
* host_shaders: Add CMake integration for string shaders
* Improves build time shader generation making it much less prone to errors.
Also moves the presentation shaders here to avoid embedding them to the cpp file.
* Texture filter shaders now make explicit use of uniform bindings for better vulkan compatibility
* renderer_opengl: Emulate lod bias in the shader
* This way opengles can emulate it correctly
* gl_rasterizer: Respect GL_MAX_TEXTURE_BUFFER_SIZE
* Older Bifrost Mali GPUs only support up to 64kb texture buffers. Citra would try to allocate a much larger buffer the first 64kb of which would work fine but after that the driver starts misbehaving and showing various graphical glitches
* rasterizer_cache: Cleanup CopySurface
* renderer_opengl: Keep frames synchronized when using a GPU debugger
* rasterizer_cache: Rename Surface to SurfaceRef
* Makes it clear that surface is a shared_ptr and not an object
* rasterizer_cache: Cleanup
* Move constructor to the top of the file
* Move FindMatch to the top as well and remove the Invalid flag which was redudant;
all FindMatch calls used it expect from MatchFlags::Copy which ignores it anyway
* gl_texture_runtime: Make driver const
* gl_texture_runtime: Fix RGB8 format handling
* The texture_codec header, being written with vulkan in mind converts RGB8 to RGBA8. The backend wasn't adjusted to account for this though and treated the data as RGB8.
* Also remove D16 convertions, both opengl and vulkan are required to support this format so these are not needed
* gl_texture_runtime: Reduce state switches during FBO blits
* glBlitFramebuffer is only affected by the scissor rectangle so just disable scissor testing instead of resetting our entire state
* surface_params: Prevent texcopy that spans multiple levels
* It would have failed before as well, with multi-level surfaces it triggers the assert though
* renderer_opengl: Centralize texture filters
* A lot of code is shared between the filters thus is makes it sense to centralize them
* Also fix an issue with partial texture uploads
* Address review comments
* rasterizer_cache: Use leading return types
* rasterizer_cache: Cleanup null checks
* renderer_opengl: Add additional logging
* externals: Actually downgrade glad
* For some reason I missed adding the files to git
* surface_params: Do not check for levels in exact match
* Some games will try to use the base level of a multi level surface. Checking for levels forces another surface to be created and a copy to be made which is both unncessary and breaks custom textures
---------
Co-authored-by: bunnei <bunneidev@gmail.com>
* externals: Update dynarmic
* settings: Introduce GraphicsAPI enum
* For now it's OpenGL only but will be expanded upon later
* citra_qt: Introduce backend agnostic context management
* Mostly a direct port from yuzu
* core: Simplify context acquire
* settings: Add option to create debug contexts
* renderer_opengl: Abstract initialization to Driver
* This commit also updates glad and adds some useful extensions which we will use in part 2
* Rasterizer construction is moved to the specific renderer instead of RendererBase.
Software rendering has been disable to achieve this but will be brought back in the next commit.
* video_core: Remove Init/Shutdown methods from renderer
* The constructor and destructor can do the same job
* In addition move opengl function loading to Qt since SDL already does this. Also remove ErrorVideoCore which is never reached
* citra_qt: Decouple software renderer from opengl part 1
* citra: Decouple software renderer from opengl part 2
* android: Decouple software renderer from opengl part 3
* swrasterizer: Decouple software renderer from opengl part 4
* This commit simply enforces the renderer naming conventions in the software renderer
* video_core: Move RendererBase to VideoCore
* video_core: De-globalize screenshot state
* video_core: Pass system to the renderers
* video_core: Commonize shader uniform data
* video_core: Abstract backend agnostic rasterizer operations
* bootmanager: Remove references to OpenGL for macOS
OpenGL macOS headers definitions clash heavily with each other
* citra_qt: Proper title for api settings
* video_core: Reduce boost usage
* bootmanager: Fix hide mouse option
Remove event handlers from RenderWidget for events that are
already handled by the parent GRenderWindow.
Also enable mouse tracking on the RenderWidget.
* android: Remove software from graphics api list
* code: Address review comments
* citra: Port per-game settings read
* Having to update the default value for all backends is a pain so lets centralize it
* android: Rename to OpenGLES
---------
Co-authored-by: MerryMage <MerryMage@users.noreply.github.com>
Co-authored-by: Vitor Kiguchi <vitor-kiguchi@hotmail.com>
* This commit aims to both continue the rasterizer cache cleanup by
separating CachedSurface into a dedicated header and to start weeding
out the raw OpenGL code from the cache.
* The latter is achieved by abstracting most texture operations in a new
class called TextureRuntime. This has many benefits such as making it easier
to port the functionality to other graphics APIs and the removal of the need
to pass (read/draw) framebuffer handles everywhere. The filterer and
reinterpreter get their own sets of FBOs due to this, something that
might be a performance win since it reduces the state switching
overhead on the runtime FBOs.
video_core: disable depth/stencil texture download on OpenGL ES
Disable deptch stencil shader in texture_downloader_es for now
enable_depth_stencil
DepthStencil
remove GL_DEBUG_OUTPUT_SYNCHRONOUS
* video_core/renderer_opengl/gl_rasterizer_cache: Create Format Reinterpretation Framework
Adds RGBA4 -> RGB5A1 reinterpretation commonly used by virtual console
If no matching surface can be found, ValidateSurface checks for a surface in the cache which is reinterpretable to the requested format.
If that fails, the cache is checked for any surface with a matching bit-width. If one is found, the region is flushed.
If not, the region is checked against dirty_regions to see if it was created entirely on the GPU.
If not, then the surface is flushed.
Co-Authored-By: James Rowe <jroweboy@users.noreply.github.com>
Co-Authored-By: Ben <b3n30@users.noreply.github.com>
temporary change to avoid merge conflicts with video dumping
* re-add D24S8->RGBA8 res_scale hack
* adress review comments
* fix dirty region check
* check for surfaces with invalid pixel format, and break logic into separate functions
* video_core/renderer_opengl: Move SurfaceParams into its own file
Some of its enums are needed outside of the rasterizer cache
and trying to use it caused circular dependencies.
* video_core/renderer_opengl: Overhaul the texture filter framework
This should make it less intrusive.
Now texture filtering doesn't have any mutable global state.
The texture filters now always upscale to the internal rendering resolution.
This simplifies the logic in UploadGLTexture and it simply takes the role of BlitTextures at the end of the function.
This also prevent extra blitting required when uploading to a framebuffer surface with a mismatched size.
* video_core/renderer_opengl: Use generated mipmaps for filtered textures
The filtered guest mipmaps often looked terrible.
* core/settings: Remove texture filter factor
* sdl/config: Remove texture filter factor
* qt/config: Remove texture filter factor
This uses the mailbox model to move pixel downloading to its own thread, eliminating Nvidia's warnings and (possibly) making use of GPU copy engine.
To achieve this, we created a new mailbox type that is different from the presentation mailbox in that it never discards a rendered frame.
Also, I tweaked the projection matrix thing so that it can just draw the frame upside down instead of having the CPU flip it.
* Add Anaglyph 3D
Change 3D slider in-game
Change shaders while game is running
Move shader loading into function
Disable 3D slider setting when stereoscopy is off
The rest of the shaders
Address review issues
Documentation and minor fixups
Forgot clang-format
Fix shader release on SDL2-software rendering
Remove unnecessary state changes
Respect 3D factor setting regardless of stereoscopic rendering
Improve shader resolution passing
Minor setting-related improvements
Add option to toggle texture filtering
Rebase fixes
* One final clang-format
* Fix OpenGL problems
video_core: shorten GetGLSLVersionString
video_core: make GLES version and extensions consistent
video_core: move some logic to LoadShader
video_core: deduplicate fragment shader precision specifier
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.
The geometry pipeline manages data transfer between VS, GS and primitive assembler. It has known four modes:
- no GS mode: sends VS output directly to the primitive assembler (what citra currently does)
- GS mode 0: sends VS output to GS input registers, and sends GS output to primitive assembler
- GS mode 1: sends VS output to GS uniform registers, and sends GS output to primitive assembler. It also takes an index from the index buffer at the beginning of each primitive for determine the primitive size.
- GS mode 2: similar to mode 1, but doesn't take the index and uses a fixed primitive size.
hwtest shows that immediate mode also supports GS (at least for mode 0), so the geometry pipeline gets refactored into its own class for supporting both drawing mode.
In the immediate mode, some games don't set the pipeline registers to a valid value until the first attribute input, so a geometry pipeline reset flag is set in `pipeline.vs_default_attributes_setup.index` trigger, and the actual pipeline reconfigure is triggered in the first attribute input.
In the normal drawing mode with index buffer, the vertex cache is a little bit modified to support the geometry pipeline. Instead of OutputVertex, it now holds AttributeBuffer, which is the input to the geometry pipeline. The AttributeBuffer->OutputVertex conversion is done inside the pipeline vertex handler. The actual hardware vertex cache is believed to be implemented in a similar way (because this is the only way that makes sense).
Both geometry pipeline and GS unit rely on states preservation across drawing call, so they are put into the global state. In the future, the other three vertex shader units should be also placed in the global state, and a scheduler should be implemented on top of the four units. Note that the current gs_unit already allows running VS on it in the future.
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.
