Procedural Physics-Driven Cow In Browser

You are a computational graphics engineer specializing in real-time physics simulation and procedural animation. Your task is to build a fully animated cow from scratch using **pure mathematics, physics simulation, and procedural code** that runs live in a browser environment.

## Core Requirements

### Constraints
- **Zero external assets**: No 3D models (.obj, .fbx, .gltf), no baked animations, no sprite sheets, no keyframe files
- **Everything procedural**: Geometry, skeleton, motion, and deformation must be generated and calculated at runtime
- **Real-time physics**: All movement (walking, tail swaying, ear twitching, breathing) driven by physics simulation, inverse kinematics, or procedural algorithms—not pre-recorded animation curves
- **Browser-native**: Must run in modern browsers (WebGL / Canvas / WebGPU)

### Architecture

1. **Geometry Generation**
   - Define the cow body as parametric surfaces, implicit functions (metaballs, signed distance fields), or procedural meshes (subdivided primitives, extrusions)
   - Generate vertices/faces for torso, head, legs, udder, tail, ears, horns mathematically
   - Example approach: ellipsoids for body parts + cylindrical segments for legs + bezier curves for tail

2. **Skeletal System**
   - Implement a bone hierarchy: spine → neck → head; pelvis → hind legs; shoulders → front legs
   - Each bone: position, rotation, parent-child transform chain
   - Procedural skinning: bind geometry vertices to bones with weight functions (linear blend skinning or dual quaternion)

3. **Physics & Animation**
   - **Locomotion**: Inverse kinematics (IK) for leg placement during walk cycle; calculate foot contact, stride length, and gait timing from physics parameters (speed, gravity, leg length)
   - **Secondary motion**: Spring-damper systems for tail sway, ear flaps, skin jiggle; verlet integration or mass-spring mesh for soft-body effects
   - **Procedural behaviors**: Perlin/simplex noise for idle head bobbing, breathing (sinusoidal chest expansion), grazing lean
   - **Balance & grounding**: Raycast or sphere-cast ground detection; center-of-mass calculation to keep the cow stable on terrain

4. **Rendering**
   - WebGL shader pipeline: vertex shader applies skeletal transforms, fragment shader handles lighting/color
   - Optional: toon shading, simple Blinn-Phong, or PBR for visual polish

### Deliverables

- **Complete, runnable code** (HTML + JavaScript, or a framework like Three.js / Babylon.js used *only* for rendering infrastructure—geometry and animation logic must be custom)
- **Inline comments** explaining the math behind key systems (IK solver, spring damper, gait cycle)
- **Interactive demo**: User can {{interaction-controls}} (e.g., click to make the cow walk forward, adjust physics sliders for tail stiffness, rotate camera)
- **Performance target**: 60 FPS on a mid-range laptop

### Physics Simulation Details

For the {{primary-animation-focus}}, implement the underlying equations explicitly:
- If walk cycle: derive foot trajectory from cycloid or bezier paths; solve two-bone IK analytically
- If tail: model as chain of rigid bodies with angular springs, or as a bezier curve whose control points are driven by damped oscillators
- If muscle/skin: create a mass-spring lattice over the mesh surface

### Code Structure Guidance

```javascript
// Suggested module breakdown
class ProceduralCow {
  constructor() {
    this.skeleton = new Skeleton(); // bones + hierarchy
    this.geometry = this.generateMesh(); // procedural vertices/faces
    this.physics = new PhysicsEngine(); // springs, IK solvers, forces
  }
  
  update(deltaTime) {
    this.physics.step(deltaTime);
    this.skeleton.applyIK();
    this.geometry.skin(this.skeleton);
  }
  
  render(context) { /* WebGL draw calls */ }
}
```

Provide the full implementation, ensuring every movement and shape emerges from calculated equations, not artistic keyframes.