123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299 |
- /*
- * Copyright 2017 Google Inc.
- *
- * Use of this source code is governed by a BSD-style license that can be
- * found in the LICENSE file.
- */
- #ifndef GrCCCoverageProcessor_DEFINED
- #define GrCCCoverageProcessor_DEFINED
- #include "include/private/SkNx.h"
- #include "src/gpu/GrCaps.h"
- #include "src/gpu/GrGeometryProcessor.h"
- #include "src/gpu/GrPipeline.h"
- #include "src/gpu/GrShaderCaps.h"
- #include "src/gpu/glsl/GrGLSLGeometryProcessor.h"
- #include "src/gpu/glsl/GrGLSLVarying.h"
- class GrGLSLFPFragmentBuilder;
- class GrGLSLVertexGeoBuilder;
- class GrMesh;
- class GrOpFlushState;
- /**
- * This is the geometry processor for the simple convex primitive shapes (triangles and closed,
- * convex bezier curves) from which ccpr paths are composed. The output is a single-channel alpha
- * value, positive for clockwise shapes and negative for counter-clockwise, that indicates coverage.
- *
- * The caller is responsible to draw all primitives as produced by GrCCGeometry into a cleared,
- * floating point, alpha-only render target using SkBlendMode::kPlus. Once all of a path's
- * primitives have been drawn, the render target contains a composite coverage count that can then
- * be used to draw the path (see GrCCPathProcessor).
- *
- * To draw primitives, use appendMesh() and draw() (defined below).
- */
- class GrCCCoverageProcessor : public GrGeometryProcessor {
- public:
- enum class PrimitiveType {
- kTriangles,
- kWeightedTriangles, // Triangles (from the tessellator) whose winding magnitude > 1.
- kQuadratics,
- kCubics,
- kConics
- };
- static const char* PrimitiveTypeName(PrimitiveType);
- // Defines a single primitive shape with 3 input points (i.e. Triangles and Quadratics).
- // X,Y point values are transposed.
- struct TriPointInstance {
- float fValues[6];
- enum class Ordering : bool {
- kXYTransposed,
- kXYInterleaved,
- };
- void set(const SkPoint[3], const Sk2f& translate, Ordering);
- void set(const SkPoint&, const SkPoint&, const SkPoint&, const Sk2f& translate, Ordering);
- void set(const Sk2f& P0, const Sk2f& P1, const Sk2f& P2, const Sk2f& translate, Ordering);
- };
- // Defines a single primitive shape with 4 input points, or 3 input points plus a "weight"
- // parameter duplicated in both lanes of the 4th input (i.e. Cubics, Conics, and Triangles with
- // a weighted winding number). X,Y point values are transposed.
- struct QuadPointInstance {
- float fX[4];
- float fY[4];
- void set(const SkPoint[4], float dx, float dy);
- void setW(const SkPoint[3], const Sk2f& trans, float w);
- void setW(const SkPoint&, const SkPoint&, const SkPoint&, const Sk2f& trans, float w);
- void setW(const Sk2f& P0, const Sk2f& P1, const Sk2f& P2, const Sk2f& trans, float w);
- };
- virtual void reset(PrimitiveType, GrResourceProvider*) = 0;
- PrimitiveType primitiveType() const { return fPrimitiveType; }
- // Number of bezier points for curves, or 3 for triangles.
- int numInputPoints() const { return PrimitiveType::kCubics == fPrimitiveType ? 4 : 3; }
- bool isTriangles() const {
- return PrimitiveType::kTriangles == fPrimitiveType ||
- PrimitiveType::kWeightedTriangles == fPrimitiveType;
- }
- int hasInputWeight() const {
- return PrimitiveType::kWeightedTriangles == fPrimitiveType ||
- PrimitiveType::kConics == fPrimitiveType;
- }
- // GrPrimitiveProcessor overrides.
- const char* name() const override { return PrimitiveTypeName(fPrimitiveType); }
- #ifdef SK_DEBUG
- SkString dumpInfo() const override {
- return SkStringPrintf("%s\n%s", this->name(), this->INHERITED::dumpInfo().c_str());
- }
- #endif
- void getGLSLProcessorKey(const GrShaderCaps&, GrProcessorKeyBuilder* b) const override {
- SkDEBUGCODE(this->getDebugBloatKey(b));
- b->add32((int)fPrimitiveType);
- }
- GrGLSLPrimitiveProcessor* createGLSLInstance(const GrShaderCaps&) const final;
- #ifdef SK_DEBUG
- // Increases the 1/2 pixel AA bloat by a factor of debugBloat.
- void enableDebugBloat(float debugBloat) { fDebugBloat = debugBloat; }
- bool debugBloatEnabled() const { return fDebugBloat > 0; }
- float debugBloat() const { SkASSERT(this->debugBloatEnabled()); return fDebugBloat; }
- void getDebugBloatKey(GrProcessorKeyBuilder* b) const {
- uint32_t bloatBits;
- memcpy(&bloatBits, &fDebugBloat, 4);
- b->add32(bloatBits);
- }
- #endif
- // Appends a GrMesh that will draw the provided instances. The instanceBuffer must be an array
- // of either TriPointInstance or QuadPointInstance, depending on this processor's RendererPass,
- // with coordinates in the desired shape's final atlas-space position.
- virtual void appendMesh(sk_sp<const GrGpuBuffer> instanceBuffer, int instanceCount,
- int baseInstance, SkTArray<GrMesh>* out) const = 0;
- virtual void draw(GrOpFlushState*, const GrPipeline&, const SkIRect scissorRects[],
- const GrMesh[], int meshCount, const SkRect& drawBounds) const;
- // The Shader provides code to calculate each pixel's coverage in a RenderPass. It also
- // provides details about shape-specific geometry.
- class Shader {
- public:
- // Returns true if the Impl should not calculate the coverage argument for emitVaryings().
- // If true, then "coverage" will have a signed magnitude of 1.
- virtual bool calculatesOwnEdgeCoverage() const { return false; }
- // Called before generating geometry. Subclasses may set up internal member variables during
- // this time that will be needed during onEmitVaryings (e.g. transformation matrices).
- //
- // If the 'outHull4' parameter is provided, and there are not 4 input points, the subclass
- // is required to fill it with the name of a 4-point hull around which the Impl can generate
- // its geometry. If it is left unchanged, the Impl will use the regular input points.
- virtual void emitSetupCode(
- GrGLSLVertexGeoBuilder*, const char* pts, const char** outHull4 = nullptr) const {
- SkASSERT(!outHull4);
- }
- void emitVaryings(
- GrGLSLVaryingHandler* varyingHandler, GrGLSLVarying::Scope scope, SkString* code,
- const char* position, const char* coverage, const char* cornerCoverage,
- const char* wind) {
- SkASSERT(GrGLSLVarying::Scope::kVertToGeo != scope);
- this->onEmitVaryings(
- varyingHandler, scope, code, position, coverage, cornerCoverage, wind);
- }
- // Writes the signed coverage value at the current pixel to "outputCoverage".
- virtual void emitFragmentCoverageCode(
- GrGLSLFPFragmentBuilder*, const char* outputCoverage) const = 0;
- // Assigns the built-in sample mask at the current pixel.
- virtual void emitSampleMaskCode(GrGLSLFPFragmentBuilder*) const = 0;
- // Calculates the winding direction of the input points (+1, -1, or 0). Wind for extremely
- // thin triangles gets rounded to zero.
- static void CalcWind(const GrCCCoverageProcessor&, GrGLSLVertexGeoBuilder*, const char* pts,
- const char* outputWind);
- // Calculates an edge's coverage at a conservative raster vertex. The edge is defined by two
- // clockwise-ordered points, 'leftPt' and 'rightPt'. 'rasterVertexDir' is a pair of +/-1
- // values that point in the direction of conservative raster bloat, starting from an
- // endpoint.
- //
- // Coverage values ramp from -1 (completely outside the edge) to 0 (completely inside).
- static void CalcEdgeCoverageAtBloatVertex(GrGLSLVertexGeoBuilder*, const char* leftPt,
- const char* rightPt, const char* rasterVertexDir,
- const char* outputCoverage);
- // Calculates an edge's coverage at two conservative raster vertices.
- // (See CalcEdgeCoverageAtBloatVertex).
- static void CalcEdgeCoveragesAtBloatVertices(GrGLSLVertexGeoBuilder*, const char* leftPt,
- const char* rightPt, const char* bloatDir1,
- const char* bloatDir2,
- const char* outputCoverages);
- // Corner boxes require an additional "attenuation" varying that is multiplied by the
- // regular (linearly-interpolated) coverage. This function calculates the attenuation value
- // to use in the single, outermost vertex. The remaining three vertices of the corner box
- // all use an attenuation value of 1.
- static void CalcCornerAttenuation(GrGLSLVertexGeoBuilder*, const char* leftDir,
- const char* rightDir, const char* outputAttenuation);
- virtual ~Shader() {}
- protected:
- // Here the subclass adds its internal varyings to the handler and produces code to
- // initialize those varyings from a given position and coverage values.
- //
- // NOTE: the coverage values are signed appropriately for wind.
- // 'coverage' will only be +1 or -1 on curves.
- virtual void onEmitVaryings(
- GrGLSLVaryingHandler*, GrGLSLVarying::Scope, SkString* code, const char* position,
- const char* coverage, const char* cornerCoverage, const char* wind) = 0;
- // Returns the name of a Shader's internal varying at the point where where its value is
- // assigned. This is intended to work whether called for a vertex or a geometry shader.
- const char* OutName(const GrGLSLVarying& varying) const {
- using Scope = GrGLSLVarying::Scope;
- SkASSERT(Scope::kVertToGeo != varying.scope());
- return Scope::kGeoToFrag == varying.scope() ? varying.gsOut() : varying.vsOut();
- }
- // Our friendship with GrGLSLShaderBuilder does not propagate to subclasses.
- inline static SkString& AccessCodeString(GrGLSLShaderBuilder* s) { return s->code(); }
- };
- protected:
- // Slightly undershoot a bloat radius of 0.5 so vertices that fall on integer boundaries don't
- // accidentally bleed into neighbor pixels.
- static constexpr float kAABloatRadius = 0.491111f;
- GrCCCoverageProcessor(ClassID classID) : INHERITED(classID) {}
- virtual GrGLSLPrimitiveProcessor* onCreateGLSLInstance(std::unique_ptr<Shader>) const = 0;
- // Our friendship with GrGLSLShaderBuilder does not propagate to subclasses.
- inline static SkString& AccessCodeString(GrGLSLShaderBuilder* s) { return s->code(); }
- PrimitiveType fPrimitiveType;
- SkDEBUGCODE(float fDebugBloat = 0);
- class TriangleShader;
- typedef GrGeometryProcessor INHERITED;
- };
- inline const char* GrCCCoverageProcessor::PrimitiveTypeName(PrimitiveType type) {
- switch (type) {
- case PrimitiveType::kTriangles: return "kTriangles";
- case PrimitiveType::kWeightedTriangles: return "kWeightedTriangles";
- case PrimitiveType::kQuadratics: return "kQuadratics";
- case PrimitiveType::kCubics: return "kCubics";
- case PrimitiveType::kConics: return "kConics";
- }
- SK_ABORT("Invalid PrimitiveType");
- return "";
- }
- inline void GrCCCoverageProcessor::TriPointInstance::set(
- const SkPoint p[3], const Sk2f& translate, Ordering ordering) {
- this->set(p[0], p[1], p[2], translate, ordering);
- }
- inline void GrCCCoverageProcessor::TriPointInstance::set(
- const SkPoint& p0, const SkPoint& p1, const SkPoint& p2, const Sk2f& translate,
- Ordering ordering) {
- Sk2f P0 = Sk2f::Load(&p0);
- Sk2f P1 = Sk2f::Load(&p1);
- Sk2f P2 = Sk2f::Load(&p2);
- this->set(P0, P1, P2, translate, ordering);
- }
- inline void GrCCCoverageProcessor::TriPointInstance::set(
- const Sk2f& P0, const Sk2f& P1, const Sk2f& P2, const Sk2f& translate, Ordering ordering) {
- if (Ordering::kXYTransposed == ordering) {
- Sk2f::Store3(fValues, P0 + translate, P1 + translate, P2 + translate);
- } else {
- (P0 + translate).store(fValues);
- (P1 + translate).store(fValues + 2);
- (P2 + translate).store(fValues + 4);
- }
- }
- inline void GrCCCoverageProcessor::QuadPointInstance::set(const SkPoint p[4], float dx, float dy) {
- Sk4f X,Y;
- Sk4f::Load2(p, &X, &Y);
- (X + dx).store(&fX);
- (Y + dy).store(&fY);
- }
- inline void GrCCCoverageProcessor::QuadPointInstance::setW(const SkPoint p[3], const Sk2f& trans,
- float w) {
- this->setW(p[0], p[1], p[2], trans, w);
- }
- inline void GrCCCoverageProcessor::QuadPointInstance::setW(const SkPoint& p0, const SkPoint& p1,
- const SkPoint& p2, const Sk2f& trans,
- float w) {
- Sk2f P0 = Sk2f::Load(&p0);
- Sk2f P1 = Sk2f::Load(&p1);
- Sk2f P2 = Sk2f::Load(&p2);
- this->setW(P0, P1, P2, trans, w);
- }
- inline void GrCCCoverageProcessor::QuadPointInstance::setW(const Sk2f& P0, const Sk2f& P1,
- const Sk2f& P2, const Sk2f& trans,
- float w) {
- Sk2f W = Sk2f(w);
- Sk2f::Store4(this, P0 + trans, P1 + trans, P2 + trans, W);
- }
- #endif
|