@next2d/webgpu 3.0.0

package/src/Shader/wgsl/fragment/BitmapFragment.js

@@ -0,0 +1,43 @@
+export const BitmapFillFragment = /* wgsl */ `
+struct VertexOutput {
+    @builtin(position) position: vec4<f32>,
+    @location(0) bezier: vec2<f32>,
+    @location(1) color: vec4<f32>,
+    @location(2) worldPos: vec2<f32>,
+}
+
+struct BitmapUniforms {
+    bitmapMatrix: mat3x3<f32>,
+    textureWidth: f32,
+    textureHeight: f32,
+    repeat: f32,
+    _pad: f32,
+}
+
+@group(0) @binding(0) var<uniform> uniforms: BitmapUniforms;
+@group(0) @binding(1) var bitmapSampler: sampler;
+@group(0) @binding(2) var bitmapTexture: texture_2d<f32>;
+
+@fragment
+fn main(input: VertexOutput) -> @location(0) vec4<f32> {
+    let u = input.bezier.x;
+    let v = input.bezier.y;
+    if (abs(u - 0.5) > 0.001 || abs(v - 0.5) > 0.001) {
+        let d = u * u - v;
+        if (d > 0.0) {
+            discard;
+        }
+    }
+    let transformedPos = uniforms.bitmapMatrix * vec3<f32>(input.worldPos, 1.0);
+    var uv = vec2<f32>(
+        transformedPos.x / uniforms.textureWidth,
+        transformedPos.y / uniforms.textureHeight
+    );
+    if (uniforms.repeat > 0.5) {
+        uv = fract(uv);
+    }
+    let bitmapColor = textureSampleLevel(bitmapTexture, bitmapSampler, uv, 0);
+    let alpha = bitmapColor.a * input.color.a;
+    return vec4<f32>(bitmapColor.rgb * input.color.a, alpha);
+}
+`;

package/src/Shader/wgsl/fragment/BlendFragment.d.ts

@@ -0,0 +1,8 @@
+export declare const MultiplyBlendFragment: string;
+export declare const ScreenBlendFragment: string;
+export declare const LightenBlendFragment: string;
+export declare const DarkenBlendFragment: string;
+export declare const OverlayBlendFragment: string;
+export declare const HardLightBlendFragment: string;
+export declare const DifferenceBlendFragment: string;
+export declare const SubtractBlendFragment: string;

package/src/Shader/wgsl/fragment/BlendFragment.js

@@ -0,0 +1,63 @@
+/**
+ * @description ブレンドシェーダー共通ヘッダー
+ */
+const BLEND_HEADER = /* wgsl */ `struct VertexOutput {
+    @builtin(position) position: vec4<f32>,
+    @location(0) texCoord: vec2<f32>,
+}
+
+struct BlendUniforms {
+    colorTransform: vec4<f32>,
+    addColor: vec4<f32>,
+}
+
+@group(0) @binding(0) var<uniform> uniforms: BlendUniforms;
+@group(0) @binding(1) var sampler0: sampler;
+@group(0) @binding(2) var texture0: texture_2d<f32>;
+@group(0) @binding(3) var texture1: texture_2d<f32>;
+`;
+/**
+ * @description alpha guard 付きブレンドシェーダーを生成
+ */
+const createBlendFragment = (blendLogic) => BLEND_HEADER + /* wgsl */ `
+@fragment
+fn main(input: VertexOutput) -> @location(0) vec4<f32> {
+    var src = textureSampleLevel(texture1, sampler0, input.texCoord, 0);
+    var dst = textureSampleLevel(texture0, sampler0, input.texCoord, 0);
+    if (src.a == 0.0) { return dst; }
+    if (dst.a == 0.0) { return src; }
+    src = src * uniforms.colorTransform + vec4<f32>(uniforms.addColor.rgb, 0.0);
+    let a = src - src * dst.a;
+    let b = dst - dst * src.a;
+    var srcRgb = src.rgb / src.a;
+    var dstRgb = dst.rgb / dst.a;
+${blendLogic}
+    c = vec4<f32>(c.rgb * c.a, c.a);
+    return a + b + c;
+}
+`;
+export const MultiplyBlendFragment = BLEND_HEADER + /* wgsl */ `
+@fragment
+fn main(input: VertexOutput) -> @location(0) vec4<f32> {
+    var src = textureSampleLevel(texture1, sampler0, input.texCoord, 0);
+    var dst = textureSampleLevel(texture0, sampler0, input.texCoord, 0);
+    src = src * uniforms.colorTransform + vec4<f32>(uniforms.addColor.rgb, 0.0);
+    let a = src - src * dst.a;
+    let b = dst - dst * src.a;
+    let c = src * dst;
+    return a + b + c;
+}
+`;
+export const ScreenBlendFragment = createBlendFragment("    var c = vec4<f32>(srcRgb + dstRgb - srcRgb * dstRgb, src.a * dst.a);");
+export const LightenBlendFragment = createBlendFragment("    var c = vec4<f32>(max(srcRgb, dstRgb), src.a * dst.a);");
+export const DarkenBlendFragment = createBlendFragment("    var c = vec4<f32>(min(srcRgb, dstRgb), src.a * dst.a);");
+export const OverlayBlendFragment = createBlendFragment(`    let s = step(vec3<f32>(0.5), dstRgb);
+    let lo = 2.0 * srcRgb * dstRgb;
+    let hi = 1.0 - 2.0 * (1.0 - srcRgb) * (1.0 - dstRgb);
+    var c = vec4<f32>(mix(lo, hi, s), src.a * dst.a);`);
+export const HardLightBlendFragment = createBlendFragment(`    let s = step(vec3<f32>(0.5), srcRgb);
+    let lo = 2.0 * srcRgb * dstRgb;
+    let hi = 1.0 - 2.0 * (1.0 - srcRgb) * (1.0 - dstRgb);
+    var c = vec4<f32>(mix(lo, hi, s), src.a * dst.a);`);
+export const DifferenceBlendFragment = createBlendFragment("    var c = vec4<f32>(abs(srcRgb - dstRgb), src.a * dst.a);");
+export const SubtractBlendFragment = createBlendFragment("    var c = vec4<f32>(max(dstRgb - srcRgb, vec3<f32>(0.0)), src.a * dst.a);");

