+ public enum GalSurfaceFormat

+using System;

+

+namespace Ryujinx.Graphics.Gal

+ [Flags]

+ Snorm = 1 << 27,

+ Unorm = 1 << 28,

+ Sint = 1 << 29,

+ Uint = 1 << 30,

+ Sfloat = 1 << 31,

+ TypeMask = Snorm | Unorm | Sint | Uint | Sfloat,

+ FormatMask = ~TypeMask,

+ ASTC_BEGIN = ASTC_4x4,

+ ASTC_4x4 = 1,

+ ASTC_5x4,

+ ASTC_5x5,

+ ASTC_6x5,

+ ASTC_6x6,

+ ASTC_8x5,

+ ASTC_8x6,

+ ASTC_8x8,

+ ASTC_10x5,

+ ASTC_10x6,

+ ASTC_10x8,

+ ASTC_10x10,

+ ASTC_12x10,

+ ASTC_12x12,

+ ASTC_END = ASTC_12x12,

+ R4G4,

+ R4G4B4A4,

+ B4G4R4A4,

+ A4B4G4R4,

+ R5G6B5,

+ B5G6R5,

+ R5G5B5A1,

+ B5G5R5A1,

+ A1R5G5B5,

+ R8,

+ R8G8,

+ G8R8,

+ R8G8B8,

+ B8G8R8,

+ R8G8B8A8,

+ B8G8R8A8,

+ A8B8G8R8,

+ A8B8G8R8_SRGB,

+ A2R10G10B10,

+ A2B10G10R10,

+ R16,

+ R16G16,

+ R16G16B16,

+ R16G16B16A16,

+ R32,

+ R32G32,

+ R32G32B32,

+ R32G32B32A32,

+ R64,

+ R64G64,

+ R64G64B64,

+ R64G64B64A64,

+ B10G11R11,

+ E5B9G9R9,

+ D16,

+ X8_D24,

+ D32,

+ S8,

+ D16_S8,

+ D24_S8,

+ D32_S8,

+ BC1_RGB,

+ BC1_RGBA,

+ BC2,

+ BC3,

+ BC4,

+ BC5,

+ BC6H_SF16,

+ BC6H_UF16,

+ BC7,

+ ETC2_R8G8B8,

+ ETC2_R8G8B8A1,

+ ETC2_R8G8B8A8,

+ EAC_R11,

+ EAC_R11G11,

+ public interface IGalRenderTarget

+ IGalRenderTarget RenderTarget { get; }

+using Ryujinx.Graphics.Texture;

+ public void EnsureSetup(GalImage NewImage)

+ if (Width == NewImage.Width &&

+ Height == NewImage.Height &&

+ Format == NewImage.Format &&

+ Initialized)

+ return;

+ }

+ PixelInternalFormat InternalFmt;

+ PixelFormat PixelFormat;

+ PixelType PixelType;

+ if (ImageUtils.IsCompressed(NewImage.Format))

+ {

+ InternalFmt = (PixelInternalFormat)OGLEnumConverter.GetCompressedImageFormat(NewImage.Format);

+

+ PixelFormat = default(PixelFormat);

+ PixelType = default(PixelType);

+ }

+ else

+ {

+ (InternalFmt, PixelFormat, PixelType) = OGLEnumConverter.GetImageFormat(NewImage.Format);

+ }

+ GL.BindTexture(TextureTarget.Texture2D, Handle);

+ if (Initialized)

+ {

+ if (CopyBuffer == 0)

+ {

+ CopyBuffer = GL.GenBuffer();

+ }

+ int CurrentSize = Math.Max(ImageUtils.GetSize(NewImage),

+ ImageUtils.GetSize(Image));

+ GL.BindBuffer(BufferTarget.PixelPackBuffer, CopyBuffer);

+ GL.BindBuffer(BufferTarget.PixelUnpackBuffer, CopyBuffer);

+ if (CopyBufferSize < CurrentSize)

+ {

+ CopyBufferSize = CurrentSize;

+ GL.BufferData(BufferTarget.PixelPackBuffer, CurrentSize, IntPtr.Zero, BufferUsageHint.StreamCopy);

+ }

+

+ if (ImageUtils.IsCompressed(Image.Format))

+ {

+ GL.GetCompressedTexImage(TextureTarget.Texture2D, 0, IntPtr.Zero);

+ }

+ else

+ {

+ }

+ GL.DeleteTexture(Handle);

+ Handle = GL.GenTexture();

+ GL.BindTexture(TextureTarget.Texture2D, Handle);

+ }

+ const int MinFilter = (int)TextureMinFilter.Linear;

+ const int MagFilter = (int)TextureMagFilter.Linear;

+ GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMinFilter, MinFilter);

+ GL.TexParameter(TextureTarget.Texture2D, TextureParameterName.TextureMagFilter, MagFilter);

+ const int Level = 0;

+ const int Border = 0;

+ if (ImageUtils.IsCompressed(NewImage.Format))

+ {

+ Console.WriteLine("Hit");

+

+ GL.CompressedTexImage2D(

+ TextureTarget.Texture2D,

+ Level,

+ (InternalFormat)InternalFmt,

+ NewImage.Width,

+ NewImage.Height,

+ Border,

+ ImageUtils.GetSize(NewImage),

+ IntPtr.Zero);

+ }

+ else

+ {

+ InternalFmt,

+ NewImage.Width,

+ NewImage.Height,

+ }

+ if (Initialized)

+ {

+ GL.BindBuffer(BufferTarget.PixelPackBuffer, 0);

+ GL.BindBuffer(BufferTarget.PixelUnpackBuffer, 0);

+ }

+ Image = NewImage;

+ this.InternalFormat = InternalFmt;

+ this.PixelFormat = PixelFormat;

+ this.PixelType = PixelType;

+ Initialized = true;

+ public bool HasColor => ImageUtils.HasColor(Image.Format);

+ public bool HasDepth => ImageUtils.HasDepth(Image.Format);

+ public bool HasStencil => ImageUtils.HasStencil(Image.Format);

+ case GalImageFormat.R32G32B32A32 | GalImageFormat.Sfloat: return (PixelInternalFormat.Rgba32f, PixelFormat.Rgba, PixelType.Float);

+ case GalImageFormat.R32G32B32A32 | GalImageFormat.Sint: return (PixelInternalFormat.Rgba32i, PixelFormat.RgbaInteger, PixelType.Int);

+ case GalImageFormat.R32G32B32A32 | GalImageFormat.Uint: return (PixelInternalFormat.Rgba32ui, PixelFormat.RgbaInteger, PixelType.UnsignedInt);

+ case GalImageFormat.R16G16B16A16 | GalImageFormat.Sfloat: return (PixelInternalFormat.Rgba16f, PixelFormat.Rgba, PixelType.HalfFloat);

+ case GalImageFormat.R16G16B16A16 | GalImageFormat.Sint: return (PixelInternalFormat.Rgba16i, PixelFormat.RgbaInteger, PixelType.Short);

+ case GalImageFormat.R16G16B16A16 | GalImageFormat.Uint: return (PixelInternalFormat.Rgba16ui, PixelFormat.RgbaInteger, PixelType.UnsignedShort);

+ case GalImageFormat.R32G32 | GalImageFormat.Sfloat: return (PixelInternalFormat.Rg32f, PixelFormat.Rg, PixelType.Float);

+ case GalImageFormat.R32G32 | GalImageFormat.Sint: return (PixelInternalFormat.Rg32i, PixelFormat.RgInteger, PixelType.Int);

+ case GalImageFormat.R32G32 | GalImageFormat.Uint: return (PixelInternalFormat.Rg32ui, PixelFormat.RgInteger, PixelType.UnsignedInt);

+ case GalImageFormat.A8B8G8R8 | GalImageFormat.Snorm: return (PixelInternalFormat.Rgba8Snorm, PixelFormat.Rgba, PixelType.Byte);

+ case GalImageFormat.A8B8G8R8 | GalImageFormat.Unorm: return (PixelInternalFormat.Rgba8, PixelFormat.Rgba, PixelType.UnsignedByte);

+ case GalImageFormat.A8B8G8R8 | GalImageFormat.Sint: return (PixelInternalFormat.Rgba8i, PixelFormat.RgbaInteger, PixelType.Byte);

+ case GalImageFormat.A8B8G8R8 | GalImageFormat.Uint: return (PixelInternalFormat.Rgba8ui, PixelFormat.RgbaInteger, PixelType.UnsignedByte);

+ case GalImageFormat.A8B8G8R8_SRGB: return (PixelInternalFormat.Srgb8Alpha8, PixelFormat.Rgba, PixelType.UnsignedByte);

+ case GalImageFormat.A4B4G4R4 | GalImageFormat.Unorm: return (PixelInternalFormat.Rgba4, PixelFormat.Rgba, PixelType.UnsignedShort4444Reversed);

+ case GalImageFormat.A2B10G10R10 | GalImageFormat.Uint: return (PixelInternalFormat.Rgb10A2ui, PixelFormat.RgbaInteger, PixelType.UnsignedInt2101010Reversed);

+ case GalImageFormat.A2B10G10R10 | GalImageFormat.Unorm: return (PixelInternalFormat.Rgb10A2, PixelFormat.Rgba, PixelType.UnsignedInt2101010Reversed);

+ case GalImageFormat.R32 | GalImageFormat.Sfloat: 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.A1R5G5B5 | GalImageFormat.Unorm: return (PixelInternalFormat.Rgb5A1, PixelFormat.Rgba, PixelType.UnsignedShort5551);

+ case GalImageFormat.B5G6R5 | GalImageFormat.Unorm: return (PixelInternalFormat.Rgba, PixelFormat.Rgb, PixelType.UnsignedShort565);

+ case GalImageFormat.R16G16 | GalImageFormat.Sfloat: return (PixelInternalFormat.Rg16f, PixelFormat.Rg, PixelType.HalfFloat);

+ case GalImageFormat.R16G16 | GalImageFormat.Sint: return (PixelInternalFormat.Rg16i, PixelFormat.RgInteger, PixelType.Short);

+ case GalImageFormat.R16G16 | GalImageFormat.Snorm: return (PixelInternalFormat.Rg16Snorm, PixelFormat.Rg, PixelType.Byte);

+ case GalImageFormat.R16G16 | GalImageFormat.Unorm: return (PixelInternalFormat.Rg16, PixelFormat.Rg, PixelType.UnsignedShort);

+ case GalImageFormat.R8G8 | GalImageFormat.Sint: return (PixelInternalFormat.Rg8i, PixelFormat.RgInteger, PixelType.Byte);

+ case GalImageFormat.R8G8 | GalImageFormat.Snorm: return (PixelInternalFormat.Rg8Snorm, PixelFormat.Rg, PixelType.Byte);

+ case GalImageFormat.R8G8 | GalImageFormat.Uint: return (PixelInternalFormat.Rg8ui, PixelFormat.RgInteger, PixelType.UnsignedByte);

+ case GalImageFormat.R8G8 | GalImageFormat.Unorm: return (PixelInternalFormat.Rg8, PixelFormat.Rg, PixelType.UnsignedByte);

+ case GalImageFormat.R16 | GalImageFormat.Sfloat: 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.Byte);

+ 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.B10G11R11 | GalImageFormat.Sfloat: return (PixelInternalFormat.R11fG11fB10f, PixelFormat.Rgb, PixelType.UnsignedInt10F11F11FRev);

+

+ case GalImageFormat.D24_S8 | GalImageFormat.Unorm: return (PixelInternalFormat.Depth24Stencil8, PixelFormat.DepthStencil, PixelType.UnsignedInt248);

+ case GalImageFormat.D32 | GalImageFormat.Sfloat: return (PixelInternalFormat.DepthComponent32f, PixelFormat.DepthComponent, PixelType.Float);

+ case GalImageFormat.D16 | GalImageFormat.Unorm: return (PixelInternalFormat.DepthComponent16, PixelFormat.DepthComponent, PixelType.UnsignedShort);

+ case GalImageFormat.D32_S8 | GalImageFormat.Uint: return (PixelInternalFormat.Depth32fStencil8, PixelFormat.DepthStencil, PixelType.Float32UnsignedInt248Rev);

+ case GalImageFormat.BC6H_UF16 | GalImageFormat.Unorm: return InternalFormat.CompressedRgbBptcUnsignedFloat;

+ case GalImageFormat.BC6H_SF16 | GalImageFormat.Unorm: return InternalFormat.CompressedRgbBptcSignedFloat;

+ case GalImageFormat.BC7 | GalImageFormat.Unorm: return InternalFormat.CompressedRgbaBptcUnorm;

+ case GalImageFormat.BC1_RGBA | GalImageFormat.Unorm: return InternalFormat.CompressedRgbaS3tcDxt1Ext;

+ case GalImageFormat.BC2 | GalImageFormat.Unorm: return InternalFormat.CompressedRgbaS3tcDxt3Ext;

+ case GalImageFormat.BC3 | GalImageFormat.Unorm: return InternalFormat.CompressedRgbaS3tcDxt5Ext;

+ 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;

+using Ryujinx.Graphics.Texture;

+ class OGLRenderTarget : IGalRenderTarget

+ private const GalImageFormat RawFormat = GalImageFormat.A8B8G8R8 | GalImageFormat.Unorm;

+ public OGLRenderTarget(OGLTexture Texture)

+ byte[] Data = new byte[ImageUtils.GetSize(Tex.Image)];

+ public IGalRenderTarget RenderTarget { get; private set; }

+ RenderTarget = new OGLRenderTarget(Texture as OGLTexture);

+using Ryujinx.Graphics.Texture;

+ GalImageFormat TypeLess = Image.Format & GalImageFormat.FormatMask;

+

+ bool IsASTC = TypeLess >= GalImageFormat.ASTC_BEGIN && TypeLess <= GalImageFormat.ASTC_END;

+

+ if (ImageUtils.IsCompressed(Image.Format) && !IsASTC)

+ //TODO: Use KHR_texture_compression_astc_hdr when available

+ if (IsASTC)

+ Image.Format = GalImageFormat.A8B8G8R8 | GalImageFormat.Unorm;

+ }

+ else if (TypeLess == GalImageFormat.G8R8)

