#include "raylib.h"

#include "rlgl.h"

#include <math.h>

#include <stdio.h>

#ifndef PI

#define PI 3.14159265358979323846f

#define MAX_DEGREE 7

#define PRESET_COUNT 8

#define MAX_U_STEPS 210

#define MAX_V_STEPS 120

typedef struct Complex {

float re;

float im;

} Complex;

typedef struct Preset {

} Preset;

typedef struct RootMapping {

} RootMapping;

static float Clamp01(float x) {

if (x < 0.0f) return 0.0f;

if (x > 1.0f) return 1.0f;

return x;

}

static float SmootherStep01(float x) {

float t = Clamp01(x);

return t * t * t * (t * (t * 6.0f - 15.0f) + 10.0f);

}

static float ComplexAbs(Complex z) {

return sqrtf(z.re * z.re + z.im * z.im);

}

static float ComplexArg(Complex z) {

return atan2f(z.im, z.re);

}

static Complex MixComplex(Complex a, Complex b, float t) {

Complex out = {

a.re + (b.re - a.re) * t,

a.im + (b.im - a.im) * t

};

return out;

}

static void SortRootsByArg(const Preset *p, Complex out[MAX_DEGREE]) {

for (int i = 0; i < p->degree; i++) out[i] = p->roots[i];

for (int i = 0; i < p->degree - 1; i++) {

for (int j = i + 1; j < p->degree; j++) {

float ai = ComplexArg(out[i]);

float aj = ComplexArg(out[j]);

if (aj < ai) {

Complex tmp = out[i];

out[i] = out[j];

out[j] = tmp;

}

}

}

}

static Complex RootFromMapping(const Complex roots[MAX_DEGREE], int degree, int shift, int idx, int n) {

int k = (idx * degree) / n;

if (k < 0) k = 0;

if (k >= degree) k = degree - 1;

int id = (k + shift) % degree;

return roots[id];

}

static int ComputeBestShift(const Complex a[MAX_DEGREE], int da, const Complex b[MAX_DEGREE], int db, int n, int shiftA) {

int bestShift = 0;

float bestCost = 1e30f;

for (int sb = 0; sb < db; sb++) {

float cost = 0.0f;

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

Complex ra = RootFromMapping(a, da, shiftA, i, n);

Complex rb = RootFromMapping(b, db, sb, i, n);

float dx = ra.re - rb.re;

float dy = ra.im - rb.im;

cost += dx * dx + dy * dy;

}

if (cost < bestCost) {

bestCost = cost;

bestShift = sb;

}

}

return bestShift;

}

static RootMapping BuildRootMapping(const Preset *a, const Preset *b) {

RootMapping m = { 0 };

m.n = (a->degree > b->degree) ? a->degree : b->degree;

if (m.n < 1) m.n = 1;

SortRootsByArg(a, m.orderedA);

SortRootsByArg(b, m.orderedB);

m.shiftA = 0;

m.shiftB = ComputeBestShift(m.orderedA, a->degree, m.orderedB, b->degree, m.n, m.shiftA);

return m;

}

static Complex MixedRootMapped(const RootMapping *m, const Preset *a, const Preset *b, float mix, int idx) {

Complex ra = RootFromMapping(m->orderedA, a->degree, m->shiftA, idx, m->n);

Complex rb = RootFromMapping(m->orderedB, b->degree, m->shiftB, idx, m->n);

return MixComplex(ra, rb, mix);

}

static Complex ComplexSub(Complex a, Complex b) {

Complex out = { a.re - b.re, a.im - b.im };

return out;

}

static Complex ComplexMul(Complex a, Complex b) {

Complex out = { a.re * b.re - a.im * b.im, a.re * b.im + a.im * b.re };

return out;

}

static float MixedMaxRootMagnitude(const RootMapping *map, const Preset *a, const Preset *b, float mix) {

float maxMag = 1.0f;

for (int i = 0; i < map->n; i++) {

float mag = ComplexAbs(MixedRootMapped(map, a, b, mix, i));

if (mag > maxMag) maxMag = mag;

}

return maxMag;

}

