Implement texture buffers (#1152)

* Implement texture buffers

* Throw NotSupportedException where appropriate
This commit is contained in:
gdkchan 2020-04-25 10:02:18 -03:00 committed by GitHub
parent a065dc1626
commit 3cb1fa0e85
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
16 changed files with 291 additions and 135 deletions

View file

@ -12,5 +12,6 @@ namespace Ryujinx.Graphics.GAL
byte[] GetData(); byte[] GetData();
void SetData(ReadOnlySpan<byte> data); void SetData(ReadOnlySpan<byte> data);
void SetStorage(BufferRange buffer);
} }
} }

View file

@ -12,8 +12,6 @@ namespace Ryujinx.Graphics.Gpu.Engine
private const int NsToTicksFractionNumerator = 384; private const int NsToTicksFractionNumerator = 384;
private const int NsToTicksFractionDenominator = 625; private const int NsToTicksFractionDenominator = 625;
private ulong _runningCounter;
private readonly CounterCache _counterCache = new CounterCache(); private readonly CounterCache _counterCache = new CounterCache();
/// <summary> /// <summary>

View file

@ -259,7 +259,7 @@ namespace Ryujinx.Graphics.Gpu.Engine
{ {
UpdateStorageBuffers(); UpdateStorageBuffers();
BufferManager.CommitBindings(); BufferManager.CommitGraphicsBindings();
TextureManager.CommitGraphicsBindings(); TextureManager.CommitGraphicsBindings();
} }

View file

