#include "raylib.h"

#include <math.h>

#include <stdbool.h>

#include <stdio.h>

#include <stdint.h>

#include <string.h>

#define SCREEN_WIDTH 1440

#define SCREEN_HEIGHT 900

#define TOP_BAR_HEIGHT 52

#define MAX_NODES 512

#define REGISTER_COUNT 31

#define SPECIAL_REGISTER_COUNT 2

#define REGISTER_TOTAL_COUNT (REGISTER_COUNT + SPECIAL_REGISTER_COUNT)

#define REGISTER_SP_INDEX REGISTER_COUNT

#define REGISTER_PC_INDEX (REGISTER_COUNT + 1)

#define REGISTER_PORT_COUNT 3

#define REGISTER_NODE_BASE REGISTER_PORT_COUNT

typedef enum PipelineStage {

} PipelineStage;

typedef enum CoherenceState {

} CoherenceState;

typedef struct Node {

} Node;

typedef struct Camera2D64 {

} Camera2D64;

typedef struct HoverResult {

} HoverResult;

typedef struct AppState {

} AppState;

static const Color COLOR_BG = {7, 16, 24, 255};

static const Color COLOR_BG_2 = {9, 23, 36, 255};

static const Color COLOR_GRID_MINOR = {54, 92, 112, 45};

static const Color COLOR_GRID_MAJOR = {110, 180, 210, 72};

static const Color COLOR_NODE_LINE = {135, 210, 240, 210};

static const Color COLOR_NODE_FILL = {24, 52, 72, 48};

static const Color COLOR_NODE_TEXT = {185, 233, 247, 255};

static const Color COLOR_HOVER = {255, 247, 170, 255};

static const Color COLOR_TOP = {10, 24, 36, 255};

static const Color COLOR_TOP_EDGE = {80, 153, 180, 120};

static const Color COLOR_ACCENT = {120, 202, 232, 255};

static const Color COLOR_MUTED = {110, 150, 165, 255};

static double ClampDouble(double value, double min_value, double max_value) {

if (value < min_value) {

return min_value;

}

if (value > max_value) {

return max_value;

}

return value;

}

static const char *RegisterLabel(int index) {

static char labels[REGISTER_COUNT][4];

static bool initialized = false;

if (!initialized) {

for (int i = 0; i < REGISTER_COUNT; i++) {

snprintf(labels[i], sizeof(labels[i]), "x%d", i);

}

initialized = true;

}

if (index >= 0 && index < REGISTER_COUNT) {

return labels[index];

}

if (index == REGISTER_SP_INDEX) {

return "sp";

}

if (index == REGISTER_PC_INDEX) {

return "pc";

}

return "?";

}

static void ResetExecutionState(AppState *app) {

memset(app->core_register_values, 0, sizeof(app->core_register_values));

for (int core = 0; core < 2; core++) {

for (int i = 0; i < REGISTER_COUNT; i++) {

app->core_register_values[core][i] = 0;

}

}

app->core_register_values[0][1] = 0x2000ULL;

app->core_register_values[0][3] = 1ULL;

app->core_register_values[0][REGISTER_SP_INDEX] = 0x1000ULL;

app->core_register_values[0][REGISTER_PC_INDEX] = 0x8000ULL;

app->core_register_values[1][1] = 0x2000ULL;

app->core_register_values[1][3] = 1ULL;

app->core_register_values[1][REGISTER_SP_INDEX] = 0x1800ULL;

app->core_register_values[1][REGISTER_PC_INDEX] = 0x8040ULL;

app->operand_a = 0x2000ULL;

app->operand_b = 0;

app->effective_address = 0x2000ULL;

app->memory_value = 0;

app->cache_hit = true;

app->alu_result = 0;

app->cycle_number = 0;

app->pipeline_stage = PIPELINE_FETCH;

}

static const char *CoherenceStateLabel(CoherenceState state) {

switch (state) {

case COHERENCE_MODIFIED:

return "M";

case COHERENCE_EXCLUSIVE:

return "E";

case COHERENCE_SHARED:

return "S";

case COHERENCE_INVALID:

default:

return "I";

}

}

