Add render option for sky color (green-screen effect)

src/main/java/eu/crushedpixel/replaymod/ReplayMod.java

@@ -159,49 +159,14 @@ public class ReplayMod {
                 throw new IOException("File \"" + file.getPath() + "\" not found.");
             }
 
-            String renderDistance = System.getProperty("mc.renderdistance");
-            if (renderDistance != null) {
-                mc.gameSettings.renderDistanceChunks = Integer.parseInt(renderDistance);
-            }
-
             final String path = System.getProperty("replaymod.render.path");
             String type = System.getProperty("replaymod.render.type");
             String quality = System.getProperty("replaymod.render.quality");
             String fps = System.getProperty("replaymod.render.fps");
             String waitForChunks = System.getProperty("replaymod.render.waitforchunks");
             String linearMovement = System.getProperty("replaymod.render.linearmovement");
-            FrameRenderer renderer;
+            String skyColor = System.getProperty("replaymod.render.skycolor");
-            if (type != null) {
+            final RenderOptions options = new RenderOptions();
-                String[] parts = type.split(":");
-                type = parts[0].toUpperCase();
-                if ("NORMAL".equals(type) || "DEFAULT".equals(type)) {
-                    renderer = new DefaultFrameRenderer();
-                } else if ("TILED".equals(type)) {
-                    if (parts.length < 3) {
-                        throw new IllegalArgumentException("Tiled renderer requires width and height.");
-                    }
-                    int width = Integer.parseInt(parts[1]);
-                    int height = Integer.parseInt(parts[2]);
-                    renderer = new TilingFrameRenderer(width, height);
-                } else if ("STEREO".equals(type) || "STEREOSCOPIC".equals(type)) {
-                    renderer = new StereoscopicFrameRenderer();
-                } else if ("CUBIC".equals(type)) {
-                    if (parts.length < 2) {
-                        throw new IllegalArgumentException("Cubic renderer requires boolean for whether it's stable.");
-                    }
-                    renderer = new CubicFrameRenderer(Boolean.parseBoolean(parts[1]));
-                } else if ("EQUIRECTANGULAR".equals(type)) {
-                    if (parts.length < 2) {
-                        throw new IllegalArgumentException("Equirectangular renderer requires boolean for whether it's stable.");
-                    }
-                    renderer = new EquirectangularFrameRenderer(Boolean.parseBoolean(parts[1]));
-                } else {
-                    throw new IllegalArgumentException("Unknown type: " + parts[0]);
-                }
-            } else {
-                renderer = new DefaultFrameRenderer();
-            }
-            final RenderOptions options = new RenderOptions(renderer);
             if (quality != null) {
                 options.setQuality(Float.parseFloat(quality));
             }