@ -295,7 +295,9 @@ namespace Ryujinx.Graphics.Gpu.Image
/// </summary> /// </summary>
public void SynchronizeMemory() public void SynchronizeMemory()
{ {
if (_sequenceNumber == _context.SequenceNumber && _hasData) // Texture buffers are not handled here, instead they are invalidated (if modified)
// when the texture is bound. This is handled by the buffer manager.
if ((_sequenceNumber == _context.SequenceNumber && _hasData) || Info.Target == Target.TextureBuffer)
{ {
return; return;
} }

View file

@ -69,7 +69,6 @@ namespace Ryujinx.Graphics.Gpu.Image
public void SetTextures(int stage, TextureBindingInfo[] bindings) public void SetTextures(int stage, TextureBindingInfo[] bindings)
{ {
_textureBindings[stage] = bindings; _textureBindings[stage] = bindings;
_textureState[stage] = new TextureStatePerStage[bindings.Length]; _textureState[stage] = new TextureStatePerStage[bindings.Length];
} }
@ -81,7 +80,6 @@ namespace Ryujinx.Graphics.Gpu.Image
public void SetImages(int stage, TextureBindingInfo[] bindings) public void SetImages(int stage, TextureBindingInfo[] bindings)
{ {
_imageBindings[stage] = bindings; _imageBindings[stage] = bindings;
_imageState[stage] = new TextureStatePerStage[bindings.Length]; _imageState[stage] = new TextureStatePerStage[bindings.Length];
} }
@ -201,7 +199,7 @@ namespace Ryujinx.Graphics.Gpu.Image
} }
else else
{ {
packedId = ReadPackedId(stageIndex, binding.Handle); packedId = ReadPackedId(stageIndex, binding.Handle, _textureBufferIndex);
} }
int textureId = UnpackTextureId(packedId); int textureId = UnpackTextureId(packedId);
@ -227,6 +225,14 @@ namespace Ryujinx.Graphics.Gpu.Image
_context.Renderer.Pipeline.SetTexture(index, stage, hostTexture); _context.Renderer.Pipeline.SetTexture(index, stage, hostTexture);
} }
if (hostTexture != null && texture.Info.Target == Target.TextureBuffer)
{
// Ensure that the buffer texture is using the correct buffer as storage.
// Buffers are frequently re-created to accomodate larger data, so we need to re-bind
// to ensure we're not using a old buffer that was already deleted.
_context.Methods.BufferManager.SetBufferTextureStorage(hostTexture, texture.Address, texture.Size, _isCompute);
}
Sampler sampler = _samplerPool.Get(samplerId); Sampler sampler = _samplerPool.Get(samplerId);
ISampler hostSampler = sampler?.HostSampler; ISampler hostSampler = sampler?.HostSampler;
@ -258,8 +264,7 @@ namespace Ryujinx.Graphics.Gpu.Image
{ {
TextureBindingInfo binding = _imageBindings[stageIndex][index]; TextureBindingInfo binding = _imageBindings[stageIndex][index];
int packedId = ReadPackedId(stageIndex, binding.Handle); int packedId = ReadPackedId(stageIndex, binding.Handle, _textureBufferIndex);
int textureId = UnpackTextureId(packedId); int textureId = UnpackTextureId(packedId);
Texture texture = pool.Get(textureId); Texture texture = pool.Get(textureId);
@ -284,8 +289,7 @@ namespace Ryujinx.Graphics.Gpu.Image
/// <returns>The texture descriptor for the specified texture</returns> /// <returns>The texture descriptor for the specified texture</returns>
public TextureDescriptor GetTextureDescriptor(GpuState state, int stageIndex, int handle) public TextureDescriptor GetTextureDescriptor(GpuState state, int stageIndex, int handle)
{ {
int packedId = ReadPackedId(stageIndex, handle); int packedId = ReadPackedId(stageIndex, handle, state.Get<int>(MethodOffset.TextureBufferIndex));
int textureId = UnpackTextureId(packedId); int textureId = UnpackTextureId(packedId);
var poolState = state.Get<PoolState>(MethodOffset.TexturePoolState); var poolState = state.Get<PoolState>(MethodOffset.TexturePoolState);
@ -303,8 +307,9 @@ namespace Ryujinx.Graphics.Gpu.Image
/// </summary> /// </summary>
/// <param name="stageIndex">The number of the shader stage where the texture is bound</param> /// <param name="stageIndex">The number of the shader stage where the texture is bound</param>
/// <param name="wordOffset">A word offset of the handle on the buffer (the "fake" shader handle)</param> /// <param name="wordOffset">A word offset of the handle on the buffer (the "fake" shader handle)</param>
/// <param name="textureBufferIndex">Index of the constant buffer holding the texture handles</param>
/// <returns>The packed texture and sampler ID (the real texture handle)</returns> /// <returns>The packed texture and sampler ID (the real texture handle)</returns>
private int ReadPackedId(int stageIndex, int wordOffset) private int ReadPackedId(int stageIndex, int wordOffset, int textureBufferIndex)
{ {
ulong address; ulong address;
@ -312,11 +317,11 @@ namespace Ryujinx.Graphics.Gpu.Image
if (_isCompute) if (_isCompute)
{ {
address = bufferManager.GetComputeUniformBufferAddress(_textureBufferIndex); address = bufferManager.GetComputeUniformBufferAddress(textureBufferIndex);
} }
else else
{ {
address = bufferManager.GetGraphicsUniformBufferAddress(stageIndex, _textureBufferIndex); address = bufferManager.GetGraphicsUniformBufferAddress(stageIndex, textureBufferIndex);
} }
address += (uint)wordOffset * 4; address += (uint)wordOffset * 4;

View file

@ -489,7 +489,11 @@ namespace Ryujinx.Graphics.Gpu.Image
// Calculate texture sizes, used to find all overlapping textures. // Calculate texture sizes, used to find all overlapping textures.
SizeInfo sizeInfo; SizeInfo sizeInfo;
if (info.IsLinear) if (info.Target == Target.TextureBuffer)
{
sizeInfo = new SizeInfo(info.Width * info.FormatInfo.BytesPerPixel);
}
else if (info.IsLinear)
{ {
sizeInfo = SizeCalculator.GetLinearTextureSize( sizeInfo = SizeCalculator.GetLinearTextureSize(
info.Stride, info.Stride,

View file

@ -273,6 +273,19 @@ namespace Ryujinx.Graphics.Gpu.Memory
return 0; return 0;
} }
CreateBuffer(address, size);
return address;
}
/// <summary>
/// Creates a new buffer for the specified range, if it does not yet exist.
/// This can be used to ensure the existance of a buffer.
/// </summary>
/// <param name="address">Address of the buffer in memory</param>
/// <param name="size">Size of the buffer in bytes</param>
public void CreateBuffer(ulong address, ulong size)
{
ulong endAddress = address + size; ulong endAddress = address + size;
ulong alignedAddress = address & ~BufferAlignmentMask; ulong alignedAddress = address & ~BufferAlignmentMask;
@ -285,9 +298,7 @@ namespace Ryujinx.Graphics.Gpu.Memory
alignedEndAddress += BufferAlignmentSize; alignedEndAddress += BufferAlignmentSize;
} }
CreateBuffer(alignedAddress, alignedEndAddress - alignedAddress); CreateBufferAligned(alignedAddress, alignedEndAddress - alignedAddress);
return address;
} }
/// <summary> /// <summary>
@ -297,7 +308,7 @@ namespace Ryujinx.Graphics.Gpu.Memory
/// </summary> /// </summary>
/// <param name="address">Address of the buffer in guest memory</param> /// <param name="address">Address of the buffer in guest memory</param>
/// <param name="size">Size in bytes of the buffer</param> /// <param name="size">Size in bytes of the buffer</param>
private void CreateBuffer(ulong address, ulong size) private void CreateBufferAligned(ulong address, ulong size)
{ {
int overlapsCount = _buffers.FindOverlapsNonOverlapping(address, size, ref _bufferOverlaps); int overlapsCount = _buffers.FindOverlapsNonOverlapping(address, size, ref _bufferOverlaps);
@ -339,6 +350,7 @@ namespace Ryujinx.Graphics.Gpu.Memory
buffer.Dispose(); buffer.Dispose();
} }
// Existing buffers were modified, we need to rebind everything.
_rebind = true; _rebind = true;
} }
} }
@ -441,7 +453,7 @@ namespace Ryujinx.Graphics.Gpu.Memory
/// Ensures that the graphics engine bindings are visible to the host GPU. /// Ensures that the graphics engine bindings are visible to the host GPU.
/// Note: this actually performs the binding using the host graphics API. /// Note: this actually performs the binding using the host graphics API.
/// </summary> /// </summary>
public void CommitBindings() public void CommitGraphicsBindings()
{ {
if (_indexBufferDirty || _rebind) if (_indexBufferDirty || _rebind)
{ {
@ -606,6 +618,34 @@ namespace Ryujinx.Graphics.Gpu.Memory
} }
} }
/// <summary>
/// Sets the buffer storage of a buffer texture.
/// </summary>
/// <param name="texture">Buffer texture</param>
/// <param name="address">Address of the buffer in memory</param>
/// <param name="size">Size of the buffer in bytes</param>
/// <param name="compute">Indicates if the buffer texture belongs to the compute or graphics pipeline</param>
public void SetBufferTextureStorage(ITexture texture, ulong address, ulong size, bool compute)
{
CreateBuffer(address, size);
if (_rebind)
{
// We probably had to modify existing buffers to create the texture buffer,
// so rebind everything to ensure we're using the new buffers for all bound resources.
if (compute)
{
CommitComputeBindings();
}
else
{
CommitGraphicsBindings();
}
}
texture.SetStorage(GetBufferRange(address, size));
}
/// <summary> /// <summary>
/// Copy a buffer data from a given address to another. /// Copy a buffer data from a given address to another.
/// </summary> /// </summary>

