drashna/ryujinx
1
0
Fork 0
Code Activity Actions

Initial work

Browse source
This commit is contained in:
gdk 2019-10-13 03:02:07 -03:00 • committed by Thog
parent f617fb542a
commit 1876b346fe
518 changed files with 15170 additions and 12486 deletions
Download patch file Download diff file Expand all files Collapse all files

15
Ryujinx.Graphics.Gpu/State/BlendState.cs Normal file
View file

@ -0,0 +1,15 @@
using Ryujinx.Graphics.GAL.Blend;
namespace Ryujinx.Graphics.Gpu.State
{
struct BlendState
{
public Bool SeparateAlpha;
public BlendOp ColorOp;
public BlendFactor ColorSrcFactor;
public BlendFactor ColorDstFactor;
public BlendOp AlphaOp;
public BlendFactor AlphaSrcFactor;
public BlendFactor AlphaDstFactor;
}
}

17
Ryujinx.Graphics.Gpu/State/Bool.cs Normal file
View file

@ -0,0 +1,17 @@
namespace Ryujinx.Graphics.Gpu.State
{
struct Bool
{
private uint _value;
public bool IsTrue()
{
return (_value & 1) != 0;
}
public bool IsFalse()
{
return (_value & 1) == 0;
}
}
}

10
Ryujinx.Graphics.Gpu/State/ClearColors.cs Normal file
View file

@ -0,0 +1,10 @@
namespace Ryujinx.Graphics.Gpu.State
{
struct ClearColors
{
public float Red;
public float Green;
public float Blue;
public float Alpha;
}
}

11
Ryujinx.Graphics.Gpu/State/Condition.cs Normal file
View file

@ -0,0 +1,11 @@
namespace Ryujinx.Graphics.Gpu.State
{
enum Condition
{
Never,
Always,
ResultNonZero,
Equal,
NotEqual
}
}

8
Ryujinx.Graphics.Gpu/State/ConditionState.cs Normal file
View file

@ -0,0 +1,8 @@
namespace Ryujinx.Graphics.Gpu.State
{
struct ConditionState
{
public GpuVa Address;
public Condition Condition;
}
}

12
Ryujinx.Graphics.Gpu/State/CopyBufferParams.cs Normal file
View file

@ -0,0 +1,12 @@
namespace Ryujinx.Graphics.Gpu.State
{
struct CopyBufferParams
{
public GpuVa SrcAddress;
public GpuVa DstAddress;
public int SrcStride;
public int DstStride;
public int XCount;
public int YCount;
}
}

22
Ryujinx.Graphics.Gpu/State/CopyBufferSwizzle.cs Normal file
View file

@ -0,0 +1,22 @@
namespace Ryujinx.Graphics.Gpu.State
{
struct CopyBufferSwizzle
{
public uint Swizzle;
public int UnpackComponentSize()
{
return (int)((Swizzle >> 16) & 3) + 1;
}
public int UnpackSrcComponentsCount()
{
return (int)((Swizzle >> 20) & 7) + 1;
}
public int UnpackDstComponentsCount()
{
return (int)((Swizzle >> 24) & 7) + 1;
}
}
}

13
Ryujinx.Graphics.Gpu/State/CopyBufferTexture.cs Normal file
View file

@ -0,0 +1,13 @@
namespace Ryujinx.Graphics.Gpu.State
{
struct CopyBufferTexture
{
public MemoryLayout MemoryLayout;
public int Width;
public int Height;
public int Depth;
public int RegionZ;
public ushort RegionX;
public ushort RegionY;
}
}

14
Ryujinx.Graphics.Gpu/State/CopyRegion.cs Normal file
View file

@ -0,0 +1,14 @@
namespace Ryujinx.Graphics.Gpu.State
{
struct CopyRegion
{
public int DstX;
public int DstY;
public int DstWidth;
public int DstHeight;
public long SrcWidthRF;
public long SrcHeightRF;
public long SrcXF;
public long SrcYF;
}
}

15
Ryujinx.Graphics.Gpu/State/CopyTexture.cs Normal file
View file

@ -0,0 +1,15 @@
namespace Ryujinx.Graphics.Gpu.State
{
struct CopyTexture
{
public RtFormat Format;
public bool LinearLayout;
public MemoryLayout MemoryLayout;
public int Depth;
public int Layer;
public int Stride;
public int Width;
public int Height;
public GpuVa Address;
}
}

12
Ryujinx.Graphics.Gpu/State/CopyTextureControl.cs Normal file
View file

@ -0,0 +1,12 @@
namespace Ryujinx.Graphics.Gpu.State
{
struct CopyTextureControl
{
public uint Packed;
public bool UnpackLinearFilter()
{
return (Packed & (1u << 4)) != 0;
}
}
}

9
Ryujinx.Graphics.Gpu/State/DepthBiasState.cs Normal file
View file

@ -0,0 +1,9 @@
namespace Ryujinx.Graphics.Gpu.State
{
struct DepthBiasState
{
public Bool PointEnable;
public Bool LineEnable;
public Bool FillEnable;
}
}

11
Ryujinx.Graphics.Gpu/State/FaceState.cs Normal file
View file

@ -0,0 +1,11 @@
using Ryujinx.Graphics.GAL;
namespace Ryujinx.Graphics.Gpu.State
{
struct FaceState
{
public Bool CullEnable;
public FrontFace FrontFace;
public Face CullFace;
}
}

425
Ryujinx.Graphics.Gpu/State/GpuState.cs Normal file
View file

