impeller::scene Namespace Reference

Namespaces
	importer
	testing

Classes
class	Animation
class	AnimationClip
class	AnimationPlayer
struct	AnimationTransforms
class	Camera
class	CuboidGeometry
class	Geometry
class	Material
class	Mesh
class	Node
class	PhysicallyBasedMaterial
struct	PipelineKey
class	PropertyResolver
class	RotationTimelineResolver
class	ScaleTimelineResolver
class	Scene
struct	SceneCommand
class	SceneContext
struct	SceneContextOptions
class	SceneEncoder
class	Skin
class	SkinnedVertexBufferGeometry
class	TimelineResolver
class	TranslationTimelineResolver
class	UnlitMaterial
class	UnskinnedVertexBufferGeometry

Enumerations
enum	GeometryType {   GeometryType::kUnskinned = 0,   GeometryType::kSkinned = 1,   GeometryType::kLastType = kSkinned }
enum	MaterialType {   MaterialType::kUnlit = 0,   MaterialType::kLastType = kUnlit }

Functions
static std::shared_ptr< Texture >	UnpackTextureFromFlatbuffer (const fb::Texture *iptexture, Allocator &allocator)
static void	EncodeCommand (const SceneContext &scene_context, const Matrix &view_transform, RenderPass &render_pass, const SceneCommand &scene_command)

Variables
static std::atomic_uint64_t	kNextNodeID = 0

Enumeration Type Documentation

GeometryType

enum impeller::scene::GeometryType

strong

Enumerator
kUnskinned
kSkinned
kLastType

Definition at line 13 of file pipeline_key.h.

                        {
  kUnskinned = 0,
  kSkinned = 1,
  kLastType = kSkinned,
};

MaterialType

enum impeller::scene::MaterialType

strong

Enumerator
kUnlit
kLastType

Definition at line 18 of file pipeline_key.h.

                        {
  kUnlit = 0,
  kLastType = kUnlit,
};

Function Documentation

EncodeCommand()

static void impeller::scene::EncodeCommand ( const SceneContext &  scene_context, const Matrix &  view_transform, RenderPass &  render_pass, const SceneCommand &  scene_command  )

static

Definition at line 23 of file scene_encoder.cc.

                                                             {
  auto& host_buffer = render_pass.GetTransientsBuffer();
 
  Command cmd;
  DEBUG_COMMAND_INFO(cmd, scene_command.label);
  cmd.stencil_reference =
      0;  // TODO(bdero): Configurable stencil ref per-command.
 
  cmd.pipeline = scene_context.GetPipeline(
      PipelineKey{scene_command.geometry->GetGeometryType(),
                  scene_command.material->GetMaterialType()},
      scene_command.material->GetContextOptions(render_pass));
 
  scene_command.geometry->BindToCommand(
      scene_context, host_buffer, view_transform * scene_command.transform,
      cmd);
  scene_command.material->BindToCommand(scene_context, host_buffer, cmd);
 
  render_pass.AddCommand(std::move(cmd));
}

References impeller::RenderPass::AddCommand(), impeller::scene::Geometry::BindToCommand(), impeller::scene::Material::BindToCommand(), DEBUG_COMMAND_INFO, impeller::scene::SceneCommand::geometry, impeller::scene::Material::GetContextOptions(), impeller::scene::Geometry::GetGeometryType(), impeller::scene::Material::GetMaterialType(), impeller::scene::SceneContext::GetPipeline(), impeller::RenderPass::GetTransientsBuffer(), impeller::scene::SceneCommand::label, impeller::scene::SceneCommand::material, impeller::Command::pipeline, impeller::Command::stencil_reference, and impeller::scene::SceneCommand::transform.

UnpackTextureFromFlatbuffer()

static std::shared_ptr<Texture> impeller::scene::UnpackTextureFromFlatbuffer ( const fb::Texture *  iptexture, Allocator &  allocator  )

static

Definition at line 62 of file node.cc.

                          {
  if (iptexture == nullptr || iptexture->embedded_image() == nullptr ||
      iptexture->embedded_image()->bytes() == nullptr) {
    return nullptr;
  }
 
  auto embedded = iptexture->embedded_image();
 
  uint8_t bytes_per_component = 0;
  switch (embedded->component_type()) {
    case fb::ComponentType::k8Bit:
      bytes_per_component = 1;
      break;
    case fb::ComponentType::k16Bit:
      // bytes_per_component = 2;
      FML_LOG(WARNING) << "16 bit textures not yet supported.";
      return nullptr;
  }
 
  DecompressedImage::Format format;
  switch (embedded->component_count()) {
    case 1:
      format = DecompressedImage::Format::kGrey;
      break;
    case 3:
      format = DecompressedImage::Format::kRGB;
      break;
    case 4:
      format = DecompressedImage::Format::kRGBA;
      break;
    default:
      FML_LOG(WARNING) << "Textures with " << embedded->component_count()
                       << " components are not supported." << std::endl;
      return nullptr;
  }
  if (embedded->bytes()->size() != bytes_per_component *
                                       embedded->component_count() *
                                       embedded->width() * embedded->height()) {
    FML_LOG(WARNING) << "Embedded texture has an unexpected size. Skipping."
                     << std::endl;
    return nullptr;
  }
 
  auto image_mapping = std::make_shared<fml::NonOwnedMapping>(
      embedded->bytes()->Data(), embedded->bytes()->size());
  auto decompressed_image =
      DecompressedImage(ISize(embedded->width(), embedded->height()), format,
                        image_mapping)
          .ConvertToRGBA();
 
  auto texture_descriptor = TextureDescriptor{};
  texture_descriptor.storage_mode = StorageMode::kHostVisible;
  texture_descriptor.format = PixelFormat::kR8G8B8A8UNormInt;
  texture_descriptor.size = decompressed_image.GetSize();
  // TODO(bdero): Generate mipmaps for embedded textures.
  texture_descriptor.mip_count = 1u;
 
  auto texture = allocator.CreateTexture(texture_descriptor);
  if (!texture) {
    FML_LOG(ERROR) << "Could not allocate texture.";
    return nullptr;
  }
 
  auto uploaded = texture->SetContents(decompressed_image.GetAllocation());
  if (!uploaded) {
    FML_LOG(ERROR) << "Could not upload texture to device memory.";
    return nullptr;
  }
 
  return texture;
}

References impeller::DecompressedImage::ConvertToRGBA(), impeller::Allocator::CreateTexture(), impeller::DecompressedImage::kGrey, impeller::kHostVisible, impeller::kR8G8B8A8UNormInt, impeller::DecompressedImage::kRGB, impeller::DecompressedImage::kRGBA, and impeller::TextureDescriptor::storage_mode.

Referenced by impeller::scene::Node::MakeFromFlatbuffer().

Variable Documentation

kNextNodeID

std::atomic_uint64_t impeller::scene::kNextNodeID = 0

static

Definition at line 28 of file node.cc.