impeller::VerticesGeometry Class Reference

A geometry that is created from a vertices object. More...

#include <vertices_geometry.h>

Inheritance diagram for impeller::VerticesGeometry:

Public Types
enum	VertexMode {   VertexMode::kTriangles,   VertexMode::kTriangleStrip,   VertexMode::kTriangleFan }

Public Member Functions
	VerticesGeometry (std::vector< Point > vertices, std::vector< uint16_t > indices, std::vector< Point > texture_coordinates, std::vector< Color > colors, Rect bounds, VerticesGeometry::VertexMode vertex_mode)
	~VerticesGeometry ()
GeometryResult	GetPositionColorBuffer (const ContentContext &renderer, const Entity &entity, RenderPass &pass)
GeometryResult	GetPositionUVBuffer (Rect texture_coverage, Matrix effect_transform, const ContentContext &renderer, const Entity &entity, RenderPass &pass) override
GeometryResult	GetPositionBuffer (const ContentContext &renderer, const Entity &entity, RenderPass &pass) override
std::optional< Rect >	GetCoverage (const Matrix &transform) const override
GeometryVertexType	GetVertexType () const override
bool	HasVertexColors () const
bool	HasTextureCoordinates () const
std::optional< Rect >	GetTextureCoordinateCoverge () const
Public Member Functions inherited from impeller::Geometry
	Geometry ()
virtual	~Geometry ()
virtual bool	CoversArea (const Matrix &transform, const Rect &rect) const
	Determines if this geometry, transformed by the given transform, will completely cover all surface area of the given rect. More...

Additional Inherited Members
Static Public Member Functions inherited from impeller::Geometry
static std::unique_ptr< Geometry >	MakeFillPath (const Path &path, std::optional< Rect > inner_rect=std::nullopt)
static std::unique_ptr< Geometry >	MakeStrokePath (const Path &path, Scalar stroke_width=0.0, Scalar miter_limit=4.0, Cap stroke_cap=Cap::kButt, Join stroke_join=Join::kMiter)
static std::unique_ptr< Geometry >	MakeCover ()
static std::unique_ptr< Geometry >	MakeRect (Rect rect)
static std::unique_ptr< Geometry >	MakePointField (std::vector< Point > points, Scalar radius, bool round)

Detailed Description

A geometry that is created from a vertices object.

Definition at line 12 of file vertices_geometry.h.

Member Enumeration Documentation

VertexMode

enum impeller::VerticesGeometry::VertexMode

strong

Enumerator
kTriangles
kTriangleStrip
kTriangleFan

Definition at line 14 of file vertices_geometry.h.

                        {
    kTriangles,
    kTriangleStrip,
    kTriangleFan,
  };

Constructor & Destructor Documentation

VerticesGeometry()

impeller::VerticesGeometry::VerticesGeometry	(	std::vector< Point >	vertices,
		std::vector< uint16_t >	indices,
		std::vector< Point >	texture_coordinates,
		std::vector< Color >	colors,
		Rect	bounds,
		VerticesGeometry::VertexMode	vertex_mode
	)

Definition at line 55 of file vertices_geometry.cc.

    : vertices_(std::move(vertices)),
      colors_(std::move(colors)),
      texture_coordinates_(std::move(texture_coordinates)),
      indices_(std::move(indices)),
      bounds_(bounds),
      vertex_mode_(vertex_mode) {
  NormalizeIndices();
}

~VerticesGeometry()

impeller::VerticesGeometry::~VerticesGeometry ( )

default

Member Function Documentation

GetCoverage()

std::optional< Rect > impeller::VerticesGeometry::GetCoverage ( const Matrix &  transform ) const

overridevirtual

Implements impeller::Geometry.

Definition at line 304 of file vertices_geometry.cc.

                                   {
  return bounds_.TransformBounds(transform);
}

References impeller::TRect< T >::TransformBounds().

GetPositionBuffer()

GeometryResult impeller::VerticesGeometry::GetPositionBuffer ( const ContentContext &  renderer, const Entity &  entity, RenderPass &  pass  )

overridevirtual

Implements impeller::Geometry.