package/src/Shader/wgsl/fragment/EffectFragment.d.ts

@@ -0,0 +1,6 @@
+export declare const GlowFilterFragment = "\n\nstruct VertexOutput {\n    @builtin(position) position: vec4<f32>,\n    @location(0) texCoord: vec2<f32>,\n}\n\noverride IS_INNER: u32 = 0u;\noverride IS_KNOCKOUT: u32 = 0u;\n\nstruct GlowUniforms {\n    color: vec4<f32>,\n    baseScale: vec2<f32>,\n    baseOffset: vec2<f32>,\n    blurScale: vec2<f32>,\n    blurOffset: vec2<f32>,\n    strength: f32,\n    _padding1: f32,\n    _padding2: f32,\n    _padding3: f32,\n}\n\n@group(0) @binding(0) var<uniform> uniforms: GlowUniforms;\n@group(0) @binding(1) var textureSampler: sampler;\n@group(0) @binding(2) var blurTexture: texture_2d<f32>;\n@group(0) @binding(3) var baseTexture: texture_2d<f32>;\n\nfn isInside(uv: vec2<f32>) -> f32 {\n    let s = step(vec2<f32>(0.0), uv) * step(uv, vec2<f32>(1.0));\n    return s.x * s.y;\n}\n\n@fragment\nfn main(input: VertexOutput) -> @location(0) vec4<f32> {\n    let baseUV = input.texCoord * uniforms.baseScale - uniforms.baseOffset;\n    let baseColor = textureSampleLevel(baseTexture, textureSampler, baseUV, 0) * isInside(baseUV);\n\n    let blurUV = input.texCoord * uniforms.blurScale - uniforms.blurOffset;\n    let blurColor = textureSampleLevel(blurTexture, textureSampler, blurUV, 0) * isInside(blurUV);\n\n    var rawAlpha = blurColor.a;\n    if (IS_INNER == 1u) {\n        rawAlpha = 1.0 - rawAlpha;\n    }\n    let glowAlpha = clamp(rawAlpha * uniforms.strength, 0.0, 1.0);\n    let glowColor = vec4<f32>(uniforms.color.rgb * glowAlpha, uniforms.color.a * glowAlpha);\n    if (IS_INNER == 1u) {\n        let innerGlow = glowColor * baseColor.a;\n        if (IS_KNOCKOUT == 1u) {\n            return innerGlow;\n        } else {\n            return innerGlow + baseColor * (1.0 - glowColor.a);\n        }\n    } else {\n        if (IS_KNOCKOUT == 1u) {\n            return glowColor * (1.0 - baseColor.a);\n        } else {\n            return baseColor + glowColor * (1.0 - baseColor.a);\n        }\n    }\n}\n";
+export declare const DropShadowFilterFragment = "\n\nstruct VertexOutput {\n    @builtin(position) position: vec4<f32>,\n    @location(0) texCoord: vec2<f32>,\n}\n\noverride IS_INNER: u32 = 0u;\noverride IS_KNOCKOUT: u32 = 0u;\noverride IS_HIDE_OBJECT: u32 = 0u;\n\nstruct DropShadowUniforms {\n    color: vec4<f32>,\n    baseScale: vec2<f32>,\n    baseOffset: vec2<f32>,\n    blurScale: vec2<f32>,\n    blurOffset: vec2<f32>,\n    strength: f32,\n    _padding1: f32,\n    _padding2: f32,\n    _padding3: f32,\n}\n\n@group(0) @binding(0) var<uniform> uniforms: DropShadowUniforms;\n@group(0) @binding(1) var textureSampler: sampler;\n@group(0) @binding(2) var blurTexture: texture_2d<f32>;\n@group(0) @binding(3) var baseTexture: texture_2d<f32>;\n\nfn isInside(uv: vec2<f32>) -> f32 {\n    let s = step(vec2<f32>(0.0), uv) * step(uv, vec2<f32>(1.0));\n    return s.x * s.y;\n}\n\n@fragment\nfn main(input: VertexOutput) -> @location(0) vec4<f32> {\n    let baseUV = input.texCoord * uniforms.baseScale - uniforms.baseOffset;\n    let baseColor = textureSampleLevel(baseTexture, textureSampler, baseUV, 0) * isInside(baseUV);\n\n    let blurUV = input.texCoord * uniforms.blurScale - uniforms.blurOffset;\n    let blur = textureSampleLevel(blurTexture, textureSampler, blurUV, 0) * isInside(blurUV);\n\n    var rawAlpha = blur.a;\n    if (IS_INNER == 1u) {\n        rawAlpha = 1.0 - rawAlpha;\n    }\n    let shadowAlpha = clamp(rawAlpha * uniforms.strength, 0.0, 1.0);\n    let shadowColor = vec4<f32>(uniforms.color.rgb * shadowAlpha, uniforms.color.a * shadowAlpha);\n\n    if (IS_INNER == 1u) {\n        let innerShadow = shadowColor * baseColor.a;\n        if (IS_KNOCKOUT == 1u) {\n            return innerShadow;\n        } else {\n            return innerShadow + baseColor * (1.0 - shadowColor.a);\n        }\n    } else {\n        if (IS_HIDE_OBJECT == 1u) {\n            return shadowColor;\n        } else if (IS_KNOCKOUT == 1u) {\n            return shadowColor * (1.0 - baseColor.a);\n        } else {\n            return shadowColor * (1.0 - baseColor.a) + baseColor;\n        }\n    }\n}\n";
+export declare const GradientGlowFilterFragment = "\n\nstruct VertexOutput {\n    @builtin(position) position: vec4<f32>,\n    @location(0) texCoord: vec2<f32>,\n}\n\noverride GLOW_TYPE: u32 = 0u;\noverride IS_KNOCKOUT: u32 = 0u;\n\nstruct GradientGlowUniforms {\n    strength: f32,\n    _padding1: f32,\n    _padding2: f32,\n    _padding3: f32,\n    baseScale: vec2<f32>,\n    baseOffset: vec2<f32>,\n    blurScale: vec2<f32>,\n    blurOffset: vec2<f32>,\n}\n\n@group(0) @binding(0) var<uniform> uniforms: GradientGlowUniforms;\n@group(0) @binding(1) var textureSampler: sampler;\n@group(0) @binding(2) var blurTexture: texture_2d<f32>;\n@group(0) @binding(3) var baseTexture: texture_2d<f32>;\n@group(0) @binding(4) var gradientLUT: texture_2d<f32>;\n\nfn isInside(uv: vec2<f32>) -> f32 {\n    let s = step(vec2<f32>(0.0), uv) * step(uv, vec2<f32>(1.0));\n    return s.x * s.y;\n}\n\n@fragment\nfn main(input: VertexOutput) -> @location(0) vec4<f32> {\n    let baseUV = input.texCoord * uniforms.baseScale - uniforms.baseOffset;\n    let base = textureSampleLevel(baseTexture, textureSampler, baseUV, 0) * isInside(baseUV);\n\n    let blurUV = input.texCoord * uniforms.blurScale - uniforms.blurOffset;\n    var blur = textureSampleLevel(blurTexture, textureSampler, blurUV, 0) * isInside(blurUV);\n\n    blur.a = clamp(blur.a * uniforms.strength, 0.0, 1.0);\n    let glowColor = textureSampleLevel(gradientLUT, textureSampler, vec2<f32>(blur.a, 0.5), 0);\n    var result: vec4<f32>;\n    if (GLOW_TYPE == 0u) {\n        if (IS_KNOCKOUT == 1u) {\n            result = glowColor;\n        } else {\n            result = base - base * glowColor.a + glowColor;\n        }\n    } else if (GLOW_TYPE == 1u) {\n        if (IS_KNOCKOUT == 1u) {\n            result = glowColor * base.a;\n        } else {\n            result = glowColor * base.a + base * (1.0 - glowColor.a);\n        }\n    } else {\n        if (IS_KNOCKOUT == 1u) {\n            result = glowColor - glowColor * base.a;\n        } else {\n            result = base + glowColor - glowColor * base.a;\n        }\n    }\n    return result;\n}\n";
+export declare const GradientBevelFilterFragment = "\n\nstruct VertexOutput {\n    @builtin(position) position: vec4<f32>,\n    @location(0) texCoord: vec2<f32>,\n}\n\noverride BEVEL_TYPE: u32 = 0u;\noverride IS_KNOCKOUT: u32 = 0u;\n\nstruct GradientBevelUniforms {\n    strength: f32,\n    _padding1: f32,\n    _padding2: f32,\n    _padding3: f32,\n    baseScale: vec2<f32>,\n    baseOffset: vec2<f32>,\n    blurScale: vec2<f32>,\n    blurOffset: vec2<f32>,\n}\n\n@group(0) @binding(0) var<uniform> uniforms: GradientBevelUniforms;\n@group(0) @binding(1) var textureSampler: sampler;\n@group(0) @binding(2) var blurTexture: texture_2d<f32>;\n@group(0) @binding(3) var baseTexture: texture_2d<f32>;\n@group(0) @binding(4) var gradientLUT: texture_2d<f32>;\n\nfn isInside(uv: vec2<f32>) -> f32 {\n    let s = step(vec2<f32>(0.0), uv) * step(uv, vec2<f32>(1.0));\n    return s.x * s.y;\n}\n\n@fragment\nfn main(input: VertexOutput) -> @location(0) vec4<f32> {\n    let baseUV = input.texCoord * uniforms.baseScale - uniforms.baseOffset;\n    let base = textureSampleLevel(baseTexture, textureSampler, baseUV, 0) * isInside(baseUV);\n\n    let blurUV = input.texCoord * uniforms.blurScale - uniforms.blurOffset;\n    let blur1 = textureSampleLevel(blurTexture, textureSampler, blurUV, 0) * isInside(blurUV);\n\n    let mirrorUV = (1.0 - input.texCoord) * uniforms.blurScale - uniforms.blurOffset;\n    let blur2 = textureSampleLevel(blurTexture, textureSampler, mirrorUV, 0) * isInside(mirrorUV);\n\n    var highlightAlpha = blur1.a - blur2.a;\n    var shadowAlpha = blur2.a - blur1.a;\n    highlightAlpha = clamp(highlightAlpha * uniforms.strength, 0.0, 1.0);\n    shadowAlpha = clamp(shadowAlpha * uniforms.strength, 0.0, 1.0);\n\n    let lutCoord = 0.5019607843137255 - 0.5019607843137255 * shadowAlpha + 0.4980392156862745 * highlightAlpha;\n    let bevelColor = textureSampleLevel(gradientLUT, textureSampler, vec2<f32>(lutCoord, 0.5), 0);\n\n    var result: vec4<f32>;\n    if (BEVEL_TYPE == 0u) {\n        if (IS_KNOCKOUT == 1u) {\n            result = bevelColor;\n        } else {\n            result = base - base * bevelColor.a + bevelColor;\n        }\n    } else if (BEVEL_TYPE == 1u) {\n        if (IS_KNOCKOUT == 1u) {\n            result = bevelColor * base.a;\n        } else {\n            result = bevelColor * base.a + base * (1.0 - bevelColor.a);\n        }\n    } else {\n        if (IS_KNOCKOUT == 1u) {\n            result = bevelColor - bevelColor * base.a;\n        } else {\n            result = base + bevelColor - bevelColor * base.a;\n        }\n    }\n\n    return result;\n}\n";
+export declare const BevelFilterFragment = "\n\nstruct VertexOutput {\n    @builtin(position) position: vec4<f32>,\n    @location(0) texCoord: vec2<f32>,\n}\n\noverride BEVEL_TYPE: u32 = 0u;\noverride IS_KNOCKOUT: u32 = 0u;\n\nstruct BevelUniforms {\n    highlightColor: vec4<f32>,\n    shadowColor: vec4<f32>,\n    strength: f32,\n    _padding1: f32,\n    _padding2: f32,\n    _padding3: f32,\n    baseScale: vec2<f32>,\n    baseOffset: vec2<f32>,\n    blurScale: vec2<f32>,\n    blurOffset: vec2<f32>,\n}\n\n@group(0) @binding(0) var<uniform> uniforms: BevelUniforms;\n@group(0) @binding(1) var textureSampler: sampler;\n@group(0) @binding(2) var blurTexture: texture_2d<f32>;\n@group(0) @binding(3) var baseTexture: texture_2d<f32>;\n\nfn isInside(uv: vec2<f32>) -> f32 {\n    let s = step(vec2<f32>(0.0), uv) * step(uv, vec2<f32>(1.0));\n    return s.x * s.y;\n}\n\n@fragment\nfn main(input: VertexOutput) -> @location(0) vec4<f32> {\n    let baseUV = input.texCoord * uniforms.baseScale - uniforms.baseOffset;\n    let base = textureSampleLevel(baseTexture, textureSampler, baseUV, 0) * isInside(baseUV);\n\n    let blurUV = input.texCoord * uniforms.blurScale - uniforms.blurOffset;\n    let blur1 = textureSampleLevel(blurTexture, textureSampler, blurUV, 0) * isInside(blurUV);\n\n    let mirrorUV = (1.0 - input.texCoord) * uniforms.blurScale - uniforms.blurOffset;\n    let blur2 = textureSampleLevel(blurTexture, textureSampler, mirrorUV, 0) * isInside(mirrorUV);\n\n    var highlightAlpha = blur1.a - blur2.a;\n    var shadowAlpha = blur2.a - blur1.a;\n    highlightAlpha = clamp(highlightAlpha * uniforms.strength, 0.0, 1.0);\n    shadowAlpha = clamp(shadowAlpha * uniforms.strength, 0.0, 1.0);\n\n    let bevelColor = uniforms.highlightColor * highlightAlpha + uniforms.shadowColor * shadowAlpha;\n    var result: vec4<f32>;\n    if (BEVEL_TYPE == 0u) {\n        if (IS_KNOCKOUT == 1u) {\n            result = bevelColor;\n        } else {\n            result = base - base * bevelColor.a + bevelColor;\n        }\n    } else if (BEVEL_TYPE == 1u) {\n        if (IS_KNOCKOUT == 1u) {\n            result = bevelColor * base.a;\n        } else {\n            result = bevelColor * base.a + base * (1.0 - bevelColor.a);\n        }\n    } else {\n        if (IS_KNOCKOUT == 1u) {\n            result = bevelColor - bevelColor * base.a;\n        } else {\n            result = base + bevelColor - bevelColor * base.a;\n        }\n    }\n\n    return result;\n}\n";
+export declare const BevelBaseFragment = "\n\nstruct VertexOutput {\n    @builtin(position) position: vec4<f32>,\n    @location(0) texCoord: vec2<f32>,\n}\n\nstruct BevelBaseUniforms {\n    offset: vec2<f32>,\n    _padding: vec2<f32>,\n}\n\n@group(0) @binding(0) var<uniform> uniforms: BevelBaseUniforms;\n@group(0) @binding(1) var textureSampler: sampler;\n@group(0) @binding(2) var sourceTexture: texture_2d<f32>;\n\nfn isInside(uv: vec2<f32>) -> f32 {\n    let s = step(vec2<f32>(0.0), uv) * step(uv, vec2<f32>(1.0));\n    return s.x * s.y;\n}\n\n@fragment\nfn main(input: VertexOutput) -> @location(0) vec4<f32> {\n    let original = textureSampleLevel(sourceTexture, textureSampler, input.texCoord, 0);\n    let shiftedUV = input.texCoord - uniforms.offset;\n    let shifted = textureSampleLevel(sourceTexture, textureSampler, shiftedUV, 0) * isInside(shiftedUV);\n    return original * (1.0 - shifted.a);\n}\n";

