public bool SupportsAstcCompression { get; }

public bool SupportsImageLoadFormatted { get; }

public bool SupportsNonConstantTextureOffset { get; }

public Capabilities(

bool supportsAstcCompression,

bool supportsImageLoadFormatted,

bool supportsNonConstantTextureOffset,

int maximumComputeSharedMemorySize,

{

SupportsAstcCompression = supportsAstcCompression;

SupportsImageLoadFormatted = supportsImageLoadFormatted;

SupportsNonConstantTextureOffset = supportsNonConstantTextureOffset;

MaximumComputeSharedMemorySize = maximumComputeSharedMemorySize;

StorageBufferOffsetAlignment = storageBufferOffsetAlignment;

}

}

} \ No newline at end of file

void SetImage(int index, ShaderStage stage, ITexture texture);

void SetPointSize(float size);

void SetPrimitiveRestart(bool enable, int index);

{

public enum ViewportSwizzle

{

}

}

_context.Renderer.Pipeline.SetDepthMode(depthMode);

for (int index = 0; index < Constants.TotalViewports; index++)

{

float x = transform.TranslateX - MathF.Abs(transform.ScaleX);

float y = transform.TranslateY - MathF.Abs(transform.ScaleY);

RectangleF region = new RectangleF(x, y, width, height);

viewports[index] = new Viewport(

region,

extents.DepthNear,

extents.DepthFar);

}

float mipLodBias = descriptor.UnpackMipLodBias();

float maxRequestedAnisotropy = GraphicsConfig.MaxAnisotropy >= 0 && GraphicsConfig.MaxAnisotropy <= 16 ? GraphicsConfig.MaxAnisotropy : descriptor.UnpackMaxAnisotropy();

if (maxRequestedAnisotropy > maxSupportedAnisotropy)

maxRequestedAnisotropy = maxSupportedAnisotropy;

using Ryujinx.Graphics.Gpu.Image;

using Ryujinx.Graphics.Gpu.State;

using Ryujinx.Graphics.Shader;

namespace Ryujinx.Graphics.Gpu.Shader

{

public bool QuerySupportsNonConstantTextureOffset() => _context.Capabilities.SupportsNonConstantTextureOffset;

/// <summary>

/// Queries texture format information, for shaders using image load or store.

/// </summary>

/// <remarks>

};

}

/// <summary>

/// Gets the texture descriptor for a given texture on the pool.

/// </summary>

{

memory[(int)MethodOffset.ViewportExtents + index * 4 + 2] = 0;

memory[(int)MethodOffset.ViewportExtents + index * 4 + 3] = 0x3F800000;

}

// Viewport transform enable.

return TextureTarget.Texture2D;

}

}

}

{

private static readonly Lazy<bool> _supportsAstcCompression = new Lazy<bool>(() => HasExtension("GL_KHR_texture_compression_astc_ldr"));

private static readonly Lazy<bool> _supportsImageLoadFormatted = new Lazy<bool>(() => HasExtension("GL_EXT_shader_image_load_formatted"));

private static readonly Lazy<int> _maximumComputeSharedMemorySize = new Lazy<int>(() => GetLimit(All.MaxComputeSharedMemorySize));

private static readonly Lazy<int> _storageBufferOffsetAlignment = new Lazy<int>(() => GetLimit(All.ShaderStorageBufferOffsetAlignment));

public static bool SupportsAstcCompression => _supportsAstcCompression.Value;

public static bool SupportsImageLoadFormatted => _supportsImageLoadFormatted.Value;

public static bool SupportsNonConstantTextureOffset => _gpuVendor.Value == GpuVendor.Nvidia;

public static int MaximumComputeSharedMemorySize => _maximumComputeSharedMemorySize.Value;

public static int StorageBufferOffsetAlignment => _storageBufferOffsetAlignment.Value;

private static bool HasExtension(string name)

{

_vertexArray.SetIndexBuffer(buffer.Handle);

}

public void SetPointSize(float size)

{

GL.PointSize(size);

public void SetViewports(int first, ReadOnlySpan<Viewport> viewports)

{

float[] viewportArray = new float[viewports.Length * 4];

double[] depthRangeArray = new double[viewports.Length * 2];

viewportArray[viewportElemIndex + 0] = viewport.Region.X;

viewportArray[viewportElemIndex + 1] = viewport.Region.Y;

{

}

viewportArray[viewportElemIndex + 2] = MathF.Abs(viewport.Region.Width);

GL.ViewportArray(first, viewports.Length, viewportArray);

GL.DepthRangeArray(first, viewports.Length, depthRangeArray);

}

public void TextureBarrier()

HwCapabilities.SupportsAstcCompression,

HwCapabilities.SupportsImageLoadFormatted,

HwCapabilities.SupportsNonConstantTextureOffset,

HwCapabilities.MaximumComputeSharedMemorySize,

}

public void SetBufferData(BufferHandle buffer, int offset, ReadOnlySpan<byte> data)

return true;

}

public TextureFormat QueryTextureFormat(int handle)

{

return TextureFormat.R8G8B8A8Unorm;

}

}

}

public Block CurrBlock { get; set; }

public OpCode CurrOp { get; set; }

private List<Operation> _operations;

public EmitterContext(ShaderConfig config)

{

_operations = new List<Operation>();

public void PrepareForReturn()

{

{

{

Operand dest = Attribute(AttributeConsts.FragmentOutputDepth);

this.Copy(dest, src);

}

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

{

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

{

{

None = 0,

}

} \ No newline at end of file

public static ShaderProgram Translate(ulong addressA, ulong addressB, IGpuAccessor gpuAccessor, TranslationFlags flags)

{

Operation[] opsB = DecodeShader(addressB, gpuAccessor, flags, out ShaderConfig config, out int sizeB);

return Translate(Combine(opsA, opsB), config, sizeB, sizeA);