static Complex EvalPolynomialPreset(Complex z, const Preset *p) {

Complex out = { 1.0f, 0.0f };

for (int i = 0; i < p->degree; i++) {

out = ComplexMul(out, ComplexSub(z, p->roots[i]));

}

return out;

}

static Complex EvalPolynomialHomotopy(Complex z, const Preset *a, const Preset *b, float mix) {

Complex pa = EvalPolynomialPreset(z, a);

Complex pb = EvalPolynomialPreset(z, b);

Complex out = {

(1.0f - mix) * pa.re + mix * pb.re,

(1.0f - mix) * pa.im + mix * pb.im

};

return out;

}

static float SurfaceHeightFromValue(Complex p) {

float logMag = logf(ComplexAbs(p) + 1e-6f);

return -2.25f * tanhf(logMag * 0.58f);

}

static Vector3 V3Sub(Vector3 a, Vector3 b) {

Vector3 out = { a.x - b.x, a.y - b.y, a.z - b.z };

return out;

}

static Vector3 V3Cross(Vector3 a, Vector3 b) {

Vector3 out = {

a.y * b.z - a.z * b.y,

a.z * b.x - a.x * b.z,

a.x * b.y - a.y * b.x

};

return out;

}

static float V3Dot(Vector3 a, Vector3 b) {

return a.x * b.x + a.y * b.y + a.z * b.z;

}

static Vector3 V3Normalize(Vector3 v) {

float len = sqrtf(v.x * v.x + v.y * v.y + v.z * v.z);

if (len < 1e-6f) return (Vector3){ 0.0f, 1.0f, 0.0f };

return (Vector3){ v.x / len, v.y / len, v.z / len };

}

static Vector3 V3Lerp(Vector3 a, Vector3 b, float t) {

Vector3 out = {

a.x + (b.x - a.x) * t,

a.y + (b.y - a.y) * t,

a.z + (b.z - a.z) * t

};

return out;

}

static Color ShadeColor(Color c, float k) {

float s = Clamp01(k);

Color out = {

(unsigned char)fminf(255.0f, c.r * s),

(unsigned char)fminf(255.0f, c.g * s),

(unsigned char)fminf(255.0f, c.b * s),

c.a

};

return out;

}

static Color MixColor(Color a, Color b, float t) {

float u = Clamp01(t);

Color c = {

(unsigned char)((1.0f - u) * a.r + u * b.r),

(unsigned char)((1.0f - u) * a.g + u * b.g),

(unsigned char)((1.0f - u) * a.b + u * b.b),

(unsigned char)((1.0f - u) * a.a + u * b.a)

};

return c;

}

static Color SpectralColorFromComplex(Complex pVal, float yNorm) {

float arg = ComplexArg(pVal);

float lm = logf(ComplexAbs(pVal) + 1e-6f);

float w = arg + 0.95f * lm;

float r = 0.5f + 0.5f * cosf(w + 0.0f);

float g = 0.5f + 0.5f * cosf(w + 2.0943951f);

float b = 0.5f + 0.5f * cosf(w + 4.1887902f);

float phaseBands = 0.5f + 0.5f * cosf(8.0f * arg + 2.6f * lm);

float boost = 0.78f + 0.38f * phaseBands + 0.26f * Clamp01(yNorm);

Color c = {

(unsigned char)fminf(255.0f, 255.0f * powf(r, 0.82f) * boost),

(unsigned char)fminf(255.0f, 255.0f * powf(g, 0.82f) * boost),

(unsigned char)fminf(255.0f, 255.0f * powf(b, 0.82f) * boost),

255

};

return c;

}

static void DrawDottedLine3D(Vector3 a, Vector3 b, int dots, float phase, float radius, Color c) {

float head = phase - floorf(phase);

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

float u = (float)i / (float)(dots - 1);

float d = fabsf(u - head);

if (d > 0.5f) d = 1.0f - d;

float packet = expf(-(d * d) / 0.02f);

float twinkle = 0.75f + 0.25f * sinf(2.0f * PI * (u * 2.0f + phase * 0.35f));

float alpha = Clamp01(0.10f + 0.45f * packet) * twinkle;

float rr = radius * (0.75f + 0.55f * packet);

Vector3 p = V3Lerp(a, b, u);

Color cc = c;

cc.a = (unsigned char)(c.a * alpha);

DrawSphere(p, rr, cc);

}

}