@ -0,0 +1,425 @@
using Ryujinx.Graphics.GAL;
using Ryujinx.Graphics.Gpu.Image;
using System;
using System.Runtime.InteropServices;
namespace Ryujinx.Graphics.Gpu.State
{
class GpuState
{
private const int RegistersCount = 0xe00;
public delegate void MethodCallback(int argument);
private int[] _backingMemory;
private struct Register
{
public MethodCallback Callback;
public StateWriteFlags WriteFlag;
}
private Register[] _registers;
public StateWriteFlags StateWriteFlags { get; set; }
public GpuState()
{
_backingMemory = new int[RegistersCount];
_registers = new Register[RegistersCount];
StateWriteFlags = StateWriteFlags.Any;
InitializeDefaultState();
InitializeStateWatchers();
}
public bool ExitEarly;
public void CallMethod(MethodParams meth)
{
if (ExitEarly)
{
return;
}
Register register = _registers[meth.Method];
if (_backingMemory[meth.Method] != meth.Argument)
{
StateWriteFlags |= register.WriteFlag;
}
_backingMemory[meth.Method] = meth.Argument;
MethodCallback callback = register.Callback;
if (callback != null)
{
callback(meth.Argument);
}
}
public int Read(int offset)
{
return _backingMemory[offset];
}
public void RegisterCopyBufferCallback(MethodCallback callback)
{
RegisterCallback(0xc0, callback);
}
public void RegisterCopyTextureCallback(MethodCallback callback)
{
RegisterCallback(0x237, callback);
}
public void RegisterDrawEndCallback(MethodCallback callback)
{
RegisterCallback(0x585, callback);
}
public void RegisterDrawBeginCallback(MethodCallback callback)
{
RegisterCallback(0x586, callback);
}
public void RegisterSetIndexCountCallback(MethodCallback callback)
{
RegisterCallback(0x5f8, callback);
}
public void RegisterClearCallback(MethodCallback callback)
{
RegisterCallback(0x674, callback);
}
public void RegisterReportCallback(MethodCallback callback)
{
RegisterCallback(0x6c3, callback);
}
public void RegisterUniformBufferUpdateCallback(MethodCallback callback)
{
for (int index = 0; index < 16; index++)
{
RegisterCallback(0x8e4 + index, callback);
}
}
public void RegisterUniformBufferBind0Callback(MethodCallback callback)
{
RegisterCallback(0x904, callback);
}
public void RegisterUniformBufferBind1Callback(MethodCallback callback)
{
RegisterCallback(0x90c, callback);
}
public void RegisterUniformBufferBind2Callback(MethodCallback callback)
{
RegisterCallback(0x914, callback);
}
public void RegisterUniformBufferBind3Callback(MethodCallback callback)
{
RegisterCallback(0x91c, callback);
}
public void RegisterUniformBufferBind4Callback(MethodCallback callback)
{
RegisterCallback(0x924, callback);
}
public CopyTexture GetCopyDstTexture()
{
return Get<CopyTexture>(MethodOffset.CopyDstTexture);
}
public CopyTexture GetCopySrcTexture()
{
return Get<CopyTexture>(MethodOffset.CopySrcTexture);
}
public RtColorState GetRtColorState(int index)
{
return Get<RtColorState>(MethodOffset.RtColorState + 16 * index);
}
public CopyTextureControl GetCopyTextureControl()
{
return Get<CopyTextureControl>(MethodOffset.CopyTextureControl);
}
public CopyRegion GetCopyRegion()
{
return Get<CopyRegion>(MethodOffset.CopyRegion);
}
public ViewportTransform GetViewportTransform(int index)
{
return Get<ViewportTransform>(MethodOffset.ViewportTransform + 8 * index);
}
public ViewportExtents GetViewportExtents(int index)
{
return Get<ViewportExtents>(MethodOffset.ViewportExtents + 4 * index);
}
public VertexBufferDrawState GetVertexBufferDrawState()
{
return Get<VertexBufferDrawState>(MethodOffset.VertexBufferDrawState);
}
public ClearColors GetClearColors()
{
return Get<ClearColors>(MethodOffset.ClearColors);
}
public float GetClearDepthValue()
{
return Get<float>(MethodOffset.ClearDepthValue);
}
public int GetClearStencilValue()
{
return _backingMemory[(int)MethodOffset.ClearStencilValue];
}
public StencilBackMasks GetStencilBackMasks()
{
return Get<StencilBackMasks>(MethodOffset.StencilBackMasks);
}
public RtDepthStencilState GetRtDepthStencilState()
{
return Get<RtDepthStencilState>(MethodOffset.RtDepthStencilState);
}
public VertexAttribState GetVertexAttribState(int index)
{
return Get<VertexAttribState>(MethodOffset.VertexAttribState + index);
}
public Size3D GetRtDepthStencilSize()
{
return Get<Size3D>(MethodOffset.RtDepthStencilSize);
}
public Bool GetDepthTestEnable()
{
return Get<Bool>(MethodOffset.DepthTestEnable);
}
public CompareOp GetDepthTestFunc()
{
return Get<CompareOp>(MethodOffset.DepthTestFunc);
}
public Bool GetDepthWriteEnable()
{
return Get<Bool>(MethodOffset.DepthWriteEnable);
}
public Bool GetBlendEnable(int index)
{
return Get<Bool>(MethodOffset.BlendEnable + index);
}
public StencilTestState GetStencilTestState()
{
return Get<StencilTestState>(MethodOffset.StencilTestState);
}
public int GetBaseVertex()
{
return _backingMemory[(int)MethodOffset.FirstVertex];
}
public int GetBaseInstance()
{
return _backingMemory[(int)MethodOffset.FirstInstance];
}
public PoolState GetSamplerPoolState()
{
return Get<PoolState>(MethodOffset.SamplerPoolState);
}
public PoolState GetTexturePoolState()
{
return Get<PoolState>(MethodOffset.TexturePoolState);
}
public StencilBackTestState GetStencilBackTestState()
{
return Get<StencilBackTestState>(MethodOffset.StencilBackTestState);
}
public TextureMsaaMode GetRtMsaaMode()
{
return Get<TextureMsaaMode>(MethodOffset.RtMsaaMode);
}
public GpuVa GetShaderBaseAddress()
{
return Get<GpuVa>(MethodOffset.ShaderBaseAddress);
}
public PrimitiveRestartState GetPrimitiveRestartState()
{
return Get<PrimitiveRestartState>(MethodOffset.PrimitiveRestartState);
}
public IndexBufferState GetIndexBufferState()
{
return Get<IndexBufferState>(MethodOffset.IndexBufferState);
}
public FaceState GetFaceState()
{
return Get<FaceState>(MethodOffset.FaceState);
}
public ReportState GetReportState()
{
return Get<ReportState>(MethodOffset.ReportState);
}
public VertexBufferState GetVertexBufferState(int index)
{
return Get<VertexBufferState>(MethodOffset.VertexBufferState + 4 * index);
}
public BlendState GetBlendState(int index)
{
return Get<BlendState>(MethodOffset.BlendState + 8 * index);
}
public GpuVa GetVertexBufferEndAddress(int index)
{
return Get<GpuVa>(MethodOffset.VertexBufferEndAddress + 2 * index);
}
public ShaderState GetShaderState(int index)
{
return Get<ShaderState>(MethodOffset.ShaderState + 16 * index);
}
public UniformBufferState GetUniformBufferState()
{
return Get<UniformBufferState>(MethodOffset.UniformBufferState);
}
public void SetUniformBufferOffset(int offset)
{
_backingMemory[(int)MethodOffset.UniformBufferState + 3] = offset;
}
public int GetTextureBufferIndex()
{
return _backingMemory[(int)MethodOffset.TextureBufferIndex];
}
private void InitializeDefaultState()
{
// Depth ranges.
for (int index = 0; index < 8; index++)
{
_backingMemory[(int)MethodOffset.ViewportExtents + index * 4 + 2] = 0;
_backingMemory[(int)MethodOffset.ViewportExtents + index * 4 + 3] = 0x3F800000;
}
// Default front stencil mask.
_backingMemory[0x4e7] = 0xff;
// Default color mask.
_backingMemory[(int)MethodOffset.RtColorMask] = 0x1111;
}
private void InitializeStateWatchers()
{
SetWriteStateFlag(MethodOffset.RtColorState, StateWriteFlags.RtColorState, 16 * 8);
SetWriteStateFlag(MethodOffset.ViewportTransform, StateWriteFlags.ViewportTransform, 8 * 8);
SetWriteStateFlag(MethodOffset.ViewportExtents, StateWriteFlags.ViewportTransform, 4 * 8);
SetWriteStateFlag<VertexBufferDrawState>(MethodOffset.VertexBufferDrawState, StateWriteFlags.VertexBufferState);
SetWriteStateFlag<DepthBiasState>(MethodOffset.DepthBiasState, StateWriteFlags.DepthBiasState);
SetWriteStateFlag(MethodOffset.DepthBiasFactor, StateWriteFlags.DepthBiasState, 1);
SetWriteStateFlag(MethodOffset.DepthBiasUnits, StateWriteFlags.DepthBiasState, 1);
SetWriteStateFlag(MethodOffset.DepthBiasClamp, StateWriteFlags.DepthBiasState, 1);
SetWriteStateFlag<RtDepthStencilState>(MethodOffset.RtDepthStencilState, StateWriteFlags.RtDepthStencilState);
SetWriteStateFlag<Size3D> (MethodOffset.RtDepthStencilSize, StateWriteFlags.RtDepthStencilState);
SetWriteStateFlag(MethodOffset.DepthTestEnable, StateWriteFlags.DepthTestState, 1);
SetWriteStateFlag(MethodOffset.DepthWriteEnable, StateWriteFlags.DepthTestState, 1);
SetWriteStateFlag(MethodOffset.DepthTestFunc, StateWriteFlags.DepthTestState, 1);
SetWriteStateFlag(MethodOffset.VertexAttribState, StateWriteFlags.VertexAttribState, 16);
SetWriteStateFlag<StencilBackMasks> (MethodOffset.StencilBackMasks, StateWriteFlags.StencilTestState);
SetWriteStateFlag<StencilTestState> (MethodOffset.StencilTestState, StateWriteFlags.StencilTestState);
SetWriteStateFlag<StencilBackTestState>(MethodOffset.StencilBackTestState, StateWriteFlags.StencilTestState);
SetWriteStateFlag<PoolState>(MethodOffset.SamplerPoolState, StateWriteFlags.SamplerPoolState);
SetWriteStateFlag<PoolState>(MethodOffset.TexturePoolState, StateWriteFlags.TexturePoolState);
SetWriteStateFlag<ShaderState>(MethodOffset.ShaderBaseAddress, StateWriteFlags.ShaderState);
SetWriteStateFlag<PrimitiveRestartState>(MethodOffset.PrimitiveRestartState, StateWriteFlags.PrimitiveRestartState);
SetWriteStateFlag<IndexBufferState>(MethodOffset.IndexBufferState, StateWriteFlags.IndexBufferState);
SetWriteStateFlag<FaceState>(MethodOffset.FaceState, StateWriteFlags.FaceState);
SetWriteStateFlag<RtColorMask>(MethodOffset.RtColorMask, StateWriteFlags.RtColorMask);
SetWriteStateFlag(MethodOffset.VertexBufferInstanced, StateWriteFlags.VertexBufferState, 16);
SetWriteStateFlag(MethodOffset.VertexBufferState, StateWriteFlags.VertexBufferState, 4 * 16);
SetWriteStateFlag(MethodOffset.VertexBufferEndAddress, StateWriteFlags.VertexBufferState, 2 * 16);
SetWriteStateFlag(MethodOffset.BlendEnable, StateWriteFlags.BlendState, 8);
SetWriteStateFlag(MethodOffset.BlendState, StateWriteFlags.BlendState, 8 * 8);
SetWriteStateFlag(MethodOffset.ShaderState, StateWriteFlags.ShaderState, 16 * 6);
SetWriteStateFlag(MethodOffset.TextureBufferIndex, StateWriteFlags.TexturePoolState, 1);
}
private void SetWriteStateFlag<T>(MethodOffset offset, StateWriteFlags flag)
{
SetWriteStateFlag(offset, flag, Marshal.SizeOf<T>());
}
private void SetWriteStateFlag(MethodOffset offset, StateWriteFlags flag, int size)
{
for (int index = 0; index < size; index++)
{
_registers[(int)offset + index].WriteFlag = flag;
}
}
public void RegisterCallback(MethodOffset offset, MethodCallback callback)
{
_registers[(int)offset].Callback = callback;
}
private void RegisterCallback(int offset, MethodCallback callback)
{
_registers[offset].Callback = callback;
}
public T Get<T>(MethodOffset offset) where T : struct
{
return MemoryMarshal.Cast<int, T>(_backingMemory.AsSpan().Slice((int)offset))[0];
}
}
}