Definition at line 113 of file vertices_geometry.cc.

                      {
  auto index_count = indices_.size();
  auto vertex_count = vertices_.size();
 
  size_t total_vtx_bytes = vertex_count * sizeof(float) * 2;
  size_t total_idx_bytes = index_count * sizeof(uint16_t);
 
  DeviceBufferDescriptor buffer_desc;
  buffer_desc.size = total_vtx_bytes + total_idx_bytes;
  buffer_desc.storage_mode = StorageMode::kHostVisible;
 
  auto buffer =
      renderer.GetContext()->GetResourceAllocator()->CreateBuffer(buffer_desc);
 
  if (!buffer->CopyHostBuffer(
          reinterpret_cast<const uint8_t*>(vertices_.data()),
          Range{0, total_vtx_bytes}, 0)) {
    return {};
  }
  if (index_count > 0 &&
      !buffer->CopyHostBuffer(
          reinterpret_cast<uint8_t*>(const_cast<uint16_t*>(indices_.data())),
          Range{0, total_idx_bytes}, total_vtx_bytes)) {
    return {};
  }
 
  return GeometryResult{
      .type = GetPrimitiveType(),
      .vertex_buffer =
          {
              .vertex_buffer = {.buffer = buffer,
                                .range = Range{0, total_vtx_bytes}},
              .index_buffer = {.buffer = buffer,
                               .range =
                                   Range{total_vtx_bytes, total_idx_bytes}},
              .vertex_count = index_count > 0 ? index_count : vertex_count,
              .index_type =
                  index_count > 0 ? IndexType::k16bit : IndexType::kNone,
          },
      .transform = Matrix::MakeOrthographic(pass.GetRenderTargetSize()) *
                   entity.GetTransformation(),
      .prevent_overdraw = false,
  };
}

References impeller::ContentContext::GetContext(), impeller::RenderPass::GetRenderTargetSize(), impeller::Entity::GetTransformation(), impeller::k16bit, impeller::kHostVisible, impeller::kNone, impeller::Matrix::MakeOrthographic(), impeller::DeviceBufferDescriptor::size, and impeller::GeometryResult::type.

GetPositionColorBuffer()

GeometryResult impeller::VerticesGeometry::GetPositionColorBuffer	(	const ContentContext &	renderer,
		const Entity &	entity,
		RenderPass &	pass
	)

Definition at line 161 of file vertices_geometry.cc.

                      {
  using VS = GeometryColorPipeline::VertexShader;
 
  auto index_count = indices_.size();
  auto vertex_count = vertices_.size();
 
  std::vector<VS::PerVertexData> vertex_data(vertex_count);
  {
    for (auto i = 0u; i < vertex_count; i++) {
      vertex_data[i] = {
          .position = vertices_[i],
          .color = colors_[i],
      };
    }
  }
 
  size_t total_vtx_bytes = vertex_data.size() * sizeof(VS::PerVertexData);
  size_t total_idx_bytes = index_count * sizeof(uint16_t);
 
  DeviceBufferDescriptor buffer_desc;
  buffer_desc.size = total_vtx_bytes + total_idx_bytes;
  buffer_desc.storage_mode = StorageMode::kHostVisible;
 
  auto buffer =
      renderer.GetContext()->GetResourceAllocator()->CreateBuffer(buffer_desc);
 
  if (!buffer->CopyHostBuffer(reinterpret_cast<uint8_t*>(vertex_data.data()),
                              Range{0, total_vtx_bytes}, 0)) {
    return {};
  }
  if (index_count > 0 &&
      !buffer->CopyHostBuffer(
          reinterpret_cast<uint8_t*>(const_cast<uint16_t*>(indices_.data())),
          Range{0, total_idx_bytes}, total_vtx_bytes)) {
    return {};
  }
 
  return GeometryResult{
      .type = GetPrimitiveType(),
      .vertex_buffer =
          {
              .vertex_buffer = {.buffer = buffer,
                                .range = Range{0, total_vtx_bytes}},
              .index_buffer = {.buffer = buffer,
                               .range =
                                   Range{total_vtx_bytes, total_idx_bytes}},
              .vertex_count = index_count > 0 ? index_count : vertex_count,
              .index_type =
                  index_count > 0 ? IndexType::k16bit : IndexType::kNone,
          },
      .transform = Matrix::MakeOrthographic(pass.GetRenderTargetSize()) *
                   entity.GetTransformation(),
      .prevent_overdraw = false,
  };
}

References impeller::ContentContext::GetContext(), impeller::RenderPass::GetRenderTargetSize(), impeller::Entity::GetTransformation(), impeller::k16bit, impeller::kHostVisible, impeller::kNone, impeller::Matrix::MakeOrthographic(), impeller::DeviceBufferDescriptor::size, and impeller::GeometryResult::type.

GetPositionUVBuffer()

GeometryResult impeller::VerticesGeometry::GetPositionUVBuffer ( Rect  texture_coverage, Matrix  effect_transform, const ContentContext &  renderer, const Entity &  entity, RenderPass &  pass  )

overridevirtual

Reimplemented from impeller::Geometry.

