| // Copyright 2022 The Dawn & Tint Authors |
| // |
| // Redistribution and use in source and binary forms, with or without |
| // modification, are permitted provided that the following conditions are met: |
| // |
| // 1. Redistributions of source code must retain the above copyright notice, this |
| // list of conditions and the following disclaimer. |
| // |
| // 2. Redistributions in binary form must reproduce the above copyright notice, |
| // this list of conditions and the following disclaimer in the documentation |
| // and/or other materials provided with the distribution. |
| // |
| // 3. Neither the name of the copyright holder nor the names of its |
| // contributors may be used to endorse or promote products derived from |
| // this software without specific prior written permission. |
| // |
| // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" |
| // AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
| // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
| // DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE |
| // FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL |
| // DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR |
| // SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER |
| // CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, |
| // OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
| // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| |
| #include "src/tint/lang/glsl/writer/ast_raise/combine_samplers.h" |
| |
| #include <string> |
| #include <unordered_map> |
| #include <utility> |
| #include <vector> |
| |
| #include "src/tint/lang/wgsl/program/clone_context.h" |
| #include "src/tint/lang/wgsl/program/program_builder.h" |
| #include "src/tint/lang/wgsl/resolver/resolve.h" |
| #include "src/tint/lang/wgsl/sem/function.h" |
| #include "src/tint/lang/wgsl/sem/statement.h" |
| |
| #include "src/tint/utils/containers/map.h" |
| |
| TINT_INSTANTIATE_TYPEINFO(tint::glsl::writer::CombineSamplers); |
| TINT_INSTANTIATE_TYPEINFO(tint::glsl::writer::CombineSamplers::BindingInfo); |
| |
| namespace { |
| |
| bool IsGlobal(const tint::sem::VariablePair& pair) { |
| return (!pair.first || tint::Is<tint::sem::GlobalVariable>(pair.first)) && |
| (!pair.second || tint::Is<tint::sem::GlobalVariable>(pair.second)); |
| } |
| |
| } // namespace |
| |
| namespace tint::glsl::writer { |
| |
| using namespace tint::core::number_suffixes; // NOLINT |
| |
| CombineSamplers::BindingInfo::BindingInfo(const BindingMap& map, const BindingPoint& placeholder) |
| : binding_map(map), placeholder_binding_point(placeholder) {} |
| CombineSamplers::BindingInfo::BindingInfo(const BindingInfo& other) = default; |
| CombineSamplers::BindingInfo::~BindingInfo() = default; |
| |
| /// PIMPL state for the transform |
| struct CombineSamplers::State { |
| /// The source program |
| const Program& src; |
| /// The target program builder |
| ProgramBuilder b; |
| /// The clone context |
| program::CloneContext ctx = {&b, &src, /* auto_clone_symbols */ true}; |
| |
| /// The binding info |
| const BindingInfo* binding_info; |
| |
| /// Map from a texture/sampler pair to the corresponding combined sampler |
| /// variable |
| using CombinedTextureSamplerMap = std::unordered_map<sem::VariablePair, const ast::Variable*>; |
| |
| /// A map of all global texture/sampler variable pairs to the global |
| /// combined sampler variable that will replace it. |
| CombinedTextureSamplerMap global_combined_texture_samplers_; |
| |
| /// A map of all texture/sampler variable pairs that contain a function |
| /// parameter to the combined sampler function paramter that will replace it. |
| std::unordered_map<const sem::Function*, CombinedTextureSamplerMap> |
| function_combined_texture_samplers_; |
| |
| /// Placeholder global samplers used when a function contains texture-only |
| /// references (one comparison sampler, one regular). These are also used as |
| /// temporary sampler parameters to the texture builtins to satisfy the WGSL |
| /// resolver, but are then ignored and removed by the GLSL writer. |
| const ast::Variable* placeholder_samplers_[2] = {}; |
| |
| /// Group and binding attributes used by all combined sampler globals. |
| /// Group 0 and binding 0 are used, with collisions disabled. |
| /// @returns the newly-created attribute list |
| auto Attributes() const { |
| Vector<const ast::Attribute*, 3> attributes{ctx.dst->Group(0_a), ctx.dst->Binding(0_a)}; |
| attributes.Push(ctx.dst->Disable(ast::DisabledValidation::kBindingPointCollision)); |
| return attributes; |
| } |
| |
| /// Constructor |
| /// @param program the source program |
| /// @param info the binding map information |
| State(const Program& program, const BindingInfo* info) : src(program), binding_info(info) {} |
| |
| /// Creates a combined sampler global variables. |
| /// (Note this is actually a Texture node at the AST level, but it will be |
| /// written as the corresponding sampler (eg., sampler2D) on GLSL output.) |
| /// @param texture_var the texture (global) variable |
| /// @param sampler_var the sampler (global) variable |
| /// @param name the default name to use (may be overridden by map lookup) |
| /// @returns the newly-created global variable |
| const ast::Variable* CreateCombinedGlobal(const sem::Variable* texture_var, |
| const sem::Variable* sampler_var, |
| std::string name) { |
| SamplerTexturePair bp_pair; |
| bp_pair.texture_binding_point = |
| texture_var ? *texture_var->As<sem::GlobalVariable>()->Attributes().binding_point |
| : binding_info->placeholder_binding_point; |
| bp_pair.sampler_binding_point = |
| sampler_var ? *sampler_var->As<sem::GlobalVariable>()->Attributes().binding_point |
| : binding_info->placeholder_binding_point; |
| auto it = binding_info->binding_map.find(bp_pair); |
| if (it != binding_info->binding_map.end()) { |
| name = it->second; |
| } |
| ast::Type type = CreateCombinedASTTypeFor(texture_var, sampler_var); |
| Symbol symbol = ctx.dst->Symbols().New(name); |
| return ctx.dst->GlobalVar(symbol, type, Attributes()); |
| } |
| |
| /// Creates placeholder global sampler variables. |
| /// @param kind the sampler kind to create for |
| /// @returns the newly-created global variable |
| const ast::Variable* CreatePlaceholder(core::type::SamplerKind kind) { |
| ast::Type type = ctx.dst->ty.sampler(kind); |
| const char* name = kind == core::type::SamplerKind::kComparisonSampler |
| ? "placeholder_comparison_sampler" |
| : "placeholder_sampler"; |
| Symbol symbol = ctx.dst->Symbols().New(name); |
| return ctx.dst->GlobalVar(symbol, type, Attributes()); |
| } |
| |
| /// Creates Identifier for a given texture and sampler variable pair. |
| /// Depth textures with no samplers are turned into the corresponding |
| /// f32 texture (e.g., texture_depth_2d -> texture_2d<f32>). |
| /// Either texture or sampler could be nullptr, but cannot be nullptr at the same time. |
| /// The texture can only be nullptr, when the sampler is a dangling function parameter. |
| /// @param texture the texture variable of interest |
| /// @param sampler the texture variable of interest |
| /// @returns the newly-created type |
| ast::Type CreateCombinedASTTypeFor(const sem::Variable* texture, const sem::Variable* sampler) { |
| if (texture) { |
| const core::type::Type* texture_type = texture->Type()->UnwrapRef(); |
| const core::type::DepthTexture* depth = texture_type->As<core::type::DepthTexture>(); |
| if (depth && !sampler) { |
| return ctx.dst->ty.sampled_texture(depth->dim(), ctx.dst->ty.f32()); |
| } else { |
| return CreateASTTypeFor(ctx, texture_type); |
| } |
| } else { |
| TINT_ASSERT(sampler != nullptr); |
| const core::type::Type* sampler_type = sampler->Type()->UnwrapRef(); |
| return CreateASTTypeFor(ctx, sampler_type); |
| } |
| } |
| |
| /// Insert a new texture/sampler pair into the combined samplers maps (global or local, as |
| /// appropriate). If local, also add a function parameter to "params". |
| /// @param pair the texture/sampler pair to insert |
| /// @param fn the function scope in which to insert (if local) |
| /// @param params the calling function's parameter list to modify (if local) |
| void InsertPair(sem::VariablePair pair, |
| const sem::Function* fn, |
| tint::Vector<const ast::Parameter*, 8>* params) { |
| const sem::Variable* texture_var = pair.first; |
| const sem::Variable* sampler_var = pair.second; |
| std::string name = ""; |
| if (texture_var) { |
| name = texture_var->Declaration()->name->symbol.Name(); |
| } |
| if (sampler_var) { |
| if (!name.empty()) { |
| name += "_"; |
| } |
| name += sampler_var->Declaration()->name->symbol.Name(); |
| } |
| if (IsGlobal(pair)) { |
| // Both texture and sampler are global; add a new global variable |
| // to represent the combined sampler (if not already created). |
| GetOrCreate(global_combined_texture_samplers_, pair, |
| [&] { return CreateCombinedGlobal(texture_var, sampler_var, name); }); |
| } else { |
| // Either texture or sampler (or both) is a function parameter; |
| // add a new function parameter to represent the combined sampler. |
| ast::Type type = CreateCombinedASTTypeFor(texture_var, sampler_var); |
| auto* var = ctx.dst->Param(ctx.dst->Symbols().New(name), type); |
| params->Push(var); |
| function_combined_texture_samplers_[fn][pair] = var; |
| } |
| } |
| |
| /// For a given texture, find any texture/sampler pair with a non-null sampler in the given |
| /// function scope. |
| /// @param texture_var the texture variable of interest |
| /// @param fn the function scope in which to search |
| /// @returns the full pair, if found |
| const sem::VariablePair* FindFullTextureSamplerPair(const sem::Variable* texture_var, |
| const sem::Function* fn) { |
| for (auto pairIter = fn->TextureSamplerPairs().begin(); |
| pairIter != fn->TextureSamplerPairs().end(); pairIter++) { |
| if (pairIter->first == texture_var && pairIter->second) { |
| return pairIter; |
| } |
| } |
| return nullptr; |
| } |
| |
| /// Runs the transform |
| /// @returns the new program or SkipTransform if the transform is not required |
| ApplyResult Run() { |
| auto& sem = ctx.src->Sem(); |
| |
| // Remove all texture and sampler global variables. These will be replaced |
| // by combined samplers. |
| for (auto* global : ctx.src->AST().GlobalVariables()) { |
| auto* global_sem = sem.Get(global)->As<sem::GlobalVariable>(); |
| auto* type = ctx.src->TypeOf(global->type); |
| if (tint::IsAnyOf<core::type::Texture, core::type::Sampler>(type) && |
| !type->Is<core::type::StorageTexture>()) { |
| ctx.Remove(ctx.src->AST().GlobalDeclarations(), global); |
| } else if (auto binding_point = global_sem->Attributes().binding_point) { |
| if (binding_point->group == 0 && binding_point->binding == 0) { |
| auto* attribute = |
| ctx.dst->Disable(ast::DisabledValidation::kBindingPointCollision); |
| ctx.InsertFront(global->attributes, attribute); |
| } |
| } |
| } |
| |
| // Rewrite all function signatures to use combined samplers, and remove |
| // separate textures & samplers. Create new combined globals where found. |
| ctx.ReplaceAll([&](const ast::Function* ast_fn) -> const ast::Function* { |
| if (auto* fn = sem.Get(ast_fn)) { |
| auto pairs = fn->TextureSamplerPairs(); |
| if (pairs.IsEmpty()) { |
| return nullptr; |
| } |
| Vector<const ast::Parameter*, 8> params; |
| for (auto pair : fn->TextureSamplerPairs()) { |
| if (!pair.second) { |
| continue; |
| } |
| InsertPair(pair, fn, ¶ms); |
| } |
| for (auto pair : fn->TextureSamplerPairs()) { |
| if (pair.second) { |
| continue; |
| } |
| // Look for another pair with a non-null sampler. |
| // NOTE: this is O(N^2) in the number of pairs, since |
| // FindFullTextureSamplerPair() also loops over all pairs. If this proves |
| // problematic, it could be optimized. |
| if (const sem::VariablePair* fullPair = |
| FindFullTextureSamplerPair(pair.first, fn)) { |
| if (IsGlobal(pair)) { |
| global_combined_texture_samplers_[pair] = |
| global_combined_texture_samplers_[*fullPair]; |
| } else { |
| auto* var = function_combined_texture_samplers_[fn][*fullPair]; |
| function_combined_texture_samplers_[fn][pair] = var; |
| } |
| } else { |
| InsertPair(pair, fn, ¶ms); |
| } |
| } |
| // Filter out separate textures and samplers from the original |
| // function signature. |
| for (auto* param : fn->Parameters()) { |
| if (!param->Type()->IsAnyOf<core::type::Texture, core::type::Sampler>()) { |
| params.Push(ctx.Clone(param->Declaration())); |
| } |
| } |
| // Create a new function signature that differs only in the parameter |
| // list. |
| auto name = ctx.Clone(ast_fn->name); |
| auto return_type = ctx.Clone(ast_fn->return_type); |
| auto* body = ctx.Clone(ast_fn->body); |
| auto attributes = ctx.Clone(ast_fn->attributes); |
| auto return_type_attributes = ctx.Clone(ast_fn->return_type_attributes); |
| return ctx.dst->create<ast::Function>(name, params, return_type, body, |
| std::move(attributes), |
| std::move(return_type_attributes)); |
| } |
| return nullptr; |
| }); |
| |
| // Replace all function call expressions containing texture or |
| // sampler parameters to use the current function's combined samplers or |
| // the combined global samplers, as appropriate. |
| ctx.ReplaceAll([&](const ast::CallExpression* expr) -> const ast::Expression* { |
| if (auto* call = sem.Get(expr)->UnwrapMaterialize()->As<sem::Call>()) { |
| Vector<const ast::Expression*, 8> args; |
| // Replace all texture builtin calls. |
| if (auto* builtin = call->Target()->As<sem::BuiltinFn>()) { |
| const auto& signature = builtin->Signature(); |
| auto sampler_index = signature.IndexOf(core::ParameterUsage::kSampler); |
| auto texture_index = signature.IndexOf(core::ParameterUsage::kTexture); |
| if (texture_index == -1) { |
| return nullptr; |
| } |
| const sem::ValueExpression* texture = |
| call->Arguments()[static_cast<size_t>(texture_index)]; |
| // We don't want to combine storage textures with anything, since |
| // they never have associated samplers in GLSL. |
| if (texture->Type()->UnwrapRef()->Is<core::type::StorageTexture>()) { |
| return nullptr; |
| } |
| const sem::ValueExpression* sampler = |
| sampler_index != -1 ? call->Arguments()[static_cast<size_t>(sampler_index)] |
| : nullptr; |
| auto* texture_var = texture->UnwrapLoad()->As<sem::VariableUser>()->Variable(); |
| auto* sampler_var = |
| sampler ? sampler->UnwrapLoad()->As<sem::VariableUser>()->Variable() |
| : nullptr; |
| sem::VariablePair new_pair(texture_var, sampler_var); |
| for (auto* arg : expr->args) { |
| auto* type = ctx.src->TypeOf(arg)->UnwrapRef(); |
| if (type->Is<core::type::Texture>()) { |
| const ast::Variable* var = |
| IsGlobal(new_pair) |
| ? global_combined_texture_samplers_[new_pair] |
| : function_combined_texture_samplers_[call->Stmt()->Function()] |
| [new_pair]; |
| args.Push(ctx.dst->Expr(var->name->symbol)); |
| } else if (auto* sampler_type = type->As<core::type::Sampler>()) { |
| core::type::SamplerKind kind = sampler_type->kind(); |
| int index = (kind == core::type::SamplerKind::kSampler) ? 0 : 1; |
| const ast::Variable*& p = placeholder_samplers_[index]; |
| if (!p) { |
| p = CreatePlaceholder(kind); |
| } |
| args.Push(ctx.dst->Expr(p->name->symbol)); |
| } else { |
| args.Push(ctx.Clone(arg)); |
| } |
| } |
| const ast::Expression* value = ctx.dst->Call(ctx.Clone(expr->target), args); |
| if (builtin->Fn() == wgsl::BuiltinFn::kTextureLoad && |
| texture_var->Type()->UnwrapRef()->Is<core::type::DepthTexture>() && |
| !call->Stmt()->Declaration()->Is<ast::CallStatement>()) { |
| value = ctx.dst->MemberAccessor(value, "x"); |
| } |
| return value; |
| } |
| // Replace all function calls. |
| if (auto* callee = call->Target()->As<sem::Function>()) { |
| auto make_arg = [&](const sem::Variable* texture_var, |
| const sem::Variable* sampler_var) { |
| if (auto* param = tint::As<sem::Parameter>(texture_var)) { |
| const sem::ValueExpression* texture = call->Arguments()[param->Index()]; |
| texture_var = |
| texture->UnwrapLoad()->As<sem::VariableUser>()->Variable(); |
| } |
| if (auto* param = tint::As<sem::Parameter>(sampler_var)) { |
| const sem::ValueExpression* sampler = call->Arguments()[param->Index()]; |
| sampler_var = |
| sampler->UnwrapLoad()->As<sem::VariableUser>()->Variable(); |
| } |
| sem::VariablePair new_pair(texture_var, sampler_var); |
| // If both texture and sampler are (now) global, pass that |
| // global variable to the callee. Otherwise use the caller's |
| // function parameter for this pair. |
| const ast::Variable* var = |
| IsGlobal(new_pair) |
| ? global_combined_texture_samplers_[new_pair] |
| : function_combined_texture_samplers_[call->Stmt()->Function()] |
| [new_pair]; |
| return ctx.dst->Expr(var->name->symbol); |
| }; |
| |
| for (auto pair : callee->TextureSamplerPairs()) { |
| if (!pair.second) { |
| continue; |
| } |
| // Global pairs used by the callee do not require a function |
| // parameter at the call site. |
| if (IsGlobal(pair)) { |
| continue; |
| } |
| |
| args.Push(make_arg(pair.first, pair.second)); |
| } |
| for (auto pair : callee->TextureSamplerPairs()) { |
| if (pair.second) { |
| continue; |
| } |
| // Global pairs used by the callee do not require a function |
| // parameter at the call site. |
| if (IsGlobal(pair)) { |
| continue; |
| } |
| // Texture-only pairs do not require a function parameter if they've been |
| // replaced by a real pair. |
| if (FindFullTextureSamplerPair(pair.first, callee)) { |
| continue; |
| } |
| |
| args.Push(make_arg(pair.first, nullptr)); |
| } |
| // Append all of the remaining non-texture and non-sampler |
| // parameters. |
| for (auto* arg : expr->args) { |
| if (!ctx.src->TypeOf(arg) |
| ->UnwrapRef() |
| ->IsAnyOf<core::type::Texture, core::type::Sampler>()) { |
| args.Push(ctx.Clone(arg)); |
| } |
| } |
| return ctx.dst->Call(ctx.Clone(expr->target), args); |
| } |
| } |
| return nullptr; |
| }); |
| |
| ctx.Clone(); |
| return resolver::Resolve(b); |
| } |
| }; |
| |
| CombineSamplers::CombineSamplers() = default; |
| |
| CombineSamplers::~CombineSamplers() = default; |
| |
| ast::transform::Transform::ApplyResult CombineSamplers::Apply(const Program& src, |
| const ast::transform::DataMap& inputs, |
| ast::transform::DataMap&) const { |
| auto* binding_info = inputs.Get<BindingInfo>(); |
| if (!binding_info) { |
| ProgramBuilder b; |
| b.Diagnostics().add_error(diag::System::Transform, |
| "missing transform data for " + std::string(TypeInfo().name)); |
| return resolver::Resolve(b); |
| } |
| |
| return State(src, binding_info).Run(); |
| } |
| |
| } // namespace tint::glsl::writer |