package/src/Shader/wgsl/fragment/EffectFragment.js

@@ -0,0 +1,324 @@
+import { WgslIsInside, WgslVertexOutput } from "../common/SharedWgsl";
+export const GlowFilterFragment = /* wgsl */ `
+${WgslVertexOutput}
+
+override IS_INNER: u32 = 0u;
+override IS_KNOCKOUT: u32 = 0u;
+
+struct GlowUniforms {
+    color: vec4<f32>,
+    baseScale: vec2<f32>,
+    baseOffset: vec2<f32>,
+    blurScale: vec2<f32>,
+    blurOffset: vec2<f32>,
+    strength: f32,
+    _padding1: f32,
+    _padding2: f32,
+    _padding3: f32,
+}
+
+@group(0) @binding(0) var<uniform> uniforms: GlowUniforms;
+@group(0) @binding(1) var textureSampler: sampler;
+@group(0) @binding(2) var blurTexture: texture_2d<f32>;
+@group(0) @binding(3) var baseTexture: texture_2d<f32>;
+${WgslIsInside}
+
+@fragment
+fn main(input: VertexOutput) -> @location(0) vec4<f32> {
+    let baseUV = input.texCoord * uniforms.baseScale - uniforms.baseOffset;
+    let baseColor = textureSampleLevel(baseTexture, textureSampler, baseUV, 0) * isInside(baseUV);
+
+    let blurUV = input.texCoord * uniforms.blurScale - uniforms.blurOffset;
+    let blurColor = textureSampleLevel(blurTexture, textureSampler, blurUV, 0) * isInside(blurUV);
+
+    var rawAlpha = blurColor.a;
+    if (IS_INNER == 1u) {
+        rawAlpha = 1.0 - rawAlpha;
+    }
+    let glowAlpha = clamp(rawAlpha * uniforms.strength, 0.0, 1.0);
+    let glowColor = vec4<f32>(uniforms.color.rgb * glowAlpha, uniforms.color.a * glowAlpha);
+    if (IS_INNER == 1u) {
+        let innerGlow = glowColor * baseColor.a;
+        if (IS_KNOCKOUT == 1u) {
+            return innerGlow;
+        } else {
+            return innerGlow + baseColor * (1.0 - glowColor.a);
+        }
+    } else {
+        if (IS_KNOCKOUT == 1u) {
+            return glowColor * (1.0 - baseColor.a);
+        } else {
+            return baseColor + glowColor * (1.0 - baseColor.a);
+        }
+    }
+}
+`;
+export const DropShadowFilterFragment = /* wgsl */ `
+${WgslVertexOutput}
+
+override IS_INNER: u32 = 0u;
+override IS_KNOCKOUT: u32 = 0u;
+override IS_HIDE_OBJECT: u32 = 0u;
+
+struct DropShadowUniforms {
+    color: vec4<f32>,
+    baseScale: vec2<f32>,
+    baseOffset: vec2<f32>,
+    blurScale: vec2<f32>,
+    blurOffset: vec2<f32>,
+    strength: f32,
+    _padding1: f32,
+    _padding2: f32,
+    _padding3: f32,
+}
+
+@group(0) @binding(0) var<uniform> uniforms: DropShadowUniforms;
+@group(0) @binding(1) var textureSampler: sampler;
+@group(0) @binding(2) var blurTexture: texture_2d<f32>;
+@group(0) @binding(3) var baseTexture: texture_2d<f32>;
+${WgslIsInside}
+
+@fragment
+fn main(input: VertexOutput) -> @location(0) vec4<f32> {
+    let baseUV = input.texCoord * uniforms.baseScale - uniforms.baseOffset;
+    let baseColor = textureSampleLevel(baseTexture, textureSampler, baseUV, 0) * isInside(baseUV);
+
+    let blurUV = input.texCoord * uniforms.blurScale - uniforms.blurOffset;
+    let blur = textureSampleLevel(blurTexture, textureSampler, blurUV, 0) * isInside(blurUV);
+
+    var rawAlpha = blur.a;
+    if (IS_INNER == 1u) {
+        rawAlpha = 1.0 - rawAlpha;
+    }
+    let shadowAlpha = clamp(rawAlpha * uniforms.strength, 0.0, 1.0);
+    let shadowColor = vec4<f32>(uniforms.color.rgb * shadowAlpha, uniforms.color.a * shadowAlpha);
+
+    if (IS_INNER == 1u) {
+        let innerShadow = shadowColor * baseColor.a;
+        if (IS_KNOCKOUT == 1u) {
+            return innerShadow;
+        } else {
+            return innerShadow + baseColor * (1.0 - shadowColor.a);
+        }
+    } else {
+        if (IS_HIDE_OBJECT == 1u) {
+            return shadowColor;
+        } else if (IS_KNOCKOUT == 1u) {
+            return shadowColor * (1.0 - baseColor.a);
+        } else {
+            return shadowColor * (1.0 - baseColor.a) + baseColor;
+        }
+    }
+}
+`;
+export const GradientGlowFilterFragment = /* wgsl */ `
+${WgslVertexOutput}
+
+override GLOW_TYPE: u32 = 0u;
+override IS_KNOCKOUT: u32 = 0u;
+
+struct GradientGlowUniforms {
+    strength: f32,
+    _padding1: f32,
+    _padding2: f32,
+    _padding3: f32,
+    baseScale: vec2<f32>,
+    baseOffset: vec2<f32>,
+    blurScale: vec2<f32>,
+    blurOffset: vec2<f32>,
+}
+
+@group(0) @binding(0) var<uniform> uniforms: GradientGlowUniforms;
+@group(0) @binding(1) var textureSampler: sampler;
+@group(0) @binding(2) var blurTexture: texture_2d<f32>;
+@group(0) @binding(3) var baseTexture: texture_2d<f32>;
+@group(0) @binding(4) var gradientLUT: texture_2d<f32>;
+${WgslIsInside}
+
+@fragment
+fn main(input: VertexOutput) -> @location(0) vec4<f32> {
+    let baseUV = input.texCoord * uniforms.baseScale - uniforms.baseOffset;
+    let base = textureSampleLevel(baseTexture, textureSampler, baseUV, 0) * isInside(baseUV);
+
+    let blurUV = input.texCoord * uniforms.blurScale - uniforms.blurOffset;
+    var blur = textureSampleLevel(blurTexture, textureSampler, blurUV, 0) * isInside(blurUV);
+
+    blur.a = clamp(blur.a * uniforms.strength, 0.0, 1.0);
+    let glowColor = textureSampleLevel(gradientLUT, textureSampler, vec2<f32>(blur.a, 0.5), 0);
+    var result: vec4<f32>;
+    if (GLOW_TYPE == 0u) {
+        if (IS_KNOCKOUT == 1u) {
+            result = glowColor;
+        } else {
+            result = base - base * glowColor.a + glowColor;
+        }
+    } else if (GLOW_TYPE == 1u) {
+        if (IS_KNOCKOUT == 1u) {
+            result = glowColor * base.a;
+        } else {
+            result = glowColor * base.a + base * (1.0 - glowColor.a);
+        }
+    } else {
+        if (IS_KNOCKOUT == 1u) {
+            result = glowColor - glowColor * base.a;
+        } else {
+            result = base + glowColor - glowColor * base.a;
+        }
+    }
+    return result;
+}
+`;
+export const GradientBevelFilterFragment = /* wgsl */ `
+${WgslVertexOutput}
+
+override BEVEL_TYPE: u32 = 0u;
+override IS_KNOCKOUT: u32 = 0u;
+
+struct GradientBevelUniforms {
+    strength: f32,
+    _padding1: f32,
+    _padding2: f32,
+    _padding3: f32,
+    baseScale: vec2<f32>,
+    baseOffset: vec2<f32>,
+    blurScale: vec2<f32>,
+    blurOffset: vec2<f32>,
+}
+
+@group(0) @binding(0) var<uniform> uniforms: GradientBevelUniforms;
+@group(0) @binding(1) var textureSampler: sampler;
+@group(0) @binding(2) var blurTexture: texture_2d<f32>;
+@group(0) @binding(3) var baseTexture: texture_2d<f32>;
+@group(0) @binding(4) var gradientLUT: texture_2d<f32>;
+${WgslIsInside}
+
+@fragment
+fn main(input: VertexOutput) -> @location(0) vec4<f32> {
+    let baseUV = input.texCoord * uniforms.baseScale - uniforms.baseOffset;
+    let base = textureSampleLevel(baseTexture, textureSampler, baseUV, 0) * isInside(baseUV);
+
+    let blurUV = input.texCoord * uniforms.blurScale - uniforms.blurOffset;
+    let blur1 = textureSampleLevel(blurTexture, textureSampler, blurUV, 0) * isInside(blurUV);
+
+    let mirrorUV = (1.0 - input.texCoord) * uniforms.blurScale - uniforms.blurOffset;
+    let blur2 = textureSampleLevel(blurTexture, textureSampler, mirrorUV, 0) * isInside(mirrorUV);
+
+    var highlightAlpha = blur1.a - blur2.a;
+    var shadowAlpha = blur2.a - blur1.a;
+    highlightAlpha = clamp(highlightAlpha * uniforms.strength, 0.0, 1.0);
+    shadowAlpha = clamp(shadowAlpha * uniforms.strength, 0.0, 1.0);
+
+    let lutCoord = 0.5019607843137255 - 0.5019607843137255 * shadowAlpha + 0.4980392156862745 * highlightAlpha;
+    let bevelColor = textureSampleLevel(gradientLUT, textureSampler, vec2<f32>(lutCoord, 0.5), 0);
+
+    var result: vec4<f32>;
+    if (BEVEL_TYPE == 0u) {
+        if (IS_KNOCKOUT == 1u) {
+            result = bevelColor;
+        } else {
+            result = base - base * bevelColor.a + bevelColor;
+        }
+    } else if (BEVEL_TYPE == 1u) {
+        if (IS_KNOCKOUT == 1u) {
+            result = bevelColor * base.a;
+        } else {
+            result = bevelColor * base.a + base * (1.0 - bevelColor.a);
+        }
+    } else {
+        if (IS_KNOCKOUT == 1u) {
+            result = bevelColor - bevelColor * base.a;
+        } else {
+            result = base + bevelColor - bevelColor * base.a;
+        }
+    }
+
+    return result;
+}
+`;
+export const BevelFilterFragment = /* wgsl */ `
+${WgslVertexOutput}
+
+override BEVEL_TYPE: u32 = 0u;
+override IS_KNOCKOUT: u32 = 0u;
+
+struct BevelUniforms {
+    highlightColor: vec4<f32>,
+    shadowColor: vec4<f32>,
+    strength: f32,
+    _padding1: f32,
+    _padding2: f32,
+    _padding3: f32,
+    baseScale: vec2<f32>,
+    baseOffset: vec2<f32>,
+    blurScale: vec2<f32>,
+    blurOffset: vec2<f32>,
+}
+
+@group(0) @binding(0) var<uniform> uniforms: BevelUniforms;
+@group(0) @binding(1) var textureSampler: sampler;
+@group(0) @binding(2) var blurTexture: texture_2d<f32>;
+@group(0) @binding(3) var baseTexture: texture_2d<f32>;
+${WgslIsInside}
+
+@fragment
+fn main(input: VertexOutput) -> @location(0) vec4<f32> {
+    let baseUV = input.texCoord * uniforms.baseScale - uniforms.baseOffset;
+    let base = textureSampleLevel(baseTexture, textureSampler, baseUV, 0) * isInside(baseUV);
+
+    let blurUV = input.texCoord * uniforms.blurScale - uniforms.blurOffset;
+    let blur1 = textureSampleLevel(blurTexture, textureSampler, blurUV, 0) * isInside(blurUV);
+
+    let mirrorUV = (1.0 - input.texCoord) * uniforms.blurScale - uniforms.blurOffset;
+    let blur2 = textureSampleLevel(blurTexture, textureSampler, mirrorUV, 0) * isInside(mirrorUV);
+
+    var highlightAlpha = blur1.a - blur2.a;
+    var shadowAlpha = blur2.a - blur1.a;
+    highlightAlpha = clamp(highlightAlpha * uniforms.strength, 0.0, 1.0);
+    shadowAlpha = clamp(shadowAlpha * uniforms.strength, 0.0, 1.0);
+
+    let bevelColor = uniforms.highlightColor * highlightAlpha + uniforms.shadowColor * shadowAlpha;
+    var result: vec4<f32>;
+    if (BEVEL_TYPE == 0u) {
+        if (IS_KNOCKOUT == 1u) {
+            result = bevelColor;
+        } else {
+            result = base - base * bevelColor.a + bevelColor;
+        }
+    } else if (BEVEL_TYPE == 1u) {
+        if (IS_KNOCKOUT == 1u) {
+            result = bevelColor * base.a;
+        } else {
+            result = bevelColor * base.a + base * (1.0 - bevelColor.a);
+        }
+    } else {
+        if (IS_KNOCKOUT == 1u) {
+            result = bevelColor - bevelColor * base.a;
+        } else {
+            result = base + bevelColor - bevelColor * base.a;
+        }
+    }
+
+    return result;
+}
+`;
+export const BevelBaseFragment = /* wgsl */ `
+${WgslVertexOutput}
+
+struct BevelBaseUniforms {
+    offset: vec2<f32>,
+    _padding: vec2<f32>,
+}
+
+@group(0) @binding(0) var<uniform> uniforms: BevelBaseUniforms;
+@group(0) @binding(1) var textureSampler: sampler;
+@group(0) @binding(2) var sourceTexture: texture_2d<f32>;
+${WgslIsInside}
+
+@fragment
+fn main(input: VertexOutput) -> @location(0) vec4<f32> {
+    let original = textureSampleLevel(sourceTexture, textureSampler, input.texCoord, 0);
+    let shiftedUV = input.texCoord - uniforms.offset;
+    let shifted = textureSampleLevel(sourceTexture, textureSampler, shiftedUV, 0) * isInside(shiftedUV);
+    return original * (1.0 - shifted.a);
+}
+`;

