diff --git a/README.md b/README.md
index bba26ba..1156f4c 100644
--- a/README.md
+++ b/README.md
@@ -21,6 +21,7 @@ Solen och de åtta planeterna definieras i [KnownSolarSystem/solar-systems.json]
| Space / Ctrl | Upp / ner relativt kameran |
| Mushjul | Logaritmisk hastighet, 0,1 m/s till 1 000 000 c |
| Q | Mjuk flygning till närmaste planet |
+| E | Mjuk flygning till närmaste svarta hål, även från en planets markyta |
| 1–9 | Flyg till planeten på motsvarande plats i `startup.planetHotkeys` i `config.json` |
| F2 | Mjuk flygning till en bergsvy nära ytan; hastigheten sänks till 1 200 m/s |
| F3 | Närbild av närmaste stjärna |
@@ -56,6 +57,18 @@ Välj **Debug** i P-menyn för en panel till vänster med asynkron GPU-tid för
Detta är en visuell realtidsprototyp. Banorna är statiska och terrängen använder proceduriell relief; ingen hydrologisk erosionssimulering eller atmosfär med multipel spridning beräknas.
+## Svarta hål
+
+I proceduriella system ersätter ett svart hål stjärnan med 5 % sannolikhet. Samma seed och cell ger samma hål, massa och skivlutning. Kända system, inklusive Solsystemet, behåller sina definierade stjärnor. Planeterna placeras utanför ackretionsskivan och belyses av dess utstrålning.
+
+Tryck **E** för en nio sekunders kameraresa till en sned vy över skivan. Sökningen expanderar cell för cell och jämför verkliga dubbelprecisionsavstånd; den avslutas när närmaste träff är säker, med en maximal sökradie på åtta celler. Kameran lämnar först planetens yta om den behöver det.
+
+`blackHoles` i `config.json` styr `occurrenceChance` (0–1), `minimumMassSolar`, `maximumMassSolar`, `diskOuterRadiusInHorizons`, `diskBrightness` och `raySteps` (128–512). Sätt sannolikheten till 0 för att stänga av genereringen. Standardvärdena ger 200 000–600 000 solmassor, en skiva som sträcker sig till 14 horisontradier och 256 strålsteg.
+
+Renderingen integrerar böjda ljusbanor i en förenklad Schwarzschildmodell och en tunn, animerad skiva. Horisontskugga, böjda bilder av skivans baksida, fotonring, dopplerförstärkning, gravitationell rödskiftning och HDR-bloom skapar utseendet. Se [Gralla, Holz och Wald: Black Hole Shadows, Photon Rings, and Lensing Rings](https://arxiv.org/abs/1906.00873) för bakgrunden till lins- och fotonringarna. Bakgrunden samplas från scenbilden när den finns i bild; riktningar bakom kameran får ett proceduriellt stjärnfält. Detta är en visuell realtidsmodell med en konstnärligt styrd emissionsskiva.
+
+Debug-panelen visar `BLACK HOLE / LENSING` separat. Kör `Universe.App.exe --black-hole-report` för att rendera närmaste hål till `graphics-report/black-hole.png` och kontrollera shaderkompilering, OpenGL-fel och giltiga bildvärden.
+
## Projekt
- `src/Universe.Core`: koordinater, systemgenerering, noise, terräng, streaming och svept kollision.
diff --git a/config.json b/config.json
index 6ba51c5..a83580e 100644
--- a/config.json
+++ b/config.json
@@ -2,6 +2,14 @@
"universeSeed": "0x554E495645525345",
"cellSizeAu": 100,
"knownSolarSystemsFile": "KnownSolarSystem/solar-systems.json",
+ "blackHoles": {
+ "occurrenceChance": 0.05,
+ "minimumMassSolar": 200000,
+ "maximumMassSolar": 600000,
+ "diskOuterRadiusInHorizons": 14,
+ "diskBrightness": 4,
+ "raySteps": 256
+ },
"startup": {
"systemId": "sol",
"planetId": "earth",
diff --git a/src/Universe.App/Graphics/GraphicsReport.cs b/src/Universe.App/Graphics/GraphicsReport.cs
index 2d58b1c..0dd7a18 100644
--- a/src/Universe.App/Graphics/GraphicsReport.cs
+++ b/src/Universe.App/Graphics/GraphicsReport.cs
@@ -13,6 +13,29 @@ namespace Universe.App.Graphics;
/// Offscreen tests of the production shaders; no desktop capture or mouse control.
internal static class GraphicsReport
{
+ public static void RunBlackHole(GL gl, UniverseRenderer renderer, UniverseNeighborhood neighborhood, StarData hole,
+ double cellSize, int width, int height)
+ {
+ var center = UniversePosition.AtCellCenter(neighborhood.ActiveSystem.Coordinate, cellSize);
+ var body = center.Add(hole.PositionMeters, cellSize);
+ var camera = new FlyCamera(body.Add(new DVector3(0, 0, hole.RadiusMeters * 80), cellSize), cellSize);
+ camera.RequestBlackHoleView(neighborhood.ActiveSystem, hole, [neighborhood.ActiveSystem]);
+ for (var i = 0; i < 600; i++) camera.Update(1d / 60, DVector3.Zero, neighborhood);
+ for (var i = 0; i < 4; i++) renderer.Render(camera, neighborhood, 1d / 60);
+ renderer.ProfileFrame = true;
+ renderer.Render(camera, neighborhood, 1d / 60);
+ renderer.ProfileFrame = false;
+ gl.Finish();
+ if (gl.GetError() is var error && error != GLEnum.NoError) throw new InvalidOperationException($"Black hole GL error: {error}");
+ var pixels = Read(gl, width, height);
+ if (pixels.Any(p => !float.IsFinite(p)) || pixels.Where((_, i) => i % 4 != 3).Max() < .2)
+ throw new InvalidOperationException("Black hole produced invalid or empty output.");
+ var directory = Path.Combine(AppContext.BaseDirectory, "graphics-report"); Directory.CreateDirectory(directory);
+ var path = Path.Combine(directory, "black-hole.png");
+ WritePng(path, width, height, pixels, false);
+ Console.WriteLine($"Black hole: {hole.Name}; {hole.BlackHole!.MassSolar:F0} solar masses; camera {camera.Position.RelativeTo(body, cellSize).Length / hole.RadiusMeters:F2} horizons; lensing {renderer.FrameTimings["black hole lensing"]:F2} ms at {width}x{height}; image {path}");
+ }
+
public static void RunTerrainPerformance(GL gl, UniverseRenderer renderer, UniverseNeighborhood neighborhood, double cellSize, int width, int height)
{
var system = neighborhood.ActiveSystem;
diff --git a/src/Universe.App/Graphics/PerformanceOverlay.cs b/src/Universe.App/Graphics/PerformanceOverlay.cs
index a6c1bf7..97f88ac 100644
--- a/src/Universe.App/Graphics/PerformanceOverlay.cs
+++ b/src/Universe.App/Graphics/PerformanceOverlay.cs
@@ -36,6 +36,7 @@ internal sealed class PerformanceOverlay : IDisposable
AddMetric("ATMOSPHERE", "ATMOSPHERE");
AddMetric("CLOUDS / COMPOSITE", "CLOUDS / COMPOSITE");
AddMetric("SUN GLOW", "SUN GLOW");
+ AddMetric("BLACK HOLE / LENSING", "BLACK HOLE / LENSING");
AddMetric("BLOOM / POST", "BLOOM / POST");
rows.Add(("SHADOWS IN PLANET", "SEE PLANET MS", false));
rows.Add(("CPU SUBMIT", $"{Number(cpuMilliseconds)} MS", false));
diff --git a/src/Universe.App/Graphics/Shaders/black-hole.frag.glsl b/src/Universe.App/Graphics/Shaders/black-hole.frag.glsl
new file mode 100644
index 0000000..1f66e59
--- /dev/null
+++ b/src/Universe.App/Graphics/Shaders/black-hole.frag.glsl
@@ -0,0 +1,118 @@
+#version 330 core
+#include "camera-ray.glsl"
+in vec2 vUv;
+uniform sampler2D uScene;
+uniform sampler2D uDepth;
+uniform vec3 uCamera; // Relative to the hole, in Schwarzschild radii.
+uniform vec3 uDiskX;
+uniform vec3 uDiskNormal;
+uniform vec3 uDiskZ;
+uniform float uHorizonMeters;
+uniform float uOuterRadius;
+uniform float uBrightness;
+uniform float uTime;
+uniform float uSeed;
+uniform float uFar;
+uniform int uSteps;
+out vec4 fragColor;
+
+float hash21(vec2 p) {
+ vec3 p3=fract(vec3(p.xyx)*.1031);
+ p3+=dot(p3,p3.yzx+33.33);
+ return fract((p3.x+p3.y)*p3.z);
+}
+float valueNoise(vec2 p) {
+ vec2 i=floor(p),f=fract(p); f=f*f*(3.0-2.0*f);
+ float y=mod(i.y,64.0),nextY=mod(i.y+1.0,64.0);
+ return mix(mix(hash21(vec2(i.x,y)),hash21(vec2(i.x+1.0,y)),f.x),
+ mix(hash21(vec2(i.x,nextY)),hash21(vec2(i.x+1.0,nextY)),f.x),f.y);
+}
+vec3 diskLight(vec3 p,vec3 ray) {
+ float radius=length(p),angle=atan(dot(p,uDiskZ),dot(p,uDiskX));
+ float rotation=uTime*.24/pow(radius/3.0,1.5);
+ float azimuth=angle*10.185916; // 64 cells around the disk: no atan seam.
+ vec2 flow=vec2(log(radius)*38.0,azimuth-rotation+log(radius)*11.0);
+ float turbulence=valueNoise(flow+uSeed)*.55+valueNoise(flow*vec2(2.03,2.0))*.28+valueNoise(flow*vec2(4.1,4.0))*.17;
+ float threads=valueNoise(vec2(radius*110.0+turbulence*3.0,azimuth*2.0-rotation));
+ float bands=valueNoise(vec2(log(radius)*92.0,azimuth-rotation*.3));
+ float structure=(.35+.95*turbulence)*(.55+.65*threads)*(.6+.5*bands);
+ float inner=smoothstep(3.0,3.5,radius);
+ float outer=1.0-smoothstep(uOuterRadius*.68,uOuterRadius,radius);
+ float thermal=pow(3.0/max(radius,3.0),1.7);
+ vec3 cool=vec3(.42,.16,.07),hot=vec3(1.0,.87,.68);
+ vec3 tint=mix(cool,hot,pow(clamp(thermal*1.4,0.0,1.0),.6));
+ // Local orbital velocity and Schwarzschild redshift. This is an artistic
+ // thin-disk emission model, rather than a full relativistic plasma simulation.
+ vec3 tangent=normalize(cross(uDiskNormal,p));
+ float beta=sqrt(.5/max(radius-1.0,1.0));
+ float doppler=sqrt(1.0-beta*beta)/max(.25,1.0-beta*dot(tangent,-normalize(ray)));
+ float redshift=sqrt(max(.05,1.0-1.0/radius));
+ float boost=clamp(pow(doppler*redshift,3.0),.18,3.5);
+ return tint*structure*inner*outer*thermal*boost*uBrightness;
+}
+vec3 sky(vec3 direction) {
+ float front=dot(direction,uForward);
+ if(front>.001) {
+ vec2 uv=vec2(dot(direction,uRight)/(front*uAspect),dot(direction,uUp)/front)/uTanHalfFov*.5+.5;
+ if(all(greaterThanEqual(uv,vec2(0)))&&all(lessThanEqual(uv,vec2(1))))return texture(uScene,uv).rgb;
+ }
+ // Rays can curl behind the camera. Fill those directions with a fixed
+ // world-oriented starfield, without mirroring the screen at its edges.
+ vec2 sphere=vec2(atan(direction.z,direction.x),asin(clamp(direction.y,-1.0,1.0)))*vec2(700,700);
+ vec2 cell=floor(sphere),q=fract(sphere)-.5;
+ float star=step(.996,hash21(cell))*exp(-dot(q,q)*150.0);
+ float band=pow(max(0.0,1.0-abs(dot(direction,normalize(vec3(.32,.72,.48))))),17.0);
+ return vec3(.00018,.00025,.0005)+vec3(.0013,.0016,.0026)*band+star*vec3(.35,.42,.55);
+}
+vec3 acceleration(vec3 p,float angularMomentumSquared) {
+ float r2=dot(p,p);
+ // The null-geodesic orbit equation u''+u=1.5*u² (rs=1), expressed
+ // as a central force with conserved angular momentum.
+ return -1.5*angularMomentumSquared*p/(r2*r2*sqrt(r2));
+}
+void main() {
+ vec4 original=texture(uScene,vUv);
+ vec3 rd=cameraRay(vUv),p=uCamera;
+ float domain=max(32.0,uOuterRadius*2.3);
+ float b=dot(p,rd),c=dot(p,p)-domain*domain,discriminant=b*b-c;
+ if(discriminant<0.0||-b+sqrt(max(0.0,discriminant))<0.0){fragColor=original;return;}
+ float entry=max(0.0,-b-sqrt(discriminant));
+ float sceneDepth=texture(uDepth,vUv).r;
+ float sceneDistance=(exp2(sceneDepth*log2(1.0+uFar))-1.0)/max(.001,dot(rd,uForward))/uHorizonMeters;
+ if(sceneDepth<.999999&&sceneDistance=uSteps)break;
+ float r=length(p);
+ if(r<1.025){captured=true;break;}
+ if(r>domain+1.0&&dot(p,velocity)>0.0){escaped=true;break;}
+ float stepSize=clamp(r*.085,.025,2.5);
+ vec3 a=acceleration(p,h2);
+ vec3 middle=p+velocity*stepSize*.5;
+ vec3 next=p+(velocity+a*stepSize*.5)*stepSize;
+ vec3 nextVelocity=velocity+acceleration(middle,h2)*stepSize;
+ float height=dot(p,uDiskNormal),nextHeight=dot(next,uDiskNormal);
+ if(height*nextHeight<0.0) {
+ vec3 hit=mix(p,next,height/(height-nextHeight));
+ float diskRadius=length(hit);
+ if(diskRadius>3.0&&diskRadius.008))?vec3(0):sky(normalize(velocity));
+ float impact=length(cross(uCamera,rd));
+ float photonRing=exp(-pow((impact-2.59808)/.022,2.0))*.15;
+ vec3 color=emission+background*transmission+vec3(1.0,.66,.34)*photonRing;
+ fragColor=vec4(color,original.a);
+}
diff --git a/src/Universe.App/Graphics/UniverseRenderer.cs b/src/Universe.App/Graphics/UniverseRenderer.cs
index bc5a3e7..ade005b 100644
--- a/src/Universe.App/Graphics/UniverseRenderer.cs
+++ b/src/Universe.App/Graphics/UniverseRenderer.cs
@@ -40,6 +40,7 @@ internal sealed class UniverseRenderer : IDisposable
private ShaderProgram _rock;
private ShaderProgram _rockPoints;
private ShaderProgram _sunGlow;
+ private ShaderProgram _blackHole;
private ShaderProgram _ocean;
private ShaderProgram _clouds;
private ShaderProgram _cloudComposite;
@@ -53,6 +54,7 @@ internal sealed class UniverseRenderer : IDisposable
private RenderTarget _scene = null!;
private RenderTarget _gasInput = null!;
private RenderTarget _glareTarget = null!;
+ private RenderTarget _blackHoleTarget = null!;
private RenderTarget _scatterA = null!;
private RenderTarget _scatterB = null!;
private RenderTarget _bloomA = null!;
@@ -107,6 +109,7 @@ internal sealed class UniverseRenderer : IDisposable
_rock = Program("rock.vert", "rock.frag");
_rockPoints = Program("rock-point.vert", "rock-point.frag");
_sunGlow = Program("fullscreen.vert", "sun-glow.frag");
+ _blackHole = Program("fullscreen.vert", "black-hole.frag");
_ocean = Program("fullscreen.vert", "ocean.frag");
_clouds = Program("fullscreen.vert", "cloud.frag");
_cloudComposite = Program("fullscreen.vert", "cloud-composite.frag");
@@ -168,7 +171,7 @@ internal sealed class UniverseRenderer : IDisposable
foreach (var pair in new[] { ("terrain.vert","terrain.frag"),("star.vert","star.frag"),("fullscreen.vert","sky.frag"),("point.vert","point.frag"),
("fullscreen.vert","atmosphere.frag"),("fullscreen.vert","bright.frag"),("fullscreen.vert","blur.frag"),("fullscreen.vert","final.frag"),("fullscreen.vert","ring.frag"),
("fullscreen.vert","gas.frag"),("rock.vert","rock.frag"),("rock-point.vert","rock-point.frag"),("fullscreen.vert","sun-glow.frag"),("fullscreen.vert","ocean.frag"),
- ("fullscreen.vert","cloud.frag"),("fullscreen.vert","cloud-composite.frag") })
+ ("fullscreen.vert","cloud.frag"),("fullscreen.vert","cloud-composite.frag"),("fullscreen.vert","black-hole.frag") })
replacements.Add(Program(pair.Item1, pair.Item2));
}
catch (Exception error)
@@ -186,6 +189,7 @@ internal sealed class UniverseRenderer : IDisposable
_sunGlow.Dispose(); _sunGlow = replacements[12];
_ocean.Dispose(); _ocean = replacements[13];
_clouds.Dispose(); _clouds = replacements[14]; _cloudComposite.Dispose(); _cloudComposite = replacements[15];
+ _blackHole.Dispose(); _blackHole = replacements[16];
}
public void SetActiveSystem(SectorCoordinate coordinate)
@@ -211,9 +215,11 @@ internal sealed class UniverseRenderer : IDisposable
_height = System.Math.Max(height, 1);
_cloudRaw?.Dispose(); _cloudRaw = null;
_scene?.Dispose(); _gasInput?.Dispose(); _glareTarget?.Dispose(); _scatterA?.Dispose(); _scatterB?.Dispose(); _bloomA?.Dispose(); _bloomB?.Dispose();
+ _blackHoleTarget?.Dispose();
_scene = new(_gl, _width, _height, true);
_gasInput = new(_gl, _width, _height, true);
_glareTarget = new(_gl, _width, _height);
+ _blackHoleTarget = new(_gl, _width, _height);
_scatterA = new(_gl, _width, _height);
_scatterB = new(_gl, _width, _height);
_bloomA = new(_gl, System.Math.Max(1, _width / 4), System.Math.Max(1, _height / 4));
@@ -258,7 +264,7 @@ internal sealed class UniverseRenderer : IDisposable
_sky.Set("uNoise", 4); _sky.Set("uTime", (float)_time);
_sky.Set("uLightCount", system.Stars.Count);
_sky.SetVectorArray("uStarDirections", starPositions.Select(p => p.Normalized().ToVector3()).ToArray());
- _sky.SetVectorArray("uStarColors", system.Stars.Select(s => s.Color).ToArray());
+ _sky.SetVectorArray("uStarColors", system.Stars.Select(s => s.IsBlackHole ? Vector3.Zero : s.Color).ToArray());
_sky.SetFloatArray("uStarAngles", system.Stars.Select((s, i) => (float)System.Math.Asin(System.Math.Clamp(ApparentStarRadius(s, starPositions[i].Length) / starPositions[i].Length, 0, 1))).ToArray());
_gpuProfiler.BeginPass("SKY / STARFIELD");
_fullscreen.Draw();
@@ -295,6 +301,10 @@ internal sealed class UniverseRenderer : IDisposable
composed = DrawClouds(camera, system, far, composed);
_gpuProfiler.EndPass();
Mark("clouds");
+ _gpuProfiler.BeginPass("BLACK HOLE / LENSING");
+ composed = DrawBlackHoles(camera, system, far, composed);
+ _gpuProfiler.EndPass();
+ Mark("black hole lensing");
_gpuProfiler.BeginPass("SUN GLOW");
DrawSunGlow(camera, system, starPositions, far, composed);
_gpuProfiler.EndPass();
@@ -380,6 +390,7 @@ internal sealed class UniverseRenderer : IDisposable
var origin = UniversePosition.AtCellCenter(system.Coordinate, camera.CellSizeMeters);
foreach (var star in system.Stars)
{
+ if (star.IsBlackHole) continue;
var rel = origin.Add(star.PositionMeters, camera.CellSizeMeters).RelativeTo(camera.Position, camera.CellSizeMeters);
AddPoint(points, rel, star.Color * 1.3f, 3.2f);
}
@@ -748,6 +759,7 @@ internal sealed class UniverseRenderer : IDisposable
for (var i = 0; i < system.Stars.Count; i++)
{
var star = system.Stars[i];
+ if (star.IsBlackHole) continue;
_star.Set("uCenter", positions[i].ToVector3());
_star.Set("uRadius", (float)ApparentStarRadius(star, positions[i].Length));
_star.Set("uColor", star.Color);
@@ -756,6 +768,32 @@ internal sealed class UniverseRenderer : IDisposable
}
}
+ private RenderTarget DrawBlackHoles(FlyCamera camera, StarSystemData system, float far, RenderTarget source)
+ {
+ var star = system.Stars.FirstOrDefault(s => s.IsBlackHole);
+ if (star?.BlackHole is not { } hole) return source;
+ var center = UniversePosition.AtCellCenter(system.Coordinate, camera.CellSizeMeters);
+ var relative = center.Add(star.PositionMeters, camera.CellSizeMeters).RelativeTo(camera.Position, camera.CellSizeMeters);
+ if (DVector3.Dot(relative, camera.Forward) < -hole.HorizonRadiusMeters * 32) return source;
+ _gl.Disable(GLEnum.DepthTest); _gl.Disable(GLEnum.Blend); _gl.DepthMask(false);
+ _blackHoleTarget.Bind(); _blackHole.Use(); SetCameraRay(_blackHole, camera);
+ BindTexture(0, source.Color); BindTexture(1, _scene.Depth);
+ var axis = System.Math.Abs(hole.DiskNormal.Y) < .9 ? new DVector3(0, 1, 0) : new DVector3(1, 0, 0);
+ var x = DVector3.Cross(hole.DiskNormal, axis).Normalized();
+ var z = DVector3.Cross(x, hole.DiskNormal).Normalized();
+ _blackHole.Set("uScene", 0); _blackHole.Set("uDepth", 1); _blackHole.Set("uFar", far);
+ _blackHole.Set("uCamera", (-relative / hole.HorizonRadiusMeters).ToVector3());
+ _blackHole.Set("uDiskX", x.ToVector3()); _blackHole.Set("uDiskZ", z.ToVector3());
+ _blackHole.Set("uDiskNormal", hole.DiskNormal.ToVector3());
+ _blackHole.Set("uHorizonMeters", (float)hole.HorizonRadiusMeters);
+ _blackHole.Set("uOuterRadius", (float)hole.DiskOuterRadiusInHorizons);
+ _blackHole.Set("uBrightness", (float)hole.DiskBrightness);
+ _blackHole.Set("uSteps", hole.RaySteps); _blackHole.Set("uTime", (float)_time);
+ _blackHole.Set("uSeed", (float)(star.Seed & 65535) * .01f);
+ _fullscreen.Draw();
+ return _blackHoleTarget;
+ }
+
private RenderTarget DrawAtmospheres(FlyCamera camera, StarSystemData system, float far)
{
var center = UniversePosition.AtCellCenter(system.Coordinate, camera.CellSizeMeters);
@@ -948,7 +986,7 @@ internal sealed class UniverseRenderer : IDisposable
var z = DVector3.Dot(position, camera.Forward); var distance = position.Length;
var apparentRadius = ApparentStarRadius(star, distance);
var front = System.Math.Max(1, z - apparentRadius * 1.06);
- var intensity = z > 0 ? glow.Attenuation(distance, star.LuminositySolar) : 0;
+ var intensity = z > 0 && !star.IsBlackHole ? glow.Attenuation(distance, star.LuminositySolar) : 0;
var uv = new Vector3((float)(.5 + DVector3.Dot(position, camera.Right) / (2 * System.Math.Max(1, z) * tan * aspect)),
(float)(.5 + DVector3.Dot(position, camera.Up) / (2 * System.Math.Max(1, z) * tan)),
(float)(System.Math.Log2(1 + front) / System.Math.Log2(1 + far)));
@@ -1044,6 +1082,7 @@ internal sealed class UniverseRenderer : IDisposable
_benchmarkOverlay.Dispose();
_gas.Dispose(); _rock.Dispose(); _rockPoints.Dispose(); _emptyRing.Dispose(); _gasInput.Dispose();
_sunGlow.Dispose(); _glareTarget.Dispose();
+ _blackHole.Dispose(); _blackHoleTarget.Dispose();
_ocean.Dispose();
_clouds.Dispose(); _cloudComposite.Dispose(); _cloudNoise.Dispose(); _emptyCloudDensity.Dispose(); _materials.Dispose(); _cloudRaw?.Dispose();
_scene.Dispose(); _scatterA.Dispose(); _scatterB.Dispose(); _bloomA.Dispose(); _bloomB.Dispose(); _noise.Dispose();
diff --git a/src/Universe.App/Runtime/FlyCamera.cs b/src/Universe.App/Runtime/FlyCamera.cs
index 326cefb..72b093a 100644
--- a/src/Universe.App/Runtime/FlyCamera.cs
+++ b/src/Universe.App/Runtime/FlyCamera.cs
@@ -272,7 +272,7 @@ public sealed class FlyCamera
public void RequestStarView(IEnumerable systems)
{
- var nearest = systems.SelectMany(system => system.Stars.Select(star => (System: system, Star: star)))
+ var nearest = systems.SelectMany(system => system.Stars.Where(s => !s.IsBlackHole).Select(star => (System: system, Star: star)))
.MinBy(body => World(body.System, body.Star.PositionMeters).RelativeTo(Position, CellSizeMeters).LengthSquared);
if (nearest.Star is null) return;
var bodyPosition = World(nearest.System, nearest.Star.PositionMeters);
@@ -280,6 +280,28 @@ public sealed class FlyCamera
BeginFlight(bodyPosition, radial, nearest.Star.RadiusMeters * 2.55, nearest.Star.RadiusMeters * 5, -radial, new(0, 1, 0), 10_000_000);
}
+ public void RequestBlackHoleView(StarSystemData system, StarData star, IEnumerable departureSystems)
+ {
+ if (star.BlackHole is not { } hole) return;
+ var body = World(system, star.PositionMeters);
+ var equator = Perpendicular(hole.DiskNormal);
+ var radial = (equator * System.Math.Cos(.075) + hole.DiskNormal * System.Math.Sin(.075)).Normalized();
+ var up = RotateAround(hole.DiskNormal, -radial, .18);
+ Departure? departure = null;
+ var escape = departureSystems.SelectMany(s => s.Planets.Where(p => !p.IsGasPlanet).Select(p => (System: s, Planet: p)))
+ .MinBy(p => World(p.System, p.Planet.PositionMeters).RelativeTo(Position, CellSizeMeters).Length / p.Planet.RadiusMeters);
+ if (escape.Planet is { } solid)
+ {
+ var origin = World(escape.System, solid.PositionMeters);
+ var start = Position.RelativeTo(origin, CellSizeMeters);
+ if (start.Length < solid.MaximumTerrainRadiusMeters * 1.1)
+ departure = new(origin, start.Normalized(), body.RelativeTo(origin, CellSizeMeters).Normalized(),
+ start.Length, solid.MaximumTerrainRadiusMeters * 1.12);
+ }
+ BeginFlight(body, radial, star.RadiusMeters * 26, star.RadiusMeters * 70, -radial, up,
+ star.RadiusMeters * .08, duration: 9, fieldOfView: 32 * System.Math.PI / 180, departure: departure);
+ }
+
private UniversePosition World(StarSystemData system, DVector3 offset) => UniversePosition.AtCellCenter(system.Coordinate, CellSizeMeters).Add(offset, CellSizeMeters);
private void BeginFlight(UniversePosition body, DVector3 radial, double finalRadius, double approachRadius, DVector3 forward, DVector3 up, double speed,
diff --git a/src/Universe.App/UniverseApplication.cs b/src/Universe.App/UniverseApplication.cs
index 180becb..cf0395f 100644
--- a/src/Universe.App/UniverseApplication.cs
+++ b/src/Universe.App/UniverseApplication.cs
@@ -52,7 +52,7 @@ public sealed class UniverseApplication : IDisposable
_planetHotkeys = configuration.Startup.PlanetHotkeys;
var catalogPath = Path.GetFullPath(Path.Combine(Path.GetDirectoryName(configPath)!, configuration.KnownSolarSystemsFile));
var catalog = KnownSolarSystemCatalog.Load(catalogPath, configuration.CellSizeMeters);
- _generator = new(configuration.Seed, configuration.CellSizeMeters, catalog);
+ _generator = new(configuration.Seed, configuration.CellSizeMeters, catalog, configuration.BlackHoles);
_streamer = new(_generator);
var initialSystem = configuration.ResolveStartup(catalog).System;
_homeSystem = catalog.GetById("sol");
@@ -72,7 +72,7 @@ public sealed class UniverseApplication : IDisposable
var options = WindowOptions.Default with
{
Title = "Universe | loading",
- IsVisible = !Environment.GetCommandLineArgs().Any(a => a is "--graphics-report" or "--scene-report" or "--ocean-report" or "--cloud-report" or "--terrain-report" or "--menu-report" or "--terrain-perf-report"),
+ IsVisible = !Environment.GetCommandLineArgs().Any(a => a is "--graphics-report" or "--scene-report" or "--ocean-report" or "--cloud-report" or "--terrain-report" or "--menu-report" or "--terrain-perf-report" or "--black-hole-report"),
Size = new Vector2D(1440, 900),
VSync = true,
PreferredDepthBufferBits = 24,
@@ -93,6 +93,14 @@ public sealed class UniverseApplication : IDisposable
var gl = _window.CreateOpenGL();
_input = _window.CreateInput();
_renderer = new(gl, _window.FramebufferSize.X, _window.FramebufferSize.Y);
+ if (Environment.GetCommandLineArgs().Contains("--black-hole-report"))
+ {
+ var target = _streamer.FindNearestBlackHole(_camera.Position)
+ ?? throw new InvalidOperationException("No black hole found; check blackHoles.occurrenceChance.");
+ GraphicsReport.RunBlackHole(gl, _renderer, _streamer.Load(target.System.Coordinate), target.Hole,
+ _generator.CellSizeMeters, _window.FramebufferSize.X, _window.FramebufferSize.Y);
+ _window.Close(); return;
+ }
if (Environment.GetCommandLineArgs().Contains("--terrain-perf-report"))
{ GraphicsReport.RunTerrainPerformance(gl, _renderer, _neighborhood, _generator.CellSizeMeters, _window.FramebufferSize.X, _window.FramebufferSize.Y); _window.Close(); return; }
if (Environment.GetCommandLineArgs().Contains("--menu-report"))
@@ -235,6 +243,16 @@ public sealed class UniverseApplication : IDisposable
if (_benchmark?.IsRunning == true && key != Key.F1) return;
if (key == Key.Escape)
_window.Close();
+ else if (key == Key.E)
+ {
+ var target = _streamer.FindNearestBlackHole(_camera.Position);
+ if (target is { } hole)
+ {
+ _player = null;
+ _camera.RequestBlackHoleView(hole.System, hole.Hole, _neighborhood.NearbySystems.Append(_neighborhood.ActiveSystem));
+ }
+ else _window.Title = "Universe | No black hole found in the search area";
+ }
else if (_player is not null && key != Key.F1) return;
else if (key == Key.Q)
_camera.RequestFocus(_neighborhood.NearbySystems.Append(_neighborhood.ActiveSystem));
diff --git a/src/Universe.Core/Configuration/EngineConfiguration.cs b/src/Universe.Core/Configuration/EngineConfiguration.cs
index cd44ac3..0f10c1a 100644
--- a/src/Universe.Core/Configuration/EngineConfiguration.cs
+++ b/src/Universe.Core/Configuration/EngineConfiguration.cs
@@ -23,6 +23,7 @@ public sealed record EngineConfiguration
public double CellSizeAu { get; init; } = 100;
public string KnownSolarSystemsFile { get; init; } = "KnownSolarSystem/solar-systems.json";
public StartupConfiguration Startup { get; init; } = new();
+ public BlackHoleGenerationSettings BlackHoles { get; init; } = new();
public double CellSizeMeters => CellSizeAu * UniverseScale.AstronomicalUnitMeters;
public ulong Seed => UniverseSeed.StartsWith("0x", StringComparison.OrdinalIgnoreCase)
? ulong.Parse(UniverseSeed.AsSpan(2), NumberStyles.AllowHexSpecifier, CultureInfo.InvariantCulture)
@@ -42,6 +43,7 @@ public sealed record EngineConfiguration
public static EngineConfiguration Load(string path)
{
var settings = JsonSettings.Read(path);
+ (settings.BlackHoles ?? throw new InvalidDataException("config.json: blackHoles cannot be null.")).Validate();
if (string.IsNullOrWhiteSpace(settings.UniverseSeed)) throw new InvalidDataException("config.json: universeSeed cannot be empty.");
try { _ = settings.Seed; }
catch (Exception error) when (error is FormatException or OverflowException or ArgumentNullException)
diff --git a/src/Universe.Core/Generation/BlackHoleSettings.cs b/src/Universe.Core/Generation/BlackHoleSettings.cs
new file mode 100644
index 0000000..1ad6ff3
--- /dev/null
+++ b/src/Universe.Core/Generation/BlackHoleSettings.cs
@@ -0,0 +1,31 @@
+using Universe.Core.Math;
+
+namespace Universe.Core.Generation;
+
+public sealed record BlackHoleGenerationSettings
+{
+ public double OccurrenceChance { get; init; } = .05;
+ public double MinimumMassSolar { get; init; } = 200_000;
+ public double MaximumMassSolar { get; init; } = 600_000;
+ public double DiskOuterRadiusInHorizons { get; init; } = 14;
+ public double DiskBrightness { get; init; } = 4;
+ public int RaySteps { get; init; } = 256;
+
+ public void Validate()
+ {
+ if (!double.IsFinite(OccurrenceChance) || OccurrenceChance is < 0 or > 1
+ || !double.IsFinite(MinimumMassSolar) || MinimumMassSolar < 1
+ || !double.IsFinite(MaximumMassSolar) || MaximumMassSolar < MinimumMassSolar || MaximumMassSolar > 10_000_000
+ || !double.IsFinite(DiskOuterRadiusInHorizons) || DiskOuterRadiusInHorizons is < 5 or > 30
+ || !double.IsFinite(DiskBrightness) || DiskBrightness is < .01 or > 100
+ || RaySteps is < 128 or > 512)
+ throw new InvalidDataException("config.json: invalid blackHoles settings. RaySteps must be 128–512 and occurrenceChance 0–1.");
+ }
+}
+
+public sealed record BlackHoleData(double MassSolar, DVector3 DiskNormal, double DiskOuterRadiusInHorizons,
+ double DiskBrightness, int RaySteps)
+{
+ // Schwarzschild radius 2GM/c², in metres per solar mass.
+ public double HorizonRadiusMeters => MassSolar * 2953.25;
+}
diff --git a/src/Universe.Core/Generation/CelestialBodies.cs b/src/Universe.Core/Generation/CelestialBodies.cs
index 9708e9e..73895b1 100644
--- a/src/Universe.Core/Generation/CelestialBodies.cs
+++ b/src/Universe.Core/Generation/CelestialBodies.cs
@@ -14,6 +14,8 @@ public sealed record StarData(
{
public string Id { get; init; } = $"star-{Index}";
public StarGlowSettings Glow { get; init; } = new();
+ public BlackHoleData? BlackHole { get; init; }
+ public bool IsBlackHole => BlackHole is not null;
}
public sealed record PlanetData(
diff --git a/src/Universe.Core/Generation/UniverseGenerator.cs b/src/Universe.Core/Generation/UniverseGenerator.cs
index b9a4624..f189b83 100644
--- a/src/Universe.Core/Generation/UniverseGenerator.cs
+++ b/src/Universe.Core/Generation/UniverseGenerator.cs
@@ -15,17 +15,21 @@ public sealed class UniverseGenerator
private static readonly Vector3[] AtmosphereColors =
[new(0.13f, 0.32f, 1f), new(0.16f, 0.42f, 1f), new(0.09f, 0.22f, 0.88f), new(0.80f, 0.48f, 0.25f)];
- public UniverseGenerator(ulong universeSeed, double cellSizeMeters = UniverseScale.DefaultCellSizeMeters, KnownSolarSystemCatalog? knownSystems = null)
+ public UniverseGenerator(ulong universeSeed, double cellSizeMeters = UniverseScale.DefaultCellSizeMeters, KnownSolarSystemCatalog? knownSystems = null,
+ BlackHoleGenerationSettings? blackHoles = null)
{
if (!double.IsFinite(cellSizeMeters) || cellSizeMeters <= 0)
throw new ArgumentOutOfRangeException(nameof(cellSizeMeters));
UniverseSeed = universeSeed;
CellSizeMeters = cellSizeMeters;
_knownSystems = knownSystems;
+ BlackHoles = blackHoles ?? new();
+ BlackHoles.Validate();
}
public ulong UniverseSeed { get; }
public double CellSizeMeters { get; }
+ public BlackHoleGenerationSettings BlackHoles { get; }
public StarSystemData Generate(SectorCoordinate coordinate)
{
@@ -39,6 +43,9 @@ public sealed class UniverseGenerator
ProceduralNoise.Sample(noiseOffset + new DVector3(17.7, 6.3, 3.1)),
ProceduralNoise.Sample(noiseOffset + new DVector3(2.6, 22.3, 11.8))) * (CellSizeMeters * 0.18);
var starCount = random.NextDouble() < 0.46 ? 2 : 1;
+ var holeRandom = new DeterministicRandom(DeterministicRandom.Mix(systemSeed ^ 0x424C41434B484F4CUL));
+ var hasBlackHole = holeRandom.NextDouble() < BlackHoles.OccurrenceChance;
+ if (hasBlackHole) starCount = 1;
var binaryAxis = UnitVector(ref random);
var separation = (0.025 + random.NextDouble() * 0.17) * UniverseScale.AstronomicalUnitMeters;
var massRatio = 0.25 + random.NextDouble() * 0.6;
@@ -53,9 +60,20 @@ public sealed class UniverseGenerator
{ Id = $"procedural:{coordinate.X},{coordinate.Y},{coordinate.Z}:star:{i}" });
}
+ if (hasBlackHole)
+ {
+ var mass = BlackHoles.MinimumMassSolar + holeRandom.NextDouble() * (BlackHoles.MaximumMassSolar - BlackHoles.MinimumMassSolar);
+ var hole = new BlackHoleData(mass, UnitVector(ref holeRandom), BlackHoles.DiskOuterRadiusInHorizons,
+ BlackHoles.DiskBrightness, BlackHoles.RaySteps);
+ stars[0] = stars[0] with { Name = $"{coordinate.X}:{coordinate.Y}:{coordinate.Z} Black Hole", RadiusMeters = hole.HorizonRadiusMeters,
+ LuminositySolar = .8, Color = new(1f, .73f, .44f), BlackHole = hole };
+ }
+
var planetCount = random.NextInt(5, 10);
var planets = new List(planetCount);
var orbitAu = 0.38 + random.NextDouble() * 0.48;
+ if (stars[0].BlackHole is { } centralHole)
+ orbitAu = System.Math.Max(orbitAu, centralHole.HorizonRadiusMeters * centralHole.DiskOuterRadiusInHorizons * 2.5 / UniverseScale.AstronomicalUnitMeters);
var planeNormal = UnitVector(ref random);
var barycentreExtent = System.Math.Max(System.Math.Abs(barycentre.X), System.Math.Max(System.Math.Abs(barycentre.Y), System.Math.Abs(barycentre.Z)));
var maximumOrbit = (CellSizeMeters * 0.47 - barycentreExtent) / UniverseScale.AstronomicalUnitMeters / 1.32;
diff --git a/src/Universe.Core/World/UniverseStreamer.cs b/src/Universe.Core/World/UniverseStreamer.cs
index c2d35f1..6bce67b 100644
--- a/src/Universe.Core/World/UniverseStreamer.cs
+++ b/src/Universe.Core/World/UniverseStreamer.cs
@@ -9,6 +9,38 @@ public sealed class UniverseStreamer(UniverseGenerator generator)
{
private readonly Dictionary _cache = [];
+ public (StarSystemData System, StarData Hole)? FindNearestBlackHole(UniversePosition position)
+ {
+ if (generator.BlackHoles.OccurrenceChance <= 0) return null;
+ (StarSystemData System, StarData Hole)? nearest = null;
+ var bestDistance = double.PositiveInfinity;
+ var cell = generator.CellSizeMeters;
+ for (var radius = 0; radius <= 8; radius++)
+ {
+ for (var z = -radius; z <= radius; z++)
+ for (var y = -radius; y <= radius; y++)
+ for (var x = -radius; x <= radius; x++)
+ {
+ if (System.Math.Max(System.Math.Abs(x), System.Math.Max(System.Math.Abs(y), System.Math.Abs(z))) != radius) continue;
+ if (!position.Sector.TryOffset(x, y, z, out var coordinate)) continue;
+ var system = GetOrCreate(coordinate);
+ var center = UniversePosition.AtCellCenter(coordinate, cell);
+ foreach (var hole in system.Stars.Where(s => s.IsBlackHole))
+ {
+ var distance = center.Add(hole.PositionMeters, cell).RelativeTo(position, cell).Length;
+ if (distance >= bestDistance) continue;
+ nearest = (system, hole); bestDistance = distance;
+ }
+ }
+ // Any unvisited cell lies beyond at least one face of this cube.
+ var p = position.LocalOffset;
+ var edge = System.Math.Min(System.Math.Min(p.X, cell - p.X),
+ System.Math.Min(System.Math.Min(p.Y, cell - p.Y), System.Math.Min(p.Z, cell - p.Z)));
+ if (bestDistance < radius * cell + edge) break;
+ }
+ return nearest;
+ }
+
public UniverseNeighborhood Load(SectorCoordinate activeCoordinate)
{
var active = GetOrCreate(activeCoordinate);
diff --git a/tests/Universe.Tests/BlackHoleTests.cs b/tests/Universe.Tests/BlackHoleTests.cs
new file mode 100644
index 0000000..2305d16
--- /dev/null
+++ b/tests/Universe.Tests/BlackHoleTests.cs
@@ -0,0 +1,65 @@
+using Universe.App.Runtime;
+using Universe.Core.Generation;
+using Universe.Core.Math;
+using Universe.Core.World;
+
+namespace Universe.Tests;
+
+public sealed class BlackHoleTests
+{
+ [Fact]
+ public void ReplacementIsDeterministicAndPlanetsClearTheDisk()
+ {
+ var generator = new UniverseGenerator(123, blackHoles: new() { OccurrenceChance = 1 });
+ var first = generator.Generate(new(-2, 1, 3));
+ var second = generator.Generate(first.Coordinate);
+ var hole = Assert.Single(first.Stars);
+ Assert.True(hole.IsBlackHole);
+ Assert.Equal(hole, Assert.Single(second.Stars));
+ Assert.Equal(hole.RadiusMeters, hole.BlackHole!.HorizonRadiusMeters);
+ Assert.All(first.Planets, p => Assert.True((p.PositionMeters - hole.PositionMeters).Length >
+ hole.RadiusMeters * hole.BlackHole.DiskOuterRadiusInHorizons));
+ }
+
+ [Fact]
+ public void NearestSearchMatchesWideExhaustiveSearchAndFlightReachesTheHole()
+ {
+ var generator = new UniverseGenerator(0x554E495645525345UL);
+ var streamer = new UniverseStreamer(generator);
+ var start = UniversePosition.AtCellCenter(new(0, 0, 0), generator.CellSizeMeters);
+ var found = streamer.FindNearestBlackHole(start);
+ Assert.True(found.HasValue);
+ var target = found!.Value;
+ var exhaustive = generator.GenerateNeighborhood(start.Sector, 3)
+ .SelectMany(s => s.Stars.Where(h => h.IsBlackHole).Select(h => (System: s, Hole: h)))
+ .MinBy(b => UniversePosition.AtCellCenter(b.System.Coordinate, generator.CellSizeMeters)
+ .Add(b.Hole.PositionMeters, generator.CellSizeMeters).RelativeTo(start, generator.CellSizeMeters).Length);
+ Assert.Equal(exhaustive.Hole.Id, target.Hole.Id);
+ var neighborhood = streamer.Load(start.Sector);
+ var groundPlanet = neighborhood.ActiveSystem.Planets[0];
+ var groundBody = start.Add(groundPlanet.PositionMeters, generator.CellSizeMeters);
+ var groundRadial = new DVector3(1, .3, -.2).Normalized();
+ var groundPosition = groundBody.Add(groundRadial * (TerrainHeight.Sample(groundPlanet, groundRadial) + 1.8), generator.CellSizeMeters);
+ var camera = new FlyCamera(groundPosition, generator.CellSizeMeters);
+ camera.RequestBlackHoleView(target.System, target.Hole, neighborhood.NearbySystems.Append(neighborhood.ActiveSystem));
+ for (var i = 0; i < 650; i++)
+ {
+ camera.Update(1d / 60, DVector3.Zero, neighborhood);
+ if (camera.Position.Sector != neighborhood.ActiveSystem.Coordinate) neighborhood = streamer.Load(camera.Position.Sector);
+ }
+ var body = UniversePosition.AtCellCenter(target.System.Coordinate, generator.CellSizeMeters)
+ .Add(target.Hole.PositionMeters, generator.CellSizeMeters);
+ var relative = body.RelativeTo(camera.Position, generator.CellSizeMeters);
+ Assert.False(camera.IsFocusing);
+ Assert.InRange(relative.Length / target.Hole.RadiusMeters, 25.99, 26.01);
+ Assert.InRange(DVector3.Dot(relative.Normalized(), camera.Forward), .999, 1.001);
+ }
+
+ [Fact]
+ public void ZeroChanceDisablesGenerationAndSearch()
+ {
+ var generator = new UniverseGenerator(123, blackHoles: new() { OccurrenceChance = 0 });
+ Assert.All(generator.GenerateNeighborhood(new()), s => Assert.All(s.Stars, h => Assert.False(h.IsBlackHole)));
+ Assert.Null(new UniverseStreamer(generator).FindNearestBlackHole(UniversePosition.AtCellCenter(new(), generator.CellSizeMeters)));
+ }
+}