18
Ryujinx.Graphics.Gpu/State/GpuVa.cs Normal file
View file

@ -0,0 +1,18 @@
namespace Ryujinx.Graphics.Gpu.State
{
struct GpuVa
{
public uint High;
public uint Low;
public ulong Pack()
{
return Low | ((ulong)High << 32);
}
public bool IsNullPtr()
{
return (Low | High) == 0;
}
}
}

13
Ryujinx.Graphics.Gpu/State/IndexBufferState.cs Normal file
View file

@ -0,0 +1,13 @@
using Ryujinx.Graphics.GAL;
namespace Ryujinx.Graphics.Gpu.State
{
struct IndexBufferState
{
public GpuVa Address;
public GpuVa EndAddress;
public IndexType Type;
public int First;
public int Count;
}
}

17
Ryujinx.Graphics.Gpu/State/Inline2MemoryParams.cs Normal file
View file

@ -0,0 +1,17 @@
namespace Ryujinx.Graphics.Gpu.State
{
struct Inline2MemoryParams
{
public int LineLengthIn;
public int LineCount;
public GpuVa DstAddress;
public int DstStride;
public MemoryLayout DstMemoryLayout;
public int DstWidth;
public int DstHeight;
public int DstDepth;
public int DstZ;
public int DstX;
public int DstY;
}
}