static void StepExecutionCycle(AppState *app) {

app->cycle_number += 1;

app->pipeline_stage = (PipelineStage)(app->cycle_number % PIPELINE_STAGE_COUNT);

switch (app->cycle_number % 12) {

case 0:

app->core_register_values[0][0] = 0;

app->core_register_values[0][2] = 0;

app->core_register_values[1][0] = 0;

app->core_register_values[1][2] = 0;

app->memory_value = 0;

break;

case 1:

app->core_register_values[0][0] = app->memory_value & 0xffffffffULL;

app->memory_value = 0;

break;

case 2:

app->memory_value = 1;

app->core_register_values[0][2] = 0;

break;

case 3:

app->memory_value = 1;

break;

case 4:

app->memory_value = 1;

app->core_register_values[1][0] = app->memory_value & 0xffffffffULL;

break;

case 5:

app->memory_value = 1;

app->core_register_values[1][2] = 1;

break;

case 6:

app->memory_value = 1;

app->core_register_values[1][0] = app->memory_value & 0xffffffffULL;

app->core_register_values[1][2] = 1;

break;

case 7:

app->memory_value = 1;

app->core_register_values[1][0] = app->memory_value & 0xffffffffULL;

app->core_register_values[1][2] = 1;

break;

case 8:

case 9:

case 10:

case 11:

app->memory_value = 1;

app->core_register_values[1][0] = app->memory_value & 0xffffffffULL;

app->core_register_values[1][2] = 1;

break;

}

}

static Node *PushNode(AppState *app) {

if (app->node_count >= MAX_NODES) {

return NULL;

}

Node *node = &app->nodes[app->node_count++];

memset(node, 0, sizeof(*node));

return node;

}

static Node *PushNodes(AppState *app, int count) {

if (count <= 0 || app->node_count + count > MAX_NODES) {

return NULL;

}

Node *start = &app->nodes[app->node_count];

memset(start, 0, sizeof(*start) * (size_t)count);

app->node_count += count;

return start;

}

static bool IsNodeVisibleOnScreen(const Node *node, Camera2D64 camera, Rectangle viewport);

static Vector2 WorldToScreenPoint(Camera2D64 camera, Rectangle viewport, double x, double y) {

float sx = (float)(((x - camera.x) * camera.zoom) + viewport.x + (viewport.width * 0.5f));

float sy = (float)(((y - camera.y) * camera.zoom) + viewport.y + (viewport.height * 0.5f));

return (Vector2){sx, sy};

}

static Vector2 ScreenToWorldPoint(Camera2D64 camera, Rectangle viewport, Vector2 point) {

double wx = ((double)point.x - (double)viewport.x - ((double)viewport.width * 0.5)) / camera.zoom + camera.x;

double wy = ((double)point.y - (double)viewport.y - ((double)viewport.height * 0.5)) / camera.zoom + camera.y;

return (Vector2){(float)wx, (float)wy};

}

static Rectangle NodeScreenRect(const Node *node, Camera2D64 camera, Rectangle viewport) {

Vector2 a = WorldToScreenPoint(camera, viewport, node->x, node->y);

Vector2 b = WorldToScreenPoint(camera, viewport, node->x + node->width, node->y + node->height);

Rectangle rect = {

.x = a.x,

.y = a.y,

.width = b.x - a.x,

.height = b.y - a.y,

};

if (rect.width < 0) {

rect.x += rect.width;

rect.width = -rect.width;

}

if (rect.height < 0) {

rect.y += rect.height;

rect.height = -rect.height;

}

return rect;

}

static bool IsNodeDrawn(const Node *node, Camera2D64 camera, Rectangle viewport, double zoom) {

return node != NULL && zoom >= node->zoom_threshold && IsNodeVisibleOnScreen(node, camera, viewport);

}

static Vector2 NodeAnchorLeft(const Node *node, Camera2D64 camera, Rectangle viewport) {

return WorldToScreenPoint(camera, viewport, node->x, node->y + node->height * 0.5);

}

static Vector2 NodeAnchorRight(const Node *node, Camera2D64 camera, Rectangle viewport) {

return WorldToScreenPoint(camera, viewport, node->x + node->width, node->y + node->height * 0.5);

}