package/src/Shader/wgsl/fragment/FillFragment.d.ts

@@ -0,0 +1 @@
+export declare const FillFragment = "\nstruct FragmentInput {\n    @builtin(position) position: vec4<f32>,\n    @location(0) bezier: vec2<f32>,\n    @location(1) color: vec4<f32>,\n}\n\n@fragment\nfn main(input: FragmentInput) -> @location(0) vec4<f32> {\n    let f_val = input.bezier.x * input.bezier.x - input.bezier.y;\n    let dx = dpdx(f_val);\n    let dy = dpdy(f_val);\n\n    if (input.bezier.x == 0.5 && input.bezier.y == 0.5) {\n        return vec4<f32>(input.color.rgb * input.color.a, input.color.a);\n    }\n\n    let dist = f_val * inverseSqrt(dx * dx + dy * dy);\n    let coverage = smoothstep(0.5, -0.5, dist);\n\n    if (coverage <= 0.001) {\n        discard;\n    }\n\n    let finalAlpha = input.color.a * min(coverage, 1.0);\n    return vec4<f32>(input.color.rgb * finalAlpha, finalAlpha);\n}\n";

package/src/Shader/wgsl/fragment/FillFragment.js

@@ -0,0 +1,28 @@
+export const FillFragment = /* wgsl */ `
+struct FragmentInput {
+    @builtin(position) position: vec4<f32>,
+    @location(0) bezier: vec2<f32>,
+    @location(1) color: vec4<f32>,
+}
+
+@fragment
+fn main(input: FragmentInput) -> @location(0) vec4<f32> {
+    let f_val = input.bezier.x * input.bezier.x - input.bezier.y;
+    let dx = dpdx(f_val);
+    let dy = dpdy(f_val);
+
+    if (input.bezier.x == 0.5 && input.bezier.y == 0.5) {
+        return vec4<f32>(input.color.rgb * input.color.a, input.color.a);
+    }
+
+    let dist = f_val * inverseSqrt(dx * dx + dy * dy);
+    let coverage = smoothstep(0.5, -0.5, dist);
+
+    if (coverage <= 0.001) {
+        discard;
+    }
+
+    let finalAlpha = input.color.a * min(coverage, 1.0);
+    return vec4<f32>(input.color.rgb * finalAlpha, finalAlpha);
+}
+`;

