Demo

static bool bitmapPixelSet(const uint8_t *bitmap, unsigned x, unsigned y)

1. Executeconst size_t byte_index = (size_t)y * DEMO_LOGO_ROW_BYTES + x / 8U;
2. Executeconst uint8_t bit = (uint8_t)(7U - x % 8U);
3. Exit this functionreturn (bitmap[byte_index] & (uint8_t)(1U << bit)) != 0U;

static bool bitmapPixelSet(const uint8_t *bitmap, unsigned x, unsigned y)
{
    const size_t byte_index = (size_t)y * DEMO_LOGO_ROW_BYTES + x / 8U;
    const uint8_t bit = (uint8_t)(7U - x % 8U);
    return (bitmap[byte_index] & (uint8_t)(1U << bit)) != 0U;
}

static void advanceIconSlot(void)

1. Executeactive_icon_slot = (active_icon_slot + 1U) % DEMO_ICON_SLOT_COUNT;
2. Executeactive_logo_bitmap = demo_icon_slots[active_icon_slot];

static void advanceIconSlot(void)
{
    active_icon_slot = (active_icon_slot + 1U) % DEMO_ICON_SLOT_COUNT;
    active_logo_bitmap = demo_icon_slots[active_icon_slot];
}

static void selectDemoIconColourScheme(void)

1. Executedemo_icon_colour_scheme_index = (size_t)esp_random() % DEMO_ICON_COLOUR_SCHEME_COUNT;

static void selectDemoIconColourScheme(void)
{
    demo_icon_colour_scheme_index =
        (size_t)esp_random() % DEMO_ICON_COLOUR_SCHEME_COUNT;
}

static uint32_t demoStageInactivityTimeout(void)

Calls into this documentation:

1. Exit this functionreturn demoSelectorStageInactivityTimeout(selected_stage);

static uint32_t demoStageInactivityTimeout(void)
{
    return demoSelectorStageInactivityTimeout(selected_stage);
}

static void buildStageThreeBallMap(void)

1. Decisionstage_three_ball_map_ready
   True

   1. Exit this functionreturn;

   False

   Continue after this decision.

2. FOR loopint y = 0; y < DEMO_STAGE_THREE_BALL_DIAMETER; ++y

   Repeat body while the loop condition permits; then continue below.

   1. 1. FOR loopint x = 0; x < DEMO_STAGE_THREE_BALL_DIAMETER; ++x

         Repeat body while the loop condition permits; then continue below.

         1. 1. Executeconst int index = y * DEMO_STAGE_THREE_BALL_DIAMETER + x;
            2. Executeconst float normal_x = (float)(x - DEMO_STAGE_THREE_BALL_RADIUS) / (float)DEMO_STAGE_THREE_BALL_RADIUS;
            3. Executeconst float normal_y = (float)(y - DEMO_STAGE_THREE_BALL_RADIUS) / (float)DEMO_STAGE_THREE_BALL_RADIUS;
            4. Executeconst float radius_squared = normal_x * normal_x + normal_y * normal_y;
            5. Decisionradius_squared > 1.0f
               True

               1. 1. Executestage_three_ball_shade_map[index] = 0U;
                  2. Next loop iterationcontinue;

               False

               Continue after this decision.

            6. Executeconst float depth = sqrtf(1.0f - radius_squared);
            7. Executeconst float longitude = (atan2f(normal_x, depth) + DEMO_PI) / (2.0f * DEMO_PI);
            8. Executeconst float latitude = (asinf(normal_y) + DEMO_PI * 0.5f) / DEMO_PI;
            9. Executestage_three_ball_longitude_map[index] = (uint8_t)(longitude * 255.0f);
            10. Executestage_three_ball_latitude_map[index] = (uint8_t)(latitude * 255.0f);
            11. Executestage_three_ball_shade_map[index] = depth > 0.78f ? 3U : depth > 0.42f ? 2U : 1U;
3. Executestage_three_ball_map_ready = true;

static void buildStageThreeBallMap(void)
{
    if (stage_three_ball_map_ready) return;
    for (int y = 0; y < DEMO_STAGE_THREE_BALL_DIAMETER; ++y) {
        for (int x = 0; x < DEMO_STAGE_THREE_BALL_DIAMETER; ++x) {
            const int index = y * DEMO_STAGE_THREE_BALL_DIAMETER + x;
            const float normal_x = (float)(x - DEMO_STAGE_THREE_BALL_RADIUS) /
                                   (float)DEMO_STAGE_THREE_BALL_RADIUS;
            const float normal_y = (float)(y - DEMO_STAGE_THREE_BALL_RADIUS) /
                                   (float)DEMO_STAGE_THREE_BALL_RADIUS;
            const float radius_squared = normal_x * normal_x + normal_y * normal_y;
            if (radius_squared > 1.0f) {
                stage_three_ball_shade_map[index] = 0U;
                continue;
            }
            const float depth = sqrtf(1.0f - radius_squared);
            const float longitude = (atan2f(normal_x, depth) + DEMO_PI) / (2.0f * DEMO_PI);
            const float latitude = (asinf(normal_y) + DEMO_PI * 0.5f) / DEMO_PI;
            stage_three_ball_longitude_map[index] = (uint8_t)(longitude * 255.0f);
            stage_three_ball_latitude_map[index] = (uint8_t)(latitude * 255.0f);
            stage_three_ball_shade_map[index] = depth > 0.78f ? 3U : depth > 0.42f ? 2U : 1U;
        }
    }
    stage_three_ball_map_ready = true;
}

static void startStageThreeBall(uint32_t now_ms)

Calls into this documentation:

1. ExecutebuildStageThreeBallMap();
2. Executestage_three_next_icon_change_at = now_ms + DEMO_STAGE_THREE_ICON_CHANGE_MS;
3. Executestage_three_icon_slot = 0U;
4. Executestage_three_icon_bitmap = demo_icon_slots[stage_three_icon_slot];
5. Executestage_three_ball_x = 82.0f;
6. Executestage_three_ball_y = 52.0f;
7. Executestage_three_ball_velocity_x = DEMO_STAGE_THREE_BALL_HORIZONTAL_VELOCITY;
8. Executestage_three_ball_velocity_y = 0.0f;
9. Executestage_three_ball_rotation_phase = 0.0f;

static void startStageThreeBall(uint32_t now_ms)
{
    buildStageThreeBallMap();
    stage_three_next_icon_change_at = now_ms + DEMO_STAGE_THREE_ICON_CHANGE_MS;
    stage_three_icon_slot = 0U;
    stage_three_icon_bitmap = demo_icon_slots[stage_three_icon_slot];
    stage_three_ball_x = 82.0f;
    stage_three_ball_y = 52.0f;
    stage_three_ball_velocity_x = DEMO_STAGE_THREE_BALL_HORIZONTAL_VELOCITY;
    stage_three_ball_velocity_y = 0.0f;
    stage_three_ball_rotation_phase = 0.0f;
}

static void selectStageSixMesh(void)

1. Executeconst demo_mesh_t *next_mesh;
2. DO / WHILE loopnext_mesh == stage_six_current_mesh

   Run body, then test condition; repeat while true.

   1. 1. Executenext_mesh = demo_stage_six_mesh_catalog[esp_random() % DEMO_STAGE_SIX_MESH_CATALOG_COUNT];
3. Executestage_six_current_mesh = next_mesh;
4. Executesize_t next_colour_scheme = (size_t)esp_random() % DEMO_SOLID_COLOUR_SCHEME_COUNT;
5. Decisionstage_six_colour_scheme_index < DEMO_SOLID_COLOUR_SCHEME_COUNT && DEMO_SOLID_COLOUR_SCHEME_COUNT > 1U
   True

   1. 1. Executenext_colour_scheme = (size_t)esp_random() % (DEMO_SOLID_COLOUR_SCHEME_COUNT - 1U);
      2. Decisionnext_colour_scheme >= stage_six_colour_scheme_index
         True

         1. Execute++next_colour_scheme;

         False

         Continue after this decision.

   False

   Continue after this decision.

6. Executestage_six_colour_scheme_index = next_colour_scheme;

static void selectStageSixMesh(void)
{
    const demo_mesh_t *next_mesh;
    do {
        next_mesh = demo_stage_six_mesh_catalog[esp_random() % DEMO_STAGE_SIX_MESH_CATALOG_COUNT];
    } while (next_mesh == stage_six_current_mesh);
    stage_six_current_mesh = next_mesh;

    size_t next_colour_scheme =
        (size_t)esp_random() % DEMO_SOLID_COLOUR_SCHEME_COUNT;
    if (stage_six_colour_scheme_index < DEMO_SOLID_COLOUR_SCHEME_COUNT &&
        DEMO_SOLID_COLOUR_SCHEME_COUNT > 1U) {
        next_colour_scheme = (size_t)esp_random() % (DEMO_SOLID_COLOUR_SCHEME_COUNT - 1U);
        if (next_colour_scheme >= stage_six_colour_scheme_index) ++next_colour_scheme;
    }
    stage_six_colour_scheme_index = next_colour_scheme;
}

static void startStageSixSolid(uint32_t now_ms)

Calls into this documentation:

1. Executestage_six_next_change_at = now_ms + DEMO_STAGE_SIX_CHANGE_MS;
2. Executestage_six_current_mesh = NULL;
3. ExecuteselectStageSixMesh();

static void startStageSixSolid(uint32_t now_ms)
{
    stage_six_next_change_at = now_ms + DEMO_STAGE_SIX_CHANGE_MS;
    stage_six_current_mesh = NULL;
    selectStageSixMesh();
}

static uint32_t randomTextCornerIconTravelDuration(void)

1. Executeconst uint32_t range = DEMO_TEXT_CORNER_ICON_TRAVEL_MAX_MS - DEMO_TEXT_CORNER_ICON_TRAVEL_MIN_MS + 1U;
2. Exit this functionreturn DEMO_TEXT_CORNER_ICON_TRAVEL_MIN_MS + esp_random() % range;

static uint32_t randomTextCornerIconTravelDuration(void)
{
    // Keep the range inclusive so setting MIN and MAX equal later creates a
    // fixed, repeatable period without changing the animation code.
    const uint32_t range = DEMO_TEXT_CORNER_ICON_TRAVEL_MAX_MS -
                           DEMO_TEXT_CORNER_ICON_TRAVEL_MIN_MS + 1U;
    return DEMO_TEXT_CORNER_ICON_TRAVEL_MIN_MS + esp_random() % range;
}

static int16_t randomTextCornerIconRotationSpeed(void)

1. Executeconst uint32_t range = (uint32_t)(DEMO_TEXT_CORNER_ICON_ROTATION_MAX_DEGREES_PER_SECOND - DEMO_TEXT_CORNER_ICON_ROTATION_MIN_DEGREES_PER_SECOND + 1);
2. Executeconst int16_t speed = (int16_t)(DEMO_TEXT_CORNER_ICON_ROTATION_MIN_DEGREES_PER_SECOND + (int)(esp_random() % range));
3. Exit this functionreturn (esp_random() & 1U) != 0U ? speed : (int16_t)-speed;

static int16_t randomTextCornerIconRotationSpeed(void)
{
    const uint32_t range = (uint32_t)(DEMO_TEXT_CORNER_ICON_ROTATION_MAX_DEGREES_PER_SECOND -
                                      DEMO_TEXT_CORNER_ICON_ROTATION_MIN_DEGREES_PER_SECOND + 1);
    const int16_t speed = (int16_t)(DEMO_TEXT_CORNER_ICON_ROTATION_MIN_DEGREES_PER_SECOND +
                                    (int)(esp_random() % range));
    // Give neighbouring icons visibly different movement by independently
    // choosing their clockwise or anti-clockwise direction as well as speed.
    return (esp_random() & 1U) != 0U ? speed : (int16_t)-speed;
}

static void startTextCornerIconCycles(uint32_t now_ms)

Calls into this documentation:

1. FOR loopsize_t corner = 0U; corner < DEMO_TEXT_CORNER_ICON_COUNT; ++corner

   Repeat body while the loop condition permits; then continue below.

   1. 1. Executedemo_text_corner_icon_cycles[corner].cycle_started_at = now_ms;
      2. Executedemo_text_corner_icon_cycles[corner].cycle_duration_ms = randomTextCornerIconTravelDuration();
      3. Executedemo_text_corner_icon_cycles[corner].rotation_started_at = now_ms;
      4. Executedemo_text_corner_icon_cycles[corner].rotation_start_degrees = (float)(esp_random() % 360U);
      5. Executedemo_text_corner_icon_cycles[corner].rotation_degrees_per_second = randomTextCornerIconRotationSpeed();

static void startTextCornerIconCycles(uint32_t now_ms)
{
    // A text segment always starts with every icon at its own outer corner.
    // The first random duration then separates the icons naturally as they
    // travel toward the centre X line at different rates.
    for (size_t corner = 0U; corner < DEMO_TEXT_CORNER_ICON_COUNT; ++corner) {
        demo_text_corner_icon_cycles[corner].cycle_started_at = now_ms;
        demo_text_corner_icon_cycles[corner].cycle_duration_ms =
            randomTextCornerIconTravelDuration();
        // Rotation does not restart with every travel cycle: it stays smooth
        // while movement chooses a new random duration at each outer edge.
        demo_text_corner_icon_cycles[corner].rotation_started_at = now_ms;
        demo_text_corner_icon_cycles[corner].rotation_start_degrees =
            (float)(esp_random() % 360U);
        demo_text_corner_icon_cycles[corner].rotation_degrees_per_second =
            randomTextCornerIconRotationSpeed();
    }
}

static void updateTextCornerIconCycles(uint32_t now_ms)

Calls into this documentation:

1. FOR loopsize_t corner = 0U; corner < DEMO_TEXT_CORNER_ICON_COUNT; ++corner

   Repeat body while the loop condition permits; then continue below.

   1. 1. Executedemo_text_corner_icon_cycle_t *const cycle = &demo_text_corner_icon_cycles[corner];
      2. WHILE loop(uint32_t)(now_ms - cycle->cycle_started_at) >= cycle->cycle_duration_ms

         Repeat body while the loop condition permits; then continue below.

         1. 1. Executecycle->cycle_started_at += cycle->cycle_duration_ms;
            2. Executecycle->cycle_duration_ms = randomTextCornerIconTravelDuration();

static void updateTextCornerIconCycles(uint32_t now_ms)
{
    for (size_t corner = 0U; corner < DEMO_TEXT_CORNER_ICON_COUNT; ++corner) {
        demo_text_corner_icon_cycle_t *const cycle = &demo_text_corner_icon_cycles[corner];
        // A late frame can cross more than one complete cycle. Preserve the
        // remaining time by advancing from the old start, rather than snapping
        // the icon back to its corner at the current frame time.
        while ((uint32_t)(now_ms - cycle->cycle_started_at) >= cycle->cycle_duration_ms) {
            cycle->cycle_started_at += cycle->cycle_duration_ms;
            cycle->cycle_duration_ms = randomTextCornerIconTravelDuration();
        }
    }
}

static void startStageSevenWalloons(uint32_t now_ms)

1. Executestage_seven_phase = WALLOONS_TITLE_CARD;
2. Executestage_seven_phase_started_at = now_ms;
3. Executestage_seven_completed_bounces = 0U;

static void startStageSevenWalloons(uint32_t now_ms)
{
    // Begin with the boxed PET title. After the short title interval, the box
    // disappears and the original action begins with the left Walloon walking
    // from PET cell (2, 15) to (14, 15).
    stage_seven_phase = WALLOONS_TITLE_CARD;
    stage_seven_phase_started_at = now_ms;
    stage_seven_completed_bounces = 0U;
}

static void releaseStageTwelveImage(void)

1. Executeheap_caps_free(stage_twelve_image);
2. Executestage_twelve_image = NULL;
3. Executestage_twelve_image_ready = false;
4. Executestage_twelve_image_path[0] = '\0';
5. Executestage_twelve_next_image_change_at = 0U;

static void releaseStageTwelveImage(void)
{
    heap_caps_free(stage_twelve_image);
    stage_twelve_image = NULL;
    stage_twelve_image_ready = false;
    stage_twelve_image_path[0] = '\0';
    stage_twelve_next_image_change_at = 0U;
}

static void releaseStageFifteenGroundSource(void)

1. Executeheap_caps_free(stage_fifteen_ground_source);
2. Executestage_fifteen_ground_source = NULL;

static void releaseStageFifteenGroundSource(void)
{
    heap_caps_free(stage_fifteen_ground_source);
    stage_fifteen_ground_source = NULL;
}

static void startStageFifteenBattleZoneRaster(void)

Calls into this documentation:

1. ExecutereleaseStageFifteenGroundSource();
2. Executeconst size_t ground_pixels = (size_t)LCD_WIDTH * (LCD_HEIGHT - BATTLE_ZONE_HORIZON_Y);
3. Executestage_fifteen_ground_source = heap_caps_malloc(ground_pixels * sizeof(stage_fifteen_ground_source[0]), MALLOC_CAP_SPIRAM | MALLOC_CAP_8BIT);

static void startStageFifteenBattleZoneRaster(void)
{
    releaseStageFifteenGroundSource();
    const size_t ground_pixels = (size_t)LCD_WIDTH *
        (LCD_HEIGHT - BATTLE_ZONE_HORIZON_Y);
    stage_fifteen_ground_source = heap_caps_malloc(ground_pixels *
                                                   sizeof(stage_fifteen_ground_source[0]),
                                                   MALLOC_CAP_SPIRAM | MALLOC_CAP_8BIT);
}

static void chooseStageTwelveLensEdgePoint(stage_twelve_lens_edge_t edge,
                                           float *x, float *y)

1. Select a caseedge

   Enter matching case; follow source fall-through until a break, return or end.

   1. 1. Case / labelcase STAGE_TWELVE_LENS_EDGE_TOP:
      2. Execute*x = (float)(esp_random() % LCD_WIDTH);
      3. Execute*y = 0.0f;
      4. Exit enclosing loop or switchbreak;
      5. Case / labelcase STAGE_TWELVE_LENS_EDGE_RIGHT:
      6. Execute*x = (float)(LCD_WIDTH - 1);
      7. Execute*y = (float)(esp_random() % LCD_HEIGHT);
      8. Exit enclosing loop or switchbreak;
      9. Case / labelcase STAGE_TWELVE_LENS_EDGE_BOTTOM:
      10. Execute*x = (float)(esp_random() % LCD_WIDTH);
      11. Execute*y = (float)(LCD_HEIGHT - 1);
      12. Exit enclosing loop or switchbreak;
      13. Case / labelcase STAGE_TWELVE_LENS_EDGE_LEFT:
      14. Case / labeldefault:
      15. Execute*x = 0.0f;
      16. Execute*y = (float)(esp_random() % LCD_HEIGHT);
      17. Exit enclosing loop or switchbreak;

static void chooseStageTwelveLensEdgePoint(stage_twelve_lens_edge_t edge,
                                           float *x, float *y)
{
    // The centre is always on one screen edge. The lens radius can therefore
    // extend outside the display, while every sampled source pixel stays valid.
    switch (edge) {
        case STAGE_TWELVE_LENS_EDGE_TOP:
            *x = (float)(esp_random() % LCD_WIDTH);
            *y = 0.0f;
            break;
        case STAGE_TWELVE_LENS_EDGE_RIGHT:
            *x = (float)(LCD_WIDTH - 1);
            *y = (float)(esp_random() % LCD_HEIGHT);
            break;
        case STAGE_TWELVE_LENS_EDGE_BOTTOM:
            *x = (float)(esp_random() % LCD_WIDTH);
            *y = (float)(LCD_HEIGHT - 1);
            break;
        case STAGE_TWELVE_LENS_EDGE_LEFT:
        default:
            *x = 0.0f;
            *y = (float)(esp_random() % LCD_HEIGHT);
            break;
    }
}

static void chooseStageTwelveLensTarget(void)

Calls into this documentation:

1. FOR loopunsigned attempt = 0U; attempt < DEMO_STAGE_TWELVE_LENS_TARGET_ATTEMPTS; ++attempt

   Repeat body while the loop condition permits; then continue below.

   1. 1. DO / WHILE loopstage_twelve_lens_target_edge == stage_twelve_lens_current_edge

         Run body, then test condition; repeat while true.

         1. 1. Executestage_twelve_lens_target_edge = (stage_twelve_lens_edge_t)(esp_random() % STAGE_TWELVE_LENS_EDGE_COUNT);
      2. ExecutechooseStageTwelveLensEdgePoint(stage_twelve_lens_target_edge, &stage_twelve_lens_target_x, &stage_twelve_lens_target_y);
      3. Executeconst float dx = stage_twelve_lens_target_x - stage_twelve_lens_x;
      4. Executeconst float dy = stage_twelve_lens_target_y - stage_twelve_lens_y;
      5. Executeconst float distance_squared = dx * dx + dy * dy;
      6. Executeconst float minimum_squared = DEMO_STAGE_TWELVE_LENS_MIN_TARGET_DISTANCE * DEMO_STAGE_TWELVE_LENS_MIN_TARGET_DISTANCE;
      7. Decisiondistance_squared >= minimum_squared
         True

         1. Exit this functionreturn;

         False

         Continue after this decision.

static void chooseStageTwelveLensTarget(void)
{
    // Pick a different edge and a visibly long route. The bounded retry count
    // guarantees progress even if future tuning makes the distance too strict.
    for (unsigned attempt = 0U; attempt < DEMO_STAGE_TWELVE_LENS_TARGET_ATTEMPTS; ++attempt) {
        do {
            stage_twelve_lens_target_edge =
                (stage_twelve_lens_edge_t)(esp_random() % STAGE_TWELVE_LENS_EDGE_COUNT);
        } while (stage_twelve_lens_target_edge == stage_twelve_lens_current_edge);
        chooseStageTwelveLensEdgePoint(stage_twelve_lens_target_edge,
                                       &stage_twelve_lens_target_x,
                                       &stage_twelve_lens_target_y);
        const float dx = stage_twelve_lens_target_x - stage_twelve_lens_x;
        const float dy = stage_twelve_lens_target_y - stage_twelve_lens_y;
        const float distance_squared = dx * dx + dy * dy;
        const float minimum_squared = DEMO_STAGE_TWELVE_LENS_MIN_TARGET_DISTANCE *
                                      DEMO_STAGE_TWELVE_LENS_MIN_TARGET_DISTANCE;
        if (distance_squared >= minimum_squared) return;
    }
}

static bool selectStageTwelveSlideshowImage(char *path, size_t path_size,
                                            const char *excluded_path)

Calls into this documentation:

1. ExecuteDIR *const directory = opendir(DEMO_STAGE_TWELVE_SLIDESHOW_DIRECTORY);
2. Decisiondirectory == NULL
   True

   1. Exit this functionreturn false;

   False

   Continue after this decision.

3. Executechar selected_name[DEMO_STAGE_TWELVE_IMAGE_PATH_MAX] = {0};
4. Executesize_t supported_count = 0U;
5. Executestruct dirent *entry;
6. WHILE loop(entry = readdir(directory)) != NULL

   Repeat body while the loop condition permits; then continue below.

   1. 1. Decision!imageIsSupportedName(entry->d_name)
         True

         1. Next loop iterationcontinue;

         False

         Continue after this decision.

      2. Executechar candidate_path[DEMO_STAGE_TWELVE_IMAGE_PATH_MAX];
      3. Executeconst int candidate_written = snprintf(candidate_path, sizeof(candidate_path), "%s/%s", DEMO_STAGE_TWELVE_SLIDESHOW_DIRECTORY, entry->d_name);
      4. Decisioncandidate_written < 0 || (size_t)candidate_written >= sizeof(candidate_path)
         True

         1. Next loop iterationcontinue;

         False

         Continue after this decision.

      5. Decisionexcluded_path != NULL && strcmp(candidate_path, excluded_path) == 0
         True

         1. Next loop iterationcontinue;

         False

         Continue after this decision.

      6. Execute++supported_count;
      7. Decisionesp_random() % supported_count != 0U
         True

         1. Next loop iterationcontinue;

         False

         Continue after this decision.

      8. Executeconst int written = snprintf(selected_name, sizeof(selected_name), "%s", entry->d_name);
      9. Decisionwritten < 0 || (size_t)written >= sizeof(selected_name)
         True

         1. 1. Executeclosedir(directory);
            2. Exit this functionreturn false;

         False

         Continue after this decision.

7. Executeclosedir(directory);
8. Decisionsupported_count == 0U
   True

   1. Exit this functionreturn false;

   False

   Continue after this decision.

9. Executeconst int written = snprintf(path, path_size, "%s/%s", DEMO_STAGE_TWELVE_SLIDESHOW_DIRECTORY, selected_name);
10. Exit this functionreturn written >= 0 && (size_t)written < path_size;

static bool selectStageTwelveSlideshowImage(char *path, size_t path_size,
                                            const char *excluded_path)
{
    DIR *const directory = opendir(DEMO_STAGE_TWELVE_SLIDESHOW_DIRECTORY);
    if (directory == NULL) return false;

    // Reservoir sampling gives every supported file an equal chance without
    // storing the slideshow directory's full filename list in RAM.
    char selected_name[DEMO_STAGE_TWELVE_IMAGE_PATH_MAX] = {0};
    size_t supported_count = 0U;
    struct dirent *entry;
    while ((entry = readdir(directory)) != NULL) {
        if (!imageIsSupportedName(entry->d_name)) continue;
        char candidate_path[DEMO_STAGE_TWELVE_IMAGE_PATH_MAX];
        const int candidate_written = snprintf(candidate_path, sizeof(candidate_path), "%s/%s",
                                               DEMO_STAGE_TWELVE_SLIDESHOW_DIRECTORY, entry->d_name);
        if (candidate_written < 0 || (size_t)candidate_written >= sizeof(candidate_path)) continue;
        // Do not immediately repeat the current picture when the directory
        // contains another supported file to choose from.
        if (excluded_path != NULL && strcmp(candidate_path, excluded_path) == 0) continue;
        ++supported_count;
        if (esp_random() % supported_count != 0U) continue;
        const int written = snprintf(selected_name, sizeof(selected_name), "%s", entry->d_name);
        if (written < 0 || (size_t)written >= sizeof(selected_name)) {
            closedir(directory);
            return false;
        }
    }
    closedir(directory);
    if (supported_count == 0U) return false;

    const int written = snprintf(path, path_size, "%s/%s",
                                 DEMO_STAGE_TWELVE_SLIDESHOW_DIRECTORY, selected_name);
    return written >= 0 && (size_t)written < path_size;
}

static void beginStageTwelveLensGlide(uint32_t now_ms)

Calls into this documentation:

1. Executestage_twelve_lens_start_x = stage_twelve_lens_x;
2. Executestage_twelve_lens_start_y = stage_twelve_lens_y;
3. ExecutechooseStageTwelveLensTarget();
4. Executestage_twelve_lens_glide_started_at = now_ms;
5. Executestage_twelve_lens_glide_duration_ms = DEMO_STAGE_TWELVE_LENS_GLIDE_MIN_MS + (esp_random() % DEMO_STAGE_TWELVE_LENS_GLIDE_RANGE_MS);

static void beginStageTwelveLensGlide(uint32_t now_ms)
{
    stage_twelve_lens_start_x = stage_twelve_lens_x;
    stage_twelve_lens_start_y = stage_twelve_lens_y;
    chooseStageTwelveLensTarget();
    stage_twelve_lens_glide_started_at = now_ms;
    stage_twelve_lens_glide_duration_ms = DEMO_STAGE_TWELVE_LENS_GLIDE_MIN_MS +
        (esp_random() % DEMO_STAGE_TWELVE_LENS_GLIDE_RANGE_MS);
}

static void startStageTwelveSlideshowLens(uint32_t now_ms)

Calls into this documentation:

1. ExecutereleaseStageTwelveImage();
2. Executestage_twelve_image = heap_caps_malloc((size_t)LCD_WIDTH * LCD_HEIGHT * sizeof(stage_twelve_image[0]), MALLOC_CAP_SPIRAM | MALLOC_CAP_8BIT);
3. Decisionstage_twelve_image == NULL
   True

   1. Exit this functionreturn;

   False

   Continue after this decision.

4. Executechar image_path[DEMO_STAGE_TWELVE_IMAGE_PATH_MAX];
5. Decision!selectStageTwelveSlideshowImage(image_path, sizeof(image_path), NULL) || !imageDecodeFile(image_path, stage_twelve_image)
   True

   1. 1. ExecutereleaseStageTwelveImage();
      2. Exit this functionreturn;

   False

   Continue after this decision.

6. Executestage_twelve_image_ready = true;
7. Executesnprintf(stage_twelve_image_path, sizeof(stage_twelve_image_path), "%s", image_path);
8. Executestage_twelve_next_image_change_at = now_ms + DEMO_STAGE_TWELVE_IMAGE_CHANGE_MS;
9. Executestage_twelve_lens_current_edge = (stage_twelve_lens_edge_t)(esp_random() % STAGE_TWELVE_LENS_EDGE_COUNT);
10. ExecutechooseStageTwelveLensEdgePoint(stage_twelve_lens_current_edge, &stage_twelve_lens_x, &stage_twelve_lens_y);
11. ExecutebeginStageTwelveLensGlide(now_ms);

static void startStageTwelveSlideshowLens(uint32_t now_ms)
{
    releaseStageTwelveImage();
    stage_twelve_image = heap_caps_malloc((size_t)LCD_WIDTH * LCD_HEIGHT *
                                           sizeof(stage_twelve_image[0]),
                                           MALLOC_CAP_SPIRAM | MALLOC_CAP_8BIT);
    if (stage_twelve_image == NULL) return;

    char image_path[DEMO_STAGE_TWELVE_IMAGE_PATH_MAX];
    if (!selectStageTwelveSlideshowImage(image_path, sizeof(image_path), NULL) ||
        !imageDecodeFile(image_path, stage_twelve_image)) {
        releaseStageTwelveImage();
        return;
    }

    stage_twelve_image_ready = true;
    snprintf(stage_twelve_image_path, sizeof(stage_twelve_image_path), "%s", image_path);
    stage_twelve_next_image_change_at = now_ms + DEMO_STAGE_TWELVE_IMAGE_CHANGE_MS;
    stage_twelve_lens_current_edge =
        (stage_twelve_lens_edge_t)(esp_random() % STAGE_TWELVE_LENS_EDGE_COUNT);
    chooseStageTwelveLensEdgePoint(stage_twelve_lens_current_edge,
                                   &stage_twelve_lens_x, &stage_twelve_lens_y);
    beginStageTwelveLensGlide(now_ms);
}

static void updateStageTwelveSlideshowLens(uint32_t now_ms)

Calls into this documentation:

1. Decision!stage_twelve_image_ready
   True

   1. Exit this functionreturn;

   False

   Continue after this decision.

2. Decision(int32_t)(now_ms - stage_twelve_next_image_change_at) >= 0
   True

   1. 1. Executechar image_path[DEMO_STAGE_TWELVE_IMAGE_PATH_MAX];
      2. DecisionselectStageTwelveSlideshowImage(image_path, sizeof(image_path), stage_twelve_image_path) && imageDecodeFile(image_path, stage_twelve_image)
         True

         1. 1. Executesnprintf(stage_twelve_image_path, sizeof(stage_twelve_image_path), "%s", image_path);

         False

         Continue after this decision.

      3. Executestage_twelve_next_image_change_at = now_ms + DEMO_STAGE_TWELVE_IMAGE_CHANGE_MS;

   False

   Continue after this decision.

3. Executeconst uint32_t elapsed_ms = now_ms - stage_twelve_lens_glide_started_at;
4. Decisionelapsed_ms >= stage_twelve_lens_glide_duration_ms
   True

   1. 1. Executestage_twelve_lens_x = stage_twelve_lens_target_x;
      2. Executestage_twelve_lens_y = stage_twelve_lens_target_y;
      3. Executestage_twelve_lens_current_edge = stage_twelve_lens_target_edge;
      4. ExecutebeginStageTwelveLensGlide(now_ms);
      5. Exit this functionreturn;

   False

   Continue after this decision.

5. Executeconst float progress = (float)elapsed_ms / (float)stage_twelve_lens_glide_duration_ms;
6. Executestage_twelve_lens_x = stage_twelve_lens_start_x + (stage_twelve_lens_target_x - stage_twelve_lens_start_x) * progress;
7. Executestage_twelve_lens_y = stage_twelve_lens_start_y + (stage_twelve_lens_target_y - stage_twelve_lens_start_y) * progress;

