SkMesh.cpp File Reference

#include "include/core/SkMesh.h"
#include "include/core/SkAlphaType.h"
#include "include/core/SkColorSpace.h"
#include "include/core/SkData.h"
#include "include/private/SkSLSampleUsage.h"
#include "include/private/base/SkAlign.h"
#include "include/private/base/SkAssert.h"
#include "include/private/base/SkMath.h"
#include "include/private/base/SkTArray.h"
#include "include/private/base/SkTo.h"
#include "src/base/SkSafeMath.h"
#include "src/core/SkChecksum.h"
#include "src/core/SkMeshPriv.h"
#include "src/core/SkRuntimeEffectPriv.h"
#include "src/sksl/SkSLAnalysis.h"
#include "src/sksl/SkSLBuiltinTypes.h"
#include "src/sksl/SkSLCompiler.h"
#include "src/sksl/SkSLContext.h"
#include "src/sksl/SkSLProgramKind.h"
#include "src/sksl/SkSLProgramSettings.h"
#include "src/sksl/analysis/SkSLProgramVisitor.h"
#include "src/sksl/ir/SkSLExpression.h"
#include "src/sksl/ir/SkSLFieldAccess.h"
#include "src/sksl/ir/SkSLFunctionDeclaration.h"
#include "src/sksl/ir/SkSLFunctionDefinition.h"
#include "src/sksl/ir/SkSLModifierFlags.h"
#include "src/sksl/ir/SkSLProgram.h"
#include "src/sksl/ir/SkSLProgramElement.h"
#include "src/sksl/ir/SkSLReturnStatement.h"
#include "src/sksl/ir/SkSLStatement.h"
#include "src/sksl/ir/SkSLStructDefinition.h"
#include "src/sksl/ir/SkSLType.h"
#include "src/sksl/ir/SkSLVarDeclarations.h"
#include "src/sksl/ir/SkSLVariable.h"
#include "src/sksl/ir/SkSLVariableReference.h"
#include <algorithm>
#include <locale>
#include <optional>
#include <string>
#include <tuple>
#include <utility>

Go to the source code of this file.

Namespaces
namespace	SkMeshes

Macros
#define	RETURN_FAILURE(...)   return Result{nullptr, SkStringPrintf(__VA_ARGS__)}
#define	RETURN_ERROR(...)   return std::make_tuple(false, SkStringPrintf(__VA_ARGS__))
#define	RETURN_SUCCESS   return std::make_tuple(true, SkString{})
#define	FAIL_MESH_VALIDATE(...)   return std::make_tuple(false, SkStringPrintf(__VA_ARGS__))

Typedefs
using	Attribute = SkMeshSpecification::Attribute
using	Varying = SkMeshSpecification::Varying
using	IndexBuffer = SkMesh::IndexBuffer
using	VertexBuffer = SkMesh::VertexBuffer
using	Uniform = SkMeshSpecification::Uniform
using	Child = SkMeshSpecification::Child
using	ColorType = SkMeshSpecificationPriv::ColorType

Functions
static std::vector< Uniform >::iterator	find_uniform (std::vector< Uniform > &uniforms, std::string_view name)
static std::tuple< bool, SkString >	gather_uniforms_and_check_for_main (const SkSL::Program &program, std::vector< Uniform > *uniforms, std::vector< Child > *children, SkMeshSpecification::Uniform::Flags stage, size_t *offset)
ColorType	get_fs_color_type (const SkSL::Program &fsProgram)
static bool	check_name (const SkString &name)
static size_t	attribute_type_size (Attribute::Type type)
static const char *	attribute_type_string (Attribute::Type type)
static const char *	varying_type_string (Varying::Type type)
std::tuple< bool, SkString >	check_vertex_offsets_and_stride (SkSpan< const Attribute > attributes, size_t stride)
int	check_for_passthrough_local_coords_and_dead_varyings (const SkSL::Program &fsProgram, uint32_t *deadVaryingMask)
static size_t	min_vcount_for_mode (SkMesh::Mode mode)
static bool	check_update (const void *data, size_t offset, size_t size, size_t bufferSize)
SK_API sk_sp< SkMesh::IndexBuffer >	SkMeshes::MakeIndexBuffer (const void *data, size_t size)
SK_API sk_sp< SkMesh::IndexBuffer >	SkMeshes::CopyIndexBuffer (const sk_sp< SkMesh::IndexBuffer > &)
SK_API sk_sp< SkMesh::VertexBuffer >	SkMeshes::MakeVertexBuffer (const void *, size_t size)
SK_API sk_sp< SkMesh::VertexBuffer >	SkMeshes::CopyVertexBuffer (const sk_sp< SkMesh::VertexBuffer > &)

