Glow around the rim

Author: MEEPofFaith

assets/shaders/accretiondisk.frag

@@ -0,0 +1,51 @@
+#define HIGHP
+
+#define MUL 4.0
+
+uniform sampler2D u_texture;
+
+uniform vec2 u_campos;
+uniform vec2 u_resolution;
+
+uniform int u_blackholecount;
+uniform vec4 u_blackholes[MAX_COUNT];
+uniform vec4 u_colors[MAX_COUNT];
+
+varying vec2 v_texCoords;
+
+//https://stackoverflow.com/a/72973369
+vec4 blendOver(float4 a, float4 b) {
+    float newAlpha = mix(b.w, 1.0, a.w);
+    vec3 newColor = mix(b.w * b.xyz, a.xyz, a.w);
+    float divideFactor = (newAlpha > 0.001 ? (1.0 / newAlpha) : 1.0);
+    return float4(newColor * divideFactor, newAlpha);
+}
+
+void main() {
+    vec2 c = v_texCoords.xy;
+    vec2 coords = (c * u_resolution) + u_campos;
+    vec4 col = vec4(0.0);
+
+    for(int i = 0; i < u_blackholecount; ++i){
+        vec4 blackhole = u_blackholes[i];
+        float cX = blackhole.r;
+        float cY = blackhole.g;
+        float iR = blackhole.b;
+
+        float dst = distance(blackhole.xy, coords);
+        if(dst < iR){ //Inside, clear
+            gl_FragColor = vec4(0.0);
+            return;
+        }else if(dst > iR * MUL){ //Outside, skip
+            continue;
+        }else{ //Add
+            float p = 1.0 - (dst - iR) / (iR * MUL - iR);
+            vec4 c1 = u_colors[i];
+            c1.a = p;
+
+            col = blendOver(col, c1);
+        }
+    }
+
+    gl_FragColor = col;
+}

src/progressed/graphics/Draw3D.java

@@ -25,18 +25,24 @@ public class Draw3D{
 
     public static void init(){
         Events.run(Trigger.drawOver, () -> {
-            Bloom bloom = renderer.bloom;
-            if(bloom != null && bloomQueue.any()){
+            if(bloomQueue.any()){
                 bloomQueue.sort(q -> q.layer);
-                Draw.draw(PMLayer.skyBloom, () -> {
-                    bloom.capture();
+                Bloom bloom = renderer.bloom;
+                if(bloom != null){
+                    Draw.draw(PMLayer.skyBloom, () -> {
+                        bloom.capture();
+                        for(QueuedBloom b : bloomQueue){
+                            b.draw.run();
+                        }
+                        bloom.render();
+                    });
+                }else{
                     for(QueuedBloom b : bloomQueue){
                         b.draw.run();
                     }
-                    bloom.render();
-                });
+                }
+                bloomQueue.clear();
             }
-            bloomQueue.clear();
         });
     }
 

src/progressed/graphics/PMShaders.java

@@ -17,6 +17,7 @@ public class PMShaders{
     public static AlphaShader alphaShader;
     public static DimShader dimShader;
     public static GravitationalLensingShader blackHole;
+    public static AccretionDiskShader accretionDisk;
     public static PassThroughShader passThrough;
 
     public static void init(){
@@ -32,10 +33,15 @@ public static void init(){
     }
 
     public static void createBlackholeShader(){
-        GravitationalLensingShader.len *= 2;
+        if(blackHole != null){
+            GravitationalLensingShader.len *= 2;
+            blackHole.dispose();
+            accretionDisk.dispose();
+        }
+
         Shader.prependFragmentCode = "#define MAX_COUNT " + GravitationalLensingShader.len + "\n";
-        if(blackHole != null) blackHole.dispose();
         blackHole = new GravitationalLensingShader();
+        accretionDisk = new AccretionDiskShader();
         Shader.prependFragmentCode = "";
     }
 
@@ -158,7 +164,7 @@ public void apply(){
     }
 
     public static class GravitationalLensingShader extends PMLoadShader{
-        public static int len = 16 / 2;
+        public static int len = 4;
         public float[] blackholes;
 
         GravitationalLensingShader(){
@@ -175,6 +181,25 @@ public void apply(){
         }
     }
 
+    public static class AccretionDiskShader extends PMLoadShader{
+        public float[] blackholes;
+        public float[] colors;
+
+        AccretionDiskShader(){
+            super("screenspace", "accretiondisk");
+        }
+
+        @Override
+        public void apply(){
+            setUniformf("u_campos", Core.camera.position.x - Core.camera.width / 2, Core.camera.position.y - Core.camera.height / 2);
+            setUniformf("u_resolution", Core.camera.width, Core.camera.height);
+
+            setUniformi("u_blackholecount", blackholes.length / 4);
+            setUniform4fv("u_blackholes", blackholes, 0, blackholes.length);
+            setUniform4fv("u_colors", colors, 0, colors.length);
+        }
+    }
+
     static class PassThroughShader extends PMLoadShader{
         public PassThroughShader(){
             super("screenspace", "passThrough");

src/progressed/graphics/renders/BlackHoleRenderer.java

@@ -5,12 +5,14 @@
 import arc.graphics.g2d.*;
 import arc.graphics.gl.*;
 import arc.struct.*;
+import arc.util.*;
 import mindustry.game.EventType.*;
 import mindustry.graphics.*;
 import progressed.graphics.*;
 import progressed.graphics.PMShaders.*;
 
 import static arc.Core.*;
+import static mindustry.Vars.renderer;
 
 /** Renders the glowing area around black holes. (Do I even need this?) */
 public class BlackHoleRenderer{
@@ -40,19 +42,39 @@ public BlackHoleRenderer(){ //TODO setting
                 if(zones.size >= GravitationalLensingShader.len) PMShaders.createBlackholeShader();
 
                 float[] blackholes = new float[zones.size * 4];
+                float[] colors = new float[zones.size * 4];
                 for(int i = 0; i < zones.size; i++){
                     BlackHoleZone zone = zones.get(i);
                     blackholes[i * 4] = zone.x;
                     blackholes[i * 4 + 1] = zone.y;
                     blackholes[i * 4 + 2] = zone.inRadius;
                     blackholes[i * 4 + 3] = zone.outRadius;
+
+                    Tmp.c1.abgr8888(zone.color);
+                    colors[i * 4] = Tmp.c1.r;
+                    colors[i * 4 + 1] = Tmp.c1.g;
+                    colors[i * 4 + 2] = Tmp.c1.b;
+                    colors[i * 4 + 3] = Tmp.c1.a;
                 }
                 PMShaders.blackHole.blackholes = blackholes;
                 buffer.blit(PMShaders.blackHole);
 
-                zones.clear();
+                PMShaders.accretionDisk.blackholes = blackholes;
+                PMShaders.accretionDisk.colors = colors;
+                buffer.begin();
+                Draw.rect();
+                buffer.end();
 
-                //TODO accretion disk
+                Bloom bloom = renderer.bloom;
+                if(bloom != null){
+                    bloom.capture();
+                    buffer.blit(PMShaders.accretionDisk);
+                    bloom.render();
+                }else{
+                    buffer.blit(PMShaders.accretionDisk);
+                }
+
+                zones.clear();
             });
         });
     }