/* * Copyright 2016 Google Inc. * * Use of this source code is governed by a BSD-style license that can * be found in the LICENSE file. */ // // C++ // #include "SkDevice_Compute.h" #include "SkPM4f.h" // // // #if SK_SUPPORT_GPU_COMPUTE // // C++ // #include "SkImageInfo.h" #include "SkDraw.h" #include "SkMatrix.h" #include "SkPath.h" // // C // #ifdef __cplusplus extern "C" { #endif #include "../spinel/spinel/color.h" #include "../compute/skc/skc.h" #ifdef __cplusplus } #endif // // // SkDevice_Compute::SkDevice_Compute(sk_sp compute, int w, int h) : SkClipStackDevice(SkImageInfo::MakeN32Premul(w,h), SkSurfaceProps(0,kUnknown_SkPixelGeometry)) , fCompute(std::move(compute)) { fTopCTM = this->ctm(); fTransformWeakref = SKC_WEAKREF_INVALID; fClipWeakref = SKC_WEAKREF_INVALID; skc_err err; // // create a composition // #define LAYER_COUNT (1<<14) err = skc_composition_create(fCompute->context, &fComposition); SKC_ERR_CHECK(err); // Is this correct? int clipRect[] = { 0, 0, w - 1, h - 1 }; err = skc_composition_clip_set(fComposition, clipRect); SKC_ERR_CHECK(err); // // create styling // err = skc_styling_create(fCompute->context, LAYER_COUNT, 10, 2 * 1024 * 1024, &fStyling); // // create a path builder // err = skc_path_builder_create(fCompute->context, &fPB); SKC_ERR_CHECK(err); // // create a raster builder // err = skc_raster_builder_create(fCompute->context, &fRB); SKC_ERR_CHECK(err); // // create the simplest styling group that encloses all layers // styling_group_init(); } // // // SkDevice_Compute::~SkDevice_Compute() { skc_err err; err = skc_raster_builder_release(fRB); SKC_ERR_CHECK(err); err = skc_path_builder_release(fPB); SKC_ERR_CHECK(err); err = skc_styling_dispose(fStyling); SKC_ERR_CHECK(err); err = skc_composition_dispose(fComposition); SKC_ERR_CHECK(err); } // // // void SkDevice_Compute::flush() { // // seal the styling and composition objects // skc_err err; err = skc_composition_seal(fComposition); SKC_ERR_CHECK(err); err = skc_styling_seal(fStyling); SKC_ERR_CHECK(err); // // we're going to block here -- API mismatch // // // render to surface // // note this implicitly seals composition and styling // err = skc_surface_render(fCompute->surface, fComposition, fStyling); SKC_ERR_CHECK(err); // // kick off pipeline and wait here -- not needed since skc_surface_reset() blocks // err = skc_surface_wait(fCompute->surface); SKC_ERR_CHECK(err); // // reset the surface -- implicitly waits for render to finish -- FIXME -- composition might be released too early // err = skc_surface_reset(fCompute->surface); SKC_ERR_CHECK(err); // // reset composition and styling // err = skc_composition_reset(fComposition); SKC_ERR_CHECK(err); err = skc_styling_reset(fStyling); SKC_ERR_CHECK(err); // // // styling_group_init(); } // // // #define SKC_STYLING_CMDS(...) SK_ARRAY_COUNT(__VA_ARGS__),__VA_ARGS__ #define SKC_GROUP_IDS(...) SK_ARRAY_COUNT(__VA_ARGS__),__VA_ARGS__ void SkDevice_Compute::styling_group_init() { skc_styling_group_alloc(fStyling, &fGroupID); fParents.push_back(fGroupID); // ENTER skc_styling_cmd_t const styling_cmds_enter[] = { SKC_STYLING_CMD_OP_COVER_ZERO_ACC, SKC_STYLING_CMD_OP_COLOR_ZERO_ACC | SKC_STYLING_CMD_OP_IS_FINAL }; skc_styling_group_enter(fStyling, fGroupID, SKC_STYLING_CMDS(styling_cmds_enter)); skc_group_id const group_id_parents[] = { fGroupID }; skc_styling_group_parents(fStyling, fGroupID, SKC_GROUP_IDS(group_id_parents)); // RANGE skc_styling_group_range_lo(fStyling, fGroupID, 0); skc_styling_group_range_hi(fStyling, fGroupID, LAYER_COUNT-1); // LEAVE skc_styling_cmd_t const styling_cmds_leave[] = { SKC_STYLING_CMD_OP_SURFACE_COMPOSITE | SKC_STYLING_CMD_OP_IS_FINAL }; skc_styling_group_leave(fStyling, fGroupID, SKC_STYLING_CMDS(styling_cmds_leave)); // START fGroupLayerID = LAYER_COUNT-1; } // // // #define SK_SCALE_F32 (1.0f/255.0f) #define SK_TO_RGBA_F32(c) { SK_SCALE_F32 * SkColorGetR(c), \ SK_SCALE_F32 * SkColorGetG(c), \ SK_SCALE_F32 * SkColorGetB(c), \ SK_SCALE_F32 * SkColorGetA(c) } // // // void SkDevice_Compute::path_rasterize_and_place(const SkPaint& paint, const skc_path_t path, const SkMatrix* prePathMatrix) { float transform[9]; const SkMatrix& ctm = fTopCTM; SkMatrix tmp; if (prePathMatrix) { tmp.setConcat(ctm, *prePathMatrix); } transform[0] = tmp.get(SkMatrix::kMScaleX); transform[1] = tmp.get(SkMatrix::kMSkewX ); transform[2] = tmp.get(SkMatrix::kMTransX); transform[3] = tmp.get(SkMatrix::kMSkewY ); transform[4] = tmp.get(SkMatrix::kMScaleY); transform[5] = tmp.get(SkMatrix::kMTransY); transform[6] = tmp.get(SkMatrix::kMPersp0); transform[7] = tmp.get(SkMatrix::kMPersp1); transform[8] = tmp.get(SkMatrix::kMPersp2); skc_transform_weakref_t& transform_weakref = fTransformWeakref; // // always invalid for now // skc_raster_clip_weakref_t clip_weakref = fClipWeakref; // TODO Support arbitrary path clip? SkRect devClip = SkRect::MakeFromIRect(this->devClipBounds()); const float clip[] = { devClip.fLeft, devClip.fTop, devClip.fRight, devClip.fBottom }; // // // skc_err err; skc_raster_t raster; err = skc_raster_begin(fRB); err = skc_raster_add_filled(fRB, path, &transform_weakref, transform, &clip_weakref, clip); err = skc_raster_end(fRB, &raster); // // can release path handle now because it is being referenced by raster // err = skc_path_release(fCompute->context, path); // // style the path // skc_styling_cmd_t cmds[1 + 3 + 1]; cmds[0] = SKC_STYLING_CMD_OP_COVER_NONZERO; cmds[SK_ARRAY_COUNT(cmds)-1] = SKC_STYLING_CMD_OP_BLEND_OVER | SKC_STYLING_CMD_OP_IS_FINAL; { SkPM4f rgba = SkColor4f::FromColor(paint.getColor()).premul(); skc_styling_layer_fill_solid_encoder(cmds+1, rgba.fVec); skc_styling_group_layer(fStyling, fGroupID, fGroupLayerID, SKC_STYLING_CMDS(cmds)); } err = skc_composition_place(fComposition, fGroupLayerID, raster, 0, 0); // // can release raster handle now because it is being referenced by composition // err = skc_raster_release(fCompute->context, raster); SkASSERT(err == SKC_ERR_SUCCESS); fGroupLayerID -= 1; } // // // void SkDevice_Compute::path_add(const SkPaint& paint, const SkPath& path, const SkMatrix* prePathMatrix) { skc_err err; err = skc_path_begin(fPB); #if 0 SkPath::Iter pi(path,false); #else SkPath::RawIter pi(path); // this seems to work fine for now #endif SkPoint xy0; // // build path // while (true) { SkPoint pts[4]; SkPath::Verb const verb = pi.next(pts); switch (verb) { case SkPath::kMove_Verb: xy0 = pts[0]; err = skc_path_move_to(fPB, pts[0].x(),pts[0].y()); continue; case SkPath::kLine_Verb: err = skc_path_line_to(fPB, pts[1].x(),pts[1].y()); continue; case SkPath::kQuad_Verb: err = skc_path_quad_to(fPB, pts[1].x(),pts[1].y(), pts[2].x(),pts[2].y()); continue; case SkPath::kConic_Verb: // <--------------------- FIXME err = skc_path_line_to(fPB, pts[2].x(),pts[2].y()); continue; case SkPath::kCubic_Verb: err = skc_path_cubic_to(fPB, pts[1].x(),pts[1].y(), pts[2].x(),pts[2].y(), pts[3].x(),pts[3].y()); continue; case SkPath::kClose_Verb: err = skc_path_line_to(fPB,xy0.x(),xy0.y()); continue; case SkPath::kDone_Verb: break; } // // otherwise, kDone_Verb breaks out of while loop // break; } // // seal the path // skc_path_t skc_path; err = skc_path_end(fPB,&skc_path); // // rasterize the path and place it in a composition // path_rasterize_and_place(paint,skc_path,prePathMatrix); SkASSERT(err == SKC_ERR_SUCCESS); } // // // void SkDevice_Compute::circles_add( const SkPaint & paint, const SkPoint points[], int32_t const count, SkScalar const radius) { #define CIRCLE_KAPPA 0.55228474983079339840f // moar digits! #define CIRCLE_RADIUS_X radius #define CIRCLE_RADIUS_Y radius #define CIRCLE_KAPPA_X (CIRCLE_RADIUS_X * CIRCLE_KAPPA) #define CIRCLE_KAPPA_Y (CIRCLE_RADIUS_Y * CIRCLE_KAPPA) // // use a 4 Bezier approximation // float const circle[] = { 0.0f, +CIRCLE_RADIUS_Y, // move_to +CIRCLE_KAPPA_X, +CIRCLE_RADIUS_Y, // cubic_to +CIRCLE_RADIUS_X, +CIRCLE_KAPPA_Y, +CIRCLE_RADIUS_X, 0.0f, +CIRCLE_RADIUS_X, -CIRCLE_KAPPA_Y, // cubic_to +CIRCLE_KAPPA_X, -CIRCLE_RADIUS_Y, 0.0f, -CIRCLE_RADIUS_Y, -CIRCLE_KAPPA_X, -CIRCLE_RADIUS_Y, // cubic_to -CIRCLE_RADIUS_X, -CIRCLE_KAPPA_Y, -CIRCLE_RADIUS_X, 0.0f, -CIRCLE_RADIUS_X, +CIRCLE_KAPPA_Y, // cubic_to -CIRCLE_KAPPA_X, +CIRCLE_RADIUS_Y, 0.0f, +CIRCLE_RADIUS_Y }; #define CXLAT(x,y,t) circle[x]+t.fX,circle[y]+t.fY // // // skc_err err; err = skc_path_begin(fPB); // // // for (int32_t ii=0; iisurface,rgba); } void SkDevice_Compute::drawPoints(SkCanvas::PointMode mode, size_t count, const SkPoint points[], const SkPaint& paint) { if (count == 0) { return; } const SkScalar radius = paint.getStrokeWidth() * 0.5f; /* * drawPoints draws each element (point, line) separately. This means our bulk-adding into the * same raster is not valid for most blendmodes. */ switch (mode) { case SkCanvas::kPoints_PointMode: { if (paint.getStrokeCap() == SkPaint::kRound_Cap) { circles_add(paint, points, (int32_t)count, radius); } else { squares_add(paint, points,(int32_t)count, radius); } } break; case SkCanvas::kLines_PointMode: { if (count <= 1) { return; } lines_stroked_add(paint, points, (int32_t)count & ~1, radius); } break; case SkCanvas::kPolygon_PointMode: { SkPoint xy0 = points[0]; skc_err err = skc_path_begin(fPB); for (size_t i = 0; i < count; ++i) { const SkPoint xy1 = points[i]; line_stroked_butt(xy0, xy1, radius); xy0 = xy1; } // // seal the path // skc_path_t skc_path; err = skc_path_end(fPB, &skc_path); // // rasterize the path and place it in a composition // path_rasterize_and_place(paint, skc_path, nullptr); SkASSERT(err == SKC_ERR_SUCCESS); } break; default: break; } } void SkDevice_Compute::drawRect(const SkRect& rect, const SkPaint& paint) { SkPath path; path.addRect(rect); this->drawPath(path, paint, nullptr, true); } void SkDevice_Compute::drawOval(const SkRect& oval, const SkPaint& paint) { SkPath path; path.addOval(oval); this->drawPath(path, paint, nullptr, true); } void SkDevice_Compute::drawRRect(const SkRRect& rrect, const SkPaint& paint) { SkPath path; path.addRRect(rrect); this->drawPath(path, paint, nullptr, true); } void SkDevice_Compute::drawPath(const SkPath& path, const SkPaint& paint, const SkMatrix* prePathMatrix, bool pathIsMutable) { if (paint.getStyle() == SkPaint::kFill_Style) { path_add(paint,path,prePathMatrix); } else { SkPath stroked; #define SK_MAGIC_RES_SCALE 1024 paint.getFillPath(path, &stroked, nullptr, SK_MAGIC_RES_SCALE); this->path_add(paint, stroked, prePathMatrix); } } void SkDevice_Compute::drawText(const void* text, size_t length, SkScalar x, SkScalar y, const SkPaint& paint) { SkPath outline; paint.getTextPath(text,length,x,y,&outline); this->drawPath(outline, paint, nullptr, true); } void SkDevice_Compute::drawPosText(const void * text, size_t length, const SkScalar pos[], int scalarsPerPos, const SkPoint & offset, const SkPaint & paint) { #if 0 draw.drawPosText_asPaths((const char *)text,length, pos,scalarsPerPos,offset,paint); #endif } SkBaseDevice* SkDevice_Compute::onCreateDevice(const CreateInfo& cinfo, const SkPaint* paint) { #ifdef SK_USE_COMPUTE_LAYER_GROUP return this->createLayerGroup(cinfo, paint); #else // TODO return a new SkDevice_Compute when SkDevice_ComputeLayerGroup doesn't work return nullptr; #endif } void SkDevice_Compute::drawDevice(SkBaseDevice* device, int left, int top, const SkPaint& paint) { // It seems that we won't support image filter until snapSpecial and drawSpecial are implemented // (SkCanvas.cpp will call drawSpecial when the paint has an image filter). SkASSERT(!paint.getImageFilter()); #ifdef SK_USE_COMPUTE_LAYER_GROUP // In case of SkDevice_ComputeLayerGroup, we close the group SkDevice_ComputeLayerGroup* layerDevice = static_cast(device); SkASSERT(layerDevice->fRoot == this); // the layerDevice should belong to this root device SkASSERT(layerDevice->fGroupID == fGroupID); // the layerDevice should be the top device // left, top should be the same as the origin, // and we can ignore them because we have no offscreen buffer. SkASSERT(SkIPoint::Make(left, top) == device->getOrigin()); // close the group and pop the top device skc_styling_group_range_lo(fStyling, fGroupID, fGroupLayerID + 1); fGroupID = fParents.back(); fParents.pop_back(); #else // TODO handle the case where the device is a SkDevice_Compute rather than // SkDevice_ComputeLayerGroup (in which case an offscreen buffer is created). #endif } #ifdef SK_USE_COMPUTE_LAYER_GROUP SkDevice_ComputeLayerGroup* SkDevice_Compute::createLayerGroup(const CreateInfo& cinfo, const SkPaint* paint) { return new SkDevice_ComputeLayerGroup(this, cinfo, paint); } void SkDevice_Compute::onCtmChanged() { fTopCTM = this->ctm(); fTransformWeakref = SKC_WEAKREF_INVALID; } SkDevice_ComputeLayerGroup::SkDevice_ComputeLayerGroup(SkDevice_Compute* root, const CreateInfo& cinfo, const SkPaint* paint) : SkBaseDevice(SkImageInfo::MakeN32Premul(cinfo.fInfo.width(), cinfo.fInfo.height()), SkSurfaceProps(0,kUnknown_SkPixelGeometry)) { // TODO clip the group using cinfo; handle the paint's alpha and maybe color filter? // Create a new group. We'll restore the previous group during onRestore. skc_styling_group_alloc(fRoot->fStyling, &fRoot->fGroupID); fRoot->fParents.push_back(fRoot->fGroupID); fGroupID = fRoot->fGroupID; // ENTER skc_styling_cmd_t const styling_cmds_enter[] = { SKC_STYLING_CMD_OP_COVER_ZERO_ACC, SKC_STYLING_CMD_OP_COLOR_ZERO_ACC }; skc_styling_group_enter(fRoot->fStyling, fRoot->fGroupID, SKC_STYLING_CMDS(styling_cmds_enter)); skc_styling_group_parents(fRoot->fStyling, fRoot->fGroupID, fRoot->fParents.count(), fRoot->fParents.begin()); // RANGE // We'll set range_lo at restore skc_styling_group_range_hi(fRoot->fStyling, fRoot->fGroupID, fRoot->fGroupLayerID); // LEAVE skc_styling_cmd_t const styling_cmds_leave[] = { SKC_STYLING_CMD_OP_SURFACE_COMPOSITE }; skc_styling_group_leave(fRoot->fStyling, fRoot->fGroupID, SKC_STYLING_CMDS(styling_cmds_leave)); } void SkDevice_ComputeLayerGroup::drawDevice(SkBaseDevice* device, int left, int top, const SkPaint& paint) { fRoot->drawDevice(device, left, top, paint); // the root will properly close the group } SkBaseDevice* SkDevice_ComputeLayerGroup::onCreateDevice(const CreateInfo& cinfo, const SkPaint* paint) { return fRoot->createLayerGroup(cinfo, paint); } void SkDevice_ComputeLayerGroup::onCtmChanged() { this->sanityCheck(); // Cancels the translation as we're not using an offscreen buffer const SkIPoint& origin = this->getOrigin(); fRoot->fTopCTM = this->ctm(); fRoot->fTopCTM.postTranslate(SkIntToScalar(origin.fX), SkIntToScalar(origin.fY)); fRoot->fTransformWeakref = SKC_WEAKREF_INVALID; } void SkDevice_ComputeLayerGroup::onSave() { this->sanityCheck(); fRoot->onSave(); } void SkDevice_ComputeLayerGroup::onRestore() { this->sanityCheck(); fRoot->onRestore(); } void SkDevice_ComputeLayerGroup::onClipRect(const SkRect& rect, SkClipOp op, bool aa) { this->sanityCheck(); fRoot->fClipStack.clipRect(rect, fRoot->fTopCTM, op, aa); fRoot->fClipWeakref = SKC_WEAKREF_INVALID; } void SkDevice_ComputeLayerGroup::onClipRRect(const SkRRect& rrect, SkClipOp op, bool aa) { this->sanityCheck(); fRoot->fClipStack.clipRRect(rrect, fRoot->fTopCTM, op, aa); fRoot->fClipWeakref = SKC_WEAKREF_INVALID; } void SkDevice_ComputeLayerGroup::onClipPath(const SkPath& path, SkClipOp op, bool aa) { this->sanityCheck(); fRoot->fClipStack.clipPath(path, fRoot->fTopCTM, op, aa); fRoot->fClipWeakref = SKC_WEAKREF_INVALID; } void SkDevice_ComputeLayerGroup::onClipRegion(const SkRegion& deviceRgn, SkClipOp op) { this->sanityCheck(); fRoot->onClipRegion(deviceRgn, op); } void SkDevice_ComputeLayerGroup::onSetDeviceClipRestriction(SkIRect* mutableClipRestriction) { this->sanityCheck(); fRoot->onSetDeviceClipRestriction(mutableClipRestriction); } #endif // SK_USE_COMPUTE_LAYER_GROUP #endif