No chat to show

This project's files are all here to explore.

Files
src
build.gradle
gradle.properties
settings.gradle
Code
8 337
src/client/java/dev/kodari/flashbackguicapture/FlashbackGuiCapture.java
package dev.kodari.flashbackguicapture;

import com.mojang.blaze3d.platform.NativeImage;
import com.moulberry.flashback.Flashback;
import com.moulberry.flashback.action.ActionRegistry;
import com.moulberry.flashback.io.ReplayWriter;
import com.moulberry.flashback.record.Recorder;
import net.fabricmc.api.ClientModInitializer;
import net.fabricmc.fabric.api.client.event.lifecycle.v1.ClientTickEvents;
import net.fabricmc.fabric.api.client.rendering.v1.hud.HudElementRegistry;
import net.minecraft.client.Minecraft;
import net.minecraft.client.Screenshot;
import net.minecraft.client.gui.GuiGraphicsExtractor;
import net.minecraft.client.renderer.RenderPipelines;
import net.minecraft.client.renderer.texture.DynamicTexture;
import net.minecraft.resources.Identifier;

import java.io.ByteArrayOutputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.io.UncheckedIOException;
import java.util.concurrent.atomic.AtomicReference;
import java.util.zip.DeflaterOutputStream;

public final class FlashbackGuiCapture implements ClientModInitializer {
    private static final int MAX_FRAME_WIDTH = 1280;
    private static final int MAX_FRAME_HEIGHT = 720;
    private static final Identifier TEXTURE_ID = Identifier.fromNamespaceAndPath("flashback_gui_capture", "replay_frame");
    private static final AtomicReference<Frame> PLAYBACK_FRAME = new AtomicReference<>();

    private static volatile boolean capturePending;
    private static boolean lastCaptureHadScreen;
    private static DynamicTexture playbackTexture;
    private static Frame uploadedFrame;

    @Override
    public void onInitializeClient() {
        ActionRegistry.register(GuiFrameAction.INSTANCE);
        HudElementRegistry.addLast(TEXTURE_ID, FlashbackGuiCapture::renderPlaybackFrame);
        ClientTickEvents.END_CLIENT_TICK.register(client -> {
            capturePending = true;
            if (client.level == null) {
                PLAYBACK_FRAME.set(null);
            }
        });
    }

    public static void captureRenderedFrame() {
        if (!capturePending) {
            return;
        }
        capturePending = false;

        Minecraft client = Minecraft.getInstance();
        Recorder recorder = Flashback.RECORDER;
        if (recorder == null) {
            lastCaptureHadScreen = false;
            return;
        }

        if (client.gui.screen() == null) {
            if (lastCaptureHadScreen && recorder.readyToWrite()) {
                submitClearFrame(recorder);
            }
            lastCaptureHadScreen = false;
            return;
        }

        if (!recorder.readyToWrite()) {
            return;
        }

        lastCaptureHadScreen = true;
        Screenshot.takeScreenshot(client.gameRenderer.mainRenderTarget(), image -> {
            try {
                int width = Math.min(image.getWidth(), MAX_FRAME_WIDTH);
                int height = Math.min(image.getHeight(), MAX_FRAME_HEIGHT);
                double scale = Math.max(image.getWidth() / (double) width, image.getHeight() / (double) height);
                width = Math.max(1, (int) Math.round(image.getWidth() / scale));
                height = Math.max(1, (int) Math.round(image.getHeight() / scale));
                byte[] pixels = compressPixels(image, width, height);
                submitFrame(recorder, width, height, pixels);
            } finally {
                image.close();
            }
        });
    }

    public static void setPlaybackFrame(Frame frame) {
        PLAYBACK_FRAME.set(frame);
    }

    private static byte[] compressPixels(NativeImage image, int width, int height) {
        ByteArrayOutputStream bytes = new ByteArrayOutputStream();
        try (DataOutputStream output = new DataOutputStream(new DeflaterOutputStream(bytes))) {
            for (int y = 0; y < height; y++) {
                int sourceY = y * image.getHeight() / height;
                for (int x = 0; x < width; x++) {
                    int sourceX = x * image.getWidth() / width;
                    output.writeInt(image.getPixel(sourceX, sourceY));
                }
            }
        } catch (IOException exception) {
            throw new UncheckedIOException(exception);
        }
        return bytes.toByteArray();
    }

    private static void submitFrame(Recorder recorder, int width, int height, byte[] pixels) {
        if (!recorder.readyToWrite()) {
            return;
        }
        recorder.submitCustomTask(writer -> {
            writer.startAction(GuiFrameAction.INSTANCE);
            writer.friendlyByteBuf().writeBoolean(true);
            writer.friendlyByteBuf().writeInt(width);
            writer.friendlyByteBuf().writeInt(height);
            writer.friendlyByteBuf().writeByteArray(pixels);
            writer.finishAction(GuiFrameAction.INSTANCE);
        });
    }

    private static void submitClearFrame(Recorder recorder) {
        recorder.submitCustomTask(writer -> {
            writer.startAction(GuiFrameAction.INSTANCE);
            writer.friendlyByteBuf().writeBoolean(false);
            writer.finishAction(GuiFrameAction.INSTANCE);
        });
    }

    private static void renderPlaybackFrame(GuiGraphicsExtractor graphics, net.minecraft.client.DeltaTracker deltaTracker) {
        Frame frame = PLAYBACK_FRAME.get();
        if (frame == null) {
            uploadedFrame = null;
            return;
        }

        Minecraft client = Minecraft.getInstance();
        if (uploadedFrame != frame) {
            if (playbackTexture == null || playbackTexture.getPixels().getWidth() != frame.width || playbackTexture.getPixels().getHeight() != frame.height) {
                playbackTexture = new DynamicTexture("flashback gui replay frame", frame.width, frame.height, false);
                client.getTextureManager().register(TEXTURE_ID, playbackTexture);
            }

            NativeImage pixels = playbackTexture.getPixels();
            for (int y = 0; y < frame.height; y++) {
                for (int x = 0; x < frame.width; x++) {
                    pixels.setPixel(x, y, frame.pixels[y * frame.width + x]);
                }
            }
            playbackTexture.upload();
            uploadedFrame = frame;
        }

        graphics.blit(
                RenderPipelines.GUI_TEXTURED,
                TEXTURE_ID,
                0,
                0,
                0.0F,
                0.0F,
                graphics.guiWidth(),
                graphics.guiHeight(),
                frame.width,
                frame.height,
                frame.width,
                frame.height,
                -1
        );
    }

    public record Frame(int width, int height, int[] pixels) {
    }
}