501 lines
20 KiB
C++
501 lines
20 KiB
C++
// Copyright 2021 yuzu Emulator Project
|
|
// Licensed under GPLv2 or any later version
|
|
// Refer to the license.txt file included.
|
|
|
|
#include <string_view>
|
|
|
|
#include "shader_recompiler/backend/glsl/emit_context.h"
|
|
#include "shader_recompiler/backend/glsl/emit_glsl_instructions.h"
|
|
#include "shader_recompiler/frontend/ir/modifiers.h"
|
|
#include "shader_recompiler/frontend/ir/value.h"
|
|
|
|
namespace Shader::Backend::GLSL {
|
|
namespace {
|
|
std::string Texture(EmitContext& ctx, const IR::TextureInstInfo& info,
|
|
[[maybe_unused]] const IR::Value& index) {
|
|
if (info.type == TextureType::Buffer) {
|
|
throw NotImplementedException("TextureType::Buffer");
|
|
} else {
|
|
return fmt::format("tex{}", ctx.texture_bindings.at(info.descriptor_index));
|
|
}
|
|
}
|
|
|
|
std::string CastToIntVec(std::string_view value, const IR::TextureInstInfo& info) {
|
|
switch (info.type) {
|
|
case TextureType::Color1D:
|
|
return fmt::format("int({})", value);
|
|
case TextureType::ColorArray1D:
|
|
case TextureType::Color2D:
|
|
case TextureType::ColorArray2D:
|
|
return fmt::format("ivec2({})", value);
|
|
case TextureType::Color3D:
|
|
case TextureType::ColorCube:
|
|
return fmt::format("ivec3({})", value);
|
|
case TextureType::ColorArrayCube:
|
|
return fmt::format("ivec4({})", value);
|
|
default:
|
|
throw NotImplementedException("Offset type {}", info.type.Value());
|
|
}
|
|
}
|
|
|
|
std::string TexelFetchCastToInt(std::string_view value, const IR::TextureInstInfo& info) {
|
|
switch (info.type) {
|
|
case TextureType::Color1D:
|
|
return fmt::format("int({})", value);
|
|
case TextureType::ColorArray1D:
|
|
case TextureType::Color2D:
|
|
return fmt::format("ivec2({})", value);
|
|
case TextureType::ColorArray2D:
|
|
case TextureType::Color3D:
|
|
case TextureType::ColorCube:
|
|
return fmt::format("ivec3({})", value);
|
|
case TextureType::ColorArrayCube:
|
|
return fmt::format("ivec4({})", value);
|
|
default:
|
|
throw NotImplementedException("Offset type {}", info.type.Value());
|
|
}
|
|
}
|
|
|
|
std::string ShadowSamplerVecCast(TextureType type) {
|
|
switch (type) {
|
|
case TextureType::ColorArray2D:
|
|
case TextureType::ColorCube:
|
|
case TextureType::ColorArrayCube:
|
|
return "vec4";
|
|
default:
|
|
return "vec3";
|
|
}
|
|
}
|
|
|
|
std::string PtpOffsets(const IR::Value& offset, const IR::Value& offset2) {
|
|
const std::array values{offset.InstRecursive(), offset2.InstRecursive()};
|
|
if (!values[0]->AreAllArgsImmediates() || !values[1]->AreAllArgsImmediates()) {
|
|
// LOG_WARNING("Not all arguments in PTP are immediate, STUBBING");
|
|
return "";
|
|
}
|
|
const IR::Opcode opcode{values[0]->GetOpcode()};
|
|
if (opcode != values[1]->GetOpcode() || opcode != IR::Opcode::CompositeConstructU32x4) {
|
|
throw LogicError("Invalid PTP arguments");
|
|
}
|
|
auto read{[&](unsigned int a, unsigned int b) { return values[a]->Arg(b).U32(); }};
|
|
|
|
return fmt::format("ivec2[](ivec2({},{}),ivec2({},{}),ivec2({},{}),ivec2({},{}))", read(0, 0),
|
|
read(0, 1), read(0, 2), read(0, 3), read(1, 0), read(1, 1), read(1, 2),
|
|
read(1, 3));
|
|
}
|
|
|
|
IR::Inst* PrepareSparse(IR::Inst& inst) {
|
|
const auto sparse_inst{inst.GetAssociatedPseudoOperation(IR::Opcode::GetSparseFromOp)};
|
|
if (sparse_inst) {
|
|
sparse_inst->Invalidate();
|
|
}
|
|
return sparse_inst;
|
|
}
|
|
} // namespace
|
|
|
|
void EmitImageSampleImplicitLod([[maybe_unused]] EmitContext& ctx, [[maybe_unused]] IR::Inst& inst,
|
|
[[maybe_unused]] const IR::Value& index,
|
|
[[maybe_unused]] std::string_view coords,
|
|
[[maybe_unused]] std::string_view bias_lc,
|
|
[[maybe_unused]] const IR::Value& offset) {
|
|
const auto info{inst.Flags<IR::TextureInstInfo>()};
|
|
if (info.has_lod_clamp) {
|
|
throw NotImplementedException("Lod clamp samples");
|
|
}
|
|
const auto texture{Texture(ctx, info, index)};
|
|
const auto bias{info.has_bias ? fmt::format(",{}", bias_lc) : ""};
|
|
const auto texel{ctx.reg_alloc.Define(inst, Type::F32x4)};
|
|
const auto sparse_inst{PrepareSparse(inst)};
|
|
if (!sparse_inst) {
|
|
if (!offset.IsEmpty()) {
|
|
ctx.Add("{}=textureOffset({},{},{}{});", texel, texture, coords,
|
|
CastToIntVec(ctx.reg_alloc.Consume(offset), info), bias);
|
|
} else {
|
|
if (ctx.stage == Stage::Fragment) {
|
|
ctx.Add("{}=texture({},{}{});", texel, texture, coords, bias);
|
|
} else {
|
|
ctx.Add("{}=textureLod({},{},0.0);", texel, texture, coords);
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
// TODO: Query sparseTexels extension support
|
|
if (!offset.IsEmpty()) {
|
|
ctx.AddU1("{}=sparseTexelsResidentARB(sparseTextureOffsetARB({},{},{},{}{}));",
|
|
*sparse_inst, texture, coords, CastToIntVec(ctx.reg_alloc.Consume(offset), info),
|
|
texel, bias);
|
|
} else {
|
|
ctx.AddU1("{}=sparseTexelsResidentARB(sparseTextureARB({},{},{}{}));", *sparse_inst,
|
|
texture, coords, texel, bias);
|
|
}
|
|
}
|
|
|
|
void EmitImageSampleExplicitLod([[maybe_unused]] EmitContext& ctx, [[maybe_unused]] IR::Inst& inst,
|
|
[[maybe_unused]] const IR::Value& index,
|
|
[[maybe_unused]] std::string_view coords,
|
|
[[maybe_unused]] std::string_view lod_lc,
|
|
[[maybe_unused]] const IR::Value& offset) {
|
|
const auto info{inst.Flags<IR::TextureInstInfo>()};
|
|
if (info.has_bias) {
|
|
throw NotImplementedException("Bias texture samples");
|
|
}
|
|
if (info.has_lod_clamp) {
|
|
throw NotImplementedException("Lod clamp samples");
|
|
}
|
|
const auto texture{Texture(ctx, info, index)};
|
|
const auto texel{ctx.reg_alloc.Define(inst, Type::F32x4)};
|
|
const auto sparse_inst{PrepareSparse(inst)};
|
|
if (!sparse_inst) {
|
|
if (!offset.IsEmpty()) {
|
|
ctx.Add("{}=textureLodOffset({},{},{},{});", texel, texture, coords, lod_lc,
|
|
CastToIntVec(ctx.reg_alloc.Consume(offset), info));
|
|
} else {
|
|
ctx.Add("{}=textureLod({},{},{});", texel, texture, coords, lod_lc);
|
|
}
|
|
return;
|
|
}
|
|
// TODO: Query sparseTexels extension support
|
|
if (!offset.IsEmpty()) {
|
|
ctx.AddU1("{}=sparseTexelsResidentARB(sparseTexelFetchOffsetARB({},{},int({}),{},{}));",
|
|
*sparse_inst, texture, CastToIntVec(coords, info), lod_lc,
|
|
CastToIntVec(ctx.reg_alloc.Consume(offset), info), texel);
|
|
} else {
|
|
ctx.AddU1("{}=sparseTexelsResidentARB(sparseTextureLodARB({},{},{},{}));", *sparse_inst,
|
|
texture, coords, lod_lc, texel);
|
|
}
|
|
}
|
|
|
|
void EmitImageSampleDrefImplicitLod([[maybe_unused]] EmitContext& ctx,
|
|
[[maybe_unused]] IR::Inst& inst,
|
|
[[maybe_unused]] const IR::Value& index,
|
|
[[maybe_unused]] std::string_view coords,
|
|
[[maybe_unused]] std::string_view dref,
|
|
[[maybe_unused]] std::string_view bias_lc,
|
|
[[maybe_unused]] const IR::Value& offset) {
|
|
const auto info{inst.Flags<IR::TextureInstInfo>()};
|
|
const auto sparse_inst{PrepareSparse(inst)};
|
|
if (sparse_inst) {
|
|
throw NotImplementedException("Sparse texture samples");
|
|
}
|
|
if (info.has_bias) {
|
|
throw NotImplementedException("Bias texture samples");
|
|
}
|
|
if (info.has_lod_clamp) {
|
|
throw NotImplementedException("Lod clamp samples");
|
|
}
|
|
if (!offset.IsEmpty()) {
|
|
throw NotImplementedException("textureLodOffset");
|
|
}
|
|
const auto texture{Texture(ctx, info, index)};
|
|
const auto bias{info.has_bias ? fmt::format(",{}", bias_lc) : ""};
|
|
const auto cast{ShadowSamplerVecCast(info.type)};
|
|
if (ctx.stage == Stage::Fragment) {
|
|
ctx.AddF32("{}=texture({},{}({},{}){});", inst, texture, cast, coords, dref, bias);
|
|
} else {
|
|
ctx.AddF32("{}=textureLod({},{}({},{}),0.0);", inst, texture, cast, coords, dref);
|
|
}
|
|
}
|
|
|
|
void EmitImageSampleDrefExplicitLod([[maybe_unused]] EmitContext& ctx,
|
|
[[maybe_unused]] IR::Inst& inst,
|
|
[[maybe_unused]] const IR::Value& index,
|
|
[[maybe_unused]] std::string_view coords,
|
|
[[maybe_unused]] std::string_view dref,
|
|
[[maybe_unused]] std::string_view lod_lc,
|
|
[[maybe_unused]] const IR::Value& offset) {
|
|
const auto info{inst.Flags<IR::TextureInstInfo>()};
|
|
const auto sparse_inst{PrepareSparse(inst)};
|
|
if (sparse_inst) {
|
|
throw NotImplementedException("Sparse texture samples");
|
|
}
|
|
if (info.has_bias) {
|
|
throw NotImplementedException("Bias texture samples");
|
|
}
|
|
if (info.has_lod_clamp) {
|
|
throw NotImplementedException("Lod clamp samples");
|
|
}
|
|
if (!offset.IsEmpty()) {
|
|
throw NotImplementedException("textureLodOffset");
|
|
}
|
|
const auto texture{Texture(ctx, info, index)};
|
|
if (info.type == TextureType::ColorArrayCube) {
|
|
ctx.AddF32("{}=textureLod({},{},{},{});", inst, texture, coords, dref, lod_lc);
|
|
} else {
|
|
ctx.AddF32("{}=textureLod({},vec3({},{}),{});", inst, texture, coords, dref, lod_lc);
|
|
}
|
|
}
|
|
|
|
void EmitImageGather([[maybe_unused]] EmitContext& ctx, [[maybe_unused]] IR::Inst& inst,
|
|
[[maybe_unused]] const IR::Value& index,
|
|
[[maybe_unused]] std::string_view coords,
|
|
[[maybe_unused]] const IR::Value& offset,
|
|
[[maybe_unused]] const IR::Value& offset2) {
|
|
const auto info{inst.Flags<IR::TextureInstInfo>()};
|
|
const auto texture{Texture(ctx, info, index)};
|
|
const auto texel{ctx.reg_alloc.Define(inst, Type::F32x4)};
|
|
const auto sparse_inst{PrepareSparse(inst)};
|
|
if (!sparse_inst) {
|
|
if (offset.IsEmpty()) {
|
|
ctx.Add("{}=textureGather({},{},int({}));", texel, texture, coords,
|
|
info.gather_component);
|
|
return;
|
|
}
|
|
if (offset2.IsEmpty()) {
|
|
ctx.Add("{}=textureGatherOffset({},{},{},int({}));", texel, texture, coords,
|
|
CastToIntVec(ctx.reg_alloc.Consume(offset), info), info.gather_component);
|
|
return;
|
|
}
|
|
// PTP
|
|
const auto offsets{PtpOffsets(offset, offset2)};
|
|
ctx.Add("{}=textureGatherOffsets({},{},{},int({}));", texel, texture, coords, offsets,
|
|
info.gather_component);
|
|
return;
|
|
}
|
|
// TODO: Query sparseTexels extension support
|
|
if (offset.IsEmpty()) {
|
|
ctx.AddU1("{}=sparseTexelsResidentARB(sparseTextureGatherARB({},{},{},int({})));",
|
|
*sparse_inst, texture, coords, texel, info.gather_component);
|
|
}
|
|
if (offset2.IsEmpty()) {
|
|
ctx.AddU1("{}=sparseTexelsResidentARB(sparseTextureGatherOffsetARB({},{},{},{},int({})));",
|
|
*sparse_inst, texture, CastToIntVec(coords, info),
|
|
CastToIntVec(ctx.reg_alloc.Consume(offset), info), texel, info.gather_component);
|
|
}
|
|
// PTP
|
|
const auto offsets{PtpOffsets(offset, offset2)};
|
|
ctx.AddU1("{}=sparseTexelsResidentARB(sparseTextureGatherOffsetARB({},{},{},{},int({})));",
|
|
*sparse_inst, texture, CastToIntVec(coords, info), offsets, texel,
|
|
info.gather_component);
|
|
}
|
|
|
|
void EmitImageGatherDref([[maybe_unused]] EmitContext& ctx, [[maybe_unused]] IR::Inst& inst,
|
|
[[maybe_unused]] const IR::Value& index,
|
|
[[maybe_unused]] std::string_view coords,
|
|
[[maybe_unused]] const IR::Value& offset,
|
|
[[maybe_unused]] const IR::Value& offset2,
|
|
[[maybe_unused]] std::string_view dref) {
|
|
const auto info{inst.Flags<IR::TextureInstInfo>()};
|
|
const auto texture{Texture(ctx, info, index)};
|
|
const auto texel{ctx.reg_alloc.Define(inst, Type::F32x4)};
|
|
const auto sparse_inst{PrepareSparse(inst)};
|
|
if (!sparse_inst) {
|
|
if (offset.IsEmpty()) {
|
|
ctx.Add("{}=textureGather({},{},{});", texel, texture, coords, dref);
|
|
return;
|
|
}
|
|
if (offset2.IsEmpty()) {
|
|
ctx.Add("{}=textureGatherOffset({},{},{},{});", texel, texture, coords, dref,
|
|
CastToIntVec(ctx.reg_alloc.Consume(offset), info));
|
|
return;
|
|
}
|
|
// PTP
|
|
const auto offsets{PtpOffsets(offset, offset2)};
|
|
ctx.Add("{}=textureGatherOffsets({},{},{},{});", texel, texture, coords, dref, offsets);
|
|
return;
|
|
}
|
|
// TODO: Query sparseTexels extension support
|
|
if (offset.IsEmpty()) {
|
|
ctx.AddU1("{}=sparseTexelsResidentARB(sparseTextureGatherARB({},{},{},{}));", *sparse_inst,
|
|
texture, coords, dref, texel);
|
|
}
|
|
if (offset2.IsEmpty()) {
|
|
ctx.AddU1("{}=sparseTexelsResidentARB(sparseTextureGatherOffsetARB({},{},{},,{},{}));",
|
|
*sparse_inst, texture, CastToIntVec(coords, info), dref,
|
|
CastToIntVec(ctx.reg_alloc.Consume(offset), info), texel);
|
|
}
|
|
// PTP
|
|
const auto offsets{PtpOffsets(offset, offset2)};
|
|
ctx.AddU1("{}=sparseTexelsResidentARB(sparseTextureGatherOffsetARB({},{},{},,{},{}));",
|
|
*sparse_inst, texture, CastToIntVec(coords, info), dref, offsets, texel);
|
|
}
|
|
|
|
void EmitImageFetch([[maybe_unused]] EmitContext& ctx, [[maybe_unused]] IR::Inst& inst,
|
|
[[maybe_unused]] const IR::Value& index,
|
|
[[maybe_unused]] std::string_view coords,
|
|
[[maybe_unused]] std::string_view offset, [[maybe_unused]] std::string_view lod,
|
|
[[maybe_unused]] std::string_view ms) {
|
|
const auto info{inst.Flags<IR::TextureInstInfo>()};
|
|
if (info.has_bias) {
|
|
throw NotImplementedException("Bias texture samples");
|
|
}
|
|
if (info.has_lod_clamp) {
|
|
throw NotImplementedException("Lod clamp samples");
|
|
}
|
|
const auto texture{Texture(ctx, info, index)};
|
|
const auto sparse_inst{PrepareSparse(inst)};
|
|
const auto texel{ctx.reg_alloc.Define(inst, Type::F32x4)};
|
|
if (!sparse_inst) {
|
|
if (!offset.empty()) {
|
|
ctx.Add("{}=texelFetchOffset({},{},int({}),{});", texel, texture,
|
|
TexelFetchCastToInt(coords, info), lod, TexelFetchCastToInt(offset, info));
|
|
} else {
|
|
ctx.Add("{}=texelFetch({},{},int({}));", texel, texture,
|
|
TexelFetchCastToInt(coords, info), lod);
|
|
}
|
|
return;
|
|
}
|
|
// TODO: Query sparseTexels extension support
|
|
if (!offset.empty()) {
|
|
ctx.AddU1("{}=sparseTexelsResidentARB(sparseTexelFetchOffsetARB({},{},int({}),{},{}));",
|
|
*sparse_inst, texture, CastToIntVec(coords, info), lod,
|
|
CastToIntVec(offset, info), texel);
|
|
} else {
|
|
ctx.AddU1("{}=sparseTexelsResidentARB(sparseTexelFetchARB({},{},{},{}));", *sparse_inst,
|
|
texture, CastToIntVec(coords, info), lod, texel);
|
|
}
|
|
}
|
|
|
|
void EmitImageQueryDimensions([[maybe_unused]] EmitContext& ctx, [[maybe_unused]] IR::Inst& inst,
|
|
[[maybe_unused]] const IR::Value& index,
|
|
[[maybe_unused]] std::string_view lod) {
|
|
const auto info{inst.Flags<IR::TextureInstInfo>()};
|
|
const auto texture{Texture(ctx, info, index)};
|
|
switch (info.type) {
|
|
case TextureType::Color1D:
|
|
return ctx.AddU32x4(
|
|
"{}=uvec4(uint(textureSize({},int({}))),0u,0u,uint(textureQueryLevels({})));", inst,
|
|
texture, lod, texture);
|
|
case TextureType::ColorArray1D:
|
|
case TextureType::Color2D:
|
|
case TextureType::ColorCube:
|
|
return ctx.AddU32x4(
|
|
"{}=uvec4(uvec2(textureSize({},int({}))),0u,uint(textureQueryLevels({})));", inst,
|
|
texture, lod, texture);
|
|
case TextureType::ColorArray2D:
|
|
case TextureType::Color3D:
|
|
case TextureType::ColorArrayCube:
|
|
return ctx.AddU32x4(
|
|
"{}=uvec4(uvec3(textureSize({},int({}))),uint(textureQueryLevels({})));", inst, texture,
|
|
lod, texture);
|
|
case TextureType::Buffer:
|
|
throw NotImplementedException("Texture buffers");
|
|
}
|
|
throw LogicError("Unspecified image type {}", info.type.Value());
|
|
}
|
|
|
|
void EmitImageQueryLod([[maybe_unused]] EmitContext& ctx, [[maybe_unused]] IR::Inst& inst,
|
|
[[maybe_unused]] const IR::Value& index,
|
|
[[maybe_unused]] std::string_view coords) {
|
|
throw NotImplementedException("GLSL Instruction");
|
|
}
|
|
|
|
void EmitImageGradient([[maybe_unused]] EmitContext& ctx, [[maybe_unused]] IR::Inst& inst,
|
|
[[maybe_unused]] const IR::Value& index,
|
|
[[maybe_unused]] std::string_view coords,
|
|
[[maybe_unused]] std::string_view derivates,
|
|
[[maybe_unused]] std::string_view offset,
|
|
[[maybe_unused]] std::string_view lod_clamp) {
|
|
throw NotImplementedException("GLSL Instruction");
|
|
}
|
|
|
|
void EmitImageRead([[maybe_unused]] EmitContext& ctx, [[maybe_unused]] IR::Inst& inst,
|
|
[[maybe_unused]] const IR::Value& index,
|
|
[[maybe_unused]] std::string_view coords) {
|
|
throw NotImplementedException("GLSL Instruction");
|
|
}
|
|
|
|
void EmitImageWrite([[maybe_unused]] EmitContext& ctx, [[maybe_unused]] IR::Inst& inst,
|
|
[[maybe_unused]] const IR::Value& index,
|
|
[[maybe_unused]] std::string_view coords,
|
|
[[maybe_unused]] std::string_view color) {
|
|
throw NotImplementedException("GLSL Instruction");
|
|
}
|
|
|
|
void EmitBindlessImageSampleImplicitLod(EmitContext&) {
|
|
throw NotImplementedException("GLSL Instruction");
|
|
}
|
|
|
|
void EmitBindlessImageSampleExplicitLod(EmitContext&) {
|
|
throw NotImplementedException("GLSL Instruction");
|
|
}
|
|
|
|
void EmitBindlessImageSampleDrefImplicitLod(EmitContext&) {
|
|
throw NotImplementedException("GLSL Instruction");
|
|
}
|
|
|
|
void EmitBindlessImageSampleDrefExplicitLod(EmitContext&) {
|
|
throw NotImplementedException("GLSL Instruction");
|
|
}
|
|
|
|
void EmitBindlessImageGather(EmitContext&) {
|
|
throw NotImplementedException("GLSL Instruction");
|
|
}
|
|
|
|
void EmitBindlessImageGatherDref(EmitContext&) {
|
|
throw NotImplementedException("GLSL Instruction");
|
|
}
|
|
|
|
void EmitBindlessImageFetch(EmitContext&) {
|
|
throw NotImplementedException("GLSL Instruction");
|
|
}
|
|
|
|
void EmitBindlessImageQueryDimensions(EmitContext&) {
|
|
throw NotImplementedException("GLSL Instruction");
|
|
}
|
|
|
|
void EmitBindlessImageQueryLod(EmitContext&) {
|
|
throw NotImplementedException("GLSL Instruction");
|
|
}
|
|
|
|
void EmitBindlessImageGradient(EmitContext&) {
|
|
throw NotImplementedException("GLSL Instruction");
|
|
}
|
|
|
|
void EmitBindlessImageRead(EmitContext&) {
|
|
throw NotImplementedException("GLSL Instruction");
|
|
}
|
|
|
|
void EmitBindlessImageWrite(EmitContext&) {
|
|
throw NotImplementedException("GLSL Instruction");
|
|
}
|
|
|
|
void EmitBoundImageSampleImplicitLod(EmitContext&) {
|
|
throw NotImplementedException("GLSL Instruction");
|
|
}
|
|
|
|
void EmitBoundImageSampleExplicitLod(EmitContext&) {
|
|
throw NotImplementedException("GLSL Instruction");
|
|
}
|
|
|
|
void EmitBoundImageSampleDrefImplicitLod(EmitContext&) {
|
|
throw NotImplementedException("GLSL Instruction");
|
|
}
|
|
|
|
void EmitBoundImageSampleDrefExplicitLod(EmitContext&) {
|
|
throw NotImplementedException("GLSL Instruction");
|
|
}
|
|
|
|
void EmitBoundImageGather(EmitContext&) {
|
|
throw NotImplementedException("GLSL Instruction");
|
|
}
|
|
|
|
void EmitBoundImageGatherDref(EmitContext&) {
|
|
throw NotImplementedException("GLSL Instruction");
|
|
}
|
|
|
|
void EmitBoundImageFetch(EmitContext&) {
|
|
throw NotImplementedException("GLSL Instruction");
|
|
}
|
|
|
|
void EmitBoundImageQueryDimensions(EmitContext&) {
|
|
throw NotImplementedException("GLSL Instruction");
|
|
}
|
|
|
|
void EmitBoundImageQueryLod(EmitContext&) {
|
|
throw NotImplementedException("GLSL Instruction");
|
|
}
|
|
|
|
void EmitBoundImageGradient(EmitContext&) {
|
|
throw NotImplementedException("GLSL Instruction");
|
|
}
|
|
|
|
void EmitBoundImageRead(EmitContext&) {
|
|
throw NotImplementedException("GLSL Instruction");
|
|
}
|
|
|
|
void EmitBoundImageWrite(EmitContext&) {
|
|
throw NotImplementedException("GLSL Instruction");
|
|
}
|
|
|
|
} // namespace Shader::Backend::GLSL
|