static void updateStageTwelveSlideshowLens(uint32_t now_ms)
{
    if (!stage_twelve_image_ready) return;
    if ((int32_t)(now_ms - stage_twelve_next_image_change_at) >= 0) {
        char image_path[DEMO_STAGE_TWELVE_IMAGE_PATH_MAX];
        // Reuse the existing PSRAM image buffer. If a new file cannot be
        // selected or decoded, leave the already visible picture in place.
        if (selectStageTwelveSlideshowImage(image_path, sizeof(image_path),
                                             stage_twelve_image_path) &&
            imageDecodeFile(image_path, stage_twelve_image)) {
            snprintf(stage_twelve_image_path, sizeof(stage_twelve_image_path), "%s", image_path);
        }
        stage_twelve_next_image_change_at = now_ms + DEMO_STAGE_TWELVE_IMAGE_CHANGE_MS;
    }
    const uint32_t elapsed_ms = now_ms - stage_twelve_lens_glide_started_at;
    if (elapsed_ms >= stage_twelve_lens_glide_duration_ms) {
        stage_twelve_lens_x = stage_twelve_lens_target_x;
        stage_twelve_lens_y = stage_twelve_lens_target_y;
        stage_twelve_lens_current_edge = stage_twelve_lens_target_edge;
        beginStageTwelveLensGlide(now_ms);
        return;
    }

    const float progress = (float)elapsed_ms / (float)stage_twelve_lens_glide_duration_ms;
    // Use constant-speed interpolation rather than smoothstep. Smoothstep
    // reaches zero speed at every target, which made the lens visibly pause.
    stage_twelve_lens_x = stage_twelve_lens_start_x +
        (stage_twelve_lens_target_x - stage_twelve_lens_start_x) * progress;
    stage_twelve_lens_y = stage_twelve_lens_start_y +
        (stage_twelve_lens_target_y - stage_twelve_lens_start_y) * progress;
}

static unsigned walloonsPhaseSteps(uint32_t now_ms, unsigned maximum_steps)

1. Executeconst unsigned elapsed_steps = (now_ms - stage_seven_phase_started_at) / DEMO_STAGE_SEVEN_STEP_MS;
2. Exit this functionreturn elapsed_steps < maximum_steps ? elapsed_steps : maximum_steps;

static unsigned walloonsPhaseSteps(uint32_t now_ms, unsigned maximum_steps)
{
    const unsigned elapsed_steps = (now_ms - stage_seven_phase_started_at) /
                                   DEMO_STAGE_SEVEN_STEP_MS;
    return elapsed_steps < maximum_steps ? elapsed_steps : maximum_steps;
}

static void setWalloonsPhase(walloons_phase_t phase, uint32_t now_ms)

1. Executestage_seven_phase = phase;
2. Executestage_seven_phase_started_at = now_ms;

static void setWalloonsPhase(walloons_phase_t phase, uint32_t now_ms)
{
    stage_seven_phase = phase;
    stage_seven_phase_started_at = now_ms;
}

static void updateStageSevenWalloons(uint32_t now_ms)

Calls into this documentation:

1. Executeconst uint32_t elapsed = now_ms - stage_seven_phase_started_at;
2. Executeconst uint32_t walk_duration = 12U * DEMO_STAGE_SEVEN_STEP_MS;
3. Executeconst uint32_t platform_duration = 14U * DEMO_STAGE_SEVEN_STEP_MS;
4. Executeconst uint32_t vertical_duration = 13U * DEMO_STAGE_SEVEN_STEP_MS;
5. Select a casestage_seven_phase

   Enter matching case; follow source fall-through until a break, return or end.

   1. 1. Case / labelcase WALLOONS_TITLE_CARD:
      2. Decisionelapsed >= DEMO_STAGE_SEVEN_TITLE_MS
         True

         1. 1. ExecutesetWalloonsPhase(WALLOONS_LEFT_WALK_IN, now_ms);

         False

         Continue after this decision.

      3. Exit enclosing loop or switchbreak;
      4. Case / labelcase WALLOONS_LEFT_WALK_IN:
      5. Decisionelapsed >= walk_duration
         True

         1. 1. ExecutesetWalloonsPhase(WALLOONS_PAUSE_ON_SEESAW, now_ms);

         False

         Continue after this decision.

      6. Exit enclosing loop or switchbreak;
      7. Case / labelcase WALLOONS_PAUSE_ON_SEESAW:
      8. Decisionelapsed >= DEMO_STAGE_SEVEN_PAUSE_MS
         True

         1. 1. ExecutesetWalloonsPhase(WALLOONS_RIGHT_WALK_ON_PLATFORM, now_ms);

         False

         Continue after this decision.

      9. Exit enclosing loop or switchbreak;
      10. Case / labelcase WALLOONS_RIGHT_WALK_ON_PLATFORM:
      11. Decisionelapsed >= platform_duration
          True

          1. 1. ExecutesetWalloonsPhase(WALLOONS_RIGHT_DROP, now_ms);

          False

          Continue after this decision.

      12. Exit enclosing loop or switchbreak;
      13. Case / labelcase WALLOONS_RIGHT_DROP:
      14. Decisionelapsed >= vertical_duration
          True

          1. 1. ExecutesetWalloonsPhase(WALLOONS_BOUNCE_RIGHT_UP, now_ms);

          False

          Continue after this decision.

      15. Exit enclosing loop or switchbreak;
      16. Case / labelcase WALLOONS_BOUNCE_RIGHT_UP:
      17. Decisionelapsed >= vertical_duration
          True

          1. 1. ExecutesetWalloonsPhase(WALLOONS_BOUNCE_RIGHT_DOWN, now_ms);

          False

          Continue after this decision.

      18. Exit enclosing loop or switchbreak;
      19. Case / labelcase WALLOONS_BOUNCE_RIGHT_DOWN:
      20. Decisionelapsed >= vertical_duration
          True

          1. 1. ExecutesetWalloonsPhase(WALLOONS_BOUNCE_LEFT_UP, now_ms);

          False

          Continue after this decision.

      21. Exit enclosing loop or switchbreak;
      22. Case / labelcase WALLOONS_BOUNCE_LEFT_UP:
      23. Decisionelapsed >= vertical_duration
          True

          1. 1. ExecutesetWalloonsPhase(WALLOONS_BOUNCE_LEFT_DOWN, now_ms);

          False

          Continue after this decision.

      24. Exit enclosing loop or switchbreak;
      25. Case / labelcase WALLOONS_BOUNCE_LEFT_DOWN:
      26. Decisionelapsed >= vertical_duration
          True

          1. 1. ExecutesetWalloonsPhase(WALLOONS_LEFT_LANDED, now_ms);

          False

          Continue after this decision.

      27. Exit enclosing loop or switchbreak;
      28. Case / labelcase WALLOONS_LEFT_LANDED:
      29. Decisionelapsed >= DEMO_STAGE_SEVEN_LANDING_MS
          True

          1. 1. Execute++stage_seven_completed_bounces;
             2. Decisionstage_seven_completed_bounces >= DEMO_STAGE_SEVEN_BOUNCE_COUNT
                True

                1. 1. ExecutesetWalloonsPhase(WALLOONS_FINISHED, now_ms);

                False

                1. 1. ExecutesetWalloonsPhase(WALLOONS_BOUNCE_RIGHT_UP, now_ms);

          False

          Continue after this decision.

      30. Exit enclosing loop or switchbreak;
      31. Case / labelcase WALLOONS_FINISHED:
      32. Exit enclosing loop or switchbreak;

static void updateStageSevenWalloons(uint32_t now_ms)
{
    const uint32_t elapsed = now_ms - stage_seven_phase_started_at;
    const uint32_t walk_duration = 12U * DEMO_STAGE_SEVEN_STEP_MS;
    const uint32_t platform_duration = 14U * DEMO_STAGE_SEVEN_STEP_MS;
    // There are twelve row moves. Hold the twelfth (landing) cell for one full
    // step interval instead of changing phase before drawDemo can show it.
    const uint32_t vertical_duration = 13U * DEMO_STAGE_SEVEN_STEP_MS;

    switch (stage_seven_phase) {
        case WALLOONS_TITLE_CARD:
            if (elapsed >= DEMO_STAGE_SEVEN_TITLE_MS) {
                setWalloonsPhase(WALLOONS_LEFT_WALK_IN, now_ms);
            }
            break;
        case WALLOONS_LEFT_WALK_IN:
            if (elapsed >= walk_duration) {
                setWalloonsPhase(WALLOONS_PAUSE_ON_SEESAW, now_ms);
            }
            break;
        case WALLOONS_PAUSE_ON_SEESAW:
            if (elapsed >= DEMO_STAGE_SEVEN_PAUSE_MS) {
                setWalloonsPhase(WALLOONS_RIGHT_WALK_ON_PLATFORM, now_ms);
            }
            break;
        case WALLOONS_RIGHT_WALK_ON_PLATFORM:
            if (elapsed >= platform_duration) {
                setWalloonsPhase(WALLOONS_RIGHT_DROP, now_ms);
            }
            break;
        case WALLOONS_RIGHT_DROP:
            if (elapsed >= vertical_duration) {
                setWalloonsPhase(WALLOONS_BOUNCE_RIGHT_UP, now_ms);
            }
            break;
        case WALLOONS_BOUNCE_RIGHT_UP:
            if (elapsed >= vertical_duration) {
                setWalloonsPhase(WALLOONS_BOUNCE_RIGHT_DOWN, now_ms);
            }
            break;
        case WALLOONS_BOUNCE_RIGHT_DOWN:
            if (elapsed >= vertical_duration) {
                setWalloonsPhase(WALLOONS_BOUNCE_LEFT_UP, now_ms);
            }
            break;
        case WALLOONS_BOUNCE_LEFT_UP:
            if (elapsed >= vertical_duration) {
                setWalloonsPhase(WALLOONS_BOUNCE_LEFT_DOWN, now_ms);
            }
            break;
        case WALLOONS_BOUNCE_LEFT_DOWN:
            if (elapsed >= vertical_duration) {
                setWalloonsPhase(WALLOONS_LEFT_LANDED, now_ms);
            }
            break;
        case WALLOONS_LEFT_LANDED:
            // Keep the left Walloon visibly on the new low end before launching
            // the right Walloon. This is the original stunt's missing landing beat.
            if (elapsed >= DEMO_STAGE_SEVEN_LANDING_MS) {
                ++stage_seven_completed_bounces;
                if (stage_seven_completed_bounces >= DEMO_STAGE_SEVEN_BOUNCE_COUNT) {
                    setWalloonsPhase(WALLOONS_FINISHED, now_ms);
                } else {
                    setWalloonsPhase(WALLOONS_BOUNCE_RIGHT_UP, now_ms);
                }
            }
            break;
        case WALLOONS_FINISHED:
            // Hold the completed stunt until C or the shared inactivity timer advances Demo.
            break;
    }
}

static uint32_t demoTimeNow(uint32_t now_ms)

1. Exit this functionreturn now_ms - demo_paused_total_ms;

static uint32_t demoTimeNow(uint32_t now_ms)
{
    return now_ms - demo_paused_total_ms;
}

static void enterDemoStage(demo_stage_t stage, uint32_t now_ms)

Calls into this documentation:

1. Decisionselected_stage == DEMO_STAGE_SLIDESHOW_LENS
   True

   1. ExecutedemoStageSlideshowLensStop();

   False

   Continue after this decision.

2. Decisionselected_stage == DEMO_STAGE_GAME_OF_LIFE
   True

   1. ExecutedemoStageGameOfLifeStop();

   False

   Continue after this decision.

3. Decisionselected_stage == DEMO_STAGE_BATTLE_ZONE_RASTER
   True

   1. ExecutereleaseStageFifteenGroundSource();

   False

   Continue after this decision.

4. Executeselected_stage = stage;
5. Executedemo_last_interaction_at = now_ms;
6. Decisionselected_stage == DEMO_STAGE_ICON
   True

   1. 1. Executestage_one_next_effect_change_at = now_ms + DEMO_STAGE_ONE_EFFECT_CHANGE_MS;

   False

   Continue after this decision.

7. Decisionselected_stage == DEMO_STAGE_AMIGA_BALL
   True

   1. ExecutestartStageThreeBall(now_ms);

   False

   Continue after this decision.

8. Decisionselected_stage == DEMO_STAGE_GEOMETRIC_SOLID
   True

   1. ExecutestartStageSixSolid(now_ms);

   False

   Continue after this decision.

9. Decisionselected_stage == DEMO_STAGE_SCROLLER || selected_stage == DEMO_STAGE_REVERSE_SCROLLER
   True

   1. ExecutestartTextCornerIconCycles(now_ms);

   False

   Continue after this decision.

10. Decisionselected_stage == DEMO_STAGE_WALLOONS
    True

    1. ExecutedemoStageWalloonsStart(now_ms);

    False

    Continue after this decision.

11. Decisionselected_stage == DEMO_STAGE_KALEIDO
    True

    1. ExecutedemoStageKaleidoStart(now_ms);

    False

    Continue after this decision.

12. Decisionselected_stage == DEMO_STAGE_SPARKLE
    True

    1. ExecutedemoStageSparkleStart(now_ms);

    False

    Continue after this decision.

13. Decisionselected_stage == DEMO_STAGE_SQUARES
    True

    1. ExecutedemoStageSquaresStart(now_ms);

    False

    Continue after this decision.

14. Decisionselected_stage == DEMO_STAGE_BATTLE_ZONE_RASTER
    True

    1. ExecutestartStageFifteenBattleZoneRaster();

    False

    Continue after this decision.

15. Decisionselected_stage == DEMO_STAGE_BEVEL_GEARS
    True

    1. 1. Executestage_seventeen_rig_pitch_degrees = -12.0f;
       2. Executestage_seventeen_rig_yaw_degrees = 18.0f;
       3. Executestage_seventeen_rig_roll_degrees = 0.0f;
       4. Executestage_seventeen_gear_degrees[0] = 0.0f;
       5. Executestage_seventeen_gear_degrees[1] = 286.0f;
       6. Executestage_seventeen_gear_degrees[2] = 226.0f;
       7. Executestage_seventeen_style = STAGE_SEVENTEEN_STYLE_FLAT;

    False

    Continue after this decision.

16. Decisionselected_stage == DEMO_STAGE_MOUSE_MAZE
    True

    1. ExecutedemoStageMouseMazeStart(now_ms);

    False

    Continue after this decision.

17. Decisionselected_stage == DEMO_STAGE_RASTER_BANDS || selected_stage == DEMO_STAGE_LOWER_RASTER_SCROLLER || selected_stage == DEMO_STAGE_BATTLE_ZONE_RASTER
    True

    1. 1. Executeraster_band_effect_elapsed_ms = 0U;
       2. Decisionselected_stage == DEMO_STAGE_LOWER_RASTER_SCROLLER
          True

          1. 1. Executeraster_band_palette_index = DEMO_RASTER_FIRE_PALETTE_INDEX;

          False

          1. Decisionselected_stage == DEMO_STAGE_BATTLE_ZONE_RASTER
             True

             1. 1. Executeraster_band_palette_index = DEMO_RASTER_GREEN_PALETTE_INDEX;

             False

             1. 1. Executeraster_band_palette_index = DEMO_RASTER_METALLIC_PALETTE_INDEX;

    False

    Continue after this decision.

18. Decisionselected_stage == DEMO_STAGE_LOWER_RASTER_SCROLLER && scroll_text != NULL
    True

    1. 1. Executescroll_text_width = strlen(scroll_text) * PET2001_FONT_GLYPH_WIDTH * (size_t)DEMO_STAGE_FOURTEEN_SCROLL_SCALE;
       2. Executescroll_text_x = scroll_speed_pixels_per_second >= 0.0f ? (float)LCD_WIDTH : -(float)scroll_text_width;

    False

    Continue after this decision.

19. Decisionselected_stage == DEMO_STAGE_SLIDESHOW_LENS
    True

    1. ExecutedemoStageSlideshowLensStart(now_ms);

    False

    Continue after this decision.

20. Decisionselected_stage == DEMO_STAGE_PLASMA
    True

    1. ExecutedemoStagePlasmaStart();

    False

    Continue after this decision.

21. Decisionselected_stage == DEMO_STAGE_GAME_OF_LIFE
    True

    1. ExecutedemoStageGameOfLifeStart(now_ms);

    False

    Continue after this decision.

static void enterDemoStage(demo_stage_t stage, uint32_t now_ms)
{
    // Stage 12 owns a full-screen PSRAM source only while it is visible.
    if (selected_stage == DEMO_STAGE_SLIDESHOW_LENS) demoStageSlideshowLensStop();
    if (selected_stage == DEMO_STAGE_GAME_OF_LIFE) demoStageGameOfLifeStop();
    if (selected_stage == DEMO_STAGE_BATTLE_ZONE_RASTER) releaseStageFifteenGroundSource();
    selected_stage = stage;
    // Entering any segment begins a fresh shared inactivity interval.
    demo_last_interaction_at = now_ms;
    if (selected_stage == DEMO_STAGE_ICON) {
        // A full Demo loop begins a fresh automatic Stage-1 effect interval.
        stage_one_next_effect_change_at = now_ms + DEMO_STAGE_ONE_EFFECT_CHANGE_MS;
    }
    if (selected_stage == DEMO_STAGE_AMIGA_BALL) startStageThreeBall(now_ms);
    if (selected_stage == DEMO_STAGE_GEOMETRIC_SOLID) startStageSixSolid(now_ms);
    if (selected_stage == DEMO_STAGE_SCROLLER ||
        selected_stage == DEMO_STAGE_REVERSE_SCROLLER) startTextCornerIconCycles(now_ms);
    if (selected_stage == DEMO_STAGE_WALLOONS) demoStageWalloonsStart(now_ms);
    if (selected_stage == DEMO_STAGE_KALEIDO) demoStageKaleidoStart(now_ms);
    if (selected_stage == DEMO_STAGE_SPARKLE) demoStageSparkleStart(now_ms);
    if (selected_stage == DEMO_STAGE_SQUARES) demoStageSquaresStart(now_ms);
    if (selected_stage == DEMO_STAGE_BATTLE_ZONE_RASTER) startStageFifteenBattleZoneRaster();
    if (selected_stage == DEMO_STAGE_BEVEL_GEARS) {
        stage_seventeen_rig_pitch_degrees = -12.0f;
        stage_seventeen_rig_yaw_degrees = 18.0f;
        stage_seventeen_rig_roll_degrees = 0.0f;
        stage_seventeen_gear_degrees[0] = 0.0f;
        // Each driven gear begins half a tooth out of phase with the lead gear
        // at its fixed mesh contact. Their later angles are derived by motion.
        stage_seventeen_gear_degrees[1] = 286.0f;
        stage_seventeen_gear_degrees[2] = 226.0f;
        // Start with the clearest filled treatment; B cycles outline, flat-retro,
        // and shaded-metal versions without restarting the rig.
        stage_seventeen_style = STAGE_SEVENTEEN_STYLE_FLAT;
    }
    if (selected_stage == DEMO_STAGE_MOUSE_MAZE) demoStageMouseMazeStart(now_ms);
    if (selected_stage == DEMO_STAGE_RASTER_BANDS ||
        selected_stage == DEMO_STAGE_LOWER_RASTER_SCROLLER ||
        selected_stage == DEMO_STAGE_BATTLE_ZONE_RASTER) {
        raster_band_effect_elapsed_ms = 0U;
        // Each raster segment starts on its own fitting palette. B can then
        // cycle every palette from the shared list without interrupting motion.
        if (selected_stage == DEMO_STAGE_LOWER_RASTER_SCROLLER) {
            raster_band_palette_index = DEMO_RASTER_FIRE_PALETTE_INDEX;
        } else if (selected_stage == DEMO_STAGE_BATTLE_ZONE_RASTER) {
            raster_band_palette_index = DEMO_RASTER_GREEN_PALETTE_INDEX;
        } else {
            raster_band_palette_index = DEMO_RASTER_METALLIC_PALETTE_INDEX;
        }
    }
    if (selected_stage == DEMO_STAGE_LOWER_RASTER_SCROLLER && scroll_text != NULL) {
        // This segment is wider than the shared scale-2 ticker. Restart the
        // current message just outside its travel edge using its scale-3 width.
        scroll_text_width = strlen(scroll_text) * PET2001_FONT_GLYPH_WIDTH *
                            (size_t)DEMO_STAGE_FOURTEEN_SCROLL_SCALE;
        scroll_text_x = scroll_speed_pixels_per_second >= 0.0f
            ? (float)LCD_WIDTH : -(float)scroll_text_width;
    }
    if (selected_stage == DEMO_STAGE_SLIDESHOW_LENS) demoStageSlideshowLensStart(now_ms);
    if (selected_stage == DEMO_STAGE_PLASMA) demoStagePlasmaStart();
    if (selected_stage == DEMO_STAGE_GAME_OF_LIFE) demoStageGameOfLifeStart(now_ms);
}

static void advanceDemoStage(uint32_t now_ms)

Calls into this documentation:

1. ExecuteenterDemoStage(demoSelectorNextAutomaticStage(selected_stage), now_ms);

static void advanceDemoStage(uint32_t now_ms)
{
    enterDemoStage(demoSelectorNextAutomaticStage(selected_stage), now_ms);
}

static void updateStageThreeBall(float elapsed_seconds)

1. Executestage_three_ball_x += stage_three_ball_velocity_x * elapsed_seconds;
2. Executestage_three_ball_y += stage_three_ball_velocity_y * elapsed_seconds;
3. Executestage_three_ball_velocity_y += DEMO_STAGE_THREE_BALL_GRAVITY * elapsed_seconds;
4. Executestage_three_ball_rotation_phase += DEMO_STAGE_THREE_BALL_ROTATION_BANDS_PER_SECOND * elapsed_seconds;
5. Decisionstage_three_ball_rotation_phase >= (float)DEMO_STAGE_THREE_BALL_LONGITUDE_BANDS
   True

   1. 1. Executestage_three_ball_rotation_phase -= (float)DEMO_STAGE_THREE_BALL_LONGITUDE_BANDS;

   False

   Continue after this decision.

6. Decisionstage_three_ball_x < (float)DEMO_STAGE_THREE_BALL_RADIUS
   True

   1. 1. Executestage_three_ball_x = (float)DEMO_STAGE_THREE_BALL_RADIUS;
      2. Executestage_three_ball_velocity_x = DEMO_STAGE_THREE_BALL_HORIZONTAL_VELOCITY;

   False

   1. Decisionstage_three_ball_x > (float)(LCD_WIDTH - 1 - DEMO_STAGE_THREE_BALL_RADIUS)
      True

      1. 1. Executestage_three_ball_x = (float)(LCD_WIDTH - 1 - DEMO_STAGE_THREE_BALL_RADIUS);
         2. Executestage_three_ball_velocity_x = -DEMO_STAGE_THREE_BALL_HORIZONTAL_VELOCITY;

      False

      Continue after this decision.

7. Decisionstage_three_ball_y > DEMO_STAGE_THREE_BALL_FLOOR_Y - (float)DEMO_STAGE_THREE_BALL_RADIUS
   True

   1. 1. Executestage_three_ball_y = DEMO_STAGE_THREE_BALL_FLOOR_Y - (float)DEMO_STAGE_THREE_BALL_RADIUS;
      2. Executestage_three_ball_velocity_y = DEMO_STAGE_THREE_BALL_BOUNCE_VELOCITY;

   False

   Continue after this decision.

static void updateStageThreeBall(float elapsed_seconds)
{
    stage_three_ball_x += stage_three_ball_velocity_x * elapsed_seconds;
    stage_three_ball_y += stage_three_ball_velocity_y * elapsed_seconds;
    stage_three_ball_velocity_y += DEMO_STAGE_THREE_BALL_GRAVITY * elapsed_seconds;
    stage_three_ball_rotation_phase +=
        DEMO_STAGE_THREE_BALL_ROTATION_BANDS_PER_SECOND * elapsed_seconds;
    if (stage_three_ball_rotation_phase >= (float)DEMO_STAGE_THREE_BALL_LONGITUDE_BANDS) {
        stage_three_ball_rotation_phase -= (float)DEMO_STAGE_THREE_BALL_LONGITUDE_BANDS;
    }
    if (stage_three_ball_x < (float)DEMO_STAGE_THREE_BALL_RADIUS) {
        stage_three_ball_x = (float)DEMO_STAGE_THREE_BALL_RADIUS;
        stage_three_ball_velocity_x = DEMO_STAGE_THREE_BALL_HORIZONTAL_VELOCITY;
    } else if (stage_three_ball_x >
               (float)(LCD_WIDTH - 1 - DEMO_STAGE_THREE_BALL_RADIUS)) {
        stage_three_ball_x = (float)(LCD_WIDTH - 1 - DEMO_STAGE_THREE_BALL_RADIUS);
        stage_three_ball_velocity_x = -DEMO_STAGE_THREE_BALL_HORIZONTAL_VELOCITY;
    }
    if (stage_three_ball_y > DEMO_STAGE_THREE_BALL_FLOOR_Y -
                             (float)DEMO_STAGE_THREE_BALL_RADIUS) {
        stage_three_ball_y = DEMO_STAGE_THREE_BALL_FLOOR_Y -
                             (float)DEMO_STAGE_THREE_BALL_RADIUS;
        stage_three_ball_velocity_y = DEMO_STAGE_THREE_BALL_BOUNCE_VELOCITY;
    }
}

static void selectRandomStageTransition(void)

1. Executeselected_stage_transition = (demo_stage_transition_effect_t) (esp_random() % DEMO_STAGE_TRANSITION_EFFECT_COUNT);
2. Decisionselected_stage_transition != DEMO_STAGE_TRANSITION_SCROLL
   True

   1. Exit this functionreturn;

   False

   Continue after this decision.

3. Select a caseesp_random() % 4U

   Enter matching case; follow source fall-through until a break, return or end.

   1. 1. Case / labelcase 0U:
      2. Executestage_scroll_out_direction = SCREEN_TRANSITION_SCROLL_LEFT;
      3. Executestage_scroll_in_direction = SCREEN_TRANSITION_SCROLL_RIGHT;
      4. Exit enclosing loop or switchbreak;
      5. Case / labelcase 1U:
      6. Executestage_scroll_out_direction = SCREEN_TRANSITION_SCROLL_RIGHT;
      7. Executestage_scroll_in_direction = SCREEN_TRANSITION_SCROLL_LEFT;
      8. Exit enclosing loop or switchbreak;
      9. Case / labelcase 2U:
      10. Executestage_scroll_out_direction = SCREEN_TRANSITION_SCROLL_UP;
      11. Executestage_scroll_in_direction = SCREEN_TRANSITION_SCROLL_DOWN;
      12. Exit enclosing loop or switchbreak;
      13. Case / labeldefault:
      14. Executestage_scroll_out_direction = SCREEN_TRANSITION_SCROLL_DOWN;
      15. Executestage_scroll_in_direction = SCREEN_TRANSITION_SCROLL_UP;
      16. Exit enclosing loop or switchbreak;

static void selectRandomStageTransition(void)
{
    selected_stage_transition = (demo_stage_transition_effect_t)
        (esp_random() % DEMO_STAGE_TRANSITION_EFFECT_COUNT);
    if (selected_stage_transition != DEMO_STAGE_TRANSITION_SCROLL) return;

    // Each pair keeps both frames on the same axis, travelling in opposite directions.
    // The index is random so each scroll transition can go left, right, up, or down.
    switch (esp_random() % 4U) {
        case 0U:
            stage_scroll_out_direction = SCREEN_TRANSITION_SCROLL_LEFT;
            stage_scroll_in_direction = SCREEN_TRANSITION_SCROLL_RIGHT;
            break;
        case 1U:
            stage_scroll_out_direction = SCREEN_TRANSITION_SCROLL_RIGHT;
            stage_scroll_in_direction = SCREEN_TRANSITION_SCROLL_LEFT;
            break;
        case 2U:
            stage_scroll_out_direction = SCREEN_TRANSITION_SCROLL_UP;
            stage_scroll_in_direction = SCREEN_TRANSITION_SCROLL_DOWN;
            break;
        default:
            stage_scroll_out_direction = SCREEN_TRANSITION_SCROLL_DOWN;
            stage_scroll_in_direction = SCREEN_TRANSITION_SCROLL_UP;
            break;
    }
}

static void selectScrollMessage(bool switch_logo)

Calls into this documentation:

1. Executesize_t next = (size_t)esp_random() % DEMO_SCROLL_MESSAGE_COUNT;
2. Decisionscroll_message_index < DEMO_SCROLL_MESSAGE_COUNT
   True

   1. 1. Executenext = (size_t)esp_random() % (DEMO_SCROLL_MESSAGE_COUNT - 1U);
      2. Decisionnext >= scroll_message_index
         True

         1. Execute++next;

         False

         Continue after this decision.

   False

   Continue after this decision.

3. Executescroll_message_index = next;
4. Executescroll_text = demo_scroll_messages[scroll_message_index];
5. Executeconst size_t scroll_scale = selected_stage == DEMO_STAGE_LOWER_RASTER_SCROLLER ? (size_t)DEMO_STAGE_FOURTEEN_SCROLL_SCALE : DEMO_SCROLL_SCALE;
6. Executescroll_text_width = strlen(scroll_text) * PET2001_FONT_GLYPH_WIDTH * scroll_scale;
7. Executescroll_text_x = scroll_speed_pixels_per_second >= 0.0f ? (float)LCD_WIDTH : -(float)scroll_text_width;
8. Decisionswitch_logo && !DEMO_LOCK_ICON_TO_PRIMARY
   True

   1. 1. ExecuteadvanceIconSlot();

   False

   Continue after this decision.

9. Executescroll_text_effect_elapsed_ms = 0U;

static void selectScrollMessage(bool switch_logo)
{
    size_t next = (size_t)esp_random() % DEMO_SCROLL_MESSAGE_COUNT;
    if (scroll_message_index < DEMO_SCROLL_MESSAGE_COUNT) {
        next = (size_t)esp_random() % (DEMO_SCROLL_MESSAGE_COUNT - 1U);
        if (next >= scroll_message_index) ++next;
    }
    scroll_message_index = next;
    scroll_text = demo_scroll_messages[scroll_message_index];
    const size_t scroll_scale = selected_stage == DEMO_STAGE_LOWER_RASTER_SCROLLER
        ? (size_t)DEMO_STAGE_FOURTEEN_SCROLL_SCALE
        : DEMO_SCROLL_SCALE;
    scroll_text_width = strlen(scroll_text) * PET2001_FONT_GLYPH_WIDTH * scroll_scale;
    scroll_text_x = scroll_speed_pixels_per_second >= 0.0f
        ? (float)LCD_WIDTH : -(float)scroll_text_width;
    if (switch_logo && !DEMO_LOCK_ICON_TO_PRIMARY) {
        advanceIconSlot();
    }
    scroll_text_effect_elapsed_ms = 0U;
}

static bool dimFlamesBehindTickerGlyph(uint16_t *frame, int centre_x, int centre_y,
                                       float glyph_scale)

1. Decisionselected_effect != DEMO_EFFECT_RADIAL_FLAME || glyph_scale <= 0.0f
   True

   1. Exit this functionreturn false;

   False

   Continue after this decision.

2. Executeconst int half_width = (int)ceilf((float)PET2001_FONT_GLYPH_WIDTH * glyph_scale * 0.5f);
3. Executeconst int half_height = (int)ceilf((float)PET2001_FONT_GLYPH_HEIGHT * glyph_scale * 0.5f);
4. Executebool touches_flame = false;
5. FOR loopint y = centre_y - half_height; y <= centre_y + half_height; ++y

   Repeat body while the loop condition permits; then continue below.

   1. 1. Decisiony < 0 || y >= LCD_HEIGHT
         True

         1. Next loop iterationcontinue;

         False

         Continue after this decision.

      2. FOR loopint x = centre_x - half_width; x <= centre_x + half_width; ++x

         Repeat body while the loop condition permits; then continue below.

         1. 1. Decisionx < 0 || x >= LCD_WIDTH
               True

               1. Next loop iterationcontinue;

               False

               Continue after this decision.

            2. Executeuint16_t *pixel = &frame[(size_t)y * LCD_WIDTH + (size_t)x];
            3. FOR loopsize_t colour = 0U; colour < sizeof(demo_ring_colours) / sizeof(demo_ring_colours[0]); ++colour

               Repeat body while the loop condition permits; then continue below.

               1. 1. Decision*pixel != demo_ring_colours[colour]
                     True

                     1. Next loop iterationcontinue;

                     False

                     Continue after this decision.

                  2. Execute*pixel = colour == 0U ? COLOR_BLACK : demo_ring_colours[colour - 1U];
                  3. Executetouches_flame = true;
                  4. Exit enclosing loop or switchbreak;
