1Skia Graphics Release Notes 2 3This file includes a list of high level updates for each milestone release. 4 5Milestone 132 6------------- 7 * A new `SkCodec` method has been added: `hasHighBitDepthEncodedData`. 8 * `GrGLInterface` completeness requirements are modified to support using timer queries when available in the GL context. 9 The interface must have relevant functions initialized on OpenGL 3.3 or with GL_EXT_timer_query or GL_ARB_timerquery, on OpenGL ES with 10 GL_EXT_disjoint_timer_query, and on WebGL with GL_EXT_disjoint_timer_query or GL_EXT_disjoint_timer_query_webgl2. 11 * `GrGLInterface` now expects functions that take two `GLuints` instead of one `GLuint64` for `glWaitSync` and `glClientWaitSync` 12 when building with Emscripten. `GrGLMakeAssembledWebGLInterface` binds directly to the `emscipten_gl*` functions declared in the `<webgl/*>` headers rather than the functions declared 13 in `GLES3/gl32.h` and `GLES3/gl2ext.h`. 14 * `SkPathEffect::DashType`, `SkPathEffect::DashInfo` and `SkPathEffect::asADash` have been removed from the public API. 15 16* * * 17 18Milestone 131 19------------- 20 * `SkCanvas::SaveLayerRec` can optionally specify a tilemode to apply to backdrop 21 content when the new layer's effects would sample outside of the previous 22 layer's image. 23 * GrContextOptions::fSharpenMipmappedTextures has been restored. It is now enabled 24 by default but allows clients to disable this feature if desired. 25 26* * * 27 28Milestone 130 29------------- 30 * Add version of `SkAndroidCodec::getGainmapAndroidCodec` which returns an `SkAndroidCodec` instead 31 of an `SkStream`. Mark as deprecated the version that returns an `SkStream`. 32 * `SkColorFilter::filterColor` has been removed. Please use `SkColorFilter::filterColor4f` instead. 33 * SkFourByteTag has been moved to its own file: `include/core/SkFourByteTag.h` 34 * Ganesh files have been moved out of include/gpu/ into include/gpu/ganesh/. Shims have been left in place, but clients should migrate to the new paths. 35 * GR_GL_CUSTOM_SETUP_HEADER will be removed. Configuration in a client provided 36 SkUserConfig.h file (or defines set during compilation) are sufficient to affect 37 settings in GrGLConfig.h 38 * `GR_MAKE_BITFIELD_CLASS_OPS` and `GR_DECL_BITFIELD_CLASS_OPS_FRIENDS` have been removed 39 from the public API 40 * `SkMSec` has been removed from the public API, including `SkParse::FindMSec` 41 * A noop change to our SkSL runtime effect builder APIs. Moved make functions from subclasses 42 SkRuntimeShaderBuilder, SkRuntimeColorFilterBuilder, and SkRuntimeBlendBuilder to the base class 43 SkRuntimeEffectBuilder. 44 45* * * 46 47Milestone 129 48------------- 49 * The Dawn-specific constructors and methods on `skgpu::graphite::TextureInfo`, 50 `skgpu::graphite::BackendTexture`, have been deprecated and 51 moved to be functions in `DawnTypes.h` 52 * `SkImageFilters::DropShadow` and `SkImageFilters::DropShadowOnly` now accept 53 `SkColor4f` and `SkColorSpace` for the shadow color. 54 * `SkScalerContext::MakeRecAndEffects` now converts `SkFont::isEmbolden` to the `kEmbolden_Flag`. 55 It no longer automatically converts embolden requests into (more) stroking. 56 This can now (optionally) be done in `SkTypeface::onFilterRec` by calling the new `SkScalerContextRec::useStrokeForFakeBold()`. 57 * Skia no longer tests building against iOS 11. 58 The minimum deployment target is now iOS 12 as this is the minimum deplyment target for Xcode 15. 59 * The Vulkan-specific constructors and methods on `skgpu::graphite::TextureInfo`, 60 `skgpu::graphite::BackendTexture`, `skgpu::graphite::BackendSemaphore` have been deprecated and 61 moved to be functions in `VulkanGraphiteTypes.h` 62 63* * * 64 65Milestone 128 66------------- 67 * SkSL now properly reports an error if user code includes various GLSL reserved keywords. 68 Previously, Skia would correctly reject keywords that were included in "The OpenGL ES 69 Shading Language, Version 1.00," but did not detect reserved keywords added in more modern 70 GLSL versions. Instead, Skia would allow such code to compile during the construction of a 71 runtime effect, but actually rendering the effect using a modern version of OpenGL would 72 silently fail (or assert) due to the presence of the reserved name in the the code. 73 74 Examples of reserved names which SkSL will now reject include `dmat3x3`, `atomic_uint`, 75 `isampler2D`, or `imageCubeArray`. 76 77 For a more thorough list of reserved keywords, see the "3.6 Keywords" section of the 78 OpenGL Shading Language documentation. 79 * The following symbols (and their files) have been deleted in favor of their 80 GPU-backend-agnostic form: 81 - `GrVkBackendContext` -> `skgpu::VulkanBackendContext` 82 - `GrVkExtensions` -> `skgpu::VulkanExtensions` 83 - `GrVkMemoryAllocator` = `skgpu::VulkanMemoryAllocator` 84 - `GrVkBackendMemory` = `skgpu::VulkanBackendMemory` 85 - `GrVkAlloc` = `skgpu::VulkanAlloc` 86 - `GrVkYcbcrConversionInfo` = `skgpu::VulkanYcbcrConversionInfo` 87 - `GrVkGetProc` = `skgpu::VulkanGetProc` 88 * The Metal-specific constructors and methods on `skgpu::graphite::TextureInfo`, 89 `skgpu::graphite::BackendTexture`, `skgpu::graphite::BackendSemaphore` have been deprecated and 90 moved to be functions in `MtlGraphiteTypes.h` 91 * SkImage now has a method makeScaled(...) which returns a scaled version of 92 the image, retaining its original "domain" 93 - raster stays raster 94 - ganesh stays ganesh 95 - graphite stays graphite 96 - lazy images become raster (just like with makeSubset) 97 98* * * 99 100Milestone 127 101------------- 102 * SkSL now properly recognizes the types `uvec2`, `uvec3` or `uvec4`. 103 104 Unsigned types are not supported in Runtime Effects, as they did not exist in GLSL ES2; however, 105 SkSL should still recognize these typenames and reject them if they are used in a program. 106 That is, we should not allow `uvec3` to be used as a variable or function name. We will now properly 107 detect and reject this as an error. 108 * The following deprecated fields have been removed from `GrVkBackendContext`: 109 - `fMinAPIVersion`. Use `fMaxAPIVersion` instead. 110 - `fInstanceVersion`. Use `fMaxAPIVersion` instead. 111 - `fFeatures`. Use `fDeviceFeatures` or `fDeviceFeatures2` instead. 112 - `fOwnsInstanceAndDevice`. No replacement, as it had no effect. 113 114 `GrVkBackendContext` is now an alias for `skgpu::VulkanBackendContext`. Clients should use the latter, as the former will be eventually removed. 115 * SkShaderMaskFilters and SkTableMaskFilters have been deprecated. They will be removed entirely in an upcoming Skia release. 116 117* * * 118 119Milestone 126 120------------- 121 * Skia's internal array class (`skia_private::TArray<T>`) now protects its unused capacity when 122 [Address Sanitizer (ASAN)](https://clang.llvm.org/docs/AddressSanitizer.html) is enabled. Code which 123 inadvertently writes past the end of a Skia internal structure is now more likely to trigger an ASAN 124 error. 125 * `SkFloat2Bits` and `SkBits2Float` have been removed from the Skia public headers. These were always 126 private API (since they lived in `/include/private`) but they had leaked into some example code, and 127 tended to be available once a handful of Skia headers were #included. 128 * SkSL now allows the ++ and -- operators on vector and matrix variables. 129 130 Previously, attempting to use these operators on a vector or matrix would lead to an error. This was 131 a violation of the GLSL expression rules (5.9): "The arithmetic unary operators negate (-), post- 132 and pre-increment and decrement (-- and ++) operate on integer or floating-point values (including 133 vectors and matrices)." 134 * `SkScalarIsFinite`, `SkScalarsAreFinite`, and `SkScalarIsNaN` have been removed from the Skia API. 135 These calls can be replaced with the functionally-equivalent `std::isfinite` and `std::isnan`. 136 * Clients can explicitly make a Ganesh GL backend for iOS with 137 `GrGLInterfaces::MakeIOS` from `include/gpu/ganesh/gl/ios/GrGLMakeIOSInterface.h` 138 * Clients can explicitly make a Ganesh GL backend for Mac with 139 `GrGLInterfaces::MakeMac` from `include/gpu/ganesh/gl/mac/GrGLMakeMacInterface.h` 140 * The following headers have been relocated (notice "ganesh" in the filepath): 141 - include/gpu/gl/egl/GrGLMakeEGLInterface.h -> include/gpu/ganesh/gl/egl/GrGLMakeEGLInterface.h 142 - include/gpu/gl/glx/GrGLMakeGLXInterface.h -> include/gpu/ganesh/gl/glx/GrGLMakeGLXInterface.h 143 - include/gpu/gl/epoxy/GrGLMakeEpoxyEGLInterface.h -> include/gpu/ganesh/gl/epoxy/GrGLMakeEpoxyEGLInterface.h 144 145* * * 146 147Milestone 125 148------------- 149 * The size of the GPU memory cache budget can now be queried using member `maxBudgetedBytes` of `skgpu::graphite::Context` and `skgpu::graphite::Recorder`. 150 * Added `skgpu::graphite::Context::maxTextureSize()`, which exposes the maximum 151 texture dimension supported by the underlying backend. 152 * Using a MTLBinaryArchive to pre-load the MSL shader cache is no longer 153 supported in Ganesh, and the fBinaryArchive member of GrMtlBackendContext 154 has been removed. 155 * The `sksl-minify` tool can now eliminate unnecessary braces. For instance, 156 given the following SkSL code: 157 158 ``` 159 if (condition) { 160 return 1; 161 } else { 162 return 2; 163 } 164 ``` 165 166 The minifier will now emit: 167 168 ``` 169 if(a)return 1;else return 2; 170 ``` 171 * Added `SkBitmap::setColorSpace`. This API allows the colorspace of an existing 172 `SkBitmap` to be reinterpreted. The pixel data backing the bitmap will be left 173 as-is. The colorspace will be honored when the bitmap is accessed via APIs which 174 support colorspace conversion, like `readPixels`. 175 * `SkDrawLooper` has been removed completely from Skia. It was previously deprecated. 176 * Metal-specific constructors and methods have been removed from `GrBackendFormat`, 177 `GrBackendTexture`, and `GrBackendRenderTarget` and moved to 178 `include/gpu/ganesh/mtl/GrMtlBackendSurface.h` 179 * By default, //modules/skottie and //modules/svg will use primitive text shaping. 180 Clients that wish to use harfbuzz/icu for more correct shaping will need to 181 use one of the builders and call `setTextShapingFactory` with a newly-created 182 `SkShapers::Factory` implementation during construction. 183 184 For ease of configuration, `modules/skshaper/utils/FactoryHelpers.h` can be used 185 to provide this, but only if the client is depending on the correct skshaper 186 and skunicode modules (which should set defines such as `SK_SHAPER_HARFBUZZ_AVAILABLE`). 187 188 For example `builder.setTextShapingFactory(SkShapers::BestAvailable())` will use 189 Harfbuzz or CoreText for shaping if they were compiled in to the clients binary. 190 191* * * 192 193Milestone 124 194------------- 195 * `SkColorFilter::filterColor` is now deprecated and will eventually be removed in favor of `filterColor4f`. 196 * The Perlin noise shaders (`MakeFractalNoise` and `MakeTurbulence`) will now properly rotate when 197 transformed. On raster surfaces, the performance of Perlin noise has also been significantly 198 improved. 199 * Graphite's `SkImages::WrapTexture` now takes an additional parameter that indicates whether 200 a mipmapped texture should be used as is or whether Graphite should generate the upper level 201 contents from the base level contents. 202 * `GrBackendSemaphore::initMetal`, `GrBackendSemaphore::mtlSemaphore`, and 203 `GrBackendSemaphore::mtlValue` have been replaced with `GrBackendSemaphores::MakeMtl`, 204 `GrBackendSemaphores::GetMtlHandle`, and `GrBackendSemaphores::GetMtlValue`, defined in 205 `include/gpu/ganesh/mtl/GrMtlBackendSemaphore.h` 206 * `GrDirectContext::MakeMetal` has been moved to `GrDirectContexts::MakeMetal`, located in 207 `include/gpu/ganesh/mtl/GrMtlDirectContext.h`. The APIs that passed in void* have been removed 208 in that change, so clients who use those need to create a `GrMtlBackendContext` themselves. 209 210 `include/gpu/mtl/GrMtlTypes.h` and `include/gpu/mtl/GrMtlBackendContext.h` have been relocated to 211 `include/gpu/ganesh/mtl/GrMtlTypes.h` and `include/gpu/ganesh/mtl/GrMtlBackendContext.h` 212 respectively. 213 * Added `SkCodecs::DeferredImage` which is similar to `SkImages::DeferredFromEncodedData` except it 214 allows the caller to pass in a `SkCodec` directly instead of depending on compiled-in codecs. 215 * The following SkShaper functions have been moved or deleted: 216 - SkShaper::MakePrimitive() -> SkShapers::Primitive() 217 - SkShaper::MakeShaperDrivenWrapper() -> SkShapers::HB::ShaperDrivenWrapper() 218 - SkShaper::MakeShapeThenWrap() -> SkShapers::HB::ShapeThenWrap() 219 - SkShaper::MakeShapeDontWrapOrReorder() -> SkShapers::HB::ShapeDontWrapOrReorder() 220 - SkShaper::MakeCoreText() -> SkShapers::CT::CoreText() 221 - SkShaper::Make() -> deleted, use one of the above directly, 222 - SkShaper::MakeSkUnicodeBidiRunIterator() -> SkShapers::unicode::BidiRunIterator() 223 - SkShaper::MakeBiDiRunIterator() -> deleted, use SkShapers::unicode::BidiRunIterator() or SkShapers::TrivialBiDiRunIterator() 224 - SkShaper::MakeIcuBiDiRunIterator() -> deleted, use SkShapers::unicode::BidiRunIterator() 225 - SkShaper::MakeSkUnicodeHbScriptRunIterator() -> SkShapers::HB::ScriptRunIterator() 226 - SkShaper::MakeHbIcuScriptRunIterator() -> SkShapers::HB::ScriptRunIterator() 227 - SkShaper::MakeScriptRunIterator() -> deleted, use SkShapers::HB::ScriptRunIterator() or SkShapers::TrivialScriptRunIterator 228 229 Additionally, two `SkShaper::shape` method overloads have been removed - clients now need to 230 specify all 10 arguments (although it is common to pass in nullptr for features). 231 * `SkStream::getData()` has been added as a virtual. Subclasses can implement this if it is efficient 232 to turn the underlying contents into an SkData (e.g. SkStreamMemory). `SkStreamMemory::asData()` 233 has been renamed to `getData()` as a result of this change and will be removed in a future release. 234 235* * * 236 237Milestone 123 238------------- 239 * When `SkCodec::SelectionPolicy::kPreferStillImage` is passed to `SkWuffsCodec`/`SkGifDecoder` 240 creation, and the input stream cannot be rewound, the resulting `SkWuffsCodec` will no longer copy 241 the stream. Because it will now have a non-seekable stream, it no longer supports `getFrameCount`, 242 which will now simply report `1`, or `getFrameInfo`, which is useful only for animation anyway. 243 Chromium uses `kPreferStillImage`, simply because it is the default, but will not be affected by 244 this change because it always supplies a seekable stream. 245 * A `kDefault_Flag = 0` value has been added to the `SkSurfaceProps::Flags` enum. This is just a 246 self-documenting zero-value that aims to improve code readability, e.g.: 247 248 ``` 249 // The two lines below are equivalent. 250 251 SkSurfaceProps(/* surfaceFlags= */ 0, kRGB_H_SkPixelGeometry); 252 253 SkSurfaceProps(SkSurfaceProps::kDefault_Flag, kRGB_H_SkPixelGeometry); 254 ``` 255 * In native builds the default use of `wgpu::Device::Tick` to detect GPU progress has been updated 256 to use `wgpu::Instance::ProcessEvents` instead. To simulate the non-yielding behavior of `Context` 257 in native `DawnBackendContext::fTick` may still be explicitly set to `nullptr`. 258 * The Vulkan backend for both Ganesh and Graphite will now invoke an optional client-provided callback 259 function when a `VK_ERROR_DEVICE_LOST` error code is returned from the Vulkan driver. Additional 260 debugging information will be passed from the driver to this callback if the `VK_EXT_device_fault` 261 extension is supported and enabled. 262 263 This optional callback can be be provided via the `fDeviceLostContext` and `fDeviceLostProc` fields 264 on `GrVkBackendContext` (Ganesh) and `VulkanBackendContext` (Graphite). 265 * `SkAnimCodecPlayer` has been removed from the public API. 266 * `SkCodec::getImage()` will now respect the origin in the metadata (e.g. Exif metadata that 267 rotates the image). This may mean callers who provide an SkImageInfo may need to rotate it, 268 e.g. via `SkPixmapUtils::SwapWidthHeight`. 269 270* * * 271 272Milestone 122 273------------- 274 * `graphite::BackendTexture` can be created from a `WGPUTextureView`. This comes with a 275 perfomance cost when reading pixels to or writing pixels from the CPU. An intermediate 276 WGPUTexture is created to support these operations. However, this enables creating 277 `SkSurface` or `SkImage` from `wgpu::SwapChain::GetCurrentTextureView`. 278 * SkSL now properly reports an error if the body of a for-loop declares a variable which shadows the 279 for-loop induction variable. 280 281 In other words, SkSL code like this will now generate an error: 282 283 ``` 284 for (int x = 0; x < 10; ++x) { 285 int x = 123; // error: symbol 'x' was already defined 286 } 287 ``` 288 289 Previously, the declaration of `x` would be allowed, in violation of the GLSL scoping rules (6.3): 290 "For both for and while loops, the sub-statement does not introduce a new scope for variable names." 291 * The PDF code now directly depends on Skia's JPEG decoder and encoder. The build 292 time shims to avoid using a JPEG decoder and encoder have been removed. In the 293 future these may be made optional again by allowing the user to supply them at 294 runtime. 295 * SkSL variables declared inside of a switch statement will now properly fall out of scope after the 296 closing brace of the switch-block, as one would expect. 297 298 In other words, SkSL code like this will now generate an error: 299 300 ``` 301 switch (n) { 302 case 1: 303 int x = 123; 304 } 305 return x; // error: unknown identifier 'x' 306 ``` 307 308 Previously, `x` would remain accessible after the switch's closing brace. 309 * `skgpu::graphite::ContextOptions::fNeverYieldToWebGPU` is removed. Instead, yielding in an 310 Emscripten build is controlled by installing a client-provided function on 311 `skgpu::graphite::DawnBackendContext`. The client may install a function that uses Asyncify to 312 yield to the main thread loop. If no function is installed then the Context has the same 313 restrictions as with the old option. 314 315 In native builds the default is to use `wgpu::Device::Tick` to detect GPU progress. To simulate the 316 non-yielding behavior of `Context` in native `DawnBackendContext::fTick` may be explicitly set to 317 to `nullptr`. 318 319 By externalizing the use of Asyncify it is possible to build Skia without generated JS 320 code that relies on Asyncify. 321 * SkSL will now properly report an error if a function contains a top-level variable with the same 322 name as a function parameter. SkSL intends to match the scoping rules of GLSL, in particular: "A 323 function’s parameter declarations and body together form a single scope nested in the global scope." 324 325 A program like this will now be rejected: 326 327 ``` 328 void func(int var) { 329 int var; 330 } 331 332 error: 2: symbol 'var' was already defined 333 int var; 334 ^^^^^^^ 335 ``` 336 * `SkFont::getTypeface()` will no longer return a nullptr to indicate "the default typeface". 337 If left unspecified, SkFonts will use an empty typeface (e.g. no glyphs). 338 * `SkFontMgr::RefDefault()` has been deleted. Clients should instantiate and manage their own 339 `SkFontMgr`s and use them to explicitly create `SkTypeface`s 340 * `GrGLMakeNativeInterface` has been deprecated and will eventually be removed. Clients should 341 be calling the precise factory (e.g. `GrGLInterfaces::makeGLX`) they need. Some APIs that currently allow a nullptr GrGLInterface will be stop allowing this (e.g. `GrDirectContexts::MakeGL`). 342 * `SkFontArguments::Palette::Override`'s index member is changing from an `int` 343 type to `uint16_t` to make the size exact and remove an unneeded 344 signedness. This avoids platform/compiler-specific size ambiguiity and more 345 closely matches the OpenType CPAL table. 346 347* * * 348 349Milestone 121 350------------- 351 * `SkFontConfigInterface::makeTypeface` now has a required `sk_sp<SkFontMgr>` parameter to be used for 352 parsing the font data from the stream. 353 * `skgpu::graphite::ContextOptions` has a new field, `fNeverYieldToWebGPU`. This new option 354 is only valid with the Dawn backend. It indicates that `skgpu::graphite::Context` should never yield 355 to Dawn. In native this means `wgpu::Device::Tick()` is never called. In Emscripten it 356 means `Context` never yields to the main thread event loop. 357 358 When the option is enabled, `skgpu::SyncToCpu::kYes` is ignored when passed to 359 `Context::submit()`. Moreover, it is a fatal error to have submitted but unfinished 360 GPU work before deleting `Context`. A new method, `hasUnfinishedGpuWork()` is added 361 to `Context` that can be used to test this condition. 362 363 The intent of this option is to be able to use Graphite in WASM without requiring Asyncify. 364 * Deprecated `GrMipmapped` and `GrMipMapped` alias have been removed in favor of `skgpu::Mipmapped`. 365 * Harfbuzz-backed SkShaper instances will no longer treat a null SkFontMgr as meaning "use the 366 default SkFontMgr for fallback" and instead will *not* do fallback for glyphs missing from a font. 367 * `GrBackendSemaphore::initVk` and `GrBackendSemaphore::vkSemaphore` have been replaced with 368 `GrBackendSemaphores::MakeVk` and `GrBackendSemaphores::GetVkSemaphore`, defined in 369 `include/gpu/ganesh/vk/GrVkBackendSemaphore.h` 370 * The Vulkan-specific methods and constructor of `MutableTextureState` have been deprecated in favor 371 of those found in `include/gpu/vk/VulkanMutableTextureState.h`. 372 373* * * 374 375Milestone 120 376------------- 377 * `SkBase64.h` has been removed from the public API. 378 * `SkFont::refTypefaceOrDefault` and `SkFont::getTypefaceOrDefault()` have been removed from the 379 public API. 380 * `GrBackendSemaphore::initGL` and `GrBackendSemaphore::glSync` have been removed 381 from the public API. 382 * For Graphite, `SkImages::AdoptTextureFrom` has been renamed to `SkImages::WrapTexture` to 383 better reflect what is happening to the passed in texture. 384 * `GrSurfaceInfo.h` has been removed from the public API. 385 * SkMesh now allows shaders, color filters, and blenders to be used in the mesh-fragment program. 386 Pass in effects using the `children` parameter of `SkMesh::Make` or `SkMesh::MakeIndexed`. 387 For a working example, see `gm/mesh.cpp`. 388 * The behavior for SkPicture deserialization (via SkReadBuffer) to fallback to 389 `SkImages::DeferredFromEncodedData` when `SkDeserialImageProc` is not set or returns null is 390 deprecated and will be removed shortly. 391 392 `SkDeserialImageFromDataProc` has been added to SkDeserialProcs to allow clients to *safely* 393 avoid a copy when decoding image data in SkPictures. 394 395 `SkDeserialImageProc` now takes in an optional AlphaType which can be used to override the 396 AlphaType that an image was serialized with, if desired. 397 * skgpu::graphite::RecorderOptions::kDefaultRecorderBudget is now a static data member. 398 * `SkTypeface::MakeFromName`, `SkTypeface::MakeFromFile`, `SkTypeface::MakeFromStream`, and 399 `SkTypeface::MakeFromData` are deprecated and will be removed eventually. These should be replaced 400 with calls directly to the SkFontMgr that can provide the appropriate typefaces. 401 402 `SkTypeface::MakeDefault()` has been deprecated. Soon it will return an empty typeface and 403 eventually be removed. 404 405 `SkTypeface::UniqueID()` has been removed - clients should use the method instead of this static 406 function. 407 * `GrDirectContext::MakeVulkan...` has been moved to `GrDirectContexts::MakeVulkan...` which are defined 408 in `include/gpu/ganesh/vk/GrVkDirectContext.h` 409 * The various GPU wait calls on GrDirectContext, SkSurface, and GrVkSecondaryCBContext which take 410 a client supplied semaphore, now only guarantee to block the gpu transfer and fragment stages 411 instead of all gpu commands. This shouldn't affect any client since client provided gpu resources 412 (e.g. textures) are only ever used by Skia in the fragment stages. 413 414* * * 415 416Milestone 119 417------------- 418 * Added new `SkImageFilters::Crop(SkRect, SkTileMode, sk_sp<SkImageFilter>)` image filter effect that crops the output from the wrapped SkImageFilter and optionally applies the SkTileMode when sampling outside of the crop rect. 419 * `GrDirectContext::MakeGL...` has been moved to `GrDirectContexts::MakeGL...` which are defined 420 in `include/gpu/ganesh/gl/GrGLDirectContext.h` 421 * `GrDirectContext::submit` and `GrDirectContext::flushAndSubmit` calls now take a GrSyncCpu enum 422 instead of a error-prone boolean. 423 424 Similarly, calls to `GrDirectContext::performDeferredCleanup` and 425 `GrDirectContext::purgeUnlockedResources` take a GrPurgeResourceOptions enum. 426 * SkMeshSpecification no longer rejects fragment programs which include `uniform shader`, `uniform 427 colorFilter` or `uniform blender`. However, `SkMesh::Make` will not allow the mesh specification 428 to be used. 429 * `SkMesh::Make` and `SkMesh::MakeIndexed` now require a span of child effects as a new parameter. 430 This functionality is still a work in progress; for now, always pass an empty span. 431 * `sksl-minify` can now minify SkMesh programs. Pass `--meshvert` or `--meshfrag` to indicate 432 that the input program is an SkMesh vertex or fragment program. When minifying a mesh program, 433 you must supply `struct Varyings` and `struct Attributes` which correspond to the 434 SkMeshSpecification; these will be eliminated from the minified output. 435 * `SkMergePathEffect`, `SkMatrixPathEffect`, `SkStrokePathEffect`, and 436 `SkStrokeAndFillPathEffect` have been removed from the public API. 437 These effects can be implemented on the SkPath objects directly using other means and clients 438 will likely find performance boosts by doing so. 439 * `SkShadowFlags` are now visible in `include/utils/SkShadowUtils.h` 440 * `SkPicture`s no longer serialize `SkImage`s to PNG encoded data by default. Clients who wish to 441 preserve this should make use of `SkSerialProcs`, specifically the `fImageProc` field. 442 443* * * 444 445Milestone 118 446------------- 447 * `GrDirectContext::flush` variants now expect a SkSurface pointer only, not 448 an sk_sp<SkSurface>. 449 * `SkImage::makeWithFilter` has been deprecated. It has been replaced with three factory functions: 450 451 Ganesh: `SkImages::MakeWithFilter(GrRecordingContext*, ...);` -- declared in SkImageGanesh.h 452 453 Graphite: `SkImages::MakeWithFilter(skgpu::graphite::Recorder*, ...);` -- declared in Image.h 454 455 Raster: `SkImages::MakeWithFilter(...);` -- declared in SkImage.h 456 457 The new factories require the associated backend context object be valid. For example, the Graphite version will return nullptr if it isn't supplied with a `Recorder` object. 458 * SkSL and Runtime Effects are no longer optional features of Skia; they are always available. 459 The GN flag `skia_enable_sksl` has been removed. 460 * SkSL will now properly reject sequence-expressions containing arrays, or sequence-expressions 461 containing structures of arrays. Previously, the left-side expression of a sequence was checked, 462 but the right-side was not. In GLSL ES 1.0, and therefore in SkSL, the only operator which is 463 allowed to operate on arrays is the array subscript operator (`[]`). 464 * The Dawn backend for Ganesh has been removed. Dawn will continue to be supported in the 465 Graphite backend. 466 * We plan to remove SkTime.h from the public API. As of now, SkAutoTime has been 467 deleted as it was unused. 468 * Vulkan-specific calls are being removed from GrBackendSurface.h. Clients should use the 469 equivalents found in `include/gpu/ganesh/vk/GrVkBackendSurface.h"` 470 471* * * 472 473Milestone 117 474------------- 475 * `SkGraphics::AllowJIT()` has been removed. It was previously deprecated (and did nothing). 476 * New methods are added to `SkImage`, `SkSurface`, and `skgpu::graphite::context` named 477 `asyncRescaleAndReadPixeksYUVA420`. These function identically to the existing 478 `asyncRescaleAndReadPixelsYUV420` methods but return a fourth plane containing alpha at full 479 resolution. 480 * `SkAutoGraphics` was removed. This was a helper struct that simply called `SkGraphics::Init`. 481 Any instance of `SkAutoGraphics` can be replaced with a call to `SkGraphics::Init`. 482 * `SkCanvas::flush()` has been removed. It can be replaced with: 483 ``` 484 if (auto dContext = GrAsDirectContext(canvas->recordingContext())) { 485 dContext->flushAndSubmit(); 486 } 487 ``` 488 489 `SkCanvas::recordingContext()` and `SkCanvas::recorder()` are now const. They were implicitly const 490 but are now declared to be such. 491 * `SkCanvas::recordingContext()` and `SkCanvas::recorder()` are now const. 492 They were implicitly const but are now declared to be such. 493 * `SkMesh::MakeIndexBuffer`, `SkMesh::CopyIndexBuffer`, `SkMesh::MakeVertexBuffer`, and 494 `SkMesh::CopyVertexBuffer` have been moved to the `SkMeshes` namespace. Ganesh-specific versions 495 have been created in `include/gpu/ganesh/SkMeshGanesh.h`. 496 * SkPath now enforces an upper limit of 715 million path verbs. 497 * `SkRuntimeEffectBuilder::uniforms()`, `SkRuntimeEffectBuilder::children()`, 498 `SkRuntimeShaderBuilder::makeShader()`, `SkRuntimeColorFilterBuilder::makeColorFilter()`, and 499 `SkRuntimeBlendBuilder::makeBlender()` are now marked as const. No functional changes internally, 500 just making explicit what had been implicit. 501 * `SkRuntimeEffect::makeImage` and `SkRuntimeShaderBuilder::makeImage` have been removed. 502 * GL-specific calls have been removed from GrBackendSurface.h. Clients should use the 503 equivalents found in `include/gpu/ganesh/gl/GrGLBackendSurface.h` 504 * A new `SkTiledImageUtils` namespace (in `SkTiledImageUtils.h`) provides `DrawImage` and `DrawImageRect` methods that directly mirror `SkCanvas'` `drawImage` and `drawImageRect` calls. 505 506 The new entry points will breakup large `SkBitmap`-backed `SkImages` into tiles and draw them if they would be too large to upload to the gpu as one texture. 507 508 They will fall through to their `SkCanvas` correlates if tiling isn't needed or possible. 509 510* * * 511 512Milestone 116 513------------- 514 * `SkPromiseImageTexture` has been removed from the public API, as well as 515 `SkImages::PromiseTextureFrom` and `SkImages::PromiseTextureFromYUVA`, public consumers of that 516 data type. 517 * `SkDeferredDisplayList`, `SkDeferredDisplayListRecorder`, and `SkSurfaceCharacterization` have 518 been removed from the public API. 519 * The intermediate color computed by `SkBlenders::Arithmetic` is now always clamped to between 0 and 1 (inclusive), and then `enforcePremul` is applied when that parameter is true. 520 * Added a new public type, `SkColorTable`, to own the lookup tables passed into `SkColorFilters::Table`, which allows clients and the returned `SkColorFilter` to share the table memory instead of having to duplicate it in any wrapper types that lazily create Skia representations. 521 * The deprecated `SkImageFilters::Magnifier` factory that did *not* take a lens bounds parameter has been removed. 522 * `SkImageFilters::RuntimeShader` has variations that take a maximum sample radius, which is used to provide padded input images to the runtime effect so that boundary conditions are avoided. 523 * `SkImageFilters::AlphaThreshold` has been removed. Its only use was in ChromeOS and that usage has been replaced with a `Blend(kSrcIn, input, Picture(region))` filter graph to achieve the same effect. 524 * The single-argument `SkImageFilters::Image(sk_sp<SkImage>)` factory is removed. The `SkSamplingOptions` to use when rendering the image during filtering must be provided. `SkFilterMode::kLinear` is recommended over the previous bicubic default. 525 * `GrTextureGenerator` now has a subclass `GrExternalTextureGenerator` which can be subclassed by 526 clients and used with `SkImages::DeferredFromTextureGenerator` in order to create images from 527 textures that were created outside of skia. `GrTextureGenerator` has been removed from the public 528 API in favor of `GrExternalTextureGenerator`. 529 * SkPoint now uses float for its coordinates. This starts the process of removing SkScalar from Skia. 530 SkScalar was a typedef for float, so this has no practical impact on code that uses Skia. 531 * `SkSamplingOptions(SkFilterMode)` and `SkSamplingOptions(SkCubicResampler)` are no longer marked `explicit` so that samplings can be created inline more succinctly. 532 * `SkShaders` is now a namespace (was previously a non-constructable class with only static 533 functions). `SkPerlinNoiseShader::MakeFractalNoise` and `SkPerlinNoiseShader::MakeTurbulence` have 534 been moved to the `SkShaders` namespace and `SkPerlinNoiseShader` (the public non-constructable 535 class) has been slated for moving into private internals of Skia. 536 There are no functional differences in the moved functions, however the change of some #includes 537 in `include/core/SkShader.h`, `include/effects/SkGradientShader.h`, and 538 `include/effects/SkPerlinNoiseShader.h` may cause clients who were depending on the transitive 539 dependencies to now fail to compile. 540 * The following methods have been removed from SkSurface and relocated to other methods/functions: 541 - `SkSurface::asImage` -> `SkSurfaces::AsImage` (include/gpu/graphite/Surface.h) 542 - `SkSurface::flushAndSubmit` -> `GrDirectContext::flushAndSubmit` 543 - `SkSurface::flush` -> `GrDirectContext::flush` 544 - `SkSurface::makeImageCopy` -> `SkSurfaces::AsImageCopy` (include/gpu/graphite/Surface.h) 545 - `SkSurface::resolveMSAA` -> `SkSurfaces::ResolveMSAA()` (include/gpu/ganesh/SkSurfaceGanesh.h) 546 547 Additionally, `SkSurface::BackendSurfaceAccess` is now in the `SkSurfaces` namespace. 548 * The deprecated `SkTableColorFilter` class and its methods have been removed. Clients should use 549 `SkColorFilters::Table` and `SkColorFilters::TableARGB` (defined in include/core/SkColorFilter.h). 550 * The `SkYUVAPixmapInfo::SupportedDataTypes(const GrImageContext&)` constructor has been removed from 551 the public API. 552 553* * * 554 555Milestone 115 556------------- 557 * Clients now need to register codecs which Skia should use to decode raw bytes. For example: 558 `SkCodecs::Register(SkJpegDecoder::Decoder());`. Skia still provides many supported formats 559 (see `include/codec/*Decoder.h`). Clients are free to specify their own, either supplementing 560 the existing set or using a custom version instead of the one previously provided by default 561 by Skia. See `SkCodecs::Decoder` for the necessary data to provide when using a custom decoder 562 (in `include/codec/SkCodec.h`). 563 564 To ease the transition, Skia will continue (for a short while) to register codecs unless 565 `SK_DISABLE_LEGACY_INIT_DECODERS` is defined. 566 * `SkDrawable::newPictureSnapshot` is removed. Instead, call `SkDrawable::makePictureSnapshot`. 567 The old method returned a bare (but ref-counted) pointer, which was easy for clients to get wrong. 568 The new method returns an `sk_sp<SkPicture>`, which is easier to handle, and consistent with the 569 rest of skia. 570 * `SkGraphics::PurgePinnedFontCache()` has been added to allow clients to 571 explicitly trigger `SkStrikeCache` purge checks for `SkStrikes` with 572 pinners. Defining `SK_STRIKE_CACHE_DOESNT_AUTO_CHECK_PINNERS` in the 573 user configuration now disables automatic purge checking of strikes with 574 pinners. 575 * The following SkImage factories have been moved to `include/gpu/graphite/Image.h`: 576 - `SkImage::MakeGraphiteFromBackendTexture -> SkImages::AdoptTextureFrom` 577 - `SkImage::MakeGraphiteFromYUVABackendTextures -> SkImages::TextureFromYUVATextures` 578 - `SkImage::MakeGraphiteFromYUVAPixmaps -> SkImages::TextureFromYUVAPixmaps` 579 - `SkImage::MakeGraphitePromiseTexture -> SkImages::PromiseTextureFrom` 580 581 The SkImage method `makeTextureImage` has been moved to `SkImages::TextureFromImage`. 582 583 `SkImage::RequiredImageProperties` has been renamed to `SkImage::RequiredProperties`, 584 with fMipmapped turned into a boolean instead of the GPU enum. 585 * `SkImage::makeColorSpace` and `SkImage::makeColorTypeAndColorSpace` now take a `GrDirectContext` 586 as the first parameter. This should be supplied when dealing with texture-backed images and can 587 be `nullptr` otherwise. 588 * `SkImage::subset` now takes a `GrDirectContext*` as its first parameter (this can be `nullptr` for 589 non-gpu backed images. Images which are backed by a codec or picture will not be turned into a GPU 590 texture before being read. This should only impact picture-backed images, which may not be read 591 correctly if the picture contain nested texture-backed images itself. To force a conversion to 592 a texture, clients should call `SkImages::TextureFromImage`, passing in the image, and then call 593 subset on the result. Documentation has been clarified that `SkImage::subset` will return a raster- 594 backed image if the source is not backed by a texture, and texture-otherwise. 595 596 `SkImages::SubsetTextureFrom` has been added to subset an image and explicitly return a texture- 597 backed image. This allows some optimizations, especially for large images that exceed a maximum 598 texture size of a GPU. 599 600 `SkImage::makeRasterImage` and `SkImage::makeNonTextureImage` now take a `GrDirectContext*` which 601 clients should supply for reading-back pixels from texture-backed images. 602 * `SkImageFilters::Image` now returns a non-null image filter if the input `sk_sp<SkImage>` is 603 null or the src rectangle is empty or does not overlap the image. The returned filter evaluates to 604 transparent black, which is equivalent to a null or empty image. Previously, returning a null image 605 filter would mean that the dynamic source image could be surprisingly injected into the filter 606 evaluation where it might not have been intended. 607 * `SkImageFilters::Magnifier(srcRect, inset)` is deprecated. These parameters do not provide enough 608 information for the implementation to correctly respond to canvas transform or participate accurately 609 in layer bounds planning. 610 611 A new `SkImageFilters::Magnifier` function is added that takes additional parameters: the outer 612 lens bounds and the actual zoom amount (instead of inconsistently reconstructing the target zoom 613 amount, which was the prior behavior). Additionally, the new factory accepts an SkSamplingOptions 614 to control the sampling quality. 615 * `SkImageFilters::Picture` now returns a non-null image filter if the input `sk_sp<SkPicture>` is 616 null. The returned filter evaluates to transparent black, which is equivalent to a null or empty 617 picture. Previously, returning a null image filter would mean that the dynamic source image could 618 be surprisingly injected into the filter evaluation where it might not have been intended. 619 * `SkImageFilters::Shader` now returns a non-null image filter if the input `sk_sp<SkShader>` is 620 null. The returned filter evaluates to transparent black, which is equivalent to a null or empty 621 shader. Previously, returning a null image filter would mean that the dynamic source image could 622 be surprisingly injected into the filter evaluation where it might not have been intended. 623 * `SkImageGenerator::MakeFromEncoded` has been removed from the public API. 624 `SkImage::DeferredFromEncoded` or `SkCodec::MakeFromData` should be used instead. 625 * `SkSurface::getBackendTexture` and `SkSurface::getBackendRenderTarget` have been deprecated and 626 replaced with `SkSurfaces::GetBackendTexture` and `SkSurfaces::GetBackendRenderTarget` respectively. 627 These are found in `include/gpu/ganesh/SkSurfaceGanesh.h`. The supporting enum `BackendHandleAccess` 628 has also been moved to `SkSurfaces::BackendHandleAccess` as an enum class, with shorter member 629 names. 630 * SkSurface factory methods have been moved to the SkSurfaces namespace. Many have been renamed to 631 be more succinct or self-consistent. Factory methods specific to the Ganesh GPU backend are 632 defined publicly in include/gpu/ganesh/SkSurfaceGanesh.h. The Metal Ganesh backend has some 633 specific factories in include/gpu/ganesh/mtl/SkSurfaceMetal.h. 634 * SkSurface::MakeFromAHardwareBuffer -> SkSurfaces::WrapAndroidHardwareBuffer 635 * SkSurface::MakeFromBackendRenderTarget -> SkSurfaces::WrapBackendRenderTarget 636 * SkSurface::MakeFromBackendTexture -> SkSurfaces::WrapBackendTexture 637 * SkSurface::MakeFromCAMetalLayer -> SkSurfaces::WrapCAMetalLayer 638 * SkSurface::MakeFromMTKView -> SkSurfaces::WrapMTKView 639 * SkSurface::MakeGraphite -> SkSurfaces::RenderTarget 640 * SkSurface::MakeGraphiteFromBackendTexture -> SkSurfaces::WrapBackendTexture 641 * SkSurface::MakeNull -> SkSurfaces::Null 642 * SkSurface::MakeRaster -> SkSurfaces::Raster 643 * SkSurface::MakeRasterDirect -> SkSurfaces::WrapPixels 644 * SkSurface::MakeRasterDirectReleaseProc -> SkSurfaces::WrapPixels 645 * SkSurface::MakeRasterN32Premul -> SkSurfaces::Raster (clients should make SkImageInfo) 646 * SkSurface::MakeRenderTarget -> SkSurfaces::RenderTarget 647 648* * * 649 650Milestone 114 651------------- 652 * The CPU backend for Runtime Effects has been rewritten. This may cause slight differences in 653 performance and image quality when runtime effects are painted onto a raster surface. 654 * Gradient shaders support interpolation in several different color spaces, by passing a 655 `SkGradientShader::Interpolation` struct to the shader factory functions. The color space and 656 hue method options are based on the CSS Color Level 4 specfication: 657 * https://www.w3.org/TR/css-color-4/#interpolation-space 658 * https://www.w3.org/TR/css-color-4/#hue-interpolation 659 * `SkImages::GetBackendTextureFromImage` has been renamed `SkImages::MakeBackendTextureFromImage`. 660 * `SkImage::getBackendTexture()` has been moved to `SkImages::GetBackendTextureFromImage()` in 661 `SkImageGanesh.h`. 662 * `SkImage::makeTextureImage()` has been moved to `SkImages::TextureFromImage()` in 663 `SkImageGanesh.h`. 664 * `SkImage::flush()` and `SkImage::flushAndSubmit()` has been moved to 665 `GrDirectContext::flush()` and `GrDirectContext::flushAndSubmit()` in `SkImageGanesh.h`. 666 * `SkSurfaceProperties::kAlwaysDither_Flag` added to globally enable dithering for a specific 667 `SkSurface` target. 668 * `SkSerialImageProc` and `SkDeserialImageProc` are now also used to encode/decode the SkMipmap 669 layers of certain SkImages. 670 * The defines `SK_USE_WIC_ENCODER` and `SK_USE_CG_ENCODER` have been removed, as well as the code 671 to use the Windows Image Codecs and Core Graphics as a way to have Skia encode files in PNG, 672 JPEG, and WEBP format. Skia continues to support use of the NDK codecs on Android, as well 673 as using external C++ libraries (e.g. libpng, libjpeg-turbo) to *encode* images. WIC and CG 674 are still used to *decode* images on the appropriate platforms. 675 * `SkImage::encodeToData` has been deprecated. Clients should use `refEncodedData` if the image 676 was from an encoded bytestream or one of `SkPngEncoder::Encode`, `SkJpegEncoder::Encode`, 677 `SkWebpEncoder::Encode` directly. 678 * The following defines no longer do anything. GN clients should instead set the provided 679 arguments (from gn/skia.gni) as necessary: 680 - `SK_ENCODE_PNG` -> `skia_use_libjpeg_turbo_encode` 681 - `SK_ENCODE_JPEG` -> `skia_use_libpng_encode` 682 - `SK_ENCODE_WEBP` -> `skia_use_libwebp_encode` 683 Other clients should make sure the appropriate `*EncoderImpl.cpp` files from `src/encode` are 684 included in the build. 685 * `SkImageEncoder` has been removed. Clients should use one of `SkPngEncoder::Encode`, 686 `SkJpegEncoder::Encode` or `SkWebpEncoder::Encode` directly. 687 * `SkImageGenerator` has a new subclass `GrTextureGenerator` which can be used if clients want to 688 provide specialized ways of making Ganesh texture-backed Images. 689 * `SkImageGenerator::MakeFromPicture` has been removed from the public API. Clients should be 690 drawing the picture directly instead of turning it into an image first. 691 692 693* * * 694 695Milestone 113 696------------- 697 * The define SK_SUPPORT_GPU is now SK_GANESH. It is no longer detected as a 0 or 1, but 698 as the absence or presence of that define. As a result, it defaults to off (not defined) if 699 not defined (SK_SUPPORT_GPU would default to SK_SUPPORT_GPU=1 if not defined). 700 * SkStrSplit is no longer part of the public API. 701 * SkImage::encodeToData now takes a GrDirectContext. The versions which do not have that are 702 deprecated and will be removed at some point. 703 * SkMatrix::Scale, preScale, setScale, etc. with any scale factor of 0 correctly no longer 704 return true from rectStaysRect(), consistent with rectStaysRect() implying a non-zero scale. 705 * `SkImage::CompressionType` has been renamed to `SkTextureCompressionType` and moved to 706 `include/core/SkTextureCompressionType.h` 707 * `SkEncodedImageFormat.h` and `SkPngChunkReader.h` are now in include/codec 708 * `SkICC.h` is now in include/encode 709 * SkImage factory methods have been moved to the SkImages namespace. Many have been renamed to 710 be more succinct or self-consistent. Factory methods specific to the Ganesh GPU backend are 711 defined publicly in include/gpu/ganesh/SkImageGanesh.h. 712 * SkImage::MakeBackendTextureFromSkImage -> SkImages::GetBackendTextureFromImage 713 * SkImage::MakeCrossContextFromPixmap -> SkImages::CrossContextTextureFromPixmap 714 * SkImage::MakeFromAdoptedTexture -> SkImages::AdoptTextureFrom 715 * SkImage::MakeFromBitmap -> SkImages::RasterFromBitmap 716 * SkImage::MakeFromCompressedTexture -> SkImages::TextureFromCompressedTexture 717 * SkImage::MakeFromEncoded -> SkImages::DeferredFromEncodedData 718 * SkImage::MakeFromGenerator -> SkImages::DeferredFromGenerator 719 * SkImage::MakeFromPicture -> SkImages::DeferredFromPicture 720 * SkImage::MakeFromRaster -> SkImages::RasterFromPixmap 721 * SkImage::MakeFromTexture -> SkImages::BorrowTextureFrom 722 * SkImage::MakeFromYUVAPixmaps -> SkImages::TextureFromYUVAPixmaps 723 * SkImage::MakeFromYUVATextures -> SkImages::TextureFromYUVATextures 724 * SkImage::MakePromiseTexture -> SkImages::PromiseTextureFrom 725 * SkImage::MakePromiseYUVATexture -> SkImages::PromiseTextureFromYUVA 726 * SkImage::MakeRasterCopy -> SkImages::RasterFromPixmapCopy 727 * SkImage::MakeRasterData -> SkImages::RasterFromData 728 * SkImage::MakeRasterFromCompressed -> SkImages::RasterFromCompressedTextureData 729 * SkImage::MakeTextureFromCompressed -> SkImages::TextureFromCompressedTextureData 730 To help in the transition, there is some temporary bridge code (e.g. aliases) which will 731 eventually be removed. 732 733* * * 734 735Milestone 112 736------------- 737 * SkImage::CubicResampler has been removed. Clients should use SkCubicResampler from 738 include/core/SkSamplingOptions.h instead (the former was an alias for the latter). 739 * SkRuntimeColorFilterBuilder has been added. This is a helper class for setting up color filters, 740 analogous to SkRuntimeShaderBuilder. 741 * SkShaders::CoordClamp has been added. It clamps the coords passed used with another 742 shader to a rectangle. 743 * SkRandom is no longer part of the public API. 744 * SK_ARRAY_COUNT is no longer part of the public API. Clients should use std::size. 745 * SK_SCALAR_IS_FLOAT is not set anymore. SkScalar is always a float (and has been since 2017). 746 * sk_realloc_throw (an internal API) now frees up memory when 0 is passed in as the size. 747 This should have no user-facing impacts for clients which use the default allocator, but 748 requires custom allocators to also implement this change. 749 * The particles module has been deleted. 750 * SkJpegEncoder::Options includes a parameter for XMP metadata. 751 * SkJpegEncoder includes support for encoding SkYUVAPixmaps directly. 752 753* * * 754 755Milestone 111 756------------- 757 * SkToBool is no longer part of the public API. 758 * A float version of SkCanvas::saveLayerAlpha now exists as SkCanvas::saveLayerAlphaf. 759 * SkAbs32 and SkTAbs are no longer part of the public API. 760 * SkAlign2, SkAlign4, SkAlign8, SkIsAlign2, SkIsAlign4, SkIsAlign8, SkAlignPtr, SkIsAlignPtr, 761 and SkAlignTo are no longer part of the public API. 762 * GrContextOptions::fSkipGLErrorChecks no longer stops checking shader compilation and program 763 linking success. 764 * SkBackingFit is no longer part of the public API. 765 * SkBudgeted was moved from include/core/SkTypes.h to include/gpu/GpuTypes.h and moved into the 766 skgpu namespace. 767 * include/gpu/GrConfig.h has been removed; its contents were folded into other files. 768 * SkLeftShift is no longer part of the public API. 769 * SK_MaxS32 and related constants are no longer part of the public API. 770 * include/core/SkMath.h is no longer part of the public API. 771 772* * * 773 774Milestone 110 775------------- 776 * SkParsePath::ToSVGString now returns the string, rather than modifying a passed-in string. 777 * Removed previously deprecated SkImageFilters::Paint factory. Use SkImageFilters::Shader instead. 778 * SkMesh::Make and SkMesh::MakeIndexed now return a SkMesh and error message string. 779 * SkPaint::getFillPath has been replaced with skpathutils::FillPathWithPaint from 780 include/core/SkPathUtils.h. The functionality should be the same. 781 782* * * 783 784Milestone 109 785------------- 786 * SkMesh vertex and fragment main() signatures have changed. See docs on SkMeshSpecification. 787 * Added SkImage::RescaleMode::kLinear so that the async rescale/readback APIs can scale in a 788 single step no matter the total scale factor (faster but lower quality than kRepeatedLinear). 789 * SkMesh buffer factories added that make copies of CPU-backed buffers. 790 * A utility for minifying Runtime Effect code has been added to Skia. Add the gn argument 791 "skia_compile_modules = true" to your gn args, and a new utility called "sksl-minify" will be 792 compiled as part of your Skia build. Run the command: 793 `skia-minify output-file.sksl input-file.sksl` 794 to write a minified version of the runtime shader "input-file.sksl" into a file named 795 "output-file.sksl". By default, sksl-minify expects a shader, but you can also pass command 796 line options `--colorfilter` or `--blender` if your program is a color-filter or a blender. 797 A compile error will be printed to stdout if an error is found in the program. 798 * The order of SkShader local matrix concatenation has been reversed. See skbug.com/13749 799 * PromiseImages have been added to Graphite. This supports both volatile and non-volatile Promise Images. 800 See the comment for SkImage::MakeGraphitePromiseTexture for more details. 801 * Graphite has loosened the immutability requirements of SkImages - through a new SkSurface API and careful 802 synchronization, clients can now mutate the backend object backing an SkImage. The new API consists of 803 SkSurface::asImage and SkSurface::makeImageCopy. We have a document that covers the expected use cases and 804 the synchronization required for each one. 805 806* * * 807 808Milestone 108 809------------- 810 * SkShader::asAGradient() has been removed. 811 * SkMesh and SkMeshSpecification has separate sk_sp and bare ptr getters for ref counted types. 812 * Add support for specifying a custom ICC profile to SkJpegEncoder, SkPngEncoder, and 813 SkWebpEncoder. 814 815* * * 816 817Milestone 107 818------------- 819 * Exported SkColor4f::toBytes_RGBA() and SkColor4f::FromBytes_RGBA. 820 * SkWebpEncoder: Added support for animated WebP image encoding. 821 * SkRuntimeEffect shader effects were inadvertently allowing functions with the signature 822 `half4 main(float2 coords, half4 color)`. This was disallowed at Milestone 87, but the 823 restriction was inadvertently relaxed in later milestones. Going forward, we will only 824 accept a shader signature of `half4 main(float2 coords)`. 825 826* * * 827 828Milestone 106 829------------- 830 * sk_sp is marked with the [[clang::trivial_abi]] attribute where supported. 831 * SkMesh API: Allows a user to draw a vertex mesh with custom attributes and 832 varyings using SkSL. Mesh data (vertex and index) can be created on a 833 GrDirectContext to avoid re-uploading data per draw. Currently does not 834 work with SkPicture or any backend but GPU. 835 * Added SkColorFilters::Blend(const SkColor4f&, sk_sp<SkColorSpace>, SkBlendMode) to 836 complement the existing SkColorFilters::Blend(SkColor, SkBlendMode) factory. 837 * The experimental C API was removed. 838 * Added support for AVIF decoding using libavif. 839 840* * * 841 842Milestone 104 843------------- 844 * New functions SkBitmap::getColor4f and SkPixmap::getColor4f return float colors. 845 * SkRuntimeEffect takes and returns a const SkData. 846 * SkRasterHandleAllocator::MakeCanvas now takes optional SkSurfaceProps. 847 * SkImage::MakeFromPicture and SkImageGenerator::MakeFromPicture now take an optional 848 SkSurfaceProps to use when rasterizing the picture. 849 * SkRuntimeEffect::Uniform now stores the uniform name as a string_view, rather than a 850 SkString. Related methods SkRuntimeEffect::findUniform and SkRuntimeEffectBuilder::uniform 851 also take std::string_view instead of const char*. 852 * SkRuntimeEffect::Child now stores the child name as a string_view, rather than a SkString. 853 Related methods SkRuntimeEffect::findChild and SkRuntimeEffectBuilder::child also take 854 std::string_view instead of const char*. Also, SkImageFilters::RuntimeShader now takes the 855 child name(s) as std::string_view instead of const char*. 856 * skcms.h has been relocated to //modules/skcms/skcms.h (was //include/third_party/skcms/skcms.h) 857 * New functions SkCanvas::getBaseProps and SkCanvas::getTopProps; SkCanvas::getBaseProps is a 858 direct replacement for the (now deprecated) SkCanvas::getProps function, while getTopProps is 859 a variant that returns the SkSurfaceProps that are active in the current layer. 860 * New function SkEventTracer::newTracingSection(const char* name) enables splitting traces up 861 into different sections for a selection of backend tracing frameworks (Perfetto, SkDebugf). 862 863* * * 864 865Milestone 103 866------------- 867 * SkSamplingOptions now includes anisotropic filtering. Implemented on GPU only. 868 * SkBitmap::clear and SkBitmap::clearColor take in SkColor4fs 869 870* * * 871 872Milestone 102 873------------- 874 * Add glGetFloatv and glSamplerParameterf to GrGLInterface. 875 * GrGLCreateNativeInterface is removed. Use GrGLMakeNativeInterface. 876 * GrContextOptions::fSharpenMipmappedTextures is removed. MIP LOD is now always 877 biased on the GPU backend. The CPU backend implementation is modified to match 878 this behavior. 879 * Passing SkCanvas::kStrict_SrcRectConstraint disables mipmapping. The old behavior differed 880 between GPU and CPU. CPU always computed a new set of mipmap based on the subset. GPU restricted 881 the sampling coordinates to the subset in the base level but upper level pixels that map to 882 pixels outside the subset in the base level were still used. To get the previous CPU behavior 883 use SkImage::makeSubset() to make a subset image and draw that. The previous GPU behavior is 884 similar, though not exactly, equivalent to making a mipmapped image shader from the original 885 image and applying that to a rectangle. 886 * Fully disable experimental support for HW tessellation shaders. 887 GrContextOptions::fEnableExperimentalHardwareTessellation is ignored and behaves as if it is 888 false. The optimized path renderer no longer requires hardware tessellation at all, and 889 is automatically enabled when drawing to an SkSurface created with MSAA, or when 890 GrContextOptions::fInternalMultisampleCount is set to a non-zero value. 891 892* * * 893 894Milestone 101 895------------- 896 * Add maxSurfaceSampleCountForColorType(SkColorType ct) in GrContextThreadSafeProxy 897 * Enums SkAlphaType and SkColorType are broken out into their own header files in include/core/ 898 899* * * 900 901Milestone 100 902------------- 903 * Skia now requires C++17 and the corresponding standard library (or newer). 904 * Skia on iOS now requires iOS 11 to build; earlier versions of iOS do not support C++17. 905 * The skstd::string_view and skstd::optional Skia classes have been replaced with the C++17 native 906 std::string_view and std::optional. 907 * Added SkSurface::resolveMSAA api to force Skia to resolve MSAA draws. Useful for when 908 Skia wraps a client's texture as the resolve target. 909 * All of the `makeShader` functions associated with `SkRuntimeEffect` no longer take an 910 `isOpaque` parameter. These functions will now make a best effort to determine if your 911 shader always produces opaque output, and optimize accordingly. If you definitely want your 912 shader to produce opaque output, do so in the shader's SkSL code. This can be done by adjusting 913 any `return` statement in your shader with a swizzle: `return color.rgb1;`. 914 https://review.skia.org/506462 915 * SkRSXform is now exported to DLL/.so files. 916* * * 917 918Milestone 99 919------------ 920 * Added two new intrinsic functions to SkSL for use in runtime effects: 921 vec3 toLinearSrgb(vec3 color) 922 vec3 fromLinearSrgb(vec3 color) 923 These convert RGB color values between the working color space (the color space of the 924 destination surface) and a known, fixed color space. `toLinearSrgb` converts a color to the 925 sRGB color gamut, with a linear transfer function. `fromLinearSrgb` converts a color from that 926 same color space. These are helpful for effects that need to work in a specific color space, or 927 want to apply effects (like lighting) that work best in a linear color space. 928 Note that if the destination surface has no color space (color space is `nullptr`), these 929 intrinsics will do no conversion, and return the input color unchanged. 930 https://review.skia.org/481416 931 * Added a new variant of SkImageFilters::RuntimeShader that supports multiple child nodes. 932 https://review.skia.org/489536 933 * Add the ability to specify palette overrides in SkFontArguments. Implemented 934 for the FreeType-backed SkFontMgrs. 935 936* * * 937 938Milestone 98 939------------ 940 * The following functions and methods are not defined in SkSurface when SK_SUPPORT_GPU is 0: 941 MakeFromBackendTexture, MakeFromBackendRenderTarget, MakeRenderTarget, 942 getBackendTexture, getBackendRenderTarget, replaceBackendTexture. flush() with parameters 943 was removed as well. These were all no-ops anyway when just the CPU backend was compiled in 944 (noting that flush() and flushAndSubmit() are still no-ops on the CPU backend). 945 * GrBackendSemaphore only includes methods that match the GPU backend that Skia was compiled for. 946 For example, initVulkan and vkSemaphore are not defined unless the Vulkan backend is compiled 947 into Skia. 948 * Surfaces and images are now limited to just under 2GB of total size. Previously, larger images 949 could be created, but the CPU backend would fail to index them correctly. 950 * SkCanvas::drawVertices and SkCanvas::drawPatch variants that did not take SkBlendMode are 951 removed. 952 * SkImageFilters::RuntimeShader is a new public API that enables adding RuntimeShaderEffects into 953 image filter graph. 954 * SkImage::makeRawShader is a new public API that creates "raw" image shaders. makeRawShader 955 functions like SkImage::makeShader, but for images that contain non-color data. This includes 956 images encoding things like normals, material properties (eg roughness), heightmaps, or any 957 other purely mathematical data that happens to be stored in an image. These types of images are 958 useful with some programmable shaders (ie SkRuntimeEffect). 959 Raw image shaders work like regular image shaders (including filtering and tiling), with a few 960 major differences: 961 - No color space transformation is ever applied (the color space of the image is ignored). 962 - Images with an alpha type of kUnpremul are not automatically premultiplied. 963 - Bicubic filtering is not supported. If SkSamplingOptions::useCubic is true, these factories 964 will return nullptr. 965 * Removed SkCanvas::markCTM and SkCanvas::findMarkedCTM. These were created to be used with other 966 features that have since been deleted, so they served no purpose. 967 * Added limited JPEGXL support. 968 969* * * 970 971Milestone 97 972------------ 973 * Added basic support for vulkan DRM modifiers. All of these are treated as read only textures 974 internally (versus querying specific modifier support). Clients can either pass a flag to Vulkan 975 GrBackendFormat to say it uses modifiers or pass the VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT 976 to a GrBackendTexture via the GrVkImageInfo struct. 977 * The following functions and methods are not defined in SkImage when SK_SUPPORT_GPU is 0: 978 MakeTextureFromCompressed, MakeFromTexture, MakeFromCompressedTexture, 979 MakeCrossContextFromPixmap, MakeFromAdoptedTexture, MakeFromYUVATextures, 980 MakeFromYUVAPixmaps, MakePromiseTexture, MakePromiseYUVATexture, MakeBackendTextureFromSkImage, 981 flush, flushAndSubmit, getBackendTexture, makeTextureImage. 982 These were all no-ops anyway when just the CPU backend was compiled in. 983 984* * * 985 986Milestone 96 987------------ 988 * SkRuntimeEffect no longer clamps the RGB values of an effect's output to the range 0..A. 989 This makes it easier to use a hierarchy of SkSL shaders where intermediate values do not 990 represent colors but are, for example, non-color inputs to a lighting model. 991 http://review.skia.org/452558 992 993* * * 994 995Milestone 95 996------------ 997 * Minimum supported iOS raised from 8 to 11. Skia may build back to iOS 9 but versions older 998 than 11 are not tested. Community contributions to support versions 9 and 10 of iOS may be 999 considered, but they may not be complex as they cannot be tested. 1000 1001* * * 1002 1003Milestone 94 1004------------ 1005 * Metal backend has been changed to track command buffer resources manually 1006 rather than using retained resources. 1007 https://review.skia.org/432878 1008 1009 * Added virtual onResetClip() to SkCanvas for Android Framework, to emulate the soon-to-be-removed 1010 expanding clip ops guarded by SK_SUPPORT_DEPRECATED_CLIPOPS. 1011 https://review.skia.org/430897 1012 1013 * Removed SK_SUPPORT_DEPRECATED_CLIPOPS build flag. Clips can only be intersect and difference. 1014 https://review.skia.org/436565 1015 1016 * There is a new syntax for invoking (sampling) child effects in SkSL. Previously, children 1017 (shaders, colorFilters, blenders) were invoked using different overloads of `sample`. That 1018 syntax is deprecated (but still supported). Now, the child behaves like an object, with a method 1019 name `eval`. The arguments to these `eval` methods are the same as the arguments in the old 1020 `sample` intrinsics. For example: 1021 // Old syntax: 1022 sample(shader, xy) 1023 sample(colorFilter, color) 1024 sample(blender, srcColor, dstColor) 1025 // New syntax: 1026 shader.eval(xy) 1027 colorFilter.eval(color) 1028 blender.eval(srcColor, dstColor) 1029 https://review.skia.org/444735 1030 1031* * * 1032 1033Milestone 93 1034------------ 1035 * Removed SkPaint::getHash 1036 https://review.skia.org/419336 1037 1038 * Removed SkShaders::Lerp. It was unused (and easy to replicate with SkRuntimeEffect). 1039 https://review.skia.org/419796 1040 1041 * The default value of GrContextOptions::fReduceOpsTaskSplitting is now enabled. 1042 https://review.skia.org/419836 1043 1044 * Removed SkMatrix44 1045 1046* * * 1047 1048Milestone 92 1049------------ 1050 * Hides SkPathEffect::computeFastBounds() from public API; external subclasses of SkPathEffect 1051 must implement onComputeFastBounds() but can return false to signal it's not computable. 1052 https://review.skia.org/406140 1053 1054 * Add SkM44::RectToRect constructor (SkM44's equivalent to SkMatrix::RectToRect) 1055 https://review.skia.org/402957 1056 1057 * Metal support has been removed for versions of iOS older than 10.0 and MacOS older than 10.14. 1058 https://review.skia.org/401816 1059 1060 * Removed custom attributes from SkVertices and the corresponding `varying` feature from 1061 SkRuntimeEffect. 1062 https://review.skia.org/398222 1063 1064 * Dropped support for mixed samples. Mixed samples is no longer relevant for Ganesh. DMSAA and the 1065 new Ganesh architecture both rely on full MSAA, and any platform where mixed samples is 1066 supported will ultimately not use the old architecture. 1067 1068 * SkRuntimeEffect::Make has been removed. It is replaced by MakeForShader and MakeForColorFilter. 1069 These functions do stricter error checking on the SkSL, to ensure it is valid for a particular 1070 stage of the Skia pipeline. 1071 https://review.skia.org/402156 1072 1073* * * 1074 1075Milestone 91 1076------------ 1077 * The SkSL DSL API has been moved into public headers, although it is still under active 1078 development and isn't quite ready for prime time yet. 1079 https://review.skia.org/378496 1080 1081 * Skia's GPU backend no longer supports NVPR. Our more recent path renderers are more 1082 performant and are not limited to nVidia hardware. 1083 1084 * SkRuntimeEffect now supports uniforms of type int, int2, int3, and int4. Per the OpenGL ES 1085 Shading Language Version 1.00 specification, there are few guarantees about the representation 1086 or range of integral types, and operations that assume integral representation (eg, bitwise), 1087 are not supported. 1088 https://review.skia.org/391856 1089 1090 * SkRuntimeEffect requires that 'shader' variables be declared as 'uniform'. The deprecated 1091 syntax of 'in shader' is no longer supported. 1092 https://review.skia.org/393081 1093 1094* * * 1095 1096Milestone 90 1097------------ 1098 * Renamed use of sk_cf_obj in external Metal types to sk_cfp. 1099 https://review.skia.org/372556 1100 1101 * GrDirectContext::ComputeImageSize() is removed. Use SkImage::textureSize() instead. 1102 https://review.skia.org/368621 1103 https://review.skia.org/369317 1104 https://review.skia.org/371958 1105 1106 * Remove SkImageFilter::MakeMatrixFilter as it was unused and replaced with 1107 SkImageFilters::MatrixTransform. 1108 https://review.skia.org/366318 1109 1110 * Refactored particle system to use a single code string containing both Effect and Particle code. 1111 Uniform APIs are now shared for all program entry points, and no longer prefixed with 'Effect' 1112 or 'Particle'. For example, instead of `SkParticleEffect::effectUniformInfo` and 1113 `SkParticleEffect::particleUniformInfo`, there is just `SkParticleEffect::uniformInfo`. 1114 1115 * Remove SkImageFilter::CropRect from the public API as it's no longer usable. All factories 1116 work with 'SkRect', 'SkIRect', or nullable pointers to 'Sk[I]Rect'. 1117 https://review.skia.org/361496 1118 1119 * Remove deprecated SkImageFilter factory functions and supporting types. All default-provided 1120 SkImageFilters are now only constructed via 'include/effects/SkImageFilters.h' 1121 https://review.skia.org/357285 1122 1123 * Added SkRuntimeEffect::makeImage() to capture the output of an SkRuntimeEffect in an SkImage. 1124 https://review.skia.org/357284 1125 1126 * Updated SkRuntimeEffect::Make() to take an Options struct. It also now returns a Results struct 1127 instead of a tuple. 1128 https://review.skia.org/363785 1129 https://review.skia.org/367060 1130 1131 * Changed SkRuntimeEffect::Varying to have lower-case member names, with no 'f' prefix. 1132 https://review.skia.org/365656 1133 1134 * Changed SkRuntimeEffect::Uniform to have lower-case member names, with no 'f' prefix. 1135 https://review.skia.org/365696 1136 1137 * Deprecate (and ignore) SkAndroidCodec::ExifOrientation 1138 https://review.skia.org/344763 1139 1140 * Fix several minor issues in lighting image filters: 1141 - The spotlight falloff exponent is no longer clamped to [1, 128]. SVG 1.1 requires the specular 1142 lighting effect's exponent (shininess) to be clamped; not the spotlight's falloff. Any such 1143 parameter clamping is the client's responsibility, which makes Skia's lighting effect easily 1144 adaptable to SVG 1.1 (clamp exponent) or SVG 2 (no clamp). 1145 - Fix spotlight incorrectly scaling light within the cone angle. 1146 - Move saturation of RGBA to after multiplying lighting intensity with the lighting color, which 1147 improves rendering when diffuse and specular constants are greater than 1. 1148 https://review.skia.org/355496 1149 1150 * SkDeferredDisplayListRecorder::makePromiseTexture has moved to SkImage::MakePromiseTexture. 1151 New code should use the new entry point – migration CLs will be coming soon. 1152 https://review.skia.org/373716 1153 1154* * * 1155 1156Milestone 89 1157------------ 1158 1159 * Removed SkYUVAIndex and SkYUVASizeInfo. These were no longer used in any 1160 public APIs. 1161 https://review.skia.org/352497 1162 1163 * Numerous changes to SkRuntimeEffect, aligning the capabilities and restrictions with 1164 The OpenGL ES Shading Language 1.00 (aka, the shading language of OpenGL ES2 and WebGL 1.0). 1165 All built-in functions from sections 8.1 through 8.6 implemented & tested on all backends. 1166 Removed types and features that require newer versions of GLSL: 1167 https://review.skia.org/346657 [Non-square matrices] 1168 https://review.skia.org/347046 [uint, short, ushort, byte, ubyte] 1169 https://review.skia.org/349056 [while and do-while loops] 1170 https://review.skia.org/350030 [Bitwise operators and integer remainder] 1171 1172 * Add SkShadowUtils::GetLocalBounds. Generates bounding box for shadows 1173 relative to path. 1174 https://review.skia.org/351922 1175 1176 * Removed SkPerlinNoiseShader::MakeImprovedNoise. 1177 https://review.skia.org/352057 1178 1179 * Removed deprecated version of MakeFromYUVATextures. Use the version 1180 that takes GrYUVABackendTextures instead. 1181 https://review.skia.org/345174 1182 1183 * SkAnimatedImage: Always respect exif orientation 1184 Replace SkPixmapPriv::ShouldSwapWidthHeight with 1185 SkEncodedOriginSwapsWidthHeight. 1186 https://review.skia.org/344762 1187 1188 * Add kDirectionalLight_ShadowFlag support. If enabled, light position represents 1189 a vector pointing towards the light, and light radius is blur radius at elevation 1. 1190 https://review.skia.org/321792 1191 1192 * Support GL_LUMINANCE8_ALPHA8 textures. These can be used with GrBackendTexture APIs 1193 on GrDirectContext and as planes of YUVA images via GrYUVABackendTextures. 1194 https://review.skia.org/344761 1195 1196 * Removed previously deprecated SkImage::MakeFromYUVATexturesCopyToExternal. 1197 https://review.skia.org/342077 1198 1199 * Add versions of GrDirectContext::createBackendTexture and updateBackendTexture 1200 that take a GrSurfaceOrigin. The previous versions are deprecated. 1201 https://review.skia.org/341005 1202 1203 * Remove support for deprecated kDontClipToLayer_SaveLayerFlag in SkCanvas::SaveLayerRec 1204 https://review.skia.org/339988 1205 1206 * Expose more info in SkCodec::FrameInfo 1207 https://review.skia.org/339857 1208 1209 * Added dither control to the SkImageFilters::Shader factory. 1210 https://review.skia.org/338156 1211 1212 * Add MTLBinaryArchive parameter to GrMtlBackendContext. This allows 1213 Skia to cache PipelineStates in the given archive for faster 1214 shader compiles on future runs. The client must handle loading and 1215 saving of the archive. 1216 https://review.skia.org/333758 1217 1218 * Deprecated enum SkYUVAInfo::PlanarConfig has been removed. 1219 https://review.skia.org/334161 1220 1221 * Deprecated SkImage factories have been removed from 1222 SkDeferredDisplayListRecorder. 1223 1224 * The following YUV image factories have been removed: 1225 SkImage::MakeFromYUVTexturesCopyWithExternalBackend 1226 SkImage::MakeFromNV12TexturesCopyWithExternalBackend 1227 Replacement pattern outlined below. 1228 1) Make image using MakeFromYUVATextures 1229 2) Make a SkSurface around result texture using SkSurface::MakeFromBackendTexture 1230 3) surface->getCanvas()->drawImage(image, 0, 0); 1231 4) surface->flushAndSubmit() 1232 5) Optional: SkImage::MakeFromBackendTexture() to use as SkImage. 1233 https://review.skia.org/334596 1234 1235 * Added a new interface for GrDirectContext creation in Metal, using 1236 a new struct called GrMtlBackendContext. The previous interface taking 1237 a MTLDevice and MTLCommandQueue is deprecated. 1238 https://review.skia.org/334426 1239 1240 * SkCanvas::flush has been deprecated. 1241 1242* * * 1243 1244Milestone 88 1245------------ 1246 1247 * SkYUVAInfo now has separate enums for division of channels among planes and 1248 the subsampling. The previous combined enum, PlanarConfig, is deprecated. 1249 https://review.skia.org/334102 1250 1251 * Simplified SkDeferredDisplayListRecorder promise image API. Removed "release" 1252 callback and renamed "done" callback to "release". The new "release" proc can 1253 be null. Added a new SkYUVAInfo-based factory for YUVA promise texture images 1254 and deprecated the old SkYUVAIndex-based one. 1255 https://review.skia.org/331836 1256 https://review.skia.org/333519 1257 1258 * Limit the types and intrinsics supported in SkRuntimeEffect to GLSL ES 1.00 1259 https://review.skia.org/332597 1260 1261 * Add AVIF support to SkHeifCodec. 1262 1263 * Add support for creating SkSurfaceCharacterizations directly for use by a 1264 GrVkSecondaryCBDrawContext. 1265 https://review.skia.org/331877 1266 1267 * Removed SkSurfaceProps::kLegacyFontHost_InitType, SkFontLCDConfig, and related code. 1268 The default pixel geometry for SkSurfaceProps is now kUnknown instead of kRGB_H. 1269 The removal was guarded by the SK_LEGACY_SURFACE_PROPS build flag which was later removed. 1270 https://review.skia.org/322490 1271 https://review.skia.org/329364 1272 1273 * Legacy 8-bit YUV interface removed from SkImageGenerator. Use more flexible SkYUVAPixmaps- 1274 based interface instead. 1275 https://review.skia.org/327917 1276 1277 * New variant of SkImage::MakeFromYUVATextures. Takes a new type GrYUVATextures 1278 which wraps an SkYUVAInfo and compatible set of GrBackendTextures. The provides 1279 a more complete and structured specification of the planar configuration. Previous 1280 version is deprecated. 1281 Already deprecated MakeFromYUVATexturesCopyToExternal added to replace other deprecated 1282 APIs. It's not recommended that clients use this and instead use the pattern described 1283 in the API comment. 1284 https://review.skia.org/317762 1285 https://review.skia.org/329956 1286 1287 * Add field to GrContextOptions to disable mipmap support even if the backend 1288 supports it. 1289 1290 * SkTPin() removed from public API. 1291 1292 * Add new SkImageFilters::Blend factory function, in place of the now deprecated 1293 SkImageFilters::Xfermode factory function. Behavior is identical, but name better matches 1294 conventions in SkShader and SkColorFilter. 1295 https://review.skia.org/324623 1296 1297 * SkImageFilters::Foo() factory functions now accept SkIRect, SkRect, and optional SkIRect* or 1298 SkRect*, instead of previously just the optional SkIRect*. Internally, the crop rects are stored 1299 as floats to allow for fractional crops to be defined in the local coordinate system (before 1300 transformation by the canvas matrix). 1301 https://review.skia.org/324622 1302 1303 * Add new SkImageFilters::Shader factory and deprecate SkImageFilters::Paint factory. All 1304 supported/valid Paint() filters can be represented more cleanly as a Shader image filter. 1305 https://review.skia.org/323680 1306 1307 * GrContext has been replaced by two separate classes: GrDirectContext which is 1308 the traditional notion of GrContext, and GrRecordingContext which is a context 1309 that is recording an SkDeferredDisplayList and therefore has reduced functionality. 1310 Unless you are using SkDeferredDisplayList, migrate directly to GrDirectContext in 1311 all cases. 1312 1313 * CPU sync bool added to SkSurface::flushAndSubmit() and GrContext::flushAndSubmit() 1314 1315 * Removed legacy variant of SkImage::MakeFromYUVAPixmaps. Use the version that 1316 takes SkYUVAPixmaps instead. It has a more structured description of the 1317 planar configuration. 1318 https://review.skia.org/322480 1319 1320 * Some SkImage YUV image factories have been removed. Replacement patterns 1321 outlined below. 1322 SkImage::MakeFromYUVATexturesCopy 1323 1) Make SkImage from YUVA planes using SkImage::MakeFromYUVATextures 1324 2) Use Skia to allocate a surface using SkSurface::MakeRenderTarget 1325 3) surface->getCanvas()->drawImage(image, 0, 0); 1326 4) surface->makeImageSnapShot() produces RGBA image. 1327 SkImage::MakeFromYUVATexturesCopyWithExternalBackend 1328 1) Make image using MakeFromYUVATextures 1329 2) Make a SkSurface around result texture using SkSurface::MakeFromBackendTexture 1330 3) surface->getCanvas()->drawImage(image, 0, 0); 1331 4) surface->flushAndSubmit() 1332 5) Optional: SkImage::MakeFromBackendTexture() to use as SkImage. 1333 SkImage::MakeFromNV12TexturesCopy 1334 Same as SkImage::MakeFromYUVATexturesCopy 1335 https://review.skia.org/321537 1336 1337 * GrBackendRenderTargets which are created with a stencilBits param, now require 1338 the stencilBits to be 0, 8, or 16. 1339 https://review.skia.org/321545 1340 1341* * * 1342 1343Milestone 87 1344------------ 1345 1346 * GrVkImageInfo now has a field for sample count. GrBackendRenderTarget constructor 1347 that took both a GrVkImageInfo and separate sample count is deprecated. Use the 1348 version without sample count instead. Similarly, GrD3DTextureResourceInfo now 1349 has a sample count field and GrBackendRenderTarget no longer takes a separate 1350 sample count for Direct3D. The sample count for GrBackendRenderTarget is now 1351 directly queried from MtlTexture rather than passed separately. The version that 1352 takes a separate sample count is deprecated and the parameter is ignored. 1353 https://review.skia.org/320262 1354 https://review.skia.org/320757 1355 https://review.skia.org/320956 1356 1357 * Added deprecation warning for Metal support on MacOS 10.13, iOS 8.3, and older. 1358 https://review.skia.org/320260 1359 1360 * GrVkImageInfo now has a field for sample count. GrBackendRenderTarget constructor 1361 that took both a GrVkImageInfo and separate sample count is deprecated. Use the 1362 version without sample count instead. 1363 1364 * Update SkClipOp::kMax_EnumValue to include only intersect and difference when 1365 SK_SUPPORT_DEPRECATED_CLIPOPS is not defined. 1366 https://review.skia.org/320064 1367 1368 * Add support for external allocator for Direct3D 12 backend. 1369 Defines base classes for an allocation associated with a backend texture and a 1370 a memory allocator to create such allocations. 1371 Adds memory allocator to backend context. 1372 https://review.skia.org/317243 1373 1374 * Add new optional parameter to GrContext::setBackend[Texture/RenderTarget]State which can 1375 be used to return the previous GrBackendSurfaceMutableState before the requested change. 1376 https://review.skia.org/318698 1377 1378 * New optimized clip stack for GPU backends. Enabled by default but old behavior based on 1379 SkClipStack can be restored by defining SK_DISABLE_NEW_GR_CLIP_STACK when building. It is not 1380 compatible with SK_SUPPORT_DEPRECATED_CLIPOPS and we are targeting the removal of support for 1381 the deprecated, expanding clip ops. 1382 https://review.skia.org/317209 1383 1384 * GPU backends now properly honor the SkFilterQuality when calling drawAtlas. 1385 https://review.skia.org/313081 1386 1387 * The signature of 'main' used with SkRuntimeEffect SkSL has changed. There is no longer an 1388 'inout half4 color' parameter, effects must return their color instead. 1389 Valid signatures are now 'half4 main()' or 'half4 main(float2 coord)'. 1390 https://review.skia.org/310756 1391 1392 * New YUVA planar specifications for SkCodec, SkImageGenerator, SkImage::MakeFromYUVAPixmaps. 1393 Chroma subsampling is specified in more structured way. SkCodec and SkImageGenerator 1394 don't assume 3 planes with 8bit planar values. Old APIs are deprecated. 1395 https://review.skia.org/309658 1396 https://review.skia.org/312886 1397 https://review.skia.org/314276 1398 https://review.skia.org/316837 1399 https://review.skia.org/317097 1400 1401 * Added VkImageUsageFlags to GrVkImageInfo struct. 1402 1403* * * 1404 1405Milestone 86 1406------------ 1407 1408 * Remove support for 'in' variables from SkRuntimeEffect. API now exclusively refers to inputs 1409 as 'uniforms'. 1410 https://review.skia.org/309050 1411 1412 * Add SkImageGeneratorNDK and SkEncodeImageWithNDK for using Android's NDK APIs to decode and 1413 encode. 1414 https://review.skia.org/308185 1415 https://review.skia.org/308800 1416 1417 * SkImage:remove DecodeToRaster, DecodeToTexture 1418 https://review.skia.org/306331 1419 1420 * Add GrContext api to update compressed backend textures. 1421 https://review.skia.org/302265 1422 1423 * Rename GrMipMapped to GrMipmapped for consistency with new APIs. 1424 Also rename GrBackendTexture::hasMipMaps() to GrBackendTexture::hasMipmaps() 1425 https://review.skia.org/304576 1426 https://review.skia.org/304598 1427 1428 * Add option for clients to own semaphores after wait calls. 1429 https://review.skia.org/301216 1430 1431 * Remove obsolete GrFlushFlags. 1432 https://review.skia.org/298818 1433 1434 * Adds default flush() calls to SkSurface, SkImage, and GrContext. These calls do 1435 a basic flush without a submit. If you haven't updated Skia in a couple releases 1436 and still have flush() calls in your code that you expect to do a flush and 1437 submit, you should update all those to the previously added flushAndSubmit() calls 1438 instead. 1439 https://review.skia.org/299141 1440 1441 * Enable BackendSemaphores for the Direct3D backend. 1442 https://review.skia.org/298752 1443 1444 * Added SkImage:asyncRescaleAndReadPixels and SkImage::asyncRescaleAndReadPixelsYUV420 1445 https://review.skia.org/299281 1446 1447 * Ganesh is moving towards replacing GrContext with the GrDirectContext/GrRecordingContext 1448 pair. GrDirectContexts have _direct_ access to the GPU and are very similar to the old 1449 GrContext. GrRecordingContexts are less powerful contexts that lack GPU access but provided 1450 context-like utilities during DDL recording. SkSurfaces and SkCanvas will now only return 1451 GrRecordingContexts. Clients requiring context features that need GPU access can then 1452 check (via GrRecordingContext::asDirectContext) if the available recording context is actually 1453 a direct context. 1454 1455 * Replace #defined values in SkString with equivalent constexprs. 1456 http://review.skia.org/306160 1457 1458* * * 1459 1460Milestone 85 1461------------ 1462 1463 * Added GrContext::oomed() which reports whether Skia has seen a GL_OUT_OF_MEMORY 1464 error from Open GL [ES] or VK_ERROR_OUT_OF_*_MEMORY from Vulkan. 1465 https://review.skia.org/298216 1466 1467 * Add option on SkSurface::flush to pass in a GrBackendSurfaceMutableState which 1468 we will set the gpu backend surface to be at the end of the flush. 1469 https://review.skia.org/295567 1470 1471 * Add GrContext function to set mutable state on a backend surface. Currently this 1472 is only used for setting vulkan VkImage layout and queue family. 1473 https://review.skia.org/293844 1474 1475 * SkSurface factores that take GrBackendTexture or GrBackendRenderTarget now always 1476 call the release proc (if provided) on failure. SkSurface::replaceBackendTexture 1477 also calls the release proc on failure. 1478 https://review.skia.org/293762 1479 1480 * SkSurface::asyncRescaleAndReadPixels and SkSurfaceasyncRescaleAndReadPixelsYUV420 1481 now require explicit GrContext submit to guarantee finite time before callback 1482 is invoked. 1483 https://review.skia.org/292840 1484 1485 * Add VkSharingMode field to GrVkImageInfo. 1486 https://review.skia.org/293559 1487 1488 * Move SkBitmapRegionDecoder into client_utils/android. 1489 1490 * SkCanvas.clear and SkCanvas.drawColor now accept SkColor4f in addition to SkColor. 1491 1492 * Remove SkSurface::MakeFromBackendTextureAsRenderTarget. 1493 This factory existed to work around issues with GL_TEXTURE_RECTANGLE that existed 1494 in Chrome's command buffer. Those issues have since been resolved. Use 1495 SkSurface::MakeFromBackendTexutre or SkSurface::MakeFromBackendRenderTarget instead. 1496 https://review.skia.org/292719 1497 1498 * Adds submittedProc callback to GrFlushInfo which will be called when the work 1499 from the flush call is submitted to the GPU. This is specifically useful for knowing 1500 when semahpores sent with the flush have been submitted and can be waiting on. 1501 https://review.skia.org/291078 1502 1503 * GrContext submit is now required to be called in order to send GPU work to the 1504 actual GPU. The flush calls simply produces 3D API specific objects that are ready 1505 to be submitted (e.g. command buffers). For the GL backend, the flush will still 1506 send commands to the driver. However, clients should still assume the must call 1507 submit which is where any glFlush that is need for sync objects will be called. There, 1508 are flushAndSubmit() functions of GrContext, SkSurface, and SkImage that will act 1509 like the previous flush() functions. This will flush the work and immediately call 1510 submit. 1511 https://review.skia.org/289033 1512 1513 * Remove deprecated version of flush calls on GrContext and SkSurface. 1514 https://review.skia.org/2290540 1515 1516 * SkCanvas::drawVertices and drawPatch now support mapping an SkShader without explicit 1517 texture coordinates. If they're not supplied, the local positions (vertex position or 1518 patch cubic positions) will be directly used to sample the SkShader. 1519 https://review.skia.org/290130 1520 1521* * * 1522 1523Milestone 84 1524------------ 1525 1526 * Add api on GrContext, updateBackendTexture that will upload new data to a 1527 GrBackendTexture. 1528 https://review.skia.org/288909 1529 1530 * Add GrContext getter to SkSurface. 1531 https://review.skia.org/289479 1532 1533 * Deprecate GrContext and SkSurface flush() call and replace ith with flushAndSubmit(). 1534 This only effects the default flush call that takes no parameters. 1535 https://review.skia.org/289478 1536 1537 * GrContext::createBackendTexture functions that initialize the texture no longer 1538 guarantee that all the data has been uploaded and the gpu is done with the texture. 1539 Instead the client can assume the upload work has been submitted to the gpu and they 1540 must wait for that work to finish before deleting the texture. This can be done via 1541 their own synchronization or by passing in a finish proc into the create calls which 1542 will be called when it is safe to delete the texture (at least in terms of work 1543 done during the create). 1544 https://review.skia.org/286517 1545 1546 * Remove unused SkMaskFilter helpers: compbine, compose 1547 Note: shadermaskfilter will likely be removed next (clipShader should serve) 1548 1549 * Add back SkCanvas::kPreserveLCDText_SaveLayerFlag to indicate that saveLayer() 1550 will preserve LCD-text. All text in the layer must be drawn on opaque background 1551 to ensure correct rendering. 1552 1553 * Add the new directory client_utils/ for code that is specific to a single client and 1554 should be considered separate from Skia proper. Move SkFrontBufferedStream into the 1555 subdir android/. 1556 1557 * SkBitmap and SkPixmap's erase() methods now treat their color parameters 1558 consistently with the rest of Skia, with all SkColors and any untagged 1559 SkColor4fs interpreted as sRGB, not as a color in the bitmap's color space. 1560 SkPixmap::erase(SkColor4f) now takes an SkColorSpace, so you can pass 1561 pixmap.colorSpace() if you want the old behavior. 1562 1563 * SkCamera.h and SkMatrix44.h are DEPRECATED. 1564 Use SkM44 if you want to have 3d transformations. 1565 1566 * Changed Dilate and Erode image filters to take SkScalar for radius instead of int. While 1567 the image filters themselves are defined in terms of discrete pixels, the radii provided by 1568 the user are mapped through the CTM so taking ints forced over discretization. After mapping 1569 through the CTM the radii are now rounded to pixels. 1570 https://review.skia.org/281731 1571 https://review.skia.org/282636 1572 1573 * Updated the contract of GrContext and SkSurface flush calls in regards to semaphores. Made it 1574 clear that the caller is responsible for deleting any initialized semaphores after the flush 1575 call regardless if we were able to submit them or not. Also, allows skia to only submit a 1576 subset of the requested semaphores if we failed to create some. 1577 https://review.skia.org/282265 1578 1579 1580 * SkCanvas::drawVertices will now always fill the triangles specified by the vertices. Previously, 1581 vertices with no colors and no (texture coordinates or shader) would be drawn in wireframe. 1582 https://review.skia.org/282043 1583 1584* * * 1585 1586Milestone 83 1587------------ 1588 1589 * Remove localmatrix option from SkShaders::[Blend, Lerp] 1590 1591 * Fill out Direct3D parameters for backend textures and backend rendertargets. 1592 1593 * SkImage::makeTextureImage() takes an optional SkBudgeted param 1594 1595 * Made non-GL builds of GPU backend more robust. 1596 https://review.skia.org/277456 1597 1598 * MoltenVK support removed. Use Metal backend instead. 1599 https://review.skia.org/277612 1600 1601* * * 1602 1603Milestone 82 1604------------ 1605 1606 * Removed drawBitmap and related functions from SkDevice; all public drawBitmap functions on 1607 SkCanvas automatically wrap the bitmap in an SkImage and call the equivalent drawImage function. 1608 Drawing mutable SkBitmaps will now incur a mandatory copy. Switch to using SkImage directly or 1609 mark the bitmap as immutable before drawing. 1610 1611 * Removed "volatile" flag from SkVertices. All SkVertices objects are assumed to be 1612 volatile (the previous default behavior). 1613 1614 * Removed exotic legacy bitmap functions from SkCanvas (drawBitmapLattic, drawBitmapNine); the 1615 exotic SkImage functions still exist. 1616 1617 * Make it possible to selectively turn on/off individual encoders/decoders, 1618 using skia_use_(libpng/libjpeg_turbo/libwebp)(decode/encode). 1619 1620 * Removed GrGpuResource, GrSurface, and GrTexture from public api. These were not 1621 meant to be public, and we now can move them into src. Also removed getTexture 1622 function from SkImage.h 1623 1624 * Removed Bones from SkVertices 1625 1626 * Added a field to GrContextOptions that controls whether GL errors are checked after 1627 GL calls that allocate textures, etc. It also controls checking for shader compile 1628 success, and program linking success. 1629 1630 * Made SkDeferredDisplayList.h officially part of the public API (i.e., moved it to 1631 include/core). Also added a ProgramIterator to SkDeferredDisplayList which allows 1632 clients to pre-compile some of the shaders the DDL requires. 1633 1634 * Added two new helper methods to SkSurfaceCharacterization: createBackendFormat and 1635 createFBO0. These make it easier for clients to create new surface characterizations that 1636 differ only a little from an existing surface characterization. 1637 1638 * Removed SkTMax and SkTMin. 1639 * Removed SkTClamp and SkClampMax. 1640 * Removed SkScalarClampMax and SkScalarPin. 1641 * Removed SkMax32 and SkMin32. 1642 * Removed SkMaxScalar and SkMinScalar. 1643 1644 * SkColorSetA now warns if the result is unused. 1645 1646 * An SkImageInfo with a null SkColorSpace passed to SkCodec::getPixels() and 1647 related calls is treated as a request to do no color correction at decode 1648 time. 1649 1650 * Add new APIs to add attributes to document structure node when 1651 creating a tagged PDF. 1652 1653 * Remove CGFontRef parameter from SkCreateTypefaceFromCTFont. 1654 Use CTFontManagerCreateFontDescriptorFromData instead of 1655 CGFontCreateWithDataProvider to create CTFonts to avoid memory use issues. 1656 1657 * Added SkCodec:: and SkAndroidCodec::getICCProfile for reporting the native 1658 ICC profile of an encoded image, even if it doesn't map to an SkColorSpace. 1659 1660 * SkSurface::ReplaceBackendTexture takes ContentChangeMode as a parameter, 1661 which allow callers to specify whether retain a copy of the current content. 1662 1663 * Enforce the existing documentation in SkCanvas::saveLayer that it ignores 1664 any mask filter on the restore SkPaint. The 'coverage' of a layer is 1665 ill-defined, and masking should be handled by pre-clipping or using the 1666 auxiliary clip mask image of the SaveLayerRec. 1667 1668* * * 1669 1670Milestone 81 1671------------ 1672 1673 * Added support for GL_NV_fence extension. 1674 1675 * Make SkImageInfo::validRowBytes require rowBytes to be pixel aligned. This 1676 makes SkBitmap match the behavior of raster SkSurfaces in rejecting 1677 non-aligned rowBytes. 1678 1679 * Added an SkImage::MakeRasterFromCompressed entry point. Also updated 1680 SkImage::MakeFromCompressed to decompress the compressed image data if 1681 the GPU doesn't support the specified compression type (i.e., macOS Metal 1682 doesn't support BC1_RGB8_UNORM so such compressed images will always be 1683 decompressed on that platform). 1684 1685 * Added support for BC1 RGBA compressed textures 1686 1687 * Added CachingHint to SkImage::makeRasterImage 1688 1689 * Added SkAnimatedImage::getCurrentFrame() 1690 1691 * Add support to create an SkSurface from an MTKView, with delayed acquisition of 1692 the MTLDrawable. 1693 Entry point: SkSurface::MakeFromMTKView 1694 1695 * Removed SkIRect::EmptyIRect(). Use SkIRect::MakeEmpty() instead. 1696 https://review.skia.org/262382/ 1697 1698 * Moved SkRuntimeEffect to public API. This is the new (experimental) interface to custom SkSL 1699 shaders and color filters. 1700 1701 * Added BC1 compressed format support. Metal and Vulkan seem to only support the BC 1702 formats on desktop machines. 1703 1704 * Added compressed format support for backend texture creation API. 1705 This adds the following new entry points: 1706 GrContext::compressedBackendFormat 1707 GrContext::createCompressedBackendTexture 1708 The latter method comes in variants that allow color-initialized and 1709 compressed texture data initialized. 1710 1711 * Added SkMatrix::MakeTrans(SkIVector) 1712 https://review.skia.org/259804 1713 1714* * * 1715 1716Milestone 80 1717------------ 1718 1719 * For Vulkan backend, we now require that the VkDevice, Queue, and Instance outlive 1720 either the destruction or abandoning of the GrContext. Additionally, all 1721 GrBackendTextures created via GrContext::createBackendTexture calls must be deleted 1722 before destroying or abandoning the GrContext. 1723 https://review.skia.org/257921 1724 1725 * Removed SkSize& SkSize::operator=(const SkISize&) 1726 https://review.skia.org/257880 1727 1728 * SkISize width() and height() now constexpr 1729 https://review.skia.org/257680 1730 1731 * Added SkMatrix::MakeTrans(SkVector) and SkRect::makeOffset(SkVector). 1732 https://review.skia.org/255782 1733 1734 * Added SkImageInfo::MakeA8(SkISize) and added optional color space parameter to 1735 SkImageInfo::MakeN32Premul(SkISize). 1736 1737 * Added dimensions() and getFrameCount() to SkAnimatedImage 1738 https://review.skia.org/253542 1739 1740 * Removed SkMatrix44 version of toXYZD50 from SkColorSpace. Switched to skcms types in 1741 transferFn, invTrasnferFn, and gamutTransformTo functions. 1742 https://review.skia.org/252596 1743 1744 * Removed rotation and YUV support from SkColorMatrix 1745 https://review.skia.org/252188 1746 1747 * Added kBT2020_SkYUVColorSpace. This is BT.2020's YCbCr conversion (non-constant-luminance). 1748 https://review.skia.org/252160 1749 1750 * Remove old async read pixels APIs 1751 https://review.skia.org/251198 1752 1753 * Expose SkBlendModeCoeff and SkBlendMode_AsCoeff for Porter-Duff blend modes. 1754 https://review.skia.org/252600 1755 1756* * * 1757 1758Milestone 79 1759------------ 1760 1761 * SkTextBlob::Iter to discover the glyph indices and typefaces in each run 1762 https://skia-review.googlesource.com/246296 1763 1764 * Added support for PQ and HLG transfer functions to SkColorSpace. 1765 https://skia-review.googlesource.com/c/skia/+/249000 1766 1767 * Added new api on GrContext ComputeImageSize. This replaces the hold static helper 1768 ComputeTextureSize. 1769 https://skia-review.googlesource.com/c/skia/+/247337 1770 1771 * New versions of SkSurface async-rescale-and read APIs that allow client to extend 1772 the lifetime of the result data. Old versions are deprecated. 1773 https://review.skia.org/245457 1774 1775 * Add SkColorInfo. It's dimensionless SkImageInfo. 1776 https://review.skia.org/245261 1777 1778 * Added SkPixmap-based createBackendTexture method to GrContext. This allows clients to create 1779 backend resources (initialized with texture data) that Skia/Ganesh doesn't know about/track. 1780 https://review.skia.org/244676 1781 1782 * Add explicit src and dst colorspace parameters to SkColorFilter::filterColor4f() 1783 https://review.skia.org/244882 1784 1785 * Remove Vulkan/Metal float32 RGBA texture support 1786 https://review.skia.org/244881 1787 1788 * Add SkSurface::MakeFromCAMetalLayer 1789 https://review.skia.org/242563 1790 1791 * Added kAlpha_F16_SkColorType, kRG_F16_SkColorType and kRGBA_16161616_SkColorType. 1792 This is intended to help support HDR YUV uses case (e.g., P010 and P016). As such, 1793 the addition is focused on allowing creation of SkPixmaps and SkImages and not 1794 SkSurfaces (i.e., who wants to render to render to these?) 1795 https://review.skia.org/241357 1796 1797 * Start to move nested SkPath types (e.g. Direction, Verb) up to root level in SkPathTypes.h 1798 https://review.skia.org/241079 1799 1800 * Remove isRectContour and ksNestedFillRects from public 1801 https://review.skia.org/241078 1802 1803 * Added kRG_88_SkColorType. This is intended to help support YUV uses case (e.g., NV12). 1804 As such, the addition is focused on allowing creation of SkPixmaps and SkImages and not 1805 SkSurfaces (i.e., who wants to render to RG?) 1806 https://review.skia.org/239930 1807 https://review.skia.org/235797 1808 1809 * Make the size of program/pipeline caches configurable via 1810 GrContextOptions::fRuntimeProgramCacheSize 1811 https://review.skia.org/239756 1812 1813 * Added kAlpha_16_SkColorType and kRG_1616_SkColorType. This is intended to help support HDR YUV 1814 uses case (e.g., P010 and P016). As such, the addition is focused on allowing creation of 1815 SkPixmaps and SkImages and not SkSurfaces (i.e., who wants to render to render to these?) 1816 https://review.skia.org/239930 1817 1818 * Add GrContext::precompileShader to allow up-front compilation of previously-cached shaders. 1819 https://review.skia.org/239438 1820 1821* * * 1822 1823Milestone 78 1824------------ 1825 1826 * SkDrawLooper is no longer supported in SkPaint or SkCanvas. 1827 https://review.skia.org/230579 1828 https://review.skia.org/231736 1829 1830 * SkPath::Iter::next() now ignores its consumDegenerates bools. Those will so 1831 go away entirely 1832 https://review.skia.org/235104 1833 1834 * SkImage: new factories: DecodeToRaster, DecodeToTexture 1835 https://review.skia.org/234476 1836 1837 * SkImageFilter API refactor started: 1838 - Provide new factory API in include/effects/SkImageFilters 1839 - Consolidated enum types to use SkTileMode and SkColorChannel 1840 - Hide filter implementation classes 1841 - Hide previously public functions on SkImageFilter that were intended for 1842 internal use only 1843 https://review.skia.org/230198 1844 https://review.skia.org/230876 1845 https://review.skia.org/231256 1846 1847 * SkColorFilters::HSLAMatrix - new matrix color filter operating in HSLA 1848 space. 1849 https://review.skia.org/231736 1850 1851 * Modify GrBackendFormat getters to not return internal pointers. Use an enum 1852 class for GL formats. 1853 https://review.skia.org/233160 1854 1855 * Expose GrContext::dump() when SK_ENABLE_DUMP_GPU is defined. 1856 https://review.skia.org/233557 1857 1858 * Vulkan backend now supports YCbCr sampler for I420 Vulkan images that are 1859 not backed by external images. 1860 https://review.skia.org/233776 1861 1862 * Add SkCodec::SelectionPolicy for distinguishing between decoding a still 1863 image or an image sequence for a container format that has both (e.g. HEIF). 1864 https://review.skia.org/232839 1865 1866 * SkImage::makeTextureImage and SkImage::MakeCrossContextFromPixmap no longer 1867 take an SkColorSpace parameter. It was unused. 1868 https://review.skia.org/234579 1869 https://review.skia.org/234912 1870 1871 * SkImage::reinterpretColorSpace - to reinterpret image contents in a new 1872 color space. 1873 https://review.skia.org/234328 1874 1875 * Removed SkImage::MakeCrossContextFromEncoded. 1876 https://review.skia.org/234912 1877 1878 * Add Metal support for GrFence, GrSemaphore, and GrBackendSemaphore 1879 https://review.skia.org/233416 1880 1881 * SkMallocPixelRef: remove MakeDirect and MakeWithProc from API. 1882 https://review.skia.org/234660 1883 1884 * Remove 4-parameter variant of SkRect::join() and intersect(), and 1885 noemptycheck variants of intersect(). 1886 https://review.skia.org/235832 1887 https://review.skia.org/237142 1888 1889 * Remove unused sk_sp comparison operators. 1890 https://review.skia.org/236942 1891 1892 * Add SkColor4f variant to experimental_DrawEdgeAAQuad for SkiaRenderer. 1893 https://review.skia.org/237492 1894 1895 * Deprecated maxCount resource cache limit for Ganesh. 1896 This hasn't been relevant for a long time. 1897 1898 * Changed GrContextOptions' fDisallowGLSLBinaryCaching to fShaderCacheStrategy, 1899 and allow caching SkSL. 1900 https://review.skia.org/238856 1901 1902 * Use GL_QCOM_TILED_RENDERING to explicitly discard stencil 1903 1904 * Added RELEASE_NOTES.txt file 1905 https://review.skia.org/229760 1906 1907 * Implemented internal support for OpenGL tessellation. 1908