void get_vk_load_store_ops(const GrGpuCommandBuffer::LoadAndStoreInfo& info,
VkAttachmentLoadOp* loadOp, VkAttachmentStoreOp* storeOp) {
switch (info.fLoadOp) {
case GrGpuCommandBuffer::LoadOp::kLoad:
*loadOp = VK_ATTACHMENT_LOAD_OP_LOAD;
break;
case GrGpuCommandBuffer::LoadOp::kClear:
*loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR;
break;
case GrGpuCommandBuffer::LoadOp::kDiscard:
*loadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
break;
default:
SK_ABORT("Invalid LoadOp");
*loadOp = VK_ATTACHMENT_LOAD_OP_LOAD;
}
switch (info.fStoreOp) {
case GrGpuCommandBuffer::StoreOp::kStore:
*storeOp = VK_ATTACHMENT_STORE_OP_STORE;
break;
case GrGpuCommandBuffer::StoreOp::kDiscard:
*storeOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
break;
default:
SK_ABORT("Invalid StoreOp");
*storeOp = VK_ATTACHMENT_STORE_OP_STORE;
}
}
void get_vk_load_store_ops(GrLoadOp loadOpIn, GrStoreOp storeOpIn,
VkAttachmentLoadOp* loadOp, VkAttachmentStoreOp* storeOp) {
switch (loadOpIn) {
case GrLoadOp::kLoad:
*loadOp = VK_ATTACHMENT_LOAD_OP_LOAD;
break;
case GrLoadOp::kClear:
*loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR;
break;
case GrLoadOp::kDiscard:
*loadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
break;
default:
SK_ABORT("Invalid LoadOp");
*loadOp = VK_ATTACHMENT_LOAD_OP_LOAD;
}
switch (storeOpIn) {
case GrStoreOp::kStore:
*storeOp = VK_ATTACHMENT_STORE_OP_STORE;
break;
case GrStoreOp::kDiscard:
*storeOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
break;
default:
SK_ABORT("Invalid StoreOp");
*storeOp = VK_ATTACHMENT_STORE_OP_STORE;
}
}
static MaskedColor get_term(GrBlendCoeff coeff, const MaskedColor& src, const MaskedColor& dst,
const MaskedColor& value) {
switch (coeff) {
case kZero_GrBlendCoeff:
return MaskedColor(0, kRGBA_GrColorComponentFlags);
case kOne_GrBlendCoeff:
return value;
case kDC_GrBlendCoeff:
return MaskedColor::Mul(dst, value);
case kIDC_GrBlendCoeff:
return MaskedColor::Mul(MaskedColor::Invert(dst), value);
case kDA_GrBlendCoeff:
return MaskedColor::Mul(MaskedColor::ExtractAlpha(dst), value);
case kIDA_GrBlendCoeff:
return MaskedColor::Mul(MaskedColor::ExtractInverseAlpha(dst), value);
case kSC_GrBlendCoeff:
return MaskedColor::Mul(src, value);
case kISC_GrBlendCoeff:
return MaskedColor::Mul(MaskedColor::Invert(src), value);
case kSA_GrBlendCoeff:
return MaskedColor::Mul(MaskedColor::ExtractAlpha(src), value);
case kISA_GrBlendCoeff:
return MaskedColor::Mul(MaskedColor::ExtractInverseAlpha(src), value);
default:
SK_ABORT("Illegal coefficient");
return MaskedColor();
}
}
std::unique_ptr<Line> convertLine(int lineIndex) {
std::unique_ptr<Line> result = skstd::make_unique<Line>();
const char* cursor = fText[lineIndex];
size_t len = strlen(cursor);
const char* end = cursor + len;
result->glyphCount = SkUTF::CountUTF8(cursor, len);
std::vector<char>& bytes = result->utf;
while (cursor < end) {
SkUnichar u = SkUTF::NextUTF8(&cursor, end);
switch (fEncoding) {
case SkTextEncoding::kUTF8: {
char buffer[SkUTF::kMaxBytesInUTF8Sequence];
size_t count = SkUTF::ToUTF8(u, buffer);
result->utf.insert(bytes.end(), buffer, buffer + count);
break;
}
case SkTextEncoding::kUTF16: {
uint16_t buffer[2];
size_t count = SkUTF::ToUTF16(u, buffer);
result->utf.insert(bytes.end(), (char *)buffer, (char *)buffer + count * 2);
break;
}
case SkTextEncoding::kUTF32: {
result->utf.insert(bytes.end(), (char*) &u, (char*) &u + 4);
break;
}
default:
SK_ABORT("Bad encoding");
}
}
return result;
}
bool GrBackendFormat::operator==(const GrBackendFormat& that) const {
// Invalid GrBackendFormats are never equal to anything.
if (!fValid || !that.fValid) {
return false;
}
if (fBackend != that.fBackend) {
return false;
}
switch (fBackend) {
case GrBackendApi::kOpenGL:
return fGLFormat == that.fGLFormat;
case GrBackendApi::kVulkan:
#ifdef SK_VULKAN
return fVk.fFormat == that.fVk.fFormat &&
fVk.fYcbcrConversionInfo == that.fVk.fYcbcrConversionInfo;
#endif
break;
#ifdef SK_METAL
case GrBackendApi::kMetal:
return fMtlFormat == that.fMtlFormat;
#endif
break;
case GrBackendApi::kMock:
return fMockFormat == that.fMockFormat;
default:
SK_ABORT("Unknown GrBackend");
}
return false;
}
static void AddRun(const SkFont& font, int count, SkTextBlobRunIterator::GlyphPositioning pos,
const SkPoint& offset, SkTextBlobBuilder& builder,
const SkRect* bounds = nullptr) {
switch (pos) {
case SkTextBlobRunIterator::kDefault_Positioning: {
const SkTextBlobBuilder::RunBuffer& rb = builder.allocRun(font, count, offset.x(),
offset.y(), bounds);
for (int i = 0; i < count; ++i) {
rb.glyphs[i] = i;
}
} break;
case SkTextBlobRunIterator::kHorizontal_Positioning: {
const SkTextBlobBuilder::RunBuffer& rb = builder.allocRunPosH(font, count, offset.y(),
bounds);
for (int i = 0; i < count; ++i) {
rb.glyphs[i] = i;
rb.pos[i] = SkIntToScalar(i);
}
} break;
case SkTextBlobRunIterator::kFull_Positioning: {
const SkTextBlobBuilder::RunBuffer& rb = builder.allocRunPos(font, count, bounds);
for (int i = 0; i < count; ++i) {
rb.glyphs[i] = i;
rb.pos[i * 2] = SkIntToScalar(i);
rb.pos[i * 2 + 1] = -SkIntToScalar(i);
}
} break;
default:
SK_ABORT("unhandled positioning value");
}
}
static const char* pixel_config_name(GrPixelConfig config) {
switch (config) {
case kUnknown_GrPixelConfig: return "Unknown";
case kAlpha_8_GrPixelConfig: return "Alpha8";
case kAlpha_8_as_Alpha_GrPixelConfig: return "Alpha8_asAlpha";
case kAlpha_8_as_Red_GrPixelConfig: return "Alpha8_asRed";
case kGray_8_GrPixelConfig: return "Gray8";
case kGray_8_as_Lum_GrPixelConfig: return "Gray8_asLum";
case kGray_8_as_Red_GrPixelConfig: return "Gray8_asRed";
case kRGB_565_GrPixelConfig: return "RGB565";
case kRGBA_4444_GrPixelConfig: return "RGBA444";
case kRGBA_8888_GrPixelConfig: return "RGBA8888";
case kRGB_888_GrPixelConfig: return "RGB888";
case kBGRA_8888_GrPixelConfig: return "BGRA8888";
case kSRGBA_8888_GrPixelConfig: return "SRGBA8888";
case kSBGRA_8888_GrPixelConfig: return "SBGRA8888";
case kRGBA_1010102_GrPixelConfig: return "RGBA1010102";
case kRGBA_float_GrPixelConfig: return "RGBAFloat";
case kRG_float_GrPixelConfig: return "RGFloat";
case kAlpha_half_GrPixelConfig: return "AlphaHalf";
case kAlpha_half_as_Red_GrPixelConfig: return "AlphaHalf_asRed";
case kRGBA_half_GrPixelConfig: return "RGBAHalf";
}
SK_ABORT("Invalid pixel config");
return "<invalid>";
}
// To determine whether a current offset is aligned, we can just 'and' the lowest bits with the
// alignment mask. A value of 0 means aligned, any other value is how many bytes past alignment we
// are. This works since all alignments are powers of 2. The mask is always (alignment - 1).
// This alignment mask will give correct alignments for using the std430 block layout. If you want
// the std140 alignment, you can use this, but then make sure if you have an array type it is
// aligned to 16 bytes (i.e. has mask of 0xF).
// These are designated in the Vulkan spec, section 14.5.4 "Offset and Stride Assignment".
// https://www.khronos.org/registry/vulkan/specs/1.0-wsi_extensions/html/vkspec.html#interfaces-resources-layout
uint32_t grsltype_to_alignment_mask(GrSLType type) {
switch(type) {
case kShort_GrSLType: // fall through
case kUShort_GrSLType:
return 0x1;
case kShort2_GrSLType: // fall through
case kUShort2_GrSLType:
return 0x3;
case kShort3_GrSLType: // fall through
case kShort4_GrSLType:
case kUShort3_GrSLType:
case kUShort4_GrSLType:
return 0x7;
case kInt_GrSLType:
case kUint_GrSLType:
return 0x3;
case kHalf_GrSLType: // fall through
case kFloat_GrSLType:
return 0x3;
case kHalf2_GrSLType: // fall through
case kFloat2_GrSLType:
return 0x7;
case kHalf3_GrSLType: // fall through
case kFloat3_GrSLType:
return 0xF;
case kHalf4_GrSLType: // fall through
case kFloat4_GrSLType:
return 0xF;
case kUint2_GrSLType:
return 0x7;
case kInt2_GrSLType:
return 0x7;
case kInt3_GrSLType:
return 0xF;
case kInt4_GrSLType:
return 0xF;
case kHalf2x2_GrSLType: // fall through
case kFloat2x2_GrSLType:
return 0x7;
case kHalf3x3_GrSLType: // fall through
case kFloat3x3_GrSLType:
return 0xF;
case kHalf4x4_GrSLType: // fall through
case kFloat4x4_GrSLType:
return 0xF;
// This query is only valid for certain types.
case kVoid_GrSLType:
case kBool_GrSLType:
case kTexture2DSampler_GrSLType:
case kTextureExternalSampler_GrSLType:
case kTexture2DRectSampler_GrSLType:
case kBufferSampler_GrSLType:
case kTexture2D_GrSLType:
case kSampler_GrSLType:
break;
}
SK_ABORT("Unexpected type");
return 0;
}
void GrGLMorphologyEffect::onSetData(const GrGLSLProgramDataManager& pdman,
const GrFragmentProcessor& proc) {
const GrMorphologyEffect& m = proc.cast<GrMorphologyEffect>();
GrSurfaceProxy* proxy = m.textureSampler(0).proxy();
GrTexture& texture = *proxy->peekTexture();
float pixelSize = 0.0f;
switch (m.direction()) {
case GrMorphologyEffect::Direction::kX:
pixelSize = 1.0f / texture.width();
break;
case GrMorphologyEffect::Direction::kY:
pixelSize = 1.0f / texture.height();
break;
default:
SK_ABORT("Unknown filter direction.");
}
pdman.set1f(fPixelSizeUni, pixelSize);
if (m.useRange()) {
const float* range = m.range();
if (GrMorphologyEffect::Direction::kY == m.direction() &&
proxy->origin() == kBottomLeft_GrSurfaceOrigin) {
pdman.set2f(fRangeUni, 1.0f - (range[1]*pixelSize), 1.0f - (range[0]*pixelSize));
} else {
pdman.set2f(fRangeUni, range[0] * pixelSize, range[1] * pixelSize);
}
}
}
void GrCCPathParser::parsePath(const SkPath& path, const SkPoint* deviceSpacePts) {
SkASSERT(!fInstanceBuffer); // Can't call after finalize().
SkASSERT(!fParsingPath); // Call saveParsedPath() or discardParsedPath() for the last one first.
SkDEBUGCODE(fParsingPath = true);
SkASSERT(path.isEmpty() || deviceSpacePts);
fCurrPathPointsIdx = fGeometry.points().count();
fCurrPathVerbsIdx = fGeometry.verbs().count();
fCurrPathPrimitiveCounts = PrimitiveTallies();
fGeometry.beginPath();
if (path.isEmpty()) {
return;
}
const float* conicWeights = SkPathPriv::ConicWeightData(path);
int ptsIdx = 0;
int conicWeightsIdx = 0;
bool insideContour = false;
for (SkPath::Verb verb : SkPathPriv::Verbs(path)) {
switch (verb) {
case SkPath::kMove_Verb:
this->endContourIfNeeded(insideContour);
fGeometry.beginContour(deviceSpacePts[ptsIdx]);
++ptsIdx;
insideContour = true;
continue;
case SkPath::kClose_Verb:
this->endContourIfNeeded(insideContour);
insideContour = false;
continue;
case SkPath::kLine_Verb:
fGeometry.lineTo(&deviceSpacePts[ptsIdx - 1]);
++ptsIdx;
continue;
case SkPath::kQuad_Verb:
fGeometry.quadraticTo(&deviceSpacePts[ptsIdx - 1]);
ptsIdx += 2;
continue;
case SkPath::kCubic_Verb:
fGeometry.cubicTo(&deviceSpacePts[ptsIdx - 1]);
ptsIdx += 3;
continue;
case SkPath::kConic_Verb:
fGeometry.conicTo(&deviceSpacePts[ptsIdx - 1], conicWeights[conicWeightsIdx]);
ptsIdx += 2;
++conicWeightsIdx;
continue;
default:
SK_ABORT("Unexpected path verb.");
}
}
SkASSERT(ptsIdx == path.countPoints());
SkASSERT(conicWeightsIdx == SkPathPriv::ConicWeightCnt(path));
this->endContourIfNeeded(insideContour);
}
const char* onGetName() override {
switch (fType) {
case kMD5_ChecksumType: return "compute_md5";
case kMurmur3_ChecksumType: return "compute_murmur3";
default: SK_ABORT("Invalid Type"); return "";
}
}
void GLEllipticalRRectEffect::onSetData(const GrGLSLProgramDataManager& pdman,
const GrFragmentProcessor& effect) {
const EllipticalRRectEffect& erre = effect.cast<EllipticalRRectEffect>();
const SkRRect& rrect = erre.getRRect();
// If we're using a scale factor to work around precision issues, choose the largest radius
// as the scale factor. The inv radii need to be pre-adjusted by the scale factor.
if (rrect != fPrevRRect) {
SkRect rect = rrect.getBounds();
const SkVector& r0 = rrect.radii(SkRRect::kUpperLeft_Corner);
SkASSERT(r0.fX >= kRadiusMin);
SkASSERT(r0.fY >= kRadiusMin);
switch (erre.getRRect().getType()) {
case SkRRect::kSimple_Type:
rect.inset(r0.fX, r0.fY);
if (fScaleUniform.isValid()) {
if (r0.fX > r0.fY) {
pdman.set2f(fInvRadiiSqdUniform, 1.f, (r0.fX * r0.fX) / (r0.fY * r0.fY));
pdman.set2f(fScaleUniform, r0.fX, 1.f / r0.fX);
} else {
pdman.set2f(fInvRadiiSqdUniform, (r0.fY * r0.fY) / (r0.fX * r0.fX), 1.f);
pdman.set2f(fScaleUniform, r0.fY, 1.f / r0.fY);
}
} else {
pdman.set2f(fInvRadiiSqdUniform, 1.f / (r0.fX * r0.fX),
1.f / (r0.fY * r0.fY));
}
break;
case SkRRect::kNinePatch_Type: {
const SkVector& r1 = rrect.radii(SkRRect::kLowerRight_Corner);
SkASSERT(r1.fX >= kRadiusMin);
SkASSERT(r1.fY >= kRadiusMin);
rect.fLeft += r0.fX;
rect.fTop += r0.fY;
rect.fRight -= r1.fX;
rect.fBottom -= r1.fY;
if (fScaleUniform.isValid()) {
float scale = SkTMax(SkTMax(r0.fX, r0.fY), SkTMax(r1.fX, r1.fY));
float scaleSqd = scale * scale;
pdman.set4f(fInvRadiiSqdUniform, scaleSqd / (r0.fX * r0.fX),
scaleSqd / (r0.fY * r0.fY),
scaleSqd / (r1.fX * r1.fX),
scaleSqd / (r1.fY * r1.fY));
pdman.set2f(fScaleUniform, scale, 1.f / scale);
} else {
pdman.set4f(fInvRadiiSqdUniform, 1.f / (r0.fX * r0.fX),
1.f / (r0.fY * r0.fY),
1.f / (r1.fX * r1.fX),
1.f / (r1.fY * r1.fY));
}
break;
}
default:
SK_ABORT("RRect should always be simple or nine-patch.");
}
pdman.set4f(fInnerRectUniform, rect.fLeft, rect.fTop, rect.fRight, rect.fBottom);
fPrevRRect = rrect;
}
}
bool GrPixelConfigToVkFormat(GrPixelConfig config, VkFormat* format) {
VkFormat dontCare;
if (!format) {
format = &dontCare;
}
switch (config) {
case kUnknown_GrPixelConfig:
return false;
case kRGBA_8888_GrPixelConfig:
*format = VK_FORMAT_R8G8B8A8_UNORM;
return true;
case kBGRA_8888_GrPixelConfig:
*format = VK_FORMAT_B8G8R8A8_UNORM;
return true;
case kSRGBA_8888_GrPixelConfig:
*format = VK_FORMAT_R8G8B8A8_SRGB;
return true;
case kSBGRA_8888_GrPixelConfig:
*format = VK_FORMAT_B8G8R8A8_SRGB;
return true;
case kRGB_565_GrPixelConfig:
*format = VK_FORMAT_R5G6B5_UNORM_PACK16;
return true;
case kRGBA_4444_GrPixelConfig:
// R4G4B4A4 is not required to be supported so we actually
// store the data is if it was B4G4R4A4 and swizzle in shaders
*format = VK_FORMAT_B4G4R4A4_UNORM_PACK16;
return true;
case kAlpha_8_GrPixelConfig: // fall through
case kAlpha_8_as_Red_GrPixelConfig:
*format = VK_FORMAT_R8_UNORM;
return true;
case kAlpha_8_as_Alpha_GrPixelConfig:
return false;
case kGray_8_GrPixelConfig:
case kGray_8_as_Red_GrPixelConfig:
*format = VK_FORMAT_R8_UNORM;
return true;
case kGray_8_as_Lum_GrPixelConfig:
return false;
case kRGBA_float_GrPixelConfig:
*format = VK_FORMAT_R32G32B32A32_SFLOAT;
return true;
case kRG_float_GrPixelConfig:
*format = VK_FORMAT_R32G32_SFLOAT;
return true;
case kRGBA_half_GrPixelConfig:
*format = VK_FORMAT_R16G16B16A16_SFLOAT;
return true;
case kAlpha_half_GrPixelConfig: // fall through
case kAlpha_half_as_Red_GrPixelConfig:
*format = VK_FORMAT_R16_SFLOAT;
return true;
}
SK_ABORT("Unexpected config");
return false;
}
inline static GrGLenum gr_to_gl_access_pattern(GrGpuBufferType bufferType,
GrAccessPattern accessPattern) {
auto drawUsage = [](GrAccessPattern pattern) {
switch (pattern) {
case kDynamic_GrAccessPattern:
// TODO: Do we really want to use STREAM_DRAW here on non-Chromium?
return DYNAMIC_DRAW_PARAM;
case kStatic_GrAccessPattern:
return GR_GL_STATIC_DRAW;
case kStream_GrAccessPattern:
return GR_GL_STREAM_DRAW;
}
SK_ABORT("Unexpected access pattern");
return GR_GL_STATIC_DRAW;
};
auto readUsage = [](GrAccessPattern pattern) {
switch (pattern) {
case kDynamic_GrAccessPattern:
return GR_GL_DYNAMIC_READ;
case kStatic_GrAccessPattern:
return GR_GL_STATIC_READ;
case kStream_GrAccessPattern:
return GR_GL_STREAM_READ;
}
SK_ABORT("Unexpected access pattern");
return GR_GL_STATIC_READ;
};
auto usageType = [&drawUsage, &readUsage](GrGpuBufferType type, GrAccessPattern pattern) {
switch (type) {
case GrGpuBufferType::kVertex:
case GrGpuBufferType::kIndex:
case GrGpuBufferType::kXferCpuToGpu:
return drawUsage(pattern);
case GrGpuBufferType::kXferGpuToCpu:
return readUsage(pattern);
}
SK_ABORT("Unexpected gpu buffer type.");
return GR_GL_STATIC_DRAW;
};
return usageType(bufferType, accessPattern);
}
inline void pre_translate_transform_values(const float* xforms,
GrPathRendering::PathTransformType type, int count,
SkScalar x, SkScalar y, float* dst) {
if (0 == x && 0 == y) {
memcpy(dst, xforms, count * GrPathRendering::PathTransformSize(type) * sizeof(float));
return;
}
switch (type) {
case GrPathRendering::kNone_PathTransformType:
SK_ABORT("Cannot pre-translate kNone_PathTransformType.");
break;
case GrPathRendering::kTranslateX_PathTransformType:
SkASSERT(0 == y);
for (int i = 0; i < count; i++) {
dst[i] = xforms[i] + x;
}
break;
case GrPathRendering::kTranslateY_PathTransformType:
SkASSERT(0 == x);
for (int i = 0; i < count; i++) {
dst[i] = xforms[i] + y;
}
break;
case GrPathRendering::kTranslate_PathTransformType:
for (int i = 0; i < 2 * count; i += 2) {
dst[i] = xforms[i] + x;
dst[i + 1] = xforms[i + 1] + y;
}
break;
case GrPathRendering::kAffine_PathTransformType:
for (int i = 0; i < 6 * count; i += 6) {
dst[i] = xforms[i];
dst[i + 1] = xforms[i + 1];
dst[i + 2] = xforms[i] * x + xforms[i + 1] * y + xforms[i + 2];
dst[i + 3] = xforms[i + 3];
dst[i + 4] = xforms[i + 4];
dst[i + 5] = xforms[i + 3] * x + xforms[i + 4] * y + xforms[i + 5];
}
break;
default:
SK_ABORT("Unknown transform type.");
break;
}
}
GrScratchKey::ResourceType GrScratchKey::GenerateResourceType() {
static int32_t gType = INHERITED::kInvalidDomain + 1;
int32_t type = sk_atomic_inc(&gType);
if (type > SkTo<int32_t>(UINT16_MAX)) {
SK_ABORT("Too many Resource Types");
}
return static_cast<ResourceType>(type);
}
GrUniqueKey::Domain GrUniqueKey::GenerateDomain() {
static int32_t gDomain = INHERITED::kInvalidDomain + 1;
int32_t domain = sk_atomic_inc(&gDomain);
if (domain > SkTo<int32_t>(UINT16_MAX)) {
SK_ABORT("Too many GrUniqueKey Domains");
}
return static_cast<Domain>(domain);
}
/*
* Call longjmp to continue execution on an error
*/
void skjpeg_err_exit(j_common_ptr dinfo) {
// Simply return to Skia client code
// JpegDecoderMgr will take care of freeing memory
skjpeg_error_mgr* error = (skjpeg_error_mgr*) dinfo->err;
(*error->output_message) (dinfo);
if (error->fJmpBufStack.empty()) {
SK_ABORT("JPEG error with no jmp_buf set.");
}
longjmp(*error->fJmpBufStack.back(), 1);
}
static inline SkColor advance_color(SkColor old, ColorType ct, int step) {
if (kAlternatingOpaqueAndTransparent_ColorType == ct) {
ct = (step & 0x1) ? kChangingOpaque_ColorType : kChangingTransparent_ColorType ;
}
switch (ct) {
case kConstantOpaque_ColorType:
case kConstantTransparent_ColorType:
case kShaderOpaque_ColorType:
return old;
case kChangingOpaque_ColorType:
return 0xFF000000 | (old + 0x00010307);
case kChangingTransparent_ColorType:
return (0x00FFFFFF & (old + 0x00010307)) | 0x80000000;
case kAlternatingOpaqueAndTransparent_ColorType:
SK_ABORT("Can't get here");
}
SK_ABORT("Shouldn't reach here.");
return 0;
}
static GrGLenum gr_stencil_op_to_gl_path_rendering_fill_mode(GrStencilOp op) {
switch (op) {
default:
SK_ABORT("Unexpected path fill.");
/* fallthrough */;
case GrStencilOp::kIncWrap:
return GR_GL_COUNT_UP;
case GrStencilOp::kInvert:
return GR_GL_INVERT;
}
}
/**
* Called on a background thread. Here we can only modify fBackPaths.
*/
void runAnimationTask(double t, double dt, int w, int h) override {
const float tsec = static_cast<float>(t);
this->INHERITED::runAnimationTask(t, 0.5 * dt, w, h);
for (int i = 0; i < kNumPaths; ++i) {
const Glyph& glyph = fGlyphs[i];
const SkMatrix& backMatrix = fBackMatrices[i];
const Sk2f matrix[3] = {
Sk2f(backMatrix.getScaleX(), backMatrix.getSkewY()),
Sk2f(backMatrix.getSkewX(), backMatrix.getScaleY()),
Sk2f(backMatrix.getTranslateX(), backMatrix.getTranslateY())
};
SkPath* backpath = &fBackPaths[i];
backpath->reset();
backpath->setFillType(SkPath::kEvenOdd_FillType);
SkPath::RawIter iter(glyph.fPath);
SkPath::Verb verb;
SkPoint pts[4];
while ((verb = iter.next(pts)) != SkPath::kDone_Verb) {
switch (verb) {
case SkPath::kMove_Verb: {
SkPoint pt = fWaves.apply(tsec, matrix, pts[0]);
backpath->moveTo(pt.x(), pt.y());
break;
}
case SkPath::kLine_Verb: {
SkPoint endpt = fWaves.apply(tsec, matrix, pts[1]);
backpath->lineTo(endpt.x(), endpt.y());
break;
}
case SkPath::kQuad_Verb: {
SkPoint controlPt = fWaves.apply(tsec, matrix, pts[1]);
SkPoint endpt = fWaves.apply(tsec, matrix, pts[2]);
backpath->quadTo(controlPt.x(), controlPt.y(), endpt.x(), endpt.y());
break;
}
case SkPath::kClose_Verb: {
backpath->close();
break;
}
case SkPath::kCubic_Verb:
case SkPath::kConic_Verb:
case SkPath::kDone_Verb:
SK_ABORT("Unexpected path verb");
break;
}
}
}
}
void skjpeg_error_exit(j_common_ptr cinfo) {
skjpeg_error_mgr* error = (skjpeg_error_mgr*)cinfo->err;
(*error->output_message) (cinfo);
/* Let the memory manager delete any temp files before we die */
jpeg_destroy(cinfo);
if (error->fJmpBufStack.empty()) {
SK_ABORT("JPEG error with no jmp_buf set.");
}
longjmp(*error->fJmpBufStack.back(), -1);
}
static inline VkSamplerAddressMode wrap_mode_to_vk_sampler_address(
GrSamplerState::WrapMode wrapMode) {
switch (wrapMode) {
case GrSamplerState::WrapMode::kClamp:
return VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
case GrSamplerState::WrapMode::kRepeat:
return VK_SAMPLER_ADDRESS_MODE_REPEAT;
case GrSamplerState::WrapMode::kMirrorRepeat:
return VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT;
case GrSamplerState::WrapMode::kClampToBorder:
return VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER;
}
SK_ABORT("Unknown wrap mode.");
return VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
}
static inline SkColor start_color(ColorType ct) {
switch (ct) {
case kConstantOpaque_ColorType:
case kChangingOpaque_ColorType:
case kAlternatingOpaqueAndTransparent_ColorType:
return 0xFFA07040;
case kConstantTransparent_ColorType:
case kChangingTransparent_ColorType:
return 0x80A07040;
case kShaderOpaque_ColorType:
return SK_ColorWHITE;
}
SK_ABORT("Shouldn't reach here.");
return 0;
}
static GrSamplerState::WrapMode tile_mode_to_wrap_mode(const SkShader::TileMode tileMode) {
switch (tileMode) {
case SkShader::TileMode::kClamp_TileMode:
return GrSamplerState::WrapMode::kClamp;
case SkShader::TileMode::kRepeat_TileMode:
return GrSamplerState::WrapMode::kRepeat;
case SkShader::TileMode::kMirror_TileMode:
return GrSamplerState::WrapMode::kMirrorRepeat;
case SkShader::kDecal_TileMode:
// TODO: depending on caps, we should extend WrapMode for decal...
return GrSamplerState::WrapMode::kClamp;
}
SK_ABORT("Unknown tile mode.");
return GrSamplerState::WrapMode::kClamp;
}
int DWriteFontTypeface::onCharsToGlyphs(const void* chars, Encoding encoding,
uint16_t glyphs[], int glyphCount) const
{
if (nullptr == glyphs) {
EncodingProc next_ucs4_proc = find_encoding_proc(encoding);
for (int i = 0; i < glyphCount; ++i) {
const SkUnichar c = next_ucs4_proc(&chars);
BOOL exists;
fDWriteFont->HasCharacter(c, &exists);
if (!exists) {
return i;
}
}
return glyphCount;
}
switch (encoding) {
case SkTypeface::kUTF8_Encoding:
case SkTypeface::kUTF16_Encoding: {
static const int scratchCount = 256;
UINT32 scratch[scratchCount];
EncodingProc next_ucs4_proc = find_encoding_proc(encoding);
for (int baseGlyph = 0; baseGlyph < glyphCount; baseGlyph += scratchCount) {
int glyphsLeft = glyphCount - baseGlyph;
int limit = SkTMin(glyphsLeft, scratchCount);
for (int i = 0; i < limit; ++i) {
scratch[i] = next_ucs4_proc(&chars);
}
fDWriteFontFace->GetGlyphIndices(scratch, limit, &glyphs[baseGlyph]);
}
break;
}
case SkTypeface::kUTF32_Encoding: {
const UINT32* utf32 = reinterpret_cast<const UINT32*>(chars);
fDWriteFontFace->GetGlyphIndices(utf32, glyphCount, glyphs);
break;
}
default:
SK_ABORT("Invalid Text Encoding");
}
for (int i = 0; i < glyphCount; ++i) {
if (0 == glyphs[i]) {
return i;
}
}
return glyphCount;
}
static uint32_t primitive_vertices(GrPrimitiveType type) {
switch (type) {
case GrPrimitiveType::kTriangles:
return 3;
case GrPrimitiveType::kLines:
return 2;
case GrPrimitiveType::kTriangleStrip:
case GrPrimitiveType::kPoints:
case GrPrimitiveType::kLineStrip:
return 1;
case GrPrimitiveType::kLinesAdjacency:
return 4;
}
SK_ABORT("Incomplete switch\n");
return 0;
}
static bool use_flat_interpolation(GrGLSLVaryingHandler::Interpolation interpolation,
const GrShaderCaps& shaderCaps) {
switch (interpolation) {
using Interpolation = GrGLSLVaryingHandler::Interpolation;
case Interpolation::kInterpolated:
return false;
case Interpolation::kCanBeFlat:
SkASSERT(!shaderCaps.preferFlatInterpolation() ||
shaderCaps.flatInterpolationSupport());
return shaderCaps.preferFlatInterpolation();
case Interpolation::kMustBeFlat:
SkASSERT(shaderCaps.flatInterpolationSupport());
return true;
}
SK_ABORT("Invalid interpolation");
return false;
}
GrBackendFormat::GrBackendFormat(GrGLenum format, GrGLenum target)
: fBackend(GrBackendApi::kOpenGL)
, fValid(true)
, fGLFormat(format) {
switch (target) {
case GR_GL_TEXTURE_2D:
fTextureType = GrTextureType::k2D;
break;
case GR_GL_TEXTURE_RECTANGLE:
fTextureType = GrTextureType::kRectangle;
break;
case GR_GL_TEXTURE_EXTERNAL:
fTextureType = GrTextureType::kExternal;
break;
default:
SK_ABORT("Unexpected texture target");
}
}
void SkBaseDevice::drawTextBlob(const SkTextBlob* blob, SkScalar x, SkScalar y,
const SkPaint &paint, SkDrawFilter* drawFilter) {
SkPaint runPaint = paint;
SkTextBlobRunIterator it(blob);
for (;!it.done(); it.next()) {
size_t textLen = it.glyphCount() * sizeof(uint16_t);
const SkPoint& offset = it.offset();
// applyFontToPaint() always overwrites the exact same attributes,
// so it is safe to not re-seed the paint for this reason.
it.applyFontToPaint(&runPaint);
if (drawFilter && !drawFilter->filter(&runPaint, SkDrawFilter::kText_Type)) {
// A false return from filter() means we should abort the current draw.
runPaint = paint;
continue;
}
runPaint.setFlags(this->filterTextFlags(runPaint));
switch (it.positioning()) {
case SkTextBlob::kDefault_Positioning:
this->drawText(it.glyphs(), textLen, x + offset.x(), y + offset.y(), runPaint);
break;
case SkTextBlob::kHorizontal_Positioning:
this->drawPosText(it.glyphs(), textLen, it.pos(), 1,
SkPoint::Make(x, y + offset.y()), runPaint);
break;
case SkTextBlob::kFull_Positioning:
this->drawPosText(it.glyphs(), textLen, it.pos(), 2,
SkPoint::Make(x, y), runPaint);
break;
default:
SK_ABORT("unhandled positioning mode");
}
if (drawFilter) {
// A draw filter may change the paint arbitrarily, so we must re-seed in this case.
runPaint = paint;
}
}
}
