Astronand/Mindustry
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Partial 7.0 merge - API preview

Browse Source
This commit is contained in:
Anuken
2021-06-02 11:08:08 -04:00
parent ea75a357ca
commit 28b235ef07
531 changed files with 12356 additions and 6286 deletions
Download Patch File Download Diff File Expand all files Collapse all files

88
tools/src/mindustry/tools/Edgifier.java
View File

@@ -1,88 +0,0 @@
package mindustry.tools;
import arc.files.*;
import arc.graphics.*;
import arc.struct.*;
import arc.util.*;
public class Edgifier{
public static void main(String[] args){
ArcNativesLoader.load();
Pixmap pixmap = new Pixmap(Fi.get("/home/anuke/Projects/Mindustry/core/assets-raw/sprites/units/reaper.png"));
Fi.get("/home/anuke/out.png").writePNG(edgify(pixmap, 5));
}
private static Pixmap edgify(Pixmap in, int chunk){
Pixmap out = new Pixmap(in.getWidth(), in.getHeight());
IntSeq side1 = new IntSeq(), side2 = new IntSeq();
for(int x = 0; x < in.getWidth(); x += chunk){
for(int y = 0; y < in.getHeight(); y += chunk){
int bestErrors = Integer.MAX_VALUE;
int bestRotation = 0;
int bestSide1 = 0, bestSide2 = 0;
for(int rotation = 0; rotation < 8; rotation++){
side1.clear();
side2.clear();
//assign pixels present on each side
for(int cx = 0; cx < chunk; cx++){
for(int cy = 0; cy < chunk; cy++){
boolean side = classify(rotation, cx, cy, chunk);
int pixel = in.getPixel(x + cx, y + cy);
if(Pixmaps.empty(pixel)) pixel = 0; //all alpha=0 pixels are treated as 0
(side ? side1 : side2).add(pixel);
}
}
//find most popular element here
int mode1 = side1.mode(), mode2 = side2.mode();
//total errors; 'incorrect' pixels
int errors = (side1.size - side1.count(mode1)) + (side2.size - side2.count(mode2));
//Log.info("errors for rotation={0}: {1}", rotation, errors);
//update if better
if(errors < bestErrors){
bestRotation = rotation;
bestSide1 = mode1;
bestSide2 = mode2;
bestErrors = errors;
}
}
//Log.info("Best result for {0},{1}: rotation={2} 1={3} 2={4} errors={5}", x, y, bestRotation, bestSide1, bestSide2, bestErrors);
//draw with the best result
for(int cx = 0; cx < chunk; cx++){
for(int cy = 0; cy < chunk; cy++){
boolean side = classify(bestRotation, cx, cy, chunk);
out.draw(x + cx, y + cy, side ? bestSide1 : bestSide2);
}
}
}
}
return out;
}
private static boolean classify(int rotation, int x, int y, int chunk){
switch(rotation){
case 0: //return y >= chunk / 2;
case 1: return y < x;
case 2: //return x <= chunk / 2;
case 3: return (chunk - 1 - y) < x;
case 4: //return (y > chunk / 2);
case 5: return (y <= x);
case 6: //return (x < chunk / 2);
case 7: return ((chunk - 1 - y) <= x);
default: throw new IllegalArgumentException("Invalid rotation: " + rotation);
}
}
}

486
tools/src/mindustry/tools/Generators.java
View File