32
Ryujinx.Graphics.Gpu/State/MemoryLayout.cs Normal file
View file

@ -0,0 +1,32 @@
namespace Ryujinx.Graphics.Gpu.State
{
struct MemoryLayout
{
public uint Packed;
public int UnpackGobBlocksInX()
{
return 1 << (int)(Packed & 0xf);
}
public int UnpackGobBlocksInY()
{
return 1 << (int)((Packed >> 4) & 0xf);
}
public int UnpackGobBlocksInZ()
{
return 1 << (int)((Packed >> 8) & 0xf);
}
public bool UnpackIsLinear()
{
return (Packed & 0x1000) != 0;
}
public bool UnpackIsTarget3D()
{
return (Packed & 0x10000) != 0;
}
}
}

62
Ryujinx.Graphics.Gpu/State/MethodOffset.cs Normal file
View file

@ -0,0 +1,62 @@
namespace Ryujinx.Graphics.Gpu.State
{
enum MethodOffset
{
Inline2MemoryParams = 0x60,
Inline2MemoryExecute = 0x6c,
Inline2MemoryPushData = 0x6d,
CopyDstTexture = 0x80,
CopySrcTexture = 0x8c,
DispatchParamsAddress = 0xad,
Dispatch = 0xaf,
CopyBufferParams = 0x100,
CopyBufferSwizzle = 0x1c2,
CopyBufferDstTexture = 0x1c3,
CopyBufferSrcTexture = 0x1ca,
RtColorState = 0x200,
CopyTextureControl = 0x223,
CopyRegion = 0x22c,
ViewportTransform = 0x280,
ViewportExtents = 0x300,
VertexBufferDrawState = 0x35d,
ClearColors = 0x360,
ClearDepthValue = 0x364,
ClearStencilValue = 0x368,
DepthBiasState = 0x370,
StencilBackMasks = 0x3d5,
InvalidateTextures = 0x3dd,
RtDepthStencilState = 0x3f8,
VertexAttribState = 0x458,
RtDepthStencilSize = 0x48a,
DepthTestEnable = 0x4b3,
DepthWriteEnable = 0x4ba,
DepthTestFunc = 0x4c3,
BlendEnable = 0x4d8,
StencilTestState = 0x4e0,
FirstVertex = 0x50d,
FirstInstance = 0x50e,
ResetCounter = 0x54c,
RtDepthStencilEnable = 0x54e,
ConditionState = 0x554,
SamplerPoolState = 0x557,
DepthBiasFactor = 0x55b,
TexturePoolState = 0x55d,
StencilBackTestState = 0x565,
DepthBiasUnits = 0x56f,
RtMsaaMode = 0x574,
ShaderBaseAddress = 0x582,
PrimitiveRestartState = 0x591,
IndexBufferState = 0x5f2,
DepthBiasClamp = 0x61f,
VertexBufferInstanced = 0x620,
FaceState = 0x646,
RtColorMask = 0x680,
ReportState = 0x6c0,
VertexBufferState = 0x700,
BlendState = 0x780,
VertexBufferEndAddress = 0x7c0,
ShaderState = 0x800,
UniformBufferState = 0x8e0,
TextureBufferIndex = 0x982
}
}