Definition at line 220 of file vertices_geometry.cc.

                      {
  using VS = TexturePipeline::VertexShader;
 
  auto index_count = indices_.size();
  auto vertex_count = vertices_.size();
  auto size = texture_coverage.size;
  auto origin = texture_coverage.origin;
  auto has_texture_coordinates = HasTextureCoordinates();
  std::vector<VS::PerVertexData> vertex_data(vertex_count);
  {
    for (auto i = 0u; i < vertex_count; i++) {
      auto vertex = vertices_[i];
      auto texture_coord =
          has_texture_coordinates ? texture_coordinates_[i] : vertices_[i];
      auto uv =
          effect_transform * Point((texture_coord.x - origin.x) / size.width,
                                   (texture_coord.y - origin.y) / size.height);
      // From experimentation we need to clamp these values to < 1.0 or else
      // there can be flickering.
      vertex_data[i] = {
          .position = vertex,
          .texture_coords =
              Point(std::clamp(uv.x, 0.0f, 1.0f - kEhCloseEnough),
                    std::clamp(uv.y, 0.0f, 1.0f - kEhCloseEnough)),
      };
    }
  }
 
  size_t total_vtx_bytes = vertex_data.size() * sizeof(VS::PerVertexData);
  size_t total_idx_bytes = index_count * sizeof(uint16_t);
 
  DeviceBufferDescriptor buffer_desc;
  buffer_desc.size = total_vtx_bytes + total_idx_bytes;
  buffer_desc.storage_mode = StorageMode::kHostVisible;
 
  auto buffer =
      renderer.GetContext()->GetResourceAllocator()->CreateBuffer(buffer_desc);
 
  if (!buffer->CopyHostBuffer(reinterpret_cast<uint8_t*>(vertex_data.data()),
                              Range{0, total_vtx_bytes}, 0)) {
    return {};
  }
  if (index_count > 0u &&
      !buffer->CopyHostBuffer(
          reinterpret_cast<uint8_t*>(const_cast<uint16_t*>(indices_.data())),
          Range{0, total_idx_bytes}, total_vtx_bytes)) {
    return {};
  }
 
  return GeometryResult{
      .type = GetPrimitiveType(),
      .vertex_buffer =
          {
              .vertex_buffer = {.buffer = buffer,
                                .range = Range{0, total_vtx_bytes}},
              .index_buffer = {.buffer = buffer,
                               .range =
                                   Range{total_vtx_bytes, total_idx_bytes}},
              .vertex_count = index_count > 0 ? index_count : vertex_count,
              .index_type =
                  index_count > 0 ? IndexType::k16bit : IndexType::kNone,
          },
      .transform = Matrix::MakeOrthographic(pass.GetRenderTargetSize()) *
                   entity.GetTransformation(),
      .prevent_overdraw = false,
  };
}

References impeller::ContentContext::GetContext(), impeller::RenderPass::GetRenderTargetSize(), impeller::Entity::GetTransformation(), HasTextureCoordinates(), impeller::k16bit, impeller::kEhCloseEnough, impeller::kHostVisible, impeller::kNone, impeller::Matrix::MakeOrthographic(), impeller::TRect< T >::origin, impeller::DeviceBufferDescriptor::size, impeller::TRect< T >::size, and impeller::GeometryResult::type.

GetTextureCoordinateCoverge()

std::optional< Rect > impeller::VerticesGeometry::GetTextureCoordinateCoverge

(

)

const

Definition at line 100 of file vertices_geometry.cc.

                                                                      {
  if (!HasTextureCoordinates()) {
    return std::nullopt;
  }
  auto vertex_count = vertices_.size();
  if (vertex_count == 0) {
    return std::nullopt;
  }
 
  return Rect::MakePointBounds(texture_coordinates_.begin(),
                               texture_coordinates_.end());
}

References HasTextureCoordinates(), and impeller::TRect< Scalar >::MakePointBounds().

GetVertexType()

GeometryVertexType impeller::VerticesGeometry::GetVertexType ( ) const

overridevirtual

Implements impeller::Geometry.

Definition at line 293 of file vertices_geometry.cc.

                                                         {
  if (HasVertexColors()) {
    return GeometryVertexType::kColor;
  }
  if (HasTextureCoordinates()) {
    return GeometryVertexType::kUV;
  }
 
  return GeometryVertexType::kPosition;
}

References HasTextureCoordinates(), HasVertexColors(), impeller::kColor, impeller::kPosition, and impeller::kUV.

HasTextureCoordinates()

bool impeller::VerticesGeometry::HasTextureCoordinates

(

)

const

Definition at line 96 of file vertices_geometry.cc.

                                                   {
  return texture_coordinates_.size() > 0;
}

Referenced by GetPositionUVBuffer(), GetTextureCoordinateCoverge(), and GetVertexType().

HasVertexColors()

bool impeller::VerticesGeometry::HasVertexColors

(

)

const

Definition at line 92 of file vertices_geometry.cc.

                                             {
  return colors_.size() > 0;
}

Referenced by GetVertexType().

---

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

• impeller/entity/geometry/vertices_geometry.h
• impeller/entity/geometry/vertices_geometry.cc