diff options
| author | gdk <gab.dark.100@gmail.com> | 2019-10-13 03:02:07 -0300 |
|---|---|---|
| committer | Thog <thog@protonmail.com> | 2020-01-09 02:13:00 +0100 |
| commit | 1876b346fea647e8284a66bb6d62c38801035cff (patch) | |
| tree | 6eeff094298cda84d1613dc5ec0691e51d7b35f1 /Ryujinx.Graphics/Gal/OpenGL | |
| parent | f617fb542a0e3d36012d77a4b5acbde7b08902f2 (diff) | |
Initial work
Diffstat (limited to 'Ryujinx.Graphics/Gal/OpenGL')
| -rw-r--r-- | Ryujinx.Graphics/Gal/OpenGL/DeleteValueCallback.cs | 4 | ||||
| -rw-r--r-- | Ryujinx.Graphics/Gal/OpenGL/ImageHandler.cs | 27 | ||||
| -rw-r--r-- | Ryujinx.Graphics/Gal/OpenGL/OglCachedResource.cs | 191 | ||||
| -rw-r--r-- | Ryujinx.Graphics/Gal/OpenGL/OglConstBuffer.cs | 74 | ||||
| -rw-r--r-- | Ryujinx.Graphics/Gal/OpenGL/OglEnumConverter.cs | 427 | ||||
| -rw-r--r-- | Ryujinx.Graphics/Gal/OpenGL/OglExtension.cs | 70 | ||||
| -rw-r--r-- | Ryujinx.Graphics/Gal/OpenGL/OglLimit.cs | 12 | ||||
| -rw-r--r-- | Ryujinx.Graphics/Gal/OpenGL/OglPipeline.cs | 833 | ||||
| -rw-r--r-- | Ryujinx.Graphics/Gal/OpenGL/OglRasterizer.cs | 207 | ||||
| -rw-r--r-- | Ryujinx.Graphics/Gal/OpenGL/OglRenderTarget.cs | 549 | ||||
| -rw-r--r-- | Ryujinx.Graphics/Gal/OpenGL/OglRenderer.cs | 58 | ||||
| -rw-r--r-- | Ryujinx.Graphics/Gal/OpenGL/OglShader.cs | 291 | ||||
| -rw-r--r-- | Ryujinx.Graphics/Gal/OpenGL/OglShaderProgram.cs | 87 | ||||
| -rw-r--r-- | Ryujinx.Graphics/Gal/OpenGL/OglStreamBuffer.cs | 55 | ||||
| -rw-r--r-- | Ryujinx.Graphics/Gal/OpenGL/OglTexture.cs | 408 |
15 files changed, 0 insertions, 3293 deletions
diff --git a/Ryujinx.Graphics/Gal/OpenGL/DeleteValueCallback.cs b/Ryujinx.Graphics/Gal/OpenGL/DeleteValueCallback.cs deleted file mode 100644 index 63b626f1..00000000 --- a/Ryujinx.Graphics/Gal/OpenGL/DeleteValueCallback.cs +++ /dev/null @@ -1,4 +0,0 @@ -namespace Ryujinx.Graphics.Gal.OpenGL -{ - delegate void DeleteValue<T>(T value); -}
\ No newline at end of file diff --git a/Ryujinx.Graphics/Gal/OpenGL/ImageHandler.cs b/Ryujinx.Graphics/Gal/OpenGL/ImageHandler.cs deleted file mode 100644 index d7f6f004..00000000 --- a/Ryujinx.Graphics/Gal/OpenGL/ImageHandler.cs +++ /dev/null @@ -1,27 +0,0 @@ -using Ryujinx.Graphics.Texture; - -namespace Ryujinx.Graphics.Gal.OpenGL -{ - class ImageHandler - { - public GalImage Image { get; private set; } - - public int Width => Image.Width; - public int Height => Image.Height; - public int Depth => Image.Depth; - - public GalImageFormat Format => Image.Format; - - public int Handle { get; private set; } - - public bool HasColor => ImageUtils.HasColor(Image.Format); - public bool HasDepth => ImageUtils.HasDepth(Image.Format); - public bool HasStencil => ImageUtils.HasStencil(Image.Format); - - public ImageHandler(int handle, GalImage image) - { - Handle = handle; - Image = image; - } - } -} diff --git a/Ryujinx.Graphics/Gal/OpenGL/OglCachedResource.cs b/Ryujinx.Graphics/Gal/OpenGL/OglCachedResource.cs deleted file mode 100644 index 91f0a7e1..00000000 --- a/Ryujinx.Graphics/Gal/OpenGL/OglCachedResource.cs +++ /dev/null @@ -1,191 +0,0 @@ -using Ryujinx.Common; -using System; -using System.Collections.Generic; - -namespace Ryujinx.Graphics.Gal.OpenGL -{ - class OglCachedResource<T> - { - public delegate void DeleteValue(T value); - - private const int MinTimeDelta = 5 * 60000; - private const int MaxRemovalsPerRun = 10; - - private struct CacheBucket - { - public T Value { get; private set; } - - public LinkedListNode<long> Node { get; private set; } - - public long DataSize { get; private set; } - - public long Timestamp { get; private set; } - - public CacheBucket(T value, long dataSize, LinkedListNode<long> node) - { - Value = value; - DataSize = dataSize; - Node = node; - - Timestamp = PerformanceCounter.ElapsedMilliseconds; - } - } - - private Dictionary<long, CacheBucket> _cache; - - private LinkedList<long> _sortedCache; - - private DeleteValue _deleteValueCallback; - - private Queue<T> _deletePending; - - private bool _locked; - - private long _maxSize; - private long _totalSize; - - public OglCachedResource(DeleteValue deleteValueCallback, long maxSize) - { - _maxSize = maxSize; - - if (deleteValueCallback == null) - { - throw new ArgumentNullException(nameof(deleteValueCallback)); - } - - _deleteValueCallback = deleteValueCallback; - - _cache = new Dictionary<long, CacheBucket>(); - - _sortedCache = new LinkedList<long>(); - - _deletePending = new Queue<T>(); - } - - public void Lock() - { - _locked = true; - } - - public void Unlock() - { - _locked = false; - - while (_deletePending.TryDequeue(out T value)) - { - _deleteValueCallback(value); - } - - ClearCacheIfNeeded(); - } - - public void AddOrUpdate(long key, T value, long size) - { - if (!_locked) - { - ClearCacheIfNeeded(); - } - - LinkedListNode<long> node = _sortedCache.AddLast(key); - - CacheBucket newBucket = new CacheBucket(value, size, node); - - if (_cache.TryGetValue(key, out CacheBucket bucket)) - { - if (_locked) - { - _deletePending.Enqueue(bucket.Value); - } - else - { - _deleteValueCallback(bucket.Value); - } - - _sortedCache.Remove(bucket.Node); - - _totalSize -= bucket.DataSize; - - _cache[key] = newBucket; - } - else - { - _cache.Add(key, newBucket); - } - - _totalSize += size; - } - - public bool TryGetValue(long key, out T value) - { - if (_cache.TryGetValue(key, out CacheBucket bucket)) - { - value = bucket.Value; - - _sortedCache.Remove(bucket.Node); - - LinkedListNode<long> node = _sortedCache.AddLast(key); - - _cache[key] = new CacheBucket(value, bucket.DataSize, node); - - return true; - } - - value = default(T); - - return false; - } - - public bool TryGetSize(long key, out long size) - { - if (_cache.TryGetValue(key, out CacheBucket bucket)) - { - size = bucket.DataSize; - - return true; - } - - size = 0; - - return false; - } - - private void ClearCacheIfNeeded() - { - long timestamp = PerformanceCounter.ElapsedMilliseconds; - - int count = 0; - - while (count++ < MaxRemovalsPerRun) - { - LinkedListNode<long> node = _sortedCache.First; - - if (node == null) - { - break; - } - - CacheBucket bucket = _cache[node.Value]; - - long timeDelta = timestamp - bucket.Timestamp; - - if (timeDelta <= MinTimeDelta && !UnderMemoryPressure()) - { - break; - } - - _sortedCache.Remove(node); - - _cache.Remove(node.Value); - - _deleteValueCallback(bucket.Value); - - _totalSize -= bucket.DataSize; - } - } - - private bool UnderMemoryPressure() - { - return _totalSize >= _maxSize; - } - } -}
\ No newline at end of file diff --git a/Ryujinx.Graphics/Gal/OpenGL/OglConstBuffer.cs b/Ryujinx.Graphics/Gal/OpenGL/OglConstBuffer.cs deleted file mode 100644 index e076be33..00000000 --- a/Ryujinx.Graphics/Gal/OpenGL/OglConstBuffer.cs +++ /dev/null @@ -1,74 +0,0 @@ -using OpenTK.Graphics.OpenGL; -using System; - -namespace Ryujinx.Graphics.Gal.OpenGL -{ - class OglConstBuffer : IGalConstBuffer - { - private const long MaxConstBufferCacheSize = 64 * 1024 * 1024; - - private OglCachedResource<OglStreamBuffer> _cache; - - public OglConstBuffer() - { - _cache = new OglCachedResource<OglStreamBuffer>(DeleteBuffer, MaxConstBufferCacheSize); - } - - public void LockCache() - { - _cache.Lock(); - } - - public void UnlockCache() - { - _cache.Unlock(); - } - - public void Create(long key, long size) - { - OglStreamBuffer buffer = new OglStreamBuffer(BufferTarget.UniformBuffer, size); - - _cache.AddOrUpdate(key, buffer, size); - } - - public bool IsCached(long key, long size) - { - return _cache.TryGetSize(key, out long cachedSize) && cachedSize == size; - } - - public void SetData(long key, long size, IntPtr hostAddress) - { - if (_cache.TryGetValue(key, out OglStreamBuffer buffer)) - { - buffer.SetData(size, hostAddress); - } - } - - public void SetData(long key, byte[] data) - { - if (_cache.TryGetValue(key, out OglStreamBuffer buffer)) - { - buffer.SetData(data); - } - } - - public bool TryGetUbo(long key, out int uboHandle) - { - if (_cache.TryGetValue(key, out OglStreamBuffer buffer)) - { - uboHandle = buffer.Handle; - - return true; - } - - uboHandle = 0; - - return false; - } - - private static void DeleteBuffer(OglStreamBuffer buffer) - { - buffer.Dispose(); - } - } -}
\ No newline at end of file diff --git a/Ryujinx.Graphics/Gal/OpenGL/OglEnumConverter.cs b/Ryujinx.Graphics/Gal/OpenGL/OglEnumConverter.cs deleted file mode 100644 index c36d8bf9..00000000 --- a/Ryujinx.Graphics/Gal/OpenGL/OglEnumConverter.cs +++ /dev/null @@ -1,427 +0,0 @@ -using OpenTK.Graphics.OpenGL; -using System; - -namespace Ryujinx.Graphics.Gal.OpenGL -{ - static class OglEnumConverter - { - public static FrontFaceDirection GetFrontFace(GalFrontFace frontFace) - { - switch (frontFace) - { - case GalFrontFace.Cw: return FrontFaceDirection.Cw; - case GalFrontFace.Ccw: return FrontFaceDirection.Ccw; - } - - throw new ArgumentException(nameof(frontFace) + " \"" + frontFace + "\" is not valid!"); - } - - public static CullFaceMode GetCullFace(GalCullFace cullFace) - { - switch (cullFace) - { - case GalCullFace.Front: return CullFaceMode.Front; - case GalCullFace.Back: return CullFaceMode.Back; - case GalCullFace.FrontAndBack: return CullFaceMode.FrontAndBack; - } - - throw new ArgumentException(nameof(cullFace) + " \"" + cullFace + "\" is not valid!"); - } - - public static StencilOp GetStencilOp(GalStencilOp op) - { - switch (op) - { - case GalStencilOp.Keep: return StencilOp.Keep; - case GalStencilOp.Zero: return StencilOp.Zero; - case GalStencilOp.Replace: return StencilOp.Replace; - case GalStencilOp.Incr: return StencilOp.Incr; - case GalStencilOp.Decr: return StencilOp.Decr; - case GalStencilOp.Invert: return StencilOp.Invert; - case GalStencilOp.IncrWrap: return StencilOp.IncrWrap; - case GalStencilOp.DecrWrap: return StencilOp.DecrWrap; - } - - throw new ArgumentException(nameof(op) + " \"" + op + "\" is not valid!"); - } - - public static DepthFunction GetDepthFunc(GalComparisonOp func) - { - return (DepthFunction)GetFunc(func); - } - - public static StencilFunction GetStencilFunc(GalComparisonOp func) - { - return (StencilFunction)GetFunc(func); - } - - private static All GetFunc(GalComparisonOp func) - { - if ((int)func >= (int)All.Never && - (int)func <= (int)All.Always) - { - return (All)func; - } - - switch (func) - { - case GalComparisonOp.Never: return All.Never; - case GalComparisonOp.Less: return All.Less; - case GalComparisonOp.Equal: return All.Equal; - case GalComparisonOp.Lequal: return All.Lequal; - case GalComparisonOp.Greater: return All.Greater; - case GalComparisonOp.NotEqual: return All.Notequal; - case GalComparisonOp.Gequal: return All.Gequal; - case GalComparisonOp.Always: return All.Always; - } - - throw new ArgumentException(nameof(func) + " \"" + func + "\" is not valid!"); - } - - public static DrawElementsType GetDrawElementsType(GalIndexFormat format) - { - switch (format) - { - case GalIndexFormat.Byte: return DrawElementsType.UnsignedByte; - case GalIndexFormat.Int16: return DrawElementsType.UnsignedShort; - case GalIndexFormat.Int32: return DrawElementsType.UnsignedInt; - } - - throw new ArgumentException(nameof(format) + " \"" + format + "\" is not valid!"); - } - - public static PrimitiveType GetPrimitiveType(GalPrimitiveType type) - { - switch (type) - { - case GalPrimitiveType.Points: return PrimitiveType.Points; - case GalPrimitiveType.Lines: return PrimitiveType.Lines; - case GalPrimitiveType.LineLoop: return PrimitiveType.LineLoop; - case GalPrimitiveType.LineStrip: return PrimitiveType.LineStrip; - case GalPrimitiveType.Triangles: return PrimitiveType.Triangles; - case GalPrimitiveType.TriangleStrip: return PrimitiveType.TriangleStrip; - case GalPrimitiveType.TriangleFan: return PrimitiveType.TriangleFan; - case GalPrimitiveType.Polygon: return PrimitiveType.Polygon; - case GalPrimitiveType.LinesAdjacency: return PrimitiveType.LinesAdjacency; - case GalPrimitiveType.LineStripAdjacency: return PrimitiveType.LineStripAdjacency; - case GalPrimitiveType.TrianglesAdjacency: return PrimitiveType.TrianglesAdjacency; - case GalPrimitiveType.TriangleStripAdjacency: return PrimitiveType.TriangleStripAdjacency; - case GalPrimitiveType.Patches: return PrimitiveType.Patches; - } - - throw new ArgumentException(nameof(type) + " \"" + type + "\" is not valid!"); - } - - public static ShaderType GetShaderType(GalShaderType type) - { - switch (type) - { - case GalShaderType.Vertex: return ShaderType.VertexShader; - case GalShaderType.TessControl: return ShaderType.TessControlShader; - case GalShaderType.TessEvaluation: return ShaderType.TessEvaluationShader; - case GalShaderType.Geometry: return ShaderType.GeometryShader; - case GalShaderType.Fragment: return ShaderType.FragmentShader; - } - - throw new ArgumentException(nameof(type) + " \"" + type + "\" is not valid!"); - } - - public static (PixelInternalFormat, PixelFormat, PixelType) GetImageFormat(GalImageFormat format) - { - switch (format) - { - case GalImageFormat.Rgba32 | GalImageFormat.Float: return (PixelInternalFormat.Rgba32f, PixelFormat.Rgba, PixelType.Float); - case GalImageFormat.Rgba32 | GalImageFormat.Sint: return (PixelInternalFormat.Rgba32i, PixelFormat.RgbaInteger, PixelType.Int); - case GalImageFormat.Rgba32 | GalImageFormat.Uint: return (PixelInternalFormat.Rgba32ui, PixelFormat.RgbaInteger, PixelType.UnsignedInt); - case GalImageFormat.Rgba16 | GalImageFormat.Float: return (PixelInternalFormat.Rgba16f, PixelFormat.Rgba, PixelType.HalfFloat); - case GalImageFormat.Rgba16 | GalImageFormat.Sint: return (PixelInternalFormat.Rgba16i, PixelFormat.RgbaInteger, PixelType.Short); - case GalImageFormat.Rgba16 | GalImageFormat.Uint: return (PixelInternalFormat.Rgba16ui, PixelFormat.RgbaInteger, PixelType.UnsignedShort); - case GalImageFormat.Rgba16 | GalImageFormat.Unorm: return (PixelInternalFormat.Rgba16, PixelFormat.Rgba, PixelType.UnsignedShort); - case GalImageFormat.Rg32 | GalImageFormat.Float: return (PixelInternalFormat.Rg32f, PixelFormat.Rg, PixelType.Float); - case GalImageFormat.Rg32 | GalImageFormat.Sint: return (PixelInternalFormat.Rg32i, PixelFormat.RgInteger, PixelType.Int); - case GalImageFormat.Rg32 | GalImageFormat.Uint: return (PixelInternalFormat.Rg32ui, PixelFormat.RgInteger, PixelType.UnsignedInt); - case GalImageFormat.Rgbx8 | GalImageFormat.Unorm: return (PixelInternalFormat.Rgb8, PixelFormat.Rgba, PixelType.UnsignedByte); - case GalImageFormat.Rgba8 | GalImageFormat.Snorm: return (PixelInternalFormat.Rgba8Snorm, PixelFormat.Rgba, PixelType.Byte); - case GalImageFormat.Rgba8 | GalImageFormat.Unorm: return (PixelInternalFormat.Rgba8, PixelFormat.Rgba, PixelType.UnsignedByte); - case GalImageFormat.Rgba8 | GalImageFormat.Sint: return (PixelInternalFormat.Rgba8i, PixelFormat.RgbaInteger, PixelType.Byte); - case GalImageFormat.Rgba8 | GalImageFormat.Uint: return (PixelInternalFormat.Rgba8ui, PixelFormat.RgbaInteger, PixelType.UnsignedByte); - case GalImageFormat.Rgba8 | GalImageFormat.Srgb: return (PixelInternalFormat.Srgb8Alpha8, PixelFormat.Rgba, PixelType.UnsignedByte); - case GalImageFormat.Bgra8 | GalImageFormat.Unorm: return (PixelInternalFormat.Rgba8, PixelFormat.Bgra, PixelType.UnsignedByte); - case GalImageFormat.Bgra8 | GalImageFormat.Srgb: return (PixelInternalFormat.Srgb8Alpha8, PixelFormat.Bgra, PixelType.UnsignedByte); - case GalImageFormat.Rgba4 | GalImageFormat.Unorm: return (PixelInternalFormat.Rgba4, PixelFormat.Rgba, PixelType.UnsignedShort4444Reversed); - case GalImageFormat.Rgb10A2 | GalImageFormat.Uint: return (PixelInternalFormat.Rgb10A2ui, PixelFormat.RgbaInteger, PixelType.UnsignedInt2101010Reversed); - case GalImageFormat.Rgb10A2 | GalImageFormat.Unorm: return (PixelInternalFormat.Rgb10A2, PixelFormat.Rgba, PixelType.UnsignedInt2101010Reversed); - case GalImageFormat.R32 | GalImageFormat.Float: return (PixelInternalFormat.R32f, PixelFormat.Red, PixelType.Float); - case GalImageFormat.R32 | GalImageFormat.Sint: return (PixelInternalFormat.R32i, PixelFormat.Red, PixelType.Int); - case GalImageFormat.R32 | GalImageFormat.Uint: return (PixelInternalFormat.R32ui, PixelFormat.Red, PixelType.UnsignedInt); - case GalImageFormat.Bgr5A1 | GalImageFormat.Unorm: return (PixelInternalFormat.Rgb5A1, PixelFormat.Rgba, PixelType.UnsignedShort5551); - case GalImageFormat.Rgb5A1 | GalImageFormat.Unorm: return (PixelInternalFormat.Rgb5A1, PixelFormat.Rgba, PixelType.UnsignedShort1555Reversed); - case GalImageFormat.Rgb565 | GalImageFormat.Unorm: return (PixelInternalFormat.Rgba, PixelFormat.Rgb, PixelType.UnsignedShort565Reversed); - case GalImageFormat.Bgr565 | GalImageFormat.Unorm: return (PixelInternalFormat.Rgba, PixelFormat.Rgb, PixelType.UnsignedShort565); - case GalImageFormat.Rg16 | GalImageFormat.Float: return (PixelInternalFormat.Rg16f, PixelFormat.Rg, PixelType.HalfFloat); - case GalImageFormat.Rg16 | GalImageFormat.Sint: return (PixelInternalFormat.Rg16i, PixelFormat.RgInteger, PixelType.Short); - case GalImageFormat.Rg16 | GalImageFormat.Snorm: return (PixelInternalFormat.Rg16Snorm, PixelFormat.Rg, PixelType.Short); - case GalImageFormat.Rg16 | GalImageFormat.Uint: return (PixelInternalFormat.Rg16ui, PixelFormat.RgInteger, PixelType.UnsignedShort); - case GalImageFormat.Rg16 | GalImageFormat.Unorm: return (PixelInternalFormat.Rg16, PixelFormat.Rg, PixelType.UnsignedShort); - case GalImageFormat.Rg8 | GalImageFormat.Sint: return (PixelInternalFormat.Rg8i, PixelFormat.RgInteger, PixelType.Byte); - case GalImageFormat.Rg8 | GalImageFormat.Snorm: return (PixelInternalFormat.Rg8Snorm, PixelFormat.Rg, PixelType.Byte); - case GalImageFormat.Rg8 | GalImageFormat.Uint: return (PixelInternalFormat.Rg8ui, PixelFormat.RgInteger, PixelType.UnsignedByte); - case GalImageFormat.Rg8 | GalImageFormat.Unorm: return (PixelInternalFormat.Rg8, PixelFormat.Rg, PixelType.UnsignedByte); - case GalImageFormat.R16 | GalImageFormat.Float: return (PixelInternalFormat.R16f, PixelFormat.Red, PixelType.HalfFloat); - case GalImageFormat.R16 | GalImageFormat.Sint: return (PixelInternalFormat.R16i, PixelFormat.RedInteger, PixelType.Short); - case GalImageFormat.R16 | GalImageFormat.Snorm: return (PixelInternalFormat.R16Snorm, PixelFormat.Red, PixelType.Short); - case GalImageFormat.R16 | GalImageFormat.Uint: return (PixelInternalFormat.R16ui, PixelFormat.RedInteger, PixelType.UnsignedShort); - case GalImageFormat.R16 | GalImageFormat.Unorm: return (PixelInternalFormat.R16, PixelFormat.Red, PixelType.UnsignedShort); - case GalImageFormat.R8 | GalImageFormat.Sint: return (PixelInternalFormat.R8i, PixelFormat.RedInteger, PixelType.Byte); - case GalImageFormat.R8 | GalImageFormat.Snorm: return (PixelInternalFormat.R8Snorm, PixelFormat.Red, PixelType.Byte); - case GalImageFormat.R8 | GalImageFormat.Uint: return (PixelInternalFormat.R8ui, PixelFormat.RedInteger, PixelType.UnsignedByte); - case GalImageFormat.R8 | GalImageFormat.Unorm: return (PixelInternalFormat.R8, PixelFormat.Red, PixelType.UnsignedByte); - case GalImageFormat.R11G11B10 | GalImageFormat.Float: return (PixelInternalFormat.R11fG11fB10f, PixelFormat.Rgb, PixelType.UnsignedInt10F11F11FRev); - - case GalImageFormat.D16 | GalImageFormat.Unorm: return (PixelInternalFormat.DepthComponent16, PixelFormat.DepthComponent, PixelType.UnsignedShort); - case GalImageFormat.D24 | GalImageFormat.Unorm: return (PixelInternalFormat.DepthComponent24, PixelFormat.DepthComponent, PixelType.UnsignedInt); - case GalImageFormat.D24S8 | GalImageFormat.Uint: return (PixelInternalFormat.Depth24Stencil8, PixelFormat.DepthStencil, PixelType.UnsignedInt248); - case GalImageFormat.D24S8 | GalImageFormat.Unorm: return (PixelInternalFormat.Depth24Stencil8, PixelFormat.DepthStencil, PixelType.UnsignedInt248); - case GalImageFormat.D32 | GalImageFormat.Float: return (PixelInternalFormat.DepthComponent32f, PixelFormat.DepthComponent, PixelType.Float); - case GalImageFormat.D32S8 | GalImageFormat.Float: return (PixelInternalFormat.Depth32fStencil8, PixelFormat.DepthStencil, PixelType.Float32UnsignedInt248Rev); - } - - throw new NotImplementedException($"{format & GalImageFormat.FormatMask} {format & GalImageFormat.TypeMask}"); - } - - public static All GetDepthCompareFunc(DepthCompareFunc depthCompareFunc) - { - switch (depthCompareFunc) - { - case DepthCompareFunc.LEqual: - return All.Lequal; - case DepthCompareFunc.GEqual: - return All.Gequal; - case DepthCompareFunc.Less: - return All.Less; - case DepthCompareFunc.Greater: - return All.Greater; - case DepthCompareFunc.Equal: - return All.Equal; - case DepthCompareFunc.NotEqual: - return All.Notequal; - case DepthCompareFunc.Always: - return All.Always; - case DepthCompareFunc.Never: - return All.Never; - default: - throw new ArgumentException(nameof(depthCompareFunc) + " \"" + depthCompareFunc + "\" is not valid!"); - } - } - - public static InternalFormat GetCompressedImageFormat(GalImageFormat format) - { - switch (format) - { - case GalImageFormat.BptcSfloat | GalImageFormat.Float: return InternalFormat.CompressedRgbBptcSignedFloat; - case GalImageFormat.BptcUfloat | GalImageFormat.Float: return InternalFormat.CompressedRgbBptcUnsignedFloat; - case GalImageFormat.BptcUnorm | GalImageFormat.Unorm: return InternalFormat.CompressedRgbaBptcUnorm; - case GalImageFormat.BptcUnorm | GalImageFormat.Srgb: return InternalFormat.CompressedSrgbAlphaBptcUnorm; - case GalImageFormat.BC1 | GalImageFormat.Unorm: return InternalFormat.CompressedRgbaS3tcDxt1Ext; - case GalImageFormat.BC1 | GalImageFormat.Srgb: return InternalFormat.CompressedSrgbAlphaS3tcDxt1Ext; - case GalImageFormat.BC2 | GalImageFormat.Unorm: return InternalFormat.CompressedRgbaS3tcDxt3Ext; - case GalImageFormat.BC2 | GalImageFormat.Srgb: return InternalFormat.CompressedSrgbAlphaS3tcDxt3Ext; - case GalImageFormat.BC3 | GalImageFormat.Unorm: return InternalFormat.CompressedRgbaS3tcDxt5Ext; - case GalImageFormat.BC3 | GalImageFormat.Srgb: return InternalFormat.CompressedSrgbAlphaS3tcDxt5Ext; - case GalImageFormat.BC4 | GalImageFormat.Snorm: return InternalFormat.CompressedSignedRedRgtc1; - case GalImageFormat.BC4 | GalImageFormat.Unorm: return InternalFormat.CompressedRedRgtc1; - case GalImageFormat.BC5 | GalImageFormat.Snorm: return InternalFormat.CompressedSignedRgRgtc2; - case GalImageFormat.BC5 | GalImageFormat.Unorm: return InternalFormat.CompressedRgRgtc2; - } - - throw new NotImplementedException($"{format & GalImageFormat.FormatMask} {format & GalImageFormat.TypeMask}"); - } - - public static All GetTextureSwizzle(GalTextureSource source) - { - switch (source) - { - case GalTextureSource.Zero: return All.Zero; - case GalTextureSource.Red: return All.Red; - case GalTextureSource.Green: return All.Green; - case GalTextureSource.Blue: return All.Blue; - case GalTextureSource.Alpha: return All.Alpha; - case GalTextureSource.OneInt: return All.One; - case GalTextureSource.OneFloat: return All.One; - } - - throw new ArgumentException(nameof(source) + " \"" + source + "\" is not valid!"); - } - - public static TextureWrapMode GetTextureWrapMode(GalTextureWrap wrap) - { - switch (wrap) - { - case GalTextureWrap.Repeat: return TextureWrapMode.Repeat; - case GalTextureWrap.MirroredRepeat: return TextureWrapMode.MirroredRepeat; - case GalTextureWrap.ClampToEdge: return TextureWrapMode.ClampToEdge; - case GalTextureWrap.ClampToBorder: return TextureWrapMode.ClampToBorder; - case GalTextureWrap.Clamp: return TextureWrapMode.Clamp; - } - - if (OglExtension.TextureMirrorClamp) - { - switch (wrap) - { - case GalTextureWrap.MirrorClampToEdge: return (TextureWrapMode)ExtTextureMirrorClamp.MirrorClampToEdgeExt; - case GalTextureWrap.MirrorClampToBorder: return (TextureWrapMode)ExtTextureMirrorClamp.MirrorClampToBorderExt; - case GalTextureWrap.MirrorClamp: return (TextureWrapMode)ExtTextureMirrorClamp.MirrorClampExt; - } - } - else - { - // Fallback to non-mirrored clamps - switch (wrap) - { - case GalTextureWrap.MirrorClampToEdge: return TextureWrapMode.ClampToEdge; - case GalTextureWrap.MirrorClampToBorder: return TextureWrapMode.ClampToBorder; - case GalTextureWrap.MirrorClamp: return TextureWrapMode.Clamp; - } - } - - throw new ArgumentException(nameof(wrap) + " \"" + wrap + "\" is not valid!"); - } - - public static TextureMinFilter GetTextureMinFilter( - GalTextureFilter minFilter, - GalTextureMipFilter mipFilter) - { - // TODO: Mip (needs mipmap support first). - switch (minFilter) - { - case GalTextureFilter.Nearest: return TextureMinFilter.Nearest; - case GalTextureFilter.Linear: return TextureMinFilter.Linear; - } - - throw new ArgumentException(nameof(minFilter) + " \"" + minFilter + "\" is not valid!"); - } - - public static TextureMagFilter GetTextureMagFilter(GalTextureFilter filter) - { - switch (filter) - { - case GalTextureFilter.Nearest: return TextureMagFilter.Nearest; - case GalTextureFilter.Linear: return TextureMagFilter.Linear; - } - - throw new ArgumentException(nameof(filter) + " \"" + filter + "\" is not valid!"); - } - - public static BlendEquationMode GetBlendEquation(GalBlendEquation blendEquation) - { - switch (blendEquation) - { - case GalBlendEquation.FuncAdd: - case GalBlendEquation.FuncAddGl: - return BlendEquationMode.FuncAdd; - - case GalBlendEquation.FuncSubtract: - case GalBlendEquation.FuncSubtractGl: - return BlendEquationMode.FuncSubtract; - - case GalBlendEquation.FuncReverseSubtract: - case GalBlendEquation.FuncReverseSubtractGl: - return BlendEquationMode.FuncReverseSubtract; - - case GalBlendEquation.Min: - case GalBlendEquation.MinGl: - return BlendEquationMode.Min; - - case GalBlendEquation.Max: - case GalBlendEquation.MaxGl: - return BlendEquationMode.Max; - } - - throw new ArgumentException(nameof(blendEquation) + " \"" + blendEquation + "\" is not valid!"); - } - - public static BlendingFactor GetBlendFactor(GalBlendFactor blendFactor) - { - switch (blendFactor) - { - case GalBlendFactor.Zero: - case GalBlendFactor.ZeroGl: - return BlendingFactor.Zero; - - case GalBlendFactor.One: - case GalBlendFactor.OneGl: - return BlendingFactor.One; - - case GalBlendFactor.SrcColor: - case GalBlendFactor.SrcColorGl: - return BlendingFactor.SrcColor; - - case GalBlendFactor.OneMinusSrcColor: - case GalBlendFactor.OneMinusSrcColorGl: - return BlendingFactor.OneMinusSrcColor; - - case GalBlendFactor.DstColor: - case GalBlendFactor.DstColorGl: - return BlendingFactor.DstColor; - - case GalBlendFactor.OneMinusDstColor: - case GalBlendFactor.OneMinusDstColorGl: - return BlendingFactor.OneMinusDstColor; - - case GalBlendFactor.SrcAlpha: - case GalBlendFactor.SrcAlphaGl: - return BlendingFactor.SrcAlpha; - - case GalBlendFactor.OneMinusSrcAlpha: - case GalBlendFactor.OneMinusSrcAlphaGl: - return BlendingFactor.OneMinusSrcAlpha; - - case GalBlendFactor.DstAlpha: - case GalBlendFactor.DstAlphaGl: - return BlendingFactor.DstAlpha; - - case GalBlendFactor.OneMinusDstAlpha: - case GalBlendFactor.OneMinusDstAlphaGl: - return BlendingFactor.OneMinusDstAlpha; - - case GalBlendFactor.OneMinusConstantColor: - case GalBlendFactor.OneMinusConstantColorGl: - return BlendingFactor.OneMinusConstantColor; - - case GalBlendFactor.ConstantAlpha: - case GalBlendFactor.ConstantAlphaGl: - return BlendingFactor.ConstantAlpha; - - case GalBlendFactor.OneMinusConstantAlpha: - case GalBlendFactor.OneMinusConstantAlphaGl: - return BlendingFactor.OneMinusConstantAlpha; - - case GalBlendFactor.SrcAlphaSaturate: - case GalBlendFactor.SrcAlphaSaturateGl: - return BlendingFactor.SrcAlphaSaturate; - - case GalBlendFactor.Src1Color: - case GalBlendFactor.Src1ColorGl: - return BlendingFactor.Src1Color; - - case GalBlendFactor.OneMinusSrc1Color: - case GalBlendFactor.OneMinusSrc1ColorGl: - return (BlendingFactor)BlendingFactorSrc.OneMinusSrc1Color; - - case GalBlendFactor.Src1Alpha: - case GalBlendFactor.Src1AlphaGl: - return BlendingFactor.Src1Alpha; - - case GalBlendFactor.OneMinusSrc1Alpha: - case GalBlendFactor.OneMinusSrc1AlphaGl: - return (BlendingFactor)BlendingFactorSrc.OneMinusSrc1Alpha; - - case GalBlendFactor.ConstantColor: - case GalBlendFactor.ConstantColorGl: - return BlendingFactor.ConstantColor; - } - - throw new ArgumentException(nameof(blendFactor) + " \"" + blendFactor + "\" is not valid!"); - } - } -} diff --git a/Ryujinx.Graphics/Gal/OpenGL/OglExtension.cs b/Ryujinx.Graphics/Gal/OpenGL/OglExtension.cs deleted file mode 100644 index 8a1a0510..00000000 --- a/Ryujinx.Graphics/Gal/OpenGL/OglExtension.cs +++ /dev/null @@ -1,70 +0,0 @@ -using OpenTK.Graphics.OpenGL; -using Ryujinx.Common.Logging; -using System; - -namespace Ryujinx.Graphics.Gal.OpenGL -{ - static class OglExtension - { - // Private lazy backing variables - private static Lazy<bool> _enhancedLayouts = new Lazy<bool>(() => HasExtension("GL_ARB_enhanced_layouts")); - private static Lazy<bool> _textureMirrorClamp = new Lazy<bool>(() => HasExtension("GL_EXT_texture_mirror_clamp")); - private static Lazy<bool> _viewportArray = new Lazy<bool>(() => HasExtension("GL_ARB_viewport_array")); - - private static Lazy<bool> _nvidiaDriver = new Lazy<bool>(() => IsNvidiaDriver()); - - // Public accessors - public static bool EnhancedLayouts => _enhancedLayouts.Value; - public static bool TextureMirrorClamp => _textureMirrorClamp.Value; - public static bool ViewportArray => _viewportArray.Value; - - public static bool NvidiaDriver => _nvidiaDriver.Value; - - private static bool HasExtension(string name) - { - int numExtensions = GL.GetInteger(GetPName.NumExtensions); - - for (int extension = 0; extension < numExtensions; extension++) - { - if (GL.GetString(StringNameIndexed.Extensions, extension) == name) - { - return true; - } - } - - Logger.PrintInfo(LogClass.Gpu, $"OpenGL extension {name} unavailable. You may experience some performance degradation"); - - return false; - } - - private static bool IsNvidiaDriver() - { - return GL.GetString(StringName.Vendor).Equals("NVIDIA Corporation"); - } - - public static class Required - { - // Public accessors - public static bool EnhancedLayouts => _enhancedLayoutsRequired.Value; - public static bool TextureMirrorClamp => _textureMirrorClampRequired.Value; - public static bool ViewportArray => _viewportArrayRequired.Value; - - // Private lazy backing variables - private static Lazy<bool> _enhancedLayoutsRequired = new Lazy<bool>(() => HasExtensionRequired(OglExtension.EnhancedLayouts, "GL_ARB_enhanced_layouts")); - private static Lazy<bool> _textureMirrorClampRequired = new Lazy<bool>(() => HasExtensionRequired(OglExtension.TextureMirrorClamp, "GL_EXT_texture_mirror_clamp")); - private static Lazy<bool> _viewportArrayRequired = new Lazy<bool>(() => HasExtensionRequired(OglExtension.ViewportArray, "GL_ARB_viewport_array")); - - private static bool HasExtensionRequired(bool value, string name) - { - if (value) - { - return true; - } - - Logger.PrintWarning(LogClass.Gpu, $"Required OpenGL extension {name} unavailable. You may experience some rendering issues"); - - return false; - } - } - } -} diff --git a/Ryujinx.Graphics/Gal/OpenGL/OglLimit.cs b/Ryujinx.Graphics/Gal/OpenGL/OglLimit.cs deleted file mode 100644 index 2a227a37..00000000 --- a/Ryujinx.Graphics/Gal/OpenGL/OglLimit.cs +++ /dev/null @@ -1,12 +0,0 @@ -using OpenTK.Graphics.OpenGL; -using System; - -namespace Ryujinx.Graphics.Gal.OpenGL -{ - static class OglLimit - { - private static Lazy<int> _sMaxUboSize = new Lazy<int>(() => GL.GetInteger(GetPName.MaxUniformBlockSize)); - - public static int MaxUboSize => _sMaxUboSize.Value; - } -}
\ No newline at end of file diff --git a/Ryujinx.Graphics/Gal/OpenGL/OglPipeline.cs b/Ryujinx.Graphics/Gal/OpenGL/OglPipeline.cs deleted file mode 100644 index 8d886be4..00000000 --- a/Ryujinx.Graphics/Gal/OpenGL/OglPipeline.cs +++ /dev/null @@ -1,833 +0,0 @@ -using OpenTK.Graphics.OpenGL; -using Ryujinx.Graphics.Shader; -using System; -using System.Collections.Generic; - -namespace Ryujinx.Graphics.Gal.OpenGL -{ - class OglPipeline : IGalPipeline - { - private static Dictionary<GalVertexAttribSize, int> _attribElements = - new Dictionary<GalVertexAttribSize, int>() - { - { GalVertexAttribSize._32_32_32_32, 4 }, - { GalVertexAttribSize._32_32_32, 3 }, - { GalVertexAttribSize._16_16_16_16, 4 }, - { GalVertexAttribSize._32_32, 2 }, - { GalVertexAttribSize._16_16_16, 3 }, - { GalVertexAttribSize._8_8_8_8, 4 }, - { GalVertexAttribSize._16_16, 2 }, - { GalVertexAttribSize._32, 1 }, - { GalVertexAttribSize._8_8_8, 3 }, - { GalVertexAttribSize._8_8, 2 }, - { GalVertexAttribSize._16, 1 }, - { GalVertexAttribSize._8, 1 }, - { GalVertexAttribSize._10_10_10_2, 4 }, - { GalVertexAttribSize._11_11_10, 3 } - }; - - private static Dictionary<GalVertexAttribSize, VertexAttribPointerType> _floatAttribTypes = - new Dictionary<GalVertexAttribSize, VertexAttribPointerType>() - { - { GalVertexAttribSize._32_32_32_32, VertexAttribPointerType.Float }, - { GalVertexAttribSize._32_32_32, VertexAttribPointerType.Float }, - { GalVertexAttribSize._16_16_16_16, VertexAttribPointerType.HalfFloat }, - { GalVertexAttribSize._32_32, VertexAttribPointerType.Float }, - { GalVertexAttribSize._16_16_16, VertexAttribPointerType.HalfFloat }, - { GalVertexAttribSize._16_16, VertexAttribPointerType.HalfFloat }, - { GalVertexAttribSize._32, VertexAttribPointerType.Float }, - { GalVertexAttribSize._16, VertexAttribPointerType.HalfFloat } - }; - - private static Dictionary<GalVertexAttribSize, VertexAttribPointerType> _signedAttribTypes = - new Dictionary<GalVertexAttribSize, VertexAttribPointerType>() - { - { GalVertexAttribSize._32_32_32_32, VertexAttribPointerType.Int }, - { GalVertexAttribSize._32_32_32, VertexAttribPointerType.Int }, - { GalVertexAttribSize._16_16_16_16, VertexAttribPointerType.Short }, - { GalVertexAttribSize._32_32, VertexAttribPointerType.Int }, - { GalVertexAttribSize._16_16_16, VertexAttribPointerType.Short }, - { GalVertexAttribSize._8_8_8_8, VertexAttribPointerType.Byte }, - { GalVertexAttribSize._16_16, VertexAttribPointerType.Short }, - { GalVertexAttribSize._32, VertexAttribPointerType.Int }, - { GalVertexAttribSize._8_8_8, VertexAttribPointerType.Byte }, - { GalVertexAttribSize._8_8, VertexAttribPointerType.Byte }, - { GalVertexAttribSize._16, VertexAttribPointerType.Short }, - { GalVertexAttribSize._8, VertexAttribPointerType.Byte }, - { GalVertexAttribSize._10_10_10_2, VertexAttribPointerType.Int2101010Rev } - }; - - private static Dictionary<GalVertexAttribSize, VertexAttribPointerType> _unsignedAttribTypes = - new Dictionary<GalVertexAttribSize, VertexAttribPointerType>() - { - { GalVertexAttribSize._32_32_32_32, VertexAttribPointerType.UnsignedInt }, - { GalVertexAttribSize._32_32_32, VertexAttribPointerType.UnsignedInt }, - { GalVertexAttribSize._16_16_16_16, VertexAttribPointerType.UnsignedShort }, - { GalVertexAttribSize._32_32, VertexAttribPointerType.UnsignedInt }, - { GalVertexAttribSize._16_16_16, VertexAttribPointerType.UnsignedShort }, - { GalVertexAttribSize._8_8_8_8, VertexAttribPointerType.UnsignedByte }, - { GalVertexAttribSize._16_16, VertexAttribPointerType.UnsignedShort }, - { GalVertexAttribSize._32, VertexAttribPointerType.UnsignedInt }, - { GalVertexAttribSize._8_8_8, VertexAttribPointerType.UnsignedByte }, - { GalVertexAttribSize._8_8, VertexAttribPointerType.UnsignedByte }, - { GalVertexAttribSize._16, VertexAttribPointerType.UnsignedShort }, - { GalVertexAttribSize._8, VertexAttribPointerType.UnsignedByte }, - { GalVertexAttribSize._10_10_10_2, VertexAttribPointerType.UnsignedInt2101010Rev }, - { GalVertexAttribSize._11_11_10, VertexAttribPointerType.UnsignedInt10F11F11FRev } - }; - - private GalPipelineState _old; - - private OglConstBuffer _buffer; - private OglRenderTarget _renderTarget; - private OglRasterizer _rasterizer; - private OglShader _shader; - - private int _vaoHandle; - - public OglPipeline( - OglConstBuffer buffer, - OglRenderTarget renderTarget, - OglRasterizer rasterizer, - OglShader shader) - { - _buffer = buffer; - _renderTarget = renderTarget; - _rasterizer = rasterizer; - _shader = shader; - - // These values match OpenGL's defaults - _old = new GalPipelineState - { - FrontFace = GalFrontFace.Ccw, - - CullFaceEnabled = false, - CullFace = GalCullFace.Back, - - DepthTestEnabled = false, - DepthWriteEnabled = true, - DepthFunc = GalComparisonOp.Less, - DepthRangeNear = 0, - DepthRangeFar = 1, - - StencilTestEnabled = false, - - StencilBackFuncFunc = GalComparisonOp.Always, - StencilBackFuncRef = 0, - StencilBackFuncMask = UInt32.MaxValue, - StencilBackOpFail = GalStencilOp.Keep, - StencilBackOpZFail = GalStencilOp.Keep, - StencilBackOpZPass = GalStencilOp.Keep, - StencilBackMask = UInt32.MaxValue, - - StencilFrontFuncFunc = GalComparisonOp.Always, - StencilFrontFuncRef = 0, - StencilFrontFuncMask = UInt32.MaxValue, - StencilFrontOpFail = GalStencilOp.Keep, - StencilFrontOpZFail = GalStencilOp.Keep, - StencilFrontOpZPass = GalStencilOp.Keep, - StencilFrontMask = UInt32.MaxValue, - - BlendIndependent = false, - - PrimitiveRestartEnabled = false, - PrimitiveRestartIndex = 0 - }; - - for (int index = 0; index < GalPipelineState.RenderTargetsCount; index++) - { - _old.Blends[index] = BlendState.Default; - - _old.ColorMasks[index] = ColorMaskState.Default; - } - } - - public void Bind(GalPipelineState New) - { - BindConstBuffers(New); - - BindVertexLayout(New); - - if (New.FramebufferSrgb != _old.FramebufferSrgb) - { - Enable(EnableCap.FramebufferSrgb, New.FramebufferSrgb); - - _renderTarget.FramebufferSrgb = New.FramebufferSrgb; - } - - if (New.FlipX != _old.FlipX || New.FlipY != _old.FlipY || New.Instance != _old.Instance) - { - _shader.SetExtraData(New.FlipX, New.FlipY, New.Instance); - } - - if (New.FrontFace != _old.FrontFace) - { - GL.FrontFace(OglEnumConverter.GetFrontFace(New.FrontFace)); - } - - if (New.CullFaceEnabled != _old.CullFaceEnabled) - { - Enable(EnableCap.CullFace, New.CullFaceEnabled); - } - - if (New.CullFaceEnabled) - { - if (New.CullFace != _old.CullFace) - { - GL.CullFace(OglEnumConverter.GetCullFace(New.CullFace)); - } - } - - if (New.DepthTestEnabled != _old.DepthTestEnabled) - { - Enable(EnableCap.DepthTest, New.DepthTestEnabled); - } - - if (New.DepthWriteEnabled != _old.DepthWriteEnabled) - { - GL.DepthMask(New.DepthWriteEnabled); - } - - if (New.DepthTestEnabled) - { - if (New.DepthFunc != _old.DepthFunc) - { - GL.DepthFunc(OglEnumConverter.GetDepthFunc(New.DepthFunc)); - } - } - - if (New.DepthRangeNear != _old.DepthRangeNear || - New.DepthRangeFar != _old.DepthRangeFar) - { - GL.DepthRange(New.DepthRangeNear, New.DepthRangeFar); - } - - if (New.StencilTestEnabled != _old.StencilTestEnabled) - { - Enable(EnableCap.StencilTest, New.StencilTestEnabled); - } - - if (New.StencilTwoSideEnabled != _old.StencilTwoSideEnabled) - { - Enable((EnableCap)All.StencilTestTwoSideExt, New.StencilTwoSideEnabled); - } - - if (New.StencilTestEnabled) - { - if (New.StencilBackFuncFunc != _old.StencilBackFuncFunc || - New.StencilBackFuncRef != _old.StencilBackFuncRef || - New.StencilBackFuncMask != _old.StencilBackFuncMask) - { - GL.StencilFuncSeparate( - StencilFace.Back, - OglEnumConverter.GetStencilFunc(New.StencilBackFuncFunc), - New.StencilBackFuncRef, - New.StencilBackFuncMask); - } - - if (New.StencilBackOpFail != _old.StencilBackOpFail || - New.StencilBackOpZFail != _old.StencilBackOpZFail || - New.StencilBackOpZPass != _old.StencilBackOpZPass) - { - GL.StencilOpSeparate( - StencilFace.Back, - OglEnumConverter.GetStencilOp(New.StencilBackOpFail), - OglEnumConverter.GetStencilOp(New.StencilBackOpZFail), - OglEnumConverter.GetStencilOp(New.StencilBackOpZPass)); - } - - if (New.StencilBackMask != _old.StencilBackMask) - { - GL.StencilMaskSeparate(StencilFace.Back, New.StencilBackMask); - } - - if (New.StencilFrontFuncFunc != _old.StencilFrontFuncFunc || - New.StencilFrontFuncRef != _old.StencilFrontFuncRef || - New.StencilFrontFuncMask != _old.StencilFrontFuncMask) - { - GL.StencilFuncSeparate( - StencilFace.Front, - OglEnumConverter.GetStencilFunc(New.StencilFrontFuncFunc), - New.StencilFrontFuncRef, - New.StencilFrontFuncMask); - } - - if (New.StencilFrontOpFail != _old.StencilFrontOpFail || - New.StencilFrontOpZFail != _old.StencilFrontOpZFail || - New.StencilFrontOpZPass != _old.StencilFrontOpZPass) - { - GL.StencilOpSeparate( - StencilFace.Front, - OglEnumConverter.GetStencilOp(New.StencilFrontOpFail), - OglEnumConverter.GetStencilOp(New.StencilFrontOpZFail), - OglEnumConverter.GetStencilOp(New.StencilFrontOpZPass)); - } - - if (New.StencilFrontMask != _old.StencilFrontMask) - { - GL.StencilMaskSeparate(StencilFace.Front, New.StencilFrontMask); - } - } - - - // Scissor Test - // All scissor test are disabled before drawing final framebuffer to screen so we don't need to handle disabling - // Skip if there are no scissor tests to enable - if (New.ScissorTestCount != 0) - { - int scissorsApplied = 0; - bool applyToAll = false; - - for (int index = 0; index < GalPipelineState.RenderTargetsCount; index++) - { - if (New.ScissorTestEnabled[index]) - { - // If viewport arrays are unavailable apply first scissor test to all or - // there is only 1 scissor test and it's the first, the scissor test applies to all viewports - if (!OglExtension.Required.ViewportArray || (index == 0 && New.ScissorTestCount == 1)) - { - GL.Enable(EnableCap.ScissorTest); - applyToAll = true; - } - else - { - GL.Enable(IndexedEnableCap.ScissorTest, index); - } - - if (New.ScissorTestEnabled[index] != _old.ScissorTestEnabled[index] || - New.ScissorTestX[index] != _old.ScissorTestX[index] || - New.ScissorTestY[index] != _old.ScissorTestY[index] || - New.ScissorTestWidth[index] != _old.ScissorTestWidth[index] || - New.ScissorTestHeight[index] != _old.ScissorTestHeight[index]) - { - if (applyToAll) - { - GL.Scissor(New.ScissorTestX[index], New.ScissorTestY[index], - New.ScissorTestWidth[index], New.ScissorTestHeight[index]); - } - else - { - GL.ScissorIndexed(index, New.ScissorTestX[index], New.ScissorTestY[index], - New.ScissorTestWidth[index], New.ScissorTestHeight[index]); - } - } - - // If all scissor tests have been applied, or viewport arrays are unavailable we can skip remaining iterations - if (!OglExtension.Required.ViewportArray || ++scissorsApplied == New.ScissorTestCount) - { - break; - } - } - } - } - - - if (New.BlendIndependent) - { - for (int index = 0; index < GalPipelineState.RenderTargetsCount; index++) - { - SetBlendState(index, New.Blends[index], _old.Blends[index]); - } - } - else - { - if (New.BlendIndependent != _old.BlendIndependent) - { - SetAllBlendState(New.Blends[0]); - } - else - { - SetBlendState(New.Blends[0], _old.Blends[0]); - } - } - - if (New.ColorMaskCommon) - { - if (New.ColorMaskCommon != _old.ColorMaskCommon || !New.ColorMasks[0].Equals(_old.ColorMasks[0])) - { - GL.ColorMask( - New.ColorMasks[0].Red, - New.ColorMasks[0].Green, - New.ColorMasks[0].Blue, - New.ColorMasks[0].Alpha); - } - } - else - { - for (int index = 0; index < GalPipelineState.RenderTargetsCount; index++) - { - if (!New.ColorMasks[index].Equals(_old.ColorMasks[index])) - { - GL.ColorMask( - index, - New.ColorMasks[index].Red, - New.ColorMasks[index].Green, - New.ColorMasks[index].Blue, - New.ColorMasks[index].Alpha); - } - } - } - - if (New.PrimitiveRestartEnabled != _old.PrimitiveRestartEnabled) - { - Enable(EnableCap.PrimitiveRestart, New.PrimitiveRestartEnabled); - } - - if (New.PrimitiveRestartEnabled) - { - if (New.PrimitiveRestartIndex != _old.PrimitiveRestartIndex) - { - GL.PrimitiveRestartIndex(New.PrimitiveRestartIndex); - } - } - - _old = New; - } - - public void Unbind(GalPipelineState state) - { - if (state.ScissorTestCount > 0) - { - GL.Disable(EnableCap.ScissorTest); - } - } - - private void SetAllBlendState(BlendState New) - { - Enable(EnableCap.Blend, New.Enabled); - - if (New.Enabled) - { - if (New.SeparateAlpha) - { - GL.BlendEquationSeparate( - OglEnumConverter.GetBlendEquation(New.EquationRgb), - OglEnumConverter.GetBlendEquation(New.EquationAlpha)); - - GL.BlendFuncSeparate( - (BlendingFactorSrc) OglEnumConverter.GetBlendFactor(New.FuncSrcRgb), - (BlendingFactorDest)OglEnumConverter.GetBlendFactor(New.FuncDstRgb), - (BlendingFactorSrc) OglEnumConverter.GetBlendFactor(New.FuncSrcAlpha), - (BlendingFactorDest)OglEnumConverter.GetBlendFactor(New.FuncDstAlpha)); - } - else - { - GL.BlendEquation(OglEnumConverter.GetBlendEquation(New.EquationRgb)); - - GL.BlendFunc( - OglEnumConverter.GetBlendFactor(New.FuncSrcRgb), - OglEnumConverter.GetBlendFactor(New.FuncDstRgb)); - } - } - } - - private void SetBlendState(BlendState New, BlendState old) - { - if (New.Enabled != old.Enabled) - { - Enable(EnableCap.Blend, New.Enabled); - } - - if (New.Enabled) - { - if (New.SeparateAlpha) - { - if (New.EquationRgb != old.EquationRgb || - New.EquationAlpha != old.EquationAlpha) - { - GL.BlendEquationSeparate( - OglEnumConverter.GetBlendEquation(New.EquationRgb), - OglEnumConverter.GetBlendEquation(New.EquationAlpha)); - } - - if (New.FuncSrcRgb != old.FuncSrcRgb || - New.FuncDstRgb != old.FuncDstRgb || - New.FuncSrcAlpha != old.FuncSrcAlpha || - New.FuncDstAlpha != old.FuncDstAlpha) - { - GL.BlendFuncSeparate( - (BlendingFactorSrc) OglEnumConverter.GetBlendFactor(New.FuncSrcRgb), - (BlendingFactorDest)OglEnumConverter.GetBlendFactor(New.FuncDstRgb), - (BlendingFactorSrc) OglEnumConverter.GetBlendFactor(New.FuncSrcAlpha), - (BlendingFactorDest)OglEnumConverter.GetBlendFactor(New.FuncDstAlpha)); - } - } - else - { - if (New.EquationRgb != old.EquationRgb) - { - GL.BlendEquation(OglEnumConverter.GetBlendEquation(New.EquationRgb)); - } - - if (New.FuncSrcRgb != old.FuncSrcRgb || - New.FuncDstRgb != old.FuncDstRgb) - { - GL.BlendFunc( - OglEnumConverter.GetBlendFactor(New.FuncSrcRgb), - OglEnumConverter.GetBlendFactor(New.FuncDstRgb)); - } - } - } - } - - private void SetBlendState(int index, BlendState New, BlendState old) - { - if (New.Enabled != old.Enabled) - { - Enable(IndexedEnableCap.Blend, index, New.Enabled); - } - - if (New.Enabled) - { - if (New.SeparateAlpha) - { - if (New.EquationRgb != old.EquationRgb || - New.EquationAlpha != old.EquationAlpha) - { - GL.BlendEquationSeparate( - index, - OglEnumConverter.GetBlendEquation(New.EquationRgb), - OglEnumConverter.GetBlendEquation(New.EquationAlpha)); - } - - if (New.FuncSrcRgb != old.FuncSrcRgb || - New.FuncDstRgb != old.FuncDstRgb || - New.FuncSrcAlpha != old.FuncSrcAlpha || - New.FuncDstAlpha != old.FuncDstAlpha) - { - GL.BlendFuncSeparate( - index, - (BlendingFactorSrc) OglEnumConverter.GetBlendFactor(New.FuncSrcRgb), - (BlendingFactorDest)OglEnumConverter.GetBlendFactor(New.FuncDstRgb), - (BlendingFactorSrc) OglEnumConverter.GetBlendFactor(New.FuncSrcAlpha), - (BlendingFactorDest)OglEnumConverter.GetBlendFactor(New.FuncDstAlpha)); - } - } - else - { - if (New.EquationRgb != old.EquationRgb) - { - GL.BlendEquation(index, OglEnumConverter.GetBlendEquation(New.EquationRgb)); - } - - if (New.FuncSrcRgb != old.FuncSrcRgb || - New.FuncDstRgb != old.FuncDstRgb) - { - GL.BlendFunc( - index, - (BlendingFactorSrc) OglEnumConverter.GetBlendFactor(New.FuncSrcRgb), - (BlendingFactorDest)OglEnumConverter.GetBlendFactor(New.FuncDstRgb)); - } - } - } - } - - private void BindConstBuffers(GalPipelineState New) - { - int freeBinding = OglShader.ReservedCbufCount; - - void BindIfNotNull(OglShaderStage stage) - { - if (stage != null) - { - foreach (CBufferDescriptor desc in stage.ConstBufferUsage) - { - long key = New.ConstBufferKeys[(int)stage.Type][desc.Slot]; - - if (key != 0 && _buffer.TryGetUbo(key, out int uboHandle)) - { - GL.BindBufferBase(BufferRangeTarget.UniformBuffer, freeBinding, uboHandle); - } - - freeBinding++; - } - } - } - - BindIfNotNull(_shader.Current.Vertex); - BindIfNotNull(_shader.Current.TessControl); - BindIfNotNull(_shader.Current.TessEvaluation); - BindIfNotNull(_shader.Current.Geometry); - BindIfNotNull(_shader.Current.Fragment); - } - - private void BindVertexLayout(GalPipelineState New) - { - foreach (GalVertexBinding binding in New.VertexBindings) - { - if (!binding.Enabled || !_rasterizer.TryGetVbo(binding.VboKey, out int vboHandle)) - { - continue; - } - - if (_vaoHandle == 0) - { - _vaoHandle = GL.GenVertexArray(); - - // Vertex arrays shouldn't be used anywhere else in OpenGL's backend - // if you want to use it, move this line out of the if - GL.BindVertexArray(_vaoHandle); - } - - foreach (GalVertexAttrib attrib in binding.Attribs) - { - // Skip uninitialized attributes. - if (attrib.Size == 0) - { - continue; - } - - GL.BindBuffer(BufferTarget.ArrayBuffer, vboHandle); - - bool unsigned = - attrib.Type == GalVertexAttribType.Unorm || - attrib.Type == GalVertexAttribType.Uint || - attrib.Type == GalVertexAttribType.Uscaled; - - bool normalize = - attrib.Type == GalVertexAttribType.Snorm || - attrib.Type == GalVertexAttribType.Unorm; - - VertexAttribPointerType type = 0; - - if (attrib.Type == GalVertexAttribType.Float) - { - type = GetType(_floatAttribTypes, attrib); - } - else - { - if (unsigned) - { - type = GetType(_unsignedAttribTypes, attrib); - } - else - { - type = GetType(_signedAttribTypes, attrib); - } - } - - if (!_attribElements.TryGetValue(attrib.Size, out int size)) - { - throw new InvalidOperationException("Invalid attribute size \"" + attrib.Size + "\"!"); - } - - int offset = attrib.Offset; - - if (binding.Stride != 0) - { - GL.EnableVertexAttribArray(attrib.Index); - - if (attrib.Type == GalVertexAttribType.Sint || - attrib.Type == GalVertexAttribType.Uint) - { - IntPtr pointer = new IntPtr(offset); - - VertexAttribIntegerType iType = (VertexAttribIntegerType)type; - - GL.VertexAttribIPointer(attrib.Index, size, iType, binding.Stride, pointer); - } - else - { - GL.VertexAttribPointer(attrib.Index, size, type, normalize, binding.Stride, offset); - } - } - else - { - GL.DisableVertexAttribArray(attrib.Index); - - SetConstAttrib(attrib); - } - - if (binding.Instanced && binding.Divisor != 0) - { - GL.VertexAttribDivisor(attrib.Index, 1); - } - else - { - GL.VertexAttribDivisor(attrib.Index, 0); - } - } - } - } - - private static VertexAttribPointerType GetType(Dictionary<GalVertexAttribSize, VertexAttribPointerType> dict, GalVertexAttrib attrib) - { - if (!dict.TryGetValue(attrib.Size, out VertexAttribPointerType type)) - { - ThrowUnsupportedAttrib(attrib); - } - - return type; - } - - private static unsafe void SetConstAttrib(GalVertexAttrib attrib) - { - if (attrib.Size == GalVertexAttribSize._10_10_10_2 || - attrib.Size == GalVertexAttribSize._11_11_10) - { - ThrowUnsupportedAttrib(attrib); - } - - fixed (byte* ptr = attrib.Data) - { - if (attrib.Type == GalVertexAttribType.Unorm) - { - switch (attrib.Size) - { - case GalVertexAttribSize._8: - case GalVertexAttribSize._8_8: - case GalVertexAttribSize._8_8_8: - case GalVertexAttribSize._8_8_8_8: - GL.VertexAttrib4N((uint)attrib.Index, ptr); - break; - - case GalVertexAttribSize._16: - case GalVertexAttribSize._16_16: - case GalVertexAttribSize._16_16_16: - case GalVertexAttribSize._16_16_16_16: - GL.VertexAttrib4N((uint)attrib.Index, (ushort*)ptr); - break; - - case GalVertexAttribSize._32: - case GalVertexAttribSize._32_32: - case GalVertexAttribSize._32_32_32: - case GalVertexAttribSize._32_32_32_32: - GL.VertexAttrib4N((uint)attrib.Index, (uint*)ptr); - break; - } - } - else if (attrib.Type == GalVertexAttribType.Snorm) - { - switch (attrib.Size) - { - case GalVertexAttribSize._8: - case GalVertexAttribSize._8_8: - case GalVertexAttribSize._8_8_8: - case GalVertexAttribSize._8_8_8_8: - GL.VertexAttrib4N((uint)attrib.Index, (sbyte*)ptr); - break; - - case GalVertexAttribSize._16: - case GalVertexAttribSize._16_16: - case GalVertexAttribSize._16_16_16: - case GalVertexAttribSize._16_16_16_16: - GL.VertexAttrib4N((uint)attrib.Index, (short*)ptr); - break; - - case GalVertexAttribSize._32: - case GalVertexAttribSize._32_32: - case GalVertexAttribSize._32_32_32: - case GalVertexAttribSize._32_32_32_32: - GL.VertexAttrib4N((uint)attrib.Index, (int*)ptr); - break; - } - } - else if (attrib.Type == GalVertexAttribType.Uint) - { - switch (attrib.Size) - { - case GalVertexAttribSize._8: - case GalVertexAttribSize._8_8: - case GalVertexAttribSize._8_8_8: - case GalVertexAttribSize._8_8_8_8: - GL.VertexAttribI4((uint)attrib.Index, ptr); - break; - - case GalVertexAttribSize._16: - case GalVertexAttribSize._16_16: - case GalVertexAttribSize._16_16_16: - case GalVertexAttribSize._16_16_16_16: - GL.VertexAttribI4((uint)attrib.Index, (ushort*)ptr); - break; - - case GalVertexAttribSize._32: - case GalVertexAttribSize._32_32: - case GalVertexAttribSize._32_32_32: - case GalVertexAttribSize._32_32_32_32: - GL.VertexAttribI4((uint)attrib.Index, (uint*)ptr); - break; - } - } - else if (attrib.Type == GalVertexAttribType.Sint) - { - switch (attrib.Size) - { - case GalVertexAttribSize._8: - case GalVertexAttribSize._8_8: - case GalVertexAttribSize._8_8_8: - case GalVertexAttribSize._8_8_8_8: - GL.VertexAttribI4((uint)attrib.Index, (sbyte*)ptr); - break; - - case GalVertexAttribSize._16: - case GalVertexAttribSize._16_16: - case GalVertexAttribSize._16_16_16: - case GalVertexAttribSize._16_16_16_16: - GL.VertexAttribI4((uint)attrib.Index, (short*)ptr); - break; - - case GalVertexAttribSize._32: - case GalVertexAttribSize._32_32: - case GalVertexAttribSize._32_32_32: - case GalVertexAttribSize._32_32_32_32: - GL.VertexAttribI4((uint)attrib.Index, (int*)ptr); - break; - } - } - else if (attrib.Type == GalVertexAttribType.Float) - { - switch (attrib.Size) - { - case GalVertexAttribSize._32: - case GalVertexAttribSize._32_32: - case GalVertexAttribSize._32_32_32: - case GalVertexAttribSize._32_32_32_32: - GL.VertexAttrib4(attrib.Index, (float*)ptr); - break; - - default: ThrowUnsupportedAttrib(attrib); break; - } - } - } - } - - private static void ThrowUnsupportedAttrib(GalVertexAttrib attrib) - { - throw new NotImplementedException("Unsupported size \"" + attrib.Size + "\" on type \"" + attrib.Type + "\"!"); - } - - private void Enable(EnableCap cap, bool enabled) - { - if (enabled) - { - GL.Enable(cap); - } - else - { - GL.Disable(cap); - } - } - - private void Enable(IndexedEnableCap cap, int index, bool enabled) - { - if (enabled) - { - GL.Enable(cap, index); - } - else - { - GL.Disable(cap, index); - } - } - - public void ResetDepthMask() - { - _old.DepthWriteEnabled = true; - } - - public void ResetColorMask(int index) - { - _old.ColorMasks[index] = ColorMaskState.Default; - } - } -}
\ No newline at end of file diff --git a/Ryujinx.Graphics/Gal/OpenGL/OglRasterizer.cs b/Ryujinx.Graphics/Gal/OpenGL/OglRasterizer.cs deleted file mode 100644 index c19911c5..00000000 --- a/Ryujinx.Graphics/Gal/OpenGL/OglRasterizer.cs +++ /dev/null @@ -1,207 +0,0 @@ -using OpenTK.Graphics.OpenGL; -using System; - -namespace Ryujinx.Graphics.Gal.OpenGL -{ - class OglRasterizer : IGalRasterizer - { - private const long MaxVertexBufferCacheSize = 128 * 1024 * 1024; - private const long MaxIndexBufferCacheSize = 64 * 1024 * 1024; - - private int[] _vertexBuffers; - - private OglCachedResource<int> _vboCache; - private OglCachedResource<int> _iboCache; - - private struct IbInfo - { - public int Count; - public int ElemSizeLog2; - - public DrawElementsType Type; - } - - private IbInfo _indexBuffer; - - public OglRasterizer() - { - _vertexBuffers = new int[32]; - - _vboCache = new OglCachedResource<int>(GL.DeleteBuffer, MaxVertexBufferCacheSize); - _iboCache = new OglCachedResource<int>(GL.DeleteBuffer, MaxIndexBufferCacheSize); - - _indexBuffer = new IbInfo(); - } - - public void LockCaches() - { - _vboCache.Lock(); - _iboCache.Lock(); - } - - public void UnlockCaches() - { - _vboCache.Unlock(); - _iboCache.Unlock(); - } - - public void ClearBuffers( - GalClearBufferFlags flags, - int attachment, - float red, - float green, - float blue, - float alpha, - float depth, - int stencil) - { - GL.ColorMask( - attachment, - flags.HasFlag(GalClearBufferFlags.ColorRed), - flags.HasFlag(GalClearBufferFlags.ColorGreen), - flags.HasFlag(GalClearBufferFlags.ColorBlue), - flags.HasFlag(GalClearBufferFlags.ColorAlpha)); - - GL.ClearBuffer(ClearBuffer.Color, attachment, new float[] { red, green, blue, alpha }); - - GL.ColorMask(attachment, true, true, true, true); - GL.DepthMask(true); - - if (flags.HasFlag(GalClearBufferFlags.Depth)) - { - GL.ClearBuffer(ClearBuffer.Depth, 0, ref depth); - } - - if (flags.HasFlag(GalClearBufferFlags.Stencil)) - { - GL.ClearBuffer(ClearBuffer.Stencil, 0, ref stencil); - } - } - - public bool IsVboCached(long key, long dataSize) - { - return _vboCache.TryGetSize(key, out long size) && size == dataSize; - } - - public bool IsIboCached(long key, long dataSize) - { - return _iboCache.TryGetSize(key, out long size) && size == dataSize; - } - - public void CreateVbo(long key, int dataSize, IntPtr hostAddress) - { - int handle = GL.GenBuffer(); - - _vboCache.AddOrUpdate(key, handle, dataSize); - - IntPtr length = new IntPtr(dataSize); - - GL.BindBuffer(BufferTarget.ArrayBuffer, handle); - GL.BufferData(BufferTarget.ArrayBuffer, length, hostAddress, BufferUsageHint.StreamDraw); - } - - public void CreateVbo(long key, byte[] data) - { - int handle = GL.GenBuffer(); - - _vboCache.AddOrUpdate(key, handle, data.Length); - - IntPtr length = new IntPtr(data.Length); - - GL.BindBuffer(BufferTarget.ArrayBuffer, handle); - GL.BufferData(BufferTarget.ArrayBuffer, length, data, BufferUsageHint.StreamDraw); - } - - public void CreateIbo(long key, int dataSize, IntPtr hostAddress) - { - int handle = GL.GenBuffer(); - - _iboCache.AddOrUpdate(key, handle, (uint)dataSize); - - IntPtr length = new IntPtr(dataSize); - - GL.BindBuffer(BufferTarget.ElementArrayBuffer, handle); - GL.BufferData(BufferTarget.ElementArrayBuffer, length, hostAddress, BufferUsageHint.StreamDraw); - } - - public void CreateIbo(long key, int dataSize, byte[] buffer) - { - int handle = GL.GenBuffer(); - - _iboCache.AddOrUpdate(key, handle, dataSize); - - IntPtr length = new IntPtr(buffer.Length); - - GL.BindBuffer(BufferTarget.ElementArrayBuffer, handle); - GL.BufferData(BufferTarget.ElementArrayBuffer, length, buffer, BufferUsageHint.StreamDraw); - } - - public void SetIndexArray(int size, GalIndexFormat format) - { - _indexBuffer.Type = OglEnumConverter.GetDrawElementsType(format); - - _indexBuffer.Count = size >> (int)format; - - _indexBuffer.ElemSizeLog2 = (int)format; - } - - public void DrawArrays(int first, int count, GalPrimitiveType primType) - { - if (count == 0) - { - return; - } - - if (primType == GalPrimitiveType.Quads) - { - for (int offset = 0; offset < count; offset += 4) - { - GL.DrawArrays(PrimitiveType.TriangleFan, first + offset, 4); - } - } - else if (primType == GalPrimitiveType.QuadStrip) - { - GL.DrawArrays(PrimitiveType.TriangleFan, first, 4); - - for (int offset = 2; offset < count; offset += 2) - { - GL.DrawArrays(PrimitiveType.TriangleFan, first + offset, 4); - } - } - else - { - GL.DrawArrays(OglEnumConverter.GetPrimitiveType(primType), first, count); - } - } - - public void DrawElements(long iboKey, int first, int vertexBase, GalPrimitiveType primType) - { - if (!_iboCache.TryGetValue(iboKey, out int iboHandle)) - { - return; - } - - PrimitiveType mode = OglEnumConverter.GetPrimitiveType(primType); - - GL.BindBuffer(BufferTarget.ElementArrayBuffer, iboHandle); - - first <<= _indexBuffer.ElemSizeLog2; - - if (vertexBase != 0) - { - IntPtr indices = new IntPtr(first); - - GL.DrawElementsBaseVertex(mode, _indexBuffer.Count, _indexBuffer.Type, indices, vertexBase); - } - else - { - GL.DrawElements(mode, _indexBuffer.Count, _indexBuffer.Type, first); - } - } - - public bool TryGetVbo(long vboKey, out int vboHandle) - { - return _vboCache.TryGetValue(vboKey, out vboHandle); - } - } -}
\ No newline at end of file diff --git a/Ryujinx.Graphics/Gal/OpenGL/OglRenderTarget.cs b/Ryujinx.Graphics/Gal/OpenGL/OglRenderTarget.cs deleted file mode 100644 index 11fc98cb..00000000 --- a/Ryujinx.Graphics/Gal/OpenGL/OglRenderTarget.cs +++ /dev/null @@ -1,549 +0,0 @@ -using OpenTK.Graphics.OpenGL; -using Ryujinx.Graphics.Texture; -using System; - -namespace Ryujinx.Graphics.Gal.OpenGL -{ - class OglRenderTarget : IGalRenderTarget - { - private const int NativeWidth = 1280; - private const int NativeHeight = 720; - - private const int RenderTargetsCount = GalPipelineState.RenderTargetsCount; - - private struct Rect - { - public int X { get; private set; } - public int Y { get; private set; } - public int Width { get; private set; } - public int Height { get; private set; } - - public Rect(int x, int y, int width, int height) - { - X = x; - Y = y; - Width = width; - Height = height; - } - } - - private class FrameBufferAttachments - { - public int MapCount { get; set; } - - public DrawBuffersEnum[] Map { get; private set; } - - public long[] Colors { get; private set; } - - public long Zeta { get; set; } - - public FrameBufferAttachments() - { - Colors = new long[RenderTargetsCount]; - - Map = new DrawBuffersEnum[RenderTargetsCount]; - } - - public void Update(FrameBufferAttachments source) - { - for (int index = 0; index < RenderTargetsCount; index++) - { - Map[index] = source.Map[index]; - - Colors[index] = source.Colors[index]; - } - - MapCount = source.MapCount; - Zeta = source.Zeta; - } - } - - private int[] _colorHandles; - private int _zetaHandle; - - private OglTexture _texture; - - private ImageHandler _readTex; - - private Rect _window; - - private float[] _viewports; - - private bool _flipX; - private bool _flipY; - - private int _cropTop; - private int _cropLeft; - private int _cropRight; - private int _cropBottom; - - // This framebuffer is used to attach guest rendertargets, - // think of it as a dummy OpenGL VAO - private int _dummyFrameBuffer; - - // These framebuffers are used to blit images - private int _srcFb; - private int _dstFb; - - private FrameBufferAttachments _attachments; - private FrameBufferAttachments _oldAttachments; - - private int _copyPbo; - - public bool FramebufferSrgb { get; set; } - - public OglRenderTarget(OglTexture texture) - { - _attachments = new FrameBufferAttachments(); - - _oldAttachments = new FrameBufferAttachments(); - - _colorHandles = new int[RenderTargetsCount]; - - _viewports = new float[RenderTargetsCount * 4]; - - _texture = texture; - - texture.TextureDeleted += TextureDeletionHandler; - } - - private void TextureDeletionHandler(object sender, int handle) - { - // Texture was deleted, the handle is no longer valid, so - // reset all uses of this handle on a render target. - for (int attachment = 0; attachment < RenderTargetsCount; attachment++) - { - if (_colorHandles[attachment] == handle) - { - _colorHandles[attachment] = 0; - } - } - - if (_zetaHandle == handle) - { - _zetaHandle = 0; - } - } - - public void Bind() - { - if (_dummyFrameBuffer == 0) - { - _dummyFrameBuffer = GL.GenFramebuffer(); - } - - GL.BindFramebuffer(FramebufferTarget.DrawFramebuffer, _dummyFrameBuffer); - - ImageHandler cachedImage; - - for (int attachment = 0; attachment < RenderTargetsCount; attachment++) - { - long key = _attachments.Colors[attachment]; - - int handle = 0; - - if (key != 0 && _texture.TryGetImageHandler(key, out cachedImage)) - { - handle = cachedImage.Handle; - } - - if (handle == _colorHandles[attachment]) - { - continue; - } - - GL.FramebufferTexture( - FramebufferTarget.DrawFramebuffer, - FramebufferAttachment.ColorAttachment0 + attachment, - handle, - 0); - - _colorHandles[attachment] = handle; - } - - if (_attachments.Zeta != 0 && _texture.TryGetImageHandler(_attachments.Zeta, out cachedImage)) - { - if (cachedImage.Handle != _zetaHandle) - { - if (cachedImage.HasDepth && cachedImage.HasStencil) - { - GL.FramebufferTexture( - FramebufferTarget.DrawFramebuffer, - FramebufferAttachment.DepthStencilAttachment, - cachedImage.Handle, - 0); - } - else if (cachedImage.HasDepth) - { - GL.FramebufferTexture( - FramebufferTarget.DrawFramebuffer, - FramebufferAttachment.DepthAttachment, - cachedImage.Handle, - 0); - - GL.FramebufferTexture( - FramebufferTarget.DrawFramebuffer, - FramebufferAttachment.StencilAttachment, - 0, - 0); - } - else - { - throw new InvalidOperationException("Invalid image format \"" + cachedImage.Format + "\" used as Zeta!"); - } - - _zetaHandle = cachedImage.Handle; - } - } - else if (_zetaHandle != 0) - { - GL.FramebufferTexture( - FramebufferTarget.DrawFramebuffer, - FramebufferAttachment.DepthStencilAttachment, - 0, - 0); - - _zetaHandle = 0; - } - - if (OglExtension.ViewportArray) - { - GL.ViewportArray(0, RenderTargetsCount, _viewports); - } - else - { - GL.Viewport( - (int)_viewports[0], - (int)_viewports[1], - (int)_viewports[2], - (int)_viewports[3]); - } - - if (_attachments.MapCount > 1) - { - GL.DrawBuffers(_attachments.MapCount, _attachments.Map); - } - else if (_attachments.MapCount == 1) - { - GL.DrawBuffer((DrawBufferMode)_attachments.Map[0]); - } - else - { - GL.DrawBuffer(DrawBufferMode.None); - } - - _oldAttachments.Update(_attachments); - } - - public void BindColor(long key, int attachment) - { - _attachments.Colors[attachment] = key; - } - - public void UnbindColor(int attachment) - { - _attachments.Colors[attachment] = 0; - } - - public void BindZeta(long key) - { - _attachments.Zeta = key; - } - - public void UnbindZeta() - { - _attachments.Zeta = 0; - } - - public void Present(long key) - { - _texture.TryGetImageHandler(key, out _readTex); - } - - public void SetMap(int[] map) - { - if (map != null) - { - _attachments.MapCount = map.Length; - - for (int attachment = 0; attachment < _attachments.MapCount; attachment++) - { - _attachments.Map[attachment] = DrawBuffersEnum.ColorAttachment0 + map[attachment]; - } - } - else - { - _attachments.MapCount = 0; - } - } - - public void SetTransform(bool flipX, bool flipY, int top, int left, int right, int bottom) - { - _flipX = flipX; - _flipY = flipY; - - _cropTop = top; - _cropLeft = left; - _cropRight = right; - _cropBottom = bottom; - } - - public void SetWindowSize(int width, int height) - { - _window = new Rect(0, 0, width, height); - } - - public void SetViewport(int attachment, int x, int y, int width, int height) - { - int offset = attachment * 4; - - _viewports[offset + 0] = x; - _viewports[offset + 1] = y; - _viewports[offset + 2] = width; - _viewports[offset + 3] = height; - } - - public void Render() - { - if (_readTex == null) - { - return; - } - - int srcX0, srcX1, srcY0, srcY1; - - if (_cropLeft == 0 && _cropRight == 0) - { - srcX0 = 0; - srcX1 = _readTex.Width; - } - else - { - srcX0 = _cropLeft; - srcX1 = _cropRight; - } - - if (_cropTop == 0 && _cropBottom == 0) - { - srcY0 = 0; - srcY1 = _readTex.Height; - } - else - { - srcY0 = _cropTop; - srcY1 = _cropBottom; - } - - float ratioX = MathF.Min(1f, (_window.Height * (float)NativeWidth) / ((float)NativeHeight * _window.Width)); - float ratioY = MathF.Min(1f, (_window.Width * (float)NativeHeight) / ((float)NativeWidth * _window.Height)); - - int dstWidth = (int)(_window.Width * ratioX); - int dstHeight = (int)(_window.Height * ratioY); - - int dstPaddingX = (_window.Width - dstWidth) / 2; - int dstPaddingY = (_window.Height - dstHeight) / 2; - - int dstX0 = _flipX ? _window.Width - dstPaddingX : dstPaddingX; - int dstX1 = _flipX ? dstPaddingX : _window.Width - dstPaddingX; - - int dstY0 = _flipY ? dstPaddingY : _window.Height - dstPaddingY; - int dstY1 = _flipY ? _window.Height - dstPaddingY : dstPaddingY; - - GL.Viewport(0, 0, _window.Width, _window.Height); - - if (_srcFb == 0) - { - _srcFb = GL.GenFramebuffer(); - } - - GL.BindFramebuffer(FramebufferTarget.ReadFramebuffer, _srcFb); - GL.BindFramebuffer(FramebufferTarget.DrawFramebuffer, 0); - - GL.FramebufferTexture(FramebufferTarget.ReadFramebuffer, FramebufferAttachment.ColorAttachment0, _readTex.Handle, 0); - - GL.ReadBuffer(ReadBufferMode.ColorAttachment0); - - GL.Clear(ClearBufferMask.ColorBufferBit); - - GL.Disable(EnableCap.FramebufferSrgb); - - GL.BlitFramebuffer( - srcX0, - srcY0, - srcX1, - srcY1, - dstX0, - dstY0, - dstX1, - dstY1, - ClearBufferMask.ColorBufferBit, - BlitFramebufferFilter.Linear); - - if (FramebufferSrgb) - { - GL.Enable(EnableCap.FramebufferSrgb); - } - } - - public void Copy( - GalImage srcImage, - GalImage dstImage, - long srcKey, - long dstKey, - int srcLayer, - int dstLayer, - int srcX0, - int srcY0, - int srcX1, - int srcY1, - int dstX0, - int dstY0, - int dstX1, - int dstY1) - { - if (_texture.TryGetImageHandler(srcKey, out ImageHandler srcTex) && - _texture.TryGetImageHandler(dstKey, out ImageHandler dstTex)) - { - if (srcTex.HasColor != dstTex.HasColor || - srcTex.HasDepth != dstTex.HasDepth || - srcTex.HasStencil != dstTex.HasStencil) - { - throw new NotImplementedException(); - } - - if (_srcFb == 0) - { - _srcFb = GL.GenFramebuffer(); - } - - if (_dstFb == 0) - { - _dstFb = GL.GenFramebuffer(); - } - - GL.BindFramebuffer(FramebufferTarget.ReadFramebuffer, _srcFb); - GL.BindFramebuffer(FramebufferTarget.DrawFramebuffer, _dstFb); - - FramebufferAttachment attachment = GetAttachment(srcTex); - - if (ImageUtils.IsArray(srcImage.TextureTarget) && srcLayer > 0) - { - GL.FramebufferTextureLayer(FramebufferTarget.ReadFramebuffer, attachment, srcTex.Handle, 0, srcLayer); - } - else - { - GL.FramebufferTexture(FramebufferTarget.ReadFramebuffer, attachment, srcTex.Handle, 0); - } - - if (ImageUtils.IsArray(dstImage.TextureTarget) && dstLayer > 0) - { - GL.FramebufferTextureLayer(FramebufferTarget.DrawFramebuffer, attachment, dstTex.Handle, 0, dstLayer); - } - else - { - GL.FramebufferTexture(FramebufferTarget.DrawFramebuffer, attachment, dstTex.Handle, 0); - } - - - BlitFramebufferFilter filter = BlitFramebufferFilter.Nearest; - - if (srcTex.HasColor) - { - GL.DrawBuffer(DrawBufferMode.ColorAttachment0); - - filter = BlitFramebufferFilter.Linear; - } - - ClearBufferMask mask = GetClearMask(srcTex); - - GL.BlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter); - } - } - - public void Reinterpret(long key, GalImage newImage) - { - if (!_texture.TryGetImage(key, out GalImage oldImage)) - { - return; - } - - if (newImage.Format == oldImage.Format && - newImage.Width == oldImage.Width && - newImage.Height == oldImage.Height && - newImage.Depth == oldImage.Depth && - newImage.LayerCount == oldImage.LayerCount && - newImage.TextureTarget == oldImage.TextureTarget) - { - return; - } - - if (_copyPbo == 0) - { - _copyPbo = GL.GenBuffer(); - } - - GL.BindBuffer(BufferTarget.PixelPackBuffer, _copyPbo); - - // The buffer should be large enough to hold the largest texture. - int bufferSize = Math.Max(ImageUtils.GetSize(oldImage), - ImageUtils.GetSize(newImage)); - - GL.BufferData(BufferTarget.PixelPackBuffer, bufferSize, IntPtr.Zero, BufferUsageHint.StreamCopy); - - if (!_texture.TryGetImageHandler(key, out ImageHandler cachedImage)) - { - throw new InvalidOperationException(); - } - - (_, PixelFormat format, PixelType type) = OglEnumConverter.GetImageFormat(cachedImage.Format); - - TextureTarget target = ImageUtils.GetTextureTarget(newImage.TextureTarget); - - GL.BindTexture(target, cachedImage.Handle); - - GL.GetTexImage(target, 0, format, type, IntPtr.Zero); - - GL.BindBuffer(BufferTarget.PixelPackBuffer, 0); - GL.BindBuffer(BufferTarget.PixelUnpackBuffer, _copyPbo); - - GL.PixelStore(PixelStoreParameter.UnpackRowLength, oldImage.Width); - - _texture.Create(key, ImageUtils.GetSize(newImage), newImage); - - GL.PixelStore(PixelStoreParameter.UnpackRowLength, 0); - - GL.BindBuffer(BufferTarget.PixelUnpackBuffer, 0); - } - - private static FramebufferAttachment GetAttachment(ImageHandler cachedImage) - { - if (cachedImage.HasColor) - { - return FramebufferAttachment.ColorAttachment0; - } - else if (cachedImage.HasDepth && cachedImage.HasStencil) - { - return FramebufferAttachment.DepthStencilAttachment; - } - else if (cachedImage.HasDepth) - { - return FramebufferAttachment.DepthAttachment; - } - else if (cachedImage.HasStencil) - { - return FramebufferAttachment.StencilAttachment; - } - else - { - throw new InvalidOperationException(); - } - } - - private static ClearBufferMask GetClearMask(ImageHandler cachedImage) - { - return (cachedImage.HasColor ? ClearBufferMask.ColorBufferBit : 0) | - (cachedImage.HasDepth ? ClearBufferMask.DepthBufferBit : 0) | - (cachedImage.HasStencil ? ClearBufferMask.StencilBufferBit : 0); - } - } -}
\ No newline at end of file diff --git a/Ryujinx.Graphics/Gal/OpenGL/OglRenderer.cs b/Ryujinx.Graphics/Gal/OpenGL/OglRenderer.cs deleted file mode 100644 index 1ff8c7ad..00000000 --- a/Ryujinx.Graphics/Gal/OpenGL/OglRenderer.cs +++ /dev/null @@ -1,58 +0,0 @@ -using System; -using System.Collections.Concurrent; - -namespace Ryujinx.Graphics.Gal.OpenGL -{ - public class OglRenderer : IGalRenderer - { - public IGalConstBuffer Buffer { get; private set; } - - public IGalRenderTarget RenderTarget { get; private set; } - - public IGalRasterizer Rasterizer { get; private set; } - - public IGalShader Shader { get; private set; } - - public IGalPipeline Pipeline { get; private set; } - - public IGalTexture Texture { get; private set; } - - private ConcurrentQueue<Action> _actionsQueue; - - public OglRenderer() - { - Buffer = new OglConstBuffer(); - - Texture = new OglTexture(); - - RenderTarget = new OglRenderTarget(Texture as OglTexture); - - Rasterizer = new OglRasterizer(); - - Shader = new OglShader(Buffer as OglConstBuffer); - - Pipeline = new OglPipeline( - Buffer as OglConstBuffer, - RenderTarget as OglRenderTarget, - Rasterizer as OglRasterizer, - Shader as OglShader); - - _actionsQueue = new ConcurrentQueue<Action>(); - } - - public void QueueAction(Action actionMthd) - { - _actionsQueue.Enqueue(actionMthd); - } - - public void RunActions() - { - int count = _actionsQueue.Count; - - while (count-- > 0 && _actionsQueue.TryDequeue(out Action renderAction)) - { - renderAction(); - } - } - } -}
\ No newline at end of file diff --git a/Ryujinx.Graphics/Gal/OpenGL/OglShader.cs b/Ryujinx.Graphics/Gal/OpenGL/OglShader.cs deleted file mode 100644 index 8da0104e..00000000 --- a/Ryujinx.Graphics/Gal/OpenGL/OglShader.cs +++ /dev/null @@ -1,291 +0,0 @@ -using OpenTK.Graphics.OpenGL; -using Ryujinx.Graphics.Shader; -using Ryujinx.Graphics.Shader.Translation; -using System; -using System.Collections.Concurrent; -using System.Collections.Generic; -using System.Linq; - -namespace Ryujinx.Graphics.Gal.OpenGL -{ - class OglShader : IGalShader - { - public const int ReservedCbufCount = 1; - - private const int ExtraDataSize = 4; - - public OglShaderProgram Current; - - private ConcurrentDictionary<long, OglShaderStage> _stages; - - private Dictionary<OglShaderProgram, int> _programs; - - public int CurrentProgramHandle { get; private set; } - - private OglConstBuffer _buffer; - - private int _extraUboHandle; - - public OglShader(OglConstBuffer buffer) - { - _buffer = buffer; - - _stages = new ConcurrentDictionary<long, OglShaderStage>(); - - _programs = new Dictionary<OglShaderProgram, int>(); - } - - public void Create(IGalMemory memory, long key, GalShaderType type) - { - _stages.GetOrAdd(key, (stage) => ShaderStageFactory(memory, key, 0, false, type)); - } - - public void Create(IGalMemory memory, long vpAPos, long key, GalShaderType type) - { - _stages.GetOrAdd(key, (stage) => ShaderStageFactory(memory, vpAPos, key, true, type)); - } - - private OglShaderStage ShaderStageFactory( - IGalMemory memory, - long position, - long positionB, - bool isDualVp, - GalShaderType type) - { - ShaderConfig config = new ShaderConfig(type, OglLimit.MaxUboSize); - - ShaderProgram program; - - if (isDualVp) - { - ShaderDumper.Dump(memory, position, type, "a"); - ShaderDumper.Dump(memory, positionB, type, "b"); - - program = Translator.Translate(memory, (ulong)position, (ulong)positionB, config); - } - else - { - ShaderDumper.Dump(memory, position, type); - - program = Translator.Translate(memory, (ulong)position, config); - } - - string code = program.Code; - - if (ShaderDumper.IsDumpEnabled()) - { - int shaderDumpIndex = ShaderDumper.DumpIndex; - - code = "//Shader " + shaderDumpIndex + Environment.NewLine + code; - } - - return new OglShaderStage(type, code, program.Info.CBuffers, program.Info.Textures); - } - - public IEnumerable<CBufferDescriptor> GetConstBufferUsage(long key) - { - if (_stages.TryGetValue(key, out OglShaderStage stage)) - { - return stage.ConstBufferUsage; - } - - return Enumerable.Empty<CBufferDescriptor>(); - } - - public IEnumerable<TextureDescriptor> GetTextureUsage(long key) - { - if (_stages.TryGetValue(key, out OglShaderStage stage)) - { - return stage.TextureUsage; - } - - return Enumerable.Empty<TextureDescriptor>(); - } - - public unsafe void SetExtraData(float flipX, float flipY, int instance) - { - BindProgram(); - - EnsureExtraBlock(); - - GL.BindBuffer(BufferTarget.UniformBuffer, _extraUboHandle); - - float* data = stackalloc float[ExtraDataSize]; - data[0] = flipX; - data[1] = flipY; - data[2] = BitConverter.Int32BitsToSingle(instance); - - // Invalidate buffer - GL.BufferData(BufferTarget.UniformBuffer, ExtraDataSize * sizeof(float), IntPtr.Zero, BufferUsageHint.StreamDraw); - - GL.BufferSubData(BufferTarget.UniformBuffer, IntPtr.Zero, ExtraDataSize * sizeof(float), (IntPtr)data); - } - - public void Bind(long key) - { - if (_stages.TryGetValue(key, out OglShaderStage stage)) - { - Bind(stage); - } - } - - private void Bind(OglShaderStage stage) - { - switch (stage.Type) - { - case GalShaderType.Vertex: Current.Vertex = stage; break; - case GalShaderType.TessControl: Current.TessControl = stage; break; - case GalShaderType.TessEvaluation: Current.TessEvaluation = stage; break; - case GalShaderType.Geometry: Current.Geometry = stage; break; - case GalShaderType.Fragment: Current.Fragment = stage; break; - } - } - - public void Unbind(GalShaderType type) - { - switch (type) - { - case GalShaderType.Vertex: Current.Vertex = null; break; - case GalShaderType.TessControl: Current.TessControl = null; break; - case GalShaderType.TessEvaluation: Current.TessEvaluation = null; break; - case GalShaderType.Geometry: Current.Geometry = null; break; - case GalShaderType.Fragment: Current.Fragment = null; break; - } - } - - public void BindProgram() - { - if (Current.Vertex == null || - Current.Fragment == null) - { - return; - } - - if (!_programs.TryGetValue(Current, out int handle)) - { - handle = GL.CreateProgram(); - - AttachIfNotNull(handle, Current.Vertex); - AttachIfNotNull(handle, Current.TessControl); - AttachIfNotNull(handle, Current.TessEvaluation); - AttachIfNotNull(handle, Current.Geometry); - AttachIfNotNull(handle, Current.Fragment); - - GL.LinkProgram(handle); - - CheckProgramLink(handle); - - BindUniformBlocks(handle); - BindTextureLocations(handle); - - _programs.Add(Current, handle); - } - - GL.UseProgram(handle); - - CurrentProgramHandle = handle; - } - - private void EnsureExtraBlock() - { - if (_extraUboHandle == 0) - { - _extraUboHandle = GL.GenBuffer(); - - GL.BindBuffer(BufferTarget.UniformBuffer, _extraUboHandle); - - GL.BufferData(BufferTarget.UniformBuffer, ExtraDataSize * sizeof(float), IntPtr.Zero, BufferUsageHint.StreamDraw); - - GL.BindBufferBase(BufferRangeTarget.UniformBuffer, 0, _extraUboHandle); - } - } - - private void AttachIfNotNull(int programHandle, OglShaderStage stage) - { - if (stage != null) - { - stage.Compile(); - - GL.AttachShader(programHandle, stage.Handle); - } - } - - private void BindUniformBlocks(int programHandle) - { - int extraBlockindex = GL.GetUniformBlockIndex(programHandle, "Extra"); - - GL.UniformBlockBinding(programHandle, extraBlockindex, 0); - - int freeBinding = ReservedCbufCount; - - void BindUniformBlocksIfNotNull(OglShaderStage stage) - { - if (stage != null) - { - foreach (CBufferDescriptor desc in stage.ConstBufferUsage) - { - int blockIndex = GL.GetUniformBlockIndex(programHandle, desc.Name); - - if (blockIndex < 0) - { - // This may be fine, the compiler may optimize away unused uniform buffers, - // and in this case the above call would return -1 as the buffer has been - // optimized away. - continue; - } - - GL.UniformBlockBinding(programHandle, blockIndex, freeBinding); - - freeBinding++; - } - } - } - - BindUniformBlocksIfNotNull(Current.Vertex); - BindUniformBlocksIfNotNull(Current.TessControl); - BindUniformBlocksIfNotNull(Current.TessEvaluation); - BindUniformBlocksIfNotNull(Current.Geometry); - BindUniformBlocksIfNotNull(Current.Fragment); - } - - private void BindTextureLocations(int programHandle) - { - int index = 0; - - void BindTexturesIfNotNull(OglShaderStage stage) - { - if (stage != null) - { - foreach (TextureDescriptor desc in stage.TextureUsage) - { - int location = GL.GetUniformLocation(programHandle, desc.Name); - - GL.Uniform1(location, index); - - index++; - } - } - } - - GL.UseProgram(programHandle); - - BindTexturesIfNotNull(Current.Vertex); - BindTexturesIfNotNull(Current.TessControl); - BindTexturesIfNotNull(Current.TessEvaluation); - BindTexturesIfNotNull(Current.Geometry); - BindTexturesIfNotNull(Current.Fragment); - } - - private static void CheckProgramLink(int handle) - { - int status = 0; - - GL.GetProgram(handle, GetProgramParameterName.LinkStatus, out status); - - if (status == 0) - { - throw new ShaderException(GL.GetProgramInfoLog(handle)); - } - } - } -}
\ No newline at end of file diff --git a/Ryujinx.Graphics/Gal/OpenGL/OglShaderProgram.cs b/Ryujinx.Graphics/Gal/OpenGL/OglShaderProgram.cs deleted file mode 100644 index 86126bca..00000000 --- a/Ryujinx.Graphics/Gal/OpenGL/OglShaderProgram.cs +++ /dev/null @@ -1,87 +0,0 @@ -using OpenTK.Graphics.OpenGL; -using Ryujinx.Graphics.Shader; -using System; -using System.Collections.Generic; - -namespace Ryujinx.Graphics.Gal.OpenGL -{ - struct OglShaderProgram - { - public OglShaderStage Vertex; - public OglShaderStage TessControl; - public OglShaderStage TessEvaluation; - public OglShaderStage Geometry; - public OglShaderStage Fragment; - } - - class OglShaderStage : IDisposable - { - public int Handle { get; private set; } - - public bool IsCompiled { get; private set; } - - public GalShaderType Type { get; private set; } - - public string Code { get; private set; } - - public IEnumerable<CBufferDescriptor> ConstBufferUsage { get; private set; } - public IEnumerable<TextureDescriptor> TextureUsage { get; private set; } - - public OglShaderStage( - GalShaderType type, - string code, - IEnumerable<CBufferDescriptor> constBufferUsage, - IEnumerable<TextureDescriptor> textureUsage) - { - Type = type; - Code = code; - ConstBufferUsage = constBufferUsage; - TextureUsage = textureUsage; - } - - public void Compile() - { - if (Handle == 0) - { - Handle = GL.CreateShader(OglEnumConverter.GetShaderType(Type)); - - CompileAndCheck(Handle, Code); - } - } - - public void Dispose() - { - Dispose(true); - } - - protected virtual void Dispose(bool disposing) - { - if (disposing && Handle != 0) - { - GL.DeleteShader(Handle); - - Handle = 0; - } - } - - public static void CompileAndCheck(int handle, string code) - { - GL.ShaderSource(handle, code); - GL.CompileShader(handle); - - CheckCompilation(handle); - } - - private static void CheckCompilation(int handle) - { - int status = 0; - - GL.GetShader(handle, ShaderParameter.CompileStatus, out status); - - if (status == 0) - { - throw new ShaderException(GL.GetShaderInfoLog(handle)); - } - } - } -}
\ No newline at end of file diff --git a/Ryujinx.Graphics/Gal/OpenGL/OglStreamBuffer.cs b/Ryujinx.Graphics/Gal/OpenGL/OglStreamBuffer.cs deleted file mode 100644 index 58b3ace5..00000000 --- a/Ryujinx.Graphics/Gal/OpenGL/OglStreamBuffer.cs +++ /dev/null @@ -1,55 +0,0 @@ -using OpenTK.Graphics.OpenGL; -using System; - -namespace Ryujinx.Graphics.Gal.OpenGL -{ - class OglStreamBuffer : IDisposable - { - public int Handle { get; protected set; } - - public long Size { get; protected set; } - - protected BufferTarget Target { get; private set; } - - public OglStreamBuffer(BufferTarget target, long size) - { - Target = target; - Size = size; - - Handle = GL.GenBuffer(); - - GL.BindBuffer(target, Handle); - - GL.BufferData(target, (IntPtr)size, IntPtr.Zero, BufferUsageHint.StreamDraw); - } - - public void SetData(long size, IntPtr hostAddress) - { - GL.BindBuffer(Target, Handle); - - GL.BufferSubData(Target, IntPtr.Zero, (IntPtr)size, hostAddress); - } - - public void SetData(byte[] data) - { - GL.BindBuffer(Target, Handle); - - GL.BufferSubData(Target, IntPtr.Zero, (IntPtr)data.Length, data); - } - - public void Dispose() - { - Dispose(true); - } - - protected virtual void Dispose(bool disposing) - { - if (disposing && Handle != 0) - { - GL.DeleteBuffer(Handle); - - Handle = 0; - } - } - } -} diff --git a/Ryujinx.Graphics/Gal/OpenGL/OglTexture.cs b/Ryujinx.Graphics/Gal/OpenGL/OglTexture.cs deleted file mode 100644 index b5ac6692..00000000 --- a/Ryujinx.Graphics/Gal/OpenGL/OglTexture.cs +++ /dev/null @@ -1,408 +0,0 @@ -using OpenTK.Graphics.OpenGL; -using Ryujinx.Graphics.Texture; -using System; - -namespace Ryujinx.Graphics.Gal.OpenGL -{ - class OglTexture : IGalTexture - { - private const long MaxTextureCacheSize = 768 * 1024 * 1024; - - private OglCachedResource<ImageHandler> _textureCache; - - public EventHandler<int> TextureDeleted { get; set; } - - public OglTexture() - { - _textureCache = new OglCachedResource<ImageHandler>(DeleteTexture, MaxTextureCacheSize); - } - - public void LockCache() - { - _textureCache.Lock(); - } - - public void UnlockCache() - { - _textureCache.Unlock(); - } - - private void DeleteTexture(ImageHandler cachedImage) - { - TextureDeleted?.Invoke(this, cachedImage.Handle); - - GL.DeleteTexture(cachedImage.Handle); - } - - public void Create(long key, int size, GalImage image) - { - int handle = GL.GenTexture(); - - TextureTarget target = ImageUtils.GetTextureTarget(image.TextureTarget); - - GL.BindTexture(target, handle); - - const int level = 0; //TODO: Support mipmap textures. - const int border = 0; - - _textureCache.AddOrUpdate(key, new ImageHandler(handle, image), (uint)size); - - if (ImageUtils.IsCompressed(image.Format)) - { - throw new InvalidOperationException("Surfaces with compressed formats are not supported!"); - } - - (PixelInternalFormat internalFmt, - PixelFormat format, - PixelType type) = OglEnumConverter.GetImageFormat(image.Format); - - switch (target) - { - case TextureTarget.Texture1D: - GL.TexImage1D( - target, - level, - internalFmt, - image.Width, - border, - format, - type, - IntPtr.Zero); - break; - - case TextureTarget.Texture2D: - GL.TexImage2D( - target, - level, - internalFmt, - image.Width, - image.Height, - border, - format, - type, - IntPtr.Zero); - break; - case TextureTarget.Texture3D: - GL.TexImage3D( - target, - level, - internalFmt, - image.Width, - image.Height, - image.Depth, - border, - format, - type, - IntPtr.Zero); - break; - // Cube map arrays are just 2D texture arrays with 6 entries - // per cube map so we can handle them in the same way - case TextureTarget.TextureCubeMapArray: - case TextureTarget.Texture2DArray: - GL.TexImage3D( - target, - level, - internalFmt, - image.Width, - image.Height, - image.LayerCount, - border, - format, - type, - IntPtr.Zero); - break; - default: - throw new NotImplementedException($"Unsupported texture target type: {target}"); - } - } - - public void Create(long key, byte[] data, GalImage image) - { - int handle = GL.GenTexture(); - - TextureTarget target = ImageUtils.GetTextureTarget(image.TextureTarget); - - GL.BindTexture(target, handle); - - const int level = 0; //TODO: Support mipmap textures. - const int border = 0; - - _textureCache.AddOrUpdate(key, new ImageHandler(handle, image), (uint)data.Length); - - if (ImageUtils.IsCompressed(image.Format) && !IsAstc(image.Format)) - { - InternalFormat internalFmt = OglEnumConverter.GetCompressedImageFormat(image.Format); - - switch (target) - { - case TextureTarget.Texture1D: - GL.CompressedTexImage1D( - target, - level, - internalFmt, - image.Width, - border, - data.Length, - data); - break; - case TextureTarget.Texture2D: - GL.CompressedTexImage2D( - target, - level, - internalFmt, - image.Width, - image.Height, - border, - data.Length, - data); - break; - case TextureTarget.Texture3D: - GL.CompressedTexImage3D( - target, - level, - internalFmt, - image.Width, - image.Height, - image.Depth, - border, - data.Length, - data); - break; - // Cube map arrays are just 2D texture arrays with 6 entries - // per cube map so we can handle them in the same way - case TextureTarget.TextureCubeMapArray: - case TextureTarget.Texture2DArray: - GL.CompressedTexImage3D( - target, - level, - internalFmt, - image.Width, - image.Height, - image.LayerCount, - border, - data.Length, - data); - break; - case TextureTarget.TextureCubeMap: - Span<byte> array = new Span<byte>(data); - - int faceSize = ImageUtils.GetSize(image) / 6; - - for (int Face = 0; Face < 6; Face++) - { - GL.CompressedTexImage2D( - TextureTarget.TextureCubeMapPositiveX + Face, - level, - internalFmt, - image.Width, - image.Height, - border, - faceSize, - array.Slice(Face * faceSize, faceSize).ToArray()); - } - break; - default: - throw new NotImplementedException($"Unsupported texture target type: {target}"); - } - } - else - { - // TODO: Use KHR_texture_compression_astc_hdr when available - if (IsAstc(image.Format)) - { - int textureBlockWidth = ImageUtils.GetBlockWidth(image.Format); - int textureBlockHeight = ImageUtils.GetBlockHeight(image.Format); - int textureBlockDepth = ImageUtils.GetBlockDepth(image.Format); - - data = AstcDecoder.DecodeToRgba8888( - data, - textureBlockWidth, - textureBlockHeight, - textureBlockDepth, - image.Width, - image.Height, - image.Depth); - - image.Format = GalImageFormat.Rgba8 | (image.Format & GalImageFormat.TypeMask); - } - - (PixelInternalFormat internalFmt, - PixelFormat format, - PixelType type) = OglEnumConverter.GetImageFormat(image.Format); - - - switch (target) - { - case TextureTarget.Texture1D: - GL.TexImage1D( - target, - level, - internalFmt, - image.Width, - border, - format, - type, - data); - break; - case TextureTarget.Texture2D: - GL.TexImage2D( - target, - level, - internalFmt, - image.Width, - image.Height, - border, - format, - type, - data); - break; - case TextureTarget.Texture3D: - GL.TexImage3D( - target, - level, - internalFmt, - image.Width, - image.Height, - image.Depth, - border, - format, - type, - data); - break; - // Cube map arrays are just 2D texture arrays with 6 entries - // per cube map so we can handle them in the same way - case TextureTarget.TextureCubeMapArray: - case TextureTarget.Texture2DArray: - GL.TexImage3D( - target, - level, - internalFmt, - image.Width, - image.Height, - image.LayerCount, - border, - format, - type, - data); - break; - case TextureTarget.TextureCubeMap: - Span<byte> array = new Span<byte>(data); - - int faceSize = ImageUtils.GetSize(image) / 6; - - for (int face = 0; face < 6; face++) - { - GL.TexImage2D( - TextureTarget.TextureCubeMapPositiveX + face, - level, - internalFmt, - image.Width, - image.Height, - border, - format, - type, - array.Slice(face * faceSize, faceSize).ToArray()); - } - break; - default: - throw new NotImplementedException($"Unsupported texture target type: {target}"); - } - } - } - - private static bool IsAstc(GalImageFormat format) - { - format &= GalImageFormat.FormatMask; - - return format > GalImageFormat.Astc2DStart && format < GalImageFormat.Astc2DEnd; - } - - public bool TryGetImage(long key, out GalImage image) - { - if (_textureCache.TryGetValue(key, out ImageHandler cachedImage)) - { - image = cachedImage.Image; - - return true; - } - - image = default(GalImage); - - return false; - } - - public bool TryGetImageHandler(long key, out ImageHandler cachedImage) - { - if (_textureCache.TryGetValue(key, out cachedImage)) - { - return true; - } - - cachedImage = null; - - return false; - } - - public void Bind(long key, int index, GalImage image) - { - if (_textureCache.TryGetValue(key, out ImageHandler cachedImage)) - { - GL.ActiveTexture(TextureUnit.Texture0 + index); - - TextureTarget target = ImageUtils.GetTextureTarget(image.TextureTarget); - - GL.BindTexture(target, cachedImage.Handle); - - int[] swizzleRgba = new int[] - { - (int)OglEnumConverter.GetTextureSwizzle(image.XSource), - (int)OglEnumConverter.GetTextureSwizzle(image.YSource), - (int)OglEnumConverter.GetTextureSwizzle(image.ZSource), - (int)OglEnumConverter.GetTextureSwizzle(image.WSource) - }; - - GL.TexParameter(target, TextureParameterName.TextureSwizzleRgba, swizzleRgba); - } - } - - public void SetSampler(GalImage image, GalTextureSampler sampler) - { - int wrapS = (int)OglEnumConverter.GetTextureWrapMode(sampler.AddressU); - int wrapT = (int)OglEnumConverter.GetTextureWrapMode(sampler.AddressV); - int wrapR = (int)OglEnumConverter.GetTextureWrapMode(sampler.AddressP); - - int minFilter = (int)OglEnumConverter.GetTextureMinFilter(sampler.MinFilter, sampler.MipFilter); - int magFilter = (int)OglEnumConverter.GetTextureMagFilter(sampler.MagFilter); - - TextureTarget target = ImageUtils.GetTextureTarget(image.TextureTarget); - - GL.TexParameter(target, TextureParameterName.TextureWrapS, wrapS); - GL.TexParameter(target, TextureParameterName.TextureWrapT, wrapT); - GL.TexParameter(target, TextureParameterName.TextureWrapR, wrapR); - - GL.TexParameter(target, TextureParameterName.TextureMinFilter, minFilter); - GL.TexParameter(target, TextureParameterName.TextureMagFilter, magFilter); - - float[] color = new float[] - { - sampler.BorderColor.Red, - sampler.BorderColor.Green, - sampler.BorderColor.Blue, - sampler.BorderColor.Alpha - }; - - GL.TexParameter(target, TextureParameterName.TextureBorderColor, color); - - if (sampler.DepthCompare) - { - GL.TexParameter(target, TextureParameterName.TextureCompareMode, (int)All.CompareRToTexture); - GL.TexParameter(target, TextureParameterName.TextureCompareFunc, (int)OglEnumConverter.GetDepthCompareFunc(sampler.DepthCompareFunc)); - } - else - { - GL.TexParameter(target, TextureParameterName.TextureCompareMode, (int)All.None); - GL.TexParameter(target, TextureParameterName.TextureCompareFunc, (int)All.Never); - } - } - } -} |