Michael Ludwig | 460eb5e | 2018-10-29 11:09:29 -0400 | [diff] [blame] | 1 | /* |
| 2 | * Copyright 2018 Google Inc. |
| 3 | * |
| 4 | * Use of this source code is governed by a BSD-style license that can be |
| 5 | * found in the LICENSE file. |
| 6 | */ |
| 7 | |
| 8 | #ifndef GrQuadPerEdgeAA_DEFINED |
| 9 | #define GrQuadPerEdgeAA_DEFINED |
| 10 | |
Mike Klein | c0bd9f9 | 2019-04-23 12:05:21 -0500 | [diff] [blame] | 11 | #include "include/core/SkPoint.h" |
| 12 | #include "include/core/SkPoint3.h" |
Mike Klein | c0bd9f9 | 2019-04-23 12:05:21 -0500 | [diff] [blame] | 13 | #include "include/private/GrTypesPriv.h" |
Greg Daniel | f91aeb2 | 2019-06-18 09:58:02 -0400 | [diff] [blame] | 14 | #include "src/gpu/GrColor.h" |
Mike Klein | c0bd9f9 | 2019-04-23 12:05:21 -0500 | [diff] [blame] | 15 | #include "src/gpu/GrGeometryProcessor.h" |
Brian Salomon | 201cdbb | 2019-08-14 17:00:30 -0400 | [diff] [blame] | 16 | #include "src/gpu/GrSamplerState.h" |
Michael Ludwig | fd4f4df | 2019-05-29 09:51:09 -0400 | [diff] [blame] | 17 | #include "src/gpu/geometry/GrQuad.h" |
Mike Klein | c0bd9f9 | 2019-04-23 12:05:21 -0500 | [diff] [blame] | 18 | #include "src/gpu/ops/GrMeshDrawOp.h" |
Brian Salomon | f19f9ca | 2019-09-18 15:54:26 -0400 | [diff] [blame] | 19 | #include "src/gpu/ops/GrTextureOp.h" |
Michael Ludwig | 460eb5e | 2018-10-29 11:09:29 -0400 | [diff] [blame] | 20 | |
Brian Osman | 8fa7ab4 | 2019-03-18 10:22:42 -0400 | [diff] [blame] | 21 | class GrCaps; |
Michael Ludwig | 467994d | 2018-12-03 14:58:31 +0000 | [diff] [blame] | 22 | class GrColorSpaceXform; |
| 23 | class GrShaderCaps; |
Michael Ludwig | 460eb5e | 2018-10-29 11:09:29 -0400 | [diff] [blame] | 24 | |
Michael Ludwig | c182b94 | 2018-11-16 10:27:51 -0500 | [diff] [blame] | 25 | namespace GrQuadPerEdgeAA { |
Brian Salomon | f19f9ca | 2019-09-18 15:54:26 -0400 | [diff] [blame] | 26 | using Saturate = GrTextureOp::Saturate; |
Michael Ludwig | c182b94 | 2018-11-16 10:27:51 -0500 | [diff] [blame] | 27 | |
Michael Ludwig | 460eb5e | 2018-10-29 11:09:29 -0400 | [diff] [blame] | 28 | enum class Domain : bool { kNo = false, kYes = true }; |
Brian Osman | 3d139a4 | 2018-11-19 10:42:10 -0500 | [diff] [blame] | 29 | enum class ColorType { kNone, kByte, kHalf, kLast = kHalf }; |
| 30 | static const int kColorTypeCount = static_cast<int>(ColorType::kLast) + 1; |
Michael Ludwig | 460eb5e | 2018-10-29 11:09:29 -0400 | [diff] [blame] | 31 | |
Brian Salomon | 1d83542 | 2019-03-13 16:11:44 -0400 | [diff] [blame] | 32 | // Gets the minimum ColorType that can represent a color. |
Brian Osman | 8fa7ab4 | 2019-03-18 10:22:42 -0400 | [diff] [blame] | 33 | ColorType MinColorType(SkPMColor4f, GrClampType, const GrCaps&); |
Brian Salomon | 1d83542 | 2019-03-13 16:11:44 -0400 | [diff] [blame] | 34 | |
Michael Ludwig | c182b94 | 2018-11-16 10:27:51 -0500 | [diff] [blame] | 35 | // Specifies the vertex configuration for an op that renders per-edge AA quads. The vertex |
| 36 | // order (when enabled) is device position, color, local position, domain, aa edge equations. |
| 37 | // This order matches the constructor argument order of VertexSpec and is the order that |
| 38 | // GPAttributes maintains. If hasLocalCoords is false, then the local quad type can be ignored. |
| 39 | struct VertexSpec { |
| 40 | public: |
Michael Ludwig | de4c58c | 2019-06-04 09:12:59 -0400 | [diff] [blame] | 41 | VertexSpec(GrQuad::Type deviceQuadType, ColorType colorType, GrQuad::Type localQuadType, |
Brian Osman | 605c6d5 | 2019-03-15 12:10:35 -0400 | [diff] [blame] | 42 | bool hasLocalCoords, Domain domain, GrAAType aa, bool coverageAsAlpha) |
Michael Ludwig | c182b94 | 2018-11-16 10:27:51 -0500 | [diff] [blame] | 43 | : fDeviceQuadType(static_cast<unsigned>(deviceQuadType)) |
| 44 | , fLocalQuadType(static_cast<unsigned>(localQuadType)) |
| 45 | , fHasLocalCoords(hasLocalCoords) |
Brian Osman | 3d139a4 | 2018-11-19 10:42:10 -0500 | [diff] [blame] | 46 | , fColorType(static_cast<unsigned>(colorType)) |
Michael Ludwig | c182b94 | 2018-11-16 10:27:51 -0500 | [diff] [blame] | 47 | , fHasDomain(static_cast<unsigned>(domain)) |
Michael Ludwig | 93aeba0 | 2018-12-21 09:50:31 -0500 | [diff] [blame] | 48 | , fUsesCoverageAA(aa == GrAAType::kCoverage) |
Michael Ludwig | dcfbe32 | 2019-04-01 14:55:54 -0400 | [diff] [blame] | 49 | , fCompatibleWithCoverageAsAlpha(coverageAsAlpha) |
| 50 | , fRequiresGeometryDomain(aa == GrAAType::kCoverage && |
Michael Ludwig | de4c58c | 2019-06-04 09:12:59 -0400 | [diff] [blame] | 51 | deviceQuadType > GrQuad::Type::kRectilinear) { } |
Michael Ludwig | 460eb5e | 2018-10-29 11:09:29 -0400 | [diff] [blame] | 52 | |
Michael Ludwig | de4c58c | 2019-06-04 09:12:59 -0400 | [diff] [blame] | 53 | GrQuad::Type deviceQuadType() const { return static_cast<GrQuad::Type>(fDeviceQuadType); } |
| 54 | GrQuad::Type localQuadType() const { return static_cast<GrQuad::Type>(fLocalQuadType); } |
Michael Ludwig | c182b94 | 2018-11-16 10:27:51 -0500 | [diff] [blame] | 55 | bool hasLocalCoords() const { return fHasLocalCoords; } |
Brian Osman | 3d139a4 | 2018-11-19 10:42:10 -0500 | [diff] [blame] | 56 | ColorType colorType() const { return static_cast<ColorType>(fColorType); } |
| 57 | bool hasVertexColors() const { return ColorType::kNone != this->colorType(); } |
Michael Ludwig | c182b94 | 2018-11-16 10:27:51 -0500 | [diff] [blame] | 58 | bool hasDomain() const { return fHasDomain; } |
| 59 | bool usesCoverageAA() const { return fUsesCoverageAA; } |
Brian Osman | 605c6d5 | 2019-03-15 12:10:35 -0400 | [diff] [blame] | 60 | bool compatibleWithCoverageAsAlpha() const { return fCompatibleWithCoverageAsAlpha; } |
Michael Ludwig | dcfbe32 | 2019-04-01 14:55:54 -0400 | [diff] [blame] | 61 | bool requiresGeometryDomain() const { return fRequiresGeometryDomain; } |
Michael Ludwig | c182b94 | 2018-11-16 10:27:51 -0500 | [diff] [blame] | 62 | // Will always be 2 or 3 |
| 63 | int deviceDimensionality() const; |
| 64 | // Will always be 0 if hasLocalCoords is false, otherwise will be 2 or 3 |
| 65 | int localDimensionality() const; |
Michael Ludwig | 460eb5e | 2018-10-29 11:09:29 -0400 | [diff] [blame] | 66 | |
Michael Ludwig | 93aeba0 | 2018-12-21 09:50:31 -0500 | [diff] [blame] | 67 | int verticesPerQuad() const { return fUsesCoverageAA ? 8 : 4; } |
Michael Ludwig | c182b94 | 2018-11-16 10:27:51 -0500 | [diff] [blame] | 68 | private: |
Michael Ludwig | de4c58c | 2019-06-04 09:12:59 -0400 | [diff] [blame] | 69 | static_assert(GrQuad::kTypeCount <= 4, "GrQuad::Type doesn't fit in 2 bits"); |
Brian Osman | 3d139a4 | 2018-11-19 10:42:10 -0500 | [diff] [blame] | 70 | static_assert(kColorTypeCount <= 4, "Color doesn't fit in 2 bits"); |
Michael Ludwig | 460eb5e | 2018-10-29 11:09:29 -0400 | [diff] [blame] | 71 | |
Michael Ludwig | c182b94 | 2018-11-16 10:27:51 -0500 | [diff] [blame] | 72 | unsigned fDeviceQuadType: 2; |
| 73 | unsigned fLocalQuadType: 2; |
| 74 | unsigned fHasLocalCoords: 1; |
Brian Osman | 3d139a4 | 2018-11-19 10:42:10 -0500 | [diff] [blame] | 75 | unsigned fColorType : 2; |
Michael Ludwig | c182b94 | 2018-11-16 10:27:51 -0500 | [diff] [blame] | 76 | unsigned fHasDomain: 1; |
| 77 | unsigned fUsesCoverageAA: 1; |
Brian Osman | 605c6d5 | 2019-03-15 12:10:35 -0400 | [diff] [blame] | 78 | unsigned fCompatibleWithCoverageAsAlpha: 1; |
Michael Ludwig | dcfbe32 | 2019-04-01 14:55:54 -0400 | [diff] [blame] | 79 | // The geometry domain serves to clip off pixels touched by quads with sharp corners that |
| 80 | // would otherwise exceed the miter limit for the AA-outset geometry. |
| 81 | unsigned fRequiresGeometryDomain: 1; |
Michael Ludwig | 460eb5e | 2018-10-29 11:09:29 -0400 | [diff] [blame] | 82 | }; |
| 83 | |
Michael Ludwig | 467994d | 2018-12-03 14:58:31 +0000 | [diff] [blame] | 84 | sk_sp<GrGeometryProcessor> MakeProcessor(const VertexSpec& spec); |
Michael Ludwig | 20e909e | 2018-10-30 10:43:57 -0400 | [diff] [blame] | 85 | |
Brian Salomon | 67529b2 | 2019-08-13 15:31:04 -0400 | [diff] [blame] | 86 | sk_sp<GrGeometryProcessor> MakeTexturedProcessor( |
| 87 | const VertexSpec& spec, const GrShaderCaps& caps, GrTextureType textureType, |
Greg Daniel | 2c3398d | 2019-06-19 11:58:01 -0400 | [diff] [blame] | 88 | const GrSamplerState& samplerState, const GrSwizzle& swizzle, uint32_t extraSamplerKey, |
Brian Salomon | f19f9ca | 2019-09-18 15:54:26 -0400 | [diff] [blame] | 89 | sk_sp<GrColorSpaceXform> textureColorSpaceXform, Saturate saturate); |
Michael Ludwig | 20e909e | 2018-10-30 10:43:57 -0400 | [diff] [blame] | 90 | |
Michael Ludwig | c182b94 | 2018-11-16 10:27:51 -0500 | [diff] [blame] | 91 | // Fill vertices with the vertex data needed to represent the given quad. The device position, |
| 92 | // local coords, vertex color, domain, and edge coefficients will be written and/or computed |
| 93 | // based on the configuration in the vertex spec; if that attribute is disabled in the spec, |
| 94 | // then its corresponding function argument is ignored. |
| 95 | // |
Michael Ludwig | de4c58c | 2019-06-04 09:12:59 -0400 | [diff] [blame] | 96 | // Tessellation is based on the quad type of the vertex spec, not the provided GrQuad's |
Michael Ludwig | 41f395d | 2019-05-23 13:59:45 -0400 | [diff] [blame] | 97 | // so that all quads in a batch are tessellated the same. |
| 98 | // |
Michael Ludwig | c182b94 | 2018-11-16 10:27:51 -0500 | [diff] [blame] | 99 | // Returns the advanced pointer in vertices. |
Michael Ludwig | de4c58c | 2019-06-04 09:12:59 -0400 | [diff] [blame] | 100 | void* Tessellate(void* vertices, const VertexSpec& spec, const GrQuad& deviceQuad, |
| 101 | const SkPMColor4f& color, const GrQuad& localQuad, const SkRect& domain, |
Michael Ludwig | c182b94 | 2018-11-16 10:27:51 -0500 | [diff] [blame] | 102 | GrQuadAAFlags aa); |
Michael Ludwig | 460eb5e | 2018-10-29 11:09:29 -0400 | [diff] [blame] | 103 | |
Michael Ludwig | 93aeba0 | 2018-12-21 09:50:31 -0500 | [diff] [blame] | 104 | // The mesh will have its index data configured to meet the expectations of the Tessellate() |
| 105 | // function, but it the calling code must handle filling a vertex buffer via Tessellate() and |
| 106 | // then assigning it to the returned mesh. |
| 107 | // |
| 108 | // Returns false if the index data could not be allocated. |
| 109 | bool ConfigureMeshIndices(GrMeshDrawOp::Target* target, GrMesh* mesh, const VertexSpec& spec, |
| 110 | int quadCount); |
| 111 | |
| 112 | static constexpr int kNumAAQuadsInIndexBuffer = 512; |
| 113 | |
Michael Ludwig | c182b94 | 2018-11-16 10:27:51 -0500 | [diff] [blame] | 114 | } // namespace GrQuadPerEdgeAA |
Michael Ludwig | 460eb5e | 2018-10-29 11:09:29 -0400 | [diff] [blame] | 115 | |
| 116 | #endif // GrQuadPerEdgeAA_DEFINED |