Skip to content

armgit / andee

Public Imported from GitHub
0

Andee lives on your phone or Mac and uses any app like you do—no integrations, no root, any model; memory and passwords never leave your device | Andee 住进你的手机或 Mac,像你一样操作任何 App——无需集成、无需 Root、支持任意模型,记忆和密码绝不离开设备。

feat(ball): drop the raised hands and keep only the paws

booboosui04d7bfb0920f
diff --git a/app/src/main/java/net/kuafuai/andee/ui/ball/BallLook.kt b/app/src/main/java/net/kuafuai/andee/ui/ball/BallLook.kt
index 7c4ae84..41f28e6 100644
--- a/app/src/main/java/net/kuafuai/andee/ui/ball/BallLook.kt
+++ b/app/src/main/java/net/kuafuai/andee/ui/ball/BallLook.kt
@@ -400,11 +400,15 @@ class BallLook(
// ---- Gestures ----
/**
- * Draw hands and props, and honour the per-mood [Pose]: a wink, eyes that look
- * up, a lid that comes down, an open mouth with a tongue in it, a body that
- * squashes. Off for every look but one, and **off means the whole pose table is
- * ignored** rather than partly applied — the other five characters were tuned
- * without any of it, and a fist under a pig's chin was never part of the brief.
+ * Draw props and honour the per-mood [Pose]: a wink, eyes that look up, a lid
+ * that comes down, an open mouth with a tongue in it, a body that squashes. Off
+ * for every look but one, and **off means the whole pose table is ignored**
+ * rather than partly applied — the other five characters were tuned without any
+ * of it, and a star over a pig's head was never part of the brief.
+ *
+ * It used to also gate the raised-hand poses. Those are gone (see [Pose]), so
+ * what this flag still buys is the props, the sliced-lid eye and the idle life
+ * of the one look that has it.
*/
val gestures: Boolean = false,
diff --git a/app/src/main/java/net/kuafuai/andee/ui/ball/EmotionBallRenderer.kt b/app/src/main/java/net/kuafuai/andee/ui/ball/EmotionBallRenderer.kt
index 4a4a2e5..8a0c9d4 100644
--- a/app/src/main/java/net/kuafuai/andee/ui/ball/EmotionBallRenderer.kt
+++ b/app/src/main/java/net/kuafuai/andee/ui/ball/EmotionBallRenderer.kt
@@ -327,9 +327,6 @@ class EmotionBallRenderer : GLSurfaceView.Renderer {
/** One blob, instanced eight times into two paws. See [drawHands]. */
private lateinit var handMesh: Mesh
- /** A capsule along +Y for fingers: unit radius, straight section of 2·[CAPSULE_HALF] radii. See [fingerPart]. */
- private lateinit var fingerMesh: Mesh
-
/** One blob per pupil and per glint — see [drawDot]. */
private lateinit var dotMesh: Mesh
@@ -339,13 +336,6 @@ class EmotionBallRenderer : GLSurfaceView.Renderer {
private lateinit var dropMesh: Mesh
private lateinit var heartMesh: Mesh
- /** Scratch: a hand part's model matrix, built on top of the hand's own. */
- private val partM = FloatArray(16)
-
- /** The hand's own model matrix, kept while its parts are drawn. */
- private val handM = FloatArray(16)
-
- private val handColor = FloatArray(3)
private val propColor = FloatArray(3)
private val rimColor = FloatArray(3)
@@ -459,7 +449,6 @@ class EmotionBallRenderer : GLSurfaceView.Renderer {
// subdiv 2 is already smooth and subdiv 4 is 16x the triangles for
// nothing. It gets drawn eight times a frame.
handMesh = IcoSphere.build(2)
- fingerMesh = Capsule.build(1f, CAPSULE_HALF * 2f, 6, 14)
// Pupils and glints. Same unit blob as a paw part, and the same order of
// cost: four of them a frame, each about 4 dp wide on screen.
dotMesh = IcoSphere.build(2)
@@ -531,7 +520,6 @@ class EmotionBallRenderer : GLSurfaceView.Renderer {
drawSnout()
drawFace()
drawHands()
- drawGestureHands()
drawProps()
drawBlush()
drawRim()
@@ -1831,126 +1819,11 @@ class EmotionBallRenderer : GLSurfaceView.Renderer {
handMesh.draw()
}
- /**
- * The gesture hands, for a look with [BallLook.gestures]: two plump mitts parented
- * to the body, so they breathe, hop and lean with it — unlike [drawHands], whose
- * paws hold still on the ledge while the body slips.
- *
- * **A hand is a round palm, a thumb, and at most two fingers.** Two, because
- * five blobs turned into a lumpy knot at eighty dp and a bare ball with a stick
- * in it read as a candied haw on a skewer; a fat palm with a pair of short
- * chubby fingers is a V sign, a wave and a point at once, and nobody counts.
- *
- * Everything a hand does is a change of arrangement of the same few shapes, by
- * the numbers in [EmotionState.HandRender]:
- * * `fist` 0→1: open, the palm is tall with the thumb out and the two fingers
- * spread upward; closed, the palm is a tighter ball with the fingers folded
- * down over its front like two knuckles and the thumb across them.
- *
- * There is no pointing, peace-sign or thumbs-up pose, and that is a result: each
- * was built for the wink and each misread at this size — two fingers as a V that
- * turned into a lump, one finger as the rude one, a thumb as the same finger
- * again. The wink carries a heart instead ([PROP_HEART]).
- *
- * Drawn after the face so they sit over the body, in the body's own material.
- */
- private fun drawGestureHands() {
- if (!LOOK.gestures) return
- if (state.handL.s < 0.03f && state.handR.s < 0.03f) return
- for (i in 0..2) handColor[i] = bodyColor[i] * HAND_SHADE
- useShellWith(handColor)
- drawGestureHand(state.handL, -1)
- drawGestureHand(state.handR, 1)
- }
-
- private fun drawGestureHand(h: EmotionState.HandRender, side: Int) {
- if (h.s < 0.03f) return
- val sc = h.s.coerceAtMost(1.2f) * HAND_SCALE
- val r2 = LOOK.bodyScale * LOOK.bodyScale - h.x * h.x - h.y * h.y
- // On the surface where there is one, and never behind the ball: a hand set
- // out past the silhouette used to sit at z 0.12, and its inner half was
- // hidden by the body it was reaching across.
- val z = max(sqrt(max(r2, 0f)) + 0.05f, HAND_MIN_Z)
- val swing = h.waveAmt * sin(state.clock * 9f) * 24f
- val bob = h.jig * (1f - h.waveAmt) * sin(state.clock * 7f) * 0.035f
- composeModelFromRoot {
- Matrix.translateM(local, 0, h.x, h.y + bob, z)
- Matrix.rotateM(local, 0, h.roll + swing, 0f, 0f, 1f)
- if (side < 0) Matrix.scaleM(local, 0, -1f, 1f, 1f)
- Matrix.scaleM(local, 0, sc, sc, sc)
- }
- System.arraycopy(model, 0, handM, 0, 16)
- val f = h.fist
-
- // Palm: tall and wide when open, a tighter ball when closed.
- val pw = 0.185f + (0.165f - 0.185f) * f
- val ph = 0.185f + (0.160f - 0.185f) * f
- handPart(0f, 0f, 0f, pw, ph, 0.150f)
-
- // Thumb: out to the side when open, across the front when closed.
- handPart(
- 0.170f + (0.050f - 0.170f) * f,
- 0.020f + (-0.040f - 0.020f) * f,
- 0.050f + (0.150f - 0.050f) * f,
- 0.080f + (0.090f - 0.080f) * f,
- 0.095f + (0.070f - 0.095f) * f,
- 0.085f,
- )
-
- // Two fingers, each one capsule. They start at the top of the palm and lean
- // out by an angle: nearly parallel and short is a wave, folded flat on the
- // palm is a fist.
- val fr = 0.056f
- for (n in 0..1) {
- val dir = if (n == 0) -1f else 1f
- val ang = dir * 7f * (1f - f)
- val ax = dir * 0.065f
- val ay = 0.120f + (0.030f - 0.120f) * f
- val az = 0.040f + (0.120f - 0.040f) * f
- val len = 0.290f - 0.180f * f
- fingerPart(ax, ay, az, len, fr, ang)
- }
- }
-
- /** One part of a gesture hand: [handM] with a translate and a scale on it. */
- private fun handPart(x: Float, y: Float, z: Float, rx: Float, ry: Float, rz: Float) {
- System.arraycopy(handM, 0, partM, 0, 16)
- Matrix.translateM(partM, 0, x, y, z)
- Matrix.scaleM(partM, 0, rx, ry, rz)
- Matrix.multiplyMM(mv, 0, view, 0, partM, 0)
- Matrix.multiplyMM(mvp, 0, proj, 0, mv, 0)
- drawShellPart(handMesh)
- }
-
- /**
- * A finger: one capsule, [len] long tip to base and [r] thick, growing up from
- * ([bx], [by], [bz]) in the hand's own plane and leaning [angle] degrees off
- * vertical (positive toward +X).
- *
- * Placed by its base and an angle, so a V sign is two calls with two angles
- * instead of a pile of hand-tuned offsets, and drawn as a single mesh so there is
- * no seam for the eye to read as a row of beads — which is exactly what two
- * stacked ellipsoids per finger looked like.
- */
- private fun fingerPart(bx: Float, by: Float, bz: Float, len: Float, r: Float, angle: Float) {
- System.arraycopy(handM, 0, partM, 0, 16)
- Matrix.translateM(partM, 0, bx, by, bz)
- Matrix.rotateM(partM, 0, -angle, 0f, 0f, 1f)
- // The capsule is centred on its origin: lift it so its base cap sits on the
- // anchor, then stretch y so the whole thing is [len] tall.
- Matrix.translateM(partM, 0, 0f, len / 2f - r, 0f)
- val sy = len / (r * (2f + 2f * CAPSULE_HALF))
- Matrix.scaleM(partM, 0, r, r * sy, r)
- Matrix.multiplyMM(mv, 0, view, 0, partM, 0)
- Matrix.multiplyMM(mvp, 0, proj, 0, mv, 0)
- drawShellPart(fingerMesh)
- }
-
/**
* Stars, motion strokes, the shield and the sweat bead — everything a pose
* puts *around* the ball rather than on it.
*
- * Lit with the shell shader like the hands, which is what makes them puffy
+ * Lit with the shell shader like the body, which is what makes them puffy
* stickers instead of flat clip-art, and parented to the body so they bob
* with it. Each pops in by [EmotionState.prop], with a small overshoot: a prop
* that eases to full size reads as appearing, one that overshoots reads as
@@ -2192,24 +2065,6 @@ class EmotionBallRenderer : GLSurfaceView.Renderer {
/** How much of the eye's height a lowered lid slices off; see [LookMeshes.eyeCut]. */
private const val GESTURE_LID_CUT = 0.38f
-
- /** The gesture hands are a touch lighter than the body: they face the light. */
- private const val HAND_SHADE = 1.05f
-
- /** Half the straight section of the finger capsule, in radii. */
- private const val CAPSULE_HALF = 0.9f
-
- /**
- * How big a gesture hand is drawn, as a multiple of the geometry in
- * [drawGestureHand]. Measured off the sketches: a hand is about a quarter of
- * the head's width, and the first pass drew them at about a seventh — they
- * read as mittens on a doll rather than as part of the character.
- */
- private const val HAND_SCALE = 1.35f
-
- /** The shallowest a gesture hand sits: in front of the body's own edge. See [drawGestureHand]. */
- private const val HAND_MIN_Z = 0.46f
-
private val CORAL = floatArrayOf(1.0f, 0.50f, 0.40f)
private val CORAL_LIGHT = floatArrayOf(1.0f, 0.68f, 0.56f)
private val HEART_COLOR = floatArrayOf(1.0f, 0.40f, 0.52f)
@@ -2220,7 +2075,7 @@ class EmotionBallRenderer : GLSurfaceView.Renderer {
private val STAR_POS = floatArrayOf(-0.98f, 0.72f, 0.05f, 1.18f, 1.02f, 0.80f)
private val STAR_SIZE = floatArrayOf(0.20f, 0.15f, 0.19f)
- /** Motion strokes as `x, y, roll` triples — a fan from the waving hand, a pair off the pointing one, a burst on top. */
+ /** Motion strokes as `x, y, roll` triples — a fan at the side, and a burst over the head. */
private val SPARK_L = floatArrayOf(-0.78f, 0.50f, 35f, -1.04f, 0.36f, 62f, -1.22f, 0.10f, 88f)
private val SPARK_TOP = floatArrayOf(0f, 1.15f, 0f, -0.28f, 1.08f, 35f, 0.28f, 1.08f, -35f)
@@ -2485,7 +2340,7 @@ class EmotionBallRenderer : GLSurfaceView.Renderer {
// Identical lighting; the only addition is `vT`, the horn mesh's own v
// coordinate (0 at the base, 1 at the tip), and the mix it drives. Kept as a
// second program rather than a branch in the shell shader so the one that
- // draws the body, the hands and every other look's horns is not touched.
+ // draws the body and every other look's horns is not touched.
private const val HORN_VS = """
uniform mat4 uMVP;
uniform mat4 uMV;
diff --git a/app/src/main/java/net/kuafuai/andee/ui/ball/EmotionState.kt b/app/src/main/java/net/kuafuai/andee/ui/ball/EmotionState.kt
index 123120a..4e73ab8 100644
--- a/app/src/main/java/net/kuafuai/andee/ui/ball/EmotionState.kt
+++ b/app/src/main/java/net/kuafuai/andee/ui/ball/EmotionState.kt
@@ -161,23 +161,9 @@ class EmotionState {
/** `⌣` instead of `⌢` for closed eyes. A flip, not a tween. */
var arcFlip = false; private set
- /** Seconds since start, for the idle motion of hands and props. */
+ /** Seconds since start, for the idle motion of props. */
var clock = 0f; private set
- /** One hand as the renderer reads it: a [HandPose] that has been tweened. */
- class HandRender {
- var x = 0f
- var y = 0f
- var s = 0f
- var roll = 0f
- var fist = 0f
- var jig = 0f
- var waveAmt = 0f
- }
-
- val handL = HandRender()
- val handR = HandRender()
-
/** Pop-in amount of each prop, 0..1; indexed by the `PROP_*` constants. */
val prop = FloatArray(PROP_COUNT)
@@ -466,7 +452,6 @@ class EmotionState {
val gestures = LOOK.gestures
val pose = if (gestures) POSES[mood] ?: Pose.NONE else Pose.NONE
val tWink = pose.wink
- val tHandL = pose.handL
val tSparkL = pose.sparkL
val kg = min(1f, dt * 10f)
wink += (tWink - wink) * kg
@@ -476,8 +461,6 @@ class EmotionState {
poseSqx += (pose.sqx - poseSqx) * kg
poseSqy += (pose.sqy - poseSqy) * kg
arcFlip = pose.arcFlip
- tweenHand(handL, tHandL, dt)
- tweenHand(handR, pose.handR, dt)
val kp = min(1f, dt * 9f)
val away = 1f - cling.coerceIn(0f, 1f)
prop[PROP_STARS] += (pose.stars * away - prop[PROP_STARS]) * kp
@@ -651,34 +634,6 @@ class EmotionState {
mouthRotZ = PI.toFloat() + smile * LOOK.smileRoll + skew * 2.2f + LOOK.mouthTilt / DEG
}
- /**
- * Ease one hand toward its target pose.
- *
- * A hand that is not showing is *placed* at its new spot before it grows, and
- * only slides once it is visible. Sliding from wherever it last was would
- * drag a half-grown hand across the face on its way to the chin; growing in
- * place reads as the hand arriving, which is the point.
- */
- private fun tweenHand(h: HandRender, t: HandPose, dt: Float) {
- val wants = t.s > 0.02f
- if (wants) {
- if (h.s < 0.05f) {
- h.x = t.x; h.y = t.y; h.roll = t.roll; h.fist = t.fist
- } else {
- val k = min(1f, dt * 10f)
- h.x += (t.x - h.x) * k
- h.y += (t.y - h.y) * k
- h.roll += (t.roll - h.roll) * k
- h.fist += (t.fist - h.fist) * k
- }
- val kj = min(1f, dt * 6f)
- h.jig += (t.jig - h.jig) * kj
- h.waveAmt += ((if (t.wave) 1f else 0f) - h.waveAmt) * kj
- }
- val away = 1f - cling.coerceIn(0f, 1f)
- h.s += ((if (wants) t.s else 0f) * away - h.s) * min(1f, dt * 8f)
- }
-
fun writeHeads(buf: FloatArray) {
val cr = nowColor[0];
val cg = nowColor[1];
diff --git a/app/src/main/java/net/kuafuai/andee/ui/ball/Mood.kt b/app/src/main/java/net/kuafuai/andee/ui/ball/Mood.kt
index 45c9f4a..0c1c54d 100644
--- a/app/src/main/java/net/kuafuai/andee/ui/ball/Mood.kt
+++ b/app/src/main/java/net/kuafuai/andee/ui/ball/Mood.kt
@@ -19,9 +19,9 @@ package net.kuafuai.andee.ui.ball
enum class Mood {
CALM, HAPPY, CURIOUS, TENSE, ANXIOUS, CONCERNED,
// Gestures the model can ask for by name. They share the first group's
- // standing — a face the model picks — but they are drawn with hands and
- // props, which only a look with [BallLook.gestures] has; on the others each
- // one falls back to the plain face on its [FACE] row.
+ // standing — a face the model picks — but they are drawn with props, which
+ // only a look with [BallLook.gestures] has; on the others each one falls back
+ // to the plain face on its [FACE] row.
WINK, WAVE, PROTECT, CELEBRATE, REST,
LISTENING, HOLDING, THINKING, SPEAKING,
SEARCHING, SUCCESS, FAILED, SLEEPING,
@@ -261,7 +261,7 @@ val IDLE_ACTIONS: List<Pair<Action, Float>> = listOf(
* one at idle is a lie the user acts on, by speaking into a mic that is off.
* - ANXIOUS, CONCERNED, TENSE, FAILED and PROTECT read as an alarm or an error.
* - SUCCESS and CELEBRATE read as a task having finished.
- * - **REST and SLEEPING look alike** — squashed, eyes shut, hands on the belly; the
+ * - **REST and SLEEPING look alike** — squashed, eyes shut, horns slack; the
* snot bubble is all that tells them apart. REST was in this list and the
* capture showed why it cannot be: it surfaced fifteen seconds after Andee woke
* from a nap and read as the ball going straight back to sleep, which is
diff --git a/app/src/main/java/net/kuafuai/andee/ui/ball/Pose.kt b/app/src/main/java/net/kuafuai/andee/ui/ball/Pose.kt
index 8e319e7..50a33e6 100644
--- a/app/src/main/java/net/kuafuai/andee/ui/ball/Pose.kt
+++ b/app/src/main/java/net/kuafuai/andee/ui/ball/Pose.kt
@@ -1,45 +1,15 @@
package net.kuafuai.andee.ui.ball
-/**
- * Where one hand wants to be, in the ball's own space (body radius 0.87, +X to the
- * viewer's right, +Y up). The hand sits on the body's surface at that x/y, so
- * only two numbers are needed; its depth is worked out at draw time.
- *
- * Hands are the part of the face the old moods had no word for. A closed fist
- * under the chin says *thinking*, two raised fists say *we did it*, a hand over
- * the belly says *resting* — none of which a round eye and a curved mouth can
- * say, and all of which survive being drawn a thumb wide because they are
- * shapes, not colours.
- */
-class HandPose(
- val x: Float,
- val y: Float,
- /** 0 = tucked away. The hand grows from nothing at its own spot, it does not fly in. */
- val s: Float,
- /**
- * Degrees counter-clockwise on screen, for *this* hand as drawn. The geometry
- * is mirrored for the left hand but the angle is not: a raised left fist
- * leaning outward is a positive roll, a raised right one a negative.
- */
- val roll: Float = 0f,
- /** 0 = open mitten, 1 = fist. */
- val fist: Float = 0f,
- /** Idle motion: a swing of the wrist if [wave], otherwise a small vertical bob. */
- val jig: Float = 0f,
- val wave: Boolean = false,
-)
-
/**
* Everything a mood adds on top of [Face], and the reason the two are separate
* classes: [Face] is a row of numbers every look interprets, and each number is
- * a *continuous* dial. These are the discrete things — a wink, a hand, a star —
+ * a *continuous* dial. These are the discrete things — a wink, a star, a shield —
* that only the looks with [BallLook.gestures] draw. A look without it ignores
* the whole table, so adding a mood here can never change what the other five
* characters look like.
*
* Each value is a target, not a state. [EmotionState] tweens toward it, which is
- * what makes a hand slide to the chin instead of blinking onto it, and a star
- * pop in instead of appearing.
+ * what makes a star pop in instead of appearing.
*/
class Pose(
/** The viewer's-right eye closes into an arc and the other stays open. */
@@ -65,9 +35,12 @@ class Pose(
* the one part of the head that can show a mood while the face is looking away.
*/
val hornLean: Float = 0f,
- val handL: HandPose = HAND_OFF_L,
- val handR: HandPose = HAND_OFF_R,
val stars: Float = 0f,
+ /**
+ * The fan of motion strokes beside the ball. It used to be drawn around a hand
+ * raised at the side; the hand is gone and the strokes are not, deliberately —
+ * see the [POSES] row for [Mood.WAVE].
+ */
val sparkL: Float = 0f,
/** A small heart floating beside the face. */
val heart: Float = 0f,
@@ -90,24 +63,23 @@ const val PROP_SHIELD = 4
const val PROP_DROP = 5
const val PROP_COUNT = 6
-val HAND_OFF_L = HandPose(-0.62f, -0.15f, 0f)
-val HAND_OFF_R = HandPose(0.62f, -0.15f, 0f)
-
-/** The wave [Mood.WAVE] raises: a left hand up at the side, swinging. */
-val HAND_WAVE = HandPose(-0.96f, 0.05f, 1f, roll = -10f, jig = 1f, wave = true)
-
/**
* The poses. The numbers were read off the reference sketches (wink, wave, think,
* rest, protect, celebrate) the same way the look's own were off the picture:
* measured on the sketch, divided by the head's width, times the body's 1.74
* diameter. Where there was no sketch — the work moods, the worried ones — they
* are the nearest gesture a person would make.
+ *
+ * Most of these used to raise a hand and no longer do — the ball only grows paws
+ * now, and only to hang off the screen edge ([EmotionBallRenderer.drawHands]).
+ * A row that lost its whole pose is not a broken row: a mood is read through its
+ * own [Face] row and its body motion first, and those never came from here.
+ * [Mood.HOLDING] is the one left with nothing else at all, on purpose.
*/
val POSES: Map<Mood, Pose> = mapOf(
Mood.CALM to Pose(),
- // A pleased face with a little burst above the head. No hands: a happy face is
- // the one that most needs its face visible.
+ // A pleased face with a little burst above the head.
Mood.HAPPY to Pose(sparkTop = 1f, hornLean = -8f),
// Eyes up and to one side, as if something is on the shelf above you, and the
@@ -117,20 +89,11 @@ val POSES: Map<Mood, Pose> = mapOf(
// Annoyed rather than hurt: the lids come down, the horns lie back a little.
Mood.TENSE to Pose(lidCut = 0.8f, hornLean = 10f),
- // Fists drawn in at the chest, a bead of sweat, and the shiver the Face row
- // already supplies.
- Mood.ANXIOUS to Pose(
- drop = 1f, lookY = 0.1f, lidCut = -1f, hornLean = 14f,
- handL = HandPose(-0.24f, -0.46f, 0.8f, roll = 25f, fist = 1f, jig = 0.12f),
- handR = HandPose(0.24f, -0.46f, 0.8f, roll = -25f, fist = 1f, jig = 0.12f),
- ),
-
- // Hands folded low, eyes cast a little down: sorry, and about to say so.
- Mood.CONCERNED to Pose(
- lookY = -0.2f, lidCut = -1f, hornLean = 18f,
- handL = HandPose(-0.17f, -0.64f, 0.85f, roll = 30f, fist = 0.4f),
- handR = HandPose(0.17f, -0.64f, 0.85f, roll = -30f, fist = 0.4f),
- ),
+ // A bead of sweat, and the shiver the Face row already supplies.
+ Mood.ANXIOUS to Pose(drop = 1f, lookY = 0.1f, lidCut = -1f, hornLean = 14f),
+
+ // Eyes cast a little down: sorry, and about to say so.
+ Mood.CONCERNED to Pose(lookY = -0.2f, lidCut = -1f, hornLean = 18f),
// wink.webp — a closed eye and a heart floating beside the cheek. The reference
// has a pointing hand; four hands were tried here (a V, a pointing finger, a
@@ -138,72 +101,52 @@ val POSES: Map<Mood, Pose> = mapOf(
// rude finger — so the wink carries a heart, which cannot be misread.
Mood.WINK to Pose(wink = 1f, heart = 1f, hornLean = -6f),
- // wave.webp — a hand up at the side, swinging, with its motion lines.
- Mood.WAVE to Pose(sparkL = 1f, handL = HAND_WAVE, hornLean = -10f),
-
- // protect.webp — brows set, a fist at the ready and a shield held out.
- Mood.PROTECT to Pose(
- lidCut = 1f, shield = 1f, hornLean = -8f,
- handL = HandPose(-0.84f, -0.50f, 1f, roll = 20f, fist = 1f),
- ),
-
- // celebrate.webp — both fists in the air, stars, a grin; the horns spring.
- Mood.CELEBRATE to Pose(
- stars = 1f, sparkTop = 1f, hornLean = -16f,
- handL = HandPose(-1.12f, 0.0f, 1f, roll = 18f, fist = 1f, jig = 1f),
- handR = HandPose(1.12f, 0.0f, 1f, roll = -18f, fist = 1f, jig = 1f),
- ),
-
- // rest.webp — squashed down, eyes shut, both hands on the belly, horns slack.
- Mood.REST to Pose(
- sqx = 0.08f, sqy = -0.13f, arcFlip = true, hornLean = 24f,
- handL = HandPose(-0.47f, -0.50f, 0.9f, roll = 20f, fist = 0.2f),
- handR = HandPose(0.55f, -0.46f, 0.9f, roll = -20f, fist = 0.2f),
- ),
-
- // A hand cupped behind the ear: the mic is open, and the horns are up too.
- Mood.LISTENING to Pose(
- hornLean = -16f,
- handL = HandPose(-0.98f, 0.10f, 0.95f, roll = -25f, fist = 0f),
- ),
-
- // Holding the signboard up: both fists raised on either side.
- Mood.HOLDING to Pose(
- handL = HandPose(-0.96f, 0.40f, 0.85f, roll = 15f, fist = 1f, jig = 0.25f),
- handR = HandPose(0.96f, 0.40f, 0.85f, roll = -15f, fist = 1f, jig = 0.25f),
- ),
-
- // think.webp — eyes up and to the side, a fist under the chin.
- Mood.THINKING to Pose(
- lookX = 0.5f, lookY = 0.9f, hornLean = -8f,
- handL = HandPose(-0.04f, -0.66f, 1f, roll = 25f, fist = 1f),
- ),
+ // wave.webp — the fan of motion strokes that used to come off a hand raised at
+ // the side. **The hand is gone and the strokes are kept on purpose**: three marks
+ // beside a ball that is leaning and breathing still read as an event happening
+ // to it, which is all this gesture ever said at eighty dp. One field to delete
+ // here if they read as stray marks instead.
+ Mood.WAVE to Pose(sparkL = 1f, hornLean = -10f),
+
+ // protect.webp — brows set, a shield held out.
+ Mood.PROTECT to Pose(lidCut = 1f, shield = 1f, hornLean = -8f),
+
+ // celebrate.webp — stars, a grin; the horns spring.
+ Mood.CELEBRATE to Pose(stars = 1f, sparkTop = 1f, hornLean = -16f),
+
+ // rest.webp — squashed down, eyes shut, horns slack.
+ Mood.REST to Pose(sqx = 0.08f, sqy = -0.13f, arcFlip = true, hornLean = 24f),
+
+ // The mic is open. What says "listening" is the horns standing up and the head
+ // cocking, both of which are the Face row's — plus its open mouth [Face.gape],
+ // which is the shape change that survives being drawn a thumb wide.
+ Mood.LISTENING to Pose(hornLean = -16f),
+
+ // The signboard is up, and it is a real card in the ball's own window
+ // ([FloatingWindowUi.showSignboard]), not a prop. This row is empty on purpose:
+ // the mood exists to give the ball a waiting face while it holds the card, and
+ // the yellow [Face] row is where that lives. It used to raise both fists, which
+ // said "holding" to nobody at this size.
+ Mood.HOLDING to Pose(),
+
+ // think.webp — eyes up and to the side, and the gaze drift the rim and scan light
+ // ride on.
+ Mood.THINKING to Pose(lookX = 0.5f, lookY = 0.9f, hornLean = -8f),
// The mouth is the talk envelope's, which opens the thin smile rather than
- // swapping it for another shape. No hands, so the face is clear while it is
+ // swapping it for another shape. No pose, so the face is clear while it is
// being listened to.
Mood.SPEAKING to Pose(),
- // Driving an app: a fist at the glass, tapping. It was one finger out, and a
- // single finger standing up beside the face read as the rude one — two fingers
- // leaned 35° overlap into a lone vertical bar. A fist has no such reading.
- Mood.SEARCHING to Pose(
- lookY = -0.15f, hornLean = -4f,
- handR = HandPose(0.80f, -0.40f, 0.9f, roll = 15f, fist = 1f, jig = 0.9f),
- ),
+ // Driving an app: eyes down and to the side with the head cocked, which reads as
+ // "looking at something that isn't you" and is exactly true. The speed is carried
+ // by the rim, core and scan light off `busy`, not from here.
+ Mood.SEARCHING to Pose(lookY = -0.15f, hornLean = -4f),
- Mood.SUCCESS to Pose(
- stars = 1f, sparkTop = 1f, hornLean = -16f,
- handL = HandPose(-1.0f, 0.0f, 1f, roll = 18f, fist = 1f, jig = 1f),
- handR = HandPose(1.0f, 0.0f, 1f, roll = -18f, fist = 1f, jig = 1f),
- ),
+ Mood.SUCCESS to Pose(stars = 1f, sparkTop = 1f, hornLean = -16f),
// Eyes down, a bead of sweat, slumped, horns flopped.
Mood.FAILED to Pose(lookY = -0.5f, lidCut = -1.2f, drop = 1f, sqy = -0.05f, hornLean = 24f),
- Mood.SLEEPING to Pose(
- sqx = 0.08f, sqy = -0.13f, arcFlip = true, hornLean = 24f,
- handL = HandPose(-0.47f, -0.50f, 0.9f, roll = 20f, fist = 0.2f),
- handR = HandPose(0.55f, -0.46f, 0.9f, roll = -20f, fist = 0.2f),
- ),
+ Mood.SLEEPING to Pose(sqx = 0.08f, sqy = -0.13f, arcFlip = true, hornLean = 24f),
)