Crate wick_quaternion 

Quaternion support for dew expressions.

Provides quaternion types and operations for 3D rotations. Uses [x, y, z, w] component order (scalar last, matching GLM/glTF convention).

Quick Start

use wick_core::Expr;
use wick_quaternion::{Value, eval, quaternion_registry};
use std::collections::HashMap;

// Create a rotation quaternion and normalize it
let expr = Expr::parse("normalize(q)").unwrap();

let vars: HashMap<String, Value<f32>> = [
    ("q".into(), Value::Quaternion([0.0, 0.0, 0.0, 2.0])),
].into();

let result = eval(expr.ast(), &vars, &quaternion_registry()).unwrap();
assert_eq!(result, Value::Quaternion([0.0, 0.0, 0.0, 1.0]));

Features

Feature	Description
wgsl	WGSL shader code generation
lua	Lua code generation
cranelift	Cranelift JIT compilation

Types

Type	Description
Scalar	Real number
Vec3	3D vector [x, y, z]
Quaternion	Quaternion [x, y, z, w]

Functions

Function	Description
vec3(x, y, z)	Construct vector → vec3
quat(x, y, z, w)	Construct quaternion → quaternion
conj(q)	Conjugate → quaternion
length(q)	Magnitude → scalar
normalize(q)	Unit quaternion → quaternion
inverse(q)	Multiplicative inverse → quaternion
dot(q1, q2)	Dot product → scalar
lerp(q1, q2, t)	Linear interpolation → quaternion
slerp(q1, q2, t)	Spherical interpolation → quaternion
axis_angle(axis, θ)	From axis-angle → quaternion
rotate(v, q)	Rotate vector by quaternion → vec3

Operators

Operation	Result
q1 * q2	Quaternion multiplication
q * scalar	Scalar multiplication
q1 + q2	Component-wise addition
q1 - q2	Component-wise subtraction
-q	Negation

Component Order

This crate uses [x, y, z, w] order (scalar last), matching:

• GLM (OpenGL Mathematics)
• glTF format
• Unity (internal representation)

Other conventions exist (w first), so be careful when interfacing with external libraries.

Modules

ops

Binary and unary operations for quaternions.

Structs

AxisAngle

Create quaternion from axis and angle: axis_angle(axis, angle)

Conj

Quaternion conjugate: conj([x, y, z, w]) = [-x, -y, -z, w]

Dot

Dot product (4D for quaternions, 3D for vectors)

FunctionRegistry

Registry of quaternion functions.

Inverse

Quaternion inverse: inverse(q) = conj(q) / |q|² For unit quaternions, inverse = conjugate

Length

Quaternion magnitude: length(q) = sqrt(x² + y² + z² + w²)

Lerp

Linear interpolation (use slerp for rotations)

Normalize

Normalize to unit quaternion/vector

QuatConstructor

Construct Quaternion from four scalars: quat(x, y, z, w) -> Quaternion Uses [x, y, z, w] order (scalar last, matching GLM/glTF convention).

Rotate

Rotate a vector by a quaternion: rotate(vec, quat)

Signature

A function signature.

Slerp

Spherical linear interpolation for quaternions

Vec3Constructor

Construct Vec3 from three scalars: vec3(x, y, z) -> Vec3

Enums

Error

Quaternion evaluation error.

Type

Type of a quaternion value.

Value

A quaternion value, generic over numeric type.

Traits

QuaternionFn

A function that can be called from quaternion expressions.

QuaternionValue

Trait for values that support quaternion operations.

Functions

eval

Evaluate an AST with quaternion values.

quaternion_registry

Create a new registry with all standard quaternion functions.

register_quaternion

Register all standard quaternion functions.