blob: 1834b41e1e0ab0cab44db5c825429a74735ca307 [file] [log] [blame]
/*
* Copyright 2022 Google LLC
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#include "src/gpu/graphite/render/VerticesRenderStep.h"
#include "src/core/SkSLTypeShared.h"
#include "src/core/SkVertState.h"
#include "src/core/SkVerticesPriv.h"
#include "src/gpu/graphite/DrawParams.h"
#include "src/gpu/graphite/DrawTypes.h"
#include "src/gpu/graphite/DrawWriter.h"
#include "src/gpu/graphite/PipelineData.h"
#include "src/gpu/graphite/render/CommonDepthStencilSettings.h"
namespace skgpu::graphite {
namespace {
static constexpr Attribute kPositionAttr =
{"position", VertexAttribType::kFloat2, SkSLType::kFloat2};
static constexpr Attribute kTexCoordAttr =
{"texCoords", VertexAttribType::kFloat2, SkSLType::kFloat2};
static constexpr Attribute kColorAttr =
{"vertColor", VertexAttribType::kUByte4_norm, SkSLType::kHalf4};
static constexpr Attribute kSsboIndexAttr =
{"ssboIndices", VertexAttribType::kUShort2, SkSLType::kUShort2};
static constexpr Attribute kAttributePositionOnly[] =
{kPositionAttr, kSsboIndexAttr};
static constexpr Attribute kAttributeColor[] =
{kPositionAttr, kColorAttr, kSsboIndexAttr};
static constexpr Attribute kAttributeTexCoords[] =
{kPositionAttr, kTexCoordAttr, kSsboIndexAttr};
static constexpr Attribute kAttributeColorAndTexCoords[] =
{kPositionAttr, kColorAttr, kTexCoordAttr, kSsboIndexAttr};
static constexpr SkSpan<const Attribute> kAttributes[4] = {
kAttributePositionOnly,
kAttributeColor,
kAttributeTexCoords,
kAttributeColorAndTexCoords,
};
static constexpr Varying kVaryingColor[] =
{{"color", SkSLType::kHalf4}};
static constexpr SkSpan<const Varying> kVaryings[2] = {
/*none*/ {},
/*color*/ kVaryingColor
};
std::string variant_name(PrimitiveType type, bool hasColor, bool hasTexCoords) {
SkASSERT(type == PrimitiveType::kTriangles || type == PrimitiveType::kTriangleStrip);
std::string name = (type == PrimitiveType::kTriangles ? "tris" : "tristrips");
if (hasColor) {
name += "-color";
}
if (hasTexCoords) {
name += "-texCoords";
}
return name;
}
} // namespace
VerticesRenderStep::VerticesRenderStep(PrimitiveType type, bool hasColor, bool hasTexCoords)
: RenderStep("VerticesRenderStep",
variant_name(type, hasColor, hasTexCoords),
hasColor ? Flags::kEmitsPrimitiveColor | Flags::kPerformsShading
: Flags::kPerformsShading,
/*uniforms=*/{{"localToDevice", SkSLType::kFloat4x4},
{"depth", SkSLType::kFloat}},
type,
kDirectDepthGEqualPass,
/*vertexAttrs=*/ kAttributes[2*hasTexCoords + hasColor],
/*instanceAttrs=*/{},
/*varyings=*/ kVaryings[hasColor])
, fHasColor(hasColor)
, fHasTexCoords(hasTexCoords) {}
VerticesRenderStep::~VerticesRenderStep() {}
std::string VerticesRenderStep::vertexSkSL() const {
if (fHasColor && fHasTexCoords) {
return R"(
color = half4(vertColor.bgr * vertColor.a, vertColor.a);
float4 devPosition = localToDevice * float4(position, 0.0, 1.0);
devPosition.z = depth;
stepLocalCoords = texCoords;
)";
} else if (fHasTexCoords) {
return R"(
float4 devPosition = localToDevice * float4(position, 0.0, 1.0);
devPosition.z = depth;
stepLocalCoords = texCoords;
)";
} else if (fHasColor) {
return R"(
color = half4(vertColor.bgr * vertColor.a, vertColor.a);
float4 devPosition = localToDevice * float4(position, 0.0, 1.0);
devPosition.z = depth;
stepLocalCoords = position;
)";
} else {
return R"(
float4 devPosition = localToDevice * float4(position, 0.0, 1.0);
devPosition.z = depth;
stepLocalCoords = position;
)";
}
}
const char* VerticesRenderStep::fragmentColorSkSL() const {
if (fHasColor) {
return "primitiveColor = color;\n";
} else {
return "";
}
}
void VerticesRenderStep::writeVertices(DrawWriter* writer,
const DrawParams& params,
skvx::ushort2 ssboIndices) const {
SkVerticesPriv info(params.geometry().vertices()->priv());
const int vertexCount = info.vertexCount();
const int indexCount = info.indexCount();
const SkPoint* positions = info.positions();
const uint16_t* indices = info.indices();
const SkColor* colors = info.colors();
const SkPoint* texCoords = info.texCoords();
// This should always be the case if the Renderer was chosen appropriately, but the vertex
// writing loop is set up in such a way that if the shader expects color or tex coords and they
// are missing, it will just read 0s, so release builds are safe.
SkASSERT(fHasColor == SkToBool(colors));
SkASSERT(fHasTexCoords == SkToBool(texCoords));
// TODO: We could access the writer's DrawBufferManager and upload the SkVertices index buffer
// but that would require we manually manage the VertexWriter for interleaving the position,
// color, and tex coord arrays together. This wouldn't be so bad if we let ::Vertices() take
// a CPU index buffer that indexes into the accumulated vertex data (and handles offsetting for
// merged drawIndexed calls), or if we could bind multiple attribute sources and copy the
// position/color/texCoord data separately in bulk w/o using an Appender.
DrawWriter::Vertices verts{*writer};
verts.reserve(indices ? indexCount : vertexCount);
VertState state(vertexCount, indices, indexCount);
VertState::Proc vertProc = state.chooseProc(info.mode());
while (vertProc(&state)) {
verts.append(3) << positions[state.f0]
<< VertexWriter::If(fHasColor, colors ? colors[state.f0]
: SK_ColorTRANSPARENT)
<< VertexWriter::If(fHasTexCoords, texCoords ? texCoords[state.f0]
: SkPoint{0.f, 0.f})
<< ssboIndices
<< positions[state.f1]
<< VertexWriter::If(fHasColor, colors ? colors[state.f1]
: SK_ColorTRANSPARENT)
<< VertexWriter::If(fHasTexCoords, texCoords ? texCoords[state.f1]
: SkPoint{0.f, 0.f})
<< ssboIndices
<< positions[state.f2]
<< VertexWriter::If(fHasColor, colors ? colors[state.f2]
: SK_ColorTRANSPARENT)
<< VertexWriter::If(fHasTexCoords, texCoords ? texCoords[state.f2]
: SkPoint{0.f, 0.f})
<< ssboIndices;
}
}
void VerticesRenderStep::writeUniformsAndTextures(const DrawParams& params,
PipelineDataGatherer* gatherer) const {
// Vertices are transformed on the GPU. Store PaintDepth as a uniform to avoid copying the
// same depth for each vertex.
SkDEBUGCODE(UniformExpectationsValidator uev(gatherer, this->uniforms());)
gatherer->write(params.transform().matrix());
gatherer->write(params.order().depthAsFloat());
}
} // namespace skgpu::graphite