+ {

+ Data = ImageConverter.G8R8ToR8G8(

+ Data,

+ Image.Width,

+ Image.Height,

+ 1);

+

+ Image.Format = GalImageFormat.R8G8 | (Image.Format & GalImageFormat.FormatMask);

+ case GalImageFormat.ASTC_4x4 | GalImageFormat.Unorm: return 4;

+ case GalImageFormat.ASTC_5x5 | GalImageFormat.Unorm: return 5;

+ case GalImageFormat.ASTC_6x6 | GalImageFormat.Unorm: return 6;

+ case GalImageFormat.ASTC_8x8 | GalImageFormat.Unorm: return 8;

+ case GalImageFormat.ASTC_10x10 | GalImageFormat.Unorm: return 10;

+ case GalImageFormat.ASTC_12x12 | GalImageFormat.Unorm: return 12;

+ case GalImageFormat.ASTC_5x4 | GalImageFormat.Unorm: return 5;

+ case GalImageFormat.ASTC_6x5 | GalImageFormat.Unorm: return 6;

+ case GalImageFormat.ASTC_8x6 | GalImageFormat.Unorm: return 8;

+ case GalImageFormat.ASTC_10x8 | GalImageFormat.Unorm: return 10;

+ case GalImageFormat.ASTC_12x10 | GalImageFormat.Unorm: return 12;

+ case GalImageFormat.ASTC_8x5 | GalImageFormat.Unorm: return 8;

+ case GalImageFormat.ASTC_10x5 | GalImageFormat.Unorm: return 10;

+ case GalImageFormat.ASTC_10x6 | GalImageFormat.Unorm: return 10;

+ case GalImageFormat.ASTC_4x4 | GalImageFormat.Unorm: return 4;

+ case GalImageFormat.ASTC_5x5 | GalImageFormat.Unorm: return 5;

+ case GalImageFormat.ASTC_6x6 | GalImageFormat.Unorm: return 6;

+ case GalImageFormat.ASTC_8x8 | GalImageFormat.Unorm: return 8;

+ case GalImageFormat.ASTC_10x10 | GalImageFormat.Unorm: return 10;

+ case GalImageFormat.ASTC_12x12 | GalImageFormat.Unorm: return 12;

+ case GalImageFormat.ASTC_5x4 | GalImageFormat.Unorm: return 4;

+ case GalImageFormat.ASTC_6x5 | GalImageFormat.Unorm: return 5;

+ case GalImageFormat.ASTC_8x6 | GalImageFormat.Unorm: return 6;

+ case GalImageFormat.ASTC_10x8 | GalImageFormat.Unorm: return 8;

+ case GalImageFormat.ASTC_12x10 | GalImageFormat.Unorm: return 10;

+ case GalImageFormat.ASTC_8x5 | GalImageFormat.Unorm: return 5;

+ case GalImageFormat.ASTC_10x5 | GalImageFormat.Unorm: return 5;

+ case GalImageFormat.ASTC_10x6 | GalImageFormat.Unorm: return 6;

+ ShaderIrNode OperA = OpCode.Gpr8();

+ ShaderIrNode OperB = OpCode.Immf32_20();

+ bool NegB = OpCode.Read(53);

+ bool AbsA = OpCode.Read(54);

+ bool NegA = OpCode.Read(56);

+ bool AbsB = OpCode.Read(57);

+ Block.AddNode(OpCode.PredNode(new ShaderIrAsg(OpCode.Gpr0(), Op)));

+ ShaderIrNode OperA = OpCode.Gpr8();

+ ShaderIrNode OperB = OpCode.Immf32_20();

+ Block.AddNode(OpCode.PredNode(new ShaderIrAsg(OpCode.Gpr0(), Op)));

+ ShaderIrNode OperA = OpCode.Gpr8();

+ ShaderIrNode OperB = OpCode.Imm32_20();

+ bool NegA = OpCode.Read(56);

+ Block.AddNode(OpCode.PredNode(new ShaderIrAsg(OpCode.Gpr0(), Op)));

+ ShaderIrNode OperA = OpCode.Abuf28();

+ ShaderIrNode OperB = OpCode.Gpr20();

+ ShaderIpaMode Mode = (ShaderIpaMode)(OpCode.Read(54, 3));

+ Block.AddNode(OpCode.PredNode(new ShaderIrAsg(OpCode.Gpr0(), Op)));

+ int SubOp = OpCode.Read(53, 3);

+ bool InvA = OpCode.Read(55);

+ bool InvB = OpCode.Read(56);

+ ShaderIrNode OperB = GetAluNot(OpCode.Imm32_20(), InvB);

+ ShaderIrNode OperA = GetAluNot(OpCode.Gpr8(), InvA);

+ Block.AddNode(OpCode.PredNode(new ShaderIrAsg(OpCode.Gpr0(), Op)));

+ Block.AddNode(OpCode.PredNode(new ShaderIrAsg(OpCode.Gpr0(), OperB)));

+ int SubOp = OpCode.Read(20, 0xf);

+ bool AbsA = OpCode.Read(46);

+ bool NegA = OpCode.Read(48);

+ ShaderIrNode OperA = OpCode.Gpr8();

+ Block.AddNode(OpCode.PredNode(new ShaderIrAsg(OpCode.Gpr0(), Op)));

+ bool NegA = OpCode.Read(15);

+ bool NegB = OpCode.Read(32);

+ bool NegP = OpCode.Read(42);

+ ShaderIrInst LopInst = OpCode.BLop24();

+ ShaderIrNode OperA = OpCode.Pred12();

+ ShaderIrNode OperB = OpCode.Pred29();

+ ShaderIrOperPred P0Node = OpCode.Pred3();

+ ShaderIrOperPred P1Node = OpCode.Pred0();

+ ShaderIrOperPred P2Node = OpCode.Pred39();

+ Block.AddNode(OpCode.PredNode(new ShaderIrAsg(P0Node, Op)));

+ LopInst = OpCode.BLop45();

+ Block.AddNode(OpCode.PredNode(new ShaderIrAsg(P1Node, Op)));

+ Block.AddNode(OpCode.PredNode(new ShaderIrAsg(P0Node, Op)));

+ bool Signed = OpCode.Read(48);

+ ShaderIrNode OperA = OpCode.Gpr8();

+ if (OpCode.Read(50))

+ OperB = OpCode.Gpr20();

+ OperB = OpCode.Imm19_20();

+ ShaderIrOperGpr OperC = OpCode.Gpr39();

+ int Shr = OpCode.Read(51, 3);

+ Block.AddNode(OpCode.PredNode(new ShaderIrAsg(OpCode.Gpr0(), Final)));

+ ShaderIrNode OperA = OpCode.Gpr8(), OperB;

+ case ShaderOper.CR: OperB = OpCode.Cbuf34(); break;

+ case ShaderOper.Imm: OperB = OpCode.Imm19_20(); break;

+ case ShaderOper.RR: OperB = OpCode.Gpr20(); break;

+ Block.AddNode(OpCode.PredNode(new ShaderIrAsg(OpCode.Gpr0(), Op)));

+ bool NegB = OpCode.Read(48);

+ bool NegA = OpCode.Read(49);

+ ShaderIrNode OperA = OpCode.Gpr8(), OperB;

+ case ShaderOper.CR: OperB = OpCode.Cbuf34(); break;

+ case ShaderOper.Imm: OperB = OpCode.Imm19_20(); break;

+ case ShaderOper.RR: OperB = OpCode.Gpr20(); break;

+ bool Signed = OpCode.Read(48); //?

+ Block.AddNode(OpCode.PredNode(new ShaderIrAsg(OpCode.Gpr0(), Op)));

+ bool NegB = OpCode.Read(45);

+ bool AbsA = OpCode.Read(46);

+ bool NegA = OpCode.Read(48);

+ bool AbsB = OpCode.Read(49);

+ ShaderIrNode OperA = OpCode.Gpr8(), OperB;

+ case ShaderOper.CR: OperB = OpCode.Cbuf34(); break;

+ case ShaderOper.Immf: OperB = OpCode.Immf19_20(); break;

+ case ShaderOper.RR: OperB = OpCode.Gpr20(); break;

+ Block.AddNode(OpCode.PredNode(new ShaderIrAsg(OpCode.Gpr0(), Op)));

+ bool NegB = OpCode.Read(48);

+ ShaderIrNode OperA = OpCode.Gpr8(), OperB;

+ case ShaderOper.CR: OperB = OpCode.Cbuf34(); break;

+ case ShaderOper.Immf: OperB = OpCode.Immf19_20(); break;

+ case ShaderOper.RR: OperB = OpCode.Gpr20(); break;

+ Block.AddNode(OpCode.PredNode(new ShaderIrAsg(OpCode.Gpr0(), Op)));

+ bool NegB = OpCode.Read(48);

+ bool NegC = OpCode.Read(49);

+ ShaderIrNode OperA = OpCode.Gpr8(), OperB, OperC;

+ case ShaderOper.CR: OperB = OpCode.Cbuf34(); break;

+ case ShaderOper.Immf: OperB = OpCode.Immf19_20(); break;

+ case ShaderOper.RC: OperB = OpCode.Gpr39(); break;

+ case ShaderOper.RR: OperB = OpCode.Gpr20(); break;

+ OperC = GetAluFneg(OpCode.Cbuf34(), NegC);

+ OperC = GetAluFneg(OpCode.Gpr39(), NegC);

+ Block.AddNode(OpCode.PredNode(new ShaderIrAsg(OpCode.Gpr0(), Op)));

+ ShaderIrNode OperA = OpCode.Gpr8();

+ case ShaderOper.CR: OperB = OpCode.Cbuf34(); break;

+ case ShaderOper.Imm: OperB = OpCode.Imm19_20(); break;

+ case ShaderOper.RR: OperB = OpCode.Gpr20(); break;

+ bool NegA = OpCode.Read(49);

+ bool NegB = OpCode.Read(48);

+ Block.AddNode(OpCode.PredNode(new ShaderIrAsg(OpCode.Gpr0(), Op)));

+ int Mode = OpCode.Read(37, 3);

+ bool Neg1 = OpCode.Read(51);

+ bool Neg2 = OpCode.Read(50);

+ bool Neg3 = OpCode.Read(49);

+ int Height1 = OpCode.Read(35, 3);

+ int Height2 = OpCode.Read(33, 3);

+ int Height3 = OpCode.Read(31, 3);

+ case ShaderOper.CR: OperB = OpCode.Cbuf34(); break;

+ case ShaderOper.Imm: OperB = OpCode.Imm19_20(); break;

+ case ShaderOper.RR: OperB = OpCode.Gpr20(); break;

+ ShaderIrNode Src1 = GetAluIneg(ApplyHeight(OpCode.Gpr8(), Height1), Neg1);

+ ShaderIrNode Src3 = GetAluIneg(ApplyHeight(OpCode.Gpr39(), Height3), Neg3);

+ Block.AddNode(OpCode.PredNode(new ShaderIrAsg(OpCode.Gpr0(), new ShaderIrOp(ShaderIrInst.Add, Sum, Src3))));

+ bool NegB = OpCode.Read(48);

+ bool NegA = OpCode.Read(49);

+ ShaderIrNode OperA = OpCode.Gpr8(), OperB;

+ ShaderIrOperImm Scale = OpCode.Imm5_39();

+ case ShaderOper.CR: OperB = OpCode.Cbuf34(); break;

+ case ShaderOper.Imm: OperB = OpCode.Imm19_20(); break;

+ case ShaderOper.RR: OperB = OpCode.Gpr20(); break;

+ Block.AddNode(OpCode.PredNode(new ShaderIrAsg(OpCode.Gpr0(), AddOp)));

+ bool NegB = OpCode.Read(45);

+ bool AbsA = OpCode.Read(46);

+ bool NegA = OpCode.Read(48);

+ bool AbsB = OpCode.Read(49);

+ ShaderIrNode OperA = OpCode.Gpr8(), OperB;

+ case ShaderOper.CR: OperB = OpCode.Cbuf34(); break;

+ case ShaderOper.Imm: OperB = OpCode.Imm19_20(); break;

+ case ShaderOper.Immf: OperB = OpCode.Immf19_20(); break;

+ case ShaderOper.RR: OperB = OpCode.Gpr20(); break;

+ ShaderIrOperPred Pred = OpCode.Pred39();

+ bool IsMax = OpCode.Read(42);

+ Block.AddNode(OpCode.PredNode(new ShaderIrAsg(OpCode.Gpr0(), Op)));

+ ShaderIrNode PredN = OpCode.Pred39N();

+ ShaderIrAsg AsgMax = new ShaderIrAsg(OpCode.Gpr0(), OpMax);

+ ShaderIrAsg AsgMin = new ShaderIrAsg(OpCode.Gpr0(), OpMin);

+ Block.AddNode(OpCode.PredNode(new ShaderIrCond(PredN, AsgMax, Not: true)));

+ Block.AddNode(OpCode.PredNode(new ShaderIrCond(PredN, AsgMin, Not: false)));

+ bool NegA = OpCode.Read(45);

+ bool AbsA = OpCode.Read(49);

+ case ShaderOper.CR: OperA = OpCode.Cbuf34(); break;

+ case ShaderOper.Immf: OperA = OpCode.Immf19_20(); break;

+ case ShaderOper.RR: OperA = OpCode.Gpr20(); break;

+ Block.AddNode(OpCode.PredNode(new ShaderIrAsg(OpCode.Gpr0(), OperA)));

+ bool NegA = OpCode.Read(43);

+ bool AbsB = OpCode.Read(44);

+ bool NegB = OpCode.Read(53);

+ bool AbsA = OpCode.Read(54);

+ bool BoolFloat = OpCode.Read(IsFloat ? 52 : 44);

+ ShaderIrNode OperA = OpCode.Gpr8(), OperB;

+ case ShaderOper.CR: OperB = OpCode.Cbuf34(); break;

+ case ShaderOper.Imm: OperB = OpCode.Imm19_20(); break;

+ case ShaderOper.Immf: OperB = OpCode.Immf19_20(); break;

+ case ShaderOper.RR: OperB = OpCode.Gpr20(); break;

+ CmpInst = OpCode.CmpF();

+ CmpInst = OpCode.Cmp();

+ ShaderIrInst LopInst = OpCode.BLop45();

+ ShaderIrOperPred PNode = OpCode.Pred39();

+ ShaderIrNode Asg0 = new ShaderIrAsg(OpCode.Gpr0(), Imm0);

+ ShaderIrNode Asg1 = new ShaderIrAsg(OpCode.Gpr0(), Imm1);

+ Block.AddNode(OpCode.PredNode(Asg0));

+ Block.AddNode(OpCode.PredNode(Asg1));

+ bool AbsA = OpCode.Read(7);

+ bool NegP = OpCode.Read(42);

+ bool NegA = OpCode.Read(43);

+ bool AbsB = OpCode.Read(44);

+ ShaderIrNode OperA = OpCode.Gpr8(), OperB;

+ case ShaderOper.CR: OperB = OpCode.Cbuf34(); break;

+ case ShaderOper.Imm: OperB = OpCode.Imm19_20(); break;

+ case ShaderOper.Immf: OperB = OpCode.Immf19_20(); break;

+ case ShaderOper.RR: OperB = OpCode.Gpr20(); break;

+ CmpInst = OpCode.CmpF();

+ CmpInst = OpCode.Cmp();

+ ShaderIrOperPred P0Node = OpCode.Pred3();

+ ShaderIrOperPred P1Node = OpCode.Pred0();

+ ShaderIrOperPred P2Node = OpCode.Pred39();

+ Block.AddNode(OpCode.PredNode(new ShaderIrAsg(P0Node, Op)));

+ ShaderIrInst LopInst = OpCode.BLop45();

+ Block.AddNode(OpCode.PredNode(new ShaderIrAsg(P1Node, Op)));

+ Block.AddNode(OpCode.PredNode(new ShaderIrAsg(P0Node, Op)));

+ int SubOp = OpCode.Read(41, 3);

+ bool InvA = OpCode.Read(39);

+ bool InvB = OpCode.Read(40);

+ ShaderIrNode OperA = GetAluNot(OpCode.Gpr8(), InvA);

+ case ShaderOper.CR: OperB = OpCode.Cbuf34(); break;

+ case ShaderOper.Imm: OperB = OpCode.Imm19_20(); break;

+ case ShaderOper.RR: OperB = OpCode.Gpr20(); break;

+ Block.AddNode(OpCode.PredNode(new ShaderIrAsg(OpCode.Pred48(), Compare)));

+ Block.AddNode(OpCode.PredNode(new ShaderIrAsg(OpCode.Gpr0(), Op)));

+ bool SignAB = OpCode.Read(48);

+ bool SignC = OpCode.Read(49);

+ bool HighB = OpCode.Read(52);

+ bool HighA = OpCode.Read(53);

+ int Mode = OpCode.Read(50, 7);

+ ShaderIrNode OperA = OpCode.Gpr8(), OperB, OperC;

+ case ShaderOper.CR: OperB = OpCode.Cbuf34(); break;

+ case ShaderOper.Imm: OperB = OpCode.Imm19_20(); break;

+ case ShaderOper.RC: OperB = OpCode.Gpr39(); break;

+ case ShaderOper.RR: OperB = OpCode.Gpr20(); break;

+ OperC = OpCode.Cbuf34();

+ OperC = OpCode.Gpr39();

+ ProductShiftLeft = OpCode.Read(36);

+ Merge = OpCode.Read(37);

+ Block.AddNode(OpCode.PredNode(new ShaderIrAsg(OpCode.Gpr0(), AddOp)));

+ int Target = OpCode.Branch();

+ Block.AddNode(OpCode.PredNode(new ShaderIrOp(ShaderIrInst.Bra, Imm)));

+ Block.AddNode(OpCode.PredNode(new ShaderIrOp(ShaderIrInst.Exit)));

+ Block.AddNode(OpCode.PredNode(new ShaderIrOp(ShaderIrInst.Kil)));

+ int Offset = OpCode.Branch();

+ Block.AddNode(OpCode.PredNode(new ShaderIrOp(ShaderIrInst.Sync)));

+ ShaderIrNode[] Opers = OpCode.Abuf20();

+ ShaderIrOperGpr Vertex = OpCode.Gpr39();

+ ShaderIrOperGpr OperD = OpCode.Gpr0();

+ Block.AddNode(OpCode.PredNode(new ShaderIrAsg(OperD, OperA)));

+ int CbufPos = OpCode.Read(22, 0x3fff);

+ int CbufIndex = OpCode.Read(36, 0x1f);

+ int Type = OpCode.Read(48, 7);

+ Block.AddNode(new ShaderIrAsg(Temp, OpCode.Gpr8()));

+ ShaderIrOperGpr OperD = OpCode.Gpr0();

+ Block.AddNode(OpCode.PredNode(new ShaderIrAsg(OperD, Node)));

+ ShaderIrNode[] Opers = OpCode.Abuf20();

+ ShaderIrOperGpr OperD = OpCode.Gpr0();

+ Block.AddNode(OpCode.PredNode(new ShaderIrAsg(OperA, OperD)));

+ ShaderIrNode OperD = OpCode.Gpr0();

+ ShaderIrNode OperA = OpCode.Gpr8();

+ ShaderTexqInfo Info = (ShaderTexqInfo)(OpCode.Read(22, 0x1f));

+ ShaderIrNode OperC = OpCode.Imm13_36();

+ Block.AddNode(OpCode.PredNode(new ShaderIrAsg(OperD, Op0)));

+ Block.AddNode(OpCode.PredNode(new ShaderIrAsg(OperA, Op1))); //Is this right?

+ Coords[Index] = OpCode.Gpr8();

+ int ChMask = OpCode.Read(31, 0xf);

+ ? (ShaderIrNode)OpCode.Gpr20()

+ : (ShaderIrNode)OpCode.Imm13_36();

+ Block.AddNode(OpCode.PredNode(new ShaderIrAsg(Dst, Op)));

+ ShaderIrOperGpr Dst = OpCode.Gpr0();

+ Block.AddNode(OpCode.PredNode(new ShaderIrAsg(Dst, Src)));

+ ShaderIrNode OperA = OpCode.Gpr8();

+ ShaderIrNode OperB = OpCode.Gpr20();

+ ShaderIrNode OperC = OpCode.Imm13_36();

+ LutIndex = OpCode.Gpr0 ().Index != ShaderIrOperGpr.ZRIndex ? 1 : 0;

+ LutIndex |= OpCode.Gpr28().Index != ShaderIrOperGpr.ZRIndex ? 2 : 0;

+ int ChMask = MaskLut[LutIndex, OpCode.Read(50, 7)];

+ Block.AddNode(OpCode.PredNode(new ShaderIrAsg(Dst, Op)));

+ case 1: Dst = OpCode.Gpr0(); break;

+ case 2: Dst = OpCode.Gpr28(); break;

+ ? OpCode.Gpr28()

+ : OpCode.Gpr0 (); break;

+ Block.AddNode(OpCode.PredNode(new ShaderIrAsg(Dst, Src)));

+ Block.AddNode(OpCode.PredNode(new ShaderIrAsg(OpCode.Gpr0(), OpCode.Gpr8())));

+ ShaderIrOperCbuf Cbuf = OpCode.Cbuf34();

+ Block.AddNode(OpCode.PredNode(new ShaderIrAsg(OpCode.Gpr0(), Cbuf)));

+ ShaderIrOperImm Imm = OpCode.Imm19_20();

+ Block.AddNode(OpCode.PredNode(new ShaderIrAsg(OpCode.Gpr0(), Imm)));

+ ShaderIrOperImm Imm = OpCode.Imm32_20();

+ Block.AddNode(OpCode.PredNode(new ShaderIrAsg(OpCode.Gpr0(), Imm)));

+ ShaderIrOperGpr Gpr = OpCode.Gpr20();

+ Block.AddNode(OpCode.PredNode(new ShaderIrAsg(OpCode.Gpr0(), Gpr)));

+ Block.AddNode(OpCode.PredNode(new ShaderIrAsg(OpCode.Gpr0(), Source)));

+ bool NegA = OpCode.Read(45);

+ bool AbsA = OpCode.Read(49);

+ case ShaderOper.CR: OperA = OpCode.Cbuf34(); break;

+ case ShaderOper.Immf: OperA = OpCode.Immf19_20(); break;

+ case ShaderOper.RR: OperA = OpCode.Gpr20(); break;

+ Block.AddNode(OpCode.PredNode(new ShaderIrAsg(OpCode.Gpr0(), OperA)));

+ bool NegA = OpCode.Read(45);

+ bool AbsA = OpCode.Read(49);

+ case ShaderOper.CR: OperA = OpCode.Cbuf34(); break;

+ case ShaderOper.Immf: OperA = OpCode.Immf19_20(); break;

+ case ShaderOper.RR: OperA = OpCode.Gpr20(); break;

+ Block.AddNode(OpCode.PredNode(new ShaderIrAsg(OpCode.Gpr0(), Op)));

+ int Sel = OpCode.Read(41, 3);

+ bool NegA = OpCode.Read(45);

+ bool AbsA = OpCode.Read(49);

+ case ShaderOper.CR: OperA = OpCode.Cbuf34(); break;

+ case ShaderOper.Imm: OperA = OpCode.Imm19_20(); break;

+ case ShaderOper.RR: OperA = OpCode.Gpr20(); break;

+ Block.AddNode(OpCode.PredNode(new ShaderIrAsg(OpCode.Gpr0(), Op)));

+ int Sel = OpCode.Read(41, 3);

+ bool NegA = OpCode.Read(45);

+ bool AbsA = OpCode.Read(49);

+ bool SatA = OpCode.Read(50);

+ case ShaderOper.CR: OperA = OpCode.Cbuf34(); break;

+ case ShaderOper.Immf: OperA = OpCode.Immf19_20(); break;

+ case ShaderOper.RR: OperA = OpCode.Gpr20(); break;

+ Block.AddNode(OpCode.PredNode(new ShaderIrAsg(OpCode.Gpr0(), OperA)));

+ ShaderIrOperGpr Dst = OpCode.Gpr0();

+ ShaderIrNode Pred = OpCode.Pred39N();

+ ShaderIrNode ResultA = OpCode.Gpr8();

+ case ShaderOper.CR: ResultB = OpCode.Cbuf34(); break;

+ case ShaderOper.Imm: ResultB = OpCode.Imm19_20(); break;

+ case ShaderOper.RR: ResultB = OpCode.Gpr20(); break;

+ Block.AddNode(OpCode.PredNode(new ShaderIrCond(Pred, new ShaderIrAsg(Dst, ResultA), false)));

+ Block.AddNode(OpCode.PredNode(new ShaderIrCond(Pred, new ShaderIrAsg(Dst, ResultB), true)));

+ bool Signed = OpCode.Read(13);

+ IntType Type = (IntType)(OpCode.Read(10, 3));

+ return (FloatType)(OpCode.Read(8, 3));

+ switch (OpCode.Read(39, 3))

+using System;

+

+namespace Ryujinx.Graphics.Gal.Shader

+{

+ static partial class ShaderDecode

+ {

+ private static int Read(this long OpCode, int Position, int Mask)

+ {

+ return (int)(OpCode >> Position) & Mask;

+ }

+

+ private static bool Read(this long OpCode, int Position)

+ {

+ return ((OpCode >> Position) & 1) != 0;

+ }

+

+ private static int Branch(this long OpCode)

+ {

+ return ((int)(OpCode >> 20) << 8) >> 8;

+ }

+

+ private static ShaderIrOperAbuf[] Abuf20(this long OpCode)

+ {

+ int Abuf = OpCode.Read(20, 0x3ff);

+ int Size = OpCode.Read(47, 3);

+

+ ShaderIrOperGpr Vertex = OpCode.Gpr39();

+

+ ShaderIrOperAbuf[] Opers = new ShaderIrOperAbuf[Size + 1];

+

+ for (int Index = 0; Index <= Size; Index++)

+ {

+ Opers[Index] = new ShaderIrOperAbuf(Abuf + Index * 4, Vertex);

+ }

+

+ return Opers;

+ }

+

+ private static ShaderIrOperAbuf Abuf28(this long OpCode)

+ {

+ int Abuf = OpCode.Read(28, 0x3ff);

+

+ return new ShaderIrOperAbuf(Abuf, OpCode.Gpr39());

+ }

+

+ private static ShaderIrOperCbuf Cbuf34(this long OpCode)

+ {

+ return new ShaderIrOperCbuf(

+ OpCode.Read(34, 0x1f),

+ OpCode.Read(20, 0x3fff));

+ }

+

+ private static ShaderIrOperGpr Gpr8(this long OpCode)

+ {

+ return new ShaderIrOperGpr(OpCode.Read(8, 0xff));

+ }

+

+ private static ShaderIrOperGpr Gpr20(this long OpCode)

+ {

+ return new ShaderIrOperGpr(OpCode.Read(20, 0xff));

+ }

+

+ private static ShaderIrOperGpr Gpr39(this long OpCode)

+ {

+ return new ShaderIrOperGpr(OpCode.Read(39, 0xff));

+ }

+

+ private static ShaderIrOperGpr Gpr0(this long OpCode)

+ {

+ return new ShaderIrOperGpr(OpCode.Read(0, 0xff));

+ }

+

+ private static ShaderIrOperGpr Gpr28(this long OpCode)

+ {

+ return new ShaderIrOperGpr(OpCode.Read(28, 0xff));

+ }

+

+ private static ShaderIrOperImm Imm5_39(this long OpCode)

+ {

+ return new ShaderIrOperImm(OpCode.Read(39, 0x1f));

+ }

+

+ private static ShaderIrOperImm Imm13_36(this long OpCode)

+ {

+ return new ShaderIrOperImm(OpCode.Read(36, 0x1fff));

+ }

+

+ private static ShaderIrOperImm Imm32_20(this long OpCode)

+ {

+ return new ShaderIrOperImm((int)(OpCode >> 20));

+ }

+

+ private static ShaderIrOperImmf Immf32_20(this long OpCode)

+ {

+ return new ShaderIrOperImmf(BitConverter.Int32BitsToSingle((int)(OpCode >> 20)));

+ }

+

+ private static ShaderIrOperImm Imm19_20(this long OpCode)

+ {

+ int Value = OpCode.Read(20, 0x7ffff);

+

+ bool Neg = OpCode.Read(56);

+

+ if (Neg)

+ {

+ Value = -Value;

+ }

+

+ return new ShaderIrOperImm(Value);

+ }

+

+ private static ShaderIrOperImmf Immf19_20(this long OpCode)

+ {

+ uint Imm = (uint)(OpCode >> 20) & 0x7ffff;

+

+ bool Neg = OpCode.Read(56);

+

+ Imm <<= 12;

+

+ if (Neg)

+ {

+ Imm |= 0x80000000;

+ }

+

+ float Value = BitConverter.Int32BitsToSingle((int)Imm);

+

+ return new ShaderIrOperImmf(Value);

+ }

+

+ private static ShaderIrOperPred Pred0(this long OpCode)

+ {

+ return new ShaderIrOperPred(OpCode.Read(0, 7));

+ }

+

+ private static ShaderIrOperPred Pred3(this long OpCode)

+ {

+ return new ShaderIrOperPred(OpCode.Read(3, 7));

+ }

+

+ private static ShaderIrOperPred Pred12(this long OpCode)

+ {

+ return new ShaderIrOperPred(OpCode.Read(12, 7));

+ }

+

+ private static ShaderIrOperPred Pred29(this long OpCode)

+ {

+ return new ShaderIrOperPred(OpCode.Read(29, 7));

+ }

+

+ private static ShaderIrNode Pred39N(this long OpCode)

+ {

+ ShaderIrNode Node = OpCode.Pred39();

+

+ if (OpCode.Read(42))

+ {

+ Node = new ShaderIrOp(ShaderIrInst.Bnot, Node);

+ }

+

+ return Node;

+ }

+

+ private static ShaderIrOperPred Pred39(this long OpCode)

+ {

+ return new ShaderIrOperPred(OpCode.Read(39, 7));

+ }

+

+ private static ShaderIrOperPred Pred48(this long OpCode)

+ {

+ return new ShaderIrOperPred(OpCode.Read(48, 7));

+ }

+

+ private static ShaderIrInst Cmp(this long OpCode)

+ {

+ switch (OpCode.Read(49, 7))

+ {

+ case 1: return ShaderIrInst.Clt;

+ case 2: return ShaderIrInst.Ceq;

+ case 3: return ShaderIrInst.Cle;

+ case 4: return ShaderIrInst.Cgt;

+ case 5: return ShaderIrInst.Cne;

+ case 6: return ShaderIrInst.Cge;

+ }

+

+ throw new ArgumentException(nameof(OpCode));

+ }

+

+ private static ShaderIrInst CmpF(this long OpCode)

+ {

+ switch (OpCode.Read(48, 0xf))

+ {

+ case 0x1: return ShaderIrInst.Fclt;

+ case 0x2: return ShaderIrInst.Fceq;

+ case 0x3: return ShaderIrInst.Fcle;

+ case 0x4: return ShaderIrInst.Fcgt;

+ case 0x5: return ShaderIrInst.Fcne;

+ case 0x6: return ShaderIrInst.Fcge;

+ case 0x7: return ShaderIrInst.Fcnum;

+ case 0x8: return ShaderIrInst.Fcnan;

+ case 0x9: return ShaderIrInst.Fcltu;

+ case 0xa: return ShaderIrInst.Fcequ;

+ case 0xb: return ShaderIrInst.Fcleu;

+ case 0xc: return ShaderIrInst.Fcgtu;

+ case 0xd: return ShaderIrInst.Fcneu;

+ case 0xe: return ShaderIrInst.Fcgeu;

+ }

+

+ throw new ArgumentException(nameof(OpCode));

+ }

+

+ private static ShaderIrInst BLop45(this long OpCode)

+ {

+ switch (OpCode.Read(45, 3))

+ {

+ case 0: return ShaderIrInst.Band;

+ case 1: return ShaderIrInst.Bor;

+ case 2: return ShaderIrInst.Bxor;

+ }

+

+ throw new ArgumentException(nameof(OpCode));

+ }

+

+ private static ShaderIrInst BLop24(this long OpCode)

+ {

+ switch (OpCode.Read(24, 3))

+ {

+ case 0: return ShaderIrInst.Band;

+ case 1: return ShaderIrInst.Bor;

+ case 2: return ShaderIrInst.Bxor;

+ }

+

+ throw new ArgumentException(nameof(OpCode));

+ }

+

+ private static ShaderIrNode PredNode(this long OpCode, ShaderIrNode Node)

+ {

+ ShaderIrOperPred Pred = OpCode.PredNode();

+

+ if (Pred.Index != ShaderIrOperPred.UnusedIndex)

+ {

+ bool Inv = OpCode.Read(19);

+

+ Node = new ShaderIrCond(Pred, Node, Inv);

+ }

+

+ return Node;

+ }

+

+ private static ShaderIrOperPred PredNode(this long OpCode)

+ {

+ int Pred = OpCode.Read(16, 0xf);

+

+ if (Pred != 0xf)

+ {

+ Pred &= 7;

+ }

+

+ return new ShaderIrOperPred(Pred);

+ }

+ }

+} \ No newline at end of file

+ ShaderIrOperGpr Gpr0 = OpCode.Gpr0();

+ ShaderIrOperGpr Gpr8 = OpCode.Gpr8();

+ ShaderIrOperGpr Gpr20 = OpCode.Gpr20();

+ int Type = OpCode.Read(39, 3);

+ Block.AddNode(OpCode.PredNode(new ShaderIrOp(ShaderIrInst.Emit)));

+ Block.AddNode(OpCode.PredNode(new ShaderIrOp(ShaderIrInst.Cut)));

+using Ryujinx.Graphics.Memory;

+namespace Ryujinx.Graphics

+using Ryujinx.Graphics.Memory;

+namespace Ryujinx.Graphics

+namespace Ryujinx.Graphics.Memory

+ public enum NvGpuBufferType

+namespace Ryujinx.Graphics.Memory

+ public struct NvGpuPBEntry

+namespace Ryujinx.Graphics.Memory

+ public static class NvGpuPushBuffer

+namespace Ryujinx.Graphics.Memory

+ public class NvGpuVmm : IAMemory, IGalMemory

+namespace Ryujinx.Graphics.Memory

+ private const long RamSize = 4L * 1024 * 1024 * 1024;

+

+ Residency = new HashSet<long>[RamSize / PageSize];

+using Ryujinx.Graphics;

+namespace Ryujinx.Graphics

+ public class NvGpu

+namespace Ryujinx.Graphics

+using Ryujinx.Graphics.Memory;

+using Ryujinx.Graphics.Texture;

+namespace Ryujinx.Graphics

+ public class NvGpuEngine2d : INvGpuEngine

+ GalImageFormat.A8B8G8R8 | GalImageFormat.Unorm);