View file

@ -280,8 +280,12 @@ namespace Ryujinx.Graphics.Gpu.Shader
=> localMemorySize, => localMemorySize,
QueryInfoName.ComputeSharedMemorySize QueryInfoName.ComputeSharedMemorySize
=> sharedMemorySize, => sharedMemorySize,
QueryInfoName.IsTextureBuffer
=> Convert.ToInt32(QueryIsTextureBuffer(state, 0, index, compute: true)),
QueryInfoName.IsTextureRectangle
=> Convert.ToInt32(QueryIsTextureRectangle(state, 0, index, compute: true)),
QueryInfoName.TextureFormat QueryInfoName.TextureFormat
=> (int)QueryComputeTextureFormat(state, index), => (int)QueryTextureFormat(state, 0, index, compute: true),
_ _
=> QueryInfoCommon(info) => QueryInfoCommon(info)
}; };
@ -331,13 +335,13 @@ namespace Ryujinx.Graphics.Gpu.Shader
return info switch return info switch
{ {
QueryInfoName.IsTextureBuffer QueryInfoName.IsTextureBuffer
=> Convert.ToInt32(QueryIsTextureBuffer(state, (int)stage - 1, index)), => Convert.ToInt32(QueryIsTextureBuffer(state, (int)stage - 1, index, compute: false)),
QueryInfoName.IsTextureRectangle QueryInfoName.IsTextureRectangle
=> Convert.ToInt32(QueryIsTextureRectangle(state, (int)stage - 1, index)), => Convert.ToInt32(QueryIsTextureRectangle(state, (int)stage - 1, index, compute: false)),
QueryInfoName.PrimitiveTopology QueryInfoName.PrimitiveTopology
=> (int)QueryPrimitiveTopology(), => (int)QueryPrimitiveTopology(),
QueryInfoName.TextureFormat QueryInfoName.TextureFormat
=> (int)QueryGraphicsTextureFormat(state, (int)stage - 1, index), => (int)QueryTextureFormat(state, (int)stage - 1, index, compute: false),
_ _
=> QueryInfoCommon(info) => QueryInfoCommon(info)
}; };
@ -429,11 +433,12 @@ namespace Ryujinx.Graphics.Gpu.Shader
/// </summary> /// </summary>
/// <param name="state">Current GPU state</param> /// <param name="state">Current GPU state</param>
/// <param name="stageIndex">Index of the shader stage</param> /// <param name="stageIndex">Index of the shader stage</param>
/// <param name="index">Index of the texture (this is the shader "fake" handle)</param> /// <param name="handle">Index of the texture (this is the shader "fake" handle)</param>
/// <param name="compute">Indicates whenever the texture descriptor is for the compute or graphics engine</param>
/// <returns>True if the texture is a buffer texture, false otherwise</returns> /// <returns>True if the texture is a buffer texture, false otherwise</returns>
private bool QueryIsTextureBuffer(GpuState state, int stageIndex, int index) private bool QueryIsTextureBuffer(GpuState state, int stageIndex, int handle, bool compute)
{ {
return GetGraphicsTextureDescriptor(state, stageIndex, index).UnpackTextureTarget() == TextureTarget.TextureBuffer; return GetTextureDescriptor(state, stageIndex, handle, compute).UnpackTextureTarget() == TextureTarget.TextureBuffer;
} }
/// <summary> /// <summary>
@ -443,11 +448,12 @@ namespace Ryujinx.Graphics.Gpu.Shader
/// </summary> /// </summary>
/// <param name="state">Current GPU state</param> /// <param name="state">Current GPU state</param>
/// <param name="stageIndex">Index of the shader stage</param> /// <param name="stageIndex">Index of the shader stage</param>
/// <param name="index">Index of the texture (this is the shader "fake" handle)</param> /// <param name="handle">Index of the texture (this is the shader "fake" handle)</param>
/// <param name="compute">Indicates whenever the texture descriptor is for the compute or graphics engine</param>
/// <returns>True if the texture is a rectangle texture, false otherwise</returns> /// <returns>True if the texture is a rectangle texture, false otherwise</returns>
private bool QueryIsTextureRectangle(GpuState state, int stageIndex, int index) private bool QueryIsTextureRectangle(GpuState state, int stageIndex, int handle, bool compute)
{ {
var descriptor = GetGraphicsTextureDescriptor(state, stageIndex, index); var descriptor = GetTextureDescriptor(state, stageIndex, handle, compute);
TextureTarget target = descriptor.UnpackTextureTarget(); TextureTarget target = descriptor.UnpackTextureTarget();
@ -461,23 +467,13 @@ namespace Ryujinx.Graphics.Gpu.Shader
/// Queries the format of a given texture. /// Queries the format of a given texture.
/// </summary> /// </summary>
/// <param name="state">Current GPU state</param> /// <param name="state">Current GPU state</param>
/// <param name="index">Index of the texture (this is the shader "fake" handle)</param> /// <param name="stageIndex">Index of the shader stage. This is ignored if <paramref name="compute"/> is true</param>
/// <param name="handle">Index of the texture (this is the shader "fake" handle)</param>
/// <param name="compute">Indicates whenever the texture descriptor is for the compute or graphics engine</param>
/// <returns>The texture format</returns> /// <returns>The texture format</returns>
private TextureFormat QueryComputeTextureFormat(GpuState state, int index) private TextureFormat QueryTextureFormat(GpuState state, int stageIndex, int handle, bool compute)
{ {
return QueryTextureFormat(GetComputeTextureDescriptor(state, index)); return QueryTextureFormat(GetTextureDescriptor(state, stageIndex, handle, compute));
}
/// <summary>
/// Queries the format of a given texture.
/// </summary>
/// <param name="state">Current GPU state</param>
/// <param name="stageIndex">Index of the shader stage</param>
/// <param name="index">Index of the texture (this is the shader "fake" handle)</param>
/// <returns>The texture format</returns>
private TextureFormat QueryGraphicsTextureFormat(GpuState state, int stageIndex, int index)
{
return QueryTextureFormat(GetGraphicsTextureDescriptor(state, stageIndex, index));
} }
/// <summary> /// <summary>
@ -541,23 +537,20 @@ namespace Ryujinx.Graphics.Gpu.Shader
/// Gets the texture descriptor for a given texture on the pool. /// Gets the texture descriptor for a given texture on the pool.
/// </summary> /// </summary>
/// <param name="state">Current GPU state</param> /// <param name="state">Current GPU state</param>
/// <param name="stageIndex">Index of the shader stage. This is ignored if <paramref name="compute"/> is true</param>
/// <param name="handle">Index of the texture (this is the shader "fake" handle)</param> /// <param name="handle">Index of the texture (this is the shader "fake" handle)</param>
/// <param name="compute">Indicates whenever the texture descriptor is for the compute or graphics engine</param>
/// <returns>Texture descriptor</returns> /// <returns>Texture descriptor</returns>
private TextureDescriptor GetComputeTextureDescriptor(GpuState state, int handle) private TextureDescriptor GetTextureDescriptor(GpuState state, int stageIndex, int handle, bool compute)
{ {
return _context.Methods.TextureManager.GetComputeTextureDescriptor(state, handle); if (compute)
} {
return _context.Methods.TextureManager.GetComputeTextureDescriptor(state, handle);
/// <summary> }
/// Gets the texture descriptor for a given texture on the pool. else
/// </summary> {
/// <param name="state">Current GPU state</param> return _context.Methods.TextureManager.GetGraphicsTextureDescriptor(state, stageIndex, handle);
/// <param name="stageIndex">Index of the shader stage</param> }
/// <param name="handle">Index of the texture (this is the shader "fake" handle)</param>
/// <returns>Texture descriptor</returns>
private TextureDescriptor GetGraphicsTextureDescriptor(GpuState state, int stageIndex, int handle)
{
return _context.Methods.TextureManager.GetGraphicsTextureDescriptor(state, stageIndex, handle);
} }
/// <summary> /// <summary>

View file

@ -26,7 +26,7 @@ namespace Ryujinx.Graphics.OpenGL
private bool _depthTest; private bool _depthTest;
private bool _hasDepthBuffer; private bool _hasDepthBuffer;
private TextureView _unit0Texture; private TextureBase _unit0Texture;
private ClipOrigin _clipOrigin; private ClipOrigin _clipOrigin;
private ClipDepthMode _clipDepthMode; private ClipDepthMode _clipDepthMode;
@ -616,13 +616,13 @@ namespace Ryujinx.Graphics.OpenGL
if (unit != -1 && texture != null) if (unit != -1 && texture != null)
{ {
TextureView view = (TextureView)texture; TextureBase texBase = (TextureBase)texture;
FormatInfo formatInfo = FormatTable.GetFormatInfo(view.Format); FormatInfo formatInfo = FormatTable.GetFormatInfo(texBase.Format);
SizedInternalFormat format = (SizedInternalFormat)formatInfo.PixelInternalFormat; SizedInternalFormat format = (SizedInternalFormat)formatInfo.PixelInternalFormat;
GL.BindImageTexture(unit, view.Handle, 0, true, 0, TextureAccess.ReadWrite, format); GL.BindImageTexture(unit, texBase.Handle, 0, true, 0, TextureAccess.ReadWrite, format);
} }
} }
@ -801,11 +801,11 @@ namespace Ryujinx.Graphics.OpenGL
{ {
if (unit == 0) if (unit == 0)
{ {
_unit0Texture = ((TextureView)texture); _unit0Texture = (TextureBase)texture;
} }
else else
{ {
((TextureView)texture).Bind(unit); ((TextureBase)texture).Bind(unit);
} }
} }
} }

