pixi-silk 0.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/dist/shader.js ADDED
@@ -0,0 +1,516 @@
1
+ import { GradientAtlas } from "./atlas.js";
2
+ import { GlProgram, Shader, UniformGroup } from "pixi.js";
3
+ //#region src/shader.ts
4
+ /** @internal Vertex stage of the uber program (GLSL ES 3.00). */
5
+ const vertex = `#version 300 es
6
+ in vec2 aCorner;
7
+ in vec4 aBounds;
8
+ in vec4 aShape0;
9
+ in vec4 aShape1;
10
+ in vec4 aShape2;
11
+ in vec4 aMeta;
12
+ in vec4 aFill;
13
+ in vec4 aStroke;
14
+ in vec4 aGrad;
15
+ in vec4 aPaint;
16
+ in vec4 aDash;
17
+ uniform mat3 uProjectionMatrix;
18
+ uniform mat3 uWorldTransformMatrix;
19
+ uniform vec4 uWorldColorAlpha;
20
+ uniform vec2 uResolution;
21
+ uniform mat3 uTransformMatrix;
22
+ uniform vec4 uColor;
23
+ uniform vec4 uSilk;
24
+ out vec2 vPos;
25
+ flat out vec4 vShape0;
26
+ flat out vec4 vShape1;
27
+ flat out vec4 vShape2;
28
+ flat out vec4 vMeta;
29
+ flat out vec4 vFill;
30
+ flat out vec4 vStroke;
31
+ flat out vec4 vGrad;
32
+ flat out vec4 vPaint;
33
+ flat out vec4 vDash;
34
+ flat out vec4 vTint;
35
+ void main(void)
36
+ {
37
+ mat3 m = uProjectionMatrix * uWorldTransformMatrix * uTransformMatrix;
38
+ vec2 hr = 0.5 * abs(uResolution);
39
+ vec2 jx = m[0].xy * hr;
40
+ vec2 jy = m[1].xy * hr;
41
+ float a2 = dot(jx, jx) + dot(jy, jy);
42
+ float det = abs(jx.x * jy.y - jx.y * jy.x);
43
+ float smin = sqrt(max(0.5 * (a2 - sqrt(max(a2 * a2 - 4.0 * det * det, 0.0))), 1e-12));
44
+ float lpx = 1.0 / smin;
45
+ float pad = (0.5 * uSilk.y + 1.0) * lpx;
46
+ int type = int(aMeta.x + 0.5);
47
+ int flags = int(aMeta.y + 0.5);
48
+ vec2 pos;
49
+ if (type == 4)
50
+ {
51
+ vec2 a = aShape0.xy;
52
+ vec2 b = aShape0.zw;
53
+ vec2 ab = b - a;
54
+ float len = length(ab);
55
+ vec2 dir = len > 1e-9 ? ab / len : vec2(1.0, 0.0);
56
+ vec2 nrm = vec2(-dir.y, dir.x);
57
+ float ext = max(max(aShape2.z, aShape2.w), 0.5 * lpx * uSilk.z) + 3.0 * aMeta.w + pad;
58
+ pos = (aCorner.x < 0.5 ? a - dir * ext : b + dir * ext) + nrm * (aCorner.y < 0.5 ? -ext : ext);
59
+ }
60
+ else
61
+ {
62
+ float pl = pad;
63
+ float pr = pad;
64
+ if (type == 5)
65
+ {
66
+ pl = (flags & 64) != 0 ? pad : 0.0;
67
+ pr = (flags & 128) != 0 ? pad : 0.0;
68
+ }
69
+ pos = vec2(aCorner.x < 0.5 ? aBounds.x - pl : aBounds.z + pr,
70
+ aCorner.y < 0.5 ? aBounds.y - pad : aBounds.w + pad);
71
+ }
72
+ vPos = pos;
73
+ gl_Position = vec4((m * vec3(pos, 1.0)).xy, 0.0, 1.0);
74
+ vShape0 = aShape0;
75
+ vShape1 = aShape1;
76
+ vShape2 = aShape2;
77
+ vMeta = aMeta;
78
+ vFill = aFill;
79
+ vStroke = aStroke;
80
+ vGrad = aGrad;
81
+ vPaint = aPaint;
82
+ vDash = aDash;
83
+ vTint = uColor * uWorldColorAlpha;
84
+ }`;
85
+ /** @internal Fragment stage: signed distance, coverage and paint for every primitive type. */
86
+ const fragment = `#version 300 es
87
+ precision highp int;
88
+ in vec2 vPos;
89
+ flat in vec4 vShape0;
90
+ flat in vec4 vShape1;
91
+ flat in vec4 vShape2;
92
+ flat in vec4 vMeta;
93
+ flat in vec4 vFill;
94
+ flat in vec4 vStroke;
95
+ flat in vec4 vGrad;
96
+ flat in vec4 vPaint;
97
+ flat in vec4 vDash;
98
+ flat in vec4 vTint;
99
+ uniform highp sampler2D uGradients;
100
+ uniform vec4 uSilk;
101
+ out vec4 finalColor;
102
+ const float PI = 3.14159265358979;
103
+ const float TAU = 6.28318530717959;
104
+ float gPx;
105
+ float gSigma;
106
+ float erfApprox(float x)
107
+ {
108
+ float s = sign(x);
109
+ float a = abs(x);
110
+ float t = 1.0 + (0.278393 + (0.230389 + 0.078108 * (a * a)) * a) * a;
111
+ t *= t;
112
+ return s - s / (t * t);
113
+ }
114
+ float cover(float sd)
115
+ {
116
+ if (gSigma > 0.0)
117
+ {
118
+ float s = sqrt(gSigma * gSigma + 0.1 * gPx * gPx);
119
+ return 0.5 - 0.5 * erfApprox(sd / (s * 1.41421356));
120
+ }
121
+ return clamp(0.5 - sd / gPx, 0.0, 1.0);
122
+ }
123
+ float dot2(vec2 v) { return dot(v, v); }
124
+ vec2 rotate(vec2 p, float a)
125
+ {
126
+ float c = cos(a);
127
+ float s = sin(a);
128
+ return vec2(c * p.x - s * p.y, s * p.x + c * p.y);
129
+ }
130
+ float sdRoundBox(vec2 p, vec2 b, vec4 r, float n)
131
+ {
132
+ r.xy = (p.x > 0.0) ? r.xy : r.zw;
133
+ float rad = (p.y > 0.0) ? r.x : r.y;
134
+ rad = min(rad, min(b.x, b.y));
135
+ vec2 q = abs(p) - b + rad;
136
+ float inner = min(max(q.x, q.y), 0.0);
137
+ if (n <= 2.001 || rad <= 0.0) return inner + length(max(q, 0.0)) - rad;
138
+ vec2 m = max(q, 0.0) / rad;
139
+ float ln = pow(pow(m.x, n) + pow(m.y, n), 1.0 / n);
140
+ float g = 1.0;
141
+ if (ln > 1e-5) g = length(pow(m / ln, vec2(n - 1.0)));
142
+ return inner + rad * (ln - 1.0) / max(g, 0.5);
143
+ }
144
+ float sdEllipse(vec2 p, vec2 ab)
145
+ {
146
+ vec2 pa = abs(p);
147
+ vec2 t = vec2(0.70710678);
148
+ float k = ab.x * ab.x - ab.y * ab.y;
149
+ for (int i = 0; i < 3; i++)
150
+ {
151
+ vec2 xy = ab * t;
152
+ vec2 e = vec2(k * t.x * t.x * t.x / ab.x, -k * t.y * t.y * t.y / ab.y);
153
+ vec2 r = xy - e;
154
+ vec2 q = pa - e;
155
+ t = clamp((q * length(r) / max(length(q), 1e-9) + e) / ab, 0.0, 1.0);
156
+ t /= max(length(t), 1e-9);
157
+ }
158
+ float d = length(pa - ab * t);
159
+ vec2 n = pa / ab;
160
+ return dot(n, n) > 1.0 ? d : -d;
161
+ }
162
+ float sdWedge(vec2 q, float h)
163
+ {
164
+ vec2 c = vec2(sin(h), cos(h));
165
+ q.x = abs(q.x);
166
+ float m = length(q - c * max(dot(q, c), 0.0));
167
+ return m * sign(c.y * q.x - c.x * q.y);
168
+ }
169
+ float sdHeart(vec2 p)
170
+ {
171
+ p.x = abs(p.x);
172
+ if (p.y + p.x > 1.0) return sqrt(dot2(p - vec2(0.25, 0.75))) - 0.35355339;
173
+ return sqrt(min(dot2(p - vec2(0.0, 1.0)), dot2(p - 0.5 * max(p.x + p.y, 0.0)))) * sign(p.x - p.y);
174
+ }
175
+ float sdStar(vec2 p, float r, float n, float en)
176
+ {
177
+ float an = PI / n;
178
+ vec2 acs = vec2(cos(an), sin(an));
179
+ vec2 ecs = vec2(cos(en), sin(en));
180
+ float bn = mod(atan(p.x, p.y), 2.0 * an) - an;
181
+ p = length(p) * vec2(cos(bn), abs(sin(bn)));
182
+ p -= r * acs;
183
+ p += ecs * clamp(-dot(p, ecs), 0.0, r * acs.y / ecs.y);
184
+ return length(p) * sign(p.x);
185
+ }
186
+ float sdTriangle(vec2 p, vec2 p0, vec2 p1, vec2 p2)
187
+ {
188
+ vec2 e0 = p1 - p0, e1 = p2 - p1, e2 = p0 - p2;
189
+ vec2 v0 = p - p0, v1 = p - p1, v2 = p - p2;
190
+ vec2 pq0 = v0 - e0 * clamp(dot(v0, e0) / dot(e0, e0), 0.0, 1.0);
191
+ vec2 pq1 = v1 - e1 * clamp(dot(v1, e1) / dot(e1, e1), 0.0, 1.0);
192
+ vec2 pq2 = v2 - e2 * clamp(dot(v2, e2) / dot(e2, e2), 0.0, 1.0);
193
+ float s = sign(e0.x * e2.y - e0.y * e2.x);
194
+ vec2 d = min(min(vec2(dot(pq0, pq0), s * (v0.x * e0.y - v0.y * e0.x)),
195
+ vec2(dot(pq1, pq1), s * (v1.x * e1.y - v1.y * e1.x))),
196
+ vec2(dot(pq2, pq2), s * (v2.x * e2.y - v2.y * e2.x)));
197
+ return -sqrt(d.x) * sign(d.y);
198
+ }
199
+ float sdTaper(vec2 p, vec2 pa, vec2 pb, float ra, float rb)
200
+ {
201
+ p -= pa;
202
+ pb -= pa;
203
+ float h = dot(pb, pb);
204
+ float b = ra - rb;
205
+ if (h < 1e-10 || b * b >= h) return ra >= rb ? length(p) - ra : length(p - pb) - rb;
206
+ vec2 q = vec2(dot(p, vec2(pb.y, -pb.x)), dot(p, pb)) / h;
207
+ q.x = abs(q.x);
208
+ vec2 c = vec2(sqrt(h - b * b), b);
209
+ float k = c.x * q.y - c.y * q.x;
210
+ float m = dot(c, q);
211
+ float n = dot(q, q);
212
+ if (k < 0.0) return sqrt(h * n) - ra;
213
+ if (k > c.x) return sqrt(h * (n + 1.0 - 2.0 * q.y)) - rb;
214
+ return m - ra;
215
+ }
216
+ float distSeg(vec2 p, vec2 a, vec2 b)
217
+ {
218
+ vec2 pa = p - a, ba = b - a;
219
+ float h = clamp(dot(pa, ba) / max(dot(ba, ba), 1e-12), 0.0, 1.0);
220
+ return length(pa - ba * h);
221
+ }
222
+ float boxEnd(float e, float v, float hw)
223
+ {
224
+ vec2 q = vec2(e, v - hw);
225
+ return length(max(q, 0.0)) + min(max(q.x, q.y), 0.0);
226
+ }
227
+ float dashSD(float u, float v, float L, float hw, int cap, bool closed)
228
+ {
229
+ float dash = vDash.x;
230
+ float period = max(vDash.x + vDash.y, 1e-5);
231
+ float k = floor((u + vDash.z) / period);
232
+ float best = 1e6;
233
+ for (int i = -1; i <= 1; i++)
234
+ {
235
+ float s0 = (k + float(i)) * period - vDash.z;
236
+ float s1 = s0 + dash;
237
+ if (!closed)
238
+ {
239
+ s0 = max(s0, 0.0);
240
+ s1 = min(s1, L);
241
+ if (s1 < s0) continue;
242
+ }
243
+ float e = abs(u - 0.5 * (s0 + s1)) - 0.5 * (s1 - s0);
244
+ float sd;
245
+ if (cap == 1) sd = length(vec2(max(e, 0.0), v)) - hw;
246
+ else sd = boxEnd(cap == 2 ? e - hw : e, v, hw);
247
+ best = min(best, sd);
248
+ }
249
+ return best;
250
+ }
251
+ vec4 gradientColor(vec2 p, float u, float L, int kind)
252
+ {
253
+ float t;
254
+ if (kind == 1)
255
+ {
256
+ vec2 ab = vGrad.zw - vGrad.xy;
257
+ t = dot(p - vGrad.xy, ab) / max(dot(ab, ab), 1e-12);
258
+ }
259
+ else if (kind == 2)
260
+ {
261
+ t = (length(p - vGrad.xy) - vGrad.w) / max(vGrad.z - vGrad.w, 1e-9);
262
+ }
263
+ else if (kind == 3)
264
+ {
265
+ vec2 q = p - vGrad.xy;
266
+ float sw = vGrad.w;
267
+ float as = max(abs(sw), 1e-9);
268
+ float rel = mod((atan(q.y, q.x) - vGrad.z) * (sw < 0.0 ? -1.0 : 1.0), TAU);
269
+ if (as < TAU - 1e-4 && rel > 0.5 * (as + TAU)) rel -= TAU;
270
+ t = rel / as;
271
+ }
272
+ else
273
+ {
274
+ t = u / max(L, 1e-9);
275
+ }
276
+ int ext = int(vPaint.z + 0.5);
277
+ if (ext == 1) t = fract(t);
278
+ else if (ext == 2) t = 1.0 - abs(mod(t, 2.0) - 1.0);
279
+ t = clamp(t, 0.0, 1.0);
280
+ return textureLod(uGradients, vec2((t * 255.0 + 0.5) / 256.0, (vPaint.y + 0.5) / 256.0), 0.0);
281
+ }
282
+ float ign(vec2 p)
283
+ {
284
+ return fract(52.9829189 * fract(dot(p, vec2(0.06711056, 0.00583715))));
285
+ }
286
+ void main(void)
287
+ {
288
+ vec2 p = vPos;
289
+ vec2 ddx = dFdx(p);
290
+ vec2 ddy = dFdy(p);
291
+ float px = max(sqrt(abs(ddx.x * ddy.y - ddx.y * ddy.x)), 1e-7);
292
+ gPx = px * uSilk.y;
293
+ gSigma = vMeta.w;
294
+ int type = int(vMeta.x + 0.5);
295
+ int flags = int(vMeta.y + 0.5);
296
+ bool hasFill = (flags & 1) != 0;
297
+ bool hasStroke = (flags & 2) != 0 && vMeta.z > 0.0;
298
+ bool dashed = (flags & 8) != 0;
299
+ int cap0 = (flags >> 8) & 3;
300
+ int cap1 = (flags >> 10) & 3;
301
+ float hw = 0.5 * vMeta.z;
302
+ float hwEff = max(hw, 0.5 * px * uSilk.z);
303
+ float strokeScale = hw / max(hwEff, 1e-9);
304
+ float align = vDash.w;
305
+ float d = 1e6;
306
+ float sd = 1e6;
307
+ bool open = false;
308
+ float u = 0.0;
309
+ float L = 1.0;
310
+ float fillScale = 1.0;
311
+ float areaCov = 0.0;
312
+ if (type == 0)
313
+ {
314
+ vec2 b = vShape0.zw;
315
+ vec2 bi = max(b, vec2(0.5 * px));
316
+ fillScale = (b.x / bi.x) * (b.y / bi.y);
317
+ vec2 q = p - vShape0.xy;
318
+ if (vShape2.w != 0.0) q = rotate(q, -vShape2.w);
319
+ d = sdRoundBox(q, bi, vShape1, vShape2.x);
320
+ }
321
+ else if (type == 1)
322
+ {
323
+ vec2 ab = vShape0.zw;
324
+ vec2 abi = max(ab, vec2(0.5 * px));
325
+ fillScale = (ab.x / abi.x) * (ab.y / abi.y);
326
+ vec2 q = p - vShape0.xy;
327
+ if (vShape2.w != 0.0) q = rotate(q, -vShape2.w);
328
+ d = abs(abi.x - abi.y) <= 1e-4 * max(abi.x, abi.y) ? length(q) - abi.x : sdEllipse(q, abi);
329
+ float rm = 0.5 * (abi.x + abi.y) + align * hwEff;
330
+ u = mod(atan(q.y, q.x) + 0.5 * PI, TAU) * rm;
331
+ L = TAU * rm;
332
+ }
333
+ else if (type == 2 || type == 3)
334
+ {
335
+ vec2 q = p - vShape0.xy;
336
+ float sweep = vShape1.x;
337
+ float h = min(abs(sweep) * 0.5, PI);
338
+ float mid = vShape0.w + 0.5 * sweep;
339
+ float cm = cos(mid);
340
+ float sm = sin(mid);
341
+ vec2 qr = vec2(sm * q.x - cm * q.y, cm * q.x + sm * q.y);
342
+ float len = length(q);
343
+ bool full = h >= PI - 1e-4;
344
+ if (type == 2)
345
+ {
346
+ open = true;
347
+ float r = vShape0.z;
348
+ u = (h - (sweep < 0.0 ? -1.0 : 1.0) * atan(qr.x, qr.y)) * r;
349
+ L = 2.0 * h * r;
350
+ float v = abs(len - r);
351
+ if (dashed) sd = dashSD(u, v, L, hwEff, cap0, full);
352
+ else if (full) sd = v - hwEff;
353
+ else if (cap0 == 1)
354
+ {
355
+ vec2 sc = vec2(sin(h), cos(h));
356
+ vec2 qa = vec2(abs(qr.x), qr.y);
357
+ sd = ((sc.y * qa.x > sc.x * qa.y) ? length(qa - sc * r) : v) - hwEff;
358
+ }
359
+ else
360
+ {
361
+ float e = sdWedge(qr, h);
362
+ sd = boxEnd(cap0 == 2 ? e - hwEff : e, v, hwEff);
363
+ }
364
+ }
365
+ else
366
+ {
367
+ float r1 = vShape0.z;
368
+ float r0 = vShape1.y;
369
+ float rc = vShape1.z;
370
+ float dA = len - (r1 - rc);
371
+ if (r0 > 0.0) dA = max(dA, (r0 + rc) - len);
372
+ float dW = full ? -1e6 : sdWedge(qr, h) + rc;
373
+ vec2 w = vec2(dA, dW);
374
+ d = length(max(w, 0.0)) + min(max(w.x, w.y), 0.0) - rc;
375
+ }
376
+ }
377
+ else if (type == 4)
378
+ {
379
+ open = true;
380
+ vec2 a = vShape0.xy;
381
+ vec2 b = vShape0.zw;
382
+ float mn = 0.5 * px * uSilk.z;
383
+ float ra = max(vShape2.z, mn);
384
+ float rb = max(vShape2.w, mn);
385
+ float dSelf = sdTaper(p, a, b, ra, rb);
386
+ float bias = 1e-3 * px;
387
+ if ((flags & 16) != 0 && sdTaper(p, vShape1.xy, a, max(vDash.w, mn), ra) - dSelf < bias) discard;
388
+ if ((flags & 32) != 0 && dSelf - sdTaper(p, b, vShape1.zw, rb, max(vPaint.w, mn)) >= bias) discard;
389
+ vec2 ab = b - a;
390
+ float ls = length(ab);
391
+ vec2 dir = ls > 1e-9 ? ab / ls : vec2(1.0, 0.0);
392
+ float us = dot(p - a, dir);
393
+ float hr = mix(vShape2.z, vShape2.w, clamp(us / max(ls, 1e-9), 0.0, 1.0));
394
+ float hrEff = max(hr, mn);
395
+ strokeScale = hr / max(hrEff, 1e-9);
396
+ u = vShape2.x + us;
397
+ L = vShape2.y;
398
+ if (dashed)
399
+ {
400
+ sd = dashSD(u, distSeg(p, a, b), L, hrEff, cap0, (flags & 8192) != 0);
401
+ }
402
+ else
403
+ {
404
+ bool nearStart = us < 0.5 * ls;
405
+ float v = abs(dir.x * (p.y - a.y) - dir.y * (p.x - a.x));
406
+ if (nearStart && (flags & 16) == 0 && cap0 != 1) sd = boxEnd(-us - (cap0 == 2 ? ra : 0.0), v, ra);
407
+ else if (!nearStart && (flags & 32) == 0 && cap1 != 1) sd = boxEnd(us - ls - (cap1 == 2 ? rb : 0.0), v, rb);
408
+ else sd = dSelf;
409
+ }
410
+ }
411
+ else if (type == 5)
412
+ {
413
+ vec2 a = vShape0.xy;
414
+ vec2 b = vShape0.zw;
415
+ vec2 c = vShape1.xy;
416
+ vec2 e = vShape1.zw;
417
+ vec2 t1 = (b - a) / max(length(b - a), 1e-9);
418
+ vec2 t2 = (e - c) / max(length(e - c), 1e-9);
419
+ areaCov = cover(dot(p - a, vec2(t1.y, -t1.x))) * cover(dot(p - c, vec2(-t2.y, t2.x)));
420
+ if ((flags & 64) != 0) areaCov *= cover(a.x - p.x);
421
+ if ((flags & 128) != 0) areaCov *= cover(p.x - b.x);
422
+ }
423
+ else if (type == 6)
424
+ {
425
+ float s = vShape0.z;
426
+ vec2 q = p - vShape0.xy;
427
+ if (vShape2.w != 0.0) q = rotate(q, -vShape2.w);
428
+ q /= s;
429
+ d = (sdHeart(vec2(q.x, 0.552 - q.y)) - vShape0.w) * s;
430
+ }
431
+ else if (type == 7)
432
+ {
433
+ vec2 q = rotate(p - vShape0.xy, -vShape0.w);
434
+ q.y = -q.y;
435
+ float rc = vShape1.z;
436
+ d = sdStar(q, vShape0.z - rc, vShape1.x, vShape1.y) - rc;
437
+ }
438
+ else if (type == 8)
439
+ {
440
+ d = sdTriangle(p, vShape0.xy, vShape0.zw, vShape1.xy) - vShape1.z;
441
+ }
442
+ vec4 fillCol = hasFill ? vFill : vec4(0.0);
443
+ vec4 strokeCol = vStroke;
444
+ int gk = int(vPaint.x + 0.5);
445
+ if (gk > 0)
446
+ {
447
+ vec4 g = gradientColor(p, u, L, gk);
448
+ if ((flags & 4096) != 0) strokeCol *= g;
449
+ else fillCol *= g;
450
+ }
451
+ vec4 col;
452
+ if (type == 5)
453
+ {
454
+ col = fillCol * areaCov;
455
+ }
456
+ else if (open)
457
+ {
458
+ col = strokeCol * (cover(sd) * strokeScale);
459
+ }
460
+ else if (hasStroke)
461
+ {
462
+ float off = align * hwEff;
463
+ if (dashed)
464
+ {
465
+ float cS = cover(dashSD(u, abs(d - off), L, hwEff, cap0, true)) * strokeScale;
466
+ col = strokeCol * cS + fillCol * (cover(d) * fillScale * (1.0 - strokeCol.a * cS));
467
+ }
468
+ else
469
+ {
470
+ float cLo = cover(d - (off - hwEff));
471
+ float cHi = cover(d - (off + hwEff));
472
+ float cS = max(cHi - cLo, 0.0) * strokeScale;
473
+ float under = max(cover(d) - cLo, 0.0);
474
+ col = strokeCol * cS + fillCol * ((cLo + under * (1.0 - strokeCol.a * strokeScale)) * fillScale);
475
+ }
476
+ }
477
+ else
478
+ {
479
+ col = fillCol * (cover(d) * fillScale);
480
+ }
481
+ col *= vTint;
482
+ if (col.a <= 0.0) discard;
483
+ if ((flags & 4) != 0)
484
+ {
485
+ float n = ign(gl_FragCoord.xy) - 0.5;
486
+ col.rgb = clamp(col.rgb + n * (uSilk.x / 255.0), 0.0, col.a);
487
+ }
488
+ finalColor = col;
489
+ }`;
490
+ let program = null;
491
+ function createSilkShader(settings) {
492
+ program ??= GlProgram.from({
493
+ vertex,
494
+ fragment,
495
+ name: "silk-sdf",
496
+ preferredVertexPrecision: "highp",
497
+ preferredFragmentPrecision: "highp"
498
+ });
499
+ return new Shader({
500
+ glProgram: program,
501
+ resources: {
502
+ uGradients: GradientAtlas.shared.source,
503
+ silkUniforms: new UniformGroup({ uSilk: {
504
+ value: new Float32Array([
505
+ settings.dither,
506
+ settings.aaWidth,
507
+ settings.minStrokePx,
508
+ 0
509
+ ]),
510
+ type: "vec4<f32>"
511
+ } })
512
+ }
513
+ });
514
+ }
515
+ //#endregion
516
+ export { createSilkShader, fragment, vertex };
package/package.json ADDED
@@ -0,0 +1,75 @@
1
+ {
2
+ "name": "pixi-silk",
3
+ "version": "0.1.0",
4
+ "description": "Smooth vector graphics for PixiJS v8: analytic anti-aliased SDF primitives, squircles, arcs, polylines, dashes, OKLab gradients, glows and DPR-exact canvases, one draw call per object.",
5
+ "type": "module",
6
+ "sideEffects": false,
7
+ "main": "./dist/index.js",
8
+ "types": "./dist/index.d.ts",
9
+ "exports": {
10
+ ".": {
11
+ "types": "./dist/index.d.ts",
12
+ "default": "./dist/index.js"
13
+ },
14
+ "./package.json": "./package.json"
15
+ },
16
+ "files": [
17
+ "dist",
18
+ "README.md",
19
+ "LICENSE",
20
+ "CHANGELOG.md"
21
+ ],
22
+ "publishConfig": {
23
+ "access": "public"
24
+ },
25
+ "scripts": {
26
+ "build": "tsdown",
27
+ "test": "vitest run",
28
+ "test:watch": "vitest",
29
+ "typecheck": "tsc && tsc -p tsconfig.build.json",
30
+ "prepack": "node ../../scripts/stage-package-files.mjs",
31
+ "postpack": "node ../../scripts/stage-package-files.mjs --clean"
32
+ },
33
+ "peerDependencies": {
34
+ "pixi.js": "^8.6.0"
35
+ },
36
+ "devDependencies": {
37
+ "@arethetypeswrong/core": "^0.18.5",
38
+ "pixi.js": "^8.21.0",
39
+ "publint": "^0.3.24",
40
+ "tsdown": "^0.23.0",
41
+ "typescript": "^7.0.2",
42
+ "vitest": "^5.0.2"
43
+ },
44
+ "license": "MIT",
45
+ "author": "schmooky",
46
+ "homepage": "https://pixi-silk.schmooky.dev",
47
+ "bugs": {
48
+ "url": "https://github.com/schmooky/pixi-silk/issues"
49
+ },
50
+ "repository": {
51
+ "type": "git",
52
+ "url": "git+https://github.com/schmooky/pixi-silk.git",
53
+ "directory": "packages/pixi-silk"
54
+ },
55
+ "keywords": [
56
+ "pixi",
57
+ "pixijs",
58
+ "pixi.js",
59
+ "graphics",
60
+ "vector",
61
+ "antialiasing",
62
+ "anti-aliasing",
63
+ "sdf",
64
+ "signed-distance-field",
65
+ "shader",
66
+ "webgl",
67
+ "squircle",
68
+ "gradient",
69
+ "oklab",
70
+ "charts",
71
+ "retina",
72
+ "hidpi",
73
+ "typescript"
74
+ ]
75
+ }