+ GalImageFormat.A8B8G8R8 | GalImageFormat.Unorm);

+ Gpu.Renderer.RenderTarget.Copy(

+ Gpu.Renderer.RenderTarget.GetBufferData(SrcKey, (byte[] Buffer) =>

+ Gpu.Renderer.RenderTarget.SetBufferData(

+namespace Ryujinx.Graphics

+using Ryujinx.Graphics.Memory;

+using Ryujinx.Graphics.Texture;

+namespace Ryujinx.Graphics

+ public class NvGpuEngine3d : INvGpuEngine

+

+ Gpu.Renderer.RenderTarget.UnbindColor(FbIndex);

+ GalImageFormat ImageFormat = ImageUtils.ConvertSurface((GalSurfaceFormat)Format);

+ long Size = ImageUtils.GetSize(Image);

+ Gpu.Renderer.RenderTarget.BindColor(Key, FbIndex);

+

+ Gpu.Renderer.RenderTarget.SetViewport(VpX, VpY, VpW, VpH);

+ Gpu.Renderer.RenderTarget.UnbindZeta();

+ GalImageFormat ImageFormat = ImageUtils.ConvertZeta((GalZetaFormat)Format);

+ long Size = ImageUtils.GetSize(Image);

+

+ Gpu.Renderer.RenderTarget.BindZeta(Key);

+ Gpu.Renderer.RenderTarget.SetMap(Map);

+ Gpu.Renderer.RenderTarget.SetMap(null);

+ Gpu.Renderer.RenderTarget.BindTexture(Key, TexIndex);

+ long Size = (uint)ImageUtils.GetSize(NewImage);

+namespace Ryujinx.Graphics

+using Ryujinx.Graphics.Memory;

+using Ryujinx.Graphics.Texture;

+namespace Ryujinx.Graphics

+ public class NvGpuEngineDma : INvGpuEngine

+namespace Ryujinx.Graphics

+using Ryujinx.Graphics.Memory;

+namespace Ryujinx.Graphics

+ public class NvGpuFifo

+namespace Ryujinx.Graphics

+using Ryujinx.Graphics.Memory;

+namespace Ryujinx.Graphics

+using System;

+using System.Collections;

+using System.Collections.Generic;

+using System.Diagnostics;

+using System.IO;

+

+namespace Ryujinx.Graphics.Texture

+{

+ public class ASTCDecoderException : Exception

+ {

+ public ASTCDecoderException(string ExMsg) : base(ExMsg) { }

+ }

+

+ //https://github.com/GammaUNC/FasTC/blob/master/ASTCEncoder/src/Decompressor.cpp

+ public static class ASTCDecoder

+ {

+ struct TexelWeightParams

+ {

+ public int Width;

+ public int Height;

+ public bool DualPlane;

+ public int MaxWeight;

+ public bool Error;

+ public bool VoidExtentLDR;

+ public bool VoidExtentHDR;

+

+ public int GetPackedBitSize()

+ {

+ // How many indices do we have?

+ int Indices = Height * Width;

+

+ if (DualPlane)

+ {

+ Indices *= 2;

+ }

+

+ IntegerEncoded IntEncoded = IntegerEncoded.CreateEncoding(MaxWeight);

+

+ return IntEncoded.GetBitLength(Indices);

+ }

+

+ public int GetNumWeightValues()

+ {

+ int Ret = Width * Height;

+

+ if (DualPlane)

+ {

+ Ret *= 2;

+ }

+

+ return Ret;

+ }

+ }

+

+ public static byte[] DecodeToRGBA8888(

+ byte[] InputBuffer,

+ int BlockX,

+ int BlockY,

+ int BlockZ,

+ int X,

+ int Y,

+ int Z)

+ {

+ using (MemoryStream InputStream = new MemoryStream(InputBuffer))

+ {

+ BinaryReader BinReader = new BinaryReader(InputStream);

+

+ if (BlockX > 12 || BlockY > 12)

+ {

+ throw new ASTCDecoderException("Block size unsupported!");

+ }

+

+ if (BlockZ != 1 || Z != 1)

+ {

+ throw new ASTCDecoderException("3D compressed textures unsupported!");

+ }

+

+ using (MemoryStream OutputStream = new MemoryStream())

+ {

+ int BlockIndex = 0;

+

+ for (int j = 0; j < Y; j += BlockY)

+ {

+ for (int i = 0; i < X; i += BlockX)

+ {

+ int[] DecompressedData = new int[144];

+

+ DecompressBlock(BinReader.ReadBytes(0x10), DecompressedData, BlockX, BlockY);

+

+ int DecompressedWidth = Math.Min(BlockX, X - i);

+ int DecompressedHeight = Math.Min(BlockY, Y - j);

+ int BaseOffsets = (j * X + i) * 4;

+

+ for (int jj = 0; jj < DecompressedHeight; jj++)

+ {

+ OutputStream.Seek(BaseOffsets + jj * X * 4, SeekOrigin.Begin);

+

+ byte[] OutputBuffer = new byte[DecompressedData.Length * sizeof(int)];

+ Buffer.BlockCopy(DecompressedData, 0, OutputBuffer, 0, OutputBuffer.Length);

+

+ OutputStream.Write(OutputBuffer, jj * BlockX * 4, DecompressedWidth * 4);

+ }

+

+ BlockIndex++;

+ }

+ }

+

+ return OutputStream.ToArray();

+ }

+ }

+ }

+

+ public static bool DecompressBlock(

+ byte[] InputBuffer,

+ int[] OutputBuffer,

+ int BlockWidth,

+ int BlockHeight)

+ {

+ BitArrayStream BitStream = new BitArrayStream(new BitArray(InputBuffer));

+ TexelWeightParams TexelParams = DecodeBlockInfo(BitStream);

+

+ if (TexelParams.Error)

+ {

+ throw new ASTCDecoderException("Invalid block mode");

+ }

+

+ if (TexelParams.VoidExtentLDR)

+ {

+ FillVoidExtentLDR(BitStream, OutputBuffer, BlockWidth, BlockHeight);

+

+ return true;

+ }

+

+ if (TexelParams.VoidExtentHDR)

+ {

+ throw new ASTCDecoderException("HDR void extent blocks are unsupported!");

+ }

+

+ if (TexelParams.Width > BlockWidth)

+ {

+ throw new ASTCDecoderException("Texel weight grid width should be smaller than block width");

+ }

+

+ if (TexelParams.Height > BlockHeight)

+ {

+ throw new ASTCDecoderException("Texel weight grid height should be smaller than block height");

+ }

+

+ // Read num partitions

+ int NumberPartitions = BitStream.ReadBits(2) + 1;

+ Debug.Assert(NumberPartitions <= 4);

+

+ if (NumberPartitions == 4 && TexelParams.DualPlane)

+ {

+ throw new ASTCDecoderException("Dual plane mode is incompatible with four partition blocks");

+ }

+

+ // Based on the number of partitions, read the color endpoint mode for

+ // each partition.

+

+ // Determine partitions, partition index, and color endpoint modes

+ int PlaneIndices = -1;

+ int PartitionIndex;

+ uint[] ColorEndpointMode = { 0, 0, 0, 0 };

+

+ BitArrayStream ColorEndpointStream = new BitArrayStream(new BitArray(16 * 8));

+

+ // Read extra config data...

+ uint BaseColorEndpointMode = 0;

+

+ if (NumberPartitions == 1)

+ {

+ ColorEndpointMode[0] = (uint)BitStream.ReadBits(4);

+ PartitionIndex = 0;

+ }

+ else

+ {

+ PartitionIndex = BitStream.ReadBits(10);

+ BaseColorEndpointMode = (uint)BitStream.ReadBits(6);

+ }

+

+ uint BaseMode = (BaseColorEndpointMode & 3);

+

+ // Remaining bits are color endpoint data...

+ int NumberWeightBits = TexelParams.GetPackedBitSize();

+ int RemainingBits = 128 - NumberWeightBits - BitStream.Position;

+

+ // Consider extra bits prior to texel data...

+ uint ExtraColorEndpointModeBits = 0;

+

+ if (BaseMode != 0)

+ {

+ switch (NumberPartitions)

+ {

+ case 2: ExtraColorEndpointModeBits += 2; break;

+ case 3: ExtraColorEndpointModeBits += 5; break;

+ case 4: ExtraColorEndpointModeBits += 8; break;

+ default: Debug.Assert(false); break;

+ }

+ }

+

+ RemainingBits -= (int)ExtraColorEndpointModeBits;

+

+ // Do we have a dual plane situation?

+ int PlaneSelectorBits = 0;

+

+ if (TexelParams.DualPlane)

+ {

+ PlaneSelectorBits = 2;

+ }

+

+ RemainingBits -= PlaneSelectorBits;

+

+ // Read color data...

+ int ColorDataBits = RemainingBits;

+

+ while (RemainingBits > 0)

+ {

+ int NumberBits = Math.Min(RemainingBits, 8);

+ int Bits = BitStream.ReadBits(NumberBits);

+ ColorEndpointStream.WriteBits(Bits, NumberBits);

+ RemainingBits -= 8;

+ }

+

+ // Read the plane selection bits

+ PlaneIndices = BitStream.ReadBits(PlaneSelectorBits);

+

+ // Read the rest of the CEM

+ if (BaseMode != 0)

+ {

+ uint ExtraColorEndpointMode = (uint)BitStream.ReadBits((int)ExtraColorEndpointModeBits);

+ uint TempColorEndpointMode = (ExtraColorEndpointMode << 6) | BaseColorEndpointMode;

+ TempColorEndpointMode >>= 2;

+

+ bool[] C = new bool[4];

+

+ for (int i = 0; i < NumberPartitions; i++)

+ {

+ C[i] = (TempColorEndpointMode & 1) != 0;

+ TempColorEndpointMode >>= 1;

+ }

+

+ byte[] M = new byte[4];

+

+ for (int i = 0; i < NumberPartitions; i++)

+ {

+ M[i] = (byte)(TempColorEndpointMode & 3);

+ TempColorEndpointMode >>= 2;

+ Debug.Assert(M[i] <= 3);

+ }

+

+ for (int i = 0; i < NumberPartitions; i++)

+ {

+ ColorEndpointMode[i] = BaseMode;

+ if (!(C[i])) ColorEndpointMode[i] -= 1;

+ ColorEndpointMode[i] <<= 2;

+ ColorEndpointMode[i] |= M[i];

+ }

+ }

+ else if (NumberPartitions > 1)

+ {

+ uint TempColorEndpointMode = BaseColorEndpointMode >> 2;

+

+ for (uint i = 0; i < NumberPartitions; i++)

+ {

+ ColorEndpointMode[i] = TempColorEndpointMode;

+ }

+ }

+

+ // Make sure everything up till here is sane.

+ for (int i = 0; i < NumberPartitions; i++)

+ {

+ Debug.Assert(ColorEndpointMode[i] < 16);

+ }

+ Debug.Assert(BitStream.Position + TexelParams.GetPackedBitSize() == 128);

+

+ // Decode both color data and texel weight data

+ int[] ColorValues = new int[32]; // Four values * two endpoints * four maximum partitions

+ DecodeColorValues(ColorValues, ColorEndpointStream.ToByteArray(), ColorEndpointMode, NumberPartitions, ColorDataBits);

+

+ ASTCPixel[][] EndPoints = new ASTCPixel[4][];

+ EndPoints[0] = new ASTCPixel[2];

+ EndPoints[1] = new ASTCPixel[2];

+ EndPoints[2] = new ASTCPixel[2];

+ EndPoints[3] = new ASTCPixel[2];

+

+ int ColorValuesPosition = 0;

+

+ for (int i = 0; i < NumberPartitions; i++)

+ {

+ ComputeEndpoints(EndPoints[i], ColorValues, ColorEndpointMode[i], ref ColorValuesPosition);

+ }

+

+ // Read the texel weight data.

+ byte[] TexelWeightData = (byte[])InputBuffer.Clone();

+

+ // Reverse everything

+ for (int i = 0; i < 8; i++)

+ {

+ byte a = ReverseByte(TexelWeightData[i]);

+ byte b = ReverseByte(TexelWeightData[15 - i]);

+

+ TexelWeightData[i] = b;

+ TexelWeightData[15 - i] = a;

+ }

+

+ // Make sure that higher non-texel bits are set to zero

+ int ClearByteStart = (TexelParams.GetPackedBitSize() >> 3) + 1;

+ TexelWeightData[ClearByteStart - 1] &= (byte)((1 << (TexelParams.GetPackedBitSize() % 8)) - 1);

+

+ int cLen = 16 - ClearByteStart;

+ for (int i = ClearByteStart; i < ClearByteStart + cLen; i++) TexelWeightData[i] = 0;

+

+ List<IntegerEncoded> TexelWeightValues = new List<IntegerEncoded>();

+ BitArrayStream WeightBitStream = new BitArrayStream(new BitArray(TexelWeightData));

+

+ IntegerEncoded.DecodeIntegerSequence(TexelWeightValues, WeightBitStream, TexelParams.MaxWeight, TexelParams.GetNumWeightValues());

+

+ // Blocks can be at most 12x12, so we can have as many as 144 weights

+ int[][] Weights = new int[2][];

+ Weights[0] = new int[144];

+ Weights[1] = new int[144];

+

+ UnquantizeTexelWeights(Weights, TexelWeightValues, TexelParams, BlockWidth, BlockHeight);

+

+ // Now that we have endpoints and weights, we can interpolate and generate

+ // the proper decoding...

+ for (int j = 0; j < BlockHeight; j++)

+ {

+ for (int i = 0; i < BlockWidth; i++)

+ {

+ int Partition = Select2DPartition(PartitionIndex, i, j, NumberPartitions, ((BlockHeight * BlockWidth) < 32));

+ Debug.Assert(Partition < NumberPartitions);

+

+ ASTCPixel Pixel = new ASTCPixel(0, 0, 0, 0);

+ for (int Component = 0; Component < 4; Component++)

+ {

+ int Component0 = EndPoints[Partition][0].GetComponent(Component);

+ Component0 = BitArrayStream.Replicate(Component0, 8, 16);

+ int Component1 = EndPoints[Partition][1].GetComponent(Component);

+ Component1 = BitArrayStream.Replicate(Component1, 8, 16);

+

+ int Plane = 0;

+

+ if (TexelParams.DualPlane && (((PlaneIndices + 1) & 3) == Component))

+ {

+ Plane = 1;

+ }

+

+ int Weight = Weights[Plane][j * BlockWidth + i];

+ int FinalComponent = (Component0 * (64 - Weight) + Component1 * Weight + 32) / 64;

+

+ if (FinalComponent == 65535)

+ {

+ Pixel.SetComponent(Component, 255);

+ }

+ else

+ {

+ double FinalComponentFloat = FinalComponent;

+ Pixel.SetComponent(Component, (int)(255.0 * (FinalComponentFloat / 65536.0) + 0.5));

+ }

+ }

+

+ OutputBuffer[j * BlockWidth + i] = Pixel.Pack();

+ }

+ }

+

+ return true;

+ }

+

+ private static int Select2DPartition(int Seed, int X, int Y, int PartitionCount, bool IsSmallBlock)

+ {

+ return SelectPartition(Seed, X, Y, 0, PartitionCount, IsSmallBlock);

+ }

+

+ private static int SelectPartition(int Seed, int X, int Y, int Z, int PartitionCount, bool IsSmallBlock)

+ {

+ if (PartitionCount == 1)

+ {

+ return 0;

+ }

+

+ if (IsSmallBlock)

+ {

+ X <<= 1;

+ Y <<= 1;

+ Z <<= 1;

+ }

+

+ Seed += (PartitionCount - 1) * 1024;

+

+ int RightNum = Hash52((uint)Seed);

+ byte Seed01 = (byte)(RightNum & 0xF);

+ byte Seed02 = (byte)((RightNum >> 4) & 0xF);

+ byte Seed03 = (byte)((RightNum >> 8) & 0xF);

+ byte Seed04 = (byte)((RightNum >> 12) & 0xF);

+ byte Seed05 = (byte)((RightNum >> 16) & 0xF);

+ byte Seed06 = (byte)((RightNum >> 20) & 0xF);

+ byte Seed07 = (byte)((RightNum >> 24) & 0xF);

+ byte Seed08 = (byte)((RightNum >> 28) & 0xF);

+ byte Seed09 = (byte)((RightNum >> 18) & 0xF);

+ byte Seed10 = (byte)((RightNum >> 22) & 0xF);

+ byte Seed11 = (byte)((RightNum >> 26) & 0xF);

+ byte Seed12 = (byte)(((RightNum >> 30) | (RightNum << 2)) & 0xF);

+

+ Seed01 *= Seed01; Seed02 *= Seed02;

+ Seed03 *= Seed03; Seed04 *= Seed04;

+ Seed05 *= Seed05; Seed06 *= Seed06;

+ Seed07 *= Seed07; Seed08 *= Seed08;

+ Seed09 *= Seed09; Seed10 *= Seed10;

+ Seed11 *= Seed11; Seed12 *= Seed12;

+

+ int SeedHash1, SeedHash2, SeedHash3;

+

+ if ((Seed & 1) != 0)

+ {

+ SeedHash1 = (Seed & 2) != 0 ? 4 : 5;

+ SeedHash2 = (PartitionCount == 3) ? 6 : 5;

+ }

+ else

+ {

+ SeedHash1 = (PartitionCount == 3) ? 6 : 5;

+ SeedHash2 = (Seed & 2) != 0 ? 4 : 5;

+ }

+

+ SeedHash3 = (Seed & 0x10) != 0 ? SeedHash1 : SeedHash2;

+

+ Seed01 >>= SeedHash1; Seed02 >>= SeedHash2; Seed03 >>= SeedHash1; Seed04 >>= SeedHash2;

+ Seed05 >>= SeedHash1; Seed06 >>= SeedHash2; Seed07 >>= SeedHash1; Seed08 >>= SeedHash2;

+ Seed09 >>= SeedHash3; Seed10 >>= SeedHash3; Seed11 >>= SeedHash3; Seed12 >>= SeedHash3;

+

+ int a = Seed01 * X + Seed02 * Y + Seed11 * Z + (RightNum >> 14);

+ int b = Seed03 * X + Seed04 * Y + Seed12 * Z + (RightNum >> 10);

+ int c = Seed05 * X + Seed06 * Y + Seed09 * Z + (RightNum >> 6);

+ int d = Seed07 * X + Seed08 * Y + Seed10 * Z + (RightNum >> 2);

+

+ a &= 0x3F; b &= 0x3F; c &= 0x3F; d &= 0x3F;

+

+ if (PartitionCount < 4) d = 0;

+ if (PartitionCount < 3) c = 0;

+

+ if (a >= b && a >= c && a >= d) return 0;

+ else if (b >= c && b >= d) return 1;

+ else if (c >= d) return 2;

+ return 3;

+ }

+

+ static int Hash52(uint Val)

+ {

+ Val ^= Val >> 15; Val -= Val << 17; Val += Val << 7; Val += Val << 4;

+ Val ^= Val >> 5; Val += Val << 16; Val ^= Val >> 7; Val ^= Val >> 3;

+ Val ^= Val << 6; Val ^= Val >> 17;

+

+ return (int)Val;

+ }

+

+ static void UnquantizeTexelWeights(

+ int[][] OutputBuffer,

+ List<IntegerEncoded> Weights,

+ TexelWeightParams TexelParams,

+ int BlockWidth,

+ int BlockHeight)

+ {

+ int WeightIndices = 0;

+ int[][] Unquantized = new int[2][];

+ Unquantized[0] = new int[144];

+ Unquantized[1] = new int[144];

+

+ for (int i = 0; i < Weights.Count; i++)

+ {

+ Unquantized[0][WeightIndices] = UnquantizeTexelWeight(Weights[i]);

+

+ if (TexelParams.DualPlane)

+ {

+ i++;

+ Unquantized[1][WeightIndices] = UnquantizeTexelWeight(Weights[i]);

+

+ if (i == Weights.Count)

+ {

+ break;

+ }

+ }

+

+ if (++WeightIndices >= (TexelParams.Width * TexelParams.Height)) break;

+ }

+

+ // Do infill if necessary (Section C.2.18) ...

+ int Ds = (1024 + (BlockWidth / 2)) / (BlockWidth - 1);

+ int Dt = (1024 + (BlockHeight / 2)) / (BlockHeight - 1);

+

+ int PlaneScale = TexelParams.DualPlane ? 2 : 1;

+

+ for (int Plane = 0; Plane < PlaneScale; Plane++)

+ {

+ for (int t = 0; t < BlockHeight; t++)

+ {

+ for (int s = 0; s < BlockWidth; s++)

+ {

+ int cs = Ds * s;

+ int ct = Dt * t;

+

+ int gs = (cs * (TexelParams.Width - 1) + 32) >> 6;

+ int gt = (ct * (TexelParams.Height - 1) + 32) >> 6;

+

+ int js = gs >> 4;

+ int fs = gs & 0xF;

+

+ int jt = gt >> 4;

+ int ft = gt & 0x0F;

+

+ int w11 = (fs * ft + 8) >> 4;

+ int w10 = ft - w11;

+ int w01 = fs - w11;

+ int w00 = 16 - fs - ft + w11;

+

+ int v0 = js + jt * TexelParams.Width;

+

+ int p00 = 0;

+ int p01 = 0;

+ int p10 = 0;

+ int p11 = 0;

+

+ if (v0 < (TexelParams.Width * TexelParams.Height))

+ {

+ p00 = Unquantized[Plane][v0];

+ }

+

+ if (v0 + 1 < (TexelParams.Width * TexelParams.Height))

+ {

+ p01 = Unquantized[Plane][v0 + 1];

+ }

+

+ if (v0 + TexelParams.Width < (TexelParams.Width * TexelParams.Height))

+ {

+ p10 = Unquantized[Plane][v0 + TexelParams.Width];

+ }

+

+ if (v0 + TexelParams.Width + 1 < (TexelParams.Width * TexelParams.Height))

+ {

+ p11 = Unquantized[Plane][v0 + TexelParams.Width + 1];

+ }

+

+ OutputBuffer[Plane][t * BlockWidth + s] = (p00 * w00 + p01 * w01 + p10 * w10 + p11 * w11 + 8) >> 4;

+ }

+ }

+ }

+ }

+

+ static int UnquantizeTexelWeight(IntegerEncoded IntEncoded)

+ {

+ int BitValue = IntEncoded.BitValue;

+ int BitLength = IntEncoded.NumberBits;

+

+ int A = BitArrayStream.Replicate(BitValue & 1, 1, 7);

+ int B = 0, C = 0, D = 0;

+

+ int Result = 0;

+

+ switch (IntEncoded.GetEncoding())

+ {

+ case IntegerEncoded.EIntegerEncoding.JustBits:

+ Result = BitArrayStream.Replicate(BitValue, BitLength, 6);

+ break;

+

+ case IntegerEncoded.EIntegerEncoding.Trit:

+ {

+ D = IntEncoded.TritValue;

+ Debug.Assert(D < 3);

+

+ switch (BitLength)

+ {

+ case 0:

+ {

+ int[] Results = { 0, 32, 63 };

+ Result = Results[D];

+

+ break;

+ }

+

+ case 1:

+ {

+ C = 50;

+ break;

+ }

+

+ case 2:

+ {

+ C = 23;

+ int b = (BitValue >> 1) & 1;

+ B = (b << 6) | (b << 2) | b;

+

+ break;

+ }

+

+ case 3:

+ {

+ C = 11;

+ int cb = (BitValue >> 1) & 3;

+ B = (cb << 5) | cb;

+

+ break;

+ }

+

+ default:

+ throw new ASTCDecoderException("Invalid trit encoding for texel weight");

+ }

+

+ break;

+ }

+

+ case IntegerEncoded.EIntegerEncoding.Quint:

+ {

+ D = IntEncoded.QuintValue;

+ Debug.Assert(D < 5);

+

+ switch (BitLength)

+ {

+ case 0:

+ {

+ int[] Results = { 0, 16, 32, 47, 63 };

+ Result = Results[D];

+

+ break;

+ }

+

+ case 1:

+ {

+ C = 28;

+

+ break;

+ }

+

+ case 2:

+ {

+ C = 13;

+ int b = (BitValue >> 1) & 1;

+ B = (b << 6) | (b << 1);

+

+ break;

+ }

+

+ default:

+ throw new ASTCDecoderException("Invalid quint encoding for texel weight");

+ }

+

+ break;

+ }

+ }

+

+ if (IntEncoded.GetEncoding() != IntegerEncoded.EIntegerEncoding.JustBits && BitLength > 0)

+ {

+ // Decode the value...

+ Result = D * C + B;

+ Result ^= A;

+ Result = (A & 0x20) | (Result >> 2);

+ }

+

+ Debug.Assert(Result < 64);

+

+ // Change from [0,63] to [0,64]

+ if (Result > 32)

+ {

+ Result += 1;

+ }

+

+ return Result;

+ }

+

+ static byte ReverseByte(byte b)

+ {

+ // Taken from http://graphics.stanford.edu/~seander/bithacks.html#ReverseByteWith64Bits

+ return (byte)((((b) * 0x80200802L) & 0x0884422110L) * 0x0101010101L >> 32);

+ }

+

+ static uint[] ReadUintColorValues(int Number, int[] ColorValues, ref int ColorValuesPosition)

+ {

+ uint[] Ret = new uint[Number];

+

+ for (int i = 0; i < Number; i++)

+ {

+ Ret[i] = (uint)ColorValues[ColorValuesPosition++];

+ }

+

+ return Ret;

+ }

+

+ static int[] ReadIntColorValues(int Number, int[] ColorValues, ref int ColorValuesPosition)

+ {

+ int[] Ret = new int[Number];

+

+ for (int i = 0; i < Number; i++)

+ {

+ Ret[i] = ColorValues[ColorValuesPosition++];

+ }

+

+ return Ret;

+ }

+

+ static void ComputeEndpoints(

+ ASTCPixel[] EndPoints,

+ int[] ColorValues,

+ uint ColorEndpointMode,

+ ref int ColorValuesPosition)

+ {

+ switch (ColorEndpointMode)

+ {

+ case 0:

+ {

+ uint[] Val = ReadUintColorValues(2, ColorValues, ref ColorValuesPosition);

+

+ EndPoints[0] = new ASTCPixel(0xFF, (short)Val[0], (short)Val[0], (short)Val[0]);

+ EndPoints[1] = new ASTCPixel(0xFF, (short)Val[1], (short)Val[1], (short)Val[1]);

+

+ break;

+ }

+

+

+ case 1:

+ {

+ uint[] Val = ReadUintColorValues(2, ColorValues, ref ColorValuesPosition);

+ int L0 = (int)((Val[0] >> 2) | (Val[1] & 0xC0));

+ int L1 = (int)Math.Max(L0 + (Val[1] & 0x3F), 0xFFU);

+

+ EndPoints[0] = new ASTCPixel(0xFF, (short)L0, (short)L0, (short)L0);

+ EndPoints[1] = new ASTCPixel(0xFF, (short)L1, (short)L1, (short)L1);

+

+ break;

+ }

+

+ case 4:

+ {

+ uint[] Val = ReadUintColorValues(4, ColorValues, ref ColorValuesPosition);

+

+ EndPoints[0] = new ASTCPixel((short)Val[2], (short)Val[0], (short)Val[0], (short)Val[0]);

+ EndPoints[1] = new ASTCPixel((short)Val[3], (short)Val[1], (short)Val[1], (short)Val[1]);

+

+ break;

+ }

+

+ case 5:

+ {

+ int[] Val = ReadIntColorValues(4, ColorValues, ref ColorValuesPosition);

+

+ BitArrayStream.BitTransferSigned(ref Val[1], ref Val[0]);

+ BitArrayStream.BitTransferSigned(ref Val[3], ref Val[2]);

+

+ EndPoints[0] = new ASTCPixel((short)Val[2], (short)Val[0], (short)Val[0], (short)Val[0]);

+ EndPoints[1] = new ASTCPixel((short)(Val[2] + Val[3]), (short)(Val[0] + Val[1]), (short)(Val[0] + Val[1]), (short)(Val[0] + Val[1]));

+

+ EndPoints[0].ClampByte();

+ EndPoints[1].ClampByte();

+

+ break;

+ }

+

+ case 6:

+ {

+ uint[] Val = ReadUintColorValues(4, ColorValues, ref ColorValuesPosition);

+

+ EndPoints[0] = new ASTCPixel(0xFF, (short)(Val[0] * Val[3] >> 8), (short)(Val[1] * Val[3] >> 8), (short)(Val[2] * Val[3] >> 8));

+ EndPoints[1] = new ASTCPixel(0xFF, (short)Val[0], (short)Val[1], (short)Val[2]);

+

+ break;

+ }

+

+ case 8:

+ {

+ uint[] Val = ReadUintColorValues(6, ColorValues, ref ColorValuesPosition);

+

+ if (Val[1] + Val[3] + Val[5] >= Val[0] + Val[2] + Val[4])

+ {

+ EndPoints[0] = new ASTCPixel(0xFF, (short)Val[0], (short)Val[2], (short)Val[4]);

+ EndPoints[1] = new ASTCPixel(0xFF, (short)Val[1], (short)Val[3], (short)Val[5]);

+ }

+ else

+ {

+ EndPoints[0] = ASTCPixel.BlueContract(0xFF, (short)Val[1], (short)Val[3], (short)Val[5]);

+ EndPoints[1] = ASTCPixel.BlueContract(0xFF, (short)Val[0], (short)Val[2], (short)Val[4]);

+ }

+

+ break;

+ }

+

+ case 9:

+ {

+ int[] Val = ReadIntColorValues(6, ColorValues, ref ColorValuesPosition);

+

+ BitArrayStream.BitTransferSigned(ref Val[1], ref Val[0]);

+ BitArrayStream.BitTransferSigned(ref Val[3], ref Val[2]);

+ BitArrayStream.BitTransferSigned(ref Val[5], ref Val[4]);

+

+ if (Val[1] + Val[3] + Val[5] >= 0)

+ {

+ EndPoints[0] = new ASTCPixel(0xFF, (short)Val[0], (short)Val[2], (short)Val[4]);

+ EndPoints[1] = new ASTCPixel(0xFF, (short)(Val[0] + Val[1]), (short)(Val[2] + Val[3]), (short)(Val[4] + Val[5]));

+ }

+ else

+ {

+ EndPoints[0] = ASTCPixel.BlueContract(0xFF, Val[0] + Val[1], Val[2] + Val[3], Val[4] + Val[5]);

+ EndPoints[1] = ASTCPixel.BlueContract(0xFF, Val[0], Val[2], Val[4]);

+ }

+

+ EndPoints[0].ClampByte();

+ EndPoints[1].ClampByte();

+

+ break;

+ }

+

+ case 10:

+ {

+ uint[] Val = ReadUintColorValues(6, ColorValues, ref ColorValuesPosition);

+

+ EndPoints[0] = new ASTCPixel((short)Val[4], (short)(Val[0] * Val[3] >> 8), (short)(Val[1] * Val[3] >> 8), (short)(Val[2] * Val[3] >> 8));

+ EndPoints[1] = new ASTCPixel((short)Val[5], (short)Val[0], (short)Val[1], (short)Val[2]);

+

+ break;

+ }

+

+ case 12:

+ {

+ uint[] Val = ReadUintColorValues(8, ColorValues, ref ColorValuesPosition);

+

+ if (Val[1] + Val[3] + Val[5] >= Val[0] + Val[2] + Val[4])

+ {

+ EndPoints[0] = new ASTCPixel((short)Val[6], (short)Val[0], (short)Val[2], (short)Val[4]);

+ EndPoints[1] = new ASTCPixel((short)Val[7], (short)Val[1], (short)Val[3], (short)Val[5]);

+ }

+ else

+ {

+ EndPoints[0] = ASTCPixel.BlueContract((short)Val[7], (short)Val[1], (short)Val[3], (short)Val[5]);

+ EndPoints[1] = ASTCPixel.BlueContract((short)Val[6], (short)Val[0], (short)Val[2], (short)Val[4]);

+ }

+

+ break;

+ }

+

+ case 13:

+ {

+ int[] Val = ReadIntColorValues(8, ColorValues, ref ColorValuesPosition);

+

+ BitArrayStream.BitTransferSigned(ref Val[1], ref Val[0]);

+ BitArrayStream.BitTransferSigned(ref Val[3], ref Val[2]);

+ BitArrayStream.BitTransferSigned(ref Val[5], ref Val[4]);

+ BitArrayStream.BitTransferSigned(ref Val[7], ref Val[6]);

+

+ if (Val[1] + Val[3] + Val[5] >= 0)

+ {

+ EndPoints[0] = new ASTCPixel((short)Val[6], (short)Val[0], (short)Val[2], (short)Val[4]);

+ EndPoints[1] = new ASTCPixel((short)(Val[7] + Val[6]), (short)(Val[0] + Val[1]), (short)(Val[2] + Val[3]), (short)(Val[4] + Val[5]));

+ }

+ else

+ {

+ EndPoints[0] = ASTCPixel.BlueContract(Val[6] + Val[7], Val[0] + Val[1], Val[2] + Val[3], Val[4] + Val[5]);

+ EndPoints[1] = ASTCPixel.BlueContract(Val[6], Val[0], Val[2], Val[4]);

+ }

+

+ EndPoints[0].ClampByte();

+ EndPoints[1].ClampByte();

+

+ break;

+ }

+

+ default:

+ throw new ASTCDecoderException("Unsupported color endpoint mode (is it HDR?)");

+ }

+ }

+

+ static void DecodeColorValues(

+ int[] OutputValues,

+ byte[] InputData,

+ uint[] Modes,

+ int NumberPartitions,

+ int NumberBitsForColorData)

+ {

+ // First figure out how many color values we have

+ int NumberValues = 0;

+

+ for (int i = 0; i < NumberPartitions; i++)

+ {

+ NumberValues += (int)((Modes[i] >> 2) + 1) << 1;

+ }

+

+ // Then based on the number of values and the remaining number of bits,

+ // figure out the max value for each of them...

+ int Range = 256;

+

+ while (--Range > 0)

+ {

+ IntegerEncoded IntEncoded = IntegerEncoded.CreateEncoding(Range);

+ int BitLength = IntEncoded.GetBitLength(NumberValues);

+

+ if (BitLength <= NumberBitsForColorData)

+ {

+ // Find the smallest possible range that matches the given encoding

+ while (--Range > 0)

+ {

+ IntegerEncoded NewIntEncoded = IntegerEncoded.CreateEncoding(Range);

+ if (!NewIntEncoded.MatchesEncoding(IntEncoded))

+ {

+ break;

+ }

+ }

+

+ // Return to last matching range.

+ Range++;

+ break;

+ }

+ }

+

+ // We now have enough to decode our integer sequence.

+ List<IntegerEncoded> IntegerEncodedSequence = new List<IntegerEncoded>();

+ BitArrayStream ColorBitStream = new BitArrayStream(new BitArray(InputData));

+

+ IntegerEncoded.DecodeIntegerSequence(IntegerEncodedSequence, ColorBitStream, Range, NumberValues);

+

+ // Once we have the decoded values, we need to dequantize them to the 0-255 range

+ // This procedure is outlined in ASTC spec C.2.13

+ int OutputIndices = 0;

+

+ foreach (IntegerEncoded IntEncoded in IntegerEncodedSequence)

+ {

+ int BitLength = IntEncoded.NumberBits;

+ int BitValue = IntEncoded.BitValue;

+

+ Debug.Assert(BitLength >= 1);

+

+ int A = 0, B = 0, C = 0, D = 0;

+ // A is just the lsb replicated 9 times.

+ A = BitArrayStream.Replicate(BitValue & 1, 1, 9);

+

+ switch (IntEncoded.GetEncoding())

+ {

+ case IntegerEncoded.EIntegerEncoding.JustBits:

+ {

+ OutputValues[OutputIndices++] = BitArrayStream.Replicate(BitValue, BitLength, 8);

+

+ break;

+ }

+

+ case IntegerEncoded.EIntegerEncoding.Trit:

+ {

+ D = IntEncoded.TritValue;

+

+ switch (BitLength)

+ {

+ case 1:

+ {

+ C = 204;

+

+ break;

+ }

+

+ case 2:

+ {

+ C = 93;

+ // B = b000b0bb0

+ int b = (BitValue >> 1) & 1;

+ B = (b << 8) | (b << 4) | (b << 2) | (b << 1);

+

+ break;

+ }

+

+ case 3:

+ {

+ C = 44;

+ // B = cb000cbcb

+ int cb = (BitValue >> 1) & 3;

+ B = (cb << 7) | (cb << 2) | cb;

+

+ break;

+ }

+

+

+ case 4:

+ {

+ C = 22;

+ // B = dcb000dcb

+ int dcb = (BitValue >> 1) & 7;

+ B = (dcb << 6) | dcb;

+

+ break;

+ }

+

+ case 5:

+ {

+ C = 11;

+ // B = edcb000ed

+ int edcb = (BitValue >> 1) & 0xF;

+ B = (edcb << 5) | (edcb >> 2);

+

+ break;

+ }

+

+ case 6:

+ {

+ C = 5;

+ // B = fedcb000f

+ int fedcb = (BitValue >> 1) & 0x1F;

+ B = (fedcb << 4) | (fedcb >> 4);

+

+ break;

+ }

+

+ default:

+ throw new ASTCDecoderException("Unsupported trit encoding for color values!");

+ }

+

+ break;

+ }

+

+ case IntegerEncoded.EIntegerEncoding.Quint:

+ {

+ D = IntEncoded.QuintValue;

+

+ switch (BitLength)

+ {

+ case 1:

+ {

+ C = 113;

+

+ break;

+ }

+

+ case 2:

+ {

+ C = 54;

+ // B = b0000bb00

+ int b = (BitValue >> 1) & 1;

+ B = (b << 8) | (b << 3) | (b << 2);

+

+ break;

+ }

+

+ case 3:

+ {

+ C = 26;

+ // B = cb0000cbc

+ int cb = (BitValue >> 1) & 3;

+ B = (cb << 7) | (cb << 1) | (cb >> 1);

+

+ break;

+ }

+

+ case 4:

+ {

+ C = 13;

+ // B = dcb0000dc

+ int dcb = (BitValue >> 1) & 7;

+ B = (dcb << 6) | (dcb >> 1);

+

+ break;

+ }

+

+ case 5:

+ {

+ C = 6;

+ // B = edcb0000e

+ int edcb = (BitValue >> 1) & 0xF;

+ B = (edcb << 5) | (edcb >> 3);

+

+ break;

+ }

+

+ default:

+ throw new ASTCDecoderException("Unsupported quint encoding for color values!");

+ }

+ break;

+ }

+ }

+

+ if (IntEncoded.GetEncoding() != IntegerEncoded.EIntegerEncoding.JustBits)

+ {

+ int T = D * C + B;

+ T ^= A;

+ T = (A & 0x80) | (T >> 2);

+

+ OutputValues[OutputIndices++] = T;

+ }

+ }

+

+ // Make sure that each of our values is in the proper range...

+ for (int i = 0; i < NumberValues; i++)

+ {

+ Debug.Assert(OutputValues[i] <= 255);

+ }

+ }

+

+ static void FillVoidExtentLDR(BitArrayStream BitStream, int[] OutputBuffer, int BlockWidth, int BlockHeight)

+ {

+ // Don't actually care about the void extent, just read the bits...

+ for (int i = 0; i < 4; ++i)

+ {

+ BitStream.ReadBits(13);

+ }

+

+ // Decode the RGBA components and renormalize them to the range [0, 255]

+ ushort R = (ushort)BitStream.ReadBits(16);

+ ushort G = (ushort)BitStream.ReadBits(16);

+ ushort B = (ushort)BitStream.ReadBits(16);

+ ushort A = (ushort)BitStream.ReadBits(16);

+

+ int RGBA = (R >> 8) | (G & 0xFF00) | ((B) & 0xFF00) << 8 | ((A) & 0xFF00) << 16;

+

+ for (int j = 0; j < BlockHeight; j++)

+ {

+ for (int i = 0; i < BlockWidth; i++)

+ {

+ OutputBuffer[j * BlockWidth + i] = RGBA;

+ }

+ }

+ }

+

+ static TexelWeightParams DecodeBlockInfo(BitArrayStream BitStream)

+ {

+ TexelWeightParams TexelParams = new TexelWeightParams();

+

+ // Read the entire block mode all at once

+ ushort ModeBits = (ushort)BitStream.ReadBits(11);

+

+ // Does this match the void extent block mode?

+ if ((ModeBits & 0x01FF) == 0x1FC)

+ {

+ if ((ModeBits & 0x200) != 0)

+ {

+ TexelParams.VoidExtentHDR = true;

+ }

+ else

+ {

+ TexelParams.VoidExtentLDR = true;

+ }

+

+ // Next two bits must be one.

+ if ((ModeBits & 0x400) == 0 || BitStream.ReadBits(1) == 0)

+ {

+ TexelParams.Error = true;

+ }

+

+ return TexelParams;

+ }

+

+ // First check if the last four bits are zero

+ if ((ModeBits & 0xF) == 0)

+ {

+ TexelParams.Error = true;

+ return TexelParams;

+ }

+

+ // If the last two bits are zero, then if bits

+ // [6-8] are all ones, this is also reserved.

+ if ((ModeBits & 0x3) == 0 && (ModeBits & 0x1C0) == 0x1C0)

+ {

+ TexelParams.Error = true;

+

+ return TexelParams;

+ }

+

+ // Otherwise, there is no error... Figure out the layout

+ // of the block mode. Layout is determined by a number

+ // between 0 and 9 corresponding to table C.2.8 of the

+ // ASTC spec.

+ int Layout = 0;

+

+ if ((ModeBits & 0x1) != 0 || (ModeBits & 0x2) != 0)

+ {

+ // layout is in [0-4]

+ if ((ModeBits & 0x8) != 0)

+ {

+ // layout is in [2-4]

+ if ((ModeBits & 0x4) != 0)

+ {

+ // layout is in [3-4]

+ if ((ModeBits & 0x100) != 0)

+ {

+ Layout = 4;

+ }

+ else

+ {

+ Layout = 3;

+ }

+ }

+ else

+ {

+ Layout = 2;

+ }

+ }

+ else

+ {

+ // layout is in [0-1]

+ if ((ModeBits & 0x4) != 0)

+ {

+ Layout = 1;

+ }

+ else

+ {

+ Layout = 0;

+ }

+ }

+ }

+ else

+ {

+ // layout is in [5-9]

+ if ((ModeBits & 0x100) != 0)

+ {

+ // layout is in [7-9]

+ if ((ModeBits & 0x80) != 0)

+ {

+ // layout is in [7-8]

+ Debug.Assert((ModeBits & 0x40) == 0);

+

+ if ((ModeBits & 0x20) != 0)

+ {

+ Layout = 8;

+ }

+ else

+ {

+ Layout = 7;

+ }

+ }

+ else

+ {

+ Layout = 9;

+ }

+ }

+ else

+ {

+ // layout is in [5-6]

+ if ((ModeBits & 0x80) != 0)

+ {

+ Layout = 6;

+ }

+ else

+ {

+ Layout = 5;

+ }

+ }

+ }

+

+ Debug.Assert(Layout < 10);

+

+ // Determine R

+ int R = (ModeBits >> 4) & 1;

+ if (Layout < 5)

+ {

+ R |= (ModeBits & 0x3) << 1;

+ }

+ else

+ {

+ R |= (ModeBits & 0xC) >> 1;

+ }

+

+ Debug.Assert(2 <= R && R <= 7);

+

+ // Determine width & height

+ switch (Layout)

+ {

+ case 0:

+ {

+ int A = (ModeBits >> 5) & 0x3;

+ int B = (ModeBits >> 7) & 0x3;

+

+ TexelParams.Width = B + 4;

+ TexelParams.Height = A + 2;

+

+ break;

+ }

+

+ case 1:

+ {

+ int A = (ModeBits >> 5) & 0x3;

+ int B = (ModeBits >> 7) & 0x3;

+

+ TexelParams.Width = B + 8;

+ TexelParams.Height = A + 2;

+

+ break;

+ }

+

+ case 2:

+ {

+ int A = (ModeBits >> 5) & 0x3;

+ int B = (ModeBits >> 7) & 0x3;

+

+ TexelParams.Width = A + 2;

+ TexelParams.Height = B + 8;

+

+ break;

+ }

+

+ case 3:

+ {

+ int A = (ModeBits >> 5) & 0x3;

+ int B = (ModeBits >> 7) & 0x1;

+

+ TexelParams.Width = A + 2;

+ TexelParams.Height = B + 6;

+

+ break;

+ }

+

+ case 4:

+ {

+ int A = (ModeBits >> 5) & 0x3;

+ int B = (ModeBits >> 7) & 0x1;

+

+ TexelParams.Width = B + 2;

+ TexelParams.Height = A + 2;

+

+ break;

+ }

+

+ case 5:

+ {

+ int A = (ModeBits >> 5) & 0x3;

+

+ TexelParams.Width = 12;

+ TexelParams.Height = A + 2;

+

+ break;

+ }

+

+ case 6:

+ {

+ int A = (ModeBits >> 5) & 0x3;

+

+ TexelParams.Width = A + 2;

+ TexelParams.Height = 12;

+

+ break;

+ }

+

+ case 7:

+ {

+ TexelParams.Width = 6;

+ TexelParams.Height = 10;

+

+ break;

+ }

+

+ case 8:

+ {

+ TexelParams.Width = 10;

+ TexelParams.Height = 6;

+ break;

+ }

+

+ case 9:

+ {

+ int A = (ModeBits >> 5) & 0x3;

+ int B = (ModeBits >> 9) & 0x3;

+

+ TexelParams.Width = A + 6;

+ TexelParams.Height = B + 6;

+

+ break;

+ }

+

+ default:

+ //Don't know this layout...

+ TexelParams.Error = true;

+ break;

+ }

+

+ // Determine whether or not we're using dual planes

+ // and/or high precision layouts.

+ bool D = ((Layout != 9) && ((ModeBits & 0x400) != 0));

+ bool H = (Layout != 9) && ((ModeBits & 0x200) != 0);

+

+ if (H)

+ {

+ int[] MaxWeights = { 9, 11, 15, 19, 23, 31 };

+ TexelParams.MaxWeight = MaxWeights[R - 2];

+ }

+ else

+ {

+ int[] MaxWeights = { 1, 2, 3, 4, 5, 7 };

+ TexelParams.MaxWeight = MaxWeights[R - 2];

+ }

+

+ TexelParams.DualPlane = D;

+

+ return TexelParams;

+ }

+ }

+}

+using System;

+using System.Diagnostics;

+

+namespace Ryujinx.Graphics.Texture

+{

+ class ASTCPixel

+ {

+ public short R { get; set; }

+ public short G { get; set; }

+ public short B { get; set; }

+ public short A { get; set; }

+

+ byte[] BitDepth = new byte[4];

+

+ public ASTCPixel(short _A, short _R, short _G, short _B)

+ {

+ A = _A;

+ R = _R;

+ G = _G;

+ B = _B;

+

+ for (int i = 0; i < 4; i++)

+ BitDepth[i] = 8;

+ }

+

+ public void ClampByte()

+ {

+ R = Math.Min(Math.Max(R, (short)0), (short)255);

+ G = Math.Min(Math.Max(G, (short)0), (short)255);

+ B = Math.Min(Math.Max(B, (short)0), (short)255);

+ A = Math.Min(Math.Max(A, (short)0), (short)255);

+ }

+

+ public short GetComponent(int Index)

+ {

+ switch(Index)

+ {

+ case 0: return A;

+ case 1: return R;

+ case 2: return G;

+ case 3: return B;

+ }

+

+ return 0;

+ }

+

+ public void SetComponent(int Index, int Value)

+ {

+ switch (Index)

+ {

+ case 0:

+ A = (short)Value;

+ break;

+ case 1:

+ R = (short)Value;

+ break;

+ case 2:

+ G = (short)Value;

+ break;

+ case 3:

+ B = (short)Value;

+ break;

+ }

+ }

+

+ public void ChangeBitDepth(byte[] Depth)

+ {

+ for(int i = 0; i< 4; i++)

+ {

+ int Value = ChangeBitDepth(GetComponent(i), BitDepth[i], Depth[i]);

+

+ SetComponent(i, Value);

+ BitDepth[i] = Depth[i];

+ }

+ }

+

+ short ChangeBitDepth(short Value, byte OldDepth, byte NewDepth)

+ {

+ Debug.Assert(NewDepth <= 8);

+ Debug.Assert(OldDepth <= 8);

+

+ if (OldDepth == NewDepth)

+ {

+ // Do nothing

+ return Value;

+ }

+ else if (OldDepth == 0 && NewDepth != 0)

+ {

+ return (short)((1 << NewDepth) - 1);

+ }

+ else if (NewDepth > OldDepth)

+ {

+ return (short)BitArrayStream.Replicate(Value, OldDepth, NewDepth);

+ }

+ else

+ {

+ // oldDepth > newDepth

+ if (NewDepth == 0)

+ {

+ return 0xFF;

+ }

+ else

+ {

+ byte BitsWasted = (byte)(OldDepth - NewDepth);

+ short TempValue = Value;

+

+ TempValue = (short)((TempValue + (1 << (BitsWasted - 1))) >> BitsWasted);

+ TempValue = Math.Min(Math.Max((short)0, TempValue), (short)((1 << NewDepth) - 1));

+

+ return (byte)(TempValue);

+ }

+ }

+ }

+

+ public int Pack()

+ {

+ ASTCPixel NewPixel = new ASTCPixel(A, R, G, B);

+ byte[] eightBitDepth = { 8, 8, 8, 8 };

+

+ NewPixel.ChangeBitDepth(eightBitDepth);

+

+ return (byte)NewPixel.A << 24 |

+ (byte)NewPixel.B << 16 |

+ (byte)NewPixel.G << 8 |

+ (byte)NewPixel.R << 0;

+ }

+

+ // Adds more precision to the blue channel as described

+ // in C.2.14

+ public static ASTCPixel BlueContract(int a, int r, int g, int b)

+ {

+ return new ASTCPixel((short)(a),

+ (short)((r + b) >> 1),

+ (short)((g + b) >> 1),

+ (short)(b));

+ }

+ }

+}

+using System;

+using System.Collections;

+

+namespace Ryujinx.Graphics.Texture

+{

+ public class BitArrayStream

+ {

+ public BitArray BitsArray;

+

+ public int Position { get; private set; }

+

+ public BitArrayStream(BitArray BitArray)

+ {

+ BitsArray = BitArray;

+ Position = 0;

+ }

+

+ public short ReadBits(int Length)

+ {

+ int RetValue = 0;

+ for (int i = Position; i < Position + Length; i++)

+ {

+ if (BitsArray[i])

+ {

+ RetValue |= 1 << (i - Position);

+ }

+ }

+

+ Position += Length;

+ return (short)RetValue;

+ }

+

+ public int ReadBits(int Start, int End)

+ {

+ int RetValue = 0;

+ for (int i = Start; i <= End; i++)

+ {

+ if (BitsArray[i])

+ {

+ RetValue |= 1 << (i - Start);

+ }

+ }

+

+ return RetValue;

+ }

+

+ public int ReadBit(int Index)

+ {

+ return Convert.ToInt32(BitsArray[Index]);

+ }

+

+ public void WriteBits(int Value, int Length)

+ {

+ for (int i = Position; i < Position + Length; i++)

+ {

+ BitsArray[i] = ((Value >> (i - Position)) & 1) != 0;

+ }

+

+ Position += Length;

+ }

+

+ public byte[] ToByteArray()

+ {

+ byte[] RetArray = new byte[(BitsArray.Length + 7) / 8];

+ BitsArray.CopyTo(RetArray, 0);

+ return RetArray;

+ }

+

+ public static int Replicate(int Value, int NumberBits, int ToBit)

+ {

+ if (NumberBits == 0) return 0;

+ if (ToBit == 0) return 0;

+

+ int TempValue = Value & ((1 << NumberBits) - 1);

+ int RetValue = TempValue;

+ int ResLength = NumberBits;

+

+ while (ResLength < ToBit)

+ {

+ int Comp = 0;

+ if (NumberBits > ToBit - ResLength)

+ {

+ int NewShift = ToBit - ResLength;

+ Comp = NumberBits - NewShift;

+ NumberBits = NewShift;

+ }

+ RetValue <<= NumberBits;

+ RetValue |= TempValue >> Comp;

+ ResLength += NumberBits;

+ }

+ return RetValue;

+ }

+

+ public static int PopCnt(int Number)

+ {

+ int Counter;

+ for (Counter = 0; Number != 0; Counter++)

+ {

+ Number &= Number - 1;

+ }

+ return Counter;

+ }

+

+ public static void Swap<T>(ref T lhs, ref T rhs)

+ {

+ T Temp = lhs;

+ lhs = rhs;

+ rhs = Temp;

+ }

+

+ // Transfers a bit as described in C.2.14

+ public static void BitTransferSigned(ref int a, ref int b)

+ {

+ b >>= 1;

+ b |= a & 0x80;

+ a >>= 1;

+ a &= 0x3F;

+ if ((a & 0x20) != 0) a -= 0x40;

+ }

+ }

+}

+namespace Ryujinx.Graphics.Texture

+namespace Ryujinx.Graphics.Texture

+namespace Ryujinx.Graphics.Texture

+{

+ static class ImageConverter

+ {

+ public static byte[] G8R8ToR8G8(

+ byte[] Data,

+ int Width,

+ int Height,

+ int Depth)

+ {

+ int Texels = Width * Height * Depth;

+

+ byte[] Output = new byte[Texels * 2];

+

+ for (int Texel = 0; Texel < Texels; Texel++)

+ {

+ Output[Texel * 2 + 0] = Data[Texel * 2 + 1];

+ Output[Texel * 2 + 1] = Data[Texel * 2 + 0];

+ }

+

+ return Output;

+ }

+ }

+} \ No newline at end of file

+using Ryujinx.Graphics.Gal;

+using System;

+using System.Collections.Generic;

+

+namespace Ryujinx.Graphics.Texture

+{

+ static class ImageUtils

+ {

+ struct ImageDescriptor

+ {

+ public TextureReaderDelegate Reader;

+

+ public bool HasColor;

+ public bool HasDepth;

+ public bool HasStencil;

+

+ public bool Compressed;

+

+ public ImageDescriptor(

+ TextureReaderDelegate Reader,

+ bool HasColor,

+ bool HasDepth,

+ bool HasStencil,

+ bool Compressed)

+ {

+ this.Reader = Reader;

+ this.HasColor = HasColor;

+ this.HasDepth = HasDepth;

+ this.HasStencil = HasStencil;

+ this.Compressed = Compressed;

+ }

+ }

+

+ private const GalImageFormat Snorm = GalImageFormat.Snorm;

+ private const GalImageFormat Unorm = GalImageFormat.Unorm;

+ private const GalImageFormat Sint = GalImageFormat.Sint;

+ private const GalImageFormat Uint = GalImageFormat.Uint;

+ private const GalImageFormat Sfloat = GalImageFormat.Sfloat;

+

+ private static readonly Dictionary<GalTextureFormat, GalImageFormat> s_TextureTable =

+ new Dictionary<GalTextureFormat, GalImageFormat>()

+ {

+ { GalTextureFormat.R32G32B32A32, GalImageFormat.R32G32B32A32 | Sint | Uint | Sfloat },

+ { GalTextureFormat.R16G16B16A16, GalImageFormat.R16G16B16A16 | Snorm | Unorm | Sint | Uint | Sfloat },

+ { GalTextureFormat.R32G32, GalImageFormat.R32G32 | Sint | Uint | Sfloat },

+ { GalTextureFormat.A8B8G8R8, GalImageFormat.A8B8G8R8 | Snorm | Unorm | Sint | Uint },

+ { GalTextureFormat.A2B10G10R10, GalImageFormat.A2B10G10R10 | Snorm | Unorm | Sint | Uint },

+ { GalTextureFormat.G8R8, GalImageFormat.G8R8 | Snorm | Unorm | Sint | Uint },

+ { GalTextureFormat.R16, GalImageFormat.R16 | Snorm | Unorm | Sint | Uint | Sfloat },

+ { GalTextureFormat.R8, GalImageFormat.R8 | Snorm | Unorm | Sint | Uint },

+ { GalTextureFormat.R32, GalImageFormat.R32 | Sint | Uint | Sfloat },

+ { GalTextureFormat.A4B4G4R4, GalImageFormat.A4B4G4R4 | Unorm },

+ { GalTextureFormat.A1B5G5R5, GalImageFormat.A1R5G5B5 | Unorm },

+ { GalTextureFormat.B5G6R5, GalImageFormat.B5G6R5 | Unorm },

+ { GalTextureFormat.BF10GF11RF11, GalImageFormat.B10G11R11 | Sfloat },

+ { GalTextureFormat.Z24S8, GalImageFormat.D24_S8 | Unorm },

+ { GalTextureFormat.ZF32, GalImageFormat.D32 | Sfloat },

+ { GalTextureFormat.ZF32_X24S8, GalImageFormat.D32_S8 | Unorm },

+

+ //Compressed formats

+ { GalTextureFormat.BC6H_SF16, GalImageFormat.BC6H_SF16 | Unorm },

+ { GalTextureFormat.BC6H_UF16, GalImageFormat.BC6H_UF16 | Unorm },

+ { GalTextureFormat.BC7U, GalImageFormat.BC7 | Unorm },

+ { GalTextureFormat.BC1, GalImageFormat.BC1_RGBA | Unorm },

+ { GalTextureFormat.BC2, GalImageFormat.BC2 | Unorm },

+ { GalTextureFormat.BC3, GalImageFormat.BC3 | Unorm },

+ { GalTextureFormat.BC4, GalImageFormat.BC4 | Unorm | Snorm },

+ { GalTextureFormat.BC5, GalImageFormat.BC5 | Unorm | Snorm },

+ { GalTextureFormat.Astc2D4x4, GalImageFormat.ASTC_4x4 | Unorm },

+ { GalTextureFormat.Astc2D5x5, GalImageFormat.ASTC_5x5 | Unorm },

+ { GalTextureFormat.Astc2D6x6, GalImageFormat.ASTC_6x6 | Unorm },

+ { GalTextureFormat.Astc2D8x8, GalImageFormat.ASTC_8x8 | Unorm },

+ { GalTextureFormat.Astc2D10x10, GalImageFormat.ASTC_10x10 | Unorm },

+ { GalTextureFormat.Astc2D12x12, GalImageFormat.ASTC_12x12 | Unorm },

+ { GalTextureFormat.Astc2D5x4, GalImageFormat.ASTC_5x4 | Unorm },

+ { GalTextureFormat.Astc2D6x5, GalImageFormat.ASTC_6x5 | Unorm },

+ { GalTextureFormat.Astc2D8x6, GalImageFormat.ASTC_8x6 | Unorm },

+ { GalTextureFormat.Astc2D10x8, GalImageFormat.ASTC_10x8 | Unorm },

+ { GalTextureFormat.Astc2D12x10, GalImageFormat.ASTC_12x10 | Unorm },

+ { GalTextureFormat.Astc2D8x5, GalImageFormat.ASTC_8x5 | Unorm },

+ { GalTextureFormat.Astc2D10x5, GalImageFormat.ASTC_10x5 | Unorm },

+ { GalTextureFormat.Astc2D10x6, GalImageFormat.ASTC_10x6 | Unorm }

+ };

+

+ private static readonly Dictionary<GalImageFormat, ImageDescriptor> s_ImageTable =

+ new Dictionary<GalImageFormat, ImageDescriptor>()

+ {

+ { GalImageFormat.R32G32B32A32, new ImageDescriptor(TextureReader.Read16Bpp, true, false, false, false) },

+ { GalImageFormat.R16G16B16A16, new ImageDescriptor(TextureReader.Read8Bpp, true, false, false, false) },

+ { GalImageFormat.R32G32, new ImageDescriptor(TextureReader.Read8Bpp, true, false, false, false) },

+ { GalImageFormat.A8B8G8R8, new ImageDescriptor(TextureReader.Read4Bpp, true, false, false, false) },

+ { GalImageFormat.A2B10G10R10, new ImageDescriptor(TextureReader.Read4Bpp, true, false, false, false) },

+ { GalImageFormat.R32, new ImageDescriptor(TextureReader.Read4Bpp, true, false, false, false) },

+ { GalImageFormat.A4B4G4R4, new ImageDescriptor(TextureReader.Read2Bpp, true, false, false, false) },

+ { GalImageFormat.BC6H_SF16, new ImageDescriptor(TextureReader.Read16BptCompressedTexture4x4, true, false, false, true) },

+ { GalImageFormat.BC6H_UF16, new ImageDescriptor(TextureReader.Read16BptCompressedTexture4x4, true, false, false, true) },

+ { GalImageFormat.A1R5G5B5, new ImageDescriptor(TextureReader.Read5551, true, false, false, false) },

+ { GalImageFormat.B5G6R5, new ImageDescriptor(TextureReader.Read565, true, false, false, false) },

+ { GalImageFormat.BC7, new ImageDescriptor(TextureReader.Read16BptCompressedTexture4x4, true, false, false, true) },

+ { GalImageFormat.R16G16, new ImageDescriptor(TextureReader.Read4Bpp, true, false, false, false) },

+ { GalImageFormat.R8G8, new ImageDescriptor(TextureReader.Read2Bpp, true, false, false, false) },

+ { GalImageFormat.G8R8, new ImageDescriptor(TextureReader.Read2Bpp, true, false, false, false) },

+ { GalImageFormat.R16, new ImageDescriptor(TextureReader.Read2Bpp, true, false, false, false) },

+ { GalImageFormat.R8, new ImageDescriptor(TextureReader.Read1Bpp, true, false, false, false) },

+ { GalImageFormat.B10G11R11, new ImageDescriptor(TextureReader.Read4Bpp, true, false, false, false) },

+ { GalImageFormat.A8B8G8R8_SRGB, new ImageDescriptor(TextureReader.Read4Bpp, true, false, false, false) },

+ { GalImageFormat.BC1_RGBA, new ImageDescriptor(TextureReader.Read8Bpt4x4, true, false, false, true) },

+ { GalImageFormat.BC2, new ImageDescriptor(TextureReader.Read16BptCompressedTexture4x4, true, false, false, true) },

+ { GalImageFormat.BC3, new ImageDescriptor(TextureReader.Read16BptCompressedTexture4x4, true, false, false, true) },

+ { GalImageFormat.BC4, new ImageDescriptor(TextureReader.Read8Bpt4x4, true, false, false, true) },

+ { GalImageFormat.BC5, new ImageDescriptor(TextureReader.Read16BptCompressedTexture4x4, true, false, false, true) },

+ { GalImageFormat.ASTC_4x4, new ImageDescriptor(TextureReader.Read16BptCompressedTexture4x4, true, false, false, true) },

+ { GalImageFormat.ASTC_5x5, new ImageDescriptor(TextureReader.Read16BptCompressedTexture5x5, true, false, false, true) },

+ { GalImageFormat.ASTC_6x6, new ImageDescriptor(TextureReader.Read16BptCompressedTexture6x6, true, false, false, true) },

+ { GalImageFormat.ASTC_8x8, new ImageDescriptor(TextureReader.Read16BptCompressedTexture8x8, true, false, false, true) },

+ { GalImageFormat.ASTC_10x10, new ImageDescriptor(TextureReader.Read16BptCompressedTexture10x10, true, false, false, true) },

+ { GalImageFormat.ASTC_12x12, new ImageDescriptor(TextureReader.Read16BptCompressedTexture12x12, true, false, false, true) },

+ { GalImageFormat.ASTC_5x4, new ImageDescriptor(TextureReader.Read16BptCompressedTexture5x4, true, false, false, true) },

+ { GalImageFormat.ASTC_6x5, new ImageDescriptor(TextureReader.Read16BptCompressedTexture6x5, true, false, false, true) },

+ { GalImageFormat.ASTC_8x6, new ImageDescriptor(TextureReader.Read16BptCompressedTexture8x6, true, false, false, true) },

+ { GalImageFormat.ASTC_10x8, new ImageDescriptor(TextureReader.Read16BptCompressedTexture10x8, true, false, false, true) },

+ { GalImageFormat.ASTC_12x10, new ImageDescriptor(TextureReader.Read16BptCompressedTexture12x10, true, false, false, true) },

+ { GalImageFormat.ASTC_8x5, new ImageDescriptor(TextureReader.Read16BptCompressedTexture8x5, true, false, false, true) },

+ { GalImageFormat.ASTC_10x5, new ImageDescriptor(TextureReader.Read16BptCompressedTexture10x5, true, false, false, true) },

+ { GalImageFormat.ASTC_10x6, new ImageDescriptor(TextureReader.Read16BptCompressedTexture10x6, true, false, false, true) },

+

+ { GalImageFormat.D24_S8, new ImageDescriptor(TextureReader.Read4Bpp, false, true, true, false) },

+ { GalImageFormat.D32, new ImageDescriptor(TextureReader.Read4Bpp, false, true, false, false) },

+ { GalImageFormat.D16, new ImageDescriptor(TextureReader.Read2Bpp, false, true, false, false) },

+ { GalImageFormat.D32_S8, new ImageDescriptor(TextureReader.Read8Bpp, false, true, true, false) },

+ };

+

+ public static GalImageFormat ConvertTexture(

+ GalTextureFormat Format,

+ GalTextureType RType,

+ GalTextureType GType,

+ GalTextureType BType,

+ GalTextureType AType)

+ {

+ if (RType != GType || RType != BType || RType != AType)

+ {

+ throw new NotImplementedException("Per component types are not implemented");

+ }

+

+ if (!s_TextureTable.TryGetValue(Format, out GalImageFormat ImageFormat))

+ {

+ throw new NotImplementedException("Texture with format " + ((int)Format).ToString("x2") + " not implemented");

+ }

+

+ GalTextureType Type = RType;

+

+ GalImageFormat FormatType = GetFormatType(RType);

+

+ if (ImageFormat.HasFlag(FormatType))

+ {

+ return (ImageFormat & GalImageFormat.FormatMask) | FormatType;

+ }

+ else

+ {

+ throw new NotImplementedException("Texture with format " + Format +

+ " and component type " + Type + " is not implemented");

+ }

+ }

+

+ public static GalImageFormat ConvertSurface(GalSurfaceFormat Format)

+ {

+ switch (Format)

+ {

+ case GalSurfaceFormat.RGBA32Float: return GalImageFormat.R32G32B32A32 | Sfloat;

+ case GalSurfaceFormat.RGBA16Float: return GalImageFormat.R16G16B16A16 | Sfloat;

+ case GalSurfaceFormat.RG32Float: return GalImageFormat.R32G32 | Sfloat;

+ case GalSurfaceFormat.RG32Sint: return GalImageFormat.R32G32 | Sint;

+ case GalSurfaceFormat.RG32Uint: return GalImageFormat.R32G32 | Uint;

+ case GalSurfaceFormat.BGRA8Unorm: return GalImageFormat.R8G8B8A8 | Unorm; //Is this right?

+ case GalSurfaceFormat.BGRA8Srgb: return GalImageFormat.A8B8G8R8_SRGB; //This one might be wrong

+ case GalSurfaceFormat.RGB10A2Unorm: return GalImageFormat.A2B10G10R10 | Unorm;

+ case GalSurfaceFormat.RGBA8Unorm: return GalImageFormat.A8B8G8R8 | Unorm;

+ case GalSurfaceFormat.RGBA8Srgb: return GalImageFormat.A8B8G8R8_SRGB;

+ case GalSurfaceFormat.RGBA8Snorm: return GalImageFormat.A8B8G8R8 | Snorm;

+ case GalSurfaceFormat.RG16Snorm: return GalImageFormat.R16G16 | Snorm;

+ case GalSurfaceFormat.RG16Float: return GalImageFormat.R16G16 | Sfloat;

+ case GalSurfaceFormat.R11G11B10Float: return GalImageFormat.B10G11R11 | Sfloat;

+ case GalSurfaceFormat.R32Float: return GalImageFormat.R32 | Sfloat;

+ case GalSurfaceFormat.RG8Unorm: return GalImageFormat.R8G8 | Unorm;

+ case GalSurfaceFormat.RG8Snorm: return GalImageFormat.R8 | Snorm;

+ case GalSurfaceFormat.R16Float: return GalImageFormat.R16 | Sfloat;

+ case GalSurfaceFormat.R8Unorm: return GalImageFormat.R8 | Unorm;

+ }

+

+ throw new NotImplementedException(Format.ToString());

+ }

+

+ public static GalImageFormat ConvertZeta(GalZetaFormat Format)

+ {

+ switch (Format)

+ {

+ case GalZetaFormat.Z32Float: return GalImageFormat.D32 | Sfloat;

+ case GalZetaFormat.S8Z24Unorm: return GalImageFormat.D24_S8 | Unorm;

+ case GalZetaFormat.Z16Unorm: return GalImageFormat.D16 | Unorm;

+ //This one might not be Uint, change when a texture uses this format

+ case GalZetaFormat.Z32S8X24Float: return GalImageFormat.D32_S8 | Uint;

+ }

+

+ throw new NotImplementedException(Format.ToString());

+ }

+

+ public static TextureReaderDelegate GetReader(GalImageFormat Format)

+ {

+ return GetImageDescriptor(Format).Reader;

+ }

+

+ public static int GetSize(GalImage Image)

+ {

+ switch (Image.Format & GalImageFormat.FormatMask)

+ {

+ case GalImageFormat.R32G32B32A32:

+ return Image.Width * Image.Height * 16;

+

+ case GalImageFormat.R16G16B16A16:

+ case GalImageFormat.D32_S8:

+ case GalImageFormat.R32G32:

+ return Image.Width * Image.Height * 8;

+

+ case GalImageFormat.A8B8G8R8:

+ case GalImageFormat.A8B8G8R8_SRGB: