Pliant — Sprite Mesh Deformation for GameMaker

GameMaker can scale a sprite and rotate it. It cannot bend one. image_angle moves the whole rectangle; image_xscale stretches it evenly. The interior never moves. So flags don't ripple, jellies don't wobble, grass doesn't sway, and a boss that takes a hit just… flashes.

Pliant turns any sprite into a deformable mesh, in pure GML. One line subdivides it into a vertex-buffer grid; after that you stack deformers on it like modifiers and the interior of the picture moves — every frame, at runtime, with the sprite's own texture.

Twelve composable deformers

wave · bend · twist · taper · squash · sway · turbulence · pinch · ripple · jelly · lattice · shatter

Offsets add, so deformers stack without fighting: a flag is sway + wave + turbulence, a breathing pickup is one self-oscillating squash, a hit boss is a jelly spring you kick with mesh.hit(). A free-form 3×3 lattice warps anything the presets can't. Six ready presets ship: flag, grass, jelly, breathe, underwater, shockwave.

Springs, not tweens

Motion is driven by a spring integrator, not a fixed-duration curve. A tween evaluated over a known duration must restart when you retarget it mid-flight — that restart is the hitch you see in hand-rolled squash-and-stretch. A spring holds position and velocity, so it can be retargeted every frame: hit the jelly while it is still wobbling and the impulses compound, exactly like the real thing. Springs are sub-stepped, so an alt-tab stall cannot NaN the mesh.

Shatter is a topology, not a shader

A shared vertex grid cannot tear — a boundary vertex exists once and can only move one way. Pliant's shatter runs on duplicated per-quad vertices: every shard is rigid, keeps its own piece of the texture, spins about its own centre and falls on a gravity arc. Deterministic, too — turbulence and shatter hash their inputs, so a death animation replays identically every run.

What it costs, measured honestly

Measured on a mid-range desktop, VM (interpreted) runtime, worst case — every mesh re-deformed and its buffer rewritten every frame: one full-density 792-triangle mesh costs ~6.6 ms/frame; two hold 60 fps; ten crowd-density (8×8) meshes hold ~55 fps. YYC builds will do better; these are the floor, not the ceiling.

And the structural fact that matters more: a static stack — bend a signpost, taper a tower, lattice-warp a portrait — is rebuilt once and then costs approximately nothing per frame. Pliant only re-evaluates a mesh when something on it is time-varying. The honest use is hero sprites and moments: the boss, the flag, the pickup, the shatter — plus free static shaping everywhere.

Built to be read

• Pure GML. No native extension, no DLL, no dependency — nothing to break on a runtime update.
• The maths is engine-free. All twelve deformers and the spring live in two files with zero engine calls — total functions of their inputs, no random(), no globals. The half that can be wrong is the half you can read.
• Texture-page safe. UVs come from sprite_get_uvs, so trimmed sprites on a texture page render correctly.
• Namespaced. Everything is pli_/PLI_ — nothing collides with your project.
• A runnable 12-page demo room ships beside the library, each page one deformer next to plain draw_sprite, so you can evaluate every claim on this page in two minutes.

The API, in five lines

mesh = new PliantMesh(spr_flag, 18, 22);
mesh.add(PLI_SWAY,  { amp: 6 });
mesh.add(PLI_WAVE,  { amp: 8, freq: 2.2, speed: 1.4 });
mesh.step(delta_time / 1000000);
mesh.draw(x, y);

What's in the download

• Pliant.yymps — import via Tools › Import Local Package
• The full raw project — readable, commented source, no minification
• 4 scripts (2 of them zero-engine-call maths), the demo object, the demo room
• Readme with quickstart, API reference and per-deformer parameter tables

Requires GameMaker 2024+ (built and package-verified on runtime 2024.14). Windows/Mac/Linux/console-agnostic — it is pure GML over vertex buffers. Code is AI-written and disclosed as such; every visual claim above was verified by running the demo and looking at the frames.

The rest of the GameMaker set

All four came out of the same habit: draw it from code instead of shipping a PNG, so none of it lands on your texture page.

Kinetic UI — panels, borders and bars generated at draw time. One code path from 480p to 4K, and you retheme it by editing a palette.

Trove — 75 item forms over 12 material palettes, so 900 inventory icons with no atlas, plus the inventory layer to show them off.

Meridian — skill trees where you declare the dependencies and never type a node position. 60 sigil motifs across 8 palettes, all drawn at runtime.

All four together in GameMaker Complete, $73.46 instead of $104.96.