Mesh-based rendering

core/src/mindustry/graphics/PlanetGrid.java

@@ -57,7 +57,7 @@ public class PlanetGrid{
         //add corners to corners
         for(Corner c : grid.corners){
             for(int k = 0; k < 3; k++){
-                c.corners[k] = c.tiles[k].corners[(position(c.tiles[k], c) + 1) % 5];
+                c.corners[k] = c.tiles[k].corners[(pos(c.tiles[k], c) + 1) % 5];
             }
         }
         //new edges
@@ -107,7 +107,7 @@ public class PlanetGrid{
         //connect corners
         for(Corner c : grid.corners){
             for(int k = 0; k < 3; k++){
-                c.corners[k] = c.tiles[k].corners[(position(c.tiles[k], c) + 1) % (c.tiles[k].edgeCount)];
+                c.corners[k] = c.tiles[k].corners[(pos(c.tiles[k], c) + 1) % (c.tiles[k].edgeCount)];
             }
         }
         //new edges
@@ -129,7 +129,7 @@ public class PlanetGrid{
         Tile[] t = {grid.tiles[t1], grid.tiles[t2], grid.tiles[t3]};
         c.v = Tmp.v31.set(t[0].v).add(t[1].v).add(t[2].v).cpy().nor();
         for(int i = 0; i < 3; i++){
-            t[i].corners[position(t[i], t[(i + 2) % 3])] = c;
+            t[i].corners[pos(t[i], t[(i + 2) % 3])] = c;
             c.tiles[i] = t[i];
         }
     }
@@ -138,38 +138,38 @@ public class PlanetGrid{
         Edge e = grid.edges[id];
         Tile[] t = {grid.tiles[t1], grid.tiles[t2]};
         Corner[] c = {
-        grid.corners[t[0].corners[position(t[0], t[1])].id],
+        grid.corners[t[0].corners[pos(t[0], t[1])].id],
-        grid.corners[t[0].corners[(position(t[0], t[1]) + 1) % t[0].edgeCount].id]};
+        grid.corners[t[0].corners[(pos(t[0], t[1]) + 1) % t[0].edgeCount].id]};
         for(int i = 0; i < 2; i++){
-            t[i].edges[position(t[i], t[(i + 1) % 2])] = e;
+            t[i].edges[pos(t[i], t[(i + 1) % 2])] = e;
             e.tiles[i] = t[i];
-            c[i].edges[position(c[i], c[(i + 1) % 2])] = e;
+            c[i].edges[pos(c[i], c[(i + 1) % 2])] = e;
             e.corners[i] = c[i];
         }
     }
 
-    int position(Tile t, Tile n){
+    int pos(Tile t, Tile n){
         for(int i = 0; i < t.edgeCount; i++)
             if(t.tiles[i] == n)
                 return i;
         return -1;
     }
 
-    int position(Tile t, Corner c){
+    int pos(Tile t, Corner c){
         for(int i = 0; i < t.edgeCount; i++)
             if(t.corners[i] == c)
                 return i;
         return -1;
     }
 
-    int position(Tile t, Edge e){
+    int pos(Tile t, Edge e){
         for(int i = 0; i < t.edgeCount; i++)
             if(t.edges[i] == e)
                 return i;
         return -1;
     }
 
-    int position(Corner c, Corner n){
+    int pos(Corner c, Corner n){
         for(int i = 0; i < 3; i++)
             if(c.corners[i] == n)
                 return i;

core/src/mindustry/graphics/PlanetRenderer.java

@@ -2,33 +2,41 @@ package mindustry.graphics;
 
 import arc.*;
 import arc.graphics.*;
+import arc.graphics.VertexAttributes.*;
 import arc.graphics.g2d.*;
 import arc.graphics.g3d.*;
 import arc.graphics.gl.*;
-import arc.math.*;
+import arc.input.*;
 import arc.math.geom.*;
-import arc.struct.*;
 import arc.util.*;
 import arc.util.noise.*;
 import mindustry.graphics.PlanetGrid.*;
 
 public class PlanetRenderer{
-    private ImmediateRenderer3D rend = new ImmediateRenderer3D(500000, true, true, 0, new Shader(Core.files.internal("shaders/planet.vertex.glsl").readString(), Core.files.internal("shaders/planet.fragment.glsl").readString()));
     private Camera3D cam = new Camera3D();
+    private Shader shader = new Shader(Core.files.internal("shaders/planet.vertex.glsl").readString(), Core.files.internal("shaders/planet.fragment.glsl").readString());
+    private Mesh mesh;
 
-    private IntArray tmpIndices = new IntArray();
+    private int vcount = 0;
-    private IntArray indices = new IntArray();
+    private float[] floats = new float[3 + 3 + 1];
-    private Array<Vertex> vertices = new Array<>();
 
     private Color[] colors = {Color.royal, Color.tan, Color.forest, Color.olive, Color.lightGray, Color.white};
     private Simplex sim = new Simplex();
+    private float lastX, lastY;
 
-    {
+    public PlanetRenderer(){
-        //int div = 100;
+        int size = 500000;
-        //ico();
+
-        //generate(15, 15, 15, div, div);
+        mesh = new Mesh(true, size, 0,
+            new VertexAttribute(Usage.position, 3, Shader.positionAttribute),
+            new VertexAttribute(Usage.normal, 3, Shader.normalAttribute),
+            new VertexAttribute(Usage.colorPacked, 4, Shader.colorAttribute));
+        mesh.getVerticesBuffer().limit(size);
+        mesh.getVerticesBuffer().position(0);
 
         planet();
+        Tmp.v1.trns(0, 2.5f);
+        cam.position.set(Tmp.v1.x, 0f, Tmp.v1.y);
     }
 
     public void draw(){
@@ -37,24 +45,38 @@ public class PlanetRenderer{
         Gl.clear(Gl.depthBufferBit | Gl.colorBufferBit);
         Gl.enable(Gl.depthTest);
 
-        Tmp.v1.trns(Time.time() / 20f, 2f);
+        input();
-        cam.position.set(Tmp.v1.x, 0f, Tmp.v1.y);
+
         cam.resize(Core.graphics.getWidth(), Core.graphics.getHeight());
         cam.update();
         cam.lookAt(0, 0, 0);
         cam.update();
 
-        rend.begin(cam.combined(), Gl.triangleStrip);
+        shader.begin();
-        drawTri();
+        shader.setUniformMatrix4("u_projModelView", cam.combined().val);
-        rend.end();
+        mesh.render(shader, Gl.triangleStrip);
+        shader.end();
+
         Gl.disable(Gl.depthTest);
     }
 
+    void input(){
+        Vec3 v = cam.unproject(Tmp.v33.set(Core.input.mouseX(), Core.input.mouseY(), 0f));
+
+        if(Core.input.keyDown(KeyCode.MOUSE_LEFT)){
+
+            //dx /= Core.graphics.getWidth();
+            //dy /= Core.graphics.getHeight();
+            cam.position.rotate(Vec3.Y, (v.x - lastX) * 100);
+            //cam.position.rotate(Vec3.Z, dy);
+        }
+        lastX = v.x;
+        lastY = v.y;
+    }
+
     void planet(){
         PlanetGrid p = new PlanetGrid();
         Grid grid = p.newGrid(4);
-        vertices.clear();
-        indices.clear();
 
         for(Tile tile : grid.tiles){
 
@@ -62,7 +84,6 @@ public class PlanetRenderer{
             Corner[] c = tile.corners;
 
             for(Corner corner : c){
-                //corner.v.scl(10f);
                 nor.add(corner.v);
             }
             nor.nor();
@@ -73,23 +94,34 @@ public class PlanetRenderer{
 
             if(c.length > 5){
                 verts(c[0].v, c[4].v, c[5].v, nor);
+            }else{
+                verts(c[0].v, c[3].v, c[4].v, nor);
             }
         }
     }
 
     void verts(Vec3 a, Vec3 b, Vec3 c, Vec3 normal){
-        indices.add(vert(a, normal), vert(b, normal), vert(c, normal));
+        vert(a, normal);
+        vert(b, normal);
+        vert(c, normal);
     }
 
     int vert(Vec3 a, Vec3 normal){
-        Vertex v = new Vertex();
+        floats[0] = a.x;
-        v.pos.set(a);
+        floats[1] = a.y;
-        v.normal.set(normal).nor();
+        floats[2] = a.z;
-        v.color.set(Color.royal);
-        vertices.add(v);
-        return vertices.size - 1;
-    }
 
+        floats[3] = normal.x;
+        floats[4] = normal.y;
+        floats[5] = normal.z;
+
+        floats[6] = Color.royal.toFloatBits();
+
+        mesh.getVerticesBuffer().put(floats);
+
+        return vcount++;
+    }
+/*
     void ico(){
         float s = 2f/Mathf.sqrt(5), c = 1f/Mathf.sqrt(5);
 
@@ -116,6 +148,10 @@ public class PlanetRenderer{
             indices.add(i+1,(7-i)%5+7,(8-i)%5+7);
         }
 
+        norm();
+    }
+
+    void norm(){
         Array<Vertex> newVertices = new Array<>();
         IntArray newIndices = new IntArray();
         for(int i = 0; i < indices.size; i += 3){
@@ -170,7 +206,7 @@ public class PlanetRenderer{
 
                 Vertex vert = new Vertex();
                 vert.normal.set(Tmp.v32.set(Tmp.v31).nor());
-                vert.color.set(color(Tmp.v31));//set(vert.normal.x, vert.normal.y, vert.normal.z, 1f);
+                vert.color.set(vert.normal.x, vert.normal.y, vert.normal.z, 1f);
                 vert.uv.set(u, v);
                 vert.pos.set(Tmp.v31);
 
@@ -186,6 +222,8 @@ public class PlanetRenderer{
                 tempOffset = (tempOffset + 1) % tmpIndices.size;
             }
         }
+
+        //norm();
     }
 
     Color color(Vec3 v){
@@ -220,7 +258,7 @@ public class PlanetRenderer{
             v4.d();
             v1.d();
         }
-    }
+    }*/
 
     class Vertex{
         Color color = new Color();
@@ -228,13 +266,6 @@ public class PlanetRenderer{
         Vec2 uv = new Vec2();
         Vec3 pos = new Vec3();
 
-        void d(){
-            rend.color(color);
-            rend.normal(normal);
-            rend.texCoord(uv.x, uv.y);
-            rend.vertex(pos);
-        }
-
         Vertex copy(){
             Vertex v = new Vertex();
             v.color.set(color);

gradle.properties

@@ -1,3 +1,3 @@
 org.gradle.daemon=true
 org.gradle.jvmargs=-Xms256m -Xmx1024m
-archash=faf6939e377d9faade8c7645d09f4a4b0de9c4a7
+archash=b20e64361b2ad86850bb9d6f4d0c842bd1af83e5