Macro Definition Documentation

FAIL_MESH_VALIDATE

#define FAIL_MESH_VALIDATE

(

...

)

return std::make_tuple(false, SkStringPrintf(__VA_ARGS__))

RETURN_ERROR

#define RETURN_ERROR

(

...

)

return std::make_tuple(false, SkStringPrintf(__VA_ARGS__))

Definition at line 62 of file SkMesh.cpp.

RETURN_FAILURE

#define RETURN_FAILURE

(

...

)

return Result{nullptr, SkStringPrintf(__VA_ARGS__)}

Definition at line 60 of file SkMesh.cpp.

RETURN_SUCCESS

#define RETURN_SUCCESS   return std::make_tuple(true, SkString{})

Definition at line 64 of file SkMesh.cpp.

Typedef Documentation

Attribute

using Attribute = SkMeshSpecification::Attribute

Definition at line 54 of file SkMesh.cpp.

Child

using Child = SkMeshSpecification::Child

Definition at line 67 of file SkMesh.cpp.

ColorType

using ColorType = SkMeshSpecificationPriv::ColorType

Definition at line 137 of file SkMesh.cpp.

IndexBuffer

using IndexBuffer = SkMesh::IndexBuffer

Definition at line 57 of file SkMesh.cpp.

Uniform

using Uniform = SkMeshSpecification::Uniform

Definition at line 66 of file SkMesh.cpp.

Varying

using Varying = SkMeshSpecification::Varying

Definition at line 55 of file SkMesh.cpp.

VertexBuffer

using VertexBuffer = SkMesh::VertexBuffer

Definition at line 58 of file SkMesh.cpp.

Function Documentation

attribute_type_size()

static size_t attribute_type_size ( Attribute::Type  type )

static

Definition at line 175 of file SkMesh.cpp.

                                                      {
    switch (type) {
        case Attribute::Type::kFloat:         return 4;
        case Attribute::Type::kFloat2:        return 2*4;
        case Attribute::Type::kFloat3:        return 3*4;
        case Attribute::Type::kFloat4:        return 4*4;
        case Attribute::Type::kUByte4_unorm:  return 4;
    }
    SkUNREACHABLE;
}

attribute_type_string()

static const char * attribute_type_string ( Attribute::Type  type )

static

Definition at line 186 of file SkMesh.cpp.

                                                             {
    switch (type) {
        case Attribute::Type::kFloat:         return "float";
        case Attribute::Type::kFloat2:        return "float2";
        case Attribute::Type::kFloat3:        return "float3";
        case Attribute::Type::kFloat4:        return "float4";
        case Attribute::Type::kUByte4_unorm:  return "half4";
    }
    SkUNREACHABLE;
}

check_for_passthrough_local_coords_and_dead_varyings()

int check_for_passthrough_local_coords_and_dead_varyings	(	const SkSL::Program &	fsProgram,
		uint32_t *	deadVaryingMask
	)

