22#ifndef HOLLYWOOD_MONSTERS_SCENES_ANIMATION_CHANNELS_H
23#define HOLLYWOOD_MONSTERS_SCENES_ANIMATION_CHANNELS_H
25#include "common/array.h"
26#include "common/random.h"
27#include "common/types.h"
29#include "hollywood/monsters/scenes/animation_layers.h"
41 void reset(
byte initialFrame, uint32 millis) {
42 frameIndex = initialFrame;
51 void addDelta(uint32 delta) {
52 timerAccumulator += delta;
56 if (frameMillis == 0 || timerAccumulator < frameMillis)
59 timerAccumulator -= frameMillis;
63 uint consumeFrames(uint32 delta) {
67 while (consumeFrame())
73 uint32 timerAccumulator;
90 static constexpr uint kInvalidTrack = 0xffffffff;
96 uint addLoop(uint layerId, uint32 frameMillis,
97 uint16 frameCount,
bool active =
true) {
98 if (!_layers.hasLayer(layerId) || frameCount == 0 || frameCount > 0x100)
100 return addTrack(kCycle, layerId, frameMillis, 0,
101 (
byte)(frameCount - 1),
false, active);
104 uint addRange(uint layerId, uint32 frameMillis,
105 byte firstFrame,
byte lastFrame,
bool active =
true) {
106 if (!_layers.hasLayer(layerId) || firstFrame > lastFrame)
107 return kInvalidTrack;
108 return addTrack(kCycle, layerId, frameMillis, firstFrame,
109 lastFrame,
false, active);
113 uint addFrameMap(uint layerId, uint32 frameMillis,
114 bool active =
true) {
115 if (!_layers.hasLayer(layerId))
116 return kInvalidTrack;
118 if (layer.frameMap ==
nullptr || layer.frameMapSize == 0 || layer.frameMapSize > 0x100)
119 return kInvalidTrack;
120 return addTrack(kCycle, layerId, frameMillis, 0,
121 (
byte)(layer.frameMapSize - 1),
false, active);
124 uint addPingPong(uint layerId, uint32 frameMillis,
125 byte firstFrame,
byte lastFrame,
bool active =
true) {
126 if (!_layers.hasLayer(layerId) || firstFrame > lastFrame)
127 return kInvalidTrack;
128 return addTrack(kPingPong, layerId, frameMillis, firstFrame,
129 lastFrame,
false, active);
133 byte lastFrame,
bool avoidRepeats,
bool active =
true) {
134 if (firstFrame > lastFrame)
135 return kInvalidTrack;
136 return addTrack(kRandom, layer, frameMillis, firstFrame, lastFrame,
137 avoidRepeats, active);
140 uint addRandom(uint layerId, uint32 frameMillis,
141 byte firstFrame,
byte lastFrame,
bool avoidRepeats,
bool active =
true) {
142 if (!_layers.hasLayer(layerId) || firstFrame > lastFrame)
143 return kInvalidTrack;
144 return addTrack(kRandom, layerId, frameMillis, firstFrame,
145 lastFrame, avoidRepeats, active);
148 bool hasTrack(uint
id)
const {
149 return id < _tracks.
size();
152 void setActive(uint
id,
bool active) {
154 _tracks[id].active = active;
157 bool isActive(uint
id)
const {
158 return hasTrack(
id) && _tracks[id].active;
161 void reset(uint
id) {
163 Track &track = _tracks[id];
164 track.reset(targetLayer(track));
168 void resetToFrame(uint
id,
byte frame) {
169 if (hasTrack(
id) && frame >= _tracks[
id].firstFrame && frame <= _tracks[
id].lastFrame) {
170 Track &track = _tracks[id];
171 track.reset(targetLayer(track), frame);
176 void setRange(uint
id,
byte firstFrame,
byte lastFrame) {
177 if (!hasTrack(
id) || firstFrame > lastFrame)
180 Track &track = _tracks[id];
181 track.firstFrame = firstFrame;
182 track.lastFrame = lastFrame;
185 void resetTimer(uint
id) {
187 _tracks[id].channel.resetTimer();
191 void resetTimer(uint
id, uint32 frameMillis) {
192 if (!hasTrack(
id) || frameMillis == 0)
194 _tracks[id].channel.frameMillis = frameMillis;
195 _tracks[id].channel.resetTimer();
199 void prime(uint
id) {
201 _tracks[id].channel.timerAccumulator = _tracks[id].channel.frameMillis;
205 bool changed =
false;
206 for (uint i = 0; i < _tracks.
size(); ++i)
207 changed = advance(i, delta, random) || changed;
212 if (!hasTrack(
id) || !_tracks[
id].active)
215 Track &track = _tracks[id];
217 if (target ==
nullptr) {
218 track.channel.resetTimer();
221 const uint frames = track.channel.consumeFrames(delta);
222 for (uint frame = 0; frame < frames; ++frame)
223 track.advanceFrame(*target, random);
237 stableLayer(
nullptr),
238 layerId(SceneLayerStack::kInvalidLayer),
248 reset(target, firstFrame);
253 channel.reset(frame, channel.frameMillis);
254 if (target !=
nullptr)
255 target->reset(frame);
259 channel.frameIndex = frame;
260 target.setFrame(frame);
264 byte frame = target.frameIndex;
267 setFrame(target, frame >= firstFrame && frame < lastFrame ? frame + 1 : firstFrame);
270 if (firstFrame == lastFrame) {
271 setFrame(target, firstFrame);
272 }
else if (forward) {
273 if (frame >= lastFrame) {
275 setFrame(target, lastFrame - 1);
277 setFrame(target, frame + 1);
279 }
else if (frame <= firstFrame) {
281 setFrame(target, firstFrame + 1);
283 setFrame(target, frame - 1);
287 const uint count = (uint)lastFrame - firstFrame + 1;
288 byte nextFrame = frame;
289 const uint maxAttempts = avoidRepeats && count > 1 ? 8 : 1;
290 for (uint attempt = 0; attempt < maxAttempts && nextFrame == frame; ++attempt)
291 nextFrame = firstFrame + (
byte)random.getRandomNumber(count - 1);
292 if (avoidRepeats && count > 1 && nextFrame == frame) {
293 nextFrame = frame >= firstFrame && frame <= lastFrame ?
294 firstFrame + (byte)((frame - firstFrame + 1) % count) : firstFrame;
296 setFrame(target, nextFrame);
314 byte firstFrame,
byte lastFrame,
bool avoidRepeats,
bool active) {
315 return addTrack(mode, &layer, SceneLayerStack::kInvalidLayer,
316 frameMillis, firstFrame, lastFrame, avoidRepeats, active);
319 uint addTrack(Mode mode, uint layerId, uint32 frameMillis,
320 byte firstFrame,
byte lastFrame,
bool avoidRepeats,
bool active) {
321 return addTrack(mode,
nullptr, layerId, frameMillis, firstFrame,
322 lastFrame, avoidRepeats, active);
326 uint32 frameMillis,
byte firstFrame,
byte lastFrame,
327 bool avoidRepeats,
bool active) {
328 if (frameMillis == 0)
329 return kInvalidTrack;
333 track.stableLayer = stableLayer;
334 track.layerId = layerId;
335 track.channel.frameMillis = frameMillis;
336 track.firstFrame = firstFrame;
337 track.lastFrame = lastFrame;
338 track.avoidRepeats = avoidRepeats;
339 track.active = active;
340 track.reset(targetLayer(track));
342 return _tracks.
size() - 1;
346 if (track.layerId != SceneLayerStack::kInvalidLayer)
347 return _layers.hasLayer(track.layerId) ? &_layers.layer(track.layerId) :
nullptr;
348 return track.stableLayer;
358 enum FirstPhaseTarget {
368 _firstPhaseAnimatesFirst(
true),
373 void configure(
byte firstBaseFrame,
byte secondBaseFrame,
374 FirstPhaseTarget firstPhaseTarget) {
375 _firstBaseFrame = firstBaseFrame;
376 _secondBaseFrame = secondBaseFrame;
377 _firstPhaseAnimatesFirst = firstPhaseTarget == kFirstFrame;
378 reset(
false, kMinimumTicks);
381 void reset(
bool secondPhase,
byte ticksRemaining) {
382 _secondPhase = secondPhase;
383 _ticksRemaining = ticksRemaining;
384 firstFrame = _firstBaseFrame;
385 secondFrame = _secondBaseFrame;
389 return kMinimumTicks + (byte)random.getRandomNumber(kAdditionalTicksMax);
393 if (_ticksRemaining == 0) {
394 _secondPhase = !_secondPhase;
395 if (animatesFirstFrame())
396 firstFrame = _firstBaseFrame;
398 secondFrame = _secondBaseFrame;
399 _ticksRemaining = randomPhaseTicks(random);
404 if (animatesFirstFrame())
405 firstFrame = _firstBaseFrame + (byte)random.getRandomNumber(kFrameOffsetMax);
407 secondFrame = _secondBaseFrame + (byte)random.getRandomNumber(kFrameOffsetMax);
417 kAdditionalTicksMax = 0x18
420 bool animatesFirstFrame()
const {
421 return _secondPhase ? !_firstPhaseAnimatesFirst : _firstPhaseAnimatesFirst;
424 byte _firstBaseFrame;
425 byte _secondBaseFrame;
426 bool _firstPhaseAnimatesFirst;
428 byte _ticksRemaining;
449 returnToIdleAfterLongSequence(
true) {
452 void configure(uint32 frameMillis,
byte idle,
byte shortStart,
byte longStart,
byte longEnd,
453 byte shortRandom,
byte longRandom) {
455 shortFrame = shortStart;
456 longFirstFrame = longStart;
457 longLastFrame = longEnd;
458 shortRandomMax = shortRandom;
459 longRandomMax = longRandom;
460 returnToIdleAfterLongSequence =
true;
461 channel.reset(idleFrame, frameMillis);
466 channel.frameIndex = idleFrame;
467 channel.resetTimer();
471 void setStateAndFrame(
byte newState,
byte newFrame) {
473 channel.frameIndex = newFrame;
476 void setFrame(
byte newFrame) {
477 channel.frameIndex = newFrame;
482 if (canStartSequence && longRandomMax != 0 && random.getRandomNumber(longRandomMax) == 0) {
483 setStateAndFrame(2, longFirstFrame);
486 if (canStartSequence && shortRandomMax != 0 && random.getRandomNumber(shortRandomMax) == 0) {
487 setStateAndFrame(1, shortFrame);
488 return kShortStarted;
490 }
else if (state == 1) {
492 }
else if (state == 2) {
493 if (channel.frameIndex == longLastFrame) {
494 if (returnToIdleAfterLongSequence)
496 return kLongFinished;
498 ++channel.frameIndex;
505 const uint frameCount = channel.consumeFrames(delta);
506 for (uint frame = 0; frame < frameCount; ++frame)
507 advanceTick(random, canStartSequence);
518 bool returnToIdleAfterLongSequence;
size_type size() const
Definition: array.h:316
void push_back(const T &element)
Definition: array.h:181
Definition: animation_channels.h:88
Definition: animation_layers.h:109
Definition: animation_channels.h:357
Definition: animation_channels.h:432
Definition: animation_layers.h:33
Definition: animation_channels.h:34