8
Ryujinx.Graphics.Gpu/State/PoolState.cs Normal file
View file

@ -0,0 +1,8 @@
namespace Ryujinx.Graphics.Gpu.State
{
struct PoolState
{
public GpuVa Address;
public int MaximumId;
}
}

8
Ryujinx.Graphics.Gpu/State/PrimitiveRestartState.cs Normal file
View file

@ -0,0 +1,8 @@
namespace Ryujinx.Graphics.Gpu.State
{
struct PrimitiveRestartState
{
public bool Enable;
public int Index;
}
}

50
Ryujinx.Graphics.Gpu/State/PrimitiveTopology.cs Normal file
View file

@ -0,0 +1,50 @@
using Ryujinx.Graphics.GAL;
namespace Ryujinx.Graphics.Gpu.State
{
enum PrimitiveType
{
Points,
Lines,
LineLoop,
LineStrip,
Triangles,
TriangleStrip,
TriangleFan,
Quads,
QuadStrip,
Polygon,
LinesAdjacency,
LineStripAdjacency,
TrianglesAdjacency,
TriangleStripAdjacency,
Patches
}
static class PrimitiveTypeConverter
{
public static PrimitiveTopology Convert(this PrimitiveType topology)
{
switch (topology)
{
case PrimitiveType.Points: return PrimitiveTopology.Points;
case PrimitiveType.Lines: return PrimitiveTopology.Lines;
case PrimitiveType.LineLoop: return PrimitiveTopology.LineLoop;
case PrimitiveType.LineStrip: return PrimitiveTopology.LineStrip;
case PrimitiveType.Triangles: return PrimitiveTopology.Triangles;
case PrimitiveType.TriangleStrip: return PrimitiveTopology.TriangleStrip;
case PrimitiveType.TriangleFan: return PrimitiveTopology.TriangleFan;
case PrimitiveType.Quads: return PrimitiveTopology.Quads;
case PrimitiveType.QuadStrip: return PrimitiveTopology.QuadStrip;
case PrimitiveType.Polygon: return PrimitiveTopology.Polygon;
case PrimitiveType.LinesAdjacency: return PrimitiveTopology.LinesAdjacency;
case PrimitiveType.LineStripAdjacency: return PrimitiveTopology.LineStripAdjacency;
case PrimitiveType.TrianglesAdjacency: return PrimitiveTopology.TrianglesAdjacency;
case PrimitiveType.TriangleStripAdjacency: return PrimitiveTopology.TriangleStripAdjacency;
case PrimitiveType.Patches: return PrimitiveTopology.Patches;
}
return PrimitiveTopology.Triangles;
}
}
}

25
Ryujinx.Graphics.Gpu/State/ReportCounterType.cs Normal file
View file

@ -0,0 +1,25 @@
namespace Ryujinx.Graphics.Gpu.State
{
enum ReportCounterType
{
Zero = 0,
InputVertices = 1,
InputPrimitives = 3,
VertexShaderInvocations = 5,
GeometryShaderInvocations = 7,
GeometryShaderPrimitives = 9,
TransformFeedbackPrimitivesWritten = 0xb,
ClipperInputPrimitives = 0xf,
ClipperOutputPrimitives = 0x11,
PrimitivesGenerated = 0x12,
FragmentShaderInvocations = 0x13,
SamplesPassed = 0x15,
TessControlShaderInvocations = 0x1b,
TessEvaluationShaderInvocations = 0x1d,
TessEvaluationShaderPrimitives = 0x1f,
ZcullStats0 = 0x2a,
ZcullStats1 = 0x2c,
ZcullStats2 = 0x2e,
ZcullStats3 = 0x30
}
}

8
Ryujinx.Graphics.Gpu/State/ReportMode.cs Normal file
View file

@ -0,0 +1,8 @@
namespace Ryujinx.Graphics.Gpu.State
{
enum ReportMode
{
Semaphore = 0,
Counter = 2
}
}

9
Ryujinx.Graphics.Gpu/State/ReportState.cs Normal file
View file

@ -0,0 +1,9 @@
namespace Ryujinx.Graphics.Gpu.State
{
struct ReportState
{
public GpuVa Address;
public int Payload;
public uint Control;
}
}

21
Ryujinx.Graphics.Gpu/State/ResetCounterType.cs Normal file
View file

@ -0,0 +1,21 @@
namespace Ryujinx.Graphics.Gpu.State
{
enum ResetCounterType
{
SamplesPassed = 1,
ZcullStats = 2,
TransformFeedbackPrimitivesWritten = 0x10,
InputVertices = 0x12,
InputPrimitives = 0x13,
VertexShaderInvocations = 0x15,
TessControlShaderInvocations = 0x16,
TessEvaluationShaderInvocations = 0x17,
TessEvaluationShaderPrimitives = 0x18,
GeometryShaderInvocations = 0x1a,
GeometryShaderPrimitives = 0x1b,
ClipperInputPrimitives = 0x1c,
ClipperOutputPrimitives = 0x1d,
FragmentShaderInvocations = 0x1e,
PrimitivesGenerated = 0x1f
}
}

27
Ryujinx.Graphics.Gpu/State/RtColorMask.cs Normal file
View file

@ -0,0 +1,27 @@
namespace Ryujinx.Graphics.Gpu.State
{
struct RtColorMask
{
public uint Packed;
public bool UnpackRed()
{
return (Packed & 0x1) != 0;
}
public bool UnpackGreen()
{
return (Packed & 0x10) != 0;
}
public bool UnpackBlue()
{
return (Packed & 0x100) != 0;
}
public bool UnpackAlpha()
{
return (Packed & 0x1000) != 0;
}
}
}

