ELF>@P@8 @x x 000pppp$$@@Std@@PtdԃԃԃTtdPPP44QtdRtdpppGNU`y,PCC[b{EݳW?B ER@D"  @%nhBCDEFGHIKMOPQRTUWXYZ[\^_`abcdygk7CҐC\w}nKBa#]s?@ApHH}HtHH=HH9tH~Ht H=H5H)HH?HHHtH}HtfD=eu3UH=}Ht H=.}c<]f.@ff.gf.f.f.f.f.DHUHAVAUIATISHHA$M]IKOHHk8DIHk8L1f/1f/@)u E $f(AɉAHHk8D1f/1f/@)ARLIREJfGHwIHk8D1f/1f/)ȃt^ff.BHHHk8D1f/E1f/AD)tH9s#DABIHk8LHmDDL)LwHEBI)IL9LHL]MuLmIH[A\A]A^]ÉE A$HHk8DIHk8L1f/1f/@)E $f(AɉHLL@HUHAVAUIATISHHA$M]IKOHHk8IHk8 1f/1f/@)u E $f(AɉAHHk81f/1f/@)ARLIREJff.GHwIHk81f/1f/)ȃtM@BHHHk81f/E1f/AD)tH9sDABIHk8 HfDL)LwHEBI)IL9LHL]MLmIH[A\A]A^]ÉE A$HHk8IHk8 1f/1f/@)E $f(AɉHLLff.HUHAVAUIATISHHA$M]IKOHHk8DIHk8L1f/1f/@)u E $f(AɉAHHk8D1f/1f/@)ARLIREJfGHwIHk8D1f/1f/)ȃtNBHHHk8D1f/E1f/AD)tH9s#DABIHk8LH}DDL)LwHEBI)IL9LHL]MLmIH[A\A]A^]ÉE A$HHk8DIHk8L1f/1f/@)E $f(AɉHLL@HUHAVAUIATISHHA$M]IKOHHk8DIHk8L1f/1f/@)u E $f(AɉAHHk8D1f/1f/@)ARLIREJfGHwIHk8D1f/1f/)ȃtNBHHHk8D1f/E1f/AD)tH9sDABIHk8LHDL)LwHEBI)IL9LHL]MLmIH[A\A]A^]ÉE A$HHk8DIHk8L1f/1f/@)E $f(AɉHLLÐff.Ɔe1fUfDoflfDlfofoflflHSHXD)])M)ef(f()Uff(t=HIf(Uf/Yu 1H]@fD(EH)UHfDXfffDYfDXEfDXEfDYfA(fA(D)Eff(&tf/HwfD(Mf(UfDXMf(Mf(HfD(EDHf(fD\fA(fA(fEffA(f(fD\fDYf(f\fAYfA\D)Mf(ffXff(ffD(EfD( Hf(uf(Ef(UD)Ef\fAXfAYfX)Eff(mf(f(ff(s5Gf(Uf/uH]HwqUHHUoF H~0HMfo GEMfoMH}foEoEHH]fƆeH@ff.Ht H~~V(~HY~F~X~FY~~XЅu V4UHV(HH@@,H~.@4Hv H0zLuJ.H8zDuBHO8LG0HtHI HE)UAHE(U@(H@,P4fHO8LGHtHIHEHUHuH})UAHE(UHUHuH}fU(HV(~HSHHH~~^C(H~Y~FHv ~X~Y~~X(((t/HO8HGHtHI)U(((US4H]@HO8K8C4HGHtH HUHuH})Ue]HC4C((Ue]HUHC,HuH}m@U(~HV(HSHHH~~~~vDND~~C(AYD~YH~DYY~X~XAYDDY~XDXFHv ~XEX((t.HO8HG HtHI)e(A((ec4H]fHO8K8C4HGHtH HUHuH})e]UuDEHC4C((e]UuHC,DEHUHuH}XfDUD(~D(HV(HSHHX~D~N>DfY~VA~ًC(D(DnD^EDYH~AYAYEY~X~Y^EXHv ~D(EXEX~X(YAYAY(EY((DX(AXDXXA(AXڅt4HO8HG(HtHI)uA(A((us4H]HO8K8C4HGHtH HUHuH})umeDuD}]UHC4C((umeDuHC,D}]UHUHuH}<UHSHH(F(t9C,.C4HV(H~K0Hv z5u3.K8z-u+HO8HG0HtHI fC(C,H]HO8HGHtHIHUHuH}HUHuH}ff.UHSHHH?mHH]%mfH4UAfHHPGDW@p9HyHHk8fD(qDf(fDfHmHDfD(fDD@0D@x Hn)5m)5m)5mH9eqPy yXfD(fD(A4fD(DfATfDUfDVf(fTfUfVy`DfATfDUfA(fDVAhDfDTfUfAVfATfDUf(fDVf(AfTfUfVf(fTAfAUfVf(fTfAUfVf(fTfUfVf(fTfUfVffTfUQPf(fVfTfUfVfA`҉Q@Hl)5^l)5gl)5plA8f.G8xA9 fDFLA9rA$IwDDEHyHHk8HMDMme]UMEHHiDMHMfHDEEHMU]emQDHk8HtDDMHqHHMjHMDMfDEEHMU]emADHyHDI@pHiDMHMfHDEEHMU]emuA@D9rADHyHpЉA@Jf.f(8t^f.O(E„tf.G E„u;fo w0f(f(ff(@tG0of(f(f(@~8t0~0u^f.^ Nzuf.N(zuF0ZV DUZHf(HH Hu)U1Huf(U~8tF0V ~8t"~0uFf.F Nzu f.N(zuHUfDofDofDlfofofEofDlflHATflISfDofDoHD=;dH%(H]fD(fD fEfE(fE(fE\fE\fA(fA(fA(fff(fW;f(=:AYYXf(fT;f/%fA(fA(fE(1ffE\D)f(D)\fD)0DYf(f(D)@D)PAYD)`DXD^f(fEfEYfEXfA(fA(D)fA\fA\fY:fY-:fAXfAXfA\fA\f(ff(ffD(`fDoPfD(@fD(0fD(fD(fD(=(:R  fEYfA(˃LfA\fEY׉D)pD)0fAYfEXfEXD)@fAXfE(D)UU]fD\f(fA\fEYfAYfDXxfAXfE(D)PfD\)EemfEYfDXpD)Eu}D)`%fD(`fD(=39fD(PfD(@fDo0f HEdH+%((HL[A\]f.fD( A|$8t+fAd$ f.f(f(ff(z*u(f.(zuHEdH+%(ukH[A\]ÐfA(At$0fA(ff(@u3HEdH+%(u2(f(LH[f(A\]1AD$0Ad$\dff.H~8tgfZf.v EЄtOfZf.v(EЄt8.EЄt+.EЄt.EЄt.D„tfDG Zf(ZfA(fff(fD(Zf(A\A\f(f(YYXff/ 6fD(fE^fE(f(A\E\YDYA\D67YYfD/r1f(A\Yf(fA\Y\YYfD/s6fA(fEf(1f(f(ffffA(Xf(f(H~8tkffZf.n(ZE„tf.f E„u8fw w0f(f(ff(@tG0wf(f(DH~8tkfv ffZZf.f(ffD(f(z u fA.zt4w0ffZZ@tG0wfA(f(}DUHf(HH0FAA9s))t IqMLMH<1\MLMAIfDFDA9rA?vA11DDƉMIyLMHDEu^HtYH\DELMHMHtVAQHt DEIqLM!^LMDEMHIyE!\DELMHMHuAD9Fff.x|xvUIAHH 9rBAA9s&IqM)LMHHC(HHC0eRHKC@vCDH{H"KHH]%K@UH#]ff.HHHtxUHHH}HuZJH}O,tGLG0Hu1L H9t-H;2uH@IHtHPHUUJHUH@BJ1H1DUHSHLJMtLHH]LEH11H5CHHJ11H5HI11H5HH11H5HkH11H5pHIH&IH='gVHt0HEHIU[HH97H1G)>HHHEHIHDwpWtDHtGpHtGtUHAUATIHuSHLHdL,%(LmAHUHUЋuHQHHHHLHDGHUdH+%(u H[A\A]]Gff.%FHfDG@fG0G4G8GG x*GDfGPfG`fЉG@fUHHG8H]HLmH i D_4LeE(_Pf.kzkf(~ f(fTf. 5Mf(fTf.cXf(f(fTf.v5H,ffUDH*f(fAT\f(fVf(fTf.uS`f(f(fTf.v8H,fD(fD fUH*DfETAXfVf(f(fTf.khfD(f(fTf.v7H,f(fD .fDUH*fATXfAVf(fTf.\\f(ffff(f(%ffffTfTfUfUfVfVf(f(fffTfUfTfUfVfVffflDcDEu/ELeIfDfDcDEtHCHHECxM g B   ] 8   s N ( ECxAD9C|D9YSP~ Dc|Vf(f(fTf.v3H,f5fUH*f(fT\fVf(51f/r{D*fD/rk% YcXf(f(fTf.v5H,ffUD H*f(fAT\f(fVf/rfD/fDLeE1HBLH]LmDFl*E9rA$I5 DHHk8 H HAHH S|Hk8HtHH,CHHDkxf-Yk`f(f(fTf.f/3fD/(Y[hfD(f(fTf.v:H,fD(fDafDUH*DfETAXfAVf(f/fD/LuL},LmDe,fHh,LH,)p@*Yډ4Ɖ<8E]f*YH1I]f*Y]f*Y]DAYETA,AYEɉM6AD,iAYE A,QAYEED@D,0AYEEDM@,AYE(E@MEE,DMD9ADNE9EOD9fAnEDME9ELA9fAnAENfbfofY*A9DOA9EMfAnA9DLA9AA9fAnfbD!D9flAG E9fpƒI8fY!I8AGAGfo%EAg9qm\mAĸA9fuf(pAF\uEf/HhA9ff(E*^p}ff/ff(DuA*^}uH`)PhmhuHQwDpHfmhJf(P`@ %,;dDHfIH@ "29.tUH1f=D;DJUDBT>T> T>09rL\]^]\f(fTf.v6H,fH*fD(DfETA\fD(fDUf(fAVP\U^UXfD(fDTfA.v8H,fEL*fE(DfETE\fD(fDUfA(fAV,E1҅AHD,҉P,E9EODP0A9H9P0}HJ<H1HP*ff.ff.HH9rAAEsǃЉǃ ЉvǃЉQǃЉ,ǃ,Љ(MC|CxǃЉǃЉǃЉǃЉǃЉgǃЉBDH6HH*CxD9LeCxHDƉUDhDE:DEHDDEUH։UuHuHuHLH1DhDEAHI9uHL 1HPfAHH9uHDeLMHUHr$HMDfHc;V4LLf.D`D$HEE9V}HcV;V 8LLfff.AD`E$HEE9V }EAH8A9oLMAAHMHHULK49H(HhHHuD0D`ID IDMfff.EEE$MID9D)HhD9IGJ<HLLEDUHEH}*H}HEDULEH4HWH9szfff.H9s_Hk8ATHffnHfbfH9s/HfHnHk8AD1f/E1f/AD)ɃtHH9rD9D)HD9IG…N<HLHELeHEIOI4H9sn@I9s\Hk8AHf.fnHfbfI9s,PfHnHk8A1f/1f/@)tHH9rIIL9mDL(HPLLD0HLD DHuHhHL DID(ID0MfDEEE $MID9D)D9IGHhLDMLEJ<HHEH} H}HELEDMH4HWH9szfff.H9s_Hk8ATHffnHfbfH9s/HfHnHk8AD1f/E1f/AD)уtHH9rD9D)HD9IGN<HLHEL5HEIOI4H9so@I9s]Hk8ATHffnHfbfI9s-PfHnHk8AD1f/1f/@)tHH9rIIL9mCD`D(L D0D(1ECL-At/At$H}Hk8HGhH70H8H9uDЃpAt6u1=L8EMtHcI9B(3E1LU}U/IHkELUUȉE@DUfEu H(fAE$fD"$HxHHuƃe1I$[A\]fff.UHHL}dH%(HE1HFHhH]HLeLLmILuE1fDAD$(C{lHHxHJ#A.T$I|$z]u[fA.D$zOuMA.D$zEuCA.T$z;u9A.D$ z1u/A.D$$z'u%HA$Hx#A=fDH`H\#Hx`\"AoL$fID$ EHxEEEHE)p"fHEHxEHEEELm#MMLA4$I|$Hp"EADžtzE.EH}HuMzu .MzHUtAHO8HGHtHIHUH@H8HHH8H@HHHO8HG0HtHI HxG4HH)EH`IHKlChQ9H{pH5"SlHL8Ho"H9v`hdln9ADhDNE9EO9L׋pDhDl9L9pNA9DO9LƋtDl9LtAL$(ED$,A|$0AT$4AD$8AMHAI@I9GA9H]LeLmLuAAL$,h9OщhpAL$49LщplAL$09OщltAL$89LщtAE\ЉChH @ff.LƃeAEH]LeE1LmLuHEdH+%(BDL}fjHxHHDnA9fff.DEL A9rA5DDHH{pHHzH0DHHHzClHHtHspgDHHNjKlH{pDKhQEf^LH#11H5XIH$11H5AL11H5-L11H5yL11H5%L$L;H=ܾg+Mt5HHL=EH]LeAELuLm'NIHHL=TM8&I9)LHDHHHChD9pKlH{pQH]LeLmLuJf.UHH@dH%(HE1euNDHH]HE~`HuHLeALuAu*H]LeLuHEdH+%(fCTH{Pp a!CT}1EM@ƍPHCXAAHPUԅAfAEE1fxfDfpfD@fDHfH fH 1ɅLuHDfP)ʹHH'fPD҉)֍VDEHH'fP)HH'fPDD)LeHH'fPC`H]xlfE11*DLeLuƃeH]H]fE1fH fp1fDfD@fxfp1fpf1fD@fx@H]LeLuff.UHHdH%(HE1eLeIHA|$`HLL}fA~Hx`dhlpH]HxLmA$LuM$HuLAu*H]LeLmLuL}HEdH+%(sÐ1HfHx`HMdhfAnlpHUHuH})HMHULe]EU\uAl$ \ET$,HxD(DY(YUYYAT$(DXXXE((XA(Y(YAXD$0AYXAd$$DYEXL$4DX=// .v,A/fD/ sE.tA,A\fP//s .>,\fP// s .,((fPWYAY\(T / K 9^DYDYA/-D/ sE.A,YY//s .,W%YY//%s .{,Y(Y//}rAD$<A$hH[A\A]]ÐЉGP5fDAD$hs@AD$8UHHH]HL}HudH%(HE1eRW`GTLeLgpLuEGlLmM4M9E1fI<$I2AM9uACTHADEEHMHtH~H9A(HE}IIHDuKlmEHEC`DCTIAGfA1fAGh9Lº9OºfAGl9Lº9OºfAG p9Lº9OºfAG tIG9Lº9ODfAGtMHsXnDCTMHE1GffVEWAfAAfDMLMEUHUt7D0D0LGBWE#D 9sLuAAAfF$WfAHL9u D9ZCI|LspClM,M9tWHxL}I@IH1HAMtLHLZIMM9uL}HxHEHtO~h~pfpf~f~fp)HMAl)HMA LHǃMtHՉI9F(XHt\ML8LLuHHI?ffwHHt HeH9P(tL^E1}uMLeLmLuH(HEdH+%( LH]L}IDH}LeLmLuH@ L;8txHEH@ L;8fff.LeLmLuE1[@Lq AFM>E;EMEuLIIHIEnHEEE1HEMn HtI9t H"EM}AEEM~MAFMKlHEHHEHoHMHH9A(LLeLmLuIHEE1fDDFDA9rA?wD1DExHHEHHgxDmDEAtDE1MDEMLuDEE1HELxMIA]AfDLE9seA;vlsEIFpJ<?IIL9euDELxDLA@EaH1fH눋ELE1QLeLmLu0 LeLmLuzf.UHSHHHGHGHHCHH]%UHATISHHHǃMtdI9tL[A\]ff.tH1u8t,wZHt%HOZHEf.H$HHGfHHDÐH1%-HH/* * Copyright (C) 2026 Behdad Esfahbod * * This is part of HarfBuzz, a text shaping library. * * Permission is hereby granted, without written agreement and without * license or royalty fees, to use, copy, modify, and distribute this * software and its documentation for any purpose, provided that the * above copyright notice and the following two paragraphs appear in * all copies of this software. * * IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN * IF THE COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH * DAMAGE. * * THE COPYRIGHT HOLDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND * FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS * ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. */ /* Requires Metal Shading Language 2.0. */ /* Dilate a glyph vertex by half a pixel on screen. * * position: object-space vertex position (modified in place) * texcoord: em-space sample coordinates (modified in place) * normal: object-space outward normal at this vertex * jac: inverse of the 2x2 linear part of the em-to-object transform, * stored row-major as (j00, j01, j10, j11). Maps object-space * displacements back to em-space for texcoord adjustment. * For simple scaling with y-flip (the common case): * em-to-object = [[s, 0], [0, -s]] * jac = (1/s, 0, 0, -1/s) * m: model-view-projection matrix * viewport: viewport size in pixels */ void hb_gpu_dilate (thread float2& position, thread float2& texcoord, float2 normal, float4 jac, float4x4 m, float2 viewport) { float2 n = normalize (normal); float4 clipPos = m * float4 (position, 0.0, 1.0); float4 clipN = m * float4 (n, 0.0, 0.0); float s = clipPos.w; float t = clipN.w; float u = (s * clipN.x - t * clipPos.x) * viewport.x; float v = (s * clipN.y - t * clipPos.y) * viewport.y; float s2 = s * s; float st = s * t; float uv = u * u + v * v; float denom = uv - st * st; float d = abs (denom) > 1.0 / 16777216.0 ? s2 * (st + sqrt (uv)) / denom : 0.0; float2 dPos = d * normal; position += dPos; texcoord += float2 (dot (dPos, jac.xy), dot (dPos, jac.zw)); } /* * Copyright (C) 2026 Behdad Esfahbod * Copyright (C) 2017 Eric Lengyel * * The _hb_gpu_slug body below is based on the Slug algorithm by * Eric Lengyel: https://github.com/EricLengyel/Slug * * This is part of HarfBuzz, a text shaping library. * * Permission is hereby granted, without written agreement and without * license or royalty fees, to use, copy, modify, and distribute this * software and its documentation for any purpose, provided that the * above copyright notice and the following two paragraphs appear in * all copies of this software. * * IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN * IF THE COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH * DAMAGE. * * THE COPYRIGHT HOLDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND * FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS * ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. */ /* Shared fragment-shader helpers for the hb-gpu renderers. * * Requires GLSL 3.30 or GLSL ES 3.00. * * For GLSL ES 3.00 / WebGL2, define HB_GPU_ATLAS_2D before * including this source. The atlas is then a 2D isampler2D * texture of known width (set via hb_gpu_atlas_width uniform) * instead of an isamplerBuffer. * * Exports: * hb_gpu_fetch (offset) atlas lookup * _hb_gpu_slug (rc, pixelsPerEm, glyphLoc) MSAA-aware Slug * coverage (caller supplies * pixelsPerEm so it can be * invoked from non-uniform * control flow) * hb_gpu_ppem (rc, glyphLoc) pixels per em at fragment * _hb_gpu_curve_counts (rc, glyphLoc) debug: per-pixel curve counts * hb_gpu_stem_darken (cov, brightness, ppem) thin-stroke contrast * correction */ #ifndef HB_GPU_UNITS_PER_EM #define HB_GPU_UNITS_PER_EM 4 #endif #define HB_GPU_INV_UNITS float(1.0 / float(HB_GPU_UNITS_PER_EM)) #ifdef HB_GPU_ATLAS_2D uniform highp isampler2D hb_gpu_atlas; uniform int hb_gpu_atlas_width; ivec4 hb_gpu_fetch (int offset) { return texelFetch (hb_gpu_atlas, ivec2 (offset % hb_gpu_atlas_width, offset / hb_gpu_atlas_width), 0); } #else uniform isamplerBuffer hb_gpu_atlas; ivec4 hb_gpu_fetch (int offset) { return texelFetch (hb_gpu_atlas, offset); } #endif uint _hb_gpu_calc_root_code (float y1, float y2, float y3) { uint i1 = floatBitsToUint (y1) >> 31U; uint i2 = floatBitsToUint (y2) >> 30U; uint i3 = floatBitsToUint (y3) >> 29U; uint shift = (i2 & 2U) | (i1 & ~2U); shift = (i3 & 4U) | (shift & ~4U); return (0x2E74U >> shift) & 0x0101U; } vec2 _hb_gpu_solve_horiz_poly (vec2 a, vec2 b, vec2 p1) { float ra = 1.0 / a.y; float rb = 0.5 / b.y; float d = sqrt (max (b.y * b.y - a.y * p1.y, 0.0)); float t1 = (b.y - d) * ra; float t2 = (b.y + d) * ra; if (a.y == 0.0) t1 = t2 = p1.y * rb; return vec2 ((a.x * t1 - b.x * 2.0) * t1 + p1.x, (a.x * t2 - b.x * 2.0) * t2 + p1.x); } vec2 _hb_gpu_solve_vert_poly (vec2 a, vec2 b, vec2 p1) { float ra = 1.0 / a.x; float rb = 0.5 / b.x; float d = sqrt (max (b.x * b.x - a.x * p1.x, 0.0)); float t1 = (b.x - d) * ra; float t2 = (b.x + d) * ra; if (a.x == 0.0) t1 = t2 = p1.x * rb; return vec2 ((a.y * t1 - b.y * 2.0) * t1 + p1.y, (a.y * t2 - b.y * 2.0) * t2 + p1.y); } float _hb_gpu_calc_coverage (float xcov, float ycov, float xwgt, float ywgt) { float coverage = max (abs (xcov * xwgt + ycov * ywgt) / max (xwgt + ywgt, 1.0 / 65536.0), min (abs (xcov), abs (ycov))); return clamp (coverage, 0.0, 1.0); } /* Decoded glyph band info for a pixel position. */ struct _hb_gpu_glyph_info { int glyphLoc; int bandBase; ivec2 bandIndex; int numHBands; int numVBands; vec2 scale; }; _hb_gpu_glyph_info _hb_gpu_decode_glyph (vec2 renderCoord, uint glyphLoc_) { _hb_gpu_glyph_info gi; gi.glyphLoc = int (glyphLoc_); ivec4 header0 = hb_gpu_fetch (gi.glyphLoc); ivec4 header1 = hb_gpu_fetch (gi.glyphLoc + 1); vec4 ext = vec4 (header0) * HB_GPU_INV_UNITS; gi.numHBands = header1.r; gi.numVBands = header1.g; gi.scale = vec2 (float (header1.b), float (header1.a)); vec2 extSize = ext.zw - ext.xy; vec2 bandScale = vec2 (float (gi.numVBands), float (gi.numHBands)) / max (extSize, vec2 (1.0 / 65536.0)); vec2 bandOffset = -ext.xy * bandScale; gi.bandIndex = clamp (ivec2 (renderCoord * bandScale + bandOffset), ivec2 (0, 0), ivec2 (gi.numVBands - 1, gi.numHBands - 1)); gi.bandBase = gi.glyphLoc + 2; return gi; } /* Return pixels per em at this fragment. */ float hb_gpu_ppem (vec2 renderCoord, uint glyphLoc_) { _hb_gpu_glyph_info gi = _hb_gpu_decode_glyph (renderCoord, glyphLoc_); vec2 emsPerPixel = fwidth (renderCoord); return min (gi.scale.x, gi.scale.y) / max (emsPerPixel.x, emsPerPixel.y); } /* Return per-pixel curve counts: (horizontal, vertical). */ ivec2 _hb_gpu_curve_counts (vec2 renderCoord, uint glyphLoc_) { _hb_gpu_glyph_info gi = _hb_gpu_decode_glyph (renderCoord, glyphLoc_); int hCount = hb_gpu_fetch (gi.bandBase + gi.bandIndex.y).r; int vCount = hb_gpu_fetch (gi.bandBase + gi.numHBands + gi.bandIndex.x).r; return ivec2 (hCount, vCount); } /* Single-sample coverage in [0, 1]. */ float _hb_gpu_slug_single (vec2 renderCoord, vec2 pixelsPerEm, uint glyphLoc_) { _hb_gpu_glyph_info gi = _hb_gpu_decode_glyph (renderCoord, glyphLoc_); int glyphLoc = gi.glyphLoc; int bandBase = gi.bandBase; int numHBands = gi.numHBands; float xcov = 0.0; float xwgt = 0.0; ivec4 hbandData = hb_gpu_fetch (bandBase + gi.bandIndex.y); int hCurveCount = hbandData.r; /* Symmetric: choose rightward (desc) or leftward (asc) sort */ float hSplit = float (hbandData.a) * HB_GPU_INV_UNITS; bool hLeftRay = (renderCoord.x < hSplit); int hDataOffset = (hLeftRay ? hbandData.b : hbandData.g) + 32768; for (int ci = 0; ci < hCurveCount; ci++) { int curveOffset = hb_gpu_fetch (glyphLoc + hDataOffset + ci).r + 32768; ivec4 raw12 = hb_gpu_fetch (glyphLoc + curveOffset); ivec4 raw3 = hb_gpu_fetch (glyphLoc + curveOffset + 1); vec4 q12 = vec4 (raw12) * HB_GPU_INV_UNITS; vec2 q3 = vec2 (raw3.rg) * HB_GPU_INV_UNITS; vec4 p12 = q12 - vec4 (renderCoord, renderCoord); vec2 p3 = q3 - renderCoord; if (hLeftRay) { if (min (min (p12.x, p12.z), p3.x) * pixelsPerEm.x > 0.5) break; } else { if (max (max (p12.x, p12.z), p3.x) * pixelsPerEm.x < -0.5) break; } uint code = _hb_gpu_calc_root_code (p12.y, p12.w, p3.y); if (code != 0U) { vec2 a = q12.xy - q12.zw * 2.0 + q3; vec2 b = q12.xy - q12.zw; vec2 r = _hb_gpu_solve_horiz_poly (a, b, p12.xy) * pixelsPerEm.x; /* For leftward ray: saturate(0.5 - r) counts coverage from the left */ vec2 cov = hLeftRay ? clamp (vec2 (0.5) - r, 0.0, 1.0) : clamp (r + vec2 (0.5), 0.0, 1.0); if ((code & 1U) != 0U) { xcov += cov.x; xwgt = max (xwgt, clamp (1.0 - abs (r.x) * 2.0, 0.0, 1.0)); } if (code > 1U) { xcov -= cov.y; xwgt = max (xwgt, clamp (1.0 - abs (r.y) * 2.0, 0.0, 1.0)); } } } /* Crossings over a closed contour sum to zero, so a leftward ray * returns the negative of what a rightward ray would; flip it back * so that xcov and ycov keep a common sign convention. */ if (hLeftRay) xcov = -xcov; float ycov = 0.0; float ywgt = 0.0; ivec4 vbandData = hb_gpu_fetch (bandBase + numHBands + gi.bandIndex.x); int vCurveCount = vbandData.r; float vSplit = float (vbandData.a) * HB_GPU_INV_UNITS; bool vLeftRay = (renderCoord.y < vSplit); int vDataOffset = (vLeftRay ? vbandData.b : vbandData.g) + 32768; for (int ci = 0; ci < vCurveCount; ci++) { int curveOffset = hb_gpu_fetch (glyphLoc + vDataOffset + ci).r + 32768; ivec4 raw12 = hb_gpu_fetch (glyphLoc + curveOffset); ivec4 raw3 = hb_gpu_fetch (glyphLoc + curveOffset + 1); vec4 q12 = vec4 (raw12) * HB_GPU_INV_UNITS; vec2 q3 = vec2 (raw3.rg) * HB_GPU_INV_UNITS; vec4 p12 = q12 - vec4 (renderCoord, renderCoord); vec2 p3 = q3 - renderCoord; if (vLeftRay) { if (min (min (p12.y, p12.w), p3.y) * pixelsPerEm.y > 0.5) break; } else { if (max (max (p12.y, p12.w), p3.y) * pixelsPerEm.y < -0.5) break; } uint code = _hb_gpu_calc_root_code (p12.x, p12.z, p3.x); if (code != 0U) { vec2 a = q12.xy - q12.zw * 2.0 + q3; vec2 b = q12.xy - q12.zw; vec2 r = _hb_gpu_solve_vert_poly (a, b, p12.xy) * pixelsPerEm.y; vec2 cov = vLeftRay ? clamp (vec2 (0.5) - r, 0.0, 1.0) : clamp (r + vec2 (0.5), 0.0, 1.0); if ((code & 1U) != 0U) { ycov -= cov.x; ywgt = max (ywgt, clamp (1.0 - abs (r.x) * 2.0, 0.0, 1.0)); } if (code > 1U) { ycov += cov.y; ywgt = max (ywgt, clamp (1.0 - abs (r.y) * 2.0, 0.0, 1.0)); } } } /* Ditto, for the vertical ray. */ if (vLeftRay) ycov = -ycov; return _hb_gpu_calc_coverage (xcov, ycov, xwgt, ywgt); } /* MSAA-aware Slug coverage. Caller supplies pixelsPerEm so this * function can be invoked from non-uniform control flow (for * example inside an op-stream branch in hb-gpu-paint-fragment.wgsl, * where WGSL would otherwise reject an fwidth call). */ float _hb_gpu_slug (vec2 renderCoord, vec2 pixelsPerEm, uint glyphLoc_) { float c = _hb_gpu_slug_single (renderCoord, pixelsPerEm, glyphLoc_); #ifndef HB_GPU_NO_MSAA float ppem = hb_gpu_ppem (renderCoord, glyphLoc_); if (ppem < 16.0) { vec2 emsPerPixel = 1.0 / pixelsPerEm; vec2 d = emsPerPixel * (1.0 / 3.0); float msaa = 0.25 * (_hb_gpu_slug_single (renderCoord + vec2 (-d.x, -d.y), pixelsPerEm, glyphLoc_) + _hb_gpu_slug_single (renderCoord + vec2 ( d.x, -d.y), pixelsPerEm, glyphLoc_) + _hb_gpu_slug_single (renderCoord + vec2 (-d.x, d.y), pixelsPerEm, glyphLoc_) + _hb_gpu_slug_single (renderCoord + vec2 ( d.x, d.y), pixelsPerEm, glyphLoc_)); c = mix (c, msaa, smoothstep (16.0, 8.0, ppem)); } #endif return c; } /* Stem darkening for small sizes. * * coverage: output of hb_gpu_draw / _hb_gpu_slug * brightness: foreground brightness in [0, 1] * ppem: pixels per em at this fragment */ float hb_gpu_stem_darken (float coverage, float brightness, float ppem) { return pow (coverage, mix (pow (2.0, brightness - 0.5), 1.0, smoothstep (8.0, 48.0, ppem))); } /* * Copyright (C) 2026 Behdad Esfahbod * * This is part of HarfBuzz, a text shaping library. * * Permission is hereby granted, without written agreement and without * license or royalty fees, to use, copy, modify, and distribute this * software and its documentation for any purpose, provided that the * above copyright notice and the following two paragraphs appear in * all copies of this software. * * IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN * IF THE COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH * DAMAGE. * * THE COPYRIGHT HOLDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND * FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS * ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. */ /* Shared fragment-shader helpers for the hb-gpu renderers. * * Requires Metal Shading Language 2.0. */ #ifndef HB_GPU_UNITS_PER_EM #define HB_GPU_UNITS_PER_EM 4 #endif #define HB_GPU_INV_UNITS float(1.0 / float(HB_GPU_UNITS_PER_EM)) int4 hb_gpu_fetch (device const short4* hb_gpu_atlas, int offset) { return int4 (hb_gpu_atlas[offset]); } uint _hb_gpu_calc_root_code (float y1, float y2, float y3) { uint i1 = as_type (y1) >> 31U; uint i2 = as_type (y2) >> 30U; uint i3 = as_type (y3) >> 29U; uint shift = (i2 & 2U) | (i1 & ~2U); shift = (i3 & 4U) | (shift & ~4U); return (0x2E74U >> shift) & 0x0101U; } float2 _hb_gpu_solve_horiz_poly (float2 a, float2 b, float2 p1) { float ra = 1.0 / a.y; float rb = 0.5 / b.y; float d = sqrt (max (b.y * b.y - a.y * p1.y, 0.0)); float t1 = (b.y - d) * ra; float t2 = (b.y + d) * ra; if (a.y == 0.0) t1 = t2 = p1.y * rb; return float2 ((a.x * t1 - b.x * 2.0) * t1 + p1.x, (a.x * t2 - b.x * 2.0) * t2 + p1.x); } float2 _hb_gpu_solve_vert_poly (float2 a, float2 b, float2 p1) { float ra = 1.0 / a.x; float rb = 0.5 / b.x; float d = sqrt (max (b.x * b.x - a.x * p1.x, 0.0)); float t1 = (b.x - d) * ra; float t2 = (b.x + d) * ra; if (a.x == 0.0) t1 = t2 = p1.x * rb; return float2 ((a.y * t1 - b.y * 2.0) * t1 + p1.y, (a.y * t2 - b.y * 2.0) * t2 + p1.y); } float _hb_gpu_calc_coverage (float xcov, float ycov, float xwgt, float ywgt) { float coverage = max (abs (xcov * xwgt + ycov * ywgt) / max (xwgt + ywgt, 1.0 / 65536.0), min (abs (xcov), abs (ycov))); return clamp (coverage, 0.0, 1.0); } /* Decoded glyph band info for a pixel position. */ struct _hb_gpu_glyph_info { int glyphLoc; int bandBase; int2 bandIndex; int numHBands; int numVBands; float2 scale; }; _hb_gpu_glyph_info _hb_gpu_decode_glyph (float2 renderCoord, uint glyphLoc_, device const short4* hb_gpu_atlas) { _hb_gpu_glyph_info gi; gi.glyphLoc = int (glyphLoc_); int4 header0 = hb_gpu_fetch (hb_gpu_atlas, gi.glyphLoc); int4 header1 = hb_gpu_fetch (hb_gpu_atlas, gi.glyphLoc + 1); float4 ext = float4 (header0) * HB_GPU_INV_UNITS; gi.numHBands = header1.r; gi.numVBands = header1.g; gi.scale = float2 (float (header1.b), float (header1.a)); float2 extSize = ext.zw - ext.xy; float2 bandScale = float2 (float (gi.numVBands), float (gi.numHBands)) / max (extSize, float2 (1.0 / 65536.0)); float2 bandOffset = -ext.xy * bandScale; gi.bandIndex = clamp (int2 (renderCoord * bandScale + bandOffset), int2 (0, 0), int2 (gi.numVBands - 1, gi.numHBands - 1)); gi.bandBase = gi.glyphLoc + 2; return gi; } /* Return pixels per em at this fragment. * * renderCoord: em-space sample position * glyphLoc: texel offset of glyph blob in atlas */ float hb_gpu_ppem (float2 renderCoord, uint glyphLoc_, device const short4* hb_gpu_atlas) { _hb_gpu_glyph_info gi = _hb_gpu_decode_glyph (renderCoord, glyphLoc_, hb_gpu_atlas); float2 emsPerPixel = fwidth (renderCoord); return min (gi.scale.x, gi.scale.y) / max (emsPerPixel.x, emsPerPixel.y); } /* Return per-pixel curve counts: (horizontal, vertical). */ int2 _hb_gpu_curve_counts (float2 renderCoord, uint glyphLoc_, device const short4* hb_gpu_atlas) { _hb_gpu_glyph_info gi = _hb_gpu_decode_glyph (renderCoord, glyphLoc_, hb_gpu_atlas); int hCount = hb_gpu_fetch (hb_gpu_atlas, gi.bandBase + gi.bandIndex.y).r; int vCount = hb_gpu_fetch (hb_gpu_atlas, gi.bandBase + gi.numHBands + gi.bandIndex.x).r; return int2 (hCount, vCount); } /* Single-sample coverage in [0, 1]. */ float _hb_gpu_slug_single (float2 renderCoord, float2 pixelsPerEm, uint glyphLoc_, device const short4* hb_gpu_atlas) { _hb_gpu_glyph_info gi = _hb_gpu_decode_glyph (renderCoord, glyphLoc_, hb_gpu_atlas); int glyphLoc = gi.glyphLoc; int bandBase = gi.bandBase; int numHBands = gi.numHBands; float xcov = 0.0; float xwgt = 0.0; int4 hbandData = hb_gpu_fetch (hb_gpu_atlas, bandBase + gi.bandIndex.y); int hCurveCount = hbandData.r; /* Symmetric: choose rightward (desc) or leftward (asc) sort */ float hSplit = float (hbandData.a) * HB_GPU_INV_UNITS; bool hLeftRay = (renderCoord.x < hSplit); int hDataOffset = (hLeftRay ? hbandData.b : hbandData.g) + 32768; for (int ci = 0; ci < hCurveCount; ci++) { int curveOffset = hb_gpu_fetch (hb_gpu_atlas, glyphLoc + hDataOffset + ci).r + 32768; int4 raw12 = hb_gpu_fetch (hb_gpu_atlas, glyphLoc + curveOffset); int4 raw3 = hb_gpu_fetch (hb_gpu_atlas, glyphLoc + curveOffset + 1); float4 q12 = float4 (raw12) * HB_GPU_INV_UNITS; float2 q3 = float2 (raw3.rg) * HB_GPU_INV_UNITS; float4 p12 = q12 - float4 (renderCoord, renderCoord); float2 p3 = q3 - renderCoord; if (hLeftRay) { if (min (min (p12.x, p12.z), p3.x) * pixelsPerEm.x > 0.5) break; } else { if (max (max (p12.x, p12.z), p3.x) * pixelsPerEm.x < -0.5) break; } uint code = _hb_gpu_calc_root_code (p12.y, p12.w, p3.y); if (code != 0U) { float2 a = q12.xy - q12.zw * 2.0 + q3; float2 b = q12.xy - q12.zw; float2 r = _hb_gpu_solve_horiz_poly (a, b, p12.xy) * pixelsPerEm.x; /* For leftward ray: saturate(0.5 - r) counts coverage from the left */ float2 cov = hLeftRay ? clamp (float2 (0.5) - r, 0.0, 1.0) : clamp (r + float2 (0.5), 0.0, 1.0); if ((code & 1U) != 0U) { xcov += cov.x; xwgt = max (xwgt, clamp (1.0 - abs (r.x) * 2.0, 0.0, 1.0)); } if (code > 1U) { xcov -= cov.y; xwgt = max (xwgt, clamp (1.0 - abs (r.y) * 2.0, 0.0, 1.0)); } } } /* Crossings over a closed contour sum to zero, so a leftward ray * returns the negative of what a rightward ray would; flip it back * so that xcov and ycov keep a common sign convention. */ if (hLeftRay) xcov = -xcov; float ycov = 0.0; float ywgt = 0.0; int4 vbandData = hb_gpu_fetch (hb_gpu_atlas, bandBase + numHBands + gi.bandIndex.x); int vCurveCount = vbandData.r; float vSplit = float (vbandData.a) * HB_GPU_INV_UNITS; bool vLeftRay = (renderCoord.y < vSplit); int vDataOffset = (vLeftRay ? vbandData.b : vbandData.g) + 32768; for (int ci = 0; ci < vCurveCount; ci++) { int curveOffset = hb_gpu_fetch (hb_gpu_atlas, glyphLoc + vDataOffset + ci).r + 32768; int4 raw12 = hb_gpu_fetch (hb_gpu_atlas, glyphLoc + curveOffset); int4 raw3 = hb_gpu_fetch (hb_gpu_atlas, glyphLoc + curveOffset + 1); float4 q12 = float4 (raw12) * HB_GPU_INV_UNITS; float2 q3 = float2 (raw3.rg) * HB_GPU_INV_UNITS; float4 p12 = q12 - float4 (renderCoord, renderCoord); float2 p3 = q3 - renderCoord; if (vLeftRay) { if (min (min (p12.y, p12.w), p3.y) * pixelsPerEm.y > 0.5) break; } else { if (max (max (p12.y, p12.w), p3.y) * pixelsPerEm.y < -0.5) break; } uint code = _hb_gpu_calc_root_code (p12.x, p12.z, p3.x); if (code != 0U) { float2 a = q12.xy - q12.zw * 2.0 + q3; float2 b = q12.xy - q12.zw; float2 r = _hb_gpu_solve_vert_poly (a, b, p12.xy) * pixelsPerEm.y; float2 cov = vLeftRay ? clamp (float2 (0.5) - r, 0.0, 1.0) : clamp (r + float2 (0.5), 0.0, 1.0); if ((code & 1U) != 0U) { ycov -= cov.x; ywgt = max (ywgt, clamp (1.0 - abs (r.x) * 2.0, 0.0, 1.0)); } if (code > 1U) { ycov += cov.y; ywgt = max (ywgt, clamp (1.0 - abs (r.y) * 2.0, 0.0, 1.0)); } } } /* Ditto, for the vertical ray. */ if (vLeftRay) ycov = -ycov; return _hb_gpu_calc_coverage (xcov, ycov, xwgt, ywgt); } /* Return coverage in [0, 1]. * * renderCoord: em-space sample position * glyphLoc: texel offset of glyph blob in atlas * hb_gpu_atlas: device pointer to the atlas buffer */ /* The MSAA-aware implementation. Caller supplies pixelsPerEm so * this function can be invoked from non-uniform control flow (for * example from a paint op-stream branch where a recomputed fwidth * would be rejected by strict derivative-uniformity rules). */ float _hb_gpu_slug (float2 renderCoord, float2 pixelsPerEm, uint glyphLoc_, device const short4* hb_gpu_atlas) { float c = _hb_gpu_slug_single (renderCoord, pixelsPerEm, glyphLoc_, hb_gpu_atlas); #ifndef HB_GPU_NO_MSAA float ppem = hb_gpu_ppem (renderCoord, glyphLoc_, hb_gpu_atlas); if (ppem < 16.0) { float2 emsPerPixel = 1.0 / pixelsPerEm; float2 d = emsPerPixel * (1.0 / 3.0); float msaa = 0.25 * (_hb_gpu_slug_single (renderCoord + float2 (-d.x, -d.y), pixelsPerEm, glyphLoc_, hb_gpu_atlas) + _hb_gpu_slug_single (renderCoord + float2 ( d.x, -d.y), pixelsPerEm, glyphLoc_, hb_gpu_atlas) + _hb_gpu_slug_single (renderCoord + float2 (-d.x, d.y), pixelsPerEm, glyphLoc_, hb_gpu_atlas) + _hb_gpu_slug_single (renderCoord + float2 ( d.x, d.y), pixelsPerEm, glyphLoc_, hb_gpu_atlas)); c = mix (c, msaa, smoothstep (16.0, 8.0, ppem)); } #endif return c; } /* Stem darkening for small sizes. * * coverage: output of hb_gpu_draw * brightness: foreground brightness in [0, 1] * ppem: pixels per em at this fragment */ float hb_gpu_stem_darken (float coverage, float brightness, float ppem) { return pow (coverage, mix (pow (2.0, brightness - 0.5), 1.0, smoothstep (8.0, 48.0, ppem))); } /* * Copyright (C) 2026 Behdad Esfahbod * * This is part of HarfBuzz, a text shaping library. * * Permission is hereby granted, without written agreement and without * license or royalty fees, to use, copy, modify, and distribute this * software and its documentation for any purpose, provided that the * above copyright notice and the following two paragraphs appear in * all copies of this software. * * IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN * IF THE COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH * DAMAGE. * * THE COPYRIGHT HOLDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND * FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS * ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. */ /* Shared fragment-shader helpers for the hb-gpu renderers. * * Requires WGSL (WebGPU Shading Language). */ const HB_GPU_UNITS_PER_EM: f32 = 4.0; const HB_GPU_INV_UNITS: f32 = 1.0 / 4.0; fn hb_gpu_fetch (hb_gpu_atlas: ptr>, read>, offset: i32) -> vec4 { return (*hb_gpu_atlas)[offset]; } fn _hb_gpu_calc_root_code (y1: f32, y2: f32, y3: f32) -> u32 { let i1 = bitcast (y1) >> 31u; let i2 = bitcast (y2) >> 30u; let i3 = bitcast (y3) >> 29u; var shift = (i2 & 2u) | (i1 & ~2u); shift = (i3 & 4u) | (shift & ~4u); return (0x2E74u >> shift) & 0x0101u; } fn _hb_gpu_solve_horiz_poly (a: vec2f, b: vec2f, p1: vec2f) -> vec2f { let ra = 1.0 / a.y; let rb = 0.5 / b.y; let d = sqrt (max (b.y * b.y - a.y * p1.y, 0.0)); var t1 = (b.y - d) * ra; var t2 = (b.y + d) * ra; if (a.y == 0.0) { t1 = p1.y * rb; t2 = t1; } return vec2f ((a.x * t1 - b.x * 2.0) * t1 + p1.x, (a.x * t2 - b.x * 2.0) * t2 + p1.x); } fn _hb_gpu_solve_vert_poly (a: vec2f, b: vec2f, p1: vec2f) -> vec2f { let ra = 1.0 / a.x; let rb = 0.5 / b.x; let d = sqrt (max (b.x * b.x - a.x * p1.x, 0.0)); var t1 = (b.x - d) * ra; var t2 = (b.x + d) * ra; if (a.x == 0.0) { t1 = p1.x * rb; t2 = t1; } return vec2f ((a.y * t1 - b.y * 2.0) * t1 + p1.y, (a.y * t2 - b.y * 2.0) * t2 + p1.y); } fn _hb_gpu_calc_coverage (xcov: f32, ycov: f32, xwgt: f32, ywgt: f32) -> f32 { let coverage = max (abs (xcov * xwgt + ycov * ywgt) / max (xwgt + ywgt, 1.0 / 65536.0), min (abs (xcov), abs (ycov))); return clamp (coverage, 0.0, 1.0); } /* Decoded glyph band info for a pixel position. */ struct _hb_gpu_glyph_info { glyphLoc: i32, bandBase: i32, bandIndex: vec2, numHBands: i32, numVBands: i32, scale: vec2f, } fn _hb_gpu_decode_glyph (renderCoord: vec2f, glyphLoc_: u32, hb_gpu_atlas: ptr>, read>) -> _hb_gpu_glyph_info { var gi: _hb_gpu_glyph_info; gi.glyphLoc = i32 (glyphLoc_); let header0 = hb_gpu_fetch (hb_gpu_atlas, gi.glyphLoc); let header1 = hb_gpu_fetch (hb_gpu_atlas, gi.glyphLoc + 1); let ext = vec4f (header0) * HB_GPU_INV_UNITS; gi.numHBands = header1.r; gi.numVBands = header1.g; gi.scale = vec2f (f32 (header1.b), f32 (header1.a)); let extSize = ext.zw - ext.xy; let bandScale = vec2f (f32 (gi.numVBands), f32 (gi.numHBands)) / max (extSize, vec2f (1.0 / 65536.0)); let bandOffset = -ext.xy * bandScale; gi.bandIndex = clamp (vec2 (renderCoord * bandScale + bandOffset), vec2 (0, 0), vec2 (gi.numVBands - 1, gi.numHBands - 1)); gi.bandBase = gi.glyphLoc + 2; return gi; } /* Return pixels per em at this fragment. * * renderCoord: em-space sample position * glyphLoc: texel offset of glyph blob in atlas */ fn hb_gpu_ppem (renderCoord: vec2f, glyphLoc_: u32, hb_gpu_atlas: ptr>, read>) -> f32 { let gi = _hb_gpu_decode_glyph (renderCoord, glyphLoc_, hb_gpu_atlas); let emsPerPixel = fwidth (renderCoord); return min (gi.scale.x, gi.scale.y) / max (emsPerPixel.x, emsPerPixel.y); } /* Return per-pixel curve counts: (horizontal, vertical). */ fn _hb_gpu_curve_counts (renderCoord: vec2f, glyphLoc_: u32, hb_gpu_atlas: ptr>, read>) -> vec2 { let gi = _hb_gpu_decode_glyph (renderCoord, glyphLoc_, hb_gpu_atlas); let hCount = hb_gpu_fetch (hb_gpu_atlas, gi.bandBase + gi.bandIndex.y).r; let vCount = hb_gpu_fetch (hb_gpu_atlas, gi.bandBase + gi.numHBands + gi.bandIndex.x).r; return vec2 (hCount, vCount); } /* Single-sample coverage in [0, 1]. */ fn _hb_gpu_slug_single (renderCoord: vec2f, pixelsPerEm: vec2f, glyphLoc_: u32, hb_gpu_atlas: ptr>, read>) -> f32 { let gi = _hb_gpu_decode_glyph (renderCoord, glyphLoc_, hb_gpu_atlas); let glyphLoc = gi.glyphLoc; let bandBase = gi.bandBase; let numHBands = gi.numHBands; var xcov: f32 = 0.0; var xwgt: f32 = 0.0; let hbandData = hb_gpu_fetch (hb_gpu_atlas, bandBase + gi.bandIndex.y); let hCurveCount = hbandData.r; /* Symmetric: choose rightward (desc) or leftward (asc) sort */ let hSplit = f32 (hbandData.a) * HB_GPU_INV_UNITS; let hLeftRay = (renderCoord.x < hSplit); var hDataOffset: i32; if (hLeftRay) { hDataOffset = hbandData.b + 32768; } else { hDataOffset = hbandData.g + 32768; } for (var ci: i32 = 0; ci < hCurveCount; ci++) { let curveOffset = hb_gpu_fetch (hb_gpu_atlas, glyphLoc + hDataOffset + ci).r + 32768; let raw12 = hb_gpu_fetch (hb_gpu_atlas, glyphLoc + curveOffset); let raw3 = hb_gpu_fetch (hb_gpu_atlas, glyphLoc + curveOffset + 1); let q12 = vec4f (raw12) * HB_GPU_INV_UNITS; let q3 = vec2f (vec2 (raw3.r, raw3.g)) * HB_GPU_INV_UNITS; let p12 = q12 - vec4f (renderCoord, renderCoord); let p3 = q3 - renderCoord; if (hLeftRay) { if (min (min (p12.x, p12.z), p3.x) * pixelsPerEm.x > 0.5) { break; } } else { if (max (max (p12.x, p12.z), p3.x) * pixelsPerEm.x < -0.5) { break; } } let code = _hb_gpu_calc_root_code (p12.y, p12.w, p3.y); if (code != 0u) { let a = q12.xy - q12.zw * 2.0 + q3; let b = q12.xy - q12.zw; let r = _hb_gpu_solve_horiz_poly (a, b, p12.xy) * pixelsPerEm.x; /* For leftward ray: saturate(0.5 - r) counts coverage from the left */ var cov: vec2f; if (hLeftRay) { cov = clamp (vec2f (0.5) - r, vec2f (0.0), vec2f (1.0)); } else { cov = clamp (r + vec2f (0.5), vec2f (0.0), vec2f (1.0)); } if ((code & 1u) != 0u) { xcov += cov.x; xwgt = max (xwgt, clamp (1.0 - abs (r.x) * 2.0, 0.0, 1.0)); } if (code > 1u) { xcov -= cov.y; xwgt = max (xwgt, clamp (1.0 - abs (r.y) * 2.0, 0.0, 1.0)); } } } /* Crossings over a closed contour sum to zero, so a leftward ray * returns the negative of what a rightward ray would; flip it back * so that xcov and ycov keep a common sign convention. */ if (hLeftRay) { xcov = -xcov; } var ycov: f32 = 0.0; var ywgt: f32 = 0.0; let vbandData = hb_gpu_fetch (hb_gpu_atlas, bandBase + numHBands + gi.bandIndex.x); let vCurveCount = vbandData.r; let vSplit = f32 (vbandData.a) * HB_GPU_INV_UNITS; let vLeftRay = (renderCoord.y < vSplit); var vDataOffset: i32; if (vLeftRay) { vDataOffset = vbandData.b + 32768; } else { vDataOffset = vbandData.g + 32768; } for (var ci: i32 = 0; ci < vCurveCount; ci++) { let curveOffset = hb_gpu_fetch (hb_gpu_atlas, glyphLoc + vDataOffset + ci).r + 32768; let raw12 = hb_gpu_fetch (hb_gpu_atlas, glyphLoc + curveOffset); let raw3 = hb_gpu_fetch (hb_gpu_atlas, glyphLoc + curveOffset + 1); let q12 = vec4f (raw12) * HB_GPU_INV_UNITS; let q3 = vec2f (vec2 (raw3.r, raw3.g)) * HB_GPU_INV_UNITS; let p12 = q12 - vec4f (renderCoord, renderCoord); let p3 = q3 - renderCoord; if (vLeftRay) { if (min (min (p12.y, p12.w), p3.y) * pixelsPerEm.y > 0.5) { break; } } else { if (max (max (p12.y, p12.w), p3.y) * pixelsPerEm.y < -0.5) { break; } } let code = _hb_gpu_calc_root_code (p12.x, p12.z, p3.x); if (code != 0u) { let a = q12.xy - q12.zw * 2.0 + q3; let b = q12.xy - q12.zw; let r = _hb_gpu_solve_vert_poly (a, b, p12.xy) * pixelsPerEm.y; var cov: vec2f; if (vLeftRay) { cov = clamp (vec2f (0.5) - r, vec2f (0.0), vec2f (1.0)); } else { cov = clamp (r + vec2f (0.5), vec2f (0.0), vec2f (1.0)); } if ((code & 1u) != 0u) { ycov -= cov.x; ywgt = max (ywgt, clamp (1.0 - abs (r.x) * 2.0, 0.0, 1.0)); } if (code > 1u) { ycov += cov.y; ywgt = max (ywgt, clamp (1.0 - abs (r.y) * 2.0, 0.0, 1.0)); } } } /* Ditto, for the vertical ray. */ if (vLeftRay) { ycov = -ycov; } return _hb_gpu_calc_coverage (xcov, ycov, xwgt, ywgt); } /* Return coverage in [0, 1]. * * renderCoord: em-space sample position * glyphLoc: texel offset of glyph blob in atlas * hb_gpu_atlas: storage buffer pointer to the atlas */ /* The MSAA-aware implementation. Caller supplies pixelsPerEm so * this function can be invoked from non-uniform control flow (for * example inside an op-stream branch in hb-gpu-paint-fragment.wgsl, * where WGSL would otherwise reject an fwidth call). */ fn _hb_gpu_slug (renderCoord: vec2f, pixelsPerEm: vec2f, glyphLoc_: u32, hb_gpu_atlas: ptr>, read>) -> f32 { var c = _hb_gpu_slug_single (renderCoord, pixelsPerEm, glyphLoc_, hb_gpu_atlas); /* Inline ppem from pixelsPerEm so we don't re-enter hb_gpu_ppem * (which would call fwidth again -- rejected by WGSL when this * function is invoked from non-uniform control flow). */ let gi_pp = _hb_gpu_decode_glyph (renderCoord, glyphLoc_, hb_gpu_atlas); let ppem = min (gi_pp.scale.x, gi_pp.scale.y) * min (pixelsPerEm.x, pixelsPerEm.y); if (ppem < 16.0) { let emsPerPixel = 1.0 / pixelsPerEm; let d = emsPerPixel * (1.0 / 3.0); let msaa = 0.25 * (_hb_gpu_slug_single (renderCoord + vec2f (-d.x, -d.y), pixelsPerEm, glyphLoc_, hb_gpu_atlas) + _hb_gpu_slug_single (renderCoord + vec2f ( d.x, -d.y), pixelsPerEm, glyphLoc_, hb_gpu_atlas) + _hb_gpu_slug_single (renderCoord + vec2f (-d.x, d.y), pixelsPerEm, glyphLoc_, hb_gpu_atlas) + _hb_gpu_slug_single (renderCoord + vec2f ( d.x, d.y), pixelsPerEm, glyphLoc_, hb_gpu_atlas)); c = mix (c, msaa, smoothstep (16.0, 8.0, ppem)); } return c; } /* Stem darkening for small sizes. * * coverage: output of hb_gpu_draw * brightness: foreground brightness in [0, 1] * ppem: pixels per em at this fragment */ fn hb_gpu_stem_darken (coverage: f32, brightness: f32, ppem: f32) -> f32 { return pow (coverage, mix (pow (2.0, brightness - 0.5), 1.0, smoothstep (8.0, 48.0, ppem))); } /* * Copyright (C) 2026 Behdad Esfahbod * * This is part of HarfBuzz, a text shaping library. * * Permission is hereby granted, without written agreement and without * license or royalty fees, to use, copy, modify, and distribute this * software and its documentation for any purpose, provided that the * above copyright notice and the following two paragraphs appear in * all copies of this software. * * IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN * IF THE COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH * DAMAGE. * * THE COPYRIGHT HOLDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND * FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS * ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. */ /* Shared fragment-shader helpers for the hb-gpu renderers. * * Requires Shader Model 5.0+. * * The caller must declare: * StructuredBuffer hb_gpu_atlas : register(t0); */ #ifndef HB_GPU_UNITS_PER_EM #define HB_GPU_UNITS_PER_EM 4 #endif #define HB_GPU_INV_UNITS (1.0 / (float) HB_GPU_UNITS_PER_EM) int4 hb_gpu_fetch (int offset) { return hb_gpu_atlas[offset]; } uint _hb_gpu_calc_root_code (float y1, float y2, float y3) { uint i1 = asuint (y1) >> 31u; uint i2 = asuint (y2) >> 30u; uint i3 = asuint (y3) >> 29u; uint shift = (i2 & 2u) | (i1 & ~2u); shift = (i3 & 4u) | (shift & ~4u); return (0x2E74u >> shift) & 0x0101u; } float2 _hb_gpu_solve_horiz_poly (float2 a, float2 b, float2 p1) { float ra = 1.0 / a.y; float rb = 0.5 / b.y; float d = sqrt (max (b.y * b.y - a.y * p1.y, 0.0)); float t1 = (b.y - d) * ra; float t2 = (b.y + d) * ra; if (a.y == 0.0) t1 = t2 = p1.y * rb; return float2 ((a.x * t1 - b.x * 2.0) * t1 + p1.x, (a.x * t2 - b.x * 2.0) * t2 + p1.x); } float2 _hb_gpu_solve_vert_poly (float2 a, float2 b, float2 p1) { float ra = 1.0 / a.x; float rb = 0.5 / b.x; float d = sqrt (max (b.x * b.x - a.x * p1.x, 0.0)); float t1 = (b.x - d) * ra; float t2 = (b.x + d) * ra; if (a.x == 0.0) t1 = t2 = p1.x * rb; return float2 ((a.y * t1 - b.y * 2.0) * t1 + p1.y, (a.y * t2 - b.y * 2.0) * t2 + p1.y); } float _hb_gpu_calc_coverage (float xcov, float ycov, float xwgt, float ywgt) { float coverage = max (abs (xcov * xwgt + ycov * ywgt) / max (xwgt + ywgt, 1.0 / 65536.0), min (abs (xcov), abs (ycov))); return clamp (coverage, 0.0, 1.0); } struct _hb_gpu_glyph_info { int glyphLoc; int bandBase; int2 bandIndex; int numHBands; int numVBands; float2 scale; }; _hb_gpu_glyph_info _hb_gpu_decode_glyph (float2 renderCoord, uint glyphLoc_) { _hb_gpu_glyph_info gi; gi.glyphLoc = (int) glyphLoc_; int4 header0 = hb_gpu_fetch (gi.glyphLoc); int4 header1 = hb_gpu_fetch (gi.glyphLoc + 1); float4 ext = (float4) header0 * HB_GPU_INV_UNITS; gi.numHBands = header1.r; gi.numVBands = header1.g; gi.scale = float2 ((float) header1.b, (float) header1.a); float2 extSize = ext.zw - ext.xy; float2 bandScale = float2 ((float) gi.numVBands, (float) gi.numHBands) / max (extSize, float2 (1.0 / 65536.0, 1.0 / 65536.0)); float2 bandOffset = -ext.xy * bandScale; gi.bandIndex = clamp ((int2) (renderCoord * bandScale + bandOffset), int2 (0, 0), int2 (gi.numVBands - 1, gi.numHBands - 1)); gi.bandBase = gi.glyphLoc + 2; return gi; } /* Return pixels per em at this fragment. * * renderCoord: em-space sample position * glyphLoc: texel offset of glyph blob in atlas */ float hb_gpu_ppem (float2 renderCoord, uint glyphLoc_) { _hb_gpu_glyph_info gi = _hb_gpu_decode_glyph (renderCoord, glyphLoc_); float2 emsPerPixel = fwidth (renderCoord); return min (gi.scale.x, gi.scale.y) / max (emsPerPixel.x, emsPerPixel.y); } int2 _hb_gpu_curve_counts (float2 renderCoord, uint glyphLoc_) { _hb_gpu_glyph_info gi = _hb_gpu_decode_glyph (renderCoord, glyphLoc_); int hCount = hb_gpu_fetch (gi.bandBase + gi.bandIndex.y).r; int vCount = hb_gpu_fetch (gi.bandBase + gi.numHBands + gi.bandIndex.x).r; return int2 (hCount, vCount); } /* Single-sample coverage in [0, 1]. */ float _hb_gpu_slug_single (float2 renderCoord, float2 pixelsPerEm, uint glyphLoc_) { _hb_gpu_glyph_info gi = _hb_gpu_decode_glyph (renderCoord, glyphLoc_); int glyphLoc = gi.glyphLoc; int bandBase = gi.bandBase; int numHBands = gi.numHBands; float xcov = 0.0; float xwgt = 0.0; int4 hbandData = hb_gpu_fetch (bandBase + gi.bandIndex.y); int hCurveCount = hbandData.r; float hSplit = (float) hbandData.a * HB_GPU_INV_UNITS; bool hLeftRay = (renderCoord.x < hSplit); int hDataOffset = (hLeftRay ? hbandData.b : hbandData.g) + 32768; for (int ci = 0; ci < hCurveCount; ci++) { int curveOffset = hb_gpu_fetch (glyphLoc + hDataOffset + ci).r + 32768; int4 raw12 = hb_gpu_fetch (glyphLoc + curveOffset); int4 raw3 = hb_gpu_fetch (glyphLoc + curveOffset + 1); float4 q12 = (float4) raw12 * HB_GPU_INV_UNITS; float2 q3 = (float2) raw3.rg * HB_GPU_INV_UNITS; float4 p12 = q12 - float4 (renderCoord, renderCoord); float2 p3 = q3 - renderCoord; if (hLeftRay) { if (min (min (p12.x, p12.z), p3.x) * pixelsPerEm.x > 0.5) break; } else { if (max (max (p12.x, p12.z), p3.x) * pixelsPerEm.x < -0.5) break; } uint code = _hb_gpu_calc_root_code (p12.y, p12.w, p3.y); if (code != 0u) { float2 a = q12.xy - q12.zw * 2.0 + q3; float2 b = q12.xy - q12.zw; float2 r = _hb_gpu_solve_horiz_poly (a, b, p12.xy) * pixelsPerEm.x; float2 cov = hLeftRay ? clamp (float2 (0.5, 0.5) - r, 0.0, 1.0) : clamp (r + float2 (0.5, 0.5), 0.0, 1.0); if ((code & 1u) != 0u) { xcov += cov.x; xwgt = max (xwgt, clamp (1.0 - abs (r.x) * 2.0, 0.0, 1.0)); } if (code > 1u) { xcov -= cov.y; xwgt = max (xwgt, clamp (1.0 - abs (r.y) * 2.0, 0.0, 1.0)); } } } /* Crossings over a closed contour sum to zero, so a leftward ray * returns the negative of what a rightward ray would; flip it back * so that xcov and ycov keep a common sign convention. */ if (hLeftRay) xcov = -xcov; float ycov = 0.0; float ywgt = 0.0; int4 vbandData = hb_gpu_fetch (bandBase + numHBands + gi.bandIndex.x); int vCurveCount = vbandData.r; float vSplit = (float) vbandData.a * HB_GPU_INV_UNITS; bool vLeftRay = (renderCoord.y < vSplit); int vDataOffset = (vLeftRay ? vbandData.b : vbandData.g) + 32768; for (int ci = 0; ci < vCurveCount; ci++) { int curveOffset = hb_gpu_fetch (glyphLoc + vDataOffset + ci).r + 32768; int4 raw12 = hb_gpu_fetch (glyphLoc + curveOffset); int4 raw3 = hb_gpu_fetch (glyphLoc + curveOffset + 1); float4 q12 = (float4) raw12 * HB_GPU_INV_UNITS; float2 q3 = (float2) raw3.rg * HB_GPU_INV_UNITS; float4 p12 = q12 - float4 (renderCoord, renderCoord); float2 p3 = q3 - renderCoord; if (vLeftRay) { if (min (min (p12.y, p12.w), p3.y) * pixelsPerEm.y > 0.5) break; } else { if (max (max (p12.y, p12.w), p3.y) * pixelsPerEm.y < -0.5) break; } uint code = _hb_gpu_calc_root_code (p12.x, p12.z, p3.x); if (code != 0u) { float2 a = q12.xy - q12.zw * 2.0 + q3; float2 b = q12.xy - q12.zw; float2 r = _hb_gpu_solve_vert_poly (a, b, p12.xy) * pixelsPerEm.y; float2 cov = vLeftRay ? clamp (float2 (0.5, 0.5) - r, 0.0, 1.0) : clamp (r + float2 (0.5, 0.5), 0.0, 1.0); if ((code & 1u) != 0u) { ycov -= cov.x; ywgt = max (ywgt, clamp (1.0 - abs (r.x) * 2.0, 0.0, 1.0)); } if (code > 1u) { ycov += cov.y; ywgt = max (ywgt, clamp (1.0 - abs (r.y) * 2.0, 0.0, 1.0)); } } } /* Ditto, for the vertical ray. */ if (vLeftRay) ycov = -ycov; return _hb_gpu_calc_coverage (xcov, ycov, xwgt, ywgt); } /* Return coverage in [0, 1]. * * Caller must declare: StructuredBuffer hb_gpu_atlas * * renderCoord: em-space sample position * glyphLoc: texel offset of glyph blob in atlas */ /* The MSAA-aware implementation. Caller supplies pixelsPerEm so * this function can be invoked from non-uniform control flow (for * example from a paint op-stream branch). */ float _hb_gpu_slug (float2 renderCoord, float2 pixelsPerEm, uint glyphLoc_) { float c = _hb_gpu_slug_single (renderCoord, pixelsPerEm, glyphLoc_); #ifndef HB_GPU_NO_MSAA float ppem = hb_gpu_ppem (renderCoord, glyphLoc_); if (ppem < 16.0) { float2 emsPerPixel = 1.0 / pixelsPerEm; float2 d = emsPerPixel * (1.0 / 3.0); float msaa = 0.25 * (_hb_gpu_slug_single (renderCoord + float2 (-d.x, -d.y), pixelsPerEm, glyphLoc_) + _hb_gpu_slug_single (renderCoord + float2 ( d.x, -d.y), pixelsPerEm, glyphLoc_) + _hb_gpu_slug_single (renderCoord + float2 (-d.x, d.y), pixelsPerEm, glyphLoc_) + _hb_gpu_slug_single (renderCoord + float2 ( d.x, d.y), pixelsPerEm, glyphLoc_)); c = lerp (c, msaa, smoothstep (16.0, 8.0, ppem)); } #endif return c; } /* Stem darkening for small sizes. * * coverage: output of hb_gpu_draw * brightness: foreground brightness in [0, 1] * ppem: pixels per em at this fragment */ float hb_gpu_stem_darken (float coverage, float brightness, float ppem) { return pow (coverage, lerp (pow (2.0, brightness - 0.5), 1.0, smoothstep (8.0, 48.0, ppem))); } /* * Copyright (C) 2026 Behdad Esfahbod * * This is part of HarfBuzz, a text shaping library. * * Permission is hereby granted, without written agreement and without * license or royalty fees, to use, copy, modify, and distribute this * software and its documentation for any purpose, provided that the * above copyright notice and the following two paragraphs appear in * all copies of this software. * * IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN * IF THE COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH * DAMAGE. * * THE COPYRIGHT HOLDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND * FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS * ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. */ /* Requires GLSL 3.30 or GLSL ES 3.00. */ /* Dilate a glyph vertex by half a pixel on screen. * * position: object-space vertex position (modified in place) * texcoord: em-space sample coordinates (modified in place) * normal: object-space outward normal at this vertex * jac: inverse of the 2x2 linear part of the em-to-object transform, * stored row-major as (j00, j01, j10, j11). Maps object-space * displacements back to em-space for texcoord adjustment. * For simple scaling with y-flip (the common case): * em-to-object = [[s, 0], [0, -s]] * jac = (1/s, 0, 0, -1/s) * m: model-view-projection matrix * viewport: viewport size in pixels */ void hb_gpu_dilate (inout vec2 position, inout vec2 texcoord, vec2 normal, vec4 jac, mat4 m, vec2 viewport) { vec2 n = normalize (normal); vec4 clipPos = m * vec4 (position, 0.0, 1.0); vec4 clipN = m * vec4 (n, 0.0, 0.0); float s = clipPos.w; float t = clipN.w; float u = (s * clipN.x - t * clipPos.x) * viewport.x; float v = (s * clipN.y - t * clipPos.y) * viewport.y; float s2 = s * s; float st = s * t; float uv = u * u + v * v; float denom = uv - st * st; float d = abs (denom) > 1.0 / 16777216.0 ? s2 * (st + sqrt (uv)) / denom : 0.0; vec2 dPos = d * normal; position += dPos; texcoord += vec2 (dot (dPos, jac.xy), dot (dPos, jac.zw)); } /* * Copyright (C) 2026 Behdad Esfahbod * * This is part of HarfBuzz, a text shaping library. * * Permission is hereby granted, without written agreement and without * license or royalty fees, to use, copy, modify, and distribute this * software and its documentation for any purpose, provided that the * above copyright notice and the following two paragraphs appear in * all copies of this software. * * IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN * IF THE COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH * DAMAGE. * * THE COPYRIGHT HOLDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND * FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS * ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. */ /* Requires WGSL (WebGPU Shading Language). */ /* Dilate a glyph vertex by half a pixel on screen. * * position: object-space vertex position (modified in place) * texcoord: em-space sample coordinates (modified in place) * normal: object-space outward normal at this vertex * jac: inverse of the 2x2 linear part of the em-to-object transform, * stored row-major as (j00, j01, j10, j11). Maps object-space * displacements back to em-space for texcoord adjustment. * For simple scaling with y-flip (the common case): * em-to-object = [[s, 0], [0, -s]] * jac = (1/s, 0, 0, -1/s) * m: model-view-projection matrix * viewport: viewport size in pixels * * Returns (new_position, new_texcoord). */ fn hb_gpu_dilate (position: vec2f, texcoord: vec2f, normal: vec2f, jac: vec4f, m: mat4x4f, viewport: vec2f) -> array { let n = normalize (normal); let clipPos = m * vec4f (position, 0.0, 1.0); let clipN = m * vec4f (n, 0.0, 0.0); let s = clipPos.w; let t = clipN.w; let u = (s * clipN.x - t * clipPos.x) * viewport.x; let v = (s * clipN.y - t * clipPos.y) * viewport.y; let s2 = s * s; let st = s * t; let uv = u * u + v * v; let denom = uv - st * st; var d: f32; if (abs (denom) > 1.0 / 16777216.0) { d = s2 * (st + sqrt (uv)) / denom; } else { d = 0.0; } let dPos = d * normal; return array ( position + dPos, texcoord + vec2f (dot (dPos, jac.xy), dot (dPos, jac.zw)) ); } /* * Copyright (C) 2026 Behdad Esfahbod * * This is part of HarfBuzz, a text shaping library. * * Permission is hereby granted, without written agreement and without * license or royalty fees, to use, copy, modify, and distribute this * software and its documentation for any purpose, provided that the * above copyright notice and the following two paragraphs appear in * all copies of this software. * * IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN * IF THE COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH * DAMAGE. * * THE COPYRIGHT HOLDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND * FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS * ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. */ /* Requires Shader Model 5.0+. */ /* Dilate a glyph vertex by half a pixel on screen. * * position: object-space vertex position (modified in place) * texcoord: em-space sample coordinates (modified in place) * normal: object-space outward normal at this vertex * jac: inverse of the 2x2 linear part of the em-to-object transform * m: model-view-projection matrix * viewport: viewport size in pixels */ void hb_gpu_dilate (inout float2 position, inout float2 texcoord, float2 normal, float4 jac, float4x4 m, float2 viewport) { float2 n = normalize (normal); float4 clipPos = mul (m, float4 (position, 0.0, 1.0)); float4 clipN = mul (m, float4 (n, 0.0, 0.0)); float s = clipPos.w; float t = clipN.w; float u = (s * clipN.x - t * clipPos.x) * viewport.x; float v = (s * clipN.y - t * clipPos.y) * viewport.y; float s2 = s * s; float st = s * t; float uv = u * u + v * v; float denom = uv - st * st; float d = abs (denom) > 1.0 / 16777216.0 ? s2 * (st + sqrt (uv)) / denom : 0.0; float2 dPos = d * normal; position += dPos; texcoord += float2 (dot (dPos, jac.xy), dot (dPos, jac.zw)); } /* * Copyright (C) 2026 Behdad Esfahbod * * This is part of HarfBuzz, a text shaping library. * * Permission is hereby granted, without written agreement and without * license or royalty fees, to use, copy, modify, and distribute this * software and its documentation for any purpose, provided that the * above copyright notice and the following two paragraphs appear in * all copies of this software. * * IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN * IF THE COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH * DAMAGE. * * THE COPYRIGHT HOLDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND * FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS * ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. */ /* Draw-renderer fragment shader entry. The heavy lifting (Slug * coverage, MSAA, ppem, stem darkening) lives in the shared * hb-gpu-fragment.glsl that must be prepended to this source; * this file only adds the thin hb_gpu_draw() wrapper that lifts * pixelsPerEm out of fwidth() at uniform control flow before * calling the shared _hb_gpu_slug(). */ float hb_gpu_draw (vec2 renderCoord, uint glyphLoc_) { vec2 pixelsPerEm = 1.0 / fwidth (renderCoord); return _hb_gpu_slug (renderCoord, pixelsPerEm, glyphLoc_); } /* * Copyright (C) 2026 Behdad Esfahbod * * This is part of HarfBuzz, a text shaping library. * * Permission is hereby granted, without written agreement and without * license or royalty fees, to use, copy, modify, and distribute this * software and its documentation for any purpose, provided that the * above copyright notice and the following two paragraphs appear in * all copies of this software. * * IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN * IF THE COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH * DAMAGE. * * THE COPYRIGHT HOLDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND * FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS * ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. */ /* Draw-renderer fragment shader entry (Metal). Heavy lifting * (Slug coverage, MSAA, ppem, stem darkening) lives in the shared * hb-gpu-fragment.msl that must be prepended to this source. */ float hb_gpu_draw (float2 renderCoord, uint glyphLoc_, device const short4* hb_gpu_atlas) { float2 pixelsPerEm = 1.0 / fwidth (renderCoord); return _hb_gpu_slug (renderCoord, pixelsPerEm, glyphLoc_, hb_gpu_atlas); } /* * Copyright (C) 2026 Behdad Esfahbod * * This is part of HarfBuzz, a text shaping library. * * Permission is hereby granted, without written agreement and without * license or royalty fees, to use, copy, modify, and distribute this * software and its documentation for any purpose, provided that the * above copyright notice and the following two paragraphs appear in * all copies of this software. * * IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN * IF THE COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH * DAMAGE. * * THE COPYRIGHT HOLDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND * FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS * ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. */ /* Draw-renderer fragment shader entry (WGSL). Heavy lifting * (Slug coverage, MSAA, ppem, stem darkening) lives in the shared * hb-gpu-fragment.wgsl that must be prepended to this source. */ fn hb_gpu_draw (renderCoord: vec2f, glyphLoc_: u32, hb_gpu_atlas: ptr>, read>) -> f32 { let pixelsPerEm = 1.0 / fwidth (renderCoord); return _hb_gpu_slug (renderCoord, pixelsPerEm, glyphLoc_, hb_gpu_atlas); } /* * Copyright (C) 2026 Behdad Esfahbod * * This is part of HarfBuzz, a text shaping library. * * Permission is hereby granted, without written agreement and without * license or royalty fees, to use, copy, modify, and distribute this * software and its documentation for any purpose, provided that the * above copyright notice and the following two paragraphs appear in * all copies of this software. * * IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN * IF THE COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH * DAMAGE. * * THE COPYRIGHT HOLDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND * FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS * ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. */ /* Draw-renderer fragment shader entry (HLSL). Heavy lifting * (Slug coverage, MSAA, ppem, stem darkening) lives in the shared * hb-gpu-fragment.hlsl that must be prepended to this source. */ float hb_gpu_draw (float2 renderCoord, uint glyphLoc_) { float2 pixelsPerEm = 1.0 / fwidth (renderCoord); return _hb_gpu_slug (renderCoord, pixelsPerEm, glyphLoc_); } /* * Copyright (C) 2026 Behdad Esfahbod * * This is part of HarfBuzz, a text shaping library. * * Permission is hereby granted, without written agreement and without * license or royalty fees, to use, copy, modify, and distribute this * software and its documentation for any purpose, provided that the * above copyright notice and the following two paragraphs appear in * all copies of this software. * * IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN * IF THE COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH * DAMAGE. * * THE COPYRIGHT HOLDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND * FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS * ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. */ /* Paint-renderer fragment shader. * * Assumes the shared fragment helpers (hb-gpu-fragment.glsl) and * the draw-renderer fragment helpers (hb-gpu-draw-fragment.glsl) * are prepended to this source. The draw helper provides * hb_gpu_draw() which this interpreter calls to compute clip-glyph * coverage. */ /* Fetch the i'th stop of a gradient color line starting at @stops_base * (2 texels per stop). Resolves is_foreground to @foreground. */ vec4 _hb_gpu_stop_color (int stops_base, int i, vec4 foreground, out float offset) { ivec4 a = hb_gpu_fetch (stops_base + i * 2); offset = float (a.r) / 32767.0; ivec4 b = hb_gpu_fetch (stops_base + i * 2 + 1); if ((a.g & 1) != 0) return vec4 (foreground.rgb, foreground.a * (float (b.a) / 32767.0)); return vec4 (b) / 32767.0; } /* Apply the color-line extend mode to a projected `t` value. */ float _hb_gpu_extend_t (float t, int extend) { if (extend == 1) { /* HB_PAINT_EXTEND_REPEAT */ return t - floor (t); } else if (extend == 2) { /* HB_PAINT_EXTEND_REFLECT */ float u = t - 2.0 * floor (t * 0.5); return u > 1.0 ? 2.0 - u : u; } return clamp (t, 0.0, 1.0); /* PAD (default) */ } /* Walk stops starting at @stops_base and return the sampled color * at @t. Same logic reused by all gradient subtypes. */ vec4 _hb_gpu_eval_stops (int stops_base, int stop_count, float t, vec4 foreground) { float off_prev; vec4 col_prev = _hb_gpu_stop_color (stops_base, 0, foreground, off_prev); if (t <= off_prev) return col_prev; for (int i = 1; i < stop_count; i++) { float off; vec4 col = _hb_gpu_stop_color (stops_base, i, foreground, off); if (t <= off) { float span = off - off_prev; float f = span > 1e-6 ? (t - off_prev) / span : 0.0; /* Interpolate in premultiplied space per OpenType COLR spec. */ vec4 p0 = vec4 (col_prev.rgb * col_prev.a, col_prev.a); vec4 p1 = vec4 (col.rgb * col.a, col.a); vec4 pm = mix (p0, p1, f); return pm.a > 1e-6 ? vec4 (pm.rgb / pm.a, pm.a) : vec4 (0.0); } col_prev = col; off_prev = off; } return col_prev; } /* Apply the stored 2x2 M^-1 (row-major i16 Q10) to @v. Scaling * renderCoord deltas back into canonical gradient space. */ vec2 _hb_gpu_apply_minv (ivec4 m, vec2 v) { vec4 mf = vec4 (m) * (1.0 / 1024.0); return vec2 (mf.x * v.x + mf.y * v.y, mf.z * v.x + mf.w * v.y); } /* Sample a linear gradient whose param blob starts at @grad_base: * texel 0: (p0_rendered.x, p0_rendered.y, d_canonical.x, d_canonical.y) * texel 1: L^-1 as i16 Q10 (row-major) * texels 2..: stops (2 texels each) * Evaluate t in untransformed space. */ vec4 _hb_gpu_sample_linear (vec2 renderCoord, int grad_base, int stop_count, int extend, vec4 foreground) { ivec4 t0 = hb_gpu_fetch (grad_base); ivec4 m = hb_gpu_fetch (grad_base + 1); vec2 p0_r = vec2 (float (t0.r), float (t0.g)); vec2 d = vec2 (float (t0.b), float (t0.a)); float denom = dot (d, d); if (denom < 1e-6) return vec4 (0.0); vec2 p = _hb_gpu_apply_minv (m, renderCoord - p0_r); float t = dot (p, d) / denom; t = _hb_gpu_extend_t (t, extend); return _hb_gpu_eval_stops (grad_base + 2, stop_count, t, foreground); } /* Sample a two-circle radial gradient whose param blob starts at * @grad_base: * texel 0: (c0_rendered.x, c0_rendered.y, d_canonical.x, d_canonical.y) * d = c1 - c0 in untransformed space * texel 1: (r0, r1, _, _) in untransformed font units * texel 2: L^-1 as i16 Q10 (row-major) * texels 3..: stops (2 texels each) * Solves |p - t*cd|^2 = (r0 + t*(r1-r0))^2 with p in untransformed * space, so non-uniform scale / shear on the transform becomes a * proper ellipse-in-rendered-space instead of a scalar-fudge. */ vec4 _hb_gpu_sample_radial (vec2 renderCoord, int grad_base, int stop_count, int extend, vec4 foreground) { ivec4 t0 = hb_gpu_fetch (grad_base); ivec4 t1 = hb_gpu_fetch (grad_base + 1); ivec4 m = hb_gpu_fetch (grad_base + 2); vec2 c0_r = vec2 (float (t0.r), float (t0.g)); vec2 cd = vec2 (float (t0.b), float (t0.a)); float r0 = float (t1.r); float r1 = float (t1.g); float dr = r1 - r0; vec2 p = _hb_gpu_apply_minv (m, renderCoord - c0_r); float A = dot (cd, cd) - dr * dr; float B = -2.0 * (dot (p, cd) + r0 * dr); float C = dot (p, p) - r0 * r0; float t; if (abs (A) > 1e-6) { float disc = B * B - 4.0 * A * C; if (disc < 0.0) return vec4 (0.0); float sq = sqrt (disc); /* Prefer the larger root; fall back to the smaller if the * larger gives a negative interpolated radius. */ float t1 = (-B + sq) / (2.0 * A); float t2 = (-B - sq) / (2.0 * A); t = (r0 + t1 * dr >= 0.0) ? t1 : t2; } else { if (abs (B) < 1e-6) return vec4 (0.0); t = -C / B; } t = _hb_gpu_extend_t (t, extend); return _hb_gpu_eval_stops (grad_base + 3, stop_count, t, foreground); } /* Sample a sweep gradient whose param blob starts at @grad_base: * texel 0: (center_rendered.x, center_rendered.y, start_q14, end_q14) * start/end are Q14 fractions of pi in untransformed space * texel 1: L^-1 as i16 Q10 (row-major) * texels 2..: stops (2 texels each) */ vec4 _hb_gpu_sample_sweep (vec2 renderCoord, int grad_base, int stop_count, int extend, vec4 foreground) { ivec4 t0 = hb_gpu_fetch (grad_base); ivec4 m = hb_gpu_fetch (grad_base + 1); vec2 c_r = vec2 (float (t0.r), float (t0.g)); float a0 = float (t0.b) / 16384.0; /* fraction of pi */ float a1 = float (t0.a) / 16384.0; float span = a1 - a0; if (abs (span) < 1e-6) return vec4 (0.0); vec2 p = _hb_gpu_apply_minv (m, renderCoord - c_r); /* atan2 returns (-pi, pi]; normalize to [0, 2) fractions of pi. */ float ang = atan (p.y, p.x) / 3.14159265358979; if (ang < 0.0) ang += 2.0; float t = (ang - a0) / span; t = _hb_gpu_extend_t (t, extend); return _hb_gpu_eval_stops (grad_base + 2, stop_count, t, foreground); } /* Composite two premultiplied RGBA layers using one of the COLRv1 * compositing modes. Unsupported modes fall back to SRC_OVER. * Values match hb_paint_composite_mode_t. */ vec4 _hb_gpu_composite (vec4 src, vec4 dst, int mode) { vec4 r = src + dst * (1.0 - src.a); /* SRC_OVER default */ /* Approximate unsupported COLRv1 modes with the nearest Porter-Duff * mode we do implement. Better a recognizable rendering than a * silent SRC_OVER fallback. DIFFERENCE / EXCLUSION / HSL_* are * not similar enough to anything we have, so they still fall * through to SRC_OVER below. */ if (mode == 14 || mode == 18 || mode == 19) mode = 23; /* OVERLAY / COLOR_BURN / HARD_LIGHT -> MULTIPLY */ else if (mode == 17 || mode == 20) mode = 13; /* COLOR_DODGE / SOFT_LIGHT -> SCREEN */ if (mode == 0) r = vec4 (0.0); /* CLEAR */ else if (mode == 1) r = src; /* SRC */ else if (mode == 2) r = dst; /* DST */ else if (mode == 4) r = dst + src * (1.0 - dst.a); /* DST_OVER */ else if (mode == 5) r = src * dst.a; /* SRC_IN */ else if (mode == 6) r = dst * src.a; /* DST_IN */ else if (mode == 7) r = src * (1.0 - dst.a); /* SRC_OUT */ else if (mode == 8) r = dst * (1.0 - src.a); /* DST_OUT */ else if (mode == 9) /* SRC_ATOP */ r = src * dst.a + dst * (1.0 - src.a); else if (mode == 10) /* DST_ATOP */ r = dst * src.a + src * (1.0 - dst.a); else if (mode == 11) /* XOR */ r = src * (1.0 - dst.a) + dst * (1.0 - src.a); else if (mode == 12) /* PLUS */ r = min (src + dst, vec4 (1.0)); else if (mode == 13) { /* SCREEN (premul) */ r.rgb = src.rgb + dst.rgb - src.rgb * dst.rgb; r.a = src.a + dst.a - src.a * dst.a; } else if (mode == 15) { /* DARKEN */ r.rgb = min (src.rgb * dst.a, dst.rgb * src.a) + src.rgb * (1.0 - dst.a) + dst.rgb * (1.0 - src.a); r.a = src.a + dst.a - src.a * dst.a; } else if (mode == 16) { /* LIGHTEN */ r.rgb = max (src.rgb * dst.a, dst.rgb * src.a) + src.rgb * (1.0 - dst.a) + dst.rgb * (1.0 - src.a); r.a = src.a + dst.a - src.a * dst.a; } else if (mode == 23) { /* MULTIPLY (premul) */ r.rgb = src.rgb * (1.0 - dst.a) + dst.rgb * (1.0 - src.a) + src.rgb * dst.rgb; r.a = src.a + dst.a - src.a * dst.a; } /* SRC_OVER (3) and DIFFERENCE / EXCLUSION / HSL_* (21, 22, 24-27) * fall through to the SRC_OVER default. */ return r; } /* Wrap _hb_gpu_slug with a sub-glyph extents bail-out. Many * paint layers cover a small region of the outer glyph quad; for * fragments outside the layer's bbox (with an AA + MSAA-spread * margin) the slug coverage is exactly 0, so we can skip the * band/curve walk entirely. */ float _hb_gpu_slug_clipped (vec2 renderCoord, vec2 pixelsPerEm, uint glyphLoc_) { ivec4 header0 = hb_gpu_fetch (int (glyphLoc_)); vec4 ext = vec4 (header0) * HB_GPU_INV_UNITS; vec2 margin = 2.0 / pixelsPerEm; if (any (lessThan (renderCoord, ext.xy - margin)) || any (greaterThan (renderCoord, ext.zw + margin))) return 0.0; return _hb_gpu_slug (renderCoord, pixelsPerEm, glyphLoc_); } /* Combine slug coverages from all clip outlines on the current * layer. Factored out of LAYER_SOLID and LAYER_GRADIENT so the * shader has one set of inlined slug walks instead of two. flags * bits: 0x100 = HAS_CLIP2; 0x200 = HAS_CLIP3 (HAS_CLIP3 implies * HAS_CLIP2). */ float _hb_gpu_layer_coverage (vec2 renderCoord, vec2 pixelsPerEm, int base, int flags, int clip1_payload, int clip2_payload, int clip3_payload) { float cov = _hb_gpu_slug_clipped (renderCoord, pixelsPerEm, uint (base + clip1_payload)); if ((flags & 0x100) != 0) { cov *= _hb_gpu_slug_clipped (renderCoord, pixelsPerEm, uint (base + clip2_payload)); if ((flags & 0x200) != 0) cov *= _hb_gpu_slug_clipped (renderCoord, pixelsPerEm, uint (base + clip3_payload)); } return cov; } /* Walks the paint blob's flat op stream and returns a * premultiplied RGBA coverage value for the current fragment. * * glyphLoc: atlas texel offset of the paint-blob header. * foreground: caller-supplied foreground color, used when an op * sets the is_foreground flag. */ #define HB_GPU_PAINT_GROUP_DEPTH 4 vec4 hb_gpu_paint (vec2 renderCoord, uint glyphLoc, vec4 foreground, out float coverage) { /* fwidth once, at uniform control flow: every per-layer * coverage sample below uses this pre-computed pixelsPerEm via * _hb_gpu_slug. */ vec2 pixelsPerEm = 1.0 / fwidth (renderCoord); int base = int (glyphLoc); ivec4 h0 = hb_gpu_fetch (base); /* (num_ops, _, _, _) */ ivec4 h2 = hb_gpu_fetch (base + 2); /* (ops_offset, _, _, _) */ int num_ops = h0.r; int cursor = base + h2.r; vec4 acc = vec4 (0.0); vec4 group_stack[HB_GPU_PAINT_GROUP_DEPTH]; int sp = 0; coverage = 0.0; for (int i = 0; i < num_ops; i++) { ivec4 op = hb_gpu_fetch (cursor); int op_type = op.r; int aux = op.g; int payload = (op.b << 16) | (op.a & 0xffff); if (op_type == 0) /* LAYER_SOLID */ { /* texel 1: (clip2_hi, clip2_lo, clip3_hi, clip3_lo) -- valid * per HAS_CLIP2 / HAS_CLIP3 flag bits. * texel 2: RGBA as signed Q15. */ ivec4 op2 = hb_gpu_fetch (cursor + 1); int clip2_payload = (op2.r << 16) | (op2.g & 0xffff); int clip3_payload = (op2.b << 16) | (op2.a & 0xffff); ivec4 ct = hb_gpu_fetch (cursor + 2); vec4 col = ((aux & 1) != 0) ? vec4 (foreground.rgb, foreground.a * (float (ct.a) / 32767.0)) : vec4 (ct) / 32767.0; float cov = _hb_gpu_layer_coverage (renderCoord, pixelsPerEm, base, aux, payload, clip2_payload, clip3_payload); coverage = max (coverage, cov); vec4 src = vec4 (col.rgb * col.a, col.a) * cov; acc = src + acc * (1.0 - src.a); cursor += 3; } else if (op_type == 1) /* LAYER_GRADIENT */ { /* texel 1: (clip2_hi, clip2_lo, clip3_hi, clip3_lo) -- valid * per HAS_CLIP2 / HAS_CLIP3 flag bits. * texel 2: (grad_payload_hi, grad_payload_lo, extend, stop_count) */ ivec4 op2 = hb_gpu_fetch (cursor + 1); int clip2_payload = (op2.r << 16) | (op2.g & 0xffff); int clip3_payload = (op2.b << 16) | (op2.a & 0xffff); ivec4 op3 = hb_gpu_fetch (cursor + 2); int grad_payload = (op3.r << 16) | (op3.g & 0xffff); int extend = op3.b; int stop_count = op3.a; int subtype = aux & 0xff; vec4 col = vec4 (0.0); if (subtype == 0) /* linear */ col = _hb_gpu_sample_linear (renderCoord, base + grad_payload, stop_count, extend, foreground); else if (subtype == 1) /* radial */ col = _hb_gpu_sample_radial (renderCoord, base + grad_payload, stop_count, extend, foreground); else if (subtype == 2) /* sweep */ col = _hb_gpu_sample_sweep (renderCoord, base + grad_payload, stop_count, extend, foreground); float cov = _hb_gpu_layer_coverage (renderCoord, pixelsPerEm, base, aux, payload, clip2_payload, clip3_payload); coverage = max (coverage, cov); vec4 src = vec4 (col.rgb * col.a, col.a) * cov; acc = src + acc * (1.0 - src.a); cursor += 3; } else if (op_type == 2) /* PUSH_GROUP */ { if (sp < HB_GPU_PAINT_GROUP_DEPTH) { group_stack[sp] = acc; sp++; } acc = vec4 (0.0); cursor += 1; } else if (op_type == 3) /* POP_GROUP */ { if (sp > 0) { sp--; vec4 src = acc; vec4 dst = group_stack[sp]; acc = _hb_gpu_composite (src, dst, aux); } cursor += 1; } else { break; } } return acc; } /* * Copyright (C) 2026 Behdad Esfahbod * * This is part of HarfBuzz, a text shaping library. * * Permission is hereby granted, without written agreement and without * license or royalty fees, to use, copy, modify, and distribute this * software and its documentation for any purpose, provided that the * above copyright notice and the following two paragraphs appear in * all copies of this software. * * IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN * IF THE COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH * DAMAGE. * * THE COPYRIGHT HOLDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND * FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS * ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. */ /* Paint-renderer fragment shader (Metal). * * Assumes the shared fragment helpers (hb-gpu-fragment.msl) and * the draw-renderer fragment helpers (hb-gpu-draw-fragment.msl) * are prepended to this source. */ /* Fetch the i'th stop (2 texels per stop), resolving is_foreground. */ static float4 _hb_gpu_stop_color (device const short4* hb_gpu_atlas, int stops_base, int i, float4 foreground, thread float &offset) { int4 a = int4 (hb_gpu_atlas[stops_base + i * 2]); offset = float (a.r) / 32767.0; int4 b = int4 (hb_gpu_atlas[stops_base + i * 2 + 1]); if ((a.g & 1) != 0) return float4 (foreground.rgb, foreground.a * (float (b.a) / 32767.0)); return float4 (b) / 32767.0; } static float _hb_gpu_extend_t (float t, int extend) { if (extend == 1) return t - floor (t); if (extend == 2) { float u = t - 2.0 * floor (t * 0.5); return u > 1.0 ? 2.0 - u : u; } return clamp (t, 0.0, 1.0); } static float4 _hb_gpu_eval_stops (device const short4* hb_gpu_atlas, int stops_base, int stop_count, float t, float4 foreground) { float off_prev; float4 col_prev = _hb_gpu_stop_color (hb_gpu_atlas, stops_base, 0, foreground, off_prev); if (t <= off_prev) return col_prev; for (int i = 1; i < stop_count; i++) { float off; float4 col = _hb_gpu_stop_color (hb_gpu_atlas, stops_base, i, foreground, off); if (t <= off) { float span = off - off_prev; float f = span > 1e-6 ? (t - off_prev) / span : 0.0; float4 p0 = float4 (col_prev.rgb * col_prev.a, col_prev.a); float4 p1 = float4 (col.rgb * col.a, col.a); float4 pm = mix (p0, p1, f); return pm.a > 1e-6 ? float4 (pm.rgb / pm.a, pm.a) : float4 (0.0); } col_prev = col; off_prev = off; } return col_prev; } /* Apply the stored 2x2 M^-1 (row-major i16 Q10) to a vector. */ static float2 _hb_gpu_apply_minv (int4 m, float2 v) { float4 mf = float4 (m) * (1.0 / 1024.0); return float2 (mf.x * v.x + mf.y * v.y, mf.z * v.x + mf.w * v.y); } static float4 _hb_gpu_sample_linear (float2 renderCoord, int grad_base, int stop_count, int extend, float4 foreground, device const short4* hb_gpu_atlas) { int4 t0 = int4 (hb_gpu_atlas[grad_base]); int4 m = int4 (hb_gpu_atlas[grad_base + 1]); float2 p0_r = float2 (float (t0.r), float (t0.g)); float2 d = float2 (float (t0.b), float (t0.a)); float denom = dot (d, d); if (denom < 1e-6) return float4 (0.0); float2 p = _hb_gpu_apply_minv (m, renderCoord - p0_r); float t = dot (p, d) / denom; t = _hb_gpu_extend_t (t, extend); return _hb_gpu_eval_stops (hb_gpu_atlas, grad_base + 2, stop_count, t, foreground); } static float4 _hb_gpu_sample_radial (float2 renderCoord, int grad_base, int stop_count, int extend, float4 foreground, device const short4* hb_gpu_atlas) { int4 t0 = int4 (hb_gpu_atlas[grad_base]); int4 t1 = int4 (hb_gpu_atlas[grad_base + 1]); int4 m = int4 (hb_gpu_atlas[grad_base + 2]); float2 c0_r = float2 (float (t0.r), float (t0.g)); float2 cd = float2 (float (t0.b), float (t0.a)); float r0 = float (t1.r); float r1 = float (t1.g); float dr = r1 - r0; float2 p = _hb_gpu_apply_minv (m, renderCoord - c0_r); float A = dot (cd, cd) - dr * dr; float B = -2.0 * (dot (p, cd) + r0 * dr); float C = dot (p, p) - r0 * r0; float t; if (abs (A) > 1e-6) { float disc = B * B - 4.0 * A * C; if (disc < 0.0) return float4 (0.0); float sq = sqrt (disc); float t1r = (-B + sq) / (2.0 * A); float t2r = (-B - sq) / (2.0 * A); t = (r0 + t1r * dr >= 0.0) ? t1r : t2r; } else { if (abs (B) < 1e-6) return float4 (0.0); t = -C / B; } t = _hb_gpu_extend_t (t, extend); return _hb_gpu_eval_stops (hb_gpu_atlas, grad_base + 3, stop_count, t, foreground); } static float4 _hb_gpu_sample_sweep (float2 renderCoord, int grad_base, int stop_count, int extend, float4 foreground, device const short4* hb_gpu_atlas) { int4 t0 = int4 (hb_gpu_atlas[grad_base]); int4 m = int4 (hb_gpu_atlas[grad_base + 1]); float2 c_r = float2 (float (t0.r), float (t0.g)); float a0 = float (t0.b) / 16384.0; float a1 = float (t0.a) / 16384.0; float span = a1 - a0; if (abs (span) < 1e-6) return float4 (0.0); float2 p = _hb_gpu_apply_minv (m, renderCoord - c_r); float ang = atan2 (p.y, p.x) / 3.14159265358979; if (ang < 0.0) ang += 2.0; float t = (ang - a0) / span; t = _hb_gpu_extend_t (t, extend); return _hb_gpu_eval_stops (hb_gpu_atlas, grad_base + 2, stop_count, t, foreground); } static float4 _hb_gpu_composite (float4 src, float4 dst, int mode) { float4 r = src + dst * (1.0 - src.a); /* SRC_OVER default */ /* Mode numbers match hb_paint_composite_mode_t. SRC_OVER (3) is * the default `r` above. */ /* Approximate unsupported modes with the nearest Porter-Duff mode * we do implement. DIFFERENCE / EXCLUSION / HSL_* still fall * through to SRC_OVER below. */ if (mode == 14 || mode == 18 || mode == 19) mode = 23; /* OVERLAY / COLOR_BURN / HARD_LIGHT -> MULTIPLY */ else if (mode == 17 || mode == 20) mode = 13; /* COLOR_DODGE / SOFT_LIGHT -> SCREEN */ if (mode == 0) r = float4 (0.0); /* CLEAR */ else if (mode == 1) r = src; /* SRC */ else if (mode == 2) r = dst; /* DST */ else if (mode == 4) r = dst + src * (1.0 - dst.a); /* DST_OVER */ else if (mode == 5) r = src * dst.a; /* SRC_IN */ else if (mode == 6) r = dst * src.a; /* DST_IN */ else if (mode == 7) r = src * (1.0 - dst.a); /* SRC_OUT */ else if (mode == 8) r = dst * (1.0 - src.a); /* DST_OUT */ else if (mode == 9) /* SRC_ATOP */ r = src * dst.a + dst * (1.0 - src.a); else if (mode == 10) /* DST_ATOP */ r = dst * src.a + src * (1.0 - dst.a); else if (mode == 11) /* XOR */ r = src * (1.0 - dst.a) + dst * (1.0 - src.a); else if (mode == 12) /* PLUS */ r = min (src + dst, float4 (1.0)); else if (mode == 13) { /* SCREEN (premul) */ r.rgb = src.rgb + dst.rgb - src.rgb * dst.rgb; r.a = src.a + dst.a - src.a * dst.a; } else if (mode == 15) { /* DARKEN */ r.rgb = min (src.rgb * dst.a, dst.rgb * src.a) + src.rgb * (1.0 - dst.a) + dst.rgb * (1.0 - src.a); r.a = src.a + dst.a - src.a * dst.a; } else if (mode == 16) { /* LIGHTEN */ r.rgb = max (src.rgb * dst.a, dst.rgb * src.a) + src.rgb * (1.0 - dst.a) + dst.rgb * (1.0 - src.a); r.a = src.a + dst.a - src.a * dst.a; } else if (mode == 23) { /* MULTIPLY (premul) */ r.rgb = src.rgb * (1.0 - dst.a) + dst.rgb * (1.0 - src.a) + src.rgb * dst.rgb; r.a = src.a + dst.a - src.a * dst.a; } /* SRC_OVER (3) and DIFFERENCE / EXCLUSION / HSL_* (21, 22, 24-27) * fall through to the SRC_OVER default. */ return r; } /* Wrap _hb_gpu_slug with a sub-glyph extents bail-out. Many * paint layers cover a small region of the outer glyph quad; for * fragments outside the layer's bbox (with an AA + MSAA-spread * margin) the slug coverage is exactly 0, so we can skip the * band/curve walk entirely. */ float _hb_gpu_slug_clipped (float2 renderCoord, float2 pixelsPerEm, uint glyphLoc_, device const short4* hb_gpu_atlas) { int4 header0 = hb_gpu_fetch (hb_gpu_atlas, int (glyphLoc_)); float4 ext = float4 (header0) * HB_GPU_INV_UNITS; float2 margin = 2.0 / pixelsPerEm; if (any (renderCoord < ext.xy - margin) || any (renderCoord > ext.zw + margin)) return 0.0; return _hb_gpu_slug (renderCoord, pixelsPerEm, glyphLoc_, hb_gpu_atlas); } /* Combine slug coverages from all clip outlines on the layer. * Factored out so the shader has one set of inlined slug walks * instead of two (one per LAYER op type). flags bits: 0x100 = * HAS_CLIP2; 0x200 = HAS_CLIP3 (HAS_CLIP3 implies HAS_CLIP2). */ static float _hb_gpu_layer_coverage (float2 renderCoord, float2 pixelsPerEm, int base, int flags, int clip1_payload, int clip2_payload, int clip3_payload, device const short4* hb_gpu_atlas) { float cov = _hb_gpu_slug_clipped (renderCoord, pixelsPerEm, uint (base + clip1_payload), hb_gpu_atlas); if ((flags & 0x100) != 0) { cov *= _hb_gpu_slug_clipped (renderCoord, pixelsPerEm, uint (base + clip2_payload), hb_gpu_atlas); if ((flags & 0x200) != 0) cov *= _hb_gpu_slug_clipped (renderCoord, pixelsPerEm, uint (base + clip3_payload), hb_gpu_atlas); } return cov; } #define HB_GPU_PAINT_GROUP_DEPTH 4 float4 hb_gpu_paint (float2 renderCoord, uint glyphLoc_, float4 foreground, device const short4* hb_gpu_atlas, thread float &coverage) { /* fwidth once, at uniform control flow. */ float2 pixelsPerEm = 1.0 / fwidth (renderCoord); int base = int (glyphLoc_); int4 h0 = int4 (hb_gpu_atlas[base]); /* (num_ops, _, _, _) */ int4 h2 = int4 (hb_gpu_atlas[base + 2]); /* (ops_offset, _, _, _) */ int num_ops = h0.r; int cursor = base + h2.r; float4 acc = float4 (0.0); float4 group_stack[HB_GPU_PAINT_GROUP_DEPTH]; int sp = 0; coverage = 0.0; for (int i = 0; i < num_ops; i++) { int4 op = int4 (hb_gpu_atlas[cursor]); int op_type = op.r; int aux = op.g; int payload = (op.b << 16) | (op.a & 0xffff); if (op_type == 0) /* LAYER_SOLID */ { /* texel 1: (clip2_hi, clip2_lo, clip3_hi, clip3_lo) -- valid * per HAS_CLIP2 / HAS_CLIP3 flag bits. * texel 2: RGBA as signed Q15. */ int4 op2 = int4 (hb_gpu_atlas[cursor + 1]); int clip2_payload = (op2.r << 16) | (op2.g & 0xffff); int clip3_payload = (op2.b << 16) | (op2.a & 0xffff); int4 ct = int4 (hb_gpu_atlas[cursor + 2]); float4 col = ((aux & 1) != 0) ? float4 (foreground.rgb, foreground.a * (float (ct.a) / 32767.0)) : float4 (ct) / 32767.0; float cov = _hb_gpu_layer_coverage (renderCoord, pixelsPerEm, base, aux, payload, clip2_payload, clip3_payload, hb_gpu_atlas); coverage = max (coverage, cov); float4 src = float4 (col.rgb * col.a, col.a) * cov; acc = src + acc * (1.0 - src.a); cursor += 3; } else if (op_type == 1) /* LAYER_GRADIENT */ { int4 op2 = int4 (hb_gpu_atlas[cursor + 1]); int clip2_payload = (op2.r << 16) | (op2.g & 0xffff); int clip3_payload = (op2.b << 16) | (op2.a & 0xffff); int4 op3 = int4 (hb_gpu_atlas[cursor + 2]); int grad_payload = (op3.r << 16) | (op3.g & 0xffff); int extend = op3.b; int stop_count = op3.a; int subtype = aux & 0xff; float4 col = float4 (0.0); if (subtype == 0) col = _hb_gpu_sample_linear (renderCoord, base + grad_payload, stop_count, extend, foreground, hb_gpu_atlas); else if (subtype == 1) col = _hb_gpu_sample_radial (renderCoord, base + grad_payload, stop_count, extend, foreground, hb_gpu_atlas); else if (subtype == 2) col = _hb_gpu_sample_sweep (renderCoord, base + grad_payload, stop_count, extend, foreground, hb_gpu_atlas); float cov = _hb_gpu_layer_coverage (renderCoord, pixelsPerEm, base, aux, payload, clip2_payload, clip3_payload, hb_gpu_atlas); coverage = max (coverage, cov); float4 src = float4 (col.rgb * col.a, col.a) * cov; acc = src + acc * (1.0 - src.a); cursor += 3; } else if (op_type == 2) /* PUSH_GROUP */ { if (sp < HB_GPU_PAINT_GROUP_DEPTH) { group_stack[sp] = acc; sp++; } acc = float4 (0.0); cursor += 1; } else if (op_type == 3) /* POP_GROUP */ { if (sp > 0) { sp--; float4 src = acc; float4 dst = group_stack[sp]; acc = _hb_gpu_composite (src, dst, aux); } cursor += 1; } else { break; } } return acc; } /* * Copyright (C) 2026 Behdad Esfahbod * * This is part of HarfBuzz, a text shaping library. * * Permission is hereby granted, without written agreement and without * license or royalty fees, to use, copy, modify, and distribute this * software and its documentation for any purpose, provided that the * above copyright notice and the following two paragraphs appear in * all copies of this software. * * IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN * IF THE COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH * DAMAGE. * * THE COPYRIGHT HOLDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND * FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS * ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. */ /* Paint-renderer fragment shader (WGSL). * * Assumes the shared fragment helpers (hb-gpu-fragment.wgsl) and * the draw-renderer fragment helpers (hb-gpu-draw-fragment.wgsl) * are prepended to this source. * * atlas is passed as an explicit storage-buffer pointer parameter, * matching WGSL's scoping rules. */ fn _hb_gpu_stop_color (hb_gpu_atlas: ptr>, read>, stops_base: i32, i: i32, foreground: vec4f, offset: ptr) -> vec4f { let a = hb_gpu_fetch (hb_gpu_atlas, stops_base + i * 2); *offset = f32 (a.r) / 32767.0; let b = hb_gpu_fetch (hb_gpu_atlas, stops_base + i * 2 + 1); if ((a.g & 1) != 0) { return vec4f (foreground.rgb, foreground.a * (f32 (b.a) / 32767.0)); } return vec4f (b) / 32767.0; } fn _hb_gpu_extend_t (t: f32, extend: i32) -> f32 { if (extend == 1) { return t - floor (t); } if (extend == 2) { let u = t - 2.0 * floor (t * 0.5); if (u > 1.0) { return 2.0 - u; } return u; } return clamp (t, 0.0, 1.0); } fn _hb_gpu_eval_stops (hb_gpu_atlas: ptr>, read>, stops_base: i32, stop_count: i32, t: f32, foreground: vec4f) -> vec4f { var off_prev: f32; var col_prev = _hb_gpu_stop_color (hb_gpu_atlas, stops_base, 0, foreground, &off_prev); if (t <= off_prev) { return col_prev; } for (var i: i32 = 1; i < stop_count; i = i + 1) { var off: f32; let col = _hb_gpu_stop_color (hb_gpu_atlas, stops_base, i, foreground, &off); if (t <= off) { let span = off - off_prev; var f: f32 = 0.0; if (span > 1e-6) { f = (t - off_prev) / span; } let p0 = vec4f (col_prev.rgb * col_prev.a, col_prev.a); let p1 = vec4f (col.rgb * col.a, col.a); let pm = mix (p0, p1, f); if (pm.a > 1e-6) { return vec4f (pm.rgb / pm.a, pm.a); } return vec4f (0.0); } col_prev = col; off_prev = off; } return col_prev; } /* Apply the stored 2x2 M^-1 (row-major i16 Q10) to a vector. */ fn _hb_gpu_apply_minv (m: vec4, v: vec2f) -> vec2f { let mf = vec4f (m) * (1.0 / 1024.0); return vec2f (mf.x * v.x + mf.y * v.y, mf.z * v.x + mf.w * v.y); } fn _hb_gpu_sample_linear (renderCoord: vec2f, grad_base: i32, stop_count: i32, extend: i32, foreground: vec4f, hb_gpu_atlas: ptr>, read>) -> vec4f { let t0 = hb_gpu_fetch (hb_gpu_atlas, grad_base); let m = hb_gpu_fetch (hb_gpu_atlas, grad_base + 1); let p0_r = vec2f (f32 (t0.r), f32 (t0.g)); let d = vec2f (f32 (t0.b), f32 (t0.a)); let denom = dot (d, d); if (denom < 1e-6) { return vec4f (0.0); } let p = _hb_gpu_apply_minv (m, renderCoord - p0_r); var t = dot (p, d) / denom; t = _hb_gpu_extend_t (t, extend); return _hb_gpu_eval_stops (hb_gpu_atlas, grad_base + 2, stop_count, t, foreground); } fn _hb_gpu_sample_radial (renderCoord: vec2f, grad_base: i32, stop_count: i32, extend: i32, foreground: vec4f, hb_gpu_atlas: ptr>, read>) -> vec4f { let t0 = hb_gpu_fetch (hb_gpu_atlas, grad_base); let t1 = hb_gpu_fetch (hb_gpu_atlas, grad_base + 1); let m = hb_gpu_fetch (hb_gpu_atlas, grad_base + 2); let c0_r = vec2f (f32 (t0.r), f32 (t0.g)); let cd = vec2f (f32 (t0.b), f32 (t0.a)); let r0 = f32 (t1.r); let r1 = f32 (t1.g); let dr = r1 - r0; let p = _hb_gpu_apply_minv (m, renderCoord - c0_r); let A = dot (cd, cd) - dr * dr; let B = -2.0 * (dot (p, cd) + r0 * dr); let C = dot (p, p) - r0 * r0; var t: f32; if (abs (A) > 1e-6) { let disc = B * B - 4.0 * A * C; if (disc < 0.0) { return vec4f (0.0); } let sq = sqrt (disc); let t1r = (-B + sq) / (2.0 * A); let t2r = (-B - sq) / (2.0 * A); if (r0 + t1r * dr >= 0.0) { t = t1r; } else { t = t2r; } } else { if (abs (B) < 1e-6) { return vec4f (0.0); } t = -C / B; } t = _hb_gpu_extend_t (t, extend); return _hb_gpu_eval_stops (hb_gpu_atlas, grad_base + 3, stop_count, t, foreground); } fn _hb_gpu_sample_sweep (renderCoord: vec2f, grad_base: i32, stop_count: i32, extend: i32, foreground: vec4f, hb_gpu_atlas: ptr>, read>) -> vec4f { let t0 = hb_gpu_fetch (hb_gpu_atlas, grad_base); let m = hb_gpu_fetch (hb_gpu_atlas, grad_base + 1); let c_r = vec2f (f32 (t0.r), f32 (t0.g)); let a0 = f32 (t0.b) / 16384.0; let a1 = f32 (t0.a) / 16384.0; let span = a1 - a0; if (abs (span) < 1e-6) { return vec4f (0.0); } let p = _hb_gpu_apply_minv (m, renderCoord - c_r); var ang = atan2 (p.y, p.x) / 3.14159265358979; if (ang < 0.0) { ang = ang + 2.0; } var t = (ang - a0) / span; t = _hb_gpu_extend_t (t, extend); return _hb_gpu_eval_stops (hb_gpu_atlas, grad_base + 2, stop_count, t, foreground); } fn _hb_gpu_composite (src: vec4f, dst: vec4f, mode_in: i32) -> vec4f { var r = src + dst * (1.0 - src.a); /* SRC_OVER default */ /* Mode numbers match hb_paint_composite_mode_t. Approximate * unsupported modes with the nearest Porter-Duff mode we do * implement; DIFFERENCE / EXCLUSION / HSL_* still fall through to * SRC_OVER below. */ var mode = mode_in; if (mode == 14 || mode == 18 || mode == 19) { mode = 23; } /* OVERLAY / COLOR_BURN / HARD_LIGHT -> MULTIPLY */ else if (mode == 17 || mode == 20) { mode = 13; } /* COLOR_DODGE / SOFT_LIGHT -> SCREEN */ if (mode == 0) { r = vec4f (0.0); } /* CLEAR */ else if (mode == 1) { r = src; } /* SRC */ else if (mode == 2) { r = dst; } /* DST */ else if (mode == 4) { r = dst + src * (1.0 - dst.a); } /* DST_OVER */ else if (mode == 5) { r = src * dst.a; } /* SRC_IN */ else if (mode == 6) { r = dst * src.a; } /* DST_IN */ else if (mode == 7) { r = src * (1.0 - dst.a); } /* SRC_OUT */ else if (mode == 8) { r = dst * (1.0 - src.a); } /* DST_OUT */ else if (mode == 9) { r = src * dst.a + dst * (1.0 - src.a); } /* SRC_ATOP */ else if (mode == 10) { r = dst * src.a + src * (1.0 - dst.a); } /* DST_ATOP */ else if (mode == 11) { r = src * (1.0 - dst.a) + dst * (1.0 - src.a); } /* XOR */ else if (mode == 12) { r = min (src + dst, vec4f (1.0)); } /* PLUS */ else if (mode == 13) { /* SCREEN (premul) */ r = vec4f (src.rgb + dst.rgb - src.rgb * dst.rgb, src.a + dst.a - src.a * dst.a); } else if (mode == 15) { /* DARKEN */ r = vec4f (min (src.rgb * dst.a, dst.rgb * src.a) + src.rgb * (1.0 - dst.a) + dst.rgb * (1.0 - src.a), src.a + dst.a - src.a * dst.a); } else if (mode == 16) { /* LIGHTEN */ r = vec4f (max (src.rgb * dst.a, dst.rgb * src.a) + src.rgb * (1.0 - dst.a) + dst.rgb * (1.0 - src.a), src.a + dst.a - src.a * dst.a); } else if (mode == 23) { /* MULTIPLY (premul) */ r = vec4f (src.rgb * (1.0 - dst.a) + dst.rgb * (1.0 - src.a) + src.rgb * dst.rgb, src.a + dst.a - src.a * dst.a); } /* SRC_OVER (3) and DIFFERENCE / EXCLUSION / HSL_* (21, 22, 24-27) * fall through to the SRC_OVER default. */ return r; } /* Wrap _hb_gpu_slug with a sub-glyph extents bail-out. Many * paint layers cover a small region of the outer glyph quad; for * fragments outside the layer's bbox (with an AA + MSAA-spread * margin) the slug coverage is exactly 0, so we can skip the * band/curve walk entirely. */ fn _hb_gpu_slug_clipped (renderCoord: vec2f, pixelsPerEm: vec2f, glyphLoc_: u32, hb_gpu_atlas: ptr>, read>) -> f32 { let header0 = hb_gpu_fetch (hb_gpu_atlas, i32 (glyphLoc_)); let ext = vec4f (header0) * HB_GPU_INV_UNITS; let margin = 2.0 / pixelsPerEm; if (any (renderCoord < ext.xy - margin) || any (renderCoord > ext.zw + margin)) { return 0.0; } return _hb_gpu_slug (renderCoord, pixelsPerEm, glyphLoc_, hb_gpu_atlas); } /* Combine slug coverages from all clip outlines on the layer. * Factored so the shader has one set of inlined slug walks * instead of two (one per LAYER op type). flags bits: 0x100 = * HAS_CLIP2; 0x200 = HAS_CLIP3 (HAS_CLIP3 implies HAS_CLIP2). */ fn _hb_gpu_layer_coverage (renderCoord: vec2f, pixelsPerEm: vec2f, base: i32, flags: i32, clip1_payload: i32, clip2_payload: i32, clip3_payload: i32, hb_gpu_atlas: ptr>, read>) -> f32 { var cov = _hb_gpu_slug_clipped (renderCoord, pixelsPerEm, u32 (base + clip1_payload), hb_gpu_atlas); if ((flags & 0x100) != 0) { cov = cov * _hb_gpu_slug_clipped (renderCoord, pixelsPerEm, u32 (base + clip2_payload), hb_gpu_atlas); if ((flags & 0x200) != 0) { cov = cov * _hb_gpu_slug_clipped (renderCoord, pixelsPerEm, u32 (base + clip3_payload), hb_gpu_atlas); } } return cov; } const HB_GPU_PAINT_GROUP_DEPTH: i32 = 4; fn hb_gpu_paint (renderCoord: vec2f, glyphLoc_: u32, foreground: vec4f, hb_gpu_atlas: ptr>, read>, coverage: ptr) -> vec4f { /* Compute pixelsPerEm once here at uniform control flow. WGSL * rejects fwidth inside a loop-conditional branch, so we call * _hb_gpu_slug (the MSAA-aware implementation that takes a * pre-computed pixelsPerEm) instead of the top-level * hb_gpu_draw() which would re-call fwidth. */ let emsPerPixel = fwidth (renderCoord); let pixelsPerEm = 1.0 / emsPerPixel; let base = i32 (glyphLoc_); let h0 = hb_gpu_fetch (hb_gpu_atlas, base); // (num_ops, _, _, _) let h2 = hb_gpu_fetch (hb_gpu_atlas, base + 2); // (ops_offset, _, _, _) let num_ops = h0.r; var cursor = base + h2.r; var acc = vec4f (0.0); var group_stack: array; var sp: i32 = 0; *coverage = 0.0; for (var i: i32 = 0; i < num_ops; i = i + 1) { let op = hb_gpu_fetch (hb_gpu_atlas, cursor); let op_type = op.r; let aux = op.g; let payload = (op.b << 16) | (op.a & 0xffff); if (op_type == 0) { // LAYER_SOLID // texel 1: (clip2_hi, clip2_lo, clip3_hi, clip3_lo) -- valid // per HAS_CLIP2 / HAS_CLIP3 flag bits. // texel 2: RGBA as signed Q15. let op2 = hb_gpu_fetch (hb_gpu_atlas, cursor + 1); let clip2_payload = (op2.r << 16) | (op2.g & 0xffff); let clip3_payload = (op2.b << 16) | (op2.a & 0xffff); let ct = hb_gpu_fetch (hb_gpu_atlas, cursor + 2); var col: vec4f; if ((aux & 1) != 0) { col = vec4f (foreground.rgb, foreground.a * (f32 (ct.a) / 32767.0)); } else { col = vec4f (ct) / 32767.0; } let cov = _hb_gpu_layer_coverage (renderCoord, pixelsPerEm, base, aux, payload, clip2_payload, clip3_payload, hb_gpu_atlas); *coverage = max (*coverage, cov); let src = vec4f (col.rgb * col.a, col.a) * cov; acc = src + acc * (1.0 - src.a); cursor = cursor + 3; } else if (op_type == 1) { // LAYER_GRADIENT let op2 = hb_gpu_fetch (hb_gpu_atlas, cursor + 1); let clip2_payload = (op2.r << 16) | (op2.g & 0xffff); let clip3_payload = (op2.b << 16) | (op2.a & 0xffff); let op3 = hb_gpu_fetch (hb_gpu_atlas, cursor + 2); let grad_payload = (op3.r << 16) | (op3.g & 0xffff); let extend = op3.b; let stop_count = op3.a; let subtype = aux & 0xff; var col = vec4f (0.0); if (subtype == 0) { col = _hb_gpu_sample_linear (renderCoord, base + grad_payload, stop_count, extend, foreground, hb_gpu_atlas); } else if (subtype == 1) { col = _hb_gpu_sample_radial (renderCoord, base + grad_payload, stop_count, extend, foreground, hb_gpu_atlas); } else if (subtype == 2) { col = _hb_gpu_sample_sweep (renderCoord, base + grad_payload, stop_count, extend, foreground, hb_gpu_atlas); } let cov = _hb_gpu_layer_coverage (renderCoord, pixelsPerEm, base, aux, payload, clip2_payload, clip3_payload, hb_gpu_atlas); *coverage = max (*coverage, cov); let src = vec4f (col.rgb * col.a, col.a) * cov; acc = src + acc * (1.0 - src.a); cursor = cursor + 3; } else if (op_type == 2) { // PUSH_GROUP if (sp < HB_GPU_PAINT_GROUP_DEPTH) { group_stack[sp] = acc; sp = sp + 1; } acc = vec4f (0.0); cursor = cursor + 1; } else if (op_type == 3) { // POP_GROUP if (sp > 0) { sp = sp - 1; let src = acc; let dst = group_stack[sp]; acc = _hb_gpu_composite (src, dst, aux); } cursor = cursor + 1; } else { break; } } return acc; } /* * Copyright (C) 2026 Behdad Esfahbod * * This is part of HarfBuzz, a text shaping library. * * Permission is hereby granted, without written agreement and without * license or royalty fees, to use, copy, modify, and distribute this * software and its documentation for any purpose, provided that the * above copyright notice and the following two paragraphs appear in * all copies of this software. * * IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN * IF THE COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH * DAMAGE. * * THE COPYRIGHT HOLDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND * FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS * ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. */ /* Paint-renderer fragment shader (HLSL). * * Assumes the shared fragment helpers (hb-gpu-fragment.hlsl) and * the draw-renderer fragment helpers (hb-gpu-draw-fragment.hlsl) * are prepended to this source. */ float4 _hb_gpu_stop_color (int stops_base, int i, float4 foreground, out float offset) { int4 a = hb_gpu_fetch (stops_base + i * 2); offset = (float) a.r / 32767.0; int4 b = hb_gpu_fetch (stops_base + i * 2 + 1); if ((a.g & 1) != 0) return float4 (foreground.rgb, foreground.a * ((float) b.a / 32767.0)); return (float4) b / 32767.0; } float _hb_gpu_extend_t (float t, int extend) { if (extend == 1) return t - floor (t); if (extend == 2) { float u = t - 2.0 * floor (t * 0.5); return u > 1.0 ? 2.0 - u : u; } return clamp (t, 0.0, 1.0); } float4 _hb_gpu_eval_stops (int stops_base, int stop_count, float t, float4 foreground) { float off_prev; float4 col_prev = _hb_gpu_stop_color (stops_base, 0, foreground, off_prev); if (t <= off_prev) return col_prev; for (int i = 1; i < stop_count; i++) { float off; float4 col = _hb_gpu_stop_color (stops_base, i, foreground, off); if (t <= off) { float span = off - off_prev; float f = span > 1e-6 ? (t - off_prev) / span : 0.0; float4 p0 = float4 (col_prev.rgb * col_prev.a, col_prev.a); float4 p1 = float4 (col.rgb * col.a, col.a); float4 pm = lerp (p0, p1, f); return pm.a > 1e-6 ? float4 (pm.rgb / pm.a, pm.a) : float4 (0.0, 0.0, 0.0, 0.0); } col_prev = col; off_prev = off; } return col_prev; } /* Apply the stored 2x2 M^-1 (row-major i16 Q10) to a vector. */ float2 _hb_gpu_apply_minv (int4 m, float2 v) { float4 mf = (float4) m * (1.0 / 1024.0); return float2 (mf.x * v.x + mf.y * v.y, mf.z * v.x + mf.w * v.y); } float4 _hb_gpu_sample_linear (float2 renderCoord, int grad_base, int stop_count, int extend, float4 foreground) { int4 t0 = hb_gpu_fetch (grad_base); int4 m = hb_gpu_fetch (grad_base + 1); float2 p0_r = float2 ((float) t0.r, (float) t0.g); float2 d = float2 ((float) t0.b, (float) t0.a); float denom = dot (d, d); if (denom < 1e-6) return float4 (0.0, 0.0, 0.0, 0.0); float2 p = _hb_gpu_apply_minv (m, renderCoord - p0_r); float t = dot (p, d) / denom; t = _hb_gpu_extend_t (t, extend); return _hb_gpu_eval_stops (grad_base + 2, stop_count, t, foreground); } float4 _hb_gpu_sample_radial (float2 renderCoord, int grad_base, int stop_count, int extend, float4 foreground) { int4 t0 = hb_gpu_fetch (grad_base); int4 t1 = hb_gpu_fetch (grad_base + 1); int4 m = hb_gpu_fetch (grad_base + 2); float2 c0_r = float2 ((float) t0.r, (float) t0.g); float2 cd = float2 ((float) t0.b, (float) t0.a); float r0 = (float) t1.r; float r1 = (float) t1.g; float dr = r1 - r0; float2 p = _hb_gpu_apply_minv (m, renderCoord - c0_r); float A = dot (cd, cd) - dr * dr; float B = -2.0 * (dot (p, cd) + r0 * dr); float C = dot (p, p) - r0 * r0; float t; if (abs (A) > 1e-6) { float disc = B * B - 4.0 * A * C; if (disc < 0.0) return float4 (0.0, 0.0, 0.0, 0.0); float sq = sqrt (disc); float t1r = (-B + sq) / (2.0 * A); float t2r = (-B - sq) / (2.0 * A); t = (r0 + t1r * dr >= 0.0) ? t1r : t2r; } else { if (abs (B) < 1e-6) return float4 (0.0, 0.0, 0.0, 0.0); t = -C / B; } t = _hb_gpu_extend_t (t, extend); return _hb_gpu_eval_stops (grad_base + 3, stop_count, t, foreground); } float4 _hb_gpu_sample_sweep (float2 renderCoord, int grad_base, int stop_count, int extend, float4 foreground) { int4 t0 = hb_gpu_fetch (grad_base); int4 m = hb_gpu_fetch (grad_base + 1); float2 c_r = float2 ((float) t0.r, (float) t0.g); float a0 = (float) t0.b / 16384.0; float a1 = (float) t0.a / 16384.0; float span = a1 - a0; if (abs (span) < 1e-6) return float4 (0.0, 0.0, 0.0, 0.0); float2 p = _hb_gpu_apply_minv (m, renderCoord - c_r); float ang = atan2 (p.y, p.x) / 3.14159265358979; if (ang < 0.0) ang += 2.0; float t = (ang - a0) / span; t = _hb_gpu_extend_t (t, extend); return _hb_gpu_eval_stops (grad_base + 2, stop_count, t, foreground); } float4 _hb_gpu_composite (float4 src, float4 dst, int mode) { float4 r = src + dst * (1.0 - src.a); /* SRC_OVER default */ /* Mode numbers match hb_paint_composite_mode_t. Approximate * unsupported modes with the nearest Porter-Duff mode we do * implement; DIFFERENCE / EXCLUSION / HSL_* still fall through to * SRC_OVER below. */ if (mode == 14 || mode == 18 || mode == 19) mode = 23; /* OVERLAY / COLOR_BURN / HARD_LIGHT -> MULTIPLY */ else if (mode == 17 || mode == 20) mode = 13; /* COLOR_DODGE / SOFT_LIGHT -> SCREEN */ if (mode == 0) r = float4 (0.0, 0.0, 0.0, 0.0); /* CLEAR */ else if (mode == 1) r = src; /* SRC */ else if (mode == 2) r = dst; /* DST */ else if (mode == 4) r = dst + src * (1.0 - dst.a); /* DST_OVER */ else if (mode == 5) r = src * dst.a; /* SRC_IN */ else if (mode == 6) r = dst * src.a; /* DST_IN */ else if (mode == 7) r = src * (1.0 - dst.a); /* SRC_OUT */ else if (mode == 8) r = dst * (1.0 - src.a); /* DST_OUT */ else if (mode == 9) r = src * dst.a + dst * (1.0 - src.a); /* SRC_ATOP */ else if (mode == 10) r = dst * src.a + src * (1.0 - dst.a); /* DST_ATOP */ else if (mode == 11) r = src * (1.0 - dst.a) + dst * (1.0 - src.a); /* XOR */ else if (mode == 12) r = min (src + dst, float4 (1.0, 1.0, 1.0, 1.0)); /* PLUS */ else if (mode == 13) { /* SCREEN (premul) */ r.rgb = src.rgb + dst.rgb - src.rgb * dst.rgb; r.a = src.a + dst.a - src.a * dst.a; } else if (mode == 15) { /* DARKEN */ r.rgb = min (src.rgb * dst.a, dst.rgb * src.a) + src.rgb * (1.0 - dst.a) + dst.rgb * (1.0 - src.a); r.a = src.a + dst.a - src.a * dst.a; } else if (mode == 16) { /* LIGHTEN */ r.rgb = max (src.rgb * dst.a, dst.rgb * src.a) + src.rgb * (1.0 - dst.a) + dst.rgb * (1.0 - src.a); r.a = src.a + dst.a - src.a * dst.a; } else if (mode == 23) { /* MULTIPLY (premul) */ r.rgb = src.rgb * (1.0 - dst.a) + dst.rgb * (1.0 - src.a) + src.rgb * dst.rgb; r.a = src.a + dst.a - src.a * dst.a; } /* SRC_OVER (3) and DIFFERENCE / EXCLUSION / HSL_* (21, 22, 24-27) * fall through to the SRC_OVER default. */ return r; } /* Wrap _hb_gpu_slug with a sub-glyph extents bail-out. Many * paint layers cover a small region of the outer glyph quad; for * fragments outside the layer's bbox (with an AA + MSAA-spread * margin) the slug coverage is exactly 0, so we can skip the * band/curve walk entirely. */ float _hb_gpu_slug_clipped (float2 renderCoord, float2 pixelsPerEm, uint glyphLoc_) { int4 header0 = hb_gpu_fetch ((int) glyphLoc_); float4 ext = (float4) header0 * HB_GPU_INV_UNITS; float2 margin = 2.0 / pixelsPerEm; if (any (renderCoord < ext.xy - margin) || any (renderCoord > ext.zw + margin)) return 0.0; return _hb_gpu_slug (renderCoord, pixelsPerEm, glyphLoc_); } /* Combine slug coverages from all clip outlines on the layer. * Factored so the shader has one set of inlined slug walks * instead of two (one per LAYER op type). flags bits: 0x100 = * HAS_CLIP2; 0x200 = HAS_CLIP3 (HAS_CLIP3 implies HAS_CLIP2). */ float _hb_gpu_layer_coverage (float2 renderCoord, float2 pixelsPerEm, int base, int flags, int clip1_payload, int clip2_payload, int clip3_payload) { float cov = _hb_gpu_slug_clipped (renderCoord, pixelsPerEm, (uint) (base + clip1_payload)); if ((flags & 0x100) != 0) { cov *= _hb_gpu_slug_clipped (renderCoord, pixelsPerEm, (uint) (base + clip2_payload)); if ((flags & 0x200) != 0) cov *= _hb_gpu_slug_clipped (renderCoord, pixelsPerEm, (uint) (base + clip3_payload)); } return cov; } #define HB_GPU_PAINT_GROUP_DEPTH 4 float4 hb_gpu_paint (float2 renderCoord, uint glyphLoc_, float4 foreground, out float coverage) { /* fwidth once, at uniform control flow. */ float2 pixelsPerEm = 1.0 / fwidth (renderCoord); int base = (int) glyphLoc_; int4 h0 = hb_gpu_fetch (base); /* (num_ops, _, _, _) */ int4 h2 = hb_gpu_fetch (base + 2); /* (ops_offset, _, _, _) */ int num_ops = h0.r; int cursor = base + h2.r; float4 acc = float4 (0.0, 0.0, 0.0, 0.0); float4 group_stack[HB_GPU_PAINT_GROUP_DEPTH]; coverage = 0.0; int sp = 0; for (int i = 0; i < num_ops; i++) { int4 op = hb_gpu_fetch (cursor); int op_type = op.r; int aux = op.g; int payload = (op.b << 16) | (op.a & 0xffff); if (op_type == 0) /* LAYER_SOLID */ { /* texel 1: (clip2_hi, clip2_lo, clip3_hi, clip3_lo) -- valid * per HAS_CLIP2 / HAS_CLIP3 flag bits. * texel 2: RGBA as signed Q15. */ int4 op2 = hb_gpu_fetch (cursor + 1); int clip2_payload = (op2.r << 16) | (op2.g & 0xffff); int clip3_payload = (op2.b << 16) | (op2.a & 0xffff); int4 ct = hb_gpu_fetch (cursor + 2); float4 col = ((aux & 1) != 0) ? float4 (foreground.rgb, foreground.a * ((float) ct.a / 32767.0)) : (float4) ct / 32767.0; float cov = _hb_gpu_layer_coverage (renderCoord, pixelsPerEm, base, aux, payload, clip2_payload, clip3_payload); coverage = max (coverage, cov); float4 src = float4 (col.rgb * col.a, col.a) * cov; acc = src + acc * (1.0 - src.a); cursor += 3; } else if (op_type == 1) /* LAYER_GRADIENT */ { int4 op2 = hb_gpu_fetch (cursor + 1); int clip2_payload = (op2.r << 16) | (op2.g & 0xffff); int clip3_payload = (op2.b << 16) | (op2.a & 0xffff); int4 op3 = hb_gpu_fetch (cursor + 2); int grad_payload = (op3.r << 16) | (op3.g & 0xffff); int extend = op3.b; int stop_count = op3.a; int subtype = aux & 0xff; float4 col = float4 (0.0, 0.0, 0.0, 0.0); if (subtype == 0) col = _hb_gpu_sample_linear (renderCoord, base + grad_payload, stop_count, extend, foreground); else if (subtype == 1) col = _hb_gpu_sample_radial (renderCoord, base + grad_payload, stop_count, extend, foreground); else if (subtype == 2) col = _hb_gpu_sample_sweep (renderCoord, base + grad_payload, stop_count, extend, foreground); float cov = _hb_gpu_layer_coverage (renderCoord, pixelsPerEm, base, aux, payload, clip2_payload, clip3_payload); coverage = max (coverage, cov); float4 src = float4 (col.rgb * col.a, col.a) * cov; acc = src + acc * (1.0 - src.a); cursor += 3; } else if (op_type == 2) { if (sp < HB_GPU_PAINT_GROUP_DEPTH) { group_stack[sp] = acc; sp++; } acc = float4 (0.0, 0.0, 0.0, 0.0); cursor += 1; } else if (op_type == 3) { if (sp > 0) { sp--; float4 src = acc; float4 dst = group_stack[sp]; acc = _hb_gpu_composite (src, dst, aux); } cursor += 1; } else { break; } } return acc; } @-q=?0CA@@P?????UUUUUU?UUUUUU?????F̼+D>@F;Pl|||L|,LLL@dl <L0 D,|L< 4