102 Dalmatians: Puppies to the Rescue
Decompilation Source Reference | GitLab repository
Loading...
Searching...
No Matches
sprite_commands.c
Go to the documentation of this file.
1/* Recovered game implementation; original addresses identify provenance. */
7#include "pcdogs/math/types.h"
11#include <math.h>
12#include <stdarg.h>
13#include <string.h>
14
15/* The 32-bit frame difference wraps before the Q12 shift and unsigned division. */
16static int32_t sprite_eased_fraction(struct Math_RangeI32 frames, struct Math_EasePairI32 ease)
17{
18 uint32_t start = (uint32_t)frames.min;
19 uint32_t elapsed_q12 = ((uint32_t)g_frameCounter - start) << MATH_Q12_SHIFT;
20 uint32_t frame_count = (uint32_t)frames.max - start + 1;
21 return Math_EaseInOut(elapsed_q12 / frame_count, ease.a, ease.b);
22}
23
24// Original pcdogs.exe: 0x442500
25// Decodes a sprite movement target, duration, and easing values, preserving the interpolated position when retargeting. It branches while the unsigned end-frame comparison indicates the move is active.
26void Script_OpAnimateSpriteMove(struct Entity *entity, uint8_t **ip)
27{
28 (void)entity;
29 uint8_t **instruction_pointer = ip;
30 uint32_t relative_skip = 0;
31
32 uint8_t *operand_cursor = (*instruction_pointer + 2);
33
34 *instruction_pointer = (operand_cursor);
35 relative_skip = (uint32_t)(operand_cursor[-2]) << 8;
36 relative_skip |= operand_cursor[-1];
37 *instruction_pointer = (&operand_cursor[1]);
38
39 char sprite_index = *(uint8_t *)operand_cursor;
40
41 *instruction_pointer = (&operand_cursor[2]);
42
43 char negate_target_x = operand_cursor[1];
44
45 *instruction_pointer = (&operand_cursor[6]);
46
47 int32_t target_x_high_word_value = (uint32_t)(operand_cursor[2]) << 24;
48
49 target_x_high_word_value |= (uint32_t)(operand_cursor[4]) << 8;
50 target_x_high_word_value |= (uint32_t)(operand_cursor[3]) << 16;
51 target_x_high_word_value |= operand_cursor[5];
52
53 int32_t target_x = target_x_high_word_value;
54
55 *instruction_pointer = (&operand_cursor[7]);
56
57 uint8_t negate_target_y = operand_cursor[6];
58
59 *instruction_pointer = (&operand_cursor[0xb]);
60
61 int32_t target_y_high_word_value = (uint32_t)(operand_cursor[7]) << 24;
62
63 target_y_high_word_value |= (uint32_t)(operand_cursor[8]) << 16;
64 target_y_high_word_value |= (uint32_t)(operand_cursor[9]) << 8;
65 target_y_high_word_value |= operand_cursor[0xa];
66 *instruction_pointer = (&operand_cursor[0xf]);
67
68 int32_t raw_target_y = target_y_high_word_value;
69 int32_t duration_high_word_value = (uint32_t)(operand_cursor[0xb]) << 24;
70
71 duration_high_word_value |= (uint32_t)(operand_cursor[0xc]) << 16;
72 duration_high_word_value |= (uint32_t)(operand_cursor[0xd]) << 8;
73
74 int32_t target_y = raw_target_y;
75
76 duration_high_word_value |= operand_cursor[0xe];
77 *instruction_pointer = (&operand_cursor[0x10]);
78
79 char ease_start_percent = operand_cursor[0xf];
80
81 *instruction_pointer = (&operand_cursor[0x11]);
82
83 char ease_end_percent = operand_cursor[0x10];
84
85 if (negate_target_x == 1)
86 target_x = -(target_x);
87
88 if (negate_target_y == 1)
89 target_y = -(raw_target_y);
90
91 struct PKG_SpriteEntry *sprite_list = pkg_resource_current_level_data->sprite_list;
92 int16_t x = sprite_list[(uint8_t)sprite_index].move_target.x;
93 struct PKG_SpriteEntry *sprite = &sprite_list[(uint8_t)sprite_index];
94
95 if ((int32_t)x != target_x || (int32_t)sprite->move_target.y != target_y)
96 {
97 if (sprite->move_frame_range.max)
98 {
99 int32_t fraction = sprite_eased_fraction(sprite->move_frame_range, sprite->move_ease);
100 sprite->move_start.x += ((sprite->move_target.x - sprite->move_start.x) * fraction) >> MATH_Q12_SHIFT;
101 sprite->move_start.y += ((sprite->move_target.y - sprite->move_start.y) * fraction) >> MATH_Q12_SHIFT;
102 }
103 else
104 sprite->move_start = sprite->move_target;
105
106 sprite->move_target = (struct Math_Vec2I16){
107 .x = (uint16_t)target_x,
108 .y = (uint16_t)target_y};
109
111
112 int32_t frame_counter = g_frameCounter;
113
114 sprite->move_ease.a = ((uint32_t)(uint8_t)ease_start_percent << MATH_Q12_SHIFT) / SCRIPT_EASE_PERCENT_SCALE;
115 sprite->bounds.w = 0;
116
117 uint8_t dirty_sprite_flags = sprite->state_flags & (uint8_t)~SCRIPT_SPRITE_CACHE_VALID;
118
119 sprite->move_frame_range.max =
120 (((duration_high_word_value)*SCRIPT_FRAMES_PER_SECOND) >> MATH_Q12_SHIFT) + frame_counter;
121 sprite->move_ease.b = ((uint32_t)(uint8_t)ease_end_percent << MATH_Q12_SHIFT) / SCRIPT_EASE_PERCENT_SCALE;
122 sprite->state_flags = dirty_sprite_flags;
123 }
124
125 if ((uint32_t)sprite->move_frame_range.max > (uint32_t)g_frameCounter)
126 *instruction_pointer = (&operand_cursor[relative_skip]);
127}
128
129// Original pcdogs.exe: 0x442720
130// Decodes sprite scale targets, duration, and easing, updating the interpolated start when retargeting and branching while scaling remains active. The wrapped interpolation numerator and unchecked unsigned division are retained.
131void Script_OpAnimateZoom(struct Entity *entity, uint8_t **ip)
132{
133 (void)entity;
134
135 uint8_t *code = *ip;
136 uint8_t *branch_target = code + 2 + ((uint32_t)code[0] << 8 | code[1]);
137
138 unsigned sprite_index = code[2];
139
140 uint32_t scale_and_duration_operands[3];
141
142 for (int i = 0; i < 3; ++i)
143 {
144 const uint8_t *operand_bytes = code + 3 + i * 4;
145
146 scale_and_duration_operands[i] = (uint32_t)operand_bytes[0] << 24 | (uint32_t)operand_bytes[1] << 16 | (uint32_t)operand_bytes[2] << 8 | operand_bytes[3];
147 }
148
149 int32_t scale_x = (int32_t)(scale_and_duration_operands[0] << MATH_Q12_SHIFT) / 100;
150 int32_t scale_y = (int32_t)(scale_and_duration_operands[1] << MATH_Q12_SHIFT) / 100;
151
152 unsigned ease_a = code[15], ease_b = code[16];
153 *ip = code + 17;
154
155 struct PKG_SpriteEntry *sprite = &pkg_resource_current_level_data->sprite_list[sprite_index];
156
157 if (sprite->scale_target.x != scale_x || sprite->scale_target.y != scale_y)
158 {
159 if (sprite->scale_frame_range.max)
160 {
161 int32_t eased_fraction = sprite_eased_fraction(sprite->scale_frame_range, sprite->scale_ease);
162
163 sprite->scale_start.x += ((sprite->scale_target.x - sprite->scale_start.x) * eased_fraction) >> MATH_Q12_SHIFT;
164 sprite->scale_start.y += ((sprite->scale_target.y - sprite->scale_start.y) * eased_fraction) >> MATH_Q12_SHIFT;
165 }
166 else
167 sprite->scale_start = sprite->scale_target;
168
169 sprite->scale_target.x = scale_x;
170 sprite->scale_target.y = scale_y;
172 sprite->scale_frame_range.max = ((int32_t)(scale_and_duration_operands[2] * 30) >> MATH_Q12_SHIFT) + g_frameCounter;
173 sprite->bounds.w = 0;
174 sprite->scale_ease.a = (ease_a << MATH_Q12_SHIFT) / 50;
175 sprite->scale_ease.b = (ease_b << MATH_Q12_SHIFT) / 50;
176 sprite->state_flags &= (uint8_t)~SCRIPT_SPRITE_CACHE_VALID;
177 }
178
179 if ((uint32_t)sprite->scale_frame_range.max > (uint32_t)g_frameCounter)
180 *ip = branch_target;
181}
182
183// Original pcdogs.exe: 0x442930
184// Decodes sprite rotation, duration, and easing, wraps the starting angle for the requested direction, and branches while the rotation interval remains active.
185void Script_OpProcessSpriteRotation(struct Entity *entity, uint8_t **ip)
186{
187 (void)entity;
188 int64_t rotation_conversion_product;
189 uint8_t **instruction_pointer = ip;
190 uint32_t relative_skip = 0;
191 uint8_t *operand_cursor = &(*instruction_pointer)[2];
192
193 *instruction_pointer = operand_cursor;
194 relative_skip = (uint32_t)(operand_cursor[-2]) << 8;
195 relative_skip |= operand_cursor[-1];
196 *instruction_pointer = &operand_cursor[1];
197
198 char sprite_index = *(uint8_t *)operand_cursor;
199
200 *instruction_pointer = &operand_cursor[2];
201
202 char negate_rotation = operand_cursor[1];
203
204 *instruction_pointer = &operand_cursor[6];
205
206 int32_t rotation_high_word_value = (uint32_t)(operand_cursor[2]) << 24;
207
208 rotation_high_word_value |= (uint32_t)(operand_cursor[4]) << 8;
209 rotation_high_word_value |= (uint32_t)(operand_cursor[3]) << 16;
210 rotation_high_word_value |= operand_cursor[5];
211 *instruction_pointer = &operand_cursor[0xa];
212
213 int32_t raw_rotation_target_1 = rotation_high_word_value;
214 int32_t duration_high_word_value = (uint32_t)(operand_cursor[6]) << 24;
215
216 duration_high_word_value |= (uint32_t)(operand_cursor[7]) << 16;
217 duration_high_word_value |= (uint32_t)(operand_cursor[8]) << 8;
218 duration_high_word_value |= operand_cursor[9];
219
220 int32_t raw_rotation_target = raw_rotation_target_1;
221
222 *instruction_pointer = &operand_cursor[0xb];
223
224 char ease_start_percent = operand_cursor[0xa];
225
226 *instruction_pointer = &operand_cursor[0xc];
227
228 char ease_end_percent = operand_cursor[0xb];
229
230 if (negate_rotation == 1)
231 raw_rotation_target = -(raw_rotation_target_1);
232
233 rotation_conversion_product = (int64_t)ENTITY_ANGLE_SCALE_Q12 * raw_rotation_target;
234
235 int32_t target_rotation_angle = (int32_t)((rotation_conversion_product) >> MATH_Q12_SHIFT);
236 struct PKG_SpriteEntry *sprite_list = pkg_resource_current_level_data->sprite_list;
237 struct PKG_SpriteEntry *sprite = &sprite_list[(uint8_t)sprite_index];
238 int32_t prior_target_rotation = sprite->rotation_target_angle;
239
240 if (prior_target_rotation != target_rotation_angle)
241 {
242 if (sprite->rotation_frame_range.max)
243 {
244 int32_t eased_fraction = sprite_eased_fraction(sprite->rotation_frame_range, sprite->rotation_ease);
246
248 }
249 else
250 sprite->rotation_start_angle = prior_target_rotation;
251
252 int32_t wrapped_start_angle = sprite->rotation_start_angle & SCRIPT_SPRITE_ANGLE_Q12_WRAP_MASK;
253
254 sprite->rotation_start_angle = wrapped_start_angle;
255
256 if (!negate_rotation && wrapped_start_angle)
257 sprite->rotation_start_angle = wrapped_start_angle - (MATH_ANGLE_FULL_TURN << MATH_Q12_SHIFT);
258
259 sprite->rotation_target_angle = target_rotation_angle;
261
262 int32_t rotation_end_frame = (((duration_high_word_value)*SCRIPT_FRAMES_PER_SECOND) >> MATH_Q12_SHIFT) + g_frameCounter;
263
264 sprite->rotation_ease.a = ((uint32_t)(uint8_t)ease_start_percent << MATH_Q12_SHIFT) / SCRIPT_EASE_PERCENT_SCALE;
265 sprite->rotation_frame_range.max = rotation_end_frame;
266
267 uint8_t dirty_sprite_flags = sprite->state_flags & (uint8_t)~SCRIPT_SPRITE_CACHE_VALID;
268
269 sprite->rotation_ease.b = ((uint32_t)(uint8_t)ease_end_percent << MATH_Q12_SHIFT) / SCRIPT_EASE_PERCENT_SCALE;
270 sprite->state_flags = dirty_sprite_flags;
271 }
272
273 if ((uint32_t)sprite->rotation_frame_range.max > (uint32_t)g_frameCounter)
274 *instruction_pointer = &operand_cursor[relative_skip];
275}
276
277// Original pcdogs.exe: 0x442b30
278// Decodes a sprite color target, duration, and easing and starts a new interval only when the target changes. Frame conversion retains wrapped 32-bit multiplication before the signed shift, and the wait comparison is unsigned.
279void Script_OpAnimateSpriteColor(struct Entity *entity, uint8_t **ip)
280{
281 (void)entity;
282 uint8_t *operands = *ip + 2;
283
284 *ip = operands;
285
286 uint32_t relative_skip = ((uint32_t)operands[-2] << 8) | operands[-1];
287
288 *ip = operands + 1;
289
290 uint8_t sprite_index = operands[0];
291
292 *ip = operands + 2;
293
294 uint32_t target_color = operands[1];
295
296 *ip = operands + 3;
297 target_color |= (uint32_t)operands[2] << 8;
298 *ip = operands + 4;
299 target_color |= (uint32_t)operands[3] << 16;
300 *ip = operands + 8;
301
302 uint32_t duration = ((uint32_t)operands[4] << 24) |
303 ((uint32_t)operands[5] << 16) |
304 ((uint32_t)operands[6] << 8) | operands[7];
305
306 *ip = operands + 9;
307
308 uint8_t ease_a = operands[8];
309
310 *ip = operands + 10;
311
312 uint8_t ease_b = operands[9];
313 struct PKG_SpriteEntry *sprite =
314 &pkg_resource_current_level_data->sprite_list[sprite_index];
315
316 if ((uint32_t)sprite->color_target_word != target_color)
317 {
318 sprite->color_target_word = target_color;
319 sprite->color_start = sprite->current_color;
322
323 /* Native LEA/SHL multiplication wraps before the arithmetic shift. */
324 int32_t frame_delta = (int32_t)(duration * 30u) >> MATH_Q12_SHIFT;
325
326 sprite->color_frame_range.max = (uint32_t)frame_delta + (uint32_t)g_frameCounter;
327 sprite->color_ease.a = ((uint32_t)ease_a << MATH_Q12_SHIFT) / 50;
328 sprite->color_ease.b = ((uint32_t)ease_b << MATH_Q12_SHIFT) / 50;
329 sprite->state_flags &= (uint8_t)~SCRIPT_SPRITE_CACHE_VALID;
330 }
331
332 if ((uint32_t)sprite->color_frame_range.max > (uint32_t)g_frameCounter)
333 *ip = operands + relative_skip;
334}
335
336// Original pcdogs.exe: 0x442c70
337// Decodes a packed sprite property and updates the applicable content, alignment, or control state, invalidating cached bounds when required.
338void Script_OpSetSpriteProperty(struct Entity *entity, uint8_t **ip)
339{
340 uint8_t **instruction_pointer = ip;
341 uint8_t *operand_cursor = (*instruction_pointer + 1);
342
343 *instruction_pointer = operand_cursor;
344
345 uint8_t sprite_index = operand_cursor[-1];
346 int32_t *resolved_storage = (int32_t *)(((uintptr_t)ip & ~UINT32_C(0xff)) | sprite_index);
347
348 *instruction_pointer = &operand_cursor[4];
349
350 int32_t property_high_word_value = (uint32_t)(*(uint8_t *)operand_cursor) << 24;
351
352 property_high_word_value |= (uint32_t)(operand_cursor[1]) << 16;
353 property_high_word_value |= (uint32_t)(operand_cursor[2]) << 8;
354 property_high_word_value |= operand_cursor[3];
355
356 int32_t encoded_property = property_high_word_value;
357 struct PKG_SpriteEntry *sprite =
358 &pkg_resource_current_level_data->sprite_list[sprite_index];
359 int32_t ref_id = encoded_property & SCRIPT_VALUE_PAYLOAD_MASK;
360 int32_t property_selector_or_control_flags = encoded_property - ref_id;
361
362 if (property_selector_or_control_flags > SCRIPT_SPRITE_LAYER)
363 {
364 if (property_selector_or_control_flags == SCRIPT_SPRITE_LITERAL_CONTENT)
365 {
366 if (sprite->type == SCRIPT_SPRITE_LITERAL_TYPE && ref_id != sprite->content_value)
367 {
368 sprite->content_value = ref_id;
369
370 uint8_t state_flags = sprite->state_flags;
371
372 sprite->bounds.w = 0;
374 }
375 }
376 else if (property_selector_or_control_flags == SCRIPT_SPRITE_LINK)
377 {
378 int32_t prior_link_index = (uint8_t)(sprite->link_index);
379
380 if (ref_id != prior_link_index)
381 {
382 sprite->link_index = (uint8_t)ref_id;
383
384 uint8_t link_dirty_flags = sprite->state_flags & (uint8_t)~SCRIPT_SPRITE_CACHE_VALID;
385
386 sprite->bounds.w = 0;
387 sprite->state_flags = link_dirty_flags;
388 }
389 }
390 else
391 {
392 if (property_selector_or_control_flags != SCRIPT_SPRITE_ANCHOR)
393 {
394 uint8_t state_flags = sprite->state_flags;
395
396 sprite->bounds.w = 0;
398
399 return;
400 }
401
402 int32_t prior_anchor_code = (uint8_t)(sprite->anchor_code);
403
404 if (ref_id != prior_anchor_code)
405 {
406 sprite->anchor_code = (uint8_t)ref_id;
407
408 uint8_t anchor_dirty_flags = sprite->state_flags & (uint8_t)~SCRIPT_SPRITE_CACHE_VALID;
409
410 sprite->bounds.w = 0;
411 sprite->state_flags = anchor_dirty_flags;
412 }
413 }
414 }
415 else if (property_selector_or_control_flags == SCRIPT_SPRITE_LAYER)
416 {
417 int32_t prior_layer_index = (uint8_t)(sprite->layer_index);
418
419 if (ref_id != prior_layer_index)
420 {
421 sprite->layer_index = (uint8_t)ref_id;
422 sprite->state_flags &= (uint8_t)~SCRIPT_SPRITE_CACHE_VALID;
423 }
424 }
425 else if (!property_selector_or_control_flags)
426 {
427 bool disable_sprite = !ref_id;
428 uint16_t control_flags = sprite->control_flags;
429
430 if (disable_sprite)
431 {
433 {
434 sprite->bounds.w = 0;
436 sprite->state_flags &= (uint8_t)~SCRIPT_SPRITE_CACHE_VALID;
437 }
438 }
440 {
442 sprite->bounds.w = 0;
444 sprite->state_flags &= (uint8_t)~SCRIPT_SPRITE_CACHE_VALID;
445 }
446 }
447 else if (property_selector_or_control_flags == SCRIPT_SPRITE_ALIGNMENT)
448 {
449 uint16_t control_flags = sprite->control_flags;
450 int32_t alignment_bits = ref_id << SCRIPT_SPRITE_ALIGNMENT_SHIFT;
451
453 {
454 uint8_t alignment_dirty_flags = sprite->state_flags & (uint8_t)~SCRIPT_SPRITE_CACHE_VALID;
455
457 sprite->state_flags = alignment_dirty_flags;
458 }
459 }
460 else
461 {
462 if (property_selector_or_control_flags != SCRIPT_SPRITE_VARIABLE_CONTENT || sprite->type != SCRIPT_SPRITE_VARIABLE_TYPE)
463 {
464 uint8_t state_flags = sprite->state_flags;
465
466 sprite->bounds.w = 0;
468
469 return;
470 }
471
472 int32_t resolved_content_value = Script_ResolveVariableRef(entity, &resolved_storage, ref_id);
473
474 if (resolved_content_value != sprite->content_value)
475 {
476 sprite->content_value = resolved_content_value;
477
478 uint8_t content_dirty_flags = sprite->state_flags & (uint8_t)~SCRIPT_SPRITE_CACHE_VALID;
479
480 sprite->bounds.w = 0;
481 sprite->state_flags = content_dirty_flags;
482 }
483 }
484}
#define ENTITY_ANGLE_SCALE_Q12
Definition constants.h:32
#define MATH_Q12_SHIFT
Definition constants.h:8
#define MATH_ANGLE_FULL_TURN
Definition constants.h:13
int32_t Math_EaseInOut(int32_t t_q12, int32_t ease_in_q12, int32_t ease_out_q12)
#define pkg_resource_current_level_data
Definition globals.h:117
#define SCRIPT_VALUE_PAYLOAD_MASK
Definition constants.h:18
#define SCRIPT_SPRITE_CACHE_VALID
Definition constants.h:54
#define SCRIPT_SPRITE_ALIGNMENT_BIT_2
Definition constants.h:58
#define SCRIPT_SPRITE_ALIGNMENT_BIT_1
Definition constants.h:57
#define SCRIPT_FRAMES_PER_SECOND
Definition constants.h:71
#define SCRIPT_SPRITE_ALIGNMENT_SHIFT
Definition constants.h:59
#define SCRIPT_SPRITE_ANGLE_Q12_WRAP_MASK
Definition constants.h:60
#define SCRIPT_SPRITE_ENABLED_FLAG
Definition constants.h:55
@ SCRIPT_SPRITE_LITERAL_TYPE
Definition constants.h:67
@ SCRIPT_SPRITE_VARIABLE_TYPE
Definition constants.h:68
#define SCRIPT_EASE_PERCENT_SCALE
Definition constants.h:73
@ SCRIPT_SPRITE_ANCHOR
Definition constants.h:51
@ SCRIPT_SPRITE_LINK
Definition constants.h:50
@ SCRIPT_SPRITE_VARIABLE_CONTENT
Definition constants.h:47
@ SCRIPT_SPRITE_LITERAL_CONTENT
Definition constants.h:49
@ SCRIPT_SPRITE_ALIGNMENT
Definition constants.h:46
@ SCRIPT_SPRITE_LAYER
Definition constants.h:48
#define SCRIPT_SPRITE_ALIGNMENT_BIT_0
Definition constants.h:56
int32_t Script_ResolveVariableRef(struct Entity *entity, int32_t **value_storage_inout, int32_t ref_id)
Definition interpreter.c:16
void Script_OpSetSpriteProperty(struct Entity *entity, uint8_t **ip)
void Script_OpAnimateZoom(struct Entity *entity, uint8_t **ip)
void Script_OpAnimateSpriteColor(struct Entity *entity, uint8_t **ip)
static int32_t sprite_eased_fraction(struct Math_RangeI32 frames, struct Math_EasePairI32 ease)
void Script_OpAnimateSpriteMove(struct Entity *entity, uint8_t **ip)
void Script_OpProcessSpriteRotation(struct Entity *entity, uint8_t **ip)
Definition types.h:22
int32_t b
Definition types.h:148
int32_t a
Definition types.h:147
int32_t min
Definition types.h:242
int32_t max
Definition types.h:243
int16_t w
Definition types.h:268
int16_t x
Definition types.h:402
int16_t y
Definition types.h:403
int32_t y
Definition types.h:425
int32_t x
Definition types.h:424
int32_t rotation_start_angle
Definition types.h:1022
uint8_t state_flags
Definition types.h:1008
uint8_t color_start_reserved_high
Definition types.h:1000
struct Math_EasePairI32 color_ease
Definition types.h:1003
struct Math_RangeI32 color_frame_range
Definition types.h:1002
struct Math_Vec2I16 move_start
Definition types.h:991
struct Math_RangeI32 scale_frame_range
Definition types.h:997
struct Math_EasePairI32 rotation_ease
Definition types.h:1025
struct Math_Vec2I16 move_target
Definition types.h:992
uint8_t current_color_reserved_high
Definition types.h:1016
uint16_t control_flags
Definition types.h:975
struct Math_Vec2I32 scale_target
Definition types.h:996
uint8_t type
Definition types.h:970
struct Math_Vec2I32 scale_start
Definition types.h:995
uint8_t anchor_code
Definition types.h:1007
int32_t content_value
Definition types.h:990
int32_t rotation_target_angle
Definition types.h:1023
int32_t color_target_word
Definition types.h:1001
struct Math_EasePairI32 move_ease
Definition types.h:994
struct Math_EasePairI32 scale_ease
Definition types.h:998
uint8_t link_index
Definition types.h:1006
struct Math_ColorRGB8 color_start
Definition types.h:999
struct Math_RectI16 bounds
Definition types.h:1005
uint8_t layer_index
Definition types.h:971
struct Math_RangeI32 rotation_frame_range
Definition types.h:1024
struct Math_RangeI32 move_frame_range
Definition types.h:993
struct Math_ColorRGB8 current_color
Definition types.h:1015
#define g_frameCounter
Definition values.h:501