6. Exit this functionreturn touches_flame;

static bool dimFlamesBehindTickerGlyph(uint16_t *frame, int centre_x, int centre_y,
                                       float glyph_scale)
{
    if (selected_effect != DEMO_EFFECT_RADIAL_FLAME || glyph_scale <= 0.0f) return false;
    const int half_width = (int)ceilf((float)PET2001_FONT_GLYPH_WIDTH * glyph_scale * 0.5f);
    const int half_height = (int)ceilf((float)PET2001_FONT_GLYPH_HEIGHT * glyph_scale * 0.5f);
    bool touches_flame = false;
    for (int y = centre_y - half_height; y <= centre_y + half_height; ++y) {
        if (y < 0 || y >= LCD_HEIGHT) continue;
        for (int x = centre_x - half_width; x <= centre_x + half_width; ++x) {
            if (x < 0 || x >= LCD_WIDTH) continue;
            uint16_t *pixel = &frame[(size_t)y * LCD_WIDTH + (size_t)x];
            for (size_t colour = 0U; colour < sizeof(demo_ring_colours) /
                                              sizeof(demo_ring_colours[0]); ++colour) {
                if (*pixel != demo_ring_colours[colour]) continue;
                // Retain the moving fire shape but step it down for white PET text.
                *pixel = colour == 0U ? COLOR_BLACK : demo_ring_colours[colour - 1U];
                touches_flame = true;
                break;
            }
        }
    }
    return touches_flame;
}

static uint16_t demoScrollRainbowColour(unsigned glyph_index)

1. Executeconst unsigned colour_count = sizeof(demo_scroll_rainbow_colours) / sizeof(demo_scroll_rainbow_colours[0]);
2. Executeconst unsigned time_step = scroll_text_effect_elapsed_ms / DEMO_SCROLL_RAINBOW_MS_PER_COLOUR;
3. Executeconst unsigned glyph_step = glyph_index / DEMO_SCROLL_RAINBOW_GLYPHS_PER_COLOUR;
4. Exit this functionreturn demo_scroll_rainbow_colours[(glyph_step + time_step) % colour_count];

static uint16_t demoScrollRainbowColour(unsigned glyph_index)
{
    const unsigned colour_count = sizeof(demo_scroll_rainbow_colours) /
                                 sizeof(demo_scroll_rainbow_colours[0]);
    const unsigned time_step = scroll_text_effect_elapsed_ms /
                               DEMO_SCROLL_RAINBOW_MS_PER_COLOUR;
    const unsigned glyph_step = glyph_index / DEMO_SCROLL_RAINBOW_GLYPHS_PER_COLOUR;
    return demo_scroll_rainbow_colours[(glyph_step + time_step) % colour_count];
}

static float stageFourMagnifierScale(int glyph_centre_x)

1. Executeconst float distance = fabsf((float)glyph_centre_x - (float)DEMO_STAGE_FOUR_MAGNIFIER_CENTRE_X);
2. Executefloat influence = 1.0f - distance / DEMO_STAGE_FOUR_MAGNIFIER_RADIUS;
3. Decisioninfluence < 0.0f
   True

   1. Executeinfluence = 0.0f;

   False

   Continue after this decision.

4. Executeinfluence *= influence;
5. Exit this functionreturn (float)DEMO_SCROLL_SCALE + (DEMO_STAGE_FOUR_MAGNIFIER_MAX_SCALE - (float)DEMO_SCROLL_SCALE) * influence;

static float stageFourMagnifierScale(int glyph_centre_x)
{
    const float distance = fabsf((float)glyph_centre_x -
                                 (float)DEMO_STAGE_FOUR_MAGNIFIER_CENTRE_X);
    float influence = 1.0f - distance / DEMO_STAGE_FOUR_MAGNIFIER_RADIUS;
    if (influence < 0.0f) influence = 0.0f;
    // Squaring concentrates the largest letters around the exact screen centre.
    influence *= influence;
    return (float)DEMO_SCROLL_SCALE +
           (DEMO_STAGE_FOUR_MAGNIFIER_MAX_SCALE - (float)DEMO_SCROLL_SCALE) * influence;
}

static float stageFourMagnifierPosition(int glyph_centre_x)

1. Executeconst float centre = (float)DEMO_STAGE_FOUR_MAGNIFIER_CENTRE_X;
2. Executeconst float offset = (float)glyph_centre_x - centre;
3. Executeconst float distance = fabsf(offset);
4. Decisiondistance >= DEMO_STAGE_FOUR_MAGNIFIER_RADIUS
   True

   1. Exit this functionreturn (float)glyph_centre_x;

   False

   Continue after this decision.

5. Executeconst float influence = 1.0f - distance / DEMO_STAGE_FOUR_MAGNIFIER_RADIUS;
6. Exit this functionreturn centre + offset * (1.0f + DEMO_STAGE_FOUR_MAGNIFIER_SPACING_STRENGTH * influence * influence);

static float stageFourMagnifierPosition(int glyph_centre_x)
{
    const float centre = (float)DEMO_STAGE_FOUR_MAGNIFIER_CENTRE_X;
    const float offset = (float)glyph_centre_x - centre;
    const float distance = fabsf(offset);
    if (distance >= DEMO_STAGE_FOUR_MAGNIFIER_RADIUS) return (float)glyph_centre_x;
    const float influence = 1.0f - distance / DEMO_STAGE_FOUR_MAGNIFIER_RADIUS;
    // Spread the glyph centres with the lens so expanded neighbouring letters do not overlap.
    return centre + offset * (1.0f + DEMO_STAGE_FOUR_MAGNIFIER_SPACING_STRENGTH *
                              influence * influence);
}

static float stageFiveMagnifierScale(int glyph_centre_x)

1. Executefloat influence = fabsf((float)glyph_centre_x - (float)DEMO_STAGE_FOUR_MAGNIFIER_CENTRE_X) / DEMO_STAGE_FOUR_MAGNIFIER_RADIUS;
2. Decisioninfluence > 1.0f
   True

   1. Executeinfluence = 1.0f;

   False

   Continue after this decision.

3. Exit this functionreturn (float)DEMO_SCROLL_SCALE + (DEMO_STAGE_FOUR_MAGNIFIER_MAX_SCALE - (float)DEMO_SCROLL_SCALE) * influence * influence;

static float stageFiveMagnifierScale(int glyph_centre_x)
{
    float influence = fabsf((float)glyph_centre_x -
                            (float)DEMO_STAGE_FOUR_MAGNIFIER_CENTRE_X) /
                      DEMO_STAGE_FOUR_MAGNIFIER_RADIUS;
    if (influence > 1.0f) influence = 1.0f;
    // Inverse lens: smallest at centre, largest at the screen edges and beyond.
    return (float)DEMO_SCROLL_SCALE +
           (DEMO_STAGE_FOUR_MAGNIFIER_MAX_SCALE - (float)DEMO_SCROLL_SCALE) *
           influence * influence;
}

static float stageFiveMagnifierPosition(int glyph_centre_x)

1. Executeconst float centre = (float)DEMO_STAGE_FOUR_MAGNIFIER_CENTRE_X;
2. Executeconst float offset = (float)glyph_centre_x - centre;
3. Executefloat influence = fabsf(offset) / DEMO_STAGE_FOUR_MAGNIFIER_RADIUS;
4. Decisioninfluence > 1.0f
   True

   1. Executeinfluence = 1.0f;

   False

   Continue after this decision.

5. Exit this functionreturn centre + offset * (1.0f + DEMO_STAGE_FOUR_MAGNIFIER_SPACING_STRENGTH * influence * influence);

static float stageFiveMagnifierPosition(int glyph_centre_x)
{
    const float centre = (float)DEMO_STAGE_FOUR_MAGNIFIER_CENTRE_X;
    const float offset = (float)glyph_centre_x - centre;
    float influence = fabsf(offset) / DEMO_STAGE_FOUR_MAGNIFIER_RADIUS;
    if (influence > 1.0f) influence = 1.0f;
    // Keep the maximum expansion beyond both screen edges so large letters enter
    // and leave cleanly instead of snapping back to their ordinary spacing.
    return centre + offset * (1.0f + DEMO_STAGE_FOUR_MAGNIFIER_SPACING_STRENGTH *
                              influence * influence);
}

static void drawScrollText(uint16_t *frame)

Calls into this documentation:

1. Decisionscroll_text == NULL
   True

   1. Exit this functionreturn;

   False

   Continue after this decision.

2. Executeconst unsigned text_length = (unsigned)strlen(scroll_text);
3. Executeconst int base_x = (int)lroundf(scroll_text_x);
4. Executeconst bool magnifier_active = selected_stage == DEMO_STAGE_SCROLLER || selected_stage == DEMO_STAGE_REVERSE_SCROLLER;
5. Executeconst bool raster_band_scroller = selected_stage == DEMO_STAGE_RASTER_BANDS || selected_stage == DEMO_STAGE_LOWER_RASTER_SCROLLER || selected_stage == DEMO_STAGE_BATTLE_ZONE_RASTER;
6. Executeconst bool lower_raster_band_scroller = selected_stage == DEMO_STAGE_LOWER_RASTER_SCROLLER;
7. Executeconst bool battle_zone_raster_scroller = selected_stage == DEMO_STAGE_BATTLE_ZONE_RASTER;
8. Executeconst int advance = PET2001_FONT_GLYPH_WIDTH * (lower_raster_band_scroller ? (int)DEMO_STAGE_FOURTEEN_SCROLL_SCALE : DEMO_SCROLL_SCALE);
9. Executeconst uint32_t text_wave_elapsed_ms = raster_band_scroller ? raster_band_effect_elapsed_ms : scroll_text_effect_elapsed_ms;
10. Executeconst bool reverse_magnifier = selected_stage == DEMO_STAGE_REVERSE_SCROLLER;
11. FOR loopunsigned index = 0U; index < text_length; ++index

    Repeat body while the loop condition permits; then continue below.

    1. 1. Executeconst int unscaled_centre_x = base_x + (int)index * advance + advance / 2;
       2. Executeconst int centre_x = !magnifier_active ? unscaled_centre_x : (int)lroundf(reverse_magnifier ? stageFiveMagnifierPosition(unscaled_centre_x) : stageFourMagnifierPosition(unscaled_centre_x));
       3. Executeconst float glyph_scale = !magnifier_active ? (lower_raster_band_scroller ? DEMO_STAGE_FOURTEEN_SCROLL_SCALE : (float)DEMO_SCROLL_SCALE) : (reverse_magnifier ? stageFiveMagnifierScale(unscaled_centre_x) : stageFourMagnifierScale(unscaled_centre_x));
       4. Executeconst int glyph_margin = (int)ceilf((float)PET2001_FONT_GLYPH_WIDTH * glyph_scale);
       5. Executeconst int centre_y = magnifier_active ? DEMO_STAGE_FOUR_MAGNIFIER_CENTRE_Y : (lower_raster_band_scroller ? DEMO_STAGE_FOURTEEN_SCROLL_CENTRE_Y : (battle_zone_raster_scroller ? DEMO_STAGE_FIFTEEN_SCROLL_CENTRE_Y : (raster_band_scroller ? DEMO_STAGE_ELEVEN_SCROLL_CENTRE_Y : DEMO_SCROLL_Y))) + graphics_text_effect_wave_offset(text_wave_elapsed_ms, index, lower_raster_band_scroller ? DEMO_STAGE_FOURTEEN_SCROLL_WAVE_AMPLITUDE : (battle_zone_raster_scroller ? DEMO_STAGE_FIFTEEN_SCROLL_WAVE_AMPLITUDE : (raster_band_scroller ? DEMO_STAGE_ELEVEN_SCROLL_WAVE_AMPLITUDE : DEMO_SCROLL_EFFECT_WAVE_AMPLITUDE))) + (raster_band_scroller ? 0 : advance / 2);
       6. Decisioncentre_x + glyph_margin < 0 || centre_x - glyph_margin >= LCD_WIDTH || centre_y + glyph_margin < 0 || centre_y - glyph_margin >= LCD_HEIGHT
          True

          1. 1. Next loop iterationcontinue;

          False

          Continue after this decision.

       7. Executeconst uint16_t glyph_color = dimFlamesBehindTickerGlyph(frame, centre_x, centre_y, glyph_scale) ? COLOR_WHITE : demoScrollRainbowColour(index);
       8. ExecutedrawPet2001AsciiCharTransformed(frame, centre_x, centre_y, scroll_text[index], glyph_scale, 0.0f, glyph_color);

static void drawScrollText(uint16_t *frame)
{
    if (scroll_text == NULL) return;

    const unsigned text_length = (unsigned)strlen(scroll_text);
    const int base_x = (int)lroundf(scroll_text_x);
    const bool magnifier_active = selected_stage == DEMO_STAGE_SCROLLER ||
                                  selected_stage == DEMO_STAGE_REVERSE_SCROLLER;
    const bool raster_band_scroller = selected_stage == DEMO_STAGE_RASTER_BANDS ||
                                      selected_stage == DEMO_STAGE_LOWER_RASTER_SCROLLER ||
                                      selected_stage == DEMO_STAGE_BATTLE_ZONE_RASTER;
    const bool lower_raster_band_scroller =
        selected_stage == DEMO_STAGE_LOWER_RASTER_SCROLLER;
    const bool battle_zone_raster_scroller =
        selected_stage == DEMO_STAGE_BATTLE_ZONE_RASTER;
    const int advance = PET2001_FONT_GLYPH_WIDTH *
        (lower_raster_band_scroller ? (int)DEMO_STAGE_FOURTEEN_SCROLL_SCALE :
                                     DEMO_SCROLL_SCALE);
    const uint32_t text_wave_elapsed_ms = raster_band_scroller ?
        raster_band_effect_elapsed_ms : scroll_text_effect_elapsed_ms;
    const bool reverse_magnifier = selected_stage == DEMO_STAGE_REVERSE_SCROLLER;
    for (unsigned index = 0U; index < text_length; ++index) {
        const int unscaled_centre_x = base_x + (int)index * advance + advance / 2;
        const int centre_x = !magnifier_active ? unscaled_centre_x :
            (int)lroundf(reverse_magnifier ? stageFiveMagnifierPosition(unscaled_centre_x) :
                                                 stageFourMagnifierPosition(unscaled_centre_x));
        const float glyph_scale = !magnifier_active ?
            (lower_raster_band_scroller ? DEMO_STAGE_FOURTEEN_SCROLL_SCALE :
                                          (float)DEMO_SCROLL_SCALE) :
            (reverse_magnifier ? stageFiveMagnifierScale(unscaled_centre_x) :
                                 stageFourMagnifierScale(unscaled_centre_x));
        const int glyph_margin = (int)ceilf((float)PET2001_FONT_GLYPH_WIDTH * glyph_scale);
        const int centre_y = magnifier_active ? DEMO_STAGE_FOUR_MAGNIFIER_CENTRE_Y :
            (lower_raster_band_scroller ? DEMO_STAGE_FOURTEEN_SCROLL_CENTRE_Y :
             (battle_zone_raster_scroller ? DEMO_STAGE_FIFTEEN_SCROLL_CENTRE_Y :
              (raster_band_scroller ? DEMO_STAGE_ELEVEN_SCROLL_CENTRE_Y : DEMO_SCROLL_Y))) +
            graphics_text_effect_wave_offset(text_wave_elapsed_ms, index,
                lower_raster_band_scroller ? DEMO_STAGE_FOURTEEN_SCROLL_WAVE_AMPLITUDE :
                (battle_zone_raster_scroller ? DEMO_STAGE_FIFTEEN_SCROLL_WAVE_AMPLITUDE :
                 (raster_band_scroller ? DEMO_STAGE_ELEVEN_SCROLL_WAVE_AMPLITUDE :
                                       DEMO_SCROLL_EFFECT_WAVE_AMPLITUDE))) +
            (raster_band_scroller ? 0 : advance / 2);
        // Long messages contain many off-screen glyphs; skip their transform work.
        if (centre_x + glyph_margin < 0 || centre_x - glyph_margin >= LCD_WIDTH ||
            centre_y + glyph_margin < 0 || centre_y - glyph_margin >= LCD_HEIGHT) {
            continue;
        }
        const uint16_t glyph_color = dimFlamesBehindTickerGlyph(frame, centre_x, centre_y,
                                                                 glyph_scale)
            ? COLOR_WHITE : demoScrollRainbowColour(index);
        drawPet2001AsciiCharTransformed(frame, centre_x, centre_y, scroll_text[index],
                                         glyph_scale, 0.0f, glyph_color);
    }
}

static graphics_point_t projectPoint(float source_x, float source_y, float depth,
                                     const demo_rotation_t *rotation)

1. Executeconst float scaled_x = source_x * DEMO_FACE_SCALE;
2. Executeconst float scaled_y = source_y * DEMO_FACE_SCALE;
3. Executeconst float pitched_y = scaled_y * rotation->pitch_cosine - depth * rotation->pitch_sine;
4. Executeconst float pitched_z = scaled_y * rotation->pitch_sine + depth * rotation->pitch_cosine;
5. Executeconst float yawed_x = scaled_x * rotation->yaw_cosine + pitched_z * rotation->yaw_sine;
6. Executeconst float yawed_z = -scaled_x * rotation->yaw_sine + pitched_z * rotation->yaw_cosine;
7. Executeconst float rotated_x = yawed_x * rotation->roll_cosine - pitched_y * rotation->roll_sine;
8. Executeconst float rotated_y = yawed_x * rotation->roll_sine + pitched_y * rotation->roll_cosine;
9. Executeconst float perspective = DEMO_CAMERA_DISTANCE / (DEMO_CAMERA_DISTANCE + yawed_z);
10. Executeconst graphics_point_t result = { .x = DEMO_CENTRE_X + (int)lroundf(rotated_x * perspective), .y = DEMO_CENTRE_Y + (int)lroundf(rotated_y * perspective), };
11. Exit this functionreturn result;

static graphics_point_t projectPoint(float source_x, float source_y, float depth,
                                     const demo_rotation_t *rotation)
{
    const float scaled_x = source_x * DEMO_FACE_SCALE;
    const float scaled_y = source_y * DEMO_FACE_SCALE;
    const float pitched_y = scaled_y * rotation->pitch_cosine -
                            depth * rotation->pitch_sine;
    const float pitched_z = scaled_y * rotation->pitch_sine +
                            depth * rotation->pitch_cosine;
    const float yawed_x = scaled_x * rotation->yaw_cosine +
                          pitched_z * rotation->yaw_sine;
    const float yawed_z = -scaled_x * rotation->yaw_sine +
                          pitched_z * rotation->yaw_cosine;
    const float rotated_x = yawed_x * rotation->roll_cosine -
                            pitched_y * rotation->roll_sine;
    const float rotated_y = yawed_x * rotation->roll_sine +
                            pitched_y * rotation->roll_cosine;
    const float perspective = DEMO_CAMERA_DISTANCE / (DEMO_CAMERA_DISTANCE + yawed_z);
    const graphics_point_t result = {
        .x = DEMO_CENTRE_X + (int)lroundf(rotated_x * perspective),
        .y = DEMO_CENTRE_Y + (int)lroundf(rotated_y * perspective),
    };
    return result;
}

static float demoRingInnerRadius(void)

Calls into this documentation:

1. Executeconst float pitch = pitch_degrees * DEMO_PI / 180.0f;
2. Executeconst float yaw = yaw_degrees * DEMO_PI / 180.0f;
3. Executeconst float roll = roll_degrees * DEMO_PI / 180.0f;
4. Executeconst demo_rotation_t rotation = { cosf(pitch), sinf(pitch), cosf(yaw), sinf(yaw), cosf(roll), sinf(roll), };
5. Executefloat outer_radius = 0.0f;
6. FOR loopunsigned sample = 0U; sample < 16U; ++sample

   Repeat body while the loop condition permits; then continue below.

   1. 1. Executeconst float angle = (float)sample * DEMO_PI * 2.0f / 16.0f;
      2. FOR loopunsigned depth_index = 0U; depth_index < 2U; ++depth_index

         Repeat body while the loop condition permits; then continue below.

         1. 1. Executeconst graphics_point_t point = projectPoint(cosf(angle) * 30.0f, sinf(angle) * 30.0f, depth_index == 0U ? 0.0f : DEMO_EXTRUSION_DEPTH, &rotation);
            2. Executeconst float dx = (float)point.x - DEMO_CENTRE_X;
            3. Executeconst float dy = (float)point.y - DEMO_CENTRE_Y;
            4. Executeconst float radius = sqrtf(dx * dx + dy * dy);
            5. Decisionradius > outer_radius
               True

               1. Executeouter_radius = radius;

               False

               Continue after this decision.

7. Exit this functionreturn outer_radius + DEMO_RING_ICON_GAP;

static float demoRingInnerRadius(void)
{
    const float pitch = pitch_degrees * DEMO_PI / 180.0f;
    const float yaw = yaw_degrees * DEMO_PI / 180.0f;
    const float roll = roll_degrees * DEMO_PI / 180.0f;
    const demo_rotation_t rotation = {
        cosf(pitch), sinf(pitch), cosf(yaw), sinf(yaw), cosf(roll), sinf(roll),
    };
    float outer_radius = 0.0f;
    for (unsigned sample = 0U; sample < 16U; ++sample) {
        const float angle = (float)sample * DEMO_PI * 2.0f / 16.0f;
        for (unsigned depth_index = 0U; depth_index < 2U; ++depth_index) {
            const graphics_point_t point = projectPoint(cosf(angle) * 30.0f,
                sinf(angle) * 30.0f, depth_index == 0U ? 0.0f : DEMO_EXTRUSION_DEPTH,
                &rotation);
            const float dx = (float)point.x - DEMO_CENTRE_X;
            const float dy = (float)point.y - DEMO_CENTRE_Y;
            const float radius = sqrtf(dx * dx + dy * dy);
            if (radius > outer_radius) outer_radius = radius;
        }
    }
    return outer_radius + DEMO_RING_ICON_GAP;
}

static void drawLogoSlice(uint16_t *frame, const uint8_t *bitmap, float depth,
                          const demo_rotation_t *rotation, uint16_t color)

Calls into this documentation:

1. FOR loopunsigned y = 0U; y < DEMO_LOGO_HEIGHT; ++y

   Repeat body while the loop condition permits; then continue below.

   1. 1. Executeunsigned run_start = 0U;
      2. WHILE looprun_start < DEMO_LOGO_WIDTH

         Repeat body while the loop condition permits; then continue below.

         1. 1. WHILE looprun_start < DEMO_LOGO_WIDTH && !bitmapPixelSet(bitmap, run_start, y)

               Repeat body while the loop condition permits; then continue below.

               1. 1. Execute++run_start;
            2. Decisionrun_start == DEMO_LOGO_WIDTH
               True

               1. Exit enclosing loop or switchbreak;

               False

               Continue after this decision.

            3. Executeunsigned run_end = run_start + 1U;
            4. WHILE looprun_end < DEMO_LOGO_WIDTH && bitmapPixelSet(bitmap, run_end, y)

               Repeat body while the loop condition permits; then continue below.

               1. 1. Execute++run_end;
            5. Executeconst float left = (float)run_start - (float)DEMO_LOGO_WIDTH * 0.5f;
            6. Executeconst float right = (float)run_end - (float)DEMO_LOGO_WIDTH * 0.5f;
            7. Executeconst float top = (float)y - (float)DEMO_LOGO_HEIGHT * 0.5f;
            8. Executeconst graphics_point_t run[4] = { projectPoint(left, top, depth, rotation), projectPoint(right, top, depth, rotation), projectPoint(right, top + 1.0f, depth, rotation), projectPoint(left, top + 1.0f, depth, rotation), };
            9. Executefill_convex_polygon(frame, run, 4U, color);
            10. Executerun_start = run_end;

static void drawLogoSlice(uint16_t *frame, const uint8_t *bitmap, float depth,
                          const demo_rotation_t *rotation, uint16_t color)
{
    for (unsigned y = 0U; y < DEMO_LOGO_HEIGHT; ++y) {
        unsigned run_start = 0U;
        while (run_start < DEMO_LOGO_WIDTH) {
            while (run_start < DEMO_LOGO_WIDTH && !bitmapPixelSet(bitmap, run_start, y)) {
                ++run_start;
            }
            if (run_start == DEMO_LOGO_WIDTH) break;
            unsigned run_end = run_start + 1U;
            while (run_end < DEMO_LOGO_WIDTH && bitmapPixelSet(bitmap, run_end, y)) {
                ++run_end;
            }

            const float left = (float)run_start - (float)DEMO_LOGO_WIDTH * 0.5f;
            const float right = (float)run_end - (float)DEMO_LOGO_WIDTH * 0.5f;
            const float top = (float)y - (float)DEMO_LOGO_HEIGHT * 0.5f;
            const graphics_point_t run[4] = {
                projectPoint(left, top, depth, rotation),
                projectPoint(right, top, depth, rotation),
                projectPoint(right, top + 1.0f, depth, rotation),
                projectPoint(left, top + 1.0f, depth, rotation),
            };
            fill_convex_polygon(frame, run, 4U, color);
            run_start = run_end;
        }
    }
}

static graphics_point_t projectApproachPoint(float source_x, float source_y, float depth,
                                             const demo_rotation_t *rotation, float scale,
                                             int centre_x, int centre_y)

1. Executeconst float scaled_x = source_x * scale;
2. Executeconst float scaled_y = source_y * scale;
3. Executeconst float scaled_depth = depth * scale;
4. Executeconst float pitched_y = scaled_y * rotation->pitch_cosine - scaled_depth * rotation->pitch_sine;
5. Executeconst float pitched_z = scaled_y * rotation->pitch_sine + scaled_depth * rotation->pitch_cosine;
6. Executeconst float yawed_x = scaled_x * rotation->yaw_cosine + pitched_z * rotation->yaw_sine;
7. Executeconst float yawed_z = -scaled_x * rotation->yaw_sine + pitched_z * rotation->yaw_cosine;
8. Executeconst float rotated_x = yawed_x * rotation->roll_cosine - pitched_y * rotation->roll_sine;
9. Executeconst float rotated_y = yawed_x * rotation->roll_sine + pitched_y * rotation->roll_cosine;
10. Executeconst float perspective = DEMO_CAMERA_DISTANCE / (DEMO_CAMERA_DISTANCE + yawed_z);
11. Executeconst graphics_point_t result = { .x = centre_x + (int)lroundf(rotated_x * perspective), .y = centre_y + (int)lroundf(rotated_y * perspective), };
12. Exit this functionreturn result;

static graphics_point_t projectApproachPoint(float source_x, float source_y, float depth,
                                             const demo_rotation_t *rotation, float scale,
                                             int centre_x, int centre_y)
{
    const float scaled_x = source_x * scale;
    const float scaled_y = source_y * scale;
    const float scaled_depth = depth * scale;
    const float pitched_y = scaled_y * rotation->pitch_cosine -
                            scaled_depth * rotation->pitch_sine;
    const float pitched_z = scaled_y * rotation->pitch_sine +
                            scaled_depth * rotation->pitch_cosine;
    const float yawed_x = scaled_x * rotation->yaw_cosine +
                          pitched_z * rotation->yaw_sine;
    const float yawed_z = -scaled_x * rotation->yaw_sine +
                          pitched_z * rotation->yaw_cosine;
    const float rotated_x = yawed_x * rotation->roll_cosine -
                            pitched_y * rotation->roll_sine;
    const float rotated_y = yawed_x * rotation->roll_sine +
                            pitched_y * rotation->roll_cosine;
    const float perspective = DEMO_CAMERA_DISTANCE / (DEMO_CAMERA_DISTANCE + yawed_z);
    const graphics_point_t result = {
        .x = centre_x + (int)lroundf(rotated_x * perspective),
        .y = centre_y + (int)lroundf(rotated_y * perspective),
    };
    return result;
}

static void drawApproachLogoSlice(uint16_t *frame, const uint8_t *bitmap, float depth,
                                  const demo_rotation_t *rotation, float scale,
                                  int centre_x, int centre_y, uint16_t color)

Calls into this documentation:

1. FOR loopunsigned y = 0U; y < DEMO_LOGO_HEIGHT; ++y

   Repeat body while the loop condition permits; then continue below.

   1. 1. Executeunsigned run_start = 0U;
      2. WHILE looprun_start < DEMO_LOGO_WIDTH

         Repeat body while the loop condition permits; then continue below.

         1. 1. WHILE looprun_start < DEMO_LOGO_WIDTH && !bitmapPixelSet(bitmap, run_start, y)

               Repeat body while the loop condition permits; then continue below.

               1. 1. Execute++run_start;
            2. Decisionrun_start == DEMO_LOGO_WIDTH
               True

               1. Exit enclosing loop or switchbreak;

               False

               Continue after this decision.

            3. Executeunsigned run_end = run_start + 1U;
            4. WHILE looprun_end < DEMO_LOGO_WIDTH && bitmapPixelSet(bitmap, run_end, y)

               Repeat body while the loop condition permits; then continue below.

               1. 1. Execute++run_end;
            5. Executeconst float left = (float)run_start - (float)DEMO_LOGO_WIDTH * 0.5f;
            6. Executeconst float right = (float)run_end - (float)DEMO_LOGO_WIDTH * 0.5f;
            7. Executeconst float top = (float)y - (float)DEMO_LOGO_HEIGHT * 0.5f;
            8. Executeconst graphics_point_t run[4] = { projectApproachPoint(left, top, depth, rotation, scale, centre_x, centre_y), projectApproachPoint(right, top, depth, rotation, scale, centre_x, centre_y), projectApproachPoint(right, top + 1.0f, depth, rotation, scale, centre_x, centre_y), projectApproachPoint(left, top + 1.0f, depth, rotation, scale, centre_x, centre_y), };
            9. Executefill_convex_polygon(frame, run, 4U, color);
            10. Executerun_start = run_end;

static void drawApproachLogoSlice(uint16_t *frame, const uint8_t *bitmap, float depth,
                                  const demo_rotation_t *rotation, float scale,
                                  int centre_x, int centre_y, uint16_t color)
{
    for (unsigned y = 0U; y < DEMO_LOGO_HEIGHT; ++y) {
        unsigned run_start = 0U;
        while (run_start < DEMO_LOGO_WIDTH) {
            while (run_start < DEMO_LOGO_WIDTH && !bitmapPixelSet(bitmap, run_start, y)) {
                ++run_start;
            }
            if (run_start == DEMO_LOGO_WIDTH) break;
            unsigned run_end = run_start + 1U;
            while (run_end < DEMO_LOGO_WIDTH && bitmapPixelSet(bitmap, run_end, y)) {
                ++run_end;
            }
            const float left = (float)run_start - (float)DEMO_LOGO_WIDTH * 0.5f;
            const float right = (float)run_end - (float)DEMO_LOGO_WIDTH * 0.5f;
            const float top = (float)y - (float)DEMO_LOGO_HEIGHT * 0.5f;
            const graphics_point_t run[4] = {
                projectApproachPoint(left, top, depth, rotation, scale, centre_x, centre_y),
                projectApproachPoint(right, top, depth, rotation, scale, centre_x, centre_y),
                projectApproachPoint(right, top + 1.0f, depth, rotation, scale, centre_x, centre_y),
                projectApproachPoint(left, top + 1.0f, depth, rotation, scale, centre_x, centre_y),
            };
            fill_convex_polygon(frame, run, 4U, color);
            run_start = run_end;
        }
    }
}

static void beginDemoSegments(uint32_t now_ms)

1. Executedemo_instructions_active = false;
2. Executedemo_last_interaction_at = now_ms;
3. Executestage_one_next_effect_change_at = now_ms + DEMO_STAGE_ONE_EFFECT_CHANGE_MS;