static Vector2 NodeAnchorTop(const Node *node, Camera2D64 camera, Rectangle viewport) {

return WorldToScreenPoint(camera, viewport, node->x + node->width * 0.5, node->y);

}

static Vector2 NodeAnchorBottom(const Node *node, Camera2D64 camera, Rectangle viewport) {

return WorldToScreenPoint(camera, viewport, node->x + node->width * 0.5, node->y + node->height);

}

static Rectangle GetMiniMapRect(void) {

return (Rectangle){

(float)GetScreenWidth() - 246.0f,

(float)GetScreenHeight() - 178.0f,

226.0f,

142.0f

};

}

static Rectangle GetWorldBounds(const AppState *app) {

double min_x = app->nodes[0].x;

double min_y = app->nodes[0].y;

double max_x = app->nodes[0].x + app->nodes[0].width;

double max_y = app->nodes[0].y + app->nodes[0].height;

for (int i = 1; i < 4; i++) {

const Node *node = &app->nodes[i];

if (node->x < min_x) {

min_x = node->x;

}

if (node->y < min_y) {

min_y = node->y;

}

if (node->x + node->width > max_x) {

max_x = node->x + node->width;

}

if (node->y + node->height > max_y) {

max_y = node->y + node->height;

}

}

min_x -= 1800.0;

min_y -= 1400.0;

max_x += 1800.0;

max_y += 1400.0;

return (Rectangle){(float)min_x, (float)min_y, (float)(max_x - min_x), (float)(max_y - min_y)};

}

static Vector2 WorldToMiniMapPoint(Rectangle bounds, Rectangle mini_map, double x, double y) {

float px = mini_map.x + (float)(((x - bounds.x) / bounds.width) * mini_map.width);

float py = mini_map.y + (float)(((y - bounds.y) / bounds.height) * mini_map.height);

return (Vector2){px, py};

}

static Vector2 MiniMapToWorldPoint(Rectangle bounds, Rectangle mini_map, Vector2 point) {

double nx = ((double)point.x - mini_map.x) / mini_map.width;

double ny = ((double)point.y - mini_map.y) / mini_map.height;

return (Vector2){

(float)(bounds.x + nx * bounds.width),

(float)(bounds.y + ny * bounds.height)

};

}

static Rectangle ClampRectToBounds(Rectangle rect, Rectangle bounds) {

if (rect.width > bounds.width) {

rect.width = bounds.width;

}

if (rect.height > bounds.height) {

rect.height = bounds.height;

}

if (rect.x < bounds.x) {

rect.x = bounds.x;

}

if (rect.y < bounds.y) {

rect.y = bounds.y;

}

if (rect.x + rect.width > bounds.x + bounds.width) {

rect.x = bounds.x + bounds.width - rect.width;

}

if (rect.y + rect.height > bounds.y + bounds.height) {

rect.y = bounds.y + bounds.height - rect.height;

}

return rect;

}

static bool IsNodeVisibleOnScreen(const Node *node, Camera2D64 camera, Rectangle viewport) {

Rectangle rect = NodeScreenRect(node, camera, viewport);

Rectangle expanded = {

rect.x - 80.0f,

rect.y - 80.0f,

rect.width + 160.0f,

rect.height + 160.0f

};

return CheckCollisionRecs(expanded, viewport);

}

static bool PointInNode(const Node *node, Vector2 world_point) {

return world_point.x >= node->x &&

world_point.x <= node->x + node->width &&

world_point.y >= node->y &&

world_point.y <= node->y + node->height;

}

static double SelectGridStep(double zoom) {

static const double steps[] = {

10.0, 20.0, 50.0, 100.0, 200.0, 500.0,

1000.0, 2000.0, 5000.0, 10000.0, 20000.0

};

for (int i = 0; i < (int)(sizeof(steps) / sizeof(steps[0])); i++) {

if (steps[i] * zoom >= 34.0) {

return steps[i];

}

}

return 50000.0;

}

