runtime_effect_contents.cc

Go to the documentation of this file.

// Copyright 2013 The Flutter Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
 
#include "impeller/entity/contents/runtime_effect_contents.h"
 
#include <algorithm>
#include <future>
#include <memory>
 
#include "flutter/fml/logging.h"
#include "flutter/fml/make_copyable.h"
#include "impeller/base/validation.h"
#include "impeller/core/formats.h"
#include "impeller/core/runtime_types.h"
#include "impeller/core/shader_types.h"
#include "impeller/entity/contents/content_context.h"
#include "impeller/entity/runtime_effect.vert.h"
#include "impeller/renderer/capabilities.h"
#include "impeller/renderer/pipeline_library.h"
#include "impeller/renderer/render_pass.h"
#include "impeller/renderer/shader_function.h"
#include "impeller/renderer/shader_key.h"
#include "impeller/renderer/vertex_descriptor.h"
 
namespace impeller {
 
// static
BufferView RuntimeEffectContents::EmplaceUniform(
    const uint8_t* source_data,
    HostBuffer& data_host_buffer,
    const RuntimeUniformDescription& uniform) {
  size_t minimum_uniform_alignment =
      data_host_buffer.GetMinimumUniformAlignment();
  size_t alignment = std::max(uniform.bit_width / 8, minimum_uniform_alignment);
 
  if (uniform.padding_layout.empty()) {
    return data_host_buffer.Emplace(source_data, uniform.GetGPUSize(),
                                    alignment);
  }
 
  // If the uniform has a padding layout, we need to repack the data.
  // We can do this by using the EmplaceProc to write directly to the
  // HostBuffer.
  return data_host_buffer.Emplace(
      uniform.GetGPUSize(), alignment,
      [&uniform, source_data](uint8_t* destination) {
        size_t count = uniform.array_elements.value_or(1);
        if (count == 0) {
          // Make sure to run at least once.
          count = 1;
        }
        size_t uniform_byte_index = 0u;
        size_t struct_float_index = 0u;
        auto* float_destination = reinterpret_cast<float*>(destination);
        auto* float_source = reinterpret_cast<const float*>(source_data);
 
        for (size_t i = 0; i < count; i++) {
          for (RuntimePaddingType byte_type : uniform.padding_layout) {
            if (byte_type == RuntimePaddingType::kPadding) {
              float_destination[struct_float_index++] = 0.f;
            } else {
              FML_DCHECK(byte_type == RuntimePaddingType::kFloat);
              float_destination[struct_float_index++] =
                  float_source[uniform_byte_index++];
            }
          }
        }
      });
}
 
RuntimeEffectContents::RuntimeEffectContents(const Geometry* geometry)
    : geometry_(geometry) {}
 
RuntimeEffectContents::~RuntimeEffectContents() = default;
 
const Geometry* RuntimeEffectContents::GetGeometry() const {
  return geometry_;
}
 
void RuntimeEffectContents::SetRuntimeStage(
    std::shared_ptr<RuntimeStage> runtime_stage) {
  runtime_stage_ = std::move(runtime_stage);
  // Precompute the scoped registry name now so that the hot per-frame
  // `Render` path does not re-allocate it on every call. The name is keyed
  // on the stage's library id and entrypoint, both of which are stable for
  // a given `runtime_stage_` value, so this stays valid until the next
  // `SetRuntimeStage`.
  if (runtime_stage_) {
    scoped_fragment_name_ = ShaderKey::MakeUserScopedName(
        ShaderKey::kScopeRuntimeEffect, runtime_stage_->GetLibraryId(),
        runtime_stage_->GetEntrypoint());
  } else {
    scoped_fragment_name_.clear();
  }
}
 
void RuntimeEffectContents::SetUniformData(
    std::shared_ptr<std::vector<uint8_t>> uniform_data) {
  uniform_data_ = std::move(uniform_data);
}
 
void RuntimeEffectContents::SetTextureInputs(
    std::vector<TextureInput> texture_inputs) {
  texture_inputs_ = std::move(texture_inputs);
}
 
static ShaderType GetShaderType(RuntimeUniformType type) {
  switch (type) {
    case kSampledImage:
      return ShaderType::kSampledImage;
    case kFloat:
      return ShaderType::kFloat;
    case kStruct:
      return ShaderType::kStruct;
  }
}
 
static std::unique_ptr<ShaderMetadata> MakeShaderMetadata(
    const RuntimeUniformDescription& uniform) {
  std::unique_ptr<ShaderMetadata> metadata = std::make_unique<ShaderMetadata>();
  metadata->name = uniform.name;
 
  // If the element is not an array, then the runtime stage flatbuffer will
  // represent the unspecified array_elements as the default value of 0.
  std::optional<size_t> array_elements;
  if (uniform.array_elements.value_or(0) > 0) {
    array_elements = uniform.array_elements;
  }
 
  size_t member_size = uniform.dimensions.rows * uniform.dimensions.cols *
                       (uniform.bit_width / 8u);
 
  const ShaderType shader_type = GetShaderType(uniform.type);
  const std::optional<ShaderFloatType> float_type = DeriveShaderFloatType(
      shader_type, uniform.dimensions.rows, uniform.dimensions.cols);
 
  metadata->members.emplace_back(ShaderStructMemberMetadata{
      .type = shader_type,                                      //
      .size = member_size,                                      //
      .byte_length = member_size * array_elements.value_or(1),  //
      .array_elements = array_elements,                         //
      .float_type = float_type,                                 //
  });
 
  return metadata;
}
 
bool RuntimeEffectContents::BootstrapShader(
    const ContentContext& renderer) const {
  if (!RegisterShader(renderer)) {
    return false;
  }
  ContentContextOptions options;
  options.color_attachment_pixel_format =
      renderer.GetContext()->GetCapabilities()->GetDefaultColorFormat();
  CreatePipeline(renderer, options, /*async=*/true);
  return true;
}
 
bool RuntimeEffectContents::RegisterShader(
    const ContentContext& renderer) const {
  const std::shared_ptr<Context>& context = renderer.GetContext();
  const std::shared_ptr<ShaderLibrary>& library = context->GetShaderLibrary();
 
  std::shared_ptr<const ShaderFunction> function =
      library->GetFunction(scoped_fragment_name_, ShaderStage::kFragment);
 
  //--------------------------------------------------------------------------
  /// Resolve runtime stage function.
  ///
 
  if (function && runtime_stage_->IsDirty()) {
    renderer.ClearCachedRuntimeEffectPipeline(scoped_fragment_name_);
    context->GetPipelineLibrary()->RemovePipelinesWithEntryPoint(function);
    library->UnregisterFunction(scoped_fragment_name_, ShaderStage::kFragment);
 
    function = nullptr;
  }
 
  if (!function) {
    std::promise<bool> promise;
    auto future = promise.get_future();
 
    library->RegisterFunction(
        scoped_fragment_name_, ToShaderStage(runtime_stage_->GetShaderStage()),
        runtime_stage_->GetCodeMapping(),
        fml::MakeCopyable([promise = std::move(promise)](bool result) mutable {
          promise.set_value(result);
        }));
 
    if (!future.get()) {
      VALIDATION_LOG << "Failed to build runtime effect (entry point: "
                     << runtime_stage_->GetEntrypoint() << ")";
      return false;
    }
 
    function =
        library->GetFunction(scoped_fragment_name_, ShaderStage::kFragment);
    if (!function) {
      VALIDATION_LOG
          << "Failed to fetch runtime effect function immediately after "
             "registering it (entry point: "
          << runtime_stage_->GetEntrypoint() << ")";
      return false;
    }
 
    runtime_stage_->SetClean();
  }
  return true;
}
 
std::shared_ptr<Pipeline<PipelineDescriptor>>
RuntimeEffectContents::CreatePipeline(const ContentContext& renderer,
                                      ContentContextOptions options,
                                      bool async) const {
  const std::shared_ptr<Context>& context = renderer.GetContext();
  const std::shared_ptr<ShaderLibrary>& library = context->GetShaderLibrary();
  const std::shared_ptr<const Capabilities>& caps = context->GetCapabilities();
  const PixelFormat color_attachment_format = caps->GetDefaultColorFormat();
  const PixelFormat stencil_attachment_format =
      caps->GetDefaultDepthStencilFormat();
 
  using VS = RuntimeEffectVertexShader;
 
  PipelineDescriptor desc;
  desc.SetLabel("Runtime Stage");
  desc.AddStageEntrypoint(
      library->GetFunction(VS::kEntrypointName, ShaderStage::kVertex));
  desc.AddStageEntrypoint(
      library->GetFunction(scoped_fragment_name_, ShaderStage::kFragment));
 
  std::shared_ptr<VertexDescriptor> vertex_descriptor =
      std::make_shared<VertexDescriptor>();
  vertex_descriptor->SetStageInputs(VS::kAllShaderStageInputs,
                                    VS::kInterleavedBufferLayout);
  vertex_descriptor->RegisterDescriptorSetLayouts(VS::kDescriptorSetLayouts);
  vertex_descriptor->RegisterDescriptorSetLayouts(
      runtime_stage_->GetDescriptorSetLayouts().data(),
      runtime_stage_->GetDescriptorSetLayouts().size());
  desc.SetVertexDescriptor(std::move(vertex_descriptor));
  desc.SetColorAttachmentDescriptor(
      0u, {.format = color_attachment_format, .blending_enabled = true});
 
  desc.SetStencilAttachmentDescriptors(StencilAttachmentDescriptor{});
  desc.SetStencilPixelFormat(stencil_attachment_format);
 
  desc.SetDepthStencilAttachmentDescriptor(DepthAttachmentDescriptor{});
  desc.SetDepthPixelFormat(stencil_attachment_format);
 
  options.ApplyToPipelineDescriptor(desc);
  if (async) {
    context->GetPipelineLibrary()->GetPipeline(desc, async);
    return nullptr;
  }
 
  auto pipeline = context->GetPipelineLibrary()->GetPipeline(desc, async).Get();
  if (!pipeline) {
    VALIDATION_LOG << "Failed to get or create runtime effect pipeline.";
    return nullptr;
  }
 
  return pipeline;
}
 
bool RuntimeEffectContents::Render(const ContentContext& renderer,
                                   const Entity& entity,
                                   RenderPass& pass) const {
  const std::shared_ptr<Context>& context = renderer.GetContext();
  const std::shared_ptr<ShaderLibrary>& library = context->GetShaderLibrary();
 
  //--------------------------------------------------------------------------
  /// Get or register shader. Flutter will do this when the runtime effect
  /// is first loaded, but this check is added to supporting testing of the
  /// Aiks API and non-flutter usage of Impeller.
  ///
  if (!RegisterShader(renderer)) {
    return false;
  }
 
  //--------------------------------------------------------------------------
  /// Fragment stage uniforms.
  ///
  BindFragmentCallback bind_callback = [this, &renderer,
                                        &context](RenderPass& pass) {
    size_t buffer_index = 0;
    size_t buffer_offset = 0;
    size_t sampler_location = 0;
    size_t buffer_location = 0;
 
    // Uniforms are ordered in the IPLR according to their
    // declaration and the uniform location reflects the correct offset to
    // be mapped to - except that it may include all proceeding
    // uniforms of a different type. For example, a texture sampler that comes
    // after 4 float uniforms may have a location of 4. Since we know that
    // the declarations are already ordered, we can track the uniform location
    // ourselves.
    auto& data_host_buffer = renderer.GetTransientsDataBuffer();
    for (const auto& uniform : runtime_stage_->GetUniforms()) {
      std::unique_ptr<ShaderMetadata> metadata = MakeShaderMetadata(uniform);
      switch (uniform.type) {
        case kSampledImage: {
          FML_DCHECK(sampler_location < texture_inputs_.size());
          auto& input = texture_inputs_[sampler_location];
 
          raw_ptr<const Sampler> sampler =
              context->GetSamplerLibrary()->GetSampler(
                  input.sampler_descriptor);
 
          SampledImageSlot image_slot;
          image_slot.name = uniform.name.c_str();
          image_slot.binding = uniform.binding;
          image_slot.texture_index = sampler_location;
          pass.BindDynamicResource(ShaderStage::kFragment,
                                   DescriptorType::kSampledImage, image_slot,
                                   std::move(metadata), input.texture, sampler);
          sampler_location++;
          break;
        }
        case kFloat: {
          FML_DCHECK(renderer.GetContext()->GetBackendType() !=
                     Context::BackendType::kVulkan)
              << "Uniform " << uniform.name
              << " had unexpected type kFloat for Vulkan backend.";
 
          BufferView buffer_view = EmplaceUniform(
              uniform_data_->data() + buffer_offset, data_host_buffer, uniform);
 
          ShaderUniformSlot uniform_slot;
          uniform_slot.name = uniform.name.c_str();
          uniform_slot.ext_res_0 = buffer_location;
          pass.BindDynamicResource(ShaderStage::kFragment,
                                   DescriptorType::kUniformBuffer, uniform_slot,
                                   std::move(metadata), std::move(buffer_view));
          buffer_index++;
          buffer_offset += uniform.GetDartSize();
          buffer_location++;
          break;
        }
        case kStruct: {
          FML_DCHECK(renderer.GetContext()->GetBackendType() ==
                     Context::BackendType::kVulkan);
          ShaderUniformSlot uniform_slot;
          uniform_slot.binding = uniform.location;
          uniform_slot.name = uniform.name.c_str();
 
          pass.BindResource(
              ShaderStage::kFragment, DescriptorType::kUniformBuffer,
              uniform_slot, nullptr,
              EmplaceUniform(uniform_data_->data(), data_host_buffer, uniform));
        }
      }
    }
 
    return true;
  };
 
  /// Now that the descriptor set layouts are known, get the pipeline.
  using VS = RuntimeEffectVertexShader;
 
  PipelineBuilderCallback pipeline_callback =
      [&](ContentContextOptions options) {
        // Pipeline creation callback for the cache handler to call.
        return renderer.GetCachedRuntimeEffectPipeline(
            scoped_fragment_name_, options, [&]() {
              return CreatePipeline(renderer, options, /*async=*/false);
            });
      };
 
  return ColorSourceContents::DrawGeometry<VS>(renderer, entity, pass,
                                               pipeline_callback,
                                               VS::FrameInfo{}, bind_callback);
}
 
}  // namespace impeller