13
Ryujinx.Graphics.Gpu/State/RtColorState.cs Normal file
View file

@ -0,0 +1,13 @@
namespace Ryujinx.Graphics.Gpu.State
{
struct RtColorState
{
public GpuVa Address;
public int WidthOrStride;
public int Height;
public RtFormat Format;
public MemoryLayout MemoryLayout;
public int Depth;
public int LayerSize;
}
}

10
Ryujinx.Graphics.Gpu/State/RtDepthStencilState.cs Normal file
View file

@ -0,0 +1,10 @@
namespace Ryujinx.Graphics.Gpu.State
{
struct RtDepthStencilState
{
public GpuVa Address;
public RtFormat Format;
public MemoryLayout MemoryLayout;
public int LayerSize;
}
}

137
Ryujinx.Graphics.Gpu/State/RtFormat.cs Normal file
View file

@ -0,0 +1,137 @@
using Ryujinx.Graphics.GAL;
using Ryujinx.Graphics.Gpu.Image;
namespace Ryujinx.Graphics.Gpu.State
{
enum RtFormat
{
D32Float = 0xa,
D16Unorm = 0x13,
D24UnormS8Uint = 0x14,
S8Uint = 0x17,
D32FloatS8Uint = 0x19,
R32G32B32A32Float = 0xc0,
R32G32B32A32Sint = 0xc1,
R32G32B32A32Uint = 0xc2,
R32G32B32X32Float = 0xc3,
R32G32B32X32Sint = 0xc4,
R32G32B32X32Uint = 0xc5,
R16G16B16X16Unorm = 0xc6,
R16G16B16X16Snorm = 0xc7,
R16G16B16X16Sint = 0xc8,
R16G16B16X16Uint = 0xc9,
R16G16B16A16Float = 0xca,
R32G32Float = 0xcb,
R32G32Sint = 0xcc,
R32G32Uint = 0xcd,
R16G16B16X16Float = 0xce,
B8G8R8A8Unorm = 0xcf,
B8G8R8A8Srgb = 0xd0,
R10G10B10A2Unorm = 0xd1,
R10G10B10A2Uint = 0xd2,
R8G8B8A8Unorm = 0xd5,
R8G8B8A8Srgb = 0xd6,
R8G8B8X8Snorm = 0xd7,
R8G8B8X8Sint = 0xd8,
R8G8B8X8Uint = 0xd9,
R16G16Unorm = 0xda,
R16G16Snorm = 0xdb,
R16G16Sint = 0xdc,
R16G16Uint = 0xdd,
R16G16Float = 0xde,
R11G11B10Float = 0xe0,
R32Sint = 0xe3,
R32Uint = 0xe4,
R32Float = 0xe5,
B8G8R8X8Unorm = 0xe6,
B8G8R8X8Srgb = 0xe7,
B5G6R5Unorm = 0xe8,
B5G5R5A1Unorm = 0xe9,
R8G8Unorm = 0xea,
R8G8Snorm = 0xeb,
R8G8Sint = 0xec,
R8G8Uint = 0xed,
R16Unorm = 0xee,
R16Snorm = 0xef,
R16Sint = 0xf0,
R16Uint = 0xf1,
R16Float = 0xf2,
R8Unorm = 0xf3,
R8Snorm = 0xf4,
R8Sint = 0xf5,
R8Uint = 0xf6,
B5G5R5X1Unorm = 0xf8,
R8G8B8X8Unorm = 0xf9,
R8G8B8X8Srgb = 0xfa
}
static class RtFormatConverter
{
public static FormatInfo Convert(this RtFormat format)
{
switch (format)
{
case RtFormat.D32Float: return new FormatInfo(Format.D32Float, 1, 1, 4);
case RtFormat.D16Unorm: return new FormatInfo(Format.D16Unorm, 1, 1, 2);
case RtFormat.D24UnormS8Uint: return new FormatInfo(Format.D24UnormS8Uint, 1, 1, 4);
case RtFormat.S8Uint: return new FormatInfo(Format.S8Uint, 1, 1, 1);
case RtFormat.D32FloatS8Uint: return new FormatInfo(Format.D32FloatS8Uint, 1, 1, 8);
case RtFormat.R32G32B32A32Float: return new FormatInfo(Format.R32G32B32A32Float, 1, 1, 16);
case RtFormat.R32G32B32A32Sint: return new FormatInfo(Format.R32G32B32A32Sint, 1, 1, 16);
case RtFormat.R32G32B32A32Uint: return new FormatInfo(Format.R32G32B32A32Uint, 1, 1, 16);
case RtFormat.R32G32B32X32Float: return new FormatInfo(Format.R32G32B32A32Float, 1, 1, 16);
case RtFormat.R32G32B32X32Sint: return new FormatInfo(Format.R32G32B32A32Sint, 1, 1, 16);
case RtFormat.R32G32B32X32Uint: return new FormatInfo(Format.R32G32B32A32Uint, 1, 1, 16);
case RtFormat.R16G16B16X16Unorm: return new FormatInfo(Format.R16G16B16A16Unorm, 1, 1, 8);
case RtFormat.R16G16B16X16Snorm: return new FormatInfo(Format.R16G16B16A16Snorm, 1, 1, 8);
case RtFormat.R16G16B16X16Sint: return new FormatInfo(Format.R16G16B16A16Sint, 1, 1, 8);
case RtFormat.R16G16B16X16Uint: return new FormatInfo(Format.R16G16B16A16Uint, 1, 1, 8);
case RtFormat.R16G16B16A16Float: return new FormatInfo(Format.R16G16B16A16Float, 1, 1, 8);
case RtFormat.R32G32Float: return new FormatInfo(Format.R32G32Float, 1, 1, 8);
case RtFormat.R32G32Sint: return new FormatInfo(Format.R32G32Sint, 1, 1, 8);
case RtFormat.R32G32Uint: return new FormatInfo(Format.R32G32Uint, 1, 1, 8);
case RtFormat.R16G16B16X16Float: return new FormatInfo(Format.R16G16B16A16Float, 1, 1, 8);
case RtFormat.B8G8R8A8Unorm: return new FormatInfo(Format.B8G8R8A8Unorm, 1, 1, 4);
case RtFormat.B8G8R8A8Srgb: return new FormatInfo(Format.B8G8R8A8Srgb, 1, 1, 4);
case RtFormat.R10G10B10A2Unorm: return new FormatInfo(Format.R10G10B10A2Unorm, 1, 1, 4);
case RtFormat.R10G10B10A2Uint: return new FormatInfo(Format.R10G10B10A2Uint, 1, 1, 4);
case RtFormat.R8G8B8A8Unorm: return new FormatInfo(Format.R8G8B8A8Unorm, 1, 1, 4);
case RtFormat.R8G8B8A8Srgb: return new FormatInfo(Format.R8G8B8A8Srgb, 1, 1, 4);
case RtFormat.R8G8B8X8Snorm: return new FormatInfo(Format.R8G8B8A8Snorm, 1, 1, 4);
case RtFormat.R8G8B8X8Sint: return new FormatInfo(Format.R8G8B8A8Sint, 1, 1, 4);
case RtFormat.R8G8B8X8Uint: return new FormatInfo(Format.R8G8B8A8Uint, 1, 1, 4);
case RtFormat.R16G16Unorm: return new FormatInfo(Format.R16G16Unorm, 1, 1, 4);
case RtFormat.R16G16Snorm: return new FormatInfo(Format.R16G16Snorm, 1, 1, 4);
case RtFormat.R16G16Sint: return new FormatInfo(Format.R16G16Sint, 1, 1, 4);
case RtFormat.R16G16Uint: return new FormatInfo(Format.R16G16Uint, 1, 1, 4);
case RtFormat.R16G16Float: return new FormatInfo(Format.R16G16Float, 1, 1, 4);
case RtFormat.R11G11B10Float: return new FormatInfo(Format.R11G11B10Float, 1, 1, 4);
case RtFormat.R32Sint: return new FormatInfo(Format.R32Sint, 1, 1, 4);
case RtFormat.R32Uint: return new FormatInfo(Format.R32Uint, 1, 1, 4);
case RtFormat.R32Float: return new FormatInfo(Format.R32Float, 1, 1, 4);
case RtFormat.B8G8R8X8Unorm: return new FormatInfo(Format.B8G8R8A8Unorm, 1, 1, 4);
case RtFormat.B8G8R8X8Srgb: return new FormatInfo(Format.B8G8R8A8Srgb, 1, 1, 4);
case RtFormat.B5G6R5Unorm: return new FormatInfo(Format.B5G6R5Unorm, 1, 1, 2);
case RtFormat.B5G5R5A1Unorm: return new FormatInfo(Format.B5G5R5A1Unorm, 1, 1, 2);
case RtFormat.R8G8Unorm: return new FormatInfo(Format.R8G8Unorm, 1, 1, 2);
case RtFormat.R8G8Snorm: return new FormatInfo(Format.R8G8Snorm, 1, 1, 2);
case RtFormat.R8G8Sint: return new FormatInfo(Format.R8G8Sint, 1, 1, 2);
case RtFormat.R8G8Uint: return new FormatInfo(Format.R8G8Uint, 1, 1, 2);
case RtFormat.R16Unorm: return new FormatInfo(Format.R16Unorm, 1, 1, 2);
case RtFormat.R16Snorm: return new FormatInfo(Format.R16Snorm, 1, 1, 2);
case RtFormat.R16Sint: return new FormatInfo(Format.R16Sint, 1, 1, 2);
case RtFormat.R16Uint: return new FormatInfo(Format.R16Uint, 1, 1, 2);
case RtFormat.R16Float: return new FormatInfo(Format.R16Float, 1, 1, 2);
case RtFormat.R8Unorm: return new FormatInfo(Format.R8Unorm, 1, 1, 1);
case RtFormat.R8Snorm: return new FormatInfo(Format.R8Snorm, 1, 1, 1);
case RtFormat.R8Sint: return new FormatInfo(Format.R8Sint, 1, 1, 1);
case RtFormat.R8Uint: return new FormatInfo(Format.R8Uint, 1, 1, 1);
case RtFormat.B5G5R5X1Unorm: return new FormatInfo(Format.B5G5R5X1Unorm, 1, 1, 2);
case RtFormat.R8G8B8X8Unorm: return new FormatInfo(Format.R8G8B8A8Unorm, 1, 1, 4);
case RtFormat.R8G8B8X8Srgb: return new FormatInfo(Format.R8G8B8A8Srgb, 1, 1, 4);
}
return FormatInfo.Default;
}
}
}

