Ryujinx/Ryujinx.Graphics.Gpu/Engine/Methods.cs

1143 lines
44 KiB
C#
Raw Normal View History

2019-12-29 18:41:50 +01:00
using Ryujinx.Common.Logging;
2019-10-13 08:02:07 +02:00
using Ryujinx.Graphics.GAL;
using Ryujinx.Graphics.Gpu.Image;
using Ryujinx.Graphics.Gpu.Memory;
using Ryujinx.Graphics.Gpu.Shader;
2019-10-13 08:02:07 +02:00
using Ryujinx.Graphics.Gpu.State;
using Ryujinx.Graphics.Shader;
using Ryujinx.Graphics.Texture;
2019-10-13 08:02:07 +02:00
using System;
using System.Linq;
2019-10-13 08:02:07 +02:00
using System.Runtime.InteropServices;
namespace Ryujinx.Graphics.Gpu.Engine
{
2019-12-29 18:41:50 +01:00
using Texture = Image.Texture;
/// <summary>
/// GPU method implementations.
/// </summary>
2019-10-13 08:02:07 +02:00
partial class Methods
{
2019-12-29 18:41:50 +01:00
private readonly GpuContext _context;
private readonly ShaderProgramInfo[] _currentProgramInfo;
2019-10-13 08:02:07 +02:00
2019-12-31 23:09:49 +01:00
/// <summary>
/// In-memory shader cache.
/// </summary>
public ShaderCache ShaderCache { get; }
/// <summary>
/// GPU buffer manager.
/// </summary>
public BufferManager BufferManager { get; }
/// <summary>
/// GPU texture manager.
/// </summary>
2019-12-29 18:41:50 +01:00
public TextureManager TextureManager { get; }
2019-10-13 08:02:07 +02:00
private bool _isAnyVbInstanced;
private bool _vsUsesInstanceId;
private bool _forceShaderUpdate;
private bool _prevTfEnable;
/// <summary>
/// Creates a new instance of the GPU methods class.
/// </summary>
/// <param name="context">GPU context</param>
2019-10-13 08:02:07 +02:00
public Methods(GpuContext context)
{
_context = context;
2019-12-31 23:09:49 +01:00
ShaderCache = new ShaderCache(_context);
2019-10-13 08:02:07 +02:00
2020-01-01 16:39:09 +01:00
_currentProgramInfo = new ShaderProgramInfo[Constants.ShaderStages];
2019-12-29 18:41:50 +01:00
BufferManager = new BufferManager(context);
TextureManager = new TextureManager(context);
context.MemoryManager.MemoryUnmapped += _counterCache.MemoryUnmappedHandler;
context.MemoryManager.MemoryUnmapped += TextureManager.MemoryUnmappedHandler;
2019-10-13 08:02:07 +02:00
}
/// <summary>
/// Register callback for GPU method calls that triggers an action on the GPU.
/// </summary>
/// <param name="state">GPU state where the triggers will be registered</param>
2019-11-22 03:46:14 +01:00
public void RegisterCallbacks(GpuState state)
2019-10-13 08:02:07 +02:00
{
2019-11-22 03:46:14 +01:00
state.RegisterCallback(MethodOffset.LaunchDma, LaunchDma);
state.RegisterCallback(MethodOffset.LoadInlineData, LoadInlineData);
2019-10-13 08:02:07 +02:00
2019-11-22 03:46:14 +01:00
state.RegisterCallback(MethodOffset.Dispatch, Dispatch);
2019-10-13 08:02:07 +02:00
state.RegisterCallback(MethodOffset.SyncpointAction, IncrementSyncpoint);
2019-11-22 03:46:14 +01:00
state.RegisterCallback(MethodOffset.CopyBuffer, CopyBuffer);
state.RegisterCallback(MethodOffset.CopyTexture, CopyTexture);
2019-10-13 08:02:07 +02:00
2019-11-22 03:46:14 +01:00
state.RegisterCallback(MethodOffset.TextureBarrier, TextureBarrier);
state.RegisterCallback(MethodOffset.TextureBarrierTiled, TextureBarrierTiled);
state.RegisterCallback(MethodOffset.VbElementU8, VbElementU8);
state.RegisterCallback(MethodOffset.VbElementU16, VbElementU16);
state.RegisterCallback(MethodOffset.VbElementU32, VbElementU32);
2019-11-22 03:46:14 +01:00
state.RegisterCallback(MethodOffset.ResetCounter, ResetCounter);
2019-10-13 08:02:07 +02:00
state.RegisterCallback(MethodOffset.DrawEnd, DrawEnd);
state.RegisterCallback(MethodOffset.DrawBegin, DrawBegin);
state.RegisterCallback(MethodOffset.DrawIndexedSmall, DrawIndexedSmall);
state.RegisterCallback(MethodOffset.DrawIndexedSmall2, DrawIndexedSmall2);
state.RegisterCallback(MethodOffset.DrawIndexedSmallIncInstance, DrawIndexedSmallIncInstance);
state.RegisterCallback(MethodOffset.DrawIndexedSmallIncInstance2, DrawIndexedSmallIncInstance2);
2019-10-13 08:02:07 +02:00
2019-11-22 03:46:14 +01:00
state.RegisterCallback(MethodOffset.IndexBufferCount, SetIndexBufferCount);
2019-11-22 03:46:14 +01:00
state.RegisterCallback(MethodOffset.Clear, Clear);
2019-11-22 03:46:14 +01:00
state.RegisterCallback(MethodOffset.Report, Report);
state.RegisterCallback(MethodOffset.FirmwareCall4, FirmwareCall4);
2019-11-22 03:46:14 +01:00
state.RegisterCallback(MethodOffset.UniformBufferUpdateData, 16, UniformBufferUpdate);
2019-11-22 03:46:14 +01:00
state.RegisterCallback(MethodOffset.UniformBufferBindVertex, UniformBufferBindVertex);
state.RegisterCallback(MethodOffset.UniformBufferBindTessControl, UniformBufferBindTessControl);
state.RegisterCallback(MethodOffset.UniformBufferBindTessEvaluation, UniformBufferBindTessEvaluation);
state.RegisterCallback(MethodOffset.UniformBufferBindGeometry, UniformBufferBindGeometry);
state.RegisterCallback(MethodOffset.UniformBufferBindFragment, UniformBufferBindFragment);
2019-10-13 08:02:07 +02:00
}
/// <summary>
/// Updates host state based on the current guest GPU state.
/// </summary>
/// <param name="state">Guest GPU state</param>
/// <param name="firstIndex">Index of the first index buffer element used on the draw</param>
/// <param name="indexCount">Number of index buffer elements used on the draw</param>
private void UpdateState(GpuState state, int firstIndex, int indexCount)
2019-10-13 08:02:07 +02:00
{
bool tfEnable = state.Get<Boolean32>(MethodOffset.TfEnable);
if (!tfEnable && _prevTfEnable)
{
_context.Renderer.Pipeline.EndTransformFeedback();
_prevTfEnable = false;
}
2019-10-13 08:02:07 +02:00
// Shaders must be the first one to be updated if modified, because
// some of the other state depends on information from the currently
// bound shaders.
if (state.QueryModified(MethodOffset.ShaderBaseAddress, MethodOffset.ShaderState) || _forceShaderUpdate)
2019-10-13 08:02:07 +02:00
{
_forceShaderUpdate = false;
2019-11-22 03:46:14 +01:00
UpdateShaderState(state);
2019-10-13 08:02:07 +02:00
}
if (state.QueryModified(MethodOffset.TfBufferState))
{
UpdateTfBufferState(state);
}
if (state.QueryModified(MethodOffset.ClipDistanceEnable))
{
UpdateUserClipState(state);
}
if (state.QueryModified(MethodOffset.RasterizeEnable))
{
UpdateRasterizerState(state);
}
if (state.QueryModified(MethodOffset.RtColorState,
MethodOffset.RtDepthStencilState,
MethodOffset.RtControl,
MethodOffset.RtDepthStencilSize,
MethodOffset.RtDepthStencilEnable))
{
UpdateRenderTargetState(state, useControl: true);
}
2019-10-13 08:02:07 +02:00
if (state.QueryModified(MethodOffset.ScissorState))
{
UpdateScissorState(state);
}
if (state.QueryModified(MethodOffset.ViewVolumeClipControl))
{
UpdateDepthClampState(state);
}
if (state.QueryModified(MethodOffset.AlphaTestEnable,
MethodOffset.AlphaTestRef,
MethodOffset.AlphaTestFunc))
{
UpdateAlphaTestState(state);
}
2019-11-22 03:46:14 +01:00
if (state.QueryModified(MethodOffset.DepthTestEnable,
MethodOffset.DepthWriteEnable,
MethodOffset.DepthTestFunc))
2019-10-13 08:02:07 +02:00
{
2019-11-22 03:46:14 +01:00
UpdateDepthTestState(state);
2019-10-13 08:02:07 +02:00
}
if (state.QueryModified(MethodOffset.DepthMode,
MethodOffset.ViewportTransform,
MethodOffset.ViewportExtents))
2019-10-13 08:02:07 +02:00
{
2019-11-22 03:46:14 +01:00
UpdateViewportTransform(state);
2019-10-13 08:02:07 +02:00
}
2019-11-22 03:46:14 +01:00
if (state.QueryModified(MethodOffset.DepthBiasState,
MethodOffset.DepthBiasFactor,
MethodOffset.DepthBiasUnits,
MethodOffset.DepthBiasClamp))
2019-10-13 08:02:07 +02:00
{
2019-11-22 03:46:14 +01:00
UpdateDepthBiasState(state);
2019-10-13 08:02:07 +02:00
}
2019-11-22 03:46:14 +01:00
if (state.QueryModified(MethodOffset.StencilBackMasks,
MethodOffset.StencilTestState,
MethodOffset.StencilBackTestState))
2019-10-13 08:02:07 +02:00
{
2019-11-22 03:46:14 +01:00
UpdateStencilTestState(state);
2019-10-13 08:02:07 +02:00
}
// Pools.
if (state.QueryModified(MethodOffset.SamplerPoolState, MethodOffset.SamplerIndex))
2019-10-13 08:02:07 +02:00
{
2019-11-22 03:46:14 +01:00
UpdateSamplerPoolState(state);
2019-10-13 08:02:07 +02:00
}
2019-11-22 03:46:14 +01:00
if (state.QueryModified(MethodOffset.TexturePoolState))
2019-10-13 08:02:07 +02:00
{
2019-11-22 03:46:14 +01:00
UpdateTexturePoolState(state);
2019-10-13 08:02:07 +02:00
}
// Input assembler state.
2019-11-22 03:46:14 +01:00
if (state.QueryModified(MethodOffset.VertexAttribState))
2019-10-13 08:02:07 +02:00
{
2019-11-22 03:46:14 +01:00
UpdateVertexAttribState(state);
}
if (state.QueryModified(MethodOffset.PointSize,
MethodOffset.VertexProgramPointSize,
MethodOffset.PointSpriteEnable,
MethodOffset.PointCoordReplace))
2020-02-02 00:19:46 +01:00
{
UpdatePointState(state);
2020-02-02 00:19:46 +01:00
}
2019-11-22 03:46:14 +01:00
if (state.QueryModified(MethodOffset.PrimitiveRestartState))
{
2019-11-22 03:46:14 +01:00
UpdatePrimitiveRestartState(state);
}
2019-11-22 03:46:14 +01:00
if (state.QueryModified(MethodOffset.IndexBufferState))
{
UpdateIndexBufferState(state, firstIndex, indexCount);
}
2019-11-22 03:46:14 +01:00
if (state.QueryModified(MethodOffset.VertexBufferDrawState,
MethodOffset.VertexBufferInstanced,
MethodOffset.VertexBufferState,
MethodOffset.VertexBufferEndAddress))
{
2019-11-22 03:46:14 +01:00
UpdateVertexBufferState(state);
2019-10-13 08:02:07 +02:00
}
2019-11-22 03:46:14 +01:00
if (state.QueryModified(MethodOffset.FaceState))
2019-10-13 08:02:07 +02:00
{
2019-11-22 03:46:14 +01:00
UpdateFaceState(state);
2019-10-13 08:02:07 +02:00
}
if (state.QueryModified(MethodOffset.RtColorMaskShared, MethodOffset.RtColorMask))
2019-10-13 08:02:07 +02:00
{
2019-11-22 03:46:14 +01:00
UpdateRtColorMask(state);
2019-10-13 08:02:07 +02:00
}
if (state.QueryModified(MethodOffset.BlendIndependent,
MethodOffset.BlendConstant,
MethodOffset.BlendStateCommon,
MethodOffset.BlendEnableCommon,
MethodOffset.BlendEnable,
MethodOffset.BlendState))
2019-10-13 08:02:07 +02:00
{
2019-11-22 03:46:14 +01:00
UpdateBlendState(state);
2019-10-13 08:02:07 +02:00
}
if (state.QueryModified(MethodOffset.LogicOpState))
{
UpdateLogicOpState(state);
}
2019-10-13 08:02:07 +02:00
CommitBindings();
if (tfEnable && !_prevTfEnable)
{
_context.Renderer.Pipeline.BeginTransformFeedback(Topology);
_prevTfEnable = true;
}
2019-10-13 08:02:07 +02:00
}
/// <summary>
/// Updates Rasterizer primitive discard state based on guest gpu state.
/// </summary>
/// <param name="state">Current GPU state</param>
private void UpdateRasterizerState(GpuState state)
{
Boolean32 enable = state.Get<Boolean32>(MethodOffset.RasterizeEnable);
_context.Renderer.Pipeline.SetRasterizerDiscard(!enable);
}
/// <summary>
/// Ensures that the bindings are visible to the host GPU.
2020-01-01 16:39:09 +01:00
/// Note: this actually performs the binding using the host graphics API.
/// </summary>
2019-10-13 08:02:07 +02:00
private void CommitBindings()
{
UpdateStorageBuffers();
BufferManager.CommitGraphicsBindings();
2019-12-29 18:41:50 +01:00
TextureManager.CommitGraphicsBindings();
2019-10-13 08:02:07 +02:00
}
/// <summary>
/// Updates storage buffer bindings.
/// </summary>
private void UpdateStorageBuffers()
{
for (int stage = 0; stage < _currentProgramInfo.Length; stage++)
{
ShaderProgramInfo info = _currentProgramInfo[stage];
if (info == null)
{
continue;
}
for (int index = 0; index < info.SBuffers.Count; index++)
{
BufferDescriptor sb = info.SBuffers[index];
2019-12-29 18:41:50 +01:00
ulong sbDescAddress = BufferManager.GetGraphicsUniformBufferAddress(stage, 0);
int sbDescOffset = 0x110 + stage * 0x100 + sb.Slot * 0x10;
sbDescAddress += (ulong)sbDescOffset;
SbDescriptor sbDescriptor = _context.PhysicalMemory.Read<SbDescriptor>(sbDescAddress);
2019-12-29 18:41:50 +01:00
BufferManager.SetGraphicsStorageBuffer(stage, sb.Slot, sbDescriptor.PackAddress(), (uint)sbDescriptor.Size);
}
}
}
/// <summary>
/// Updates render targets (color and depth-stencil buffers) based on current render target state.
/// </summary>
/// <param name="state">Current GPU state</param>
/// <param name="useControl">Use draw buffers information from render target control register</param>
/// <param name="singleUse">If this is not -1, it indicates that only the given indexed target will be used.</param>
private void UpdateRenderTargetState(GpuState state, bool useControl, int singleUse = -1)
{
var rtControl = state.Get<RtControl>(MethodOffset.RtControl);
int count = useControl ? rtControl.UnpackCount() : Constants.TotalRenderTargets;
2019-11-22 03:46:14 +01:00
var msaaMode = state.Get<TextureMsaaMode>(MethodOffset.RtMsaaMode);
2019-10-13 08:02:07 +02:00
int samplesInX = msaaMode.SamplesInX();
int samplesInY = msaaMode.SamplesInY();
var scissor = state.Get<ScreenScissorState>(MethodOffset.ScreenScissorState);
Size sizeHint = new Size(scissor.X + scissor.Width, scissor.Y + scissor.Height, 1);
bool changedScale = false;
for (int index = 0; index < Constants.TotalRenderTargets; index++)
2019-10-13 08:02:07 +02:00
{
int rtIndex = useControl ? rtControl.UnpackPermutationIndex(index) : index;
2019-10-13 08:02:07 +02:00
var colorState = state.Get<RtColorState>(MethodOffset.RtColorState, rtIndex);
if (index >= count || !IsRtEnabled(colorState))
{
changedScale |= TextureManager.SetRenderTargetColor(index, null);
2019-10-13 08:02:07 +02:00
continue;
}
2019-10-13 08:02:07 +02:00
Texture color = TextureManager.FindOrCreateTexture(colorState, samplesInX, samplesInY, sizeHint);
2019-10-13 08:02:07 +02:00
changedScale |= TextureManager.SetRenderTargetColor(index, color);
2019-10-13 08:02:07 +02:00
if (color != null)
{
color.SignalModified();
2019-10-13 08:02:07 +02:00
}
}
2019-11-22 03:46:14 +01:00
bool dsEnable = state.Get<Boolean32>(MethodOffset.RtDepthStencilEnable);
2019-10-13 08:02:07 +02:00
2019-12-29 18:41:50 +01:00
Texture depthStencil = null;
2019-10-13 08:02:07 +02:00
if (dsEnable)
{
2019-11-22 03:46:14 +01:00
var dsState = state.Get<RtDepthStencilState>(MethodOffset.RtDepthStencilState);
var dsSize = state.Get<Size3D>(MethodOffset.RtDepthStencilSize);
2019-10-13 08:02:07 +02:00
depthStencil = TextureManager.FindOrCreateTexture(dsState, dsSize, samplesInX, samplesInY, sizeHint);
2019-10-13 08:02:07 +02:00
}
changedScale |= TextureManager.SetRenderTargetDepthStencil(depthStencil);
if (changedScale)
{
TextureManager.UpdateRenderTargetScale(singleUse);
_context.Renderer.Pipeline.SetRenderTargetScale(TextureManager.RenderTargetScale);
UpdateViewportTransform(state);
UpdateScissorState(state);
}
if (depthStencil != null)
{
depthStencil.SignalModified();
}
2019-10-13 08:02:07 +02:00
}
/// <summary>
/// Checks if a render target color buffer is used.
/// </summary>
/// <param name="colorState">Color buffer information</param>
/// <returns>True if the specified buffer is enabled/used, false otherwise</returns>
2019-10-13 08:02:07 +02:00
private static bool IsRtEnabled(RtColorState colorState)
{
// Colors are disabled by writing 0 to the format.
return colorState.Format != 0 && colorState.WidthOrStride != 0;
}
/// <summary>
/// Updates host scissor test state based on current GPU state.
/// </summary>
/// <param name="state">Current GPU state</param>
private void UpdateScissorState(GpuState state)
{
for (int index = 0; index < Constants.TotalViewports; index++)
{
ScissorState scissor = state.Get<ScissorState>(MethodOffset.ScissorState, index);
bool enable = scissor.Enable && (scissor.X1 != 0 || scissor.Y1 != 0 || scissor.X2 != 0xffff || scissor.Y2 != 0xffff);
_context.Renderer.Pipeline.SetScissorEnable(index, enable);
if (enable)
{
int x = scissor.X1;
int y = scissor.Y1;
int width = scissor.X2 - x;
int height = scissor.Y2 - y;
float scale = TextureManager.RenderTargetScale;
if (scale != 1f)
{
x = (int)(x * scale);
y = (int)(y * scale);
width = (int)Math.Ceiling(width * scale);
height = (int)Math.Ceiling(height * scale);
}
_context.Renderer.Pipeline.SetScissor(index, x, y, width, height);
}
}
}
/// <summary>
/// Updates host depth clamp state based on current GPU state.
/// </summary>
/// <param name="state">Current GPU state</param>
private void UpdateDepthClampState(GpuState state)
{
ViewVolumeClipControl clip = state.Get<ViewVolumeClipControl>(MethodOffset.ViewVolumeClipControl);
_context.Renderer.Pipeline.SetDepthClamp((clip & ViewVolumeClipControl.DepthClampDisabled) == 0);
}
/// <summary>
/// Updates host alpha test state based on current GPU state.
/// </summary>
/// <param name="state">Current GPU state</param>
private void UpdateAlphaTestState(GpuState state)
{
_context.Renderer.Pipeline.SetAlphaTest(
state.Get<Boolean32>(MethodOffset.AlphaTestEnable),
state.Get<float>(MethodOffset.AlphaTestRef),
state.Get<CompareOp>(MethodOffset.AlphaTestFunc));
}
/// <summary>
/// Updates host depth test state based on current GPU state.
/// </summary>
/// <param name="state">Current GPU state</param>
2019-11-22 03:46:14 +01:00
private void UpdateDepthTestState(GpuState state)
2019-10-13 08:02:07 +02:00
{
_context.Renderer.Pipeline.SetDepthTest(new DepthTestDescriptor(
2019-11-22 03:46:14 +01:00
state.Get<Boolean32>(MethodOffset.DepthTestEnable),
state.Get<Boolean32>(MethodOffset.DepthWriteEnable),
state.Get<CompareOp>(MethodOffset.DepthTestFunc)));
2019-10-13 08:02:07 +02:00
}
/// <summary>
/// Updates host viewport transform and clipping state based on current GPU state.
/// </summary>
/// <param name="state">Current GPU state</param>
2019-11-22 03:46:14 +01:00
private void UpdateViewportTransform(GpuState state)
2019-10-13 08:02:07 +02:00
{
var yControl = state.Get<YControl> (MethodOffset.YControl);
var face = state.Get<FaceState>(MethodOffset.FaceState);
UpdateFrontFace(yControl, face.FrontFace);
bool flipY = yControl.HasFlag(YControl.NegateY);
Span<Viewport> viewports = stackalloc Viewport[Constants.TotalViewports];
2019-10-13 08:02:07 +02:00
for (int index = 0; index < Constants.TotalViewports; index++)
{
2019-11-22 03:46:14 +01:00
var transform = state.Get<ViewportTransform>(MethodOffset.ViewportTransform, index);
var extents = state.Get<ViewportExtents> (MethodOffset.ViewportExtents, index);
2019-10-13 08:02:07 +02:00
float scaleX = MathF.Abs(transform.ScaleX);
float scaleY = transform.ScaleY;
2019-10-13 08:02:07 +02:00
if (flipY)
{
scaleY = -scaleY;
}
if (!_context.Capabilities.SupportsViewportSwizzle && transform.UnpackSwizzleY() == ViewportSwizzle.NegativeY)
{
scaleY = -scaleY;
}
if (index == 0)
{
// Try to guess the depth mode being used on the high level API
// based on current transform.
// It is setup like so by said APIs:
// If depth mode is ZeroToOne:
// TranslateZ = Near
// ScaleZ = Far - Near
// If depth mode is MinusOneToOne:
// TranslateZ = (Near + Far) / 2
// ScaleZ = (Far - Near) / 2
// DepthNear/Far are sorted such as that Near is always less than Far.
DepthMode depthMode = extents.DepthNear != transform.TranslateZ &&
extents.DepthFar != transform.TranslateZ ? DepthMode.MinusOneToOne : DepthMode.ZeroToOne;
_context.Renderer.Pipeline.SetDepthMode(depthMode);
}
float x = transform.TranslateX - scaleX;
float y = transform.TranslateY - scaleY;
float width = scaleX * 2;
float height = scaleY * 2;
float scale = TextureManager.RenderTargetScale;
if (scale != 1f)
{
x *= scale;
y *= scale;
width *= scale;
height *= scale;
}
2019-12-31 23:22:45 +01:00
RectangleF region = new RectangleF(x, y, width, height);
2019-10-13 08:02:07 +02:00
ViewportSwizzle swizzleX = transform.UnpackSwizzleX();
ViewportSwizzle swizzleY = transform.UnpackSwizzleY();
ViewportSwizzle swizzleZ = transform.UnpackSwizzleZ();
ViewportSwizzle swizzleW = transform.UnpackSwizzleW();
float depthNear = extents.DepthNear;
float depthFar = extents.DepthFar;
if (transform.ScaleZ < 0)
{
float temp = depthNear;
depthNear = depthFar;
depthFar = temp;
}
viewports[index] = new Viewport(region, swizzleX, swizzleY, swizzleZ, swizzleW, depthNear, depthFar);
2019-10-13 08:02:07 +02:00
}
_context.Renderer.Pipeline.SetViewports(0, viewports);
2019-10-13 08:02:07 +02:00
}
/// <summary>
/// Updates host depth bias (also called polygon offset) state based on current GPU state.
/// </summary>
/// <param name="state">Current GPU state</param>
2019-11-22 03:46:14 +01:00
private void UpdateDepthBiasState(GpuState state)
2019-10-13 08:02:07 +02:00
{
2019-11-22 03:46:14 +01:00
var depthBias = state.Get<DepthBiasState>(MethodOffset.DepthBiasState);
2019-10-13 08:02:07 +02:00
2019-11-22 03:46:14 +01:00
float factor = state.Get<float>(MethodOffset.DepthBiasFactor);
float units = state.Get<float>(MethodOffset.DepthBiasUnits);
float clamp = state.Get<float>(MethodOffset.DepthBiasClamp);
2019-10-13 08:02:07 +02:00
2019-12-29 18:41:50 +01:00
PolygonModeMask enables;
2019-10-13 08:02:07 +02:00
enables = (depthBias.PointEnable ? PolygonModeMask.Point : 0);
enables |= (depthBias.LineEnable ? PolygonModeMask.Line : 0);
enables |= (depthBias.FillEnable ? PolygonModeMask.Fill : 0);
2019-10-13 08:02:07 +02:00
_context.Renderer.Pipeline.SetDepthBias(enables, factor, units / 2f, clamp);
2019-10-13 08:02:07 +02:00
}
/// <summary>
/// Updates host stencil test state based on current GPU state.
/// </summary>
/// <param name="state">Current GPU state</param>
2019-11-22 03:46:14 +01:00
private void UpdateStencilTestState(GpuState state)
2019-10-13 08:02:07 +02:00
{
var backMasks = state.Get<StencilBackMasks>(MethodOffset.StencilBackMasks);
var test = state.Get<StencilTestState>(MethodOffset.StencilTestState);
2019-11-22 03:46:14 +01:00
var backTest = state.Get<StencilBackTestState>(MethodOffset.StencilBackTestState);
2019-10-13 08:02:07 +02:00
CompareOp backFunc;
StencilOp backSFail;
StencilOp backDpPass;
StencilOp backDpFail;
int backFuncRef;
int backFuncMask;
int backMask;
if (backTest.TwoSided)
2019-10-13 08:02:07 +02:00
{
backFunc = backTest.BackFunc;
backSFail = backTest.BackSFail;
backDpPass = backTest.BackDpPass;
backDpFail = backTest.BackDpFail;
backFuncRef = backMasks.FuncRef;
backFuncMask = backMasks.FuncMask;
backMask = backMasks.Mask;
}
else
{
backFunc = test.FrontFunc;
backSFail = test.FrontSFail;
backDpPass = test.FrontDpPass;
backDpFail = test.FrontDpFail;
backFuncRef = test.FrontFuncRef;
backFuncMask = test.FrontFuncMask;
backMask = test.FrontMask;
}
_context.Renderer.Pipeline.SetStencilTest(new StencilTestDescriptor(
test.Enable,
2019-10-13 08:02:07 +02:00
test.FrontFunc,
test.FrontSFail,
test.FrontDpPass,
test.FrontDpFail,
test.FrontFuncRef,
test.FrontFuncMask,
test.FrontMask,
backFunc,
backSFail,
backDpPass,
backDpFail,
backFuncRef,
backFuncMask,
backMask));
}
/// <summary>
/// Updates current sampler pool address and size based on guest GPU state.
/// </summary>
/// <param name="state">Current GPU state</param>
2019-11-22 03:46:14 +01:00
private void UpdateSamplerPoolState(GpuState state)
2019-10-13 08:02:07 +02:00
{
var texturePool = state.Get<PoolState>(MethodOffset.TexturePoolState);
2019-11-22 03:46:14 +01:00
var samplerPool = state.Get<PoolState>(MethodOffset.SamplerPoolState);
2019-10-13 08:02:07 +02:00
var samplerIndex = state.Get<SamplerIndex>(MethodOffset.SamplerIndex);
int maximumId = samplerIndex == SamplerIndex.ViaHeaderIndex
? texturePool.MaximumId
: samplerPool.MaximumId;
2019-12-29 18:41:50 +01:00
TextureManager.SetGraphicsSamplerPool(samplerPool.Address.Pack(), maximumId, samplerIndex);
2019-10-13 08:02:07 +02:00
}
/// <summary>
/// Updates current texture pool address and size based on guest GPU state.
/// </summary>
/// <param name="state">Current GPU state</param>
2019-11-22 03:46:14 +01:00
private void UpdateTexturePoolState(GpuState state)
2019-10-13 08:02:07 +02:00
{
2019-11-22 03:46:14 +01:00
var texturePool = state.Get<PoolState>(MethodOffset.TexturePoolState);
2019-10-13 08:02:07 +02:00
2019-12-29 18:41:50 +01:00
TextureManager.SetGraphicsTexturePool(texturePool.Address.Pack(), texturePool.MaximumId);
2019-10-13 08:02:07 +02:00
2019-12-29 18:41:50 +01:00
TextureManager.SetGraphicsTextureBufferIndex(state.Get<int>(MethodOffset.TextureBufferIndex));
2019-10-13 08:02:07 +02:00
}
/// <summary>
/// Updates host vertex attributes based on guest GPU state.
/// </summary>
/// <param name="state">Current GPU state</param>
2019-11-22 03:46:14 +01:00
private void UpdateVertexAttribState(GpuState state)
2019-10-13 08:02:07 +02:00
{
Span<VertexAttribDescriptor> vertexAttribs = stackalloc VertexAttribDescriptor[Constants.TotalVertexAttribs];
2019-10-13 08:02:07 +02:00
for (int index = 0; index < Constants.TotalVertexAttribs; index++)
2019-10-13 08:02:07 +02:00
{
2019-11-22 03:46:14 +01:00
var vertexAttrib = state.Get<VertexAttribState>(MethodOffset.VertexAttribState, index);
2019-10-13 08:02:07 +02:00
if (!FormatTable.TryGetAttribFormat(vertexAttrib.UnpackFormat(), out Format format))
{
Logger.Debug?.Print(LogClass.Gpu, $"Invalid attribute format 0x{vertexAttrib.UnpackFormat():X}.");
2019-10-13 08:02:07 +02:00
format = Format.R32G32B32A32Float;
}
vertexAttribs[index] = new VertexAttribDescriptor(
vertexAttrib.UnpackBufferIndex(),
vertexAttrib.UnpackOffset(),
vertexAttrib.UnpackIsConstant(),
2019-10-13 08:02:07 +02:00
format);
}
2019-12-29 18:41:50 +01:00
_context.Renderer.Pipeline.SetVertexAttribs(vertexAttribs);
2019-10-13 08:02:07 +02:00
}
2020-02-02 00:19:46 +01:00
/// <summary>
/// Updates host point size based on guest GPU state.
/// </summary>
/// <param name="state">Current GPU state</param>
private void UpdatePointState(GpuState state)
2020-02-02 00:19:46 +01:00
{
float size = state.Get<float>(MethodOffset.PointSize);
bool isProgramPointSize = state.Get<Boolean32>(MethodOffset.VertexProgramPointSize);
bool enablePointSprite = state.Get<Boolean32>(MethodOffset.PointSpriteEnable);
// TODO: Need to figure out a way to map PointCoordReplace enable bit.
Origin origin = (state.Get<int>(MethodOffset.PointCoordReplace) & 4) == 0 ? Origin.LowerLeft : Origin.UpperLeft;
2020-02-02 00:19:46 +01:00
_context.Renderer.Pipeline.SetPointParameters(size, isProgramPointSize, enablePointSprite, origin);
2020-02-02 00:19:46 +01:00
}
/// <summary>
/// Updates host primitive restart based on guest GPU state.
/// </summary>
/// <param name="state">Current GPU state</param>
2019-11-22 03:46:14 +01:00
private void UpdatePrimitiveRestartState(GpuState state)
2019-10-13 08:02:07 +02:00
{
2019-11-22 03:46:14 +01:00
PrimitiveRestartState primitiveRestart = state.Get<PrimitiveRestartState>(MethodOffset.PrimitiveRestartState);
2019-10-13 08:02:07 +02:00
_context.Renderer.Pipeline.SetPrimitiveRestart(
2019-10-13 08:02:07 +02:00
primitiveRestart.Enable,
primitiveRestart.Index);
}
/// <summary>
/// Updates host index buffer binding based on guest GPU state.
/// </summary>
/// <param name="state">Current GPU state</param>
/// <param name="firstIndex">Index of the first index buffer element used on the draw</param>
/// <param name="indexCount">Number of index buffer elements used on the draw</param>
private void UpdateIndexBufferState(GpuState state, int firstIndex, int indexCount)
2019-10-13 08:02:07 +02:00
{
2019-11-22 03:46:14 +01:00
var indexBuffer = state.Get<IndexBufferState>(MethodOffset.IndexBufferState);
2019-10-13 08:02:07 +02:00
if (indexCount == 0)
2019-10-13 08:02:07 +02:00
{
return;
}
ulong gpuVa = indexBuffer.Address.Pack();
// Do not use the end address to calculate the size, because
// the result may be much larger than the real size of the index buffer.
ulong size = (ulong)(firstIndex + indexCount);
2019-10-13 08:02:07 +02:00
switch (indexBuffer.Type)
{
case IndexType.UShort: size *= 2; break;
case IndexType.UInt: size *= 4; break;
}
2019-12-29 18:41:50 +01:00
BufferManager.SetIndexBuffer(gpuVa, size, indexBuffer.Type);
2019-10-13 08:02:07 +02:00
// The index buffer affects the vertex buffer size calculation, we
// need to ensure that they are updated.
2019-11-22 03:46:14 +01:00
UpdateVertexBufferState(state);
2019-10-13 08:02:07 +02:00
}
/// <summary>
/// Updates host vertex buffer bindings based on guest GPU state.
/// </summary>
/// <param name="state">Current GPU state</param>
2019-11-22 03:46:14 +01:00
private void UpdateVertexBufferState(GpuState state)
2019-10-13 08:02:07 +02:00
{
_isAnyVbInstanced = false;
for (int index = 0; index < Constants.TotalVertexBuffers; index++)
2019-10-13 08:02:07 +02:00
{
2019-11-22 03:46:14 +01:00
var vertexBuffer = state.Get<VertexBufferState>(MethodOffset.VertexBufferState, index);
2019-10-13 08:02:07 +02:00
if (!vertexBuffer.UnpackEnable())
{
2019-12-29 18:41:50 +01:00
BufferManager.SetVertexBuffer(index, 0, 0, 0, 0);
2019-10-13 08:02:07 +02:00
continue;
}
2019-11-22 03:46:14 +01:00
GpuVa endAddress = state.Get<GpuVa>(MethodOffset.VertexBufferEndAddress, index);
2019-10-13 08:02:07 +02:00
ulong address = vertexBuffer.Address.Pack();
int stride = vertexBuffer.UnpackStride();
2019-11-22 03:46:14 +01:00
bool instanced = state.Get<Boolean32>(MethodOffset.VertexBufferInstanced + index);
2019-10-13 08:02:07 +02:00
int divisor = instanced ? vertexBuffer.Divisor : 0;
_isAnyVbInstanced |= divisor != 0;
ulong size;
if (_ibStreamer.HasInlineIndexData || _drawIndexed || stride == 0 || instanced)
2019-10-13 08:02:07 +02:00
{
// This size may be (much) larger than the real vertex buffer size.
// Avoid calculating it this way, unless we don't have any other option.
size = endAddress.Pack() - address + 1;
}
else
{
// For non-indexed draws, we can guess the size from the vertex count
// and stride.
2019-11-22 03:46:14 +01:00
int firstInstance = state.Get<int>(MethodOffset.FirstInstance);
2019-10-13 08:02:07 +02:00
2019-11-22 03:46:14 +01:00
var drawState = state.Get<VertexBufferDrawState>(MethodOffset.VertexBufferDrawState);
2019-10-13 08:02:07 +02:00
size = (ulong)((firstInstance + drawState.First + drawState.Count) * stride);
}
2019-12-29 18:41:50 +01:00
BufferManager.SetVertexBuffer(index, address, size, stride, divisor);
2019-10-13 08:02:07 +02:00
}
}
/// <summary>
/// Updates host face culling and orientation based on guest GPU state.
/// </summary>
/// <param name="state">Current GPU state</param>
2019-11-22 03:46:14 +01:00
private void UpdateFaceState(GpuState state)
2019-10-13 08:02:07 +02:00
{
var yControl = state.Get<YControl> (MethodOffset.YControl);
var face = state.Get<FaceState>(MethodOffset.FaceState);
2019-10-13 08:02:07 +02:00
_context.Renderer.Pipeline.SetFaceCulling(face.CullEnable, face.CullFace);
2019-10-13 08:02:07 +02:00
UpdateFrontFace(yControl, face.FrontFace);
}
/// <summary>
/// Updates the front face based on the current front face and the origin.
/// </summary>
/// <param name="yControl">Y control register value, where the origin is located</param>
/// <param name="frontFace">Front face</param>
private void UpdateFrontFace(YControl yControl, FrontFace frontFace)
{
bool isUpperLeftOrigin = !yControl.HasFlag(YControl.TriangleRastFlip);
if (isUpperLeftOrigin)
{
frontFace = frontFace == FrontFace.CounterClockwise ? FrontFace.Clockwise : FrontFace.CounterClockwise;
}
_context.Renderer.Pipeline.SetFrontFace(frontFace);
2019-10-13 08:02:07 +02:00
}
/// <summary>
/// Updates host render target color masks, based on guest GPU state.
2020-01-01 16:39:09 +01:00
/// This defines which color channels are written to each color buffer.
/// </summary>
/// <param name="state">Current GPU state</param>
2019-11-22 03:46:14 +01:00
private void UpdateRtColorMask(GpuState state)
2019-10-13 08:02:07 +02:00
{
bool rtColorMaskShared = state.Get<Boolean32>(MethodOffset.RtColorMaskShared);
Span<uint> componentMasks = stackalloc uint[Constants.TotalRenderTargets];
2019-10-13 08:02:07 +02:00
for (int index = 0; index < Constants.TotalRenderTargets; index++)
{
var colorMask = state.Get<RtColorMask>(MethodOffset.RtColorMask, rtColorMaskShared ? 0 : index);
2019-10-13 08:02:07 +02:00
2019-12-29 18:41:50 +01:00
uint componentMask;
2019-10-13 08:02:07 +02:00
componentMask = (colorMask.UnpackRed() ? 1u : 0u);
componentMask |= (colorMask.UnpackGreen() ? 2u : 0u);
componentMask |= (colorMask.UnpackBlue() ? 4u : 0u);
componentMask |= (colorMask.UnpackAlpha() ? 8u : 0u);
componentMasks[index] = componentMask;
}
_context.Renderer.Pipeline.SetRenderTargetColorMasks(componentMasks);
2019-10-13 08:02:07 +02:00
}
/// <summary>
/// Updates host render target color buffer blending state, based on guest state.
/// </summary>
/// <param name="state">Current GPU state</param>
2019-11-22 03:46:14 +01:00
private void UpdateBlendState(GpuState state)
2019-10-13 08:02:07 +02:00
{
bool blendIndependent = state.Get<Boolean32>(MethodOffset.BlendIndependent);
ColorF blendConstant = state.Get<ColorF>(MethodOffset.BlendConstant);
for (int index = 0; index < Constants.TotalRenderTargets; index++)
2019-10-13 08:02:07 +02:00
{
BlendDescriptor descriptor;
if (blendIndependent)
{
bool enable = state.Get<Boolean32> (MethodOffset.BlendEnable, index);
var blend = state.Get<BlendState>(MethodOffset.BlendState, index);
descriptor = new BlendDescriptor(
enable,
blendConstant,
blend.ColorOp,
blend.ColorSrcFactor,
blend.ColorDstFactor,
blend.AlphaOp,
blend.AlphaSrcFactor,
blend.AlphaDstFactor);
}
else
{
bool enable = state.Get<Boolean32> (MethodOffset.BlendEnable, 0);
var blend = state.Get<BlendStateCommon>(MethodOffset.BlendStateCommon);
descriptor = new BlendDescriptor(
enable,
blendConstant,
blend.ColorOp,
blend.ColorSrcFactor,
blend.ColorDstFactor,
blend.AlphaOp,
blend.AlphaSrcFactor,
blend.AlphaDstFactor);
}
2019-10-13 08:02:07 +02:00
2019-12-29 18:41:50 +01:00
_context.Renderer.Pipeline.SetBlendState(index, descriptor);
2019-10-13 08:02:07 +02:00
}
}
/// <summary>
/// Updates host logical operation state, based on guest state.
/// </summary>
/// <param name="state">Current GPU state</param>
public void UpdateLogicOpState(GpuState state)
{
LogicalOpState logicOpState = state.Get<LogicalOpState>(MethodOffset.LogicOpState);
_context.Renderer.Pipeline.SetLogicOpState(logicOpState.Enable, logicOpState.LogicalOp);
}
/// <summary>
/// Storage buffer address and size information.
/// </summary>
2019-10-13 08:02:07 +02:00
private struct SbDescriptor
{
#pragma warning disable CS0649
2019-10-13 08:02:07 +02:00
public uint AddressLow;
public uint AddressHigh;
public int Size;
public int Padding;
#pragma warning restore CS0649
2019-10-13 08:02:07 +02:00
public ulong PackAddress()
{
return AddressLow | ((ulong)AddressHigh << 32);
}
}
/// <summary>
/// Updates host shaders based on the guest GPU state.
/// </summary>
/// <param name="state">Current GPU state</param>
2019-11-22 03:46:14 +01:00
private void UpdateShaderState(GpuState state)
2019-10-13 08:02:07 +02:00
{
ShaderAddresses addresses = new ShaderAddresses();
Span<ShaderAddresses> addressesSpan = MemoryMarshal.CreateSpan(ref addresses, 1);
Span<ulong> addressesArray = MemoryMarshal.Cast<ShaderAddresses, ulong>(addressesSpan);
2019-11-22 03:46:14 +01:00
ulong baseAddress = state.Get<GpuVa>(MethodOffset.ShaderBaseAddress).Pack();
2019-10-13 08:02:07 +02:00
for (int index = 0; index < 6; index++)
{
2019-11-22 03:46:14 +01:00
var shader = state.Get<ShaderState>(MethodOffset.ShaderState, index);
2019-10-13 08:02:07 +02:00
if (!shader.UnpackEnable() && index != 1)
{
continue;
}
addressesArray[index] = baseAddress + shader.Offset;
}
ShaderBundle gs = ShaderCache.GetGraphicsShader(state, addresses);
2019-10-13 08:02:07 +02:00
_vsUsesInstanceId = gs.Shaders[0]?.Info.UsesInstanceId ?? false;
2019-10-13 08:02:07 +02:00
int storageBufferBindingsCount = 0;
int uniformBufferBindingsCount = 0;
2020-01-01 16:39:09 +01:00
for (int stage = 0; stage < Constants.ShaderStages; stage++)
2019-10-13 08:02:07 +02:00
{
ShaderProgramInfo info = gs.Shaders[stage]?.Info;
2019-10-13 08:02:07 +02:00
_currentProgramInfo[stage] = info;
2019-10-13 08:02:07 +02:00
if (info == null)
{
TextureManager.SetGraphicsTextures(stage, Array.Empty<TextureBindingInfo>());
TextureManager.SetGraphicsImages(stage, Array.Empty<TextureBindingInfo>());
BufferManager.SetGraphicsStorageBufferBindings(stage, null);
BufferManager.SetGraphicsUniformBufferBindings(stage, null);
2019-10-13 08:02:07 +02:00
continue;
}
var textureBindings = new TextureBindingInfo[info.Textures.Count];
for (int index = 0; index < info.Textures.Count; index++)
{
var descriptor = info.Textures[index];
Target target = ShaderTexture.GetTarget(descriptor.Type);
2019-10-13 08:02:07 +02:00
textureBindings[index] = new TextureBindingInfo(
target,
descriptor.Binding,
descriptor.CbufSlot,
descriptor.HandleIndex,
descriptor.Flags);
2019-10-13 08:02:07 +02:00
}
2019-12-29 18:41:50 +01:00
TextureManager.SetGraphicsTextures(stage, textureBindings);
var imageBindings = new TextureBindingInfo[info.Images.Count];
for (int index = 0; index < info.Images.Count; index++)
{
var descriptor = info.Images[index];
Target target = ShaderTexture.GetTarget(descriptor.Type);
Format format = ShaderTexture.GetFormat(descriptor.Format);
imageBindings[index] = new TextureBindingInfo(
target,
format,
descriptor.Binding,
descriptor.CbufSlot,
descriptor.HandleIndex,
descriptor.Flags);
}
2019-12-29 18:41:50 +01:00
TextureManager.SetGraphicsImages(stage, imageBindings);
2019-10-13 08:02:07 +02:00
BufferManager.SetGraphicsStorageBufferBindings(stage, info.SBuffers);
BufferManager.SetGraphicsUniformBufferBindings(stage, info.CBuffers);
2019-10-13 08:02:07 +02:00
if (info.SBuffers.Count != 0)
2019-10-13 08:02:07 +02:00
{
storageBufferBindingsCount = Math.Max(storageBufferBindingsCount, info.SBuffers.Max(x => x.Binding) + 1);
2019-10-13 08:02:07 +02:00
}
if (info.CBuffers.Count != 0)
2019-10-13 08:02:07 +02:00
{
uniformBufferBindingsCount = Math.Max(uniformBufferBindingsCount, info.CBuffers.Max(x => x.Binding) + 1);
2019-10-13 08:02:07 +02:00
}
}
BufferManager.SetGraphicsStorageBufferBindingsCount(storageBufferBindingsCount);
BufferManager.SetGraphicsUniformBufferBindingsCount(uniformBufferBindingsCount);
2019-12-29 18:41:50 +01:00
_context.Renderer.Pipeline.SetProgram(gs.HostProgram);
2019-10-13 08:02:07 +02:00
}
/// <summary>
/// Updates transform feedback buffer state based on the guest GPU state.
/// </summary>
/// <param name="state">Current GPU state</param>
private void UpdateTfBufferState(GpuState state)
{
for (int index = 0; index < Constants.TotalTransformFeedbackBuffers; index++)
{
TfBufferState tfb = state.Get<TfBufferState>(MethodOffset.TfBufferState, index);
if (!tfb.Enable)
{
BufferManager.SetTransformFeedbackBuffer(index, 0, 0);
continue;
}
BufferManager.SetTransformFeedbackBuffer(index, tfb.Address.Pack(), (uint)tfb.Size);
}
}
/// <summary>
/// Updates user-defined clipping based on the guest GPU state.
/// </summary>
/// <param name="state">Current GPU state</param>
private void UpdateUserClipState(GpuState state)
{
int clipMask = state.Get<int>(MethodOffset.ClipDistanceEnable);
for (int i = 0; i < Constants.TotalClipDistances; ++i)
{
_context.Renderer.Pipeline.SetUserClipDistance(i, (clipMask & (1 << i)) != 0);
}
}
/// <summary>
/// Issues a texture barrier.
/// This waits until previous texture writes from the GPU to finish, before
/// performing new operations with said textures.
/// </summary>
2020-01-01 16:39:09 +01:00
/// <param name="state">Current GPU state (unused)</param>
/// <param name="argument">Method call argument (unused)</param>
2019-11-22 03:46:14 +01:00
private void TextureBarrier(GpuState state, int argument)
{
_context.Renderer.Pipeline.TextureBarrier();
}
/// <summary>
/// Issues a texture barrier.
/// This waits until previous texture writes from the GPU to finish, before
/// performing new operations with said textures.
/// This performs a per-tile wait, it is only valid if both the previous write
/// and current access has the same access patterns.
/// This may be faster than the regular barrier on tile-based rasterizers.
/// </summary>
2020-01-01 16:39:09 +01:00
/// <param name="state">Current GPU state (unused)</param>
/// <param name="argument">Method call argument (unused)</param>
2019-11-22 03:46:14 +01:00
private void TextureBarrierTiled(GpuState state, int argument)
{
_context.Renderer.Pipeline.TextureBarrierTiled();
}
2019-10-13 08:02:07 +02:00
}
}