static void beginDemoSegments(uint32_t now_ms)
{
    demo_instructions_active = false;
    demo_last_interaction_at = now_ms;
    stage_one_next_effect_change_at = now_ms + DEMO_STAGE_ONE_EFFECT_CHANGE_MS;
}

void startDemo(uint32_t now_ms)

Calls into this documentation:

1. ExecutedemoStageSlideshowLensStop();
2. ExecutedemoStageGameOfLifeStop();
3. ExecutereleaseStageFifteenGroundSource();
4. ExecutedemoStagePlasmaInitialize();
5. Executepitch_degrees = 0.0f;
6. Executeyaw_degrees = 0.0f;
7. Executeroll_degrees = 0.0f;
8. Executeactive_icon_slot = 0U;
9. Executeactive_logo_bitmap = demo_icon_slots[active_icon_slot];
10. ExecuteselectDemoIconColourScheme();
11. Executescroll_speed_pixels_per_second = DEMO_SCROLL_INITIAL_PIXELS_PER_SECOND;
12. Executeselected_stage = DEMO_STAGE_ICON;
13. Executestage_two_distance = DEMO_STAGE_TWO_START_DISTANCE;
14. Executestage_two_auto_approaching = true;
15. Executestage_three_next_icon_change_at = 0U;
16. Executestage_three_icon_slot = 0U;
17. Executestage_three_icon_bitmap = NULL;
18. Executestage_six_next_change_at = 0U;
19. Executestage_six_current_mesh = NULL;
20. Executestage_six_colour_scheme_index = DEMO_SOLID_COLOUR_SCHEME_COUNT;
21. Executeraster_band_palette_index = DEMO_RASTER_METALLIC_PALETTE_INDEX;
22. Executedemo_paused_total_ms = 0U;
23. Executedemo_selector_active = false;
24. Executedemo_selector_clear_new_stage = false;
25. Executedemo_selector_item = 0U;
26. Executedemo_selector_joystick_direction = 0;
27. Executedemo_selector_repeating = false;
28. Executedemo_instructions_active = true;
29. Executedemo_instructions_started_at = now_ms;
30. Executestarfield_initialize(&demo_instruction_starfield, 60U, 0, 0, LCD_WIDTH, LCD_HEIGHT, STARFIELD_COLOUR);
31. Executestage_one_next_effect_change_at = 0U;
32. Executedemo_last_interaction_at = now_ms;
33. ExecutescreenTransitionReset(&stage_transition);
34. Executestage_change_requested = false;
35. Executestage_zoom_in_requested = false;
36. Executestage_zooming_in = false;
37. Executestage_scroll_in_requested = false;
38. Executestage_reveal_requested = false;
39. Executeselected_stage_transition = DEMO_STAGE_TRANSITION_SHRINK_ZOOM;
40. Executestage_scroll_out_direction = SCREEN_TRANSITION_SCROLL_LEFT;
41. Executestage_scroll_in_direction = SCREEN_TRANSITION_SCROLL_RIGHT;
42. ExecuteselectScrollMessage(false);
43. Executelast_update_ms = now_ms;
44. Executesparkle_phase = now_ms / DEMO_DOT_SPARKLE_INTERVAL_MS;
45. Executeradial_flame_initialize(&demo_ring_flame, demo_ring_heat, DEMO_RING_SEGMENTS, DEMO_RING_LAYERS, DEMO_RING_LAYER_DEPTH, esp_random());
46. Executeselected_effect = DEMO_EFFECT_RADIAL_FLAME;
47. Executerunning = true;

void startDemo(uint32_t now_ms)
{
    demoStageSlideshowLensStop();
    demoStageGameOfLifeStop();
    releaseStageFifteenGroundSource();
    demoStagePlasmaInitialize();
    pitch_degrees = 0.0f;
    yaw_degrees = 0.0f;
    roll_degrees = 0.0f;
    active_icon_slot = 0U;
    active_logo_bitmap = demo_icon_slots[active_icon_slot];
    selectDemoIconColourScheme();
    scroll_speed_pixels_per_second = DEMO_SCROLL_INITIAL_PIXELS_PER_SECOND;
    selected_stage = DEMO_STAGE_ICON;
    stage_two_distance = DEMO_STAGE_TWO_START_DISTANCE;
    stage_two_auto_approaching = true;
    stage_three_next_icon_change_at = 0U;
    stage_three_icon_slot = 0U;
    stage_three_icon_bitmap = NULL;
    stage_six_next_change_at = 0U;
    stage_six_current_mesh = NULL;
    stage_six_colour_scheme_index = DEMO_SOLID_COLOUR_SCHEME_COUNT;
    raster_band_palette_index = DEMO_RASTER_METALLIC_PALETTE_INDEX;
    demo_paused_total_ms = 0U;
    demo_selector_active = false;
    demo_selector_clear_new_stage = false;
    demo_selector_item = 0U;
    demo_selector_joystick_direction = 0;
    demo_selector_repeating = false;
    demo_instructions_active = true;
    demo_instructions_started_at = now_ms;
    starfield_initialize(&demo_instruction_starfield, 60U, 0, 0, LCD_WIDTH, LCD_HEIGHT,
                          STARFIELD_COLOUR);
    stage_one_next_effect_change_at = 0U;
    demo_last_interaction_at = now_ms;
    screenTransitionReset(&stage_transition);
    stage_change_requested = false;
    stage_zoom_in_requested = false;
    stage_zooming_in = false;
    stage_scroll_in_requested = false;
    stage_reveal_requested = false;
    selected_stage_transition = DEMO_STAGE_TRANSITION_SHRINK_ZOOM;
    stage_scroll_out_direction = SCREEN_TRANSITION_SCROLL_LEFT;
    stage_scroll_in_direction = SCREEN_TRANSITION_SCROLL_RIGHT;
    selectScrollMessage(false);
    last_update_ms = now_ms;
    sparkle_phase = now_ms / DEMO_DOT_SPARKLE_INTERVAL_MS;
    radial_flame_initialize(&demo_ring_flame, demo_ring_heat, DEMO_RING_SEGMENTS,
                            DEMO_RING_LAYERS, DEMO_RING_LAYER_DEPTH, esp_random());
    // Start with the outward fire ring; A/K then selects the remaining effects.
    selected_effect = DEMO_EFFECT_RADIAL_FLAME;
    running = true;
}

void stopDemo(void)

Calls into this documentation:

1. ExecutescreenTransitionDeinitialize(&stage_transition);
2. ExecutedemoStageSlideshowLensStop();
3. ExecutedemoStageGameOfLifeStop();
4. ExecutereleaseStageFifteenGroundSource();
5. Executerunning = false;

void stopDemo(void)
{
    screenTransitionDeinitialize(&stage_transition);
    demoStageSlideshowLensStop();
    demoStageGameOfLifeStop();
    releaseStageFifteenGroundSource();
    running = false;
}

static void moveDemoSelector(int direction, uint32_t now_ms)

1. Executeconst size_t item_count = DEMO_STAGE_COUNT + 1U;
2. Decisiondirection < 0
   True

   1. 1. Executedemo_selector_item = demo_selector_item == 0U ? item_count - 1U : demo_selector_item - 1U;

   False

   1. Decisiondirection > 0
      True

      1. 1. Executedemo_selector_item = (demo_selector_item + 1U) % item_count;

      False

      Continue after this decision.

3. Executedemo_selector_last_move_at = now_ms;

static void moveDemoSelector(int direction, uint32_t now_ms)
{
    const size_t item_count = DEMO_STAGE_COUNT + 1U;
    if (direction < 0) {
        demo_selector_item = demo_selector_item == 0U ? item_count - 1U :
            demo_selector_item - 1U;
    } else if (direction > 0) {
        demo_selector_item = (demo_selector_item + 1U) % item_count;
    }
    demo_selector_last_move_at = now_ms;
}

static void closeDemoSelector(uint32_t now_ms)

Calls into this documentation:

1. Executedemo_paused_total_ms += now_ms - demo_selector_started_at;
2. Executedemo_selector_active = false;
3. Executedemo_selector_joystick_direction = 0;
4. Executedemo_selector_repeating = false;
5. Executelast_update_ms = demoTimeNow(now_ms);

static void closeDemoSelector(uint32_t now_ms)
{
    demo_paused_total_ms += now_ms - demo_selector_started_at;
    demo_selector_active = false;
    demo_selector_joystick_direction = 0;
    demo_selector_repeating = false;
    last_update_ms = demoTimeNow(now_ms);
}

static void openDemoSelector(uint32_t now_ms)

1. Executedemo_selector_active = true;
2. Executedemo_selector_started_at = now_ms;
3. Executedemo_selector_item = 0U;
4. Executedemo_selector_joystick_direction = 0;
5. Executedemo_selector_repeating = false;

static void openDemoSelector(uint32_t now_ms)
{
    demo_selector_active = true;
    demo_selector_started_at = now_ms;
    demo_selector_item = 0U;
    demo_selector_joystick_direction = 0;
    demo_selector_repeating = false;
}

void demoAction(bool next_effect, bool toggle_icon, bool next_stage, bool user_long_pressed,
                bool selector_previous, bool selector_next, uint32_t now_ms)

Calls into this documentation:

1. Decision!running
   True

   1. Exit this functionreturn;

   False

   Continue after this decision.

2. Decisiondemo_selector_active
   True

   1. 1. Decisionselector_previous
         True

         1. 1. ExecutemoveDemoSelector(-1, now_ms);

         False

         1. Decisionselector_next
            True

            1. 1. ExecutemoveDemoSelector(1, now_ms);

            False

            1. Decisionnext_effect
               True

               1. 1. Executeconst size_t selected_item = demo_selector_item;
                  2. ExecutecloseDemoSelector(now_ms);
                  3. Decisionselected_item != 0U
                     True

                     1. 1. ExecutescreenTransitionReset(&stage_transition);
                        2. Executestage_change_requested = false;
                        3. Executestage_zoom_in_requested = false;
                        4. Executestage_zooming_in = false;
                        5. Executestage_scroll_in_requested = false;
                        6. Executestage_reveal_requested = false;
                        7. Executedemo_instructions_active = false;
                        8. ExecuteenterDemoStage((demo_stage_t)(selected_item - 1U), demoTimeNow(now_ms));
                        9. Executedemo_selector_clear_new_stage = true;

                     False

                     Continue after this decision.

               False

               Continue after this decision.

      2. Exit this functionreturn;

   False

   Continue after this decision.

3. Decisionuser_long_pressed
   True

   1. 1. ExecuteopenDemoSelector(now_ms);
      2. Exit this functionreturn;

   False

   Continue after this decision.

4. Executenow_ms = demoTimeNow(now_ms);
5. Decisiondemo_instructions_active
   True

   1. 1. Decisionnext_stage
         True

         1. ExecutebeginDemoSegments(now_ms);

         False

         Continue after this decision.

      2. Exit this functionreturn;

   False

   Continue after this decision.

6. Decisiontoggle_icon
   True

   1. 1. Decisionselected_stage == DEMO_STAGE_GEOMETRIC_SOLID
         True

         1. 1. ExecuteselectStageSixMesh();
            2. Executedemo_last_interaction_at = now_ms;

         False

         1. Decisionselected_stage == DEMO_STAGE_RASTER_BANDS || selected_stage == DEMO_STAGE_LOWER_RASTER_SCROLLER || selected_stage == DEMO_STAGE_BATTLE_ZONE_RASTER
            True

            1. 1. Executeraster_band_palette_index = (raster_band_palette_index + 1U) % DEMO_RASTER_BAND_PALETTE_COUNT;
               2. Executedemo_last_interaction_at = now_ms;

            False

            1. Decisionselected_stage == DEMO_STAGE_PLASMA
               True

               1. 1. ExecutedemoStagePlasmaNextPalette();
                  2. Executedemo_last_interaction_at = now_ms;

               False

               1. Decisionselected_stage == DEMO_STAGE_BEVEL_GEARS
                  True

                  1. 1. Executestage_seventeen_style = (stage_seventeen_style_t) (((unsigned)stage_seventeen_style + 1U) % STAGE_SEVENTEEN_STYLE_COUNT);
                     2. Executedemo_last_interaction_at = now_ms;

                  False

                  1. Decisionselected_stage != DEMO_STAGE_AMIGA_BALL && selected_stage != DEMO_STAGE_SCROLLER && selected_stage != DEMO_STAGE_REVERSE_SCROLLER && selected_stage != DEMO_STAGE_WALLOONS && selected_stage != DEMO_STAGE_KALEIDO && selected_stage != DEMO_STAGE_SPARKLE && selected_stage != DEMO_STAGE_SQUARES && selected_stage != DEMO_STAGE_SLIDESHOW_LENS && !DEMO_LOCK_ICON_TO_PRIMARY
                     True

                     1. 1. ExecuteadvanceIconSlot();
                        2. Executedemo_last_interaction_at = now_ms;

                     False

                     Continue after this decision.

   False

   Continue after this decision.

7. Decisionnext_stage && !stage_change_requested && !stage_zoom_in_requested && !stage_scroll_in_requested && !stage_reveal_requested && !screenTransitionActive(&stage_transition) && !screenRevealActive(&stage_transition) && !screenScrollActive(&stage_transition) && !screenSliceActive(&stage_transition)
   True

   1. 1. ExecuteselectRandomStageTransition();
      2. Executestage_change_requested = true;

   False

   1. Decisionnext_effect && selected_stage == DEMO_STAGE_ICON
      True

      1. 1. Executeselected_effect = (demo_effect_t)(((unsigned)selected_effect + 1U) % DEMO_EFFECT_COUNT);
         2. Executedemo_last_interaction_at = now_ms;

      False

      Continue after this decision.

void demoAction(bool next_effect, bool toggle_icon, bool next_stage, bool user_long_pressed,
                bool selector_previous, bool selector_next, uint32_t now_ms)
{
    if (!running) return;
    if (demo_selector_active) {
        if (selector_previous) {
            moveDemoSelector(-1, now_ms);
        } else if (selector_next) {
            moveDemoSelector(1, now_ms);
        } else if (next_effect) {
            const size_t selected_item = demo_selector_item;
            closeDemoSelector(now_ms);
            if (selected_item != 0U) {
                screenTransitionReset(&stage_transition);
                stage_change_requested = false;
                stage_zoom_in_requested = false;
                stage_zooming_in = false;
                stage_scroll_in_requested = false;
                stage_reveal_requested = false;
                demo_instructions_active = false;
                enterDemoStage((demo_stage_t)(selected_item - 1U), demoTimeNow(now_ms));
                // Present one clean black frame before the newly initialized segment draws.
                demo_selector_clear_new_stage = true;
            }
        }
        return;
    }
    if (user_long_pressed) {
        openDemoSelector(now_ms);
        return;
    }
    now_ms = demoTimeNow(now_ms);
    if (demo_instructions_active) {
        // C skips the control page and starts Segment 1. A, B, and the stick
        // remain inactive here so the Demo always begins from its known state.
        if (next_stage) beginDemoSegments(now_ms);
        return;
    }
    if (toggle_icon) {
        if (selected_stage == DEMO_STAGE_GEOMETRIC_SOLID) {
            // B previews another catalogue solid and restarts the shared inactivity timer.
            // Deliberately leave the independent five-second automatic change deadline alone.
            selectStageSixMesh();
            demo_last_interaction_at = now_ms;
        } else if (selected_stage == DEMO_STAGE_RASTER_BANDS ||
                   selected_stage == DEMO_STAGE_LOWER_RASTER_SCROLLER ||
                   selected_stage == DEMO_STAGE_BATTLE_ZONE_RASTER) {
            // B cycles the shared palette list without disturbing the bar's
            // travel, colour-roll phase, or the scroller's wave.
            raster_band_palette_index =
                (raster_band_palette_index + 1U) % DEMO_RASTER_BAND_PALETTE_COUNT;
            demo_last_interaction_at = now_ms;
        } else if (selected_stage == DEMO_STAGE_PLASMA) {
            // B changes only the plasma ramp; wave phases and ticker movement continue.
            demoStagePlasmaNextPalette();
            demo_last_interaction_at = now_ms;
        } else if (selected_stage == DEMO_STAGE_BEVEL_GEARS) {
            // B changes only the presentation treatment; gear and rig phases stay continuous.
            stage_seventeen_style = (stage_seventeen_style_t)
                (((unsigned)stage_seventeen_style + 1U) % STAGE_SEVENTEEN_STYLE_COUNT);
            demo_last_interaction_at = now_ms;
        } else if (selected_stage != DEMO_STAGE_AMIGA_BALL &&
                   selected_stage != DEMO_STAGE_SCROLLER &&
                   selected_stage != DEMO_STAGE_REVERSE_SCROLLER &&
                   selected_stage != DEMO_STAGE_WALLOONS &&
                   selected_stage != DEMO_STAGE_KALEIDO &&
                   selected_stage != DEMO_STAGE_SPARKLE &&
                   selected_stage != DEMO_STAGE_SQUARES &&
                   selected_stage != DEMO_STAGE_SLIDESHOW_LENS &&
                   !DEMO_LOCK_ICON_TO_PRIMARY) {
            advanceIconSlot();
            demo_last_interaction_at = now_ms;
        }
    }
    if (next_stage && !stage_change_requested && !stage_zoom_in_requested &&
        !stage_scroll_in_requested && !stage_reveal_requested &&
        !screenTransitionActive(&stage_transition) && !screenRevealActive(&stage_transition) &&
        !screenScrollActive(&stage_transition) && !screenSliceActive(&stage_transition)) {
        // Capture happens after this update, once drawDemo has completed the outgoing frame.
        selectRandomStageTransition();
        stage_change_requested = true;
    } else if (next_effect && selected_stage == DEMO_STAGE_ICON) {
        selected_effect = (demo_effect_t)(((unsigned)selected_effect + 1U) %
                                          DEMO_EFFECT_COUNT);
        demo_last_interaction_at = now_ms;
    }
}

void updateDemo(int joystick_x, int joystick_y, bool joystick_valid, uint32_t now_ms)

Calls into this documentation:

1. Decisiondemo_selector_active
   True

   1. 1. Executeint direction = 0;
      2. Decisionjoystick_valid
         True

         1. 1. Decisionjoystick_y > DEMO_SELECTOR_JOYSTICK_ENTER
               True

               1. Executedirection = -1;

               False

               1. Decisionjoystick_y < -DEMO_SELECTOR_JOYSTICK_ENTER
                  True

                  1. Executedirection = 1;

                  False

                  Continue after this decision.

         False

         Continue after this decision.

      3. Decisiondirection == 0
         True

         1. 1. Decisionjoystick_y >= -DEMO_SELECTOR_JOYSTICK_RELEASE && joystick_y <= DEMO_SELECTOR_JOYSTICK_RELEASE
               True

               1. 1. Executedemo_selector_joystick_direction = 0;
                  2. Executedemo_selector_repeating = false;

               False

               Continue after this decision.

            2. Exit this functionreturn;

         False

         Continue after this decision.

      4. Decisiondirection != demo_selector_joystick_direction
         True

         1. 1. Executedemo_selector_joystick_direction = direction;
            2. Executedemo_selector_repeating = false;
            3. ExecutemoveDemoSelector(direction, now_ms);

         False

         1. Decisionnow_ms - demo_selector_last_move_at >= (demo_selector_repeating ? DEMO_SELECTOR_JOYSTICK_REPEAT_MS : DEMO_SELECTOR_JOYSTICK_REPEAT_START_MS)
            True

            1. 1. Executedemo_selector_repeating = true;
               2. ExecutemoveDemoSelector(direction, now_ms);

            False

            Continue after this decision.

      5. Exit this functionreturn;

   False

   Continue after this decision.

2. Executenow_ms = demoTimeNow(now_ms);
3. Decision!running || now_ms - last_update_ms < DEMO_FRAME_MS
   True

   1. Exit this functionreturn;

   False

   Continue after this decision.

4. Executeuint32_t elapsed_ms = now_ms - last_update_ms;
5. Decisionelapsed_ms > 50U
   True

   1. Executeelapsed_ms = 50U;

   False

   Continue after this decision.

6. Executelast_update_ms = now_ms;
7. Decisiondemo_instructions_active
   True

   1. 1. Executestarfield_update(&demo_instruction_starfield, elapsed_ms);
      2. Decision(uint32_t)(now_ms - demo_instructions_started_at) >= DEMO_INSTRUCTIONS_DURATION_MS
         True

         1. 1. ExecutebeginDemoSegments(now_ms);

         False

         Continue after this decision.

      3. Exit this functionreturn;

   False

   Continue after this decision.

8. DecisionscreenTransitionActive(&stage_transition)
   True

   1. 1. DecisionscreenTransitionComplete(&stage_transition)
         True

         1. 1. ExecutescreenTransitionReset(&stage_transition);
            2. Decisionstage_zooming_in
               True

               1. 1. Executestage_zooming_in = false;

               False

               1. 1. ExecuteadvanceDemoStage(now_ms);
                  2. Executestage_zoom_in_requested = true;

         False

         Continue after this decision.

      2. Exit this functionreturn;

   False

   Continue after this decision.

9. DecisionscreenRevealActive(&stage_transition)
   True

   1. 1. DecisionscreenRevealComplete(&stage_transition)
         True

         1. 1. ExecutescreenRevealReset(&stage_transition);

         False

         Continue after this decision.

      2. Exit this functionreturn;

   False

   Continue after this decision.

10. DecisionscreenScrollActive(&stage_transition)
    True

    1. 1. DecisionscreenScrollComplete(&stage_transition)
          True

          1. 1. ExecutescreenScrollReset(&stage_transition);

          False

          Continue after this decision.

       2. Exit this functionreturn;

    False

    Continue after this decision.

11. DecisionscreenSliceActive(&stage_transition)
    True

    1. 1. DecisionscreenSliceComplete(&stage_transition)
          True

          1. 1. ExecutescreenSliceReset(&stage_transition);
             2. ExecuteadvanceDemoStage(now_ms);
             3. Executestage_zoom_in_requested = true;

          False

          Continue after this decision.

       2. Exit this functionreturn;

    False

    Continue after this decision.

12. Executepitch_degrees += DEMO_PITCH_DEGREES_PER_SECOND * (float)elapsed_ms / 1000.0f;
13. Executeyaw_degrees += DEMO_YAW_DEGREES_PER_SECOND * (float)elapsed_ms / 1000.0f;
14. Executeroll_degrees += DEMO_ROLL_DEGREES_PER_SECOND * (float)elapsed_ms / 1000.0f;
15. Executeconst float elapsed_seconds = (float)elapsed_ms / 1000.0f;
16. Decisionselected_stage == DEMO_STAGE_AMIGA_BALL
    True

    1. 1. ExecuteupdateStageThreeBall(elapsed_seconds);
       2. Decision(int32_t)(now_ms - stage_three_next_icon_change_at) >= 0
          True

          1. 1. Executestage_three_icon_slot = (stage_three_icon_slot + 1U) % DEMO_ICON_SLOT_COUNT;
             2. Executestage_three_icon_bitmap = demo_icon_slots[stage_three_icon_slot];
             3. Executestage_three_next_icon_change_at += DEMO_STAGE_THREE_ICON_CHANGE_MS;

          False

          Continue after this decision.

    False

    Continue after this decision.

17. Decisionselected_stage == DEMO_STAGE_GEOMETRIC_SOLID
    True

    1. 1. Decision(int32_t)(now_ms - stage_six_next_change_at) >= 0
          True

          1. 1. ExecuteselectStageSixMesh();
             2. Executestage_six_next_change_at += DEMO_STAGE_SIX_CHANGE_MS;

          False

          Continue after this decision.

    False

    Continue after this decision.

18. Decisionselected_stage == DEMO_STAGE_WALLOONS
    True

    1. 1. ExecutedemoStageWalloonsUpdate(now_ms);

    False

    Continue after this decision.

19. Decisionselected_stage == DEMO_STAGE_KALEIDO
    True

    1. 1. ExecutedemoStageKaleidoUpdate(now_ms);

    False

    Continue after this decision.

20. Decisionselected_stage == DEMO_STAGE_SPARKLE
    True

    1. 1. ExecutedemoStageSparkleUpdate(now_ms);

    False

    Continue after this decision.

21. Decisionselected_stage == DEMO_STAGE_SQUARES
    True

    1. 1. ExecutedemoStageSquaresUpdate(now_ms);

    False

    Continue after this decision.

22. Decisionselected_stage == DEMO_STAGE_RASTER_BANDS || selected_stage == DEMO_STAGE_LOWER_RASTER_SCROLLER || selected_stage == DEMO_STAGE_BATTLE_ZONE_RASTER
    True

    1. 1. Executeraster_band_effect_elapsed_ms += elapsed_ms;

    False

    Continue after this decision.

23. Decisionselected_stage == DEMO_STAGE_SLIDESHOW_LENS
    True

    1. 1. ExecutedemoStageSlideshowLensUpdate(now_ms);

    False

    Continue after this decision.

24. Decisionselected_stage == DEMO_STAGE_PLASMA
    True

    1. 1. ExecutedemoStagePlasmaUpdate(elapsed_ms);

    False

    Continue after this decision.

25. Decisionselected_stage == DEMO_STAGE_GAME_OF_LIFE
    True

    1. 1. ExecutedemoStageGameOfLifeUpdate(elapsed_ms);

    False

    Continue after this decision.

26. Decisionselected_stage == DEMO_STAGE_BEVEL_GEARS
    True

    1. 1. Executeconst float angle_step = DEMO_STAGE_SEVENTEEN_GEAR_DEGREES_PER_SECOND * elapsed_seconds;
       2. Executestage_seventeen_rig_pitch_degrees += DEMO_STAGE_SEVENTEEN_RIG_PITCH_DEGREES_PER_SECOND * elapsed_seconds;
       3. Executestage_seventeen_rig_yaw_degrees += DEMO_STAGE_SEVENTEEN_RIG_YAW_DEGREES_PER_SECOND * elapsed_seconds;
       4. Executestage_seventeen_rig_roll_degrees += DEMO_STAGE_SEVENTEEN_RIG_ROLL_DEGREES_PER_SECOND * elapsed_seconds;
       5. Executestage_seventeen_gear_degrees[0] += angle_step;
       6. Executestage_seventeen_gear_degrees[1] -= angle_step;
       7. Executestage_seventeen_gear_degrees[2] -= angle_step;

    False

    Continue after this decision.

27. Decisionselected_stage == DEMO_STAGE_MOUSE_MAZE
    True

    1. 1. ExecutedemoStageMouseMazeUpdate(now_ms);

    False

    Continue after this decision.

28. Decisionselected_stage == DEMO_STAGE_SCROLLER || selected_stage == DEMO_STAGE_REVERSE_SCROLLER
    True

    1. 1. ExecuteupdateTextCornerIconCycles(now_ms);

    False

    Continue after this decision.

29. Decisionselected_stage == DEMO_STAGE_ICON && (int32_t)(now_ms - stage_one_next_effect_change_at) >= 0
    True

    1. 1. Executeselected_effect = (demo_effect_t)(((unsigned)selected_effect + 1U) % DEMO_EFFECT_COUNT);
       2. Executestage_one_next_effect_change_at = now_ms + DEMO_STAGE_ONE_EFFECT_CHANGE_MS;

    False

    Continue after this decision.

30. Decisionjoystick_valid && (joystick_x < -DEMO_INACTIVITY_JOYSTICK_DEAD_ZONE || joystick_x > DEMO_INACTIVITY_JOYSTICK_DEAD_ZONE || (selected_stage == DEMO_STAGE_APPROACH && (joystick_y < -DEMO_INACTIVITY_JOYSTICK_DEAD_ZONE || joystick_y > DEMO_INACTIVITY_JOYSTICK_DEAD_ZONE)))
    True

    1. 1. Executedemo_last_interaction_at = now_ms;

    False

    Continue after this decision.

31. Decisionjoystick_valid && (joystick_x < -DEMO_SCROLL_JOYSTICK_DEAD_ZONE || joystick_x > DEMO_SCROLL_JOYSTICK_DEAD_ZONE)
    True

    1. 1. Executefloat deflection = (float)(joystick_x < 0 ? -joystick_x : joystick_x) - (float)DEMO_SCROLL_JOYSTICK_DEAD_ZONE;
       2. Executedeflection /= DEMO_SCROLL_JOYSTICK_FULL_TRAVEL - (float)DEMO_SCROLL_JOYSTICK_DEAD_ZONE;
       3. Decisiondeflection > 1.0f
          True

          1. Executedeflection = 1.0f;

          False

          Continue after this decision.

       4. Executeconst float direction = joystick_x < 0 ? 1.0f : -1.0f;
       5. Executescroll_speed_pixels_per_second += direction * DEMO_SCROLL_ACCELERATION_PIXELS_PER_SECOND_SQUARED * deflection * elapsed_seconds;
       6. Decisionscroll_speed_pixels_per_second > DEMO_SCROLL_MAX_PIXELS_PER_SECOND
          True

          1. 1. Executescroll_speed_pixels_per_second = DEMO_SCROLL_MAX_PIXELS_PER_SECOND;

          False

          1. Decisionscroll_speed_pixels_per_second < -DEMO_SCROLL_MAX_PIXELS_PER_SECOND
             True

             1. 1. Executescroll_speed_pixels_per_second = -DEMO_SCROLL_MAX_PIXELS_PER_SECOND;

             False

             Continue after this decision.

    False

    Continue after this decision.

32. Decisionselected_stage == DEMO_STAGE_APPROACH && joystick_valid && (joystick_y < -DEMO_STAGE_TWO_JOYSTICK_DEAD_ZONE || joystick_y > DEMO_STAGE_TWO_JOYSTICK_DEAD_ZONE)
    True

    1. 1. Executefloat deflection = (float)(joystick_y < 0 ? -joystick_y : joystick_y) - (float)DEMO_STAGE_TWO_JOYSTICK_DEAD_ZONE;
       2. Executedeflection /= DEMO_SCROLL_JOYSTICK_FULL_TRAVEL - (float)DEMO_STAGE_TWO_JOYSTICK_DEAD_ZONE;
       3. Decisiondeflection > 1.0f
          True

          1. Executedeflection = 1.0f;

          False

          Continue after this decision.

       4. Executeconst float direction = joystick_y > 0 ? 1.0f : -1.0f;
       5. Executestage_two_distance -= direction * DEMO_STAGE_TWO_APPROACH_UNITS_PER_SECOND * deflection * elapsed_seconds;
       6. Decisionstage_two_distance < DEMO_STAGE_TWO_MIN_DISTANCE
          True

          1. 1. Executestage_two_distance = DEMO_STAGE_TWO_MIN_DISTANCE;

          False

          1. Decisionstage_two_distance > DEMO_STAGE_TWO_MAX_DISTANCE
             True

             1. 1. Executestage_two_distance = DEMO_STAGE_TWO_MAX_DISTANCE;

             False

             Continue after this decision.

    False

    Continue after this decision.

33. Decisionselected_stage == DEMO_STAGE_APPROACH && (!joystick_valid || (joystick_y >= -DEMO_STAGE_TWO_JOYSTICK_DEAD_ZONE && joystick_y <= DEMO_STAGE_TWO_JOYSTICK_DEAD_ZONE))
    True

    1. 1. Executeconst float auto_distance_step = DEMO_STAGE_TWO_AUTO_APPROACH_UNITS_PER_SECOND * elapsed_seconds;
       2. Decisionstage_two_auto_approaching
          True

          1. 1. Executestage_two_distance -= auto_distance_step;
             2. Decisionstage_two_distance <= DEMO_STAGE_TWO_MIN_DISTANCE
                True

                1. 1. Executestage_two_distance = DEMO_STAGE_TWO_MIN_DISTANCE;
                   2. Executestage_two_auto_approaching = false;

                False

                Continue after this decision.

          False

          1. 1. Executestage_two_distance += auto_distance_step;
             2. Decisionstage_two_distance >= DEMO_STAGE_TWO_MAX_DISTANCE
                True

                1. 1. Executestage_two_distance = DEMO_STAGE_TWO_MAX_DISTANCE;
                   2. Executestage_two_auto_approaching = true;

                False

                Continue after this decision.

    False

    Continue after this decision.