19
Ryujinx.Graphics.Gpu/State/ShaderState.cs Normal file
View file

@ -0,0 +1,19 @@
namespace Ryujinx.Graphics.Gpu.State
{
struct ShaderState
{
public uint Control;
public uint Offset;
public uint Unknown0x8;
public int MaxRegisters;
public ShaderType Type;
public uint Unknown0x14;
public uint Unknown0x18;
public uint Unknown0x1c;
public bool UnpackEnable()
{
return (Control & 1) != 0;
}
}
}

11
Ryujinx.Graphics.Gpu/State/ShaderType.cs Normal file
View file

@ -0,0 +1,11 @@
namespace Ryujinx.Graphics.Gpu.State
{
enum ShaderType
{
Vertex,
TessellationControl,
TessellationEvaluation,
Geometry,
Fragment
}
}

9
Ryujinx.Graphics.Gpu/State/Size3D.cs Normal file
View file

@ -0,0 +1,9 @@
namespace Ryujinx.Graphics.Gpu.State
{
struct Size3D
{
public int Width;
public int Height;
public int Depth;
}
}

34
Ryujinx.Graphics.Gpu/State/StateWriteFlags.cs Normal file
View file

@ -0,0 +1,34 @@
namespace Ryujinx.Graphics.Gpu.State
{
enum StateWriteFlags
{
InputAssemblerGroup =
VertexAttribState |
PrimitiveRestartState |
IndexBufferState |
VertexBufferState,
RenderTargetGroup =
RtColorState |
RtDepthStencilState,
RtColorState = 1 << 0,
ViewportTransform = 1 << 1,
DepthBiasState = 1 << 2,
RtDepthStencilState = 1 << 3,
DepthTestState = 1 << 4,
VertexAttribState = 1 << 5,
StencilTestState = 1 << 6,
SamplerPoolState = 1 << 7,
TexturePoolState = 1 << 8,
PrimitiveRestartState = 1 << 9,
IndexBufferState = 1 << 10,
FaceState = 1 << 11,
RtColorMask = 1 << 12,
VertexBufferState = 1 << 13,
BlendState = 1 << 14,
ShaderState = 1 << 15,
Any = -1
}
}

