Skip to main content

Variable: sketchStroke

const sketchStroke: object

Defined in: modules/geometry/sketch-stroke/sketch-stroke.ts:140

Fragment coverage for geometry-anchored pencil strokes and solid architectural lines.

Type Declaration​

bindingLayout​

readonly bindingLayout: readonly [{ group: 3; name: "sketchStroke"; }]

defaultUniforms​

readonly defaultUniforms: object = defaults

defaultUniforms.extension​

extension: number = 3

defaultUniforms.grain​

grain: number = 0.45

defaultUniforms.jitter​

jitter: number = 0.7

defaultUniforms.minimumAntialias​

minimumAntialias: number = 0.7

defaultUniforms.offset​

offset: number = 0

defaultUniforms.sketch​

sketch: number = 1

defaultUniforms.variation​

variation: number = 0.35

defaultUniforms.width​

width: number = 2

fs​

readonly fs: string

name​

readonly name: "sketchStroke" = 'sketchStroke'

source​

source: "\nstruct sketchStrokeUniforms {\n width: f32,\n jitter: f32,\n variation: f32,\n grain: f32,\n offset: f32,\n extension: f32,\n sketch: f32,\n minimumAntialias: f32,\n};\n@group(3) @binding(auto) var<uniform> sketchStroke: sketchStrokeUniforms;\nfn sketchStroke_noise(coordinate: f32) -> f32 {\n let cell = floor(coordinate);\n let fraction = fract(coordinate);\n let first = fract(sin(cell * 127.1) * 43758.5453);\n let second = fract(sin((cell + 1.0) * 127.1) * 43758.5453);\n return mix(first, second, fraction * fraction * (3.0 - 2.0 * fraction));\n}\nfn sketchStroke_noise2(coordinate: vec2<f32>) -> f32 {\n let cell = floor(coordinate);\n var fraction = fract(coordinate);\n fraction = fraction * fraction * (vec2<f32>(3.0) - 2.0 * fraction);\n let first = fract(sin(dot(cell, vec2<f32>(127.1, 311.7))) * 43758.5453);\n let second = fract(sin(dot(cell + vec2<f32>(1.0, 0.0), vec2<f32>(127.1, 311.7))) * 43758.5453);\n let third = fract(sin(dot(cell + vec2<f32>(0.0, 1.0), vec2<f32>(127.1, 311.7))) * 43758.5453);\n let fourth = fract(sin(dot(cell + vec2<f32>(1.0, 1.0), vec2<f32>(127.1, 311.7))) * 43758.5453);\n return mix(mix(first, second, fraction.x), mix(third, fourth, fraction.x), fraction.y);\n}\nfn sketchStroke_getCoverage(coordinates: vec2<f32>, strokeLength: f32, seed: f32) -> f32 {\n let along = coordinates.x;\n let side = select(1.0, -1.0, sketchStroke_noise(seed * 29.0) < 0.5);\n let center = (sketchStroke_noise(along * strokeLength / 36.0 + seed * 19.0) * 2.0 - 1.0) * sketchStroke.jitter * sketchStroke.sketch + side * sketchStroke.offset * sketchStroke.sketch;\n let variation = mix(1.0, 0.55 + sketchStroke_noise(along * 31.0 + seed * 7.0) * 0.75, sketchStroke.variation * sketchStroke.sketch);\n let grainCoordinates = vec2<f32>(along * strokeLength, coordinates.y) + vec2<f32>(seed * 17.0, seed * 53.0);\n let coarseGrain = sketchStroke_noise2(grainCoordinates * 0.55);\n let fineGrain = sketchStroke_noise2(grainCoordinates * 2.8);\n let toothGrain = sketchStroke_noise2(grainCoordinates * 6.5);\n let grainTexture = coarseGrain * 0.35 + fineGrain * 0.4 + toothGrain * 0.25;\n let edgeRoughness = (grainTexture - 0.5) * sketchStroke.grain * sketchStroke.sketch * 0.7;\n let radius = sketchStroke.width * 0.5 * variation + edgeRoughness;\n let endDistance = max(-along, along - 1.0) * strokeLength - sketchStroke.extension;\n let distance = max(abs(coordinates.y - center) - radius, endDistance);\n let antialias = max(fwidth(distance), max(sketchStroke.minimumAntialias, 0.0001));\n let coverage = 1.0 - smoothstep(-antialias * 0.5, antialias * 0.5, distance);\n // Keep the pigment opaque; grain changes the stroke edge so the paper does not show through as white flecks.\n return coverage;\n}\n"

uniformTypes​

readonly uniformTypes: object

uniformTypes.extension​

readonly extension: "f32" = 'f32'

uniformTypes.grain​

readonly grain: "f32" = 'f32'

uniformTypes.jitter​

readonly jitter: "f32" = 'f32'

uniformTypes.minimumAntialias​

readonly minimumAntialias: "f32" = 'f32'

uniformTypes.offset​

readonly offset: "f32" = 'f32'

uniformTypes.sketch​

readonly sketch: "f32" = 'f32'

uniformTypes.variation​

readonly variation: "f32" = 'f32'

uniformTypes.width​

readonly width: "f32" = 'f32'

vs​

readonly vs: "\nlayout(std140) uniform sketchStrokeUniforms {\n float width;\n float jitter;\n float variation;\n float grain;\n float offset;\n float extension;\n float sketch;\n float minimumAntialias;\n} sketchStroke;\n" = uniformBlock

getUniforms()​

readonly getUniforms(props?): object

Parameters​

props?​

SketchStrokeProps = {}

Returns​

extension​

extension: number = 3

Endpoint overshoot in stroke units; geometry must reserve this space.

grain​

grain: number = 0.45

Strength of pencil grain, from zero to one.

jitter​

jitter: number = 0.7

Maximum centerline displacement in transverse-coordinate units.

minimumAntialias​

minimumAntialias: number = 0.7

Minimum edge smoothing in stroke units. Defaults to 0.7 for pixel-sized strokes.

offset​

offset: number = 0

Transverse screen-space displacement for a secondary hand-drawn pass.

sketch​

sketch: number = 1

Zero gives a solid stroke; one enables sketch shading.

variation​

variation: number = 0.35

Fractional width variation, from zero to one.

width​

width: number = 2

Full stroke width in the same units as the transverse coordinate.