Implement ODS rendering via Iris Shader for MC 1.17

src/main/java/com/replaymod/render/capturer/IrisODSFrameCapturer.java

@@ -0,0 +1,156 @@
+//#if MC>=11600
+package com.replaymod.render.capturer;
+
+import com.mojang.blaze3d.platform.GlStateManager;
+import com.replaymod.render.RenderSettings;
+import com.replaymod.render.frame.CubicOpenGlFrame;
+import com.replaymod.render.frame.ODSOpenGlFrame;
+import com.replaymod.render.frame.OpenGlFrame;
+import com.replaymod.render.rendering.Channel;
+import com.replaymod.render.rendering.FrameCapturer;
+import de.johni0702.minecraft.gui.utils.lwjgl.ReadableDimension;
+import net.coderbot.iris.Iris;
+import net.coderbot.iris.config.IrisConfig;
+
+import java.io.IOException;
+import java.util.HashMap;
+import java.util.Map;
+
+import static com.replaymod.core.versions.MCVer.popMatrix;
+import static com.replaymod.core.versions.MCVer.pushMatrix;
+import static com.replaymod.core.versions.MCVer.resizeMainWindow;
+import static org.lwjgl.opengl.GL11.GL_COLOR_BUFFER_BIT;
+import static org.lwjgl.opengl.GL11.GL_DEPTH_BUFFER_BIT;
+
+public class IrisODSFrameCapturer implements FrameCapturer<ODSOpenGlFrame> {
+
+    public static final String SHADER_PACK_NAME = "assets/replaymod/iris/ods";
+    public static IrisODSFrameCapturer INSTANCE;
+    private final CubicPboOpenGlFrameCapturer left, right;
+    private final String prevShaderPack;
+    private int direction;
+    private boolean isLeftEye;
+
+    public IrisODSFrameCapturer(WorldRenderer worldRenderer, final RenderInfo renderInfo, int frameSize) {
+        RenderInfo fakeInfo = new RenderInfo() {
+            private int call;
+            private float partialTicks;
+            @Override
+            public ReadableDimension getFrameSize() {
+                return renderInfo.getFrameSize();
+            }
+
+            @Override
+            public int getFramesDone() {
+                return renderInfo.getFramesDone();
+            }
+
+            @Override
+            public int getTotalFrames() {
+                return renderInfo.getTotalFrames();
+            }
+
+            @Override
+            public float updateForNextFrame() {
+                if (call++ % 2 == 0) {
+                    partialTicks = renderInfo.updateForNextFrame();
+                }
+                return partialTicks;
+            }
+
+            @Override
+            public RenderSettings getRenderSettings() {
+                return renderInfo.getRenderSettings();
+            }
+        };
+        left = new CubicStereoFrameCapturer(worldRenderer, fakeInfo, frameSize);
+        right = new CubicStereoFrameCapturer(worldRenderer, fakeInfo, frameSize);
+
+        INSTANCE = this;
+        prevShaderPack = Iris.getIrisConfig().getShaderPackName().orElse(null);
+        setShaderPack(SHADER_PACK_NAME);
+    }
+
+    private static void setShaderPack(String name) {
+        IrisConfig irisConfig = Iris.getIrisConfig();
+        irisConfig.setShaderPackName(name);
+        try {
+            irisConfig.save();
+            Iris.reload();
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    public int getDirection() {
+        return direction;
+    }
+
+    public boolean isLeftEye() {
+        return isLeftEye;
+    }
+
+    @Override
+    public boolean isDone() {
+        return left.isDone() && right.isDone();
+    }
+
+    @Override
+    public Map<Channel, ODSOpenGlFrame> process() {
+        isLeftEye = true;
+        Map<Channel, CubicOpenGlFrame> leftChannels = left.process();
+        isLeftEye = false;
+        Map<Channel, CubicOpenGlFrame> rightChannels = right.process();
+
+        if (leftChannels != null && rightChannels != null) {
+            Map<Channel, ODSOpenGlFrame> result = new HashMap<>();
+            for (Channel channel : Channel.values()) {
+                CubicOpenGlFrame leftFrame = leftChannels.get(channel);
+                CubicOpenGlFrame rightFrame = rightChannels.get(channel);
+                if (leftFrame != null && rightFrame != null) {
+                    result.put(channel, new ODSOpenGlFrame(leftFrame, rightFrame));
+                }
+            }
+            return result;
+        }
+        return null;
+    }
+
+    @Override
+    public void close() throws IOException {
+        left.close();
+        right.close();
+        INSTANCE = null;
+        setShaderPack(prevShaderPack);
+    }
+
+    private class CubicStereoFrameCapturer extends CubicPboOpenGlFrameCapturer {
+        public CubicStereoFrameCapturer(WorldRenderer worldRenderer, RenderInfo renderInfo, int frameSize) {
+            super(worldRenderer, renderInfo, frameSize);
+        }
+
+        @Override
+        protected OpenGlFrame renderFrame(int frameId, float partialTicks, CubicOpenGlFrameCapturer.Data captureData) {
+            resizeMainWindow(mc, getFrameWidth(), getFrameHeight());
+
+            pushMatrix();
+            frameBuffer().beginWrite(true);
+
+            GlStateManager.clear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT
+                    //#if MC>=11400
+                    , false
+                    //#endif
+            );
+            GlStateManager.enableTexture();
+
+            direction = captureData.ordinal();
+            worldRenderer.renderWorld(partialTicks, null);
+
+            frameBuffer().endWrite();
+            popMatrix();
+
+            return captureFrame(frameId, captureData);
+        }
+    }
+}
+//#endif