bool is not always guaranteed to be the same size on every platform.
On some platforms it may be one byte, on others it can be 8 bytes if the
platform dictates it. It's implementation-defined.
This can be problematic when it comes to storing this
data to disk (it can also be space-inefficient, but that's not really an
issue). Also say for some reason you moved your savestates to another
platform, it's possible they won't load correctly due to differences in size.
This change stores all bools to savestates as if they were a byte in size
and handles the loading of them accordingly.
During boot of Other M, there is momentarily a period when VICallback's
cycles late is larger than GetTicksPerHalfLine(). Because
GetTicksPerHalfLine() returns a u32 and c++'s weird type promotion rules,
cycleslate gets promoted from a s32 to a u32 and the result of the
substraction is a really large u32.
Before ScheduleEvent accuracy improvements, ScheduleEvent took a s32, so
the result got cast back to the small negitave we expect. But it now takes
a s64 and the u32 to s64 conversion gives us a really large number (around
two seconds) and Other M times out while waiting for something.
Now that the accuracy of ScheduleEvent has changed, 0 cycles will
schedule an event as soon as possible. But this breaks ATV 2.
So we schedule it 100 cycles out (unless it's a really short copy)
The NES games on the Zelda Collecters Edition disk use a XFB which is
only 256 pixels wide, but has a stide of 640 pixels.
This fits our definition of a interlaced xfb, as a second line of data
could fit in the extra space. The solution is to check that we are
actually in a interlaced video mode before activating the force
progressive hack.
MSVC's implementation of numeric_limits currently generates incorrect
signaling NaNs. The resulting values are actually quiet NaNs instead.
This commit is based off of a solution by shuffle2. The only
difference is a template specialization for floats is also added
to cover all bases
This is an oversight from pr https://github.com/dolphin-emu/dolphin/pull/3266 . Thanks to degasus for pointing this out.
It's possible that MAX_TEXTURE_BINARY_SIZE can be optimised, but i wanted to play it safe considering the 5.0 stable release.
Reading uninitalized memory is non-deterministic. We used to only
clear the memory when using EmulatedBS2_GC or FifoPlayer, but we
now do it during Memory::Init instead so it always gets done.
Drivers that don't support GL_ARB_shading_language_420pack require that
the storage qualifier be specified even when inside an interface block.
AMD's driver throws a compile error when "centroid in/out" is used within
an interface block.
Our previous behavior was to include the storage qualifier regardless, but
this wasn't working on AMD, therefore we should check for the presence of
the extension and include based on this, instead.
I'm not entirely sure what is happening, but this optimisation is causing an issue in Sonic Riders: Zero Gravity. Apparently the issue would also be fixed by PR#3747, but this PR should also fix similar issues.
Games that use partial updates might get slower with this, so some performance regression testing would be nice. Games like New Super Mario Bros, RS2, Zelda TP and Silent Hill. Testing with high graphics settings makes sense, since this would mostly end up in more work for the GPU.
Previously the default queryed the controller 4500 times a second,
Wasn't really a problem for most games as they set it to a sane
value. But fifoplayer didn't, and so in my profile dolphin spends
12% of the cpu time reading the controllers.
This new default value (I just took what the gamecube bios set)
drops that to 1.2% of cpu time and increase the framerate of the
silent hill fifo by 10-12%
The D3D backend was always forcing Anisotropic filtering when that is enabled regardless of how the game chose to configure the texture filtering registers; this causes the same issues as "Force Filtering" without Anisotropy, such as causing game UI elements to no longer line up adjacent correctly. Historically, OpenGL's Anisotropy support has always worked "better" than D3D's due to seeming to not have this problem; unfortunately, OpenGL's Anisotropy specification only gives GL_LINEAR based filtering modes defined behavior, with only the mipmap setting being required to be considered. Some OpenGL implementations were implicitly disabling Anisotropy when the min/mag filters were set to GL_NEAREST, but this behavior is not required by the spec so cannot be relied on.
Events scheduled more than 4.12 seconds in the future (2.96 seconds for
Wii games) would overflow the sign bit and get scheduled in the past
instead, causing them to fire instantly.
Previously GlobalTimer was only updated at the end of each slice
when CoreTiming::Advance() was called, so it could be upto 20,000
cycles off.
This was causing huge problems with games which made heavy use of
the time base register, such as OoT (virtual console) and Pokemon
puzzle.
I've also made it so event scheduling will be accurate to the jit
block level, instead of accurate to the slice.
