SolarSystem.cs

using OpenGL;
using System.Text.Json;

namespace Licenta_ver1
{
    public class CelestialBodyData
    {
        public string Name { get; set; }
        public Vertex3f Position { get; set; }
        public Vertex3f Velocity { get; set; }
        public double Radius { get; set; }
        public Color Color { get; set; }
        public double Mass { get; set; }
        public string TexturePath { get; set; }

        // new properties in degrees
        public float OrbitInclinationDeg { get; set; }
        public float SpinAxisDeg { get; set; }
        public float SpinPhaseDeg { get; set; }
    }

    public struct Vec3 { public double x, y, z; }

    /// <summary>
    /// Manages a collection of celestial bodies: loading, simulation, rendering.
    /// </summary>
    public class SolarSystem : IDisposable
    {
        private readonly Renderer _renderer;
        private readonly List<PlanetLoader.CelestialBodyData> _bodies;

        public float DistanceScale = 1e-10f;
        public float PlanetRadiusScale = 6e-7f;
        public float SunRadiusScale = 5e-6f;

        public SolarSystem(string jsonPath)
        {
            // 1) Load raw JSON data
            _bodies = PlanetLoader.LoadFromJson(jsonPath);

            // 3) Build the Sphere list
            var spheres = new List<Sphere>(_bodies.Count);
            foreach (var b in _bodies)
            {
                // convert tilts & spins to radians
                float orbitTiltRad = b.OrbitInclinationDeg * MathF.PI / 180f;
                float spinAxisRad = b.SpinAxisDeg * MathF.PI / 180f;
                float spinPhaseRad = b.SpinPhaseDeg * MathF.PI / 180f;

                // compute orbit normal & spin axis (tilted Y axis)
                var orbitNormal = new Vertex3f(
                    MathF.Sin(orbitTiltRad),
                    MathF.Cos(orbitTiltRad),
                    0f
                );
                var spinAxis = new Vertex3f(
                    MathF.Sin(spinAxisRad),
                    MathF.Cos(spinAxisRad),
                    0f
                );

                // apply distance and radius scaling
                var center = new Vertex3f(
                    (float)b.Position.x * DistanceScale,
                    (float)b.Position.y * DistanceScale,
                    (float)b.Position.z * DistanceScale
                );
                float radius;
                if (Path.GetFileNameWithoutExtension(b.TexturePath).ToLower() == "sun")
                    radius = b.Radius * SunRadiusScale;
                else
                    radius = b.Radius * PlanetRadiusScale;

                // add to list
                spheres.Add(new Sphere(
                    center,
                    radius,
                    b.TexturePath,
                    orbitNormal,
                    spinAxis,
                    spinPhaseRad
                ));
            }

            // 4) Create the renderer with all spheres at once
            _renderer = new Renderer(spheres);
        }

        public void Render(int w, int h, string primaryfocus, string? secondaryfocus, float yaw, float pitch, float dist)
            => _renderer.Render(w, h, primaryfocus, secondaryfocus, yaw, pitch, dist);

        public void Dispose()
            => _renderer.Dispose();

        /// <summary>
        /// Advance the physics simulation by dt seconds (simple Euler integrator).
        /// </summary>
        public void Simulate(double dt)
        {
            int n = _bodies.Count;
            if (n < 2) return;

            const double G = 6.674e-11;

            // zero forces
            for (int i = 0; i < n; i++)
                _bodies[i].Force = new Vertex3f(0, 0, 0);

            // pairwise gravity
            for (int i = 0; i < n; i++)
            {
                var bi = _bodies[i];
                for (int j = i + 1; j < n; j++)
                {
                    var bj = _bodies[j];
                    float dx = bj.Position.x - bi.Position.x;
                    float dy = bj.Position.y - bi.Position.y;
                    float dz = bj.Position.z - bi.Position.z;

                    double dist2 = dx * dx + dy * dy + dz * dz;
                    if (dist2 <= 0) continue;
                    double dist = Math.Sqrt(dist2);
                    if (dist <= bi.Radius + bj.Radius) continue;

                    double mag = G * bi.Mass * bj.Mass / dist2;
                    float ux = (float)(dx / dist);
                    float uy = (float)(dy / dist);
                    float uz = (float)(dz / dist);

                    var fij = new Vertex3f(
                        (float)(mag * ux),
                        (float)(mag * uy),
                        (float)(mag * uz)
                    );
                    bj.SpinPhaseDeg = (bj.SpinPhaseDeg + bj.SpinRateDegPerSec * (float)dt) % 360f;

                    bi.Force += fij;
                    bj.Force -= fij;
                }
            }

            // integrate
            for (int i = 0; i < n; i++)
            {
                var b = _bodies[i];
                var acc = b.Force / b.Mass;
                b.Velocity += acc * (float)dt;
                b.Position += b.Velocity * (float)dt;
            }
        }

