@lightningjs/renderer 3.0.0-beta20 → 3.0.0-beta22

package/dist/src/core/shaders/webgl/RoundedWithBorderAndShadow.js

@@ -22,6 +22,8 @@ export const RoundedWithBorderAndShadow = {
         const props = this.props;
         this.uniformRGBA('u_borderColor', props['border-color']);
         this.uniform4fa('u_borderWidth', props['border-w']);
+        this.uniform1f('u_borderGap', this.props['border-gap']);
+        this.uniform1f('u_borderAlign', this.props['border-align']);
         this.uniformRGBA('u_shadowColor', props['shadow-color']);
         this.uniform4fa('u_shadow', props['shadow-projection']);
         this.uniform4fa('u_radius', calcFactoredRadiusArray(props.radius, node.w, node.h));
@@ -46,45 +48,94 @@ export const RoundedWithBorderAndShadow = {
     uniform vec4 u_shadow;
     uniform vec4 u_radius;
     uniform vec4 u_borderWidth;
+    uniform float u_borderGap;
+    uniform float u_borderAlign;
 
     varying vec4 v_color;
     varying vec2 v_textureCoords;
     varying vec2 v_nodeCoords;
 
-    varying vec4 v_innerRadius;
     varying vec2 v_innerSize;
+    varying vec2 v_outerSize;
+    varying vec2 v_outerBorderUv;
+    varying vec2 v_innerBorderUv;
+    varying vec4 v_innerBorderRadius;
+    varying vec4 v_outerBorderRadius;
     varying vec2 v_halfDimensions;
+    varying float v_edgeWidth;
     varying float v_borderZero;
 
     void main() {
       vec2 screenSpace = vec2(2.0 / u_resolution.x,  -2.0 / u_resolution.y);
-      vec2 outerEdge = clamp(a_nodeCoords * 2.0 - vec2(1.0), -1.0, 1.0);
+      vec2 edge = clamp(a_nodeCoords * 2.0 - vec2(1.0), -1.0, 1.0);
 
-      vec2 shadowEdge = outerEdge * ((u_shadow.w * 2.0)+ u_shadow.z) + u_shadow.xy;
-      vec2 normVertexPos = a_position * u_pixelRatio;
-
-      vec2 vertexPos = (a_position + outerEdge + shadowEdge) * u_pixelRatio;
-      gl_Position = vec4(vertexPos.x * screenSpace.x - 1.0, -sign(screenSpace.y) * (vertexPos.y * -abs(screenSpace.y)) + 1.0, 0.0, 1.0);
-
-      v_halfDimensions = u_dimensions * 0.5;
-
-      v_color = a_color;
-      v_nodeCoords = a_nodeCoords + (screenSpace + shadowEdge) / (u_dimensions);
-      v_textureCoords = a_textureCoords + (screenSpace + shadowEdge) / (u_dimensions);
+      vec2 edgeOffset = edge * ((u_shadow.w * 2.0)+ u_shadow.z) + u_shadow.xy;
+      vec2 vertexPos = (a_position + edge + edgeOffset) * u_pixelRatio;
 
       v_borderZero = u_borderWidth == vec4(0.0) ? 1.0 : 0.0;
 
+      v_innerSize = vec2(0.0);
+      v_outerSize = vec2(0.0);
 
       if(v_borderZero == 0.0) {
-        v_innerRadius = vec4(
-          max(0.0, u_radius.x - max(u_borderWidth.x, u_borderWidth.w) - 0.5),
-          max(0.0, u_radius.y - max(u_borderWidth.x, u_borderWidth.y) - 0.5),
-          max(0.0, u_radius.z - max(u_borderWidth.z, u_borderWidth.y) - 0.5),
-          max(0.0, u_radius.w - max(u_borderWidth.z, u_borderWidth.w) - 0.5)
+        float borderTop = u_borderWidth.x;
+        float borderRight = u_borderWidth.y;
+        float borderBottom = u_borderWidth.z;
+        float borderLeft = u_borderWidth.w;
+
+        v_outerBorderUv = vec2(0.0);
+        v_innerBorderUv = vec2(0.0);
+
+        vec2 borderSize = vec2(borderRight + borderLeft, borderTop + borderBottom);
+        vec2 extraSize = borderSize * u_borderAlign;
+        float gapLeft = step(0.001, borderLeft) * u_borderGap;
+        float gapRight = step(0.001, borderRight) * u_borderGap;
+        float gapTop = step(0.001, borderTop) * u_borderGap;
+        float gapBottom = step(0.001, borderBottom) * u_borderGap;
+        vec2 gapSize = vec2(gapLeft + gapRight, gapTop + gapBottom);
+
+        v_outerSize = (u_dimensions + gapSize + extraSize) * 0.5;
+        v_innerSize = v_outerSize - borderSize * 0.5;
+
+        // Use sign() to avoid branching
+        vec2 borderDiff = vec2(borderRight - borderLeft, borderBottom - borderTop);
+        vec2 signDiff = sign(borderDiff);
+        borderDiff = abs(borderDiff);
+
+        vec2 gapDiff = vec2(gapRight - gapLeft, gapBottom - gapTop);
+        vec2 signGapDiff = sign(gapDiff);
+        gapDiff = abs(gapDiff);
+
+        v_outerBorderUv = -signDiff * borderDiff * u_borderAlign * 0.5 - signGapDiff * gapDiff * 0.5;
+        v_innerBorderUv = v_outerBorderUv + signDiff * borderDiff * 0.5;
+
+        v_outerBorderRadius = vec4(
+          max(0.0, u_radius.x + max(borderTop * u_borderAlign + u_borderGap, borderLeft * u_borderAlign + u_borderGap)),
+          max(0.0, u_radius.y + max(borderTop * u_borderAlign + u_borderGap, borderRight * u_borderAlign + u_borderGap)),
+          max(0.0, u_radius.z + max(borderBottom * u_borderAlign + u_borderGap, borderRight * u_borderAlign + u_borderGap)),
+          max(0.0, u_radius.w + max(borderBottom * u_borderAlign + u_borderGap, borderLeft * u_borderAlign + u_borderGap))
         );
 
-        v_innerSize = (vec2(u_dimensions.x - (u_borderWidth[3] + u_borderWidth[1]) - 1.0, u_dimensions.y - (u_borderWidth[0] + u_borderWidth[2])) - 2.0) * 0.5;
+        v_innerBorderRadius = vec4(
+          max(0.0, v_outerBorderRadius.x - max(borderTop, borderLeft)),
+          max(0.0, v_outerBorderRadius.y - max(borderTop, borderRight)),
+          max(0.0, v_outerBorderRadius.z - max(borderBottom, borderRight)),
+          max(0.0, v_outerBorderRadius.w - max(borderBottom, borderLeft))
+        );
+
+        vec2 edgeOffsetExtra = step(u_dimensions * 0.5, v_outerSize) * edge * (extraSize + u_borderGap);
+        edgeOffset += edgeOffsetExtra;
+
+        vertexPos = (a_position + edge + edgeOffset) * u_pixelRatio;
       }
+
+      gl_Position = vec4(vertexPos.x * screenSpace.x - 1.0, -sign(screenSpace.y) * (vertexPos.y * -abs(screenSpace.y)) + 1.0, 0.0, 1.0);
+
+      v_halfDimensions = u_dimensions * 0.5;
+      v_edgeWidth = 1.0 / u_pixelRatio;
+      v_color = a_color;
+      v_nodeCoords = a_nodeCoords + (screenSpace + edgeOffset) / (u_dimensions);
+      v_textureCoords = a_textureCoords + (screenSpace + edgeOffset) / (u_dimensions);
     }
   `,
     fragment: `
@@ -111,9 +162,14 @@ export const RoundedWithBorderAndShadow = {
     varying vec2 v_textureCoords;
     varying vec2 v_nodeCoords;
 
-    varying vec2 v_halfDimensions;
-    varying vec4 v_innerRadius;
     varying vec2 v_innerSize;
+    varying vec2 v_outerSize;
+    varying vec2 v_outerBorderUv;
+    varying vec2 v_innerBorderUv;
+    varying vec4 v_innerBorderRadius;
+    varying vec4 v_outerBorderRadius;
+    varying vec2 v_halfDimensions;
+    varying float v_edgeWidth;
     varying float v_borderZero;
 
     float roundedBox(vec2 p, vec2 s, vec4 r) {
@@ -133,30 +189,34 @@ export const RoundedWithBorderAndShadow = {
 
     void main() {
       vec4 color = texture2D(u_texture, v_textureCoords) * v_color;
-
+      vec4 resultColor = vec4(0.0);
       vec2 boxUv = v_nodeCoords.xy * u_dimensions - v_halfDimensions;
-      float outerDist = roundedBox(boxUv, v_halfDimensions - 1.0, u_radius);
-
-      float edgeWidth = 1.0 / u_pixelRatio;
-      float outerAlpha = 1.0 - smoothstep(-0.5 * edgeWidth, 0.5 * edgeWidth, outerDist);
-
-      float shadowAlpha = shadowBox(boxUv - u_shadow.xy, v_halfDimensions + u_shadow.w, u_radius + u_shadow.z);
-      vec4 shadow = mix(vec4(0.0), u_shadowColor, shadowAlpha);
+      float nodeDist = roundedBox(boxUv, v_halfDimensions - v_edgeWidth, u_radius);
+      float nodeAlpha = 1.0 - smoothstep(-0.5 * v_edgeWidth, 0.5 * v_edgeWidth, nodeDist);
+      float shadowAlpha;
 
       if(v_borderZero == 1.0) {
-        gl_FragColor = mix(shadow, color, outerAlpha) * u_alpha;
+        shadowAlpha = shadowBox(boxUv - u_shadow.xy, v_halfDimensions + u_shadow.w - v_edgeWidth, u_radius + u_shadow.z);
+        resultColor = mix(resultColor, u_shadowColor, shadowAlpha);
+        gl_FragColor = mix(resultColor, color, nodeAlpha) * u_alpha;
         return;
       }
 
-      boxUv.x += u_borderWidth.y > u_borderWidth.w ? (u_borderWidth.y - u_borderWidth.w) * 0.5 : -(u_borderWidth.w - u_borderWidth.y) * 0.5;
-      boxUv.y += u_borderWidth.z > u_borderWidth.x ? ((u_borderWidth.z - u_borderWidth.x) * 0.5 + 0.5) : -(u_borderWidth.x - u_borderWidth.z) * 0.5;
-
-      float innerDist = roundedBox(boxUv, v_innerSize, v_innerRadius);
-      float innerAlpha = 1.0 - smoothstep(-0.5 * edgeWidth, 0.5 * edgeWidth, innerDist);
+      if(v_outerSize.x > v_halfDimensions.x || v_outerSize.y > v_halfDimensions.y) {
+        shadowAlpha = shadowBox(boxUv + v_outerBorderUv - u_shadow.xy, v_outerSize + u_shadow.w - v_edgeWidth, v_outerBorderRadius + u_shadow.z);
+      }
+      else {
+        shadowAlpha = shadowBox(boxUv - u_shadow.xy, v_halfDimensions + u_shadow.w - v_edgeWidth, u_radius + u_shadow.z);
+      }
 
-      vec4 resColor = mix(u_borderColor, color, innerAlpha);
-      resColor = mix(shadow, resColor, outerAlpha);
-      gl_FragColor = resColor * u_alpha;
+      float outerDist = roundedBox(boxUv + v_outerBorderUv, v_outerSize - v_edgeWidth, v_outerBorderRadius);
+      float innerDist = roundedBox(boxUv + v_innerBorderUv, v_innerSize - v_edgeWidth, v_innerBorderRadius);
+      float borderDist = max(-innerDist, outerDist);
+      float borderAlpha = (1.0 - smoothstep(-0.5 * v_edgeWidth, 0.5 * v_edgeWidth, borderDist)) * u_borderColor.a;
+      resultColor = mix(resultColor, u_shadowColor, shadowAlpha);
+      resultColor = mix(resultColor, color, nodeAlpha);
+      resultColor = mix(resultColor, vec4(u_borderColor.rgb, 1.0), borderAlpha);
+      gl_FragColor = resultColor * u_alpha;
     }
   `,
 };

package/dist/src/core/shaders/webgl/RoundedWithBorderAndShadow.js.map

@@ -1 +1 @@
-{"version":3,"file":"RoundedWithBorderAndShadow.js","sourceRoot":"","sources":["../../../../../src/core/shaders/webgl/RoundedWithBorderAndShadow.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAGH,OAAO,EAAE,uBAAuB,EAAE,MAAM,oBAAoB,CAAC;AAG7D,OAAO,EACL,kCAAkC,GAEnC,MAAM,oDAAoD,CAAC;AAE5D,MAAM,CAAC,MAAM,0BAA0B,GACrC;IACE,KAAK,EAAE,kCAAkC,CAAC,KAAK;IAC/C,MAAM,CAAC,IAAc;QACnB,MAAM,KAAK,GAAG,IAAI,CAAC,KAAM,CAAC;QAC1B,IAAI,CAAC,WAAW,CAAC,eAAe,EAAE,KAAK,CAAC,cAAc,CAAC,CAAC,CAAC;QACzD,IAAI,CAAC,UAAU,CAAC,eAAe,EAAE,KAAK,CAAC,UAAU,CAAS,CAAC,CAAC;QAE5D,IAAI,CAAC,WAAW,CAAC,eAAe,EAAE,KAAK,CAAC,cAAc,CAAC,CAAC,CAAC;QACzD,IAAI,CAAC,UAAU,CAAC,UAAU,EAAE,KAAK,CAAC,mBAAmB,CAAC,CAAC,CAAC;QAExD,IAAI,CAAC,UAAU,CACb,UAAU,EACV,uBAAuB,CAAC,KAAK,CAAC,MAAc,EAAE,IAAI,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,CAAC,CAC9D,CAAC;IACJ,CAAC;IACD,MAAM,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4DT;IACC,QAAQ,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuEX;CACA,CAAC"}
+{"version":3,"file":"RoundedWithBorderAndShadow.js","sourceRoot":"","sources":["../../../../../src/core/shaders/webgl/RoundedWithBorderAndShadow.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAGH,OAAO,EAAE,uBAAuB,EAAE,MAAM,oBAAoB,CAAC;AAG7D,OAAO,EACL,kCAAkC,GAEnC,MAAM,oDAAoD,CAAC;AAE5D,MAAM,CAAC,MAAM,0BAA0B,GACrC;IACE,KAAK,EAAE,kCAAkC,CAAC,KAAK;IAC/C,MAAM,CAAC,IAAc;QACnB,MAAM,KAAK,GAAG,IAAI,CAAC,KAAM,CAAC;QAC1B,IAAI,CAAC,WAAW,CAAC,eAAe,EAAE,KAAK,CAAC,cAAc,CAAC,CAAC,CAAC;QACzD,IAAI,CAAC,UAAU,CAAC,eAAe,EAAE,KAAK,CAAC,UAAU,CAAS,CAAC,CAAC;QAC5D,IAAI,CAAC,SAAS,CAAC,aAAa,EAAE,IAAI,CAAC,KAAM,CAAC,YAAY,CAAW,CAAC,CAAC;QACnE,IAAI,CAAC,SAAS,CAAC,eAAe,EAAE,IAAI,CAAC,KAAM,CAAC,cAAc,CAAW,CAAC,CAAC;QAEvE,IAAI,CAAC,WAAW,CAAC,eAAe,EAAE,KAAK,CAAC,cAAc,CAAC,CAAC,CAAC;QACzD,IAAI,CAAC,UAAU,CAAC,UAAU,EAAE,KAAK,CAAC,mBAAmB,CAAC,CAAC,CAAC;QAExD,IAAI,CAAC,UAAU,CACb,UAAU,EACV,uBAAuB,CAAC,KAAK,CAAC,MAAc,EAAE,IAAI,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,CAAC,CAC9D,CAAC;IACJ,CAAC;IACD,MAAM,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6GT;IACC,QAAQ,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgFX;CACA,CAAC"}

package/dist/src/core/shaders/webgl/RoundedWithShadow.js

@@ -48,6 +48,8 @@ export const RoundedWithShadow = {
     varying vec2 v_textureCoords;
     varying vec2 v_nodeCoords;
 
+    varying float v_edgeWidth;
+
     float roundedBox(vec2 p, vec2 s, vec4 r) {
       r.xy = (p.x > 0.0) ? r.yz : r.xw;
       r.x = (p.y > 0.0) ? r.y : r.x;
@@ -68,12 +70,11 @@ export const RoundedWithShadow = {
       vec2 halfDimensions = (u_dimensions * 0.5);
 
       vec2 boxUv = v_nodeCoords.xy * u_dimensions - halfDimensions;
-      float boxDist = roundedBox(boxUv, halfDimensions, u_radius);
+      float boxDist = roundedBox(boxUv, halfDimensions - v_edgeWidth, u_radius);
 
-      float edgeWidth = 1.0 / u_pixelRatio;
-      float roundedAlpha = 1.0 - smoothstep(-0.5 * edgeWidth, 0.5 * edgeWidth, boxDist);
+      float roundedAlpha = 1.0 - smoothstep(-0.5 * v_edgeWidth, 0.5 * v_edgeWidth, boxDist);
 
-      float shadowAlpha = shadowBox(boxUv - u_shadow.xy, halfDimensions + u_shadow.w, u_radius + u_shadow.z);
+      float shadowAlpha = shadowBox(boxUv - u_shadow.xy, halfDimensions + u_shadow.w - v_edgeWidth, u_radius + u_shadow.z);
 
       vec4 resColor = vec4(0.0);
       resColor = mix(resColor, u_shadow_color, shadowAlpha);

package/dist/src/core/shaders/webgl/RoundedWithShadow.js.map

@@ -1 +1 @@
-{"version":3,"file":"RoundedWithShadow.js","sourceRoot":"","sources":["../../../../../src/core/shaders/webgl/RoundedWithShadow.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAGH,OAAO,EAAE,uBAAuB,EAAE,MAAM,oBAAoB,CAAC;AAG7D,OAAO,EACL,yBAAyB,GAE1B,MAAM,2CAA2C,CAAC;AACnD,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAErC,MAAM,CAAC,MAAM,iBAAiB,GAA4C;IACxE,KAAK,EAAE,yBAAyB,CAAC,KAAK;IACtC,MAAM,CAAC,IAAc;QACnB,IAAI,CAAC,WAAW,CAAC,gBAAgB,EAAE,IAAI,CAAC,KAAM,CAAC,cAAc,CAAE,CAAC,CAAC;QACjE,IAAI,CAAC,UAAU,CAAC,UAAU,EAAE,IAAI,CAAC,KAAM,CAAC,mBAAmB,CAAE,CAAC,CAAC;QAC/D,IAAI,CAAC,UAAU,CACb,UAAU,EACV,uBAAuB,CAAC,IAAI,CAAC,KAAM,CAAC,MAAc,EAAE,IAAI,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,CAAC,CACpE,CAAC;IACJ,CAAC;IACD,MAAM,EAAE,MAAM,CAAC,MAAgB;IAC/B,QAAQ,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuDT;CACF,CAAC"}
+{"version":3,"file":"RoundedWithShadow.js","sourceRoot":"","sources":["../../../../../src/core/shaders/webgl/RoundedWithShadow.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAGH,OAAO,EAAE,uBAAuB,EAAE,MAAM,oBAAoB,CAAC;AAG7D,OAAO,EACL,yBAAyB,GAE1B,MAAM,2CAA2C,CAAC;AACnD,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAErC,MAAM,CAAC,MAAM,iBAAiB,GAA4C;IACxE,KAAK,EAAE,yBAAyB,CAAC,KAAK;IACtC,MAAM,CAAC,IAAc;QACnB,IAAI,CAAC,WAAW,CAAC,gBAAgB,EAAE,IAAI,CAAC,KAAM,CAAC,cAAc,CAAE,CAAC,CAAC;QACjE,IAAI,CAAC,UAAU,CAAC,UAAU,EAAE,IAAI,CAAC,KAAM,CAAC,mBAAmB,CAAE,CAAC,CAAC;QAC/D,IAAI,CAAC,UAAU,CACb,UAAU,EACV,uBAAuB,CAAC,IAAI,CAAC,KAAM,CAAC,MAAc,EAAE,IAAI,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,CAAC,CACpE,CAAC;IACJ,CAAC;IACD,MAAM,EAAE,MAAM,CAAC,MAAgB;IAC/B,QAAQ,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwDT;CACF,CAAC"}

package/dist/src/core/shaders/webgl/Shadow.js

@@ -44,12 +44,14 @@ export const Shadow = {
     varying vec2 v_textureCoords;
     varying vec2 v_nodeCoords;
 
+    varying float v_edgeWidth;
+    varying vec2 v_halfDimensions;
+
     void main() {
       vec2 screenSpace = vec2(2.0 / u_resolution.x,  -2.0 / u_resolution.y);
       vec2 outerEdge = clamp(a_nodeCoords * 2.0 - vec2(1.0), -1.0, 1.0);
 
       vec2 shadowEdge = outerEdge * ((u_shadow.w * 2.0)+ u_shadow.z) + u_shadow.xy;
-      vec2 normVertexPos = a_position * u_pixelRatio;
 
       vec2 vertexPos = (a_position + outerEdge + shadowEdge) * u_pixelRatio;
       gl_Position = vec4(vertexPos.x * screenSpace.x - 1.0, -sign(screenSpace.y) * (vertexPos.y * -abs(screenSpace.y)) + 1.0, 0.0, 1.0);
@@ -57,6 +59,9 @@ export const Shadow = {
       v_color = a_color;
       v_nodeCoords = a_nodeCoords + (screenSpace + shadowEdge) / (u_dimensions);
       v_textureCoords = a_textureCoords + (screenSpace + shadowEdge) / (u_dimensions);
+
+      v_halfDimensions = u_dimensions * 0.5;
+      v_edgeWidth = 1.0 / u_pixelRatio;
     }
   `,
     fragment: `
@@ -79,6 +84,9 @@ export const Shadow = {
     varying vec2 v_textureCoords;
     varying vec2 v_nodeCoords;
 
+    varying vec2 v_halfDimensions;
+    varying float v_edgeWidth;
+
     float box(vec2 p, vec2 s) {
       vec2 q = abs(p) - s;
       return (min(max(q.x, q.y), 0.0) + length(max(q, 0.0))) + 2.0;
@@ -92,13 +100,11 @@ export const Shadow = {
 
     void main() {
       vec4 color = texture2D(u_texture, v_textureCoords) * v_color;
-      vec2 halfDimensions = (u_dimensions * 0.5);
-
-      vec2 boxUv = v_nodeCoords.xy * u_dimensions - halfDimensions;
-      float boxDist = box(boxUv, halfDimensions);
+      vec2 boxUv = v_nodeCoords.xy * u_dimensions - v_halfDimensions;
+      float boxDist = box(boxUv, v_halfDimensions - v_edgeWidth);
 
       float boxAlpha = 1.0 - smoothstep(0.0, u_pixelRatio, boxDist);
-      float shadowDist = shadowBox(boxUv - u_shadow.xy, halfDimensions + u_shadow.w, u_shadow.z);
+      float shadowDist = shadowBox(boxUv - u_shadow.xy, v_halfDimensions + u_shadow.w - v_edgeWidth, u_shadow.z);
 
       vec4 resColor = vec4(0.0);
       resColor = mix(resColor, u_color, shadowDist);

package/dist/src/core/shaders/webgl/Shadow.js.map

@@ -1 +1 @@
-{"version":3,"file":"Shadow.js","sourceRoot":"","sources":["../../../../../src/core/shaders/webgl/Shadow.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAGH,OAAO,EACL,cAAc,GAEf,MAAM,gCAAgC,CAAC;AAExC,MAAM,CAAC,MAAM,MAAM,GAAiC;IAClD,KAAK,EAAE,cAAc,CAAC,KAAK;IAC3B,MAAM;QACJ,IAAI,CAAC,WAAW,CAAC,SAAS,EAAE,IAAI,CAAC,KAAM,CAAC,KAAK,CAAC,CAAC;QAC/C,IAAI,CAAC,UAAU,CAAC,UAAU,EAAE,IAAI,CAAC,KAAM,CAAC,UAAU,CAAC,CAAC;IACtD,CAAC;IACD,MAAM,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCP;IACD,QAAQ,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CT;CACF,CAAC"}
+{"version":3,"file":"Shadow.js","sourceRoot":"","sources":["../../../../../src/core/shaders/webgl/Shadow.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAGH,OAAO,EACL,cAAc,GAEf,MAAM,gCAAgC,CAAC;AAExC,MAAM,CAAC,MAAM,MAAM,GAAiC;IAClD,KAAK,EAAE,cAAc,CAAC,KAAK;IAC3B,MAAM;QACJ,IAAI,CAAC,WAAW,CAAC,SAAS,EAAE,IAAI,CAAC,KAAM,CAAC,KAAK,CAAC,CAAC;QAC/C,IAAI,CAAC,UAAU,CAAC,UAAU,EAAE,IAAI,CAAC,KAAM,CAAC,UAAU,CAAC,CAAC;IACtD,CAAC;IACD,MAAM,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CP;IACD,QAAQ,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CT;CACF,CAAC"}

package/dist/src/core/text-rendering/CanvasFont.d.ts

@@ -0,0 +1,14 @@
+import { CoreFont, type CoreFontProps } from './CoreFont.js';
+import type { NormalizedFontMetrics, TextRenderer } from './TextRenderer.js';
+export type CanvasFontProps = CoreFontProps & {
+    fontUrl: string;
+};
+export declare class CanvasFont extends CoreFont {
+    private measureContext;
+    type: string;
+    url: string;
+    constructor(textRenderer: TextRenderer, props: CanvasFontProps, measureContext: CanvasRenderingContext2D | OffscreenCanvasRenderingContext2D);
+    load(): void;
+    measureText(text: string, letterSpacing: number): number;
+    getMetrics(fontSize: number): NormalizedFontMetrics;
+}

package/dist/src/core/text-rendering/CanvasFont.js

@@ -0,0 +1,115 @@
+/*
+ * If not stated otherwise in this file or this component's LICENSE file the
+ * following copyright and licenses apply:
+ *
+ * Copyright 2025 Comcast Cable Communications Management, LLC.
+ *
+ * Licensed under the Apache License, Version 2.0 (the License);
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { CoreFont, FontState } from './CoreFont.js';
+import { normalizeFontMetrics } from './TextLayoutEngine.js';
+import { hasZeroWidthSpace } from './Utils.js';
+export class CanvasFont extends CoreFont {
+    measureContext;
+    type = 'canvas';
+    url;
+    constructor(textRenderer, props, measureContext) {
+        super(textRenderer, props);
+        this.measureContext = measureContext;
+        this.url = props.fontUrl;
+        this.metrics = props.metrics;
+    }
+    load() {
+        if (this.state !== FontState.Created) {
+            return;
+        }
+        if (this.family === 'sans-serif') {
+            // Default font, skip loading
+            this.onLoaded();
+            return;
+        }
+        this.state = FontState.Loading;
+        new FontFace(this.family, `url(${this.url})`)
+            .load()
+            .then((loadedFont) => {
+            document.fonts.add(loadedFont);
+            this.onLoaded();
+        })
+            .catch((error) => {
+            this.state = FontState.Failed;
+            console.error(`Failed to load font: ${this.family}`, error);
+            this.emit('failed');
+            throw error;
+        });
+    }
+    measureText(text, letterSpacing) {
+        if (letterSpacing === 0) {
+            return this.measureContext.measureText(text).width;
+        }
+        if (hasZeroWidthSpace(text) === false) {
+            return (this.measureContext.measureText(text).width +
+                letterSpacing * text.length);
+        }
+        return text.split('').reduce((acc, char) => {
+            if (hasZeroWidthSpace(char) === true) {
+                return acc;
+            }
+            return acc + this.measureContext.measureText(char).width + letterSpacing;
+        }, 0);
+    }
+    getMetrics(fontSize) {
+        let m = this.normalizedMetrics[fontSize];
+        if (m !== undefined) {
+            return m;
+        }
+        let metrics = this.metrics;
+        if (metrics === undefined) {
+            metrics = calculateCanvasMetrics(this.family, fontSize, this.measureContext);
+        }
+        m = this.normalizedMetrics[fontSize] = normalizeFontMetrics(metrics, fontSize);
+        return m;
+    }
+}
+function calculateCanvasMetrics(fontFamily, fontSize, measureContext) {
+    // If the font face doesn't have metrics defined, we fallback to using the
+    // browser's measureText method to calculate take a best guess at the font
+    // actual font's metrics.
+    // - fontBoundingBox[Ascent|Descent] is the best estimate but only supported
+    //   in Chrome 87+ (2020), Firefox 116+ (2023), and Safari 11.1+ (2018).
+    //   - It is an estimate as it can vary between browsers.
+    // - actualBoundingBox[Ascent|Descent] is less accurate and supported in
+    //   Chrome 77+ (2019), Firefox 74+ (2020), and Safari 11.1+ (2018).
+    // - If neither are supported, we'll use some default values which will
+    //   get text on the screen but likely not be great.
+    // NOTE: It's been decided not to rely on fontBoundingBox[Ascent|Descent]
+    // as it's browser support is limited and it also tends to produce higher than
+    // expected values. It is instead HIGHLY RECOMMENDED that developers provide
+    // explicit metrics in the font face definition.
+    measureContext.font = `normal ${fontSize}px Unknown, ${fontFamily}`;
+    const metrics = measureContext.measureText('ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz');
+    console.warn(`Font metrics not provided for Canvas Web font ${fontFamily}. ` +
+        'Using fallback values. It is HIGHLY recommended you use the latest ' +
+        'version of the Lightning 3 `msdf-generator` tool to extract the default ' +
+        'metrics for the font and provide them in the Canvas Web font definition.');
+    const ascender = metrics.fontBoundingBoxAscent ?? metrics.actualBoundingBoxAscent ?? 0;
+    const descender = metrics.fontBoundingBoxDescent ?? metrics.actualBoundingBoxDescent ?? 0;
+    return {
+        ascender,
+        descender: -descender,
+        lineGap: (metrics.emHeightAscent ?? 0) +
+            (metrics.emHeightDescent ?? 0) -
+            (ascender + descender),
+        unitsPerEm: (metrics.emHeightAscent ?? 0) + (metrics.emHeightDescent ?? 0),
+    };
+}
+//# sourceMappingURL=CanvasFont.js.map

package/dist/src/core/text-rendering/CanvasFont.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"CanvasFont.js","sourceRoot":"","sources":["../../../../src/core/text-rendering/CanvasFont.ts"],"names":[],"mappings":"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"}

package/dist/src/core/text-rendering/CoreFont.d.ts

@@ -0,0 +1,33 @@
+import type { CoreTextNode } from '../CoreTextNode.js';
+import type { FontMetrics, NormalizedFontMetrics, TextRenderer } from './TextRenderer.js';
+import { EventEmitter } from '../../common/EventEmitter.js';
+export declare enum FontState {
+    Created = 0,
+    Loading = 1,
+    Loaded = 2,
+    Failed = 3
+}
+export interface CoreFontProps {
+    fontFamily: string;
+    metrics?: FontMetrics;
+}
+/**
+ * EventEmiter only intended to communicated with FontManager
+ */
+export declare abstract class CoreFont extends EventEmitter {
+    protected waitingNodes?: Record<number, CoreTextNode>;
+    protected normalizedMetrics?: Record<number, NormalizedFontMetrics>;
+    textRenderer: TextRenderer;
+    state: FontState;
+    family: string;
+    metrics?: FontMetrics;
+    constructor(textRenderer: TextRenderer, props: CoreFontProps);
+    protected onLoaded(): void;
+    waiting(node: CoreTextNode): void;
+    stopWaiting(node: CoreTextNode): void;
+    destroy(): void;
+    abstract type: string;
+    abstract load(): void;
+    abstract measureText(text: string, letterSpacing: number): number;
+    abstract getMetrics(fontSize: number): NormalizedFontMetrics;
+}

package/dist/src/core/text-rendering/CoreFont.js

@@ -0,0 +1,48 @@
+import { UpdateType } from '../CoreNode.js';
+import { EventEmitter } from '../../common/EventEmitter.js';
+export var FontState;
+(function (FontState) {
+    FontState[FontState["Created"] = 0] = "Created";
+    FontState[FontState["Loading"] = 1] = "Loading";
+    FontState[FontState["Loaded"] = 2] = "Loaded";
+    FontState[FontState["Failed"] = 3] = "Failed";
+})(FontState || (FontState = {}));
+/**
+ * EventEmiter only intended to communicated with FontManager
+ */
+export class CoreFont extends EventEmitter {
+    waitingNodes = Object.create(null);
+    normalizedMetrics = Object.create(null);
+    textRenderer;
+    state;
+    family;
+    metrics;
+    constructor(textRenderer, props) {
+        super();
+        this.family = props.fontFamily;
+        this.state = FontState.Created;
+        this.textRenderer = textRenderer;
+    }
+    onLoaded() {
+        const waitingNodes = this.waitingNodes;
+        for (let key in waitingNodes) {
+            waitingNodes[key].setUpdateType(UpdateType.Local);
+            delete waitingNodes[key];
+        }
+        this.state = FontState.Loaded;
+    }
+    waiting(node) {
+        this.waitingNodes[node.id] = node;
+    }
+    stopWaiting(node) {
+        if (this.waitingNodes[node.id]) {
+            delete this.waitingNodes[node.id];
+        }
+    }
+    destroy() {
+        delete this.waitingNodes;
+        delete this.normalizedMetrics;
+        delete this.metrics;
+    }
+}
+//# sourceMappingURL=CoreFont.js.map

package/dist/src/core/text-rendering/CoreFont.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"CoreFont.js","sourceRoot":"","sources":["../../../../src/core/text-rendering/CoreFont.ts"],"names":[],"mappings":"AAwBA,OAAO,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAC5C,OAAO,EAAE,YAAY,EAAE,MAAM,8BAA8B,CAAC;AAE5D,MAAM,CAAN,IAAY,SAKX;AALD,WAAY,SAAS;IACnB,+CAAO,CAAA;IACP,+CAAO,CAAA;IACP,6CAAM,CAAA;IACN,6CAAM,CAAA;AACR,CAAC,EALW,SAAS,KAAT,SAAS,QAKpB;AAOD;;GAEG;AACH,MAAM,OAAgB,QAAS,SAAQ,YAAY;IACvC,YAAY,GAAkC,MAAM,CAAC,MAAM,CACnE,IAAI,CAC2B,CAAC;IACxB,iBAAiB,GACzB,MAAM,CAAC,MAAM,CAAC,IAAI,CAA0C,CAAC;IAExD,YAAY,CAAe;IAC3B,KAAK,CAAY;IACjB,MAAM,CAAS;IACf,OAAO,CAAe;IAE7B,YAAY,YAA0B,EAAE,KAAoB;QAC1D,KAAK,EAAE,CAAC;QACR,IAAI,CAAC,MAAM,GAAG,KAAK,CAAC,UAAU,CAAC;QAC/B,IAAI,CAAC,KAAK,GAAG,SAAS,CAAC,OAAO,CAAC;QAC/B,IAAI,CAAC,YAAY,GAAG,YAAY,CAAC;IACnC,CAAC;IAES,QAAQ;QAChB,MAAM,YAAY,GAAG,IAAI,CAAC,YAAY,CAAC;QACvC,KAAK,IAAI,GAAG,IAAI,YAAY,EAAE,CAAC;YAC7B,YAAY,CAAC,GAAG,CAAE,CAAC,aAAa,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC;YACnD,OAAO,YAAY,CAAC,GAAG,CAAC,CAAC;QAC3B,CAAC;QACD,IAAI,CAAC,KAAK,GAAG,SAAS,CAAC,MAAM,CAAC;IAChC,CAAC;IAEM,OAAO,CAAC,IAAkB;QAC/B,IAAI,CAAC,YAAa,CAAC,IAAI,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC;IACrC,CAAC;IAEM,WAAW,CAAC,IAAkB;QACnC,IAAI,IAAI,CAAC,YAAa,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE,CAAC;YAChC,OAAO,IAAI,CAAC,YAAa,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;QACrC,CAAC;IACH,CAAC;IAEM,OAAO;QACZ,OAAO,IAAI,CAAC,YAAY,CAAC;QACzB,OAAO,IAAI,CAAC,iBAAiB,CAAC;QAC9B,OAAO,IAAI,CAAC,OAAO,CAAC;IACtB,CAAC;CAMF"}

package/dist/src/core/text-rendering/FontManager.d.ts

@@ -0,0 +1,11 @@
+import type { Stage } from '../Stage.js';
+import type { CoreFont } from './CoreFont.js';
+import type { FontLoadOptions, TextRenderer, TextRenderers } from './TextRenderer.js';
+export declare class CoreFontManager {
+    private fonts;
+    private renderers;
+    constructor(stage: Stage, textRenderers: TextRenderer[]);
+    loadFont(type: TextRenderers, options: FontLoadOptions): void;
+    unloadFont(fontFamily: string): void;
+    getFont(fontFamily: string): CoreFont | undefined;
+}

package/dist/src/core/text-rendering/FontManager.js

@@ -0,0 +1,41 @@
+export class CoreFontManager {
+    fonts = Object.create(null);
+    renderers = Object.create(null);
+    constructor(stage, textRenderers) {
+        for (let i = 0; i < textRenderers.length; i++) {
+            const renderer = textRenderers[i];
+            this.renderers[renderer.type] = renderer;
+            renderer.init(stage, this);
+        }
+    }
+    loadFont(type, options) {
+        const targetRenderer = this.renderers[type];
+        if (targetRenderer === undefined) {
+            console.error('renderer type for this font does not exist');
+            return;
+        }
+        const font = targetRenderer.createFont(options);
+        if (font === undefined) {
+            return;
+        }
+        font.load();
+        this.fonts[options.fontFamily] = font;
+    }
+    unloadFont(fontFamily) {
+        const targetFont = this.fonts[fontFamily];
+        if (targetFont === undefined) {
+            return;
+        }
+        targetFont.destroy();
+        delete this.fonts[fontFamily];
+    }
+    getFont(fontFamily) {
+        const font = this.fonts[fontFamily];
+        if (font === undefined) {
+            console.warn('fontFamily not registered');
+            return;
+        }
+        return font;
+    }
+}
+//# sourceMappingURL=FontManager.js.map

package/dist/src/core/text-rendering/FontManager.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"FontManager.js","sourceRoot":"","sources":["../../../../src/core/text-rendering/FontManager.ts"],"names":[],"mappings":"AAQA,MAAM,OAAO,eAAe;IAClB,KAAK,GAA6B,MAAM,CAAC,MAAM,CAAC,IAAI,CAG3D,CAAC;IACM,SAAS,GAAiC,MAAM,CAAC,MAAM,CAC7D,IAAI,CAC2B,CAAC;IAElC,YAAY,KAAY,EAAE,aAA6B;QACrD,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,aAAa,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;YAC9C,MAAM,QAAQ,GAAG,aAAa,CAAC,CAAC,CAAE,CAAC;YACnC,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,IAAI,CAAC,GAAG,QAAQ,CAAC;YACzC,QAAQ,CAAC,IAAI,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC;QAC7B,CAAC;IACH,CAAC;IAED,QAAQ,CAAC,IAAmB,EAAE,OAAwB;QACpD,MAAM,cAAc,GAAG,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC;QAC5C,IAAI,cAAc,KAAK,SAAS,EAAE,CAAC;YACjC,OAAO,CAAC,KAAK,CAAC,4CAA4C,CAAC,CAAC;YAC5D,OAAO;QACT,CAAC;QACD,MAAM,IAAI,GAAG,cAAc,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC;QAChD,IAAI,IAAI,KAAK,SAAS,EAAE,CAAC;YACvB,OAAO;QACT,CAAC;QACD,IAAI,CAAC,IAAI,EAAE,CAAC;QACZ,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,UAAU,CAAC,GAAG,IAAI,CAAC;IACxC,CAAC;IAED,UAAU,CAAC,UAAkB;QAC3B,MAAM,UAAU,GAAG,IAAI,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC;QAC1C,IAAI,UAAU,KAAK,SAAS,EAAE,CAAC;YAC7B,OAAO;QACT,CAAC;QACD,UAAU,CAAC,OAAO,EAAE,CAAC;QACrB,OAAO,IAAI,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC;IAChC,CAAC;IAED,OAAO,CAAC,UAAkB;QACxB,MAAM,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC;QACpC,IAAI,IAAI,KAAK,SAAS,EAAE,CAAC;YACvB,OAAO,CAAC,IAAI,CAAC,2BAA2B,CAAC,CAAC;YAC1C,OAAO;QACT,CAAC;QACD,OAAO,IAAI,CAAC;IACd,CAAC;CACF"}

package/dist/src/core/text-rendering/SdfFont.d.ts

@@ -0,0 +1,29 @@
+import type { Stage } from '../Stage.js';
+import type { ImageTexture } from '../textures/ImageTexture.js';
+import { CoreFont, type CoreFontProps } from './CoreFont.js';
+import { type SdfFontData } from './SdfFontHandler.js';
+import type { NormalizedFontMetrics, TextRenderer } from './TextRenderer.js';
+export type SdfFontProps = CoreFontProps & {
+    atlasUrl: string;
+    atlasDataUrl: string;
+};
+export declare class SdfFont extends CoreFont {
+    private stage;
+    type: string;
+    atlasUrl: string;
+    atlasDataUrl: string;
+    atlasTexture?: ImageTexture;
+    private glyphMap?;
+    private kerningTable?;
+    private data?;
+    constructor(textRenderer: TextRenderer, props: SdfFontProps, stage: Stage);
+    load(): void;
+    private hardFail;
+    private processFontData;
+    measureText(text: string, letterSpacing: number): number;
+    getMetrics(fontSize: number): NormalizedFontMetrics;
+    getGlyph(codepoint: number): import("./SdfFontHandler.js").SdfGlyph | null;
+    getKerning(firstGlyph: number, secondGlyph: number): number;
+    getAtlas(): ImageTexture;
+    getData(): SdfFontData;
+}