View file

@ -20,19 +20,14 @@ namespace Ryujinx.Graphics.OpenGL
internal TextureCopy TextureCopy { get; } internal TextureCopy TextureCopy { get; }
public string GpuVendor { get; private set; } public string GpuVendor { get; private set; }
public string GpuRenderer { get; private set; } public string GpuRenderer { get; private set; }
public string GpuVersion { get; private set; } public string GpuVersion { get; private set; }
public Renderer() public Renderer()
{ {
_pipeline = new Pipeline(); _pipeline = new Pipeline();
_counters = new Counters(); _counters = new Counters();
_window = new Window(this); _window = new Window(this);
TextureCopy = new TextureCopy(this); TextureCopy = new TextureCopy(this);
} }
@ -58,7 +53,7 @@ namespace Ryujinx.Graphics.OpenGL
public ITexture CreateTexture(TextureCreateInfo info) public ITexture CreateTexture(TextureCreateInfo info)
{ {
return new TextureStorage(this, info).CreateDefaultView(); return info.Target == Target.TextureBuffer ? new TextureBuffer(info) : new TextureStorage(this, info).CreateDefaultView();
} }
public Capabilities GetCapabilities() public Capabilities GetCapabilities()

View file

@ -0,0 +1,39 @@
using OpenTK.Graphics.OpenGL;
using Ryujinx.Graphics.GAL;
using System;
using System.Collections.Generic;
using System.Text;
namespace Ryujinx.Graphics.OpenGL
{
class TextureBase
{
public int Handle { get; protected set; }
protected TextureCreateInfo Info { get; }
public int Width => Info.Width;
public int Height => Info.Height;
public Target Target => Info.Target;
public Format Format => Info.Format;
public TextureBase(TextureCreateInfo info)
{
Info = info;
Handle = GL.GenTexture();
}
public void Bind(int unit)
{
Bind(Target.Convert(), unit);
}
protected void Bind(TextureTarget target, int unit)
{
GL.ActiveTexture(TextureUnit.Texture0 + unit);
GL.BindTexture(target, Handle);
}
}
}

