| // Copyright 2013 The Flutter Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "impeller/entity/geometry/geometry.h" |
| |
| #include <memory> |
| #include <optional> |
| |
| #include "impeller/entity/geometry/cover_geometry.h" |
| #include "impeller/entity/geometry/ellipse_geometry.h" |
| #include "impeller/entity/geometry/fill_path_geometry.h" |
| #include "impeller/entity/geometry/line_geometry.h" |
| #include "impeller/entity/geometry/point_field_geometry.h" |
| #include "impeller/entity/geometry/rect_geometry.h" |
| #include "impeller/entity/geometry/stroke_path_geometry.h" |
| #include "impeller/geometry/rect.h" |
| |
| namespace impeller { |
| |
| VertexBufferBuilder<TextureFillVertexShader::PerVertexData> |
| ComputeUVGeometryCPU( |
| VertexBufferBuilder<SolidFillVertexShader::PerVertexData>& input, |
| Point texture_origin, |
| Size texture_coverage, |
| Matrix effect_transform) { |
| VertexBufferBuilder<TextureFillVertexShader::PerVertexData> vertex_builder; |
| vertex_builder.Reserve(input.GetVertexCount()); |
| input.IterateVertices( |
| [&vertex_builder, &texture_coverage, &effect_transform, |
| &texture_origin](SolidFillVertexShader::PerVertexData old_vtx) { |
| TextureFillVertexShader::PerVertexData data; |
| data.position = old_vtx.position; |
| data.texture_coords = effect_transform * |
| (old_vtx.position - texture_origin) / |
| texture_coverage; |
| vertex_builder.AppendVertex(data); |
| }); |
| return vertex_builder; |
| } |
| |
| GeometryResult ComputeUVGeometryForRect(Rect source_rect, |
| Rect texture_coverage, |
| Matrix effect_transform, |
| const ContentContext& renderer, |
| const Entity& entity, |
| RenderPass& pass) { |
| auto& host_buffer = pass.GetTransientsBuffer(); |
| |
| auto uv_transform = |
| texture_coverage.GetNormalizingTransform() * effect_transform; |
| std::vector<Point> data(8); |
| auto points = source_rect.GetPoints(); |
| for (auto i = 0u, j = 0u; i < 8; i += 2, j++) { |
| data[i] = points[j]; |
| data[i + 1] = uv_transform * points[j]; |
| } |
| |
| return GeometryResult{ |
| .type = PrimitiveType::kTriangleStrip, |
| .vertex_buffer = |
| { |
| .vertex_buffer = host_buffer.Emplace( |
| data.data(), 16 * sizeof(float), alignof(float)), |
| .vertex_count = 4, |
| .index_type = IndexType::kNone, |
| }, |
| .transform = Matrix::MakeOrthographic(pass.GetRenderTargetSize()) * |
| entity.GetTransform(), |
| .prevent_overdraw = false, |
| }; |
| } |
| |
| GeometryResult Geometry::GetPositionUVBuffer(Rect texture_coverage, |
| Matrix effect_transform, |
| const ContentContext& renderer, |
| const Entity& entity, |
| RenderPass& pass) const { |
| return {}; |
| } |
| |
| std::shared_ptr<Geometry> Geometry::MakeFillPath( |
| const Path& path, |
| std::optional<Rect> inner_rect) { |
| return std::make_shared<FillPathGeometry>(path, inner_rect); |
| } |
| |
| std::shared_ptr<Geometry> Geometry::MakePointField(std::vector<Point> points, |
| Scalar radius, |
| bool round) { |
| return std::make_shared<PointFieldGeometry>(std::move(points), radius, round); |
| } |
| |
| std::shared_ptr<Geometry> Geometry::MakeStrokePath(const Path& path, |
| Scalar stroke_width, |
| Scalar miter_limit, |
| Cap stroke_cap, |
| Join stroke_join) { |
| // Skia behaves like this. |
| if (miter_limit < 0) { |
| miter_limit = 4.0; |
| } |
| return std::make_shared<StrokePathGeometry>(path, stroke_width, miter_limit, |
| stroke_cap, stroke_join); |
| } |
| |
| std::shared_ptr<Geometry> Geometry::MakeCover() { |
| return std::make_shared<CoverGeometry>(); |
| } |
| |
| std::shared_ptr<Geometry> Geometry::MakeRect(Rect rect) { |
| return std::make_shared<RectGeometry>(rect); |
| } |
| |
| std::shared_ptr<Geometry> Geometry::MakeLine(Point p0, |
| Point p1, |
| Scalar width, |
| Cap cap) { |
| return std::make_shared<LineGeometry>(p0, p1, width, cap); |
| } |
| |
| std::shared_ptr<Geometry> Geometry::MakeCircle(Point center, Scalar radius) { |
| return std::make_shared<EllipseGeometry>(center, radius); |
| } |
| |
| bool Geometry::CoversArea(const Matrix& transform, const Rect& rect) const { |
| return false; |
| } |
| |
| bool Geometry::IsAxisAlignedRect() const { |
| return false; |
| } |
| |
| } // namespace impeller |