@@ -14,48 +14,25 @@ import mindustry.ctype.*;
import mindustry.game.*;
import mindustry.gen.*;
import mindustry.graphics.*;
import mindustry.tools.ImagePacker.*;
import mindustry.type.*;
import mindustry.ui.*;
import mindustry.world.*;
import mindustry.world.blocks.*;
import mindustry.world.blocks.environment.*;
import mindustry.world.blocks.legacy.*;
import mindustry.world.meta.*;
import java.util.concurrent.*;
import static mindustry.Vars.*;
import static mindustry.tools.ImagePacker.*;
public class Generators{
//used for changing colors in the UI - testing only
static final IntIntMap paletteMap = IntIntMap.with(
//empty for now
0x454545ff, 0x00000000,//0x32394bff,
0x00000099, 0x00000000//0x000000ff
);
static final Cicon logicIcon = Cicon.medium;
static final int logicIconSize = (int)iconMed, maxUiIcon = 128;
public static void generate(){
ObjectMap<Block, Image> gens = new ObjectMap<>();
public static void run(){
ObjectMap<Block, Pixmap> gens = new ObjectMap<>();
if(!paletteMap.isEmpty()){
ImagePacker.generate("uipalette", () -> {
Fi.get("../ui").walk(fi -> {
if(!fi.extEquals("png")) return;
Pixmap pix = new Pixmap(fi);
pix.setBlending(Pixmap.Blending.sourceOver);
pix.each((x, y) -> {
int value = pix.getPixel(x, y);
pix.draw(x, y, paletteMap.get(value, value));
});
fi.writePNG(pix);
});
});
}
ImagePacker.generate("splashes", () -> {
ArcNativesLoader.load();
generate("splashes", () -> {
int frames = 12;
int size = 32;
@@ -70,90 +47,129 @@ public class Generators{
pixmap.each((x, y) -> {
float dst = Mathf.dst(x, y, size/2f, size/2f);
if(Math.abs(dst - radius) <= stroke){
pixmap.draw(x, y, Color.white);
pixmap.set(x, y, Color.white);
}
});
Fi.get("splash-" + i + ".png").writePNG(pixmap);
Fi.get("splash-" + i + ".png").writePng(pixmap);
pixmap.dispose();
}
});
ImagePacker.generate("cliffs", () -> {
int size = 64;
Color dark = new Color(0.5f, 0.5f, 0.6f, 1f).mul(0.98f);
Color mid = Color.lightGray;
generate("bubbles", () -> {
Image[] images = new Image[8];
int frames = 16;
int size = 40;
for(int i = 0; i < frames; i++){
float fin = (float)i / (frames);
float fout = 1f - fin;
float stroke = 3.5f * fout;
float radius = (size/2f) * fin;
float shinelen = radius / 2.5f, shinerad = stroke*1.5f + 0.3f;
float shinex = size/2f + shinelen / Mathf.sqrt2, shiney = size/2f - shinelen / Mathf.sqrt2;
Pixmap pixmap = new Pixmap(size, size);
pixmap.each((x, y) -> {
float dst = Mathf.dst(x, y, size/2f, size/2f);
if(Math.abs(dst - radius) <= stroke || Mathf.within(x, y, shinex, shiney, shinerad)){
pixmap.set(x, y, Color.white);
}
});
Fi.get("bubble-" + i + ".png").writePng(pixmap);
pixmap.dispose();
}
});
generate("cliffs", () -> {
ExecutorService exec = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());
int size = 64;
int dark = new Color(0.5f, 0.5f, 0.6f, 1f).mul(0.98f).rgba();
int mid = Color.lightGray.rgba();
Pixmap[] images = new Pixmap[8];
for(int i = 0; i < 8; i++){
images[i] = ImagePacker.get("cliff" + i);
images[i] = new Pixmap(((GenRegion)Core.atlas.find("cliff" + i)).path);
}
for(int i = Byte.MIN_VALUE; i <= Byte.MAX_VALUE; i++){
Image result = new Image(size, size);
byte[][] mask = new byte[size][size];
int bi = i;
exec.execute(() -> {
Color color = new Color();
Pixmap result = new Pixmap(size, size);
byte[][] mask = new byte[size][size];
byte val = (byte)i;
//check each bit/direction
for(int j = 0; j < 8; j++){
if((val & (1 << j)) != 0){
if(j % 2 == 1 && (((val & (1 << (j + 1))) != 0) != ((val & (1 << (j - 1))) != 0))){
continue;
}
Image image = images[j];
image.each((x, y) -> {
Color color = image.getColor(x, y);
if(color.a > 0.1){
//white -> bit 1 -> top
//black -> bit 2 -> bottom
mask[x][y] |= (color.r > 0.5f ? 1 : 2);
byte val = (byte)bi;
//check each bit/direction
for(int j = 0; j < 8; j++){
if((val & (1 << j)) != 0){
if(j % 2 == 1 && (((val & (1 << (j + 1))) != 0) != ((val & (1 << (j - 1))) != 0))){
continue;
}
});
}
}
result.each((x, y) -> {
byte m = mask[x][y];
if(m != 0){
//mid
if(m == 3){
//find nearest non-mid color
byte best = 0;
float bestDst = 0;
boolean found = false;
//expand search range until found
for(int rad = 9; rad < 64; rad += 7){
for(int cx = Math.max(x - rad, 0); cx <= Math.min(x + rad, size - 1); cx++){
for(int cy = Math.max(y - rad, 0); cy <= Math.min(y + rad, size - 1); cy++){
byte nval = mask[cx][cy];
if(nval == 1 || nval == 2){
float dst2 = Mathf.dst2(cx, cy, x, y);
if(dst2 <= rad * rad && (!found || dst2 < bestDst)){
best = nval;
bestDst = dst2;
found = true;
Pixmap image = images[j];
image.each((x, y) -> {
color.set(image.getRaw(x, y));
if(color.a > 0.1){
//white -> bit 1 -> top
//black -> bit 2 -> bottom
mask[x][y] |= (color.r > 0.5f ? 1 : 2);
}
});
}
}
result.each((x, y) -> {
byte m = mask[x][y];
if(m != 0){
//mid
if(m == 3){
//find nearest non-mid color
byte best = 0;
float bestDst = 0;
boolean found = false;
//expand search range until found
for(int rad = 9; rad < 64; rad += 7){
for(int cx = Math.max(x - rad, 0); cx <= Math.min(x + rad, size - 1); cx++){
for(int cy = Math.max(y - rad, 0); cy <= Math.min(y + rad, size - 1); cy++){
byte nval = mask[cx][cy];
if(nval == 1 || nval == 2){
float dst2 = Mathf.dst2(cx, cy, x, y);
if(dst2 <= rad * rad && (!found || dst2 < bestDst)){
best = nval;
bestDst = dst2;
found = true;
}
}
}
}
}
if(found){
m = best;
}
}
if(found){
m = best;
}
result.setRaw(x, y, m == 1 ? Color.whiteRgba : m == 2 ? dark : mid);
}
});
result.draw(x, y, m == 1 ? Color.white : m == 2 ? dark : mid);
}
Fi.get("../blocks/environment/cliffmask" + (val & 0xff) + ".png").writePng(result);
});
}
result.save("../blocks/environment/cliffmask" + (val & 0xff));
try{
exec.shutdown();
exec.awaitTermination(Long.MAX_VALUE, TimeUnit.SECONDS);
}catch(Exception e){
throw new RuntimeException("go away", e);
}
});
ImagePacker.generate("cracks", () -> {
generate("cracks", () -> {
RidgedPerlin r = new RidgedPerlin(1, 3);
for(int size = 1; size <= BlockRenderer.maxCrackSize; size++){
int dim = size * 32;
@@ -161,17 +177,17 @@ public class Generators{
for(int i = 0; i < steps; i++){
float fract = i / (float)steps;
Image image = new Image(dim, dim);
Pixmap image = new Pixmap(dim, dim);
for(int x = 0; x < dim; x++){
for(int y = 0; y < dim; y++){
float dst = Mathf.dst((float)x/dim, (float)y/dim, 0.5f, 0.5f) * 2f;
if(dst < 1.2f && r.getValue(x, y, 1f / 40f) - dst*(1f-fract) > 0.16f){
image.draw(x, y, Color.white);
image.setRaw(x, y, Color.whiteRgba);
}
}
}
Image output = new Image(image.width, image.height);
Pixmap output = new Pixmap(image.width, image.height);
int rad = 3;
//median filter
@@ -181,30 +197,31 @@ public class Generators{
for(int cx = -rad; cx < rad; cx++){
for(int cy = -rad; cy < rad; cy++){
int wx = Mathf.clamp(cx + x, 0, output.width - 1), wy = Mathf.clamp(cy + y, 0, output.height - 1);
Color color = image.getColor(wx, wy);
if(color.a > 0.5f){
int color = image.getRaw(wx, wy);
if((color & 0xff) > 127){
whites ++;
}else{
clears ++;
}
}
}
output.draw(x, y, whites >= clears ? Color.white : Color.clear);
output.setRaw(x, y, whites >= clears ? Color.whiteRgba : Color.clearRgba);
}
}
output.save("cracks-" + size + "-" + i);
Fi.get("cracks-" + size + "-" + i + ".png").writePng(output);
}
}
});
ImagePacker.generate("block-icons", () -> {
Image colors = new Image(content.blocks().size, 1);
generate("block-icons", () -> {
Pixmap colors = new Pixmap(content.blocks().size, 1);
for(Block block : content.blocks()){
if(block.isAir() || block instanceof ConstructBlock || block instanceof OreBlock || block instanceof LegacyBlock) continue;
block.load();
block.loadIcon();
TextureRegion[] regions = block.getGeneratedIcons();
@@ -216,20 +233,25 @@ public class Generators{
}
}
Image shardTeamTop = null;
for(TextureRegion region : block.makeIconRegions()){
GenRegion gen = (GenRegion)region;
save(get(region).outline(block.outlineColor, block.outlineRadius), gen.name + "-outline");
}
Pixmap shardTeamTop = null;
if(block.teamRegion.found()){
Image teamr = ImagePacker.get(block.teamRegion);
Pixmap teamr = get(block.teamRegion);
for(Team team : Team.all){
if(team.hasPalette){
Image out = new Image(teamr.width, teamr.height);
Pixmap out = new Pixmap(teamr.width, teamr.height);
teamr.each((x, y) -> {
int color = teamr.getColor(x, y).rgba8888();
int color = teamr.getRaw(x, y);
int index = color == 0xffffffff ? 0 : color == 0xdcc6c6ff ? 1 : color == 0x9d7f7fff ? 2 : -1;
out.draw(x, y, index == -1 ? teamr.getColor(x, y) : team.palette[index]);
out.setRaw(x, y, index == -1 ? teamr.getRaw(x, y) : team.palette[index].rgba());
});
out.save(block.name + "-team-" + team.name);
save(out, block.name + "-team-" + team.name);
if(team == Team.sharded){
shardTeamTop = out;
@@ -243,87 +265,63 @@ public class Generators{
}
try{
Image last = null;
Pixmap last = null;
if(block.outlineIcon){
int radius = 4;
GenRegion region = (GenRegion)regions[block.outlinedIcon >= 0 ? block.outlinedIcon : regions.length -1];
Image base = ImagePacker.get(region);
Image out = last = new Image(region.width, region.height);
for(int x = 0; x < out.width; x++){
for(int y = 0; y < out.height; y++){
Color color = base.getColor(x, y);
out.draw(x, y, color);
if(color.a < 1f){
boolean found = false;
outer:
for(int rx = -radius; rx <= radius; rx++){
for(int ry = -radius; ry <= radius; ry++){
if(Mathf.dst(rx, ry) <= radius && base.getColor(rx + x, ry + y).a > 0.01f){
found = true;
break outer;
}
}
}
if(found){
out.draw(x, y, block.outlineColor);
}
}
}
}
Pixmap base = get(region);
Pixmap out = last = base.outline(block.outlineColor, block.outlineRadius);
//do not run for legacy ones
if(block.outlinedIcon >= 0){
//prevents the regions above from being ignored/invisible/etc
for(int i = block.outlinedIcon + 1; i < regions.length; i++){
out.draw(ImagePacker.get(regions[i]));
out.draw(get(regions[i]), true);
}
}
region.path.delete();
out.save(block.name);
save(out, block.name);
}
Image image = ImagePacker.get(regions[0]);
if(!regions[0].found()){
continue;
}
Pixmap image = get(regions[0]);
int i = 0;
for(TextureRegion region : regions){
i++;
if(i != regions.length || last == null){
image.draw(region);
image.draw(get(region), true);
}else{
image.draw(last);
image.draw(last, true);
}
//draw shard (default team top) on top of first sprite
if(region == block.teamRegions[Team.sharded.id] && shardTeamTop != null){
image.draw(shardTeamTop);
image.draw(shardTeamTop, true);
}
}
if(!(regions.length == 1 && regions[0] == Core.atlas.find(block.name) && shardTeamTop == null)){
image.save("block-" + block.name + "-full");
save(image, "block-" + block.name + "-full");
}
image.save("../editor/" + block.name + "-icon-editor");
save(image, "../editor/" + block.name + "-icon-editor");
for(Cicon icon : Cicon.scaled){
Image scaled = new Image(icon.size, icon.size);
scaled.drawScaled(image);
scaled.save("../ui/block-" + block.name + "-" + icon.name());
if(icon == logicIcon && block.synthetic() && block.buildVisibility != BuildVisibility.hidden){
image.save(block.name + "-icon-logic");
}
if(block.buildVisibility != BuildVisibility.hidden){
saveScaled(image, block.name + "-icon-logic", logicIconSize);
}
saveScaled(image, "../ui/block-" + block.name + "-ui", Math.min(image.width, maxUiIcon));
boolean hasEmpty = false;
Color average = new Color();
Color average = new Color(), c = new Color();
float asum = 0f;
for(int x = 0; x < image.width; x++){
for(int y = 0; y < image.height; y++){
Color color = image.getColor(x, y);
Color color = c.set(image.get(x, y));
average.r += color.r*color.a;
average.g += color.g*color.a;
average.b += color.b*color.a;
@@ -343,94 +341,81 @@ public class Generators{
}
//encode square sprite in alpha channel
average.a = hasEmpty ? 0.1f : 1f;
colors.draw(block.id, 0, average);
colors.setRaw(block.id, 0, average.rgba());
}catch(NullPointerException e){
Log.err("Block &ly'@'&lr has an null region!", block);
}
}
colors.save("../../../assets/sprites/block_colors");
save(colors, "../../../assets/sprites/block_colors");
});
ImagePacker.generate("shallows", () -> {
generate("shallows", () -> {
content.blocks().<ShallowLiquid>each(b -> b instanceof ShallowLiquid, floor -> {
Image overlay = ImagePacker.get(floor.liquidBase.region);
Pixmap overlay = get(floor.liquidBase.region);
int index = 0;
for(TextureRegion region : floor.floorBase.variantRegions()){
Image res = new Image(32, 32);
res.draw(ImagePacker.get(region));
Pixmap res = get(region).copy();
for(int x = 0; x < res.width; x++){
for(int y = 0; y < res.height; y++){
Color color = overlay.getColor(x, y).a(floor.liquidOpacity);
res.draw(x, y, color);
res.set(x, y, Pixmap.blend((overlay.getRaw(x, y) & 0xffffff00) | (int)(floor.liquidOpacity * 255), res.getRaw(x, y)));
}
}
String name = floor.name + "" + (++index);
res.save("../blocks/environment/" + name);
res.save("../editor/editor-" + name);
save(res, "../blocks/environment/" + name);
save(res, "../editor/editor-" + name);
gens.put(floor, res);
}
});
});
ImagePacker.generate("item-icons", () -> {
generate("item-icons", () -> {
for(UnlockableContent item : Seq.<UnlockableContent>withArrays(content.items(), content.liquids(), content.statusEffects())){
if(item instanceof StatusEffect && !ImagePacker.has(item.getContentType().name() + "-" + item.name)){
if(item instanceof StatusEffect && !has(item.getContentType().name() + "-" + item.name)){
continue;
}
Image base = ImagePacker.get(item.getContentType().name() + "-" + item.name);
Pixmap base = get(item.getContentType().name() + "-" + item.name);
//tint status effect icon color
if(item instanceof StatusEffect){
StatusEffect stat = (StatusEffect)item;
Image tint = base;
base.each((x, y) -> tint.draw(x, y, tint.getColor(x, y).mul(stat.color)));
Pixmap tint = base;
base.each((x, y) -> tint.setRaw(x, y, Color.muli(tint.getRaw(x, y), stat.color.rgba())));
//outline the image
Image container = new Image(38, 38);
container.draw(base, 3, 3);
base = container.outline(3, Pal.gray);
Pixmap container = new Pixmap(38, 38);
container.draw(base, 3, 3, true);
base = container.outline(Pal.gray, 3);
}
for(Cicon icon : Cicon.scaled){
//if(icon.size == base.width) continue;
Image image = new Image(icon.size, icon.size);
image.drawScaled(base);
image.save((item instanceof StatusEffect ? "../ui/" : "") + item.getContentType().name() + "-" + item.name + "-" + icon.name(), !(item instanceof StatusEffect));
if(icon == Cicon.medium){
image.save("../ui/" + item.getContentType() + "-" + item.name + "-icon");
}
if(icon == logicIcon){
image.save(item.name + "-icon-logic");
}
}
saveScaled(base, item.name + "-icon-logic", logicIconSize);
save(base, "../ui/" + item.getContentType().name() + "-" + item.name + "-ui");
}
});
ImagePacker.generate("unit-icons", () -> content.units().each(type -> {
//TODO broken, freezes
generate("unit-icons", () -> content.units().each(type -> {
if(type.isHidden()) return; //hidden units don't generate
ObjectSet<String> outlined = new ObjectSet<>();
try{
type.load();
type.loadIcon();
type.init();
Color outc = Pal.darkerMetal;
Func<Image, Image> outline = i -> i.outline(3, outc);
Func<Pixmap, Pixmap> outline = i -> i.outline(Pal.darkerMetal, 3);
Cons<TextureRegion> outliner = t -> {
if(t != null && t.found()){
ImagePacker.replace(t, outline.get(ImagePacker.get(t)));
replace(t, outline.get(get(t)));
}
};
for(Weapon weapon : type.weapons){
if(outlined.add(weapon.name) && ImagePacker.has(weapon.name)){
outline.get(ImagePacker.get(weapon.name)).save(weapon.name + "-outline");
if(outlined.add(weapon.name) && has(weapon.name)){
save(outline.get(get(weapon.name)), weapon.name + "-outline");
}
}
@@ -440,47 +425,54 @@ public class Generators{
outliner.get(type.baseJointRegion);
if(type.constructor.get() instanceof Legsc) outliner.get(type.legRegion);
Image image = outline.get(ImagePacker.get(type.region));
Pixmap image = outline.get(get(type.region));
image.save(type.name + "-outline");
save(image, type.name + "-outline");
//draw mech parts
if(type.constructor.get() instanceof Mechc){
image.drawCenter(type.baseRegion);
image.drawCenter(type.legRegion);
image.drawCenter(type.legRegion, true, false);
image.draw(type.region);
drawCenter(image, get(type.baseRegion));
drawCenter(image, get(type.legRegion));
drawCenter(image, get(type.legRegion).flipX());
image.draw(get(type.region), true);
}
//draw outlines
for(Weapon weapon : type.weapons){
weapon.load();
image.draw(outline.get(ImagePacker.get(weapon.region)),
image.draw(weapon.flipSprite ? outline.get(get(weapon.region)).flipX() : outline.get(get(weapon.region)),
(int)(weapon.x / Draw.scl + image.width / 2f - weapon.region.width / 2f),
(int)(-weapon.y / Draw.scl + image.height / 2f - weapon.region.height / 2f),
weapon.flipSprite, false);
true
);
}
//draw base region on top to mask weapons
image.draw(type.region);
image.draw(get(type.region), true);
int baseColor = Color.valueOf("ffa665").rgba();
Image baseCell = ImagePacker.get(type.cellRegion);
Image cell = new Image(type.cellRegion.width, type.cellRegion.height);
cell.each((x, y) -> cell.draw(x, y, baseCell.getColor(x, y).mul(Color.valueOf("ffa665"))));
Pixmap baseCell = get(type.cellRegion);
Pixmap cell = new Pixmap(type.cellRegion.width, type.cellRegion.height);
cell.each((x, y) -> cell.set(x, y, Color.muli(baseCell.getRaw(x, y), baseColor)));
image.draw(cell, image.width / 2 - cell.width / 2, image.height / 2 - cell.height / 2);
image.draw(cell, image.width / 2 - cell.width / 2, image.height / 2 - cell.height / 2, true);
for(Weapon weapon : type.weapons){
weapon.load();
image.draw(weapon.top ? outline.get(ImagePacker.get(weapon.region)) : ImagePacker.get(weapon.region),
Pixmap wepReg = weapon.top ? outline.get(get(weapon.region)) : get(weapon.region);
if(weapon.flipSprite){
wepReg = wepReg.flipX();
}
image.draw(wepReg,
(int)(weapon.x / Draw.scl + image.width / 2f - weapon.region.width / 2f),
(int)(-weapon.y / Draw.scl + image.height / 2f - weapon.region.height / 2f),
weapon.flipSprite, false);
true);
}
image.save("unit-" + type.name + "-full");
save(image, "unit-" + type.name + "-full");
Rand rand = new Rand();
rand.setSeed(type.name.hashCode());
@@ -492,9 +484,9 @@ public class Generators{
float offsetRange = Math.max(image.width, image.height) * 0.15f;
Vec2 offset = new Vec2(1, 1).rotate(rand.random(360f)).setLength(rand.random(0, offsetRange)).add(image.width/2f, image.height/2f);
Image[] wrecks = new Image[splits];
Pixmap[] wrecks = new Pixmap[splits];
for(int i = 0; i < wrecks.length; i++){
wrecks[i] = new Image(image.width, image.height);
wrecks[i] = new Pixmap(image.width, image.height);
}
RidgedPerlin r = new RidgedPerlin(1, 3);
@@ -510,92 +502,82 @@ public class Generators{
//distort edges with random noise
float noise = (float)Noise.rawNoise(dst / (9f + image.width/70f)) * (60 + image.width/30f);
int section = (int)Mathf.clamp(Mathf.mod(offset.angleTo(x, y) + noise + degrees, 360f) / 360f * splits, 0, splits - 1);
if(!vval) wrecks[section].draw(x, y, image.getColor(x, y).mul(rValue ? 0.7f : 1f));
if(!vval) wrecks[section].setRaw(x, y, Color.muli(image.getRaw(x, y), rValue ? 0.7f : 1f));
});
for(int i = 0; i < wrecks.length; i++){
wrecks[i].save(type.name + "-wreck" + i);
save(wrecks[i], "../rubble/" + type.name + "-wreck" + i);
}
for(Cicon icon : Cicon.scaled){
Vec2 size = Scaling.fit.apply(image.width, image.height, icon.size, icon.size);
Image scaled = new Image((int)size.x, (int)size.y);
int maxd = Math.min(Math.max(image.width, image.height), maxUiIcon);
Pixmap fit = new Pixmap(maxd, maxd);
drawScaledFit(fit, image);
scaled.drawScaled(image);
scaled.save("../ui/unit-" + type.name + "-" + icon.name());
if(icon == logicIcon){
scaled.save(type.name + "-icon-logic");
}
}
saveScaled(fit, type.name + "-icon-logic", logicIconSize);
save(fit, "../ui/unit-" + type.name + "-ui");
}catch(IllegalArgumentException e){
Log.err("WARNING: Skipping unit @: @", type.name, e.getMessage());
}
}));
ImagePacker.generate("ore-icons", () -> {
generate("ore-icons", () -> {
content.blocks().<OreBlock>each(b -> b instanceof OreBlock, ore -> {
String prefix = ore instanceof WallOreBlock ? "wall-ore-" : "ore-";
Item item = ore.itemDrop;
int shadowColor = Color.rgba8888(0, 0, 0, 0.3f);
for(int i = 0; i < 3; i++){
for(int i = 0; i < ore.variants; i++){
//get base image to draw on
Image image = new Image(32, 32);
Image shadow = ImagePacker.get(item.name + (i + 1));
Pixmap base = get((ore instanceof WallOreBlock ? "wall-" : "") + item.name + (i + 1));
Pixmap image = base.copy();
int offset = image.width / tilesize - 1;
for(int x = 0; x < image.width; x++){
for(int y = offset; y < image.height; y++){
Color color = shadow.getColor(x, y - offset);
//draw semi transparent background
if(color.a > 0.001f){
color.set(0, 0, 0, 0.3f);
image.draw(x, y, color);
if(base.getA(x, y - offset) != 0){
image.setRaw(x, y, Pixmap.blend(shadowColor, base.getRaw(x, y)));
}
}
}
image.draw(ImagePacker.get(item.name + (i + 1)));
image.save("../blocks/environment/ore-" + item.name + (i + 1));
image.save("../editor/editor-ore-" + item.name + (i + 1));
image.draw(base, true);
save(image, "../blocks/environment/" + prefix + item.name + (i + 1));
save(image, "../editor/editor-" + prefix + item.name + (i + 1));
image.save("block-" + ore.name + "-full");
for(Cicon icon : Cicon.scaled){
Image scaled = new Image(icon.size, icon.size);
scaled.drawScaled(image);
scaled.save("../ui/block-" + ore.name + "-" + icon.name());
}
save(image, "block-" + ore.name + "-full");
save(image, "../ui/block-" + ore.name + "-ui");
}
});
});
ImagePacker.generate("edges", () -> {
generate("edges", () -> {
content.blocks().<Floor>each(b -> b instanceof Floor && !(b instanceof OverlayFloor), floor -> {
if(ImagePacker.has(floor.name + "-edge") || floor.blendGroup != floor){
if(has(floor.name + "-edge") || floor.blendGroup != floor){
return;
}
try{
Image image = gens.get(floor, ImagePacker.get(floor.getGeneratedIcons()[0]));
Image edge = ImagePacker.get("edge-stencil");
Image result = new Image(edge.width, edge.height);
Pixmap image = gens.get(floor, get(floor.getGeneratedIcons()[0]));
Pixmap edge = get("edge-stencil");
Pixmap result = new Pixmap(edge.width, edge.height);
for(int x = 0; x < edge.width; x++){
for(int y = 0; y < edge.height; y++){
result.draw(x, y, edge.getColor(x, y).mul(image.getColor(x % image.width, y % image.height)));
result.set(x, y, Color.muli(edge.getRaw(x, y), image.get(x % image.width, y % image.height)));
}
}
result.save("../blocks/environment/" + floor.name + "-edge");
save(result, "../blocks/environment/" + floor.name + "-edge");
}catch(Exception ignored){}
});
});
ImagePacker.generate("scorches", () -> {
generate("scorches", () -> {
for(int size = 0; size < 10; size++){
for(int i = 0; i < 3; i++){
ScorchGenerator gen = new ScorchGenerator();
@@ -615,7 +597,7 @@ public class Generators{
Pixmap out = gen.generate();
Pixmap median = Pixmaps.median(out, 2, 0.75);
Fi.get("../rubble/scorch-" + size + "-" + i + ".png").writePNG(median);
Fi.get("../rubble/scorch-" + size + "-" + i + ".png").writePng(median);
out.dispose();
median.dispose();
}
@@ -623,4 +605,30 @@ public class Generators{
});
}
/** Generates a scorch pixmap based on parameters. Thread safe, unless multiple scorch generators are running in parallel. */
public static class ScorchGenerator{
private static final Simplex sim = new Simplex();
public int size = 80, seed = 0, color = Color.whiteRgba;
public double scale = 18, pow = 2, octaves = 4, pers = 0.4, add = 2, nscl = 4.5f;
public Pixmap generate(){
Pixmap pix = new Pixmap(size, size);
sim.setSeed(seed);
pix.each((x, y) -> {
double dst = Mathf.dst(x, y, size/2, size/2) / (size / 2f);
double scaled = Math.abs(dst - 0.5f) * 5f + add;
scaled -= noise(Angles.angle(x, y, size/2, size/2))*nscl;
if(scaled < 1.5f) pix.setRaw(x, y, color);
});
return pix;
}
private double noise(float angle){
return Math.pow(sim.octaveNoise2D(octaves, pers, 1 / scale, Angles.trnsx(angle, size/2f) + size/2f, Angles.trnsy(angle, size/2f) + size/2f), pow);
}
}
}

21
tools/src/mindustry/tools/IconConverter.java
View File

@@ -17,7 +17,6 @@ public class IconConverter{
Fi.get("fontgen/icon_parts").deleteDirectory();
Fi[] list = new Fi("icons").list();
ArcNativesLoader.load();
Seq<Fi> files = new Seq<>();
for(Fi img : list){
@@ -42,25 +41,25 @@ public class IconConverter{
}
void convert(Pixmap pixmap, Fi output){
boolean[][] grid = new boolean[pixmap.getWidth()][pixmap.getHeight()];
boolean[][] grid = new boolean[pixmap.width][pixmap.height];
for(int x = 0; x < pixmap.getWidth(); x++){
for(int y = 0; y < pixmap.getHeight(); y++){
grid[x][pixmap.getHeight() - 1 - y] = !Pixmaps.empty(pixmap.getPixel(x, y));
for(int x = 0; x < pixmap.width; x++){
for(int y = 0; y < pixmap.height; y++){
grid[x][pixmap.height - 1 - y] = !pixmap.empty(x, y);
}
}
float xscl = 1f, yscl = 1f;//resolution / (float)pixmap.getWidth(), yscl = resolution / (float)pixmap.getHeight();
float scl = xscl;
width = pixmap.getWidth();
height = pixmap.getHeight();
width = pixmap.width;
height = pixmap.height;
out.append("<svg width=\"").append(pixmap.getWidth()).append("\" height=\"").append(pixmap.getHeight()).append("\">\n");
out.append("<svg width=\"").append(pixmap.width).append("\" height=\"").append(pixmap.height).append("\">\n");
for(int x = -1; x < pixmap.getWidth(); x++){
for(int y = -1; y < pixmap.getHeight(); y++){
int index = index(x, y, pixmap.getWidth(), pixmap.getHeight(), grid);
for(int x = -1; x < pixmap.width; x++){
for(int y = -1; y < pixmap.height; y++){
int index = index(x, y, pixmap.width, pixmap.height, grid);
float leftx = x * xscl, boty = y * yscl, rightx = x * xscl + xscl, topy = y * xscl + yscl,
midx = x * xscl + xscl / 2f, midy = y * yscl + yscl / 2f;

229
tools/src/mindustry/tools/Image.java
View File

@@ -1,229 +0,0 @@
package mindustry.tools;
import arc.func.*;
import arc.graphics.Color;
import arc.graphics.g2d.*;
import arc.math.*;
import arc.math.geom.*;
import arc.struct.*;
import arc.util.*;
import mindustry.tools.ImagePacker.*;
import javax.imageio.*;
import java.awt.*;
import java.awt.image.*;
import java.io.*;
class Image{
private static Seq<Image> toDispose = new Seq<>();
private BufferedImage image;
private Graphics2D graphics;
private Color color = new Color();
public final int width, height;
Image(TextureRegion region){
this(ImagePacker.buf(region));
}
Image(BufferedImage src){
this.image = new BufferedImage(src.getWidth(), src.getHeight(), BufferedImage.TYPE_INT_ARGB);
this.graphics = image.createGraphics();
this.graphics.drawImage(src, 0, 0, null);
this.width = image.getWidth();
this.height = image.getHeight();
toDispose.add(this);
}
Image(int width, int height){
this(new BufferedImage(width, height, BufferedImage.TYPE_INT_ARGB));
}
Image copy(){
Image out =new Image(width, height);
out.draw(this);
return out;
}
boolean isEmpty(int x, int y){
if(!Structs.inBounds(x, y, width, height)){
return true;
}
Color color = getColor(x, y);
return color.a <= 0.001f;
}
Color getColor(int x, int y){
if(!Structs.inBounds(x, y, width, height)) return color.set(0, 0, 0, 0);
int i = image.getRGB(x, y);
color.argb8888(i);
return color;
}
Image outline(int radius, Color outlineColor){
Image out = copy();
for(int x = 0; x < out.width; x++){
for(int y = 0; y < out.height; y++){
Color color = getColor(x, y);
out.draw(x, y, color);
if(color.a < 1f){
boolean found = false;
outer:
for(int rx = -radius; rx <= radius; rx++){
for(int ry = -radius; ry <= radius; ry++){
if(Mathf.dst(rx, ry) <= radius && getColor(rx + x, ry + y).a > 0.01f){
found = true;
break outer;
}
}
}
if(found){
out.draw(x, y, outlineColor);
}
}
}
}
return out;
}
Image shadow(float alpha, int rad){
Image out = silhouette(new Color(0f, 0f, 0f, alpha)).blur(rad);
out.draw(this);
return out;
}
Image silhouette(Color color){
Image out = copy();
each((x, y) -> out.draw(x, y, getColor(x, y).set(color.r, color.g, color.b, this.color.a * color.a)));
return out;
}
Image blur(int radius){
Image out = copy();
Color c = new Color();
int[] sum = {0};
for(int x = 0; x < out.width; x++){
for(int y = 0; y < out.height; y++){
sum[0] = 0;
Geometry.circle(x, y, radius, (cx, cy) -> {
int rx = Mathf.clamp(cx, 0, out.width - 1), ry = Mathf.clamp(cy, 0, out.height - 1);
Color other = getColor(rx, ry);
c.r += other.r;
c.g += other.g;
c.b += other.b;
c.a += other.a;
sum[0] ++;
});
c.mula(1f / sum[0]);
out.draw(x, y, c);
}
}
return out;
}
void each(Intc2 cons){
for(int x = 0; x < width; x++){
for(int y = 0; y < height; y++){
cons.get(x, y);
}
}
}
void draw(int x, int y, Color color){
graphics.setColor(new java.awt.Color(color.r, color.g, color.b, color.a));
graphics.fillRect(x, y, 1, 1);
}
/** Draws a region at the top left corner. */
void draw(TextureRegion region){
draw(region, 0, 0, false, false);
}
/** Draws a region at the center. */
void drawCenter(TextureRegion region){
draw(region, (width - region.width) / 2, (height - region.height) / 2, false, false);
}
/** Draws a region at the center. */
void drawCenter(TextureRegion region, boolean flipx, boolean flipy){
draw(region, (width - region.width) / 2, (height - region.height) / 2, flipx, flipy);
}
void drawScaled(Image image){
graphics.drawImage(image.image.getScaledInstance(width, height, java.awt.Image.SCALE_AREA_AVERAGING), 0, 0, width, height, null);
}
/** Draws an image at the top left corner. */
void draw(Image image){
draw(image, 0, 0);
}
/** Draws an image at the coordinates specified. */
void draw(Image image, int x, int y){
graphics.drawImage(image.image, x, y, null);
}
void draw(TextureRegion region, boolean flipx, boolean flipy){
draw(region, 0, 0, flipx, flipy);
}
void draw(TextureRegion region, int x, int y, boolean flipx, boolean flipy){
GenRegion.validate(region);
draw(ImagePacker.get(region), x, y, flipx, flipy);
}
void draw(Image region, int x, int y, boolean flipx, boolean flipy){
int ofx = 0, ofy = 0;
graphics.drawImage(region.image,
x, y,
x + region.width,
y + region.height,
(flipx ? region.width : 0) + ofx,
(flipy ? region.height : 0) + ofy,
(flipx ? 0 : region.width) + ofx,
(flipy ? 0 : region.height) + ofy,
null);
}
/** @param name Name of texture file name to create, without any extensions. */
void save(String name){
try{
ImageIO.write(image, "png", new File(name + ".png"));
}catch(IOException e){
throw new RuntimeException(e);
}
}
void save(String name, boolean antialias){
save(name);
if(!antialias){
new File(name + ".png").setLastModified(0);
}
}
static int total(){
return toDispose.size;
}
static void dispose(){
for(Image image : toDispose){
image.graphics.dispose();
}
toDispose.clear();
}
}

127
tools/src/mindustry/tools/ImagePacker.java
View File

@@ -2,8 +2,10 @@ package mindustry.tools;
import arc.*;
import arc.files.*;
import arc.graphics.*;
import arc.graphics.g2d.*;
import arc.graphics.g2d.TextureAtlas.*;
import arc.math.geom.*;
import arc.struct.*;
import arc.util.*;
import arc.util.Log.*;
@@ -12,20 +14,16 @@ import mindustry.*;
import mindustry.content.*;
import mindustry.core.*;
import mindustry.ctype.*;
import mindustry.type.*;
import mindustry.world.*;
import mindustry.world.blocks.*;
import javax.imageio.*;
import java.awt.image.*;
import java.io.*;
public class ImagePacker{
static ObjectMap<String, TextureRegion> regionCache = new ObjectMap<>();
static ObjectMap<String, BufferedImage> imageCache = new ObjectMap<>();
static ObjectMap<String, PackIndex> cache = new ObjectMap<>();
public static void main(String[] args) throws Exception{
Vars.headless = true;
//makes PNG loading slightly faster
ArcNativesLoader.load();
Log.logger = new NoopLogHandler();
@@ -36,66 +34,59 @@ public class ImagePacker{
Fi.get("../../../assets-raw/sprites_out").walk(path -> {
if(!path.extEquals("png")) return;
String fname = path.nameWithoutExtension();
try{
BufferedImage image = ImageIO.read(path.file());
if(image == null) throw new IOException("image " + path.absolutePath() + " is null for terrible reasons");
GenRegion region = new GenRegion(fname, path){{
width = image.getWidth();
height = image.getHeight();
u2 = v2 = 1f;
u = v = 0f;
}};
regionCache.put(fname, region);
imageCache.put(fname, image);
}catch(IOException e){
throw new RuntimeException(e);
}
cache.put(path.nameWithoutExtension(), new PackIndex(path));
});
Core.atlas = new TextureAtlas(){
@Override
public AtlasRegion find(String name){
if(!regionCache.containsKey(name)){
if(!cache.containsKey(name)){
GenRegion region = new GenRegion(name, null);
region.invalid = true;
return region;
}
return (AtlasRegion)regionCache.get(name);
PackIndex index = cache.get(name);
if(index.pixmap == null){
index.pixmap = new Pixmap(index.file);
index.region = new GenRegion(name, index.file){{
width = index.pixmap.width;
height = index.pixmap.height;
u2 = v2 = 1f;
u = v = 0f;
}};
}
return index.region;
}
@Override
public AtlasRegion find(String name, TextureRegion def){
if(!regionCache.containsKey(name)){
if(!cache.containsKey(name)){
return (AtlasRegion)def;
}
return (AtlasRegion)regionCache.get(name);
return find(name);
}
@Override
public AtlasRegion find(String name, String def){
if(!regionCache.containsKey(name)){
return (AtlasRegion)regionCache.get(def);
if(!cache.containsKey(name)){
return find(def);
}
return (AtlasRegion)regionCache.get(name);
return find(name);
}
@Override
public boolean has(String s){
return regionCache.containsKey(s);
return cache.containsKey(s);
}
};
Draw.scl = 1f / Core.atlas.find("scale_marker").width;
Time.mark();
Generators.generate();
Generators.run();
Log.info("&ly[Generator]&lc Total time to generate: &lg@&lcms", Time.elapsed());
Log.info("&ly[Generator]&lc Total images created: &lg@", Image.total());
Image.dispose();
//Log.info("&ly[Generator]&lc Total images created: &lg@", Image.total());
//format:
//character-ID=contentname:texture-name
@@ -130,9 +121,7 @@ public class ImagePacker{
}
static String texname(UnlockableContent c){
if(c instanceof Block) return "block-" + c.name + "-medium";
if(c instanceof UnitType) return "unit-" + c.name + "-medium";
return c.getContentType() + "-" + c.name + "-icon";
return c.getContentType() + "-" + c.name + "-ui";
}
static void generate(String name, Runnable run){
@@ -141,15 +130,7 @@ public class ImagePacker{
Log.info("&ly[Generator]&lc Time to generate &lm@&lc: &lg@&lcms", name, Time.elapsed());
}
static BufferedImage buf(TextureRegion region){
return imageCache.get(((AtlasRegion)region).name);
}
static Image create(int width, int height){
return new Image(width, height);
}
static Image get(String name){
static Pixmap get(String name){
return get(Core.atlas.find(name));
}
@@ -157,18 +138,40 @@ public class ImagePacker{
return Core.atlas.has(name);
}
static Image get(TextureRegion region){
GenRegion.validate(region);
static Pixmap get(TextureRegion region){
validate(region);
return new Image(imageCache.get(((AtlasRegion)region).name));
return cache.get(((AtlasRegion)region).name).pixmap.copy();
}
static void replace(String name, Image image){
image.save(name);
static void save(Pixmap pix, String path){
Fi.get(path + ".png").writePng(pix);
}
static void drawCenter(Pixmap pix, Pixmap other){
pix.draw(other, pix.width/2 - other.width/2, pix.height/2 - other.height/2, true);
}
static void saveScaled(Pixmap pix, String name, int size){
Pixmap scaled = new Pixmap(size, size);
//TODO bad linear scaling
scaled.draw(pix, 0, 0, pix.width, pix.height, 0, 0, size, size, true, true);
save(scaled, name);
}
static void drawScaledFit(Pixmap base, Pixmap image){
Vec2 size = Scaling.fit.apply(image.width, image.height, base.width, base.height);
int wx = (int)size.x, wy = (int)size.y;
//TODO bad linear scaling
base.draw(image, 0, 0, image.width, image.height, base.width/2 - wx/2, base.height/2 - wy/2, wx, wy, true, true);
}
static void replace(String name, Pixmap image){
Fi.get(name + ".png").writePng(image);
((GenRegion)Core.atlas.find(name)).path.delete();
}
static void replace(TextureRegion region, Image image){
static void replace(TextureRegion region, Pixmap image){
replace(((GenRegion)region).name, image);
}
@@ -176,6 +179,12 @@ public class ImagePacker{
throw new IllegalArgumentException(Strings.format(message, args));
}
static void validate(TextureRegion region){
if(((GenRegion)region).invalid){
ImagePacker.err("Region does not exist: @", ((GenRegion)region).name);
}
}
static class GenRegion extends AtlasRegion{
boolean invalid;
Fi path;
@@ -190,11 +199,15 @@ public class ImagePacker{
public boolean found(){
return !invalid;
}
}
static void validate(TextureRegion region){
if(((GenRegion)region).invalid){
ImagePacker.err("Region does not exist: @", ((GenRegion)region).name);
}
static class PackIndex{
@Nullable AtlasRegion region;
@Nullable Pixmap pixmap;
Fi file;
public PackIndex(Fi file){
this.file = file;
}
}
}

5
tools/src/mindustry/tools/ScriptMainGenerator.java
View File

@@ -79,15 +79,18 @@ public class ScriptMainGenerator{
"mindustry.entities.abilities",
"mindustry.ai.types",
"mindustry.type.weather",
"mindustry.type.weapons",
"mindustry.game.Objectives",
"mindustry.world.blocks",
"mindustry.world.draw"
"mindustry.world.draw",
"mindustry.type"
);
String classTemplate = "package mindustry.mod;\n" +
"\n" +
"import arc.struct.*;\n" +
"/** Generated class. Maps simple class names to concrete classes. For use in JSON mods. */\n" +
"@SuppressWarnings(\"deprecation\")\n" +
"public class ClassMap{\n" +
" public static final ObjectMap<String, Class<?>> classes = new ObjectMap<>();\n" +
" \n" +