34. Decisionnow_ms - demo_last_interaction_at >= demoStageInactivityTimeout() && !stage_change_requested
    True

    1. 1. ExecuteselectRandomStageTransition();
       2. Executestage_change_requested = true;

    False

    Continue after this decision.

35. Executescroll_text_x -= scroll_speed_pixels_per_second * elapsed_seconds;
36. Executescroll_text_effect_elapsed_ms += elapsed_ms;
37. Decisionpitch_degrees >= 360.0f
    True

    1. Executepitch_degrees -= 360.0f;

    False

    Continue after this decision.

38. Decisionyaw_degrees >= 360.0f
    True

    1. Executeyaw_degrees -= 360.0f;

    False

    Continue after this decision.

39. Decisionroll_degrees >= 360.0f
    True

    1. Executeroll_degrees -= 360.0f;

    False

    Continue after this decision.

40. Decisionstage_seventeen_rig_pitch_degrees >= 360.0f
    True

    1. Executestage_seventeen_rig_pitch_degrees -= 360.0f;

    False

    Continue after this decision.

41. Decisionstage_seventeen_rig_yaw_degrees >= 360.0f
    True

    1. Executestage_seventeen_rig_yaw_degrees -= 360.0f;

    False

    Continue after this decision.

42. Decisionstage_seventeen_rig_roll_degrees >= 360.0f
    True

    1. Executestage_seventeen_rig_roll_degrees -= 360.0f;

    False

    Continue after this decision.

43. FOR loopsize_t gear = 0U; gear < 3U; ++gear

    Repeat body while the loop condition permits; then continue below.

    1. 1. WHILE loopstage_seventeen_gear_degrees[gear] >= 360.0f

          Repeat body while the loop condition permits; then continue below.

          1. 1. Executestage_seventeen_gear_degrees[gear] -= 360.0f;
       2. WHILE loopstage_seventeen_gear_degrees[gear] < 0.0f

          Repeat body while the loop condition permits; then continue below.

          1. 1. Executestage_seventeen_gear_degrees[gear] += 360.0f;
44. Decision(scroll_speed_pixels_per_second > 0.0f && scroll_text_x <= -(float)scroll_text_width) || (scroll_speed_pixels_per_second < 0.0f && scroll_text_x >= (float)LCD_WIDTH)
    True

    1. 1. ExecuteselectScrollMessage(selected_stage != DEMO_STAGE_SCROLLER && selected_stage != DEMO_STAGE_REVERSE_SCROLLER && selected_stage != DEMO_STAGE_RASTER_BANDS && selected_stage != DEMO_STAGE_BATTLE_ZONE_RASTER);

    False

    Continue after this decision.

45. Executesparkle_phase = now_ms / DEMO_DOT_SPARKLE_INTERVAL_MS;
46. Executeradial_flame_update_wavy(&demo_ring_flame, DEMO_RING_WAVE_AMPLITUDE, DEMO_RING_WAVE_COUNT, (float)now_ms * DEMO_RING_WAVE_DEGREES_PER_SECOND / 1000.0f, DEMO_RING_EXTRA_COOLING);

void updateDemo(int joystick_x, int joystick_y, bool joystick_valid, uint32_t now_ms)
{
    if (demo_selector_active) {
        int direction = 0;
        if (joystick_valid) {
            if (joystick_y > DEMO_SELECTOR_JOYSTICK_ENTER) direction = -1;
            else if (joystick_y < -DEMO_SELECTOR_JOYSTICK_ENTER) direction = 1;
        }
        if (direction == 0) {
            if (joystick_y >= -DEMO_SELECTOR_JOYSTICK_RELEASE &&
                joystick_y <= DEMO_SELECTOR_JOYSTICK_RELEASE) {
                demo_selector_joystick_direction = 0;
                demo_selector_repeating = false;
            }
            return;
        }
        if (direction != demo_selector_joystick_direction) {
            demo_selector_joystick_direction = direction;
            demo_selector_repeating = false;
            moveDemoSelector(direction, now_ms);
        } else if (now_ms - demo_selector_last_move_at >=
                   (demo_selector_repeating ? DEMO_SELECTOR_JOYSTICK_REPEAT_MS :
                    DEMO_SELECTOR_JOYSTICK_REPEAT_START_MS)) {
            demo_selector_repeating = true;
            moveDemoSelector(direction, now_ms);
        }
        return;
    }
    now_ms = demoTimeNow(now_ms);
    if (!running || now_ms - last_update_ms < DEMO_FRAME_MS) return;
    uint32_t elapsed_ms = now_ms - last_update_ms;
    if (elapsed_ms > 50U) elapsed_ms = 50U;
    last_update_ms = now_ms;
    if (demo_instructions_active) {
        // The control page has its own fixed duration and does not consume any
        // of Segment 1's normal inactivity timeout.
        starfield_update(&demo_instruction_starfield, elapsed_ms);
        if ((uint32_t)(now_ms - demo_instructions_started_at) >=
            DEMO_INSTRUCTIONS_DURATION_MS) {
            beginDemoSegments(now_ms);
        }
        return;
    }
    if (screenTransitionActive(&stage_transition)) {
        if (screenTransitionComplete(&stage_transition)) {
            // The transition's finished frame was shown. Either resume the new stage or
            // select it and request its off-screen capture for the incoming zoom.
            screenTransitionReset(&stage_transition);
            if (stage_zooming_in) {
                stage_zooming_in = false;
            } else {
                advanceDemoStage(now_ms);
                stage_zoom_in_requested = true;
            }
        }
        return;
    }
    if (screenRevealActive(&stage_transition)) {
        if (screenRevealComplete(&stage_transition)) {
            screenRevealReset(&stage_transition);
        }
        return;
    }
    if (screenScrollActive(&stage_transition)) {
        if (screenScrollComplete(&stage_transition)) {
            screenScrollReset(&stage_transition);
        }
        return;
    }
    if (screenSliceActive(&stage_transition)) {
        if (screenSliceComplete(&stage_transition)) {
            screenSliceReset(&stage_transition);
            advanceDemoStage(now_ms);
            stage_zoom_in_requested = true;
        }
        return;
    }
    pitch_degrees += DEMO_PITCH_DEGREES_PER_SECOND * (float)elapsed_ms / 1000.0f;
    yaw_degrees += DEMO_YAW_DEGREES_PER_SECOND * (float)elapsed_ms / 1000.0f;
    roll_degrees += DEMO_ROLL_DEGREES_PER_SECOND * (float)elapsed_ms / 1000.0f;
    const float elapsed_seconds = (float)elapsed_ms / 1000.0f;
    if (selected_stage == DEMO_STAGE_AMIGA_BALL) {
        updateStageThreeBall(elapsed_seconds);
        // This signed comparison continues to work if the millisecond counter wraps.
        if ((int32_t)(now_ms - stage_three_next_icon_change_at) >= 0) {
            stage_three_icon_slot = (stage_three_icon_slot + 1U) % DEMO_ICON_SLOT_COUNT;
            stage_three_icon_bitmap = demo_icon_slots[stage_three_icon_slot];
            stage_three_next_icon_change_at += DEMO_STAGE_THREE_ICON_CHANGE_MS;
        }
    }
    if (selected_stage == DEMO_STAGE_GEOMETRIC_SOLID) {
        if ((int32_t)(now_ms - stage_six_next_change_at) >= 0) {
            selectStageSixMesh();
            stage_six_next_change_at += DEMO_STAGE_SIX_CHANGE_MS;
        }
    }
    if (selected_stage == DEMO_STAGE_WALLOONS) {
        demoStageWalloonsUpdate(now_ms);
    }
    if (selected_stage == DEMO_STAGE_KALEIDO) {
        demoStageKaleidoUpdate(now_ms);
    }
    if (selected_stage == DEMO_STAGE_SPARKLE) {
        demoStageSparkleUpdate(now_ms);
    }
    if (selected_stage == DEMO_STAGE_SQUARES) {
        demoStageSquaresUpdate(now_ms);
    }
    if (selected_stage == DEMO_STAGE_RASTER_BANDS ||
        selected_stage == DEMO_STAGE_LOWER_RASTER_SCROLLER ||
        selected_stage == DEMO_STAGE_BATTLE_ZONE_RASTER) {
        raster_band_effect_elapsed_ms += elapsed_ms;
    }
    if (selected_stage == DEMO_STAGE_SLIDESHOW_LENS) {
        demoStageSlideshowLensUpdate(now_ms);
    }
    if (selected_stage == DEMO_STAGE_PLASMA) {
        demoStagePlasmaUpdate(elapsed_ms);
    }
    if (selected_stage == DEMO_STAGE_GAME_OF_LIFE) {
        demoStageGameOfLifeUpdate(elapsed_ms);
    }
    if (selected_stage == DEMO_STAGE_BEVEL_GEARS) {
        const float angle_step = DEMO_STAGE_SEVENTEEN_GEAR_DEGREES_PER_SECOND *
                                 elapsed_seconds;
        stage_seventeen_rig_pitch_degrees +=
            DEMO_STAGE_SEVENTEEN_RIG_PITCH_DEGREES_PER_SECOND * elapsed_seconds;
        stage_seventeen_rig_yaw_degrees +=
            DEMO_STAGE_SEVENTEEN_RIG_YAW_DEGREES_PER_SECOND * elapsed_seconds;
        stage_seventeen_rig_roll_degrees +=
            DEMO_STAGE_SEVENTEEN_RIG_ROLL_DEGREES_PER_SECOND * elapsed_seconds;
        // The two driven gears reverse from the common lead phase, preserving
        // their fixed tooth-to-gap relationship at both mesh contacts.
        stage_seventeen_gear_degrees[0] += angle_step;
        stage_seventeen_gear_degrees[1] -= angle_step;
        stage_seventeen_gear_degrees[2] -= angle_step;
    }
    if (selected_stage == DEMO_STAGE_MOUSE_MAZE) {
        demoStageMouseMazeUpdate(now_ms);
    }
    if (selected_stage == DEMO_STAGE_SCROLLER ||
        selected_stage == DEMO_STAGE_REVERSE_SCROLLER) {
        updateTextCornerIconCycles(now_ms);
    }
    if (selected_stage == DEMO_STAGE_ICON &&
        (int32_t)(now_ms - stage_one_next_effect_change_at) >= 0) {
        // Keep the automatic sequence in the same enum order as a manual A press.
        selected_effect = (demo_effect_t)(((unsigned)selected_effect + 1U) % DEMO_EFFECT_COUNT);
        stage_one_next_effect_change_at = now_ms + DEMO_STAGE_ONE_EFFECT_CHANGE_MS;
    }
    if (joystick_valid &&
        (joystick_x < -DEMO_INACTIVITY_JOYSTICK_DEAD_ZONE ||
         joystick_x > DEMO_INACTIVITY_JOYSTICK_DEAD_ZONE ||
         (selected_stage == DEMO_STAGE_APPROACH &&
          (joystick_y < -DEMO_INACTIVITY_JOYSTICK_DEAD_ZONE ||
           joystick_y > DEMO_INACTIVITY_JOYSTICK_DEAD_ZONE)))) {
        demo_last_interaction_at = now_ms;
    }
    if (joystick_valid && (joystick_x < -DEMO_SCROLL_JOYSTICK_DEAD_ZONE ||
                           joystick_x > DEMO_SCROLL_JOYSTICK_DEAD_ZONE)) {
        float deflection = (float)(joystick_x < 0 ? -joystick_x : joystick_x) -
                           (float)DEMO_SCROLL_JOYSTICK_DEAD_ZONE;
        deflection /= DEMO_SCROLL_JOYSTICK_FULL_TRAVEL -
                      (float)DEMO_SCROLL_JOYSTICK_DEAD_ZONE;
        if (deflection > 1.0f) deflection = 1.0f;
        const float direction = joystick_x < 0 ? 1.0f : -1.0f;
        scroll_speed_pixels_per_second += direction *
                                          DEMO_SCROLL_ACCELERATION_PIXELS_PER_SECOND_SQUARED *
                                          deflection * elapsed_seconds;
        if (scroll_speed_pixels_per_second > DEMO_SCROLL_MAX_PIXELS_PER_SECOND) {
            scroll_speed_pixels_per_second = DEMO_SCROLL_MAX_PIXELS_PER_SECOND;
        } else if (scroll_speed_pixels_per_second < -DEMO_SCROLL_MAX_PIXELS_PER_SECOND) {
            scroll_speed_pixels_per_second = -DEMO_SCROLL_MAX_PIXELS_PER_SECOND;
        }
    }
    if (selected_stage == DEMO_STAGE_APPROACH && joystick_valid &&
        (joystick_y < -DEMO_STAGE_TWO_JOYSTICK_DEAD_ZONE ||
         joystick_y > DEMO_STAGE_TWO_JOYSTICK_DEAD_ZONE)) {
        float deflection = (float)(joystick_y < 0 ? -joystick_y : joystick_y) -
                           (float)DEMO_STAGE_TWO_JOYSTICK_DEAD_ZONE;
        deflection /= DEMO_SCROLL_JOYSTICK_FULL_TRAVEL -
                      (float)DEMO_STAGE_TWO_JOYSTICK_DEAD_ZONE;
        if (deflection > 1.0f) deflection = 1.0f;
        const float direction = joystick_y > 0 ? 1.0f : -1.0f;
        stage_two_distance -= direction * DEMO_STAGE_TWO_APPROACH_UNITS_PER_SECOND *
                              deflection * elapsed_seconds;
        if (stage_two_distance < DEMO_STAGE_TWO_MIN_DISTANCE) {
            stage_two_distance = DEMO_STAGE_TWO_MIN_DISTANCE;
        } else if (stage_two_distance > DEMO_STAGE_TWO_MAX_DISTANCE) {
            stage_two_distance = DEMO_STAGE_TWO_MAX_DISTANCE;
        }
    }
    if (selected_stage == DEMO_STAGE_APPROACH &&
        (!joystick_valid ||
         (joystick_y >= -DEMO_STAGE_TWO_JOYSTICK_DEAD_ZONE &&
          joystick_y <= DEMO_STAGE_TWO_JOYSTICK_DEAD_ZONE))) {
        // With no vertical-stick input, travel toward the current end and reverse there.
        const float auto_distance_step = DEMO_STAGE_TWO_AUTO_APPROACH_UNITS_PER_SECOND *
                                         elapsed_seconds;
        if (stage_two_auto_approaching) {
            stage_two_distance -= auto_distance_step;
            if (stage_two_distance <= DEMO_STAGE_TWO_MIN_DISTANCE) {
                stage_two_distance = DEMO_STAGE_TWO_MIN_DISTANCE;
                stage_two_auto_approaching = false;
            }
        } else {
            stage_two_distance += auto_distance_step;
            if (stage_two_distance >= DEMO_STAGE_TWO_MAX_DISTANCE) {
                stage_two_distance = DEMO_STAGE_TWO_MAX_DISTANCE;
                stage_two_auto_approaching = true;
            }
        }
    }
    if (now_ms - demo_last_interaction_at >= demoStageInactivityTimeout() &&
        !stage_change_requested) {
        // Match C's normal route so every automatic advance uses a regular transition.
        selectRandomStageTransition();
        stage_change_requested = true;
    }
    scroll_text_x -= scroll_speed_pixels_per_second * elapsed_seconds;
    scroll_text_effect_elapsed_ms += elapsed_ms;
    if (pitch_degrees >= 360.0f) pitch_degrees -= 360.0f;
    if (yaw_degrees >= 360.0f) yaw_degrees -= 360.0f;
    if (roll_degrees >= 360.0f) roll_degrees -= 360.0f;
    if (stage_seventeen_rig_pitch_degrees >= 360.0f) stage_seventeen_rig_pitch_degrees -= 360.0f;
    if (stage_seventeen_rig_yaw_degrees >= 360.0f) stage_seventeen_rig_yaw_degrees -= 360.0f;
    if (stage_seventeen_rig_roll_degrees >= 360.0f) stage_seventeen_rig_roll_degrees -= 360.0f;
    for (size_t gear = 0U; gear < 3U; ++gear) {
        while (stage_seventeen_gear_degrees[gear] >= 360.0f) {
            stage_seventeen_gear_degrees[gear] -= 360.0f;
        }
        while (stage_seventeen_gear_degrees[gear] < 0.0f) {
            stage_seventeen_gear_degrees[gear] += 360.0f;
        }
    }
    if ((scroll_speed_pixels_per_second > 0.0f &&
         scroll_text_x <= -(float)scroll_text_width) ||
        (scroll_speed_pixels_per_second < 0.0f && scroll_text_x >= (float)LCD_WIDTH)) {
        selectScrollMessage(selected_stage != DEMO_STAGE_SCROLLER &&
                            selected_stage != DEMO_STAGE_REVERSE_SCROLLER &&
                            selected_stage != DEMO_STAGE_RASTER_BANDS &&
                            selected_stage != DEMO_STAGE_BATTLE_ZONE_RASTER);
    }
    sparkle_phase = now_ms / DEMO_DOT_SPARKLE_INTERVAL_MS;
    radial_flame_update_wavy(&demo_ring_flame, DEMO_RING_WAVE_AMPLITUDE,
                             DEMO_RING_WAVE_COUNT,
                             (float)now_ms * DEMO_RING_WAVE_DEGREES_PER_SECOND / 1000.0f,
                             DEMO_RING_EXTRA_COOLING);
}

static void drawApproachStage(uint16_t *frame)

Calls into this documentation:

1. Executestatic const int terrain_bands[] = {58, 76, 101, 134};
2. Executeconst int horizon = 42;
3. FOR loopsize_t index = 0U; index < sizeof(terrain_bands) / sizeof(terrain_bands[0]); ++index

   Repeat body while the loop condition permits; then continue below.

   1. 1. Executedraw_line(frame, 0, terrain_bands[index], LCD_WIDTH - 1, terrain_bands[index], COLOR_DARKGREEN);
4. FOR loopint lane = -3; lane <= 3; ++lane

   Repeat body while the loop condition permits; then continue below.

   1. 1. Executedraw_line(frame, DEMO_CENTRE_X + lane * 10, horizon, DEMO_CENTRE_X + lane * 50, LCD_HEIGHT - 1, COLOR_DARKGREEN);
5. Executedraw_line(frame, 0, horizon, LCD_WIDTH - 1, horizon, COLOR_LIME);
6. Executeint icon_size = (int)lroundf(2400.0f / stage_two_distance);
7. Decisionicon_size < 4
   True

   1. Executeicon_size = 4;

   False

   Continue after this decision.

8. Decisionicon_size > DEMO_STAGE_TWO_MAX_ICON_PIXELS
   True

   1. Executeicon_size = DEMO_STAGE_TWO_MAX_ICON_PIXELS;

   False

   Continue after this decision.

9. Executeconst int icon_base_y = horizon + (int)lroundf(2000.0f / stage_two_distance);
10. Executeconst float pitch_radians = pitch_degrees * DEMO_PI / 180.0f;
11. Executeconst float yaw_radians = yaw_degrees * DEMO_PI / 180.0f;
12. Executeconst float roll_radians = roll_degrees * DEMO_PI / 180.0f;
13. Executeconst demo_rotation_t rotation = { .pitch_cosine = cosf(pitch_radians), .pitch_sine = sinf(pitch_radians), .yaw_cosine = cosf(yaw_radians), .yaw_sine = sinf(yaw_radians), .roll_cosine = cosf(roll_radians), .roll_sine = sinf(roll_radians), };
14. Executeconst float scale = (float)icon_size / (float)DEMO_LOGO_WIDTH;
15. Executeconst int centre_y = icon_base_y - icon_size / 2;
16. Decisionrotation.pitch_cosine * rotation.yaw_cosine >= 0.0f
    True

    1. 1. FOR loopunsigned depth = DEMO_EXTRUSION_DEPTH; depth > 0U; depth -= DEMO_EXTRUSION_STEP

          Repeat body while the loop condition permits; then continue below.

          1. 1. ExecutedrawApproachLogoSlice(frame, active_logo_bitmap, (float)depth, &rotation, scale, DEMO_CENTRE_X, centre_y, demo_icon_colour_schemes[demo_icon_colour_scheme_index].depth);
       2. ExecutedrawApproachLogoSlice(frame, active_logo_bitmap, 0.0f, &rotation, scale, DEMO_CENTRE_X, centre_y, demo_icon_colour_schemes[demo_icon_colour_scheme_index].front);

    False

    1. 1. ExecutedrawApproachLogoSlice(frame, active_logo_bitmap, 0.0f, &rotation, scale, DEMO_CENTRE_X, centre_y, demo_icon_colour_schemes[demo_icon_colour_scheme_index].front);
       2. FOR loopunsigned depth = DEMO_EXTRUSION_STEP; depth <= DEMO_EXTRUSION_DEPTH; depth += DEMO_EXTRUSION_STEP

          Repeat body while the loop condition permits; then continue below.

          1. 1. ExecutedrawApproachLogoSlice(frame, active_logo_bitmap, (float)depth, &rotation, scale, DEMO_CENTRE_X, centre_y, demo_icon_colour_schemes[demo_icon_colour_scheme_index].depth);

static void drawApproachStage(uint16_t *frame)
{
    static const int terrain_bands[] = {58, 76, 101, 134};
    const int horizon = 42;
    for (size_t index = 0U; index < sizeof(terrain_bands) / sizeof(terrain_bands[0]); ++index) {
        draw_line(frame, 0, terrain_bands[index], LCD_WIDTH - 1, terrain_bands[index],
                  COLOR_DARKGREEN);
    }
    for (int lane = -3; lane <= 3; ++lane) {
        draw_line(frame, DEMO_CENTRE_X + lane * 10, horizon,
                  DEMO_CENTRE_X + lane * 50, LCD_HEIGHT - 1, COLOR_DARKGREEN);
    }
    draw_line(frame, 0, horizon, LCD_WIDTH - 1, horizon, COLOR_LIME);

    int icon_size = (int)lroundf(2400.0f / stage_two_distance);
    if (icon_size < 4) icon_size = 4;
    if (icon_size > DEMO_STAGE_TWO_MAX_ICON_PIXELS) icon_size = DEMO_STAGE_TWO_MAX_ICON_PIXELS;
    const int icon_base_y = horizon + (int)lroundf(2000.0f / stage_two_distance);
    const float pitch_radians = pitch_degrees * DEMO_PI / 180.0f;
    const float yaw_radians = yaw_degrees * DEMO_PI / 180.0f;
    const float roll_radians = roll_degrees * DEMO_PI / 180.0f;
    const demo_rotation_t rotation = {
        .pitch_cosine = cosf(pitch_radians),
        .pitch_sine = sinf(pitch_radians),
        .yaw_cosine = cosf(yaw_radians),
        .yaw_sine = sinf(yaw_radians),
        .roll_cosine = cosf(roll_radians),
        .roll_sine = sinf(roll_radians),
    };
    const float scale = (float)icon_size / (float)DEMO_LOGO_WIDTH;
    const int centre_y = icon_base_y - icon_size / 2;
    if (rotation.pitch_cosine * rotation.yaw_cosine >= 0.0f) {
        for (unsigned depth = DEMO_EXTRUSION_DEPTH; depth > 0U;
             depth -= DEMO_EXTRUSION_STEP) {
            drawApproachLogoSlice(frame, active_logo_bitmap, (float)depth, &rotation, scale,
                                  DEMO_CENTRE_X, centre_y,
                                  demo_icon_colour_schemes[demo_icon_colour_scheme_index].depth);
        }
        drawApproachLogoSlice(frame, active_logo_bitmap, 0.0f, &rotation, scale,
                              DEMO_CENTRE_X, centre_y,
                              demo_icon_colour_schemes[demo_icon_colour_scheme_index].front);
    } else {
        drawApproachLogoSlice(frame, active_logo_bitmap, 0.0f, &rotation, scale,
                              DEMO_CENTRE_X, centre_y,
                              demo_icon_colour_schemes[demo_icon_colour_scheme_index].front);
        for (unsigned depth = DEMO_EXTRUSION_STEP; depth <= DEMO_EXTRUSION_DEPTH;
             depth += DEMO_EXTRUSION_STEP) {
            drawApproachLogoSlice(frame, active_logo_bitmap, (float)depth, &rotation, scale,
                                  DEMO_CENTRE_X, centre_y,
                                  demo_icon_colour_schemes[demo_icon_colour_scheme_index].depth);
        }
    }
}

static void drawStageThreeBall(uint16_t *frame)

Calls into this documentation:

1. Executeclear(frame, RGB565(0, 32, 175));
2. Executeconst int centre_x = (int)lroundf(stage_three_ball_x);
3. Executeconst int centre_y = (int)lroundf(stage_three_ball_y);
4. Executeconst uint8_t rotation = (uint8_t)stage_three_ball_rotation_phase;
5. Executeconst uint16_t shadow = RGB565(0, 0, 80);
6. Executefill_rect(frame, centre_x - 13, (int)DEMO_STAGE_THREE_BALL_FLOOR_Y, 27, 1, shadow);
7. Executefill_rect(frame, centre_x - 19, (int)DEMO_STAGE_THREE_BALL_FLOOR_Y + 1, 39, 2, shadow);
8. Executefill_rect(frame, centre_x - 15, (int)DEMO_STAGE_THREE_BALL_FLOOR_Y + 3, 31, 1, shadow);
9. Executeconst uint8_t *bitmap = stage_three_icon_bitmap != NULL ? stage_three_icon_bitmap : demo_jd_bitmap;
10. FOR loopint y = 0; y < DEMO_STAGE_THREE_BALL_DIAMETER; ++y

    Repeat body while the loop condition permits; then continue below.

    1. 1. Executeconst int screen_y = centre_y - DEMO_STAGE_THREE_BALL_RADIUS + y;
       2. Decisionscreen_y < 0 || screen_y >= LCD_HEIGHT
          True

          1. Next loop iterationcontinue;

          False

          Continue after this decision.

       3. FOR loopint x = 0; x < DEMO_STAGE_THREE_BALL_DIAMETER; ++x

          Repeat body while the loop condition permits; then continue below.

          1. 1. Executeconst int index = y * DEMO_STAGE_THREE_BALL_DIAMETER + x;
             2. Executeconst uint8_t shade = stage_three_ball_shade_map[index];
             3. Decisionshade == 0U
                True

                1. Next loop iterationcontinue;

                False

                Continue after this decision.

             4. Executeconst int screen_x = centre_x - DEMO_STAGE_THREE_BALL_RADIUS + x;
             5. Decisionscreen_x < 0 || screen_x >= LCD_WIDTH
                True

                1. Next loop iterationcontinue;

                False

                Continue after this decision.

             6. Executeconst unsigned texture_x = ((((unsigned)stage_three_ball_longitude_map[index] * DEMO_LOGO_WIDTH) >> 8U) + (unsigned)rotation * DEMO_LOGO_WIDTH / DEMO_STAGE_THREE_BALL_LONGITUDE_BANDS) % DEMO_LOGO_WIDTH;
             7. Executeconst unsigned texture_y = ((unsigned)stage_three_ball_latitude_map[index] * DEMO_LOGO_HEIGHT) >> 8U;
             8. Executeconst size_t byte_index = (size_t)texture_y * DEMO_LOGO_ROW_BYTES + texture_x / 8U;
             9. Executeconst uint8_t bit = (uint8_t)(7U - texture_x % 8U);
             10. Executeconst bool icon_pixel = (bitmap[byte_index] & (uint8_t)(1U << bit)) != 0U;
             11. Executeframe[(size_t)screen_y * LCD_WIDTH + (size_t)screen_x] = icon_pixel ? stage_three_red_shades[shade - 1U] : stage_three_white_shades[shade - 1U];

static void drawStageThreeBall(uint16_t *frame)
{
    // Keep the classic blue field, while the scrolling PET text is layered later by drawDemo.
    clear(frame, RGB565(0, 32, 175));
    const int centre_x = (int)lroundf(stage_three_ball_x);
    const int centre_y = (int)lroundf(stage_three_ball_y);
    const uint8_t rotation = (uint8_t)stage_three_ball_rotation_phase;
    const uint16_t shadow = RGB565(0, 0, 80);
    fill_rect(frame, centre_x - 13, (int)DEMO_STAGE_THREE_BALL_FLOOR_Y, 27, 1, shadow);
    fill_rect(frame, centre_x - 19, (int)DEMO_STAGE_THREE_BALL_FLOOR_Y + 1, 39, 2, shadow);
    fill_rect(frame, centre_x - 15, (int)DEMO_STAGE_THREE_BALL_FLOOR_Y + 3, 31, 1, shadow);

    const uint8_t *bitmap = stage_three_icon_bitmap != NULL ? stage_three_icon_bitmap :
                                                             demo_jd_bitmap;
    for (int y = 0; y < DEMO_STAGE_THREE_BALL_DIAMETER; ++y) {
        const int screen_y = centre_y - DEMO_STAGE_THREE_BALL_RADIUS + y;
        if (screen_y < 0 || screen_y >= LCD_HEIGHT) continue;
        for (int x = 0; x < DEMO_STAGE_THREE_BALL_DIAMETER; ++x) {
            const int index = y * DEMO_STAGE_THREE_BALL_DIAMETER + x;
            const uint8_t shade = stage_three_ball_shade_map[index];
            if (shade == 0U) continue;
            const int screen_x = centre_x - DEMO_STAGE_THREE_BALL_RADIUS + x;
            if (screen_x < 0 || screen_x >= LCD_WIDTH) continue;

            // The packed Demo icon is a rotating spherical texture. Set pixels replace
            // the Amiga ball's red checks; clear pixels retain the shaded white surface.
            const unsigned texture_x = ((((unsigned)stage_three_ball_longitude_map[index] *
                                          DEMO_LOGO_WIDTH) >> 8U) +
                                        (unsigned)rotation * DEMO_LOGO_WIDTH /
                                        DEMO_STAGE_THREE_BALL_LONGITUDE_BANDS) % DEMO_LOGO_WIDTH;
            const unsigned texture_y = ((unsigned)stage_three_ball_latitude_map[index] *
                                        DEMO_LOGO_HEIGHT) >> 8U;
            const size_t byte_index = (size_t)texture_y * DEMO_LOGO_ROW_BYTES + texture_x / 8U;
            const uint8_t bit = (uint8_t)(7U - texture_x % 8U);
            const bool icon_pixel = (bitmap[byte_index] & (uint8_t)(1U << bit)) != 0U;
            frame[(size_t)screen_y * LCD_WIDTH + (size_t)screen_x] = icon_pixel
                ? stage_three_red_shades[shade - 1U] : stage_three_white_shades[shade - 1U];
        }
    }
}

static demo_point_3d_t rotateMeshPoint(demo_point_3d_t point, const demo_rotation_t *rotation)

1. Executeconst float pitched_y = point.y * rotation->pitch_cosine - point.z * rotation->pitch_sine;
2. Executeconst float pitched_z = point.y * rotation->pitch_sine + point.z * rotation->pitch_cosine;
3. Executeconst float yawed_x = point.x * rotation->yaw_cosine + pitched_z * rotation->yaw_sine;
4. Executeconst float yawed_z = -point.x * rotation->yaw_sine + pitched_z * rotation->yaw_cosine;
5. Executeconst demo_point_3d_t result = { .x = yawed_x * rotation->roll_cosine - pitched_y * rotation->roll_sine, .y = yawed_x * rotation->roll_sine + pitched_y * rotation->roll_cosine, .z = yawed_z, };
6. Exit this functionreturn result;

static demo_point_3d_t rotateMeshPoint(demo_point_3d_t point, const demo_rotation_t *rotation)
{
    const float pitched_y = point.y * rotation->pitch_cosine - point.z * rotation->pitch_sine;
    const float pitched_z = point.y * rotation->pitch_sine + point.z * rotation->pitch_cosine;
    const float yawed_x = point.x * rotation->yaw_cosine + pitched_z * rotation->yaw_sine;
    const float yawed_z = -point.x * rotation->yaw_sine + pitched_z * rotation->yaw_cosine;
    const demo_point_3d_t result = {
        .x = yawed_x * rotation->roll_cosine - pitched_y * rotation->roll_sine,
        .y = yawed_x * rotation->roll_sine + pitched_y * rotation->roll_cosine,
        .z = yawed_z,
    };
    return result;
}

static graphics_point_t projectMeshPoint(const demo_point_3d_t *point)

