Fire texture generator

This was a real doozy! Trying to figure out how I should scale the fire was a challenge, but I managed to figure it out in the end.

README.md

@@ -13,6 +13,7 @@ The program can also generate some non-deterministic textures, if a valid value
 
 - Water textures from Minecraft Classic 0.0.19a
 - Lava textures from Minecraft Classic 0.0.19a and 0.0.22a
+- Fire textures
 
 ## How to generate the textures.
 

src/main/java/mcTextureGen/MCTextureGenerator.java

@@ -10,6 +10,7 @@
 import mcTextureGen.generators.Classic19aLavaGenerator;
 import mcTextureGen.generators.Classic19aWaterGenerator;
 import mcTextureGen.generators.Classic22aLavaGenerator;
+import mcTextureGen.generators.FireGenerator;
 import mcTextureGen.generators.GearRotationFramesGenerator;
 import mcTextureGen.generators.MC4k1Generator;
 import mcTextureGen.generators.MC4k2Generator;
@@ -20,7 +21,7 @@ public final class MCTextureGenerator {
     // private static boolean hasDebugInfo = true;
 
     public static AbstractTextureGenerator[] getTextureGenerators() {
-        return new AbstractTextureGenerator[] { new MC4k1Generator(), new MC4k2Generator(), new GearRotationFramesGenerator(), new NetherPortalGenerator(), new Classic19aWaterGenerator(), new Classic19aLavaGenerator(), new Classic22aLavaGenerator() };
+        return new AbstractTextureGenerator[] { new MC4k1Generator(), new MC4k2Generator(), new GearRotationFramesGenerator(), new NetherPortalGenerator(), new Classic19aWaterGenerator(), new Classic19aLavaGenerator(), new Classic22aLavaGenerator(), new FireGenerator() };
     }
 
     public static void main(final String[] args) {

src/main/java/mcTextureGen/generators/FireGenerator.java

@@ -0,0 +1,120 @@
+package mcTextureGen.generators;
+
+import java.awt.image.BufferedImage;
+import java.awt.image.DataBufferByte;
+import java.util.Random;
+
+import mcTextureGen.data.TextureGroup;
+
+public final class FireGenerator extends AbstractTextureGenerator {
+
+    private static final int fireMulti = 1;
+
+    // Set up fire texture size
+    private static final int fireTextureWidth = 16 * fireMulti;
+    private static final int fireTextureHeight = 20 * fireMulti;
+
+    // Pixels to sample from.
+    private static final int sampleXLeft = 1;
+    private static final int sampleXRight = 1;
+    private static final int sampleYDown = 0;
+    private static final int sampleYUp = 1;
+
+    // This was originally a counter that was incremented inside the code that sampled neighboring pixels,
+    // but the counter would always end up at the same value (24, purely deterministic at build time).
+    private static final int selfSamples = 1;
+    private static final int sampleCounterStart = 18 * fireMulti;
+    private static final int sampleCounterIterations = (sampleXLeft + selfSamples + sampleXRight) * (sampleYDown + selfSamples + sampleYUp);
+    private static final int sampleCounterEnd = sampleCounterStart + sampleCounterIterations;
+
+    // wtFloat is a very strange constant. I felt the name was appropriate, given how hard it was to pin down.
+    // These sorts of constants keep me awake at night.
+
+    // Earlier versions of Minecraft.
+    //private static final float wtFloat = 1.06F;
+    // Later versions.
+    //private static final float wtFloat = 1.0600001F;
+
+    // This is the current method I've settled on to determine the scaled value of wtFloat.
+    // If fireMulti is 1, it results in 1.06F.
+    private static final float wtFloat = 1.0F + (selfSamples * 0.01F) + (((sampleCounterIterations - selfSamples) * 0.01F) / fireMulti);
+
+    // TODO It's rumored that some versions of pocket edition have this as 25.2?
+    // If that's true, removing " + (selfSamples * 0.01F)" from wtFloat might simulate this.
+    private static final float divPixelIntensity = sampleCounterEnd * wtFloat;
+
+    @Override
+    public String getGeneratorName() {
+        return "Fire";
+    }
+
+    @Override
+    public TextureGroup[] getTextureGroups() {
+        return new TextureGroup[] { fireTextures() };
+    }
+
+    private TextureGroup fireTextures() {
+        float[] fireImagePrevious = new float[fireTextureWidth * fireTextureHeight];
+        float[] fireImageCurrent = new float[fireTextureWidth * fireTextureHeight];
+        final Random rand = getRandom();
+        final BufferedImage[] fireImages = new BufferedImage[nonDeterministicFrames];
+
+        for (int currentFrame = 0; currentFrame < nonDeterministicFrames; currentFrame++) {
+            for (int fireX = 0; fireX < fireTextureWidth; ++fireX) {
+                // Loop over every row except the bottom row
+                for (int fireY = 0; fireY < (fireTextureHeight - 1); ++fireY) {
+                    // Start by sampling the pixel above
+                    float pixelIntensity = fireImagePrevious[fireX + ((fireY + 1) * fireTextureWidth)] * sampleCounterStart;
+
+                    // Sample from one pixel left to one pixel right, on this row and the above row
+                    for (int localFireX = fireX - sampleXLeft; localFireX <= (fireX + sampleXRight); ++localFireX) {
+                        for (int localFireY = fireY - sampleYDown; localFireY <= (fireY + sampleYUp); ++localFireY) {
+                            // Check to make sure the pixel we're sampling is in bounds
+                            if ((localFireX >= 0) && (localFireY >= 0) && (localFireX < fireTextureWidth) && (localFireY < fireTextureHeight)) {
+                                pixelIntensity += fireImagePrevious[localFireX + (localFireY * fireTextureWidth)];
+                            }
+                        }
+                    }
+
+                    // Set pixel value, compensating for the additional sampling
+                    fireImageCurrent[fireX + (fireY * fireTextureWidth)] = pixelIntensity / divPixelIntensity;
+                }
+
+                // Randomize bottom row of pixels
+                fireImageCurrent[fireX + ((fireTextureHeight - 1) * fireTextureWidth)] = (float)((rand.nextDouble() * rand.nextDouble() * rand.nextDouble() * (3 + fireMulti)) + (rand.nextDouble() * 0.1F) + 0.2F);
+            }
+
+            final float[] fireImageCurrentTemp = fireImageCurrent;
+            fireImageCurrent = fireImagePrevious;
+            fireImagePrevious = fireImageCurrentTemp;
+            final BufferedImage currentFireImage = new BufferedImage(fireTextureWidth, fireTextureHeight, BufferedImage.TYPE_4BYTE_ABGR);
+            final byte[] imageByteData = ((DataBufferByte) currentFireImage.getRaster().getDataBuffer()).getData();
+
+            for (int currentPixel = 0; currentPixel < (fireTextureWidth * fireTextureHeight); ++currentPixel) {
+                // Boost intensity
+                float pixelIntensity = fireImagePrevious[currentPixel] * 1.8F;
+
+                // Clamp pixel intensity
+                if (pixelIntensity > 1.0F) {
+                    pixelIntensity = 1.0F;
+                }
+
+                if (pixelIntensity < 0.0F) {
+                    pixelIntensity = 0.0F;
+                }
+
+                final int imageOffset = currentPixel * 4;
+                // If the pixel isn't intense enough, make it transparent
+                imageByteData[imageOffset + 0] = (byte) (pixelIntensity < 0.5F ? 0 : 255);
+                imageByteData[imageOffset + 1] = (byte) (pixelIntensity * pixelIntensity * pixelIntensity * pixelIntensity * pixelIntensity * pixelIntensity * pixelIntensity * pixelIntensity * pixelIntensity * pixelIntensity * 255.0F);
+                imageByteData[imageOffset + 2] = (byte) (pixelIntensity * pixelIntensity * 255.0F);
+                imageByteData[imageOffset + 3] = (byte) ((pixelIntensity * 155.0F) + 100.0F);
+            }
+
+            fireImages[currentFrame] = currentFireImage;
+        }
+
+        return new TextureGroup("Fire_Textures", fireImages);
+    }
+
+}