static void DrawDottedLine2D(Vector2 a, Vector2 b, int dots, float phase, float radius, Color c) {

float head = phase - floorf(phase);

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

float u = (float)i / (float)(dots - 1);

float d = fabsf(u - head);

if (d > 0.5f) d = 1.0f - d;

float packet = expf(-(d * d) / 0.03f);

float twinkle = 0.78f + 0.22f * sinf(2.0f * PI * (u * 1.8f + phase * 0.30f));

float alpha = Clamp01(0.08f + 0.40f * packet) * twinkle;

float rr = radius * (0.78f + 0.45f * packet);

Vector2 p = { a.x + (b.x - a.x) * u, a.y + (b.y - a.y) * u };

Color cc = c;

cc.a = (unsigned char)(c.a * alpha);

DrawCircleV(p, rr, cc);

}

}

static void DrawOrbitDots2D(Vector2 center, float radius, int dots, float phase, float dotRadius, Color c) {

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

float u = ((float)i / (float)dots) + phase;

u -= floorf(u);

float ang = 2.0f * PI * u;

Vector2 p = { center.x + radius * cosf(ang), center.y + radius * sinf(ang) };

float pulse = 0.65f + 0.35f * sinf(2.0f * PI * u + phase * 6.0f);

Color cc = c;

cc.a = (unsigned char)(c.a * pulse);

DrawCircleV(p, dotRadius * (0.75f + 0.45f * pulse), cc);

}

}

static void DrawOrbitDots3D(Vector3 center, float radius, int dots, float phase, float dotRadius, Color c) {

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

float u = ((float)i / (float)dots) + phase;

u -= floorf(u);

float ang = 2.0f * PI * u;

Vector3 p = { center.x + radius * cosf(ang), center.y, center.z + radius * sinf(ang) };

float pulse = 0.65f + 0.35f * sinf(2.0f * PI * u + phase * 6.0f);

Color cc = c;

cc.a = (unsigned char)(c.a * pulse);

DrawSphere(p, dotRadius * (0.75f + 0.45f * pulse), cc);

}

}

static void DrawZeroContourLines(

) {

for (int u = 0; u < uSteps - 1; u++) {

for (int v = 0; v < vSteps - 1; v++) {

Vector3 p00 = mesh[u][v];

Vector3 p10 = mesh[u + 1][v];

Vector3 p11 = mesh[u + 1][v + 1];

Vector3 p01 = mesh[u][v + 1];

float f00 = vals[u][v];

float f10 = vals[u + 1][v];

float f11 = vals[u + 1][v + 1];

float f01 = vals[u][v + 1];

Vector3 pts[4];

int pc = 0;

if ((f00 > 0.0f) != (f10 > 0.0f)) {

float t = fabsf(f00) / (fabsf(f00) + fabsf(f10) + 1e-12f);

pts[pc++] = (Vector3){ p00.x + (p10.x - p00.x) * t, yPlane, p00.z + (p10.z - p00.z) * t };

}

if ((f10 > 0.0f) != (f11 > 0.0f)) {

float t = fabsf(f10) / (fabsf(f10) + fabsf(f11) + 1e-12f);

pts[pc++] = (Vector3){ p10.x + (p11.x - p10.x) * t, yPlane, p10.z + (p11.z - p10.z) * t };

}

if ((f11 > 0.0f) != (f01 > 0.0f)) {

float t = fabsf(f11) / (fabsf(f11) + fabsf(f01) + 1e-12f);

pts[pc++] = (Vector3){ p11.x + (p01.x - p11.x) * t, yPlane, p11.z + (p01.z - p11.z) * t };

}

if ((f01 > 0.0f) != (f00 > 0.0f)) {

float t = fabsf(f01) / (fabsf(f01) + fabsf(f00) + 1e-12f);

pts[pc++] = (Vector3){ p01.x + (p00.x - p01.x) * t, yPlane, p01.z + (p00.z - p01.z) * t };

}

if (pc == 2) {

DrawLine3D((Vector3){ pts[0].x, pts[0].y - thickness, pts[0].z }, (Vector3){ pts[1].x, pts[1].y - thickness, pts[1].z }, (Color){ col.r, col.g, col.b, (unsigned char)(col.a * 0.55f) });

DrawLine3D(pts[0], pts[1], col);

DrawLine3D((Vector3){ pts[0].x, pts[0].y + thickness, pts[0].z }, (Vector3){ pts[1].x, pts[1].y + thickness, pts[1].z }, (Color){ col.r, col.g, col.b, (unsigned char)(col.a * 0.55f) });

} else if (pc == 4) {

DrawLine3D((Vector3){ pts[0].x, pts[0].y - thickness, pts[0].z }, (Vector3){ pts[1].x, pts[1].y - thickness, pts[1].z }, (Color){ col.r, col.g, col.b, (unsigned char)(col.a * 0.55f) });

DrawLine3D(pts[0], pts[1], col);

DrawLine3D((Vector3){ pts[0].x, pts[0].y + thickness, pts[0].z }, (Vector3){ pts[1].x, pts[1].y + thickness, pts[1].z }, (Color){ col.r, col.g, col.b, (unsigned char)(col.a * 0.55f) });

DrawLine3D((Vector3){ pts[2].x, pts[2].y - thickness, pts[2].z }, (Vector3){ pts[3].x, pts[3].y - thickness, pts[3].z }, (Color){ col.r, col.g, col.b, (unsigned char)(col.a * 0.55f) });

DrawLine3D(pts[2], pts[3], col);

DrawLine3D((Vector3){ pts[2].x, pts[2].y + thickness, pts[2].z }, (Vector3){ pts[3].x, pts[3].y + thickness, pts[3].z }, (Color){ col.r, col.g, col.b, (unsigned char)(col.a * 0.55f) });

}

}

}

}

