lygia 1.3.3 → 1.4.0

package/.github/workflows/ci.yml

@@ -0,0 +1,39 @@
+name: ci
+
+on:
+  push:
+    branches: [tomain, lee/ci, patricio/ci]
+  pull_request:
+    branches: [main]
+
+jobs:
+  validate:
+    strategy:
+      matrix:
+       os: [macos-latest]
+    runs-on: ${{ matrix.os }}
+    
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+        with:
+          submodules: recursive
+          lfs: true
+      
+      - name: Setup pnpm
+        uses: pnpm/action-setup@v4
+        with:
+          version: '10.26.0'
+          
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: '24'
+          cache: 'pnpm'
+          
+      - name: Install dependencies
+        run: pnpm install --frozen-lockfile
+        
+      - name: Run CI checks (macOS)
+        if: matrix.os == 'macos-latest'
+        run: pnpm ci:check

package/README.md

@@ -8,6 +8,8 @@ Best of all, LYGIA grows and improves every day thanks to the support of the com
 
 ## How to use it?
 
+_For using Lygia with WebGPU, see the [WebGPU README](./README_WebGPU.md)._
+
 In your shader just `#include` the functions you need and use them:
 
 <div class="codeAndCanvas" data="example.frag">
@@ -37,13 +39,13 @@ In your shader just `#include` the functions you need and use them:
     
 </div>
 
-If you just need to resolve the dependencies of a shader file you got, the fastest way would be to drag&drop your shader file in the box below. We can resolve the dependencies for you.
+<!-- If you just need to resolve the dependencies of a shader file you got, the fastest way would be to drag&drop your shader file in the box below. We can resolve the dependencies for you.
 
 <div class="container">
     <div class="file-drop-area">
     <span class="file-msg">Drop your shader file <a href="https://lygia.xyz/">here</a></span>
     </div>
-</div>
+</div> -->
 
 LYGIA have been integrated into the following Engines, Frameworks, Creative Tools and online editors:
 
@@ -60,6 +62,7 @@ LYGIA have been integrated into the following Engines, Frameworks, Creative Tool
     <a href="https://github.com/kujohn/lygia_ogl_examples"><img src="https://lygia.xyz/imgs/ogl.png" alt="ogl" title="ogl" width="64" /></a>
     <a href="https://www.npmjs.com/package/lygia"><img src="https://lygia.xyz/imgs/npm.png" alt="npm" title="npm" width="64" /></a>
     <a href="https://codesandbox.io/s/lygia-react-starter-fftx6p"><img src="https://lygia.xyz/imgs/r3f.png" alt="r3rf" title="r3rf" width="64" /></a>
+    <a href="https://cycling74.com/packages/jitlygia"><img src="https://lygia.xyz/imgs/max.png" alt="max" title="max" width="64" /></a>
 </p>
 
 <p style="text-align: center;" >

package/README_WESL.md

