render_pipeline.h File Reference

#include <memory>
#include "flutter/lib/gpu/context.h"
#include "flutter/lib/gpu/export.h"
#include "flutter/lib/gpu/shader.h"
#include "flutter/lib/ui/dart_wrapper.h"
#include "impeller/renderer/pipeline_descriptor.h"
#include "impeller/renderer/vertex_descriptor.h"

Go to the source code of this file.

Classes
class	flutter::gpu::RenderPipeline

Namespaces
namespace	flutter
namespace	flutter::gpu

Functions
FLUTTER_GPU_EXPORT Dart_Handle	InternalFlutterGpu_RenderPipeline_Initialize (Dart_Handle wrapper, flutter::gpu::Context *gpu_context, flutter::gpu::Shader *vertex_shader, flutter::gpu::Shader *fragment_shader, Dart_Handle buffer_layouts_handle, Dart_Handle attributes_handle, Dart_Handle attribute_names_handle)

Function Documentation

InternalFlutterGpu_RenderPipeline_Initialize()

FLUTTER_GPU_EXPORT Dart_Handle InternalFlutterGpu_RenderPipeline_Initialize ( Dart_Handle  wrapper, flutter::gpu::Context *  gpu_context, flutter::gpu::Shader *  vertex_shader, flutter::gpu::Shader *  fragment_shader, Dart_Handle  buffer_layouts_handle, Dart_Handle  attributes_handle, Dart_Handle  attribute_names_handle  )

extern

Exports

Definition at line 292 of file render_pipeline.cc.

                                        {
  // Lazily register the shaders synchronously if they haven't been already.
  vertex_shader->RegisterSync(*gpu_context);
  fragment_shader->RegisterSync(*gpu_context);
 
  std::shared_ptr<impeller::VertexDescriptor> vertex_descriptor;
 
  const bool buffer_layouts_provided = !Dart_IsNull(buffer_layouts_handle);
  const bool attributes_provided = !Dart_IsNull(attributes_handle);
  const bool attribute_names_provided = !Dart_IsNull(attribute_names_handle);
  if (buffer_layouts_provided != attributes_provided ||
      attributes_provided != attribute_names_provided) {
    return tonic::ToDart(
        "VertexLayout requires buffer layouts, attributes, and attribute "
        "names to be provided together.");
  }
 
  if (buffer_layouts_provided) {
    // Copy the packed Dart-side ByteData buffers into local vectors so the
    // tonic::DartByteData typed-data handles are released before we make any
    // call back into the Dart VM (e.g. tonic::ToDart for an error string).
    // Holding a typed-data handle while calling into the VM raises
    // "Callbacks into the Dart VM are currently prohibited." Errors raised
    // inside the inner scope must therefore be deferred to a local string
    // and returned only after the typed-data handles go out of scope.
    std::vector<int32_t> buffer_layouts_ints;
    std::vector<int32_t> attribute_ints;
    std::vector<char> attribute_names_bytes;
    std::string copy_error;
    {
      tonic::DartByteData buffer_layouts_data(buffer_layouts_handle);
      tonic::DartByteData attributes_data(attributes_handle);
      tonic::DartByteData attribute_names_data(attribute_names_handle);
      if (buffer_layouts_data.length_in_bytes() %
              (flutter::gpu::kBufferLayoutInts * sizeof(int32_t)) !=
          0) {
        copy_error =
            "Internal error: buffer layouts ByteData has invalid length.";
      } else if (attributes_data.length_in_bytes() %
                     (flutter::gpu::kAttributeInts * sizeof(int32_t)) !=
                 0) {
        copy_error = "Internal error: attributes ByteData has invalid length.";
      } else {
        const auto* buffer_layouts_src =
            static_cast<const int32_t*>(buffer_layouts_data.data());
        const auto* attributes_src =
            static_cast<const int32_t*>(attributes_data.data());
        const auto* names_src =
            static_cast<const char*>(attribute_names_data.data());
        buffer_layouts_ints.assign(
            buffer_layouts_src,
            buffer_layouts_src +
                buffer_layouts_data.length_in_bytes() / sizeof(int32_t));
        attribute_ints.assign(
            attributes_src, attributes_src + attributes_data.length_in_bytes() /
                                                 sizeof(int32_t));
        attribute_names_bytes.assign(
            names_src, names_src + attribute_names_data.length_in_bytes());
      }
    }
    if (!copy_error.empty()) {
      return tonic::ToDart(copy_error);
    }
 
    absl::StatusOr<std::shared_ptr<impeller::VertexDescriptor>> built =
        flutter::gpu::BuildCustomVertexDescriptor(
            *vertex_shader,
            std::span<const int32_t>(buffer_layouts_ints.data(),
                                     buffer_layouts_ints.size()),
            std::span<const int32_t>(attribute_ints.data(),
                                     attribute_ints.size()),
            std::span<const char>(attribute_names_bytes.data(),
                                  attribute_names_bytes.size()));
    if (!built.ok()) {
      return tonic::ToDart(std::string(built.status().message()));
    }
    vertex_descriptor = *std::move(built);
  } else {
    vertex_descriptor = vertex_shader->CreateVertexDescriptor();
  }
 
  auto res = fml::MakeRefCounted<flutter::gpu::RenderPipeline>(
      fml::RefPtr<flutter::gpu::Shader>(vertex_shader),    //
      fml::RefPtr<flutter::gpu::Shader>(fragment_shader),  //
      std::move(vertex_descriptor));
  res->AssociateWithDartWrapper(wrapper);
 
  return Dart_Null();
}

References flutter::gpu::Shader::CreateVertexDescriptor(), tonic::DartByteData::data(), tonic::DartByteData::length_in_bytes(), flutter::gpu::Shader::RegisterSync(), and tonic::ToDart().