static Camera3D BuildSurfaceCamera(float cameraDistance, float camYaw, float camPitch, float camZoom) {

Camera3D cam = { 0 };

float camY = camPitch;

if (camY < -1.2f) camY = -1.2f;

if (camY > 1.2f) camY = 1.2f;

float dist = cameraDistance * camZoom;

cam.position = (Vector3){

dist * cosf(camY) * cosf(camYaw),

dist * sinf(camY),

dist * cosf(camY) * sinf(camYaw)

};

cam.target = (Vector3){ 0.0f, 0.0f, 0.0f };

cam.up = (Vector3){ 0.0f, 1.0f, 0.0f };

cam.fovy = 45.0f;

cam.projection = CAMERA_PERSPECTIVE;

return cam;

}

static void DrawHeightExplanationPanel(Rectangle panel, float mix, Complex z, Complex pA, Complex pB, Complex pT, float yHeight, int morphing) {

DrawRectangleRounded(panel, 0.05f, 10, (Color){ 7, 13, 30, 208 });

DrawRectangleRoundedLines(panel, 0.05f, 10, (Color){ 120, 182, 255, 120 });

Rectangle left = { panel.x + 12, panel.y + 34, panel.width * 0.47f, panel.height - 46 };

Rectangle right = { panel.x + panel.width * 0.50f, panel.y + 34, panel.width * 0.48f - 10, panel.height - 46 };

DrawRectangleRounded(left, 0.06f, 8, (Color){ 8, 18, 38, 175 });

DrawRectangleRounded(right, 0.06f, 8, (Color){ 8, 18, 38, 175 });

Vector2 c = { left.x + left.width * 0.5f, left.y + left.height * 0.5f };

float maxMag = fmaxf(1.0f, fmaxf(ComplexAbs(pA), fmaxf(ComplexAbs(pB), ComplexAbs(pT))));

float scale = fminf(left.width, left.height) * 0.40f / maxMag;

DrawLine((int)left.x + 8, (int)c.y, (int)(left.x + left.width - 8), (int)c.y, (Color){ 125, 172, 230, 95 });

DrawLine((int)c.x, (int)left.y + 8, (int)c.x, (int)(left.y + left.height - 8), (Color){ 125, 172, 230, 95 });

DrawText("Value plane", (int)left.x + 8, (int)left.y + 8, 14, (Color){ 180, 218, 255, 230 });

Vector2 vA = { c.x + pA.re * scale, c.y - pA.im * scale };

Vector2 vB = { c.x + pB.re * scale, c.y - pB.im * scale };

Vector2 vT = { c.x + pT.re * scale, c.y - pT.im * scale };

if (morphing) {

DrawLineEx(c, vA, 2.0f, (Color){ 255, 168, 148, 190 });

DrawLineEx(c, vB, 2.0f, (Color){ 140, 222, 255, 190 });

}

DrawLineEx(c, vT, 3.0f, (Color){ 255, 245, 210, 235 });

if (morphing) {

DrawCircleV(vA, 3.8f, (Color){ 255, 168, 148, 220 });

DrawCircleV(vB, 3.8f, (Color){ 140, 222, 255, 220 });

}

DrawCircleV(vT, 5.0f, (Color){ 255, 245, 210, 245 });

if (morphing) {

DrawText("Pa", (int)vA.x + 6, (int)vA.y - 2, 13, (Color){ 255, 172, 156, 220 });

DrawText("Pb", (int)vB.x + 6, (int)vB.y - 2, 13, (Color){ 145, 228, 255, 220 });

DrawText("Pt", (int)vT.x + 6, (int)vT.y - 2, 13, (Color){ 255, 245, 210, 240 });

} else {

DrawText("P", (int)vT.x + 6, (int)vT.y - 2, 13, (Color){ 255, 245, 210, 240 });

}

float absPt = ComplexAbs(pT);

float logMag = logf(absPt + 1e-6f);

float nLog = Clamp01((logMag + 5.0f) / 10.0f);

float nY = Clamp01((yHeight + 2.25f) / 4.5f);

if (morphing) {

DrawText("Pt = (1-t)Pa + tPb", (int)right.x + 8, (int)right.y + 8, 15, (Color){ 202, 229, 255, 235 });

DrawText("height = -2.25*tanh(0.58*ln(|Pt|+1e-6))", (int)right.x + 8, (int)right.y + 27, 14, (Color){ 186, 210, 245, 225 });

} else {

DrawText("P(z) at hovered point", (int)right.x + 8, (int)right.y + 8, 15, (Color){ 202, 229, 255, 235 });

DrawText("height = -2.25*tanh(0.58*ln(|P(z)|+1e-6))", (int)right.x + 8, (int)right.y + 27, 14, (Color){ 186, 210, 245, 225 });

}

DrawRectangle((int)right.x + 8, (int)right.y + 52, (int)right.width - 16, 11, (Color){ 28, 48, 80, 220 });

DrawRectangle((int)right.x + 8, (int)right.y + 52, (int)((right.width - 16) * nLog), 11, (Color){ 130, 210, 255, 225 });

DrawText(morphing ? "ln(|Pt|)" : "ln(|P(z)|)", (int)right.x + 8, (int)right.y + 66, 13, (Color){ 175, 215, 255, 220 });

DrawRectangle((int)right.x + 8, (int)right.y + 87, (int)right.width - 16, 11, (Color){ 28, 48, 80, 220 });

DrawRectangle((int)right.x + 8, (int)right.y + 87, (int)((right.width - 16) * nY), 11, (Color){ 255, 210, 140, 225 });

DrawText("surface height", (int)right.x + 8, (int)right.y + 101, 13, (Color){ 255, 222, 166, 220 });

char info1[128];

char info2[160];

if (morphing) {

snprintf(info1, sizeof(info1), "z = %.3f %+.3fi t = %.3f", z.re, z.im, mix);

snprintf(info2, sizeof(info2), "|Pt|=%.5f ln|Pt|=%.5f y=%.5f", absPt, logMag, yHeight);

} else {

snprintf(info1, sizeof(info1), "z = %.3f %+.3fi", z.re, z.im);

snprintf(info2, sizeof(info2), "|P(z)|=%.5f ln|P(z)|=%.5f y=%.5f", absPt, logMag, yHeight);

}

DrawText(info1, (int)right.x + 8, (int)right.y + 124, 14, (Color){ 234, 240, 250, 230 });

DrawText(info2, (int)right.x + 8, (int)right.y + 142, 14, (Color){ 234, 240, 250, 230 });

}

