submodule/skia/src/core/SkMeshPriv.h

   1 /*
   2  * Copyright 2021 Google LLC
   3  *
   4  * Use of this source code is governed by a BSD-style license that can be
   5  * found in the LICENSE file.
   6  */
   7
   8 #ifndef SkMeshPriv_DEFINED
   9 #define SkMeshPriv_DEFINED
  10
  11 #include "include/core/SkMesh.h"
  12
  13 #ifdef SK_ENABLE_SKSL
  14 #include "include/core/SkData.h"
  15 #include "include/private/gpu/ganesh/GrTypesPriv.h"
  16 #include "src/core/SkSLTypeShared.h"
  17
  18 #if SK_SUPPORT_GPU
  19 #include "include/gpu/GrDirectContext.h"
  20 #include "src/gpu/ganesh/GrDirectContextPriv.h"
  21 #include "src/gpu/ganesh/GrGpuBuffer.h"
  22 #include "src/gpu/ganesh/GrResourceCache.h"
  23 #include "src/gpu/ganesh/GrResourceProvider.h"
  24 #endif
  25
  26 struct SkMeshSpecificationPriv {
  27     using Varying   = SkMeshSpecification::Varying;
  28     using Attribute = SkMeshSpecification::Attribute;
  29     using ColorType = SkMeshSpecification::ColorType;
  30
  31     static SkSpan<const Varying> Varyings(const SkMeshSpecification& spec) {
  32         return SkMakeSpan(spec.fVaryings);
  33     }
  34
  35     static const SkSL::Program* VS(const SkMeshSpecification& spec) { return spec.fVS.get(); }
  36     static const SkSL::Program* FS(const SkMeshSpecification& spec) { return spec.fFS.get(); }
  37
  38     static int Hash(const SkMeshSpecification& spec) { return spec.fHash; }
  39
  40     static ColorType GetColorType(const SkMeshSpecification& spec) { return spec.fColorType; }
  41     static bool HasColors(const SkMeshSpecification& spec) {
  42         return GetColorType(spec) != ColorType::kNone;
  43     }
  44
  45     static SkColorSpace* ColorSpace(const SkMeshSpecification& spec) {
  46         return spec.fColorSpace.get();
  47     }
  48
  49     static SkAlphaType AlphaType(const SkMeshSpecification& spec) { return spec.fAlphaType; }
  50
  51     static bool HasLocalCoords(const SkMeshSpecification& spec) { return spec.fHasLocalCoords; }
  52
  53     static SkSLType VaryingTypeAsSLType(Varying::Type type) {
  54         switch (type) {
  55             case Varying::Type::kFloat:  return SkSLType::kFloat;
  56             case Varying::Type::kFloat2: return SkSLType::kFloat2;
  57             case Varying::Type::kFloat3: return SkSLType::kFloat3;
  58             case Varying::Type::kFloat4: return SkSLType::kFloat4;
  59             case Varying::Type::kHalf:   return SkSLType::kHalf;
  60             case Varying::Type::kHalf2:  return SkSLType::kHalf2;
  61             case Varying::Type::kHalf3:  return SkSLType::kHalf3;
  62             case Varying::Type::kHalf4:  return SkSLType::kHalf4;
  63         }
  64         SkUNREACHABLE;
  65     }
  66
  67     static GrVertexAttribType AttrTypeAsVertexAttribType(Attribute::Type type) {
  68         switch (type) {
  69             case Attribute::Type::kFloat:        return kFloat_GrVertexAttribType;
  70             case Attribute::Type::kFloat2:       return kFloat2_GrVertexAttribType;
  71             case Attribute::Type::kFloat3:       return kFloat3_GrVertexAttribType;
  72             case Attribute::Type::kFloat4:       return kFloat4_GrVertexAttribType;
  73             case Attribute::Type::kUByte4_unorm: return kUByte4_norm_GrVertexAttribType;
  74         }
  75         SkUNREACHABLE;
  76     }
  77
  78     static SkSLType AttrTypeAsSLType(Attribute::Type type) {
  79         switch (type) {
  80             case Attribute::Type::kFloat:        return SkSLType::kFloat;
  81             case Attribute::Type::kFloat2:       return SkSLType::kFloat2;
  82             case Attribute::Type::kFloat3:       return SkSLType::kFloat3;
  83             case Attribute::Type::kFloat4:       return SkSLType::kFloat4;
  84             case Attribute::Type::kUByte4_unorm: return SkSLType::kHalf4;
  85         }
  86         SkUNREACHABLE;
  87     }
  88 };
  89
  90 struct SkMeshPriv {
  91     class Buffer {
  92     public:
  93         virtual ~Buffer() = 0;
  94
  95         Buffer() = default;
  96         Buffer(const Buffer&) = delete;
  97
  98         Buffer& operator=(const Buffer&) = delete;
  99
 100         virtual sk_sp<const SkData> asData() const { return nullptr; }
 101
 102 #if SK_SUPPORT_GPU
 103         virtual sk_sp<const GrGpuBuffer> asGpuBuffer() const { return nullptr; }
 104 #endif
 105
 106         virtual size_t size() const = 0;
 107     };
 108
 109     class IB : public Buffer, public SkMesh::IndexBuffer  {};
 110     class VB : public Buffer, public SkMesh::VertexBuffer {};
 111
 112     template <typename Base> class CpuBuffer final : public Base {
 113     public:
 114         CpuBuffer()           = default;
 115         ~CpuBuffer() override = default;
 116
 117         static sk_sp<Base> Make(sk_sp<const SkData> data);
 118
 119         sk_sp<const SkData> asData() const override { return fData; }
 120
 121         size_t size() const override { return fData->size(); }
 122
 123     private:
 124         sk_sp<const SkData> fData;
 125     };
 126
 127     using CpuIndexBuffer  = CpuBuffer<IB>;
 128     using CpuVertexBuffer = CpuBuffer<VB>;
 129
 130 #if SK_SUPPORT_GPU
 131     template <typename Base, GrGpuBufferType> class GpuBuffer final : public Base {
 132     public:
 133         GpuBuffer() = default;
 134
 135         ~GpuBuffer() override;
 136
 137         static sk_sp<Base> Make(GrDirectContext*, sk_sp<const SkData>);
 138
 139         sk_sp<const GrGpuBuffer> asGpuBuffer() const override { return fBuffer; }
 140
 141         size_t size() const override { return fBuffer->size(); }
 142
 143     private:
 144         sk_sp<GrGpuBuffer> fBuffer;
 145         GrDirectContext::DirectContextID fContextID;
 146     };
 147
 148     using GpuIndexBuffer  = GpuBuffer<IB, GrGpuBufferType::kIndex >;
 149     using GpuVertexBuffer = GpuBuffer<VB, GrGpuBufferType::kVertex>;
 150 #endif  // SK_SUPPORT_GPU
 151 };
 152
 153 inline SkMeshPriv::Buffer::~Buffer() = default;
 154
 155 template <typename Base> sk_sp<Base> SkMeshPriv::CpuBuffer<Base>::Make(sk_sp<const SkData> data) {
 156     SkASSERT(data);
 157     auto result = new CpuBuffer<Base>;
 158     result->fData = std::move(data);
 159     return sk_sp<Base>(result);
 160 }
 161 #if SK_SUPPORT_GPU
 162
 163 template <typename Base, GrGpuBufferType Type> SkMeshPriv::GpuBuffer<Base, Type>::~GpuBuffer() {
 164     GrResourceCache::ReturnResourceFromThread(std::move(fBuffer), fContextID);
 165 }
 166
 167 template <typename Base, GrGpuBufferType Type>
 168 sk_sp<Base> SkMeshPriv::GpuBuffer<Base, Type>::Make(GrDirectContext* dc,sk_sp<const SkData> data) {
 169     SkASSERT(dc);
 170     SkASSERT(data);
 171
 172     sk_sp<GrGpuBuffer> buffer = dc->priv().resourceProvider()->createBuffer(
 173             data->size(),
 174             Type,
 175             kStatic_GrAccessPattern,
 176             data->data());
 177     if (!buffer) {
 178         return nullptr;
 179     }
 180
 181     auto result = new GpuBuffer;
 182     result->fBuffer    = std::move(buffer);
 183     result->fContextID = dc->directContextID();
 184     return sk_sp<Base>(result);
 185 }
 186
 187 #endif  // SK_SUPPORT_GPU
 188
 189 #endif  // SK_ENABLE_SKSL
 190
 191 #endif