1. Executeconst float perspective = DEMO_STAGE_SIX_CAMERA_DISTANCE / (DEMO_STAGE_SIX_CAMERA_DISTANCE + point->z);
2. Executeconst graphics_point_t result = { .x = DEMO_STAGE_SIX_CENTRE_X + (int)lroundf(point->x * perspective), .y = DEMO_STAGE_SIX_CENTRE_Y + (int)lroundf(point->y * perspective), };
3. Exit this functionreturn result;

static graphics_point_t projectMeshPoint(const demo_point_3d_t *point)
{
    const float perspective = DEMO_STAGE_SIX_CAMERA_DISTANCE /
                              (DEMO_STAGE_SIX_CAMERA_DISTANCE + point->z);
    const graphics_point_t result = {
        .x = DEMO_STAGE_SIX_CENTRE_X + (int)lroundf(point->x * perspective),
        .y = DEMO_STAGE_SIX_CENTRE_Y + (int)lroundf(point->y * perspective),
    };
    return result;
}

static uint16_t meshFaceColour(float brightness)

1. Executeconst demo_solid_colour_scheme_t *scheme = &demo_solid_colour_schemes[stage_six_colour_scheme_index];
2. Decisionbrightness > 0.76f
   True

   1. Exit this functionreturn scheme->face_shades[0];

   False

   Continue after this decision.

3. Decisionbrightness > 0.52f
   True

   1. Exit this functionreturn scheme->face_shades[1];

   False

   Continue after this decision.

4. Decisionbrightness > 0.28f
   True

   1. Exit this functionreturn scheme->face_shades[2];

   False

   Continue after this decision.

5. Exit this functionreturn scheme->face_shades[3];

static uint16_t meshFaceColour(float brightness)
{
    const demo_solid_colour_scheme_t *scheme =
        &demo_solid_colour_schemes[stage_six_colour_scheme_index];
    if (brightness > 0.76f) return scheme->face_shades[0];
    if (brightness > 0.52f) return scheme->face_shades[1];
    if (brightness > 0.28f) return scheme->face_shades[2];
    return scheme->face_shades[3];
}

static float meshFaceBrightness(const demo_point_3d_t *first, const demo_point_3d_t *second,
                                const demo_point_3d_t *third)

1. Executeconst demo_point_3d_t first_edge = { .x = second->x - first->x, .y = second->y - first->y, .z = second->z - first->z, };
2. Executeconst demo_point_3d_t second_edge = { .x = third->x - first->x, .y = third->y - first->y, .z = third->z - first->z, };
3. Executeconst demo_point_3d_t normal = { .x = first_edge.y * second_edge.z - first_edge.z * second_edge.y, .y = first_edge.z * second_edge.x - first_edge.x * second_edge.z, .z = first_edge.x * second_edge.y - first_edge.y * second_edge.x, };
4. Executeconst float length = sqrtf(normal.x * normal.x + normal.y * normal.y + normal.z * normal.z);
5. Decisionlength <= 0.0f
   True

   1. Exit this functionreturn 0.0f;

   False

   Continue after this decision.

6. Executeconst float light = fabsf((normal.x * 0.35f - normal.y * 0.45f + normal.z * 0.82f) / length);
7. Exit this functionreturn light > 1.0f ? 1.0f : light;

static float meshFaceBrightness(const demo_point_3d_t *first, const demo_point_3d_t *second,
                                const demo_point_3d_t *third)
{
    const demo_point_3d_t first_edge = {
        .x = second->x - first->x, .y = second->y - first->y, .z = second->z - first->z,
    };
    const demo_point_3d_t second_edge = {
        .x = third->x - first->x, .y = third->y - first->y, .z = third->z - first->z,
    };
    const demo_point_3d_t normal = {
        .x = first_edge.y * second_edge.z - first_edge.z * second_edge.y,
        .y = first_edge.z * second_edge.x - first_edge.x * second_edge.z,
        .z = first_edge.x * second_edge.y - first_edge.y * second_edge.x,
    };
    const float length = sqrtf(normal.x * normal.x + normal.y * normal.y + normal.z * normal.z);
    if (length <= 0.0f) return 0.0f;
    // Both sides are shaded because depth sorting, rather than culling, is what lets
    // one generic face table render solids with either winding direction.
    const float light = fabsf((normal.x * 0.35f - normal.y * 0.45f + normal.z * 0.82f) / length);
    return light > 1.0f ? 1.0f : light;
}

static void drawFilledMesh(uint16_t *frame, const demo_mesh_t *mesh,
                           const demo_rotation_t *rotation)

Calls into this documentation:

1. Decisionmesh == NULL || mesh->vertices == NULL || mesh->faces == NULL || mesh->vertex_count > DEMO_MESH_MAX_VERTICES || mesh->face_count > DEMO_MESH_MAX_FACES
   True

   1. 1. Exit this functionreturn;

   False

   Continue after this decision.

2. Executedemo_point_3d_t rotated_vertices[DEMO_MESH_MAX_VERTICES];
3. Executedemo_mesh_face_draw_t draw_order[DEMO_MESH_MAX_FACES];
4. FOR loopsize_t vertex = 0U; vertex < mesh->vertex_count; ++vertex

   Repeat body while the loop condition permits; then continue below.

   1. 1. Executedemo_point_3d_t scaled = mesh->vertices[vertex];
      2. Executescaled.x *= DEMO_STAGE_SIX_SOLID_SCALE;
      3. Executescaled.y *= DEMO_STAGE_SIX_SOLID_SCALE;
      4. Executescaled.z *= DEMO_STAGE_SIX_SOLID_SCALE;
      5. Executerotated_vertices[vertex] = rotateMeshPoint(scaled, rotation);
5. FOR loopsize_t face = 0U; face < mesh->face_count; ++face

   Repeat body while the loop condition permits; then continue below.

   1. 1. Executeconst demo_mesh_face_t *source_face = &mesh->faces[face];
      2. Decisionsource_face->vertex_indices == NULL || source_face->vertex_count < 3U || source_face->vertex_count > DEMO_MESH_MAX_FACE_VERTICES
         True

         1. 1. Exit this functionreturn;

         False

         Continue after this decision.

      3. Executefloat total_depth = 0.0f;
      4. FOR loopsize_t corner = 0U; corner < source_face->vertex_count; ++corner

         Repeat body while the loop condition permits; then continue below.

         1. 1. Executeconst uint8_t vertex = source_face->vertex_indices[corner];
            2. Decisionvertex >= mesh->vertex_count
               True

               1. Exit this functionreturn;

               False

               Continue after this decision.

            3. Executetotal_depth += rotated_vertices[vertex].z;
      5. Executedraw_order[face] = (demo_mesh_face_draw_t) { .face_index = face, .depth = total_depth / (float)source_face->vertex_count, .brightness = meshFaceBrightness(&rotated_vertices[source_face->vertex_indices[0]], &rotated_vertices[source_face->vertex_indices[1]], &rotated_vertices[source_face->vertex_indices[2]]), };
6. FOR loopsize_t pass = 0U; pass + 1U < mesh->face_count; ++pass

   Repeat body while the loop condition permits; then continue below.

   1. 1. FOR loopsize_t index = 0U; index + 1U < mesh->face_count - pass; ++index

         Repeat body while the loop condition permits; then continue below.

         1. 1. Decisiondraw_order[index].depth <= draw_order[index + 1U].depth
               True

               1. Next loop iterationcontinue;

               False

               Continue after this decision.

            2. Executeconst demo_mesh_face_draw_t temporary = draw_order[index];
            3. Executedraw_order[index] = draw_order[index + 1U];
            4. Executedraw_order[index + 1U] = temporary;
7. FOR loopsize_t order = 0U; order < mesh->face_count; ++order

   Repeat body while the loop condition permits; then continue below.

   1. 1. Executeconst demo_mesh_face_t *source_face = &mesh->faces[draw_order[order].face_index];
      2. Executegraphics_point_t polygon[DEMO_MESH_MAX_FACE_VERTICES];
      3. FOR loopsize_t corner = 0U; corner < source_face->vertex_count; ++corner

         Repeat body while the loop condition permits; then continue below.

         1. 1. Executepolygon[corner] = projectMeshPoint(&rotated_vertices[source_face->vertex_indices[corner]]);
      4. Executefill_convex_polygon(frame, polygon, source_face->vertex_count, meshFaceColour(draw_order[order].brightness));
      5. FOR loopsize_t corner = 0U; corner < source_face->vertex_count; ++corner

         Repeat body while the loop condition permits; then continue below.

         1. 1. Executeconst size_t next_corner = (corner + 1U) % source_face->vertex_count;
            2. Executedraw_line(frame, polygon[corner].x, polygon[corner].y, polygon[next_corner].x, polygon[next_corner].y, demo_solid_colour_schemes[stage_six_colour_scheme_index].edge);

static void drawFilledMesh(uint16_t *frame, const demo_mesh_t *mesh,
                           const demo_rotation_t *rotation)
{
    if (mesh == NULL || mesh->vertices == NULL || mesh->faces == NULL ||
        mesh->vertex_count > DEMO_MESH_MAX_VERTICES || mesh->face_count > DEMO_MESH_MAX_FACES) {
        return;
    }

    demo_point_3d_t rotated_vertices[DEMO_MESH_MAX_VERTICES];
    demo_mesh_face_draw_t draw_order[DEMO_MESH_MAX_FACES];
    for (size_t vertex = 0U; vertex < mesh->vertex_count; ++vertex) {
        demo_point_3d_t scaled = mesh->vertices[vertex];
        scaled.x *= DEMO_STAGE_SIX_SOLID_SCALE;
        scaled.y *= DEMO_STAGE_SIX_SOLID_SCALE;
        scaled.z *= DEMO_STAGE_SIX_SOLID_SCALE;
        rotated_vertices[vertex] = rotateMeshPoint(scaled, rotation);
    }

    for (size_t face = 0U; face < mesh->face_count; ++face) {
        const demo_mesh_face_t *source_face = &mesh->faces[face];
        if (source_face->vertex_indices == NULL || source_face->vertex_count < 3U ||
            source_face->vertex_count > DEMO_MESH_MAX_FACE_VERTICES) {
            return;
        }
        float total_depth = 0.0f;
        for (size_t corner = 0U; corner < source_face->vertex_count; ++corner) {
            const uint8_t vertex = source_face->vertex_indices[corner];
            if (vertex >= mesh->vertex_count) return;
            total_depth += rotated_vertices[vertex].z;
        }
        draw_order[face] = (demo_mesh_face_draw_t) {
            .face_index = face,
            .depth = total_depth / (float)source_face->vertex_count,
            .brightness = meshFaceBrightness(&rotated_vertices[source_face->vertex_indices[0]],
                                             &rotated_vertices[source_face->vertex_indices[1]],
                                             &rotated_vertices[source_face->vertex_indices[2]]),
        };
    }

    // Painter's order draws the farthest polygon first, allowing nearer filled faces
    // to cover it without a full per-pixel depth buffer.
    for (size_t pass = 0U; pass + 1U < mesh->face_count; ++pass) {
        for (size_t index = 0U; index + 1U < mesh->face_count - pass; ++index) {
            if (draw_order[index].depth <= draw_order[index + 1U].depth) continue;
            const demo_mesh_face_draw_t temporary = draw_order[index];
            draw_order[index] = draw_order[index + 1U];
            draw_order[index + 1U] = temporary;
        }
    }

    for (size_t order = 0U; order < mesh->face_count; ++order) {
        const demo_mesh_face_t *source_face = &mesh->faces[draw_order[order].face_index];
        graphics_point_t polygon[DEMO_MESH_MAX_FACE_VERTICES];
        for (size_t corner = 0U; corner < source_face->vertex_count; ++corner) {
            polygon[corner] = projectMeshPoint(&rotated_vertices[source_face->vertex_indices[corner]]);
        }
        fill_convex_polygon(frame, polygon, source_face->vertex_count,
                            meshFaceColour(draw_order[order].brightness));
        for (size_t corner = 0U; corner < source_face->vertex_count; ++corner) {
            const size_t next_corner = (corner + 1U) % source_face->vertex_count;
            draw_line(frame, polygon[corner].x, polygon[corner].y,
                      polygon[next_corner].x, polygon[next_corner].y,
                      demo_solid_colour_schemes[stage_six_colour_scheme_index].edge);
        }
    }
}

static void drawStageSixSolid(uint16_t *frame)

Calls into this documentation:

1. Executeconst float pitch_radians = pitch_degrees * DEMO_PI / 180.0f;
2. Executeconst float yaw_radians = yaw_degrees * DEMO_PI / 180.0f;
3. Executeconst float roll_radians = roll_degrees * DEMO_PI / 180.0f;
4. Executeconst demo_rotation_t rotation = { .pitch_cosine = cosf(pitch_radians), .pitch_sine = sinf(pitch_radians), .yaw_cosine = cosf(yaw_radians), .yaw_sine = sinf(yaw_radians), .roll_cosine = cosf(roll_radians), .roll_sine = sinf(roll_radians), };
5. ExecutedrawFilledMesh(frame, stage_six_current_mesh, &rotation);

static void drawStageSixSolid(uint16_t *frame)
{
    const float pitch_radians = pitch_degrees * DEMO_PI / 180.0f;
    const float yaw_radians = yaw_degrees * DEMO_PI / 180.0f;
    const float roll_radians = roll_degrees * DEMO_PI / 180.0f;
    const demo_rotation_t rotation = {
        .pitch_cosine = cosf(pitch_radians), .pitch_sine = sinf(pitch_radians),
        .yaw_cosine = cosf(yaw_radians), .yaw_sine = sinf(yaw_radians),
        .roll_cosine = cosf(roll_radians), .roll_sine = sinf(roll_radians),
    };
    drawFilledMesh(frame, stage_six_current_mesh, &rotation);
}

static demo_rotation_t stageSeventeenRotation(float pitch_degrees, float yaw_degrees,
                                              float roll_degrees)

1. Executeconst float pitch = pitch_degrees * DEMO_PI / 180.0f;
2. Executeconst float yaw = yaw_degrees * DEMO_PI / 180.0f;
3. Executeconst float roll = roll_degrees * DEMO_PI / 180.0f;
4. Exit this functionreturn (demo_rotation_t) { .pitch_cosine = cosf(pitch), .pitch_sine = sinf(pitch), .yaw_cosine = cosf(yaw), .yaw_sine = sinf(yaw), .roll_cosine = cosf(roll), .roll_sine = sinf(roll), };

static demo_rotation_t stageSeventeenRotation(float pitch_degrees, float yaw_degrees,
                                              float roll_degrees)
{
    const float pitch = pitch_degrees * DEMO_PI / 180.0f;
    const float yaw = yaw_degrees * DEMO_PI / 180.0f;
    const float roll = roll_degrees * DEMO_PI / 180.0f;
    return (demo_rotation_t) {
        .pitch_cosine = cosf(pitch), .pitch_sine = sinf(pitch),
        .yaw_cosine = cosf(yaw), .yaw_sine = sinf(yaw),
        .roll_cosine = cosf(roll), .roll_sine = sinf(roll),
    };
}

static demo_point_3d_t stageSeventeenGearOrigin(unsigned gear)

1. Select a casegear

   Enter matching case; follow source fall-through until a break, return or end.

   1. 1. Case / labelcase 0U:
      2. Exit this functionreturn (demo_point_3d_t) {.x = 0.0f, .y = DEMO_STAGE_SEVENTEEN_LEAD_Y, .z = 0.0f};
      3. Case / labelcase 1U:
      4. Exit this functionreturn (demo_point_3d_t) {.x = -DEMO_STAGE_SEVENTEEN_DRIVEN_X, .y = DEMO_STAGE_SEVENTEEN_DRIVEN_Y, .z = 0.0f};
      5. Case / labeldefault:
      6. Exit this functionreturn (demo_point_3d_t) {.x = DEMO_STAGE_SEVENTEEN_DRIVEN_X, .y = DEMO_STAGE_SEVENTEEN_DRIVEN_Y, .z = 0.0f};

static demo_point_3d_t stageSeventeenGearOrigin(unsigned gear)
{
    switch (gear) {
        case 0U: return (demo_point_3d_t) {.x = 0.0f, .y = DEMO_STAGE_SEVENTEEN_LEAD_Y,
                                             .z = 0.0f};
        case 1U: return (demo_point_3d_t) {.x = -DEMO_STAGE_SEVENTEEN_DRIVEN_X,
                                             .y = DEMO_STAGE_SEVENTEEN_DRIVEN_Y, .z = 0.0f};
        default: return (demo_point_3d_t) {.x = DEMO_STAGE_SEVENTEEN_DRIVEN_X,
                                            .y = DEMO_STAGE_SEVENTEEN_DRIVEN_Y, .z = 0.0f};
    }
}

static demo_rotation_t stageSeventeenGearAxisRotation(unsigned gear)

Calls into this documentation:

1. Select a casegear

   Enter matching case; follow source fall-through until a break, return or end.

   1. 1. Case / labelcase 0U:
      2. Exit this functionreturn stageSeventeenRotation(-22.5f, 0.0f, 0.0f);
      3. Case / labelcase 1U:
      4. Exit this functionreturn stageSeventeenRotation(14.8f, 22.5f, 0.0f);
      5. Case / labeldefault:
      6. Exit this functionreturn stageSeventeenRotation(14.8f, -22.5f, 0.0f);

static demo_rotation_t stageSeventeenGearAxisRotation(unsigned gear)
{
    // Each backward axis converges toward the triangular centre. The front
    // centres therefore remain at the wide-rim mesh contacts while the narrow
    // rear centres close by the same ratio as the tapering tooth radii.
    switch (gear) {
        case 0U: return stageSeventeenRotation(-22.5f, 0.0f, 0.0f);
        case 1U: return stageSeventeenRotation(14.8f, 22.5f, 0.0f);
        default: return stageSeventeenRotation(14.8f, -22.5f, 0.0f);
    }
}

static demo_point_3d_t stageSeventeenTransformPoint(demo_point_3d_t point,
                                                     const demo_point_3d_t *origin,
                                                     const demo_rotation_t *axis_rotation,
                                                     const demo_rotation_t *rig_rotation)

Calls into this documentation:

1. Executedemo_point_3d_t transformed = rotateMeshPoint(point, axis_rotation);
2. Executetransformed.x += origin->x;
3. Executetransformed.y += origin->y;
4. Executetransformed.z += origin->z;
5. Exit this functionreturn rotateMeshPoint(transformed, rig_rotation);

static demo_point_3d_t stageSeventeenTransformPoint(demo_point_3d_t point,
                                                     const demo_point_3d_t *origin,
                                                     const demo_rotation_t *axis_rotation,
                                                     const demo_rotation_t *rig_rotation)
{
    demo_point_3d_t transformed = rotateMeshPoint(point, axis_rotation);
    transformed.x += origin->x;
    transformed.y += origin->y;
    transformed.z += origin->z;
    return rotateMeshPoint(transformed, rig_rotation);
}

static graphics_point_t stageSeventeenProjectPoint(const demo_point_3d_t *point)

1. Executeconst float perspective = DEMO_STAGE_SEVENTEEN_CAMERA_DISTANCE / (DEMO_STAGE_SEVENTEEN_CAMERA_DISTANCE + point->z);
2. Exit this functionreturn (graphics_point_t) { .x = DEMO_STAGE_SEVENTEEN_CENTRE_X + (int)lroundf(point->x * perspective), .y = DEMO_STAGE_SEVENTEEN_CENTRE_Y + (int)lroundf(point->y * perspective), };

static graphics_point_t stageSeventeenProjectPoint(const demo_point_3d_t *point)
{
    const float perspective = DEMO_STAGE_SEVENTEEN_CAMERA_DISTANCE /
                              (DEMO_STAGE_SEVENTEEN_CAMERA_DISTANCE + point->z);
    return (graphics_point_t) {
        .x = DEMO_STAGE_SEVENTEEN_CENTRE_X + (int)lroundf(point->x * perspective),
        .y = DEMO_STAGE_SEVENTEEN_CENTRE_Y + (int)lroundf(point->y * perspective),
    };
}

static uint16_t stageSeventeenFaceColour(void)

1. Decisionstage_seventeen_style == STAGE_SEVENTEEN_STYLE_FLAT
   True

   1. Exit this functionreturn RGB565(230, 195, 30);

   False

   Continue after this decision.

2. Decisionstage_seventeen_style == STAGE_SEVENTEEN_STYLE_METALLIC
   True

   1. Exit this functionreturn RGB565(255, 220, 70);

   False

   Continue after this decision.

3. Exit this functionreturn COLOR_BLACK;

static uint16_t stageSeventeenFaceColour(void)
{
    if (stage_seventeen_style == STAGE_SEVENTEEN_STYLE_FLAT) return RGB565(230, 195, 30);
    if (stage_seventeen_style == STAGE_SEVENTEEN_STYLE_METALLIC) return RGB565(255, 220, 70);
    return COLOR_BLACK;
}

static uint16_t stageSeventeenRearColour(void)

1. Decisionstage_seventeen_style == STAGE_SEVENTEEN_STYLE_FLAT
   True

   1. Exit this functionreturn RGB565(170, 135, 10);

   False

   Continue after this decision.

2. Decisionstage_seventeen_style == STAGE_SEVENTEEN_STYLE_METALLIC
   True

   1. Exit this functionreturn RGB565(210, 175, 30);

   False

   Continue after this decision.

3. Exit this functionreturn COLOR_BLACK;

static uint16_t stageSeventeenRearColour(void)
{
    if (stage_seventeen_style == STAGE_SEVENTEEN_STYLE_FLAT) return RGB565(170, 135, 10);
    if (stage_seventeen_style == STAGE_SEVENTEEN_STYLE_METALLIC) return RGB565(210, 175, 30);
    return COLOR_BLACK;
}

static uint16_t stageSeventeenSideColour(unsigned segment)

1. Decisionstage_seventeen_style == STAGE_SEVENTEEN_STYLE_FLAT
   True

   1. 1. Exit this functionreturn (segment & 2U) == 0U ? RGB565(160, 120, 8) : RGB565(90, 68, 2);

   False

   Continue after this decision.

2. Decisionstage_seventeen_style == STAGE_SEVENTEEN_STYLE_METALLIC
   True

   1. 1. Exit this functionreturn (segment & 2U) == 0U ? RGB565(195, 155, 18) : RGB565(115, 85, 3);

   False

   Continue after this decision.

3. Exit this functionreturn COLOR_BLACK;

static uint16_t stageSeventeenSideColour(unsigned segment)
{
    if (stage_seventeen_style == STAGE_SEVENTEEN_STYLE_FLAT) {
        return (segment & 2U) == 0U ? RGB565(160, 120, 8) : RGB565(90, 68, 2);
    }
    if (stage_seventeen_style == STAGE_SEVENTEEN_STYLE_METALLIC) {
        return (segment & 2U) == 0U ? RGB565(195, 155, 18) : RGB565(115, 85, 3);
    }
    return COLOR_BLACK;
}

static uint16_t stageSeventeenEdgeColour(void)

1. Exit this functionreturn stage_seventeen_style == STAGE_SEVENTEEN_STYLE_METALLIC ? RGB565(255, 245, 160) : RGB565(255, 220, 50);

static uint16_t stageSeventeenEdgeColour(void)
{
    return stage_seventeen_style == STAGE_SEVENTEEN_STYLE_METALLIC ? RGB565(255, 245, 160) :
        RGB565(255, 220, 50);
}

static void stageSeventeenAppendFace(const graphics_point_t *points, uint8_t point_count,
                                     float depth, uint16_t colour)

1. Decisionstage_seventeen_draw_face_count >= DEMO_STAGE_SEVENTEEN_DRAW_FACE_COUNT || point_count < 3U || point_count > 4U
   True

   1. Exit this functionreturn;

   False

   Continue after this decision.

2. Executestage_seventeen_draw_face_t *const face = &stage_seventeen_draw_faces[stage_seventeen_draw_face_count++];
3. FOR loopuint8_t point = 0U; point < point_count; ++point

   Repeat body while the loop condition permits; then continue below.

   1. Executeface->points[point] = points[point];
4. Executeface->depth = depth;
5. Executeface->colour = colour;
6. Executeface->point_count = point_count;

static void stageSeventeenAppendFace(const graphics_point_t *points, uint8_t point_count,
                                     float depth, uint16_t colour)
{
    if (stage_seventeen_draw_face_count >= DEMO_STAGE_SEVENTEEN_DRAW_FACE_COUNT ||
        point_count < 3U || point_count > 4U) return;
    stage_seventeen_draw_face_t *const face =
        &stage_seventeen_draw_faces[stage_seventeen_draw_face_count++];
    for (uint8_t point = 0U; point < point_count; ++point) face->points[point] = points[point];
    face->depth = depth;
    face->colour = colour;
    face->point_count = point_count;
}

static void stageSeventeenBuildGear(unsigned gear, const demo_rotation_t *rig_rotation)

Calls into this documentation:

1. Executeconst unsigned point_count = DEMO_STAGE_SEVENTEEN_TOOTH_COUNT * 2U;
2. Executegraphics_point_t front[DEMO_STAGE_SEVENTEEN_TOOTH_COUNT * 2U];
3. Executegraphics_point_t rear[DEMO_STAGE_SEVENTEEN_TOOTH_COUNT * 2U];
4. Executedemo_point_3d_t front_points[DEMO_STAGE_SEVENTEEN_TOOTH_COUNT * 2U];
5. Executedemo_point_3d_t rear_points[DEMO_STAGE_SEVENTEEN_TOOTH_COUNT * 2U];
6. Executeconst demo_point_3d_t origin = stageSeventeenGearOrigin(gear);
7. Executeconst demo_rotation_t axis_rotation = stageSeventeenGearAxisRotation(gear);
8. Executeconst float spin = stage_seventeen_gear_degrees[gear] * DEMO_PI / 180.0f;
9. Executeconst float front_z = 0.0f;
10. Executeconst float rear_z = DEMO_STAGE_SEVENTEEN_CONE_DEPTH;
11. Executedemo_point_3d_t front_centre = {.x = 0.0f, .y = 0.0f, .z = front_z};
12. Executedemo_point_3d_t rear_centre = {.x = 0.0f, .y = 0.0f, .z = rear_z};
13. Executefront_centre = stageSeventeenTransformPoint(front_centre, &origin, &axis_rotation, rig_rotation);
14. Executerear_centre = stageSeventeenTransformPoint(rear_centre, &origin, &axis_rotation, rig_rotation);
15. Executeconst graphics_point_t projected_front_centre = stageSeventeenProjectPoint(&front_centre);
16. Executeconst graphics_point_t projected_rear_centre = stageSeventeenProjectPoint(&rear_centre);
17. FOR loopunsigned point = 0U; point < point_count; ++point

    Repeat body while the loop condition permits; then continue below.

    1. 1. Executeconst float angle = spin + (float)point * DEMO_PI / (float)DEMO_STAGE_SEVENTEEN_TOOTH_COUNT;
       2. Executeconst float front_radius = (point & 1U) == 0U ? DEMO_STAGE_SEVENTEEN_FRONT_RADIUS : DEMO_STAGE_SEVENTEEN_FRONT_RADIUS * DEMO_STAGE_SEVENTEEN_TOOTH_ROOT_RATIO;
       3. Executeconst float rear_radius = (point & 1U) == 0U ? DEMO_STAGE_SEVENTEEN_REAR_RADIUS : DEMO_STAGE_SEVENTEEN_REAR_RADIUS * DEMO_STAGE_SEVENTEEN_TOOTH_ROOT_RATIO;
       4. Executedemo_point_3d_t front_point = { .x = cosf(angle) * front_radius, .y = sinf(angle) * front_radius, .z = front_z, };
       5. Executedemo_point_3d_t rear_point = { .x = cosf(angle) * rear_radius, .y = sinf(angle) * rear_radius, .z = rear_z, };
       6. Executefront_points[point] = stageSeventeenTransformPoint(front_point, &origin, &axis_rotation, rig_rotation);
       7. Executerear_points[point] = stageSeventeenTransformPoint(rear_point, &origin, &axis_rotation, rig_rotation);
       8. Executefront[point] = stageSeventeenProjectPoint(&front_points[point]);
       9. Executerear[point] = stageSeventeenProjectPoint(&rear_points[point]);
18. FOR loopunsigned point = 0U; point < point_count; ++point

    Repeat body while the loop condition permits; then continue below.

    1. 1. Executeconst unsigned next = (point + 1U) % point_count;
       2. Executeconst graphics_point_t side[] = {rear[point], rear[next], front[next], front[point]};
       3. ExecutestageSeventeenAppendFace(side, 4U, (rear_points[point].z + rear_points[next].z + front_points[next].z + front_points[point].z) * 0.25f, stageSeventeenSideColour(point));
       4. Executeconst graphics_point_t wedge[] = {projected_front_centre, front[point], front[next]};
       5. ExecutestageSeventeenAppendFace(wedge, 3U, (front_centre.z + front_points[point].z + front_points[next].z) / 3.0f, stageSeventeenFaceColour());
       6. Executeconst graphics_point_t rear_wedge[] = {projected_rear_centre, rear[next], rear[point]};
       7. ExecutestageSeventeenAppendFace(rear_wedge, 3U, (rear_centre.z + rear_points[point].z + rear_points[next].z) / 3.0f, stageSeventeenRearColour());

static void stageSeventeenBuildGear(unsigned gear, const demo_rotation_t *rig_rotation)
{
    const unsigned point_count = DEMO_STAGE_SEVENTEEN_TOOTH_COUNT * 2U;
    graphics_point_t front[DEMO_STAGE_SEVENTEEN_TOOTH_COUNT * 2U];
    graphics_point_t rear[DEMO_STAGE_SEVENTEEN_TOOTH_COUNT * 2U];
    demo_point_3d_t front_points[DEMO_STAGE_SEVENTEEN_TOOTH_COUNT * 2U];
    demo_point_3d_t rear_points[DEMO_STAGE_SEVENTEEN_TOOTH_COUNT * 2U];
    const demo_point_3d_t origin = stageSeventeenGearOrigin(gear);
    const demo_rotation_t axis_rotation = stageSeventeenGearAxisRotation(gear);
    const float spin = stage_seventeen_gear_degrees[gear] * DEMO_PI / 180.0f;
    // Origins are the wide, front-face centres. Each gear then narrows and
    // travels inward through its complete depth toward the shared rear mesh.
    const float front_z = 0.0f;
    const float rear_z = DEMO_STAGE_SEVENTEEN_CONE_DEPTH;
    demo_point_3d_t front_centre = {.x = 0.0f, .y = 0.0f, .z = front_z};
    demo_point_3d_t rear_centre = {.x = 0.0f, .y = 0.0f, .z = rear_z};
    front_centre = stageSeventeenTransformPoint(front_centre, &origin, &axis_rotation, rig_rotation);
    rear_centre = stageSeventeenTransformPoint(rear_centre, &origin, &axis_rotation, rig_rotation);
    const graphics_point_t projected_front_centre = stageSeventeenProjectPoint(&front_centre);
    const graphics_point_t projected_rear_centre = stageSeventeenProjectPoint(&rear_centre);

    for (unsigned point = 0U; point < point_count; ++point) {
        const float angle = spin + (float)point * DEMO_PI / (float)DEMO_STAGE_SEVENTEEN_TOOTH_COUNT;
        const float front_radius = (point & 1U) == 0U ? DEMO_STAGE_SEVENTEEN_FRONT_RADIUS :
            DEMO_STAGE_SEVENTEEN_FRONT_RADIUS * DEMO_STAGE_SEVENTEEN_TOOTH_ROOT_RATIO;
        // Preserve the same tooth/gap rhythm on the narrow end. Joining these
        // matching corners makes every tooth a full tapered ridge, rather than
        // letting the front cog collapse into a smooth conical rear hub.
        const float rear_radius = (point & 1U) == 0U ? DEMO_STAGE_SEVENTEEN_REAR_RADIUS :
            DEMO_STAGE_SEVENTEEN_REAR_RADIUS * DEMO_STAGE_SEVENTEEN_TOOTH_ROOT_RATIO;
        demo_point_3d_t front_point = {
            .x = cosf(angle) * front_radius, .y = sinf(angle) * front_radius, .z = front_z,
        };
        demo_point_3d_t rear_point = {
            .x = cosf(angle) * rear_radius,
            .y = sinf(angle) * rear_radius, .z = rear_z,
        };
        front_points[point] =
            stageSeventeenTransformPoint(front_point, &origin, &axis_rotation, rig_rotation);
        rear_points[point] =
            stageSeventeenTransformPoint(rear_point, &origin, &axis_rotation, rig_rotation);
        front[point] = stageSeventeenProjectPoint(&front_points[point]);
        rear[point] = stageSeventeenProjectPoint(&rear_points[point]);
    }

    for (unsigned point = 0U; point < point_count; ++point) {
        const unsigned next = (point + 1U) % point_count;
        const graphics_point_t side[] = {rear[point], rear[next], front[next], front[point]};
        stageSeventeenAppendFace(side, 4U,
            (rear_points[point].z + rear_points[next].z + front_points[next].z +
             front_points[point].z) * 0.25f, stageSeventeenSideColour(point));
        // A cog outline is concave at the tooth roots, so its front remains a
        // set of separately sorted centre wedges rather than one polygon.
        const graphics_point_t wedge[] = {projected_front_centre, front[point], front[next]};
        stageSeventeenAppendFace(wedge, 3U,
            (front_centre.z + front_points[point].z + front_points[next].z) / 3.0f,
            stageSeventeenFaceColour());
        // The rear is also concave at its tooth roots. Its individual wedges
        // close the narrow end without crossing the adjacent tapered ridges.
        const graphics_point_t rear_wedge[] = {projected_rear_centre, rear[next], rear[point]};
        stageSeventeenAppendFace(rear_wedge, 3U,
            (rear_centre.z + rear_points[point].z + rear_points[next].z) / 3.0f,
            stageSeventeenRearColour());
    }
}

