mirror of
https://github.com/KytyPS5/KytyPS5.git
synced 2026-10-20 02:47:02 +02:00
nmzik
1126 lines
53 KiB
C++
1126 lines
53 KiB
C++
#include "graphics/guest_gpu/gpu_format.h"
|
|
#include "graphics/shader/recompiler/backend/spirv/spirvEmitterInstructions.h"
|
|
#include "graphics/shader/recompiler/frontend/decode/ImageOps.h"
|
|
|
|
#include <algorithm>
|
|
#include <bit>
|
|
|
|
namespace Libs::Graphics::ShaderRecompiler::Spirv::Emitter {
|
|
namespace {
|
|
|
|
uint32_t DmaskComponentIndex(uint32_t dmask, uint32_t component) {
|
|
uint32_t index = 0;
|
|
for (uint32_t i = 0; i < component; i++) {
|
|
index += (dmask >> i) & 1u;
|
|
}
|
|
return index;
|
|
}
|
|
|
|
uint32_t DmaskComponent(uint32_t dmask, uint32_t index) {
|
|
for (uint32_t component = 0; component < 4u; component++) {
|
|
if (((dmask >> component) & 1u) != 0u && index-- == 0u) return component;
|
|
}
|
|
return 0u;
|
|
}
|
|
|
|
uint32_t ImageGatherComponent(uint32_t dmask) {
|
|
switch (dmask) {
|
|
case 0x2u: return 1;
|
|
case 0x4u: return 2;
|
|
case 0x8u: return 3;
|
|
default: return 0;
|
|
}
|
|
}
|
|
|
|
bool HasFlag(const IR::MemoryInfo& mem, uint32_t flag) {
|
|
return (mem.image_sample_flags & flag) != 0u;
|
|
}
|
|
|
|
uint32_t AddressU32(ValueEmitContext& ctx, const IR::MemoryInfo& mem, const IR::Inst& address,
|
|
uint32_t component) {
|
|
const auto layout = Decoder::ImageAddressComponentLayout(mem.image_sample_flags, component);
|
|
const auto packed = layout.bit_offset / 32u;
|
|
if (packed >= address.NumArgs()) return ConstantU32(ctx.state, 0);
|
|
auto value = ctx.Def(address.Arg(packed));
|
|
if (layout.bit_width == 16u) {
|
|
if ((layout.bit_offset & 31u) != 0u) {
|
|
value = Binary(ctx.state, spv::OpShiftRightLogical, TypeU32(ctx.state), value,
|
|
ConstantU32(ctx.state, 16));
|
|
}
|
|
value = Binary(ctx.state, spv::OpBitwiseAnd, TypeU32(ctx.state), value,
|
|
ConstantU32(ctx.state, 0xffffu));
|
|
}
|
|
return value;
|
|
}
|
|
|
|
uint32_t AddressF32(ValueEmitContext& ctx, const IR::MemoryInfo& mem, const IR::Inst& address,
|
|
uint32_t component) {
|
|
const auto value = AddressU32(ctx, mem, address, component);
|
|
return Decoder::ImageAddressComponentLayout(mem.image_sample_flags, component).bit_width == 16u
|
|
? EmitF16BitsToF32(ctx.state, value)
|
|
: Unary(ctx.state, spv::OpBitcast, TypeF32(ctx.state), value);
|
|
}
|
|
|
|
ImageSampleLayout Layout(const IR::MemoryInfo& mem) {
|
|
ImageSampleLayout layout;
|
|
uint32_t cursor = 0;
|
|
const auto& info = ImageDimensionInfoFor(mem.image_dimension);
|
|
if (HasFlag(mem, Decoder::ImageSampleFlagOffset)) layout.offset = cursor++;
|
|
if (HasFlag(mem, Decoder::ImageSampleFlagBias)) layout.bias = cursor++;
|
|
if (HasFlag(mem, Decoder::ImageSampleFlagCompare)) layout.dref = cursor++;
|
|
if (HasFlag(mem, Decoder::ImageSampleFlagDerivative)) {
|
|
layout.grad_x = cursor;
|
|
cursor += info.spatial_components;
|
|
layout.grad_y = cursor;
|
|
cursor += info.spatial_components;
|
|
}
|
|
layout.coord = cursor;
|
|
cursor += info.coordinate_components;
|
|
if (HasFlag(mem, Decoder::ImageSampleFlagLod)) layout.lod = cursor++;
|
|
return layout;
|
|
}
|
|
|
|
uint32_t ZeroF32(EmitterState& state) {
|
|
return ConstantF32(state, 0);
|
|
}
|
|
|
|
uint32_t GatherMip(ValueEmitContext& ctx, const IR::Inst& inst, const IR::MemoryInfo& mem,
|
|
const IR::Inst& address, const ImageSampleLayout& layout, uint32_t mip_count) {
|
|
auto& state = ctx.state;
|
|
const auto Extract = [&](uint32_t word, uint32_t first, uint32_t count) {
|
|
return EmitBitFieldUExtract(state, word, ConstantU32(state, first),
|
|
ConstantU32(state, count));
|
|
};
|
|
const auto LodFixed = [&](uint32_t word, uint32_t first) {
|
|
return Binary(state, spv::OpFMul, TypeF32(state),
|
|
Unary(state, spv::OpConvertUToF, TypeF32(state), Extract(word, first, 12)),
|
|
ConstantF32Value(state, 1.0f / 256.0f));
|
|
};
|
|
const auto sampler_control = ctx.Arg(inst, 6);
|
|
const auto preclamp = Binary(state, spv::OpINotEqual, TypeBool(state),
|
|
Extract(sampler_control, 28, 1), ConstantU32(state, 0));
|
|
const auto half = ConstantF32Value(state, 0.5f);
|
|
const auto zero = ZeroF32(state);
|
|
const auto base = Unary(state, spv::OpConvertUToF, TypeF32(state),
|
|
Extract(ctx.Arg(inst, 4), 12, 4));
|
|
const auto minimum = Binary(state, spv::OpFSub, TypeF32(state),
|
|
LodFixed(ctx.Arg(inst, 3), 8), base);
|
|
const auto last = ConstantF32Value(state, static_cast<float>(mip_count - 1u));
|
|
auto lod = Binary(state, spv::OpFAdd, TypeF32(state),
|
|
AddressF32(ctx, mem, address, layout.lod),
|
|
Select(state, TypeF32(state), preclamp, half, zero));
|
|
lod = EmitGlsl<GLSLstd450FClamp, IR::Type::F32>(
|
|
state, lod, LodFixed(ctx.Arg(inst, 5), 0), LodFixed(ctx.Arg(inst, 5), 12));
|
|
// T# minimum LOD is in physical mip space and applies after the S# view-relative clamp.
|
|
lod = EmitGlsl<GLSLstd450FMax, IR::Type::F32>(state, lod, minimum);
|
|
lod = EmitGlsl<GLSLstd450FClamp, IR::Type::F32>(state, lod, zero, last);
|
|
lod = Binary(state, spv::OpFAdd, TypeF32(state), lod,
|
|
Select(state, TypeF32(state), preclamp, zero, half));
|
|
// The clamped value is nonnegative, so conversion performs the integer mip rounding.
|
|
const auto mip = EmitUMin32(state, Unary(state, spv::OpConvertFToU, TypeU32(state), lod),
|
|
ConstantU32(state, mip_count - 1u));
|
|
const auto mip_none = Binary(state, spv::OpIEqual, TypeBool(state),
|
|
Extract(sampler_control, 26, 2), ConstantU32(state, 0));
|
|
return Select(state, TypeU32(state), mip_none, ConstantU32(state, 0), mip);
|
|
}
|
|
|
|
uint32_t CubeAxis(EmitterState& state, uint32_t value) {
|
|
return Binary(state, spv::OpFSub, TypeF32(state), value, ConstantF32(state, 0x3f800000u));
|
|
}
|
|
|
|
uint32_t CubeLayer(EmitterState& state, uint32_t value) {
|
|
const auto guest = state.builder.AllocateId();
|
|
state.builder.AddFunction(spv::OpConvertFToU, TypeU32(state), guest, value);
|
|
const auto padding = Binary(
|
|
state, spv::OpShiftLeftLogical, TypeU32(state),
|
|
Binary(state, spv::OpShiftRightLogical, TypeU32(state), guest, ConstantU32(state, 3)),
|
|
ConstantU32(state, 1));
|
|
const auto host = Binary(state, spv::OpISub, TypeU32(state), guest, padding);
|
|
const auto result = state.builder.AllocateId();
|
|
state.builder.AddFunction(spv::OpConvertUToF, TypeF32(state), result, host);
|
|
return result;
|
|
}
|
|
|
|
uint32_t CoordF32(ValueEmitContext& ctx, const IR::MemoryInfo& mem, const IR::Inst& address,
|
|
uint32_t first, uint32_t components, bool cube = false) {
|
|
auto x = AddressF32(ctx, mem, address, first);
|
|
if (components == 1u) return x;
|
|
auto y = mem.image_address_components > first + 1u ? AddressF32(ctx, mem, address, first + 1u)
|
|
: ZeroF32(ctx.state);
|
|
if (cube) {
|
|
x = CubeAxis(ctx.state, x);
|
|
y = CubeAxis(ctx.state, y);
|
|
}
|
|
const auto result = ctx.state.builder.AllocateId();
|
|
if (components == 3u) {
|
|
auto z = mem.image_address_components > first + 2u
|
|
? AddressF32(ctx, mem, address, first + 2u)
|
|
: ZeroF32(ctx.state);
|
|
if (cube) z = CubeLayer(ctx.state, z);
|
|
ctx.state.builder.AddFunction(spv::OpCompositeConstruct, TypeF32Vector(ctx.state, 3),
|
|
result, x, y, z);
|
|
} else {
|
|
ctx.state.builder.AddFunction(spv::OpCompositeConstruct, TypeF32Vector(ctx.state, 2),
|
|
result, x, y);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
uint32_t CoordU32(ValueEmitContext& ctx, const IR::MemoryInfo& mem, const IR::Inst& address,
|
|
ImageDimension dimension) {
|
|
const auto components = ImageDimensionInfoFor(dimension).coordinate_components;
|
|
const auto x = AddressU32(ctx, mem, address, 0);
|
|
if (components == 1u) return x;
|
|
const auto y = mem.image_address_components > 1u ? AddressU32(ctx, mem, address, 1)
|
|
: ConstantU32(ctx.state, 0);
|
|
const auto result = ctx.state.builder.AllocateId();
|
|
if (components == 3u) {
|
|
const auto z = mem.image_address_components > 2u ? AddressU32(ctx, mem, address, 2)
|
|
: ConstantU32(ctx.state, 0);
|
|
ctx.state.builder.AddFunction(spv::OpCompositeConstruct, TypeU32Vector(ctx.state, 3),
|
|
result, x, y, z);
|
|
} else {
|
|
ctx.state.builder.AddFunction(spv::OpCompositeConstruct, TypeU32Vector(ctx.state, 2),
|
|
result, x, y);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
uint32_t LodU32(ValueEmitContext& ctx, const IR::MemoryInfo& mem, const IR::Inst& address,
|
|
ImageDimension dimension) {
|
|
const auto component = ImageDimensionInfoFor(dimension).coordinate_components;
|
|
return mem.image_has_mip && mem.image_address_components > component
|
|
? AddressU32(ctx, mem, address, component)
|
|
: ConstantU32(ctx.state, 0);
|
|
}
|
|
|
|
uint32_t FloatBits(ValueEmitContext& ctx, uint32_t value) {
|
|
return Unary(ctx.state, spv::OpBitcast, TypeU32(ctx.state), value);
|
|
}
|
|
|
|
uint32_t SampledComponentBits(ValueEmitContext& ctx, uint32_t value,
|
|
Prospero::TextureNumericClass numeric_class) {
|
|
if (numeric_class == Prospero::TextureNumericClass::Uint) {
|
|
return value;
|
|
}
|
|
return Unary(ctx.state, spv::OpBitcast, TypeU32(ctx.state), value);
|
|
}
|
|
|
|
uint32_t SampledComponentZero(EmitterState& state, Prospero::TextureNumericClass numeric_class) {
|
|
switch (numeric_class) {
|
|
case Prospero::TextureNumericClass::Float: return ZeroF32(state);
|
|
case Prospero::TextureNumericClass::Uint: return ConstantU32(state, 0);
|
|
case Prospero::TextureNumericClass::Sint: return ConstantI32(state, 0);
|
|
case Prospero::TextureNumericClass::Unsupported: break;
|
|
}
|
|
EXIT("invalid sampled image numeric class");
|
|
}
|
|
|
|
uint32_t ResultVector(ValueEmitContext& ctx, uint32_t value,
|
|
Prospero::TextureNumericClass numeric_class, bool dref,
|
|
const IR::MemoryInfo& mem, bool gather = false) {
|
|
auto value_class = numeric_class;
|
|
const auto conversion = ctx.state.program.info.images[mem.resource].conversion_format;
|
|
if (conversion != Prospero::BufferFormat::kInvalid) {
|
|
value_class = Prospero::SampledTextureNumericClass(conversion);
|
|
}
|
|
if (dref) {
|
|
value_class = Prospero::TextureNumericClass::Float;
|
|
}
|
|
const bool integer = value_class == Prospero::TextureNumericClass::Uint ||
|
|
value_class == Prospero::TextureNumericClass::Sint;
|
|
if (mem.data_bits == 16u) {
|
|
uint32_t packed[4] = {ConstantU32(ctx.state, 0), ConstantU32(ctx.state, 0),
|
|
ConstantU32(ctx.state, 0), ConstantU32(ctx.state, 0)};
|
|
const auto scalar = [&](uint32_t index) {
|
|
if (dref) return value;
|
|
const auto component = gather ? index : DmaskComponent(mem.dmask, index);
|
|
const auto result = ctx.state.builder.AllocateId();
|
|
ctx.state.builder.AddFunction(spv::OpCompositeExtract,
|
|
ImageScalarType(ctx.state, value_class), result, value,
|
|
component);
|
|
return result;
|
|
};
|
|
for (uint32_t word = 0; word < mem.data_dwords; word++) {
|
|
const auto low_index = word * 2u;
|
|
const auto high_index = low_index + 1u;
|
|
const auto low = scalar(low_index);
|
|
const auto high = high_index < mem.component_count
|
|
? scalar(high_index)
|
|
: SampledComponentZero(ctx.state, value_class);
|
|
if (integer) {
|
|
const auto low_bits = SampledComponentBits(ctx, low, value_class);
|
|
const auto high_bits = SampledComponentBits(ctx, high, value_class);
|
|
const auto mask = ConstantU32(ctx.state, 0xffffu);
|
|
packed[word] =
|
|
Binary(ctx.state, spv::OpBitwiseOr, TypeU32(ctx.state),
|
|
Binary(ctx.state, spv::OpBitwiseAnd, TypeU32(ctx.state), low_bits, mask),
|
|
Binary(ctx.state, spv::OpShiftLeftLogical, TypeU32(ctx.state),
|
|
Binary(ctx.state, spv::OpBitwiseAnd, TypeU32(ctx.state),
|
|
high_bits, mask),
|
|
ConstantU32(ctx.state, 16u)));
|
|
} else {
|
|
const auto pair = ctx.state.builder.AllocateId();
|
|
ctx.state.builder.AddFunction(spv::OpCompositeConstruct,
|
|
TypeF32Vector(ctx.state, 2), pair, low, high);
|
|
packed[word] = ctx.state.builder.AllocateId();
|
|
ctx.state.builder.AddFunction(spv::OpExtInst, TypeU32(ctx.state), packed[word],
|
|
GlslStd450(ctx.state), GLSLstd450PackHalf2x16, pair);
|
|
}
|
|
}
|
|
const auto result = ctx.state.builder.AllocateId();
|
|
ctx.state.builder.AddFunction(spv::OpCompositeConstruct, TypeU32Vector(ctx.state, 4),
|
|
result, packed[0], packed[1], packed[2], packed[3]);
|
|
return result;
|
|
}
|
|
if (!dref)
|
|
return value_class == Prospero::TextureNumericClass::Uint
|
|
? value : Unary(ctx.state, spv::OpBitcast, TypeU32Vector(ctx.state, 4), value);
|
|
const auto result = ctx.state.builder.AllocateId();
|
|
const auto zero = ConstantU32(ctx.state, 0);
|
|
ctx.state.builder.AddFunction(spv::OpCompositeConstruct, TypeU32Vector(ctx.state, 4), result,
|
|
FloatBits(ctx, value), zero, zero, zero);
|
|
return result;
|
|
}
|
|
|
|
uint32_t QueryDimensions(ValueEmitContext& ctx, const IR::MemoryInfo& mem,
|
|
const IR::Inst& address) {
|
|
const auto dimension = ctx.state.program.info.images.at(mem.resource).dimension;
|
|
const auto& info = ImageDimensionInfoFor(dimension);
|
|
const auto image = LoadImageDescriptor(ctx.state, mem.resource);
|
|
const auto size = ctx.state.builder.AllocateId();
|
|
if (info.multisampled != 0u) {
|
|
ctx.state.builder.AddFunction(spv::OpImageQuerySize,
|
|
ImageViewSizeType(ctx.state, dimension), size, image);
|
|
} else {
|
|
ctx.state.builder.AddFunction(spv::OpImageQuerySizeLod,
|
|
ImageViewSizeType(ctx.state, dimension), size, image,
|
|
AddressU32(ctx, mem, address, 0));
|
|
}
|
|
const auto components = info.coordinate_components;
|
|
uint32_t result[4] = {ConstantU32(ctx.state, 0), ConstantU32(ctx.state, 0),
|
|
ConstantU32(ctx.state, 0), ConstantU32(ctx.state, 0)};
|
|
if (components == 1u) {
|
|
result[0] = size;
|
|
} else {
|
|
for (uint32_t index = 0; index < components; index++) {
|
|
result[index] = ctx.state.builder.AllocateId();
|
|
ctx.state.builder.AddFunction(spv::OpCompositeExtract, TypeU32(ctx.state),
|
|
result[index], size, index);
|
|
}
|
|
}
|
|
if (info.multisampled == 0u) {
|
|
result[3] = ctx.state.builder.AllocateId();
|
|
ctx.state.builder.AddFunction(spv::OpImageQueryLevels, TypeU32(ctx.state), result[3],
|
|
image);
|
|
}
|
|
const auto vector = ctx.state.builder.AllocateId();
|
|
ctx.state.builder.AddFunction(spv::OpCompositeConstruct, TypeU32Vector(ctx.state, 4), vector,
|
|
result[0], result[1], result[2], result[3]);
|
|
return vector;
|
|
}
|
|
|
|
uint32_t PackedOffset(ValueEmitContext& ctx, IR::Value value, ImageDimension dimension,
|
|
uint32_t& mask) {
|
|
const auto components = ImageDimensionInfoFor(dimension).spatial_components;
|
|
uint32_t values[3] {};
|
|
if (value.IsImmediate()) {
|
|
// RDNA2 packs signed six-bit texel offsets into the low bits of each byte.
|
|
for (uint32_t index = 0; index < components; index++) {
|
|
const auto bits = (value.U32() >> (index * 8u)) & 0x3fu;
|
|
values[index] = ConstantI32(ctx.state, static_cast<int32_t>(bits ^ 0x20u) - 0x20);
|
|
}
|
|
mask |= spv::ImageOperandsConstOffsetMask;
|
|
return components == 1u
|
|
? values[0]
|
|
: ctx.state.builder.Constant(spv::OpConstantComposite,
|
|
TypeI32Vector(ctx.state, components),
|
|
std::span(values).first(components));
|
|
}
|
|
ctx.state.builder.RequireCapability(spv::CapabilityImageGatherExtended);
|
|
mask |= spv::ImageOperandsOffsetMask;
|
|
const auto packed = Unary(ctx.state, spv::OpBitcast, TypeI32(ctx.state), ctx.Def(value));
|
|
for (uint32_t index = 0; index < components; index++) {
|
|
values[index] = ctx.state.builder.AllocateId();
|
|
ctx.state.builder.AddFunction(spv::OpBitFieldSExtract, TypeI32(ctx.state), values[index],
|
|
packed, ConstantU32(ctx.state, index * 8u),
|
|
ConstantU32(ctx.state, 6));
|
|
}
|
|
if (components == 1u) return values[0];
|
|
const auto result = ctx.state.builder.AllocateId();
|
|
ctx.state.builder.AddFunction(spv::OpCompositeConstruct, TypeI32Vector(ctx.state, components),
|
|
result, std::span(values).first(components));
|
|
return result;
|
|
}
|
|
|
|
uint32_t HorizontalOffsets(EmitterState& state, ImageDimension dimension) {
|
|
const auto components = ImageDimensionInfoFor(dimension).spatial_components;
|
|
const auto count = ConstantU32(state, 4);
|
|
const auto element_type = components == 1u ? TypeI32(state) : TypeI32Vector(state, 2);
|
|
const auto array_type = state.builder.Type(spv::OpTypeArray, element_type, count);
|
|
uint32_t offsets[4] {};
|
|
for (uint32_t index = 0; index < 4u; index++) {
|
|
const auto x = ConstantI32(state, static_cast<int32_t>(index) - 1);
|
|
if (components == 1u) {
|
|
offsets[index] = x;
|
|
} else {
|
|
offsets[index] = state.builder.Constant(
|
|
spv::OpConstantComposite, TypeI32Vector(state, 2), x, ConstantI32(state, 0));
|
|
}
|
|
}
|
|
return state.builder.Constant(spv::OpConstantComposite, array_type, offsets[0], offsets[1],
|
|
offsets[2], offsets[3]);
|
|
}
|
|
|
|
uint32_t InverseSwizzle(uint32_t swizzle, uint32_t component) {
|
|
for (uint32_t source = 0; source < 4u; source++) {
|
|
if (((swizzle >> (source * 3u)) & 7u) == 4u + component) return source;
|
|
}
|
|
return UINT32_MAX;
|
|
}
|
|
|
|
Format::BufferFormatInfo ImageConversionFormat(const EmitterState& state,
|
|
const IR::MemoryInfo& mem) {
|
|
const auto& image = state.program.info.images[mem.resource];
|
|
const auto format = image.conversion_format;
|
|
if (format == Prospero::BufferFormat::kInvalid) return {};
|
|
const auto info = Format::GetFormatInfo(format);
|
|
const bool raw_signed = IR::RawSignedStorageFormat(image, format) != Prospero::BufferFormat::kInvalid;
|
|
EXIT_IF((Prospero::RemapTextureFormat(format) == format && !raw_signed) || info.component_count == 0u ||
|
|
info.component_count > 4u);
|
|
EXIT_IF(!raw_signed && info.type != Format::ComponentType::Uscaled &&
|
|
((info.type != Format::ComponentType::Uint &&
|
|
info.type != Format::ComponentType::Unorm) || !info.packed_bitfield ||
|
|
info.byte_size != sizeof(uint32_t)));
|
|
return info;
|
|
}
|
|
|
|
uint32_t ExtractPackedImageComponent(EmitterState& state, const Format::BufferFormatInfo& info,
|
|
uint32_t packed, uint32_t type, uint32_t component) {
|
|
const auto result = state.builder.AllocateId();
|
|
state.builder.AddFunction(spv::OpBitFieldUExtract, type, result, packed,
|
|
ConstantU32(state, info.component_bit_offset[component]),
|
|
ConstantU32(state, info.component_bits[component]));
|
|
return result;
|
|
}
|
|
|
|
uint32_t ImageGatherSource(const EmitterState& state, const IR::MemoryInfo& mem) {
|
|
const auto component = ImageGatherComponent(mem.dmask);
|
|
const auto info = ImageConversionFormat(state, mem);
|
|
if (info.format == Prospero::BufferFormat::kInvalid) return component;
|
|
if (info.packed_bitfield) return 0u;
|
|
const auto selector =
|
|
(state.program.info.images[mem.resource].shader_swizzle >> (component * 3u)) & 7u;
|
|
return selector >= 4u ? (selector - 4u) % info.component_count : 0u;
|
|
}
|
|
|
|
uint32_t UnpackImageTexel(ValueEmitContext& ctx, const IR::MemoryInfo& mem, uint32_t texel) {
|
|
const auto info = ImageConversionFormat(ctx.state, mem);
|
|
if (info.format == Prospero::BufferFormat::kInvalid) return texel;
|
|
|
|
const auto numeric_class = ctx.state.program.info.images[mem.resource].numeric_class;
|
|
const auto scalar_type = ImageScalarType(ctx.state, numeric_class);
|
|
uint32_t packed = 0;
|
|
if (info.packed_bitfield) {
|
|
packed = ctx.state.builder.AllocateId();
|
|
ctx.state.builder.AddFunction(spv::OpCompositeExtract, scalar_type, packed, texel, 0u);
|
|
}
|
|
uint32_t components[4] {};
|
|
for (uint32_t component = 0; component < info.component_count; component++) {
|
|
if (info.packed_bitfield) {
|
|
components[component] =
|
|
ExtractPackedImageComponent(ctx.state, info, packed, scalar_type, component);
|
|
components[component] =
|
|
NormalizeFormatComponent(ctx.state, info, component, components[component]);
|
|
} else {
|
|
components[component] = ctx.state.builder.AllocateId();
|
|
ctx.state.builder.AddFunction(spv::OpCompositeExtract, scalar_type,
|
|
components[component], texel, component);
|
|
// UNorm backing preserves the guest's filtering; scaling precedes swizzle constants.
|
|
components[component] = Binary(ctx.state, spv::OpFMul, scalar_type, components[component],
|
|
ConstantF32Value(ctx.state, 255.0f));
|
|
}
|
|
}
|
|
for (uint32_t component = info.component_count; component < 4u; component++) {
|
|
components[component] = components[component % info.component_count];
|
|
}
|
|
|
|
const auto swizzle = ctx.state.program.info.images[mem.resource].shader_swizzle;
|
|
uint32_t selected[4] {};
|
|
for (uint32_t component = 0; component < 4u; component++) {
|
|
const auto selector = (swizzle >> (component * 3u)) & 7u;
|
|
if (selector == 1u) {
|
|
selected[component] = info.packed_bitfield
|
|
? ConstantU32(ctx.state, Format::FormattedConstantBits(info, Format::FormattedSourceKind::One))
|
|
: ConstantF32Value(ctx.state, 1.0f);
|
|
} else if (selector >= 4u) {
|
|
selected[component] = components[selector - 4u];
|
|
} else {
|
|
selected[component] = info.packed_bitfield ? ConstantU32(ctx.state, 0u)
|
|
: ZeroF32(ctx.state);
|
|
}
|
|
}
|
|
const auto result = ctx.state.builder.AllocateId();
|
|
ctx.state.builder.AddFunction(spv::OpCompositeConstruct,
|
|
ImageVectorType(ctx.state, numeric_class, 4), result, selected[0],
|
|
selected[1], selected[2], selected[3]);
|
|
return info.type == Format::ComponentType::Unorm
|
|
? Unary(ctx.state, spv::OpBitcast, TypeF32Vector(ctx.state, 4), result) : result;
|
|
}
|
|
|
|
uint32_t UnpackImageGather(ValueEmitContext& ctx, const IR::MemoryInfo& mem, uint32_t gathered) {
|
|
const auto info = ImageConversionFormat(ctx.state, mem);
|
|
if (info.format == Prospero::BufferFormat::kInvalid) return gathered;
|
|
|
|
const auto component = ImageGatherComponent(mem.dmask);
|
|
const auto selector =
|
|
(ctx.state.program.info.images[mem.resource].shader_swizzle >> (component * 3u)) & 7u;
|
|
const auto numeric_class = ctx.state.program.info.images[mem.resource].numeric_class;
|
|
const auto vector_type = ImageVectorType(ctx.state, numeric_class, 4);
|
|
if (selector < 4u) {
|
|
uint32_t value;
|
|
switch (info.type) {
|
|
case Format::ComponentType::Uscaled:
|
|
value = ConstantF32Value(ctx.state, selector == 1u ? 1.0f : 0.0f);
|
|
break;
|
|
default: value = ConstantU32(ctx.state, selector == 1u ? 1u : 0u); break;
|
|
}
|
|
return ctx.state.builder.Constant(spv::OpConstantComposite, vector_type, value, value,
|
|
value, value);
|
|
}
|
|
if (!info.packed_bitfield) {
|
|
const auto scale = ConstantF32Value(ctx.state, 255.0f);
|
|
const auto scales = ctx.state.builder.Constant(spv::OpConstantComposite, vector_type,
|
|
scale, scale, scale, scale);
|
|
return Binary(ctx.state, spv::OpFMul, vector_type, gathered, scales);
|
|
}
|
|
|
|
return ExtractPackedImageComponent(ctx.state, info, gathered, TypeU32Vector(ctx.state, 4),
|
|
(selector - 4u) % info.component_count);
|
|
}
|
|
|
|
uint32_t SamplePackedUnormLz(ValueEmitContext& ctx, const IR::MemoryInfo& mem, uint32_t coord) {
|
|
auto& state = ctx.state;
|
|
const auto& image = state.program.info.images[mem.resource];
|
|
const auto info = ImageConversionFormat(state, mem);
|
|
const auto sampled = MakeSampledImage(state, mem.resource,
|
|
LoadSamplerDescriptor(state, mem.sampler));
|
|
const auto gathered = state.builder.AllocateId();
|
|
state.builder.AddFunction(spv::OpImageGather, TypeU32Vector(state, 4), gathered, sampled,
|
|
coord, ConstantU32(state, 0u));
|
|
state.builder.RequireCapability(spv::CapabilityImageQuery);
|
|
const auto size = state.builder.AllocateId();
|
|
state.builder.AddFunction(spv::OpImageQuerySizeLod, TypeU32Vector(state, 2), size,
|
|
LoadImageDescriptor(state, mem.resource), ConstantU32(state, 0u));
|
|
const auto size_f32 = Unary(state, spv::OpConvertUToF, TypeF32Vector(state, 2), size);
|
|
const auto half = ConstantF32Value(state, 0.5f);
|
|
const auto halves = state.builder.Constant(spv::OpConstantComposite,
|
|
TypeF32Vector(state, 2), half, half);
|
|
const auto fractions = state.builder.AllocateId();
|
|
state.builder.AddFunction(
|
|
spv::OpExtInst, TypeF32Vector(state, 2), fractions, GlslStd450(state), GLSLstd450Fract,
|
|
Binary(state, spv::OpFSub, TypeF32Vector(state, 2),
|
|
Binary(state, spv::OpFMul, TypeF32Vector(state, 2), coord, size_f32), halves));
|
|
uint32_t fraction[2];
|
|
uint32_t complement[2];
|
|
for (uint32_t axis = 0; axis < 2u; axis++) {
|
|
fraction[axis] = state.builder.AllocateId();
|
|
state.builder.AddFunction(spv::OpCompositeExtract, TypeF32(state), fraction[axis],
|
|
fractions, axis);
|
|
complement[axis] = Binary(state, spv::OpFSub, TypeF32(state),
|
|
ConstantF32Value(state, 1.0f), fraction[axis]);
|
|
}
|
|
// Gather order is (x0, y1), (x1, y1), (x1, y0), (x0, y0).
|
|
const auto weights = state.builder.AllocateId();
|
|
state.builder.AddFunction(
|
|
spv::OpCompositeConstruct, TypeF32Vector(state, 4), weights,
|
|
Binary(state, spv::OpFMul, TypeF32(state), complement[0], fraction[1]),
|
|
Binary(state, spv::OpFMul, TypeF32(state), fraction[0], fraction[1]),
|
|
Binary(state, spv::OpFMul, TypeF32(state), fraction[0], complement[1]),
|
|
Binary(state, spv::OpFMul, TypeF32(state), complement[0], complement[1]));
|
|
uint32_t decoded[4] {};
|
|
uint32_t selected[4] {ZeroF32(state), ZeroF32(state), ZeroF32(state), ZeroF32(state)};
|
|
for (uint32_t component = 0; component < 4u; component++) {
|
|
if ((mem.dmask & (1u << component)) == 0u) continue;
|
|
const auto selector = (image.shader_swizzle >> (component * 3u)) & 7u;
|
|
if (selector == 1u) {
|
|
selected[component] = ConstantF32Value(state, 1.0f);
|
|
} else if (selector >= 4u) {
|
|
const auto physical = (selector - 4u) % info.component_count;
|
|
if (decoded[physical] == 0u) {
|
|
const auto texels = Unary(
|
|
state, spv::OpConvertUToF, TypeF32Vector(state, 4),
|
|
ExtractPackedImageComponent(state, info, gathered,
|
|
TypeU32Vector(state, 4), physical));
|
|
decoded[physical] = Binary(
|
|
state, spv::OpFMul, TypeF32(state),
|
|
Binary(state, spv::OpDot, TypeF32(state), texels, weights),
|
|
ConstantF32Value(state, 1.0f / ((1u << info.component_bits[physical]) - 1u)));
|
|
}
|
|
selected[component] = decoded[physical];
|
|
}
|
|
}
|
|
const auto result = state.builder.AllocateId();
|
|
state.builder.AddFunction(spv::OpCompositeConstruct, TypeF32Vector(state, 4), result,
|
|
selected[0], selected[1], selected[2], selected[3]);
|
|
return result;
|
|
}
|
|
|
|
uint32_t EmitOneDimensionalGatherLz(ValueEmitContext& ctx, const IR::MemoryInfo& mem,
|
|
uint32_t coord, Prospero::TextureNumericClass numeric_class) {
|
|
auto& state = ctx.state;
|
|
state.builder.RequireCapability(spv::CapabilityImageQuery);
|
|
const auto image = LoadImageDescriptor(state, mem.resource);
|
|
const auto width = state.builder.AllocateId();
|
|
state.builder.AddFunction(spv::OpImageQuerySizeLod, TypeU32(state), width, image,
|
|
ConstantU32(state, 0));
|
|
const auto width_f32 = state.builder.AllocateId();
|
|
state.builder.AddFunction(spv::OpConvertUToF, TypeF32(state), width_f32, width);
|
|
const auto left = state.builder.AllocateId();
|
|
state.builder.AddFunction(spv::OpExtInst, TypeF32(state), left, GlslStd450(state),
|
|
GLSLstd450Floor,
|
|
Binary(state, spv::OpFSub, TypeF32(state),
|
|
Binary(state, spv::OpFMul, TypeF32(state), coord, width_f32),
|
|
ConstantF32(state, 0x3f000000u)));
|
|
|
|
const auto sampled = MakeSampledImage(state, mem.resource,
|
|
LoadSamplerDescriptor(state, mem.sampler));
|
|
const auto vector_type = ImageVectorType(state, numeric_class, 4);
|
|
const auto scalar_type = ImageScalarType(state, numeric_class);
|
|
const auto component = ImageGatherSource(state, mem);
|
|
uint32_t values[2] {};
|
|
for (uint32_t index = 0; index < 2u; index++) {
|
|
const auto sample_coord =
|
|
Binary(state, spv::OpFDiv, TypeF32(state),
|
|
Binary(state, spv::OpFAdd, TypeF32(state), left,
|
|
ConstantF32(state, index == 0u ? 0x3f000000u : 0x3fc00000u)),
|
|
width_f32);
|
|
const auto texel = state.builder.AllocateId();
|
|
state.builder.AddFunction(spv::OpImageSampleExplicitLod, vector_type, texel, sampled,
|
|
sample_coord, spv::ImageOperandsLodMask, ZeroF32(state));
|
|
values[index] = state.builder.AllocateId();
|
|
state.builder.AddFunction(spv::OpCompositeExtract, scalar_type, values[index], texel,
|
|
component);
|
|
}
|
|
const auto result = state.builder.AllocateId();
|
|
state.builder.AddFunction(spv::OpCompositeConstruct, vector_type, result, values[0], values[1],
|
|
values[1], values[0]);
|
|
return result;
|
|
}
|
|
|
|
uint32_t StoreTexel(ValueEmitContext& ctx, const IR::MemoryInfo& mem, uint32_t data, bool integer) {
|
|
const auto swizzle = ctx.state.program.info.images[mem.resource].shader_swizzle;
|
|
const auto info = ImageConversionFormat(ctx.state, mem);
|
|
const bool converted = info.format != Prospero::BufferFormat::kInvalid;
|
|
const bool packed = info.packed_bitfield;
|
|
EXIT_IF(converted && info.type != Format::ComponentType::Sint &&
|
|
(!packed || (info.type != Format::ComponentType::Uint &&
|
|
info.type != Format::ComponentType::Unorm)));
|
|
const auto zero = ConstantU32(ctx.state, 0);
|
|
uint32_t values[4] {zero, zero, zero, zero};
|
|
auto packed_value = zero;
|
|
const auto dmask = mem.dmask != 0u ? mem.dmask : 1u;
|
|
for (uint32_t component = 0; component < (converted ? info.component_count : 4u); component++) {
|
|
const auto source = InverseSwizzle(swizzle, component);
|
|
const bool selected = source < 4u && ((dmask >> source) & 1u) != 0u;
|
|
uint32_t raw = zero;
|
|
if (selected) {
|
|
const auto packed_index = DmaskComponentIndex(dmask, source);
|
|
raw = ctx.state.builder.AllocateId();
|
|
ctx.state.builder.AddFunction(spv::OpCompositeExtract, TypeU32(ctx.state), raw, data,
|
|
mem.data_bits == 16u ? packed_index / 2u : packed_index);
|
|
if (mem.data_bits == 16u) {
|
|
if ((packed_index & 1u) != 0u) {
|
|
raw = Binary(ctx.state, spv::OpShiftRightLogical, TypeU32(ctx.state), raw,
|
|
ConstantU32(ctx.state, 16u));
|
|
}
|
|
if (!packed) {
|
|
raw = Binary(ctx.state, spv::OpBitwiseAnd, TypeU32(ctx.state), raw,
|
|
ConstantU32(ctx.state, 0xffffu));
|
|
}
|
|
}
|
|
}
|
|
if (converted) {
|
|
if (!selected) continue;
|
|
if (!packed) {
|
|
values[component] =
|
|
EncodeFormattedStoreComponent(ctx.state, info, component, raw, mem.data_bits);
|
|
continue;
|
|
}
|
|
const auto value =
|
|
EncodePackedColorComponent(ctx.state, info, component, raw, mem.data_bits);
|
|
packed_value = packed_value == zero ? value
|
|
: Binary(ctx.state, spv::OpBitwiseOr, TypeU32(ctx.state), packed_value, value);
|
|
continue;
|
|
}
|
|
values[component] = integer ? raw
|
|
: mem.data_bits == 16u
|
|
? EmitF16BitsToF32(ctx.state, raw)
|
|
: Unary(ctx.state, spv::OpBitcast, TypeF32(ctx.state), raw);
|
|
}
|
|
if (packed) values[0] = packed_value;
|
|
const auto texel = ctx.state.builder.AllocateId();
|
|
ctx.state.builder.AddFunction(spv::OpCompositeConstruct,
|
|
integer ? TypeU32Vector(ctx.state, 4)
|
|
: TypeF32Vector(ctx.state, 4),
|
|
texel, values[0], values[1], values[2], values[3]);
|
|
return texel;
|
|
}
|
|
|
|
template <typename Emit>
|
|
auto EmitImageAccess(ValueEmitContext& ctx, const IR::Inst& inst, uint32_t result_type,
|
|
const Emit& emit) {
|
|
auto& state = ctx.state;
|
|
const auto& mem = ctx.Memory(inst);
|
|
const auto& image = state.program.info.images.at(mem.resource);
|
|
if (image.indirect_root != mem.resource) return emit(mem.resource, 0u);
|
|
const auto* handle = inst.Arg(0).ResolveInstruction();
|
|
const auto* source = image.source < state.program.descriptor_sources.size()
|
|
? &state.program.descriptor_sources[image.source]
|
|
: nullptr;
|
|
if (handle == nullptr || source == nullptr || !source->indirect_descriptor.has_value() ||
|
|
handle->NumArgs() == 0u) {
|
|
ctx.Fail(inst, "has invalid indirect image key provenance");
|
|
}
|
|
const auto key = ctx.Def(handle->Arg(0));
|
|
if (state.flattened_srt_variable == 0 ||
|
|
image.indirect_resources.size() < 2u) {
|
|
ctx.Fail(inst, "has no indirect image runtime mapping");
|
|
}
|
|
const auto selected = EmitIndirectResourceIndex(
|
|
state, key, image.indirect_mapping_offset, image.indirect_search_iterations, 0u);
|
|
struct ImageRun {
|
|
uint32_t first;
|
|
uint32_t count;
|
|
uint32_t resource;
|
|
uint32_t slot_bias;
|
|
};
|
|
std::vector<ImageRun> runs;
|
|
for (uint32_t ordinal = 0; ordinal < image.indirect_resources.size(); ++ordinal) {
|
|
const auto resource = image.indirect_resources[ordinal];
|
|
const auto& candidate = state.program.info.images[resource];
|
|
const auto kind = *IR::DescriptorBindingForImage(candidate);
|
|
if (!runs.empty()) {
|
|
auto& run = runs.back();
|
|
const auto& first = state.program.info.images[run.resource];
|
|
const auto next_slot = run.slot_bias + ordinal;
|
|
if (candidate.dimension == first.dimension && candidate.cube == first.cube &&
|
|
IR::DescriptorBindingForImage(first) == kind &&
|
|
(inst.GetOpcode() != IR::ValueOpcode::ImageWrite ||
|
|
candidate.shader_swizzle == first.shader_swizzle) &&
|
|
candidate.mip_count == 1u && first.mip_count == 1u &&
|
|
(ordinal == 1u || candidate.descriptor_index == next_slot)) {
|
|
// Native roots precede appended children; only the root may have a slot gap.
|
|
if (ordinal == 1u)
|
|
run.slot_bias = candidate.descriptor_index - ordinal;
|
|
++run.count;
|
|
continue;
|
|
}
|
|
}
|
|
runs.push_back({ordinal, 1u, resource,
|
|
candidate.descriptor_index - ordinal});
|
|
}
|
|
const auto EmitRun = [&](uint32_t index) {
|
|
const auto& run = runs[index];
|
|
if (run.count == 1u) return emit(run.resource, 0u);
|
|
auto slot = Binary(state, spv::OpIAdd, TypeU32(state), selected,
|
|
ConstantU32(state, run.slot_bias));
|
|
if (run.first == 0u) {
|
|
const auto root_slot = image.descriptor_index;
|
|
if (root_slot != run.slot_bias) {
|
|
const auto is_root = Binary(state, spv::OpIEqual, TypeBool(state), selected,
|
|
ConstantU32(state, 0u));
|
|
const auto root_or_child = state.builder.AllocateId();
|
|
state.builder.AddFunction(spv::OpSelect, TypeU32(state), root_or_child,
|
|
is_root, ConstantU32(state, root_slot), slot);
|
|
slot = root_or_child;
|
|
}
|
|
}
|
|
return emit(run.resource, slot);
|
|
};
|
|
auto run_index = ConstantU32(state, 0u);
|
|
for (uint32_t index = 1; index < runs.size(); ++index) {
|
|
const auto at_or_after = Binary(state, spv::OpUGreaterThanEqual, TypeBool(state),
|
|
selected, ConstantU32(state, runs[index].first));
|
|
const auto next = state.builder.AllocateId();
|
|
state.builder.AddFunction(spv::OpSelect, TypeU32(state), next, at_or_after,
|
|
ConstantU32(state, index), run_index);
|
|
run_index = next;
|
|
}
|
|
return runs.size() == 1u
|
|
? EmitRun(0u)
|
|
: EmitIndexSwitch(state, run_index, static_cast<uint32_t>(runs.size()),
|
|
result_type, EmitRun);
|
|
}
|
|
|
|
template <typename Emit>
|
|
uint32_t EmitImageResult(ValueEmitContext& ctx, const IR::Inst& inst, const Emit& emit) {
|
|
auto& state = ctx.state;
|
|
const auto& mem = ctx.Memory(inst);
|
|
const auto& image = state.program.info.images[mem.resource];
|
|
const bool gather = inst.GetOpcode() == IR::ValueOpcode::ImageGatherRaw;
|
|
const bool dref = HasFlag(mem, Decoder::ImageSampleFlagCompare);
|
|
const bool scalar = dref && !gather;
|
|
const bool mixed = std::ranges::any_of(image.indirect_resources, [&](uint32_t resource) {
|
|
return state.program.info.images[resource].numeric_class != image.numeric_class;
|
|
});
|
|
const auto native_type = [&](uint32_t resource) {
|
|
return scalar ? TypeF32(state) : ImageVectorType(
|
|
state, dref ? Prospero::TextureNumericClass::Float
|
|
: state.program.info.images[resource].numeric_class, 4);
|
|
};
|
|
const auto result_bits = [&](uint32_t resource, uint32_t value) {
|
|
auto candidate_mem = mem;
|
|
candidate_mem.resource = resource;
|
|
if (!scalar) {
|
|
value = gather ? UnpackImageGather(ctx, candidate_mem, value)
|
|
: UnpackImageTexel(ctx, candidate_mem, value);
|
|
}
|
|
return ResultVector(ctx, value,
|
|
dref ? Prospero::TextureNumericClass::Float
|
|
: state.program.info.images[resource].numeric_class,
|
|
scalar, candidate_mem, gather);
|
|
};
|
|
// RDNA returns register bits. Convert per typed run only when the join mixes
|
|
// numeric classes; homogeneous accesses keep their single conversion after it.
|
|
const auto value = EmitImageAccess(
|
|
ctx, inst, mixed ? TypeU32Vector(state, 4) : native_type(mem.resource),
|
|
[&](uint32_t resource, uint32_t array_index) {
|
|
const auto native = emit(resource, array_index, native_type(resource));
|
|
return mixed ? result_bits(resource, native) : native;
|
|
});
|
|
return mixed ? value : result_bits(mem.resource, value);
|
|
}
|
|
|
|
struct ImageSampler {
|
|
uint32_t id = 0;
|
|
bool dynamic = false;
|
|
};
|
|
|
|
std::array<ImageSampler, 2> LoadImageSamplers(ValueEmitContext& ctx, const IR::Inst& inst) {
|
|
auto& state = ctx.state;
|
|
const auto& mem = ctx.Memory(inst);
|
|
const auto& samplers = state.program.info.samplers;
|
|
const auto& root = samplers.at(mem.sampler);
|
|
std::array<ImageSampler, 2> result {};
|
|
const auto load = [&](const IR::ImageResource& image) {
|
|
const bool integer = image.numeric_class != Prospero::TextureNumericClass::Float;
|
|
auto& sampler = result[integer];
|
|
if (sampler.id != 0u) return;
|
|
uint32_t index = mem.sampler;
|
|
if (root.integer_border != integer) {
|
|
const auto found = std::ranges::find_if(samplers, [&](const auto& candidate) {
|
|
return candidate.snapshot_index == root.snapshot_index &&
|
|
candidate.integer_border == integer;
|
|
});
|
|
if (found == samplers.end()) ctx.Fail(inst, "has no typed sampler variant");
|
|
index = static_cast<uint32_t>(found - samplers.begin());
|
|
}
|
|
uint32_t array_index = 0;
|
|
const auto& candidates = samplers[index].indirect_resources;
|
|
if (!candidates.empty()) {
|
|
const auto* handle = inst.Arg(1).ResolveInstruction();
|
|
if (handle == nullptr || handle->GetOpcode() != IR::ValueOpcode::GetSamplerResource)
|
|
ctx.Fail(inst, "has invalid finite sampler key provenance");
|
|
auto selected = ctx.Def(handle->Arg(0));
|
|
if (samplers[index].indirect_root != IR::SamplerResource::NoIndirectSampler)
|
|
selected = EmitIndirectResourceIndex(state, selected,
|
|
samplers[index].indirect_mapping_offset,
|
|
samplers[index].indirect_search_iterations, 0u);
|
|
array_index = EmitIndexSwitch(
|
|
state, selected, static_cast<uint32_t>(candidates.size()),
|
|
TypeU32(state), [&](uint32_t ordinal) { return ConstantU32(state, candidates[ordinal]); });
|
|
}
|
|
sampler = {LoadSamplerDescriptor(state, index, array_index), array_index != 0u};
|
|
};
|
|
const auto& image = state.program.info.images[mem.resource];
|
|
load(image);
|
|
for (const auto candidate: image.indirect_resources) load(state.program.info.images[candidate]);
|
|
return result;
|
|
}
|
|
|
|
} // namespace
|
|
|
|
void EmitImage(ValueEmitContext& ctx, const IR::Inst& inst) {
|
|
const auto op = inst.GetOpcode();
|
|
const auto image_info = IR::ImageOpcodeInfoOf(op);
|
|
auto& state = ctx.state;
|
|
const auto& mem = ctx.Memory(inst);
|
|
const auto image_arg = inst.Arg(0);
|
|
ctx.ResourceIndex(image_arg, IR::ValueOpcode::GetImageResource);
|
|
const auto& image = state.program.info.images.at(mem.resource);
|
|
const auto* address = ctx.ImageAddress(inst.Arg(image_info.needs_sampler ? 2 : 1));
|
|
if (op == IR::ValueOpcode::ImageQueryDimensions) {
|
|
state.builder.RequireCapability(spv::CapabilityImageQuery);
|
|
ctx.Define(inst, QueryDimensions(ctx, mem, *address));
|
|
return;
|
|
}
|
|
if (image_info.needs_sampler &&
|
|
image.conversion_format == Prospero::BufferFormat::k11_11_10UNorm) {
|
|
if (op != IR::ValueOpcode::ImageSampleRaw ||
|
|
image.dimension != ImageDimension::Dim2D ||
|
|
mem.image_dimension != ImageDimension::Dim2D || mem.data_bits != 32u ||
|
|
mem.image_sample_flags != Decoder::ImageSampleFlagLevelZero ||
|
|
image.indirect_root != IR::ImageResource::NoIndirectImage ||
|
|
!state.program.info.samplers.at(mem.sampler).indirect_resources.empty()) {
|
|
ctx.Fail(inst, "packed UNorm sampling requires a direct 2D sample_lz");
|
|
return;
|
|
}
|
|
const auto coord = CoordF32(ctx, mem, *address, Layout(mem).coord, 2u);
|
|
ctx.Define(inst, ResultVector(ctx, SamplePackedUnormLz(ctx, mem, coord),
|
|
Prospero::TextureNumericClass::Float, false, mem));
|
|
return;
|
|
}
|
|
if (op == IR::ValueOpcode::ImageQueryLod) {
|
|
state.builder.RequireCapability(spv::CapabilityImageQuery);
|
|
const auto dimension = image.dimension;
|
|
const auto sampled = MakeSampledImage(state, mem.resource,
|
|
LoadSamplerDescriptor(state, mem.sampler));
|
|
const auto lod = state.builder.AllocateId();
|
|
state.builder.AddFunction(
|
|
spv::OpImageQueryLod, TypeF32Vector(state, 2), lod, sampled,
|
|
CoordF32(ctx, mem, *address, 0, ImageDimensionInfoFor(dimension).spatial_components,
|
|
image.cube));
|
|
uint32_t values[4] = {ConstantU32(state, 0), ConstantU32(state, 0), ConstantU32(state, 0),
|
|
ConstantU32(state, 0)};
|
|
for (uint32_t index = 0; index < 2u; index++) {
|
|
const auto component = state.builder.AllocateId();
|
|
state.builder.AddFunction(spv::OpCompositeExtract, TypeF32(state), component, lod,
|
|
index);
|
|
values[index] = FloatBits(ctx, component);
|
|
}
|
|
const auto result = state.builder.AllocateId();
|
|
state.builder.AddFunction(spv::OpCompositeConstruct, TypeU32Vector(state, 4), result,
|
|
values[0], values[1], values[2], values[3]);
|
|
ctx.Define(inst, result);
|
|
return;
|
|
}
|
|
if (op == IR::ValueOpcode::ImageRead) {
|
|
const auto condition = ctx.Arg(inst, 2);
|
|
ctx.Define(
|
|
inst,
|
|
EmitValueOrDefaultIfCondition(
|
|
state, condition, TypeU32Vector(state, 4), ConstantU32CompositeZero(state, 4),
|
|
[&]() {
|
|
return EmitImageResult(
|
|
ctx, inst, [&](uint32_t resource, uint32_t array_index, uint32_t result_type) {
|
|
const auto& candidate = state.program.info.images[resource];
|
|
const auto dimension = candidate.dimension;
|
|
const auto& dimension_info = ImageDimensionInfoFor(dimension);
|
|
const auto descriptor = LoadImageDescriptor(state, resource, 0u, array_index);
|
|
const auto fetched = state.builder.AllocateId();
|
|
const auto coord = CoordU32(ctx, mem, *address, dimension);
|
|
if (dimension_info.multisampled != 0u) {
|
|
state.builder.AddFunction(
|
|
spv::OpImageFetch, result_type, fetched,
|
|
descriptor, coord, spv::ImageOperandsSampleMask,
|
|
AddressU32(ctx, mem, *address, dimension_info.coordinate_components));
|
|
} else {
|
|
state.builder.AddFunction(
|
|
spv::OpImageFetch, result_type, fetched,
|
|
descriptor, coord, spv::ImageOperandsLodMask,
|
|
LodU32(ctx, mem, *address, mem.image_dimension));
|
|
}
|
|
return fetched;
|
|
});
|
|
}));
|
|
return;
|
|
}
|
|
if (op == IR::ValueOpcode::ImageWrite) {
|
|
EmitIfCondition(state, ctx.Arg(inst, 3), [&]() {
|
|
EmitImageAccess(ctx, inst, 0u, [&](uint32_t resource, uint32_t array_index) {
|
|
const auto& candidate = state.program.info.images[resource];
|
|
auto selected = mem;
|
|
selected.resource = resource;
|
|
const auto mip_lod = candidate.mip_mode == IR::ImageMipMode::Dynamic
|
|
? LodU32(ctx, mem, *address, mem.image_dimension) : 0u;
|
|
const auto coord = CoordU32(ctx, mem, *address, candidate.dimension);
|
|
const auto texel = StoreTexel(ctx, selected, ctx.Arg(inst, 2),
|
|
candidate.numeric_class == Prospero::TextureNumericClass::Uint);
|
|
EmitStorageImageWrite(state, resource, mip_lod, coord, texel, array_index);
|
|
});
|
|
});
|
|
return;
|
|
}
|
|
if (op == IR::ValueOpcode::ImageSampleRaw || op == IR::ValueOpcode::ImageGatherRaw) {
|
|
const auto dimension = image.dimension;
|
|
const auto& dimension_info = ImageDimensionInfoFor(dimension);
|
|
const auto layout = Layout(mem);
|
|
const auto numeric_class = image.numeric_class;
|
|
const bool dref = HasFlag(mem, Decoder::ImageSampleFlagCompare);
|
|
IR::Value offset_value;
|
|
if (layout.offset != NoImageComponent) {
|
|
const auto value = address->Arg(layout.offset).Resolve();
|
|
offset_value = IR::ResolveActiveU32(value, inst.Arg(inst.NumArgs() - 1u).Resolve());
|
|
if (offset_value.IsEmpty()) offset_value = value;
|
|
}
|
|
if (dref && state.program.info.images[mem.resource].conversion_format !=
|
|
Prospero::BufferFormat::kInvalid) {
|
|
ctx.Fail(inst, "uses depth comparison with a converted image");
|
|
return;
|
|
}
|
|
if (op == IR::ValueOpcode::ImageGatherRaw) {
|
|
if (dimension == ImageDimension::Dim1D) {
|
|
if (image.indirect_root == mem.resource || dref ||
|
|
!HasFlag(mem, Decoder::ImageSampleFlagLevelZero) ||
|
|
HasFlag(mem, Decoder::ImageSampleFlagOffset) ||
|
|
HasFlag(mem, Decoder::ImageSampleFlagGatherHorizontal)) {
|
|
ctx.Fail(inst, "has an unsupported 1D gather variant");
|
|
return;
|
|
}
|
|
const auto coord = CoordF32(ctx, mem, *address, layout.coord,
|
|
dimension_info.coordinate_components, image.cube);
|
|
const auto sample = EmitOneDimensionalGatherLz(ctx, mem, coord, numeric_class);
|
|
ctx.Define(inst, ResultVector(ctx, UnpackImageGather(ctx, mem, sample),
|
|
numeric_class, false, mem, true));
|
|
return;
|
|
}
|
|
if (dimension == ImageDimension::Dim1DArray) {
|
|
ctx.Fail(inst, "has an unsupported 1D-array gather");
|
|
return;
|
|
}
|
|
uint32_t component_or_dref;
|
|
if (dref) {
|
|
component_or_dref = layout.dref != NoImageComponent
|
|
? AddressF32(ctx, mem, *address, layout.dref)
|
|
: ZeroF32(state);
|
|
} else {
|
|
component_or_dref = ConstantU32(state, ImageGatherSource(state, mem));
|
|
}
|
|
const auto samplers = LoadImageSamplers(ctx, inst);
|
|
const auto EmitGather = [&](uint32_t resource, uint32_t array_index, uint32_t result_type) {
|
|
const auto& candidate = state.program.info.images[resource];
|
|
const auto sampler = samplers[candidate.numeric_class != Prospero::TextureNumericClass::Float];
|
|
const auto dimension = candidate.dimension;
|
|
const auto coord = CoordF32(
|
|
ctx, mem, *address, layout.coord,
|
|
ImageDimensionInfoFor(dimension).coordinate_components, candidate.cube);
|
|
uint32_t operand_mask = 0;
|
|
uint32_t offset = 0;
|
|
if (HasFlag(mem, Decoder::ImageSampleFlagGatherHorizontal)) {
|
|
operand_mask = spv::ImageOperandsConstOffsetsMask;
|
|
offset = HorizontalOffsets(state, dimension);
|
|
} else if (layout.offset != NoImageComponent) {
|
|
offset = PackedOffset(ctx, offset_value, dimension, operand_mask);
|
|
}
|
|
const auto EmitMip = [&](uint32_t mip) {
|
|
const auto sampled = MakeSampledImage(state, resource, sampler.id, mip, array_index,
|
|
sampler.dynamic);
|
|
const auto sample = state.builder.AllocateId();
|
|
const std::array operands {operand_mask, offset};
|
|
state.builder.AddFunction(
|
|
dref ? spv::OpImageDrefGather : spv::OpImageGather, result_type,
|
|
sample, sampled, coord, component_or_dref,
|
|
std::span(operands).first(operand_mask != 0u ? 2u : 0u));
|
|
return sample;
|
|
};
|
|
return candidate.mip_mode == IR::ImageMipMode::Dynamic && candidate.mip_count > 1u
|
|
? EmitIndexSwitch(
|
|
state, GatherMip(ctx, inst, mem, *address, layout, candidate.mip_count),
|
|
candidate.mip_count, result_type, EmitMip)
|
|
: EmitMip(0u);
|
|
};
|
|
ctx.Define(inst, EmitImageResult(ctx, inst, EmitGather));
|
|
return;
|
|
}
|
|
const bool explicit_lod = HasFlag(mem, Decoder::ImageSampleFlagDerivative) ||
|
|
HasFlag(mem, Decoder::ImageSampleFlagLod) ||
|
|
HasFlag(mem, Decoder::ImageSampleFlagLevelZero) ||
|
|
state.program.stage != ShaderType::Pixel;
|
|
auto opcode = spv::OpImageSampleImplicitLod;
|
|
if (explicit_lod) {
|
|
opcode = dref ? spv::OpImageSampleDrefExplicitLod : spv::OpImageSampleExplicitLod;
|
|
} else if (dref) {
|
|
opcode = spv::OpImageSampleDrefImplicitLod;
|
|
}
|
|
uint32_t dref_value = 0;
|
|
if (dref) {
|
|
dref_value = ZeroF32(state);
|
|
if (layout.dref != NoImageComponent) {
|
|
dref_value = AddressF32(ctx, mem, *address, layout.dref);
|
|
}
|
|
}
|
|
std::array<uint32_t, 4> operands {};
|
|
size_t operand_count = 0;
|
|
if (HasFlag(mem, Decoder::ImageSampleFlagDerivative)) {
|
|
operands[0] = spv::ImageOperandsGradMask;
|
|
operands[1] = CoordF32(ctx, mem, *address, layout.grad_x, dimension_info.spatial_components);
|
|
operands[2] = CoordF32(ctx, mem, *address, layout.grad_y, dimension_info.spatial_components);
|
|
operand_count = 3;
|
|
} else if (explicit_lod) {
|
|
auto lod = ZeroF32(state);
|
|
if (HasFlag(mem, Decoder::ImageSampleFlagLod) && layout.lod != NoImageComponent) {
|
|
lod = AddressF32(ctx, mem, *address, layout.lod);
|
|
}
|
|
operands[0] = spv::ImageOperandsLodMask;
|
|
operands[1] = lod;
|
|
operand_count = 2;
|
|
} else if (layout.bias != NoImageComponent) {
|
|
operands[0] = spv::ImageOperandsBiasMask;
|
|
operands[1] = AddressF32(ctx, mem, *address, layout.bias);
|
|
operand_count = 2;
|
|
}
|
|
if (layout.offset != NoImageComponent &&
|
|
!offset_value.IsImmediate() && !state.maintenance8_enabled) {
|
|
ctx.Fail(inst, "requires maintenance8 for a dynamic sample texel offset");
|
|
}
|
|
const auto samplers = LoadImageSamplers(ctx, inst);
|
|
const auto EmitSample = [&](uint32_t resource, uint32_t array_index, uint32_t result_type) {
|
|
const auto& candidate = state.program.info.images[resource];
|
|
const auto sampler = samplers[candidate.numeric_class != Prospero::TextureNumericClass::Float];
|
|
auto sample_operands = operands;
|
|
auto sample_operand_count = operand_count;
|
|
if (layout.offset != NoImageComponent) {
|
|
sample_operand_count = std::max(size_t{1}, sample_operand_count);
|
|
sample_operands[sample_operand_count++] = PackedOffset(
|
|
ctx, offset_value, candidate.dimension, sample_operands[0]);
|
|
}
|
|
const auto coord =
|
|
CoordF32(ctx, mem, *address, layout.coord,
|
|
ImageDimensionInfoFor(candidate.dimension).coordinate_components,
|
|
candidate.cube);
|
|
const auto sampled = MakeSampledImage(state, resource, sampler.id, 0u, array_index,
|
|
sampler.dynamic);
|
|
const auto sample = state.builder.AllocateId();
|
|
state.builder.AddFunction(opcode, result_type, sample, sampled, coord,
|
|
std::span(&dref_value, dref ? 1u : 0u),
|
|
std::span<const uint32_t>(sample_operands).first(sample_operand_count));
|
|
return sample;
|
|
};
|
|
ctx.Define(inst, EmitImageResult(ctx, inst, EmitSample));
|
|
return;
|
|
}
|
|
if (image_info.access == IR::ImageAccess::Atomic) {
|
|
const auto dimension = image.dimension;
|
|
const auto result_type = TypeId(state, inst.GetType());
|
|
const auto zero = image.atomic64 ? ConstantU64(state, 0) : ConstantU32(state, 0);
|
|
ctx.Define(inst, EmitValueOrDefaultIfCondition(
|
|
state, ctx.Arg(inst, inst.NumArgs() - 1), result_type, zero, [&]() {
|
|
const auto pointer = state.builder.AllocateId();
|
|
const auto pointer_type =
|
|
state.builder.Type(spv::OpTypePointer, spv::StorageClassImage,
|
|
image.atomic64 ? TypeU64(state) : TypeU32(state));
|
|
state.builder.AddFunction(spv::OpImageTexelPointer, pointer_type, pointer,
|
|
ImageDescriptorPointer(state, mem.resource),
|
|
CoordU32(ctx, mem, *address, dimension),
|
|
ConstantU32(state, 0));
|
|
if (op == IR::ValueOpcode::ImageAtomicFMin32 ||
|
|
op == IR::ValueOpcode::ImageAtomicFMax32) {
|
|
return AtomicUpdate(state, pointer, IR::ResourceKind::Image,
|
|
[&](uint32_t old) {
|
|
return EmitFloatAtomicReplacement(
|
|
state, old, ctx.Arg(inst, 2),
|
|
op == IR::ValueOpcode::ImageAtomicFMax32);
|
|
});
|
|
}
|
|
const auto old = EmitAtomicOperation(ctx, inst, pointer, spv::ScopeDevice);
|
|
EmitAtomicMemoryBarrier(state, IR::ResourceKind::Image);
|
|
return old;
|
|
}));
|
|
return;
|
|
}
|
|
ctx.Fail(inst, "has no image SPIR-V emitter");
|
|
}
|
|
|
|
} // namespace Libs::Graphics::ShaderRecompiler::Spirv::Emitter
|