static void DrawWorldGrid(Camera2D64 camera, Rectangle viewport, double time_seconds) {

Vector2 top_left = ScreenToWorldPoint(camera, viewport, (Vector2){viewport.x, viewport.y});

Vector2 bottom_right = ScreenToWorldPoint(camera, viewport, (Vector2){viewport.x + viewport.width, viewport.y + viewport.height});

double min_x = top_left.x;

double max_x = bottom_right.x;

double min_y = top_left.y;

double max_y = bottom_right.y;

if (min_x > max_x) {

double tmp = min_x;

min_x = max_x;

max_x = tmp;

}

if (min_y > max_y) {

double tmp = min_y;

min_y = max_y;

max_y = tmp;

}

double minor_step = SelectGridStep(camera.zoom);

double major_step = minor_step * 5.0;

float pulse = 0.80f + 0.20f * sinf((float)(time_seconds * 0.45));

for (double x = floor(min_x / minor_step) * minor_step; x <= max_x; x += minor_step) {

Vector2 a = WorldToScreenPoint(camera, viewport, x, min_y);

Vector2 b = WorldToScreenPoint(camera, viewport, x, max_y);

bool major = fabs(fmod(x, major_step)) < 0.001 || fabs(fmod(x, major_step) - major_step) < 0.001;

DrawLineV(a, b, major ? Fade(COLOR_GRID_MAJOR, pulse) : COLOR_GRID_MINOR);

}

for (double y = floor(min_y / minor_step) * minor_step; y <= max_y; y += minor_step) {

Vector2 a = WorldToScreenPoint(camera, viewport, min_x, y);

Vector2 b = WorldToScreenPoint(camera, viewport, max_x, y);

bool major = fabs(fmod(y, major_step)) < 0.001 || fabs(fmod(y, major_step) - major_step) < 0.001;

DrawLineV(a, b, major ? Fade(COLOR_GRID_MAJOR, pulse) : COLOR_GRID_MINOR);

}

Vector2 origin_x1 = WorldToScreenPoint(camera, viewport, 0.0, min_y);

Vector2 origin_x2 = WorldToScreenPoint(camera, viewport, 0.0, max_y);

Vector2 origin_y1 = WorldToScreenPoint(camera, viewport, min_x, 0.0);

Vector2 origin_y2 = WorldToScreenPoint(camera, viewport, max_x, 0.0);

DrawLineEx(origin_x1, origin_x2, 1.5f, Fade(COLOR_ACCENT, 0.65f));

DrawLineEx(origin_y1, origin_y2, 1.5f, Fade(COLOR_ACCENT, 0.65f));

}

static void UpdateHoverRecursive(Node *node, Vector2 world_point, double zoom, int depth, HoverResult *result) {

if (zoom < node->zoom_threshold) {

return;

}

if (PointInNode(node, world_point)) {

double area = node->width * node->height;

if (result->node == NULL || depth > result->depth || (depth == result->depth && area < result->area)) {

result->node = node;

result->depth = depth;

result->area = area;

}

}

for (int i = 0; i < node->child_count; i++) {

UpdateHoverRecursive(&node->children[i], world_point, zoom, depth + 1, result);

}

}

static void DrawNodeRecursive(const Node *node, Camera2D64 camera, Rectangle viewport, const Node *hovered, double zoom, double time_seconds) {

if (zoom < node->zoom_threshold || !IsNodeVisibleOnScreen(node, camera, viewport)) {

return;

}

Rectangle rect = NodeScreenRect(node, camera, viewport);

bool is_hovered = (hovered == node);

bool large_enough = rect.width >= 10.0f && rect.height >= 10.0f;

if (large_enough) {

float title_height = rect.height > 34.0f ? 20.0f : fminf(16.0f, rect.height * 0.3f);

float sweep = 0.4f + 0.2f * sinf((float)(time_seconds * 0.9 + node->x * 0.0001 + node->y * 0.00013));

Color fill = Fade(COLOR_NODE_FILL, is_hovered ? 0.28f : 0.18f);

Color line = is_hovered ? COLOR_HOVER : COLOR_NODE_LINE;

float thickness = is_hovered ? 2.0f : 1.0f;

DrawRectangleRec(rect, fill);

DrawRectangle((int)rect.x, (int)rect.y, (int)rect.width, (int)title_height, Fade(COLOR_ACCENT, 0.08f + sweep * 0.03f));

DrawRectangleLinesEx(rect, thickness, line);

if (rect.width > 70.0f && rect.height > 24.0f) {

int font_size = (int)ClampDouble(rect.height * 0.12, 10.0, is_hovered ? 24.0 : 22.0);

DrawText(node->label, (int)rect.x + 8, (int)rect.y + 4, font_size, is_hovered ? COLOR_HOVER : COLOR_NODE_TEXT);

}

if (rect.width > 120.0f && rect.height > 42.0f) {

DrawLineEx(

(Vector2){rect.x, rect.y + title_height},

(Vector2){rect.x + rect.width, rect.y + title_height},

1.0f,

Fade(COLOR_NODE_LINE, 0.7f)

);

}

}

for (int i = 0; i < node->child_count; i++) {

DrawNodeRecursive(&node->children[i], camera, viewport, hovered, zoom, time_seconds);

}

}

