VS emulation solutions without GLSL

[JayFoxRox]

Solutions without GLSL

A proper solution would be to use code which allows rounding modes to be deterministic. To my knowledge, of the GPU languages only OpenCL and GL NV VS allows this.
The following languages don't specify a rounding mode: GL ARB VS, Spir-V, GLSL, HLSL and Cg.

OpenCL

<FIXME: meh OpenCL sucks>
<FIXME: OpenCL in vulkan?>

VS JIT

A VS JIT is probably the best long-term solution we could use.
Most CPUs are IEEE float compatible and provide well-defined behaviour, this is a major benefit for accuracy.
This CPU environment is probably also the most maintainable / easy to understand code.

A JIT is also independent of rendering backend. So if we ever want to move to something like Vulkan, we wouldn't have to worry about shader translation.

State-shaders would also become trivial to implement.
State shaders essentially allow running a vertex shader which writes to constant registers.
That way, the CPU can read-back shader results.
So far, we are not aware of a single Xbox game using state-shaders. However, for testing and debugging tools, state-shaders might become useful in the future.

An often cited drawback of JITs is portability.
However, porting an emitter to a new architecture is often trivial as we only need a handful of different host instructions. There is no branching in Xbox shaders either.
For platforms which restrict running JIT'ed code, there could also be an interpreter which benefits from a JIT backend. However, we likely won't ever run on these platforms as our CPU (and possibly DSP) would also have the same issue.

Coming from a GLSL backend, we might also face a performance regression initially (See previously linked Citra experience). However, I assume we probably won't spend much time in our JIT'ed VS code (compared to Citra, also see notes in "Workarounds for GLSL" section above).
FIXME: The following is not true; we need to have this vertex upload for the FFP. so we need an alternative concept still. This is also not respected in the OpenCL section
Furthermore we reduce complexity / bandwidth of our vertex upload and we get rid of shader compilation stutter (as we move from a C like language to assembly emitters).
I'm not sure what the net outcome will be, but I don't think we'd suffer much performance issues when switching to JIT - we might even see speedups.