First draft of new star fieldHEADmaster

2 files changed, 204 insertions, 2 deletions

diff --git a/core/src/main/java/org/snoopdesigns/endless/screen/main/MainScreen.java b/core/src/main/java/org/snoopdesigns/endless/screen/main/MainScreen.java
index ed26ef6..a219b32 100644
--- a/core/src/main/java/org/snoopdesigns/endless/screen/main/MainScreen.java
+++ b/core/src/main/java/org/snoopdesigns/endless/screen/main/MainScreen.java
@@ -19,6 +19,7 @@ public class MainScreen implements Screen {
     private float screenHeight;
 
     private Renderable starField;
+    private Renderable starFieldDebug;
     private Renderable cameraDebug;
     private Renderable playerShip;
     private OrthographicCamera camera;
@@ -44,7 +45,7 @@ public class MainScreen implements Screen {
                 camera.viewportWidth *= scale;
                 camera.viewportHeight = camera.viewportWidth *
                         (screenHeight / screenWidth);
-                normalizeCamera();
+                //normalizeCamera();
                 return true;
             }
 
@@ -58,6 +59,7 @@ public class MainScreen implements Screen {
         });
 
         starField = new StarField();
+        starFieldDebug = new StarFieldDebug();
         cameraDebug = new CameraDebug();
         playerShip = new PlayerShip();
 
@@ -71,7 +73,8 @@ public class MainScreen implements Screen {
 
         ScreenUtils.clear(Color.BLACK);
 
-        starField.render(delta, renderContext);
+        //starField.render(delta, renderContext);
+        starFieldDebug.render(delta, renderContext);
         cameraDebug.render(delta, renderContext);
         playerShip.render(delta, renderContext);
     }