@@ -0,0 +1,40 @@
+## Contributing a WebGPU WESL Shader
+WESL is a strict superset of WGSL, adding import statements, conditional compilation, and other features.
+
+### To add a shader to Lygia WESL:
+
+1. Add a `.wesl` file alongside the other shader files.
+   - The Lygia convention is to have one user-facing function per file.
+     This keeps things organized while keeping user application bundle sizes small.
+   - It's fine to put multiple type variants of the same function in the same file.
+     For example, variants for a `fn` with `f32` and the same `fn` with `vec3f` arguments go in the same file.
+1. Add appropriate tests in `test/wesl`.
+    - Use `testCompute()` for pure math functions
+    - Use `testFragment()` for derivative functions (`fwidth`, `dpdx`, `dpdy`) or texture sampling
+    - Use `toMatchImage()` for visual regression tests (filters, generative patterns, complex rendering)
+
+### Notes when porting to WESL:
+- WESL file names can't start with a number, and can't be current WGSL or WESL keywords.
+- The file/directory hierarchy translates to double colons in WESL:
+  ```rs
+    import lygia::color::space::hsl2rgb::hsl2rgb;
+  ```
+  See [WESL imports](https://wesl-lang.dev/spec/Imports) for details. 
+- You can also reference other shader modules inline without import statements.
+  ```rs
+    fn foo() -> f32 {
+      let p = lygia::math::consts::PI;
+      return p;
+    }
+  ```
+- Conditional transpilation is supported via `@if`, `@else`, and `@elseif` statements.
+Conditions can be set at runtime or build time.[^1]
+See [WESL Conditions](https://wesl-lang.dev/spec/ConditionalTranslation) for details.
+
+### WESL Resources
+WESL is documented at [wesl-lang.dev](https://wesl-lang.dev).
+Community support for WESL is available on [GitHub](https://github.com/wgsl-tooling-wg) and on [Discord](https://discord.gg/5UhkaSu4dt).
+
+### Future Plans
+- Function overloads or generics to reduce duplication across type variants
+- Setting conditions from imported shaders.

package/README_WebGPU.md

@@ -0,0 +1,203 @@
+This page describes how to link Lygia shader functions
+into your WebGPU application using WESL tools.
+
+[WESL](https://wesl-lang.dev) is a superset of WGSL that adds
+features with community-supported tools.
+WESL tools are available in Rust and JavaScript/TypeScript.
+
+_Most (but not all) Lygia GLSL shaders are now available
+for WebGPU using WESL.
+If a Lygia function you need is missing,
+please file an [issue](https://github.com/patriciogonzalezvivo/lygia/issues)
+or help [contribute](./README_WESL.md)._[^1][^2]
+
+## Using JavaScript or TypeScript
+
+Install with `npm install lygia` or `pnpm install lygia`
+([lygia npm package](https://www.npmjs.com/package/lygia)).
+Once you install, 500+ Lygia functions
+and constants will be available for you to use
+via `import` statements in your application shader code.
+
+```rs
+import lygia::math::consts::PI;
+
+fn main() {
+  let p = PI;
+}
+```
+
+The JS tools automatically tree-shake, including only the Lygia
+functions your application uses.
+
+WESL integrates with popular bundlers (vite, webpack, rollup) through plugins,
+or for custom build pipelines, you can use the `wesl-link` command-line tool
+or the link API. 
+
+### Using a JavaScript/TypeScript Bundler
+
+If you build your application with a JavaScript/TypeScript bundler
+like `vite`, `webpack` or `rollup`,
+install the
+[wesl](https://www.npmjs.com/package/wesl?activeTab=readme) and
+[wesl-plugin](https://www.npmjs.com/package/wesl-plugin) packages.
+
+#### Runtime Linking with a Bundler
+Import shader code into your JavaScript or TypeScript application using the 
+import statements suffixed with `?link` and the shaders will be linked together at runtime:
+
+```ts
+import appWesl from "../shaders/app.wesl?link";
+import { link } from "wesl";
+
+const linked = await link(appWesl);
+linked.createShaderModule(gpuDevice);
+```
+
+For more details, check the [WESL bundler documentation](https://wesl-lang.dev/docs/JavaScript-Builds#wesl-with-javascript-bundlers) or refer to this
+[lygia example using vite](https://stackblitz.com/github/wgsl-tooling-wg/examples/tree/main/lygia-example?file=README.md).
+
+#### Static Linking with a Bundler
+Alternatively,
+you can statically link your shaders in advance using the `?static` suffix:
+```ts
+import appWgsl from "../shaders/app.wesl?static";
+```
+See the [lygia static linking example](https://stackblitz.com/github/wgsl-tooling-wg/examples/tree/main/lygia-static-example)
+for details. 
+
+
+#### Runtime vs. Static Linking
+Static linking bundles your shader modules together into a single transpiled WGSL string.
+Static linking means you don't need WESL linker in your runtime bundle (~15KB savings).
+However, static linking is less flexible 
+because your application can't use WESL's conditional compilation
+features (`@if` directives) to adapt shaders at runtime based on GPU capabilities
+or user configuration.
+
+Many Lygia shader functions include `@if` [conditions](https://wesl-lang.dev/spec/ConditionalTranslation).
+For example see `@if(YUV_SDTV)` in [`yuv2rgb`](https://github.com/patriciogonzalezvivo/lygia/blob/main/color/space/yuv2rgb.wesl).
+With runtime linking, you can set these conditions dynamically.
+With static linking, conditions are resolved at build time.
+
+### Command Line Linking
+
+For custom build pipelines, use the `wesl-link` command-line tool to statically link shaders.
+
+#### Linking Application Shaders
+Link your application shader file that imports Lygia functions:
+
+```sh
+npx wesl-link ./shaders/main.wesl
+```
+
+See the [Lygia CLI linking example](https://stackblitz.com/github/wgsl-tooling-wg/examples/tree/main/lygia-cli-example?file=README.md) for details.
+
+#### Linking Lygia Modules on the Command Line
+To get standalone WGSL for a specific Lygia module, 
+call wesl-link on that module.
+
+**From the npm package:**
+```sh
+npx wesl-link lygia::color::layer::addSourceOver
+```
+
+**From a lygia repository clone:**
+```sh
+npx wesl-link package::color::layer::addSourceOver
+
+# alternate syntax
+npx wesl-link color/layer/addSourceOver.wesl
+```
+
+Either approach produces the WGSL for the requested Lygia module linked with its dependencies.
+
+### Link Using the API
+You can use the linking API directly to build custom solutions:
+
+```ts
+import { link } from "wesl";
+
+const main = `import lygia::math::consts::PI; ...`;
+const linked = await link({weslSrc: {main }});
+const shaderModule = linked.createShaderModule(gpuDevice);
+```
+
+See the [API documentation](https://wesl-lang.dev/docs/JavaScript-Builds) for details.
+
+### Additional WESL Examples
+
+More WESL examples are available [here](https://github.com/wgsl-tooling-wg/examples).
+Most examples run with one click in a browser sandbox.
+The examples can also be used as starter templates with `degit`.
+
+## Using Rust
+
+```sh
+cargo add lygia
+```
+
+### Linking at build time
+```sh
+cargo add --build wesl
+```
+
+```rs
+/// build.rs
+fn main() {
+    wesl::Wesl::new("src/shaders").build_artifact("main.wesl", "my_shader");
+}
+```
+
+### Linking at run-time
+
+```sh
+cargo add wesl
+```
+
+```rs
+let shader_string = Wesl::new("src/shaders")
+    .compile("main.wesl")
+    .inspect_err(|e| eprintln!("WESL error: {e}")) // pretty errors with `display()`
+    .unwrap()
+    .to_string();
+```
+
+### Using the Rust CLI tool
+```sh
+cargo install wesl-cli
+wesl compile <path/to/shader.wesl>
+```
+
+
+### WESL Rust Documentation
+See [Getting Started Rust](https://wesl-lang.dev/docs/Getting-Started-Rust), 
+the [wesl crate documentation](https://docs.rs/wesl/latest/wesl/),
+and [WESL rust examples](https://github.com/wgsl-tooling-wg/wesl-rs/tree/main/examples).
+
+
+## About WESL
+WESL extends WGSL with:
+- `import` statements to split shader code across files and load npm/cargo libraries
+- `@if @else @elseif` statements to assemble specialized shaders at build time or runtime
+
+Current WESL tools include:
+- Linkers in Rust and JavaScript (to combine WGSL/WESL files into applications)
+- Syntax highlighters for zed, helix and nvim
+
+### Coming Soon
+Additional WESL tools in development:
+- HTML [documentation generator](https://github.com/jannik4/wesldoc)
+- [Language server](https://github.com/wgsl-analyzer/wgsl-analyzer)
+- VSCode plugin
+- Code formatter
+
+Read more about WESL at [wesl-lang.dev](https://wesl-lang.dev).
+
+[^1]: Lygia functions are small and self-contained.
+You can just copy, paste and edit them into your app if you prefer doing things manually!
+
+[^2]: Lygia currently hosts two versions of WebGPU shaders. 
+The newer versions use the WESL language and have a `.wesl` suffix.
+For new Lygia users, we recommend `.wesl`. 
+(The older versions use a `.wgsl` suffix, but are less complete and use a custom `#include` syntax.) 

package/animation/easing/backIn.wesl

@@ -0,0 +1,11 @@
+import lygia::math::consts::PI;
+
+/*
+contributors: Hugh Kennedy (https://github.com/hughsk)
+description: Back in easing. From https://github.com/stackgl/glsl-easings
+use: backIn(<f32> x)
+examples:
+    - https://raw.githubusercontent.com/patriciogonzalezvivo/lygia_examples/main/animation_easing.frag
+*/
+
+fn backIn(t: f32) -> f32 { return pow(t, 3.0) - t * sin(t * PI); }

package/animation/easing/backInOut.wesl

@@ -0,0 +1,14 @@
+import lygia::animation::easing::backIn::{backIn};
+
+/*
+contributors: Hugh Kennedy (https://github.com/hughsk)
+description: Back in/out easing. From https://github.com/stackgl/glsl-easings
+use: backInOut(<f32> x)
+examples:
+    - https://raw.githubusercontent.com/patriciogonzalezvivo/lygia_examples/main/animation_easing.frag
+*/
+
+fn backInOut(t: f32) -> f32 {
+  let g = backIn(select(1.0 - (2.0 * t - 1.0), 2.0 * t, t < 0.5));
+  return select(0.5 * (1.0 - g) + 0.5, 0.5 * g, t < 0.5);
+}

package/animation/easing/backOut.wesl

@@ -0,0 +1,11 @@
+import lygia::animation::easing::backIn::{backIn};
+
+/*
+contributors: Hugh Kennedy (https://github.com/hughsk)
+description: Back out easing. From https://github.com/stackgl/glsl-easings
+use: backOut(<f32> x)
+examples:
+    - https://raw.githubusercontent.com/patriciogonzalezvivo/lygia_examples/main/animation_easing.frag
+*/
+
+fn backOut(t: f32) -> f32 { return 1.0 - backIn(1.0 - t); }

package/animation/easing/bounceIn.wesl

@@ -0,0 +1,11 @@
+import lygia::animation::easing::bounceOut::{bounceOut};
+
+/*
+contributors: Hugh Kennedy (https://github.com/hughsk)
+description: Bounce in easing. From https://github.com/stackgl/glsl-easings
+use: <f32> bounceIn(<f32> x)
+examples:
+    - https://raw.githubusercontent.com/eduardfossas/lygia-study-examples/main/animation/e_EasingBounce.frag
+*/
+
+fn bounceIn(t: f32) -> f32 { return 1.0 - bounceOut(1.0 - t); }

package/animation/easing/bounceInOut.wesl

@@ -0,0 +1,17 @@
+import lygia::animation::easing::bounceOut::{bounceOut};
+
+/*
+contributors: Hugh Kennedy (https://github.com/hughsk)
+description: Bounce in/out easing. From https://github.com/stackgl/glsl-easings
+use: <f32> bounceInOut(<f32> x)
+examples:
+    - https://raw.githubusercontent.com/eduardfossas/lygia-study-examples/main/animation/e_EasingBounce.frag
+*/
+
+fn bounceInOut(t: f32) -> f32 {
+  return select(
+    0.5 * bounceOut(t * 2.0 - 1.0) + 0.5,
+    0.5 * (1.0 - bounceOut(1.0 - t * 2.0)),
+    t < 0.5
+  );
+}

package/animation/easing/bounceOut.wesl

@@ -0,0 +1,33 @@
+/*
+contributors: Hugh Kennedy (https://github.com/hughsk)
+description: Bounce out easing. From https://github.com/stackgl/glsl-easings
+use: <f32> bounceOut(<f32> x)
+examples:
+    - https://raw.githubusercontent.com/eduardfossas/lygia-study-examples/main/animation/e_EasingBounce.frag
+*/
+
+fn bounceOut(t: f32) -> f32 {
+    const a = 4.0 / 11.0;
+    const b = 8.0 / 11.0;
+    const c = 9.0 / 10.0;
+
+    const ca = 4356.0 / 361.0;
+    const cb = 35442.0 / 1805.0;
+    const cc = 16061.0 / 1805.0;
+
+    let t2 = t * t;
+
+    return select(
+      select(
+        select(
+          10.8 * t * t - 20.52 * t + 10.72,
+          ca * t2 - cb * t + cc,
+          t < c
+        ),
+        9.075 * t2 - 9.9 * t + 3.4,
+        t < b
+      ),
+      7.5625 * t2,
+      t < a
+    );
+}

package/animation/easing/circularIn.wesl

@@ -0,0 +1,9 @@
+/*
+contributors: Hugh Kennedy (https://github.com/hughsk)
+description: Circular in easing. From https://github.com/stackgl/glsl-easings
+use: circularIn(<f32> x)
+examples:
+    - https://raw.githubusercontent.com/patriciogonzalezvivo/lygia_examples/main/animation_easing.frag
+*/
+
+fn circularIn(t: f32) -> f32 { return 1.0 - sqrt(1.0 - t * t); }

package/animation/easing/circularInOut.wesl

@@ -0,0 +1,15 @@
+/*
+contributors: Hugh Kennedy (https://github.com/hughsk)
+description: Circular in/out easing. From https://github.com/stackgl/glsl-easings
+use: circularInOut(<f32> x)
+examples:
+    - https://raw.githubusercontent.com/patriciogonzalezvivo/lygia_examples/main/animation_easing.frag
+*/
+
+fn circularInOut(t: f32) -> f32 {
+  return select(
+    0.5 * (sqrt((3.0 - 2.0 * t) * (2.0 * t - 1.0)) + 1.0),
+    0.5 * (1.0 - sqrt(1.0 - 4.0 * t * t)),
+    t < 0.5
+  );
+}

package/animation/easing/circularOut.wesl

@@ -0,0 +1,9 @@
+/*
+contributors: Hugh Kennedy (https://github.com/hughsk)
+description: Circular out easing. From https://github.com/stackgl/glsl-easings
+use: circularOut(<f32> x)
+examples:
+    - https://raw.githubusercontent.com/patriciogonzalezvivo/lygia_examples/main/animation_easing.frag
+*/
+
+fn circularOut(t: f32) -> f32 { return sqrt((2.0 - t) * t); }

package/animation/easing/cubicIn.wesl

@@ -0,0 +1,9 @@
+/*
+contributors: Hugh Kennedy (https://github.com/hughsk)
+description: Cubic in easing. From https://github.com/stackgl/glsl-easings
+use: cubicIn(<f32> x)
+examples:
+    - https://raw.githubusercontent.com/patriciogonzalezvivo/lygia_examples/main/animation_easing.frag
+*/
+
+fn cubicIn(t: f32) -> f32 { return t * t * t; }

package/animation/easing/cubicInOut.wesl

@@ -0,0 +1,15 @@
+/*
+contributors: Hugh Kennedy (https://github.com/hughsk)
+description: Cubic in/out easing. From https://github.com/stackgl/glsl-easings
+use: cubicInOut(<f32> x)
+examples:
+    - https://raw.githubusercontent.com/patriciogonzalezvivo/lygia_examples/main/animation_easing.frag
+*/
+
+fn cubicInOut(t: f32) -> f32 {
+  return select(
+    0.5 * pow(2.0 * t - 2.0, 3.0) + 1.0,
+    4.0 * t * t * t,
+    t < 0.5
+  );
+}

package/animation/easing/cubicOut.wesl

@@ -0,0 +1,12 @@
+/*
+contributors: Hugh Kennedy (https://github.com/hughsk)
+description: Cubic out easing. From https://github.com/stackgl/glsl-easings
+use: cubicOut(<f32> x)
+examples:
+    - https://raw.githubusercontent.com/patriciogonzalezvivo/lygia_examples/main/animation_easing.frag
+*/
+
+fn cubicOut(t: f32) -> f32 {
+    let f = t - 1.0;
+    return f * f * f + 1.0;
+}

package/animation/easing/elasticIn.wesl

@@ -0,0 +1,11 @@
+import lygia::math::consts::HALF_PI;
+
+/*
+contributors: Hugh Kennedy (https://github.com/hughsk)
+description: Elastic in easing. From https://github.com/stackgl/glsl-easings
+use: elasticIn(<f32> x)
+examples:
+    - https://raw.githubusercontent.com/patriciogonzalezvivo/lygia_examples/main/animation_easing.frag
+*/
+
+fn elasticIn(t: f32) -> f32 { return sin(13.0 * t * HALF_PI) * pow(2.0, 10.0 * (t - 1.0)); }

package/animation/easing/elasticInOut.wesl

@@ -0,0 +1,17 @@
+import lygia::math::consts::HALF_PI;
+
+/*
+contributors: Hugh Kennedy (https://github.com/hughsk)
+description: Elastic in/out easing. From https://github.com/stackgl/glsl-easings
+use: elasticInOut(<f32> x)
+examples:
+    - https://raw.githubusercontent.com/patriciogonzalezvivo/lygia_examples/main/animation_easing.frag
+*/
+
+fn elasticInOut(t: f32) -> f32 {
+  return select(
+    0.5 * sin(-13.0 * HALF_PI * ((2.0 * t - 1.0) + 1.0)) * pow(2.0, -10.0 * (2.0 * t - 1.0)) + 1.0,
+    0.5 * sin(13.0 * HALF_PI * 2.0 * t) * pow(2.0, 10.0 * (2.0 * t - 1.0)),
+    t < 0.5
+  );
+}

package/animation/easing/elasticOut.wesl

@@ -0,0 +1,11 @@
+import lygia::math::consts::HALF_PI;
+
+/*
+contributors: Hugh Kennedy (https://github.com/hughsk)
+description: Elastic out easing. From https://github.com/stackgl/glsl-easings
+use: elasticOut(<f32> x)
+examples:
+    - https://raw.githubusercontent.com/patriciogonzalezvivo/lygia_examples/main/animation_easing.frag
+*/
+
+fn elasticOut(t: f32) -> f32 { return sin(-13.0 * (t + 1.0) * HALF_PI) * pow(2.0, -10.0 * t) + 1.0; }

package/animation/easing/exponentialIn.wesl

@@ -0,0 +1,15 @@
+/*
+contributors: Hugh Kennedy (https://github.com/hughsk)
+description: Exponential in easing. From https://github.com/stackgl/glsl-easings
+use: exponentialIn(<f32> x)
+examples:
+    - https://raw.githubusercontent.com/patriciogonzalezvivo/lygia_examples/main/animation_easing.frag
+*/
+
+fn exponentialIn(t: f32) -> f32 {
+  return select(
+    pow(2.0, 10.0 * (t - 1.0)),
+    t,
+    t == 0.0
+  );
+}

package/animation/easing/exponentialInOut.wesl

@@ -0,0 +1,19 @@
+/*
+contributors: Hugh Kennedy (https://github.com/hughsk)
+description: Exponential in/out easing. From https://github.com/stackgl/glsl-easings
+use: exponentialInOut(<f32> x)
+examples:
+    - https://raw.githubusercontent.com/patriciogonzalezvivo/lygia_examples/main/animation_easing.frag
+*/
+
+fn exponentialInOut(t: f32) -> f32 {
+  return select(
+    select(
+      -0.5 * pow(2.0, 10.0 - (t * 20.0)) + 1.0,
+      0.5 * pow(2.0, (20.0 * t) - 10.0),
+      t < 0.5
+    ),
+    t,
+    t == 0.0 || t == 1.0
+  );
+}

package/animation/easing/exponentialOut.wesl

@@ -0,0 +1,15 @@
+/*
+contributors: Hugh Kennedy (https://github.com/hughsk)
+description: Exponential out easing. From https://github.com/stackgl/glsl-easings
+use: exponentialOut(<f32> x)
+examples:
+    - https://raw.githubusercontent.com/patriciogonzalezvivo/lygia_examples/main/animation_easing.frag
+*/
+
+fn exponentialOut(t: f32) -> f32 {
+  return select(
+    1.0 - pow(2.0, -10.0 * t),
+    t,
+    t == 1.0
+  );
+}

package/animation/easing/linearIn.wesl

@@ -0,0 +1,9 @@
+/*
+contributors: Hugh Kennedy (https://github.com/hughsk)
+description: Linear easing. From https://github.com/stackgl/glsl-easings
+use: linearIn(<f32> x)
+examples:
+    - https://raw.githubusercontent.com/patriciogonzalezvivo/lygia_examples/main/animation_easing.frag
+*/
+
+fn linearIn(t: f32) -> f32 { return t; }

package/animation/easing/linearInOut.wesl

@@ -0,0 +1,9 @@
+/*
+contributors: Hugh Kennedy (https://github.com/hughsk)
+description: Linear easing. From https://github.com/stackgl/glsl-easings
+use: linearInOut(<f32> x)
+examples:
+    - https://raw.githubusercontent.com/patriciogonzalezvivo/lygia_examples/main/animation_easing.frag
+*/
+
+fn linearInOut(t: f32) -> f32 { return t; }

package/animation/easing/linearOut.wesl

@@ -0,0 +1,9 @@
+/*
+contributors: Hugh Kennedy (https://github.com/hughsk)
+description: Linear easing. From https://github.com/stackgl/glsl-easings
+use: linearOut(<f32> x)
+examples:
+    - https://raw.githubusercontent.com/patriciogonzalezvivo/lygia_examples/main/animation_easing.frag
+*/
+
+fn linearOut(t: f32) -> f32 { return t; }

package/animation/easing/quadraticIn.wesl

@@ -0,0 +1,9 @@
+/*
+contributors: Hugh Kennedy (https://github.com/hughsk)
+description: Quadrtic in easing. From https://github.com/stackgl/glsl-easings
+use: quadraticIn(<f32> x)
+examples:
+    - https://raw.githubusercontent.com/patriciogonzalezvivo/lygia_examples/main/animation_easing.frag
+*/
+
+fn quadraticIn(t: f32) -> f32 { return t * t; }

package/animation/easing/quadraticInOut.wesl

@@ -0,0 +1,12 @@
+/*
+contributors: Hugh Kennedy (https://github.com/hughsk)
+description: Quadrtic in/out easing. From https://github.com/stackgl/glsl-easings
+use: quadraticInOut(<f32> x)
+examples:
+    - https://raw.githubusercontent.com/patriciogonzalezvivo/lygia_examples/main/animation_easing.frag
+*/
+
+fn quadraticInOut(t: f32) -> f32 {
+  let p = 2.0 * t * t;
+  return select(-p + (4.0 * t) - 1.0, p, t < 0.5);
+}

package/animation/easing/quadraticOut.wesl

@@ -0,0 +1,9 @@
+/*
+contributors: Hugh Kennedy (https://github.com/hughsk)
+description: Quadrtic out easing. From https://github.com/stackgl/glsl-easings
+use: quadraticOut(<f32> x)
+examples:
+    - https://raw.githubusercontent.com/patriciogonzalezvivo/lygia_examples/main/animation_easing.frag
+*/
+
+fn quadraticOut(t: f32) -> f32 { return -t * (t - 2.0); }