static void drawStageSeventeenBevelGears(uint16_t *frame)

Calls into this documentation:

1. Executeconst demo_rotation_t rig_rotation = stageSeventeenRotation(stage_seventeen_rig_pitch_degrees, stage_seventeen_rig_yaw_degrees, stage_seventeen_rig_roll_degrees);
2. Executestage_seventeen_draw_face_count = 0U;
3. FOR loopunsigned gear = 0U; gear < 3U; ++gear

   Repeat body while the loop condition permits; then continue below.

   1. ExecutestageSeventeenBuildGear(gear, &rig_rotation);
4. FOR loopsize_t pass = 0U; pass + 1U < stage_seventeen_draw_face_count; ++pass

   Repeat body while the loop condition permits; then continue below.

   1. 1. FOR loopsize_t index = 0U; index + 1U < stage_seventeen_draw_face_count - pass; ++index

         Repeat body while the loop condition permits; then continue below.

         1. 1. Decisionstage_seventeen_draw_faces[index].depth >= stage_seventeen_draw_faces[index + 1U].depth
               True

               1. Next loop iterationcontinue;

               False

               Continue after this decision.

            2. Executeconst stage_seventeen_draw_face_t temporary = stage_seventeen_draw_faces[index];
            3. Executestage_seventeen_draw_faces[index] = stage_seventeen_draw_faces[index + 1U];
            4. Executestage_seventeen_draw_faces[index + 1U] = temporary;
5. FOR loopsize_t face_index = 0U; face_index < stage_seventeen_draw_face_count; ++face_index

   Repeat body while the loop condition permits; then continue below.

   1. 1. Executeconst stage_seventeen_draw_face_t *const face = &stage_seventeen_draw_faces[face_index];
      2. Decisionstage_seventeen_style != STAGE_SEVENTEEN_STYLE_OUTLINE
         True

         1. 1. Executefill_convex_polygon(frame, face->points, face->point_count, face->colour);

         False

         Continue after this decision.

      3. FOR loopuint8_t point = 0U; point < face->point_count; ++point

         Repeat body while the loop condition permits; then continue below.

         1. 1. Executeconst uint8_t next = (uint8_t)((point + 1U) % face->point_count);
            2. Executedraw_line(frame, face->points[point].x, face->points[point].y, face->points[next].x, face->points[next].y, stageSeventeenEdgeColour());

static void drawStageSeventeenBevelGears(uint16_t *frame)
{
    const demo_rotation_t rig_rotation = stageSeventeenRotation(stage_seventeen_rig_pitch_degrees,
        stage_seventeen_rig_yaw_degrees, stage_seventeen_rig_roll_degrees);
    stage_seventeen_draw_face_count = 0U;
    for (unsigned gear = 0U; gear < 3U; ++gear) stageSeventeenBuildGear(gear, &rig_rotation);
    // Positive Z is farther from this camera. Sorting every tooth face, rather
    // than three whole gears, preserves the interlock throughout the rig tumble.
    for (size_t pass = 0U; pass + 1U < stage_seventeen_draw_face_count; ++pass) {
        for (size_t index = 0U; index + 1U < stage_seventeen_draw_face_count - pass; ++index) {
            if (stage_seventeen_draw_faces[index].depth >=
                stage_seventeen_draw_faces[index + 1U].depth) continue;
            const stage_seventeen_draw_face_t temporary = stage_seventeen_draw_faces[index];
            stage_seventeen_draw_faces[index] = stage_seventeen_draw_faces[index + 1U];
            stage_seventeen_draw_faces[index + 1U] = temporary;
        }
    }
    for (size_t face_index = 0U; face_index < stage_seventeen_draw_face_count; ++face_index) {
        const stage_seventeen_draw_face_t *const face = &stage_seventeen_draw_faces[face_index];
        if (stage_seventeen_style != STAGE_SEVENTEEN_STYLE_OUTLINE) {
            fill_convex_polygon(frame, face->points, face->point_count, face->colour);
        }
        for (uint8_t point = 0U; point < face->point_count; ++point) {
            const uint8_t next = (uint8_t)((point + 1U) % face->point_count);
            draw_line(frame, face->points[point].x, face->points[point].y,
                      face->points[next].x, face->points[next].y, stageSeventeenEdgeColour());
        }
    }
}

static void drawTextCornerIcons(uint16_t *frame)

Calls into this documentation:

1. Executeconst unsigned colour_count = sizeof(demo_scroll_rainbow_colours) / sizeof(demo_scroll_rainbow_colours[0]);
2. FOR loopsize_t corner = 0U; corner < sizeof(demo_text_corner_icon_slots) / sizeof(demo_text_corner_icon_slots[0]); ++corner

   Repeat body while the loop condition permits; then continue below.

   1. 1. Executeconst size_t slot = (size_t)demo_text_corner_icon_slots[corner] % DEMO_ICON_SLOT_COUNT;
      2. Executeconst uint8_t *bitmap = demo_icon_slots[slot];
      3. Executeconst demo_text_corner_icon_cycle_t *const cycle = &demo_text_corner_icon_cycles[corner];
      4. Executeconst float rotation_degrees = cycle->rotation_start_degrees + (float)cycle->rotation_degrees_per_second * (float)(last_update_ms - cycle->rotation_started_at) / 1000.0f;
      5. Executeconst float rotation_radians = rotation_degrees * DEMO_PI / 180.0f;
      6. Executeconst demo_rotation_t rotation = { .pitch_cosine = 1.0f, .pitch_sine = 0.0f, .yaw_cosine = 1.0f, .yaw_sine = 0.0f, .roll_cosine = cosf(rotation_radians), .roll_sine = sinf(rotation_radians), };
      7. Executeconst float travel_phase = (float)(last_update_ms - cycle->cycle_started_at) / (float)cycle->cycle_duration_ms;
      8. Executeconst float centre_progress = 0.5f - 0.5f * cosf(travel_phase * 2.0f * DEMO_PI);
      9. Executeconst int centre_x = (int)lroundf((float)demo_text_corner_icon_x[corner] + ((float)(LCD_WIDTH / 2) - (float)demo_text_corner_icon_x[corner]) * centre_progress);
      10. Executeconst uint32_t pulse_offset = (uint32_t)corner * DEMO_TEXT_CORNER_ICON_PULSE_STAGGER_MS;
      11. Executeconst float pulse_phase = (float)((last_update_ms + pulse_offset) % DEMO_TEXT_CORNER_ICON_PULSE_MS) / (float)DEMO_TEXT_CORNER_ICON_PULSE_MS;
      12. Executeconst float pulse = 0.5f + 0.5f * sinf(pulse_phase * 2.0f * DEMO_PI);
      13. Executeconst float scale = DEMO_TEXT_CORNER_ICON_SCALE_MIN + (DEMO_TEXT_CORNER_ICON_SCALE_MAX - DEMO_TEXT_CORNER_ICON_SCALE_MIN) * pulse;
      14. Executeconst unsigned colour_index = (unsigned)(last_update_ms / DEMO_TEXT_CORNER_ICON_COLOUR_MS + corner * 2U) % colour_count;
      15. Executeconst uint16_t colour = demo_scroll_rainbow_colours[colour_index];
      16. FOR loopunsigned depth = DEMO_TEXT_CORNER_ICON_DEPTH; depth > 0U; depth -= DEMO_TEXT_CORNER_ICON_DEPTH_STEP

          Repeat body while the loop condition permits; then continue below.

          1. 1. ExecutedrawApproachLogoSlice(frame, bitmap, (float)depth, &rotation, scale, centre_x, demo_text_corner_icon_y[corner], C64_COLOR_DARK_GREY);
      17. ExecutedrawApproachLogoSlice(frame, bitmap, 0.0f, &rotation, scale, centre_x, demo_text_corner_icon_y[corner], colour);

static void drawTextCornerIcons(uint16_t *frame)
{
    // No value below comes from the main Demo rotation or either text effect.
    // Every icon's travel, pulse, colour, and rotation come from its own state.
    const unsigned colour_count = sizeof(demo_scroll_rainbow_colours) /
                                 sizeof(demo_scroll_rainbow_colours[0]);
    for (size_t corner = 0U; corner < sizeof(demo_text_corner_icon_slots) /
                                       sizeof(demo_text_corner_icon_slots[0]); ++corner) {
        const size_t slot = (size_t)demo_text_corner_icon_slots[corner] % DEMO_ICON_SLOT_COUNT;
        const uint8_t *bitmap = demo_icon_slots[slot];
        const demo_text_corner_icon_cycle_t *const cycle =
            &demo_text_corner_icon_cycles[corner];
        const float rotation_degrees = cycle->rotation_start_degrees +
            (float)cycle->rotation_degrees_per_second *
            (float)(last_update_ms - cycle->rotation_started_at) / 1000.0f;
        const float rotation_radians = rotation_degrees * DEMO_PI / 180.0f;
        const demo_rotation_t rotation = {
            .pitch_cosine = 1.0f, .pitch_sine = 0.0f,
            .yaw_cosine = 1.0f, .yaw_sine = 0.0f,
            .roll_cosine = cosf(rotation_radians),
            .roll_sine = sinf(rotation_radians),
        };
        // updateTextCornerIconCycles() restarts this cycle at every completed
        // trip with a newly random duration. This fraction therefore describes
        // one complete, independent edge -> centre -> edge journey.
        const float travel_phase = (float)(last_update_ms - cycle->cycle_started_at) /
                                   (float)cycle->cycle_duration_ms;
        // 0.0 at the outer corner, 1.0 at the centre X line, then back out.
        const float centre_progress = 0.5f - 0.5f * cosf(travel_phase * 2.0f * DEMO_PI);
        const int centre_x = (int)lroundf((float)demo_text_corner_icon_x[corner] +
                                          ((float)(LCD_WIDTH / 2) -
                                           (float)demo_text_corner_icon_x[corner]) *
                                          centre_progress);
        const uint32_t pulse_offset = (uint32_t)corner * DEMO_TEXT_CORNER_ICON_PULSE_STAGGER_MS;
        const float pulse_phase = (float)((last_update_ms + pulse_offset) %
                                          DEMO_TEXT_CORNER_ICON_PULSE_MS) /
                                  (float)DEMO_TEXT_CORNER_ICON_PULSE_MS;
        const float pulse = 0.5f + 0.5f * sinf(pulse_phase * 2.0f * DEMO_PI);
        const float scale = DEMO_TEXT_CORNER_ICON_SCALE_MIN +
                            (DEMO_TEXT_CORNER_ICON_SCALE_MAX -
                             DEMO_TEXT_CORNER_ICON_SCALE_MIN) * pulse;
        const unsigned colour_index = (unsigned)(last_update_ms /
                                      DEMO_TEXT_CORNER_ICON_COLOUR_MS + corner * 2U) % colour_count;
        const uint16_t colour = demo_scroll_rainbow_colours[colour_index];

        // Draw far slices first so the pulsing coloured face remains in front.
        for (unsigned depth = DEMO_TEXT_CORNER_ICON_DEPTH; depth > 0U;
             depth -= DEMO_TEXT_CORNER_ICON_DEPTH_STEP) {
            drawApproachLogoSlice(frame, bitmap, (float)depth, &rotation, scale,
                                  centre_x, demo_text_corner_icon_y[corner], C64_COLOR_DARK_GREY);
        }
        drawApproachLogoSlice(frame, bitmap, 0.0f, &rotation, scale,
                              centre_x, demo_text_corner_icon_y[corner], colour);
    }
}

static void drawStageFifteenBattleZoneBackground(uint16_t *frame)

Calls into this documentation:

1. Executeconst int source_top = BATTLE_ZONE_HORIZON_Y;
2. Executeconst int source_height = LCD_HEIGHT - source_top;
3. Executeconst int destination_top = DEMO_STAGE_FIFTEEN_HORIZON_Y;
4. Executeconst int destination_height = LCD_HEIGHT - destination_top;
5. Executeconst int forward_source_offset = (int)( (raster_band_effect_elapsed_ms % DEMO_STAGE_FIFTEEN_FORWARD_CYCLE_MS) * (uint32_t)source_height / DEMO_STAGE_FIFTEEN_FORWARD_CYCLE_MS);
6. ExecutedrawBattleZoneLandscape(frame);
7. Decisionstage_fifteen_ground_source != NULL
   True

   1. 1. Executememcpy(stage_fifteen_ground_source, &frame[(size_t)source_top * LCD_WIDTH], (size_t)LCD_WIDTH * (size_t)source_height * sizeof(frame[0]));
      2. FOR loopint x = 0; x < LCD_WIDTH; ++x

         Repeat body while the loop condition permits; then continue below.

         1. 1. Executestage_fifteen_ground_source[x] = COLOR_BLACK;

   False

   Continue after this decision.

8. Decisionstage_fifteen_ground_source == NULL
   True

   1. 1. FOR loopint destination_y = LCD_HEIGHT - 1; destination_y >= destination_top; --destination_y

         Repeat body while the loop condition permits; then continue below.

         1. 1. Executeconst int source_y = source_top + (destination_y - destination_top) * (source_height - 1) / (destination_height - 1);
            2. Executememcpy(&frame[(size_t)destination_y * LCD_WIDTH], &frame[(size_t)source_y * LCD_WIDTH], LCD_WIDTH * sizeof(frame[0]));

   False

   1. 1. FOR loopint destination_y = LCD_HEIGHT - 1; destination_y >= destination_top; --destination_y

         Repeat body while the loop condition permits; then continue below.

         1. 1. Executeconst int unscrolled_source_offset = (destination_y - destination_top) * (source_height - 1) / (destination_height - 1);
            2. Executeconst int source_row = (unscrolled_source_offset - forward_source_offset + source_height) % source_height;
            3. Executememcpy(&frame[(size_t)destination_y * LCD_WIDTH], &stage_fifteen_ground_source[(size_t)source_row * LCD_WIDTH], LCD_WIDTH * sizeof(frame[0]));
9. Executefill_rect(frame, 0, 0, LCD_WIDTH, destination_top, COLOR_BLACK);
10. Executedraw_line(frame, 0, destination_top, LCD_WIDTH - 1, destination_top, COLOR_LIME);

static void drawStageFifteenBattleZoneBackground(uint16_t *frame)
{
    const int source_top = BATTLE_ZONE_HORIZON_Y;
    const int source_height = LCD_HEIGHT - source_top;
    const int destination_top = DEMO_STAGE_FIFTEEN_HORIZON_Y;
    const int destination_height = LCD_HEIGHT - destination_top;
    // Moving the source lookup upward makes terrain features travel down from
    // the horizon toward the viewer. A wrapped source introduces the next
    // ground pattern at the fixed horizon.
    const int forward_source_offset = (int)(
        (raster_band_effect_elapsed_ms % DEMO_STAGE_FIFTEEN_FORWARD_CYCLE_MS) *
        (uint32_t)source_height / DEMO_STAGE_FIFTEEN_FORWARD_CYCLE_MS);

    drawBattleZoneLandscape(frame);
    if (stage_fifteen_ground_source != NULL) {
        memcpy(stage_fifteen_ground_source, &frame[(size_t)source_top * LCD_WIDTH],
               (size_t)LCD_WIDTH * (size_t)source_height * sizeof(frame[0]));
        // The captured first ground row is Battle Zone's lime horizon. Segment
        // 15 draws its own fixed horizon below, so remove this copy before it
        // can wrap through the moving texture as an unwanted bright stripe.
        for (int x = 0; x < LCD_WIDTH; ++x) {
            stage_fifteen_ground_source[x] = COLOR_BLACK;
        }
    }

    if (stage_fifteen_ground_source == NULL) {
        // A PSRAM allocation failure leaves a static, safely compressed
        // landscape instead of risking corrupt rows with wrapped in-place reads.
        for (int destination_y = LCD_HEIGHT - 1; destination_y >= destination_top;
             --destination_y) {
            const int source_y = source_top +
                (destination_y - destination_top) * (source_height - 1) /
                (destination_height - 1);
            memcpy(&frame[(size_t)destination_y * LCD_WIDTH],
                   &frame[(size_t)source_y * LCD_WIDTH], LCD_WIDTH * sizeof(frame[0]));
        }
    } else {
        for (int destination_y = LCD_HEIGHT - 1; destination_y >= destination_top;
             --destination_y) {
            const int unscrolled_source_offset =
                (destination_y - destination_top) * (source_height - 1) /
                (destination_height - 1);
            const int source_row =
                (unscrolled_source_offset - forward_source_offset + source_height) % source_height;
            memcpy(&frame[(size_t)destination_y * LCD_WIDTH],
                   &stage_fifteen_ground_source[(size_t)source_row * LCD_WIDTH],
                   LCD_WIDTH * sizeof(frame[0]));
        }
    }
    // The original unscaled sky and terrain in the top half are no longer part
    // of this segment, leaving the bar and horizon-anchored scroller clear.
    fill_rect(frame, 0, 0, LCD_WIDTH, destination_top, COLOR_BLACK);
    // The wrapped texture moves, but the bright green horizon remains a stable
    // reference line exactly beneath the scroller.
    draw_line(frame, 0, destination_top, LCD_WIDTH - 1, destination_top, COLOR_LIME);
}

static void drawRasterBands(uint16_t *frame)

Calls into this documentation:

1. Executeconst bool lower_half_stage = selected_stage == DEMO_STAGE_LOWER_RASTER_SCROLLER;
2. Executeconst bool battle_zone_stage = selected_stage == DEMO_STAGE_BATTLE_ZONE_RASTER;
3. Executeconst int block_height = lower_half_stage ? DEMO_STAGE_FOURTEEN_BAND_HEIGHT : (battle_zone_stage ? DEMO_STAGE_FIFTEEN_BAND_BLOCK_HEIGHT : DEMO_STAGE_ELEVEN_BAND_BLOCK_HEIGHT);
4. Executeconst uint32_t drift_ms = battle_zone_stage ? DEMO_STAGE_FIFTEEN_BAND_DRIFT_MS : DEMO_STAGE_ELEVEN_BAND_DRIFT_MS;
5. Executeconst int travel_height = battle_zone_stage ? DEMO_STAGE_FIFTEEN_HORIZON_Y : LCD_HEIGHT;
6. Executeconst float drift_phase = (float)(raster_band_effect_elapsed_ms % drift_ms) / (float)drift_ms;
7. Executeconst int band_top = lower_half_stage ? DEMO_STAGE_FOURTEEN_BAND_TOP : (int)lroundf((float)(travel_height - block_height) * (0.5f + 0.5f * sinf(drift_phase * 2.0f * DEMO_PI)));
8. Executeconst demo_raster_band_palette_t *palette = demo_raster_band_palettes[raster_band_palette_index];
9. Executedraw_rolling_raster_band(frame, band_top, block_height, DEMO_STAGE_ELEVEN_BAND_HEIGHT, raster_band_effect_elapsed_ms, DEMO_STAGE_ELEVEN_COLOUR_ROLL_MS, palette);

static void drawRasterBands(uint16_t *frame)
{
    const bool lower_half_stage = selected_stage == DEMO_STAGE_LOWER_RASTER_SCROLLER;
    const bool battle_zone_stage = selected_stage == DEMO_STAGE_BATTLE_ZONE_RASTER;
    const int block_height = lower_half_stage ? DEMO_STAGE_FOURTEEN_BAND_HEIGHT :
        (battle_zone_stage ? DEMO_STAGE_FIFTEEN_BAND_BLOCK_HEIGHT :
                             DEMO_STAGE_ELEVEN_BAND_BLOCK_HEIGHT);
    const uint32_t drift_ms = battle_zone_stage ? DEMO_STAGE_FIFTEEN_BAND_DRIFT_MS :
                                                  DEMO_STAGE_ELEVEN_BAND_DRIFT_MS;
    // Segment 16 reserves its lower half for the scaled Battle Zone ground.
    // Its bar may touch the halfway horizon but cannot enter that landscape.
    const int travel_height = battle_zone_stage ? DEMO_STAGE_FIFTEEN_HORIZON_Y :
                                                  LCD_HEIGHT;
    const float drift_phase = (float)(raster_band_effect_elapsed_ms % drift_ms) /
                              (float)drift_ms;
    const int band_top = lower_half_stage ? DEMO_STAGE_FOURTEEN_BAND_TOP :
        (int)lroundf((float)(travel_height - block_height) *
            (0.5f + 0.5f * sinf(drift_phase * 2.0f * DEMO_PI)));
    const demo_raster_band_palette_t *palette =
        demo_raster_band_palettes[raster_band_palette_index];
    draw_rolling_raster_band(frame, band_top, block_height,
                             DEMO_STAGE_ELEVEN_BAND_HEIGHT,
                             raster_band_effect_elapsed_ms,
                             DEMO_STAGE_ELEVEN_COLOUR_ROLL_MS, palette);
}

static void drawStageTwelveSlideshowLens(uint16_t *frame)

Calls into this documentation:

1. Decision!stage_twelve_image_ready || stage_twelve_image == NULL
   True

   1. 1. Executedraw_text_centred(frame, LCD_WIDTH / 2, LCD_HEIGHT / 2, "NO SLIDESHOW IMAGE", 1, C64_COLOR_LIGHT_GREY);
      2. Exit this functionreturn;

   False

   Continue after this decision.

2. Executeconst size_t frame_bytes = (size_t)LCD_WIDTH * LCD_HEIGHT * sizeof(frame[0]);
3. Executememcpy(frame, stage_twelve_image, frame_bytes);
4. Executeconst int centre_x = (int)lroundf(stage_twelve_lens_x);
5. Executeconst int centre_y = (int)lroundf(stage_twelve_lens_y);
6. Executeconst int radius = DEMO_STAGE_TWELVE_LENS_RADIUS;
7. Executeconst int outer_radius_squared = radius * radius;
8. Executeconst int inner_radius = radius - DEMO_STAGE_TWELVE_LENS_RIM_WIDTH;
9. Executeconst int inner_radius_squared = inner_radius * inner_radius;
10. Executeconst int first_y = centre_y - radius < 0 ? 0 : centre_y - radius;
11. Executeconst int last_y = centre_y + radius >= LCD_HEIGHT ? LCD_HEIGHT - 1 : centre_y + radius;
12. Executeconst int first_x = centre_x - radius < 0 ? 0 : centre_x - radius;
13. Executeconst int last_x = centre_x + radius >= LCD_WIDTH ? LCD_WIDTH - 1 : centre_x + radius;
14. FOR loopint y = first_y; y <= last_y; ++y

    Repeat body while the loop condition permits; then continue below.

    1. 1. FOR loopint x = first_x; x <= last_x; ++x

          Repeat body while the loop condition permits; then continue below.

          1. 1. Executeconst int dx = x - centre_x;
             2. Executeconst int dy = y - centre_y;
             3. Executeconst int distance_squared = dx * dx + dy * dy;
             4. Decisiondistance_squared > outer_radius_squared
                True

                1. Next loop iterationcontinue;

                False

                Continue after this decision.

             5. Decisiondistance_squared > inner_radius_squared
                True

                1. 1. Executeframe[(size_t)y * LCD_WIDTH + (size_t)x] = DEMO_STAGE_TWELVE_LENS_RIM_COLOUR;
                   2. Next loop iterationcontinue;

                False

                Continue after this decision.

             6. Executeconst int source_x = (int)lroundf((float)centre_x + (float)dx / DEMO_STAGE_TWELVE_LENS_MAGNIFICATION);
             7. Executeconst int source_y = (int)lroundf((float)centre_y + (float)dy / DEMO_STAGE_TWELVE_LENS_MAGNIFICATION);
             8. Executeframe[(size_t)y * LCD_WIDTH + (size_t)x] = stage_twelve_image[(size_t)source_y * LCD_WIDTH + (size_t)source_x];

static void drawStageTwelveSlideshowLens(uint16_t *frame)
{
    if (!stage_twelve_image_ready || stage_twelve_image == NULL) {
        draw_text_centred(frame, LCD_WIDTH / 2, LCD_HEIGHT / 2,
                          "NO SLIDESHOW IMAGE", 1, C64_COLOR_LIGHT_GREY);
        return;
    }

    const size_t frame_bytes = (size_t)LCD_WIDTH * LCD_HEIGHT * sizeof(frame[0]);
    memcpy(frame, stage_twelve_image, frame_bytes);

    const int centre_x = (int)lroundf(stage_twelve_lens_x);
    const int centre_y = (int)lroundf(stage_twelve_lens_y);
    const int radius = DEMO_STAGE_TWELVE_LENS_RADIUS;
    const int outer_radius_squared = radius * radius;
    const int inner_radius = radius - DEMO_STAGE_TWELVE_LENS_RIM_WIDTH;
    const int inner_radius_squared = inner_radius * inner_radius;

    // Sample nearer to the lens centre inside the circle. Clamp the visible
    // part to the framebuffer because edge destinations deliberately place
    // part of the lens beyond the screen.
    const int first_y = centre_y - radius < 0 ? 0 : centre_y - radius;
    const int last_y = centre_y + radius >= LCD_HEIGHT ? LCD_HEIGHT - 1 :
                                                        centre_y + radius;
    const int first_x = centre_x - radius < 0 ? 0 : centre_x - radius;
    const int last_x = centre_x + radius >= LCD_WIDTH ? LCD_WIDTH - 1 :
                                                       centre_x + radius;
    for (int y = first_y; y <= last_y; ++y) {
        for (int x = first_x; x <= last_x; ++x) {
            const int dx = x - centre_x;
            const int dy = y - centre_y;
            const int distance_squared = dx * dx + dy * dy;
            if (distance_squared > outer_radius_squared) continue;

            if (distance_squared > inner_radius_squared) {
                frame[(size_t)y * LCD_WIDTH + (size_t)x] = DEMO_STAGE_TWELVE_LENS_RIM_COLOUR;
                continue;
            }

            const int source_x = (int)lroundf((float)centre_x +
                (float)dx / DEMO_STAGE_TWELVE_LENS_MAGNIFICATION);
            const int source_y = (int)lroundf((float)centre_y +
                (float)dy / DEMO_STAGE_TWELVE_LENS_MAGNIFICATION);
            frame[(size_t)y * LCD_WIDTH + (size_t)x] =
                stage_twelve_image[(size_t)source_y * LCD_WIDTH + (size_t)source_x];
        }
    }
}

static void drawStageSevenGlyph(uint16_t *frame, int column, int row, uint8_t glyph)

Calls into this documentation:

1. Executeconst int display_row = row + DEMO_STAGE_SEVEN_ROW_OFFSET;
2. Decisioncolumn < 0 || column >= 40 || display_row < 0 || display_row >= 21
   True

   1. Exit this functionreturn;

   False

   Continue after this decision.

3. ExecutedrawPet2001Glyph(frame, column * (int)PET2001_FONT_GLYPH_WIDTH, display_row * (int)PET2001_FONT_GLYPH_HEIGHT, glyph, false, DEMO_STAGE_SEVEN_PET_COLOUR, COLOR_BLACK, 1);

static void drawStageSevenGlyph(uint16_t *frame, int column, int row, uint8_t glyph)
{
    const int display_row = row + DEMO_STAGE_SEVEN_ROW_OFFSET;
    if (column < 0 || column >= 40 || display_row < 0 || display_row >= 21) return;
    drawPet2001Glyph(frame, column * (int)PET2001_FONT_GLYPH_WIDTH,
                     display_row * (int)PET2001_FONT_GLYPH_HEIGHT, glyph, false,
                     DEMO_STAGE_SEVEN_PET_COLOUR, COLOR_BLACK, 1);
}

static void drawStageSevenWalloon(uint16_t *frame, int column, int row, bool walking)

Calls into this documentation:

1. ExecutedrawStageSevenGlyph(frame, column, row, walking ? 81U : 87U);
2. ExecutedrawStageSevenGlyph(frame, column - 1, row + 1, 64U);
3. ExecutedrawStageSevenGlyph(frame, column, row + 1, 71U);
4. ExecutedrawStageSevenGlyph(frame, column + 1, row + 1, 64U);
5. ExecutedrawStageSevenGlyph(frame, column, row + 2, 90U);
6. ExecutedrawStageSevenGlyph(frame, column - 1, row + 3, 78U);
7. ExecutedrawStageSevenGlyph(frame, column + 1, row + 3, 77U);

static void drawStageSevenWalloon(uint16_t *frame, int column, int row, bool walking)
{
    // This is the original seven-cell Walloon from BASIC lines 1800-1820.
    // The walking top cell alternates the original 87 and 81 glyphs, while the
    // rest of the PET-character sprite remains exactly as the listing defines it.
    drawStageSevenGlyph(frame, column, row, walking ? 81U : 87U);
    drawStageSevenGlyph(frame, column - 1, row + 1, 64U);
    drawStageSevenGlyph(frame, column, row + 1, 71U);
    drawStageSevenGlyph(frame, column + 1, row + 1, 64U);
    drawStageSevenGlyph(frame, column, row + 2, 90U);
    drawStageSevenGlyph(frame, column - 1, row + 3, 78U);
    drawStageSevenGlyph(frame, column + 1, row + 3, 77U);
}

static void drawStageSevenPlayfield(uint16_t *frame)

Calls into this documentation:

1. FOR loopint column = 10; column <= 28; ++column

   Repeat body while the loop condition permits; then continue below.

   1. 1. ExecutedrawStageSevenGlyph(frame, column, 5, 127U);
2. FOR loopint row = 5; row <= 15; ++row

   Repeat body while the loop condition permits; then continue below.

   1. 1. ExecutedrawStageSevenGlyph(frame, 28, row, 127U);

static void drawStageSevenPlayfield(uint16_t *frame)
{
    // Retain the upper platform and right-hand climbing pole throughout the
    // act. Their origin is BASIC lines 220-290, at PET cell (10, 5).
    for (int column = 10; column <= 28; ++column) {
        drawStageSevenGlyph(frame, column, 5, 127U);
    }
    for (int row = 5; row <= 15; ++row) {
        drawStageSevenGlyph(frame, 28, row, 127U);
    }
}

static void drawStageSevenTitleBox(uint16_t *frame)

Calls into this documentation:

1. ExecutedrawStageSevenPlayfield(frame);
2. FOR loopint row = 5; row <= 15; ++row

   Repeat body while the loop condition permits; then continue below.

   1. 1. ExecutedrawStageSevenGlyph(frame, 10, row, 127U);
3. FOR loopint column = 10; column <= 25; ++column

   Repeat body while the loop condition permits; then continue below.

   1. 1. ExecutedrawStageSevenGlyph(frame, column, 15, 127U);
