Merge branches '6.0' and 'splinterface-impl' of https://github.com/Anuken/Mindustry into splinterface-impl
# Conflicts: # core/assets/sprites/block_colors.png # core/assets/sprites/sprites.atlas # core/assets/sprites/sprites.png # core/assets/sprites/sprites3.png # core/assets/sprites/sprites5.png # core/src/mindustry/Vars.java # core/src/mindustry/entities/traits/SaveTrait.java # core/src/mindustry/maps/generators/MapGenerator.java # core/src/mindustry/ui/dialogs/DeployDialog.java # core/src/mindustry/world/blocks/Floor.java # desktop/src/mindustry/desktop/DesktopLauncher.java # gradle.properties
This commit is contained in:
Anuken
@@ -31,6 +31,17 @@ public enum CacheLayer{
|
||||
endShader(Shaders.tar);
|
||||
}
|
||||
},
|
||||
slag{
|
||||
@Override
|
||||
public void begin(){
|
||||
beginShader();
|
||||
}
|
||||
|
||||
@Override
|
||||
public void end(){
|
||||
endShader(Shaders.slag);
|
||||
}
|
||||
},
|
||||
normal,
|
||||
walls;
|
||||
|
||||
|
||||
@@ -43,7 +43,7 @@ public class MenuRenderer implements Disposable{
|
||||
}
|
||||
|
||||
private void generate(){
|
||||
Tile[][] tiles = world.createTiles(width, height);
|
||||
Tiles tiles = world.resize(width, height);
|
||||
Array<Block> ores = content.blocks().select(b -> b instanceof OreBlock);
|
||||
shadows = new FrameBuffer(width, height);
|
||||
int offset = Mathf.random(100000);
|
||||
@@ -154,10 +154,10 @@ public class MenuRenderer implements Disposable{
|
||||
}
|
||||
|
||||
Tile tile;
|
||||
tiles[x][y] = (tile = new CachedTile());
|
||||
tiles.set(x, y, (tile = new CachedTile()));
|
||||
tile.x = (short)x;
|
||||
tile.y = (short)y;
|
||||
tile.setFloor((Floor) floor);
|
||||
tile.setFloor(floor.asFloor());
|
||||
tile.setBlock(wall);
|
||||
tile.setOverlay(ore);
|
||||
}
|
||||
|
||||
@@ -0,0 +1,266 @@
|
||||
package mindustry.graphics;
|
||||
|
||||
import arc.math.*;
|
||||
import arc.math.geom.*;
|
||||
import arc.util.*;
|
||||
|
||||
//TODO clean this up somehow
|
||||
public class PlanetGrid{
|
||||
private static final PlanetGrid[] cache = new PlanetGrid[10];
|
||||
|
||||
private static final float x = -0.525731112119133606f;
|
||||
private static final float z = -0.850650808352039932f;
|
||||
|
||||
private static final Vec3[] iTiles = {
|
||||
new Vec3(-x, 0, z), new Vec3(x, 0, z), new Vec3(-x, 0, -z), new Vec3(x, 0, -z),
|
||||
new Vec3(0, z, x), new Vec3(0, z, -x), new Vec3(0, -z, x), new Vec3(0, -z, -x),
|
||||
new Vec3(z, x, 0), new Vec3(-z, x, 0), new Vec3(z, -x, 0), new Vec3(-z, -x, 0)
|
||||
};
|
||||
|
||||
private static final int[][] iTilesP = {
|
||||
{9, 4, 1, 6, 11}, {4, 8, 10, 6, 0}, {11, 7, 3, 5, 9}, {2, 7, 10, 8, 5},
|
||||
{9, 5, 8, 1, 0}, {2, 3, 8, 4, 9}, {0, 1, 10, 7, 11}, {11, 6, 10, 3, 2},
|
||||
{5, 3, 10, 1, 4}, {2, 5, 4, 0, 11}, {3, 7, 6, 1, 8}, {7, 2, 9, 0, 6}
|
||||
};
|
||||
|
||||
public final int size;
|
||||
public final Ptile[] tiles;
|
||||
public final Corner[] corners;
|
||||
public final Edge[] edges;
|
||||
|
||||
PlanetGrid(int size){
|
||||
this.size = size;
|
||||
|
||||
tiles = new Ptile[tileCount(size)];
|
||||
for(int i = 0; i < tiles.length; i++){
|
||||
tiles[i] = new Ptile(i, i < 12 ? 5 : 6);
|
||||
}
|
||||
|
||||
corners = new Corner[cornerCount(size)];
|
||||
for(int i = 0; i < corners.length; i++){
|
||||
corners[i] = new Corner(i);
|
||||
}
|
||||
|
||||
edges = new Edge[edgeCount(size)];
|
||||
for(int i = 0; i < edges.length; i++){
|
||||
edges[i] = new Edge(i);
|
||||
}
|
||||
}
|
||||
|
||||
public static PlanetGrid newGrid(int size){
|
||||
//cache grids between calls, since only ~5 different grids total are needed
|
||||
if(size < cache.length && cache[size] != null){
|
||||
return cache[size];
|
||||
}
|
||||
|
||||
PlanetGrid result;
|
||||
if(size == 0){
|
||||
result = initialGrid();
|
||||
}else{
|
||||
result = subdividedGrid(newGrid(size - 1));
|
||||
}
|
||||
|
||||
//store grid in cache
|
||||
if(size < cache.length){
|
||||
cache[size] = result;
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
static PlanetGrid initialGrid(){
|
||||
PlanetGrid grid = new PlanetGrid(0);
|
||||
|
||||
for(Ptile t : grid.tiles){
|
||||
t.v = iTiles[t.id];
|
||||
for(int k = 0; k < 5; k++){
|
||||
t.tiles[k] = grid.tiles[iTilesP[t.id][k]];
|
||||
}
|
||||
}
|
||||
for(int i = 0; i < 5; i++){
|
||||
addCorner(i, grid, 0, iTilesP[0][(i + 4) % 5], iTilesP[0][i]);
|
||||
}
|
||||
for(int i = 0; i < 5; i++){
|
||||
addCorner(i + 5, grid, 3, iTilesP[3][(i + 4) % 5], iTilesP[3][i]);
|
||||
}
|
||||
addCorner(10, grid, 10, 1, 8);
|
||||
addCorner(11, grid, 1, 10, 6);
|
||||
addCorner(12, grid, 6, 10, 7);
|
||||
addCorner(13, grid, 6, 7, 11);
|
||||
addCorner(14, grid, 11, 7, 2);
|
||||
addCorner(15, grid, 11, 2, 9);
|
||||
addCorner(16, grid, 9, 2, 5);
|
||||
addCorner(17, grid, 9, 5, 4);
|
||||
addCorner(18, grid, 4, 5, 8);
|
||||
addCorner(19, grid, 4, 8, 1);
|
||||
|
||||
//add corners to corners
|
||||
for(Corner c : grid.corners){
|
||||
for(int k = 0; k < 3; k++){
|
||||
c.corners[k] = c.tiles[k].corners[(pos(c.tiles[k], c) + 1) % 5];
|
||||
}
|
||||
}
|
||||
//new edges
|
||||
int nextEdge = 0;
|
||||
for(Ptile t : grid.tiles){
|
||||
for(int k = 0; k < 5; k++){
|
||||
if(t.edges[k] == null){
|
||||
addEdge(nextEdge++, grid, t.id, iTilesP[t.id][k]);
|
||||
}
|
||||
}
|
||||
}
|
||||
return grid;
|
||||
}
|
||||
|
||||
static PlanetGrid subdividedGrid(PlanetGrid prev){
|
||||
PlanetGrid grid = new PlanetGrid(prev.size + 1);
|
||||
|
||||
int prevTiles = prev.tiles.length;
|
||||
int prevCorners = prev.corners.length;
|
||||
|
||||
//old tiles
|
||||
for(int i = 0; i < prevTiles; i++){
|
||||
grid.tiles[i].v = prev.tiles[i].v;
|
||||
for(int k = 0; k < grid.tiles[i].edgeCount; k++){
|
||||
|
||||
grid.tiles[i].tiles[k] = grid.tiles[prev.tiles[i].corners[k].id + prevTiles];
|
||||
}
|
||||
}
|
||||
//old corners become tiles
|
||||
for(int i = 0; i < prevCorners; i++){
|
||||
grid.tiles[i + prevTiles].v = prev.corners[i].v;
|
||||
for(int k = 0; k < 3; k++){
|
||||
grid.tiles[i + prevTiles].tiles[2 * k] = grid.tiles[prev.corners[i].corners[k].id + prevTiles];
|
||||
grid.tiles[i + prevTiles].tiles[2 * k + 1] = grid.tiles[prev.corners[i].tiles[k].id];
|
||||
}
|
||||
}
|
||||
//new corners
|
||||
int nextCorner = 0;
|
||||
for(Ptile n : prev.tiles){
|
||||
Ptile t = grid.tiles[n.id];
|
||||
for(int k = 0; k < t.edgeCount; k++){
|
||||
addCorner(nextCorner, grid, t.id, t.tiles[(k + t.edgeCount - 1) % t.edgeCount].id, t.tiles[k].id);
|
||||
nextCorner++;
|
||||
}
|
||||
}
|
||||
//connect corners
|
||||
for(Corner c : grid.corners){
|
||||
for(int k = 0; k < 3; k++){
|
||||
c.corners[k] = c.tiles[k].corners[(pos(c.tiles[k], c) + 1) % (c.tiles[k].edgeCount)];
|
||||
}
|
||||
}
|
||||
//new edges
|
||||
int nextEdge = 0;
|
||||
for(Ptile t : grid.tiles){
|
||||
for(int k = 0; k < t.edgeCount; k++){
|
||||
if(t.edges[k] == null){
|
||||
addEdge(nextEdge, grid, t.id, t.tiles[k].id);
|
||||
nextEdge++;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return grid;
|
||||
}
|
||||
|
||||
static void addCorner(int id, PlanetGrid grid, int t1, int t2, int t3){
|
||||
Corner c = grid.corners[id];
|
||||
Ptile[] 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[pos(t[i], t[(i + 2) % 3])] = c;
|
||||
c.tiles[i] = t[i];
|
||||
}
|
||||
}
|
||||
|
||||
static void addEdge(int id, PlanetGrid grid, int t1, int t2){
|
||||
Edge e = grid.edges[id];
|
||||
Ptile[] t = {grid.tiles[t1], grid.tiles[t2]};
|
||||
Corner[] c = {
|
||||
grid.corners[t[0].corners[pos(t[0], t[1])].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[pos(t[i], t[(i + 1) % 2])] = e;
|
||||
e.tiles[i] = t[i];
|
||||
c[i].edges[pos(c[i], c[(i + 1) % 2])] = e;
|
||||
e.corners[i] = c[i];
|
||||
}
|
||||
}
|
||||
|
||||
static int pos(Ptile t, Ptile n){
|
||||
for(int i = 0; i < t.edgeCount; i++)
|
||||
if(t.tiles[i] == n)
|
||||
return i;
|
||||
return -1;
|
||||
}
|
||||
|
||||
static int pos(Ptile t, Corner c){
|
||||
for(int i = 0; i < t.edgeCount; i++)
|
||||
if(t.corners[i] == c)
|
||||
return i;
|
||||
return -1;
|
||||
}
|
||||
|
||||
static int pos(Corner c, Corner n){
|
||||
for(int i = 0; i < 3; i++)
|
||||
if(c.corners[i] == n)
|
||||
return i;
|
||||
return -1;
|
||||
}
|
||||
|
||||
static int tileCount(int size){
|
||||
return 10 * Mathf.pow(3, size) + 2;
|
||||
}
|
||||
|
||||
static int cornerCount(int size){
|
||||
return 20 * Mathf.pow(3, size);
|
||||
}
|
||||
|
||||
static int edgeCount(int size){
|
||||
return 30 * Mathf.pow(3, size);
|
||||
}
|
||||
|
||||
public static class Ptile{
|
||||
public final int id;
|
||||
public final int edgeCount;
|
||||
|
||||
public final Ptile[] tiles;
|
||||
public final Corner[] corners;
|
||||
public final Edge[] edges;
|
||||
|
||||
public Vec3 v = new Vec3();
|
||||
|
||||
public Ptile(int id, int edgeCount){
|
||||
this.id = id;
|
||||
this.edgeCount = edgeCount;
|
||||
|
||||
tiles = new Ptile[edgeCount];
|
||||
corners = new Corner[edgeCount];
|
||||
edges = new Edge[edgeCount];
|
||||
}
|
||||
}
|
||||
|
||||
public static class Corner{
|
||||
public final int id;
|
||||
public final Ptile[] tiles = new Ptile[3];
|
||||
public final Corner[] corners = new Corner[3];
|
||||
public final Edge[] edges = new Edge[3];
|
||||
|
||||
public Vec3 v = new Vec3();
|
||||
public Vec3 bv = new Vec3();
|
||||
|
||||
public Corner(int id){
|
||||
this.id = id;
|
||||
}
|
||||
}
|
||||
|
||||
public static class Edge{
|
||||
public final int id;
|
||||
public final Ptile[] tiles = new Ptile[2];
|
||||
public final Corner[] corners = new Corner[2];
|
||||
|
||||
public Edge(int id){
|
||||
this.id = id;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,140 @@
|
||||
package mindustry.graphics;
|
||||
|
||||
import arc.graphics.*;
|
||||
import arc.graphics.VertexAttributes.*;
|
||||
import arc.graphics.gl.*;
|
||||
import arc.math.geom.*;
|
||||
import arc.util.ArcAnnotate.*;
|
||||
import arc.util.*;
|
||||
import mindustry.graphics.PlanetGrid.*;
|
||||
import mindustry.maps.planet.*;
|
||||
|
||||
public class PlanetMesh{
|
||||
private float[] floats = new float[3 + 3 + 1];
|
||||
private Vec3 vec = new Vec3();
|
||||
private Mesh mesh;
|
||||
private PlanetGrid grid;
|
||||
private Vec3 center = new Vec3();
|
||||
|
||||
private boolean lines;
|
||||
private float radius, intensity = 0.2f;
|
||||
|
||||
private final PlanetGenerator gen;
|
||||
|
||||
public PlanetMesh(int divisions, PlanetGenerator gen){
|
||||
this(divisions, gen, 1f, false);
|
||||
}
|
||||
|
||||
public PlanetMesh(int divisions, PlanetGenerator gen, float radius, boolean lines){
|
||||
this.gen = gen;
|
||||
this.radius = radius;
|
||||
this.grid = PlanetGrid.newGrid(divisions);
|
||||
this.lines = lines;
|
||||
|
||||
int vertices = grid.tiles.length * 12 * (3 + 3 + 1);
|
||||
|
||||
mesh = new Mesh(true, vertices, 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(mesh.getMaxVertices());
|
||||
mesh.getVerticesBuffer().position(0);
|
||||
|
||||
generateMesh();
|
||||
}
|
||||
|
||||
/** @return the sector that is hit by this ray, or null if nothing intersects it. */
|
||||
public @Nullable Ptile getTile(Ray ray){
|
||||
boolean found = Intersector3D.intersectRaySphere(ray, center, radius, Tmp.v33);
|
||||
if(!found) return null;
|
||||
return Structs.findMin(grid.tiles, t -> t.v.dst(Tmp.v33));
|
||||
}
|
||||
|
||||
public void render(Mat3D mat){
|
||||
Shaders.planet.begin();
|
||||
Shaders.planet.setUniformMatrix4("u_projModelView", mat.val);
|
||||
mesh.render(Shaders.planet, lines ? Gl.lines : Gl.triangles);
|
||||
Shaders.planet.end();
|
||||
}
|
||||
|
||||
private void generateMesh(){
|
||||
|
||||
for(Ptile tile : grid.tiles){
|
||||
|
||||
Vec3 nor = Tmp.v31.setZero();
|
||||
Corner[] c = tile.corners;
|
||||
|
||||
for(Corner corner : c){
|
||||
corner.bv.set(corner.v).setLength(radius);
|
||||
}
|
||||
|
||||
for(Corner corner : c){
|
||||
corner.v.setLength(radius + elevation(corner.bv)*intensity);
|
||||
}
|
||||
|
||||
for(Corner corner : c){
|
||||
nor.add(corner.v);
|
||||
}
|
||||
nor.nor();
|
||||
|
||||
Vec3 realNormal = normal(c[0].v, c[2].v, c[4].v);
|
||||
nor.set(realNormal);
|
||||
|
||||
Color color = color(tile.v);
|
||||
|
||||
if(lines){
|
||||
nor.set(1f, 1f, 1f);
|
||||
|
||||
for(int i = 0; i < c.length; i++){
|
||||
Vec3 v1 = c[i].v;
|
||||
Vec3 v2 = c[(i + 1) % c.length].v;
|
||||
|
||||
vert(v1, nor, color);
|
||||
vert(v2, nor, color);
|
||||
}
|
||||
}else{
|
||||
verts(c[0].v, c[1].v, c[2].v, nor, color);
|
||||
verts(c[0].v, c[2].v, c[3].v, nor, color);
|
||||
verts(c[0].v, c[3].v, c[4].v, nor, color);
|
||||
|
||||
if(c.length > 5){
|
||||
verts(c[0].v, c[4].v, c[5].v, nor, color);
|
||||
}else{
|
||||
verts(c[0].v, c[3].v, c[4].v, nor, color);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private Vec3 normal(Vec3 v1, Vec3 v2, Vec3 v3){
|
||||
return Tmp.v32.set(v2).sub(v1).crs(v3.x - v1.x, v3.y - v1.y, v3.z - v1.z).nor();
|
||||
}
|
||||
|
||||
private float elevation(Vec3 v){
|
||||
return gen.getHeight(vec.set(v).scl(1f / radius));
|
||||
}
|
||||
|
||||
private Color color(Vec3 v){
|
||||
return gen.getColor(vec.set(v).scl(1f / radius));
|
||||
}
|
||||
|
||||
private void verts(Vec3 a, Vec3 b, Vec3 c, Vec3 normal, Color color){
|
||||
vert(a, normal, color);
|
||||
vert(b, normal, color);
|
||||
vert(c, normal, color);
|
||||
}
|
||||
|
||||
private void vert(Vec3 a, Vec3 normal, Color color){
|
||||
floats[0] = a.x;
|
||||
floats[1] = a.y;
|
||||
floats[2] = a.z;
|
||||
|
||||
floats[3] = normal.x;
|
||||
floats[4] = normal.y;
|
||||
floats[5] = normal.z;
|
||||
|
||||
floats[6] = color.toFloatBits();
|
||||
mesh.getVerticesBuffer().put(floats);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,123 @@
|
||||
package mindustry.graphics;
|
||||
|
||||
import arc.*;
|
||||
import arc.graphics.*;
|
||||
import arc.graphics.g2d.*;
|
||||
import arc.graphics.g3d.*;
|
||||
import arc.input.*;
|
||||
import arc.math.geom.*;
|
||||
import arc.util.*;
|
||||
import mindustry.graphics.PlanetGrid.*;
|
||||
import mindustry.maps.planet.*;
|
||||
import mindustry.type.*;
|
||||
import mindustry.type.Sector.*;
|
||||
import mindustry.world.*;
|
||||
|
||||
import static mindustry.Vars.*;
|
||||
|
||||
public class PlanetRenderer implements PlanetGenerator{
|
||||
private final Color outlineColor = Pal.accent.cpy().a(0.7f);
|
||||
private final float camLength = 4f, outlineRad = 1.15f;
|
||||
private final boolean drawnRect = true;
|
||||
|
||||
private final PlanetMesh[] outlines = new PlanetMesh[10];
|
||||
private final Camera3D cam = new Camera3D();
|
||||
private final VertexBatch3D batch = new VertexBatch3D(false, true, 0);
|
||||
|
||||
private float lastX, lastY;
|
||||
|
||||
public PlanetRenderer(){
|
||||
Tmp.v1.trns(0, camLength);
|
||||
cam.position.set(Tmp.v1.x, 0f, Tmp.v1.y);
|
||||
}
|
||||
|
||||
public void render(Planet planet){
|
||||
Draw.flush();
|
||||
Gl.clear(Gl.depthBufferBit);
|
||||
Gl.enable(Gl.depthTest);
|
||||
|
||||
input();
|
||||
|
||||
cam.resize(Core.graphics.getWidth(), Core.graphics.getHeight());
|
||||
cam.update();
|
||||
cam.lookAt(0, 0, 0);
|
||||
cam.update();
|
||||
|
||||
PlanetMesh outline = outline(planet.size);
|
||||
|
||||
planet.mesh.render(cam.combined());
|
||||
outline.render(cam.combined());
|
||||
|
||||
Ptile tile = outline.getTile(cam.getPickRay(Core.input.mouseX(), Core.input.mouseY()));
|
||||
if(tile != null){
|
||||
|
||||
Sector sector = planet.getSector(tile);
|
||||
for(int i = 0; i < sector.tile.corners.length; i++){
|
||||
batch.color(outlineColor);
|
||||
batch.vertex(sector.tile.corners[i].v);
|
||||
}
|
||||
batch.flush(cam.combined(), Gl.triangleFan);
|
||||
|
||||
if(drawnRect){
|
||||
//TODO hack.
|
||||
SectorRect rect = sector.rect;
|
||||
rect.center.scl(outlineRad);
|
||||
rect.right.scl(outlineRad);
|
||||
rect.top.scl(outlineRad);
|
||||
|
||||
batch.color(Pal.place);
|
||||
batch.vertex(rect.project(0, 0));
|
||||
batch.color(Pal.place);
|
||||
batch.vertex(rect.project(1, 0));
|
||||
batch.color(Pal.place);
|
||||
batch.vertex(rect.project(1, 1));
|
||||
batch.color(Pal.place);
|
||||
batch.vertex(rect.project(0, 1));
|
||||
batch.flush(cam.combined(), Gl.lineLoop);
|
||||
|
||||
rect.center.scl(1f / outlineRad);
|
||||
rect.right.scl(1f / outlineRad);
|
||||
rect.top.scl(1f / outlineRad);
|
||||
|
||||
if(Core.input.keyTap(KeyCode.SPACE)){
|
||||
control.playSector(sector);
|
||||
ui.planet.hide();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
Gl.disable(Gl.depthTest);
|
||||
}
|
||||
|
||||
private PlanetMesh outline(int size){
|
||||
if(outlines[size] == null){
|
||||
outlines[size] = new PlanetMesh(size, this, outlineRad, true);
|
||||
}
|
||||
return outlines[size];
|
||||
}
|
||||
|
||||
private void input(){
|
||||
Vec3 v = Tmp.v33.set(Core.input.mouseX(), Core.input.mouseY(), 0);
|
||||
|
||||
if(Core.input.keyDown(KeyCode.MOUSE_LEFT)){
|
||||
cam.position.rotate(Vec3.Y, (v.x - lastX) / 10);
|
||||
}
|
||||
lastX = v.x;
|
||||
lastY = v.y;
|
||||
}
|
||||
|
||||
@Override
|
||||
public float getHeight(Vec3 position){
|
||||
return 0;
|
||||
}
|
||||
|
||||
@Override
|
||||
public Color getColor(Vec3 position){
|
||||
return outlineColor;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void generate(Vec3 position, TileGen tile){
|
||||
|
||||
}
|
||||
}
|
||||
@@ -11,13 +11,13 @@ import arc.util.Time;
|
||||
public class Shaders{
|
||||
public static Shadow shadow;
|
||||
public static BlockBuild blockbuild;
|
||||
public static @Nullable
|
||||
Shield shield;
|
||||
public static @Nullable Shield shield;
|
||||
public static UnitBuild build;
|
||||
public static FogShader fog;
|
||||
public static MenuShader menu;
|
||||
public static LightShader light;
|
||||
public static SurfaceShader water, tar;
|
||||
public static SurfaceShader water, tar, slag;
|
||||
public static Shader planet;
|
||||
|
||||
public static void init(){
|
||||
shadow = new Shadow();
|
||||
@@ -35,6 +35,8 @@ public class Shaders{
|
||||
light = new LightShader();
|
||||
water = new SurfaceShader("water");
|
||||
tar = new SurfaceShader("tar");
|
||||
slag = new SurfaceShader("slag");
|
||||
planet = new LoadShader("planet", "planet");
|
||||
}
|
||||
|
||||
public static class LightShader extends LoadShader{
|
||||
|
||||
Reference in New Issue
Block a user