View file

@ -0,0 +1,71 @@
using OpenTK.Graphics.OpenGL;
using Ryujinx.Graphics.GAL;
using System;
namespace Ryujinx.Graphics.OpenGL
{
class TextureBuffer : TextureBase, ITexture
{
private int _bufferOffset;
private int _bufferSize;
private Buffer _buffer;
public TextureBuffer(TextureCreateInfo info) : base(info) {}
public void CopyTo(ITexture destination, int firstLayer, int firstLevel)
{
throw new NotSupportedException();
}
public void CopyTo(ITexture destination, Extents2D srcRegion, Extents2D dstRegion, bool linearFilter)
{
throw new NotSupportedException();
}
public ITexture CreateView(TextureCreateInfo info, int firstLayer, int firstLevel)
{
throw new NotSupportedException();
}
public byte[] GetData()
{
return _buffer?.GetData(_bufferOffset, _bufferSize);
}
public void SetData(ReadOnlySpan<byte> data)
{
_buffer?.SetData(_bufferOffset, data.Slice(0, Math.Min(data.Length, _bufferSize)));
}
public void SetStorage(BufferRange buffer)
{
if (buffer.Buffer == _buffer &&
buffer.Offset == _bufferOffset &&
buffer.Size == _bufferSize)
{
return;
}
_buffer = (Buffer)buffer.Buffer;
_bufferOffset = buffer.Offset;
_bufferSize = buffer.Size;
Bind(0);
SizedInternalFormat format = (SizedInternalFormat)FormatTable.GetFormatInfo(Info.Format).PixelInternalFormat;
GL.TexBufferRange(TextureBufferTarget.TextureBuffer, format, _buffer.Handle, (IntPtr)buffer.Offset, buffer.Size);
}
public void Dispose()
{
if (Handle != 0)
{
GL.DeleteTexture(Handle);
Handle = 0;
}
}
}
}

View file