@@ -214,6 +179,46 @@ public class ReplayMod {
             if (linearMovement != null) {
                 options.setLinearMovement(Boolean.parseBoolean(linearMovement));
             }
+            if (skyColor != null) {
+                if (skyColor.startsWith("0x")) {
+                    options.setSkyColor(Integer.parseInt(skyColor.substring(2), 16));
+                } else {
+                    options.setSkyColor(Integer.parseInt(skyColor));
+                }
+            }
+
+            FrameRenderer renderer;
+            if (type != null) {
+                String[] parts = type.split(":");
+                type = parts[0].toUpperCase();
+                if ("NORMAL".equals(type) || "DEFAULT".equals(type)) {
+                    renderer = new DefaultFrameRenderer(options);
+                } else if ("TILED".equals(type)) {
+                    if (parts.length < 3) {
+                        throw new IllegalArgumentException("Tiled renderer requires width and height.");
+                    }
+                    int width = Integer.parseInt(parts[1]);
+                    int height = Integer.parseInt(parts[2]);
+                    renderer = new TilingFrameRenderer(options, width, height);
+                } else if ("STEREO".equals(type) || "STEREOSCOPIC".equals(type)) {
+                    renderer = new StereoscopicFrameRenderer(options);
+                } else if ("CUBIC".equals(type)) {
+                    if (parts.length < 2) {
+                        throw new IllegalArgumentException("Cubic renderer requires boolean for whether it's stable.");
+                    }
+                    renderer = new CubicFrameRenderer(options, Boolean.parseBoolean(parts[1]));
+                } else if ("EQUIRECTANGULAR".equals(type)) {
+                    if (parts.length < 2) {
+                        throw new IllegalArgumentException("Equirectangular renderer requires boolean for whether it's stable.");
+                    }
+                    renderer = new EquirectangularFrameRenderer(options, Boolean.parseBoolean(parts[1]));
+                } else {
+                    throw new IllegalArgumentException("Unknown type: " + parts[0]);
+                }
+            } else {
+                renderer = new DefaultFrameRenderer(options);
+            }
+            options.setRenderer(renderer);
 
             @SuppressWarnings("unchecked")
             Queue<ListenableFutureTask> tasks = mc.scheduledTasks;
@@ -221,6 +226,15 @@ public class ReplayMod {
                 tasks.add(ListenableFutureTask.create(new Runnable() {
                     @Override
                     public void run() {
+                        String renderDistance = System.getProperty("replaymod.render.mc.renderdistance");
+                        String clouds = System.getProperty("replaymod.render.mc.clouds");
+                        if (renderDistance != null) {
+                            mc.gameSettings.renderDistanceChunks = Integer.parseInt(renderDistance);
+                        }
+                        if (clouds != null) {
+                            mc.gameSettings.clouds = Boolean.parseBoolean(clouds);
+                        }
+
                         System.out.println("Loading replay...");
                         ReplayHandler.startReplay(file, false);
 

src/main/java/eu/crushedpixel/replaymod/gui/GuiRenderSettings.java

@@ -256,19 +256,8 @@ public class GuiRenderSettings extends GuiScreen {
         FrameRenderer renderer = null;
 
         RendererSettings r = rendererDropdown.getElement(rendererDropdown.getSelectionIndex());
-        if(r == RendererSettings.DEFAULT) {
-            renderer = new DefaultFrameRenderer();
-        } else if(r == RendererSettings.TILED) {
-            renderer = new TilingFrameRenderer(getWidthSetting(), getHeightSetting());
-        } else if(r == RendererSettings.STEREOSCOPIC) {
-            renderer = new StereoscopicFrameRenderer();
-        } else if(r == RendererSettings.CUBIC) {
-            renderer = new CubicFrameRenderer(ignoreCamDir.isChecked());
-        } else if(r == RendererSettings.EQUIRECTANGULAR) {
-            renderer = new EquirectangularFrameRenderer(ignoreCamDir.isChecked());
-        }
 
-        RenderOptions options = new RenderOptions(renderer);
+        RenderOptions options = new RenderOptions();
 
         options.setLinearMovement(linear);
         ReplayMod.replaySettings.setLinearMovement(linear);
@@ -282,6 +271,19 @@ public class GuiRenderSettings extends GuiScreen {
         options.setQuality(qualitySlider.getQuality());
         ReplayMod.replaySettings.setVideoQuality(qualitySlider.getQuality());
 
+        if(r == RendererSettings.DEFAULT) {
+            renderer = new DefaultFrameRenderer(options);
+        } else if(r == RendererSettings.TILED) {
+            renderer = new TilingFrameRenderer(options, getWidthSetting(), getHeightSetting());
+        } else if(r == RendererSettings.STEREOSCOPIC) {
+            renderer = new StereoscopicFrameRenderer(options);
+        } else if(r == RendererSettings.CUBIC) {
+            renderer = new CubicFrameRenderer(options, ignoreCamDir.isChecked());
+        } else if(r == RendererSettings.EQUIRECTANGULAR) {
+            renderer = new EquirectangularFrameRenderer(options, ignoreCamDir.isChecked());
+        }
+        options.setRenderer(renderer);
+
         ReplayHandler.startPath(options);
     }
 

src/main/java/eu/crushedpixel/replaymod/settings/RenderOptions.java

@@ -10,10 +10,7 @@ public final class RenderOptions {
     private int fps = 30;
     private boolean waitForChunks = true;
     private boolean isLinearMovement = false;
-
+    private int skyColor = -1;
-    public RenderOptions(FrameRenderer renderer) {
-        this.renderer = notNull(renderer);
-    }
 
     public FrameRenderer getRenderer() {
         return renderer;
@@ -57,12 +54,26 @@ public final class RenderOptions {
         this.isLinearMovement = isLinearMovement;
     }
 
+    public boolean isDefaultSky() {
+        return skyColor == -1;
+    }
+
+    public int getSkyColor() {
+        return skyColor;
+    }
+
+    public void setSkyColor(int skyColor) {
+        this.skyColor = skyColor;
+    }
+
     public RenderOptions copy() {
-        RenderOptions copy = new RenderOptions(renderer);
+        RenderOptions copy = new RenderOptions();
+        copy.renderer = this.renderer;
         copy.quality = this.quality;
         copy.fps = this.fps;
         copy.waitForChunks = this.waitForChunks;
         copy.isLinearMovement = this.isLinearMovement;
+        copy.skyColor = this.skyColor;
         return copy;
     }
 }

src/main/java/eu/crushedpixel/replaymod/video/entity/CubicEntityRenderer.java

@@ -1,6 +1,7 @@
 package eu.crushedpixel.replaymod.video.entity;
 
 import eu.crushedpixel.replaymod.replay.ReplayHandler;
+import eu.crushedpixel.replaymod.settings.RenderOptions;
 import net.minecraft.client.renderer.GlStateManager;
 import net.minecraft.entity.Entity;
 
@@ -32,7 +33,8 @@ public class CubicEntityRenderer extends CustomEntityRenderer {
     private final boolean stable;
     private Direction direction;
 
-    public CubicEntityRenderer(boolean stable) {
+    public CubicEntityRenderer(RenderOptions options, boolean stable) {
+        super(options);
         this.stable = stable;
     }
 

src/main/java/eu/crushedpixel/replaymod/video/entity/CustomEntityRenderer.java

@@ -2,6 +2,7 @@ package eu.crushedpixel.replaymod.video.entity;
 
 import eu.crushedpixel.replaymod.renderer.SpectatorRenderer;
 import eu.crushedpixel.replaymod.replay.ReplayHandler;
+import eu.crushedpixel.replaymod.settings.RenderOptions;
 import net.minecraft.client.Minecraft;
 import net.minecraft.client.particle.EffectRenderer;
 import net.minecraft.client.renderer.*;
@@ -29,6 +30,12 @@ public abstract class CustomEntityRenderer {
     };
     protected int frameCount;
 
+    protected final RenderOptions options;
+
+    public CustomEntityRenderer(RenderOptions options) {
+        this.options = options;
+    }
+
     protected void gluPerspective(float fovY, float aspect, float zNear, float zFar) {
         Project.gluPerspective(fovY, aspect, zNear, zFar);
     }
@@ -76,27 +83,33 @@ public abstract class CustomEntityRenderer {
         ClippingHelperImpl.getInstance();
         ICamera camera = new NoCullingCamera();
 
-        if (this.mc.gameSettings.renderDistanceChunks >= 4) {
+        if (this.mc.gameSettings.renderDistanceChunks >= 4 || !options.isDefaultSky()   ) {
-            proxied.setupFog(-1, partialTicks);
+            setupFog(-1, partialTicks);
             matrixMode(GL_PROJECTION);
             loadIdentity();
             gluPerspective(proxied.getFOVModifier(partialTicks, true), (float) mc.displayWidth / mc.displayHeight, 0.05F, proxied.farPlaneDistance * 2.0F);
             matrixMode(GL_MODELVIEW);
-            renderglobal.renderSky(partialTicks, renderPass);
+            if (options.isDefaultSky()) {
+                renderglobal.renderSky(partialTicks, renderPass);
+            } else {
+                int c = options.getSkyColor();
+                clearColor(c >> 16, c >> 8 & 0xff, c & 0xff, 0xff);
+                clear(GL_COLOR_BUFFER_BIT);
+            }
             matrixMode(GL_PROJECTION);
             loadIdentity();
             gluPerspective(proxied.getFOVModifier(partialTicks, true), (float) mc.displayWidth / mc.displayHeight, 0.05F, proxied.farPlaneDistance * MathHelper.SQRT_2);
             matrixMode(GL_MODELVIEW);
         }
 
-        proxied.setupFog(0, partialTicks);
+        setupFog(0, partialTicks);
         shadeModel(GL_SMOOTH);
 
         if (entity.posY + entity.getEyeHeight() < 128) {
             renderCloudsCheck(renderglobal, partialTicks, renderPass);
         }
 
-        proxied.setupFog(0, partialTicks);
+        setupFog(0, partialTicks);
         mc.getTextureManager().bindTexture(TextureMap.locationBlocksTexture);
         RenderHelper.disableStandardItemLighting();
         renderglobal.setupTerrain(entity, partialTicks, camera, frameCount++, mc.thePlayer.isSpectator());
@@ -136,7 +149,7 @@ public abstract class CustomEntityRenderer {
         proxied.enableLightmap();
         effectrenderer.renderLitParticles(entity, partialTicks);
         RenderHelper.disableStandardItemLighting();
-        proxied.setupFog(0, partialTicks);
+        setupFog(0, partialTicks);
         effectrenderer.renderParticles(entity, partialTicks);
         proxied.disableLightmap();
 
@@ -149,7 +162,7 @@ public abstract class CustomEntityRenderer {
         enableCull();
         tryBlendFuncSeparate(770, 771, 1, 0);
         alphaFunc(516, 0.1F);
-        proxied.setupFog(0, partialTicks);
+        setupFog(0, partialTicks);
         enableBlend();
         depthMask(false);
         mc.getTextureManager().bindTexture(TextureMap.locationBlocksTexture);
@@ -206,6 +219,12 @@ public abstract class CustomEntityRenderer {
         orientCamera(partialTicks);
     }
 
+    protected void setupFog(int fogDistanceFlag, float partialTicks) {
+        if (options.isDefaultSky()) {
+            proxied.setupFog(fogDistanceFlag, partialTicks);
+        }
+    }
+
     protected void orientCamera(float partialTicks) {
         proxied.orientCamera(partialTicks);
     }
@@ -217,7 +236,7 @@ public abstract class CustomEntityRenderer {
             gluPerspective(proxied.getFOVModifier(partialTicks, true), (float) this.mc.displayWidth / (float) this.mc.displayHeight, 0.05F, proxied.farPlaneDistance * 4.0F);
             matrixMode(GL_MODELVIEW);
             pushMatrix();
-            proxied.setupFog(0, partialTicks);
+            setupFog(0, partialTicks);
             renderglobal.renderClouds(partialTicks, renderPass);
             disableFog();
             popMatrix();

src/main/java/eu/crushedpixel/replaymod/video/entity/StereoscopicEntityRenderer.java

@@ -1,5 +1,6 @@
 package eu.crushedpixel.replaymod.video.entity;
 
+import eu.crushedpixel.replaymod.settings.RenderOptions;
 import net.minecraft.client.renderer.GlStateManager;
 import net.minecraft.util.MathHelper;
 
@@ -12,6 +13,10 @@ public class StereoscopicEntityRenderer extends CustomEntityRenderer {
 
     private boolean leftEye;
 
+    public StereoscopicEntityRenderer(RenderOptions options) {
+        super(options);
+    }
+
     public void setEye(boolean leftEye) {
         this.leftEye = leftEye;
     }

src/main/java/eu/crushedpixel/replaymod/video/entity/TilingEntityRenderer.java

@@ -1,5 +1,6 @@
 package eu.crushedpixel.replaymod.video.entity;
 
+import eu.crushedpixel.replaymod.settings.RenderOptions;
 import eu.crushedpixel.replaymod.video.frame.TilingFrameRenderer;
 
 import static net.minecraft.client.renderer.GlStateManager.scale;
@@ -10,7 +11,8 @@ public class TilingEntityRenderer extends CustomEntityRenderer {
     private final TilingFrameRenderer renderer;
     private int tileX, tileY;
 
-    public TilingEntityRenderer(TilingFrameRenderer renderer) {
+    public TilingEntityRenderer(RenderOptions options, TilingFrameRenderer renderer) {
+        super(options);
         this.renderer = renderer;
     }
 

src/main/java/eu/crushedpixel/replaymod/video/frame/CubicFrameRenderer.java

@@ -1,5 +1,6 @@
 package eu.crushedpixel.replaymod.video.frame;
 
+import eu.crushedpixel.replaymod.settings.RenderOptions;
 import eu.crushedpixel.replaymod.video.entity.CubicEntityRenderer;
 import net.minecraft.client.Minecraft;
 import net.minecraft.crash.CrashReport;
@@ -17,15 +18,15 @@ public class CubicFrameRenderer extends FrameRenderer {
     protected final CubicEntityRenderer entityRenderer;
     protected final int displaySize;
 
-    protected CubicFrameRenderer(int videoWidth, int videoHeight, boolean stable) {
+    protected CubicFrameRenderer(RenderOptions options, int videoWidth, int videoHeight, boolean stable) {
-        super(videoWidth, videoHeight, getDisplaySize() * getDisplaySize() * 3);
+        super(options, videoWidth, videoHeight, getDisplaySize() * getDisplaySize() * 3);
         this.displaySize = getDisplaySize();
-        this.entityRenderer = new CubicEntityRenderer(stable);
+        this.entityRenderer = new CubicEntityRenderer(options, stable);
         setCustomEntityRenderer(entityRenderer);
     }
 
-    public CubicFrameRenderer(boolean stable) {
+    public CubicFrameRenderer(RenderOptions options, boolean stable) {
-        this(getDisplaySize() * 4, getDisplaySize() * 3, stable);
+        this(options, getDisplaySize() * 4, getDisplaySize() * 3, stable);
     }
 
     @Override

src/main/java/eu/crushedpixel/replaymod/video/frame/DefaultFrameRenderer.java

@@ -1,5 +1,6 @@
 package eu.crushedpixel.replaymod.video.frame;
 
+import eu.crushedpixel.replaymod.settings.RenderOptions;
 import net.minecraft.client.Minecraft;
 import net.minecraft.util.Timer;
 
@@ -7,8 +8,8 @@ import java.awt.image.BufferedImage;
 
 public class DefaultFrameRenderer extends FrameRenderer {
 
-    public DefaultFrameRenderer() {
+    public DefaultFrameRenderer(RenderOptions options) {
-        super(Minecraft.getMinecraft().displayWidth, Minecraft.getMinecraft().displayHeight);
+        super(options, Minecraft.getMinecraft().displayWidth, Minecraft.getMinecraft().displayHeight);
     }
 
     @Override

src/main/java/eu/crushedpixel/replaymod/video/frame/EquirectangularFrameRenderer.java

@@ -1,5 +1,6 @@
 package eu.crushedpixel.replaymod.video.frame;
 
+import eu.crushedpixel.replaymod.settings.RenderOptions;
 import eu.crushedpixel.replaymod.video.entity.CubicEntityRenderer;
 import net.minecraft.crash.CrashReport;
 import net.minecraft.util.ReportedException;
@@ -12,8 +13,8 @@ import static java.lang.Math.PI;
 
 public class EquirectangularFrameRenderer extends CubicFrameRenderer {
 
-    public EquirectangularFrameRenderer(boolean stable) {
+    public EquirectangularFrameRenderer(RenderOptions options, boolean stable) {
-        super(getDisplaySize() * 4, getDisplaySize() * 2, stable);
+        super(options, getDisplaySize() * 4, getDisplaySize() * 2, stable);
     }
 
     @Override

src/main/java/eu/crushedpixel/replaymod/video/frame/FrameRenderer.java

@@ -2,6 +2,7 @@ package eu.crushedpixel.replaymod.video.frame;
 
 import com.google.common.base.Preconditions;
 import com.google.common.util.concurrent.Runnables;
+import eu.crushedpixel.replaymod.settings.RenderOptions;
 import eu.crushedpixel.replaymod.video.entity.CustomEntityRenderer;
 import net.minecraft.client.Minecraft;
 import net.minecraft.client.gui.Gui;
@@ -25,6 +26,7 @@ import static org.lwjgl.opengl.GL11.GL_DEPTH_BUFFER_BIT;
 public abstract class FrameRenderer {
     private static final ResourceLocation noPreviewTexture = new ResourceLocation("replaymod", "logo.jpg");
     protected final Minecraft mc = Minecraft.getMinecraft();
+    protected final RenderOptions options;
     private final int videoWidth;
     private final int videoHeight;
     private CustomEntityRenderer customEntityRenderer;
@@ -33,18 +35,20 @@ public abstract class FrameRenderer {
     private boolean previewActive = false;
     protected final ByteBuffer buffer;
 
-    public FrameRenderer(int videoWidth, int videoHeight) {
+    public FrameRenderer(RenderOptions options, int videoWidth, int videoHeight) {
+        this.options = options;
         this.videoWidth = videoWidth;
         this.videoHeight = videoHeight;
         this.buffer = BufferUtils.createByteBuffer(mc.displayWidth * mc.displayHeight * 3);
-        this.customEntityRenderer = new CustomEntityRenderer() {};
+        this.customEntityRenderer = new CustomEntityRenderer(options) {};
     }
 
-    public FrameRenderer(int videoWidth, int videoHeight, int bufferSize) {
+    public FrameRenderer(RenderOptions options, int videoWidth, int videoHeight, int bufferSize) {
+        this.options = options;
         this.videoWidth = videoWidth;
         this.videoHeight = videoHeight;
         this.buffer = BufferUtils.createByteBuffer(bufferSize);
-        this.customEntityRenderer = new CustomEntityRenderer() {};
+        this.customEntityRenderer = new CustomEntityRenderer(options) {};
     }
 
     public final int getVideoWidth() {

src/main/java/eu/crushedpixel/replaymod/video/frame/StereoscopicFrameRenderer.java

@@ -1,5 +1,6 @@
 package eu.crushedpixel.replaymod.video.frame;
 
+import eu.crushedpixel.replaymod.settings.RenderOptions;
 import eu.crushedpixel.replaymod.video.entity.StereoscopicEntityRenderer;
 import net.minecraft.client.Minecraft;
 import net.minecraft.crash.CrashReport;
@@ -9,10 +10,11 @@ import net.minecraft.util.Timer;
 import java.awt.image.BufferedImage;
 
 public class StereoscopicFrameRenderer extends FrameRenderer {
-    private final StereoscopicEntityRenderer entityRenderer = new StereoscopicEntityRenderer();
+    private final StereoscopicEntityRenderer entityRenderer;
 
-    public StereoscopicFrameRenderer() {
+    public StereoscopicFrameRenderer(RenderOptions options) {
-        super(Minecraft.getMinecraft().displayWidth * 2, Minecraft.getMinecraft().displayHeight);
+        super(options, Minecraft.getMinecraft().displayWidth * 2, Minecraft.getMinecraft().displayHeight);
+        entityRenderer = new StereoscopicEntityRenderer(options);
         setCustomEntityRenderer(entityRenderer);
     }
 

src/main/java/eu/crushedpixel/replaymod/video/frame/TilingFrameRenderer.java

@@ -1,5 +1,6 @@
 package eu.crushedpixel.replaymod.video.frame;
 
+import eu.crushedpixel.replaymod.settings.RenderOptions;
 import eu.crushedpixel.replaymod.video.entity.TilingEntityRenderer;
 import net.minecraft.crash.CrashReport;
 import net.minecraft.util.ReportedException;
@@ -9,12 +10,13 @@ import java.awt.image.BufferedImage;
 import java.util.Arrays;
 
 public class TilingFrameRenderer extends FrameRenderer {
-    private final TilingEntityRenderer entityRenderer = new TilingEntityRenderer(this);
+    private final TilingEntityRenderer entityRenderer;
     private final int tileWidth;
     private final int tileHeight;
 
-    public TilingFrameRenderer(int videoWidth, int videoHeight) {
+    public TilingFrameRenderer(RenderOptions options, int videoWidth, int videoHeight) {
-        super(videoWidth, videoHeight);
+        super(options, videoWidth, videoHeight);
+        this.entityRenderer = new TilingEntityRenderer(options, this);
         this.tileWidth = mc.displayWidth;
         this.tileHeight = mc.displayHeight;
         setCustomEntityRenderer(entityRenderer);