static void DrawArrowHead(Vector2 from, Vector2 to, Color color) {

Vector2 dir = {to.x - from.x, to.y - from.y};

float length = sqrtf(dir.x * dir.x + dir.y * dir.y);

if (length < 0.001f) {

return;

}

dir.x /= length;

dir.y /= length;

Vector2 ortho = {-dir.y, dir.x};

Vector2 tip = to;

Vector2 left = {tip.x - dir.x * 10.0f + ortho.x * 4.0f, tip.y - dir.y * 10.0f + ortho.y * 4.0f};

Vector2 right = {tip.x - dir.x * 10.0f - ortho.x * 4.0f, tip.y - dir.y * 10.0f - ortho.y * 4.0f};

DrawTriangle(tip, left, right, color);

}

static void DrawArrowLine(Vector2 start, Vector2 end, Color color) {

DrawLineEx(start, end, 1.2f, color);

DrawArrowHead(start, end, color);

}

static const Node *RegisterNodeAt(const Node *register_nodes, int index) {

if (register_nodes == NULL || index < 0 || index >= REGISTER_TOTAL_COUNT) {

return NULL;

}

return &register_nodes[index];

}

static void DrawCpuInterconnects(const AppState *app) {

double zoom = app->camera.zoom;

if (!IsNodeDrawn(app->cpu, app->camera, app->viewport, zoom)) {

return;

}

Color bus = Fade(COLOR_NODE_LINE, 0.72f);

Color feed = Fade(COLOR_ACCENT, 0.48f);

if (IsNodeDrawn(app->core0_read_port_a, app->camera, app->viewport, zoom) &&

IsNodeDrawn(app->core0_alu, app->camera, app->viewport, zoom)) {

DrawArrowLine(NodeAnchorRight(app->core0_read_port_a, app->camera, app->viewport), NodeAnchorLeft(app->core0_alu, app->camera, app->viewport), feed);

}

if (IsNodeDrawn(app->core0_read_port_b, app->camera, app->viewport, zoom) &&

IsNodeDrawn(app->core0_alu, app->camera, app->viewport, zoom)) {

DrawArrowLine(NodeAnchorRight(app->core0_read_port_b, app->camera, app->viewport), NodeAnchorLeft(app->core0_alu, app->camera, app->viewport), feed);

}

if (IsNodeDrawn(app->core1_read_port_a, app->camera, app->viewport, zoom) &&

IsNodeDrawn(app->core1_alu, app->camera, app->viewport, zoom)) {

DrawArrowLine(NodeAnchorRight(app->core1_read_port_a, app->camera, app->viewport), NodeAnchorLeft(app->core1_alu, app->camera, app->viewport), feed);

}

if (IsNodeDrawn(app->core1_read_port_b, app->camera, app->viewport, zoom) &&

IsNodeDrawn(app->core1_alu, app->camera, app->viewport, zoom)) {

DrawArrowLine(NodeAnchorRight(app->core1_read_port_b, app->camera, app->viewport), NodeAnchorLeft(app->core1_alu, app->camera, app->viewport), feed);

}

if (IsNodeDrawn(app->core0_alu, app->camera, app->viewport, zoom) &&

IsNodeDrawn(app->core0_writeback, app->camera, app->viewport, zoom)) {

DrawArrowLine(NodeAnchorRight(app->core0_alu, app->camera, app->viewport), NodeAnchorLeft(app->core0_writeback, app->camera, app->viewport), bus);

}

if (IsNodeDrawn(app->core1_alu, app->camera, app->viewport, zoom) &&

IsNodeDrawn(app->core1_writeback, app->camera, app->viewport, zoom)) {

DrawArrowLine(NodeAnchorRight(app->core1_alu, app->camera, app->viewport), NodeAnchorLeft(app->core1_writeback, app->camera, app->viewport), bus);

}

if (IsNodeDrawn(app->core0_lsu, app->camera, app->viewport, zoom) &&

IsNodeDrawn(app->core0_writeback, app->camera, app->viewport, zoom)) {

DrawArrowLine(NodeAnchorTop(app->core0_lsu, app->camera, app->viewport), NodeAnchorBottom(app->core0_writeback, app->camera, app->viewport), bus);

}

if (IsNodeDrawn(app->core1_lsu, app->camera, app->viewport, zoom) &&

IsNodeDrawn(app->core1_writeback, app->camera, app->viewport, zoom)) {

DrawArrowLine(NodeAnchorTop(app->core1_lsu, app->camera, app->viewport), NodeAnchorBottom(app->core1_writeback, app->camera, app->viewport), bus);

}

if (IsNodeDrawn(app->core0_writeback, app->camera, app->viewport, zoom) &&

IsNodeDrawn(app->core0_writeback_port, app->camera, app->viewport, zoom)) {

DrawArrowLine(NodeAnchorLeft(app->core0_writeback, app->camera, app->viewport), NodeAnchorRight(app->core0_writeback_port, app->camera, app->viewport), feed);

}

if (IsNodeDrawn(app->core1_writeback, app->camera, app->viewport, zoom) &&

IsNodeDrawn(app->core1_writeback_port, app->camera, app->viewport, zoom)) {

DrawArrowLine(NodeAnchorLeft(app->core1_writeback, app->camera, app->viewport), NodeAnchorRight(app->core1_writeback_port, app->camera, app->viewport), feed);

}

if (IsNodeDrawn(app->core0_read_port_a, app->camera, app->viewport, zoom) &&

IsNodeDrawn(app->core0_lsu, app->camera, app->viewport, zoom)) {

DrawArrowLine(NodeAnchorRight(app->core0_read_port_a, app->camera, app->viewport), NodeAnchorLeft(app->core0_lsu, app->camera, app->viewport), feed);

}

if (IsNodeDrawn(app->core1_read_port_a, app->camera, app->viewport, zoom) &&

IsNodeDrawn(app->core1_lsu, app->camera, app->viewport, zoom)) {

DrawArrowLine(NodeAnchorRight(app->core1_read_port_a, app->camera, app->viewport), NodeAnchorLeft(app->core1_lsu, app->camera, app->viewport), feed);

}

if (IsNodeDrawn(app->core0_lsu, app->camera, app->viewport, zoom) &&

IsNodeDrawn(app->l1d, app->camera, app->viewport, zoom)) {

DrawArrowLine(NodeAnchorBottom(app->core0_lsu, app->camera, app->viewport), NodeAnchorTop(app->l1d, app->camera, app->viewport), bus);

}

if (IsNodeDrawn(app->core1_lsu, app->camera, app->viewport, zoom) &&

IsNodeDrawn(app->core1_l1d, app->camera, app->viewport, zoom)) {

DrawArrowLine(NodeAnchorBottom(app->core1_lsu, app->camera, app->viewport), NodeAnchorTop(app->core1_l1d, app->camera, app->viewport), bus);

}

if (IsNodeDrawn(app->l1d, app->camera, app->viewport, zoom) &&

IsNodeDrawn(app->fabric, app->camera, app->viewport, zoom)) {

DrawArrowLine(NodeAnchorRight(app->l1d, app->camera, app->viewport), NodeAnchorLeft(app->fabric, app->camera, app->viewport), bus);

}

if (IsNodeDrawn(app->core1_l1d, app->camera, app->viewport, zoom) &&

IsNodeDrawn(app->fabric, app->camera, app->viewport, zoom)) {

DrawArrowLine(NodeAnchorRight(app->fabric, app->camera, app->viewport), NodeAnchorLeft(app->core1_l1d, app->camera, app->viewport), bus);

}

if (IsNodeDrawn(app->fabric, app->camera, app->viewport, zoom) &&

IsNodeDrawn(app->main_memory, app->camera, app->viewport, zoom)) {

DrawArrowLine(NodeAnchorRight(app->fabric, app->camera, app->viewport), NodeAnchorLeft(app->main_memory, app->camera, app->viewport), feed);

}

if (IsNodeDrawn(app->core1_lsu, app->camera, app->viewport, zoom) &&

IsNodeDrawn(app->syscall_entry, app->camera, app->viewport, zoom)) {

DrawArrowLine(NodeAnchorBottom(app->core1_lsu, app->camera, app->viewport), NodeAnchorTop(app->syscall_entry, app->camera, app->viewport), feed);

}

if (IsNodeDrawn(app->syscall_entry, app->camera, app->viewport, zoom) &&

IsNodeDrawn(app->futex_wait_queue, app->camera, app->viewport, zoom)) {

DrawArrowLine(NodeAnchorRight(app->syscall_entry, app->camera, app->viewport), NodeAnchorLeft(app->futex_wait_queue, app->camera, app->viewport), bus);

}

if (IsNodeDrawn(app->futex_wait_queue, app->camera, app->viewport, zoom) &&

IsNodeDrawn(app->scheduler, app->camera, app->viewport, zoom)) {

DrawArrowLine(NodeAnchorRight(app->futex_wait_queue, app->camera, app->viewport), NodeAnchorLeft(app->scheduler, app->camera, app->viewport), bus);

}

if (IsNodeDrawn(app->scheduler, app->camera, app->viewport, zoom) &&

IsNodeDrawn(app->wakeup_path, app->camera, app->viewport, zoom)) {

DrawArrowLine(NodeAnchorBottom(app->scheduler, app->camera, app->viewport), NodeAnchorTop(app->wakeup_path, app->camera, app->viewport), feed);

}

}

