Every VideoCommon message goes through the printf log and alert macros,
PRIM_LOG included; a register field or an enum in a message is printed
as its number.
The names built along the way no longer go through fmt:
- a texture's name parts (its size, hashes and format) are formatted
into buffers on the stack, and the wildcard names concatenated;
- an EFB or XFB copy's name and dump path are made by one helper, from
an id formatted on the stack;
- dump paths, graphics mod paths and group names are concatenated;
- the projection lookup key is formatted on the stack, on the heap only
when a name runs past it, as before;
- the format overlay draws TextureFormatName, a constant string.
The no-op LOG_NORM and LOG_VTX macros, commented out since they were
added, are gone. The register formatters in the headers stay until the
assertions move over.
watcher ran a thread per watched directory (the texture pack's, the
graphics mods') so that a texture file changed on disk while a game
ran was loaded again; on Windows its backend throws, so its file was
the one built with exceptions. A texture pack or mod is now read as the
game starts, and a change to it is seen at the next start.
With it go Common::FilesystemWatcher, the library's map from file to
asset kept only to answer the watcher, and the asset cache's dirty
asset queue that only the watcher filled.
Every JSON reader (Triforce card decks, dynamic input textures, graphics
mods and their per-game profiles) now pulls its file through rjson from a
VFS filestream and fills its structures as it parses, with no document
tree in between. JsonUtil and the vendored picojson go away, as does the
graphics mod serialization nothing called.
Move and scale actions take their X, Y and Z straight from the parsed
feature instead of re-reading a kept JSON value. rjson.c and rjson.h are
imported unchanged from libretro-common.
Flush passes the bound cache entries' texture names by pointer instead
of copying each into a new string, and SetConstants walks the mod
manager's action lists in place instead of gathering them into a new
vector. The projection-texture lookup builds its key on the stack and
finds it through a string_view hash, skipping it when no mod targets one.
XFStateManager's change ranges are plain int/bool arrays handed out by
pointer; the savestate bytes are unchanged.
Both fed user-written GLSL to the backends at runtime, which the move to
bytecode emitted straight from the shader generators leaves no compiler
for. The frontend's own shader pipeline covers post-processing.
The presentation pass keeps a plain copy and the built-in correction
shader for output resampling, colour space and gamma correction and HDR
scaling, now compiled in rather than loaded from Sys/Shaders. The
graphics-mod system keeps its draw, EFB, projection and texture actions;
custom pipelines, materials, shader, mesh and sampler assets, the custom
constant buffers in every backend and the two mods built on them are
gone, along with the shader generators' custom-shader hooks.
Accomplished using `run-clang-tidy` with `performance-move-const-arg,performance-unnecessary-value-param,modernize-pass-by-value`.
Changed arguments to const references, removed them where inappropriate (e.g. sink parameters). Same with std::move.
Manually reviewed each change to make sure that it makes sense, and do something more appropriate if possible.
* Add a 'AfterEFB' function to graphics mod action that can return a Material
* Rename previous EFB graphics mod function to 'BeforeEFB' to differentiate from 'AfterEFB'
* Rename previous XFB graphics mod function to 'BeforeXFB' to mirror EFB
Yellow squiggly lines begone!
Done automatically on .cpp files through `run-clang-tidy`, with manual corrections to the mistakes.
If an import is directly used, but is technically unnecessary since it's recursively imported by something else, it is *not* removed.
The tool doesn't touch .h files, so I did some of them by hand while fixing errors due to old recursive imports.
Not everything is removed, but the cleanup should be substantial enough.
Because this done on Linux, code that isn't used on it is mostly untouched.
(Hopefully no open PR is depending on these imports...)
Fix some common anti-patterns with these data structures.
- You can dereference the iterator returned by `find` to access the
underlying value directly, without an extra `operator[]`/`at`.
- Rather than checking for an element before insertion/deletion, you can
just do the operation and if needed check the return value to
determine if the insertion/deletion succeeded.
Instead, we make the event take a reference to the system and then pass
it in when the event is triggered.
This does introduce two other accessors, but these are much easier to
refactor out over time, and without modification to the existing event
interface.
LibretroAdmin