Definition at line 254 of file SkMesh.cpp.

                                                                                    {
    SkASSERT(deadVaryingMask);
 
    using namespace SkSL;
    static constexpr int kFailed = -2;
 
    class Visitor final : public SkSL::ProgramVisitor {
    public:
        Visitor(const Context& context) : fContext(context) {}
 
        void visit(const Program& program) { ProgramVisitor::visit(program); }
 
        int passthroughFieldIndex() const { return fPassthroughFieldIndex; }
 
        uint32_t fieldUseMask() const { return fFieldUseMask; }
 
    protected:
        bool visitProgramElement(const ProgramElement& p) override {
            if (p.is<StructDefinition>()) {
                const auto& def = p.as<StructDefinition>();
                if (def.type().name() == "Varyings") {
                    fVaryingsType = &def.type();
                }
                // No reason to keep looking at this type definition.
                return false;
            }
            if (p.is<FunctionDefinition>() && p.as<FunctionDefinition>().declaration().isMain()) {
                SkASSERT(!fVaryings);
                fVaryings = p.as<FunctionDefinition>().declaration().parameters()[0];
 
                SkASSERT(fVaryingsType && fVaryingsType->matches(fVaryings->type()));
 
                fInMain = true;
                bool result = ProgramVisitor::visitProgramElement(p);
                fInMain = false;
                return result;
            }
            return ProgramVisitor::visitProgramElement(p);
        }
 
        bool visitStatement(const Statement& s) override {
            if (!fInMain) {
                return ProgramVisitor::visitStatement(s);
            }
            // We should only get here if are in main and therefore found the varyings parameter.
            SkASSERT(fVaryings);
            SkASSERT(fVaryingsType);
 
            if (fPassthroughFieldIndex == kFailed) {
                // We've already determined there are return statements that aren't passthrough
                // or return different fields.
                return ProgramVisitor::visitStatement(s);
            }
            if (!s.is<ReturnStatement>()) {
                return ProgramVisitor::visitStatement(s);
            }
 
            // We just detect simple cases like "return varyings.foo;"
            const auto& rs = s.as<ReturnStatement>();
            SkASSERT(rs.expression());
            if (!rs.expression()->is<FieldAccess>()) {
                this->passthroughFailed();
                return ProgramVisitor::visitStatement(s);
            }
            const auto& fa = rs.expression()->as<FieldAccess>();
            if (!fa.base()->is<VariableReference>()) {
                this->passthroughFailed();
                return ProgramVisitor::visitStatement(s);
            }
            const auto& baseRef = fa.base()->as<VariableReference>();
            if (baseRef.variable() != fVaryings) {
                this->passthroughFailed();
                return ProgramVisitor::visitStatement(s);
            }
            if (fPassthroughFieldIndex >= 0) {
                // We already found an OK return statement. Check if this one returns the same
                // field.
                if (fa.fieldIndex() != fPassthroughFieldIndex) {
                    this->passthroughFailed();
                    return ProgramVisitor::visitStatement(s);
                }
                // We don't call our base class here because we don't want to hit visitExpression
                // and mark the returned field as used.
                return false;
            }
            const Field& field = fVaryings->type().fields()[fa.fieldIndex()];
            if (!field.fType->matches(*fContext.fTypes.fFloat2)) {
                this->passthroughFailed();
                return ProgramVisitor::visitStatement(s);
            }
            fPassthroughFieldIndex = fa.fieldIndex();
            // We don't call our base class here because we don't want to hit visitExpression and
            // mark the returned field as used.
            return false;
        }
 
        bool visitExpression(const Expression& e) override {
            // Anything before the Varyings struct is defined doesn't matter.
            if (!fVaryingsType) {
                return false;
            }
            if (!e.is<FieldAccess>()) {
                return ProgramVisitor::visitExpression(e);
            }
            const auto& fa = e.as<FieldAccess>();
            if (!fa.base()->type().matches(*fVaryingsType)) {
                return ProgramVisitor::visitExpression(e);
            }
            fFieldUseMask |= 1 << fa.fieldIndex();
            return false;
        }
 
    private:
        void passthroughFailed() {
            if (fPassthroughFieldIndex >= 0) {
                fFieldUseMask |= 1 << fPassthroughFieldIndex;
            }
            fPassthroughFieldIndex = kFailed;
        }
 
        const Context&  fContext;
        const Type*     fVaryingsType          = nullptr;
        const Variable* fVaryings              = nullptr;
        int             fPassthroughFieldIndex = -1;
        bool            fInMain                = false;
        uint32_t        fFieldUseMask          = 0;
    };
 
    Visitor v(*fsProgram.fContext);
    v.visit(fsProgram);
    *deadVaryingMask = ~v.fieldUseMask();
    return v.passthroughFieldIndex();
}

check_name()

static bool check_name ( const SkString &  name )

static