static void DrawHighlightedNode(const Node *node, const AppState *app, Color color, float fill_alpha) {

if (!IsNodeDrawn(node, app->camera, app->viewport, app->camera.zoom)) {

return;

}

Rectangle rect = NodeScreenRect(node, app->camera, app->viewport);

DrawRectangleRec(rect, Fade(color, fill_alpha));

DrawRectangleLinesEx(rect, 2.0f, color);

}

static void DrawHighlightedRegisterLower32(const Node *node, const AppState *app, const char *alias, Color color, float fill_alpha) {

if (!IsNodeDrawn(node, app->camera, app->viewport, app->camera.zoom)) {

return;

}

Rectangle rect = NodeScreenRect(node, app->camera, app->viewport);

Rectangle lower = {

rect.x + 4.0f,

rect.y + rect.height * 0.52f,

rect.width - 8.0f,

rect.height * 0.40f

};

DrawRectangleRec(lower, Fade(color, fill_alpha));

DrawRectangleLinesEx(lower, 1.5f, color);

if (rect.width > 64.0f && rect.height > 26.0f) {

DrawText(alias, (int)lower.x + 6, (int)lower.y + 2, 10, color);

}

}

static void DrawRegisterValueText(const Node *node, const AppState *app, uint64_t value, Color color) {

if (!IsNodeDrawn(node, app->camera, app->viewport, app->camera.zoom)) {

return;

}

Rectangle rect = NodeScreenRect(node, app->camera, app->viewport);

if (rect.width < 44.0f || rect.height < 24.0f) {

return;

}

char value_text[32];

snprintf(value_text, sizeof(value_text), "0x%llx", (unsigned long long)value);

int font_size = rect.height > 60.0f ? 11 : 8;

DrawText(value_text, (int)rect.x + 8, (int)(rect.y + rect.height - (float)font_size - 7.0f), font_size, color);

}