static Color RootColor(Complex r, float t, float extraHue) {

float mag = ComplexAbs(r);

float arg = ComplexArg(r);

float hue = (arg + PI) * (180.0f / PI) + extraHue + t * 8.0f;

float sat = 0.58f + 0.30f * Clamp01(mag / 2.6f);

float val = 0.72f + 0.24f * (0.5f + 0.5f * sinf(t * 0.9f + arg));

return ColorFromHSV(hue, sat, val);

}

static void DrawBackdrop(int w, int h, int topBarH, float t) {

DrawRectangleGradientV(0, topBarH, w, h - topBarH, (Color){ 4, 9, 24, 255 }, (Color){ 1, 3, 12, 255 });

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

float phase = t * (0.08f + 0.015f * i) + 0.6f * i;

float x = (float)w * (0.07f + 0.07f * i) + 55.0f * sinf(phase);

float y = topBarH + (float)(h - topBarH) * (0.12f + 0.06f * i) + 35.0f * cosf(phase * 1.1f);

float rad = 70.0f + 35.0f * (0.5f + 0.5f * sinf(phase * 0.7f));

Color c = { (unsigned char)(18 + i * 5), (unsigned char)(28 + i * 6), (unsigned char)(46 + i * 7), 24 };

DrawCircleGradient((int)x, (int)y, rad, c, BLANK);

}

}