9
Ryujinx.Graphics.Gpu/State/StencilBackMasks.cs Normal file
View file

@ -0,0 +1,9 @@
namespace Ryujinx.Graphics.Gpu.State
{
struct StencilBackMasks
{
public int FuncRef;
public int Mask;
public int FuncMask;
}
}

14
Ryujinx.Graphics.Gpu/State/StencilBackTestState.cs Normal file
View file

@ -0,0 +1,14 @@
using Ryujinx.Graphics.GAL;
using Ryujinx.Graphics.GAL.DepthStencil;
namespace Ryujinx.Graphics.Gpu.State
{
struct StencilBackTestState
{
public Bool TwoSided;
public StencilOp BackSFail;
public StencilOp BackDpFail;
public StencilOp BackDpPass;
public CompareOp BackFunc;
}
}

17
Ryujinx.Graphics.Gpu/State/StencilTestState.cs Normal file
View file

@ -0,0 +1,17 @@
using Ryujinx.Graphics.GAL;
using Ryujinx.Graphics.GAL.DepthStencil;
namespace Ryujinx.Graphics.Gpu.State
{
struct StencilTestState
{
public Bool Enable;
public StencilOp FrontSFail;
public StencilOp FrontDpFail;
public StencilOp FrontDpPass;
public CompareOp FrontFunc;
public int FrontFuncRef;
public int FrontFuncMask;
public int FrontMask;
}
}

9
Ryujinx.Graphics.Gpu/State/UniformBufferState.cs Normal file
View file

@ -0,0 +1,9 @@
namespace Ryujinx.Graphics.Gpu.State
{
struct UniformBufferState
{
public int Size;
public GpuVa Address;
public int Offset;
}
}

22
Ryujinx.Graphics.Gpu/State/VertexAttribState.cs Normal file
View file

@ -0,0 +1,22 @@
namespace Ryujinx.Graphics.Gpu.State
{
struct VertexAttribState
{
public uint Attribute;
public int UnpackBufferIndex()
{
return (int)(Attribute & 0x1f);
}
public int UnpackOffset()
{
return (int)((Attribute >> 7) & 0x3fff);
}
public uint UnpackFormat()
{
return Attribute & 0x3fe00000;
}
}
}

8
Ryujinx.Graphics.Gpu/State/VertexBufferDrawState.cs Normal file
View file

@ -0,0 +1,8 @@
namespace Ryujinx.Graphics.Gpu.State
{
struct VertexBufferDrawState
{
public int First;
public int Count;
}
}

19
Ryujinx.Graphics.Gpu/State/VertexBufferState.cs Normal file
View file

@ -0,0 +1,19 @@
namespace Ryujinx.Graphics.Gpu.State
{
struct VertexBufferState
{
public uint Control;
public GpuVa Address;
public int Divisor;
public int UnpackStride()
{
return (int)(Control & 0xfff);
}
public bool UnpackEnable()
{
return (Control & (1 << 12)) != 0;
}
}
}

12
Ryujinx.Graphics.Gpu/State/ViewportExtents.cs Normal file
View file

@ -0,0 +1,12 @@
namespace Ryujinx.Graphics.Gpu.State
{
struct ViewportExtents
{
public ushort X;
public ushort Width;
public ushort Y;
public ushort Height;
public float DepthNear;
public float DepthFar;
}
}

36
Ryujinx.Graphics.Gpu/State/ViewportTransform.cs Normal file
View file

@ -0,0 +1,36 @@
using Ryujinx.Graphics.GAL;
namespace Ryujinx.Graphics.Gpu.State
{
struct ViewportTransform
{
public float ScaleX;
public float ScaleY;
public float ScaleZ;
public float TranslateX;
public float TranslateY;
public float TranslateZ;
public uint Swizzle;
public uint SubpixelPrecisionBias;
public ViewportSwizzle UnpackSwizzleX()
{
return (ViewportSwizzle)(Swizzle & 7);
}
public ViewportSwizzle UnpackSwizzleY()
{
return (ViewportSwizzle)((Swizzle >> 4) & 7);
}
public ViewportSwizzle UnpackSwizzleZ()
{
return (ViewportSwizzle)((Swizzle >> 8) & 7);
}
public ViewportSwizzle UnpackSwizzleW()
{
return (ViewportSwizzle)((Swizzle >> 12) & 7);
}
}
}