static void DrawBlockSummary(const Node *node, const AppState *app, const char *text, Color color) {

if (!IsNodeDrawn(node, app->camera, app->viewport, app->camera.zoom) || text == NULL) {

return;

}

Rectangle rect = NodeScreenRect(node, app->camera, app->viewport);

if (rect.width < 120.0f || rect.height < 54.0f) {

return;

}

DrawText(text, (int)rect.x + 8, (int)rect.y + 28, 12, color);

}

static bool IsScreenPointNearViewport(Vector2 p, Rectangle viewport, float margin);

static void DrawAnnotatedBusActivity(Vector2 a, Vector2 b, Rectangle viewport, Color color, const char *annotation, double time_seconds) {

if (!IsScreenPointNearViewport(a, viewport, 180.0f) &&

!IsScreenPointNearViewport(b, viewport, 180.0f)) {

return;

}

DrawLineEx(a, b, 2.0f, Fade(color, 0.22f));

Vector2 delta = {b.x - a.x, b.y - a.y};

float length = sqrtf(delta.x * delta.x + delta.y * delta.y);

if (length > 1.0f) {

Vector2 dir = {delta.x / length, delta.y / length};

float dash_length = 18.0f;

float gap = 10.0f;

float pattern = dash_length + gap;

float phase = fmodf((float)(time_seconds * 120.0), pattern);

float cursor = -phase;

int dash_index = 0;

while (cursor < length) {

float start_t = fmaxf(cursor, 0.0f);

float end_t = fminf(cursor + dash_length, length);

if (end_t > start_t) {

float pulse = 0.45f + 0.55f * sinf((float)(time_seconds * 4.0 + dash_index * 0.7));

Vector2 s = {a.x + dir.x * start_t, a.y + dir.y * start_t};

Vector2 e = {a.x + dir.x * end_t, a.y + dir.y * end_t};

DrawLineEx(s, e, 1.4f, Fade(color, 0.35f + 0.45f * pulse));

}

cursor += pattern;

dash_index += 1;

}

}

if (annotation != NULL && annotation[0] != '\0') {

Vector2 mid = {(a.x + b.x) * 0.5f, (a.y + b.y) * 0.5f};

int width = MeasureText(annotation, 12) + 16;

Rectangle box = {mid.x - width * 0.5f, mid.y - 12.0f, (float)width, 22.0f};

DrawRectangleRec(box, Fade(COLOR_TOP, 0.88f));

DrawRectangleLinesEx(box, 1.0f, Fade(color, 0.70f));

DrawText(annotation, (int)box.x + 8, (int)box.y + 5, 12, color);

}

}