diff --git a/core/src/main/java/org/snoopdesigns/endless/screen/main/StarFieldDebug.java b/core/src/main/java/org/snoopdesigns/endless/screen/main/StarFieldDebug.java
new file mode 100644
index 0000000..a79e591
--- /dev/null
+++ b/core/src/main/java/org/snoopdesigns/endless/screen/main/StarFieldDebug.java
@@ -0,0 +1,199 @@
+package org.snoopdesigns.endless.screen.main;
+
+import com.badlogic.gdx.graphics.GL30;
+import com.badlogic.gdx.graphics.Mesh;
+import com.badlogic.gdx.graphics.VertexAttribute;
+import com.badlogic.gdx.graphics.VertexAttributes;
+import com.badlogic.gdx.graphics.glutils.ShaderProgram;
+import com.badlogic.gdx.math.Vector2;
+import org.snoopdesigns.endless.render.RenderContext;
+import org.snoopdesigns.endless.render.Renderable;
+
+import java.security.SecureRandom;
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Random;
+import java.util.stream.IntStream;
+
+public class StarFieldDebug implements Renderable {
+
+    private static final Random rand = new SecureRandom();
+    private static final double PI = Math.PI;
+    private static final int TILE_SIZE = 256;
+    private static final int MAX_OFFSET = 50;
+    private static final int MAX_OFFSET_DISTANCE = MAX_OFFSET * MAX_OFFSET;
+    private static final int MIN_OFFSET_DISTANCE = MAX_OFFSET_DISTANCE / 4;
+    private static final float[] STAR_CORNERS = {
+            0.0f * (float) PI,
+            0.5f * (float) PI,
+            1.5f * (float) PI,
+            0.5f * (float) PI,
+            1.5f * (float) PI,
+            1.0f * (float) PI
+    };
+
+    private final ShaderProgram shader;
+    private final Mesh mesh;
+
+    private static final String VERTEX_SHADER = """
+            #version 130
+            in vec2 offset;
+            in float size;
+            in float corner;
+            uniform mat4 u_projTrans;
+            void main() {
+                vec2 coord = vec2(sin(corner), cos(corner));
+                vec4 pos = vec4(offset.x + coord.x, offset.y + coord.y, 0, 1);
+                gl_Position = u_projTrans * pos;
+            }
+            """;
+    private static final String FRAGMENT_SHADER = """
+            void main() {
+                gl_FragColor = vec4(1, 1, 1, 1);
+            }
+            """;
+
+    public StarFieldDebug() {
+        shader = new ShaderProgram(VERTEX_SHADER, FRAGMENT_SHADER);
+        System.out.println("Shader compiled: " + shader.isCompiled());
+        System.out.println(shader.getLog());
+
+        final var vertices = createStarVertices();
+
+        mesh = new Mesh(true, 6 * 16384, 0,
+                new VertexAttribute(VertexAttributes.Usage.Generic, 2, "offset"),
+                new VertexAttribute(VertexAttributes.Usage.Generic, 1, "size"),
+                new VertexAttribute(VertexAttributes.Usage.Generic, 1, "corner"));
+        final var mul = 100;
+        mesh.setVertices(vertices);
+        /*mesh.setVertices(new float[] {
+                mul * -0.5f, mul * -0.5f, 0f, 1f,
+                mul * 0.5f, mul * -0.5f, 0f, 1f,
+                mul * 0.5f, mul * 0.5f, 0f, 1f,
+                mul * -0.5f, mul * 0.5f, 0f, 1f
+        });*/
+        //mesh.setIndices(new short[] {0, 1, 2, 2, 3, 0});
+    }
+
+    @Override
+    public void render(float delta, RenderContext renderContext) {
+        shader.bind();
+        shader.setUniformMatrix("u_projTrans", renderContext.getCamera().combined);
+        mesh.render(shader, GL30.GL_TRIANGLES);
+    }
+
+    public static void main(String[] args) {
+        final var starVertices = createStarVertices();
+    }
+
+    public static float[] createStarVertices() {
+        // Input values
+        final int width = 4096;
+        final int stars = 16384;
+
+        final int widthMod = width - 1;
+        final int tileCols = width / TILE_SIZE;
+        final List<Integer> tileIndex = new ArrayList<>();
+        IntStream.range(0, tileCols * tileCols)
+                .forEach(i -> tileIndex.add(0));
+
+        // Generate offset vector
+        // Offset is used to later generate a random point X,Y
+        // Looks like a booblik with small ring of MAX_OFFSET * MAX_OFFSET / 4 till MAX_OFFSET * MAX_OFFSET
+        final List<Vector2> offsets = new ArrayList<>();
+        for (int x = -MAX_OFFSET; x <= MAX_OFFSET; x++) {
+            for (int y = -MAX_OFFSET; y <= MAX_OFFSET; y++) {
+                int d = x * x + y * y;
+                if (d < MIN_OFFSET_DISTANCE || d > MAX_OFFSET_DISTANCE) {
+                    continue;
+                }
+                offsets.add(new Vector2(x, y));
+            }
+        }
+
+        // Generate random points in a temporary list
+        final List<Vector2> temp = new ArrayList<>();
+
+        int x = rand.nextInt(width);
+        int y = rand.nextInt(width);
+
+        for (int i = 0; i < stars; i++) {
+            for (int j = 0; j < 10; j++) { // shake original random coordinates 10 times with random offsets up to 50 in any direction
+                int index = rand.nextInt(offsets.size());
+                final Vector2 offset = offsets.get(index);
+                final int incrementX = (int) offset.x;
+                final int incrementY = (int) offset.y;
+                x += incrementX;
+                y += incrementY;
+                x &= widthMod;
+                y &= widthMod;
+            }
+            temp.add(new Vector2(x, y));
+
+            // Increment counter in tile index to which generated point ended
+            int index = (x / TILE_SIZE) + (y / TILE_SIZE) * tileCols;
+            tileIndex.set(index, tileIndex.get(index) + 1);
+        }
+
+        // Accumulate item counts in tileIndex
+        tileIndex.add(0, 0);
+        tileIndex.remove(tileIndex.size() - 1);
+        for (int i = 1; i < tileIndex.size(); i++) {
+            tileIndex.set(i, tileIndex.get(i) + tileIndex.get(i - 1));
+        }
+
+        class StarPoint {
+            float x;
+            float y;
+            float size;
+            float corner;
+        }
+        // Each star consists of six vertices, each with four data elements
+        final List<StarPoint> data = new ArrayList<>(6 * stars);
+        IntStream.range(0, 6 * stars)
+                .forEach(i -> data.add(null));
+        final Iterator<Vector2> tempIterator = temp.iterator();
+
+        while (tempIterator.hasNext()) {
+            // Get the x and y coordinates
+            final var randomPoint = tempIterator.next();
+            x = (int) randomPoint.x;
+            y = (int) randomPoint.y;
+            int index = (x / TILE_SIZE) + (y / TILE_SIZE) * tileCols;
+
+            // Randomize sub-pixel position, size, and brightness
+            int randomValue = rand.nextInt(4096);
+            float fx = (x & (TILE_SIZE - 1)) + (randomValue & 15) * 0.0625f;
+            float fy = (y & (TILE_SIZE - 1)) + (randomValue >> 8) * 0.0625f;
+            float size = (((randomValue >> 4) & 15) + 20) * 0.0625f;
+
+            // Fill in the data array
+            int tileStartIndex = tileIndex.get(index);
+            int dataIndex = 6 * tileStartIndex;
+            tileIndex.set(index, tileStartIndex + 1);
+
+            for (final float corner : STAR_CORNERS) {
+                final var star = new StarPoint();
+                star.x = fx;
+                star.y = fy;
+                star.size = size;
+                star.corner = corner;
+                data.set(dataIndex++, star);
+            }
+        }
+
+        // Adjust tile indices for proper referencing
+        tileIndex.add(0, 0);
+
+        float[] result = new float[6 * 4 * stars];
+        for (int i = 0; i < data.size(); i++) {
+            final var star = data.get(i);
+            result[4 * i] = star.x;
+            result[4 * i + 1] = star.y;
+            result[4 * i + 2] = star.size;
+            result[4 * i + 3] = star.corner;
+        }
+        return result;
+    }
+}