repository·main·Indexed 27 days ago
https://github.com/google/skiaSkia is a 2D graphics library. This documentation covers build system configurations for Bazel, GN, and CMake, including RBE Docker image management and external dependency handling. It also provides guidance on CanvasKit (a WebAssembly version of Skia's Canvas API), fuzzing executables for bug identification via OSS-Fuzz, and compiling the minimal_ios_mtl_skia_app for iOS using the Metal backend.
Skia is a graphics library used for drawing text, geometries, and images. It supports advanced graphical features including:
Skia supports multiple device backends for output:
The infra/bots/recipe_modules directory contains Skia-specific modules used by recipes (located in infra/bots/recipes). These modules provide shared utilities for building, running, and managing Skia-related tasks within the infrastructure.
Available modules include:
builder_name_schema: Derives expected behavior from task (builder) names.core: A starting point for most recipes; handles setup and sync steps.ct: Shared Cluster Telemetry utilities.flavor: Handles platform-specific details by allowing callers to specify high-level commands.infra: Shared infrastructure-related utilities.run: Utilities for executing commands.swarming: Utilities for managing Swarming tasks.vars: Common global variables used across Skia recipes and modules.Skia uses a recipe framework to execute work within Swarming tasks. The core components are:
recipes.py: The script used for running and testing recipes.recipes: The entry points for specific task types (e.g., compiling or running tests).recipe_modules: Shared modules utilized by recipes..recipe_deps: Managed dependencies from other repositories, automatically synced by recipes.py.Skia operates using two primary coordinate systems:
(0, 0) is at the upper-left corner, and coordinates extend to (w, h) at the bottom-right. These are effectively measured in pixels.SkCanvas. By default, local and device coordinates are identical, meaning geometry is typically specified in pixel units.Skia performs color management by transforming colors from a source color space to a destination color space via a common connection space: XYZ D50.
The process consists of six logical steps:
Note: Steps 2 and 5 (transfer function applications) are the most computationally expensive.
SkSL (Skia Shading Language) is a standardized variant of GLSL used as Skia's internal shading language. The SkSL compiler converts code into GLSL, GLSL ES, SPIR-V, or MSL.
Key syntax and type differences from GLSL:
float, int, and uint are always high precision. half, short, and ushort are medium precision.<base type><columns> (e.g., float2 instead of vec2, bool4 instead of bvec4).<base type><columns>x<rows> (e.g., float2x3 instead of mat2x3).sk_Caps.<name> (e.g., sk_Caps.integerSupport). These can be used in if statements for compile-time branch elimination.sk_FragColor for output color (do not declare it).sk_Position (device coordinates) instead of gl_Position.sk_PointSize instead of gl_PointSize.sk_VertexID instead of gl_VertexID.sk_InstanceID instead of gl_InstanceID.sk_FragCoord for fragment coordinates (relative to upper left).sk_Clockwise instead of gl_FrontFacing.#version statement required..0 to make a number a float (e.g., float2(x, y) * 4 is valid).1.0f or 0xFFu are unsupported.sample (e.g., sample(sampler2D, float3)).inline modifier to force inlining.float2(float3(1))) is disallowed; use swizzles instead.GPU gradients in Skia are composed of three distinct architectural components:
GrXxxxxGradientColorizer): A one-dimensional component that returns a color for an interpolant value t in the range [0.0, 1.0]. It handles color stops and how to wrap, tile, or clamp out-of-bound inputs.GrYyyyyGradientLayout): Converts 2D geometry/position into the 1D domain used by the colorizer (e.g., linear or radial). This is the component to implement when designing new gradient shapes.GrClampedGradientEffect: Handles clamped and decal tile modes. Requires border colors to be specified externally.GrTiledGradientEffect: Implements repeat and mirror tile modes.GrGradientShader provides static factory functions to create GrFragmentProcessor graphs that reproduce a specific SkGradientShader.
The Skia CPU backend is responsible for rendering graphics on the CPU without utilizing a GPU. The architecture follows a data flow from high-level API calls down to pixel memory writing. The core components include:
SkBitmapDevice): Manages the target bitmap.SkDraw): Coordinates the drawing process.SkScan): Converts geometry into coverage information.SkRasterPipelineBlitter): Writes final colors to the destination.SkRasterPipeline): Manages the rendering pipeline.SkPixmap, SkBitmap, and SkPixelRef): Provides access to the underlying pixel data.Skia's drawing operations are organized around the SkCanvas object, which acts as the host for drawing calls like drawRect, drawPath, and drawText.
Every drawing operation typically requires two components:
SkRect, SkPath, SkImage).SkPaint object that defines color, stroke, font, and effects.SkCanvas maintains state related to the drawing destination, such as the current transformation matrix (translation, rotation, skewing, perspective) and clipping regions. In contrast, SkPaint holds the stylistic attributes, such as color and blending modes.
canvas->drawRect(rect, paint);In Skia, text rendering is split into two distinct phases: Shaping and Drawing.
Skia exposes these capabilities via the SkShaper API to allow developers to perform text processing independently of the final rendering context.
tools/unicode_comparison directory provides utilities for comparing Unicode data between SkUnicode (C++) and Go. It consists of a C++ bridge and a set of Go utilities for data downloading, preprocessing, and table generation.