@ -4,10 +4,8 @@ using System;
namespace Ryujinx.Graphics.OpenGL namespace Ryujinx.Graphics.OpenGL
{ {
class TextureView : ITexture class TextureView : TextureBase, ITexture
{ {
public int Handle { get; private set; }
private readonly Renderer _renderer; private readonly Renderer _renderer;
private readonly TextureStorage _parent; private readonly TextureStorage _parent;
@ -16,33 +14,22 @@ namespace Ryujinx.Graphics.OpenGL
private TextureView _incompatibleFormatView; private TextureView _incompatibleFormatView;
private readonly TextureCreateInfo _info;
public int FirstLayer { get; private set; } public int FirstLayer { get; private set; }
public int FirstLevel { get; private set; } public int FirstLevel { get; private set; }
public int Width => _info.Width;
public int Height => _info.Height;
public Target Target => _info.Target;
public Format Format => _info.Format;
public TextureView( public TextureView(
Renderer renderer, Renderer renderer,
TextureStorage parent, TextureStorage parent,
TextureCreateInfo info, TextureCreateInfo info,
int firstLayer, int firstLayer,
int firstLevel) int firstLevel) : base(info)
{ {
_renderer = renderer; _renderer = renderer;
_parent = parent; _parent = parent;
_info = info;
FirstLayer = firstLayer; FirstLayer = firstLayer;
FirstLevel = firstLevel; FirstLevel = firstLevel;
Handle = GL.GenTexture();
CreateView(); CreateView();
} }
@ -50,7 +37,7 @@ namespace Ryujinx.Graphics.OpenGL
{ {
TextureTarget target = Target.Convert(); TextureTarget target = Target.Convert();
FormatInfo format = FormatTable.GetFormatInfo(_info.Format); FormatInfo format = FormatTable.GetFormatInfo(Info.Format);
PixelInternalFormat pixelInternalFormat; PixelInternalFormat pixelInternalFormat;
@ -69,9 +56,9 @@ namespace Ryujinx.Graphics.OpenGL
_parent.Handle, _parent.Handle,
pixelInternalFormat, pixelInternalFormat,
FirstLevel, FirstLevel,
_info.Levels, Info.Levels,
FirstLayer, FirstLayer,
_info.GetLayers()); Info.GetLayers());
GL.ActiveTexture(TextureUnit.Texture0); GL.ActiveTexture(TextureUnit.Texture0);
@ -79,15 +66,15 @@ namespace Ryujinx.Graphics.OpenGL
int[] swizzleRgba = new int[] int[] swizzleRgba = new int[]
{ {
(int)_info.SwizzleR.Convert(), (int)Info.SwizzleR.Convert(),
(int)_info.SwizzleG.Convert(), (int)Info.SwizzleG.Convert(),
(int)_info.SwizzleB.Convert(), (int)Info.SwizzleB.Convert(),
(int)_info.SwizzleA.Convert() (int)Info.SwizzleA.Convert()
}; };
GL.TexParameter(target, TextureParameterName.TextureSwizzleRgba, swizzleRgba); GL.TexParameter(target, TextureParameterName.TextureSwizzleRgba, swizzleRgba);
int maxLevel = _info.Levels - 1; int maxLevel = Info.Levels - 1;
if (maxLevel < 0) if (maxLevel < 0)
{ {
@ -95,12 +82,12 @@ namespace Ryujinx.Graphics.OpenGL
} }
GL.TexParameter(target, TextureParameterName.TextureMaxLevel, maxLevel); GL.TexParameter(target, TextureParameterName.TextureMaxLevel, maxLevel);
GL.TexParameter(target, TextureParameterName.DepthStencilTextureMode, (int)_info.DepthStencilMode.Convert()); GL.TexParameter(target, TextureParameterName.DepthStencilTextureMode, (int)Info.DepthStencilMode.Convert());
} }
public ITexture CreateView(TextureCreateInfo info, int firstLayer, int firstLevel) public ITexture CreateView(TextureCreateInfo info, int firstLayer, int firstLevel)
{ {
if (_info.IsCompressed == info.IsCompressed) if (Info.IsCompressed == info.IsCompressed)
{ {
firstLayer += FirstLayer; firstLayer += FirstLayer;
firstLevel += FirstLevel; firstLevel += FirstLevel;
@ -135,10 +122,10 @@ namespace Ryujinx.Graphics.OpenGL
{ {
if (_incompatibleFormatView == null) if (_incompatibleFormatView == null)
{ {
_incompatibleFormatView = (TextureView)_renderer.CreateTexture(_info); _incompatibleFormatView = (TextureView)_renderer.CreateTexture(Info);
} }
TextureCopyUnscaled.Copy(_parent.Info, _incompatibleFormatView._info, _parent.Handle, _incompatibleFormatView.Handle, FirstLayer, 0, FirstLevel, 0); TextureCopyUnscaled.Copy(_parent.Info, _incompatibleFormatView.Info, _parent.Handle, _incompatibleFormatView.Handle, FirstLayer, 0, FirstLevel, 0);
return _incompatibleFormatView.Handle; return _incompatibleFormatView.Handle;
} }
@ -150,7 +137,7 @@ namespace Ryujinx.Graphics.OpenGL
{ {
if (_incompatibleFormatView != null) if (_incompatibleFormatView != null)
{ {
TextureCopyUnscaled.Copy(_incompatibleFormatView._info, _parent.Info, _incompatibleFormatView.Handle, _parent.Handle, 0, FirstLayer, 0, FirstLevel); TextureCopyUnscaled.Copy(_incompatibleFormatView.Info, _parent.Info, _incompatibleFormatView.Handle, _parent.Handle, 0, FirstLayer, 0, FirstLevel);
} }
} }
@ -158,13 +145,13 @@ namespace Ryujinx.Graphics.OpenGL
{ {
TextureView destinationView = (TextureView)destination; TextureView destinationView = (TextureView)destination;
TextureCopyUnscaled.Copy(_info, destinationView._info, Handle, destinationView.Handle, 0, firstLayer, 0, firstLevel); TextureCopyUnscaled.Copy(Info, destinationView.Info, Handle, destinationView.Handle, 0, firstLayer, 0, firstLevel);
if (destinationView._emulatedViewParent != null) if (destinationView._emulatedViewParent != null)
{ {
TextureCopyUnscaled.Copy( TextureCopyUnscaled.Copy(
_info, Info,
destinationView._emulatedViewParent._info, destinationView._emulatedViewParent.Info,
Handle, Handle,
destinationView._emulatedViewParent.Handle, destinationView._emulatedViewParent.Handle,
0, 0,
@ -183,9 +170,9 @@ namespace Ryujinx.Graphics.OpenGL
{ {
int size = 0; int size = 0;
for (int level = 0; level < _info.Levels; level++) for (int level = 0; level < Info.Levels; level++)
{ {
size += _info.GetMipSize(level); size += Info.GetMipSize(level);
} }
byte[] data = new byte[size]; byte[] data = new byte[size];
@ -207,7 +194,7 @@ namespace Ryujinx.Graphics.OpenGL
Bind(target, 0); Bind(target, 0);
FormatInfo format = FormatTable.GetFormatInfo(_info.Format); FormatInfo format = FormatTable.GetFormatInfo(Info.Format);
int faces = 1; int faces = 1;
@ -218,11 +205,11 @@ namespace Ryujinx.Graphics.OpenGL
faces = 6; faces = 6;
} }
for (int level = 0; level < _info.Levels; level++) for (int level = 0; level < Info.Levels; level++)
{ {
for (int face = 0; face < faces; face++) for (int face = 0; face < faces; face++)
{ {
int faceOffset = face * _info.GetMipSize2D(level); int faceOffset = face * Info.GetMipSize2D(level);
if (format.IsCompressed) if (format.IsCompressed)
{ {
@ -239,7 +226,7 @@ namespace Ryujinx.Graphics.OpenGL
} }
} }
ptr += _info.GetMipSize(level); ptr += Info.GetMipSize(level);
} }
} }
@ -260,17 +247,17 @@ namespace Ryujinx.Graphics.OpenGL
Bind(target, 0); Bind(target, 0);
FormatInfo format = FormatTable.GetFormatInfo(_info.Format); FormatInfo format = FormatTable.GetFormatInfo(Info.Format);
int width = _info.Width; int width = Info.Width;
int height = _info.Height; int height = Info.Height;
int depth = _info.Depth; int depth = Info.Depth;
int offset = 0; int offset = 0;
for (int level = 0; level < _info.Levels; level++) for (int level = 0; level < Info.Levels; level++)
{ {
int mipSize = _info.GetMipSize(level); int mipSize = Info.GetMipSize(level);
int endOffset = offset + mipSize; int endOffset = offset + mipSize;
@ -279,7 +266,7 @@ namespace Ryujinx.Graphics.OpenGL
return; return;
} }
switch (_info.Target) switch (Info.Target)
{ {
case Target.Texture1D: case Target.Texture1D:
if (format.IsCompressed) if (format.IsCompressed)
@ -419,16 +406,9 @@ namespace Ryujinx.Graphics.OpenGL
} }
} }
public void Bind(int unit) public void SetStorage(BufferRange buffer)
{ {
Bind(Target.Convert(), unit); throw new NotSupportedException();
}
private void Bind(TextureTarget target, int unit)
{
GL.ActiveTexture(TextureUnit.Texture0 + unit);
GL.BindTexture(target, Handle);
} }
public void Dispose() public void Dispose()

View file

@ -166,7 +166,7 @@ namespace Ryujinx.Graphics.Shader.Decoders
Set("000101xxxxxxxx", InstEmit.Iscadd, typeof(OpCodeAluImm32)); Set("000101xxxxxxxx", InstEmit.Iscadd, typeof(OpCodeAluImm32));
Set("0101110000011x", InstEmit.Iscadd, typeof(OpCodeAluReg)); Set("0101110000011x", InstEmit.Iscadd, typeof(OpCodeAluReg));
Set("010010110101xx", InstEmit.Iset, typeof(OpCodeSetCbuf)); Set("010010110101xx", InstEmit.Iset, typeof(OpCodeSetCbuf));
Set("001101100101xx", InstEmit.Iset, typeof(OpCodeSetImm)); Set("0011011x0101xx", InstEmit.Iset, typeof(OpCodeSetImm));
Set("010110110101xx", InstEmit.Iset, typeof(OpCodeSetReg)); Set("010110110101xx", InstEmit.Iset, typeof(OpCodeSetReg));
Set("010010110110xx", InstEmit.Isetp, typeof(OpCodeSetCbuf)); Set("010010110110xx", InstEmit.Isetp, typeof(OpCodeSetCbuf));
Set("0011011x0110xx", InstEmit.Isetp, typeof(OpCodeSetImm)); Set("0011011x0110xx", InstEmit.Isetp, typeof(OpCodeSetImm));

View file

@ -376,6 +376,7 @@ namespace Ryujinx.Graphics.Shader.Instructions
{ {
case TextureTarget.Texture1DLodZero: case TextureTarget.Texture1DLodZero:
sourcesList.Add(Ra()); sourcesList.Add(Ra());
sourcesList.Add(ConstF(0));
break; break;
case TextureTarget.Texture2D: case TextureTarget.Texture2D:
@ -429,11 +430,21 @@ namespace Ryujinx.Graphics.Shader.Instructions
flags = ConvertTextureFlags(tldsOp.Target) | TextureFlags.IntCoords; flags = ConvertTextureFlags(tldsOp.Target) | TextureFlags.IntCoords;
if (tldsOp.Target == TexelLoadTarget.Texture1DLodZero && context.Config.QueryInfoBool(QueryInfoName.IsTextureBuffer, tldsOp.Immediate))
{
type = SamplerType.TextureBuffer;
flags &= ~TextureFlags.LodLevel;
}
switch (tldsOp.Target) switch (tldsOp.Target)
{ {
case TexelLoadTarget.Texture1DLodZero: case TexelLoadTarget.Texture1DLodZero:
sourcesList.Add(Ra()); sourcesList.Add(Ra());
sourcesList.Add(Const(0));
if (type != SamplerType.TextureBuffer)
{
sourcesList.Add(Const(0));
}
break; break;
case TexelLoadTarget.Texture1DLodLevel: case TexelLoadTarget.Texture1DLodLevel:
@ -615,8 +626,7 @@ namespace Ryujinx.Graphics.Shader.Instructions
List<Operand> sourcesList = new List<Operand>(); List<Operand> sourcesList = new List<Operand>();
SamplerType type = ConvertSamplerType(op.Dimensions); SamplerType type = ConvertSamplerType(op.Dimensions);
TextureFlags flags = TextureFlags.Gather; TextureFlags flags = TextureFlags.Gather;
if (op.Bindless) if (op.Bindless)
@ -1008,6 +1018,16 @@ namespace Ryujinx.Graphics.Shader.Instructions
type |= SamplerType.Multisample; type |= SamplerType.Multisample;
} }
if (type == SamplerType.Texture1D && flags == TextureFlags.IntCoords && !isBindless)
{
bool isTypeBuffer = context.Config.QueryInfoBool(QueryInfoName.IsTextureBuffer, op.Immediate);
if (isTypeBuffer)
{
type = SamplerType.TextureBuffer;
}
}
Operand[] sources = sourcesList.ToArray(); Operand[] sources = sourcesList.ToArray();
int rdIndex = op.Rd.Index; int rdIndex = op.Rd.Index;
@ -1190,7 +1210,7 @@ namespace Ryujinx.Graphics.Shader.Instructions
return SamplerType.None; return SamplerType.None;
} }
private static TextureFlags ConvertTextureFlags(Decoders.TextureTarget type) private static TextureFlags ConvertTextureFlags(TextureTarget type)
{ {
switch (type) switch (type)
{ {

View file

@ -1,19 +1,27 @@
using Ryujinx.Common;
using System; using System;
namespace Ryujinx.Graphics.Texture namespace Ryujinx.Graphics.Texture
{ {
public struct SizeInfo public struct SizeInfo
{ {
private int[] _mipOffsets; private readonly int[] _mipOffsets;
private int[] _allOffsets; private readonly int[] _allOffsets;
private int _levels; private readonly int _levels;
public int LayerSize { get; } public int LayerSize { get; }
public int TotalSize { get; } public int TotalSize { get; }
public SizeInfo( public SizeInfo(int size)
{
_mipOffsets = new int[] { 0 };
_allOffsets = new int[] { 0 };
_levels = 1;
LayerSize = size;
TotalSize = size;
}
internal SizeInfo(
int[] mipOffsets, int[] mipOffsets,
int[] allOffsets, int[] allOffsets,
int levels, int levels,
@ -29,7 +37,7 @@ namespace Ryujinx.Graphics.Texture
public int GetMipOffset(int level) public int GetMipOffset(int level)
{ {
if ((uint)level > _mipOffsets.Length) if ((uint)level >= _mipOffsets.Length)
{ {
throw new ArgumentOutOfRangeException(nameof(level)); throw new ArgumentOutOfRangeException(nameof(level));
} }