70fe17e12f
I think this is vestigial from some time in the past where RTC was public. Also just expose the methods that add ops rather than have so many friends + testingOnly versions. Change-Id: I60d9fdff23b2d67039a7b37815da7ff9e73d8999 Reviewed-on: https://skia-review.googlesource.com/c/skia/+/339158 Commit-Queue: Brian Salomon <bsalomon@google.com> Reviewed-by: Robert Phillips <robertphillips@google.com>
351 lines
13 KiB
C++
351 lines
13 KiB
C++
/*
|
|
* Copyright 2016 Google Inc.
|
|
*
|
|
* Use of this source code is governed by a BSD-style license that can be
|
|
* found in the LICENSE file.
|
|
*/
|
|
|
|
#include "bench/Benchmark.h"
|
|
|
|
#include "include/core/SkString.h"
|
|
#include "include/gpu/GrDirectContext.h"
|
|
#include "include/private/SkHalf.h"
|
|
#include "src/core/SkColorSpacePriv.h"
|
|
#include "src/gpu/GrDirectContextPriv.h"
|
|
#include "src/gpu/GrGeometryProcessor.h"
|
|
#include "src/gpu/GrMemoryPool.h"
|
|
#include "src/gpu/GrProgramInfo.h"
|
|
#include "src/gpu/GrRenderTargetContext.h"
|
|
#include "src/gpu/SkGr.h"
|
|
#include "src/gpu/glsl/GrGLSLColorSpaceXformHelper.h"
|
|
#include "src/gpu/glsl/GrGLSLFragmentShaderBuilder.h"
|
|
#include "src/gpu/glsl/GrGLSLGeometryProcessor.h"
|
|
#include "src/gpu/glsl/GrGLSLVarying.h"
|
|
#include "src/gpu/glsl/GrGLSLVertexGeoBuilder.h"
|
|
#include "src/gpu/ops/GrMeshDrawOp.h"
|
|
#include "src/gpu/ops/GrSimpleMeshDrawOpHelper.h"
|
|
|
|
namespace {
|
|
|
|
enum Mode {
|
|
kBaseline_Mode, // Do the wrong thing, but quickly.
|
|
kFloat_Mode, // Transform colors on CPU, use float4 attributes.
|
|
kHalf_Mode, // Transform colors on CPU, use half4 attributes.
|
|
kShader_Mode, // Use ubyte4 attributes, transform colors on GPU (vertex shader).
|
|
};
|
|
|
|
class GP : public GrGeometryProcessor {
|
|
public:
|
|
static GrGeometryProcessor* Make(SkArenaAlloc* arena, Mode mode,
|
|
sk_sp<GrColorSpaceXform> colorSpaceXform) {
|
|
return arena->make<GP>(mode, std::move(colorSpaceXform));
|
|
}
|
|
|
|
const char* name() const override { return "VertexColorXformGP"; }
|
|
|
|
GrGLSLPrimitiveProcessor* createGLSLInstance(const GrShaderCaps&) const override {
|
|
class GLSLGP : public GrGLSLGeometryProcessor {
|
|
public:
|
|
void onEmitCode(EmitArgs& args, GrGPArgs* gpArgs) override {
|
|
const GP& gp = args.fGP.cast<GP>();
|
|
GrGLSLVertexBuilder* vertBuilder = args.fVertBuilder;
|
|
GrGLSLFPFragmentBuilder* fragBuilder = args.fFragBuilder;
|
|
GrGLSLVaryingHandler* varyingHandler = args.fVaryingHandler;
|
|
GrGLSLUniformHandler* uniformHandler = args.fUniformHandler;
|
|
|
|
varyingHandler->emitAttributes(gp);
|
|
|
|
// Setup color
|
|
GrGLSLVarying varying(kHalf4_GrSLType);
|
|
varyingHandler->addVarying("color", &varying);
|
|
vertBuilder->codeAppendf("half4 color = %s;", gp.fInColor.name());
|
|
|
|
if (kShader_Mode == gp.fMode) {
|
|
fColorSpaceHelper.emitCode(uniformHandler, gp.fColorSpaceXform.get(),
|
|
kVertex_GrShaderFlag);
|
|
SkString xformedColor;
|
|
vertBuilder->appendColorGamutXform(&xformedColor, "color", &fColorSpaceHelper);
|
|
vertBuilder->codeAppendf("color = %s;", xformedColor.c_str());
|
|
vertBuilder->codeAppend("color = half4(color.rgb * color.a, color.a);");
|
|
}
|
|
|
|
vertBuilder->codeAppendf("%s = color;", varying.vsOut());
|
|
fragBuilder->codeAppendf("%s = %s;", args.fOutputColor, varying.fsIn());
|
|
|
|
// Position
|
|
this->writeOutputPosition(args.fVertBuilder, gpArgs, gp.fInPosition.name());
|
|
|
|
// Coverage
|
|
fragBuilder->codeAppendf("%s = half4(1);", args.fOutputCoverage);
|
|
}
|
|
void setData(const GrGLSLProgramDataManager& pdman,
|
|
const GrPrimitiveProcessor& primProc) override {
|
|
const GP& gp = primProc.cast<GP>();
|
|
fColorSpaceHelper.setData(pdman, gp.fColorSpaceXform.get());
|
|
}
|
|
|
|
GrGLSLColorSpaceXformHelper fColorSpaceHelper;
|
|
};
|
|
return new GLSLGP();
|
|
}
|
|
|
|
void getGLSLProcessorKey(const GrShaderCaps&, GrProcessorKeyBuilder* b) const override {
|
|
b->add32(fMode);
|
|
b->add32(GrColorSpaceXform::XformKey(fColorSpaceXform.get()));
|
|
}
|
|
|
|
private:
|
|
friend class ::SkArenaAlloc; // for access to ctor
|
|
|
|
GP(Mode mode, sk_sp<GrColorSpaceXform> colorSpaceXform)
|
|
: INHERITED(kVertexColorSpaceBenchGP_ClassID)
|
|
, fMode(mode)
|
|
, fColorSpaceXform(std::move(colorSpaceXform)) {
|
|
fInPosition = {"inPosition", kFloat2_GrVertexAttribType, kFloat2_GrSLType};
|
|
switch (fMode) {
|
|
case kBaseline_Mode:
|
|
case kShader_Mode:
|
|
fInColor = {"inColor", kUByte4_norm_GrVertexAttribType, kHalf4_GrSLType};
|
|
break;
|
|
case kFloat_Mode:
|
|
fInColor = {"inColor", kFloat4_GrVertexAttribType, kHalf4_GrSLType};
|
|
break;
|
|
case kHalf_Mode:
|
|
fInColor = {"inColor", kHalf4_GrVertexAttribType, kHalf4_GrSLType};
|
|
break;
|
|
}
|
|
this->setVertexAttributes(&fInPosition, 2);
|
|
}
|
|
|
|
Mode fMode;
|
|
sk_sp<GrColorSpaceXform> fColorSpaceXform;
|
|
|
|
Attribute fInPosition;
|
|
Attribute fInColor;
|
|
|
|
using INHERITED = GrGeometryProcessor;
|
|
};
|
|
|
|
class Op : public GrMeshDrawOp {
|
|
public:
|
|
DEFINE_OP_CLASS_ID
|
|
|
|
const char* name() const override { return "VertColorXformOp"; }
|
|
|
|
Op(GrColor color)
|
|
: INHERITED(ClassID())
|
|
, fMode(kBaseline_Mode)
|
|
, fColor(color) {
|
|
this->setBounds(SkRect::MakeWH(100.f, 100.f), HasAABloat::kNo, IsHairline::kNo);
|
|
}
|
|
|
|
Op(const SkColor4f& color4f, Mode mode)
|
|
: INHERITED(ClassID())
|
|
, fMode(mode)
|
|
, fColor4f(color4f) {
|
|
SkASSERT(kFloat_Mode == fMode || kHalf_Mode == mode);
|
|
this->setBounds(SkRect::MakeWH(100.f, 100.f), HasAABloat::kNo, IsHairline::kNo);
|
|
}
|
|
|
|
Op(GrColor color, sk_sp<GrColorSpaceXform> colorSpaceXform)
|
|
: INHERITED(ClassID())
|
|
, fMode(kShader_Mode)
|
|
, fColor(color)
|
|
, fColorSpaceXform(std::move(colorSpaceXform)) {
|
|
this->setBounds(SkRect::MakeWH(100.f, 100.f), HasAABloat::kNo, IsHairline::kNo);
|
|
}
|
|
|
|
FixedFunctionFlags fixedFunctionFlags() const override {
|
|
return FixedFunctionFlags::kNone;
|
|
}
|
|
|
|
GrProcessorSet::Analysis finalize(const GrCaps&, const GrAppliedClip*,
|
|
bool hasMixedSampledCoverage, GrClampType) override {
|
|
return GrProcessorSet::EmptySetAnalysis();
|
|
}
|
|
|
|
private:
|
|
friend class ::GrMemoryPool;
|
|
|
|
GrProgramInfo* programInfo() override { return fProgramInfo; }
|
|
|
|
void onCreateProgramInfo(const GrCaps* caps,
|
|
SkArenaAlloc* arena,
|
|
const GrSurfaceProxyView& writeView,
|
|
GrAppliedClip&& appliedClip,
|
|
const GrXferProcessor::DstProxyView& dstProxyView,
|
|
GrXferBarrierFlags renderPassXferBarriers,
|
|
GrLoadOp colorLoadOp) override {
|
|
GrGeometryProcessor* gp = GP::Make(arena, fMode, fColorSpaceXform);
|
|
|
|
fProgramInfo = GrSimpleMeshDrawOpHelper::CreateProgramInfo(caps,
|
|
arena,
|
|
writeView,
|
|
std::move(appliedClip),
|
|
dstProxyView,
|
|
gp,
|
|
GrProcessorSet::MakeEmptySet(),
|
|
GrPrimitiveType::kTriangleStrip,
|
|
renderPassXferBarriers,
|
|
colorLoadOp,
|
|
GrPipeline::InputFlags::kNone);
|
|
}
|
|
|
|
void onPrepareDraws(Target* target) override {
|
|
if (!fProgramInfo) {
|
|
this->createProgramInfo(target);
|
|
}
|
|
|
|
size_t vertexStride = fProgramInfo->primProc().vertexStride();
|
|
const int kVertexCount = 1024;
|
|
sk_sp<const GrBuffer> vertexBuffer;
|
|
int firstVertex = 0;
|
|
void* verts = target->makeVertexSpace(vertexStride, kVertexCount, &vertexBuffer,
|
|
&firstVertex);
|
|
if (!verts) {
|
|
return;
|
|
}
|
|
|
|
const float dx = 100.0f / kVertexCount;
|
|
if (kFloat_Mode == fMode) {
|
|
struct V {
|
|
SkPoint fPos;
|
|
SkColor4f fColor;
|
|
};
|
|
SkASSERT(sizeof(V) == vertexStride);
|
|
V* v = (V*)verts;
|
|
for (int i = 0; i < kVertexCount; i += 2) {
|
|
v[i + 0].fPos.set(dx * i, 0.0f);
|
|
v[i + 0].fColor = fColor4f;
|
|
v[i + 1].fPos.set(dx * i, 100.0f);
|
|
v[i + 1].fColor = fColor4f;
|
|
}
|
|
} else if (kHalf_Mode == fMode) {
|
|
struct V {
|
|
SkPoint fPos;
|
|
uint64_t fColor;
|
|
};
|
|
SkASSERT(sizeof(V) == vertexStride);
|
|
uint64_t color;
|
|
Sk4h halfColor = SkFloatToHalf_finite_ftz(Sk4f::Load(&fColor4f));
|
|
color = (uint64_t)halfColor[0] << 48 |
|
|
(uint64_t)halfColor[1] << 32 |
|
|
(uint64_t)halfColor[2] << 16 |
|
|
(uint64_t)halfColor[3] << 0;
|
|
V* v = (V*)verts;
|
|
for (int i = 0; i < kVertexCount; i += 2) {
|
|
v[i + 0].fPos.set(dx * i, 0.0f);
|
|
v[i + 0].fColor = color;
|
|
v[i + 1].fPos.set(dx * i, 100.0f);
|
|
v[i + 1].fColor = color;
|
|
}
|
|
} else {
|
|
struct V {
|
|
SkPoint fPos;
|
|
GrColor fColor;
|
|
};
|
|
SkASSERT(sizeof(V) == vertexStride);
|
|
V* v = (V*)verts;
|
|
for (int i = 0; i < kVertexCount; i += 2) {
|
|
v[i + 0].fPos.set(dx * i, 0.0f);
|
|
v[i + 0].fColor = fColor;
|
|
v[i + 1].fPos.set(dx * i, 100.0f);
|
|
v[i + 1].fColor = fColor;
|
|
}
|
|
}
|
|
|
|
fMesh = target->allocMesh();
|
|
fMesh->set(std::move(vertexBuffer), kVertexCount, firstVertex);
|
|
}
|
|
|
|
void onExecute(GrOpFlushState* flushState, const SkRect& chainBounds) override {
|
|
if (!fProgramInfo || !fMesh) {
|
|
return;
|
|
}
|
|
|
|
flushState->bindPipelineAndScissorClip(*fProgramInfo, chainBounds);
|
|
flushState->bindTextures(fProgramInfo->primProc(), nullptr, fProgramInfo->pipeline());
|
|
flushState->drawMesh(*fMesh);
|
|
}
|
|
|
|
Mode fMode;
|
|
GrColor fColor;
|
|
SkColor4f fColor4f;
|
|
sk_sp<GrColorSpaceXform> fColorSpaceXform;
|
|
|
|
GrSimpleMesh* fMesh = nullptr;
|
|
GrProgramInfo* fProgramInfo = nullptr;
|
|
|
|
using INHERITED = GrMeshDrawOp;
|
|
};
|
|
} // namespace
|
|
|
|
class VertexColorSpaceBench : public Benchmark {
|
|
public:
|
|
VertexColorSpaceBench(Mode mode, const char* name) : fMode(mode) {
|
|
fName = "vertexcolorspace";
|
|
fName.appendf("_%s", name);
|
|
}
|
|
|
|
bool isSuitableFor(Backend backend) override { return kGPU_Backend == backend; }
|
|
const char* onGetName() override { return fName.c_str(); }
|
|
|
|
void onDraw(int loops, SkCanvas* canvas) override {
|
|
auto context = canvas->recordingContext()->asDirectContext();
|
|
SkASSERT(context);
|
|
|
|
if (kHalf_Mode == fMode &&
|
|
!context->priv().caps()->halfFloatVertexAttributeSupport()) {
|
|
return;
|
|
}
|
|
|
|
auto p3 = SkColorSpace::MakeRGB(SkNamedTransferFn::kSRGB,
|
|
SkNamedGamut::kDisplayP3);
|
|
auto xform = GrColorSpaceXform::Make(sk_srgb_singleton(), kUnpremul_SkAlphaType,
|
|
p3.get(), kUnpremul_SkAlphaType);
|
|
|
|
SkRandom r;
|
|
const int kDrawsPerLoop = 32;
|
|
|
|
for (int i = 0; i < loops; ++i) {
|
|
auto rtc = GrRenderTargetContext::Make(
|
|
context, GrColorType::kRGBA_8888, p3, SkBackingFit::kApprox, {100, 100});
|
|
SkASSERT(rtc);
|
|
|
|
for (int j = 0; j < kDrawsPerLoop; ++j) {
|
|
SkColor c = r.nextU();
|
|
GrOp::Owner op = nullptr;
|
|
GrRecordingContext* rContext = canvas->recordingContext();
|
|
switch (fMode) {
|
|
case kBaseline_Mode:
|
|
op = GrOp::Make<Op>(rContext, SkColorToPremulGrColor(c));
|
|
break;
|
|
case kShader_Mode:
|
|
op = GrOp::Make<Op>(rContext, SkColorToUnpremulGrColor(c), xform);
|
|
break;
|
|
case kHalf_Mode:
|
|
case kFloat_Mode: {
|
|
SkColor4f c4f = SkColor4f::FromColor(c);
|
|
c4f = xform->apply(c4f);
|
|
op = GrOp::Make<Op>(rContext, c4f, fMode);
|
|
}
|
|
}
|
|
rtc->addDrawOp(std::move(op));
|
|
}
|
|
|
|
context->flushAndSubmit();
|
|
}
|
|
}
|
|
|
|
private:
|
|
SkString fName;
|
|
Mode fMode;
|
|
|
|
using INHERITED = Benchmark;
|
|
};
|
|
|
|
DEF_BENCH(return new VertexColorSpaceBench(kBaseline_Mode, "baseline"));
|
|
DEF_BENCH(return new VertexColorSpaceBench(kFloat_Mode, "float"));
|
|
DEF_BENCH(return new VertexColorSpaceBench(kHalf_Mode, "half"));
|
|
DEF_BENCH(return new VertexColorSpaceBench(kShader_Mode, "shader"));
|