static void DrawTopBar(int w, int page, int paused) {

Rectangle bar = { 0, 0, (float)w, 62.0f };

DrawRectangleRec(bar, (Color){ 3, 8, 18, 238 });

DrawLine(0, 61, w, 61, (Color){ 68, 140, 230, 120 });

Rectangle tab1 = { 16, 14, 110, 34 };

Rectangle tab2 = { 138, 14, 110, 34 };

Color active = (Color){ 44, 132, 232, 230 };

Color idle = (Color){ 22, 41, 70, 220 };

DrawRectangleRounded(tab1, 0.25f, 8, page == 0 ? active : idle);

DrawRectangleRounded(tab2, 0.25f, 8, page == 1 ? active : idle);

DrawText("[1] Roots", 30, 23, 16, RAYWHITE);

DrawText("[2] Empty", 150, 23, 16, RAYWHITE);

DrawText("P: preset Space: pause/resume Q: quit", w - 420, 23, 16, (Color){ 180, 223, 255, 220 });

if (paused) DrawText("PAUSED", w / 2 - 34, 23, 16, (Color){ 255, 220, 140, 235 });

}

static int DrawMiniComplexPlane(Rectangle panel, const Preset *a, const Preset *b, float mix, float t, int existingHover, int probeActive, Complex probeZ) {

(void)t;

RootMapping map = BuildRootMapping(a, b);

int n = map.n;

Vector2 mouse = GetMousePosition();

DrawRectangleRounded(panel, 0.06f, 10, (Color){ 6, 13, 30, 205 });

DrawRectangleRoundedLines(panel, 0.06f, 10, (Color){ 120, 185, 255, 120 });

Rectangle inner = { panel.x + 14, panel.y + 26, panel.width - 28, panel.height - 40 };

Vector2 c = { inner.x + inner.width * 0.5f, inner.y + inner.height * 0.5f };

float maxMag = 1.5f;

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

Complex r = MixedRootMapped(&map, a, b, mix, i);

float m = ComplexAbs(r);

if (m > maxMag) maxMag = m;

}

float scale = fminf(inner.width, inner.height) * 0.42f / maxMag;

Color grid = (Color){ 88, 130, 198, 80 };

for (int k = -4; k <= 4; k++) {

DrawLine((int)(c.x + k * scale * 0.5f), (int)inner.y, (int)(c.x + k * scale * 0.5f), (int)(inner.y + inner.height), grid);

DrawLine((int)inner.x, (int)(c.y + k * scale * 0.5f), (int)(inner.x + inner.width), (int)(c.y + k * scale * 0.5f), grid);

}

