• Kits
  • Sign in

study.js

vitormagic-hand-remix

At fb85056Copy the commit ID

fb85056History

Preview

Code11.3 KiB
import { createStage } from "./glove.js?monochrome";
import { createPosePlayer, pointLoopDuration } from "./poses.js?point-loop-curl";
import { fingerLoops, fingerLoopPose } from "./finger-loops.js";

// Flexion at the joints, followed by spread at the base.
// Digits run from the thumb to the outer finger.
const digits = {
  curl: [
    [28, 35, 18, -18], [51, 69, 42, 0], [64, 76, 44, 0], [66, 78, 44, 4], [70, 80, 43, 6],
  ],
  notice: [
    [18, 25, 15, -9], [1, 18, 12, 4], [40, 52, 27, -1], [49, 57, 29, 2], [54, 65, 32, 5],
  ],
  reach: [
    [19, 24, 13, -13], [-5, 2, 1, 7], [56, 65, 28, 0], [61, 68, 32, 3], [65, 73, 36, 6],
  ],
  pinch: [
    [26, 29, 12, -43], [36, 44, 23, 10], [52, 64, 39, -1], [59, 69, 41, 2], [64, 75, 42, 5],
  ],
  reveal: [
    [10, 12, 6, -3], [1, 7, 4, 5], [-5, 6, 3, 0], [0, 9, 5, -4], [7, 14, 8, -8],
  ],
};

const variants = [
  { name: "Sleight of Hand", note: "A careful pinch and a palm-up flourish.", length: 5.6, beats: [.07,.25,.43,.71], lift: .78, prop: "star" },
  { name: "Rubber Glove", note: "A big windup, a long stretch, and a spring back.", length: 4.75, beats: [.07,.28,.42,.69], lift: 1.0, prop: "star", elastic: true },
  { name: "Pocket Blob", note: "A longer pause in blob form before the fingers emerge.", length: 6.0, beats: [.07,.30,.48,.74], lift: .58, prop: "pearl", tucked: true },
  { name: "Paper Puppet", note: "An upright wrist and quick, theatrical turns.", length: 5.1, beats: [.07,.24,.39,.68], lift: .86, prop: "diamond", crisp: true },
  { name: "Ghost Glove", note: "A slow drift and a reveal that floats out of its grasp.", length: 6.65, beats: [.07,.25,.47,.70], lift: 1.06, prop: "moon" },
];

function frame(time, shape, { x = 0, y = 0, z = 0, tilt = 0, turn = 0, roll = 0, width = 1, height = 1, open = 1 } = {}) {
  return { time, shape, x, y, z, tilt, turn, roll, width, height, open };
}

function timeline(variant) {
  const [curl, notice, reach, reveal] = variant.beats;
  const turn = variant.crisp ? 1.34 : 1;
  const rest = { x: -.21, y: -.34, tilt: -6, turn: -12, roll: 4, open: 0 };
  return [
    frame(0, "curl", rest),
    frame(curl, "curl", { ...rest, y: -.37 }),
    frame(notice - (variant.tucked ? .057 : .095), "curl", {
      ...rest, x: -.27, y: -.29, roll: 12,
    }),
    frame(notice, "notice", {
      x: -.35, y: -.01, tilt: -12, turn: -28 * turn, roll: -19, open: .79,
    }),
    frame(reach, "reach", {
      x: .16, y: .06, tilt: 3, turn: -14, roll: -51, height: variant.elastic ? 1.24 : 1.02,
    }),
    frame(reveal - .14, "pinch", { x: .44, y: .085, z: .06, tilt: 9, turn: -3, roll: -61 }),
    frame(reveal - .075, "pinch", { x: .15, y: -.09, tilt: 17, turn: 5, roll: -61, height: variant.elastic ? .88 : .98 }),
    frame(reveal, "reveal", { x: -.06, y: -.055, tilt: -26, turn: 11 * turn, roll: -51 }),
    frame(reveal + .078, "reveal", { x: -.15, y: -.015, tilt: -21, turn: 8, roll: -44 }),
    frame(.90, "curl", { ...rest, y: -.41, width: 1.09, height: .90, open: .09 }),
    frame(1, "curl", rest),
  ];
}

const mix = (a, b, t) => a + (b - a) * t;
const clamp = (number) => Math.min(1, Math.max(0, number));
const smooth = (t) => t * t * (3 - 2 * t);
const easeOut = (t) => 1 - (1 - t) ** 3;

