View difference between Paste ID: 0YixvSer and 0AcY6YV2

 package net.minecraft.client.model.geom;
 
 import java.awt.*;
 import java.awt.image.BufferedImage;
 import java.io.*;
 import java.util.*;
 import java.util.List;
 
 import javax.imageio.ImageIO;
 import net.minecraft.src.MathHelper;
-import net.minecraft.client.model.dragon.DragonModel;
+import net.minecraft.src.ModelBox;
-import util.Mth;
+import net.minecraft.src.ModelDragon;
 import net.minecraft.src.ModelRenderer;
 
 public class ImageGenerator {
     private static final int WIDTH = 256;
     private static final int HEIGHT = 256;
 
     private class Region {
         public int x1, y1, x2, y2;
 
         public Region(int x1, int y1, int x2, int y2) {
             this.x1 = x1;
             this.y1 = y1;
             this.x2 = x2;
             this.y2 = y2;
         }
 
         public void move(int xo, int yo) {
             x1 += xo;
             y1 += yo;
             x2 += xo;
             y2 += yo;
         }
 
         public boolean overlaps(Region r2, int xo, int yo) {
             if (r2.x2 + xo <= x1) return false;
             if (r2.y2 + yo <= y1) return false;
             if (r2.x1 + xo >= x2) return false;
             if (r2.y1 + yo >= y2) return false;
             return true;
         }
 
         public void render(Graphics g) {
             g.fillRect(x1, y1, x2 - x1, y2 - y1);
         }
     }
 
     private class UnfoldedCube {
         public int x, y;
         public Region[] cubeRegions = new Region[6];
         public String id;
         public int width, height;
-        public UnfoldedCube(Cube cube) {
+
-            int xs = Mth.ceil(cube.x1 - cube.x0);
+        public UnfoldedCube(ModelBox cube) {
-            int ys = Mth.ceil(cube.y1 - cube.y0);
+//            int xs = Mth.ceil(cube.x1 - cube.x0);
-            int zs = Mth.ceil(cube.z1 - cube.z0);
+//            int ys = Mth.ceil(cube.y1 - cube.y0);
 //            int zs = Mth.ceil(cube.z1 - cube.z0);
             int xs = MathHelper.func_40346_b(cube.field_40674_d - cube.field_40678_a);
             int ys = MathHelper.func_40346_b(cube.field_40675_e - cube.field_40676_b);
             int zs = MathHelper.func_40346_b(cube.field_40672_f - cube.field_40677_c);
-            id = cube.id;
+
             width = xs * 2 + zs * 2;
             height = zs + ys;
 
             id = cube.field_40673_g;
 
             cubeRegions[0] = new Region(0, zs, zs, zs + ys);
             cubeRegions[1] = new Region(zs, zs, zs + xs, zs + ys);
             cubeRegions[2] = new Region(zs + xs, zs, zs + xs + zs, zs + ys);
             cubeRegions[3] = new Region(zs + xs + zs, zs, zs + xs + zs + xs, zs + ys);
             cubeRegions[4] = new Region(zs, 0, zs + xs, zs);
             cubeRegions[5] = new Region(zs + xs, 0, zs + xs * 2, zs);
         }
 
         public boolean fits(int x, int y) {
             for (int i = 0; i < 6; i++) {
                 if (!isFree(cubeRegions[i], x, y)) return false;
             }
             return true;
         }
 
         public void place(int x, int y) {
             this.x = x;
             this.y = y;
             for (int i = 0; i < 6; i++) {
                 cubeRegions[i].move(x, y);
                 occupiedRegions.add(cubeRegions[i]);
             }
         }
 
         public void render(Graphics g) {
             float hue = (float) Math.random();
             g.setColor(new Color(Color.HSBtoRGB(hue, 1, 0.7f)));
             cubeRegions[5].render(g);
             g.setColor(new Color(Color.HSBtoRGB(hue, 1, 1.0f)));
             cubeRegions[4].render(g);
             g.setColor(new Color(Color.HSBtoRGB(hue, 1, 0.9f)));
             cubeRegions[1].render(g);
             cubeRegions[3].render(g);
             g.setColor(new Color(Color.HSBtoRGB(hue, 1, 0.8f)));
             cubeRegions[0].render(g);
             cubeRegions[2].render(g);
         }
     }
 
     private List<Region> occupiedRegions = new ArrayList<Region>();
 
     private boolean isFree(Region region, int xo, int yo) {
         if (region.x1 + xo < 0) return false;
         if (region.y1 + yo < 0) return false;
         if (region.x2 + xo > WIDTH) return false;
         if (region.y2 + yo > HEIGHT) return false;
 
         for (int i = 0; i < occupiedRegions.size(); i++) {
             if (occupiedRegions.get(i).overlaps(region, xo, yo)) return false;
         }
-    public void generateImage(List<ModelPart> parts) {
+
         return true;
-        List<Cube> cubes = new ArrayList<Cube>();
+
-        for (ModelPart mp : parts) {
+
     public void generateImage(List<ModelRenderer> parts) {
 
         List<ModelBox> cubes = new ArrayList<ModelBox>();
-        Collections.sort(cubes, new Comparator<Cube>() {
+        for (ModelRenderer mp : parts) {
             getCubes(mp, cubes);
-            public int compare(Cube c0, Cube c1) {
+
-                int xs = Mth.ceil(c0.x1 - c0.x0);
+
-                int ys = Mth.ceil(c0.y1 - c0.y0);
+        Collections.sort(cubes, new Comparator<ModelBox>() {
-                int zs = Mth.ceil(c0.z1 - c0.z0);
+
             public int compare(ModelBox c0, ModelBox c1) {
 //                int xs = Mth.ceil(c0.x1 - c0.x0);
 //                int ys = Mth.ceil(c0.y1 - c0.y0);
 //                int zs = Mth.ceil(c0.z1 - c0.z0);
-                xs = Mth.ceil(c1.x1 - c1.x0);
+                int xs = MathHelper.func_40346_b(c0.field_40674_d - c0.field_40678_a);
-                ys = Mth.ceil(c1.y1 - c1.y0);
+                int ys = MathHelper.func_40346_b(c0.field_40675_e - c0.field_40676_b);
-                zs = Mth.ceil(c1.z1 - c1.z0);
+                int zs = MathHelper.func_40346_b(c0.field_40672_f - c0.field_40677_c);
 
                 int ww0 = xs * 2 + zs * 2;
                 int hh0 = zs + ys;
 
 //                xs = Mth.ceil(c1.x1 - c1.x0);
 //                ys = Mth.ceil(c1.y1 - c1.y0);
 //                zs = Mth.ceil(c1.z1 - c1.z0);
                 xs = MathHelper.func_40346_b(c1.field_40674_d - c1.field_40678_a);
                 ys = MathHelper.func_40346_b(c1.field_40675_e - c1.field_40676_b);
                 zs = MathHelper.func_40346_b(c1.field_40672_f - c1.field_40677_c);
 
                 int ww1 = xs * 2 + zs * 2;
                 int hh1 = zs + ys;
 
                 if (ww0 * hh0 < ww1 * hh1) {
-        for (Cube cube : cubes) {
+
                 } else if (ww0 * hh0 > ww1 * hh1) {
                     return -1;
                 }
 
                 return 0;
             }
         });
 
         List<UnfoldedCube> unfolded = new ArrayList<UnfoldedCube>();
         for (ModelBox cube : cubes) {
             UnfoldedCube uc = new UnfoldedCube(cube);
 
             boolean placed = false;
             positionLoop: for (int y = 0; y < HEIGHT - uc.height; y++) {
                 for (int x = 0; x < WIDTH - uc.width; x++) {
                     if (uc.fits(x, y)) {
                         uc.place(x, y);
                         placed = true;
                         break positionLoop;
                     }
                 }
             }
             if (!placed) {
-            System.out.println("setMapTex(\"" + uc.id + "\", " + uc.x + ", " + uc.y + ");");
+
             } else {
                 unfolded.add(uc);
             }
         }
 
         BufferedImage img = new BufferedImage(WIDTH, HEIGHT, BufferedImage.TYPE_INT_ARGB);
         Graphics g = img.getGraphics();
         System.out.println("----------------");
         for (UnfoldedCube uc : unfolded) {
-    public void getCubes(ModelPart mp, List<Cube> cubeList) {
+            System.out.println("setTextureOffset(\"" + uc.id + "\", " + uc.x + ", " + uc.y + ");");
-        addLoop: for (Cube cube : mp.cubes) {
+
-            if (cube.id != null) {
+
-                for (Cube otherCube : cubeList) {
+
-                    if (otherCube.id != null) {
+
-                        if (otherCube.id.equals(cube.id)) {
+
-                            System.out.println("Duplicate " + cube.id);
+
         }
     }
 
     public void getCubes(ModelRenderer mp, List<ModelBox> cubeList) {
         addLoop: for (Object cubeObj : mp.cubeList) {
             ModelBox cube = (ModelBox) cubeObj;
             if (cube.field_40673_g != null) {
                 for (ModelBox otherCube : cubeList) {
                     if (otherCube.field_40673_g != null) {
                         if (otherCube.field_40673_g.equals(cube.field_40673_g)) {
-        new ImageGenerator().generateImage(new DragonModel(0).cubes);
+                            System.out.println("Duplicate " + cube.field_40673_g);
                             continue addLoop;
                         }
                     }
                 }
             }
             cubeList.add(cube);
         }
     }
 
     public static void main(String[] args) {
         new ImageGenerator().generateImage(new ModelDragon(0).boxList);
     }
 }