Definition at line 163 of file SkMesh.cpp.

                                             {
    if (name.isEmpty()) {
        return false;
    }
    for (size_t i = 0; i < name.size(); ++i) {
        if (name[i] != '_' && !std::isalnum(name[i], std::locale::classic())) {
            return false;
        }
    }
    return true;
}

check_update()

static bool check_update ( const void *  data, size_t  offset, size_t  size, size_t  bufferSize  )

inlinestatic

Definition at line 864 of file SkMesh.cpp.

                                                                                                 {
    SkSafeMath sm;
    return data                                &&
           size                                &&
           SkIsAlign4(offset)                  &&
           SkIsAlign4(size)                    &&
           sm.add(offset, size) <= bufferSize  &&
           sm.ok();
}

check_vertex_offsets_and_stride()

std::tuple< bool, SkString > check_vertex_offsets_and_stride	(	SkSpan< const Attribute >	attributes,
		size_t	stride
	)

Definition at line 212 of file SkMesh.cpp.

                                                                {
    // Vulkan 1.0 has a minimum maximum attribute count of 2048.
    static_assert(SkMeshSpecification::kMaxStride       <= 2048);
    // ES 2 has a max of 8.
    static_assert(SkMeshSpecification::kMaxAttributes   <= 8);
    // Four bytes alignment is required by Metal.
    static_assert(SkMeshSpecification::kStrideAlignment >= 4);
    static_assert(SkMeshSpecification::kOffsetAlignment >= 4);
    // ES2 has a minimum maximum of 8. We may need one for a broken gl_FragCoord workaround and
    // one for local coords.
    static_assert(SkMeshSpecification::kMaxVaryings     <= 6);
 
    if (attributes.empty()) {
        RETURN_ERROR("At least 1 attribute is required.");
    }
    if (attributes.size() > SkMeshSpecification::kMaxAttributes) {
        RETURN_ERROR("A maximum of %zu attributes is allowed.",
                     SkMeshSpecification::kMaxAttributes);
    }
    static_assert(SkIsPow2(SkMeshSpecification::kStrideAlignment));
    if (stride == 0 || stride & (SkMeshSpecification::kStrideAlignment - 1)) {
        RETURN_ERROR("Vertex stride must be a non-zero multiple of %zu.",
                     SkMeshSpecification::kStrideAlignment);
    }
    if (stride > SkMeshSpecification::kMaxStride) {
        RETURN_ERROR("Stride cannot exceed %zu.", SkMeshSpecification::kMaxStride);
    }
    for (const auto& a : attributes) {
        if (a.offset & (SkMeshSpecification::kOffsetAlignment - 1)) {
            RETURN_ERROR("Attribute offset must be a multiple of %zu.",
                         SkMeshSpecification::kOffsetAlignment);
        }
        // This equivalent to vertexAttributeAccessBeyondStride==VK_FALSE in
        // VK_KHR_portability_subset. First check is to avoid overflow in second check.
        if (a.offset >= stride || a.offset + attribute_type_size(a.type) > stride) {
            RETURN_ERROR("Attribute offset plus size cannot exceed stride.");
        }
    }
    RETURN_SUCCESS;
}

find_uniform()

static std::vector< Uniform >::iterator find_uniform ( std::vector< Uniform > &  uniforms, std::string_view  name  )

static

Definition at line 69 of file SkMesh.cpp.

                                                                        {
    return std::find_if(uniforms.begin(), uniforms.end(),
                        [name](const SkMeshSpecification::Uniform& u) { return u.name == name; });
}

gather_uniforms_and_check_for_main()

static std::tuple< bool, SkString > gather_uniforms_and_check_for_main ( const SkSL::Program &  program, std::vector< Uniform > *  uniforms, std::vector< Child > *  children, SkMeshSpecification::Uniform::Flags  stage, size_t *  offset  )

static

