impeller::scene::Geometry Class Reference

#include <geometry.h>

Inheritance diagram for impeller::scene::Geometry:

Public Member Functions
virtual	~Geometry ()
virtual GeometryType	GetGeometryType () const =0
virtual VertexBuffer	GetVertexBuffer (Allocator &allocator) const =0
virtual void	BindToCommand (const SceneContext &scene_context, HostBuffer &buffer, const Matrix &transform, RenderPass &pass) const =0
virtual void	SetJointsTexture (const std::shared_ptr< Texture > &texture)

Static Public Member Functions
static std::shared_ptr< CuboidGeometry >	MakeCuboid (Vector3 size)
static std::shared_ptr< Geometry >	MakeVertexBuffer (VertexBuffer vertex_buffer, bool is_skinned)
static std::shared_ptr< Geometry >	MakeFromFlatbuffer (const fb::MeshPrimitive &mesh, Allocator &allocator)

Detailed Description

Definition at line 29 of file geometry.h.

Constructor & Destructor Documentation

~Geometry()

impeller::scene::Geometry::~Geometry ( )

virtualdefault

Geometry

Member Function Documentation

BindToCommand()

virtual void impeller::scene::Geometry::BindToCommand ( const SceneContext &  scene_context, HostBuffer &  buffer, const Matrix &  transform, RenderPass &  pass  ) const

pure virtual

Implemented in impeller::scene::CuboidGeometry, impeller::scene::UnskinnedVertexBufferGeometry, and impeller::scene::SkinnedVertexBufferGeometry.

GetGeometryType()

virtual GeometryType impeller::scene::Geometry::GetGeometryType ( ) const

pure virtual

Implemented in impeller::scene::CuboidGeometry, impeller::scene::UnskinnedVertexBufferGeometry, and impeller::scene::SkinnedVertexBufferGeometry.

GetVertexBuffer()

virtual VertexBuffer impeller::scene::Geometry::GetVertexBuffer ( Allocator &  allocator ) const

pure virtual

Implemented in impeller::scene::CuboidGeometry, impeller::scene::UnskinnedVertexBufferGeometry, and impeller::scene::SkinnedVertexBufferGeometry.

MakeCuboid()

std::shared_ptr< CuboidGeometry > impeller::scene::Geometry::MakeCuboid ( Vector3  size )

static

Definition at line 31 of file geometry.cc.

                                                               {
  auto result = std::make_shared<CuboidGeometry>();
  result->SetSize(size);
  return result;
}

MakeFromFlatbuffer()

std::shared_ptr< Geometry > impeller::scene::Geometry::MakeFromFlatbuffer ( const fb::MeshPrimitive &  mesh, Allocator &  allocator  )

static

Definition at line 50 of file geometry.cc.

                          {
  IndexType index_type;
  switch (mesh.indices()->type()) {
    case fb::IndexType::k16Bit:
      index_type = IndexType::k16bit;
      break;
    case fb::IndexType::k32Bit:
      index_type = IndexType::k32bit;
      break;
  }
 
  const uint8_t* vertices_start;
  size_t vertices_bytes;
  bool is_skinned;
 
  switch (mesh.vertices_type()) {
    case fb::VertexBuffer::UnskinnedVertexBuffer: {
      const auto* vertices =
          mesh.vertices_as_UnskinnedVertexBuffer()->vertices();
      vertices_start = reinterpret_cast<const uint8_t*>(vertices->Get(0));
      vertices_bytes = vertices->size() * sizeof(fb::Vertex);
      is_skinned = false;
      break;
    }
    case fb::VertexBuffer::SkinnedVertexBuffer: {
      const auto* vertices = mesh.vertices_as_SkinnedVertexBuffer()->vertices();
      vertices_start = reinterpret_cast<const uint8_t*>(vertices->Get(0));
      vertices_bytes = vertices->size() * sizeof(fb::SkinnedVertex);
      is_skinned = true;
      break;
    }
    case fb::VertexBuffer::NONE:
      VALIDATION_LOG << "Invalid vertex buffer type.";
      return nullptr;
  }
 
  const uint8_t* indices_start =
      reinterpret_cast<const uint8_t*>(mesh.indices()->data()->Data());
 
  const size_t indices_bytes = mesh.indices()->data()->size();
  if (vertices_bytes == 0 || indices_bytes == 0) {
    return nullptr;
  }
 
  DeviceBufferDescriptor buffer_desc;
  buffer_desc.size = vertices_bytes + indices_bytes;
  buffer_desc.storage_mode = StorageMode::kHostVisible;
 
  auto buffer = allocator.CreateBuffer(buffer_desc);
  buffer->SetLabel("Mesh vertices+indices");
 
  if (!buffer->CopyHostBuffer(vertices_start, Range(0, vertices_bytes))) {
    return nullptr;
  }
  if (!buffer->CopyHostBuffer(indices_start, Range(0, indices_bytes),
                              vertices_bytes)) {
    return nullptr;
  }
 
  VertexBuffer vertex_buffer = {
      .vertex_buffer = {.buffer = buffer, .range = Range(0, vertices_bytes)},
      .index_buffer = {.buffer = buffer,
                       .range = Range(vertices_bytes, indices_bytes)},
      .vertex_count = mesh.indices()->count(),
      .index_type = index_type,
  };
  return MakeVertexBuffer(std::move(vertex_buffer), is_skinned);
}

MakeVertexBuffer()

std::shared_ptr< Geometry > impeller::scene::Geometry::MakeVertexBuffer ( VertexBuffer  vertex_buffer, bool  is_skinned  )

static

Definition at line 37 of file geometry.cc.

                                                                      {
  if (is_skinned) {
    auto result = std::make_shared<SkinnedVertexBufferGeometry>();
    result->SetVertexBuffer(std::move(vertex_buffer));
    return result;
  } else {
    auto result = std::make_shared<UnskinnedVertexBufferGeometry>();
    result->SetVertexBuffer(std::move(vertex_buffer));
    return result;
  }
}

SetJointsTexture()

void impeller::scene::Geometry::SetJointsTexture ( const std::shared_ptr< Texture > &  texture )

virtual

Reimplemented in impeller::scene::SkinnedVertexBufferGeometry.

Definition at line 121 of file geometry.cc.

{}

---

The documentation for this class was generated from the following files:

• impeller/scene/geometry.h
• impeller/scene/geometry.cc