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 ()=default
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) const override
GeometryResult	GetPositionBuffer (const ContentContext &renderer, const Entity &entity, RenderPass &pass) const 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
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...
virtual bool	IsAxisAlignedRect () const

Additional Inherited Members
Static Public Member Functions inherited from impeller::Geometry
static std::shared_ptr< Geometry >	MakeFillPath (Path path, std::optional< Rect > inner_rect=std::nullopt)
static std::shared_ptr< Geometry >	MakeStrokePath (Path path, Scalar stroke_width=0.0, Scalar miter_limit=4.0, Cap stroke_cap=Cap::kButt, Join stroke_join=Join::kMiter)
static std::shared_ptr< Geometry >	MakeCover ()
static std::shared_ptr< Geometry >	MakeRect (const Rect &rect)
static std::shared_ptr< Geometry >	MakeOval (const Rect &rect)
static std::shared_ptr< Geometry >	MakeLine (const Point &p0, const Point &p1, Scalar width, Cap cap)
static std::shared_ptr< Geometry >	MakeCircle (const Point &center, Scalar radius)
static std::shared_ptr< Geometry >	MakeStrokedCircle (const Point &center, Scalar radius, Scalar stroke_width)
static std::shared_ptr< Geometry >	MakeRoundRect (const Rect &rect, const Size &radii)
static std::shared_ptr< Geometry >	MakePointField (std::vector< Point > points, Scalar radius, bool round)
Static Protected Member Functions inherited from impeller::Geometry
static GeometryResult	ComputePositionGeometry (const Tessellator::VertexGenerator &generator, const Entity &entity, RenderPass &pass)
static GeometryResult	ComputePositionUVGeometry (const Tessellator::VertexGenerator &generator, const Matrix &uv_transform, const Entity &entity, RenderPass &pass)

Detailed Description

A geometry that is created from a vertices object.

Definition at line 13 of file vertices_geometry.h.

Member Enumeration Documentation

VertexMode

enum impeller::VerticesGeometry::VertexMode

strong

Enumerator
kTriangles
kTriangleStrip
kTriangleFan

Definition at line 15 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 297 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  ) const

overridevirtual

Implements impeller::Geometry.

Definition at line 111 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 = pass.GetOrthographicTransform() * entity.GetTransform(),
      .prevent_overdraw = false,
  };
}

References impeller::ContentContext::GetContext(), impeller::RenderPass::GetOrthographicTransform(), impeller::Entity::GetTransform(), impeller::k16bit, impeller::kHostVisible, impeller::kNone, impeller::DeviceBufferDescriptor::size, and impeller::GeometryResult::type.

GetPositionColorBuffer()

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

Definition at line 158 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 = pass.GetOrthographicTransform() * entity.GetTransform(),
      .prevent_overdraw = false,
  };
}

References impeller::ContentContext::GetContext(), impeller::RenderPass::GetOrthographicTransform(), impeller::Entity::GetTransform(), impeller::k16bit, impeller::kHostVisible, impeller::kNone, 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  ) const

overridevirtual

Implements impeller::Geometry.

Definition at line 216 of file vertices_geometry.cc.

                            {
  using VS = TexturePipeline::VertexShader;
 
  auto index_count = indices_.size();
  auto vertex_count = vertices_.size();
  auto uv_transform =
      texture_coverage.GetNormalizingTransform() * effect_transform;
  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 = uv_transform * texture_coord;
      // 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 = pass.GetOrthographicTransform() * entity.GetTransform(),
      .prevent_overdraw = false,
  };
}

References impeller::ContentContext::GetContext(), impeller::TRect< T >::GetNormalizingTransform(), impeller::RenderPass::GetOrthographicTransform(), impeller::Entity::GetTransform(), HasTextureCoordinates(), impeller::k16bit, impeller::kEhCloseEnough, impeller::kHostVisible, impeller::kNone, impeller::DeviceBufferDescriptor::size, and impeller::GeometryResult::type.

GetTextureCoordinateCoverge()

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

(

)

const

Definition at line 98 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 286 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 94 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 90 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