Definition at line 76 of file SkMesh.cpp.

                                                   {
    bool foundMain = false;
    for (const SkSL::ProgramElement* elem : program.elements()) {
        if (elem->is<SkSL::FunctionDefinition>()) {
            const SkSL::FunctionDefinition& defn = elem->as<SkSL::FunctionDefinition>();
            const SkSL::FunctionDeclaration& decl = defn.declaration();
            if (decl.isMain()) {
                foundMain = true;
            }
        } else if (elem->is<SkSL::GlobalVarDeclaration>()) {
            const SkSL::GlobalVarDeclaration& global = elem->as<SkSL::GlobalVarDeclaration>();
            const SkSL::VarDeclaration& varDecl = global.declaration()->as<SkSL::VarDeclaration>();
            const SkSL::Variable& var = *varDecl.var();
            if (var.modifierFlags().isUniform()) {
                if (var.type().isEffectChild()) {
                    // This is a child effect; add it to our list of children.
                    children->push_back(SkRuntimeEffectPriv::VarAsChild(var, children->size()));
                } else {
                    // This is a uniform variable; make sure it exists in our list of uniforms, and
                    // ensure that the type and layout matches between VS and FS.
                    auto iter = find_uniform(*uniforms, var.name());
                    const auto& context = *program.fContext;
                    if (iter == uniforms->end()) {
                        uniforms->push_back(SkRuntimeEffectPriv::VarAsUniform(var, context,
                                                                              offset));
                        uniforms->back().flags |= stage;
                    } else {
                        // Check that the two declarations are equivalent
                        size_t ignoredOffset = 0;
                        auto uniform = SkRuntimeEffectPriv::VarAsUniform(var, context,
                                                                         &ignoredOffset);
                        if (uniform.isArray() != iter->isArray() ||
                            uniform.type      != iter->type      ||
                            uniform.count     != iter->count) {
                            return {false,
                                    SkStringPrintf("Uniform %.*s declared with different types"
                                                   " in vertex and fragment shaders.",
                                                   (int)var.name().size(), var.name().data())};
                        }
                        if (uniform.isColor() != iter->isColor()) {
                            return {false,
                                    SkStringPrintf("Uniform %.*s declared with different color"
                                                   " layout in vertex and fragment shaders.",
                                                   (int)var.name().size(), var.name().data())};
                        }
                        (*iter).flags |= stage;
                    }
                }
            }
        }
    }
    if (!foundMain) {
        return {false, SkString("No main function found.")};
    }
    return {true, {}};
}

get_fs_color_type()

ColorType get_fs_color_type

(

const SkSL::Program &

fsProgram

)

Definition at line 139 of file SkMesh.cpp.

                                                          {
    for (const SkSL::ProgramElement* elem : fsProgram.elements()) {
        if (elem->is<SkSL::FunctionDefinition>()) {
            const SkSL::FunctionDefinition& defn = elem->as<SkSL::FunctionDefinition>();
            const SkSL::FunctionDeclaration& decl = defn.declaration();
            if (decl.isMain()) {
                SkASSERT(decl.parameters().size() == 1 || decl.parameters().size() == 2);
                if (decl.parameters().size() == 1) {
                    return ColorType::kNone;
                }
                const SkSL::Type& paramType = decl.parameters()[1]->type();
                SkASSERT(paramType.matches(*fsProgram.fContext->fTypes.fHalf4) ||
                         paramType.matches(*fsProgram.fContext->fTypes.fFloat4));
                return paramType.matches(*fsProgram.fContext->fTypes.fHalf4) ? ColorType::kHalf4
                                                                             : ColorType::kFloat4;
            }
        }
    }
    SkUNREACHABLE;
}

min_vcount_for_mode()

static size_t min_vcount_for_mode ( SkMesh::Mode  mode )

static

Definition at line 759 of file SkMesh.cpp.

                                                   {
    switch (mode) {
        case SkMesh::Mode::kTriangles:     return 3;
        case SkMesh::Mode::kTriangleStrip: return 3;
    }
    SkUNREACHABLE;
}

varying_type_string()

static const char * varying_type_string ( Varying::Type  type )

static

Definition at line 197 of file SkMesh.cpp.

                                                         {
    switch (type) {
        case Varying::Type::kFloat:  return "float";
        case Varying::Type::kFloat2: return "float2";
        case Varying::Type::kFloat3: return "float3";
        case Varying::Type::kFloat4: return "float4";
        case Varying::Type::kHalf:   return "half";
        case Varying::Type::kHalf2:  return "half2";
        case Varying::Type::kHalf3:  return "half3";
        case Varying::Type::kHalf4:  return "half4";
    }
    SkUNREACHABLE;
}