static bool IsScreenPointNearViewport(Vector2 p, Rectangle viewport, float margin) {

return p.x >= viewport.x - margin &&

p.x <= viewport.x + viewport.width + margin &&

p.y >= viewport.y - margin &&

p.y <= viewport.y + viewport.height + margin;

}

static void DrawAssemblyInstruction(const AppState *app) {

if (!IsNodeDrawn(app->assembly, app->camera, app->viewport, app->camera.zoom)) {

return;

}

Rectangle rect = NodeScreenRect(app->assembly, app->camera, app->viewport);

if (rect.width < 120.0f || rect.height < 80.0f) {

return;

}

Rectangle panel = {rect.x + 24.0f, rect.y + 48.0f, rect.width - 48.0f, fminf(94.0f, rect.height - 64.0f)};

int title_font = (int)ClampDouble(panel.height * 0.16f, 13.0, 20.0);

int line_font = (int)ClampDouble(panel.height * 0.18f, 14.0, 22.0);

int detail_font = (int)ClampDouble(panel.height * 0.14f, 12.0, 18.0);

DrawRectangleRec(panel, Fade(COLOR_TOP, 0.55f));

DrawRectangleLinesEx(panel, 1.0f, Fade(COLOR_NODE_LINE, 0.55f));

DrawText("AArch64", (int)panel.x + 10, (int)panel.y + 10, title_font, COLOR_MUTED);

DrawText("Core 0: LDAXR / STXR", (int)panel.x + 10, (int)panel.y + 10 + title_font + 7, line_font, COLOR_HOVER);