package/src/Shader/wgsl/fragment/FilterFragment.d.ts

@@ -0,0 +1,10 @@
+export declare const TextureCopyFragment = "\n\nstruct VertexOutput {\n    @builtin(position) position: vec4<f32>,\n    @location(0) texCoord: vec2<f32>,\n}\n\nstruct CopyUniforms {\n    scale: vec2<f32>,\n    offset: vec2<f32>,\n}\n\n@group(0) @binding(0) var<uniform> uniforms: CopyUniforms;\n@group(0) @binding(1) var textureSampler: sampler;\n@group(0) @binding(2) var inputTexture: texture_2d<f32>;\n\n@fragment\nfn main(input: VertexOutput) -> @location(0) vec4<f32> {\n    let uv = input.texCoord * uniforms.scale + uniforms.offset;\n    return textureSampleLevel(inputTexture, textureSampler, uv, 0);\n}\n";
+export declare const BlurTextureCopyFragment = "\n\nstruct VertexOutput {\n    @builtin(position) position: vec4<f32>,\n    @location(0) texCoord: vec2<f32>,\n}\n\nstruct CopyUniforms {\n    scale: vec2<f32>,\n    offset: vec2<f32>,\n}\n\n@group(0) @binding(0) var<uniform> uniforms: CopyUniforms;\n@group(0) @binding(1) var textureSampler: sampler;\n@group(0) @binding(2) var inputTexture: texture_2d<f32>;\n\n@fragment\nfn main(input: VertexOutput) -> @location(0) vec4<f32> {\n    let uv = (input.texCoord - uniforms.offset) * uniforms.scale;\n    let clampedUv = clamp(uv, vec2<f32>(0.0), vec2<f32>(1.0));\n    let color = textureSampleLevel(inputTexture, textureSampler, clampedUv, 0);\n    let inBounds = uv.x >= 0.0 && uv.x <= 1.0 && uv.y >= 0.0 && uv.y <= 1.0;\n    return select(vec4<f32>(0.0, 0.0, 0.0, 0.0), color, inBounds);\n}\n";
+export declare const FilterOutputFragment = "\n\nstruct VertexOutput {\n    @builtin(position) position: vec4<f32>,\n    @location(0) texCoord: vec2<f32>,\n}\n\nstruct CopyUniforms {\n    scale: vec2<f32>,\n    offset: vec2<f32>,\n}\n\n@group(0) @binding(0) var<uniform> uniforms: CopyUniforms;\n@group(0) @binding(1) var textureSampler: sampler;\n@group(0) @binding(2) var inputTexture: texture_2d<f32>;\n\n@fragment\nfn main(input: VertexOutput) -> @location(0) vec4<f32> {\n    let uv = input.texCoord * uniforms.scale + uniforms.offset;\n    let clampedUv = clamp(uv, vec2<f32>(0.0), vec2<f32>(1.0));\n    let color = textureSampleLevel(inputTexture, textureSampler, clampedUv, 0);\n    let inBounds = uv.x >= 0.0 && uv.x <= 1.0 && uv.y >= 0.0 && uv.y <= 1.0;\n    return select(vec4<f32>(0.0, 0.0, 0.0, 0.0), color, inBounds);\n}\n";
+export declare const ColorTransformFragment = "\n\nstruct VertexOutput {\n    @builtin(position) position: vec4<f32>,\n    @location(0) texCoord: vec2<f32>,\n}\n\nstruct ColorTransformUniforms {\n    mul: vec4<f32>,\n    add: vec4<f32>,\n}\n\n@group(0) @binding(0) var<uniform> ct: ColorTransformUniforms;\n@group(0) @binding(1) var textureSampler: sampler;\n@group(0) @binding(2) var inputTexture: texture_2d<f32>;\n\n@fragment\nfn main(input: VertexOutput) -> @location(0) vec4<f32> {\n    var color = textureSampleLevel(inputTexture, textureSampler, input.texCoord, 0);\n\n    color = vec4<f32>(color.rgb / max(vec3<f32>(0.0001), vec3<f32>(color.a)), color.a);\n    color = clamp(color * ct.mul + ct.add, vec4<f32>(0.0), vec4<f32>(1.0));\n    color = vec4<f32>(color.rgb * color.a, color.a);\n\n    return color;\n}\n";
+export declare const YFlipColorTransformFragment = "\n\nstruct VertexOutput {\n    @builtin(position) position: vec4<f32>,\n    @location(0) texCoord: vec2<f32>,\n}\n\nstruct YFlipCTUniforms {\n    scale: vec2<f32>,\n    offset: vec2<f32>,\n    mul: vec4<f32>,\n    add: vec4<f32>,\n}\n\n@group(0) @binding(0) var<uniform> uniforms: YFlipCTUniforms;\n@group(0) @binding(1) var textureSampler: sampler;\n@group(0) @binding(2) var inputTexture: texture_2d<f32>;\n\n@fragment\nfn main(input: VertexOutput) -> @location(0) vec4<f32> {\n    let uv = input.texCoord * uniforms.scale + uniforms.offset;\n    var color = textureSampleLevel(inputTexture, textureSampler, uv, 0);\n\n    color = vec4<f32>(color.rgb / max(vec3<f32>(0.0001), vec3<f32>(color.a)), color.a);\n    color = clamp(color * uniforms.mul + uniforms.add, vec4<f32>(0.0), vec4<f32>(1.0));\n    color = vec4<f32>(color.rgb * color.a, color.a);\n\n    return color;\n}\n";
+export declare const ColorMatrixFilterFragment = "\n\nstruct VertexOutput {\n    @builtin(position) position: vec4<f32>,\n    @location(0) texCoord: vec2<f32>,\n}\n\nstruct ColorMatrixUniforms {\n    matrix: mat4x4<f32>,\n    offset: vec4<f32>,\n}\n\n@group(0) @binding(0) var<uniform> uniforms: ColorMatrixUniforms;\n@group(0) @binding(1) var textureSampler: sampler;\n@group(0) @binding(2) var inputTexture: texture_2d<f32>;\n\n@fragment\nfn main(input: VertexOutput) -> @location(0) vec4<f32> {\n    var color = textureSampleLevel(inputTexture, textureSampler, input.texCoord, 0);\n\n    color = vec4<f32>(color.rgb / max(vec3<f32>(0.0001), vec3<f32>(color.a)), color.a);\n    var result = uniforms.matrix * color + uniforms.offset;\n    result = clamp(result, vec4<f32>(0.0), vec4<f32>(1.0));\n    result = vec4<f32>(result.rgb * result.a, result.a);\n\n    return result;\n}\n";
+export declare const NodeClearFragment = "\n@fragment\nfn main() -> @location(0) vec4<f32> {\n    return vec4<f32>(0.0, 0.0, 0.0, 0.0);\n}\n";
+export declare const PositionedTextureFragment = "\n\nstruct VertexOutput {\n    @builtin(position) position: vec4<f32>,\n    @location(0) texCoord: vec2<f32>,\n}\n\n@group(0) @binding(1) var textureSampler: sampler;\n@group(0) @binding(2) var inputTexture: texture_2d<f32>;\n\n@fragment\nfn main(input: VertexOutput) -> @location(0) vec4<f32> {\n    return textureSampleLevel(inputTexture, textureSampler, input.texCoord, 0);\n}\n";
+export declare const BitmapSyncFragment = "\n\nstruct VertexOutput {\n    @builtin(position) position: vec4<f32>,\n    @location(0) texCoord: vec2<f32>,\n}\n\n@group(0) @binding(1) var textureSampler: sampler;\n@group(0) @binding(2) var inputTexture: texture_2d<f32>;\n\n@fragment\nfn main(input: VertexOutput) -> @location(0) vec4<f32> {\n    return textureSampleLevel(inputTexture, textureSampler, input.texCoord, 0);\n}\n";
+export declare const BlendGenericFragment = "\nstruct VertexOutput {\n    @builtin(position) position: vec4<f32>,\n    @location(0) texCoord: vec2<f32>,\n    @location(1) color: vec4<f32>,\n}\n\nstruct BlendUniforms {\n    blendMode: f32,\n}\n\n@group(0) @binding(1) var<uniform> blend: BlendUniforms;\n@group(0) @binding(2) var srcSampler: sampler;\n@group(0) @binding(3) var srcTexture: texture_2d<f32>;\n@group(0) @binding(4) var dstSampler: sampler;\n@group(0) @binding(5) var dstTexture: texture_2d<f32>;\n\nfn blendNormal(src: vec4<f32>, dst: vec4<f32>) -> vec4<f32> {\n    return src;\n}\n\nfn blendMultiply(src: vec4<f32>, dst: vec4<f32>) -> vec4<f32> {\n    return src * dst;\n}\n\nfn blendScreen(src: vec4<f32>, dst: vec4<f32>) -> vec4<f32> {\n    return src + dst - src * dst;\n}\n\nfn blendAdd(src: vec4<f32>, dst: vec4<f32>) -> vec4<f32> {\n    return min(src + dst, vec4<f32>(1.0));\n}\n\n@fragment\nfn main(input: VertexOutput) -> @location(0) vec4<f32> {\n    let src = textureSampleLevel(srcTexture, srcSampler, input.texCoord, 0);\n    let dst = textureSampleLevel(dstTexture, dstSampler, input.texCoord, 0);\n    var result: vec4<f32>;\n    if (blend.blendMode < 0.5) {\n        result = blendNormal(src, dst);\n    } else if (blend.blendMode < 1.5) {\n        result = blendMultiply(src, dst);\n    } else if (blend.blendMode < 2.5) {\n        result = blendScreen(src, dst);\n    } else {\n        result = blendAdd(src, dst);\n    }\n    return result * input.color;\n}\n";