DrawLineEx((Vector2){ inner.x, c.y }, (Vector2){ inner.x + inner.width, c.y }, 2.0f, (Color){ 170, 214, 255, 180 });

DrawLineEx((Vector2){ c.x, inner.y }, (Vector2){ c.x, inner.y + inner.height }, 2.0f, (Color){ 170, 214, 255, 180 });

if (probeActive) {

Vector2 q = { c.x + probeZ.re * scale, c.y - probeZ.im * scale };

DrawDottedLine2D((Vector2){ inner.x, q.y }, (Vector2){ inner.x + inner.width, q.y }, 34, 0.11f * t, 1.9f, (Color){ 255, 232, 176, 170 });

DrawDottedLine2D((Vector2){ q.x, inner.y }, (Vector2){ q.x, inner.y + inner.height }, 34, 0.15f * t + 0.23f, 1.9f, (Color){ 172, 218, 255, 170 });

DrawCircleV(q, 4.8f, (Color){ 255, 245, 210, 165 });

}

int hovered = -1;

float hoveredDist = 1e9f;

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

Complex r = MixedRootMapped(&map, a, b, mix, i);

Vector2 p = { c.x + r.re * scale, c.y - r.im * scale };

float dx = p.x - mouse.x;

float dy = p.y - mouse.y;

float d = sqrtf(dx * dx + dy * dy);

if (CheckCollisionPointRec(mouse, panel) && d < 11.0f && d < hoveredDist) {

hovered = i;

hoveredDist = d;

}

}

if (hovered < 0 && CheckCollisionPointRec(mouse, panel)) hovered = existingHover;

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

Complex r = MixedRootMapped(&map, a, b, mix, i);

Vector2 p = { c.x + r.re * scale, c.y - r.im * scale };

Color col = RootColor(r, t, i * 34.0f);

float rad = (i == hovered) ? 8.5f : 5.5f;

DrawCircleV(p, rad + 4.0f, (Color){ col.r, col.g, col.b, (unsigned char)(i == hovered ? 120 : 55) });

DrawCircleV(p, rad, col);

DrawCircleLines((int)p.x, (int)p.y, rad + 1.0f, (Color){ 255, 255, 255, 200 });

if (i == hovered) {

float ph = 0.12f * t;

DrawOrbitDots2D(p, rad + 5.8f, 20, ph, 1.7f, (Color){ 255, 240, 190, 210 });

DrawOrbitDots2D(p, rad + 9.2f, 26, -0.8f * ph + 0.13f, 1.4f, (Color){ 165, 228, 255, 180 });

for (int k = 0; k < 8; k++) {

float ang = 2.0f * PI * ((float)k / 8.0f) + 0.5f * t;

Vector2 q = { p.x + (rad + 12.0f) * cosf(ang), p.y + (rad + 12.0f) * sinf(ang) };

DrawLineEx(p, q, 1.2f, (Color){ 255, 235, 190, 85 });

}

}

}

DrawText("Complex Plane", (int)panel.x + 14, (int)panel.y + 7, 18, (Color){ 190, 220, 255, 235 });

if (hovered >= 0) {

Complex r = MixedRootMapped(&map, a, b, mix, hovered);

char txt[96];

snprintf(txt, sizeof(txt), "r%d = %.3f %+.3fi", hovered + 1, r.re, r.im);

DrawText(txt, (int)panel.x + 14, (int)(panel.y + panel.height - 20), 16, (Color){ 245, 226, 170, 240 });

}

return hovered;

}

static int MiniPanelHoverToComplex(Rectangle panel, Vector2 mouse, const Preset *a, const Preset *b, float mix, Complex *outZ) {

RootMapping map = BuildRootMapping(a, b);

int n = map.n;

Rectangle inner = { panel.x + 14, panel.y + 26, panel.width - 28, panel.height - 40 };

if (!CheckCollisionPointRec(mouse, inner)) return 0;

float maxMag = 1.5f;

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

Complex r = MixedRootMapped(&map, a, b, mix, i);

float m = ComplexAbs(r);

if (m > maxMag) maxMag = m;

}

float scale = fminf(inner.width, inner.height) * 0.42f / maxMag;

