| // Copyright 2017 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 "dawn/native/opengl/ShaderModuleGL.h" | |
| #include <sstream> | |
| #include <unordered_map> | |
| #include <utility> | |
| #include "absl/container/flat_hash_map.h" | |
| #include "dawn/common/MatchVariant.h" | |
| #include "dawn/native/Adapter.h" | |
| #include "dawn/native/BindGroupLayoutInternal.h" | |
| #include "dawn/native/CacheRequest.h" | |
| #include "dawn/native/Pipeline.h" | |
| #include "dawn/native/TintUtils.h" | |
| #include "dawn/native/opengl/BindGroupLayoutGL.h" | |
| #include "dawn/native/opengl/BindingPoint.h" | |
| #include "dawn/native/opengl/DeviceGL.h" | |
| #include "dawn/native/opengl/PipelineLayoutGL.h" | |
| #include "dawn/native/opengl/UtilsGL.h" | |
| #include "dawn/platform/DawnPlatform.h" | |
| #include "dawn/platform/tracing/TraceEvent.h" | |
| #include "src/tint/api/common/binding_point.h" | |
| namespace dawn::native { | |
| namespace { | |
| GLenum GLShaderType(SingleShaderStage stage) { | |
| switch (stage) { | |
| case SingleShaderStage::Vertex: | |
| return GL_VERTEX_SHADER; | |
| case SingleShaderStage::Fragment: | |
| return GL_FRAGMENT_SHADER; | |
| case SingleShaderStage::Compute: | |
| return GL_COMPUTE_SHADER; | |
| } | |
| DAWN_UNREACHABLE(); | |
| } | |
| tint::glsl::writer::Version::Standard ToTintGLStandard(opengl::OpenGLVersion::Standard standard) { | |
| switch (standard) { | |
| case opengl::OpenGLVersion::Standard::Desktop: | |
| return tint::glsl::writer::Version::Standard::kDesktop; | |
| case opengl::OpenGLVersion::Standard::ES: | |
| return tint::glsl::writer::Version::Standard::kES; | |
| } | |
| DAWN_UNREACHABLE(); | |
| } | |
| using BindingMap = absl::flat_hash_map<tint::BindingPoint, tint::BindingPoint>; | |
| opengl::CombinedSampler* AppendCombinedSampler(opengl::CombinedSamplerInfo* info, | |
| tint::BindingPoint texture, | |
| tint::BindingPoint sampler, | |
| tint::BindingPoint placeholderBindingPoint) { | |
| info->emplace_back(); | |
| opengl::CombinedSampler* combinedSampler = &info->back(); | |
| combinedSampler->usePlaceholderSampler = sampler == placeholderBindingPoint; | |
| combinedSampler->samplerLocation.group = BindGroupIndex(sampler.group); | |
| combinedSampler->samplerLocation.binding = BindingNumber(sampler.binding); | |
| combinedSampler->textureLocation.group = BindGroupIndex(texture.group); | |
| combinedSampler->textureLocation.binding = BindingNumber(texture.binding); | |
| return combinedSampler; | |
| } | |
| using InterstageLocationAndName = std::pair<uint32_t, std::string>; | |
| using SubstituteOverrideConfig = std::unordered_map<tint::OverrideId, double>; | |
| #define GLSL_COMPILATION_REQUEST_MEMBERS(X) \ | |
| X(ShaderModuleBase::ShaderModuleHash, shaderModuleHash) \ | |
| X(CacheKey::UnsafeUnkeyedValue<ShaderModuleBase::ScopedUseTintProgram>, inputProgram) \ | |
| X(std::string, entryPointName) \ | |
| X(SingleShaderStage, stage) \ | |
| X(SubstituteOverrideConfig, substituteOverrideConfig) \ | |
| X(LimitsForCompilationRequest, limits) \ | |
| X(CacheKey::UnsafeUnkeyedValue<LimitsForCompilationRequest>, adapterSupportedLimits) \ | |
| X(bool, disableSymbolRenaming) \ | |
| X(std::vector<InterstageLocationAndName>, interstageVariables) \ | |
| X(tint::glsl::writer::Options, tintOptions) \ | |
| X(CacheKey::UnsafeUnkeyedValue<dawn::platform::Platform*>, platform) | |
| DAWN_MAKE_CACHE_REQUEST(GLSLCompilationRequest, GLSL_COMPILATION_REQUEST_MEMBERS); | |
| #undef GLSL_COMPILATION_REQUEST_MEMBERS | |
| #define GLSL_COMPILATION_MEMBERS(X) X(std::string, glsl) | |
| // clang-format off | |
| DAWN_SERIALIZABLE(struct, GLSLCompilation, GLSL_COMPILATION_MEMBERS) { | |
| static ResultOrError<GLSLCompilation> FromValidatedBlob(Blob blob) { | |
| GLSLCompilation result; | |
| DAWN_TRY_ASSIGN(result, FromBlob(std::move(blob))); | |
| DAWN_INVALID_IF(result.glsl.empty(), "Cached GLSLCompilation result has no GLSL"); | |
| return result; | |
| } | |
| }; | |
| // clang-format on | |
| #undef GLSL_COMPILATION_MEMBERS | |
| } // namespace | |
| } // namespace dawn::native | |
| namespace dawn::native::opengl { | |
| namespace { | |
| // Find all the sampler/texture pairs for this entry point, and create CombinedSamplers for them. | |
| // CombinedSampler records the binding points of the original texture and sampler, and generates a | |
| // unique name. The corresponding uniforms will be retrieved by these generated names in PipelineGL. | |
| // Any texture-only references will have "usePlaceholderSampler" set to true, and only the texture | |
| // binding point will be used in naming them. In addition, Dawn will bind a non-filtering sampler | |
| // for them (see PipelineGL). | |
| CombinedSamplerInfo GenerateCombinedSamplerInfo(const EntryPointMetadata& metadata, | |
| tint::glsl::writer::Bindings& bindings, | |
| BindingMap externalTextureExpansionMap, | |
| bool* needsPlaceholderSampler | |
| ) { | |
| auto samplerAndNonSamplerTextureUses = metadata.samplerAndNonSamplerTexturePairs; | |
| CombinedSamplerInfo combinedSamplerInfo; | |
| for (const auto& use : samplerAndNonSamplerTextureUses) { | |
| // Convert BindingSlot in metadata back to tint::BindingPoint | |
| tint::BindingPoint samplerBindPoint = | |
| use.sampler == EntryPointMetadata::nonSamplerBindingPoint | |
| ? bindings.placeholder_sampler_bind_point | |
| : ToTint(use.sampler); | |
| tint::BindingPoint texBindPoint = ToTint(use.texture); | |
| CombinedSampler* info = | |
| AppendCombinedSampler(&combinedSamplerInfo, ToTint(use.texture), | |
| use.sampler == EntryPointMetadata::nonSamplerBindingPoint | |
| ? bindings.placeholder_sampler_bind_point | |
| : ToTint(use.sampler), | |
| bindings.placeholder_sampler_bind_point); | |
| if (info->usePlaceholderSampler) { | |
| *needsPlaceholderSampler = true; | |
| } | |
| // Note, the rest of Dawn is expecting to use the un-modified WGSL binding points when | |
| // looking up information on the combined samplers. Tint is expecting Dawn to provide | |
| // the final expected values for those entry points. So, we end up using the original | |
| // values for the AppendCombinedSampler calls and the remapped binding points when we | |
| // put things in the tint bindings structure. | |
| { | |
| auto texIt = bindings.texture.find(texBindPoint); | |
| if (texIt != bindings.texture.end()) { | |
| texBindPoint.group = 0; | |
| texBindPoint.binding = texIt->second.binding; | |
| } else { | |
| // The plane0 texture will be in external_textures, not textures, so we have to set | |
| // the `sampler_texture_to_name` based on the external_texture value. | |
| auto exIt = bindings.external_texture.find(texBindPoint); | |
| if (exIt != bindings.external_texture.end()) { | |
| texBindPoint.group = 0; | |
| texBindPoint.binding = exIt->second.plane0.binding; | |
| } | |
| } | |
| } | |
| { | |
| auto it = bindings.sampler.find(samplerBindPoint); | |
| if (it != bindings.sampler.end()) { | |
| samplerBindPoint.group = 0; | |
| samplerBindPoint.binding = it->second.binding; | |
| } | |
| } | |
| bindings.sampler_texture_to_name.emplace( | |
| tint::glsl::writer::binding::CombinedTextureSamplerPair{texBindPoint, samplerBindPoint, | |
| false}, | |
| info->GetName()); | |
| // If the texture has an associated plane1 texture (ie., it's an external texture), | |
| // append a new combined sampler with the same sampler and the plane1 texture. | |
| auto it = externalTextureExpansionMap.find(ToTint(use.texture)); | |
| if (it != externalTextureExpansionMap.end()) { | |
| CombinedSampler* plane1Info = | |
| AppendCombinedSampler(&combinedSamplerInfo, it->second, | |
| use.sampler == EntryPointMetadata::nonSamplerBindingPoint | |
| ? bindings.placeholder_sampler_bind_point | |
| : ToTint(use.sampler), | |
| bindings.placeholder_sampler_bind_point); | |
| tint::BindingPoint plane1TexBindPoint = it->second; | |
| auto dstIt = bindings.external_texture.find(ToTint(use.texture)); | |
| if (dstIt != bindings.external_texture.end()) { | |
| plane1TexBindPoint.group = 0; | |
| plane1TexBindPoint.binding = dstIt->second.plane1.binding; | |
| } | |
| bindings.sampler_texture_to_name.emplace( | |
| tint::glsl::writer::binding::CombinedTextureSamplerPair{plane1TexBindPoint, | |
| samplerBindPoint, true}, | |
| plane1Info->GetName()); | |
| } | |
| } | |
| return combinedSamplerInfo; | |
| } | |
| bool GenerateTextureBuiltinFromUniformData(const EntryPointMetadata& metadata, | |
| const PipelineLayout* layout, | |
| BindingPointToFunctionAndOffset* bindingPointToData, | |
| tint::glsl::writer::Bindings& bindings) { | |
| auto textureBuiltinsFromUniformData = metadata.textureQueries; | |
| if (textureBuiltinsFromUniformData.empty()) { | |
| return false; | |
| } | |
| for (size_t i = 0; i < textureBuiltinsFromUniformData.size(); ++i) { | |
| const auto& info = textureBuiltinsFromUniformData[i]; | |
| // This is the unmodified binding point from the WGSL shader. | |
| tint::BindingPoint srcBindingPoint{info.group, info.binding}; | |
| bindings.texture_builtins_from_uniform.ubo_bindingpoint_ordering.emplace_back( | |
| srcBindingPoint); | |
| // The remapped binding point is inserted into the Dawn data structure. | |
| const BindGroupLayoutInternalBase* bgl = | |
| layout->GetBindGroupLayout(BindGroupIndex{info.group}); | |
| tint::BindingPoint dstBindingPoint = tint::BindingPoint{ | |
| info.group, static_cast<uint32_t>(bgl->GetBindingIndex(BindingNumber{info.binding}))}; | |
| BindPointFunction type = BindPointFunction::kTextureNumLevels; | |
| switch (info.type) { | |
| case EntryPointMetadata::TextureMetadataQuery::TextureQueryType::TextureNumLevels: | |
| type = BindPointFunction::kTextureNumLevels; | |
| break; | |
| case EntryPointMetadata::TextureMetadataQuery::TextureQueryType::TextureNumSamples: | |
| type = BindPointFunction::kTextureNumSamples; | |
| break; | |
| } | |
| // Note, the `sizeof(uint32_t)` has to match up with the data type created by the | |
| // `TextureBuiltinsFromUniform` when it creates the UBO structure. | |
| bindingPointToData->emplace(dstBindingPoint, | |
| std::pair{type, static_cast<uint32_t>(i * sizeof(uint32_t))}); | |
| } | |
| return true; | |
| } | |
| bool GenerateArrayLengthFromuniformData(const BindingInfoArray& moduleBindingInfo, | |
| const PipelineLayout* layout, | |
| tint::glsl::writer::Bindings& bindings) { | |
| const PipelineLayout::BindingIndexInfo& indexInfo = layout->GetBindingIndexInfo(); | |
| for (BindGroupIndex group : layout->GetBindGroupLayoutsMask()) { | |
| const BindGroupLayoutInternalBase* bgl = layout->GetBindGroupLayout(group); | |
| for (const auto& [binding, shaderBindingInfo] : moduleBindingInfo[group]) { | |
| BindingIndex bindingIndex = bgl->GetBindingIndex(binding); | |
| const BindingInfo& bindingInfo = bgl->GetBindingInfo(bindingIndex); | |
| // TODO(crbug.com/408010433): capturing binding directly in lambda is C++20 | |
| // extension in cmake | |
| uint32_t capturedBindingNumber = static_cast<uint32_t>(binding); | |
| MatchVariant( | |
| bindingInfo.bindingLayout, | |
| [&](const BufferBindingInfo& bufferBinding) { | |
| switch (bufferBinding.type) { | |
| case wgpu::BufferBindingType::Storage: | |
| case kInternalStorageBufferBinding: | |
| case wgpu::BufferBindingType::ReadOnlyStorage: | |
| case kInternalReadOnlyStorageBufferBinding: { | |
| // Use ssbo index as the indices for the buffer size lookups | |
| // in the array length from uniform transform. | |
| tint::BindingPoint srcBindingPoint = {static_cast<uint32_t>(group), | |
| capturedBindingNumber}; | |
| uint32_t ssboIndex = indexInfo[group][bindingIndex]; | |
| bindings.array_length_from_uniform.bindpoint_to_size_index.emplace( | |
| srcBindingPoint, ssboIndex); | |
| break; | |
| } | |
| default: | |
| break; | |
| } | |
| }, | |
| [](const StaticSamplerBindingInfo&) {}, [](const SamplerBindingInfo&) {}, | |
| [](const TextureBindingInfo&) {}, [](const StorageTextureBindingInfo&) {}, | |
| [](const InputAttachmentBindingInfo&) {}); | |
| } | |
| } | |
| return bindings.array_length_from_uniform.bindpoint_to_size_index.size() > 0; | |
| } | |
| } // namespace | |
| std::string GetBindingName(BindGroupIndex group, BindingNumber bindingNumber) { | |
| std::ostringstream o; | |
| o << "dawn_binding_" << static_cast<uint32_t>(group) << "_" | |
| << static_cast<uint32_t>(bindingNumber); | |
| return o.str(); | |
| } | |
| bool operator<(const BindingLocation& a, const BindingLocation& b) { | |
| return std::tie(a.group, a.binding) < std::tie(b.group, b.binding); | |
| } | |
| bool operator<(const CombinedSampler& a, const CombinedSampler& b) { | |
| return std::tie(a.usePlaceholderSampler, a.samplerLocation, a.textureLocation) < | |
| std::tie(b.usePlaceholderSampler, a.samplerLocation, b.textureLocation); | |
| } | |
| std::string CombinedSampler::GetName() const { | |
| std::ostringstream o; | |
| o << "dawn_combined"; | |
| if (usePlaceholderSampler) { | |
| o << "_placeholder_sampler"; | |
| } else { | |
| o << "_" << static_cast<uint32_t>(samplerLocation.group) << "_" | |
| << static_cast<uint32_t>(samplerLocation.binding); | |
| } | |
| o << "_with_" << static_cast<uint32_t>(textureLocation.group) << "_" | |
| << static_cast<uint32_t>(textureLocation.binding); | |
| return o.str(); | |
| } | |
| // static | |
| ResultOrError<Ref<ShaderModule>> ShaderModule::Create( | |
| Device* device, | |
| const UnpackedPtr<ShaderModuleDescriptor>& descriptor, | |
| const std::vector<tint::wgsl::Extension>& internalExtensions, | |
| ShaderModuleParseResult* parseResult, | |
| std::unique_ptr<OwnedCompilationMessages>* compilationMessages) { | |
| Ref<ShaderModule> module = AcquireRef(new ShaderModule(device, descriptor, internalExtensions)); | |
| DAWN_TRY(module->Initialize(parseResult, compilationMessages)); | |
| return module; | |
| } | |
| ShaderModule::ShaderModule(Device* device, | |
| const UnpackedPtr<ShaderModuleDescriptor>& descriptor, | |
| std::vector<tint::wgsl::Extension> internalExtensions) | |
| : ShaderModuleBase(device, descriptor, std::move(internalExtensions)) {} | |
| MaybeError ShaderModule::Initialize( | |
| ShaderModuleParseResult* parseResult, | |
| std::unique_ptr<OwnedCompilationMessages>* compilationMessages) { | |
| DAWN_TRY(InitializeBase(parseResult, compilationMessages)); | |
| return {}; | |
| } | |
| std::pair<tint::glsl::writer::Bindings, BindingMap> GenerateBindingInfo( | |
| SingleShaderStage stage, | |
| const PipelineLayout* layout, | |
| const BindingInfoArray& moduleBindingInfo, | |
| GLSLCompilationRequest& req) { | |
| // Because of the way the rest of the backend uses the binding information, we need to pass | |
| // through the original WGSL values in the combined shader map. That means, we need to store | |
| // that data for the external texture, otherwise it ends up getting lost. | |
| BindingMap externalTextureExpansionMap; | |
| tint::glsl::writer::Bindings bindings; | |
| for (BindGroupIndex group : layout->GetBindGroupLayoutsMask()) { | |
| const BindGroupLayout* bgl = ToBackend(layout->GetBindGroupLayout(group)); | |
| for (const auto& [binding, shaderBindingInfo] : moduleBindingInfo[group]) { | |
| tint::BindingPoint srcBindingPoint{static_cast<uint32_t>(group), | |
| static_cast<uint32_t>(binding)}; | |
| BindingIndex bindingIndex = bgl->GetBindingIndex(binding); | |
| auto& bindingIndexInfo = layout->GetBindingIndexInfo()[group]; | |
| uint32_t shaderIndex = bindingIndexInfo[bindingIndex]; | |
| tint::BindingPoint dstBindingPoint{0, shaderIndex}; | |
| auto* const bufferBindingInfo = | |
| std::get_if<BufferBindingInfo>(&shaderBindingInfo.bindingInfo); | |
| if (bufferBindingInfo) { | |
| switch (bufferBindingInfo->type) { | |
| case wgpu::BufferBindingType::Uniform: | |
| bindings.uniform.emplace( | |
| srcBindingPoint, | |
| tint::glsl::writer::binding::Uniform{dstBindingPoint.binding}); | |
| break; | |
| case kInternalStorageBufferBinding: | |
| case wgpu::BufferBindingType::Storage: | |
| case wgpu::BufferBindingType::ReadOnlyStorage: | |
| case kInternalReadOnlyStorageBufferBinding: | |
| bindings.storage.emplace( | |
| srcBindingPoint, | |
| tint::glsl::writer::binding::Storage{dstBindingPoint.binding}); | |
| break; | |
| case wgpu::BufferBindingType::BindingNotUsed: | |
| case wgpu::BufferBindingType::Undefined: | |
| DAWN_UNREACHABLE(); | |
| break; | |
| } | |
| } else if (std::holds_alternative<SamplerBindingInfo>(shaderBindingInfo.bindingInfo)) { | |
| bindings.sampler.emplace( | |
| srcBindingPoint, tint::glsl::writer::binding::Sampler{dstBindingPoint.binding}); | |
| } else if (std::holds_alternative<TextureBindingInfo>(shaderBindingInfo.bindingInfo)) { | |
| bindings.texture.emplace( | |
| srcBindingPoint, tint::glsl::writer::binding::Texture{dstBindingPoint.binding}); | |
| } else if (std::holds_alternative<StorageTextureBindingInfo>( | |
| shaderBindingInfo.bindingInfo)) { | |
| bindings.storage_texture.emplace( | |
| srcBindingPoint, | |
| tint::glsl::writer::binding::StorageTexture{dstBindingPoint.binding}); | |
| } else if (std::holds_alternative<ExternalTextureBindingInfo>( | |
| shaderBindingInfo.bindingInfo)) { | |
| const auto& etBindingMap = bgl->GetExternalTextureBindingExpansionMap(); | |
| const auto& expansion = etBindingMap.find(binding); | |
| DAWN_ASSERT(expansion != etBindingMap.end()); | |
| using BindingInfo = tint::glsl::writer::binding::BindingInfo; | |
| const auto& bindingExpansion = expansion->second; | |
| const BindingInfo plane0{ | |
| bindingIndexInfo[bgl->GetBindingIndex(bindingExpansion.plane0)]}; | |
| const BindingInfo plane1{ | |
| bindingIndexInfo[bgl->GetBindingIndex(bindingExpansion.plane1)]}; | |
| const BindingInfo metadata{ | |
| bindingIndexInfo[bgl->GetBindingIndex(bindingExpansion.params)]}; | |
| tint::BindingPoint plane1WGSLBindingPoint{ | |
| static_cast<uint32_t>(group), static_cast<uint32_t>(bindingExpansion.plane1)}; | |
| externalTextureExpansionMap[srcBindingPoint] = plane1WGSLBindingPoint; | |
| bindings.external_texture.emplace( | |
| srcBindingPoint, | |
| tint::glsl::writer::binding::ExternalTexture{metadata, plane0, plane1}); | |
| } | |
| } | |
| } | |
| return {bindings, externalTextureExpansionMap}; | |
| } | |
| ResultOrError<GLuint> ShaderModule::CompileShader( | |
| const OpenGLFunctions& gl, | |
| const ProgrammableStage& programmableStage, | |
| SingleShaderStage stage, | |
| bool usesVertexIndex, | |
| bool usesInstanceIndex, | |
| bool usesFragDepth, | |
| VertexAttributeMask bgraSwizzleAttributes, | |
| CombinedSamplerInfo* combinedSamplers, | |
| const PipelineLayout* layout, | |
| bool* needsPlaceholderSampler, | |
| BindingPointToFunctionAndOffset* bindingPointToTextureBuiltinData, | |
| bool* needsSSBOLengthUniformBuffer) { | |
| TRACE_EVENT0(GetDevice()->GetPlatform(), General, "TranslateToGLSL"); | |
| const OpenGLVersion& version = ToBackend(GetDevice())->GetGL().GetVersion(); | |
| GLSLCompilationRequest req = {}; | |
| req.shaderModuleHash = GetHash(); | |
| req.inputProgram = UseTintProgram(); | |
| // Since (non-Vulkan) GLSL does not support descriptor sets, generate a | |
| // mapping from the original group/binding pair to a binding-only | |
| // value. This mapping will be used by Tint to remap all global | |
| // variables to the 1D space. | |
| const EntryPointMetadata& entryPointMetaData = GetEntryPoint(programmableStage.entryPoint); | |
| const BindingInfoArray& moduleBindingInfo = entryPointMetaData.bindings; | |
| auto [bindings, externalTextureExpansionMap] = | |
| GenerateBindingInfo(stage, layout, moduleBindingInfo, req); | |
| // When textures are accessed without a sampler (e.g., textureLoad()), returned | |
| // CombinedSamplerInfo should use this sentinel value as sampler binding point. | |
| bindings.placeholder_sampler_bind_point = {static_cast<uint32_t>(kMaxBindGroupsTyped), 0}; | |
| CombinedSamplerInfo combinedSamplerInfo = GenerateCombinedSamplerInfo( | |
| entryPointMetaData, bindings, externalTextureExpansionMap, needsPlaceholderSampler); | |
| bool needsInternalUBO = GenerateTextureBuiltinFromUniformData( | |
| entryPointMetaData, layout, bindingPointToTextureBuiltinData, bindings); | |
| if (needsInternalUBO) { | |
| DAWN_ASSERT(!bindingPointToTextureBuiltinData->empty()); | |
| // Some texture builtin functions are unsupported on GLSL ES. These are emulated with | |
| // internal uniforms. | |
| bindings.texture_builtins_from_uniform.ubo_binding = {kMaxBindGroups + 1, 0}; | |
| // Remap the internal ubo binding as well. | |
| bindings.uniform.emplace(bindings.texture_builtins_from_uniform.ubo_binding, | |
| tint::glsl::writer::binding::Uniform{ | |
| layout->GetInternalTextureBuiltinsUniformBinding()}); | |
| } | |
| req.stage = stage; | |
| req.entryPointName = programmableStage.entryPoint; | |
| req.substituteOverrideConfig = BuildSubstituteOverridesTransformConfig(programmableStage); | |
| req.limits = LimitsForCompilationRequest::Create(GetDevice()->GetLimits().v1); | |
| req.adapterSupportedLimits = | |
| LimitsForCompilationRequest::Create(GetDevice()->GetAdapter()->GetLimits().v1); | |
| if (GetDevice()->IsToggleEnabled(Toggle::GLUseArrayLengthFromUniform)) { | |
| *needsSSBOLengthUniformBuffer = | |
| GenerateArrayLengthFromuniformData(moduleBindingInfo, layout, bindings); | |
| if (*needsSSBOLengthUniformBuffer) { | |
| req.tintOptions.use_array_length_from_uniform = true; | |
| bindings.array_length_from_uniform.ubo_binding = {kMaxBindGroups + 2, 0}; | |
| bindings.uniform.emplace(bindings.array_length_from_uniform.ubo_binding, | |
| tint::glsl::writer::binding::Uniform{ | |
| layout->GetInternalArrayLengthUniformBinding()}); | |
| } | |
| } | |
| req.platform = UnsafeUnkeyedValue(GetDevice()->GetPlatform()); | |
| req.tintOptions.version = tint::glsl::writer::Version(ToTintGLStandard(version.GetStandard()), | |
| version.GetMajor(), version.GetMinor()); | |
| req.tintOptions.disable_robustness = false; | |
| if (usesVertexIndex) { | |
| req.tintOptions.first_vertex_offset = 4 * PipelineLayout::ImmediateLocation::FirstVertex; | |
| } | |
| if (usesInstanceIndex) { | |
| req.tintOptions.first_instance_offset = | |
| 4 * PipelineLayout::ImmediateLocation::FirstInstance; | |
| } | |
| if (usesFragDepth) { | |
| req.tintOptions.depth_range_offsets = {4 * PipelineLayout::ImmediateLocation::MinDepth, | |
| 4 * PipelineLayout::ImmediateLocation::MaxDepth}; | |
| } | |
| if (stage == SingleShaderStage::Vertex) { | |
| for (VertexAttributeLocation i : bgraSwizzleAttributes) { | |
| req.tintOptions.bgra_swizzle_locations.insert(static_cast<uint8_t>(i)); | |
| } | |
| } | |
| req.tintOptions.strip_all_names = !GetDevice()->IsToggleEnabled(Toggle::DisableSymbolRenaming); | |
| req.interstageVariables = {}; | |
| for (size_t i = 0; i < entryPointMetaData.interStageVariables.size(); i++) { | |
| if (entryPointMetaData.usedInterStageVariables[i]) { | |
| req.interstageVariables.emplace_back(static_cast<uint32_t>(i), | |
| entryPointMetaData.interStageVariables[i].name); | |
| } | |
| } | |
| req.tintOptions.bindings = std::move(bindings); | |
| req.tintOptions.disable_polyfill_integer_div_mod = | |
| GetDevice()->IsToggleEnabled(Toggle::DisablePolyfillsOnIntegerDivisonAndModulo); | |
| req.tintOptions.enable_integer_range_analysis = | |
| GetDevice()->IsToggleEnabled(Toggle::EnableIntegerRangeAnalysisInRobustness); | |
| CacheResult<GLSLCompilation> compilationResult; | |
| DAWN_TRY_LOAD_OR_RUN( | |
| compilationResult, GetDevice(), std::move(req), GLSLCompilation::FromValidatedBlob, | |
| [](GLSLCompilationRequest r) -> ResultOrError<GLSLCompilation> { | |
| // Requires Tint Program here right before actual using. | |
| auto inputProgram = r.inputProgram.UnsafeGetValue()->GetTintProgram(); | |
| const tint::Program* tintInputProgram = &(inputProgram->program); | |
| // Convert the AST program to an IR module. | |
| tint::Result<tint::core::ir::Module> ir; | |
| { | |
| SCOPED_DAWN_HISTOGRAM_TIMER_MICROS(r.platform.UnsafeGetValue(), | |
| "ShaderModuleProgramToIR"); | |
| ir = tint::wgsl::reader::ProgramToLoweredIR(*tintInputProgram); | |
| DAWN_INVALID_IF(ir != tint::Success, | |
| "An error occurred while generating Tint IR\n%s", | |
| ir.Failure().reason); | |
| } | |
| { | |
| SCOPED_DAWN_HISTOGRAM_TIMER_MICROS(r.platform.UnsafeGetValue(), | |
| "ShaderModuleSingleEntryPoint"); | |
| auto singleEntryPointResult = | |
| tint::core::ir::transform::SingleEntryPoint(ir.Get(), r.entryPointName); | |
| DAWN_INVALID_IF(singleEntryPointResult != tint::Success, | |
| "Pipeline single entry point (IR) failed:\n%s", | |
| singleEntryPointResult.Failure().reason); | |
| } | |
| // this needs to run after SingleEntryPoint transform which removes unused | |
| // overrides for the current entry point. | |
| { | |
| SCOPED_DAWN_HISTOGRAM_TIMER_MICROS(r.platform.UnsafeGetValue(), | |
| "ShaderModuleSubstituteOverrides"); | |
| tint::core::ir::transform::SubstituteOverridesConfig cfg; | |
| cfg.map = std::move(r.substituteOverrideConfig); | |
| auto substituteOverridesResult = | |
| tint::core::ir::transform::SubstituteOverrides(ir.Get(), cfg); | |
| DAWN_INVALID_IF(substituteOverridesResult != tint::Success, | |
| "Pipeline override substitution (IR) failed:\n%s", | |
| substituteOverridesResult.Failure().reason); | |
| } | |
| tint::Result<tint::glsl::writer::Output> result; | |
| { | |
| SCOPED_DAWN_HISTOGRAM_TIMER_MICROS(r.platform.UnsafeGetValue(), | |
| "ShaderModuleGenerateGLSL"); | |
| // Generate GLSL from Tint IR. | |
| result = tint::glsl::writer::Generate(ir.Get(), r.tintOptions); | |
| DAWN_INVALID_IF(result != tint::Success, | |
| "An error occurred while generating GLSL:\n%s", | |
| result.Failure().reason); | |
| } | |
| // Workgroup validation has to come after `Generate` because it may require | |
| // overrides to have been substituted. | |
| if (r.stage == SingleShaderStage::Compute) { | |
| // Validate workgroup size after program runs transforms. | |
| Extent3D _; | |
| DAWN_TRY_ASSIGN(_, | |
| ValidateComputeStageWorkgroupSize( | |
| result->workgroup_info.x, result->workgroup_info.y, | |
| result->workgroup_info.z, result->workgroup_info.storage_size, | |
| /* usesSubgroupMatrix */ false, | |
| /* maxSubgroupSize, GL backend not support */ 0, r.limits, | |
| r.adapterSupportedLimits.UnsafeGetValue())); | |
| } | |
| return GLSLCompilation{{std::move(result->glsl)}}; | |
| }, | |
| "OpenGL.CompileShaderToGLSL"); | |
| if (GetDevice()->IsToggleEnabled(Toggle::DumpShaders)) { | |
| std::ostringstream dumpedMsg; | |
| dumpedMsg << "/* Dumped generated GLSL */\n" << compilationResult->glsl; | |
| GetDevice()->EmitLog(WGPULoggingType_Info, dumpedMsg.str().c_str()); | |
| } | |
| GLuint shader = DAWN_GL_TRY(gl, CreateShader(GLShaderType(stage))); | |
| const char* source = compilationResult->glsl.c_str(); | |
| { | |
| SCOPED_DAWN_HISTOGRAM_TIMER_MICROS(GetDevice()->GetPlatform(), "GLSL.CompileShader"); | |
| DAWN_GL_TRY(gl, ShaderSource(shader, 1, &source, nullptr)); | |
| DAWN_GL_TRY(gl, CompileShader(shader)); | |
| } | |
| GLint compileStatus = GL_FALSE; | |
| DAWN_GL_TRY(gl, GetShaderiv(shader, GL_COMPILE_STATUS, &compileStatus)); | |
| if (compileStatus == GL_FALSE) { | |
| GLint infoLogLength = 0; | |
| DAWN_GL_TRY(gl, GetShaderiv(shader, GL_INFO_LOG_LENGTH, &infoLogLength)); | |
| if (infoLogLength > 1) { | |
| std::vector<char> buffer(infoLogLength); | |
| DAWN_GL_TRY(gl, GetShaderInfoLog(shader, infoLogLength, nullptr, &buffer[0])); | |
| DAWN_GL_TRY(gl, DeleteShader(shader)); | |
| return DAWN_VALIDATION_ERROR("%s\nProgram compilation failed:\n%s", source, | |
| buffer.data()); | |
| } | |
| } | |
| GetDevice()->GetBlobCache()->EnsureStored(compilationResult); | |
| *combinedSamplers = std::move(combinedSamplerInfo); | |
| return shader; | |
| } | |
| } // namespace dawn::native::opengl |