function render(study) {
  if (study.loop === "point") {
    study.draw?.(study.posePlayer.pointLoopPose(study.progress));
    study.scrubber.value = Math.round(study.progress * 1000);
    return;
  }
  const fingerLoop = fingerLoops[study.loop];
  if (fingerLoop) {
    study.draw?.(fingerLoopPose(fingerLoop, study.progress));
    study.scrubber.value = Math.round(study.progress * 1000);
    return;
  }
  const { variant, frames, progress, buttons, scrubber, draw } = study;
  const target = frames.findIndex((frame, index) => index > 0 && frame.time >= progress);
  const from = frames[target - 1];
  const to = frames[target];
  const fraction = clamp((progress - from.time) / (to.time - from.time));
  const blend = to.shape === "reveal" && from.shape === "pinch"
    ? easeOut(fraction)
    : smooth(fraction);

  const get = (key) => mix(from[key], to[key], blend);
  const [, notice, reach, reveal] = variant.beats;
  const release = clamp((progress - reveal + .075) / .21);
  const rise = easeOut(release);
  const fade = 1 - smooth(clamp((progress - reveal - .052) / (1 - reveal - .052)));
  const beat = progress >= reveal + .10 ? 0
    : progress >= reveal - .048 ? 3
    : progress >= reach - .052 ? 2
    : progress >= notice - .05 ? 1 : 0;
  const open = get("open");
  draw?.({
    x: get("x"), y: get("y") + .045 * Math.sin(progress * Math.PI * 2), z: get("z"),
    tilt: get("tilt"), turn: get("turn"), roll: get("roll"),
    width: get("width"), height: get("height"), open,
    fingers: digits[from.shape].map((digit, index) =>
      digit.map((angle, joint) => mix(angle, digits[to.shape][index][joint], blend))),
    spark: easeOut(clamp(release * 4.8)) * fade,
    sparkX: 1.12 + rise * .33, sparkY: .41 + rise * variant.lift, rise,
    cue: .75 * smooth(clamp((progress - notice + .11) / .052)) *
      (1 - smooth(clamp((progress - reveal + .15) / .09))),
  });

  scrubber.value = Math.round(progress * 1000);
  if (beat !== study.beat) {
    buttons[study.beat]?.removeAttribute("aria-current");
    buttons[beat].setAttribute("aria-current", "step");
    study.beat = beat;
  }
}

const motion = matchMedia("(prefers-reduced-motion: reduce)");
const switcher = document.querySelector("prototype-switcher");
const template = document.querySelector("#study");
let request = 0;
let lastFrame = 0;
const visible = new Set();
const studiesByStage = new Map();

function schedule() {
  const needsFrame = (study) => study.loop ? study.draw && study.playing : study.posePlayer?.isMoving();
  if (!request && !document.hidden && [...visible].some(needsFrame)) {
    request = requestAnimationFrame(tick);
  }
}

function tick(now) {
  request = 0;
  const delta = lastFrame ? Math.min(now - lastFrame, 64) : 0;
  lastFrame = now;
  for (const study of visible) {
    if (!study.loop) {
      study.posePlayer?.step(delta);
    } else if (study.playing && study.draw) {
      const duration = study.loop === "point"
        ? pointLoopDuration
        : fingerLoops[study.loop]?.length ?? study.variant.length;
      study.progress = (study.progress + delta / (duration * 1000)) % 1;
      render(study);
    }
  }
  schedule();
  if (!request) lastFrame = 0;
}

function loadStage(study, element) {
  study.loading = true;
  createStage(element, study.variant).then((draw) => {
    study.draw = (pose) => {
      study.renderedPose = pose;
      draw(pose);
    };
    const rest = { ...study.frames[0], fingers: digits.curl };
    study.posePlayer = createPosePlayer(
      rest, digits.reveal, study.draw, schedule, () => motion.matches,
    );
    element.querySelector(".status").remove();
    if (study.loop) render(study);
    else study.posePlayer.select(study.pose);
    syncRotationPanel(study);
    schedule();
  }).catch((error) => {
    console.error(error);
    element.querySelector(".status").textContent = "The 3D preview could not be loaded.";
  });
}

const observer = new IntersectionObserver((entries) => {
  for (const entry of entries) {
    const study = studiesByStage.get(entry.target);
    if (entry.isIntersecting) {
      visible.add(study);
      if (!study.loading) loadStage(study, entry.target);
    } else {
      visible.delete(study);
    }
  }
  schedule();
});

function setPlaying(study, playing) {
  study.playing = playing;
  study.play.textContent = playing ? "Pause" : "Play";
  schedule();
}

function seek(study, progress) {
  setPlaying(study, false);
  study.progress = progress;
  render(study);
}

