From 49d14e98fe43fdff818e7571c1a61cd5045fedc0 Mon Sep 17 00:00:00 2001 From: Chris Dalton Date: Fri, 27 Jul 2018 12:38:35 -0600 Subject: sksl: Add a "sk_Clockwise" built-in This allows us to identify clockwise-winding triangles, in terms of Skia device space, in all backends and with all render target origins. Bug: skia: Change-Id: I220e1c459e0129d1cc4dee6458ef94277fbedd21 Reviewed-on: https://skia-review.googlesource.com/142662 Commit-Queue: Chris Dalton Reviewed-by: Ethan Nicholas --- gm/clockwise.cpp | 191 +++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 191 insertions(+) create mode 100644 gm/clockwise.cpp (limited to 'gm') diff --git a/gm/clockwise.cpp b/gm/clockwise.cpp new file mode 100644 index 0000000000..3c01a99372 --- /dev/null +++ b/gm/clockwise.cpp @@ -0,0 +1,191 @@ +/* + * Copyright 2018 Google Inc. + * + * Use of this source code is governed by a BSD-style license that can be + * found in the LICENSE file. + */ + +#include "gm.h" + +#include "GrClip.h" +#include "GrContext.h" +#include "GrGpuCommandBuffer.h" +#include "GrMemoryPool.h" +#include "GrOpFlushState.h" +#include "GrRenderTargetContext.h" +#include "GrRenderTargetContextPriv.h" +#include "GrRenderTarget.h" +#include "glsl/GrGLSLFragmentShaderBuilder.h" +#include "glsl/GrGLSLGeometryProcessor.h" +#include "glsl/GrGLSLVarying.h" +#include "glsl/GrGLSLVertexGeoBuilder.h" + +namespace skiagm { + +static constexpr GrGeometryProcessor::Attribute gVertex{"vertex", kFloat2_GrVertexAttribType}; + +/** + * This is a GPU-backend specific test. It ensures that SkSL properly identifies clockwise-winding + * triangles (sk_Clockwise), in terms of to Skia device space, in all backends and with all render + * target origins. We draw clockwise triangles green and counter-clockwise red. + */ +class ClockwiseGM : public GM { +private: + SkString onShortName() final { return SkString("clockwise"); } + SkISize onISize() override { return SkISize::Make(300, 200); } + void onDraw(SkCanvas*) override; +}; + +//////////////////////////////////////////////////////////////////////////////////////////////////// +// SkSL code. + +class ClockwiseTestProcessor : public GrGeometryProcessor { +public: + ClockwiseTestProcessor(bool readSkFragCoord) + : GrGeometryProcessor(kClockwiseTestProcessor_ClassID) + , fReadSkFragCoord(readSkFragCoord) { + this->setVertexAttributeCnt(1); + } + const char* name() const override { return "ClockwiseTestProcessor"; } + void getGLSLProcessorKey(const GrShaderCaps&, GrProcessorKeyBuilder* b) const final { + b->add32(fReadSkFragCoord); + } + GrGLSLPrimitiveProcessor* createGLSLInstance(const GrShaderCaps&) const final; + +private: + const Attribute& onVertexAttribute(int i) const override { return gVertex; } + + const bool fReadSkFragCoord; + + friend class GLSLClockwiseTestProcessor; +}; + +class GLSLClockwiseTestProcessor : public GrGLSLGeometryProcessor { + void setData(const GrGLSLProgramDataManager& pdman, const GrPrimitiveProcessor&, + FPCoordTransformIter&& transformIter) override {} + + void onEmitCode(EmitArgs& args, GrGPArgs* gpArgs) override { + const ClockwiseTestProcessor& proc = args.fGP.cast(); + args.fVaryingHandler->emitAttributes(proc); + gpArgs->fPositionVar.set(kFloat2_GrSLType, "vertex"); + args.fFragBuilder->codeAppendf( + "%s = sk_Clockwise ? half4(0,1,0,1) : half4(1,0,0,1);", args.fOutputColor); + if (!proc.fReadSkFragCoord) { + args.fFragBuilder->codeAppendf("%s = half4(1);", args.fOutputCoverage); + } else { + // Verify layout(origin_upper_left) on gl_FragCoord does not affect gl_FrontFacing. + args.fFragBuilder->codeAppendf("%s = half4(min(sk_FragCoord.y, 1));", + args.fOutputCoverage); + } + } +}; + +GrGLSLPrimitiveProcessor* ClockwiseTestProcessor::createGLSLInstance( + const GrShaderCaps&) const { + return new GLSLClockwiseTestProcessor; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////// +// Draw Op. + +class ClockwiseTestOp : public GrDrawOp { +public: + DEFINE_OP_CLASS_ID + + static std::unique_ptr Make(GrContext* context, bool readSkFragCoord, int y = 0) { + GrOpMemoryPool* pool = context->contextPriv().opMemoryPool(); + return pool->allocate(readSkFragCoord, y); + } + +private: + ClockwiseTestOp(bool readSkFragCoord, float y) + : GrDrawOp(ClassID()), fReadSkFragCoord(readSkFragCoord), fY(y) { + this->setBounds(SkRect::MakeIWH(300, 100), HasAABloat::kNo, IsZeroArea::kNo); + } + + const char* name() const override { return "ClockwiseTestOp"; } + FixedFunctionFlags fixedFunctionFlags() const override { return FixedFunctionFlags::kNone; } + RequiresDstTexture finalize(const GrCaps&, const GrAppliedClip*) override { + return RequiresDstTexture::kNo; + } + bool onCombineIfPossible(GrOp* other, const GrCaps& caps) override { return false; } + void onPrepare(GrOpFlushState*) override {} + void onExecute(GrOpFlushState* flushState) override { + SkPoint vertices[4] = { + {100, fY}, + {0, fY+100}, + {0, fY}, + {100, fY+100}, + }; + sk_sp vertexBuffer(flushState->resourceProvider()->createBuffer( + sizeof(vertices), kVertex_GrBufferType, kStatic_GrAccessPattern, + GrResourceProvider::kNone_Flag, vertices)); + GrPipeline pipeline(flushState->drawOpArgs().fProxy, GrPipeline::ScissorState::kDisabled, + SkBlendMode::kPlus); + GrMesh mesh(GrPrimitiveType::kTriangleStrip); + mesh.setNonIndexedNonInstanced(4); + mesh.setVertexData(vertexBuffer.get()); + flushState->rtCommandBuffer()->draw(ClockwiseTestProcessor(fReadSkFragCoord), pipeline, + nullptr, nullptr, &mesh, 1, SkRect::MakeIWH(100, 100)); + } + + const bool fReadSkFragCoord; + const float fY; + + friend class ::GrOpMemoryPool; // for ctor +}; + +//////////////////////////////////////////////////////////////////////////////////////////////////// +// Test. + +void ClockwiseGM::onDraw(SkCanvas* canvas) { + GrContext* ctx = canvas->getGrContext(); + GrRenderTargetContext* rtc = canvas->internal_private_accessTopLayerRenderTargetContext(); + if (!ctx || !rtc) { + DrawGpuOnlyMessage(canvas); + return; + } + + rtc->clear(nullptr, GrColorPackRGBA(0,0,0,255), + GrRenderTargetContext::CanClearFullscreen::kYes); + + // Draw the test directly to the frame buffer. + rtc->priv().testingOnly_addDrawOp(ClockwiseTestOp::Make(ctx, false, 0)); + rtc->priv().testingOnly_addDrawOp(ClockwiseTestOp::Make(ctx, true, 100)); + + // Draw the test to an off-screen, top-down render target. + if (auto topLeftRTC = ctx->contextPriv().makeDeferredRenderTargetContext( + SkBackingFit::kExact, 100, 200, rtc->accessRenderTarget()->config(), + nullptr, 1, GrMipMapped::kNo, kTopLeft_GrSurfaceOrigin, nullptr, + SkBudgeted::kYes)) { + topLeftRTC->clear(nullptr, 0, GrRenderTargetContext::CanClearFullscreen::kYes); + topLeftRTC->priv().testingOnly_addDrawOp(ClockwiseTestOp::Make(ctx, false, 0)); + topLeftRTC->priv().testingOnly_addDrawOp(ClockwiseTestOp::Make(ctx, true, 100)); + rtc->drawTexture(GrNoClip(), sk_ref_sp(topLeftRTC->asTextureProxy()), + GrSamplerState::Filter::kNearest, 0xffffffff, {0,0,100,200}, + {100,0,200,200}, GrAA::kNo, + SkCanvas::SrcRectConstraint::kStrict_SrcRectConstraint, SkMatrix::I(), + nullptr); + } + + // Draw the test to an off-screen, bottom-up render target. + if (auto topLeftRTC = ctx->contextPriv().makeDeferredRenderTargetContext( + SkBackingFit::kExact, 100, 200, rtc->accessRenderTarget()->config(), + nullptr, 1, GrMipMapped::kNo, kBottomLeft_GrSurfaceOrigin, nullptr, + SkBudgeted::kYes)) { + topLeftRTC->clear(nullptr, 0, GrRenderTargetContext::CanClearFullscreen::kYes); + topLeftRTC->priv().testingOnly_addDrawOp(ClockwiseTestOp::Make(ctx, false, 0)); + topLeftRTC->priv().testingOnly_addDrawOp(ClockwiseTestOp::Make(ctx, true, 100)); + rtc->drawTexture(GrNoClip(), sk_ref_sp(topLeftRTC->asTextureProxy()), + GrSamplerState::Filter::kNearest, 0xffffffff, {0,0,100,200}, + {200,0,300,200}, GrAA::kNo, + SkCanvas::SrcRectConstraint::kStrict_SrcRectConstraint, SkMatrix::I(), + nullptr); + } +} + +//////////////////////////////////////////////////////////////////////////////////////////////////// + +DEF_GM( return new ClockwiseGM(); ) + +} -- cgit v1.2.3