subframe tick interpollation fix

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

@@ -87,6 +87,11 @@ public abstract class OpenGlFrameCapturer<F extends Frame, D extends CaptureData
     }
 
     protected OpenGlFrame renderFrame(int frameId, float partialTicks, D captureData) {
+        renderWorldOnly(partialTicks, captureData);
+        return captureFrame(frameId, captureData);
+    }
+
+    protected void renderWorldOnly(float partialTicks, D captureData) {
         resizeMainWindow(mc, getFrameWidth(), getFrameHeight());
 
         pushMatrix();
@@ -115,8 +120,6 @@ public abstract class OpenGlFrameCapturer<F extends Frame, D extends CaptureData
         frameBuffer().endWrite();
         //#endif
         popMatrix();
-
-        return captureFrame(frameId, captureData);
     }
 
     protected OpenGlFrame captureFrame(int frameId, D captureData) {

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

@@ -10,11 +10,15 @@ import com.replaymod.pathing.properties.LensProperties;
 
 import com.replaymod.render.RenderSettings;
 import com.replaymod.render.utils.ByteBufferPool;
+import com.replaymod.render.utils.AccumulationBuffer;
 import com.replaymod.replay.ReplayHandler;
 import com.replaymod.replay.ReplayModReplay;
 import com.replaymod.replaystudio.pathing.path.Timeline;
 import com.replaymod.simplepathing.SPTimeline;
 
+import com.replaymod.core.mixin.MinecraftAccessor;
+import com.replaymod.pathing.player.ReplayTimer;
+
 import org.apache.commons.lang3.tuple.Triple;
 
 import java.util.Collections;
@@ -50,7 +54,7 @@ public class RealLensOpenGlFrameCapturer
 
         final float GOLDEN_ANGLE = (float) (Math.PI * (3.0 - Math.sqrt(5.0)));
 
-        float random_offset = (float) Math.sqrt(r*r/n) * 0.5f;
+        float random_offset = (float) Math.sqrt(r*r/n) * 0.0f;
 
         for (int i = 0; i < n; i++) {
             float rr = r * (float) Math.sqrt((float) i / n);
@@ -88,9 +92,29 @@ public class RealLensOpenGlFrameCapturer
         return cameras;
     }
 
+    private static Data singleDiskSample(int i, int n, float focalDistance, float apertureRadius) {
+        final float GOLDEN_ANGLE = (float) (Math.PI * (3.0 - Math.sqrt(5.0)));
+
+        float rr = apertureRadius * (float) Math.sqrt((float) i / n);
+        float t  = i * GOLDEN_ANGLE;
+
+        float dx = rr * (float) Math.cos(t);
+        float dy = rr * (float) Math.sin(t);
+        float dz = 0f;
+
+        Data cam = new Data(dx, dy, dz, 0f, 0f);
+
+        float dirX = -dx, dirY = -dy, dirZ = focalDistance - dz;
+        cam.yaw   = (float) -Math.toDegrees(Math.atan2(dirX, dirZ));
+        cam.pitch = (float)  Math.toDegrees(Math.atan2(dirY, Math.sqrt(dirX * dirX + dirZ * dirZ)));
+        return cam;
+    }
+
     private final Path positionPath;
     private final Timeline timeline;
     private final ReplayHandler replayHandler;
+    private final AccumulationBuffer accum = new AccumulationBuffer();
+    private long lastConsumedTime = -1;
 
     public RealLensOpenGlFrameCapturer(
             WorldRenderer worldRenderer,
@@ -105,68 +129,71 @@ public class RealLensOpenGlFrameCapturer
 
     @Override
     public Map<Channel, RealLensOpenGlFrame> process() {
-        // Продвигает состояние игры к времени ТЕКУЩЕГО выходного кадра
-        // (через onTick -> timeline.applyToGame(videoTime)).
         renderInfo.updateForNextFrame();
         int frameId = framesDone++;
 
         RenderSettings settings = renderInfo.getRenderSettings();
         int   fps     = settings.getFramesPerSecond();
-        int   apertureSamples = settings.getLensBlurSamples();
+        int   N       = Math.max(1, settings.getLensBlurSamples());
-        int   subframes  = Math.max(1, settings.getMotionBlurSubframes());   // M
+        float shutter = settings.getShutterAngle();
-        float shutter    = settings.getShutterAngle();                       // градусы
 
-        double dt = 1000.0 / fps;                          // длительность выходного кадра, мс
+        boolean motionBlur = shutter > 0f;
-        // сколько суб-кадров затвор открыт (округляем до целого)
+        double  dt = 1000.0 / fps;
-        int openCount = Math.max(1, (int) Math.round(subframes * shutter / 360.0));
+        double  shutterFrac = motionBlur ? (shutter / 360.0) : 0.0;
 
         int width  = getFrameWidth();
         int height = getFrameHeight();
-        int bpp    = 4;
-        int totalBytes = width * height * bpp;
 
-        // ОДИН аккумулятор на весь выходной кадр (сырой BGRA-порядок из glReadPixels)
+        // перемешанный апертурный индекс (декорреляция DOF <-> время)
-        long[] accumulator = new long[totalBytes];
+        int[] apertureOrder = new int[N];
-        int totalSamples = 0;
+        for (int i = 0; i < N; i++) apertureOrder[i] = i;
+        for (int i = N - 1; i > 0; i--) {
+            int j = ThreadLocalRandom.current().nextInt(i + 1);
+            int tmp = apertureOrder[i]; apertureOrder[i] = apertureOrder[j]; apertureOrder[j] = tmp;
+        }
 
-        for (int j = 0; j < openCount; j++) {
+        accum.begin(width, height);   // float-FBO нужного размера + очистка в 0
-            // абсолютное время суб-кадра на таймлайне (мс), только вперёд
-            long tSub = (long) (frameId * dt + (j / (double) subframes) * dt);
 
-            // пересэмплить камеру + сущности + FOV/линзу на суб-времени
+        for (int i = 0; i < N; i++) {
+            long tSub;
+            if (motionBlur) {
+                double u = (i + ThreadLocalRandom.current().nextDouble()) / N; // монотонно вперёд
+                tSub = (long) (frameId * dt + u * shutterFrac * dt);
                 timeline.applyToGame(tSub, replayHandler);
-
+            } else {
-            // partialTicks для интерполяции сущностей внутри тика (50 мс)
+                tSub = (long) (frameId * dt);
-            float subPartialTicks = (float) ((tSub % 50L) / 50.0);
-
-            // DOF-параметры берём тоже на суб-времени, чтобы фокус ехал во время смаза
-            float focalDistance  = positionPath.getValue(LensProperties.FOCAL_DISTANCE,  tSub).map(Triple::getLeft).orElse(5.0f);
-            float apertureRadius = positionPath.getValue(LensProperties.APERTURE_RADIUS, tSub).map(Triple::getLeft).orElse(0.05f);
-
-            Data[] cameras = calculateCameras(focalDistance, apertureRadius, apertureSamples);
-
-            for (Data cam : cameras) {
-                OpenGlFrame sub = renderFrame(frameId, subPartialTicks, cam);
-                ByteBuffer buf = sub.getByteBuffer();
-                buf.rewind();
-                for (int i = 0; i < totalBytes; i++) {
-                    accumulator[i] += (buf.get(i) & 0xFF);
             }
-                ByteBufferPool.release(buf);   // сразу освобождаем -> нет OOM
+            long replayTime = replayHandler.getReplaySender().currentTimeStamp();
-                totalSamples++;
+            if (lastConsumedTime < 0) lastConsumedTime = replayTime;
+            int pendingTicks = (int) (replayTime / 50L - lastConsumedTime / 50L);
+            if (pendingTicks > 0) {
+                ReplayTimer timer = (ReplayTimer) ((MinecraftAccessor) mc).getTimer();
+                while (pendingTicks-- > 0) {
+                    mc.tick();              // двигает prev/cur частиц через границу тика
+                    timer.tickDelta -= 1f;  // компенсация: VideoRenderer не должен тикнуть повторно
                 }
             }
+            if (replayTime > lastConsumedTime) lastConsumedTime = replayTime;
+            float subPartialTicks = (float) ((replayTime % 50L) / 50.0);
 
-        // усредняем в один кадр
+            float focal = positionPath.getValue(LensProperties.FOCAL_DISTANCE,  tSub).map(Triple::getLeft).orElse(5.0f);
-        ByteBuffer out = ByteBufferPool.allocate(totalBytes);
+            float apert = positionPath.getValue(LensProperties.APERTURE_RADIUS, tSub).map(Triple::getLeft).orElse(0.05f);
-        for (int i = 0; i < totalBytes; i++) {
+            Data cam = singleDiskSample(apertureOrder[i], N, focal, apert);
-            out.put((byte) (accumulator[i] / totalSamples));
+
+            renderWorldOnly(subPartialTicks, cam);           // мир -> главный FBO, без readback
+            accum.add(frameBuffer().getColorAttachment());   // прибавить на GPU
         }
-        out.rewind();
 
-        OpenGlFrame averaged = new OpenGlFrame(frameId, new Dimension(width, height), bpp, out);
+        ByteBuffer out = accum.finishAveraged(N);            // ОДИН readback + деление на N
-        // Оборачиваем в RealLensOpenGlFrame с ОДНИМ кадром — процессор его пропустит через
+        accum.unbind();                                      // вернуться в главный FBO
-        // openGlBytesToBitmap (flip + swap R/B) и поделит на 1. Результат идентичен старому DOF.
+
+        OpenGlFrame averaged = new OpenGlFrame(frameId, new Dimension(width, height), 4, out);
         return Collections.singletonMap(Channel.BRGA, new RealLensOpenGlFrame(new OpenGlFrame[]{ averaged }));
     }
+
+    @Override
+    public void close() throws java.io.IOException {
+        super.close();
+        accum.close();
+    }
 }

src/main/java/com/replaymod/render/gui/GuiRenderSettings.java

@@ -204,7 +204,6 @@ public class GuiRenderSettings extends AbstractGuiPopup<GuiRenderSettings> {
                             cameraPathExport, new GuiLabel(),
                             new GuiLabel().setI18nText("replaymod.gui.rendersettings.antialiasing"), antiAliasingDropdown,
                             new GuiLabel().setI18nText("replaymod.gui.rendersettings.lensblursamples"), lensBlurSamples,
-                            new GuiLabel().setI18nText("replaymod.gui.rendersettings.motionblursubframes"), motionBlurSubframes,
                             new GuiLabel().setI18nText("replaymod.gui.rendersettings.shutterangle"), shutterAngle));
 
     public final GuiTextField exportCommand = new GuiTextField().setI18nHint("replaymod.gui.rendersettings.command")

src/main/java/com/replaymod/render/utils/AccumulationBuffer.java

@@ -0,0 +1,140 @@
+package com.replaymod.render.utils;
+
+//#if MC<12105
+import com.mojang.blaze3d.systems.RenderSystem;
+import com.mojang.blaze3d.systems.VertexSorter;
+import net.minecraft.client.render.BufferBuilder;
+import net.minecraft.client.render.Tessellator;
+import net.minecraft.client.render.VertexFormats;
+import net.minecraft.client.render.GameRenderer;
+import org.joml.Matrix4f;
+import org.lwjgl.opengl.GL11;
+import org.lwjgl.opengl.GL12;
+import org.lwjgl.opengl.GL30;
+import org.lwjgl.opengl.GL33;
+
+import java.nio.ByteBuffer;
+import java.nio.FloatBuffer;
+
+public class AccumulationBuffer {
+    private int fbo = 0;
+    private int tex = 0;
+    private int width = 0;
+    private int height = 0;
+
+    public void begin(int width, int height) {
+        if (fbo == 0 || width != this.width || height != this.height) {
+            allocate(width, height);
+        }
+        GL30.glBindFramebuffer(GL30.GL_FRAMEBUFFER, fbo);
+        GL11.glViewport(0, 0, width, height);
+        GL11.glClearColor(0f, 0f, 0f, 0f);
+        GL11.glClear(GL11.GL_COLOR_BUFFER_BIT);
+    }
+
+    private void allocate(int width, int height) {
+        close();
+        this.width = width;
+        this.height = height;
+
+        // Сырые GL-вызовы не обновляют кэш GlStateManager -> сохраняем и
+        // возвращаем привязки, иначе MC пропустит ребинд (текстура неба и т.п.).
+        int prevTex = GL11.glGetInteger(GL11.GL_TEXTURE_BINDING_2D);
+        int prevFbo = GL11.glGetInteger(GL30.GL_FRAMEBUFFER_BINDING);
+
+        tex = GL11.glGenTextures();
+        GL11.glBindTexture(GL11.GL_TEXTURE_2D, tex);
+        GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MIN_FILTER, GL11.GL_NEAREST);
+        GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MAG_FILTER, GL11.GL_NEAREST);
+        GL11.glTexImage2D(GL11.GL_TEXTURE_2D, 0, GL30.GL_RGBA32F, width, height, 0,
+                GL11.GL_RGBA, GL11.GL_FLOAT, (ByteBuffer) null);
+
+        fbo = GL30.glGenFramebuffers();
+        GL30.glBindFramebuffer(GL30.GL_FRAMEBUFFER, fbo);
+        GL30.glFramebufferTexture2D(GL30.GL_FRAMEBUFFER, GL30.GL_COLOR_ATTACHMENT0,
+                GL11.GL_TEXTURE_2D, tex, 0);
+
+        GL11.glBindTexture(GL11.GL_TEXTURE_2D, prevTex);
+        GL30.glBindFramebuffer(GL30.GL_FRAMEBUFFER, prevFbo);
+    }
+
+    public void add(int srcColorTex) {
+        GL30.glBindFramebuffer(GL30.GL_FRAMEBUFFER, fbo);
+        GL11.glViewport(0, 0, width, height);
+
+        RenderSystem.disableDepthTest();
+        RenderSystem.depthMask(false);
+        RenderSystem.enableBlend();
+        RenderSystem.blendFunc(GL11.GL_ONE, GL11.GL_ONE);
+        RenderSystem.setShaderColor(1f, 1f, 1f, 1f);
+
+        Matrix4f savedProj = RenderSystem.getProjectionMatrix();
+        VertexSorter savedSorter = RenderSystem.getVertexSorting();
+        RenderSystem.setProjectionMatrix(new Matrix4f(), VertexSorter.BY_Z);
+        RenderSystem.getModelViewStack().push();
+        RenderSystem.getModelViewStack().loadIdentity();
+        RenderSystem.applyModelViewMatrix();
+
+        RenderSystem.setShader(GameRenderer::getPositionTexProgram);
+        RenderSystem.setShaderTexture(0, srcColorTex);
+
+        int prevTex = GL11.glGetInteger(GL11.GL_TEXTURE_BINDING_2D);
+        GL11.glBindTexture(GL11.GL_TEXTURE_2D, srcColorTex);
+        GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL33.GL_TEXTURE_SWIZZLE_A, GL11.GL_ONE);
+        GL11.glBindTexture(GL11.GL_TEXTURE_2D, prevTex);
+
+        Tessellator tessellator = Tessellator.getInstance();
+        BufferBuilder bb = tessellator.getBuffer();
+        bb.begin(GL11.GL_QUADS, VertexFormats.POSITION_TEXTURE);
+        bb.vertex(-1f, -1f, 0f).texture(0f, 0f).next();
+        bb.vertex( 1f, -1f, 0f).texture(1f, 0f).next();
+        bb.vertex( 1f,  1f, 0f).texture(1f, 1f).next();
+        bb.vertex(-1f,  1f, 0f).texture(0f, 1f).next();
+        tessellator.draw();
+
+        prevTex = GL11.glGetInteger(GL11.GL_TEXTURE_BINDING_2D);
+        GL11.glBindTexture(GL11.GL_TEXTURE_2D, srcColorTex);
+        GL11.glTexParameteri(GL11.GL_TEXTURE_2D, GL33.GL_TEXTURE_SWIZZLE_A, GL11.GL_ALPHA);
+        GL11.glBindTexture(GL11.GL_TEXTURE_2D, prevTex);
+
+        RenderSystem.getModelViewStack().pop();
+        RenderSystem.applyModelViewMatrix();
+        RenderSystem.setProjectionMatrix(savedProj, savedSorter);
+        RenderSystem.disableBlend();
+        RenderSystem.depthMask(true);
+        RenderSystem.enableDepthTest();
+
+        RenderSystem.defaultBlendFunc();
+    }
+
+    public ByteBuffer finishAveraged(int samples) {
+        GL30.glBindFramebuffer(GL30.GL_FRAMEBUFFER, fbo);
+
+        int pixels = width * height;
+        FloatBuffer fb = org.lwjgl.BufferUtils.createFloatBuffer(pixels * 4);
+        GL11.glReadPixels(0, 0, width, height, GL12.GL_BGRA, GL11.GL_FLOAT, fb);
+
+        ByteBuffer out = ByteBufferPool.allocate(pixels * 4);
+        float inv = 1f / samples;
+        for (int i = 0; i < pixels * 4; i++) {
+            float v = fb.get(i) * inv;
+            int b = (int) (v * 255f + 0.5f);
+            if (b < 0) b = 0; else if (b > 255) b = 255;
+            out.put((byte) b);
+        }
+        out.rewind();
+        return out;
+    }
+
+    public void unbind() {
+        net.minecraft.client.MinecraftClient.getInstance().getFramebuffer().beginWrite(true);
+    }
+
+    public void close() {
+        if (fbo != 0) { GL30.glDeleteFramebuffers(fbo); fbo = 0; }
+        if (tex != 0) { GL11.glDeleteTextures(tex); tex = 0; }
+    }
+}
+//#else
+//$$ // TODO: путь под MC>=12105 (GpuDevice/CommandEncoder) — заполнить позже.
+//#endif