function selectPose(study, pose) {
  study.pose = pose;
  if (study.loop) setLoop(study, null);
  else {
    updatePoseButtons(study);
    study.posePlayer?.select(pose, study.renderedPose);
    syncRotationPanel(study);
  }
}

function updatePoseButtons(study) {
  for (const button of study.poseButtons) {
    button.setAttribute("aria-pressed", String(!study.loop && button.dataset.pose === study.pose));
  }
}

function syncRotationPanel(study) {
  study.rotationPanel.hidden = study.loop || study.pose === "sphere";
  study.rotationPanel.disabled = !study.posePlayer;
  if (study.rotationPanel.hidden || !study.posePlayer) return;
  const angles = study.posePlayer.rotation(study.pose);
  for (const input of study.rotationInputs) input.value = angles[input.dataset.axis];
}

function setLoop(study, loop) {
  study.loop = loop;
  for (const button of study.loopButtons) {
    button.setAttribute("aria-pressed", String(button.dataset.loop === loop));
  }
  study.loopControls.hidden = !loop;
  study.transportBeats.hidden = loop !== "reveal";
  updatePoseButtons(study);
  if (loop) {
    seek(study, 0);
    setPlaying(study, !motion.matches);
  } else {
    setPlaying(study, false);
    study.posePlayer?.select(study.pose, study.renderedPose);
  }
  syncRotationPanel(study);
}

const studies = variants.map((variant, index) => {
  const section = document.createElement("section");
  section.dataset.variant = variant.name;
  section.dataset.note = variant.note;
  section.append(template.content.cloneNode(true));
  const stage = section.querySelector(".stage");
  const study = {
    variant, frames: timeline(variant), progress: 0, beat: -1, loop: null, pose: "sphere",
    loopButtons: [...section.querySelectorAll("[data-loop]")],
    transportBeats: section.querySelector(".beats"),
    loopControls: section.querySelector(".loop-controls"),
    rotationPanel: section.querySelector(".rotation-panel"),
    rotationInputs: [...section.querySelectorAll("[data-axis]")],
    poseButtons: [...section.querySelectorAll("[data-pose]")],
    play: section.querySelector(".play"),
    scrubber: section.querySelector(".transport input"),
    buttons: [...section.querySelectorAll(".beats button")],
  };
  study.loopControls.id = `loop-controls-${index + 1}`;
  for (const button of study.loopButtons) {
    button.setAttribute("aria-controls", study.loopControls.id);
    button.addEventListener("click", () => {
      const loop = button.dataset.loop;
      setLoop(study, study.loop === loop ? null : loop);
    });
  }
  for (const button of study.poseButtons) {
    button.addEventListener("click", () => selectPose(study, button.dataset.pose));
  }
  for (const input of study.rotationInputs) {
    input.addEventListener("input", () => {
      if (input.validity.valid) study.posePlayer?.rotate(study.pose, input.dataset.axis, input.valueAsNumber);
    });
    input.addEventListener("blur", () => syncRotationPanel(study));
  }
  section.querySelector(".reset-angles").addEventListener("click", () => {
    study.posePlayer?.resetRotation(study.pose);
    syncRotationPanel(study);
  });
  syncRotationPanel(study);
  study.play.addEventListener("click", () => setPlaying(study, !study.playing));
  study.scrubber.addEventListener("input", () => seek(study, study.scrubber.valueAsNumber / 1000));
  study.buttons.forEach((button, index) => {
    button.addEventListener("click", () => seek(study, variant.beats[index]));
  });
  render(study);
  setPlaying(study, false);
  studiesByStage.set(stage, study);
  observer.observe(stage);
  switcher.append(section);
  return study;
});

motion.addEventListener("change", () => {
  for (const study of studies) {
    if (!study.loop) {
      if (motion.matches) study.posePlayer?.step(Infinity);
    } else if (motion.matches) {
      setPlaying(study, false);
    }
  }
});
document.addEventListener("visibilitychange", () => {
  lastFrame = 0;
  schedule();
});

Files

Loading files

Details

Size
11.3 KiB (11,618 bytes)
Object ID
a4d5d00…90eCopy the object ID
Verification
Size
11.3 KiB (11,618 bytes)
Object ID
a4d5d00…90eCopy the object ID
Storage
Stored as one object
Verification
  • README.md
  • cover.gif
  • cover.jpg
  • finger-loops.js
  • glove.js
  • index.html
  • kit.json
  • poses.js
  • soft-glove.js
  • study.css
  • study.js
  • switcher.js