perelman/contra-renderer
1
0
Fork 1
Code Issues 5 Pull Requests Activity

Compare commits

base: perelman:b6f2451920328a3b7c01388bee8d60cac868d183
Branches Tags
perelman:main
perelman:feature/variants
perelman:exp/dancer-colors
perelman:exp/perf/cache-strings
..
compare: perelman:14c31583e52abc6519f9214925e61812ae4e3ce9
Branches Tags
perelman:feature/variants
perelman:main
perelman:exp/dancer-colors
perelman:exp/perf/cache-strings

No commits in common. "b6f2451920328a3b7c01388bee8d60cac868d183" and "14c31583e52abc6519f9214925e61812ae4e3ce9" have entirely different histories.
b6f2451920 ... 14c31583e5

4 changed files with 23 additions and 148 deletions
Show Stats Expand all files Collapse all files

57
www/js/animation.ts
View File

@ -1,5 +1,5 @@
import { CoupleRole, DancerIdentity, Rotation, normalizeRotation } from "./danceCommon.js";
import { DancerSetPosition, DancersSetPositions, Hand, OffsetDistance, OffsetEquals, OffsetMinus, OffsetPlus, OffsetRotate, OffsetTimes, OffsetTranspose, offsetZero, setHeight } from "./rendererConstants.js";
import { DancerSetPosition, DancersSetPositions, Hand, OffsetEquals, OffsetMinus, OffsetPlus, OffsetRotate, OffsetTimes, OffsetTranspose, offsetZero, setHeight } from "./rendererConstants.js";
import { Offset, leftShoulder, rightShoulder, degreesToRadians, radiansToDegrees } from "./rendererConstants.js";
export enum AnimationKind {
@ -369,16 +369,17 @@ export class StepWideLinearAnimationSegment extends AnimationSegment {
private readonly movementAngle: number;
private readonly handTransitionProgress: number;
private readonly progressCenter?: number;
private readonly center?: Offset;
private readonly actualCenter: Offset;
private readonly hands: Map<Hand, HandAnimation>;
private readonly facing: "Start" | "Forward";
constructor({ beats, startPosition, endPosition, distanceAtMidpoint, otherPath, hands, facing }: {
constructor({ beats, startPosition, endPosition, distanceAtMidpoint, center, hands, facing }: {
beats: number;
startPosition: DancerSetPosition;
endPosition: DancerSetPosition;
distanceAtMidpoint: number;
otherPath?: { start: Offset, end: Offset };
center?: Offset;
hands?: Map<Hand, HandAnimation>;
facing?: "Start" | "Forward";
}) {
@ -402,51 +403,13 @@ export class StepWideLinearAnimationSegment extends AnimationSegment {
// Center is the point where the dancer is closest to the other dancer.
// If omitted, it's assumed the movement is symmetrical, so that happens halfway through the move.
// Otherwise, find the point on the line between the start and end closest to the center.
this.actualCenter = OffsetPlus(this.startPosition.position, OffsetTimes(vector, 0.5));
if (otherPath) {
/*
(xa(t), ya(t))
(xb(t), yb(t))
(xa_0 + xa_m*t, ya_0, ya_m*t)
(xb_0 + xb_m*t, yb_0, yb_m*t)
// can omit the sqrt
MIN[((xa_0 + xa_m*t) - (xb_0 + xb_m*t))**2 + ((ya_0, ya_m*t) - (yb_0, yb_m*t))**2]
MIN[(xa_0-xb_0 + (xa_m-xb_m)*t)**2 + (ya_0-yb_0 + (ya_m-yb_m)*t)**2]
MIN[(x_0 + x_m*t)**2 + (y_0 + y_m*t)**2]
MIN[(x_0**2 + 2x_0*x_m*t + x_m**2*t**2) + (y_0**2 + 2y_0*y_m*t + y_m**2*t**2)]
MIN[(x_0**2+y_0**2 + (2x_0*x_m+2y_0*y_m)*t + (x_m**2+y_m**2)*t**2)]
a = x_m**2+y_m**2 = (xa_m-xb_m)**2 + (ya_m-yb_m)**2
b = (2x_0*x_m+2y_0*y_m) = 2*((xa_0-xb_0)*(xa_m-xb_m) + (ya_0-yb_0)*(ya_m-yb_m))
t = -b/2a
*/
const otherVector = OffsetMinus(otherPath.end, otherPath.start);
const m = OffsetMinus(otherVector, vector);
const i = OffsetMinus(otherPath.start, this.startPosition.position);
const a = m.x*m.x + m.y*m.y;
const b = 2*(i.x*m.x + i.y*m.y);
const tMin = -b/(2*a);
const t = tMin >= 0 && tMin <= 1 ? tMin : undefined;
if (t !== undefined) {
this.progressCenter = t;
this.actualCenter = interpolateLinearOffset(t, this.startPosition.position, this.endPosition.position);
const otherCenter = interpolateLinearOffset(t, otherPath.start, otherPath.end);
const otherSideways = OffsetMinus(this.actualCenter, otherCenter);
const sidewaysLinedUp = Math.sign(otherSideways.x) === Math.sign(sideways.x) && Math.sign(otherSideways.y) === Math.sign(sideways.y);
const distanceAdjustment = OffsetDistance(this.actualCenter, otherCenter) * (sidewaysLinedUp ? +1 : -1);
if (this.distanceAtMidpoint > 0) {
this.distanceAtMidpoint = Math.max(0, this.distanceAtMidpoint - distanceAdjustment);
if (center) {
this.actualCenter = this.center = center;
this.progressCenter = ((center.x - this.startPosition.position.x) * vector.x
+ (center.y - this.startPosition.position.y) * vector.y)
/ norm;
} else {
this.distanceAtMidpoint = Math.min(0, this.distanceAtMidpoint + distanceAdjustment);
}
}
this.actualCenter = OffsetPlus(this.startPosition.position, OffsetTimes(vector, 0.5));
}
this.handTransitionProgress = 0.5 / beats;

90
www/js/interpreter.ts
View File

@ -1066,7 +1066,6 @@ function moveAsLowLevelMoves({ move, nextMove, startingPos, numProgessions }: {
side: hand,
withHands: true,
facing: "Start",
otherPath: "Swap",
}
};
@ -1150,7 +1149,6 @@ function moveAsLowLevelMoves({ move, nextMove, startingPos, numProgessions }: {
side: hand,
withHands: true,
facing: "Forward",
otherPath: "Swap",
}
},
prevEnd => ({
@ -1583,7 +1581,6 @@ function moveAsLowLevelMoves({ move, nextMove, startingPos, numProgessions }: {
side: passShoulder,
withHands: false,
facing: "Start",
otherPath: "Swap",
},
}], startPos);
} else {
@ -1611,18 +1608,16 @@ function moveAsLowLevelMoves({ move, nextMove, startingPos, numProgessions }: {
return handleCircleMove(({startPos}) => {
const startingPos = { ...startPos, facing: startPos.which.facingAcross() };
const swappedPos = { ...startingPos, which: startingPos.which.swapAcross() };
return combine([
{
beats: move.beats / 2,
endPosition: swappedPos,
endPosition: {...startingPos, which: startingPos.which.swapAcross()},
movementPattern: {
kind: SemanticAnimationKind.PassBy,
side: Hand.Right,
withHands: true,
facing: "Start",
around: startingPos.which.topBottomSide(),
otherPath: "Swap",
},
},
{
@ -1640,11 +1635,6 @@ function moveAsLowLevelMoves({ move, nextMove, startingPos, numProgessions }: {
});
case "hey":
type HeyStep = {
kind: "StandStill" | "Loop" | "CenterPass" | "EndsPassIn" | "EndsPassOut",
endPosition: SemanticPosition,
}
if (move.parameters.dir !== "across") {
throw new Error("Unsupported hey direction: " + move.parameters.dir);
}
@ -1667,77 +1657,12 @@ function moveAsLowLevelMoves({ move, nextMove, startingPos, numProgessions }: {
const firstPassInCenter: boolean = dancerIsPair(move.parameters.who);
const centerShoulder = firstPassInCenter === move.parameters.shoulder ? Hand.Right : Hand.Left;
const endsShoulder = centerShoulder.opposite();
function fixupHeyOtherPath(withoutOtherPath: Map<DancerIdentity, (LowLevelMove & { heyStep?: HeyStep })[]>): Map<DancerIdentity, LowLevelMove[]> {
const numSteps = withoutOtherPath.get(DancerIdentity.OnesLark)!.length;
for (let i = 0; i < numSteps; i++) {
for (const id of withoutOtherPath.keys()) {
const lowLevelMove = withoutOtherPath.get(id)![i];
if (lowLevelMove.movementPattern.kind !== SemanticAnimationKind.PassBy
|| !lowLevelMove.heyStep
|| lowLevelMove.movementPattern.otherPath) {
continue;
}
const heyStepKind = lowLevelMove.heyStep.kind;
let foundPair = false;
for (const otherId of withoutOtherPath.keys()) {
const otherLowLevelMove = withoutOtherPath.get(otherId)![i];
if (id === otherId
|| otherLowLevelMove.movementPattern.kind !== SemanticAnimationKind.PassBy
|| !otherLowLevelMove.heyStep
|| otherLowLevelMove.movementPattern.otherPath) {
continue;
}
const otherHeyStepKind = otherLowLevelMove.heyStep.kind;
if (heyStepKind === "CenterPass" && otherHeyStepKind === "CenterPass"
|| (lowLevelMove.startPosition.which.leftRightSide() === otherLowLevelMove.startPosition.which.leftRightSide()
&& (heyStepKind === "EndsPassIn" && otherHeyStepKind === "EndsPassOut"
|| heyStepKind === "EndsPassOut" && otherHeyStepKind === "EndsPassIn"))) {
lowLevelMove.movementPattern.otherPath = {
start: { ...otherLowLevelMove.startPosition, setOffset: lowLevelMove.startPosition.setOffset, lineOffset: lowLevelMove.startPosition.lineOffset },
end: { ...otherLowLevelMove.endPosition, setOffset: lowLevelMove.endPosition.setOffset, lineOffset: lowLevelMove.endPosition.lineOffset },
}
otherLowLevelMove.movementPattern.otherPath = {
start: { ...lowLevelMove.startPosition, setOffset: otherLowLevelMove.startPosition.setOffset, lineOffset: otherLowLevelMove.startPosition.lineOffset },
end: { ...lowLevelMove.endPosition, setOffset: otherLowLevelMove.endPosition.setOffset, lineOffset: otherLowLevelMove.endPosition.lineOffset },
}
foundPair = true;
break;
}
}
if (!foundPair && heyStepKind === "EndsPassOut") {
// Then other is standing still.
const pos = {
...([...withoutOtherPath.values()]
.map(otherMoves => otherMoves[i])
.filter(m => m.movementPattern.kind === SemanticAnimationKind.StandStill
&& m.endPosition.which.leftRightSide() === lowLevelMove.endPosition.which.leftRightSide())
[0].endPosition),
setOffset: lowLevelMove.startPosition.setOffset, lineOffset: lowLevelMove.startPosition.lineOffset
}
lowLevelMove.movementPattern.otherPath = { start: pos, end: pos };
}
}
for (const id of withoutOtherPath.keys()) {
const lowLevelMove = withoutOtherPath.get(id)![i];
if (lowLevelMove.movementPattern.kind === SemanticAnimationKind.PassBy
&& !lowLevelMove.movementPattern.otherPath) {
throw new Error("Failed to fill in otherPath for " + id + " on hey step " + i);
}
}
}
// Object was mutated.
return withoutOtherPath;
}
return fixupHeyOtherPath(handleMove(({ id, startPos }) => {
return handleMove(({ id, startPos }) => {
const endsInCircle = startPos.kind === PositionKind.Circle;
type HeyStep = {
kind: "StandStill" | "Loop" | "CenterPass" | "EndsPassIn" | "EndsPassOut",
endPosition: SemanticPosition,
}
function heyStepToPartialLowLevelMove(heyStep: HeyStep): PartialLowLevelMove & { heyStep: HeyStep } {
return {
beats: heyPartBeats,
@ -1755,7 +1680,6 @@ function moveAsLowLevelMoves({ move, nextMove, startingPos, numProgessions }: {
withHands: false,
side: heyStep.kind === "CenterPass" ? centerShoulder : endsShoulder,
facing: "Start",
otherPath: undefined!, // Placeholder, fixup later.
},
heyStep,
};
@ -1895,7 +1819,7 @@ function moveAsLowLevelMoves({ move, nextMove, startingPos, numProgessions }: {
heySteps.push(nextHeyStep);
}
return combine(heySteps.map(heyStepToPartialLowLevelMove), { ...startingPos, hands: undefined });
}));
});
case "turn alone":
if (move.parameters.who !== "everyone" || move.beats !== 0) {

14
www/js/lowLevelMove.ts
View File

@ -99,11 +99,6 @@ export type SemanticAnimation = {
around: CircleSideOrCenter,
otherPath: "Swap" | {
start: SemanticPosition,
end: SemanticPosition,
}
side: Hand,
// If true, pull by the specified hand, if false, just pass by that side without hands.
@ -734,7 +729,9 @@ function animateLowLevelMoveWithoutSlide(move: LowLevelMove): animation.Animatio
})
];
case SemanticAnimationKind.PassBy:
const width = dancerWidth/2;
const passByCenter = CenterOf(move.movementPattern.around, move.startPosition.setOffset, move.startPosition.lineOffset);
const wide = move.movementPattern.around === "Center";
const width = wide ? dancerWidth : dancerWidth/2;
const distanceAtMidpoint = move.movementPattern.side == Hand.Left ? +width : -width;
// "Pull By" is just "Pass By" with hands.
const passByHands = move.movementPattern.withHands
@ -762,10 +759,7 @@ function animateLowLevelMoveWithoutSlide(move: LowLevelMove): animation.Animatio
startPosition: startSetPosition,
endPosition: { ...endSetPosition, rotation: endRotation },
distanceAtMidpoint,
otherPath: move.movementPattern.otherPath === "Swap" ? undefined : {
start: SemanticToSetPosition(move.movementPattern.otherPath.start).position,
end: SemanticToSetPosition(move.movementPattern.otherPath.end).position,
},
center: move.movementPattern.around === "Center" ? passByCenter : undefined, // TODO Better center?
hands: passByHands,
facing: move.movementPattern.facing,
}),

6
www/js/rendererConstants.ts
View File

@ -48,12 +48,6 @@ export function OffsetEquals(a: Offset, b: Offset): boolean {
return a.x === b.x && a.y === b.y;
}
export function OffsetDistance(a: Offset, b: Offset): number {
const dx = a.x - b.x;
const dy = a.y - b.y;
return Math.sqrt(dx * dx + dy * dy);
}
export interface DancerSetPosition {
// Position of the dancer relative to the center of their set.
position: Offset;