Slash shader

Felt cute, *cuts reality*

Author: MEEPofFaith

assets/shaders/slash.frag

@@ -0,0 +1,46 @@
+#define HIGHP
+
+#define PI 3.1415926535897932384626433832795
+#define PI2 PI * 2.0
+#define HALFPI PI / 2.0
+
+uniform sampler2D u_texture;
+
+uniform vec2 u_campos;
+uniform vec2 u_resolution;
+
+uniform int u_slashescount;
+uniform vec4 u_slashes[MAX_COUNT]; //x, y, angle, offset
+
+varying vec2 v_texCoords;
+
+bool invert(float a1, float a2){
+    float fd = abs(a1 - a2);
+    float bd = PI2 - fd;
+    return a1 > a2 == bd > fd;
+}
+
+void main() {
+    vec2 c = v_texCoords.xy;
+    vec2 coords = (c * u_resolution) + u_campos;
+
+    vec2 offset = vec2(0.0);
+    for(int i = 0; i < u_slashescount; ++i){
+        vec4 slash = u_slashes[i];
+        float sX = slash.r;
+        float sY = slash.g;
+        float sA = slash.b; // [0, 2pi]
+        float sO = slash.a;
+
+        float angleTo = atan(coords.x - sX, coords.y - sY); // [-pi, pi]
+        if(angleTo < 0.0) angleTo += PI2; // Convert to [0, 2pi]
+
+        vec2 off = vec2(cos(HALFPI - sA) * sO, sin(HALFPI - sA) * sO);
+        if(invert(angleTo, sA)) off = -off; //Below the slash, invert
+
+        offset += off;
+    }
+
+    coords += offset;
+    gl_FragColor = texture2D(u_texture, (coords - u_campos) / u_resolution);
+}

gradle.properties

@@ -26,7 +26,7 @@ mindustryBEVersion =
 # Arc version, should either follow `mindustryVersion` for release or whatever hash bleeding-edge Mindustry uses.
 arcVersion = v146
 # My black hole renderer. Just use the latest release.
-blackHoleRendererVersion = v11
+blackHoleRendererVersion = v12
 
 ##### Android SDK configuration for building Android artifacts.
 # Android platform SDK version.

src/progressed/content/bullets/PayloadBullets.java

@@ -404,13 +404,16 @@ public static void load(){
             gravity = 0.02f;
             fragBullets = 1;
             fragBullet = new BlackHoleBulletType(0f, 4400f / 30f){{
-                lifetime = 10f * 60f;
-                growTime = lifetime - MissileFx.bigBlackHoleSwirl.lifetime;
+                lifetime = 4f * 60f;
+                growTime = lifetime;
+                shrinkTime = 0f;
                 swirlEffect = MissileFx.bigBlackHoleSwirl;
                 loopSoundVolume = 6f;
 
                 damageRadius = 18f * tilesize;
                 suctionRadius = 64f * tilesize;
+
+                despawnEffect = MissileFx.slashTest;
             }};
         }};
 

src/progressed/content/effects/MissileFx.java

@@ -6,14 +6,17 @@
 import arc.math.*;
 import arc.util.*;
 import blackhole.entities.effect.*;
+import blackhole.graphics.*;
 import mindustry.entities.*;
 import mindustry.gen.*;
 import mindustry.graphics.*;
+import progressed.graphics.renders.*;
 
 import static arc.graphics.g2d.Draw.*;
 import static arc.graphics.g2d.Lines.*;
 import static arc.math.Angles.*;
 import static arc.util.Tmp.*;
+import static mindustry.Vars.*;
 import static mindustry.graphics.Drawf.*;
 import static progressed.util.PMUtls.*;
 
@@ -185,5 +188,23 @@ public class MissileFx{
         });
     }),
 
-    bigBlackHoleSwirl = new SwirlEffect(90f, 16, 8f, 120f, 480f, true).layer(Layer.effect + 0.005f);
+    bigBlackHoleSwirl = new SwirlEffect(90f, 16, 8f, 120f, 480f, true).layer(Layer.effect + 0.005f),
+
+    slashTest = new Effect(90, 128 * tilesize * 8, e -> { //b i g   c l i p
+        float ang = Mathf.randomSeed(e.id, Mathf.PI2);
+        float fout = e.fout(Interp.circleIn);
+        SlashRenderer.addSlash(e.x, e.y, Mathf.halfPi - ang, 64 * fout);
+
+        ang *= Mathf.radDeg;
+        Tmp.v1.trns(ang, 128 * tilesize * fout);
+        Tmp.v2.trns(ang + 90f, tilesize * fout);
+
+        Draw.color(Color.white);
+        Fill.quad(
+            e.x + Tmp.v1.x, e.y + Tmp.v1.y,
+            e.x + Tmp.v2.x, e.y + Tmp.v2.y,
+            e.x - Tmp.v1.x, e.y - Tmp.v1.y,
+            e.x - Tmp.v2.x, e.y - Tmp.v2.y
+        );
+    }).layer(BHLayer.end + 2f);
 }