4. ExecutedrawPet2001Text(frame, 18 * (int)PET2001_FONT_GLYPH_WIDTH, 7 * (int)PET2001_FONT_GLYPH_HEIGHT, "THE", false, DEMO_STAGE_SEVEN_PET_COLOUR, COLOR_BLACK, 1);
5. ExecutedrawPet2001Text(frame, 12 * (int)PET2001_FONT_GLYPH_WIDTH, 9 * (int)PET2001_FONT_GLYPH_HEIGHT, "FLYING WALLOONS", false, DEMO_STAGE_SEVEN_PET_COLOUR, COLOR_BLACK, 1);

static void drawStageSevenTitleBox(uint16_t *frame)
{
    // The title-only left edge and lower edge make the temporary opening box.
    // They deliberately disappear before the first Walloon begins walking.
    drawStageSevenPlayfield(frame);
    for (int row = 5; row <= 15; ++row) {
        drawStageSevenGlyph(frame, 10, row, 127U);
    }
    for (int column = 10; column <= 25; ++column) {
        drawStageSevenGlyph(frame, column, 15, 127U);
    }
    // The original presents its stunt as "THE FLYING WALLOONS". Split the
    // title over two PET rows so it remains inside this 17-cell-wide frame.
    drawPet2001Text(frame, 18 * (int)PET2001_FONT_GLYPH_WIDTH,
                    7 * (int)PET2001_FONT_GLYPH_HEIGHT, "THE", false,
                    DEMO_STAGE_SEVEN_PET_COLOUR, COLOR_BLACK, 1);
    drawPet2001Text(frame, 12 * (int)PET2001_FONT_GLYPH_WIDTH,
                    9 * (int)PET2001_FONT_GLYPH_HEIGHT, "FLYING WALLOONS", false,
                    DEMO_STAGE_SEVEN_PET_COLOUR, COLOR_BLACK, 1);
}

static void drawStageSevenSeesaw(uint16_t *frame, bool left_end_down)

Calls into this documentation:

1. Executestatic const struct { int column; int row; } left_down_board[] = { {13, 19}, {14, 19}, {15, 19}, {16, 18}, {17, 18}, {18, 18}, {19, 17}, {20, 17}, {21, 17}, {22, 16}, {23, 16}, {24, 16}, };
2. Executestatic const struct { int column; int row; } right_down_board[] = { {13, 16}, {14, 16}, {15, 16}, {16, 17}, {17, 17}, {18, 17}, {19, 18}, {20, 18}, {21, 18}, {22, 19}, {23, 19}, {24, 19}, };
3. Decisionleft_end_down
   True

   1. 1. FOR loopsize_t index = 0U; index < sizeof(left_down_board) / sizeof(left_down_board[0]); ++index

         Repeat body while the loop condition permits; then continue below.

         1. 1. ExecutedrawStageSevenGlyph(frame, left_down_board[index].column, left_down_board[index].row, DEMO_STAGE_SEVEN_SEESAW_LINE_GLYPH);

   False

   1. 1. FOR loopsize_t index = 0U; index < sizeof(right_down_board) / sizeof(right_down_board[0]); ++index

         Repeat body while the loop condition permits; then continue below.

         1. 1. ExecutedrawStageSevenGlyph(frame, right_down_board[index].column, right_down_board[index].row, DEMO_STAGE_SEVEN_SEESAW_LINE_GLYPH);
4. ExecutedrawStageSevenGlyph(frame, 18, 20, 233U);
5. ExecutedrawStageSevenGlyph(frame, 19, 20, 223U);

static void drawStageSevenSeesaw(uint16_t *frame, bool left_end_down)
{
    // A single fixed PET-cell pivot replaces the listing's two absolute screen
    // snapshots. The board never slides sideways: only its stepped slope swaps
    // when the other Walloon becomes the one at the low end.
    static const struct { int column; int row; } left_down_board[] = {
        {13, 19}, {14, 19}, {15, 19}, {16, 18}, {17, 18}, {18, 18},
        {19, 17}, {20, 17}, {21, 17}, {22, 16}, {23, 16}, {24, 16},
    };
    static const struct { int column; int row; } right_down_board[] = {
        {13, 16}, {14, 16}, {15, 16}, {16, 17}, {17, 17}, {18, 17},
        {19, 18}, {20, 18}, {21, 18}, {22, 19}, {23, 19}, {24, 19},
    };
    if (left_end_down) {
        for (size_t index = 0U; index < sizeof(left_down_board) / sizeof(left_down_board[0]);
             ++index) {
            drawStageSevenGlyph(frame, left_down_board[index].column,
                                left_down_board[index].row,
                                DEMO_STAGE_SEVEN_SEESAW_LINE_GLYPH);
        }
    } else {
        for (size_t index = 0U; index < sizeof(right_down_board) / sizeof(right_down_board[0]);
             ++index) {
            drawStageSevenGlyph(frame, right_down_board[index].column,
                                right_down_board[index].row,
                                DEMO_STAGE_SEVEN_SEESAW_LINE_GLYPH);
        }
    }
    // The two original PET glyphs make a compact, fixed fulcrum below the board.
    drawStageSevenGlyph(frame, 18, 20, 233U);
    drawStageSevenGlyph(frame, 19, 20, 223U);
}

static void drawStageSevenWalloons(uint16_t *frame, uint32_t now_ms)

Calls into this documentation:

1. Decisionstage_seven_phase == WALLOONS_TITLE_CARD
   True

   1. 1. ExecutedrawStageSevenTitleBox(frame);
      2. Exit this functionreturn;

   False

   Continue after this decision.

2. ExecutedrawStageSevenPlayfield(frame);
3. Executeconst unsigned steps = walloonsPhaseSteps(now_ms, 14U);
4. Executeconst bool walking_pose = (steps & 1U) != 0U;
5. Select a casestage_seven_phase

   Enter matching case; follow source fall-through until a break, return or end.

   1. 1. Case / labelcase WALLOONS_TITLE_CARD:
      2. Exit enclosing loop or switchbreak;
      3. Case / labelcase WALLOONS_LEFT_WALK_IN:
      4. ExecutedrawStageSevenSeesaw(frame, true);
      5. ExecutedrawStageSevenWalloon(frame, 2 + (int)walloonsPhaseSteps(now_ms, 12U), 15, walking_pose);
      6. Exit enclosing loop or switchbreak;
      7. Case / labelcase WALLOONS_PAUSE_ON_SEESAW:
      8. ExecutedrawStageSevenSeesaw(frame, true);
      9. ExecutedrawStageSevenWalloon(frame, 14, 15, false);
      10. Exit enclosing loop or switchbreak;
      11. Case / labelcase WALLOONS_RIGHT_WALK_ON_PLATFORM:
      12. ExecutedrawStageSevenSeesaw(frame, true);
      13. ExecutedrawStageSevenWalloon(frame, 14, 15, false);
      14. ExecutedrawStageSevenWalloon(frame, 38 - (int)steps, 2, walking_pose);
      15. Exit enclosing loop or switchbreak;
      16. Case / labelcase WALLOONS_RIGHT_DROP:
      17. ExecutedrawStageSevenSeesaw(frame, true);
      18. ExecutedrawStageSevenWalloon(frame, 14, 15, false);
      19. ExecutedrawStageSevenWalloon(frame, 24, 2 + (int)walloonsPhaseSteps(now_ms, 13U), false);
      20. Exit enclosing loop or switchbreak;
      21. Case / labelcase WALLOONS_BOUNCE_RIGHT_UP:
      22. Case / labelcase WALLOONS_BOUNCE_RIGHT_DOWN:
      23. ExecutedrawStageSevenSeesaw(frame, true);
      24. ExecutedrawStageSevenWalloon(frame, 15, 15, false);
      25. ExecutedrawStageSevenWalloon(frame, 24, stage_seven_phase == WALLOONS_BOUNCE_RIGHT_UP ? 14 - (int)walloonsPhaseSteps(now_ms, 13U) : 2 + (int)walloonsPhaseSteps(now_ms, 13U), false);
      26. Exit enclosing loop or switchbreak;
      27. Case / labelcase WALLOONS_BOUNCE_LEFT_UP:
      28. ExecutedrawStageSevenSeesaw(frame, false);
      29. ExecutedrawStageSevenWalloon(frame, 24, 14, false);
      30. ExecutedrawStageSevenWalloon(frame, 15, 14 - (int)walloonsPhaseSteps(now_ms, 13U), false);
      31. Exit enclosing loop or switchbreak;
      32. Case / labelcase WALLOONS_BOUNCE_LEFT_DOWN:
      33. ExecutedrawStageSevenSeesaw(frame, false);
      34. ExecutedrawStageSevenWalloon(frame, 24, 14, false);
      35. ExecutedrawStageSevenWalloon(frame, 15, 2 + (int)walloonsPhaseSteps(now_ms, 13U), false);
      36. Exit enclosing loop or switchbreak;
      37. Case / labelcase WALLOONS_LEFT_LANDED:
      38. ExecutedrawStageSevenSeesaw(frame, true);
      39. ExecutedrawStageSevenWalloon(frame, 15, 15, false);
      40. Exit enclosing loop or switchbreak;
      41. Case / labelcase WALLOONS_FINISHED:
      42. ExecutedrawStageSevenSeesaw(frame, true);
      43. ExecutedrawStageSevenWalloon(frame, 15, 15, false);
      44. ExecutedrawStageSevenWalloon(frame, 24, 14, false);
      45. Exit enclosing loop or switchbreak;

static void drawStageSevenWalloons(uint16_t *frame, uint32_t now_ms)
{
    if (stage_seven_phase == WALLOONS_TITLE_CARD) {
        drawStageSevenTitleBox(frame);
        return;
    }
    drawStageSevenPlayfield(frame);

    const unsigned steps = walloonsPhaseSteps(now_ms, 14U);
    const bool walking_pose = (steps & 1U) != 0U;
    switch (stage_seven_phase) {
        case WALLOONS_TITLE_CARD:
            // Handled above so the title card contains no active Walloons.
            break;
        case WALLOONS_LEFT_WALK_IN:
            drawStageSevenSeesaw(frame, true);
            drawStageSevenWalloon(frame, 2 + (int)walloonsPhaseSteps(now_ms, 12U), 15,
                                   walking_pose);
            break;
        case WALLOONS_PAUSE_ON_SEESAW:
            drawStageSevenSeesaw(frame, true);
            drawStageSevenWalloon(frame, 14, 15, false);
            break;
        case WALLOONS_RIGHT_WALK_ON_PLATFORM:
            drawStageSevenSeesaw(frame, true);
            drawStageSevenWalloon(frame, 14, 15, false);
            drawStageSevenWalloon(frame, 38 - (int)steps, 2, walking_pose);
            break;
        case WALLOONS_RIGHT_DROP:
            drawStageSevenSeesaw(frame, true);
            drawStageSevenWalloon(frame, 14, 15, false);
            drawStageSevenWalloon(frame, 24, 2 + (int)walloonsPhaseSteps(now_ms, 13U), false);
            break;
        case WALLOONS_BOUNCE_RIGHT_UP:
        case WALLOONS_BOUNCE_RIGHT_DOWN:
            // The left Walloon remains at the low end while the right Walloon is airborne.
            drawStageSevenSeesaw(frame, true);
            drawStageSevenWalloon(frame, 15, 15, false);
            drawStageSevenWalloon(frame, 24,
                                   stage_seven_phase == WALLOONS_BOUNCE_RIGHT_UP
                                       ? 14 - (int)walloonsPhaseSteps(now_ms, 13U)
                                       : 2 + (int)walloonsPhaseSteps(now_ms, 13U), false);
            break;
        case WALLOONS_BOUNCE_LEFT_UP:
            // The right Walloon remains at the low end while the left Walloon rises.
            drawStageSevenSeesaw(frame, false);
            drawStageSevenWalloon(frame, 24, 14, false);
            drawStageSevenWalloon(frame, 15,
                                   14 - (int)walloonsPhaseSteps(now_ms, 13U), false);
            break;
        case WALLOONS_BOUNCE_LEFT_DOWN:
            drawStageSevenSeesaw(frame, false);
            drawStageSevenWalloon(frame, 24, 14, false);
            drawStageSevenWalloon(frame, 15,
                                   2 + (int)walloonsPhaseSteps(now_ms, 13U), false);
            break;
        case WALLOONS_LEFT_LANDED:
            // The landing phase makes the left-down state visible before the
            // next Walloon is launched from the other end.
            drawStageSevenSeesaw(frame, true);
            drawStageSevenWalloon(frame, 15, 15, false);
            break;
        case WALLOONS_FINISHED:
            drawStageSevenSeesaw(frame, true);
            drawStageSevenWalloon(frame, 15, 15, false);
            drawStageSevenWalloon(frame, 24, 14, false);
            break;
    }
}

static void drawDemoInstructions(uint16_t *frame)

Calls into this documentation:

1. Executeconst uint32_t elapsed_ms = last_update_ms - demo_instructions_started_at;
2. Executeconst uint32_t remaining_ms = elapsed_ms >= DEMO_INSTRUCTIONS_DURATION_MS ? 0U : DEMO_INSTRUCTIONS_DURATION_MS - elapsed_ms;
3. Executeconst unsigned seconds_remaining = (unsigned)((remaining_ms + 999U) / 1000U);
4. Executechar start_text[24];
5. Executefill_rect(frame, 0, 0, LCD_WIDTH, LCD_HEIGHT, C64_COLOR_BLUE);
6. Executestarfield_draw(frame, &demo_instruction_starfield);
7. ExecutedrawPet2001Text(frame, 40, 8, "Old school Demo", false, C64_COLOR_CYAN, C64_COLOR_BLUE, 2);
8. ExecutedrawPet2001Text(frame, 128, 32, "CONTROLS", false, C64_COLOR_LIGHT_GREY, C64_COLOR_BLUE, 1);
9. ExecutedrawPet2001Text(frame, 56, 48, "C: NEXT SEGMENT", false, C64_COLOR_YELLOW, C64_COLOR_BLUE, 1);
10. ExecutedrawPet2001Text(frame, 56, 64, "A: NEXT EFFECT (1)", false, C64_COLOR_WHITE, C64_COLOR_BLUE, 1);
11. ExecutedrawPet2001Text(frame, 56, 80, "B: ICON/SOLID/PALETTE", false, C64_COLOR_WHITE, C64_COLOR_BLUE, 1);
12. ExecutedrawPet2001Text(frame, 56, 96, "UP/DOWN: APPROACH (2)", false, C64_COLOR_WHITE, C64_COLOR_BLUE, 1);
13. ExecutedrawPet2001Text(frame, 56, 112, "LEFT/RIGHT: TICKER SPEED", false, C64_COLOR_WHITE, C64_COLOR_BLUE, 1);
14. ExecutedrawPet2001Text(frame, 56, 128, "BOOT: RETURN TO MENU", false, C64_COLOR_WHITE, C64_COLOR_BLUE, 1);
15. Executesnprintf(start_text, sizeof(start_text), "C STARTS IN %u S", seconds_remaining);
16. ExecutedrawPet2001Text(frame, 96, 152, start_text, false, C64_COLOR_YELLOW, C64_COLOR_BLUE, 1);

static void drawDemoInstructions(uint16_t *frame)
{
    const uint32_t elapsed_ms = last_update_ms - demo_instructions_started_at;
    const uint32_t remaining_ms = elapsed_ms >= DEMO_INSTRUCTIONS_DURATION_MS ? 0U :
        DEMO_INSTRUCTIONS_DURATION_MS - elapsed_ms;
    const unsigned seconds_remaining = (unsigned)((remaining_ms + 999U) / 1000U);
    char start_text[24];

    fill_rect(frame, 0, 0, LCD_WIDTH, LCD_HEIGHT, C64_COLOR_BLUE);
    starfield_draw(frame, &demo_instruction_starfield);
    drawPet2001Text(frame, 40, 8, "Old school Demo", false,
                    C64_COLOR_CYAN, C64_COLOR_BLUE, 2);
    drawPet2001Text(frame, 128, 32, "CONTROLS", false, C64_COLOR_LIGHT_GREY, C64_COLOR_BLUE, 1);
    drawPet2001Text(frame, 56, 48, "C: NEXT SEGMENT", false, C64_COLOR_YELLOW, C64_COLOR_BLUE, 1);
    drawPet2001Text(frame, 56, 64, "A: NEXT EFFECT (1)", false, C64_COLOR_WHITE, C64_COLOR_BLUE, 1);
    drawPet2001Text(frame, 56, 80, "B: ICON/SOLID/PALETTE", false,
                    C64_COLOR_WHITE, C64_COLOR_BLUE, 1);
    drawPet2001Text(frame, 56, 96, "UP/DOWN: APPROACH (2)", false, C64_COLOR_WHITE, C64_COLOR_BLUE, 1);
    drawPet2001Text(frame, 56, 112, "LEFT/RIGHT: TICKER SPEED", false,
                    C64_COLOR_WHITE, C64_COLOR_BLUE, 1);
    drawPet2001Text(frame, 56, 128, "BOOT: RETURN TO MENU", false,
                    C64_COLOR_WHITE, C64_COLOR_BLUE, 1);
    snprintf(start_text, sizeof(start_text), "C STARTS IN %u S", seconds_remaining);
    drawPet2001Text(frame, 96, 152, start_text, false, C64_COLOR_YELLOW, C64_COLOR_BLUE, 1);
}

static void drawDemoSelector(uint16_t *frame)

Calls into this documentation:

1. Executeclear(frame, COLOR_BLACK);
2. Executedraw_text_centred(frame, LCD_WIDTH / 2, 14, "SELECT DEMO SEGMENT", 1, COLOR_ORANGE);
3. FOR loopsize_t item = 0U; item <= DEMO_STAGE_COUNT; ++item

   Repeat body while the loop condition permits; then continue below.

   1. 1. Executeconst int y = DEMO_SELECTOR_FIRST_ROW_Y + (int)item * DEMO_SELECTOR_ROW_HEIGHT;
      2. Executeconst bool selected = item == demo_selector_item;
      3. Decisionselected
         True

         1. Executefill_rect(frame, 0, y - 1, LCD_WIDTH, DEMO_SELECTOR_ROW_HEIGHT, COLOR_DARKBLUE);

         False

         Continue after this decision.

      4. Executedraw_text(frame, 8, y, item == 0U ? "RETURN CURRENT" : demoSelectorStageCodeName((demo_stage_t)(item - 1U)), 1, selected ? COLOR_WHITE : COLOR_LIGHTGREY);
4. Executedraw_text_centred(frame, LCD_WIDTH / 2, 160, "D/B OR UP/DOWN A/K SELECT", 1, COLOR_LIGHTGREY);

static void drawDemoSelector(uint16_t *frame)
{
    clear(frame, COLOR_BLACK);
    draw_text_centred(frame, LCD_WIDTH / 2, 14, "SELECT DEMO SEGMENT", 1, COLOR_ORANGE);
    for (size_t item = 0U; item <= DEMO_STAGE_COUNT; ++item) {
        const int y = DEMO_SELECTOR_FIRST_ROW_Y + (int)item * DEMO_SELECTOR_ROW_HEIGHT;
        const bool selected = item == demo_selector_item;
        if (selected) fill_rect(frame, 0, y - 1, LCD_WIDTH, DEMO_SELECTOR_ROW_HEIGHT,
                                COLOR_DARKBLUE);
        draw_text(frame, 8, y, item == 0U ? "RETURN CURRENT" :
                  demoSelectorStageCodeName((demo_stage_t)(item - 1U)), 1,
                  selected ? COLOR_WHITE : COLOR_LIGHTGREY);
    }
    draw_text_centred(frame, LCD_WIDTH / 2, 160, "D/B OR UP/DOWN  A/K SELECT", 1,
                      COLOR_LIGHTGREY);
}

void drawDemo(uint16_t *frame)

Calls into this documentation:

1. Decision!running || frame == NULL
   True

   1. Exit this functionreturn;

   False

   Continue after this decision.

2. Decisiondemo_selector_active
   True

   1. 1. ExecutedrawDemoSelector(frame);
      2. Exit this functionreturn;

   False

   Continue after this decision.

3. Decisiondemo_selector_clear_new_stage
   True

   1. 1. Executeclear(frame, COLOR_BLACK);
      2. Executedemo_selector_clear_new_stage = false;
      3. Exit this functionreturn;

   False

   Continue after this decision.

4. Decisiondemo_instructions_active
   True

   1. 1. ExecutedrawDemoInstructions(frame);
      2. Exit this functionreturn;

   False

   Continue after this decision.

5. DecisionscreenTransitionActive(&stage_transition)
   True

   1. 1. ExecutescreenTransitionDraw(&stage_transition, frame, last_update_ms);
      2. Exit this functionreturn;

   False

   Continue after this decision.

6. DecisionscreenRevealActive(&stage_transition)
   True

   1. 1. ExecutescreenRevealDraw(&stage_transition, frame, last_update_ms);
      2. Exit this functionreturn;

   False

   Continue after this decision.

7. DecisionscreenScrollActive(&stage_transition) && !stage_scroll_in_requested
   True

   1. 1. ExecutescreenScrollDraw(&stage_transition, frame, last_update_ms);
      2. Exit this functionreturn;

   False

   Continue after this decision.

8. DecisionscreenSliceActive(&stage_transition)
   True

   1. 1. ExecutescreenSliceDraw(&stage_transition, frame, last_update_ms);
      2. Exit this functionreturn;

   False

   Continue after this decision.

9. Executeclear(frame, COLOR_BLACK);
10. Decisionselected_stage == DEMO_STAGE_APPROACH
    True

    1. 1. ExecutedrawApproachStage(frame);

    False

    1. Decisionselected_stage == DEMO_STAGE_AMIGA_BALL
       True

       1. 1. ExecutedrawStageThreeBall(frame);

       False

       1. Decisionselected_stage == DEMO_STAGE_SCROLLER
          True

          False

          1. Decisionselected_stage == DEMO_STAGE_REVERSE_SCROLLER
             True

             False

             1. Decisionselected_stage == DEMO_STAGE_GEOMETRIC_SOLID
                True

                1. 1. ExecutedrawStageSixSolid(frame);

                False

                1. Decisionselected_stage == DEMO_STAGE_WALLOONS
                   True

                   1. 1. ExecutedemoStageWalloonsDraw(frame, last_update_ms);

                   False

                   1. Decisionselected_stage == DEMO_STAGE_KALEIDO
                      True

                      1. 1. ExecutedemoStageKaleidoDraw(frame);

                      False

                      1. Decisionselected_stage == DEMO_STAGE_SPARKLE
                         True

                         1. 1. ExecutedemoStageSparkleDraw(frame);

                         False

                         1. Decisionselected_stage == DEMO_STAGE_SQUARES
                            True

                            1. 1. ExecutedemoStageSquaresDraw(frame);

                            False

                            1. Decisionselected_stage == DEMO_STAGE_RASTER_BANDS
                               True

                               1. 1. ExecutedrawRasterBands(frame);

                               False

                               1. Decisionselected_stage == DEMO_STAGE_SLIDESHOW_LENS
                                  True

                                  1. 1. ExecutedemoStageSlideshowLensDraw(frame);

                                  False

                                  1. Decisionselected_stage == DEMO_STAGE_PLASMA
                                     True

                                     1. 1. ExecutedemoStagePlasmaDraw(frame);

                                     False

                                     1. Decisionselected_stage == DEMO_STAGE_GAME_OF_LIFE
                                        True

                                        1. 1. ExecutedemoStageGameOfLifeDraw(frame);

                                        False

                                        1. Decisionselected_stage == DEMO_STAGE_LOWER_RASTER_SCROLLER
                                           True

                                           1. 1. ExecutedrawRasterBands(frame);

                                           False

                                           1. Decisionselected_stage == DEMO_STAGE_BATTLE_ZONE_RASTER
                                              True

                                              1. 1. ExecutedrawStageFifteenBattleZoneBackground(frame);
                                                 2. ExecutedrawRasterBands(frame);

                                              False

                                              1. Decisionselected_stage == DEMO_STAGE_BEVEL_GEARS
                                                 True

                                                 1. 1. ExecutedrawStageSeventeenBevelGears(frame);

                                                 False

                                                 1. Decisionselected_stage == DEMO_STAGE_MOUSE_MAZE
                                                    True

                                                    1. 1. ExecutedemoStageMouseMazeDraw(frame);

                                                    False

                                                    1. Decisionselected_effect == DEMO_EFFECT_DOT_GRID || selected_effect == DEMO_EFFECT_DOT_SPARKLE || selected_effect == DEMO_EFFECT_RADIAL_FLAME
                                                       True

                                                       1. 1. Executeconst bool sparkle_enabled = selected_effect == DEMO_EFFECT_DOT_SPARKLE;
                                                          2. Decisionselected_effect == DEMO_EFFECT_RADIAL_FLAME
                                                             True

                                                             1. 1. Executedraw_radial_flame(frame, &demo_ring_flame, DEMO_CENTRE_X, DEMO_CENTRE_Y, demoRingInnerRadius(), yaw_degrees, demo_ring_colours);

                                                             False

                                                             Continue after this decision.

                                                          3. Executeconst dotted_bitmap_3d_params_t dotted_sprite = { .centre_x = DEMO_CENTRE_X, .centre_y = DEMO_CENTRE_Y, .scale = DEMO_FACE_SCALE, .pitch_degrees = pitch_degrees, .yaw_degrees = yaw_degrees, .roll_degrees = roll_degrees, .depth = (float)DEMO_EXTRUSION_DEPTH, .camera_distance = DEMO_CAMERA_DISTANCE, .depth_dot_spacing = DEMO_DOT_SPACING, .dot_radius = DEMO_DOT_RADIUS, .dot_density_percent = DEMO_DOT_DENSITY_PERCENT, .random_seed = DEMO_DOT_RANDOM_SEED, .sparkle_density_percent = sparkle_enabled ? DEMO_DOT_SPARKLE_DENSITY_PERCENT : 0U, .sparkle_phase = sparkle_phase, .sparkle_radius = DEMO_DOT_SPARKLE_RADIUS, .sparkle_color = DEMO_DOT_SPARKLE_COLOR, .front_color = demo_icon_colour_schemes[demo_icon_colour_scheme_index].front, .back_color = demo_icon_colour_schemes[demo_icon_colour_scheme_index].dotted_back, .side_color = demo_icon_colour_schemes[demo_icon_colour_scheme_index].depth, };
                                                          4. Executedraw_bitmap_dotted_3d(frame, active_logo_bitmap, DEMO_LOGO_WIDTH, DEMO_LOGO_HEIGHT, &dotted_sprite);

                                                       False

                                                       1. 1. Executeconst float pitch_radians = pitch_degrees * DEMO_PI / 180.0f;
                                                          2. Executeconst float yaw_radians = yaw_degrees * DEMO_PI / 180.0f;
                                                          3. Executeconst float roll_radians = roll_degrees * DEMO_PI / 180.0f;
                                                          4. Executeconst demo_rotation_t rotation = { .pitch_cosine = cosf(pitch_radians), .pitch_sine = sinf(pitch_radians), .yaw_cosine = cosf(yaw_radians), .yaw_sine = sinf(yaw_radians), .roll_cosine = cosf(roll_radians), .roll_sine = sinf(roll_radians), };
                                                          5. Decisionrotation.pitch_cosine * rotation.yaw_cosine >= 0.0f
                                                             True

                                                             1. 1. FOR loopunsigned depth = DEMO_EXTRUSION_DEPTH; depth > 0U; depth -= DEMO_EXTRUSION_STEP

                                                                   Repeat body while the loop condition permits; then continue below.

                                                                   1. 1. ExecutedrawLogoSlice(frame, active_logo_bitmap, (float)depth, &rotation, demo_icon_colour_schemes[demo_icon_colour_scheme_index].depth);
                                                                2. ExecutedrawLogoSlice(frame, active_logo_bitmap, 0.0f, &rotation, demo_icon_colour_schemes[demo_icon_colour_scheme_index].front);

                                                             False

                                                             1. 1. ExecutedrawLogoSlice(frame, active_logo_bitmap, 0.0f, &rotation, demo_icon_colour_schemes[demo_icon_colour_scheme_index].front);
                                                                2. FOR loopunsigned depth = DEMO_EXTRUSION_STEP; depth <= DEMO_EXTRUSION_DEPTH; depth += DEMO_EXTRUSION_STEP

                                                                   Repeat body while the loop condition permits; then continue below.

                                                                   1. 1. ExecutedrawLogoSlice(frame, active_logo_bitmap, (float)depth, &rotation, demo_icon_colour_schemes[demo_icon_colour_scheme_index].depth);
11. Decisionselected_stage == DEMO_STAGE_SCROLLER || selected_stage == DEMO_STAGE_REVERSE_SCROLLER
    True

    1. 1. ExecutedrawTextCornerIcons(frame);

    False

    Continue after this decision.

12. ExecutedrawScrollText(frame);
13. Decisionstage_scroll_in_requested
    True

    1. 1. DecisionscreenScrollSetIncoming(&stage_transition, frame, stage_scroll_in_direction, DEMO_STAGE_SCROLL_GAP_PIXELS)
          True

          1. 1. ExecutescreenScrollDraw(&stage_transition, frame, last_update_ms);

          False

          Continue after this decision.

       2. Executestage_scroll_in_requested = false;
       3. Exit this functionreturn;

    False

    Continue after this decision.

14. Decisionstage_reveal_requested
    True

    1. 1. DecisionscreenRevealStart(&stage_transition, frame, last_update_ms, DEMO_STAGE_REBUILD_MS, DEMO_STAGE_REBUILD_PERCENT)
          True

          1. 1. ExecutescreenRevealDraw(&stage_transition, frame, last_update_ms);

          False

          Continue after this decision.

       2. Executestage_reveal_requested = false;
       3. Exit this functionreturn;

    False

    Continue after this decision.

15. Decisionstage_zoom_in_requested
    True

    1. 1. DecisionscreenTransitionZoomInStart(&stage_transition, frame, last_update_ms, DEMO_STAGE_ZOOM_IN_MS)
          True

          1. 1. Executestage_zooming_in = true;
             2. ExecutescreenTransitionDraw(&stage_transition, frame, last_update_ms);

          False

          Continue after this decision.

       2. Executestage_zoom_in_requested = false;
       3. Exit this functionreturn;

    False

    Continue after this decision.

16. Decisionstage_change_requested
    True

    1. 1. Select a caseselected_stage_transition

          Enter matching case; follow source fall-through until a break, return or end.

          1. 1. Case / labelcase DEMO_STAGE_TRANSITION_SHRINK_ZOOM:
             2. Decision!screenTransitionStart(&stage_transition, frame, last_update_ms, DEMO_STAGE_TRANSITION_FREEZE_MS, DEMO_STAGE_TRANSITION_ZOOM_MS)
                True

                1. 1. ExecuteadvanceDemoStage(last_update_ms);
                   2. Executestage_zoom_in_requested = true;

                False

                Continue after this decision.

             3. Exit enclosing loop or switchbreak;
             4. Case / labelcase DEMO_STAGE_TRANSITION_REBUILD:
             5. ExecuteadvanceDemoStage(last_update_ms);
             6. Executestage_reveal_requested = true;
             7. Exit enclosing loop or switchbreak;
             8. Case / labelcase DEMO_STAGE_TRANSITION_SCROLL:
             9. Decision!screenScrollOutStart(&stage_transition, frame, last_update_ms, stage_scroll_out_direction, DEMO_STAGE_SCROLL_STEP_MS, DEMO_STAGE_SCROLL_PIXELS_PER_STEP)
                True

                1. 1. ExecuteadvanceDemoStage(last_update_ms);
                   2. Executestage_scroll_in_requested = true;

                False

                1. 1. ExecuteadvanceDemoStage(last_update_ms);
                   2. Executestage_scroll_in_requested = true;
             10. Exit enclosing loop or switchbreak;
             11. Case / labelcase DEMO_STAGE_TRANSITION_SLICES:
             12. Decision!screenSliceStart(&stage_transition, frame, last_update_ms, DEMO_STAGE_SLICE_COUNT, DEMO_STAGE_SLICE_MS)
                 True

                 1. 1. ExecuteadvanceDemoStage(last_update_ms);
                    2. Executestage_zoom_in_requested = true;

                 False

                 Continue after this decision.

             13. Exit enclosing loop or switchbreak;
             14. Case / labeldefault:
             15. Exit enclosing loop or switchbreak;
       2. Executestage_change_requested = false;

    False

    Continue after this decision.