        /// <summary>
        /// Builds a scaled snapshot of all bodies and pushes it into the GPU renderer.
        /// </summary>
        public void UpdateRenderer()
        {
            var scaledData = new List<PlanetLoader.CelestialBodyData>(_bodies.Count);
            foreach (var b in _bodies)
            {
                scaledData.Add(new PlanetLoader.CelestialBodyData
                {
                    Name = b.Name,
                    Position = new Vertex3f(
                                              b.Position.x * DistanceScale,
                                              b.Position.y * DistanceScale,
                                              b.Position.z * DistanceScale
                                           ),
                    Velocity = b.Velocity,
                    Radius = b.Radius * (Path.GetFileNameWithoutExtension(b.TexturePath) == "sun" ? SunRadiusScale : PlanetRadiusScale),
                    Color = b.Color,
                    Mass = b.Mass,
                    TexturePath = b.TexturePath,
                    OrbitInclinationDeg = b.OrbitInclinationDeg,
                    SpinAxisDeg = b.SpinAxisDeg,
                    SpinPhaseDeg = b.SpinPhaseDeg
                });
            }

            // push all scaled data to TestBody in one go:
            _renderer.UpdateAllSphereData(scaledData);
        }


    }
    public static class PlanetLoader
    {
        public class PlanetJson
        {
            public string Name { get; set; }

            public class Pos
            {
                public double x { get; set; }
                public double y { get; set; }
                public double z { get; set; }
            }
            public Pos Position { get; set; }

            public class Vel
            {
                public double vx { get; set; }
                public double vy { get; set; }
                public double vz { get; set; }
            }
            public Vel Velocity { get; set; }

            public double Radius { get; set; }
            public class Col
            {
                public float r { get; set; }
                public float g { get; set; }
                public float b { get; set; }
            }
            public Col Color { get; set; }
            public double Mass { get; set; }
            public string TexturePath { get; set; }
            public float OrbitInclinationDeg { get; set; }
            public float SpinAxisDeg { get; set; }
            public float SpinPhaseDeg { get; set; }
            public float SpinRateDegPerSec { get; set; }
        }

        public class CelestialBodyData
        {
            public string Name;
            public Vertex3f Position;
            public Vertex3f Velocity;
            public float Radius;
            public Color Color;          // System.Drawing.Color
            public double Mass;
            public string TexturePath;
            public float OrbitInclinationDeg;
            public float SpinAxisDeg;
            public float SpinPhaseDeg;
            public Vertex3f Force;
            public float SpinRateDegPerSec;
        }

        public static List<CelestialBodyData> LoadFromJson(string jsonPath)
        {
            if (!File.Exists(jsonPath))
                throw new FileNotFoundException("JSON file not found", jsonPath);

            var json = File.ReadAllText(jsonPath);
            var options = new JsonSerializerOptions
            {
                PropertyNameCaseInsensitive = true,
                AllowTrailingCommas = true
            };

            var raw = JsonSerializer
                .Deserialize<List<PlanetJson>>(json, options)
                ?? throw new InvalidDataException("Failed to parse JSON");

            var list = new List<CelestialBodyData>(raw.Count);
            foreach (var p in raw)
            {
                // convert JSON color (0…1 floats) → 0…255 ints safely
                int R = (int)Math.Clamp(p.Color.r * 255f, 0f, 255f);
                int G = (int)Math.Clamp(p.Color.g * 255f, 0f, 255f);
                int B = (int)Math.Clamp(p.Color.b * 255f, 0f, 255f);
                var col = System.Drawing.Color.FromArgb(R, G, B);

                // explicit casts from double → float
                var pos = new Vertex3f(
                    (float)p.Position.x,
                    (float)p.Position.y,
                    (float)p.Position.z
                );
                var vel = new Vertex3f(
                    (float)p.Velocity.vx,
                    (float)p.Velocity.vy,
                    (float)p.Velocity.vz
                );

                list.Add(new CelestialBodyData
                {
                    Name = p.Name,
                    Position = pos,
                    Velocity = vel,
                    Radius = (float)p.Radius,
                    Color = col,
                    Mass = p.Mass,
                    TexturePath = p.TexturePath ?? "",
                    OrbitInclinationDeg = p.OrbitInclinationDeg,
                    SpinAxisDeg = p.SpinAxisDeg,
                    SpinPhaseDeg = p.SpinPhaseDeg,
                    SpinRateDegPerSec = p.SpinRateDegPerSec
                }); 
            }

            return list;
        }
    }
}