Vector2 c = { inner.x + inner.width * 0.5f, inner.y + inner.height * 0.5f };

outZ->re = (mouse.x - c.x) / scale;

outZ->im = -(mouse.y - c.y) / scale;

return 1;

}

static int MiniPanelHoveredRootIndex(Rectangle panel, Vector2 mouse, const Preset *a, const Preset *b, float mix) {

RootMapping map = BuildRootMapping(a, b);

int n = map.n;

Rectangle inner = { panel.x + 14, panel.y + 26, panel.width - 28, panel.height - 40 };

Vector2 c = { inner.x + inner.width * 0.5f, inner.y + inner.height * 0.5f };

float maxMag = 1.5f;

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

Complex r = MixedRootMapped(&map, a, b, mix, i);

float m = ComplexAbs(r);

if (m > maxMag) maxMag = m;

}

float scale = fminf(inner.width, inner.height) * 0.42f / maxMag;

int hovered = -1;

float hoveredDist = 1e9f;

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

Complex r = MixedRootMapped(&map, a, b, mix, i);

Vector2 p = { c.x + r.re * scale, c.y - r.im * scale };

float dx = p.x - mouse.x;

float dy = p.y - mouse.y;

float d = sqrtf(dx * dx + dy * dy);

if (CheckCollisionPointRec(mouse, panel) && d < 11.0f && d < hoveredDist) {

hovered = i;

hoveredDist = d;

}

}

return hovered;

}

static void DrawRootSurface(Rectangle area, const Preset *a, const Preset *b, float mix, float t, int highlightedRoot, float camYaw, float camPitch, float camZoom, int probeActive, Complex probeZ) {

RootMapping map = BuildRootMapping(a, b);

int n = map.n;

const int uSteps = 190;

const int vSteps = 108;

float maxRootMag = MixedMaxRootMagnitude(&map, a, b, mix);

float domain = 1.25f + 1.75f * maxRootMag;

float cameraDistance = 9.4f + 0.85f * maxRootMag;

float mirrorY = -2.45f;

Vector3 mesh[MAX_U_STEPS][MAX_V_STEPS] = { 0 };

Color colors[MAX_U_STEPS][MAX_V_STEPS] = { 0 };

float reVals[MAX_U_STEPS][MAX_V_STEPS] = { 0 };

float imVals[MAX_U_STEPS][MAX_V_STEPS] = { 0 };

BeginScissorMode((int)area.x, (int)area.y, (int)area.width, (int)area.height);

Camera3D cam = BuildSurfaceCamera(cameraDistance, camYaw, camPitch, camZoom);

BeginMode3D(cam);

for (int u = 0; u < uSteps; u++) {

float fu = (float)u / (float)(uSteps - 1);

float xr = -domain + 2.0f * domain * fu;

for (int v = 0; v < vSteps; v++) {

float fv = (float)v / (float)(vSteps - 1);

float yi = -domain + 2.0f * domain * fv;

Complex z = { xr, yi };

Complex pVal = EvalPolynomialHomotopy(z, a, b, mix);

float y = SurfaceHeightFromValue(pVal);

mesh[u][v] = (Vector3){ xr, y, yi };

reVals[u][v] = pVal.re;

imVals[u][v] = pVal.im;

float yNorm = (y + 2.25f) / 4.5f;

Color cMath = SpectralColorFromComplex(pVal, yNorm);

if (highlightedRoot >= 0) {

Complex hr = MixedRootMapped(&map, a, b, mix, highlightedRoot);

float dx = xr - hr.re;

float dz = yi - hr.im;

float d2 = dx * dx + dz * dz;

float glow = expf(-d2 / (0.075f * domain * domain));

cMath = MixColor(cMath, (Color){ 255, 246, 214, 255 }, 0.45f * glow);

}

colors[u][v] = cMath;

}

}

rlDisableBackfaceCulling();

DrawPlane((Vector3){ 0.0f, mirrorY, 0.0f }, (Vector2){ domain * 2.5f, domain * 2.5f }, (Color){ 10, 20, 36, 120 });

rlSetTexture(0);

rlBegin(RL_TRIANGLES);