src/progressed/graphics/PMShaders.java

@@ -152,15 +152,15 @@ public PassThroughShader(){
         }
     }
 
-    static class PMLoadShader extends Shader{
-        PMLoadShader(String vert, String frag){
+    public static class PMLoadShader extends Shader{
+        public PMLoadShader(String vert, String frag){
             super(
                 files.internal("shaders/" + vert + ".vert"),
                 tree.get("shaders/" + frag + ".frag")
             );
         }
 
-        PMLoadShader(String frag){
+        public PMLoadShader(String frag){
             this("default", frag);
         }
     }

src/progressed/graphics/renders/PMRenders.java

@@ -21,6 +21,7 @@ public class PMRenders{
 
     public static void init(){
         dimRenderer = new DimRenderer();
+        SlashRenderer.init();
 
         Events.on(ResetEvent.class, e -> {
             flashReduction = flashTime = 0;
@@ -40,6 +41,8 @@ public static void init(){
                     Draw.color();
                 }
             });
+
+            SlashRenderer.draw();
         });
     }
 

src/progressed/graphics/renders/SlashRenderer.java

@@ -0,0 +1,93 @@
+package progressed.graphics.renders;
+
+import arc.*;
+import arc.graphics.g2d.*;
+import arc.graphics.gl.*;
+import arc.math.*;
+import arc.struct.*;
+import blackhole.graphics.*;
+import progressed.graphics.PMShaders.*;
+
+import static arc.Core.*;
+
+public class SlashRenderer{
+    private static int maxCount = 4;
+    private static SlashShader slashShader;
+    private static final Seq<SlashData> slashes = new Seq<>();
+    private static FrameBuffer buffer;
+
+    private static void createShader(){
+        if(maxCount >= 1021) return; //Exceeds maximum number of registers for a single shader
+
+        if(slashShader != null){
+            maxCount = Math.min(1021, maxCount * 2);
+            slashShader.dispose();
+        }
+
+        Shader.prependFragmentCode = "#define MAX_COUNT " + maxCount + "\n";
+        slashShader = new SlashShader();
+        Shader.prependFragmentCode = "";
+    }
+
+    public static void init(){
+        createShader();
+        buffer = new FrameBuffer();
+    }
+
+    public static void addSlash(float x, float y, float a, float off){
+        slashes.add(new SlashData(x, y, a, off));
+    }
+
+    public static void draw(){
+        Draw.draw(BHLayer.begin - 0.1f, () -> {
+            buffer.resize(graphics.getWidth(), graphics.getHeight());
+            buffer.begin();
+        });
+
+        Draw.draw(BHLayer.end + 1f, () -> {
+            buffer.end();
+
+            if(slashes.size > maxCount) createShader();
+
+            float[] slashArray = new float[slashes.size * 4];
+            for(int i = 0; i < slashes.size; i++){
+                SlashData slash = slashes.get(i);
+                slashArray[i * 4] = slash.x;
+                slashArray[i * 4 + 1] = slash.y;
+                slashArray[i * 4 + 2] = Mathf.mod(slash.angle, Mathf.PI2)   ;
+                slashArray[i * 4 + 3] = slash.offset;
+            }
+            slashShader.slashes = slashArray;
+            buffer.blit(slashShader);
+            slashes.clear();
+        });
+    }
+
+    private static class SlashShader extends PMLoadShader{
+        public float[] slashes;
+
+        private SlashShader(){
+            super("screenspace", "slash");
+        }
+
+        @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_slashescount", slashes.length / 4);
+            setUniform4fv("u_slashes", slashes, 0, slashes.length);
+        }
+    }
+
+    private static class SlashData{
+        public float x, y, angle, offset;
+
+        public SlashData(float x, float y, float angle, float offset){
+            this.x = x;
+            this.y = y;
+            this.angle = angle;
+            this.offset = offset;
+        }
+    }
+}