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

798 lines
29 KiB
C#
Raw Normal View History

2019-10-13 06:02:07 +00:00
using Ryujinx.Graphics.GAL;
using Ryujinx.Graphics.GAL.Blend;
using Ryujinx.Graphics.GAL.DepthStencil;
using Ryujinx.Graphics.GAL.InputAssembler;
using Ryujinx.Graphics.GAL.Texture;
using Ryujinx.Graphics.Gpu.Image;
using Ryujinx.Graphics.Gpu.Memory;
using Ryujinx.Graphics.Gpu.Shader;
2019-10-13 06:02:07 +00:00
using Ryujinx.Graphics.Gpu.State;
using Ryujinx.Graphics.Shader;
using System;
using System.Runtime.InteropServices;
namespace Ryujinx.Graphics.Gpu.Engine
{
partial class Methods
{
private GpuContext _context;
private ShaderCache _shaderCache;
private ShaderProgramInfo[] _currentProgramInfo;
2019-10-13 06:02:07 +00:00
private BufferManager _bufferManager;
private TextureManager _textureManager;
public BufferManager BufferManager => _bufferManager;
2019-10-13 06:02:07 +00:00
public TextureManager TextureManager => _textureManager;
private bool _isAnyVbInstanced;
private bool _vsUsesInstanceId;
public Methods(GpuContext context)
{
_context = context;
_shaderCache = new ShaderCache(_context);
_currentProgramInfo = new ShaderProgramInfo[Constants.TotalShaderStages];
2019-10-13 06:02:07 +00:00
_bufferManager = new BufferManager(context);
_textureManager = new TextureManager(context);
2019-10-13 06:02:07 +00:00
}
2019-11-22 02:46:14 +00:00
public void RegisterCallbacks(GpuState state)
2019-10-13 06:02:07 +00:00
{
2019-11-22 02:46:14 +00:00
state.RegisterCallback(MethodOffset.LaunchDma, LaunchDma);
state.RegisterCallback(MethodOffset.LoadInlineData, LoadInlineData);
2019-10-13 06:02:07 +00:00
2019-11-22 02:46:14 +00:00
state.RegisterCallback(MethodOffset.Dispatch, Dispatch);
2019-10-13 06:02:07 +00:00
2019-11-22 02:46:14 +00:00
state.RegisterCallback(MethodOffset.CopyBuffer, CopyBuffer);
state.RegisterCallback(MethodOffset.CopyTexture, CopyTexture);
2019-10-13 06:02:07 +00:00
2019-11-22 02:46:14 +00:00
state.RegisterCallback(MethodOffset.TextureBarrier, TextureBarrier);
state.RegisterCallback(MethodOffset.InvalidateTextures, InvalidateTextures);
state.RegisterCallback(MethodOffset.TextureBarrierTiled, TextureBarrierTiled);
2019-11-22 02:46:14 +00:00
state.RegisterCallback(MethodOffset.ResetCounter, ResetCounter);
2019-10-13 06:02:07 +00:00
2019-11-22 02:46:14 +00:00
state.RegisterCallback(MethodOffset.DrawEnd, DrawEnd);
state.RegisterCallback(MethodOffset.DrawBegin, DrawBegin);
2019-10-13 06:02:07 +00:00
2019-11-22 02:46:14 +00:00
state.RegisterCallback(MethodOffset.IndexBufferCount, SetIndexBufferCount);
2019-11-22 02:46:14 +00:00
state.RegisterCallback(MethodOffset.Clear, Clear);
2019-11-22 02:46:14 +00:00
state.RegisterCallback(MethodOffset.Report, Report);
2019-11-22 02:46:14 +00:00
state.RegisterCallback(MethodOffset.UniformBufferUpdateData, 16, UniformBufferUpdate);
2019-11-22 02:46:14 +00: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 06:02:07 +00:00
}
2019-11-22 02:46:14 +00:00
private void UpdateState(GpuState state)
2019-10-13 06:02:07 +00: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.
2019-11-22 02:46:14 +00:00
if (state.QueryModified(MethodOffset.ShaderBaseAddress, MethodOffset.ShaderState))
2019-10-13 06:02:07 +00:00
{
2019-11-22 02:46:14 +00:00
UpdateShaderState(state);
2019-10-13 06:02:07 +00:00
}
if (state.QueryModified(MethodOffset.RtColorState,
MethodOffset.RtDepthStencilState,
MethodOffset.RtControl,
MethodOffset.RtDepthStencilSize,
MethodOffset.RtDepthStencilEnable))
{
UpdateRenderTargetState(state, useControl: true);
}
2019-10-13 06:02:07 +00:00
2019-11-22 02:46:14 +00:00
if (state.QueryModified(MethodOffset.DepthTestEnable,
MethodOffset.DepthWriteEnable,
MethodOffset.DepthTestFunc))
2019-10-13 06:02:07 +00:00
{
2019-11-22 02:46:14 +00:00
UpdateDepthTestState(state);
2019-10-13 06:02:07 +00:00
}
2019-11-22 02:46:14 +00:00
if (state.QueryModified(MethodOffset.ViewportTransform, MethodOffset.ViewportExtents))
2019-10-13 06:02:07 +00:00
{
2019-11-22 02:46:14 +00:00
UpdateViewportTransform(state);
2019-10-13 06:02:07 +00:00
}
2019-11-22 02:46:14 +00:00
if (state.QueryModified(MethodOffset.DepthBiasState,
MethodOffset.DepthBiasFactor,
MethodOffset.DepthBiasUnits,
MethodOffset.DepthBiasClamp))
2019-10-13 06:02:07 +00:00
{
2019-11-22 02:46:14 +00:00
UpdateDepthBiasState(state);
2019-10-13 06:02:07 +00:00
}
2019-11-22 02:46:14 +00:00
if (state.QueryModified(MethodOffset.StencilBackMasks,
MethodOffset.StencilTestState,
MethodOffset.StencilBackTestState))
2019-10-13 06:02:07 +00:00
{
2019-11-22 02:46:14 +00:00
UpdateStencilTestState(state);
2019-10-13 06:02:07 +00:00
}
// Pools.
if (state.QueryModified(MethodOffset.SamplerPoolState, MethodOffset.SamplerIndex))
2019-10-13 06:02:07 +00:00
{
2019-11-22 02:46:14 +00:00
UpdateSamplerPoolState(state);
2019-10-13 06:02:07 +00:00
}
2019-11-22 02:46:14 +00:00
if (state.QueryModified(MethodOffset.TexturePoolState))
2019-10-13 06:02:07 +00:00
{
2019-11-22 02:46:14 +00:00
UpdateTexturePoolState(state);
2019-10-13 06:02:07 +00:00
}
// Input assembler state.
2019-11-22 02:46:14 +00:00
if (state.QueryModified(MethodOffset.VertexAttribState))
2019-10-13 06:02:07 +00:00
{
2019-11-22 02:46:14 +00:00
UpdateVertexAttribState(state);
}
2019-11-22 02:46:14 +00:00
if (state.QueryModified(MethodOffset.PrimitiveRestartState))
{
2019-11-22 02:46:14 +00:00
UpdatePrimitiveRestartState(state);
}
2019-11-22 02:46:14 +00:00
if (state.QueryModified(MethodOffset.IndexBufferState))
{
2019-11-22 02:46:14 +00:00
UpdateIndexBufferState(state);
}
2019-11-22 02:46:14 +00:00
if (state.QueryModified(MethodOffset.VertexBufferDrawState,
MethodOffset.VertexBufferInstanced,
MethodOffset.VertexBufferState,
MethodOffset.VertexBufferEndAddress))
{
2019-11-22 02:46:14 +00:00
UpdateVertexBufferState(state);
2019-10-13 06:02:07 +00:00
}
2019-11-22 02:46:14 +00:00
if (state.QueryModified(MethodOffset.FaceState))
2019-10-13 06:02:07 +00:00
{
2019-11-22 02:46:14 +00:00
UpdateFaceState(state);
2019-10-13 06:02:07 +00:00
}
if (state.QueryModified(MethodOffset.RtColorMaskShared, MethodOffset.RtColorMask))
2019-10-13 06:02:07 +00:00
{
2019-11-22 02:46:14 +00:00
UpdateRtColorMask(state);
2019-10-13 06:02:07 +00:00
}
if (state.QueryModified(MethodOffset.BlendIndependent,
MethodOffset.BlendStateCommon,
MethodOffset.BlendEnableCommon,
MethodOffset.BlendEnable,
MethodOffset.BlendState))
2019-10-13 06:02:07 +00:00
{
2019-11-22 02:46:14 +00:00
UpdateBlendState(state);
2019-10-13 06:02:07 +00:00
}
CommitBindings();
}
private void CommitBindings()
{
UpdateStorageBuffers();
2019-10-13 06:02:07 +00:00
_bufferManager.CommitBindings();
_textureManager.CommitGraphicsBindings();
2019-10-13 06:02:07 +00:00
}
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];
ulong sbDescAddress = _bufferManager.GetGraphicsUniformBufferAddress(stage, 0);
int sbDescOffset = 0x110 + stage * 0x100 + sb.Slot * 0x10;
sbDescAddress += (ulong)sbDescOffset;
Span<byte> sbDescriptorData = _context.PhysicalMemory.Read(sbDescAddress, 0x10);
SbDescriptor sbDescriptor = MemoryMarshal.Cast<byte, SbDescriptor>(sbDescriptorData)[0];
_bufferManager.SetGraphicsStorageBuffer(stage, sb.Slot, sbDescriptor.PackAddress(), (uint)sbDescriptor.Size);
}
}
}
private void UpdateRenderTargetState(GpuState state, bool useControl)
{
var rtControl = state.Get<RtControl>(MethodOffset.RtControl);
int count = useControl ? rtControl.UnpackCount() : Constants.TotalRenderTargets;
2019-11-22 02:46:14 +00:00
var msaaMode = state.Get<TextureMsaaMode>(MethodOffset.RtMsaaMode);
2019-10-13 06:02:07 +00:00
int samplesInX = msaaMode.SamplesInX();
int samplesInY = msaaMode.SamplesInY();
for (int index = 0; index < Constants.TotalRenderTargets; index++)
2019-10-13 06:02:07 +00:00
{
int rtIndex = useControl ? rtControl.UnpackPermutationIndex(index) : index;
2019-10-13 06:02:07 +00:00
var colorState = state.Get<RtColorState>(MethodOffset.RtColorState, rtIndex);
if (index >= count || !IsRtEnabled(colorState))
{
_textureManager.SetRenderTargetColor(index, null);
2019-10-13 06:02:07 +00:00
continue;
}
2019-10-13 06:02:07 +00:00
Image.Texture color = _textureManager.FindOrCreateTexture(
colorState,
samplesInX,
samplesInY);
2019-10-13 06:02:07 +00:00
_textureManager.SetRenderTargetColor(index, color);
2019-10-13 06:02:07 +00:00
if (color != null)
{
color.Modified = true;
2019-10-13 06:02:07 +00:00
}
}
2019-11-22 02:46:14 +00:00
bool dsEnable = state.Get<Boolean32>(MethodOffset.RtDepthStencilEnable);
2019-10-13 06:02:07 +00:00
Image.Texture depthStencil = null;
if (dsEnable)
{
2019-11-22 02:46:14 +00:00
var dsState = state.Get<RtDepthStencilState>(MethodOffset.RtDepthStencilState);
var dsSize = state.Get<Size3D> (MethodOffset.RtDepthStencilSize);
2019-10-13 06:02:07 +00:00
depthStencil = _textureManager.FindOrCreateTexture(
dsState,
dsSize,
samplesInX,
samplesInY);
}
_textureManager.SetRenderTargetDepthStencil(depthStencil);
if (depthStencil != null)
{
depthStencil.Modified = true;
}
2019-10-13 06:02:07 +00:00
}
private static bool IsRtEnabled(RtColorState colorState)
{
// Colors are disabled by writing 0 to the format.
return colorState.Format != 0 && colorState.WidthOrStride != 0;
}
2019-11-22 02:46:14 +00:00
private void UpdateDepthTestState(GpuState state)
2019-10-13 06:02:07 +00:00
{
_context.Renderer.Pipeline.SetDepthTest(new DepthTestDescriptor(
2019-11-22 02:46:14 +00:00
state.Get<Boolean32>(MethodOffset.DepthTestEnable),
state.Get<Boolean32>(MethodOffset.DepthWriteEnable),
state.Get<CompareOp>(MethodOffset.DepthTestFunc)));
2019-10-13 06:02:07 +00:00
}
2019-11-22 02:46:14 +00:00
private void UpdateViewportTransform(GpuState state)
2019-10-13 06:02:07 +00:00
{
bool transformEnable = GetViewportTransformEnable(state);
bool flipY = (state.Get<int>(MethodOffset.YControl) & 1) != 0;
float yFlip = flipY ? -1 : 1;
2019-10-13 06:02:07 +00:00
Viewport[] viewports = new Viewport[Constants.TotalViewports];
for (int index = 0; index < Constants.TotalViewports; index++)
{
2019-11-22 02:46:14 +00:00
var transform = state.Get<ViewportTransform>(MethodOffset.ViewportTransform, index);
var extents = state.Get<ViewportExtents> (MethodOffset.ViewportExtents, index);
2019-10-13 06:02:07 +00:00
RectangleF region;
2019-10-13 06:02:07 +00:00
if (transformEnable)
{
float x = transform.TranslateX - MathF.Abs(transform.ScaleX);
float y = transform.TranslateY - MathF.Abs(transform.ScaleY);
2019-10-13 06:02:07 +00:00
float width = transform.ScaleX * 2;
float height = transform.ScaleY * 2 * yFlip;
region = new RectangleF(x, y, width, height);
}
else
{
// It's not possible to fully disable viewport transform, at least with the most
// common graphics APIs, but we can effectively disable it with a dummy transform.
// The transform is defined as: xw = (width / 2) * xndc + x + (width / 2)
// By setting x to -(width / 2), we effectively remove the translation.
// By setting the width to 2, we remove the scale since 2 / 2 = 1.
// Now, the only problem is the viewport clipping, that we also can't disable.
// To prevent the values from being clipped, we multiply (-1, -1, 2, 2) by
// the maximum supported viewport dimensions.
// This must be compensated on the shader, by dividing the vertex position
// by the maximum viewport dimensions.
float maxSize = (float)_context.Capabilities.MaximumViewportDimensions;
float halfMaxSize = (float)_context.Capabilities.MaximumViewportDimensions * 0.5f;
region = new RectangleF(-halfMaxSize, -halfMaxSize, maxSize, maxSize * yFlip);
}
2019-10-13 06:02:07 +00:00
viewports[index] = new Viewport(
region,
transform.UnpackSwizzleX(),
transform.UnpackSwizzleY(),
transform.UnpackSwizzleZ(),
transform.UnpackSwizzleW(),
extents.DepthNear,
extents.DepthFar);
}
_context.Renderer.Pipeline.SetViewports(0, viewports);
2019-10-13 06:02:07 +00:00
}
2019-11-22 02:46:14 +00:00
private void UpdateDepthBiasState(GpuState state)
2019-10-13 06:02:07 +00:00
{
2019-11-22 02:46:14 +00:00
var depthBias = state.Get<DepthBiasState>(MethodOffset.DepthBiasState);
2019-10-13 06:02:07 +00:00
2019-11-22 02:46:14 +00: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 06:02:07 +00:00
PolygonModeMask enables = 0;
enables = (depthBias.PointEnable ? PolygonModeMask.Point : 0);
enables |= (depthBias.LineEnable ? PolygonModeMask.Line : 0);
enables |= (depthBias.FillEnable ? PolygonModeMask.Fill : 0);
2019-10-13 06:02:07 +00:00
_context.Renderer.Pipeline.SetDepthBias(enables, factor, units, clamp);
2019-10-13 06:02:07 +00:00
}
2019-11-22 02:46:14 +00:00
private void UpdateStencilTestState(GpuState state)
2019-10-13 06:02:07 +00:00
{
2019-11-22 02:46:14 +00:00
var backMasks = state.Get<StencilBackMasks> (MethodOffset.StencilBackMasks);
var test = state.Get<StencilTestState> (MethodOffset.StencilTestState);
var backTest = state.Get<StencilBackTestState>(MethodOffset.StencilBackTestState);
2019-10-13 06:02:07 +00:00
CompareOp backFunc;
StencilOp backSFail;
StencilOp backDpPass;
StencilOp backDpFail;
int backFuncRef;
int backFuncMask;
int backMask;
if (backTest.TwoSided)
2019-10-13 06:02:07 +00: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 06:02:07 +00:00
test.FrontFunc,
test.FrontSFail,
test.FrontDpPass,
test.FrontDpFail,
test.FrontFuncRef,
test.FrontFuncMask,
test.FrontMask,
backFunc,
backSFail,
backDpPass,
backDpFail,
backFuncRef,
backFuncMask,
backMask));
}
2019-11-22 02:46:14 +00:00
private void UpdateSamplerPoolState(GpuState state)
2019-10-13 06:02:07 +00:00
{
var texturePool = state.Get<PoolState>(MethodOffset.TexturePoolState);
2019-11-22 02:46:14 +00:00
var samplerPool = state.Get<PoolState>(MethodOffset.SamplerPoolState);
2019-10-13 06:02:07 +00:00
var samplerIndex = state.Get<SamplerIndex>(MethodOffset.SamplerIndex);
int maximumId = samplerIndex == SamplerIndex.ViaHeaderIndex
? texturePool.MaximumId
: samplerPool.MaximumId;
_textureManager.SetGraphicsSamplerPool(samplerPool.Address.Pack(), maximumId, samplerIndex);
2019-10-13 06:02:07 +00:00
}
2019-11-22 02:46:14 +00:00
private void UpdateTexturePoolState(GpuState state)
2019-10-13 06:02:07 +00:00
{
2019-11-22 02:46:14 +00:00
var texturePool = state.Get<PoolState>(MethodOffset.TexturePoolState);
2019-10-13 06:02:07 +00:00
_textureManager.SetGraphicsTexturePool(texturePool.Address.Pack(), texturePool.MaximumId);
2019-10-13 06:02:07 +00:00
2019-11-22 02:46:14 +00:00
_textureManager.SetGraphicsTextureBufferIndex(state.Get<int>(MethodOffset.TextureBufferIndex));
2019-10-13 06:02:07 +00:00
}
2019-11-22 02:46:14 +00:00
private void UpdateVertexAttribState(GpuState state)
2019-10-13 06:02:07 +00:00
{
VertexAttribDescriptor[] vertexAttribs = new VertexAttribDescriptor[16];
for (int index = 0; index < 16; index++)
{
2019-11-22 02:46:14 +00:00
var vertexAttrib = state.Get<VertexAttribState>(MethodOffset.VertexAttribState, index);
2019-10-13 06:02:07 +00:00
if (!FormatTable.TryGetAttribFormat(vertexAttrib.UnpackFormat(), out Format format))
{
// TODO: warning.
format = Format.R32G32B32A32Float;
}
vertexAttribs[index] = new VertexAttribDescriptor(
vertexAttrib.UnpackBufferIndex(),
vertexAttrib.UnpackOffset(),
format);
}
_context.Renderer.Pipeline.BindVertexAttribs(vertexAttribs);
2019-10-13 06:02:07 +00:00
}
2019-11-22 02:46:14 +00:00
private void UpdatePrimitiveRestartState(GpuState state)
2019-10-13 06:02:07 +00:00
{
2019-11-22 02:46:14 +00:00
PrimitiveRestartState primitiveRestart = state.Get<PrimitiveRestartState>(MethodOffset.PrimitiveRestartState);
2019-10-13 06:02:07 +00:00
_context.Renderer.Pipeline.SetPrimitiveRestart(
2019-10-13 06:02:07 +00:00
primitiveRestart.Enable,
primitiveRestart.Index);
}
2019-11-22 02:46:14 +00:00
private void UpdateIndexBufferState(GpuState state)
2019-10-13 06:02:07 +00:00
{
2019-11-22 02:46:14 +00:00
var indexBuffer = state.Get<IndexBufferState>(MethodOffset.IndexBufferState);
2019-10-13 06:02:07 +00:00
_firstIndex = indexBuffer.First;
_indexCount = indexBuffer.Count;
if (_indexCount == 0)
{
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);
switch (indexBuffer.Type)
{
case IndexType.UShort: size *= 2; break;
case IndexType.UInt: size *= 4; break;
}
_bufferManager.SetIndexBuffer(gpuVa, size, indexBuffer.Type);
// The index buffer affects the vertex buffer size calculation, we
// need to ensure that they are updated.
2019-11-22 02:46:14 +00:00
UpdateVertexBufferState(state);
2019-10-13 06:02:07 +00:00
}
2019-11-22 02:46:14 +00:00
private void UpdateVertexBufferState(GpuState state)
2019-10-13 06:02:07 +00:00
{
_isAnyVbInstanced = false;
for (int index = 0; index < 16; index++)
{
2019-11-22 02:46:14 +00:00
var vertexBuffer = state.Get<VertexBufferState>(MethodOffset.VertexBufferState, index);
2019-10-13 06:02:07 +00:00
if (!vertexBuffer.UnpackEnable())
{
_bufferManager.SetVertexBuffer(index, 0, 0, 0, 0);
continue;
}
2019-11-22 02:46:14 +00:00
GpuVa endAddress = state.Get<GpuVa>(MethodOffset.VertexBufferEndAddress, index);
2019-10-13 06:02:07 +00:00
ulong address = vertexBuffer.Address.Pack();
int stride = vertexBuffer.UnpackStride();
2019-11-22 02:46:14 +00:00
bool instanced = state.Get<Boolean32>(MethodOffset.VertexBufferInstanced + index);
2019-10-13 06:02:07 +00:00
int divisor = instanced ? vertexBuffer.Divisor : 0;
_isAnyVbInstanced |= divisor != 0;
ulong size;
if (_drawIndexed || stride == 0 || instanced)
{
// 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 02:46:14 +00:00
int firstInstance = state.Get<int>(MethodOffset.FirstInstance);
2019-10-13 06:02:07 +00:00
2019-11-22 02:46:14 +00:00
var drawState = state.Get<VertexBufferDrawState>(MethodOffset.VertexBufferDrawState);
2019-10-13 06:02:07 +00:00
size = (ulong)((firstInstance + drawState.First + drawState.Count) * stride);
}
_bufferManager.SetVertexBuffer(index, address, size, stride, divisor);
}
}
2019-11-22 02:46:14 +00:00
private void UpdateFaceState(GpuState state)
2019-10-13 06:02:07 +00:00
{
2019-11-22 02:46:14 +00:00
var face = state.Get<FaceState>(MethodOffset.FaceState);
2019-10-13 06:02:07 +00:00
_context.Renderer.Pipeline.SetFaceCulling(face.CullEnable, face.CullFace);
2019-10-13 06:02:07 +00:00
_context.Renderer.Pipeline.SetFrontFace(face.FrontFace);
2019-10-13 06:02:07 +00:00
}
2019-11-22 02:46:14 +00:00
private void UpdateRtColorMask(GpuState state)
2019-10-13 06:02:07 +00:00
{
bool rtColorMaskShared = state.Get<Boolean32>(MethodOffset.RtColorMaskShared);
2019-10-13 06:02:07 +00:00
uint[] componentMasks = new uint[Constants.TotalRenderTargets];
for (int index = 0; index < Constants.TotalRenderTargets; index++)
{
var colorMask = state.Get<RtColorMask>(MethodOffset.RtColorMask, rtColorMaskShared ? 0 : index);
2019-10-13 06:02:07 +00:00
uint componentMask = 0;
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 06:02:07 +00:00
}
2019-11-22 02:46:14 +00:00
private void UpdateBlendState(GpuState state)
2019-10-13 06:02:07 +00:00
{
bool blendIndependent = state.Get<Boolean32>(MethodOffset.BlendIndependent);
2019-10-13 06:02:07 +00:00
BlendState[] blends = new BlendState[8];
for (int index = 0; index < 8; index++)
{
BlendDescriptor descriptor;
if (blendIndependent)
{
bool enable = state.Get<Boolean32> (MethodOffset.BlendEnable, index);
var blend = state.Get<BlendState>(MethodOffset.BlendState, index);
descriptor = new BlendDescriptor(
enable,
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,
blend.ColorOp,
blend.ColorSrcFactor,
blend.ColorDstFactor,
blend.AlphaOp,
blend.AlphaSrcFactor,
blend.AlphaDstFactor);
}
2019-10-13 06:02:07 +00:00
_context.Renderer.Pipeline.BindBlendState(index, descriptor);
2019-10-13 06:02:07 +00:00
}
}
private struct SbDescriptor
{
public uint AddressLow;
public uint AddressHigh;
public int Size;
public int Padding;
public ulong PackAddress()
{
return AddressLow | ((ulong)AddressHigh << 32);
}
}
2019-11-22 02:46:14 +00:00
private void UpdateShaderState(GpuState state)
2019-10-13 06:02:07 +00:00
{
ShaderAddresses addresses = new ShaderAddresses();
Span<ShaderAddresses> addressesSpan = MemoryMarshal.CreateSpan(ref addresses, 1);
Span<ulong> addressesArray = MemoryMarshal.Cast<ShaderAddresses, ulong>(addressesSpan);
2019-11-22 02:46:14 +00:00
ulong baseAddress = state.Get<GpuVa>(MethodOffset.ShaderBaseAddress).Pack();
2019-10-13 06:02:07 +00:00
for (int index = 0; index < 6; index++)
{
2019-11-22 02:46:14 +00:00
var shader = state.Get<ShaderState>(MethodOffset.ShaderState, index);
2019-10-13 06:02:07 +00:00
if (!shader.UnpackEnable() && index != 1)
{
continue;
}
addressesArray[index] = baseAddress + shader.Offset;
}
bool viewportTransformEnable = GetViewportTransformEnable(state);
GraphicsShader gs = _shaderCache.GetGraphicsShader(addresses, !viewportTransformEnable);
2019-10-13 06:02:07 +00:00
_vsUsesInstanceId = gs.Shader[0].Program.Info.UsesInstanceId;
2019-10-13 06:02:07 +00:00
for (int stage = 0; stage < Constants.TotalShaderStages; stage++)
{
ShaderProgramInfo info = gs.Shader[stage].Program?.Info;
2019-10-13 06:02:07 +00:00
_currentProgramInfo[stage] = info;
2019-10-13 06:02:07 +00:00
if (info == null)
{
continue;
}
var textureBindings = new TextureBindingInfo[info.Textures.Count];
for (int index = 0; index < info.Textures.Count; index++)
{
var descriptor = info.Textures[index];
Target target = GetTarget(descriptor.Type);
2019-10-13 06:02:07 +00:00
textureBindings[index] = new TextureBindingInfo(target, descriptor.HandleIndex);
}
_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 = GetTarget(descriptor.Type);
imageBindings[index] = new TextureBindingInfo(target, descriptor.HandleIndex);
}
_textureManager.SetGraphicsImages(stage, imageBindings);
2019-10-13 06:02:07 +00:00
uint sbEnableMask = 0;
uint ubEnableMask = 0;
for (int index = 0; index < info.SBuffers.Count; index++)
{
sbEnableMask |= 1u << info.SBuffers[index].Slot;
2019-10-13 06:02:07 +00:00
}
for (int index = 0; index < info.CBuffers.Count; index++)
{
ubEnableMask |= 1u << info.CBuffers[index].Slot;
}
_bufferManager.SetGraphicsStorageBufferEnableMask(stage, sbEnableMask);
_bufferManager.SetGraphicsUniformBufferEnableMask(stage, ubEnableMask);
}
_context.Renderer.Pipeline.BindProgram(gs.HostProgram);
2019-10-13 06:02:07 +00:00
}
private bool GetViewportTransformEnable(GpuState state)
{
// FIXME: We should read ViewportTransformEnable, but it seems that some games writes 0 there?
// return state.Get<Boolean32>(MethodOffset.ViewportTransformEnable) != 0;
return true;
}
private static Target GetTarget(SamplerType type)
2019-10-13 06:02:07 +00:00
{
type &= ~(SamplerType.Indexed | SamplerType.Shadow);
2019-10-13 06:02:07 +00:00
switch (type)
2019-10-13 06:02:07 +00:00
{
case SamplerType.Texture1D:
2019-10-13 06:02:07 +00:00
return Target.Texture1D;
case SamplerType.TextureBuffer:
return Target.TextureBuffer;
case SamplerType.Texture1D | SamplerType.Array:
2019-10-13 06:02:07 +00:00
return Target.Texture1DArray;
case SamplerType.Texture2D:
2019-10-13 06:02:07 +00:00
return Target.Texture2D;
case SamplerType.Texture2D | SamplerType.Array:
2019-10-13 06:02:07 +00:00
return Target.Texture2DArray;
case SamplerType.Texture2D | SamplerType.Multisample:
2019-10-13 06:02:07 +00:00
return Target.Texture2DMultisample;
case SamplerType.Texture2D | SamplerType.Multisample | SamplerType.Array:
2019-10-13 06:02:07 +00:00
return Target.Texture2DMultisampleArray;
case SamplerType.Texture3D:
2019-10-13 06:02:07 +00:00
return Target.Texture3D;
case SamplerType.TextureCube:
2019-10-13 06:02:07 +00:00
return Target.Cubemap;
case SamplerType.TextureCube | SamplerType.Array:
2019-10-13 06:02:07 +00:00
return Target.CubemapArray;
}
// TODO: Warning.
return Target.Texture2D;
}
2019-11-22 02:46:14 +00:00
private void TextureBarrier(GpuState state, int argument)
{
_context.Renderer.Pipeline.TextureBarrier();
}
2019-11-22 02:46:14 +00:00
private void InvalidateTextures(GpuState state, int argument)
2019-10-13 06:02:07 +00:00
{
_textureManager.Flush();
}
2019-11-22 02:46:14 +00:00
private void TextureBarrierTiled(GpuState state, int argument)
{
_context.Renderer.Pipeline.TextureBarrierTiled();
}
2019-10-13 06:02:07 +00:00
}
}