Ryujinx/Ryujinx.Graphics.Gpu/Image/Texture.cs

1308 lines
49 KiB
C#
Raw Normal View History

2019-10-13 06:02:07 +00:00
using Ryujinx.Common;
2019-12-28 23:45:33 +00:00
using Ryujinx.Common.Logging;
2019-10-13 06:02:07 +00:00
using Ryujinx.Graphics.GAL;
using Ryujinx.Graphics.Gpu.Memory;
using Ryujinx.Graphics.Texture;
using Ryujinx.Graphics.Texture.Astc;
using System;
using System.Collections.Generic;
using System.Diagnostics;
2019-10-13 06:02:07 +00:00
namespace Ryujinx.Graphics.Gpu.Image
{
/// <summary>
/// Represents a cached GPU texture.
/// </summary>
2019-12-31 22:37:00 +00:00
class Texture : IRange, IDisposable
2019-10-13 06:02:07 +00:00
{
private GpuContext _context;
private SizeInfo _sizeInfo;
/// <summary>
/// Texture format.
/// </summary>
2019-12-29 17:41:50 +00:00
public Format Format => Info.FormatInfo.Format;
2019-10-13 06:02:07 +00:00
/// <summary>
/// Texture information.
/// </summary>
2019-12-29 17:41:50 +00:00
public TextureInfo Info { get; private set; }
2019-10-13 06:02:07 +00:00
/// <summary>
/// Host scale factor.
/// </summary>
public float ScaleFactor { get; private set; }
/// <summary>
/// Upscaling mode. Informs if a texture is scaled, or is eligible for scaling.
/// </summary>
public TextureScaleMode ScaleMode { get; private set; }
2019-10-13 06:02:07 +00:00
private int _depth;
private int _layers;
private int _firstLayer;
private int _firstLevel;
2019-10-13 06:02:07 +00:00
private bool _hasData;
private ITexture _arrayViewTexture;
private Target _arrayViewTarget;
private Texture _viewStorage;
private List<Texture> _views;
/// <summary>
/// Host texture.
/// </summary>
2019-10-13 06:02:07 +00:00
public ITexture HostTexture { get; private set; }
/// <summary>
/// Intrusive linked list node used on the auto deletion texture cache.
/// </summary>
2019-10-13 06:02:07 +00:00
public LinkedListNode<Texture> CacheNode { get; set; }
/// <summary>
/// Event to fire when texture data is modified by the GPU.
/// </summary>
public event Action<Texture> Modified;
/// <summary>
/// Event to fire when texture data is disposed.
/// </summary>
public event Action<Texture> Disposed;
2019-10-13 06:02:07 +00:00
/// <summary>
/// Start address of the texture in guest memory.
/// </summary>
public ulong Address => Info.Address;
/// <summary>
/// End address of the texture in guest memory.
/// </summary>
2019-12-29 17:41:50 +00:00
public ulong EndAddress => Info.Address + Size;
2019-10-13 06:02:07 +00:00
/// <summary>
/// Texture size in bytes.
/// </summary>
2019-10-13 06:02:07 +00:00
public ulong Size => (ulong)_sizeInfo.TotalSize;
private (ulong, ulong)[] _modifiedRanges;
2019-10-13 06:02:07 +00:00
private int _referenceCount;
private int _sequenceNumber;
/// <summary>
/// Constructs a new instance of the cached GPU texture.
/// </summary>
/// <param name="context">GPU context that the texture belongs to</param>
/// <param name="info">Texture information</param>
/// <param name="sizeInfo">Size information of the texture</param>
/// <param name="firstLayer">The first layer of the texture, or 0 if the texture has no parent</param>
/// <param name="firstLevel">The first mipmap level of the texture, or 0 if the texture has no parent</param>
/// <param name="scaleFactor">The floating point scale factor to initialize with</param>
/// <param name="scaleMode">The scale mode to initialize with</param>
2019-10-13 06:02:07 +00:00
private Texture(
GpuContext context,
TextureInfo info,
SizeInfo sizeInfo,
int firstLayer,
int firstLevel,
float scaleFactor,
TextureScaleMode scaleMode)
2019-10-13 06:02:07 +00:00
{
InitializeTexture(context, info, sizeInfo);
_firstLayer = firstLayer;
_firstLevel = firstLevel;
ScaleFactor = scaleFactor;
ScaleMode = scaleMode;
2019-10-13 06:02:07 +00:00
_hasData = true;
}
/// <summary>
/// Constructs a new instance of the cached GPU texture.
/// </summary>
/// <param name="context">GPU context that the texture belongs to</param>
/// <param name="info">Texture information</param>
/// <param name="sizeInfo">Size information of the texture</param>
/// <param name="scaleMode">The scale mode to initialize with. If scaled, the texture's data is loaded immediately and scaled up</param>
public Texture(GpuContext context, TextureInfo info, SizeInfo sizeInfo, TextureScaleMode scaleMode)
2019-10-13 06:02:07 +00:00
{
ScaleFactor = 1f; // Texture is first loaded at scale 1x.
ScaleMode = scaleMode;
2019-10-13 06:02:07 +00:00
InitializeTexture(context, info, sizeInfo);
TextureCreateInfo createInfo = TextureManager.GetCreateInfo(info, context.Capabilities);
HostTexture = _context.Renderer.CreateTexture(createInfo, ScaleFactor);
if (scaleMode == TextureScaleMode.Scaled)
{
SynchronizeMemory(); // Load the data and then scale it up.
SetScale(GraphicsConfig.ResScale);
}
2019-10-13 06:02:07 +00:00
}
/// <summary>
/// Common texture initialization method.
/// This sets the context, info and sizeInfo fields.
/// Other fields are initialized with their default values.
/// </summary>
/// <param name="context">GPU context that the texture belongs to</param>
/// <param name="info">Texture information</param>
/// <param name="sizeInfo">Size information of the texture</param>
2019-10-13 06:02:07 +00:00
private void InitializeTexture(GpuContext context, TextureInfo info, SizeInfo sizeInfo)
{
_context = context;
_sizeInfo = sizeInfo;
_modifiedRanges = new (ulong, ulong)[(sizeInfo.TotalSize / PhysicalMemory.PageSize) + 1];
2019-10-13 06:02:07 +00:00
SetInfo(info);
_viewStorage = this;
_views = new List<Texture>();
}
/// <summary>
/// Create a texture view from this texture.
/// A texture view is defined as a child texture, from a sub-range of their parent texture.
/// For example, the initial layer and mipmap level of the view can be defined, so the texture
/// will start at the given layer/level of the parent texture.
/// </summary>
/// <param name="info">Child texture information</param>
/// <param name="sizeInfo">Child texture size information</param>
/// <param name="firstLayer">Start layer of the child texture on the parent texture</param>
/// <param name="firstLevel">Start mipmap level of the child texture on the parent texture</param>
/// <returns>The child texture</returns>
2019-10-13 06:02:07 +00:00
public Texture CreateView(TextureInfo info, SizeInfo sizeInfo, int firstLayer, int firstLevel)
{
Texture texture = new Texture(
_context,
info,
sizeInfo,
_firstLayer + firstLayer,
_firstLevel + firstLevel,
ScaleFactor,
ScaleMode);
2019-10-13 06:02:07 +00:00
TextureCreateInfo createInfo = TextureManager.GetCreateInfo(info, _context.Capabilities);
texture.HostTexture = HostTexture.CreateView(createInfo, firstLayer, firstLevel);
_viewStorage.AddView(texture);
return texture;
}
/// <summary>
/// Adds a child texture to this texture.
/// </summary>
/// <param name="texture">The child texture</param>
2019-10-13 06:02:07 +00:00
private void AddView(Texture texture)
{
_views.Add(texture);
texture._viewStorage = this;
}
/// <summary>
/// Removes a child texture from this texture.
/// </summary>
/// <param name="texture">The child texture</param>
2019-10-13 06:02:07 +00:00
private void RemoveView(Texture texture)
{
_views.Remove(texture);
texture._viewStorage = null;
DeleteIfNotUsed();
2019-10-13 06:02:07 +00:00
}
/// <summary>
/// Changes the texture size.
2020-01-01 15:39:09 +00:00
/// </summary>
/// <remarks>
/// This operation may also change the size of all mipmap levels, including from the parent
/// and other possible child textures, to ensure that all sizes are consistent.
2020-01-01 15:39:09 +00:00
/// </remarks>
/// <param name="width">The new texture width</param>
/// <param name="height">The new texture height</param>
/// <param name="depthOrLayers">The new texture depth (for 3D textures) or layers (for layered textures)</param>
2019-10-13 06:02:07 +00:00
public void ChangeSize(int width, int height, int depthOrLayers)
{
width <<= _firstLevel;
height <<= _firstLevel;
2019-12-29 17:41:50 +00:00
if (Info.Target == Target.Texture3D)
2019-10-13 06:02:07 +00:00
{
depthOrLayers <<= _firstLevel;
}
else
{
2019-12-29 17:41:50 +00:00
depthOrLayers = _viewStorage.Info.DepthOrLayers;
2019-10-13 06:02:07 +00:00
}
_viewStorage.RecreateStorageOrView(width, height, depthOrLayers);
foreach (Texture view in _viewStorage._views)
{
int viewWidth = Math.Max(1, width >> view._firstLevel);
int viewHeight = Math.Max(1, height >> view._firstLevel);
int viewDepthOrLayers;
2019-12-29 17:41:50 +00:00
if (view.Info.Target == Target.Texture3D)
2019-10-13 06:02:07 +00:00
{
viewDepthOrLayers = Math.Max(1, depthOrLayers >> view._firstLevel);
}
else
{
2019-12-29 17:41:50 +00:00
viewDepthOrLayers = view.Info.DepthOrLayers;
2019-10-13 06:02:07 +00:00
}
view.RecreateStorageOrView(viewWidth, viewHeight, viewDepthOrLayers);
}
}
/// <summary>
/// Recreates the texture storage (or view, in the case of child textures) of this texture.
/// This allows recreating the texture with a new size.
/// A copy is automatically performed from the old to the new texture.
/// </summary>
/// <param name="width">The new texture width</param>
/// <param name="height">The new texture height</param>
/// <param name="depthOrLayers">The new texture depth (for 3D textures) or layers (for layered textures)</param>
2019-10-13 06:02:07 +00:00
private void RecreateStorageOrView(int width, int height, int depthOrLayers)
{
SetInfo(new TextureInfo(
2019-12-29 17:41:50 +00:00
Info.Address,
2019-10-13 06:02:07 +00:00
width,
height,
depthOrLayers,
2019-12-29 17:41:50 +00:00
Info.Levels,
Info.SamplesInX,
Info.SamplesInY,
Info.Stride,
Info.IsLinear,
Info.GobBlocksInY,
Info.GobBlocksInZ,
Info.GobBlocksInTileX,
Info.Target,
Info.FormatInfo,
Info.DepthStencilMode,
Info.SwizzleR,
Info.SwizzleG,
Info.SwizzleB,
Info.SwizzleA));
TextureCreateInfo createInfo = TextureManager.GetCreateInfo(Info, _context.Capabilities);
2019-10-13 06:02:07 +00:00
if (_viewStorage != this)
{
ReplaceStorage(_viewStorage.HostTexture.CreateView(createInfo, _firstLayer, _firstLevel));
}
else
{
ITexture newStorage = _context.Renderer.CreateTexture(createInfo, ScaleFactor);
2019-10-13 06:02:07 +00:00
HostTexture.CopyTo(newStorage, 0, 0);
2019-10-13 06:02:07 +00:00
ReplaceStorage(newStorage);
}
}
/// <summary>
/// Blacklists this texture from being scaled. Resets its scale to 1 if needed.
/// </summary>
public void BlacklistScale()
{
ScaleMode = TextureScaleMode.Blacklisted;
SetScale(1f);
}
/// <summary>
/// Propagates the scale between this texture and another to ensure they have the same scale.
/// If one texture is blacklisted from scaling, the other will become blacklisted too.
/// </summary>
/// <param name="other">The other texture</param>
public void PropagateScale(Texture other)
{
if (other.ScaleMode == TextureScaleMode.Blacklisted || ScaleMode == TextureScaleMode.Blacklisted)
{
BlacklistScale();
other.BlacklistScale();
}
else
{
// Prefer the configured scale if present. If not, prefer the max.
float targetScale = GraphicsConfig.ResScale;
float sharedScale = (ScaleFactor == targetScale || other.ScaleFactor == targetScale) ? targetScale : Math.Max(ScaleFactor, other.ScaleFactor);
SetScale(sharedScale);
other.SetScale(sharedScale);
}
}
/// <summary>
/// Helper method for copying our Texture2DArray texture to the given target, with scaling.
/// This creates temporary views for each array layer on both textures, copying each one at a time.
/// </summary>
/// <param name="target">The texture array to copy to</param>
private void CopyArrayScaled(ITexture target)
{
TextureInfo viewInfo = new TextureInfo(
Info.Address,
Info.Width,
Info.Height,
1,
Info.Levels,
Info.SamplesInX,
Info.SamplesInY,
Info.Stride,
Info.IsLinear,
Info.GobBlocksInY,
Info.GobBlocksInZ,
Info.GobBlocksInTileX,
Target.Texture2D,
Info.FormatInfo,
Info.DepthStencilMode,
Info.SwizzleR,
Info.SwizzleG,
Info.SwizzleB,
Info.SwizzleA);
TextureCreateInfo createInfo = TextureManager.GetCreateInfo(viewInfo, _context.Capabilities);
for (int i = 0; i < Info.DepthOrLayers; i++)
{
ITexture from = HostTexture.CreateView(createInfo, i, 0);
ITexture to = target.CreateView(createInfo, i, 0);
from.CopyTo(to, new Extents2D(0, 0, from.Width, from.Height), new Extents2D(0, 0, to.Width, to.Height), true);
from.Dispose();
to.Dispose();
}
}
/// <summary>
/// Sets the Scale Factor on this texture, and immediately recreates it at the correct size.
/// When a texture is resized, a scaled copy is performed from the old texture to the new one, to ensure no data is lost.
/// If scale is equivalent, this only propagates the blacklisted/scaled mode.
/// If called on a view, its storage is resized instead.
/// When resizing storage, all texture views are recreated.
/// </summary>
/// <param name="scale">The new scale factor for this texture</param>
public void SetScale(float scale)
{
TextureScaleMode newScaleMode = ScaleMode == TextureScaleMode.Blacklisted ? ScaleMode : TextureScaleMode.Scaled;
if (_viewStorage != this)
{
_viewStorage.ScaleMode = newScaleMode;
_viewStorage.SetScale(scale);
return;
}
if (ScaleFactor != scale)
{
Logger.PrintDebug(LogClass.Gpu, $"Rescaling {Info.Width}x{Info.Height} {Info.FormatInfo.Format.ToString()} to ({ScaleFactor} to {scale}). ");
TextureCreateInfo createInfo = TextureManager.GetCreateInfo(Info, _context.Capabilities);
ScaleFactor = scale;
ITexture newStorage = _context.Renderer.CreateTexture(createInfo, ScaleFactor);
if (Info.Target == Target.Texture2DArray)
{
CopyArrayScaled(newStorage);
}
else
{
HostTexture.CopyTo(newStorage, new Extents2D(0, 0, HostTexture.Width, HostTexture.Height), new Extents2D(0, 0, newStorage.Width, newStorage.Height), true);
}
Logger.PrintDebug(LogClass.Gpu, $" Copy performed: {HostTexture.Width}x{HostTexture.Height} to {newStorage.Width}x{newStorage.Height}");
ReplaceStorage(newStorage);
// All views must be recreated against the new storage.
foreach (var view in _views)
{
Logger.PrintDebug(LogClass.Gpu, $" Recreating view {Info.Width}x{Info.Height} {Info.FormatInfo.Format.ToString()}.");
view.ScaleFactor = scale;
TextureCreateInfo viewCreateInfo = TextureManager.GetCreateInfo(view.Info, _context.Capabilities);
ITexture newView = HostTexture.CreateView(viewCreateInfo, view._firstLayer - _firstLayer, view._firstLevel - _firstLevel);
view.ReplaceStorage(newView);
view.ScaleMode = newScaleMode;
}
}
if (ScaleMode != newScaleMode)
{
ScaleMode = newScaleMode;
foreach (var view in _views)
{
view.ScaleMode = newScaleMode;
}
}
}
/// <summary>
/// Synchronizes guest and host memory.
/// This will overwrite the texture data with the texture data on the guest memory, if a CPU
/// modification is detected.
/// Be aware that this can cause texture data written by the GPU to be lost, this is just a
/// one way copy (from CPU owned to GPU owned memory).
/// </summary>
2019-10-13 06:02:07 +00:00
public void SynchronizeMemory()
{
// 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)
2019-10-13 06:02:07 +00:00
{
return;
}
_sequenceNumber = _context.SequenceNumber;
int modifiedCount = _context.PhysicalMemory.QueryModified(Address, Size, ResourceName.Texture, _modifiedRanges);
2019-10-13 06:02:07 +00:00
if (_hasData)
2019-10-13 06:02:07 +00:00
{
if (modifiedCount == 0)
{
return;
}
BlacklistScale();
2019-10-13 06:02:07 +00:00
}
ReadOnlySpan<byte> data = _context.PhysicalMemory.GetSpan(Address, (int)Size);
2019-10-13 06:02:07 +00:00
// If the texture was modified by the host GPU, we do partial invalidation
// of the texture by getting GPU data and merging in the pages of memory
// that were modified.
// Note that if ASTC is not supported by the GPU we can't read it back since
// it will use a different format. Since applications shouldn't be writing
// ASTC textures from the GPU anyway, ignoring it should be safe.
if (_context.Methods.TextureManager.IsTextureModified(this) && !Info.FormatInfo.Format.IsAstc())
{
Span<byte> gpuData = GetTextureDataFromGpu();
ulong endAddress = Address + Size;
for (int i = 0; i < modifiedCount; i++)
{
(ulong modifiedAddress, ulong modifiedSize) = _modifiedRanges[i];
ulong endModifiedAddress = modifiedAddress + modifiedSize;
if (modifiedAddress < Address)
{
modifiedAddress = Address;
}
if (endModifiedAddress > endAddress)
{
endModifiedAddress = endAddress;
}
modifiedSize = endModifiedAddress - modifiedAddress;
int offset = (int)(modifiedAddress - Address);
int length = (int)modifiedSize;
data.Slice(offset, length).CopyTo(gpuData.Slice(offset, length));
}
data = gpuData;
}
data = ConvertToHostCompatibleFormat(data);
HostTexture.SetData(data);
_hasData = true;
}
/// <summary>
/// Converts texture data to a format and layout that is supported by the host GPU.
/// </summary>
/// <param name="data">Data to be converted</param>
/// <returns>Converted data</returns>
private ReadOnlySpan<byte> ConvertToHostCompatibleFormat(ReadOnlySpan<byte> data)
{
2019-12-29 17:41:50 +00:00
if (Info.IsLinear)
2019-10-13 06:02:07 +00:00
{
data = LayoutConverter.ConvertLinearStridedToLinear(
2019-12-29 17:41:50 +00:00
Info.Width,
Info.Height,
Info.FormatInfo.BlockWidth,
Info.FormatInfo.BlockHeight,
Info.Stride,
Info.FormatInfo.BytesPerPixel,
2019-10-13 06:02:07 +00:00
data);
}
else
{
data = LayoutConverter.ConvertBlockLinearToLinear(
2019-12-29 17:41:50 +00:00
Info.Width,
Info.Height,
2019-10-13 06:02:07 +00:00
_depth,
2019-12-29 17:41:50 +00:00
Info.Levels,
2019-10-13 06:02:07 +00:00
_layers,
2019-12-29 17:41:50 +00:00
Info.FormatInfo.BlockWidth,
Info.FormatInfo.BlockHeight,
Info.FormatInfo.BytesPerPixel,
Info.GobBlocksInY,
Info.GobBlocksInZ,
Info.GobBlocksInTileX,
2019-10-13 06:02:07 +00:00
_sizeInfo,
data);
}
2019-12-29 17:41:50 +00:00
if (!_context.Capabilities.SupportsAstcCompression && Info.FormatInfo.Format.IsAstc())
2019-10-13 06:02:07 +00:00
{
if (!AstcDecoder.TryDecodeToRgba8(
data.ToArray(),
2019-12-29 17:41:50 +00:00
Info.FormatInfo.BlockWidth,
Info.FormatInfo.BlockHeight,
Info.Width,
Info.Height,
_depth,
2019-12-29 17:41:50 +00:00
Info.Levels,
out Span<byte> decoded))
{
2019-12-29 17:41:50 +00:00
string texInfo = $"{Info.Target} {Info.FormatInfo.Format} {Info.Width}x{Info.Height}x{Info.DepthOrLayers} levels {Info.Levels}";
2019-12-28 23:45:33 +00:00
Logger.PrintDebug(LogClass.Gpu, $"Invalid ASTC texture at 0x{Info.Address:X} ({texInfo}).");
}
data = decoded;
2019-10-13 06:02:07 +00:00
}
return data;
2019-10-13 06:02:07 +00:00
}
/// <summary>
/// Flushes the texture data.
/// This causes the texture data to be written back to guest memory.
/// If the texture was written by the GPU, this includes all modification made by the GPU
/// up to this point.
/// Be aware that this is an expensive operation, avoid calling it unless strictly needed.
/// This may cause data corruption if the memory is already being used for something else on the CPU side.
/// </summary>
2019-10-13 06:02:07 +00:00
public void Flush()
{
BlacklistScale();
_context.PhysicalMemory.Write(Address, GetTextureDataFromGpu());
}
/// <summary>
/// Gets data from the host GPU.
/// </summary>
/// <remarks>
/// This method should be used to retrieve data that was modified by the host GPU.
/// This is not cheap, avoid doing that unless strictly needed.
/// </remarks>
/// <returns>Host texture data</returns>
private Span<byte> GetTextureDataFromGpu()
2019-10-13 06:02:07 +00:00
{
BlacklistScale();
Span<byte> data = HostTexture.GetData();
2019-12-29 17:41:50 +00:00
if (Info.IsLinear)
{
data = LayoutConverter.ConvertLinearToLinearStrided(
2019-12-29 17:41:50 +00:00
Info.Width,
Info.Height,
Info.FormatInfo.BlockWidth,
Info.FormatInfo.BlockHeight,
Info.Stride,
Info.FormatInfo.BytesPerPixel,
data);
}
else
{
data = LayoutConverter.ConvertLinearToBlockLinear(
2019-12-29 17:41:50 +00:00
Info.Width,
Info.Height,
_depth,
2019-12-29 17:41:50 +00:00
Info.Levels,
_layers,
2019-12-29 17:41:50 +00:00
Info.FormatInfo.BlockWidth,
Info.FormatInfo.BlockHeight,
Info.FormatInfo.BytesPerPixel,
Info.GobBlocksInY,
Info.GobBlocksInZ,
Info.GobBlocksInTileX,
_sizeInfo,
data);
}
2019-10-13 06:02:07 +00:00
return data;
2019-10-13 06:02:07 +00:00
}
/// <summary>
/// Performs a comparison of this texture information, with the specified texture information.
/// This performs a strict comparison, used to check if two textures are equal.
/// </summary>
/// <param name="info">Texture information to compare with</param>
/// <param name="flags">Comparison flags</param>
/// <returns>True if the textures are strictly equal or similar, false otherwise</returns>
2019-10-13 06:02:07 +00:00
public bool IsPerfectMatch(TextureInfo info, TextureSearchFlags flags)
{
if (!FormatMatches(info, (flags & TextureSearchFlags.ForSampler) != 0, (flags & TextureSearchFlags.ForCopy) != 0))
2019-10-13 06:02:07 +00:00
{
return false;
}
if (!LayoutMatches(info))
{
return false;
}
if (!SizeMatches(info, (flags & TextureSearchFlags.Strict) == 0))
{
return false;
}
if ((flags & TextureSearchFlags.ForSampler) != 0 || (flags & TextureSearchFlags.Strict) != 0)
2019-10-13 06:02:07 +00:00
{
if (!SamplerParamsMatches(info))
{
return false;
}
}
if ((flags & TextureSearchFlags.ForCopy) != 0)
2019-10-13 06:02:07 +00:00
{
2019-12-29 17:41:50 +00:00
bool msTargetCompatible = Info.Target == Target.Texture2DMultisample && info.Target == Target.Texture2D;
2019-10-13 06:02:07 +00:00
if (!msTargetCompatible && !TargetAndSamplesCompatible(info))
{
return false;
}
}
else if (!TargetAndSamplesCompatible(info))
{
return false;
}
2019-12-29 17:41:50 +00:00
return Info.Address == info.Address && Info.Levels == info.Levels;
2019-10-13 06:02:07 +00:00
}
/// <summary>
/// Checks if the texture format matches with the specified texture information.
/// </summary>
/// <param name="info">Texture information to compare with</param>
/// <param name="forSampler">Indicates that the texture will be used for shader sampling</param>
/// <param name="forCopy">Indicates that the texture will be used as copy source or target</param>
/// <returns>True if the format matches, with the given comparison rules</returns>
private bool FormatMatches(TextureInfo info, bool forSampler, bool forCopy)
2019-10-13 06:02:07 +00:00
{
// D32F and R32F texture have the same representation internally,
// however the R32F format is used to sample from depth textures.
if (Info.FormatInfo.Format == Format.D32Float && info.FormatInfo.Format == Format.R32Float && (forSampler || forCopy))
2019-10-13 06:02:07 +00:00
{
return true;
}
if (forCopy)
{
// The 2D engine does not support depth-stencil formats, so it will instead
// use equivalent color formats. We must also consider them as compatible.
if (Info.FormatInfo.Format == Format.S8Uint && info.FormatInfo.Format == Format.R8Unorm)
{
return true;
}
if (Info.FormatInfo.Format == Format.D16Unorm && info.FormatInfo.Format == Format.R16Unorm)
{
return true;
}
if ((Info.FormatInfo.Format == Format.D24UnormS8Uint ||
Info.FormatInfo.Format == Format.D24X8Unorm) && info.FormatInfo.Format == Format.B8G8R8A8Unorm)
{
return true;
}
}
2019-12-29 17:41:50 +00:00
return Info.FormatInfo.Format == info.FormatInfo.Format;
2019-10-13 06:02:07 +00:00
}
/// <summary>
/// Checks if the texture layout specified matches with this texture layout.
/// The layout information is composed of the Stride for linear textures, or GOB block size
/// for block linear textures.
/// </summary>
/// <param name="info">Texture information to compare with</param>
/// <returns>True if the layout matches, false otherwise</returns>
2019-10-13 06:02:07 +00:00
private bool LayoutMatches(TextureInfo info)
{
2019-12-29 17:41:50 +00:00
if (Info.IsLinear != info.IsLinear)
2019-10-13 06:02:07 +00:00
{
return false;
}
// For linear textures, gob block sizes are ignored.
// For block linear textures, the stride is ignored.
if (info.IsLinear)
{
2019-12-29 17:41:50 +00:00
return Info.Stride == info.Stride;
2019-10-13 06:02:07 +00:00
}
else
{
2019-12-29 17:41:50 +00:00
return Info.GobBlocksInY == info.GobBlocksInY &&
Info.GobBlocksInZ == info.GobBlocksInZ;
2019-10-13 06:02:07 +00:00
}
}
/// <summary>
/// Checks if the texture sizes of the supplied texture information matches this texture.
/// </summary>
/// <param name="info">Texture information to compare with</param>
/// <returns>True if the size matches, false otherwise</returns>
2019-10-13 06:02:07 +00:00
public bool SizeMatches(TextureInfo info)
{
return SizeMatches(info, alignSizes: false);
}
/// <summary>
/// Checks if the texture sizes of the supplied texture information matches the given level of
/// this texture.
/// </summary>
/// <param name="info">Texture information to compare with</param>
/// <param name="level">Mipmap level of this texture to compare with</param>
/// <returns>True if the size matches with the level, false otherwise</returns>
2019-10-13 06:02:07 +00:00
public bool SizeMatches(TextureInfo info, int level)
{
2019-12-29 17:41:50 +00:00
return Math.Max(1, Info.Width >> level) == info.Width &&
Math.Max(1, Info.Height >> level) == info.Height &&
Math.Max(1, Info.GetDepth() >> level) == info.GetDepth();
2019-10-13 06:02:07 +00:00
}
/// <summary>
/// Checks if the texture sizes of the supplied texture information matches this texture.
/// </summary>
/// <param name="info">Texture information to compare with</param>
/// <param name="alignSizes">True to align the sizes according to the texture layout for comparison</param>
/// <returns>True if the sizes matches, false otherwise</returns>
2019-10-13 06:02:07 +00:00
private bool SizeMatches(TextureInfo info, bool alignSizes)
{
2019-12-29 17:41:50 +00:00
if (Info.GetLayers() != info.GetLayers())
2019-10-13 06:02:07 +00:00
{
return false;
}
if (alignSizes)
{
2019-12-29 17:41:50 +00:00
Size size0 = GetAlignedSize(Info);
2019-10-13 06:02:07 +00:00
Size size1 = GetAlignedSize(info);
return size0.Width == size1.Width &&
size0.Height == size1.Height &&
size0.Depth == size1.Depth;
}
else
{
2019-12-29 17:41:50 +00:00
return Info.Width == info.Width &&
Info.Height == info.Height &&
Info.GetDepth() == info.GetDepth();
2019-10-13 06:02:07 +00:00
}
}
/// <summary>
/// Checks if the texture shader sampling parameters matches.
/// </summary>
/// <param name="info">Texture information to compare with</param>
/// <returns>True if the texture shader sampling parameters matches, false otherwise</returns>
2019-10-13 06:02:07 +00:00
private bool SamplerParamsMatches(TextureInfo info)
{
2019-12-29 17:41:50 +00:00
return Info.DepthStencilMode == info.DepthStencilMode &&
Info.SwizzleR == info.SwizzleR &&
Info.SwizzleG == info.SwizzleG &&
Info.SwizzleB == info.SwizzleB &&
Info.SwizzleA == info.SwizzleA;
2019-10-13 06:02:07 +00:00
}
/// <summary>
/// Check if the texture target and samples count (for multisampled textures) matches.
/// </summary>
/// <param name="info">Texture information to compare with</param>
/// <returns>True if the texture target and samples count matches, false otherwise</returns>
2019-10-13 06:02:07 +00:00
private bool TargetAndSamplesCompatible(TextureInfo info)
{
2019-12-29 17:41:50 +00:00
return Info.Target == info.Target &&
Info.SamplesInX == info.SamplesInX &&
Info.SamplesInY == info.SamplesInY;
2019-10-13 06:02:07 +00:00
}
/// <summary>
/// Check if it's possible to create a view, with the given parameters, from this texture.
/// </summary>
/// <param name="info">Texture view information</param>
/// <param name="size">Texture view size</param>
/// <param name="firstLayer">Texture view initial layer on this texture</param>
/// <param name="firstLevel">Texture view first mipmap level on this texture</param>
/// <returns>True if a view with the given parameters can be created from this texture, false otherwise</returns>
public bool IsViewCompatible(
TextureInfo info,
ulong size,
out int firstLayer,
out int firstLevel)
{
return IsViewCompatible(info, size, isCopy: false, out firstLayer, out firstLevel);
}
/// <summary>
/// Check if it's possible to create a view, with the given parameters, from this texture.
/// </summary>
/// <param name="info">Texture view information</param>
/// <param name="size">Texture view size</param>
/// <param name="isCopy">True to check for copy compability, instead of view compatibility</param>
/// <param name="firstLayer">Texture view initial layer on this texture</param>
/// <param name="firstLevel">Texture view first mipmap level on this texture</param>
/// <returns>True if a view with the given parameters can be created from this texture, false otherwise</returns>
public bool IsViewCompatible(
TextureInfo info,
ulong size,
bool isCopy,
out int firstLayer,
out int firstLevel)
2019-10-13 06:02:07 +00:00
{
// Out of range.
if (info.Address < Address || info.Address + size > EndAddress)
{
firstLayer = 0;
firstLevel = 0;
return false;
}
int offset = (int)(info.Address - Address);
if (!_sizeInfo.FindView(offset, (int)size, out firstLayer, out firstLevel))
{
return false;
}
if (!ViewLayoutCompatible(info, firstLevel))
{
return false;
}
if (!ViewFormatCompatible(info))
{
return false;
}
if (!ViewSizeMatches(info, firstLevel, isCopy))
2019-10-13 06:02:07 +00:00
{
return false;
}
if (!ViewTargetCompatible(info, isCopy))
2019-10-13 06:02:07 +00:00
{
return false;
}
2019-12-29 17:41:50 +00:00
return Info.SamplesInX == info.SamplesInX &&
Info.SamplesInY == info.SamplesInY;
2019-10-13 06:02:07 +00:00
}
/// <summary>
2019-12-30 17:44:22 +00:00
/// Check if it's possible to create a view with the specified layout.
/// The layout information is composed of the Stride for linear textures, or GOB block size
/// for block linear textures.
/// </summary>
/// <param name="info">Texture information of the texture view</param>
/// <param name="level">Start level of the texture view, in relation with this texture</param>
/// <returns>True if the layout is compatible, false otherwise</returns>
2019-10-13 06:02:07 +00:00
private bool ViewLayoutCompatible(TextureInfo info, int level)
{
2019-12-29 17:41:50 +00:00
if (Info.IsLinear != info.IsLinear)
2019-10-13 06:02:07 +00:00
{
return false;
}
// For linear textures, gob block sizes are ignored.
// For block linear textures, the stride is ignored.
if (info.IsLinear)
{
2019-12-29 17:41:50 +00:00
int width = Math.Max(1, Info.Width >> level);
2019-10-13 06:02:07 +00:00
2019-12-29 17:41:50 +00:00
int stride = width * Info.FormatInfo.BytesPerPixel;
2019-10-13 06:02:07 +00:00
stride = BitUtils.AlignUp(stride, 32);
return stride == info.Stride;
}
else
{
2019-12-29 17:41:50 +00:00
int height = Math.Max(1, Info.Height >> level);
int depth = Math.Max(1, Info.GetDepth() >> level);
2019-10-13 06:02:07 +00:00
(int gobBlocksInY, int gobBlocksInZ) = SizeCalculator.GetMipGobBlockSizes(
height,
depth,
2019-12-29 17:41:50 +00:00
Info.FormatInfo.BlockHeight,
Info.GobBlocksInY,
Info.GobBlocksInZ);
2019-10-13 06:02:07 +00:00
return gobBlocksInY == info.GobBlocksInY &&
gobBlocksInZ == info.GobBlocksInZ;
}
}
/// <summary>
/// Checks if the view format is compatible with this texture format.
2019-12-30 17:44:22 +00:00
/// In general, the formats are considered compatible if the bytes per pixel values are equal,
/// but there are more complex rules for some formats, like compressed or depth-stencil formats.
/// This follows the host API copy compatibility rules.
/// </summary>
/// <param name="info">Texture information of the texture view</param>
/// <returns>True if the formats are compatible, false otherwise</returns>
2019-10-13 06:02:07 +00:00
private bool ViewFormatCompatible(TextureInfo info)
{
2019-12-29 17:41:50 +00:00
return TextureCompatibility.FormatCompatible(Info.FormatInfo, info.FormatInfo);
2019-10-13 06:02:07 +00:00
}
/// <summary>
/// Checks if the size of a given texture view is compatible with this texture.
/// </summary>
/// <param name="info">Texture information of the texture view</param>
/// <param name="level">Mipmap level of the texture view in relation to this texture</param>
/// <param name="isCopy">True to check for copy compatibility rather than view compatibility</param>
/// <returns>True if the sizes are compatible, false otherwise</returns>
private bool ViewSizeMatches(TextureInfo info, int level, bool isCopy)
2019-10-13 06:02:07 +00:00
{
2019-12-29 17:41:50 +00:00
Size size = GetAlignedSize(Info, level);
2019-10-13 06:02:07 +00:00
Size otherSize = GetAlignedSize(info);
// For copies, we can copy a subset of the 3D texture slices,
// so the depth may be different in this case.
if (!isCopy && info.Target == Target.Texture3D && size.Depth != otherSize.Depth)
{
return false;
}
return size.Width == otherSize.Width &&
size.Height == otherSize.Height;
2019-10-13 06:02:07 +00:00
}
/// <summary>
/// Check if the target of the specified texture view information is compatible with this
/// texture.
/// This follows the host API target compatibility rules.
/// </summary>
/// <param name="info">Texture information of the texture view</param>
/// <param name="isCopy">True to check for copy rather than view compatibility</param>
/// <returns>True if the targets are compatible, false otherwise</returns>
private bool ViewTargetCompatible(TextureInfo info, bool isCopy)
2019-10-13 06:02:07 +00:00
{
2019-12-29 17:41:50 +00:00
switch (Info.Target)
2019-10-13 06:02:07 +00:00
{
case Target.Texture1D:
case Target.Texture1DArray:
return info.Target == Target.Texture1D ||
info.Target == Target.Texture1DArray;
case Target.Texture2D:
return info.Target == Target.Texture2D ||
info.Target == Target.Texture2DArray;
case Target.Texture2DArray:
case Target.Cubemap:
case Target.CubemapArray:
return info.Target == Target.Texture2D ||
info.Target == Target.Texture2DArray ||
info.Target == Target.Cubemap ||
info.Target == Target.CubemapArray;
case Target.Texture2DMultisample:
case Target.Texture2DMultisampleArray:
return info.Target == Target.Texture2DMultisample ||
info.Target == Target.Texture2DMultisampleArray;
case Target.Texture3D:
return info.Target == Target.Texture3D ||
(info.Target == Target.Texture2D && isCopy);
2019-10-13 06:02:07 +00:00
}
return false;
}
/// <summary>
/// Gets the aligned sizes of the specified texture information.
/// The alignment depends on the texture layout and format bytes per pixel.
/// </summary>
/// <param name="info">Texture information to calculate the aligned size from</param>
/// <param name="level">Mipmap level for texture views</param>
/// <returns>The aligned texture size</returns>
2019-10-13 06:02:07 +00:00
private static Size GetAlignedSize(TextureInfo info, int level = 0)
{
int width = Math.Max(1, info.Width >> level);
int height = Math.Max(1, info.Height >> level);
if (info.IsLinear)
{
return SizeCalculator.GetLinearAlignedSize(
width,
height,
info.FormatInfo.BlockWidth,
info.FormatInfo.BlockHeight,
info.FormatInfo.BytesPerPixel);
}
else
{
int depth = Math.Max(1, info.GetDepth() >> level);
return SizeCalculator.GetBlockLinearAlignedSize(
width,
height,
depth,
info.FormatInfo.BlockWidth,
info.FormatInfo.BlockHeight,
info.FormatInfo.BytesPerPixel,
info.GobBlocksInY,
info.GobBlocksInZ,
2019-10-13 06:02:07 +00:00
info.GobBlocksInTileX);
}
}
/// <summary>
/// Gets a texture of the specified target type from this texture.
/// This can be used to get an array texture from a non-array texture and vice-versa.
/// If this texture and the requested targets are equal, then this texture Host texture is returned directly.
/// </summary>
/// <param name="target">The desired target type</param>
/// <returns>A view of this texture with the requested target, or null if the target is invalid for this texture</returns>
2019-10-13 06:02:07 +00:00
public ITexture GetTargetTexture(Target target)
{
2019-12-29 17:41:50 +00:00
if (target == Info.Target)
2019-10-13 06:02:07 +00:00
{
return HostTexture;
}
if (_arrayViewTexture == null && IsSameDimensionsTarget(target))
{
TextureCreateInfo createInfo = new TextureCreateInfo(
2019-12-29 17:41:50 +00:00
Info.Width,
Info.Height,
2019-10-13 06:02:07 +00:00
target == Target.CubemapArray ? 6 : 1,
2019-12-29 17:41:50 +00:00
Info.Levels,
Info.Samples,
Info.FormatInfo.BlockWidth,
Info.FormatInfo.BlockHeight,
Info.FormatInfo.BytesPerPixel,
Info.FormatInfo.Format,
Info.DepthStencilMode,
2019-10-13 06:02:07 +00:00
target,
2019-12-29 17:41:50 +00:00
Info.SwizzleR,
Info.SwizzleG,
Info.SwizzleB,
Info.SwizzleA);
2019-10-13 06:02:07 +00:00
ITexture viewTexture = HostTexture.CreateView(createInfo, 0, 0);
_arrayViewTexture = viewTexture;
_arrayViewTarget = target;
return viewTexture;
}
else if (_arrayViewTarget == target)
{
return _arrayViewTexture;
}
return null;
}
/// <summary>
/// Check if this texture and the specified target have the same number of dimensions.
/// For the purposes of this comparison, 2D and 2D Multisample textures are not considered to have
/// the same number of dimensions. Same for Cubemap and 3D textures.
/// </summary>
/// <param name="target">The target to compare with</param>
/// <returns>True if both targets have the same number of dimensions, false otherwise</returns>
2019-10-13 06:02:07 +00:00
private bool IsSameDimensionsTarget(Target target)
{
2019-12-29 17:41:50 +00:00
switch (Info.Target)
2019-10-13 06:02:07 +00:00
{
case Target.Texture1D:
case Target.Texture1DArray:
return target == Target.Texture1D ||
target == Target.Texture1DArray;
case Target.Texture2D:
case Target.Texture2DArray:
return target == Target.Texture2D ||
target == Target.Texture2DArray;
case Target.Cubemap:
case Target.CubemapArray:
return target == Target.Cubemap ||
target == Target.CubemapArray;
case Target.Texture2DMultisample:
case Target.Texture2DMultisampleArray:
return target == Target.Texture2DMultisample ||
target == Target.Texture2DMultisampleArray;
case Target.Texture3D:
return target == Target.Texture3D;
}
return false;
}
/// <summary>
/// Replaces view texture information.
/// This should only be used for child textures with a parent.
/// </summary>
/// <param name="parent">The parent texture</param>
/// <param name="info">The new view texture information</param>
/// <param name="hostTexture">The new host texture</param>
/// <param name="firstLayer">The first layer of the view</param>
/// <param name="firstLevel">The first level of the view</param>
public void ReplaceView(Texture parent, TextureInfo info, ITexture hostTexture, int firstLayer, int firstLevel)
2019-10-13 06:02:07 +00:00
{
ReplaceStorage(hostTexture);
_firstLayer = parent._firstLayer + firstLayer;
_firstLevel = parent._firstLevel + firstLevel;
2019-10-13 06:02:07 +00:00
parent._viewStorage.AddView(this);
SetInfo(info);
}
/// <summary>
/// Sets the internal texture information structure.
/// </summary>
/// <param name="info">The new texture information</param>
2019-10-13 06:02:07 +00:00
private void SetInfo(TextureInfo info)
{
2019-12-29 17:41:50 +00:00
Info = info;
2019-10-13 06:02:07 +00:00
_depth = info.GetDepth();
_layers = info.GetLayers();
}
/// <summary>
/// Signals that the texture has been modified.
/// </summary>
public void SignalModified()
{
Modified?.Invoke(this);
}
/// <summary>
/// Replaces the host texture, while disposing of the old one if needed.
/// </summary>
/// <param name="hostTexture">The new host texture</param>
2019-10-13 06:02:07 +00:00
private void ReplaceStorage(ITexture hostTexture)
{
DisposeTextures();
HostTexture = hostTexture;
}
/// <summary>
/// Checks if the texture overlaps with a memory range.
/// </summary>
/// <param name="address">Start address of the range</param>
/// <param name="size">Size of the range</param>
/// <returns>True if the texture overlaps with the range, false otherwise</returns>
2019-10-13 06:02:07 +00:00
public bool OverlapsWith(ulong address, ulong size)
{
return Address < address + size && address < EndAddress;
}
/// <summary>
/// Increments the texture reference count.
/// </summary>
2019-10-13 06:02:07 +00:00
public void IncrementReferenceCount()
{
_referenceCount++;
}
/// <summary>
/// Decrements the texture reference count.
/// When the reference count hits zero, the texture may be deleted and can't be used anymore.
/// </summary>
2019-10-13 06:02:07 +00:00
public void DecrementReferenceCount()
{
int newRefCount = --_referenceCount;
if (newRefCount == 0)
2019-10-13 06:02:07 +00:00
{
if (_viewStorage != this)
{
_viewStorage.RemoveView(this);
}
_context.Methods.TextureManager.RemoveTextureFromCache(this);
}
Debug.Assert(newRefCount >= 0);
2019-10-13 06:02:07 +00:00
DeleteIfNotUsed();
}
/// <summary>
/// Delete the texture if it is not used anymore.
/// The texture is considered unused when the reference count is zero,
/// and it has no child views.
/// </summary>
private void DeleteIfNotUsed()
{
// We can delete the texture as long it is not being used
// in any cache (the reference count is 0 in this case), and
// also all views that may be created from this texture were
// already deleted (views count is 0).
if (_referenceCount == 0 && _views.Count == 0)
{
Dispose();
2019-10-13 06:02:07 +00:00
}
}
/// <summary>
/// Performs texture disposal, deleting the texture.
/// </summary>
2019-10-13 06:02:07 +00:00
private void DisposeTextures()
{
HostTexture.Dispose();
_arrayViewTexture?.Dispose();
_arrayViewTexture = null;
}
2019-12-31 22:09:49 +00:00
/// <summary>
/// Performs texture disposal, deleting the texture.
/// </summary>
public void Dispose()
{
DisposeTextures();
Disposed?.Invoke(this);
2019-12-31 22:09:49 +00:00
}
2019-10-13 06:02:07 +00:00
}
}