impeller::scene Namespace Reference

Namespaces
namespace	importer
namespace	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 class	GeometryType { kUnskinned = 0 , kSkinned = 1 , kLastType = kSkinned }
enum class	MaterialType { kUnlit = 0 , 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 class 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 class 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 = scene_context.GetTransientsBuffer();
 
  render_pass.SetCommandLabel(scene_command.label);
  // TODO(bdero): Configurable stencil ref per-command.
  render_pass.SetStencilReference(0);
 
  render_pass.SetPipeline(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,
      render_pass);
  scene_command.material->BindToCommand(scene_context, host_buffer,
                                        render_pass);
 
  render_pass.Draw();
  ;
}

UnpackTextureFromFlatbuffer()

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

static

Definition at line 61 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;
  }
 
  switch (embedded->component_count()) {
    case 4:
      // RGBA.
      break;
    case 1:
    case 3:
    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 texture_descriptor = TextureDescriptor{};
  texture_descriptor.storage_mode = StorageMode::kHostVisible;
  texture_descriptor.format = PixelFormat::kR8G8B8A8UNormInt;
  texture_descriptor.size = ISize(embedded->width(), embedded->height());
  // 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(image_mapping);
  if (!uploaded) {
    FML_LOG(ERROR) << "Could not upload texture to device memory.";
    return nullptr;
  }
 
  return texture;
}

Variable Documentation

kNextNodeID

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

static

Definition at line 27 of file node.cc.