2016-03-23 18:50:26 +00:00
|
|
|
/*
|
|
|
|
* Copyright 2016 Google Inc.
|
|
|
|
*
|
|
|
|
* Use of this source code is governed by a BSD-style license that can be
|
|
|
|
* found in the LICENSE file.
|
|
|
|
*/
|
|
|
|
|
|
|
|
// This is a GPU-backend specific test. It relies on static intializers to work
|
|
|
|
|
2020-08-03 17:21:46 +00:00
|
|
|
#include <memory>
|
|
|
|
|
2019-04-23 17:05:21 +00:00
|
|
|
#include "include/core/SkTypes.h"
|
|
|
|
#include "tests/Test.h"
|
2016-03-23 18:50:26 +00:00
|
|
|
|
2019-04-23 17:05:21 +00:00
|
|
|
#include "include/core/SkString.h"
|
2020-07-06 14:56:46 +00:00
|
|
|
#include "include/gpu/GrDirectContext.h"
|
2019-04-23 17:05:21 +00:00
|
|
|
#include "src/core/SkPointPriv.h"
|
|
|
|
#include "src/gpu/GrContextPriv.h"
|
|
|
|
#include "src/gpu/GrGeometryProcessor.h"
|
|
|
|
#include "src/gpu/GrGpu.h"
|
|
|
|
#include "src/gpu/GrMemoryPool.h"
|
|
|
|
#include "src/gpu/GrOpFlushState.h"
|
2020-03-12 13:41:54 +00:00
|
|
|
#include "src/gpu/GrProgramInfo.h"
|
2019-04-23 17:05:21 +00:00
|
|
|
#include "src/gpu/GrRenderTargetContext.h"
|
|
|
|
#include "src/gpu/GrRenderTargetContextPriv.h"
|
|
|
|
#include "src/gpu/glsl/GrGLSLFragmentShaderBuilder.h"
|
|
|
|
#include "src/gpu/glsl/GrGLSLGeometryProcessor.h"
|
|
|
|
#include "src/gpu/glsl/GrGLSLVarying.h"
|
|
|
|
#include "src/gpu/ops/GrMeshDrawOp.h"
|
2019-12-05 21:40:31 +00:00
|
|
|
#include "src/gpu/ops/GrSimpleMeshDrawOpHelper.h"
|
2016-03-23 18:50:26 +00:00
|
|
|
|
|
|
|
namespace {
|
2017-07-13 19:29:47 +00:00
|
|
|
class Op : public GrMeshDrawOp {
|
2016-03-23 18:50:26 +00:00
|
|
|
public:
|
2016-12-01 14:36:50 +00:00
|
|
|
DEFINE_OP_CLASS_ID
|
2016-03-23 18:50:26 +00:00
|
|
|
|
2016-12-21 16:14:46 +00:00
|
|
|
const char* name() const override { return "Dummy Op"; }
|
2016-03-23 18:50:26 +00:00
|
|
|
|
2020-07-23 13:41:57 +00:00
|
|
|
static std::unique_ptr<GrDrawOp> Make(GrRecordingContext* rContext, int numAttribs) {
|
|
|
|
GrOpMemoryPool* pool = rContext->priv().opMemoryPool();
|
2018-06-19 17:09:54 +00:00
|
|
|
|
|
|
|
return pool->allocate<Op>(numAttribs);
|
2017-07-13 19:29:47 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
FixedFunctionFlags fixedFunctionFlags() const override {
|
|
|
|
return FixedFunctionFlags::kNone;
|
|
|
|
}
|
|
|
|
|
2019-06-24 00:07:38 +00:00
|
|
|
GrProcessorSet::Analysis finalize(const GrCaps&, const GrAppliedClip*,
|
|
|
|
bool hasMixedSampledCoverage, GrClampType) override {
|
2019-01-15 18:53:00 +00:00
|
|
|
return GrProcessorSet::EmptySetAnalysis();
|
2017-01-03 14:42:58 +00:00
|
|
|
}
|
2016-12-21 16:14:46 +00:00
|
|
|
|
|
|
|
private:
|
2018-06-12 14:11:12 +00:00
|
|
|
friend class ::GrOpMemoryPool;
|
|
|
|
|
2016-12-21 16:14:46 +00:00
|
|
|
Op(int numAttribs) : INHERITED(ClassID()), fNumAttribs(numAttribs) {
|
2019-10-01 19:14:44 +00:00
|
|
|
this->setBounds(SkRect::MakeWH(1.f, 1.f), HasAABloat::kNo, IsHairline::kNo);
|
2016-03-23 18:50:26 +00:00
|
|
|
}
|
|
|
|
|
2020-03-12 16:07:19 +00:00
|
|
|
GrProgramInfo* programInfo() override { return fProgramInfo; }
|
|
|
|
|
2020-03-12 13:41:54 +00:00
|
|
|
void onCreateProgramInfo(const GrCaps* caps,
|
|
|
|
SkArenaAlloc* arena,
|
2020-04-01 20:22:00 +00:00
|
|
|
const GrSurfaceProxyView* writeView,
|
2020-03-12 13:41:54 +00:00
|
|
|
GrAppliedClip&& appliedClip,
|
2020-09-11 13:33:54 +00:00
|
|
|
const GrXferProcessor::DstProxyView& dstProxyView,
|
|
|
|
GrXferBarrierFlags renderPassXferBarriers) override {
|
2016-03-23 18:50:26 +00:00
|
|
|
class GP : public GrGeometryProcessor {
|
|
|
|
public:
|
2019-11-20 21:08:10 +00:00
|
|
|
static GrGeometryProcessor* Make(SkArenaAlloc* arena, int numAttribs) {
|
|
|
|
return arena->make<GP>(numAttribs);
|
2016-09-27 13:34:10 +00:00
|
|
|
}
|
2019-11-20 21:08:10 +00:00
|
|
|
|
2016-03-23 18:50:26 +00:00
|
|
|
const char* name() const override { return "Dummy GP"; }
|
|
|
|
|
2016-11-29 18:43:05 +00:00
|
|
|
GrGLSLPrimitiveProcessor* createGLSLInstance(const GrShaderCaps&) const override {
|
2016-03-23 18:50:26 +00:00
|
|
|
class GLSLGP : public GrGLSLGeometryProcessor {
|
|
|
|
public:
|
|
|
|
void onEmitCode(EmitArgs& args, GrGPArgs* gpArgs) override {
|
|
|
|
const GP& gp = args.fGP.cast<GP>();
|
|
|
|
args.fVaryingHandler->emitAttributes(gp);
|
2018-05-29 19:33:06 +00:00
|
|
|
this->writeOutputPosition(args.fVertBuilder, gpArgs,
|
2018-06-19 18:33:47 +00:00
|
|
|
gp.fAttributes[0].name());
|
2018-02-14 20:38:14 +00:00
|
|
|
GrGLSLFPFragmentBuilder* fragBuilder = args.fFragBuilder;
|
2017-09-18 18:10:39 +00:00
|
|
|
fragBuilder->codeAppendf("%s = half4(1);", args.fOutputColor);
|
|
|
|
fragBuilder->codeAppendf("%s = half4(1);", args.fOutputCoverage);
|
2016-03-23 18:50:26 +00:00
|
|
|
}
|
|
|
|
void setData(const GrGLSLProgramDataManager& pdman,
|
2020-07-01 19:14:39 +00:00
|
|
|
const GrPrimitiveProcessor& primProc) override {}
|
2016-03-23 18:50:26 +00:00
|
|
|
};
|
|
|
|
return new GLSLGP();
|
|
|
|
}
|
2016-11-29 18:43:05 +00:00
|
|
|
void getGLSLProcessorKey(const GrShaderCaps&,
|
2016-03-23 18:50:26 +00:00
|
|
|
GrProcessorKeyBuilder* builder) const override {
|
2018-06-19 18:33:47 +00:00
|
|
|
builder->add32(fNumAttribs);
|
2016-03-23 18:50:26 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
2019-11-20 21:08:10 +00:00
|
|
|
friend class ::SkArenaAlloc; // for access to ctor
|
|
|
|
|
|
|
|
GP(int numAttribs) : INHERITED(kGP_ClassID), fNumAttribs(numAttribs) {
|
|
|
|
SkASSERT(numAttribs > 1);
|
2020-08-03 17:21:46 +00:00
|
|
|
fAttribNames = std::make_unique<SkString[]>(numAttribs);
|
|
|
|
fAttributes = std::make_unique<Attribute[]>(numAttribs);
|
2019-11-20 21:08:10 +00:00
|
|
|
for (auto i = 0; i < numAttribs; ++i) {
|
|
|
|
fAttribNames[i].printf("attr%d", i);
|
|
|
|
// This gives us more of a mix of attribute types, and allows the
|
|
|
|
// component count to fit within the limits for iOS Metal.
|
|
|
|
if (i & 0x1) {
|
|
|
|
fAttributes[i] = {fAttribNames[i].c_str(), kFloat_GrVertexAttribType,
|
|
|
|
kFloat_GrSLType};
|
|
|
|
} else {
|
|
|
|
fAttributes[i] = {fAttribNames[i].c_str(), kFloat2_GrVertexAttribType,
|
|
|
|
kFloat2_GrSLType};
|
|
|
|
}
|
|
|
|
}
|
|
|
|
this->setVertexAttributes(fAttributes.get(), numAttribs);
|
|
|
|
}
|
|
|
|
|
2018-06-19 18:33:47 +00:00
|
|
|
int fNumAttribs;
|
|
|
|
std::unique_ptr<SkString[]> fAttribNames;
|
|
|
|
std::unique_ptr<Attribute[]> fAttributes;
|
2017-10-09 14:54:08 +00:00
|
|
|
|
2020-09-03 02:42:33 +00:00
|
|
|
using INHERITED = GrGeometryProcessor;
|
2016-03-23 18:50:26 +00:00
|
|
|
};
|
2019-11-20 21:08:10 +00:00
|
|
|
|
2020-03-12 13:41:54 +00:00
|
|
|
GrGeometryProcessor* gp = GP::Make(arena, fNumAttribs);
|
|
|
|
|
|
|
|
fProgramInfo = GrSimpleMeshDrawOpHelper::CreateProgramInfo(caps,
|
|
|
|
arena,
|
2020-04-01 20:22:00 +00:00
|
|
|
writeView,
|
2020-03-12 13:41:54 +00:00
|
|
|
std::move(appliedClip),
|
|
|
|
dstProxyView,
|
|
|
|
gp,
|
|
|
|
GrProcessorSet::MakeEmptySet(),
|
|
|
|
GrPrimitiveType::kTriangles,
|
2020-09-11 13:33:54 +00:00
|
|
|
renderPassXferBarriers,
|
2020-03-12 13:41:54 +00:00
|
|
|
GrPipeline::InputFlags::kNone);
|
|
|
|
}
|
|
|
|
|
|
|
|
void onPrepareDraws(Target* target) override {
|
|
|
|
if (!fProgramInfo) {
|
|
|
|
this->createProgramInfo(target);
|
|
|
|
}
|
|
|
|
|
|
|
|
size_t vertexStride = fProgramInfo->primProc().vertexStride();
|
2018-08-07 14:02:38 +00:00
|
|
|
QuadHelper helper(target, vertexStride, 1);
|
|
|
|
SkPoint* vertices = reinterpret_cast<SkPoint*>(helper.vertices());
|
2017-11-07 01:02:02 +00:00
|
|
|
SkPointPriv::SetRectTriStrip(vertices, 0.f, 0.f, 1.f, 1.f, vertexStride);
|
2020-03-12 13:41:54 +00:00
|
|
|
fMesh = helper.mesh();
|
2020-03-11 19:55:55 +00:00
|
|
|
}
|
|
|
|
|
2019-02-26 18:13:22 +00:00
|
|
|
void onExecute(GrOpFlushState* flushState, const SkRect& chainBounds) override {
|
2020-03-12 13:41:54 +00:00
|
|
|
if (!fProgramInfo || !fMesh) {
|
|
|
|
return;
|
|
|
|
}
|
2019-12-05 21:40:31 +00:00
|
|
|
|
2020-03-16 23:34:44 +00:00
|
|
|
flushState->bindPipelineAndScissorClip(*fProgramInfo, chainBounds);
|
|
|
|
flushState->bindTextures(fProgramInfo->primProc(), nullptr, fProgramInfo->pipeline());
|
|
|
|
flushState->drawMesh(*fMesh);
|
2016-03-23 18:50:26 +00:00
|
|
|
}
|
|
|
|
|
2020-03-12 13:41:54 +00:00
|
|
|
int fNumAttribs;
|
2020-03-16 15:25:50 +00:00
|
|
|
GrSimpleMesh* fMesh = nullptr;
|
2020-03-12 13:41:54 +00:00
|
|
|
GrProgramInfo* fProgramInfo = nullptr;
|
2016-03-23 18:50:26 +00:00
|
|
|
|
2020-09-03 02:42:33 +00:00
|
|
|
using INHERITED = GrMeshDrawOp;
|
2016-03-23 18:50:26 +00:00
|
|
|
};
|
2020-08-06 18:11:56 +00:00
|
|
|
} // namespace
|
2016-03-23 18:50:26 +00:00
|
|
|
|
2016-06-27 14:15:20 +00:00
|
|
|
DEF_GPUTEST_FOR_ALL_CONTEXTS(VertexAttributeCount, reporter, ctxInfo) {
|
2020-07-06 14:56:46 +00:00
|
|
|
auto context = ctxInfo.directContext();
|
2018-01-22 15:48:15 +00:00
|
|
|
#if GR_GPU_STATS
|
2019-02-04 18:26:26 +00:00
|
|
|
GrGpu* gpu = context->priv().getGpu();
|
2018-01-22 15:48:15 +00:00
|
|
|
#endif
|
2016-04-28 16:55:15 +00:00
|
|
|
|
2020-01-08 16:52:34 +00:00
|
|
|
auto renderTargetContext = GrRenderTargetContext::Make(
|
|
|
|
context, GrColorType::kRGBA_8888, nullptr, SkBackingFit::kApprox, {1, 1});
|
2016-10-27 18:47:55 +00:00
|
|
|
if (!renderTargetContext) {
|
|
|
|
ERRORF(reporter, "Could not create render target context.");
|
2016-03-23 18:50:26 +00:00
|
|
|
return;
|
|
|
|
}
|
2019-02-04 18:26:26 +00:00
|
|
|
int attribCnt = context->priv().caps()->maxVertexAttributes();
|
2016-03-23 18:50:26 +00:00
|
|
|
if (!attribCnt) {
|
|
|
|
ERRORF(reporter, "No attributes allowed?!");
|
|
|
|
return;
|
|
|
|
}
|
2020-05-14 19:45:44 +00:00
|
|
|
context->flushAndSubmit();
|
2019-02-04 18:26:26 +00:00
|
|
|
context->priv().resetGpuStats();
|
2016-03-23 18:50:26 +00:00
|
|
|
#if GR_GPU_STATS
|
2018-01-22 15:48:15 +00:00
|
|
|
REPORTER_ASSERT(reporter, gpu->stats()->numDraws() == 0);
|
|
|
|
REPORTER_ASSERT(reporter, gpu->stats()->numFailedDraws() == 0);
|
2016-03-23 18:50:26 +00:00
|
|
|
#endif
|
2018-02-27 19:26:32 +00:00
|
|
|
// Adding discard to appease vulkan validation warning about loading uninitialized data on draw
|
|
|
|
renderTargetContext->discard();
|
|
|
|
|
2016-06-23 21:07:00 +00:00
|
|
|
GrPaint grPaint;
|
2016-03-23 18:50:26 +00:00
|
|
|
// This one should succeed.
|
2018-06-12 14:11:12 +00:00
|
|
|
renderTargetContext->priv().testingOnly_addDrawOp(Op::Make(context, attribCnt));
|
2020-05-14 19:45:44 +00:00
|
|
|
context->flushAndSubmit();
|
2016-03-23 18:50:26 +00:00
|
|
|
#if GR_GPU_STATS
|
2018-01-22 15:48:15 +00:00
|
|
|
REPORTER_ASSERT(reporter, gpu->stats()->numDraws() == 1);
|
|
|
|
REPORTER_ASSERT(reporter, gpu->stats()->numFailedDraws() == 0);
|
2016-03-23 18:50:26 +00:00
|
|
|
#endif
|
2019-02-04 18:26:26 +00:00
|
|
|
context->priv().resetGpuStats();
|
2018-06-12 14:11:12 +00:00
|
|
|
renderTargetContext->priv().testingOnly_addDrawOp(Op::Make(context, attribCnt + 1));
|
2020-05-14 19:45:44 +00:00
|
|
|
context->flushAndSubmit();
|
2016-03-23 18:50:26 +00:00
|
|
|
#if GR_GPU_STATS
|
2018-01-22 15:48:15 +00:00
|
|
|
REPORTER_ASSERT(reporter, gpu->stats()->numDraws() == 0);
|
|
|
|
REPORTER_ASSERT(reporter, gpu->stats()->numFailedDraws() == 1);
|
2016-03-23 18:50:26 +00:00
|
|
|
#endif
|
|
|
|
}
|