rt64.patch

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 79dfc38..6467e67 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -327,6 +327,7 @@ set (SOURCES
     "${PROJECT_SOURCE_DIR}/src/gbi/rt64_gbi_f3d.cpp"
     "${PROJECT_SOURCE_DIR}/src/gbi/rt64_gbi_f3dex.cpp"
     "${PROJECT_SOURCE_DIR}/src/gbi/rt64_gbi_f3dex2.cpp"
+    "${PROJECT_SOURCE_DIR}/src/gbi/rt64_gbi_f3dex2cbfd.cpp"
     "${PROJECT_SOURCE_DIR}/src/gbi/rt64_gbi_f3dgolden.cpp"
     "${PROJECT_SOURCE_DIR}/src/gbi/rt64_gbi_f3dpd.cpp"
     "${PROJECT_SOURCE_DIR}/src/gbi/rt64_gbi_f3dwave.cpp"
@@ -359,6 +360,7 @@ set (SOURCES
     "${PROJECT_SOURCE_DIR}/src/hle/rt64_projection.cpp"
     "${PROJECT_SOURCE_DIR}/src/hle/rt64_rdp.cpp"
     "${PROJECT_SOURCE_DIR}/src/hle/rt64_rdp_tmem.cpp"
+    "${PROJECT_SOURCE_DIR}/src/hle/rt64_rice_hash.cpp"
     "${PROJECT_SOURCE_DIR}/src/hle/rt64_rigid_body.cpp"
     "${PROJECT_SOURCE_DIR}/src/hle/rt64_rsp.cpp"
     "${PROJECT_SOURCE_DIR}/src/hle/rt64_state.cpp"
@@ -518,6 +520,7 @@ build_compute_shader(rt64 "src/shaders/FbWriteDepthCS.hlsl")
 build_compute_shader(rt64 "src/shaders/FbWriteDepthCS.hlsl" "src/shaders/FbWriteDepthCSMS.hlsl" "-D MULTISAMPLING")
 build_compute_shader(rt64 "src/shaders/GaussianFilterRGB3x3CS.hlsl")
 build_compute_shader(rt64 "src/shaders/BoxFilterCS.hlsl")
+build_compute_shader(rt64 "src/shaders/ConkerBlurCS.hlsl")
 build_compute_shader(rt64 "src/shaders/BicubicScalingCS.hlsl")
 build_compute_shader(rt64 "src/shaders/HistogramAverageCS.hlsl")
 build_compute_shader(rt64 "src/shaders/HistogramClearCS.hlsl")
diff --git a/include/rt64_extended_gbi.h b/include/rt64_extended_gbi.h
index d387090..094290e 100644
--- a/include/rt64_extended_gbi.h
+++ b/include/rt64_extended_gbi.h
@@ -80,7 +80,9 @@
 #define G_EX_SETVERTEXSEGMENT_V1        0x000031
 #define G_EX_SETTEXCOORDWRAPPOINT_V1    0x000032
 #define G_EX_SETRECTASPECT_V1           0x000033
-#define G_EX_MAX                        0x000034
+#define G_EX_CONKERBLURFRAMEBUFFER_V1   0x000034 // Conker: see gEXConkerBlurFramebuffer
+#define G_EX_CONKERFOCUSPLACED_V1       0x000035 // Conker: see gEXConkerFocusPlaced
+#define G_EX_MAX                        0x000036
 
 #define G_EX_ORIGIN_NONE            0x800
 #define G_EX_ORIGIN_LEFT            0x0
@@ -113,6 +115,9 @@
 #define G_EX_ASPECT_AUTO            0x0
 #define G_EX_ASPECT_STRETCH         0x1
 #define G_EX_ASPECT_ADJUST          0x2
+// Stretched to the width like G_EX_ASPECT_STRETCH, and scaled as much vertically about the
+// middle of the scissor, keeping the rect's proportions (its top and bottom are cropped).
+#define G_EX_ASPECT_ZOOM            0x3
 
 #define G_EX_VERTEX_POSITION        0x0
 #define G_EX_VERTEX_VELOCITY        0x1
@@ -579,4 +584,30 @@ typedef union {
         PARAM(aspect, 2, 0) \
     )
 
+// Conker: once the frame's last framebuffer pair drawing into the color image at address (24 bits) is drawn, its high
+// resolution picture is blurred, by strength (8 bits) quarters of an N64 pixel. A copy of the frame blurred this way
+// stays as sharp as the high resolution picture and as wide as the widened view: the pause menu's background (Conker's
+// own blurs its copy on the CPU, in RDRAM, where it's the N64's 320 pixels and only the 4:3 view).
+#define gEXConkerBlurFramebuffer(cmd, address, strength) \
+    G_EX_COMMAND1(cmd, \
+        PARAM(RT64_EXTENDED_OPCODE, 8, 24) | PARAM(G_EX_CONKERBLURFRAMEBUFFER_V1, 24, 0), \
+        PARAM(strength, 8, 24) | PARAM(address, 24, 0) \
+    )
+
+// Conker: netplay's "my view only" redraws each shown view elsewhere in the frame and moves its rectangles with it
+// (rt64_conker_view_focus.h). Some 2D of a view can't simply be moved: the bazooka's tinted copy of the frame, strips
+// copied from where the view is drawn. The display list gives it twice: placed for each place the view may be drawn,
+// and as the game draws it. Until mode 0 (or a display list starts), the rectangles that follow are:
+// - mode 1, placed: for the view at x, y (pixels of the frame, where the game draws it), drawn where it is drawn at
+//   `layouts` (one bit: G_EX_CONKER_FOCUS_WHOLE, _TOP or _BOTTOM). Drawn as they are, only while it's drawn there.
+// - mode 2, the game's own: drawn as ever, unless the view at x, y is drawn at one of `layouts` (bits), the placed ones.
+#define G_EX_CONKER_FOCUS_WHOLE     0x1
+#define G_EX_CONKER_FOCUS_TOP       0x2
+#define G_EX_CONKER_FOCUS_BOTTOM    0x4
+#define gEXConkerFocusPlaced(cmd, mode, layouts, x, y) \
+    G_EX_COMMAND1(cmd, \
+        PARAM(RT64_EXTENDED_OPCODE, 8, 24) | PARAM(G_EX_CONKERFOCUSPLACED_V1, 24, 0), \
+        PARAM(mode, 2, 30) | PARAM(layouts, 3, 24) | PARAM(x, 10, 8) | PARAM(y, 8, 0) \
+    )
+
 #endif // RT64_EXTENDED_GBI
diff --git a/src/common/rt64_common.h b/src/common/rt64_common.h
index f79adbf..e40a61d 100644
--- a/src/common/rt64_common.h
+++ b/src/common/rt64_common.h
@@ -70,6 +70,18 @@ namespace RT64 {
         int x, y, w, h;
     };
 
+    // How far (10.2 fixed point) a projection's scissor may fall short of its framebuffer pair's scissor on each
+    // side and still count as covering the whole width, for the widescreen viewport and projection adjustment.
+    // Conker's 3D scissor stops 2 pixels short of each edge of the frame, and a full-frame rectangle drawn in the
+    // same pair would otherwise put its 3D back in the 4:3 area.
+    constexpr int32_t CoversWidthSlack = 4 * 4;
+
+    // The same for a 3D view's viewport, which may fall further short: Conker's split-screen multiplayer draws each
+    // player's view 32 pixels in from each edge, and the top view shares its pair with full-frame drawing, so with
+    // the rects' slack only the bottom view was widened. Rects keep the smaller slack, so 2D a little inside the
+    // frame isn't stretched to the widened edges.
+    constexpr int32_t CoversWidthViewportSlack = 40 * 4;
+
     struct FixedRect {
         int32_t ulx;
         int32_t uly;
diff --git a/src/common/rt64_conker_view_focus.h b/src/common/rt64_conker_view_focus.h
new file mode 100644
index 0000000..168a50c
--- /dev/null
+++ b/src/common/rt64_conker_view_focus.h
@@ -0,0 +1,195 @@
+//
+// RT64
+//
+
+// Conker: netplay's "my view only", drawn anew (the host's netplay/view.cpp). While it's on, this machine's players'
+// views of the split screen are each drawn across a part of the frame of their own instead of their part of the
+// split, and the other views aren't drawn: one player's view across the whole frame, two players' views across the
+// top and bottom halves. Each view's viewport and scissor are moved and stretched with it (RSP::setViewport,
+// RDP::setScissor; a smaller one inside the view goes to the same place in the stretched view), and its projection
+// is scaled by as much as the stretch isn't uniform (ProjectionProcessor), so nothing is stretched: a view made
+// relatively taller shows more of the scene up and down, one made relatively wider more of it across. The widescreen
+// widening then widens each like any view across the frame's width. The other views' viewports are collapsed to
+// nothing and their scissors emptied, which also leaves out their 2D. Rectangles in pixels of the frame, which is
+// frameWidth by frameHeight. Only the renderer changes: the game's memory doesn't (its Render to RAM is off in
+// netplay), so it can't desync.
+
+#pragma once
+
+#include <algorithm>
+#include <cmath>
+
+#include "common/rt64_common.h"
+
+
+namespace RT64 {
+    // One focused view: where the game draws it (src), and where it's drawn instead.
+    struct ConkerFocusView {
+        float srcLeft = 0.0f, srcTop = 0.0f, srcRight = 0.0f, srcBottom = 0.0f;
+        float left = 0.0f, top = 0.0f, right = 0.0f, bottom = 0.0f;
+    };
+
+    constexpr int ConkerMaxFocusViews = 2;
+
+    struct ConkerViewFocus {
+        bool on = false;
+        int count = 0;
+        ConkerFocusView views[ConkerMaxFocusViews];
+        float frameWidth = 0.0f, frameHeight = 0.0f;
+        uint32_t ownImages[2] = {};
+    };
+
+    // Set by the game's host each frame (defined in rt64_vi_renderer.cpp): `count` views (1 or 2), each 8 floats in
+    // `rects`, its rectangle in the split then where it's drawn (left, top, right, bottom). ownImages: the
+    // addresses of two images as wide as the frame that aren't it (0 for none), the game's own copies of it (the
+    // pause menu's picture, which is also the depth image: its clear covers the whole frame, left alone anyway).
+    void setViewFocusRedraw(bool on, int count, const float *rects, float frameWidth, float frameHeight,
+        uint32_t ownImage0, uint32_t ownImage1);
+    ConkerViewFocus conkerViewFocus();
+
+    // Whether the focus applies to what's drawn now: only to the frame itself, an image as wide as the frame.
+    // The game also draws into small images of its own (a shadow's silhouette, 64 pixels wide), which the
+    // frame's views have nothing to do with, and into copies of the frame as wide as it (the pause menu's
+    // picture: tiles of the frame across all of it, which moved with the views, or left out, left the picture
+    // as it was in memory, stripes of colour behind the menu).
+    inline bool conkerFocusApplies(const ConkerViewFocus &f, uint16_t colorImageWidth, uint32_t colorImageAddress) {
+        if (!f.on || (f.count <= 0) || (f.frameWidth <= 0.0f) || (colorImageWidth != uint16_t(f.frameWidth))) {
+            return false;
+        }
+        for (uint32_t image : f.ownImages) {
+            if ((image != 0) && ((image & 0x00FFFFFF) == (colorImageAddress & 0x00FFFFFF))) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    // A point of a focused view, where it goes in the frame: the view stretched to where it's drawn.
+    inline float conkerMapX(const ConkerFocusView &v, float x) { return v.left + (x - v.srcLeft) * (v.right - v.left) / (v.srcRight - v.srcLeft); }
+    inline float conkerMapY(const ConkerFocusView &v, float y) { return v.top + (y - v.srcTop) * (v.bottom - v.top) / (v.srcBottom - v.srcTop); }
+
+    // How much a focused view's projection is scaled across and down so what's drawn keeps its shape, from how much
+    // more it's stretched across than down (k). Alone across the frame it keeps its width of the scene and is made
+    // taller or shorter by k (a 2-player half, 1.26 / 2.04, about 0.62: more of the scene up and down; a quarter,
+    // about 1: unchanged). With two views, one made relatively wider (a quarter across half the frame, 2.04 / 1.0) is
+    // met halfway (`halfway`): by the square root of k across and down, more of the scene across and less up and
+    // down, rather than a band cut from the middle of it or a view twice as wide (which the widescreen widening
+    // would make wider again).
+    inline void conkerFocusScale(const ConkerFocusView &v, bool halfway, float &xScale, float &yScale) {
+        const float stretchX = (v.right - v.left) / (v.srcRight - v.srcLeft);
+        const float stretchY = (v.bottom - v.top) / (v.srcBottom - v.srcTop);
+        const float k = stretchX / stretchY;
+        if (!std::isfinite(k) || (k <= 0.0f) || (k <= 1.0f) || !halfway) {
+            xScale = 1.0f;
+            yScale = std::isfinite(k) && (k > 0.0f) ? k : 1.0f;
+            return;
+        }
+
+        const float root = std::sqrt(k);
+        xScale = 1.0f / root;
+        yScale = root;
+    }
+
+    // Where a rectangle (in pixels) stands: the whole frame (left alone), a focused view (`index`: moved with it),
+    // or another view (not drawn). Judged by its middle, so a view's own slightly different edges match.
+    enum class ConkerViewPart { Whole, Focused, Other };
+
+    inline ConkerViewPart conkerViewPart(const ConkerViewFocus &f, float left, float top, float right, float bottom, int &index, float slack = 0.0f) {
+        if (((right - left) >= 0.9f * f.frameWidth) && ((bottom - top) >= 0.9f * f.frameHeight)) {
+            return ConkerViewPart::Whole;
+        }
+        const float middleX = (left + right) / 2.0f;
+        const float middleY = (top + bottom) / 2.0f;
+        for (int i = 0; i < f.count; i++) {
+            const ConkerFocusView &v = f.views[i];
+            if ((middleX >= v.srcLeft - slack) && (middleX <= v.srcRight + slack) && (middleY >= v.srcTop - slack) && (middleY <= v.srcBottom + slack)) {
+                index = i;
+                return ConkerViewPart::Focused;
+            }
+        }
+        return ConkerViewPart::Other;
+    }
+
+    // Whether the focused view at x, y (pixels of the frame, where the game draws it) is drawn at one of `layouts`
+    // (gEXConkerFocusPlaced's bits): alone, across the whole frame (1); or the first of two, the top half (2); or
+    // the second, the bottom half (4).
+    inline bool conkerViewDrawnAt(const ConkerViewFocus &f, float x, float y, uint8_t layouts) {
+        int index = 0;
+        if (conkerViewPart(f, x, y, x, y, index) != ConkerViewPart::Focused) {
+            return false;
+        }
+        const uint8_t layout = (f.count == 1) ? 0x1 : (index == 0) ? 0x2 : 0x4;
+        return (layouts & layout) != 0;
+    }
+
+    // A rectangle of the frame's 2D (quarter pixels), moved with its focused view: false if it isn't drawn. Only moved,
+    // never scaled: the game draws a split screen's 2D at full size.
+    // - At the line between the top and bottom views (within 3 pixels of it): shared by the views. With one view
+    //   focused it's moved down to the bottom of the frame, all of it by as much so it keeps together: the match timer
+    //   in the middle of the frame, War's and Beach's team scores beside it, Heist's row of every player's $$$. With
+    //   two it stays on the line, which is where the two halves meet.
+    // - Its middle outside the focused views: another's, left out (a piece on the line between views belongs to the
+    //   one its middle is in, as Heist's $$$ rows).
+    // - Covering most of its view in fill mode (its clears, color and depth): all of where the view is drawn.
+    // - Otherwise its view's: moved as far as the view's nearest edges move, across and down. Its middle in the
+    //   first 30% of the view's width goes with the left edge, past 70% with the right, otherwise with the middle
+    //   (wide, so centered text such as "0 (1st)" moves whole); the same down. Kept inside where the view is drawn.
+    inline bool conkerMoveRect(const ConkerViewFocus &f, bool fillMode, FixedRect &rect) {
+        const float left = rect.ulx / 4.0f, top = rect.uly / 4.0f, right = rect.lrx / 4.0f, bottom = rect.lry / 4.0f;
+        if ((right - left >= 0.9f * f.frameWidth) && (bottom - top >= 0.9f * f.frameHeight)) {
+            return true;
+        }
+        const float splitLine = f.frameHeight / 2.0f;
+        const bool split = (f.views[0].srcBottom - f.views[0].srcTop) < 0.75f * f.frameHeight;
+        float moveX = 0.0f, moveY = 0.0f;
+        const float nearLine = 3.0f;
+        int index = 0;
+        if (split && (top < splitLine + nearLine) && (bottom > splitLine - nearLine)) {
+            if (f.count == 1) {
+                const float margin = 6.0f;
+                const float sharedHalfHeight = 6.0f;
+                moveY = (f.frameHeight - margin) - (splitLine + sharedHalfHeight);
+            }
+        }
+        else if (conkerViewPart(f, left, top, right, bottom, index, 1.0f) != ConkerViewPart::Focused) {
+            return false;
+        }
+        else {
+            const ConkerFocusView &v = f.views[index];
+            const float viewWidth = v.srcRight - v.srcLeft;
+            const float viewHeight = v.srcBottom - v.srcTop;
+            if (fillMode && (right - left >= 0.8f * viewWidth) && (bottom - top >= 0.8f * viewHeight)) {
+                rect.ulx = int32_t(v.left * 4.0f);
+                rect.uly = int32_t(v.top * 4.0f);
+                rect.lrx = int32_t(v.right * 4.0f);
+                rect.lry = int32_t(v.bottom * 4.0f);
+                return true;
+            }
+
+            auto edgeMove = [](float middle, float srcStart, float srcEnd, float start, float end) {
+                const float share = (middle - srcStart) / (srcEnd - srcStart);
+                if (share < 0.3f) return start - srcStart;
+                if (share > 0.7f) return end - srcEnd;
+                return (start + end) / 2.0f - (srcStart + srcEnd) / 2.0f;
+            };
+            moveX = edgeMove((left + right) / 2.0f, v.srcLeft, v.srcRight, v.left, v.right);
+            moveY = edgeMove((top + bottom) / 2.0f, v.srcTop, v.srcBottom, v.top, v.bottom);
+            // Kept inside where the view is drawn (a piece hanging over the view's edge would go past it), where it
+            // fits in it at all.
+            const float inset = 2.0f;
+            if ((right - left) <= (v.right - v.left) - 2.0f * inset) {
+                moveX = std::clamp(moveX, (v.left + inset) - left, (v.right - inset) - right);
+            }
+            if ((bottom - top) <= (v.bottom - v.top) - 2.0f * inset) {
+                moveY = std::clamp(moveY, (v.top + inset) - top, (v.bottom - inset) - bottom);
+            }
+        }
+        const int32_t dx = int32_t(std::lround(moveX * 4.0f));
+        const int32_t dy = int32_t(std::lround(moveY * 4.0f));
+        rect.ulx += dx;
+        rect.lrx += dx;
+        rect.uly += dy;
+        rect.lry += dy;
+        return true;
+    }
+};
diff --git a/src/common/rt64_fblog.h b/src/common/rt64_fblog.h
new file mode 100644
index 0000000..c9dd621
--- /dev/null
+++ b/src/common/rt64_fblog.h
@@ -0,0 +1,80 @@
+//
+// RT64
+//
+
+// TEMP-DEBUG (Conker): a log of what happens to framebuffers, depth and widening, for the
+// widescreen door clipping. Off unless CONKER_RT64_FBLOG is set. It then logs 2 frames out of
+// every 150 (about every 5 seconds), 40 times, to rt64_fb_log.txt in the working directory.
+// Frames are workload submission frames: the same number on the game's side (hle) and on the
+// renderer's side, which run on different threads.
+
+#pragma once
+
+#include <cstdarg>
+#include <cstdint>
+#include <cstdio>
+#include <cstdlib>
+#include <mutex>
+
+namespace RT64 {
+    namespace FbLog {
+        constexpr uint64_t Period = 150;
+        constexpr uint64_t FramesPerCapture = 2;
+        constexpr uint64_t Captures = 40;
+
+        inline bool enabled() {
+            static const bool on = (std::getenv("CONKER_RT64_FBLOG") != nullptr);
+            return on;
+        }
+
+        inline bool frameLogged(uint64_t frame) {
+            return enabled() && ((frame % Period) < FramesPerCapture) && ((frame / Period) < Captures);
+        }
+
+        // The frame being processed on this thread, for code that doesn't know its workload.
+        inline uint64_t &threadFrame() {
+            thread_local uint64_t frame = UINT64_MAX;
+            return frame;
+        }
+
+        // Which side this thread is: "hle" (the game's display lists, and the native render to
+        // RDRAM) or "hires" (the widened picture on screen).
+        inline const char *&threadSide() {
+            thread_local const char *side = "?";
+            return side;
+        }
+
+        inline void setThreadFrame(uint64_t frame, const char *side = nullptr) {
+            threadFrame() = frame;
+            if (side != nullptr) {
+                threadSide() = side;
+            }
+        }
+
+        inline bool threadActive() {
+            return (threadFrame() != UINT64_MAX) && frameLogged(threadFrame());
+        }
+
+        inline void print(const char *fmt, ...) {
+            static std::mutex mutex;
+            static FILE *file = nullptr;
+            std::lock_guard<std::mutex> lock(mutex);
+            if (file == nullptr) {
+                file = std::fopen("rt64_fb_log.txt", "w");
+                if (file == nullptr) {
+                    return;
+                }
+            }
+
+            va_list args;
+            va_start(args, fmt);
+            std::vfprintf(file, fmt, args);
+            va_end(args);
+            std::fputc('\n', file);
+            std::fflush(file);
+        }
+    };
+};
+
+#define RT64_FBLOG_RECT(r) (r).ulx, (r).uly, (r).lrx, (r).lry
+#define RT64_FBLOG_RECT_FMT "(%d,%d)-(%d,%d)"
diff --git a/src/common/rt64_hlslpp.h b/src/common/rt64_hlslpp.h
index 1450565..032ed28 100644
--- a/src/common/rt64_hlslpp.h
+++ b/src/common/rt64_hlslpp.h
@@ -10,4 +10,8 @@
 #define HLSLPP_SCALAR
 #endif
 
+// The scalar implementation uses labs() without including <stdlib.h>, which recent
+// macOS SDKs no longer bring in through <math.h>.
+#include <stdlib.h>
+
 #include "hlsl++.h"
\ No newline at end of file
diff --git a/src/common/rt64_replacement_database.cpp b/src/common/rt64_replacement_database.cpp
index 9f331c9..1d3f107 100644
--- a/src/common/rt64_replacement_database.cpp
+++ b/src/common/rt64_replacement_database.cpp
@@ -145,7 +145,7 @@ namespace RT64 {
         }
     }
     
-    void ReplacementDatabase::resolvePaths(const FileSystem *fileSystem, uint32_t fileSystemIndex, std::unordered_map<uint64_t, ReplacementResolvedPath> &resolvedPathMap, bool onlyDDS, std::vector<uint64_t> *hashesMissing, std::unordered_set<std::string> *pathsToPreload) {
+    void ReplacementDatabase::resolvePaths(const FileSystem *fileSystem, uint32_t fileSystemIndex, std::unordered_map<uint64_t, ReplacementResolvedPath> &resolvedPathMap, bool onlyDDS, std::vector<uint64_t> *hashesMissing, std::unordered_set<std::string> *pathsToPreload, std::unordered_map<std::string, ReplacementResolvedPath> *ricePathMap) {
         std::unordered_map<std::string, std::string> autoPathMap;
         for (const std::string &relativePath : *fileSystem) {
             const std::filesystem::path relativePathFs = std::filesystem::u8path(relativePath);
@@ -172,6 +172,19 @@ namespace RT64 {
             }
         }
 
+        if ((ricePathMap != nullptr) && (config.autoPath == ReplacementAutoPath::Rice)) {
+            const ReplacementTexture defaultTexture;
+            for (const auto &[riceHash, relativePath] : autoPathMap) {
+                ReplacementResolvedPath &resolvedPath = (*ricePathMap)[riceHash];
+                resolvedPath.fileSystemIndex = fileSystemIndex;
+                resolvedPath.relativePath = relativePath;
+                resolvedPath.originalOperation = defaultTexture.operation;
+                resolvedPath.originalShift = defaultTexture.shift;
+                resolvedPath.resolvedOperation = resolveOperation(relativePath, defaultTexture.operation);
+                resolvedPath.resolvedShift = resolveShift(relativePath, defaultTexture.shift);
+            }
+        }
+
         auto addResolvedPath = [&](uint64_t hash, const std::string &relativePath, ReplacementOperation operation, ReplacementShift shift) {
             // Do not modify the entry if it's already in the map.
             if (resolvedPathMap.find(hash) != resolvedPathMap.end()) {
diff --git a/src/common/rt64_replacement_database.h b/src/common/rt64_replacement_database.h
index 3f74ea2..3988595 100644
--- a/src/common/rt64_replacement_database.h
+++ b/src/common/rt64_replacement_database.h
@@ -126,7 +126,9 @@ namespace RT64 {
         void buildHashMaps();
         ReplacementOperation resolveOperation(const std::string &relativePath, ReplacementOperation operation);
         ReplacementShift resolveShift(const std::string &relativePath, ReplacementShift shift);
-        void resolvePaths(const FileSystem *fileSystem, uint32_t fileSystemIndex, std::unordered_map<uint64_t, ReplacementResolvedPath> &resolvedPathMap, bool onlyDDS, std::vector<uint64_t> *hashesMissing = nullptr, std::unordered_set<std::string> *pathsToPreload = nullptr);
+        // With ricePathMap, a database whose auto path is Rice also gives each file found by its Rice hash, resolved as an
+        // entry without a path would be: for textures matched by their Rice hash as they're loaded (hle/rt64_rice_hash.h).
+        void resolvePaths(const FileSystem *fileSystem, uint32_t fileSystemIndex, std::unordered_map<uint64_t, ReplacementResolvedPath> &resolvedPathMap, bool onlyDDS, std::vector<uint64_t> *hashesMissing = nullptr, std::unordered_set<std::string> *pathsToPreload = nullptr, std::unordered_map<std::string, ReplacementResolvedPath> *ricePathMap = nullptr);
         void resolveOperations(std::unordered_map<uint64_t, ReplacementResolvedPath> &resolvedPathMap);
         void resolveShifts(std::unordered_map<uint64_t, ReplacementResolvedPath> &resolvedPathMap);
         static uint64_t stringToHash(const std::string &str);
diff --git a/src/gbi/rt64_gbi.cpp b/src/gbi/rt64_gbi.cpp
index 7006549..4984e7c 100644
--- a/src/gbi/rt64_gbi.cpp
+++ b/src/gbi/rt64_gbi.cpp
@@ -13,6 +13,7 @@
 #include "rt64_gbi_f3dpd.h"
 #include "rt64_gbi_f3dex.h"
 #include "rt64_gbi_f3dex2.h"
+#include "rt64_gbi_f3dex2cbfd.h"
 #include "rt64_gbi_f3dwave.h"
 #include "rt64_gbi_f3dzex2.h"
 #include "rt64_gbi_l3dex2.h"
@@ -110,6 +111,8 @@ namespace RT64 {
     const GBIInstance   F3DLX2_FIFO_2_08_REJ      = { "F3DLX2.fifo 2.08.Rej",                      GBIUCode::F3DEX2,      { true,   false,  true,   false,  false } }; // Needs confirmation.
     const GBIInstance   F3DEX2_FIFO_2_08_CRUISN   = { "F3DEX2.fifo 2.08 (Cruis'n Exotica)",        GBIUCode::Unknown,     { false,  false,  false,  false,  false } }; // Needs confirmation.
     const GBIInstance   F3DEX2_FIFO_2_08_PL       = { "F3DEX2.fifo 2.08 (POSLIGHT)",               GBIUCode::F3DEX2,      { false,  false,  false,  false,  true  } };
+    const GBIInstance   F3DEXBG_NON_FIFO_2_08     = { "F3DEXBG.NoN fifo 2.08 (Conker's Bad Fur Day)", GBIUCode::F3DEX2CBFD, { false,  true,   false,  false,  false } };
+    const GBIInstance   F3DEX_NON_FIFO_2_08_CBFD  = { "F3DEX.NoN fifo 2.08 (Conker's Bad Fur Day)",   GBIUCode::F3DEX2CBFD,   { false,  true,   false,  false,  false } };
     const GBIInstance   F3DEX2_XBUS_2_05          = { "F3DEX2.xbus 2.05",                          GBIUCode::F3DEX2,      { false,  false,  false,  false,  false } }; // Needs confirmation.
     const GBIInstance   F3DEX2_XBUS_2_07          = { "F3DEX2.xbus 2.07",                          GBIUCode::F3DEX2,      { false,  false,  false,  false,  false } }; // Needs confirmation.
     const GBIInstance   F3DLX2_XBUS_2_07_REJ      = { "F3DLX2.xbus 2.07.Rej",                      GBIUCode::F3DEX2,      { true,   false,  true,   false,  false } }; // Needs confirmation.
@@ -160,7 +163,7 @@ namespace RT64 {
     // 
     //                  Length      Hash                    Known instances               
     //     
-    static std::array<GBISegment, 94> textSegments = {
+    static std::array<GBISegment, 96> textSegments = {
             GBISegment{ 0x1408,     0x9C0926F5E466BE70ULL,  { &F3D_SDK_E } }, // Needs confirmation.
             GBISegment{ 0x1400,     0x34EAA6E921BCF1B2ULL,  { &F3D_SDK_F, &F3D_SDK_UNKNOWN_G, &F3D_SDK_UNKNOWN_H } }, // Needs confirmation.
             GBISegment{ 0x1408,     0x3E05E9BBE814C700ULL,  { &F3D_FIFO_SDK_E } }, // Needs confirmation.
@@ -211,6 +214,8 @@ namespace RT64 {
             GBISegment{ 0x1390,     0x0B8FE363267ADCB4ULL,  { &F3DEX2_FIFO_2_06 } },
             GBISegment{ 0x1390,     0x8C1C9814E75E1B4BULL,  { &F3DEX2_FIFO_2_07 } },
             GBISegment{ 0x1390,     0xCF55FAE288BFE48DULL,  { &F3DEX2_FIFO_2_08 } }, // Needs confirmation.
+            GBISegment{ 0x1390,     0xEFF7E499684E95B2ULL,  { &F3DEXBG_NON_FIFO_2_08 } },
+            GBISegment{ 0x1390,     0x5B76BAEB4121C82CULL,  { &F3DEX_NON_FIFO_2_08_CBFD } },
             GBISegment{ 0x1188,     0xB9FBB8E71F72B596ULL,  { &F3DEX2_FIFO_2_08_REJ } }, // Needs confirmation.
             GBISegment{ 0x1188,     0x5235C026EC14B4FBULL,  { &F3DLX2_FIFO_2_08_REJ } }, // Needs confirmation.
             GBISegment{ 0x1378,     0xC2AE06B691610132ULL,  { &F3DEX2_FIFO_2_08_CRUISN } }, // Needs confirmation.
@@ -257,7 +262,7 @@ namespace RT64 {
             GBISegment{ 0x10B0,     0xE8028E4BC6529E6EULL,  { &ZSORTP_0_33 } }, // Needs confirmation.
     };
 
-    static std::array<GBISegment, 105> dataSegments = {
+    static std::array<GBISegment, 107> dataSegments = {
             GBISegment{ 0x800,      0xEEB10D73400213B3ULL,  { &F3D_SDK_E } }, // Needs confirmation.
             GBISegment{ 0x800,      0x49651E384B48F694ULL,  { &F3D_SDK_F } }, // Needs confirmation.
             GBISegment{ 0x800,      0x1A736198F90E81C5ULL,  { &F3D_SDK_UNKNOWN_G } }, // Needs confirmation.
@@ -318,6 +323,8 @@ namespace RT64 {
             GBISegment{ 0x410,      0x47BA278DD7DB79EBULL,  { &F3DLX2_FIFO_2_06_REJ } }, // Needs confirmation.
             GBISegment{ 0x420,      0xF8649121FAB40A06ULL,  { &F3DEX2_FIFO_2_07 } },
             GBISegment{ 0x420,      0x3D4CAB9C82AD3772ULL,  { &F3DEX2_FIFO_2_08 } }, // Needs confirmation.
+            GBISegment{ 0x420,      0xAD59E246BCF1B2C2ULL,  { &F3DEXBG_NON_FIFO_2_08 } },
+            GBISegment{ 0x420,      0xD6FA1415D3E78D13ULL,  { &F3DEX_NON_FIFO_2_08_CBFD } },
             GBISegment{ 0x410,      0x14F9D11C0F58AFB5ULL,  { &F3DEX2_FIFO_2_08_REJ } }, // Needs confirmation.
             GBISegment{ 0x410,      0x25A00931C3C2A573ULL,  { &F3DLX2_FIFO_2_08_REJ } }, // Needs confirmation.
             GBISegment{ 0x420,      0xD381B0139965EE5CULL,  { &F3DEX2_FIFO_2_08_CRUISN } }, // Needs confirmation.
@@ -499,6 +506,9 @@ namespace RT64 {
             case GBIUCode::L3DEX2:
                 GBI_L3DEX2::setup(&gbi);
                 break;
+            case GBIUCode::F3DEX2CBFD:
+                GBI_F3DEX2CBFD::setup(&gbi);
+                break;
             default:
                 assert(false && "Unknown UCode.");
                 break;
diff --git a/src/gbi/rt64_gbi.h b/src/gbi/rt64_gbi.h
index 69c35d2..bcea8ec 100644
--- a/src/gbi/rt64_gbi.h
+++ b/src/gbi/rt64_gbi.h
@@ -28,6 +28,7 @@ namespace RT64 {
         S2DEX,
         S2DEX2,
         L3DEX2,
+        F3DEX2CBFD,
         Count
     };
 
diff --git a/src/gbi/rt64_gbi_extended.cpp b/src/gbi/rt64_gbi_extended.cpp
index 20c0d4d..5f0b85d 100644
--- a/src/gbi/rt64_gbi_extended.cpp
+++ b/src/gbi/rt64_gbi_extended.cpp
@@ -331,6 +331,16 @@ namespace RT64 {
             state->rdp->setRectAspect(aspect);
         }
 
+        void conkerBlurFramebufferV1(State *state, DisplayList **dl) {
+            const uint32_t address = (*dl)->p1(0, 24);
+            const uint8_t strength = (*dl)->p1(24, 8);
+            state->setConkerBlurFramebuffer(address, strength);
+        }
+
+        void conkerFocusPlacedV1(State *state, DisplayList **dl) {
+            state->rdp->setConkerFocusPlaced((*dl)->p1(30, 2), (*dl)->p1(24, 3), (*dl)->p1(8, 10), (*dl)->p1(0, 8));
+        }
+
         void noOpHook(State *state, DisplayList **dl) {
             uint32_t magicNumber = (*dl)->p0(0, 24);
             if (magicNumber == RT64_HOOK_MAGIC_NUMBER) {
@@ -439,6 +449,8 @@ namespace RT64 {
             Map[G_EX_SETVERTEXSEGMENT_V1] = &setVertexSegmentV1;
             Map[G_EX_SETTEXCOORDWRAPPOINT_V1] = &setTexcoordWrapPointV1;
             Map[G_EX_SETRECTASPECT_V1] = &setRectAspectV1;
+            Map[G_EX_CONKERBLURFRAMEBUFFER_V1] = &conkerBlurFramebufferV1;
+            Map[G_EX_CONKERFOCUSPLACED_V1] = &conkerFocusPlacedV1;
             MapInitialized = true;
         }
     }
diff --git a/src/gbi/rt64_gbi_f3dex2cbfd.cpp b/src/gbi/rt64_gbi_f3dex2cbfd.cpp
new file mode 100644
index 0000000..96768bb
--- /dev/null
+++ b/src/gbi/rt64_gbi_f3dex2cbfd.cpp
@@ -0,0 +1,123 @@
+//
+// RT64
+//
+// Conker's Bad Fur Day's modified F3DEX2, based on GLideN64's F3DEX2CBFD.
+// Commands not listed here behave as in F3DEX2.
+//
+
+#include "rt64_gbi_f3dex2cbfd.h"
+
+#include "hle/rt64_interpreter.h"
+
+#include "rt64_f3d.h"
+#include "rt64_gbi_f3dex2.h"
+
+namespace RT64 {
+    namespace GBI_F3DEX2CBFD {
+        // The game's G_LIGHTING and G_TEXTURE_GEN are kept aside: lighting is computed into the
+        // vertex colours on the CPU (RSP::lightVerticesCBFD), so the shaders must not light them
+        // again, and texture generation, which needs the normals the shaders can't see (they're
+        // held apart from the vertices, and the colours hold the lighting), is computed into the
+        // vertices' texture coordinates on the CPU too (RSP::textureGenVerticesCBFD).
+        void geometryMode(State *state, DisplayList **dl) {
+            RSP *rsp = state->rsp.get();
+            const uint32_t offMask = (*dl)->p0(0, 24);
+            const uint32_t onMask = (*dl)->w1;
+            const uint32_t current = rsp->geometryModeStack[rsp->geometryModeStackSize - 1];
+            const uint32_t previous = current | (rsp->cbfd.lighting ? G_LIGHTING : 0) |
+                (rsp->cbfd.textureGen ? G_TEXTURE_GEN : 0) | (rsp->cbfd.textureGenLinear ? G_TEXTURE_GEN_LINEAR : 0);
+            const uint32_t requested = (previous & offMask) | onMask;
+            rsp->cbfd.lighting = (requested & G_LIGHTING) != 0;
+            rsp->cbfd.textureGen = (requested & G_TEXTURE_GEN) != 0;
+            rsp->cbfd.textureGenLinear = (requested & G_TEXTURE_GEN_LINEAR) != 0;
+            rsp->modifyGeometryMode(0, requested & ~(G_LIGHTING | G_TEXTURE_GEN | G_TEXTURE_GEN_LINEAR));
+        }
+
+        void vertex(State *state, DisplayList **dl) {
+            uint8_t vtxCount = (*dl)->p0(12, 8);
+            state->rsp->setVertexCBFD((*dl)->w1, vtxCount, (*dl)->p0(1, 7) - vtxCount);
+        }
+
+        void moveWord(State *state, DisplayList **dl) {
+            switch ((*dl)->p0(16, 8)) {
+            case G_MW_NUMLIGHT:
+                state->rsp->cbfd.lightCount = (*dl)->w1 / 48;
+                break;
+            case F3DEX2CBFD_G_MW_COORD_MOD:
+                state->rsp->setCoordModCBFD((*dl)->w0, (*dl)->w1);
+                break;
+            default:
+                GBI_F3DEX2::moveWord(state, dl);
+                break;
+            }
+        }
+
+        void moveMem(State *state, DisplayList **dl) {
+            switch ((*dl)->p0(0, 8)) {
+            case F3DEX2_G_MV_VIEWPORT:
+                state->rsp->setViewport((*dl)->w1);
+                break;
+            case F3DEX2_G_MV_LIGHT: {
+                const uint32_t offset = (*dl)->p0(5, 14);
+                const uint32_t n = offset / 48;
+                if (n < 2) {
+                    state->rsp->setLookAt(n, (*dl)->w1);
+                }
+                else {
+                    state->rsp->setLightCBFD(n - 2, (*dl)->w1);
+                }
+
+                break;
+            }
+            case F3DEX2CBFD_G_MV_NORMALES:
+                state->rsp->cbfd.normalBase = state->rsp->fromSegmentedMasked((*dl)->w1);
+                break;
+            default:
+                break;
+            }
+        }
+
+        // The microcode reuses G_LOAD_UCODE to switch to its advanced lighting mode.
+        void switchLightingMode(State *state, DisplayList **dl) {
+            state->rsp->cbfd.advancedLighting = true;
+        }
+
+        void tri4(State *state, DisplayList **dl) {
+            const uint32_t w0 = (*dl)->w0;
+            const uint32_t w1 = (*dl)->w1;
+            auto field = [](uint32_t w, uint32_t shift, uint32_t bits) { return (w >> shift) & ((1U << bits) - 1); };
+            const uint32_t v[12] = {
+                field(w0, 23, 5), field(w0, 18, 5), (field(w0, 15, 3) << 2) | field(w1, 30, 2),
+                field(w0, 10, 5), field(w0, 5, 5), field(w0, 0, 5),
+                field(w1, 25, 5), field(w1, 20, 5), field(w1, 15, 5),
+                field(w1, 10, 5), field(w1, 5, 5), field(w1, 0, 5),
+            };
+
+            for (int t = 0; t < 4; t++) {
+                const uint32_t a = v[t * 3 + 0], b = v[t * 3 + 1], c = v[t * 3 + 2];
+                // Unused slots repeat an index.
+                if ((a != b) && (b != c) && (a != c)) {
+                    state->rsp->drawIndexedTri(a, b, c);
+                }
+            }
+        }
+
+        void reset(State *state) {
+            state->rsp->setClipRatioAll(2U);
+            state->rsp->cbfd.advancedLighting = false;
+        }
+
+        void setup(GBI *gbi) {
+            GBI_F3DEX2::setup(gbi);
+            gbi->resetFromTask = &reset;
+            gbi->map[F3DEX2_G_GEOMETRYMODE] = &geometryMode;
+            gbi->map[F3DEX2_G_VTX] = &vertex;
+            gbi->map[F3DEX2_G_MOVEWORD] = &moveWord;
+            gbi->map[F3DEX2_G_MOVEMEM] = &moveMem;
+            gbi->map[F3DEX2_G_LOAD_UCODE] = &switchLightingMode;
+            for (uint32_t i = 0; i < 16; i++) {
+                gbi->map[F3DEX2CBFD_G_TRI4 + i] = &tri4;
+            }
+        }
+    }
+};
diff --git a/src/gbi/rt64_gbi_f3dex2cbfd.h b/src/gbi/rt64_gbi_f3dex2cbfd.h
new file mode 100644
index 0000000..99ef5c2
--- /dev/null
+++ b/src/gbi/rt64_gbi_f3dex2cbfd.h
@@ -0,0 +1,20 @@
+//
+// RT64
+//
+
+#pragma once
+
+#include "rt64_gbi.h"
+
+// Conker's Bad Fur Day's modified F3DEX2: F3DEX2 with a different lighting
+// model (point lights, per-vertex normals held apart from the vertices, a
+// coordinate modifier) and a four-triangle command.
+#define F3DEX2CBFD_G_TRI4 0x10
+#define F3DEX2CBFD_G_MV_NORMALES 14
+#define F3DEX2CBFD_G_MW_COORD_MOD 0x10
+
+namespace RT64 {
+    namespace GBI_F3DEX2CBFD {
+        void setup(GBI *gbi);
+    };
+};
diff --git a/src/hle/rt64_application.cpp b/src/hle/rt64_application.cpp
index ee8bc1f..3e2aa3a 100644
--- a/src/hle/rt64_application.cpp
+++ b/src/hle/rt64_application.cpp
@@ -245,6 +245,11 @@ namespace RT64 {
                         // We don't know yet what driver will fix the issue for RDNA4, so if it's newer than BrokenRDNA4DriverD3D12, we only force Vulkan if it's in Automatic mode.
                         forceVulkanForCompatibility = true;
                     }
+                    else if (device->getCapabilities().uma) {
+                        // Integrated AMD graphics (sharing system memory) crashed at start in D3D12: a Ryzen 5 5560U (Vega) failed to create
+                        // its render targets and upload buffers, and nothing got drawn. Vulkan runs on the same machine, so it's the automatic choice here.
+                        forceVulkanForCompatibility = true;
+                    }
                     else {
                         // Wireframe artifacts have been reported when using a high-precision color format on RDNA3 GPUs in D3D12. The workaround is to switch to Vulkan if this is the case.
                         const bool isRX7 = deviceDescription.name.find("AMD Radeon RX 7") != std::string::npos;
@@ -524,6 +529,10 @@ namespace RT64 {
         state->updateScreen(core.decodeVI(), false);
     }
 
+    void Application::presentAgain() {
+        state->presentAgain();
+    }
+
     void Application::destroyShaderCache() {
         workloadQueue->waitForWorkloadId(state->workloadId);
         presentQueue->waitForPresentId(state->presentId);
diff --git a/src/hle/rt64_application.h b/src/hle/rt64_application.h
index 6c83fe0..8555308 100644
--- a/src/hle/rt64_application.h
+++ b/src/hle/rt64_application.h
@@ -156,6 +156,8 @@ namespace RT64 {
         SetupResult setup(uint32_t threadId);
         void processDisplayLists(uint8_t *memory, uint32_t dlStartAddress, uint32_t dlEndAddress, bool isHLE);
         void updateScreen();
+        // Presents the last frame again, as it is (the UI drawn over it anew), while the game draws none.
+        void presentAgain();
         void destroyShaderCache();
         void updateMultisampling();
         void end();
diff --git a/src/hle/rt64_framebuffer_manager.cpp b/src/hle/rt64_framebuffer_manager.cpp
index d7caa12..2043064 100644
--- a/src/hle/rt64_framebuffer_manager.cpp
+++ b/src/hle/rt64_framebuffer_manager.cpp
@@ -4,6 +4,8 @@
 
 #include "rt64_framebuffer_manager.h"
 
+#include "common/rt64_fblog.h"
+
 #include <cassert>
 #include <algorithm>
 
@@ -91,6 +93,12 @@ namespace RT64 {
         RenderTargetManager &targetManager, const ShaderLibrary *shaderLibrary)
     {
         auto it = framebuffers.find(op.writeChanges.address);
+        if (FbLog::threadActive()) {
+            FbLog::print("[%s %llu] writeChanges (RDRAM upload) to fb 0x%08X: %s", FbLog::threadSide(), (unsigned long long)(FbLog::threadFrame()), op.writeChanges.address,
+                (it == framebuffers.end()) ? "no fb" : ((it->second.lastWriteType == Framebuffer::Type::None) ? "skipped, lastWriteType None" :
+                ((it->second.lastWriteType == Framebuffer::Type::Depth) ? "into the DEPTH target" : "into the color target")));
+        }
+
         if ((it != framebuffers.end()) && (it->second.lastWriteType != Framebuffer::Type::None)) {
             const FramebufferChange *fbChange = fbChangePool.get(op.writeChanges.id);
             assert(fbChange != nullptr);
@@ -174,6 +182,12 @@ namespace RT64 {
                 tileCopy.readDepthFromStorage = true;
             }
         }
+
+        if (FbLog::threadActive()) {
+            FbLog::print("[%s %llu] tileCopy setup id %llu fb 0x%08X (w %u h %u everUsedAsDepth %d) tile (%u,%u)-(%u,%u) -> scaled left %u top %u size %ux%u, rt %ux%u misalign %u, readColorFromStorage %d readDepthFromStorage %d",
+                FbLog::threadSide(), (unsigned long long)(FbLog::threadFrame()), (unsigned long long)(tileCopy.id), fbIt->second.addressStart, fbIt->second.width, fbIt->second.height, fbIt->second.everUsedAsDepth,
+                fbTile.left, fbTile.top, fbTile.right, fbTile.bottom, tileCopy.left, tileCopy.top, tileWidth, tileHeight, rtWidth, rtHeight, rtMisalignX, tileCopy.readColorFromStorage, tileCopy.readDepthFromStorage);
+        }
     }
 
     void FramebufferManager::createTileCopyRecord(RenderWorker *renderWorker, const FramebufferOperation &op, const FramebufferStorage &fbStorage,
@@ -198,6 +212,13 @@ namespace RT64 {
             }
         }
 
+        if (FbLog::threadActive()) {
+            const FixedRect &r = fbIt->second.lastWriteRect;
+            FbLog::print("[%s %llu] tileCopy record id %llu fb 0x%08X lastWriteType %d lastWriteRect " RT64_FBLOG_RECT_FMT " colorTarget %ux%u%s",
+                FbLog::threadSide(), (unsigned long long)(FbLog::threadFrame()), (unsigned long long)(tileCopy.id), fbIt->second.addressStart, int(fbIt->second.lastWriteType), RT64_FBLOG_RECT(r),
+                colorTarget.width, colorTarget.height, (fbIt->second.lastWriteType == Framebuffer::Type::Depth) ? ": copies depth to color, then discards the fb's last write" : "");
+        }
+
         // Copy from depth target if the last write was a depth buffer.
         if (fbIt->second.lastWriteType == Framebuffer::Type::Depth) {
             RenderTargetKey depthTargetKey(fbIt->second.addressStart, fbIt->second.width, fbIt->second.siz, Framebuffer::Type::Depth);
@@ -795,8 +816,10 @@ namespace RT64 {
                 continue;
             }
 
-            // Only reuse exact matches.
-            if ((tileCopy.textureWidth == textureWidth) && (tileCopy.textureHeight == textureHeight)) {
+            // Only reuse exact matches. Compared with the size asked for, unscaled: textureWidth and textureHeight are
+            // scaled by the resolution, so with any scale but 1 they never matched, and a new copy (a texture and a
+            // framebuffer, never freed) was made at every request.
+            if ((tileCopy.requestWidth == textureWidth) && (tileCopy.requestHeight == textureHeight)) {
                 tileCopy.usedWidth = width;
                 tileCopy.usedHeight = height;
                 tileCopy.usedTimestamp = usedTimestamp;
@@ -807,6 +830,8 @@ namespace RT64 {
         // Make a new tile with a new Id.
         TileCopy &tileCopy = tileCopies[++newId];
         tileCopy.id = newId;
+        tileCopy.requestWidth = textureWidth;
+        tileCopy.requestHeight = textureHeight;
         tileCopy.usedWidth = width;
         tileCopy.usedHeight = height;
         tileCopy.usedTimestamp = usedTimestamp;
@@ -908,6 +933,11 @@ namespace RT64 {
         auto it = framebuffers.begin();
         while (it != framebuffers.end()) {
             if ((&it->second != changedFb) && (it->second.overlaps(addressStart, addressEnd))) {
+                if (FbLog::threadActive()) {
+                    FbLog::print("[%s %llu] changeRAM: fb 0x%08X wrote 0x%08X-0x%08X, overlapping fb 0x%08X-0x%08X (w %u h %u), which is marked rdramChanged",
+                        FbLog::threadSide(), (unsigned long long)(FbLog::threadFrame()), changedFb->addressStart, addressStart, addressEnd, it->second.addressStart, it->second.addressEnd, it->second.width, it->second.height);
+                }
+
                 it->second.rdramChanged = true;
             }
 
diff --git a/src/hle/rt64_framebuffer_manager.h b/src/hle/rt64_framebuffer_manager.h
index 8d36b51..fd6cf90 100644
--- a/src/hle/rt64_framebuffer_manager.h
+++ b/src/hle/rt64_framebuffer_manager.h
@@ -85,6 +85,10 @@ namespace RT64 {
             uint32_t usedWidth = 0;
             uint32_t usedHeight = 0;
             uint64_t usedTimestamp = 0;
+            // The size findTileCopyId was asked for, made a multiple as the texture is (unscaled: textureWidth and
+            // textureHeight are the scaled texture's, set when it's made), so a copy can be found again by it.
+            uint32_t requestWidth = 0;
+            uint32_t requestHeight = 0;
             bool ulScaleS = true;
             bool ulScaleT = true;
             interop::uint2 texelShift = { 0, 0 };
diff --git a/src/hle/rt64_framebuffer_pair.cpp b/src/hle/rt64_framebuffer_pair.cpp
index c944393..f611522 100644
--- a/src/hle/rt64_framebuffer_pair.cpp
+++ b/src/hle/rt64_framebuffer_pair.cpp
@@ -69,6 +69,48 @@ namespace RT64 {
         return (gameCallCount == 0) && startFbOperations.empty() && endFbOperations.empty();
     }
     
+    FixedRect FramebufferPair::wideningScissor() const {
+        if (scissorRect.isNull()) {
+            return scissorRect;
+        }
+
+        // The pair's scissor without its projections of fill rects only.
+        FixedRect drawnScissor;
+        drawnScissor.reset();
+        bool fillsLeftOut = false;
+        for (uint32_t p = 0; p < projectionCount; p++) {
+            const Projection &proj = projections[p];
+            if (proj.scissorRect.isNull()) {
+                continue;
+            }
+
+            bool fillsOnly = (proj.type == Projection::Type::Rectangle) && (proj.gameCallCount > 0);
+            for (uint32_t c = 0; fillsOnly && (c < proj.gameCallCount); c++) {
+                fillsOnly = (proj.gameCalls[c].callDesc.otherMode.cycleType() == G_CYC_FILL);
+            }
+
+            if (fillsOnly) {
+                fillsLeftOut = true;
+            }
+            else {
+                drawnScissor.merge(proj.scissorRect);
+            }
+        }
+
+        if (!fillsLeftOut || drawnScissor.isNull()) {
+            return scissorRect;
+        }
+
+        const bool reachesLeft = (drawnScissor.ulx <= scissorRect.ulx + CoversWidthSlack);
+        const bool reachesRight = (drawnScissor.lrx >= scissorRect.lrx - CoversWidthSlack);
+        const bool wideEnough = (int64_t(drawnScissor.lrx - drawnScissor.ulx) * 10) >= (int64_t(scissorRect.lrx - scissorRect.ulx) * 4);
+        if ((reachesLeft != reachesRight) && wideEnough) {
+            return drawnScissor;
+        }
+
+        return scissorRect;
+    }
+
     bool FramebufferPair::earlyPresentCandidate() const {
         // Some games might use screen framebuffers as temporary output for some operations that are clearly
         // not intended to be presented to the user. This function includes some cases commonly found in games.
diff --git a/src/hle/rt64_framebuffer_pair.h b/src/hle/rt64_framebuffer_pair.h
index 60b0fa4..6c80bb6 100644
--- a/src/hle/rt64_framebuffer_pair.h
+++ b/src/hle/rt64_framebuffer_pair.h
@@ -60,5 +60,13 @@ namespace RT64 {
         int changeProjection(uint32_t transformsIndex, Projection::Type type);
         bool isEmpty() const;
         bool earlyPresentCandidate() const;
+
+        // The scissor a viewport is compared with to tell whether it's widened (FramebufferRenderer and
+        // ProjectionProcessor, which must agree). Usually the pair's own. In split screen (Conker, issue #78)
+        // the first player's view shares its pair with the frame's clear, a fill across the whole frame, so
+        // its view didn't cover the pair's scissor and wasn't widened, though the other views (each in a pair
+        // of its own) were. Leaving out projections of fill rects only, the rest's scissor is used when it's a
+        // split-screen view: reaching one side of the frame but not the other, at least 40% of its width.
+        FixedRect wideningScissor() const;
     };
 };
\ No newline at end of file
diff --git a/src/hle/rt64_game_frame.cpp b/src/hle/rt64_game_frame.cpp
index 87392d0..58560a3 100644
--- a/src/hle/rt64_game_frame.cpp
+++ b/src/hle/rt64_game_frame.cpp
@@ -10,6 +10,28 @@
 #include "xxHash/xxh3.h"
 
 namespace RT64 {
+    // Whether two projections are drawn in parts of the frame apart from each other: a split screen's views, each
+    // player's own. Their cameras can be alike (the same projection, the view in the model matrices), and paired with
+    // each other they were drawn from between two players' cameras for a frame, the level culled for one of them.
+    static bool areScissorsApart(const FixedRect &first, const FixedRect &second) {
+        if (first.isNull() || second.isNull()) {
+            return false;
+        }
+
+        return first.intersection(second).isEmpty();
+    }
+
+    // Whether two scenes are drawn in different places, for pairing them with last frame's: apart (above), or one of
+    // them with no scissor at all (a scene that drew nothing scissored) and the other with one. Such a scene was
+    // paired with player 2's last frame before player 2's own was, and player 2's camera jittered between frames.
+    static bool areScenesPlacedApart(const FixedRect &first, const FixedRect &second) {
+        if (first.isNull() != second.isNull()) {
+            return true;
+        }
+
+        return areScissorsApart(first, second);
+    }
+
     // GameFrame
     
     bool GameFrame::areFramebufferPairsCompatible(const WorkloadQueue &workloadQueue, const GameIndices::FramebufferPair &first, const GameIndices::FramebufferPair &second) {
@@ -55,6 +77,10 @@ namespace RT64 {
         const Workload &cmpWorkload = workloadQueue.workloads[firstProj.workloadIndex];
         const FramebufferPair &cmpFbPair = cmpWorkload.fbPairs[firstProj.fbPairIndex];
         const Projection &cmpProj = cmpFbPair.projections[firstProj.projectionIndex];
+        if (areScissorsApart(cmpProj.scissorRect, fbProj.scissorRect)) {
+            return false;
+        }
+
         const interop::float4x4 &cmpViewMatrix = cmpWorkload.drawData.viewTransforms[cmpProj.transformsIndex];
         const interop::float4x4 &fbViewMatrix = workload.drawData.viewTransforms[fbProj.transformsIndex];
         const float viewMatrixDiff = matrixDifference(cmpViewMatrix, fbViewMatrix);
@@ -296,7 +322,11 @@ namespace RT64 {
                 prevWorkloadMap = &prevFrame.frameMap.workloads[workloadMap.prevWorkloadIndex];
             }
 
-            // Match the transforms linearly in the order they were submitted.
+            // Match the transforms linearly in the order they were submitted. An ID with a different number of
+            // transforms than last frame can't be paired in order: each transform after the first one added or removed
+            // would be paired with its neighbour's, and the model would fly apart for a frame (Conker's characters,
+            // cut into chunks differently as their animation changes). Each is paired with last frame's closest instead
+            // (alignTransforms). Matching none of them made the whole model snap each time (issue #76).
             ModifiedBuffers modifiedBuffers;
             auto curIt = curWorkload.transformIdMap.begin();
             auto prevIt = prevWorkload.transformIdMap.begin();
@@ -309,9 +339,31 @@ namespace RT64 {
                     prevIt++;
                 }
                 else {
-                    matchTransform(curWorkload, prevWorkload, curWorkloadMap, prevWorkloadMap, curIt->second, prevIt->second, modifiedBuffers);
-                    curIt++;
-                    prevIt++;
+                    const uint32_t id = curIt->first;
+                    const size_t curCount = curWorkload.transformIdMap.count(id);
+                    const size_t prevCount = prevWorkload.transformIdMap.count(id);
+                    if (curCount != prevCount) {
+                        thread_local std::vector<uint32_t> curIndices;
+                        thread_local std::vector<uint32_t> prevIndices;
+                        curIndices.clear();
+                        prevIndices.clear();
+                        for (size_t i = 0; i < curCount; i++, curIt++) {
+                            curIndices.push_back(curIt->second);
+                        }
+
+                        for (size_t i = 0; i < prevCount; i++, prevIt++) {
+                            prevIndices.push_back(prevIt->second);
+                        }
+
+                        alignTransforms(curWorkload, prevWorkload, curWorkloadMap, prevWorkloadMap, curIndices, prevIndices, modifiedBuffers);
+                        continue;
+                    }
+
+                    for (size_t i = 0; i < curCount; i++) {
+                        matchTransform(curWorkload, prevWorkload, curWorkloadMap, prevWorkloadMap, curIt->second, prevIt->second, modifiedBuffers);
+                        curIt++;
+                        prevIt++;
+                    }
                 }
             }
 
@@ -348,7 +400,9 @@ namespace RT64 {
                     const Projection &prevProj = prevFbPair.projections[prevFirstProj.projectionIndex];
                     const hlslpp::float4x4 &prevViewTransform = prevWorkload.drawData.viewTransforms[prevProj.transformsIndex];
                     const hlslpp::float4x4 &prevProjTransform = prevWorkload.drawData.projTransforms[prevProj.transformsIndex];
-                    matchCandidates.emplace_back(i, j, matrixDifference(curViewTransform, prevViewTransform) + matrixDifference(curProjTransform, prevProjTransform));
+                    // A scene is paired with one drawn in the same part of the frame before any other (split screen).
+                    const float apartPenalty = areScenesPlacedApart(curProj.scissorRect, prevProj.scissorRect) ? 1e20f : 0.0f;
+                    matchCandidates.emplace_back(i, j, matrixDifference(curViewTransform, prevViewTransform) + matrixDifference(curProjTransform, prevProjTransform) + apartPenalty);
                 }
             }
 
@@ -486,6 +540,17 @@ namespace RT64 {
                         viewProjMap.rigidBody = prevViewProjMap.rigidBody;
                     }
 
+                    // A game that doesn't say how its camera interpolates (Conker) gets it interpolated always, cuts between
+                    // cutscene shots too: the frames drawn between the game's showed the camera partway from one shot to the
+                    // next, inside the scenery. A cut isn't interpolated.
+                    const bool projectionAutomatic = (curProjGroup.matrixId == G_EX_ID_IGNORE) || (curProjGroup.matrixId == G_EX_ID_AUTO);
+                    if (viewProjMap.rigidBody.updateCameraCut(prevView, curView) && projectionAutomatic) {
+                        projectionLinearComponent = G_EX_COMPONENT_SKIP;
+                        projectionAngularComponent = G_EX_COMPONENT_SKIP;
+                        projectionScaleComponent = G_EX_COMPONENT_SKIP;
+                        projectionSkewComponent = G_EX_COMPONENT_SKIP;
+                    }
+
                     viewProjMap.rigidBody.updateLinear(prevView, curView, projectionLinearComponent);
                     viewProjMap.rigidBody.updateAngular(prevView, curView, projectionAngularComponent, projectionScaleComponent, projectionSkewComponent);
                     viewProjMap.rigidBody.updateDecomposition(curView, projectionDecompose);
@@ -709,7 +774,45 @@ namespace RT64 {
         }
     }
 
-    void GameFrame::matchTransform(Workload &curWorkload, const Workload &prevWorkload, GameFrameMap::WorkloadMap &curWorkloadMap, const GameFrameMap::WorkloadMap *prevWorkloadMap, uint32_t curTransformIndex, uint32_t prevTransformIndex, ModifiedBuffers &modifiedBuffers) {
+    void GameFrame::alignTransforms(Workload &curWorkload, const Workload &prevWorkload, GameFrameMap::WorkloadMap &curWorkloadMap, const GameFrameMap::WorkloadMap *prevWorkloadMap,
+        const std::vector<uint32_t> &curIndices, const std::vector<uint32_t> &prevIndices, ModifiedBuffers &modifiedBuffers)
+    {
+        // Conker's characters are skinned meshes drawn in chunks, a few vertices each with one bone's matrix, the same
+        // bone's matrix loaded again for each of its chunks. When the animation changes, the mesh is cut into chunks
+        // differently: their number, sizes and order change, but the bones they're drawn with are the same ones. So each
+        // transform is paired with last frame's closest (its position moved on by its velocity, plus OrientationWeight
+        // times how differently it's turned; mirrored ones aren't), however many vertices either draws, and several may
+        // pair with the same one: those are the same bone. None further than MaxAlignCost is paired: that one snaps. The
+        // chunks paired aren't the same geometry, so their vertices aren't interpolated (in a frame with the same chunks,
+        // a character's vertices don't move: the bones do).
+        const float OrientationWeight = 32.0f;
+        const float MaxAlignCost = 64.0f;
+        const hlslpp::float4x4 identity = hlslpp::float4x4::identity();
+        for (uint32_t curIndex : curIndices) {
+            const hlslpp::float4x4 &curTransform = curWorkload.drawData.worldTransforms[curIndex];
+            float bestCost = MaxAlignCost;
+            uint32_t bestPrev = UINT32_MAX;
+            for (uint32_t prevIndex : prevIndices) {
+                const RigidBody *prevRigidBody = (prevWorkloadMap != nullptr) ? &prevWorkloadMap->transforms[prevIndex].rigidBody : nullptr;
+                const TransformMatchResult result = computeTransformMatch(curTransform, identity, prevWorkload.drawData.worldTransforms[prevIndex], identity, prevRigidBody);
+                if (!result.valid) {
+                    continue;
+                }
+
+                const float cost = result.positionDifference + OrientationWeight * result.orientationDifference;
+                if (cost < bestCost) {
+                    bestCost = cost;
+                    bestPrev = prevIndex;
+                }
+            }
+
+            if (bestPrev != UINT32_MAX) {
+                matchTransform(curWorkload, prevWorkload, curWorkloadMap, prevWorkloadMap, curIndex, bestPrev, modifiedBuffers, false);
+            }
+        }
+    }
+
+    void GameFrame::matchTransform(Workload &curWorkload, const Workload &prevWorkload, GameFrameMap::WorkloadMap &curWorkloadMap, const GameFrameMap::WorkloadMap *prevWorkloadMap, uint32_t curTransformIndex, uint32_t prevTransformIndex, ModifiedBuffers &modifiedBuffers, bool interpolateVertices) {
         GameFrameMap::TransformMap &curTransformMap = curWorkloadMap.transforms[curTransformIndex];
         if (prevWorkloadMap != nullptr) {
             curTransformMap.rigidBody = prevWorkloadMap->transforms[prevTransformIndex].rigidBody;
@@ -733,7 +836,7 @@ namespace RT64 {
         uint32_t curVertexCount = curWorkload.drawData.worldTransformVertexCount(curTransformIndex);
         uint32_t prevVertexIndex = prevWorkload.drawData.worldTransformVertexIndices[prevTransformIndex];
         uint32_t prevVertexCount = prevWorkload.drawData.worldTransformVertexCount(prevTransformIndex);
-        if (((curGroup.vertexInterpolation != G_EX_COMPONENT_SKIP) || (curGroup.texcoordInterpolation == G_EX_COMPONENT_AUTO)) && (curVertexCount == prevVertexCount)) {
+        if (interpolateVertices && ((curGroup.vertexInterpolation != G_EX_COMPONENT_SKIP) || (curGroup.texcoordInterpolation == G_EX_COMPONENT_AUTO)) && (curVertexCount == prevVertexCount)) {
             const std::vector<float> &curPosFloats = curWorkload.drawData.posFloats;
             const std::vector<float> &prevPosFloats = prevWorkload.drawData.posFloats;
             std::vector<float> &curVelFloats = curWorkload.drawData.velFloats;
@@ -744,17 +847,178 @@ namespace RT64 {
                 const float *curPosFloatsRef = &curPosFloats[curVertexIndex * 3];
                 const float *prevPosFloatsRef = &prevPosFloats[prevVertexIndex * 3];
                 float *curVelFloatsRef = &curVelFloats[curVertexIndex * 3];
-                for (uint32_t i = 0; i < curVertexCount; i++) {
-                    for (uint32_t j = 0; j < 3; j++) {
-                        curVelFloatsRef[i * 3 + j] = (curPosFloatsRef[i * 3 + j] - prevPosFloatsRef[i * 3 + j]);
-                    }
+                // Vertices are paired by their order, so a transform matched to one drawing other geometry (same vertex
+                // count) would smear it. Motion that large in one frame isn't a model moving: leave those as they are.
+                const float MaxVertexStep = 64.0f;
+                bool plausible = true;
+                for (uint32_t i = 0; (i < curVertexCount * 3) && plausible; i++) {
+                    plausible = fabsf(curPosFloatsRef[i] - prevPosFloatsRef[i]) < MaxVertexStep;
                 }
 
-                modifiedBuffers.positionVelocity = true;
+                if (plausible) {
+                    for (uint32_t i = 0; i < curVertexCount; i++) {
+                        for (uint32_t j = 0; j < 3; j++) {
+                            curVelFloatsRef[i * 3 + j] = (curPosFloatsRef[i * 3 + j] - prevPosFloatsRef[i * 3 + j]);
+                        }
+                    }
+
+                    modifiedBuffers.positionVelocity = true;
+                }
             }
         }
 
-        if ((curGroup.texcoordInterpolation != G_EX_COMPONENT_SKIP) && (curVertexCount == prevVertexCount)) {
+        // Texture coordinates interpolated while the positions aren't: geometry rebuilt every frame with its
+        // coordinates projected from its position (Conker's Bad Fur Day's shadows: the ground under a character,
+        // clipped anew each frame, with the shadow's texture projected onto it from the light's point of view).
+        // Its vertices can't be paired with last frame's, so last frame's projection is fitted instead (a
+        // perspective map from position to texture coordinates, by least squares, in world space) and each
+        // vertex's coordinates last frame are taken from it.
+        if ((curGroup.texcoordInterpolation == G_EX_COMPONENT_INTERPOLATE) && (curGroup.vertexInterpolation == G_EX_COMPONENT_SKIP) && (curVertexCount > 0) && (prevVertexCount >= 3)) {
+            const float *prevLocal = &prevWorkload.drawData.posFloats[prevVertexIndex * 3];
+            const float *prevTc = &prevWorkload.drawData.tcFloats[prevVertexIndex * 2];
+            const float *curLocal = &curWorkload.drawData.posFloats[curVertexIndex * 3];
+            const float *curTc = &curWorkload.drawData.tcFloats[curVertexIndex * 2];
+            float *curTcVel = &curWorkload.drawData.tcVelFloats[curVertexIndex * 2];
+
+            // Positions in the world: each frame's are relative to its own transform, which can move.
+            thread_local std::vector<float> prevWorld, curWorld;
+            auto toWorld = [](const float *local, uint32_t count, const hlslpp::float4x4 &m, std::vector<float> &out) {
+                out.resize(count * 3);
+                for (uint32_t i = 0; i < count; i++) {
+                    const hlslpp::float4 w = hlslpp::mul(hlslpp::float4(local[i * 3 + 0], local[i * 3 + 1], local[i * 3 + 2], 1.0f), m);
+                    out[i * 3 + 0] = w.x;
+                    out[i * 3 + 1] = w.y;
+                    out[i * 3 + 2] = w.z;
+                }
+            };
+            toWorld(prevLocal, prevVertexCount, prevTransform, prevWorld);
+            toWorld(curLocal, curVertexCount, curTransform, curWorld);
+            const float *prevPos = prevWorld.data();
+            const float *curPos = curWorld.data();
+
+            // The texture's extent last frame.
+            float tcMin[2] = { FLT_MAX, FLT_MAX }, tcMax[2] = { -FLT_MAX, -FLT_MAX };
+            double mean[3] = {}, meanSq = 0.0;
+            for (uint32_t i = 0; i < prevVertexCount; i++) {
+                for (int b = 0; b < 2; b++) {
+                    tcMin[b] = std::min(tcMin[b], prevTc[i * 2 + b]);
+                    tcMax[b] = std::max(tcMax[b], prevTc[i * 2 + b]);
+                }
+                for (int j = 0; j < 3; j++) mean[j] += prevPos[i * 3 + j];
+            }
+            for (int j = 0; j < 3; j++) mean[j] /= prevVertexCount;
+            for (uint32_t i = 0; i < prevVertexCount; i++) {
+                for (int j = 0; j < 3; j++) meanSq += (prevPos[i * 3 + j] - mean[j]) * (prevPos[i * 3 + j] - mean[j]);
+            }
+            const double scale = std::sqrt(meanSq / prevVertexCount) + 1e-9;
+
+            // s = (a . q + a0) / (d . q + 1) and t = (b . q + b0) / (d . q + 1), q the normalised position,
+            // made linear: a . q + a0 - s (d . q) = s. Eleven unknowns: a, a0, b, b0 and d.
+            double normal[11][12] = {};
+            uint32_t used = 0;
+            auto addRow = [&](const double row[11], double rhs) {
+                for (int r = 0; r < 11; r++) {
+                    for (int c = 0; c < 11; c++) normal[r][c] += row[r] * row[c];
+                    normal[r][11] += row[r] * rhs;
+                }
+            };
+            // Every vertex follows the projection, those on the texture's edges too: the game clips the ground
+            // where the projection reaches them.
+            for (uint32_t i = 0; i < prevVertexCount; i++) {
+                const double q[3] = { (prevPos[i * 3 + 0] - mean[0]) / scale, (prevPos[i * 3 + 1] - mean[1]) / scale, (prevPos[i * 3 + 2] - mean[2]) / scale };
+                const double s = prevTc[i * 2 + 0], t = prevTc[i * 2 + 1];
+                const double rowS[11] = { q[0], q[1], q[2], 1.0, 0.0, 0.0, 0.0, 0.0, -s * q[0], -s * q[1], -s * q[2] };
+                const double rowT[11] = { 0.0, 0.0, 0.0, 0.0, q[0], q[1], q[2], 1.0, -t * q[0], -t * q[1], -t * q[2] };
+                addRow(rowS, s);
+                addRow(rowT, t);
+                used++;
+            }
+
+            // A little ridge: flat ground leaves the coefficients across it undetermined.
+            double trace = 0.0;
+            for (int r = 0; r < 11; r++) trace += normal[r][r];
+            for (int r = 0; r < 11; r++) normal[r][r] += 1e-7 * trace + 1e-12;
+
+            // Gaussian elimination with partial pivoting.
+            bool solved = (used >= 6);
+            for (int c = 0; (c < 11) && solved; c++) {
+                int pivot = c;
+                for (int r = c + 1; r < 11; r++) {
+                    if (fabs(normal[r][c]) > fabs(normal[pivot][c])) pivot = r;
+                }
+                if (fabs(normal[pivot][c]) < 1e-18) {
+                    solved = false;
+                    break;
+                }
+                if (pivot != c) {
+                    for (int k = 0; k < 12; k++) std::swap(normal[c][k], normal[pivot][k]);
+                }
+                for (int r = 0; r < 11; r++) {
+                    if (r == c) continue;
+                    const double f = normal[r][c] / normal[c][c];
+                    for (int k = c; k < 12; k++) normal[r][k] -= f * normal[c][k];
+                }
+            }
+
+            if (solved) {
+                double coef[11];
+                for (int r = 0; r < 11; r++) coef[r] = normal[r][11] / normal[r][r];
+                auto project = [&](const float *p, double out[2]) {
+                    const double q[3] = { (p[0] - mean[0]) / scale, (p[1] - mean[1]) / scale, (p[2] - mean[2]) / scale };
+                    const double w = coef[8] * q[0] + coef[9] * q[1] + coef[10] * q[2] + 1.0;
+                    out[0] = (coef[0] * q[0] + coef[1] * q[1] + coef[2] * q[2] + coef[3]) / w;
+                    out[1] = (coef[4] * q[0] + coef[5] * q[1] + coef[6] * q[2] + coef[7]) / w;
+                };
+
+                // Only if last frame's coordinates fit it closely (on average within 1% of the texture's extent).
+                double residual = 0.0;
+                for (uint32_t i = 0; i < prevVertexCount; i++) {
+                    double predicted[2];
+                    project(&prevPos[i * 3], predicted);
+                    residual += fabs(predicted[0] - prevTc[i * 2 + 0]) + fabs(predicted[1] - prevTc[i * 2 + 1]);
+                }
+                residual /= std::max(used, 1U);
+                const double spread = std::max(tcMax[0] - tcMin[0], tcMax[1] - tcMin[1]);
+
+                // The vertices fitted must cover the texture in both directions: a few, or ones along a line,
+                // fit closely while leaving the map across them undetermined.
+                float usedMin[2] = { FLT_MAX, FLT_MAX }, usedMax[2] = { -FLT_MAX, -FLT_MAX };
+                for (uint32_t i = 0; i < prevVertexCount; i++) {
+                    for (int b = 0; b < 2; b++) {
+                        usedMin[b] = std::min(usedMin[b], prevTc[i * 2 + b]);
+                        usedMax[b] = std::max(usedMax[b], prevTc[i * 2 + b]);
+                    }
+                }
+                const bool covered = (used >= 12) && ((usedMax[0] - usedMin[0]) > 0.25 * spread) && ((usedMax[1] - usedMin[1]) > 0.25 * spread);
+                if (covered && (spread > 0.0) && (residual <= 0.01 * spread)) {
+                    // The shadow moves a few texels a frame: a vertex whose coordinates would move more than a
+                    // quarter of the texture means the map doesn't hold there, and the frame is drawn as it is.
+                    const double maxStep = 0.25 * spread;
+                    bool plausible = true;
+                    for (uint32_t i = 0; (i < curVertexCount) && plausible; i++) {
+                        double predicted[2];
+                        project(&curPos[i * 3], predicted);
+                        for (int b = 0; b < 2; b++) {
+                            // Last frame's coordinates were clipped to the texture's edges too.
+                            const double previous = std::clamp(predicted[b], double(tcMin[b]), double(tcMax[b]));
+                            const double step = curTc[i * 2 + b] - previous;
+                            plausible = plausible && std::isfinite(step) && (fabs(step) <= maxStep);
+                            curTcVel[i * 2 + b] = float(step);
+                        }
+                    }
+
+                    if (plausible) {
+                        modifiedBuffers.texcoordVelocity = true;
+                    }
+                    else {
+                        for (uint32_t i = 0; i < curVertexCount * 2; i++) {
+                            curTcVel[i] = 0.0f;
+                        }
+                    }
+                }
+            }
+        }
+        else if ((curGroup.texcoordInterpolation != G_EX_COMPONENT_SKIP) && (curVertexCount == prevVertexCount)) {
             const std::vector<float> &curTcFloats = curWorkload.drawData.tcFloats;
             const std::vector<float> &prevTcFloats = prevWorkload.drawData.tcFloats;
             std::vector<float> &curVelFloats = curWorkload.drawData.tcVelFloats;
diff --git a/src/hle/rt64_game_frame.h b/src/hle/rt64_game_frame.h
index 00a72f6..32e9300 100644
--- a/src/hle/rt64_game_frame.h
+++ b/src/hle/rt64_game_frame.h
@@ -127,7 +127,10 @@ namespace RT64 {
         void set(WorkloadQueue &workloadQueue, const uint32_t *workloadIndices, uint32_t indicesCount);
         void match(RenderWorker *worker, WorkloadQueue &workloadQueue, const GameFrame &prevFrame, BufferUploader *velocityUploader, bool &velocityUploaderUsed, bool &tileInterpolationUsed, bool &lookAtInterpolationUsed);
         void matchScene(WorkloadQueue &workloadQueue, const GameFrame &prevFrame, const GameScene &curScene, const GameScene &prevScene, std::unordered_map<uint32_t, ModifiedBuffers> &workloadsModified, bool &tileInterpolationUsed, bool &lookAtInterpolationUsed);
-        void matchTransform(Workload &curWorkload, const Workload &prevWorkload, GameFrameMap::WorkloadMap &curWorkloadMap, const GameFrameMap::WorkloadMap *prevWorkloadMap, uint32_t curTransformIndex, uint32_t prevTransformIndex, ModifiedBuffers &modifiedBuffers);
+        void matchTransform(Workload &curWorkload, const Workload &prevWorkload, GameFrameMap::WorkloadMap &curWorkloadMap, const GameFrameMap::WorkloadMap *prevWorkloadMap, uint32_t curTransformIndex, uint32_t prevTransformIndex, ModifiedBuffers &modifiedBuffers, bool interpolateVertices = true);
+        // Conker: matches an ID's transforms when there are more or fewer than last frame, each with last frame's closest.
+        void alignTransforms(Workload &curWorkload, const Workload &prevWorkload, GameFrameMap::WorkloadMap &curWorkloadMap, const GameFrameMap::WorkloadMap *prevWorkloadMap,
+            const std::vector<uint32_t> &curIndices, const std::vector<uint32_t> &prevIndices, ModifiedBuffers &modifiedBuffers);
         void buildCallHashMap(uint32_t sceneProjIndex, const Workload &workload, const Projection &proj, std::multimap<uint64_t, GameCallMap> &hashMap) const;
         void buildTransformIdMap(const Workload &workload, std::multimap<uint32_t, uint32_t> &idMap, std::vector<uint32_t> &ignoredIdVector) const;
         uint64_t hashFromCall(const GameCall &call, uint32_t matrixIdHash) const;
diff --git a/src/hle/rt64_present.h b/src/hle/rt64_present.h
index e1889e5..c5d5f40 100644
--- a/src/hle/rt64_present.h
+++ b/src/hle/rt64_present.h
@@ -21,6 +21,9 @@ namespace RT64 {
         std::vector<FramebufferOperation> fbOperations;
         DebuggerFramebuffer debuggerFramebuffer;
         bool paused = false;
+        // Shown again as it was (presentAgain): the frame once, not the frames interpolated before it again. It counts
+        // the frames as presented, as a present of one frame does, so a workload waiting on them goes on.
+        bool repeated = false;
         uint64_t presentId = 0;
         uint64_t workloadId = 0;
     };
diff --git a/src/hle/rt64_present_queue.cpp b/src/hle/rt64_present_queue.cpp
index 7de5b69..0a41c76 100644
--- a/src/hle/rt64_present_queue.cpp
+++ b/src/hle/rt64_present_queue.cpp
@@ -9,7 +9,16 @@
 
 #include "rt64_workload_queue.h"
 
+#include <atomic>
+
 namespace RT64 {
+    // Frames presented to the screen so far (Conker: its FPS counter reads it, host/src/fps_counter.cpp).
+    static std::atomic<uint64_t> presentedFrames = 0;
+
+    uint64_t presentedFrameCount() {
+        return presentedFrames.load(std::memory_order_relaxed);
+    }
+
     // PresentQueue
 
     PresentQueue::PresentQueue() {
@@ -188,7 +197,8 @@ namespace RT64 {
                     }
                 }
 
-                if (presentFb->interpolationEnabled) {
+                // (A repeated present shows the frame once: its interpolated ones were shown already.)
+                if (presentFb->interpolationEnabled && !present.repeated) {
                     framesToPresent = frameCounters.count;
                 }
                 else {
@@ -402,6 +412,7 @@ namespace RT64 {
                 RenderCommandSemaphore *waitSemaphore = drawSemaphores[swapChainIndex].get();
                 presentTimestamp = Timer::current();
                 swapChainValid = ext.swapChain->present(swapChainIndex, &waitSemaphore, 1);
+                presentedFrames.fetch_add(1, std::memory_order_relaxed);
                 presentProfiler.logAndRestart();
             }
         }
diff --git a/src/hle/rt64_present_queue.h b/src/hle/rt64_present_queue.h
index e08b02c..084ccfd 100644
--- a/src/hle/rt64_present_queue.h
+++ b/src/hle/rt64_present_queue.h
@@ -17,6 +17,9 @@
 namespace RT64 {
     struct WorkloadQueue;
 
+    // The number of frames presented to the screen so far, from any thread (Conker's FPS counter).
+    uint64_t presentedFrameCount();
+
     struct PresentQueue {
         struct External {
             ApplicationWindow *appWindow = nullptr;
diff --git a/src/hle/rt64_rdp.cpp b/src/hle/rt64_rdp.cpp
index a10c11a..f6f02d2 100644
--- a/src/hle/rt64_rdp.cpp
+++ b/src/hle/rt64_rdp.cpp
@@ -4,7 +4,10 @@
 
 #include "rt64_rdp.h"
 
+#include "common/rt64_conker_view_focus.h"
+
 #include <cassert>
+#include <cmath>
 
 #include "../include/rt64_extended_gbi.h"
 
@@ -977,6 +980,29 @@ namespace RT64 {
         scissorRect.uly = std::clamp(uly + extAlignment.topOffset, extAlignment.topBound, extAlignment.bottomBound);
         scissorRect.lrx = std::clamp(movedFromOrigin(lrx + extAlignment.rightOffset, extAlignment.rightOrigin), extAlignment.leftBound, extAlignment.rightBound);
         scissorRect.lry = std::clamp(lry + extAlignment.bottomOffset, extAlignment.topBound, extAlignment.bottomBound);
+
+        // Conker: netplay's "my view only", drawn anew (rt64_conker_view_focus.h). The rectangle is in quarter pixels.
+        const ConkerViewFocus focus = conkerViewFocus();
+        if (conkerFocusApplies(focus, colorImage.width, colorImage.address)) {
+            int index = 0;
+            const ConkerViewPart part = conkerViewPart(focus, scissorRect.ulx / 4.0f, scissorRect.uly / 4.0f, scissorRect.lrx / 4.0f, scissorRect.lry / 4.0f, index);
+            if (part == ConkerViewPart::Focused) {
+                // Stretched with the view (the view's own scissor to where it's drawn), within that.
+                const ConkerFocusView &view = focus.views[index];
+                auto mapped = [](float v, float low, float high) { return int32_t(std::lround(std::clamp(v, low, high) * 4.0f)); };
+                const float left = conkerMapX(view, scissorRect.ulx / 4.0f), right = conkerMapX(view, scissorRect.lrx / 4.0f);
+                const float top = conkerMapY(view, scissorRect.uly / 4.0f), bottom = conkerMapY(view, scissorRect.lry / 4.0f);
+                scissorRect.ulx = mapped(left, view.left, view.right);
+                scissorRect.uly = mapped(top, view.top, view.bottom);
+                scissorRect.lrx = mapped(right, view.left, view.right);
+                scissorRect.lry = mapped(bottom, view.top, view.bottom);
+            }
+            else if (part == ConkerViewPart::Other) {
+                scissorRect.lrx = scissorRect.ulx;
+                scissorRect.lry = scissorRect.uly;
+            }
+        }
+
         scissorModeStack[scissorStackSize - 1] = mode;
         extended.scissorLeftOriginStack[scissorStackSize - 1] = extAlignment.leftOrigin;
         extended.scissorRightOriginStack[scissorStackSize - 1] = extAlignment.rightOrigin;
@@ -1061,6 +1087,10 @@ namespace RT64 {
         extended.global.rectAspect = aspect;
     }
 
+    void RDP::setConkerFocusPlaced(uint8_t mode, uint8_t layouts, uint16_t x, uint8_t y) {
+        extended.global.conkerPlaced = { mode, layouts, x, y };
+    }
+
     void RDP::forceUpscale2D(bool force) {
         extended.drawExtendedFlags.forceUpscale2D = force;
         state->updateDrawStatusAttribute(DrawAttribute::ExtendedFlags);
@@ -1083,6 +1113,7 @@ namespace RT64 {
         extended.global.rect = ExtendedAlignment();
         extended.global.scissor = ExtendedAlignment();
         extended.global.rectAspect = G_EX_ASPECT_AUTO;
+        extended.global.conkerPlaced = {};
     }
     
     void RDP::drawTris(uint32_t triCount, const float *pos, const float *tc, const float *col, uint8_t tile, uint8_t levels) {
@@ -1192,11 +1223,26 @@ namespace RT64 {
             }
         }
 
-        const FixedRect drawRect(movedFromOrigin(ulx, extAlignment.leftOrigin), uly, movedFromOrigin(lrx, extAlignment.rightOrigin), lry);
+        FixedRect drawRect(movedFromOrigin(ulx, extAlignment.leftOrigin), uly, movedFromOrigin(lrx, extAlignment.rightOrigin), lry);
         if (drawRect.isEmpty()) {
             return;
         }
 
+        // Conker: netplay's "my view only", drawn anew (rt64_conker_view_focus.h): the view's 2D goes with it, or the
+        // display list gives it placed where the view is drawn (gEXConkerFocusPlaced).
+        const ConkerViewFocus focus = conkerViewFocus();
+        const bool focusApplies = conkerFocusApplies(focus, colorImage.width, colorImage.address);
+        const auto &placed = extended.global.conkerPlaced;
+        if (placed.mode != 0) {
+            const bool drawnThere = focusApplies && conkerViewDrawnAt(focus, placed.x, placed.y, placed.layouts);
+            if (drawnThere != (placed.mode == 1)) {
+                return;
+            }
+        }
+        if (placed.mode != 1 && focusApplies && !conkerMoveRect(focus, usesFillMode, drawRect)) {
+            return;
+        }
+
         // Check if framebuffer pair must be changed.
         checkFramebufferPair();
 
diff --git a/src/hle/rt64_rdp.h b/src/hle/rt64_rdp.h
index 84f4e7c..bd2a810 100644
--- a/src/hle/rt64_rdp.h
+++ b/src/hle/rt64_rdp.h
@@ -93,6 +93,13 @@ namespace RT64 {
                 ExtendedAlignment rect;
                 ExtendedAlignment scissor;
                 uint8_t rectAspect;
+                // Conker: gEXConkerFocusPlaced.
+                struct {
+                    uint8_t mode;
+                    uint8_t layouts;
+                    uint16_t x;
+                    uint8_t y;
+                } conkerPlaced;
             } global;
 
             uint16_t scissorLeftOriginStack[RDP_EXTENDED_STACK_SIZE];
@@ -196,6 +203,7 @@ namespace RT64 {
         void setRectAlign(const ExtendedAlignment &extAlignment);
         void setScissorAlign(const ExtendedAlignment &extAlignment);
         void setRectAspect(uint8_t aspect);
+        void setConkerFocusPlaced(uint8_t mode, uint8_t layouts, uint16_t x, uint8_t y);
         void forceUpscale2D(bool force);
         void forceTrueBilerp(uint8_t mode);
         void forceScaleLOD(bool force);
diff --git a/src/hle/rt64_rdp_tmem.cpp b/src/hle/rt64_rdp_tmem.cpp
index 6051f4e..8f00934 100644
--- a/src/hle/rt64_rdp_tmem.cpp
+++ b/src/hle/rt64_rdp_tmem.cpp
@@ -11,6 +11,7 @@
 
 #include "common/rt64_tmem_hasher.h"
 
+#include "rt64_rice_hash.h"
 #include "rt64_state.h"
 
 namespace RT64 {
@@ -52,6 +53,7 @@ namespace RT64 {
     uint64_t TextureManager::uploadTexture(State *state, const LoadTile &loadTile, TextureCache *textureCache, uint64_t creationFrame, uint16_t width, uint16_t height, uint32_t tlut) {
         const uint8_t *TMEM = reinterpret_cast<const uint8_t *>(state->rdp->TMEM);
         uint64_t hash = TMEMHasher::hash(TMEM, loadTile, width, height, tlut, TMEMHasher::CurrentHashVersion);
+        checkRiceReplacement(state, loadTile, textureCache, hash, width, height, tlut);
         if (hashSet.find(hash) == hashSet.end()) {
             hashSet.insert(hash);
             textureCache->queueGPUUploadTMEM(hash, creationFrame, TMEM, RDP_TMEM_BYTES, width, height, tlut, loadTile, true);
@@ -189,6 +191,27 @@ namespace RT64 {
         }
     }
 
+    void TextureManager::checkRiceReplacement(State *state, const LoadTile &loadTile, TextureCache *textureCache, uint64_t hash, uint16_t width, uint16_t height, uint32_t tlut) {
+        if (!textureCache->hasRiceReplacements() || (width == 0) || (height == 0)) {
+            return;
+        }
+
+        const uint32_t generation = textureCache->getRiceGeneration();
+        if (generation != riceCheckedGeneration) {
+            riceCheckedSet.clear();
+            riceCheckedGeneration = generation;
+        }
+
+        if (!riceCheckedSet.insert(hash).second) {
+            return;
+        }
+
+        const std::vector<std::string> riceKeys = riceTextureKeys(state, loadTile, width, height, tlut);
+        if (!riceKeys.empty()) {
+            textureCache->addRiceReplacement(hash, riceKeys);
+        }
+    }
+
     void TextureManager::removeHashes(const std::vector<uint64_t> &hashes) {
         for (uint64_t hash : hashes) {
             hashSet.erase(hash);
diff --git a/src/hle/rt64_rdp_tmem.h b/src/hle/rt64_rdp_tmem.h
index 3708220..5416d68 100644
--- a/src/hle/rt64_rdp_tmem.h
+++ b/src/hle/rt64_rdp_tmem.h
@@ -16,6 +16,14 @@ namespace RT64 {
         std::set<uint64_t> hashSet;
         std::set<uint64_t> dumpedSet;
 
+        // Textures already matched against the Rice-named packs (TextureCache::getRiceGeneration: since they last changed).
+        std::set<uint64_t> riceCheckedSet;
+        uint32_t riceCheckedGeneration = 0;
+
+        // With a Rice-named pack loaded, the first time a texture is seen, its Rice names are worked out (rt64_rice_hash.h)
+        // for the texture cache to find its replacement by.
+        void checkRiceReplacement(State *state, const LoadTile &loadTile, TextureCache *textureCache, uint64_t hash, uint16_t width, uint16_t height, uint32_t tlut);
+
         void uploadEmpty(State *state, TextureCache *textureCache, uint64_t creationFrame, uint16_t width, uint16_t height, uint64_t replacementHash);
         uint64_t uploadTMEM(State *state, const LoadTile &loadTile, TextureCache *textureCache, uint64_t creationFrame, uint16_t byteOffset, uint16_t byteCount, uint16_t width, uint16_t height, uint32_t tlut);
         uint64_t uploadTexture(State *state, const LoadTile &loadTile, TextureCache *textureCache, uint64_t creationFrame, uint16_t width, uint16_t height, uint32_t tlut);
diff --git a/src/hle/rt64_rice_hash.cpp b/src/hle/rt64_rice_hash.cpp
new file mode 100644
index 0000000..b50bf1f
--- /dev/null
+++ b/src/hle/rt64_rice_hash.cpp
@@ -0,0 +1,272 @@
+//
+// RT64
+//
+// SPDX-License-Identifier: GPL-2.0-or-later
+//
+// Rice texture hashes, worked out live from RDRAM. This file is under the GNU General Public License,
+// version 2 or later, unlike the rest of RT64 (MIT). Its hashing is RT64's texture_hasher tool's
+// (src/tools/texture_hasher/texture_hasher.cpp), which "has been referenced from GlideN64 and RiceVideo
+// to imitate their hashing algorithms" and is under the GPL to comply with their licenses:
+// - the Rice CRC (RiceCRC32, the palette CRC over cimax + 1 entries) is GlideHQ's, in GLideN64's
+//   src/GLideNHQ/TxUtil.cpp, copyright (C) 2007 Hiroshi Morii, GPL version 2 or later;
+// - the sizes hashed (ReverseDXT, CalculateMaxCI, the tile and block dimensions) are Rice Video's
+//   (Rice1964; mupen64plus-video-rice, GPL version 2 or later), as GLideN64 also uses them. GLideN64
+//   (Sergey Lipskiy and contributors) is under the GPL version 2: src/tools/texture_hasher/GLIDEN64-LICENSE.
+// Which RDRAM a load read follows TextureManager::dumpTexture (rt64_rdp_tmem.cpp), whose dumps
+// texture_hasher reads.
+//
+// This program is free software; you can redistribute it and/or modify it under the terms of the GNU
+// General Public License as published by the Free Software Foundation; either version 2 of the License,
+// or (at your option) any later version. This program is distributed in the hope that it will be
+// useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+// FOR A PARTICULAR PURPOSE. See the GNU General Public License (https://www.gnu.org/licenses/) for
+// more details.
+//
+
+#include "rt64_rice_hash.h"
+
+#include <algorithm>
+#include <cstdio>
+#include <cstring>
+
+#include "shared/rt64_f3d_defines.h"
+
+#include "rt64_state.h"
+
+namespace RT64 {
+    namespace {
+        // RDRAM as RT64 sees it (State::RDRAMSize is its last byte).
+        constexpr uint32_t RiceRDRAMBytes = 0x800000;
+
+        uint32_t CalculateDXT(uint32_t txl2words) {
+            if (txl2words == 0) {
+                return 1U;
+            }
+            else {
+                return (2048 + txl2words - 1) / txl2words;
+            }
+        }
+
+        uint32_t Txl2Words(uint32_t width, uint32_t size) {
+            static const uint32_t sizeBytes[4] = { 0, 1, 2, 4 };
+            if (size == 0) {
+                return std::max(1U, width / 16);
+            }
+            else {
+                return std::max(1U, width * sizeBytes[size] / 8);
+            }
+        }
+
+        int ReverseDXT(uint32_t val, uint32_t width, uint32_t size) {
+            if (val == 0x800) {
+                return 1;
+            }
+
+            int low = 2047 / val;
+            if (CalculateDXT(low) > val) {
+                low++;
+            }
+
+            int high = 2047 / (val - 1);
+            if (low == high) {
+                return low;
+            }
+
+            for (int i = low; i <= high; i++) {
+                if (Txl2Words(width, size) == (uint32_t)i) {
+                    return i;
+                }
+            }
+
+            return (low + high) / 2;
+        }
+
+        uint8_t CalculateMaxCI8b(const uint8_t *src, uint32_t width, uint32_t height, uint32_t rowStride) {
+            uint8_t val = 0;
+            for (uint32_t y = 0; y < height; ++y) {
+                const uint8_t *buf = src + rowStride * y;
+                for (uint32_t x = 0; x < width; ++x) {
+                    if (buf[x] > val) {
+                        val = buf[x];
+                    }
+
+                    if (val == 0xFF) {
+                        return uint8_t(0xFF);
+                    }
+                }
+            }
+
+            return val;
+        }
+
+        uint8_t CalculateMaxCI4b(const uint8_t *src, uint32_t width, uint32_t height, uint32_t rowStride) {
+            uint8_t val = 0;
+            width >>= 1;
+            for (uint32_t y = 0; y < height; ++y) {
+                const uint8_t *buf = src + rowStride * y;
+                for (uint32_t x = 0; x < width; ++x) {
+                    const uint8_t val1 = buf[x] >> 4;
+                    const uint8_t val2 = buf[x] & 0xF;
+                    val = std::max(val, std::max(val1, val2));
+                    if (val == 0xF) {
+                        return uint8_t(0xF);
+                    }
+                }
+            }
+
+            return val;
+        }
+
+        uint32_t RiceCRC32(const uint8_t *src, int width, int height, int size, int rowStride) {
+            uint32_t crc32Ret = 0;
+            const uint32_t bytesPerLine = width << size >> 1;
+            int y = height - 1;
+            while (y >= 0) {
+                uint32_t esi = 0;
+                int x = bytesPerLine - 4;
+                while (x >= 0) {
+                    std::memcpy(&esi, src + x, sizeof(esi));
+                    esi ^= x;
+
+                    crc32Ret = (crc32Ret << 4) + ((crc32Ret >> 28) & 15);
+                    crc32Ret += esi;
+                    x -= 4;
+                }
+
+                esi ^= y;
+                crc32Ret += esi;
+                src += rowStride;
+                --y;
+            }
+
+            return crc32Ret;
+        }
+
+        std::string hashString(uint32_t hash) {
+            char hexStr[16];
+            snprintf(hexStr, sizeof(hexStr), "%08x", hash);
+            return std::string(hexStr);
+        }
+    }
+
+    std::vector<std::string> riceTextureKeys(const State *state, const LoadTile &loadTile, uint16_t width, uint16_t height, uint32_t tlut) {
+        const LoadTile &drawTile = loadTile;
+        const LoadOperation &loadOp = state->rdp->rice.lastLoadOpByTMEM[loadTile.tmem];
+
+        // The RDRAM the load read (TextureManager::dumpTexture).
+        uint32_t rdramStart = loadOp.texture.address;
+        uint32_t rdramCount = 0;
+        const uint32_t commonBytesOffset = (loadOp.tile.uls >> 2) << loadOp.texture.siz >> 1;
+        uint32_t commonBytesPerRow = loadOp.texture.width << loadOp.texture.siz >> 1;
+        if (loadOp.type == LoadOperation::Type::Block) {
+            const uint32_t wordCount = ((loadOp.tile.lrs - loadOp.tile.uls) >> (4 - loadOp.tile.siz)) + 1;
+            rdramStart = loadOp.texture.address + commonBytesOffset + commonBytesPerRow * loadOp.tile.ult;
+            rdramCount = (wordCount << 3);
+            commonBytesPerRow = std::max(commonBytesPerRow, uint32_t(loadTile.line) << 3U);
+        }
+        else if (loadOp.type == LoadOperation::Type::Tile) {
+            const uint32_t rowCount = 1 + ((loadOp.tile.lrt >> 2) - (loadOp.tile.ult >> 2));
+            rdramStart = loadOp.texture.address + commonBytesOffset + commonBytesPerRow * (loadOp.tile.ult >> 2);
+            rdramCount = rowCount * commonBytesPerRow;
+        }
+        else {
+            return {};
+        }
+
+        const uint32_t loadTileBpr = width << loadTile.siz >> 1;
+        rdramCount = std::max(rdramCount, std::max(loadTileBpr, commonBytesPerRow) * height);
+        if ((rdramCount == 0) || (rdramStart >= RiceRDRAMBytes) || (rdramCount > (RiceRDRAMBytes - rdramStart))) {
+            return {};
+        }
+
+        const uint8_t *rdramBytes = state->RDRAM + rdramStart;
+
+        // The size Rice hashes (texture_hasher's addRiceHash).
+        int bpl;
+        int hashWidth, hashHeight;
+        if (loadOp.type == LoadOperation::Type::Tile) {
+            uint16_t tileWidth = (std::max((loadOp.tile.lrs >> 2) - (loadOp.tile.uls >> 2), 0) + 1) & 0x03FF;
+            uint16_t tileHeight = (std::max((loadOp.tile.lrt >> 2) - (loadOp.tile.ult >> 2), 0) + 1) & 0x03FF;
+            tileWidth = (loadOp.tile.masks != 0) ? std::min(tileWidth, uint16_t(1U << loadOp.tile.masks)) : tileWidth;
+            bpl = loadOp.texture.width << loadOp.texture.siz >> 1;
+            hashWidth = std::min(tileWidth, loadOp.texture.width);
+            if (loadOp.tile.siz > drawTile.siz) {
+                hashWidth <<= loadOp.tile.siz - drawTile.siz;
+            }
+
+            hashHeight = (loadOp.tile.maskt != 0) ? std::min(tileHeight, uint16_t(1U << loadOp.tile.maskt)) : tileHeight;
+        }
+        else {
+            const int tileWidth = std::max((drawTile.lrs >> 2) - (drawTile.uls >> 2), 0) + 1;
+            const int tileHeight = std::max((drawTile.lrt >> 2) - (drawTile.ult >> 2), 0) + 1;
+            const int maskWidth = (drawTile.masks == 0) ? tileWidth : (1 << drawTile.masks);
+            const int maskHeight = (drawTile.maskt == 0) ? tileHeight : (1 << drawTile.maskt);
+            const bool clamps = (drawTile.masks == 0) || (drawTile.cms & G_TX_CLAMP);
+            const bool clampt = (drawTile.maskt == 0) || (drawTile.cmt & G_TX_CLAMP);
+            hashWidth = (clamps && (tileWidth <= 256)) ? std::min(maskWidth, tileWidth) : maskWidth;
+            hashHeight = ((clampt && (tileHeight <= 256)) || (maskHeight > 256)) ? std::min(maskHeight, tileHeight) : maskHeight;
+            if (drawTile.siz == G_IM_SIZ_32b) {
+                bpl = drawTile.line << 4;
+            }
+            else if (loadOp.tile.lrt == 0) {
+                bpl = drawTile.line << 3;
+            }
+            else {
+                uint32_t dxt = loadOp.tile.lrt;
+                if (dxt > 1) {
+                    dxt = ReverseDXT(dxt, loadOp.texture.width, loadOp.texture.siz);
+                }
+
+                bpl = dxt << 3;
+            }
+        }
+
+        // Rice hashes at least this many bytes; texture_hasher skips a texture whose dump is shorter.
+        if ((hashWidth <= 0) || (hashHeight <= 0) || (bpl <= 0)) {
+            return {};
+        }
+
+        const uint32_t expectedSize = (hashHeight - 1) * bpl + (hashWidth << drawTile.siz >> 1);
+        if (expectedSize > rdramCount) {
+            return {};
+        }
+
+        const uint32_t riceCrc = RiceCRC32(rdramBytes, hashWidth, hashHeight, drawTile.siz, bpl);
+        const std::string key = hashString(riceCrc) + "#" + std::to_string(drawTile.fmt) + "#" + std::to_string(drawTile.siz);
+        if (tlut == 0) {
+            return { key };
+        }
+
+        // The palette, as loaded last into the TLUT half of TMEM (TextureManager::dumpTexture).
+        const bool CI4 = (drawTile.siz == G_IM_SIZ_4b);
+        const int32_t paletteTMEM = (RDP_TMEM_WORDS >> 1) + (CI4 ? (drawTile.palette << 4) : 0);
+        const LoadOperation &paletteLoadOp = state->rdp->rice.lastLoadOpByTMEM[paletteTMEM];
+        const uint32_t paletteBytesOffset = (paletteLoadOp.tile.uls >> 2) << paletteLoadOp.texture.siz >> 1;
+        const uint32_t paletteBytesPerRow = paletteLoadOp.texture.width << paletteLoadOp.texture.siz >> 1;
+        const uint32_t paletteRowCount = 1 + ((paletteLoadOp.tile.lrt >> 2) - (paletteLoadOp.tile.ult >> 2));
+        const uint32_t paletteWordsPerRow = ((paletteLoadOp.tile.lrs >> 2) - (paletteLoadOp.tile.uls >> 2)) + 1;
+        const uint32_t paletteRdramStart = paletteLoadOp.texture.address + paletteBytesOffset + paletteBytesPerRow * (paletteLoadOp.tile.ult >> 2);
+        const uint32_t paletteRdramCount = (paletteRowCount - 1) * paletteBytesPerRow + (paletteWordsPerRow << 3);
+        if ((paletteRdramCount == 0) || (paletteRdramStart >= RiceRDRAMBytes) || (paletteRdramCount > (RiceRDRAMBytes - paletteRdramStart))) {
+            return { key };
+        }
+
+        const uint8_t *paletteBytes = state->RDRAM + paletteRdramStart;
+        const uint8_t cimax = CI4 ? CalculateMaxCI4b(rdramBytes, hashWidth, hashHeight, bpl) : CalculateMaxCI8b(rdramBytes, hashWidth, hashHeight, bpl);
+
+        // The palette CRC hashes cimax + 1 entries of two bytes: make sure they're in RDRAM.
+        if ((uint32_t(cimax) + 1) * 2 > (RiceRDRAMBytes - paletteRdramStart)) {
+            return { key };
+        }
+
+        const uint32_t ricePaletteCrc = RiceCRC32(paletteBytes, cimax + 1, 1, 2, CI4 ? 32 : 512);
+
+        const std::string paletteKey = key + "#" + hashString(ricePaletteCrc);
+        if (drawTile.fmt == G_IM_FMT_CI) {
+            return { paletteKey, key };
+        }
+        else {
+            return { key, paletteKey };
+        }
+    }
+};
diff --git a/src/hle/rt64_rice_hash.h b/src/hle/rt64_rice_hash.h
new file mode 100644
index 0000000..a4c715c
--- /dev/null
+++ b/src/hle/rt64_rice_hash.h
@@ -0,0 +1,27 @@
+//
+// RT64
+//
+// SPDX-License-Identifier: GPL-2.0-or-later
+//
+// Rice texture hashes, worked out live from RDRAM so texture packs named for GLideN64 and Rice Video
+// (<name>#<crc>#<format>#<size>[#<palette crc>]_all.png) replace textures without a dumped database.
+// The hashing imitates GLideN64's and Rice Video's, as RT64's texture_hasher tool does, and is under
+// the GPL, version 2 or later, like its sources (see rt64_rice_hash.cpp for them).
+//
+
+#pragma once
+
+#include <string>
+#include <vector>
+
+#include "common/rt64_load_types.h"
+
+namespace RT64 {
+    struct State;
+
+    // The Rice names a pack could give the texture loadTile samples (as width x height, with this TLUT):
+    // "crc#format#size" and, with a palette, "crc#format#size#palette crc" (GLideN64 only names the
+    // palette of CI textures, so for others the name without it comes first). Empty if the load isn't
+    // one Rice hashes.
+    std::vector<std::string> riceTextureKeys(const State *state, const LoadTile &loadTile, uint16_t width, uint16_t height, uint32_t tlut);
+};
diff --git a/src/hle/rt64_rigid_body.cpp b/src/hle/rt64_rigid_body.cpp
index fd8b3eb..7f54303 100644
--- a/src/hle/rt64_rigid_body.cpp
+++ b/src/hle/rt64_rigid_body.cpp
@@ -4,6 +4,9 @@
 
 #include "rt64_rigid_body.h"
 
+#include <algorithm>
+#include <cmath>
+
 #include "../include/rt64_extended_gbi.h"
 #include "common/rt64_math.h"
 
@@ -24,11 +27,11 @@ namespace RT64 {
             hlslpp::float3 prevPosition = prevTransform[3].xyz;
             hlslpp::float3 curPosition = curTransform[3].xyz;
             hlslpp::float3 curLinearVelocity = curPosition - prevPosition;
-            hlslpp::float3 curAcceleration = (curLinearVelocity - linearVelocity);
             float prevVelMag = hlslpp::length(linearVelocity);
             float curVelMag = hlslpp::length(curLinearVelocity);
-            float dotCurVel = std::max(hlslpp::dot(linearVelocity / std::max(prevVelMag, Epsilon), curLinearVelocity / std::max(curVelMag, Epsilon))[0], Epsilon);
-            curVelMag /= dotCurVel;
+            // A change of direction alone isn't a teleport: animations swing parts back and forth
+            // (Conker's walk reverses some of his every few frames), and snapping them on each
+            // reversal while the rest is interpolated makes the model vibrate. Only a jump in speed is.
             lerpTranslation = (curVelMag < VelocityTolerance) || (curVelMag / std::max(prevVelMag, Epsilon)) < MagnitudeThreshold;
             linearVelocity = curLinearVelocity;
         }
@@ -70,6 +73,30 @@ namespace RT64 {
         }
     }
 
+    bool RigidBody::updateCameraCut(const hlslpp::float4x4 &prevView, const hlslpp::float4x4 &curView) {
+        // The camera itself (a view matrix's inverse): where it is (row 3) and which way it looks (row 2).
+        const hlslpp::float4x4 prevCamera = hlslpp::inverse(prevView);
+        const hlslpp::float4x4 curCamera = hlslpp::inverse(curView);
+        const float move = hlslpp::length(curCamera[3].xyz - prevCamera[3].xyz);
+        const hlslpp::float3 prevForward = prevCamera[2].xyz;
+        const hlslpp::float3 curForward = curCamera[2].xyz;
+        const float lengths = hlslpp::length(prevForward) * hlslpp::length(curForward);
+        const float cosTurn = (lengths > 1e-6f) ? float(hlslpp::dot(prevForward, curForward)) / lengths : 1.0f;
+        const float turn = std::acos(std::clamp(cosTurn, -1.0f, 1.0f));
+
+        // A cut is a jump well beyond both a camera's usual pace and the one it just had: moving further than MinCutMove
+        // (world units) or turning more than MinCutTurn in one game frame, and CutJump times as far as the frame before.
+        // A camera that speeds up keeps interpolating; one that jumps to another shot, whose in-between frames would show
+        // it partway along the jump (inside the scenery, looking between the two shots), doesn't.
+        const float MinCutMove = 150.0f; // TODO: Make configurable.
+        const float MinCutTurn = 50.0f * 3.14159265f / 180.0f;
+        const float CutJump = 4.0f;
+        const bool cut = ((move > MinCutMove) && (move > cameraMove * CutJump)) || ((turn > MinCutTurn) && (turn > cameraTurn * CutJump));
+        cameraMove = move;
+        cameraTurn = turn;
+        return cut;
+    }
+
     void RigidBody::updatePerspective(const hlslpp::float4x4 &prevTransform, const hlslpp::float4x4 &curTransform, uint8_t perspInterpolation) {
         // TODO auto perspective interpolation.
         lerpPerspective = (perspInterpolation == G_EX_COMPONENT_INTERPOLATE);
diff --git a/src/hle/rt64_rigid_body.h b/src/hle/rt64_rigid_body.h
index 778e08b..f53d597 100644
--- a/src/hle/rt64_rigid_body.h
+++ b/src/hle/rt64_rigid_body.h
@@ -20,6 +20,10 @@ namespace RT64 {
         bool lerpPerspective = false;
         bool lerpDecompose = true;
 
+        // Cameras: how far the camera moved and turned (radians) over the last game frame.
+        float cameraMove = 0.0f;
+        float cameraTurn = 0.0f;
+
         // Default constructor.
         RigidBody();
 
@@ -29,6 +33,10 @@ namespace RT64 {
         // Updates the vectors with the data from the transforms and updates the rigid body to determine if rotation, scale, and skew interpolation should be skipped.
         void updateAngular(const hlslpp::float4x4 &prevTransform, const hlslpp::float4x4 &curTransform, uint8_t rotInterpolation, uint8_t scaleInterpolation, uint8_t skewInterpolation);
 
+        // Cameras: whether going from prevView to curView is a cut to another shot rather than the camera moving, and
+        // keeps how far it moved and turned, to compare the next frame with.
+        bool updateCameraCut(const hlslpp::float4x4 &prevView, const hlslpp::float4x4 &curView);
+
         // Determines if the perspective components of the transforms should be interpolated.
         void updatePerspective(const hlslpp::float4x4 &prevTransform, const hlslpp::float4x4 &curTransform, uint8_t perspInterpolation);
 
diff --git a/src/hle/rt64_rsp.cpp b/src/hle/rt64_rsp.cpp
index 1da2550..c0aeee5 100644
--- a/src/hle/rt64_rsp.cpp
+++ b/src/hle/rt64_rsp.cpp
@@ -4,7 +4,11 @@
 
 #include "rt64_rsp.h"
 
+#include "common/rt64_conker_view_focus.h"
+
+#include <algorithm>
 #include <cassert>
+#include <cmath>
 
 #include "../include/rt64_extended_gbi.h"
 #include "common/rt64_common.h"
@@ -56,6 +60,8 @@ namespace RT64 {
         lights.fill({});
         segments.fill(0);
         viewportStack[0] = {};
+        extended.viewportFocusXScaleStack.fill(1.0f);
+        extended.viewportFocusYScaleStack.fill(1.0f);
         clipRatios[0] = 1;
         clipRatios[1] = 1;
         clipRatios[2] = -1;
@@ -427,6 +433,215 @@ namespace RT64 {
         setVertexCommon<false, sizeof(VertexEXV1)>(rdramAddress, dstIndex, dstIndex + vtxCount);
     }
 
+    // Conker's Bad Fur Day (F3DEX2CBFD). Based on GLideN64's implementation.
+
+    void RSP::setVertexCBFD(uint32_t address, uint32_t vtxCount, uint32_t dstIndex) {
+        if ((dstIndex >= RSP_MAX_VERTICES) || ((dstIndex + vtxCount) > RSP_MAX_VERTICES)) {
+            assert(false && "Vertex indices are not valid. DL is possibly corrupted.");
+            return;
+        }
+
+        const uint32_t rdramAddress = fromSegmentedMasked(address);
+        const Vertex *dlVerts = reinterpret_cast<const Vertex *>(state->fromRDRAM(rdramAddress));
+        memcpy(&vertices[dstIndex], dlVerts, sizeof(Vertex) * vtxCount);
+        // Texture generation first: without the advanced lighting's normals, it reads a vertex's normal
+        // from its colour, which the lighting then replaces.
+        if (cbfd.lighting && cbfd.textureGen) {
+            textureGenVerticesCBFD(dstIndex, vtxCount);
+        }
+
+        if (cbfd.lighting) {
+            lightVerticesCBFD(dstIndex, vtxCount);
+        }
+
+        setVertexCommon<true, sizeof(Vertex)>(rdramAddress, dstIndex, dstIndex + vtxCount);
+    }
+
+    void RSP::setLightCBFD(uint32_t index, uint32_t address) {
+        if (index >= cbfd.lights.size()) {
+            return;
+        }
+
+        // Light layout (big-endian offsets): colour r,g,b at 0-2, direction x,y,z (s8) at 8-10,
+        // attenuation at 12, position x,y,z (s16) at 32-37.
+        const uint32_t rdramAddress = fromSegmentedMasked(address);
+        const uint8_t *data = state->fromRDRAM(rdramAddress);
+        auto byteAt = [&](uint32_t offset) { return data[offset ^ 3]; };
+        auto shortAt = [&](uint32_t offset) { return *reinterpret_cast<const int16_t *>(&data[offset ^ 2]); };
+        CBFDLight &light = cbfd.lights[index];
+        light.r = byteAt(0) / 255.0f;
+        light.g = byteAt(1) / 255.0f;
+        light.b = byteAt(2) / 255.0f;
+        float dx = int8_t(byteAt(8)), dy = int8_t(byteAt(9)), dz = int8_t(byteAt(10));
+        float len = std::sqrt(dx * dx + dy * dy + dz * dz);
+        if (len > 0.0f) {
+            dx /= len; dy /= len; dz /= len;
+        }
+        light.dir[0] = dx;
+        light.dir[1] = dy;
+        light.dir[2] = dz;
+        light.pos[0] = shortAt(32);
+        light.pos[1] = shortAt(34);
+        light.pos[2] = shortAt(36);
+        light.ca = byteAt(12) / 16.0f;
+    }
+
+    void RSP::setCoordModCBFD(uint32_t w0, uint32_t w1) {
+        if ((w0 & 8) != 0) {
+            return;
+        }
+
+        const uint32_t idx = (w0 >> 1) & 3;
+        const uint32_t pos = w0 & 0x30;
+        auto &mod = cbfd.coordMod;
+        if (pos == 0x00) {
+            mod[0 + idx] = float(int16_t(w1 >> 16));
+            mod[1 + idx] = float(int16_t(w1 & 0xFFFF));
+        }
+        else if (pos == 0x10) {
+            mod[4 + idx] = float(w1 >> 16) / 65536.0f;
+            mod[5 + idx] = float(w1 & 0xFFFF) / 65536.0f;
+            mod[12 + idx] = mod[0 + idx] + mod[4 + idx];
+            mod[13 + idx] = mod[1 + idx] + mod[5 + idx];
+        }
+        else if (pos == 0x20) {
+            mod[8 + idx] = float(int16_t(w1 >> 16));
+            mod[9 + idx] = float(int16_t(w1 & 0xFFFF));
+        }
+    }
+
+    // Texture generation (environment mapping, e.g. the gold of the Rareware logo, glass) on the CPU,
+    // as TextureGen.hlsli does it on the GPU for the other microcodes: the vertex's normal against
+    // the look-at vectors, in model space (turned back by the modelview's rotation, as the lights'
+    // directions are), gives each texture coordinate. The result goes into the vertex's s and t, so
+    // that the texture scale then applies as setVertexCommon applies it with texture generation
+    // (the scale / 65536 times the generated coordinate): s = generated * 32.
+    void RSP::textureGenVerticesCBFD(uint32_t dstIndex, uint32_t vtxCount) {
+        const hlslpp::float4x4 &modelView = modelMatrixStack[modelMatrixStackSize - 1];
+        auto toModel = [&](const interop::float3 &v) {
+            const hlslpp::float3 d = hlslpp::mul(modelView, hlslpp::float4(v.x, v.y, v.z, 0.0f)).xyz;
+            const float len = hlslpp::length(d);
+            return (len > 0.0f) ? hlslpp::float3(d / len) : hlslpp::float3(0.0f, 0.0f, 0.0f);
+        };
+        const hlslpp::float3 lookAtX = toModel(lookAt.x);
+        const hlslpp::float3 lookAtY = toModel(lookAt.y);
+        const uint8_t *rdram = state->fromRDRAM(0);
+        for (uint32_t i = dstIndex; i < dstIndex + vtxCount; i++) {
+            Vertex &vtx = vertices[i];
+            hlslpp::float3 normal;
+            if (cbfd.advancedLighting) {
+                const uint32_t normalAddress = cbfd.normalBase + (i << 1);
+                normal = hlslpp::float3(
+                    float(int8_t(rdram[(normalAddress + 0) ^ 3])) / 127.0f,
+                    float(int8_t(rdram[(normalAddress + 1) ^ 3])) / 127.0f,
+                    float(int8_t(vtx.flag & 0xFF)) / 127.0f);
+            }
+            else {
+                normal = hlslpp::float3(vtx.normal.x / 127.0f, vtx.normal.y / 127.0f, vtx.normal.z / 127.0f);
+            }
+
+            float u = std::clamp(float(hlslpp::dot(normal, lookAtX)), -1.0f, 1.0f);
+            float v = std::clamp(float(hlslpp::dot(normal, lookAtY)), -1.0f, 1.0f);
+            if (cbfd.textureGenLinear) {
+                u = std::acos(-u) * 325.94932f; // 1024 / pi
+                v = std::acos(-v) * 325.94932f;
+            }
+            else {
+                u = (u + 1.0f) * 512.0f;
+                v = (v + 1.0f) * 512.0f;
+            }
+
+            vtx.s = int16_t(std::clamp(u * 32.0f, -32768.0f, 32767.0f));
+            vtx.t = int16_t(std::clamp(v * 32.0f, -32768.0f, 32767.0f));
+        }
+    }
+
+    void RSP::lightVerticesCBFD(uint32_t dstIndex, uint32_t vtxCount) {
+        const int numLights = int(std::min<uint32_t>(cbfd.lightCount, uint32_t(cbfd.lights.size() - 1)));
+        const auto &mod = cbfd.coordMod;
+        const uint32_t geometryMode = geometryModeStack[geometryModeStackSize - 1];
+        const bool pointLighting = (geometryMode & G_POINT_LIGHTING) != 0;
+
+        // Directional lights in model space: the modelview's rotation applied inversely.
+        hlslpp::float3 lightDirs[12];
+        const hlslpp::float4x4 &modelView = modelMatrixStack[modelMatrixStackSize - 1];
+        for (int l = 0; l < numLights; l++) {
+            const CBFDLight &light = cbfd.lights[l];
+            hlslpp::float4 d = hlslpp::mul(modelView, hlslpp::float4(light.dir[0], light.dir[1], light.dir[2], 0.0f));
+            hlslpp::float3 d3 = d.xyz;
+            float len = hlslpp::length(d3);
+            lightDirs[l] = (len > 0.0f) ? (d3 / len) : hlslpp::float3(0.0f, 0.0f, 0.0f);
+        }
+
+        // The point lights' positions are in clip space (before the divide), as GLideN64 has them: a vertex
+        // is transformed by the modelview and projection first, then scaled by the coordinate modifier.
+        // The modelview-projection is only computed when the vertices are submitted (setVertexCommon),
+        // after the lighting, so it's computed here when it's out of date.
+        const hlslpp::float4x4 modelViewProj = modelViewProjChanged ?
+            hlslpp::mul(modelView, viewProjMatrixStack[projectionMatrixStackSize - 1]) : modelViewProjMatrix;
+
+        const uint8_t *rdram = state->fromRDRAM(0);
+        for (uint32_t i = dstIndex; i < dstIndex + vtxCount; i++) {
+            Vertex &vtx = vertices[i];
+            if (int16_t(vtx.flag) < 0) {
+                continue;
+            }
+
+            const hlslpp::float4 clip = hlslpp::mul(hlslpp::float4(float(vtx.x), float(vtx.y), float(vtx.z), 1.0f), modelViewProj);
+            const float px = (float(clip.x) + mod[8]) * mod[12];
+            const float py = (float(clip.y) + mod[9]) * mod[13];
+            const float pz = (float(clip.z) + mod[10]) * mod[14];
+
+            // The ambient colour follows the last light.
+            float r = cbfd.lights[numLights].r;
+            float g = cbfd.lights[numLights].g;
+            float b = cbfd.lights[numLights].b;
+
+            hlslpp::float3 normal(0.0f, 0.0f, 0.0f);
+            int l = numLights - 1;
+            if (cbfd.advancedLighting) {
+                const uint32_t normalAddress = cbfd.normalBase + (i << 1);
+                normal = hlslpp::float3(
+                    float(int8_t(rdram[(normalAddress + 0) ^ 3])) / 127.0f,
+                    float(int8_t(rdram[(normalAddress + 1) ^ 3])) / 127.0f,
+                    float(int8_t(vtx.flag & 0xFF)) / 127.0f);
+
+                // The last light is directional.
+                if (l >= 0) {
+                    float intensity = std::min(1.0f, float(hlslpp::dot(normal, lightDirs[l])));
+                    if (intensity > 0.0f) {
+                        r += cbfd.lights[l].r * intensity;
+                        g += cbfd.lights[l].g * intensity;
+                        b += cbfd.lights[l].b * intensity;
+                    }
+                }
+            }
+
+            // The others are point lights.
+            for (l = numLights - 2; l >= 0; l--) {
+                const CBFDLight &light = cbfd.lights[l];
+                const float vx = px - light.pos[0];
+                const float vy = py - light.pos[1];
+                const float vz = pz - light.pos[2];
+                const float len = 2.0f * (vx * vx + vy * vy + vz * vz) / 65536.0f;
+                float intensity = (len > 0.0f) ? std::min(1.0f, light.ca / len) : 1.0f;
+                if (cbfd.advancedLighting && pointLighting) {
+                    intensity *= std::min(1.0f, float(hlslpp::dot(normal, lightDirs[l])));
+                }
+
+                if (intensity > 0.0f) {
+                    r += light.r * intensity;
+                    g += light.g * intensity;
+                    b += light.b * intensity;
+                }
+            }
+
+            vtx.color.r = uint8_t(std::min(1.0f, r) * vtx.color.r);
+            vtx.color.g = uint8_t(std::min(1.0f, g) * vtx.color.g);
+            vtx.color.b = uint8_t(std::min(1.0f, b) * vtx.color.b);
+        }
+    }
+
     void RSP::setVertexColorPD(uint32_t address) {
         vertexColorPDAddress = fromSegmentedMasked(address);
     }
@@ -471,6 +686,8 @@ namespace RT64 {
             drawData.viewProjTransformGroups.emplace_back(extended.curViewProjMatrixIdGroupIndex);
             drawData.rspViewports.emplace_back(viewportStack[viewportStackSize - 1]);
             drawData.viewportOrigins.emplace_back(extended.viewportOriginStack[viewportStackSize - 1]);
+            drawData.viewportFocusXScales.emplace_back(extended.viewportFocusXScaleStack[viewportStackSize - 1]);
+            drawData.viewportFocusYScales.emplace_back(extended.viewportFocusYScaleStack[viewportStackSize - 1]);
 
             for (uint32_t j = 0; j < 4; j++) {
                 drawData.viewportClipRatios.emplace_back(clipRatios[j]);
@@ -506,13 +723,18 @@ namespace RT64 {
         const int workloadCursor = state->ext.workloadQueue->writeCursor;
         Workload &workload = state->ext.workloadQueue->workloads[workloadCursor];
 
+        // A new group starts a new transform even when the matrix is the same: otherwise the vertices after a
+        // group is pushed or popped are added to the previous transform, in the group it was made in (the
+        // commands after a group would count as its own).
+        bool groupChanged = false;
         if (extended.modelMatrixIdStackChanged) {
             const int stackIndex = extended.modelMatrixIdStackSize - 1;
             extended.curModelMatrixIdGroupIndex = int(workload.drawData.transformGroups.size());
             workload.drawData.transformGroups.emplace_back(extended.modelMatrixIdStack[stackIndex]);
             extended.modelMatrixIdStackChanged = false;
+            groupChanged = true;
         }
-        
+
         // ModelViewProj is only updated when a vertex is processed and the flag is enabled.
         auto &worldTransforms = workload.drawData.worldTransforms;
         auto &worldTransformGroups = workload.drawData.worldTransformGroups;
@@ -520,6 +742,12 @@ namespace RT64 {
         auto &worldTransformPhysicalAddresses = workload.drawData.worldTransformPhysicalAddresses;
         auto &worldTransformVertexIndices = workload.drawData.worldTransformVertexIndices;
         bool addWorldTransform = (modelViewProjChanged || modelViewProjInserted);
+        if (groupChanged && !addWorldTransform && !worldTransforms.empty()) {
+            const hlslpp::float4x4 current = worldTransforms[curTransformIndex];
+            curTransformIndex = static_cast<uint16_t>(worldTransforms.size());
+            worldTransforms.emplace_back(current);
+            addWorldTransform = true;
+        }
         if (modelViewProjChanged) {
             computeModelViewProj();
             curTransformIndex = static_cast<uint16_t>(worldTransforms.size());
@@ -731,6 +959,22 @@ namespace RT64 {
                 tcFloats.emplace_back((float)((double)((vertices[i].s) * TextureSc) / Divisor));
                 tcFloats.emplace_back((float)((double)((vertices[i].t) * TextureTc) / Divisor));
             }
+
+            // Conker's shadows (issues #73 and #75): a character's shadow is the patch of ground under it drawn again
+            // with a 64 by 64 texture on it, which the game draws every frame (the character's silhouette) and
+            // RT64 renders at the resolution's scale. Its texture coordinates are pulled in 1/16 of the way towards the
+            // middle (2 texels at each edge), so the patch never samples the texture's outermost texels. On the
+            // reporter's AMD GPU under Linux, at high resolutions, those came out dark, and a thin dark line ran along
+            // the edge of the patch next to Conker. Clamping the texture instead of wrapping it kept the line, so it's
+            // in the edge texels themselves; this inset took it away. The silhouette is drawn inside the edges, so the
+            // shadow looks the same, 6% larger (checked on Windows).
+            if ((workload.drawData.transformGroups[extended.curModelMatrixIdGroupIndex].matrixId >> 16) == 0x5348) {
+                const float shadowPull = 1.0f - 1.0f / 16.0f;
+                const size_t added = size_t(dstMax - dstIndex) * 2;
+                for (size_t i = tcFloats.size() - added; i < tcFloats.size(); i++) {
+                    tcFloats[i] = 32.0f + (tcFloats[i] - 32.0f) * shadowPull;
+                }
+            }
         }
     }
 
@@ -841,7 +1085,12 @@ namespace RT64 {
         const uint32_t globalIndex = indices[vtxIndex];
         const float screenZ = workload.drawData.posScreen[globalIndex][2] * DepthRange;
         const float zValueFloat = zValue / 65536.0f;
-        if (forceBranch || (screenZ < zValueFloat)) {
+        // A vertex behind the camera has a meaningless screen depth. The RSP's depth of
+        // such a vertex is out of range, which takes the branch (like GLideN64 does):
+        // otherwise a model whose test vertex is behind the camera, like a bridge
+        // being walked over, falls to its far version, often nothing.
+        const bool behindCamera = workload.drawData.posTransformed[globalIndex][3] <= 0.0f;
+        if (forceBranch || behindCamera || (screenZ < zValueFloat)) {
             const uint32_t rdramAddress = fromSegmentedMasked(branchDl);
             *dl = reinterpret_cast<DisplayList *>(state->fromRDRAM(rdramAddress)) - 1;
         }
@@ -910,6 +1159,36 @@ namespace RT64 {
         viewport.translate.y = float(vp->vtrans[0] + offy) / 4.0f;
         viewport.translate.z = float(vp->vtrans[3]) / DepthRange;
         extended.viewportOriginStack[viewportStackSize - 1] = ori;
+
+        // Conker: netplay's "my view only", drawn anew (rt64_conker_view_focus.h).
+        float focusXScale = 1.0f;
+        float focusYScale = 1.0f;
+        const ConkerViewFocus focus = conkerViewFocus();
+        if (conkerFocusApplies(focus, state->rdp->colorImage.width, state->rdp->colorImage.address)) {
+            const float halfWidth = std::fabs(viewport.scale.x);
+            const float halfHeight = std::fabs(viewport.scale.y);
+            int index = 0;
+            const ConkerViewPart part = conkerViewPart(focus, viewport.translate.x - halfWidth, viewport.translate.y - halfHeight,
+                viewport.translate.x + halfWidth, viewport.translate.y + halfHeight, index);
+            if ((part == ConkerViewPart::Focused) && (halfWidth > 0.0f) && (halfHeight > 0.0f)) {
+                // Stretched with the view to where it's drawn; the projection scaled so what's drawn keeps its shape.
+                const ConkerFocusView &view = focus.views[index];
+                const float stretchX = (view.right - view.left) / (view.srcRight - view.srcLeft);
+                const float stretchY = (view.bottom - view.top) / (view.srcBottom - view.srcTop);
+                conkerFocusScale(view, focus.count > 1, focusXScale, focusYScale);
+                viewport.translate.x = conkerMapX(view, viewport.translate.x);
+                viewport.translate.y = conkerMapY(view, viewport.translate.y);
+                viewport.scale.x *= stretchX;
+                viewport.scale.y *= stretchY;
+            }
+            else if (part == ConkerViewPart::Other) {
+                viewport.scale.x = 0.0f;
+                viewport.scale.y = 0.0f;
+            }
+        }
+
+        extended.viewportFocusXScaleStack[viewportStackSize - 1] = focusXScale;
+        extended.viewportFocusYScaleStack[viewportStackSize - 1] = focusYScale;
         viewportChanged = true;
     }
 
@@ -917,6 +1196,8 @@ namespace RT64 {
         if (viewportStackSize < RSP_EXTENDED_STACK_SIZE) {
             viewportStack[viewportStackSize] = viewportStack[viewportStackSize - 1];
             extended.viewportOriginStack[viewportStackSize] = extended.viewportOriginStack[viewportStackSize - 1];
+            extended.viewportFocusXScaleStack[viewportStackSize] = extended.viewportFocusXScaleStack[viewportStackSize - 1];
+            extended.viewportFocusYScaleStack[viewportStackSize] = extended.viewportFocusYScaleStack[viewportStackSize - 1];
             viewportStackSize++;
         }
     }
@@ -1152,6 +1433,16 @@ namespace RT64 {
 
             const interop::RSPViewport &viewport = viewportStack[viewportStackSize - 1];
             const FixedRect viewportClipRect = viewport.rect(clipRatios.data());
+
+            // A triangle beside the 4:3 area is still drawn when the picture is widened, so it must still count: clamp
+            // it into the area horizontally (at least a pixel wide) instead of dropping it. A pair whose triangles are
+            // all beside it (a door at the side of the widened screen) otherwise has no draw area and isn't drawn at all.
+            const FixedRect clipRect = viewportClipRect.intersection(scissorRect);
+            if (!clipRect.isNull() && ((clipRect.lrx - clipRect.ulx) >= 4)) {
+                drawRect.ulx = std::clamp(drawRect.ulx, clipRect.ulx, clipRect.lrx - 4);
+                drawRect.lrx = std::clamp(drawRect.lrx, clipRect.ulx + 4, clipRect.lrx);
+            }
+
             drawRect = viewportClipRect.intersection(scissorRect.intersection(drawRect));
             if (!drawRect.isNull()) {
                 fbPair.drawColorRect.merge(drawRect);
diff --git a/src/hle/rt64_rsp.h b/src/hle/rt64_rsp.h
index 61bb3b1..b76a3d6 100644
--- a/src/hle/rt64_rsp.h
+++ b/src/hle/rt64_rsp.h
@@ -162,6 +162,28 @@ namespace RT64 {
         std::bitset<RSP_MAX_VERTICES> used;
         std::array<Light, RSP_MAX_LIGHTS + 1> lights;
         int lightCount;
+
+        // State for Conker's Bad Fur Day's modified F3DEX2 (GBIUCode::F3DEX2CBFD). Its
+        // lighting (point lights, separate normals, a coordinate modifier) doesn't map
+        // onto RT64's shader lighting, so it is computed into the vertex colours on the
+        // CPU and G_LIGHTING is hidden from the shaders.
+        struct CBFDLight {
+            float r = 0.0f, g = 0.0f, b = 0.0f;
+            float dir[3] = {};
+            float pos[3] = {};
+            float ca = 0.0f;
+        };
+
+        struct {
+            bool lighting = false;              // G_LIGHTING as the game set it.
+            bool textureGen = false;            // G_TEXTURE_GEN as the game set it.
+            bool textureGenLinear = false;      // G_TEXTURE_GEN_LINEAR as the game set it.
+            bool advancedLighting = false;      // Switched on by G_LOAD_UCODE.
+            uint32_t normalBase = 0;            // Physical address of the per-vertex normals.
+            uint32_t lightCount = 0;
+            std::array<CBFDLight, 12> lights;
+            std::array<float, 20> coordMod = {};
+        } cbfd;
         uint32_t vertexFogIndex;
         uint32_t vertexLightIndex;
         uint32_t vertexLightCount;
@@ -205,6 +227,9 @@ namespace RT64 {
             } global;
 
             std::array<uint16_t, RSP_EXTENDED_STACK_SIZE> viewportOriginStack;
+            // Conker: how much each viewport's projection is scaled across and up and down (rt64_conker_view_focus.h).
+            std::array<float, RSP_EXTENDED_STACK_SIZE> viewportFocusXScaleStack;
+            std::array<float, RSP_EXTENDED_STACK_SIZE> viewportFocusYScaleStack;
 
             DrawExtendedType drawExtendedType;
             DrawExtendedData drawExtendedData;
@@ -254,6 +279,11 @@ namespace RT64 {
         void setVertex(uint32_t address, uint32_t vtxCount, uint32_t dstIndex);
         void setVertexPD(uint32_t address, uint32_t vtxCount, uint32_t dstIndex);
         void setVertexEXV1(uint32_t address, uint32_t vtxCount, uint32_t dstIndex);
+        void setVertexCBFD(uint32_t address, uint32_t vtxCount, uint32_t dstIndex);
+        void setLightCBFD(uint32_t index, uint32_t address);
+        void setCoordModCBFD(uint32_t w0, uint32_t w1);
+        void lightVerticesCBFD(uint32_t dstIndex, uint32_t vtxCount);
+        void textureGenVerticesCBFD(uint32_t dstIndex, uint32_t vtxCount);
         void setVertexColorPD(uint32_t address);
         void setVertexSegmentV1(bool isEnabled, uint32_t vertexElement, uint32_t vertexAddress, uint32_t baseSegmentAddress);
         template<uint32_t floatCount, uint32_t vertexSize>
diff --git a/src/hle/rt64_state.cpp b/src/hle/rt64_state.cpp
index 2970e71..3e8520a 100644
--- a/src/hle/rt64_state.cpp
+++ b/src/hle/rt64_state.cpp
@@ -4,6 +4,8 @@
 
 #include "rt64_state.h"
 
+#include "common/rt64_fblog.h"
+
 #include <cassert>
 #include <cinttypes>
 
@@ -540,6 +542,27 @@ namespace RT64 {
         FramebufferPair &fbPair = workload.fbPairs[fbPairIndex];
         fbPair.flushReason = flushReason;
 
+        // TEMP-DEBUG (Conker): FbLog, see common/rt64_fblog.h.
+        FbLog::setThreadFrame(workload.submissionFrame, "hle");
+        const bool fbLog = FbLog::threadActive();
+        if (fbLog) {
+            FbLog::print("[hle %llu] pair %d submit reason %d color 0x%08X w %u siz %u fmt %u depth 0x%08X depthRead %d depthWrite %d fillRectOnly %d projections %u calls %u",
+                (unsigned long long)(workload.submissionFrame), fbPairIndex, int(flushReason), fbPair.colorImage.address, fbPair.colorImage.width, fbPair.colorImage.siz, fbPair.colorImage.fmt,
+                fbPair.depthImage.address, fbPair.depthRead, fbPair.depthWrite, fbPair.fillRectOnly, fbPair.projectionCount, fbPair.gameCallCount);
+            FbLog::print("[hle %llu] pair %d drawColorRect " RT64_FBLOG_RECT_FMT " drawDepthRect " RT64_FBLOG_RECT_FMT " scissorRect " RT64_FBLOG_RECT_FMT " pendingFbOps %zu",
+                (unsigned long long)(workload.submissionFrame), fbPairIndex, RT64_FBLOG_RECT(fbPair.drawColorRect), RT64_FBLOG_RECT(fbPair.drawDepthRect), RT64_FBLOG_RECT(fbPair.scissorRect), drawFbOperations.size());
+            for (const FramebufferOperation &op : drawFbOperations) {
+                if (op.type == FramebufferOperation::Type::CreateTileCopy) {
+                    const FramebufferTile &t = op.createTileCopy.fbTile;
+                    FbLog::print("[hle %llu] pair %d   op tileCopy id %llu from 0x%08X tile (%u,%u)-(%u,%u) lineWidth %u siz %u fmt %u",
+                        (unsigned long long)(workload.submissionFrame), fbPairIndex, (unsigned long long)(op.createTileCopy.id), op.createTileCopy.address, t.left, t.top, t.right, t.bottom, t.lineWidth, t.siz, t.fmt);
+                }
+                else {
+                    FbLog::print("[hle %llu] pair %d   op type %d", (unsigned long long)(workload.submissionFrame), fbPairIndex, int(op.type));
+                }
+            }
+        }
+
         // Add all the pending framebuffer operations to the first one that was found.
         flushFramebufferOperations(fbPair);
 
@@ -551,6 +574,10 @@ namespace RT64 {
             uint32_t depthWriteWidth = 0;
             RT64::Framebuffer *colorFb = &framebufferManager.get(colorImg.address, colorImg.siz, colorImg.width, colorHeight);
             colorImg.formatChanged = colorFb->widthChanged || colorFb->sizChanged || colorFb->rdramChanged;
+            if (fbLog) {
+                FbLog::print("[hle %llu] pair %d colorFb 0x%08X w %u h %u widthChanged %d sizChanged %d rdramChanged %d -> formatChanged %d",
+                    (unsigned long long)(workload.submissionFrame), fbPairIndex, colorFb->addressStart, colorFb->width, colorFb->height, colorFb->widthChanged, colorFb->sizChanged, colorFb->rdramChanged, colorImg.formatChanged);
+            }
             colorFb->clearChanged();
             colorFb->addDitherPatterns(fbPair.ditherPatterns);
 
@@ -562,6 +589,11 @@ namespace RT64 {
 
                 depthFb = &framebufferManager.get(depthImg.address, G_IM_SIZ_16b, colorImg.width, colorHeight);
                 depthImg.formatChanged = depthFb->widthChanged || depthFb->sizChanged || depthFb->rdramChanged;
+                if (fbLog) {
+                    FbLog::print("[hle %llu] pair %d depthFb 0x%08X w %u h %u widthChanged %d sizChanged %d rdramChanged %d -> formatChanged %d depthWriteWidth %u",
+                        (unsigned long long)(workload.submissionFrame), fbPairIndex, depthFb->addressStart, depthFb->width, depthFb->height, depthFb->widthChanged, depthFb->sizChanged, depthFb->rdramChanged, depthImg.formatChanged, depthWriteWidth);
+                }
+
                 depthFb->clearChanged();
 
                 // Detect a fast path by checking if the framebuffer pair previous to the current one only did fill rects.
@@ -604,6 +636,10 @@ namespace RT64 {
             }
         }
 
+        if (fbLog) {
+            FbLog::print("[hle %llu] pair %d syncRequired %d", (unsigned long long)(workload.submissionFrame), fbPairIndex, fbPair.syncRequired);
+        }
+
         // Store the process Id this framebuffer pair was submitted under.
         fbPair.displayListAddress = displayListAddress;
         fbPair.displayListCounter = displayListCounter;
@@ -630,6 +666,16 @@ namespace RT64 {
         {
             framebufferManager.storeRAM(workload.fbStorage, RDRAM, fbPairIndex);
             framebufferManager.checkRAM(RDRAM, differentFbs, true);
+
+            // TEMP-DEBUG (Conker): FbLog, see common/rt64_fblog.h. Framebuffers whose RDRAM changed outside the RDP (the CPU).
+            FbLog::setThreadFrame(workload.submissionFrame, "hle");
+            if (FbLog::threadActive()) {
+                FbLog::print("[hle %llu] checkRDRAM at pair %u: %zu framebuffers differ", (unsigned long long)(workload.submissionFrame), fbPairIndex, differentFbs.size());
+                for (const Framebuffer *fb : differentFbs) {
+                    FbLog::print("[hle %llu]   differs: fb 0x%08X w %u h %u siz %u lastWriteType %d RAMBytes %u",
+                        (unsigned long long)(workload.submissionFrame), fb->addressStart, fb->width, fb->height, fb->siz, int(fb->lastWriteType), fb->RAMBytes);
+                }
+            }
             if (!differentFbs.empty()) {
                 RenderWorkerExecution execution(ext.framebufferGraphicsWorker);
                 framebufferManager.uploadRAM(ext.framebufferGraphicsWorker, differentFbs.data(), differentFbs.size(), workload.fbChangePool, RDRAM, true, drawFbOperations, drawFbDiscards, ext.shaderLibrary);
@@ -818,7 +864,8 @@ namespace RT64 {
 
         // Validate all tile copies to be used during the rendering.
         const bool extendedRenderToRAMSet = (extended.renderToRAM < UINT8_MAX);
-        const bool renderToRDRAM = extendedRenderToRAMSet ? (extended.renderToRAM != 0) : ext.emulatorConfig->framebuffer.renderToRAM;
+        // Conker: not while the game's host has it off (setRenderToRAMOff).
+        const bool renderToRDRAM = !renderToRAMOff() && (extendedRenderToRAMSet ? (extended.renderToRAM != 0) : ext.emulatorConfig->framebuffer.renderToRAM);
         const bool warningsEnabled = ext.userConfig->developerMode;
         const bool linearFiltering = !ext.userConfig->threePointFiltering;
         const size_t callTileCount = workload.drawData.callTiles.size();
@@ -1611,6 +1658,9 @@ namespace RT64 {
         }
 #   endif
 
+        // Conker: whether this frame is drawn without frames between it and the next (setInterpolationPaused).
+        workload.skipInterpolation = interpolationPaused();
+
         // Store the presentation rate in the workload.
         if (extended.refreshRate != UINT16_MAX) {
             workload.viOriginalRate = extended.refreshRate;
@@ -2666,10 +2716,22 @@ namespace RT64 {
         present.presentId = ++presentId;
         present.workloadId = workloadId;
         present.paused = paused;
+        present.repeated = false;
         present.debuggerFramebuffer.address = debuggerInspector.renderer.framebufferAddress;
         present.debuggerFramebuffer.view = (debuggerInspector.renderer.framebufferIndex >= 0);
     }
 
+    // The last present again, paused (as the debugger's pause does, without its workload: nothing is drawn anew
+    // but what the present draws over the frame), once the queues are done with it. Repeated: the frame once.
+    void State::presentAgain() {
+        ext.presentQueue->waitForPresentId(presentId);
+        ext.presentQueue->waitForIdle();
+        Present &lastPresent = ext.presentQueue->presents[ext.presentQueue->previousWriteCursor()];
+        advancePresent(lastPresent, true);
+        lastPresent.repeated = true;
+        ext.presentQueue->repeatLastPresent();
+    }
+
     void State::dpInterrupt() {
         *MI_INTR_REG |= MI_INTR_DP;
         checkInterrupts();
@@ -2727,6 +2789,13 @@ namespace RT64 {
     void State::setDitherNoiseStrength(float noiseStrength) {
         extended.ditherNoiseStrength = noiseStrength;
     }
+
+    // Conker: gEXConkerBlurFramebuffer, for the workload being made (WorkloadQueue blurs the picture as it draws it).
+    void State::setConkerBlurFramebuffer(uint32_t address, uint8_t strength) {
+        Workload &workload = ext.workloadQueue->workloads[ext.workloadQueue->writeCursor];
+        workload.extended.conkerBlurAddress = address & 0x00FFFFFF;
+        workload.extended.conkerBlurStrength = strength;
+    }
     
     void State::setExtendedRDRAM(bool isExtended) {
         extended.extendRDRAM = isExtended;
diff --git a/src/hle/rt64_state.h b/src/hle/rt64_state.h
index 7a8c13b..8400363 100644
--- a/src/hle/rt64_state.h
+++ b/src/hle/rt64_state.h
@@ -153,6 +153,7 @@ namespace RT64 {
         void inspect();
         void advanceWorkload(Workload &workload, bool paused);
         void advancePresent(Present &present, bool paused);
+        void presentAgain();
         void dpInterrupt();
         void spInterrupt();
         void advanceFramebufferRenderer();
@@ -165,6 +166,7 @@ namespace RT64 {
         void setDitherNoiseStrength(float noiseStrength);
         void setExtendedRDRAM(bool isExtended);
         void setTexcoordWrapPoint(int16_t wrapU, int16_t wrapV);
+        void setConkerBlurFramebuffer(uint32_t address, uint8_t strength);
         void startSpriteCommand(uint64_t replacementHash);
         void endSpriteCommand();
         uint8_t *fromRDRAM(uint32_t rdramAddress) const;
diff --git a/src/hle/rt64_workload.cpp b/src/hle/rt64_workload.cpp
index b4c85f5..d025d8b 100644
--- a/src/hle/rt64_workload.cpp
+++ b/src/hle/rt64_workload.cpp
@@ -4,7 +4,33 @@
 
 #include "rt64_workload.h"
 
+#include <atomic>
+#include <cstdlib>
+
+#include "../include/rt64_extended_gbi.h"
+
 namespace RT64 {
+    // Conker: see rt64_workload.h.
+    static std::atomic<bool> interpolationPausedFlag{ false };
+
+    void setInterpolationPaused(bool paused) {
+        interpolationPausedFlag = paused;
+    }
+
+    bool interpolationPaused() {
+        return interpolationPausedFlag;
+    }
+
+    static std::atomic<bool> renderToRAMOffFlag{ false };
+
+    void setRenderToRAMOff(bool off) {
+        renderToRAMOffFlag = off;
+    }
+
+    bool renderToRAMOff() {
+        return renderToRAMOffFlag;
+    }
+
     // Common functions.
 
     static uint64_t roundUp(uint64_t value, uint64_t powerOf2Alignment) {
@@ -22,6 +48,8 @@ namespace RT64 {
         workloadId = 0;
         extended.testZIndexCount = 0;
         extended.ditherNoiseStrength = 1.0f;
+        extended.conkerBlurAddress = 0;
+        extended.conkerBlurStrength = 0;
 
         commandWarnings.clear();
         spriteCommands.clear();
@@ -68,6 +96,8 @@ namespace RT64 {
         drawData.rspViewports.clear();
         drawData.viewportClipRatios.clear();
         drawData.viewportOrigins.clear();
+        drawData.viewportFocusXScales.clear();
+        drawData.viewportFocusYScales.clear();
         drawData.rspFog.clear();
         drawData.rspLights.clear();
         drawData.rspLookAt.clear();
@@ -102,6 +132,8 @@ namespace RT64 {
 
         // Push an identity matrix into the transforms by default so rects can use them.
         drawData.rspViewports.push_back(interop::RSPViewport::identity());
+        drawData.viewportFocusXScales.push_back(1.0f);
+        drawData.viewportFocusYScales.push_back(1.0f);
         drawData.viewTransforms.push_back(interop::float4x4::identity());
         drawData.projTransforms.push_back(interop::float4x4::identity());
         drawData.viewProjTransforms.push_back(interop::float4x4::identity());
@@ -315,6 +347,82 @@ namespace RT64 {
         return addedPair;
     }
 
+    bool Workload::viewOfProjection(const Projection &proj, FixedRect &viewRect) const {
+        if ((proj.type != Projection::Type::Perspective) || proj.scissorRect.isNull()) {
+            return false;
+        }
+
+        const interop::RSPViewport &viewport = drawData.rspViewports[proj.transformsIndex];
+        const int16_t *viewportClipRatios = &drawData.viewportClipRatios[proj.transformsIndex * 4];
+        viewRect = proj.scissorRect.intersection(viewport.rect(viewportClipRatios));
+        return !viewRect.isEmpty() && (drawData.viewportOrigins[proj.transformsIndex] == G_EX_ORIGIN_NONE);
+    }
+
+    bool Workload::pairWidensView(const FramebufferPair &fbPair, const Projection &proj) const {
+        FixedRect viewRect;
+        if (!viewOfProjection(proj, viewRect)) {
+            return false;
+        }
+
+        const FixedRect wideningScissor = fbPair.wideningScissor();
+        const FixedRect &pairScissor = wideningScissor.isNull() ? proj.scissorRect : wideningScissor;
+        if (viewRect.width(true, true) <= viewRect.height(true, true)) {
+            return false;
+        }
+
+        if ((viewRect.ulx <= pairScissor.ulx + CoversWidthViewportSlack) && (viewRect.lrx >= pairScissor.lrx - CoversWidthViewportSlack)) {
+            return true;
+        }
+
+        // Conker: a split screen's row of views drawn in one pair (Beach's top two quarters in one, its bottom two in
+        // another): side by side they span the pair's width, and each is widened as if it had the pair to itself.
+        auto closeTo = [](int32_t a, int32_t b) { return std::abs(a - b) <= CoversWidthSlack; };
+        int32_t rowLeft = viewRect.ulx, rowRight = viewRect.lrx;
+        uint32_t rowViews = 0;
+        for (uint32_t p = 0; p < fbPair.projectionCount; p++) {
+            FixedRect otherRect;
+            if (!viewOfProjection(fbPair.projections[p], otherRect) || !closeTo(otherRect.uly, viewRect.uly) || !closeTo(otherRect.lry, viewRect.lry)) {
+                continue;
+            }
+
+            // Another view of the row, not one across it (its width is part of the row's).
+            if (!closeTo(otherRect.ulx, viewRect.ulx) || !closeTo(otherRect.lrx, viewRect.lrx)) {
+                rowViews++;
+            }
+
+            rowLeft = std::min(rowLeft, otherRect.ulx);
+            rowRight = std::max(rowRight, otherRect.lrx);
+        }
+
+        return (rowViews > 0) && (rowLeft <= pairScissor.ulx + CoversWidthViewportSlack) && (rowRight >= pairScissor.lrx - CoversWidthViewportSlack);
+    }
+
+    bool Workload::widensView(uint32_t colorAddress, const FixedRect &viewRect) const {
+        auto closeTo = [](int32_t a, int32_t b) { return std::abs(a - b) <= CoversWidthSlack; };
+        for (uint32_t q = 0; q < fbPairCount; q++) {
+            const FramebufferPair &viewPair = fbPairs[q];
+            if (viewPair.colorImage.address != colorAddress) {
+                continue;
+            }
+
+            for (uint32_t p = 0; p < viewPair.projectionCount; p++) {
+                const Projection &viewProj = viewPair.projections[p];
+                FixedRect otherRect;
+                if (!viewOfProjection(viewProj, otherRect)) {
+                    continue;
+                }
+
+                if (closeTo(otherRect.ulx, viewRect.ulx) && closeTo(otherRect.lrx, viewRect.lrx) && closeTo(otherRect.uly, viewRect.uly) && closeTo(otherRect.lry, viewRect.lry) &&
+                    pairWidensView(viewPair, viewProj))
+                {
+                    return true;
+                }
+            }
+        }
+
+        return false;
+    }
+
     int Workload::currentFramebufferPairIndex() const {
         if (fbPairCount > 0) {
             return fbPairCount - 1;
diff --git a/src/hle/rt64_workload.h b/src/hle/rt64_workload.h
index 8ea27d5..d28d37e 100644
--- a/src/hle/rt64_workload.h
+++ b/src/hle/rt64_workload.h
@@ -23,6 +23,19 @@
 #include "rt64_transform_group.h"
 
 namespace RT64 {
+    // Conker: whether the frames the game makes from now on are drawn without frames between them, set by the
+    // game's host each frame and stored in each workload as it's made (Workload::skipInterpolation). Conker's
+    // motion blur (drunk) blends each frame with a copy of the last: with frames drawn between the game's, the
+    // last frame is a fraction of a frame old, and the blur was all but gone (issue #77).
+    void setInterpolationPaused(bool paused);
+    bool interpolationPaused();
+
+    // Conker: renders nothing back into the game's memory (its color and depth images), whatever the emulator's
+    // Render to RAM, while the game's host asks (netplay's deterministic mode): those writes come from the
+    // renderer's thread whenever it gets to a display list, and a headless run, with no renderer, has none.
+    void setRenderToRAMOff(bool off);
+    bool renderToRAMOff();
+
     struct DrawData {
         std::vector<float> posFloats;
         std::vector<float> velFloats;
@@ -62,6 +75,8 @@ namespace RT64 {
         std::vector<interop::RSPViewport> rspViewports;
         std::vector<int16_t> viewportClipRatios;
         std::vector<uint16_t> viewportOrigins;
+        std::vector<float> viewportFocusXScales;
+        std::vector<float> viewportFocusYScales;
         std::vector<interop::RSPFog> rspFog;
         std::vector<interop::RSPLight> rspLights;
         std::vector<interop::RSPLookAt> rspLookAt;
@@ -234,11 +249,16 @@ namespace RT64 {
         uint64_t workloadId = 0;
         uint64_t presentId = 0;
         bool paused = false;
+        // Conker: drawn without frames between it and the next (setInterpolationPaused).
+        bool skipInterpolation = false;
 
         struct {
             uint32_t testZIndexCount = 0;
             float ditherNoiseStrength = 1.0f;
             hlslpp::float2 texcoordWrapPoint = {};
+            // Conker: the color image whose picture is blurred once drawn, and by how much (gEXConkerBlurFramebuffer).
+            uint32_t conkerBlurAddress = 0;
+            uint8_t conkerBlurStrength = 0;
         } extended;
 
         void reset();
@@ -253,5 +273,17 @@ namespace RT64 {
         void begin(uint64_t submissionFrame);
         bool addFramebufferPair(uint32_t colorAddress, uint8_t colorFmt, uint8_t colorSiz, uint16_t colorWidth, uint32_t depthAddress);
         int currentFramebufferPairIndex() const;
+
+        // A 3D view's rect (its scissor and viewport's intersection) and whether a pair widens it: the view covers the
+        // pair's widening scissor (FramebufferPair::wideningScissor), or its row of side-by-side views in the pair does
+        // together (a split screen's two views in one pair), is wider than tall and has no custom origin.
+        bool viewOfProjection(const Projection &proj, FixedRect &viewRect) const;
+        bool pairWidensView(const FramebufferPair &fbPair, const Projection &proj) const;
+
+        // Whether the same view as viewRect, drawn to colorAddress, is widened in any of this frame's pairs. Conker's split
+        // screen (issue #78) draws each player's level in a pair of its own, widened, then every player's characters,
+        // doors and HUD in one pair across the frame, where no player's view covers the pair: their characters were drawn
+        // at 4:3, off the middle of their widened view. A view that's widened anywhere in the frame is widened everywhere.
+        bool widensView(uint32_t colorAddress, const FixedRect &viewRect) const;
     };
 };
\ No newline at end of file
diff --git a/src/hle/rt64_workload_queue.cpp b/src/hle/rt64_workload_queue.cpp
index 5a331aa..c2c5f25 100644
--- a/src/hle/rt64_workload_queue.cpp
+++ b/src/hle/rt64_workload_queue.cpp
@@ -4,6 +4,8 @@
 
 #include "rt64_workload_queue.h"
 
+#include "common/rt64_fblog.h"
+
 #include "common/rt64_thread.h"
 
 #include "rt64_present_queue.h"
@@ -449,6 +451,15 @@ namespace RT64 {
                         colorFb = &fbManager.get(colorImg.address, colorImg.siz, nativeColorWidth, nativeColorHeight);
                     }
 
+                    // Draw at the framebuffer's full height, not only down to the lowest row this pair's triangles were seen
+                    // to cover. That was measured on the N64's 4:3 screen, where triangles beside it, or crossing the plane of
+                    // the camera, don't count; the widened picture does show them. A pair drawn only at the side (Conker's
+                    // objects, once the camera's depth-row copy splits them off from the level) was cut off below that row.
+                    const Framebuffer *heightFb = (colorFb != nullptr) ? colorFb : depthFb;
+                    if ((heightFb != nullptr) && (heightFb->width == nativeColorWidth)) {
+                        nativeColorHeight = std::max(nativeColorHeight, heightFb->height);
+                    }
+
                     if (colorFb != nullptr) {
                         fbKey.colorTargetKey = RenderTargetKey(colorFb->addressStart, colorFb->width, colorFb->siz, Framebuffer::Type::Color);
                         colorTarget = &targetManager.get(fbKey.colorTargetKey);
@@ -508,6 +519,16 @@ namespace RT64 {
             colorDepthPairs.clear();
 
             const uint32_t fbPairCount = (debuggerRenderer.framebufferIndex >= 0) ? (debuggerRenderer.framebufferIndex + 1) : workload.fbPairCount;
+
+            // TEMP-DEBUG (Conker): FbLog, see common/rt64_fblog.h.
+            FbLog::setThreadFrame(workload.submissionFrame, "hires");
+            const bool fbLog = FbLog::threadActive();
+            const unsigned long long fbLogFrame = (unsigned long long)(workload.submissionFrame);
+            if (fbLog) {
+                FbLog::print("[hires %llu] frame: %u pairs, resolutionScale %.4f x %.4f, aspectRatioSource %.4f target %.4f scale %.4f (rects are 10.2 fixed point: 4 = one pixel)",
+                    fbLogFrame, fbPairCount, float(workloadConfig.resolutionScale.x), float(workloadConfig.resolutionScale.y), workloadConfig.aspectRatioSource, workloadConfig.aspectRatioTarget, workloadConfig.aspectRatioScale);
+            }
+
             for (uint32_t f = 0; f < fbPairCount; f++) {
                 const FramebufferPair &fbPair = workload.fbPairs[f];
 #           if RT_ENABLED
@@ -538,9 +559,19 @@ namespace RT64 {
                         depthFb->nativeTarget.resetBufferHistory();
                     }
 
+                    if (fbLog) {
+                        FbLog::print("[hires %llu] pair %u targets: colorFb 0x%08X depthFb 0x%08X native %ux%u fixedResScale %.4f x %.4f -> rt %ux%u misalign %u; colorTarget %ux%u depthTarget %ux%u",
+                            fbLogFrame, f, (colorFb != nullptr) ? colorFb->addressStart : 0, (depthFb != nullptr) ? depthFb->addressStart : 0, nativeColorWidth, nativeColorHeight, float(fixedResScale.x), float(fixedResScale.y),
+                            rtWidth, rtHeight, targetMisalignX, (colorTarget != nullptr) ? colorTarget->width : 0, (colorTarget != nullptr) ? colorTarget->height : 0,
+                            (depthTarget != nullptr) ? depthTarget->width : 0, (depthTarget != nullptr) ? depthTarget->height : 0);
+                    }
+
                     if ((colorTarget != nullptr) && colorTarget->resize(ext.workloadGraphicsWorker, rtWidth, rtHeight)) {
                         resizedTargets.emplace(colorTarget);
                         colorFb->readHeight = 0;
+                        if (fbLog) {
+                            FbLog::print("[hires %llu] pair %u   color target RESIZED to %ux%u", fbLogFrame, f, colorTarget->width, colorTarget->height);
+                        }
                     }
 
                     // Set up the dummy target used for rendering the depth if no depth framebuffer is active.
@@ -566,6 +597,9 @@ namespace RT64 {
                         if (depthTarget->resize(ext.workloadGraphicsWorker, rtWidth, rtHeight)) {
                             resizedTargets.emplace(depthTarget);
                             depthFb->readHeight = 0;
+                            if (fbLog) {
+                                FbLog::print("[hires %llu] pair %u   DEPTH target RESIZED to %ux%u (its contents are lost)", fbLogFrame, f, depthTarget->width, depthTarget->height);
+                            }
                         }
                     }
                 }
@@ -577,6 +611,10 @@ namespace RT64 {
             // Make sure all depth targets are at least bigger than their corresponding color targets.
             for (auto colorDepthPair : colorDepthPairs) {
                 if (colorDepthPair.second->resize(ext.workloadGraphicsWorker, colorDepthPair.first->width, colorDepthPair.first->height)) {
+                    if (fbLog) {
+                        FbLog::print("[hires %llu] a depth target was RESIZED to match its color target: %ux%u", fbLogFrame, colorDepthPair.second->width, colorDepthPair.second->height);
+                    }
+
                     resizedTargets.emplace(colorDepthPair.second);
                 }
             }
@@ -709,6 +747,12 @@ namespace RT64 {
             for (uint32_t f = 0; f < fbPairCount; f++) {
                 const FramebufferPair &fbPair = workload.fbPairs[f];
                 bool validTargets = getTargetsFromPair(f);
+                if (fbLog) {
+                    FbLog::print("[hires %llu] pair %u record: validTargets %d startOps %zu endOps %zu formatChanged color %d depth %d, depthFb lastWriteType %d readHeight %u height %u",
+                        fbLogFrame, f, validTargets, fbPair.startFbOperations.size(), fbPair.endFbOperations.size(), fbPair.colorImage.formatChanged, fbPair.depthImage.formatChanged,
+                        (validTargets && (depthFb != nullptr)) ? int(depthFb->lastWriteType) : -1, (validTargets && (depthFb != nullptr)) ? depthFb->readHeight : 0, (validTargets && (depthFb != nullptr)) ? depthFb->height : 0);
+                }
+
                 fbManager.recordOperations(ext.workloadGraphicsWorker, &workload.fbChangePool, &workload.fbStorage, ext.shaderLibrary, ext.textureCache,
                     fbPair.startFbOperations, targetManager, fixedResScale, f, workload.submissionFrame);
 
@@ -738,6 +782,11 @@ namespace RT64 {
 
                         if (colorFb->height > colorFb->readHeight) {
                             uint32_t readRowCount = colorFb->height - colorFb->readHeight;
+                            if (fbLog) {
+                                FbLog::print("[hires %llu] pair %u   color target 0x%08X rows %u-%u reloaded from RDRAM%s", fbLogFrame, f, colorFb->addressStart, colorFb->readHeight, colorFb->height,
+                                    colorImg.formatChanged ? " (formatChanged: cleared first)" : "");
+                            }
+
                             FramebufferChange *colorFbChange = colorFb->readChangeFromStorage(ext.workloadGraphicsWorker, workload.fbStorage, scratchFbChangePool,
                                 Framebuffer::Type::Color, colorImg.fmt, f, colorFb->readHeight, readRowCount, ext.shaderLibrary);
 
@@ -756,10 +805,20 @@ namespace RT64 {
                         depthFbTypeChanged = (depthFb->lastWriteType == Framebuffer::Type::Color);
 
                         bool imgFormatChanged = (colorFb == nullptr) ? colorImg.formatChanged : depthImg.formatChanged;
+                        if (fbLog && imgFormatChanged) {
+                            FbLog::print("[hires %llu] pair %u   DEPTH target CLEARED and reloaded from RDRAM (formatChanged)", fbLogFrame, f);
+                        }
+
                         if (imgFormatChanged) {
                             depthFb->discardLastWrite();
                         }
                         else if (depthFb->isLastWriteDifferent(Framebuffer::Type::Depth)) {
+                            if (fbLog) {
+                                const FixedRect &r = depthFb->lastWriteRect;
+                                FbLog::print("[hires %llu] pair %u   DEPTH target overwritten from its color-type target (lastWriteType %d) rect " RT64_FBLOG_RECT_FMT,
+                                    fbLogFrame, f, int(depthFb->lastWriteType), RT64_FBLOG_RECT(r));
+                            }
+
                             RenderTargetKey otherDepthTargetKey(depthFb->addressStart, depthFb->width, depthFb->siz, depthFb->lastWriteType);
                             RenderTarget &otherDepthTarget = targetManager.get(otherDepthTargetKey);
                             if (!otherDepthTarget.isEmpty()) {
@@ -777,6 +836,10 @@ namespace RT64 {
 
                         if (depthFb->height > depthFb->readHeight) {
                             uint32_t readRowCount = depthFb->height - depthFb->readHeight;
+                            if (fbLog) {
+                                FbLog::print("[hires %llu] pair %u   DEPTH target rows %u-%u reloaded from RDRAM (native %u wide)", fbLogFrame, f, depthFb->readHeight, depthFb->height, depthFb->width);
+                            }
+
                             FramebufferChange *depthFbChange = depthFb->readChangeFromStorage(ext.workloadGraphicsWorker, workload.fbStorage, scratchFbChangePool, Framebuffer::Type::Depth,
                                 G_IM_FMT_DEPTH, f, depthFb->readHeight, readRowCount, ext.shaderLibrary);
 
@@ -811,6 +874,26 @@ namespace RT64 {
                         overrideTarget->resolveFromTarget(ext.workloadGraphicsWorker, colorTarget, ext.shaderLibrary);
                     }
 
+                    // Conker: the picture asked for with gEXConkerBlurFramebuffer is blurred once the frame's last pair
+                    // drawing into it is drawn, before anything reads it (its tile copies are made as later pairs start).
+                    const uint32_t conkerBlurAddress = workload.extended.conkerBlurAddress;
+                    if ((conkerBlurAddress != 0) && (colorTarget != nullptr) && (colorFb != nullptr) && ((colorImg.address & 0x00FFFFFF) == conkerBlurAddress)) {
+                        bool lastPair = true;
+                        for (uint32_t g = f + 1; (g < fbPairCount) && lastPair; g++) {
+                            lastPair = ((workload.fbPairs[g].colorImage.address & 0x00FFFFFF) != conkerBlurAddress);
+                        }
+
+                        if (lastPair) {
+                            // The picture's native size at the high resolution, and sigma in N64 pixels, shrunk about as
+                            // much as the resolution is raised: the blur works on a picture about the N64's size.
+                            uint32_t blurWidth = 0, blurHeight = 0, blurMisalignment = 0;
+                            RenderTarget::computeScaledSize(colorFb->width, colorFb->height, fixedResScale, blurWidth, blurHeight, blurMisalignment);
+                            const uint32_t downsample = std::max(uint32_t(fixedResScale.y), 1U);
+                            const float sigma = (float(workload.extended.conkerBlurStrength) / 4.0f) * (fixedResScale.y / float(downsample));
+                            colorTarget->conkerBlur(ext.workloadGraphicsWorker, ext.shaderLibrary, blurWidth, blurHeight, downsample, sigma);
+                        }
+                    }
+
                     const uint64_t writeTimestamp = fbManager.nextWriteTimestamp();
                     FixedRect depthFbRect;
                     if (colorFb != nullptr) {
@@ -986,7 +1069,7 @@ namespace RT64 {
                     matchingProfiler.log();
 
                     const bool displayRateAboveOriginal = (workload.viOriginalRate > 0) && (workloadConfig.targetRate > workload.viOriginalRate);
-                    generateInterpolatedFrames = !workload.paused && displayRateAboveOriginal && !interpolationTargetKey.isEmpty();
+                    generateInterpolatedFrames = !workload.paused && !workload.skipInterpolation && displayRateAboveOriginal && !interpolationTargetKey.isEmpty();
 
                     const bool resetTicks = !generateInterpolatedFrames || (originalRateForTicks != workload.viOriginalRate) || (displayRateForTicks != workloadConfig.targetRate) || !displayRateAboveOriginal;
                     if (resetTicks) {
diff --git a/src/render/rt64_framebuffer_renderer.cpp b/src/render/rt64_framebuffer_renderer.cpp
index 9fae0d4..ce26584 100644
--- a/src/render/rt64_framebuffer_renderer.cpp
+++ b/src/render/rt64_framebuffer_renderer.cpp
@@ -7,6 +7,7 @@
 #include "../include/rt64_extended_gbi.h"
 
 #include "common/rt64_elapsed_timer.h"
+#include "common/rt64_fblog.h"
 #include "common/rt64_math.h"
 #include "hle/rt64_color_converter.h"
 #include "gbi/rt64_f3d.h"
@@ -218,7 +219,7 @@ namespace RT64 {
         textureCacheFreeSpaces = textureCache->textureMap.freeSpaces;
         textureCacheSize = static_cast<uint32_t>(textureCacheTextures.size());
         textureCacheGlobalVersion = textureCache->textureMap.globalVersion;
-        textureCacheReplacementMapEnabled = textureCache->textureMap.replacementMapEnabled;
+        textureCacheReplacementMapEnabled = textureCache->textureMap.replacementMapEnabled && !replacementsHidden(); // Conker
         dynamicTextureViewVector.clear();
         dynamicTextureBarrierVector.clear();
     }
@@ -599,8 +600,27 @@ namespace RT64 {
             case InstanceDrawCall::Type::FillRect: {
                 const auto &clearRect = drawCall.clearRect;
                 RenderTarget *chosenTarget = (fbStorage->colorTarget != nullptr) ? fbStorage->colorTarget : fbStorage->depthTarget;
-                bool rectCoversWholeTarget = (clearRect.rect.left == 0) && (clearRect.rect.top == 0) && (uint32_t(clearRect.rect.right) == chosenTarget->width) && (uint32_t(clearRect.rect.bottom) == chosenTarget->height);
-                const RenderRect *clearRects = rectCoversWholeTarget ? nullptr : &clearRect.rect;
+
+                // The rect, clipped to the target. A fill rect (drawn as this clear) can reach past the target's
+                // sides: Conker's cutscene pillarbox bars reach past both sides of the window. A clear's rects must
+                // be inside the target (Vulkan's vkCmdClearAttachments makes anything else undefined), and
+                // drivers differ in what they do with one that isn't. On Windows (NVIDIA, D3D12 and Vulkan)
+                // it was clipped as wanted. On Linux, lavapipe moved a rect starting left of the target to
+                // its left edge but kept its width, so the left bar came out too wide by the part that was
+                // off screen; and on the Steam Deck (RADV) one starting left of it seems not to be cleared at all,
+                // so there was no left bar and the strip kept old frames' pictures (issue #82). The right
+                // bar, which starts inside, was right everywhere.
+                RenderRect clippedRect = clearRect.rect;
+                clippedRect.left = std::max(clippedRect.left, 0);
+                clippedRect.top = std::max(clippedRect.top, 0);
+                clippedRect.right = std::min(clippedRect.right, int32_t(chosenTarget->width));
+                clippedRect.bottom = std::min(clippedRect.bottom, int32_t(chosenTarget->height));
+                if ((clippedRect.right <= clippedRect.left) || (clippedRect.bottom <= clippedRect.top)) {
+                    break;
+                }
+
+                bool rectCoversWholeTarget = (clippedRect.left == 0) && (clippedRect.top == 0) && (uint32_t(clippedRect.right) == chosenTarget->width) && (uint32_t(clippedRect.bottom) == chosenTarget->height);
+                const RenderRect *clearRects = rectCoversWholeTarget ? nullptr : &clippedRect;
                 uint32_t clearRectCount = rectCoversWholeTarget ? 0 : 1;
                 if (fbStorage->colorTarget != nullptr) {
                     worker->commandList->clearColor(0, clearRect.color, clearRects, clearRectCount);
@@ -1435,6 +1455,16 @@ namespace RT64 {
         const float scissorRatio = static_cast<float>(fbPair.scissorRect.width(false, true)) / static_cast<float>(fbPair.scissorRect.height(false, true));
         const bool adjustRatio = (abs((scissorRatio / p.aspectRatioSource) - 1.0f) < SimilarityPercentage);
         const float aspectRatioScale = adjustRatio ? (p.aspectRatioTarget / p.aspectRatioSource) : 1.0f;
+
+        // TEMP-DEBUG (Conker): FbLog, see common/rt64_fblog.h.
+        const bool fbLog = FbLog::frameLogged(p.curWorkload->submissionFrame);
+        const unsigned long long fbLogFrame = (unsigned long long)(p.curWorkload->submissionFrame);
+        if (fbLog) {
+            FbLog::print("[%s %llu] renderer pair %u: scissorRect " RT64_FBLOG_RECT_FMT " ratio %.4f vs source %.4f -> adjustRatio %d aspectRatioScale %.4f, fb %ux%u target %ux%u misalign %.1f",
+                FbLog::threadSide(), fbLogFrame, p.fbPairIndex, RT64_FBLOG_RECT(fbPair.scissorRect), scissorRatio, p.aspectRatioSource, adjustRatio, aspectRatioScale,
+                p.fbWidth, p.fbHeight, p.targetWidth, p.targetHeight, p.horizontalMisalignment);
+        }
+
         InstanceDrawCall instanceDrawCall;
         interop::RenderIndices renderIndices;
         uint32_t globalCallIndex = 0;
@@ -1450,6 +1480,46 @@ namespace RT64 {
         uint32_t vertexTestZFaceIndicesStart = 0;
         int32_t vertexTestZCallIndex = -1;
         RenderViewport viewportClip;
+
+        // Split-screen views that are widened (Conker's multiplayer, issue #78): each 3D view drawn to this pair's
+        // color image, widened as below and narrower than the frame. The HUD is drawn afterwards across the frame,
+        // with a scissor of the whole frame, each player's inside their view's 4:3 area; a widened view's HUD rects
+        // are scaled about its middle instead of the frame's (below), so each HUD stays on its own view, as in 4:3.
+        struct WidenedView {
+            FixedRect rect;
+            int32_t middleX;
+        };
+
+        std::vector<WidenedView> widenedViews;
+        const int32_t frameWidthFixed = int32_t(fbPair.colorImage.width) * 4;
+        for (uint32_t q = 0; q < p.curWorkload->fbPairCount; q++) {
+            const FramebufferPair &viewPair = p.curWorkload->fbPairs[q];
+            if (viewPair.colorImage.address != fbPair.colorImage.address) {
+                continue;
+            }
+
+            for (uint32_t vp = 0; vp < viewPair.projectionCount; vp++) {
+                const Projection &viewProj = viewPair.projections[vp];
+                if ((viewProj.type != Projection::Type::Perspective) || viewProj.scissorRect.isNull()) {
+                    continue;
+                }
+
+                const auto &viewViewport = drawData.rspViewports[viewProj.transformsIndex];
+                const int16_t *viewClipRatios = &drawData.viewportClipRatios[viewProj.transformsIndex * 4];
+                const FixedRect viewRect = viewProj.scissorRect.intersection(viewViewport.rect(viewClipRatios));
+                if (viewRect.isEmpty() || (drawData.viewportOrigins[viewProj.transformsIndex] != G_EX_ORIGIN_NONE)) {
+                    continue;
+                }
+
+                // The same test as the projections' (Workload::pairWidensView), rows of views in one pair included.
+                const bool widened = p.curWorkload->pairWidensView(viewPair, viewProj);
+                const bool narrowerThanFrame = (viewRect.lrx - viewRect.ulx) < (frameWidthFixed - 2 * CoversWidthSlack);
+                if (widened && narrowerThanFrame) {
+                    widenedViews.push_back({ viewRect, (viewRect.ulx + viewRect.lrx) / 2 });
+                }
+            }
+        }
+
         for (uint32_t pr = 0; (pr < fbPair.projectionCount) && (globalCallIndex < p.maxGameCall); pr++) {
             const Projection &proj = fbPair.projections[pr];
             if (proj.scissorRect.isNull()) {
@@ -1488,9 +1558,28 @@ namespace RT64 {
                 // The call's scissor spans the whole width of the framebuffer pair scissor. Custom origin must not be in use to be able to use the stretched viewport.
                 const auto &viewport = drawData.rspViewports[proj.transformsIndex];
                 FixedRect intersectionRect = proj.scissorRect.intersection(viewport.rect(viewportClipRatios));
-                bool coversWholeWidth = !intersectionRect.isEmpty() && (intersectionRect.ulx <= fbPair.scissorRect.ulx) && (intersectionRect.lrx >= fbPair.scissorRect.lrx);
+                // With no pair scissor (all its triangles culled), compare with the projection's own, as ProjectionProcessor does.
+                // In split screen the pair's scissor leaves out the frame's clear (FramebufferPair::wideningScissor, issue #78).
+                const FixedRect wideningScissor = fbPair.wideningScissor();
+                const FixedRect &pairScissor = wideningScissor.isNull() ? proj.scissorRect : wideningScissor;
+                bool coversWholeWidth = !intersectionRect.isEmpty() && (intersectionRect.ulx <= pairScissor.ulx + CoversWidthViewportSlack) && (intersectionRect.lrx >= pairScissor.lrx - CoversWidthViewportSlack);
                 bool horizontalRatio = !intersectionRect.isEmpty() && (intersectionRect.width(true, true) > intersectionRect.height(true, true));
                 bool useWideViewport = (viewportOrigin == G_EX_ORIGIN_NONE) && coversWholeWidth && horizontalRatio;
+
+                // A split-screen view widened in another pair of the frame is widened here too (Workload::widensView, issue #78).
+                const int32_t viewFrameWidthFixed = int32_t(fbPair.colorImage.width) * 4;
+                if (!useWideViewport && (viewportOrigin == G_EX_ORIGIN_NONE) && !intersectionRect.isEmpty() &&
+                    ((intersectionRect.lrx - intersectionRect.ulx) < (viewFrameWidthFixed - 2 * CoversWidthSlack)) &&
+                    p.curWorkload->widensView(fbPair.colorImage.address, intersectionRect))
+                {
+                    useWideViewport = true;
+                }
+                if (fbLog) {
+                    FbLog::print("[%s %llu] renderer pair %u proj %u type %d transforms %u calls %u: projScissor " RT64_FBLOG_RECT_FMT " viewport&scissor " RT64_FBLOG_RECT_FMT " origin %u -> covers %d horizontal %d useWideViewport %d",
+                        FbLog::threadSide(), fbLogFrame, p.fbPairIndex, pr, int(proj.type), proj.transformsIndex, proj.gameCallCount, RT64_FBLOG_RECT(proj.scissorRect), RT64_FBLOG_RECT(intersectionRect),
+                        viewportOrigin, coversWholeWidth, horizontalRatio, useWideViewport);
+                }
+
                 if (useWideViewport) {
                     projInvRatioScale = 1.0f;
                 }
@@ -1548,6 +1637,27 @@ namespace RT64 {
                     }
 
                     clearRect.rect = convertFixedRect(call.callDesc.rect, p.resolutionScale, p.fbWidth, invRatioScale, extOriginPercentage, horizontalMisalignment, call.callDesc.rectLeftOrigin, call.callDesc.rectRightOrigin);
+
+                    // The RDP clips a fill rect to the scissor, but the clear it's drawn as doesn't. Conker's split screen
+                    // (issue #78) fills each player's view with its background colour from a rect across the whole
+                    // frame, the scissor set to that view: each view's fill covered the whole frame, the views before
+                    // it included, so only the last player's level showed (the characters and doors, drawn after all
+                    // the fills, still did). The fill is clipped to its scissor, converted as the rect is: top and
+                    // bottom always, left and right when the scissor is narrower than the frame (a split-screen view).
+                    // A scissor across the frame leaves the sides as they were: a rect across it is stretched to the
+                    // widened frame, and rects drawn past the 4:3 area (the cutscene pillarbox bars, issue #82) stay.
+                    const FixedRect &fillScissor = call.callDesc.scissorRect;
+                    if (!fillScissor.isNull()) {
+                        const RenderRect scissorRect = convertFixedRect(fillScissor, p.resolutionScale, p.fbWidth, invRatioScale, extOriginPercentage, horizontalMisalignment, call.callDesc.scissorLeftOrigin, call.callDesc.scissorRightOrigin);
+                        clearRect.rect.top = std::max(clearRect.rect.top, scissorRect.top);
+                        clearRect.rect.bottom = std::min(clearRect.rect.bottom, scissorRect.bottom);
+                        const int32_t frameRight = int32_t(fbPair.colorImage.width) * 4;
+                        const bool scissorAcrossFrame = (fillScissor.ulx <= CoversWidthSlack) && (fillScissor.lrx >= frameRight - CoversWidthSlack);
+                        if (!scissorAcrossFrame) {
+                            clearRect.rect.left = std::max(clearRect.rect.left, scissorRect.left);
+                            clearRect.rect.right = std::min(clearRect.rect.right, scissorRect.right);
+                        }
+                    }
                 }
                 else if (call.callDesc.extendedType != DrawExtendedType::None) {
                     switch (call.callDesc.extendedType) {
@@ -1625,6 +1735,7 @@ namespace RT64 {
 
                         float invRatioScale = 1.0f / aspectRatioScale;
                         float horizontalMisalignment = 0.0f;
+                        bool wideRectScissor = false;
                         switch (proj.type) {
                         case Projection::Type::Perspective:
                         case Projection::Type::Orthographic: {
@@ -1645,14 +1756,62 @@ namespace RT64 {
                             // The call's scissor spans the whole width of the framebuffer pair scissor. The rect must not be using extended origins.
                             const bool regularOrigins = (call.callDesc.rectLeftOrigin == G_EX_ORIGIN_NONE) && (call.callDesc.rectRightOrigin == G_EX_ORIGIN_NONE);
                             const bool coversScissorWidth = regularOrigins && (call.callDesc.rect.ulx <= fbPair.scissorRect.ulx) && (call.callDesc.rect.lrx >= fbPair.scissorRect.lrx);
-                            if ((tileCopiesUsed || coversScissorWidth || call.callDesc.rectAspect == G_EX_ASPECT_STRETCH) && (call.callDesc.rectAspect != G_EX_ASPECT_ADJUST)) {
+                            const bool stretchAspect = (call.callDesc.rectAspect == G_EX_ASPECT_STRETCH) || (call.callDesc.rectAspect == G_EX_ASPECT_ZOOM);
+                            if ((tileCopiesUsed || coversScissorWidth || stretchAspect) && (call.callDesc.rectAspect != G_EX_ASPECT_ADJUST)) {
                                 invRatioScale = 1.0f;
                             }
                             else {
                                 horizontalMisalignment = p.horizontalMisalignment;
                             }
 
-                            RenderViewport viewportRect = convertViewportRect(call.callDesc.rect, p.resolutionScale, p.fbWidth, invRatioScale, extOriginPercentage, horizontalMisalignment, call.callDesc.rectLeftOrigin, call.callDesc.rectRightOrigin);
+                            // A HUD rect inside a widened split-screen view (see widenedViews) is scaled about the view's middle.
+                            uint16_t rectLeftOrigin = call.callDesc.rectLeftOrigin;
+                            uint16_t rectRightOrigin = call.callDesc.rectRightOrigin;
+                            if (regularOrigins && (invRatioScale != 1.0f) && !widenedViews.empty() && (frameWidthFixed > 0)) {
+                                // Wholly inside the view: the match's timer, drawn between the views and reaching into them, stays put
+                                // (going by its digits' middles split it, each half moved with a different view).
+                                const FixedRect &hudRect = call.callDesc.rect;
+                                for (const WidenedView &view : widenedViews) {
+                                    if ((hudRect.ulx >= view.rect.ulx) && (hudRect.lrx <= view.rect.lrx) && (hudRect.uly >= view.rect.uly) && (hudRect.lry <= view.rect.lry)) {
+                                        const long viewOrigin = std::lround((double(view.middleX) * G_EX_ORIGIN_RIGHT) / frameWidthFixed);
+                                        rectLeftOrigin = rectRightOrigin = uint16_t(std::clamp(viewOrigin, 0L, long(G_EX_ORIGIN_RIGHT)));
+                                        break;
+                                    }
+                                }
+                            }
+
+                            // A scissor spanning the frame's width clips the rect at the edges of the widened
+                            // frame, as it does for widened 3D, rather than at the 4:3 area: a rect the game draws
+                            // partly off the 4:3 screen (Conker's sprites near the edges) stays whole.
+                            const FixedRect &callScissor = call.callDesc.scissorRect;
+                            wideRectScissor = (call.callDesc.scissorLeftOrigin == G_EX_ORIGIN_NONE) && (call.callDesc.scissorRightOrigin == G_EX_ORIGIN_NONE) &&
+                                (callScissor.ulx <= fbPair.scissorRect.ulx + CoversWidthSlack) && (callScissor.lrx >= fbPair.scissorRect.lrx - CoversWidthSlack);
+
+                            RenderViewport viewportRect = convertViewportRect(call.callDesc.rect, p.resolutionScale, p.fbWidth, invRatioScale, extOriginPercentage, horizontalMisalignment, rectLeftOrigin, rectRightOrigin);
+
+                            // An untextured rect reaching one side of the frame (but not both: those are stretched above) continues to that
+                            // side of the widened frame (Conker's iris transitions draw their black this way).
+                            const bool reachesLeft = (call.callDesc.rect.ulx <= fbPair.scissorRect.ulx + CoversWidthSlack);
+                            const bool reachesRight = (call.callDesc.rect.lrx >= fbPair.scissorRect.lrx - CoversWidthSlack);
+                            if (regularOrigins && (rectLeftOrigin == G_EX_ORIGIN_NONE) && (invRatioScale != 1.0f) && (call.callDesc.tileCount == 0) && (reachesLeft != reachesRight)) {
+                                const RenderViewport wideFrame = convertViewportRect(fbPair.scissorRect, p.resolutionScale, p.fbWidth, 1.0f, extOriginPercentage, 0.0f, G_EX_ORIGIN_NONE, G_EX_ORIGIN_NONE);
+                                if (reachesLeft) {
+                                    const float right = viewportRect.x + viewportRect.width;
+                                    viewportRect.x = wideFrame.x;
+                                    viewportRect.width = right - wideFrame.x;
+                                }
+                                else {
+                                    viewportRect.width = (wideFrame.x + wideFrame.width) - viewportRect.x;
+                                }
+                            }
+
+                            // Zoomed: stretched to the width above, and scaled as much vertically about the middle of the scissor.
+                            if ((call.callDesc.rectAspect == G_EX_ASPECT_ZOOM) && !call.callDesc.scissorRect.isNull()) {
+                                const float middle = ((call.callDesc.scissorRect.uly + call.callDesc.scissorRect.lry) / 8.0f) * p.resolutionScale.y;
+                                viewportRect.y = middle + (viewportRect.y - middle) * aspectRatioScale;
+                                viewportRect.height *= aspectRatioScale;
+                            }
+
                             triangles.screenScale = { viewportRect.width / framebuffer.viewport.width, viewportRect.height / framebuffer.viewport.height };
                             triangles.screenOffset.x = halfPixelOffset.x + ((viewportRect.x + viewportRect.width / 2.0f) - halfViewportSize.x) / halfViewportSize.x;
                             triangles.screenOffset.y = halfPixelOffset.y + (halfViewportSize.y - (viewportRect.y + viewportRect.height / 2.0f)) / halfViewportSize.y;
@@ -1676,7 +1835,12 @@ namespace RT64 {
                             break;
                         }
 
-                        triangles.scissor = convertFixedRect(call.callDesc.scissorRect, p.resolutionScale, p.fbWidth, invRatioScale, extOriginPercentage, int32_t(horizontalMisalignment), call.callDesc.scissorLeftOrigin, call.callDesc.scissorRightOrigin);
+                        if (wideRectScissor) {
+                            triangles.scissor = convertFixedRect(call.callDesc.scissorRect, p.resolutionScale, p.fbWidth, 1.0f, extOriginPercentage, 0, call.callDesc.scissorLeftOrigin, call.callDesc.scissorRightOrigin);
+                        }
+                        else {
+                            triangles.scissor = convertFixedRect(call.callDesc.scissorRect, p.resolutionScale, p.fbWidth, invRatioScale, extOriginPercentage, int32_t(horizontalMisalignment), call.callDesc.scissorLeftOrigin, call.callDesc.scissorRightOrigin);
+                        }
 
                         bool usesViewport = (proj.type == Projection::Type::Perspective) || (proj.type == Projection::Type::Orthographic);
                         if (usesViewport) {
diff --git a/src/render/rt64_projection_processor.cpp b/src/render/rt64_projection_processor.cpp
index e842dcc..5b0ff63 100644
--- a/src/render/rt64_projection_processor.cpp
+++ b/src/render/rt64_projection_processor.cpp
@@ -4,6 +4,7 @@
 
 #include "rt64_projection_processor.h"
 
+#include "common/rt64_fblog.h"
 #include "common/rt64_math.h"
 #include "hle/rt64_workload_queue.h"
 
@@ -14,7 +15,40 @@ namespace RT64 {
         matrix[2][0] *= aspectRatioScale;
         matrix[3][0] *= aspectRatioScale;
     }
-    
+
+    // The same, about centerX (in normalized device coordinates) instead of the middle: x' = c + (x - c) * s, so in clip space
+    // x' = s * x + c * (1 - s) * w (with row vectors, column 0 is x and column 3 is w). Conker's split screen (issue #78) draws
+    // every view with a viewport across the frame, scissored to the view, and a projection moved sideways to put the picture
+    // in it: squeezed about the frame's middle, a side view's picture was pulled toward the middle of the window, its
+    // characters off the middle of their widened view.
+    inline void adjustProjectionMatrix(interop::float4x4 &matrix, const float aspectRatioScale, const float centerX) {
+        if (centerX == 0.0f) {
+            adjustProjectionMatrix(matrix, aspectRatioScale);
+            return;
+        }
+
+        const float shift = centerX * (1.0f - aspectRatioScale);
+        for (int r = 0; r < 4; r++) {
+            matrix[r][0] = matrix[r][0] * aspectRatioScale + matrix[r][3] * shift;
+        }
+    }
+
+    // How far ahead a perspective projection's camera is aimed: halfway between its near and far planes. Conker's Bad
+    // Fur Day aims each shadow's silhouette camera at the character, its planes just around it. With row vectors, w
+    // is the depth ahead (m[2][3] = -1) and z = m[2][2] * z + m[3][2] is -w at the near plane and w at the far one.
+    inline bool aimedDepth(const interop::float4x4 &m, float &depth) {
+        const float a = m[2][2];
+        const float b = m[3][2];
+        if ((m[2][3] != -1.0f) || (fabsf(a - 1.0f) < 1e-6f) || (fabsf(a + 1.0f) < 1e-6f)) {
+            return false;
+        }
+
+        const float nearDepth = b / (a - 1.0f);
+        const float farDepth = b / (a + 1.0f);
+        depth = 0.5f * (nearDepth + farDepth);
+        return std::isfinite(depth) && (nearDepth > 0.0f) && (farDepth > nearDepth);
+    }
+
     // ProjectionProcessor
 
     ProjectionProcessor::ProjectionProcessor() { }
@@ -83,6 +117,9 @@ namespace RT64 {
             const uint32_t curProjGroupIndex = workload.drawData.viewProjTransformGroups[proj.transformsIndex];
             const TransformGroup &curProjGroup = workload.drawData.transformGroups[curProjGroupIndex];
             bool adjustAspectRatio = (curProjGroup.aspectMode == G_EX_ASPECT_ADJUST);
+            // Where the projection is squeezed about, in normalized device coordinates: the middle (0), or a split-screen
+            // view's middle (see adjustProjectionMatrix, issue #78).
+            float projCenterX = 0.0f;
             if (curProjGroup.aspectMode == G_EX_ASPECT_AUTO) {
                 FixedRect intersectionRect = proj.scissorRect;
                 if (proj.usesViewport()) {
@@ -92,13 +129,43 @@ namespace RT64 {
                 }
 
                 if (!intersectionRect.isEmpty()) {
-                    bool coversWholeWidth = (intersectionRect.ulx <= fbPair.scissorRect.ulx) && (intersectionRect.lrx >= fbPair.scissorRect.lrx);
+                    // Same slack as FramebufferRenderer's wide viewport check (CoversWidthViewportSlack): the two must agree. A pair whose triangles were
+                    // all culled has no scissor; compare with the projection's own then, or this projection's transforms, which
+                    // another pair that did draw may share, would lose their widening (Conker's hub, near the naughty/nice sign).
+                    // In split screen the pair's scissor leaves out the frame's clear (FramebufferPair::wideningScissor, issue #78).
+                    const FixedRect wideningScissor = fbPair.wideningScissor();
+                    const FixedRect &pairScissor = wideningScissor.isNull() ? proj.scissorRect : wideningScissor;
+                    bool coversWholeWidth = (intersectionRect.ulx <= pairScissor.ulx + CoversWidthViewportSlack) && (intersectionRect.lrx >= pairScissor.lrx - CoversWidthViewportSlack);
                     bool horizontalRatio = (intersectionRect.width(true, true) > intersectionRect.height(true, true));
                     adjustAspectRatio = (viewportOrigin == G_EX_ORIGIN_NONE) && coversWholeWidth && horizontalRatio;
+
+                    // A split-screen view widened in another pair of the frame is widened here too (Workload::widensView), and
+                    // a widened view narrower than the frame is squeezed about its own middle.
+                    const int32_t frameWidthFixed = int32_t(fbPair.colorImage.width) * 4;
+                    const bool narrowerThanFrame = (intersectionRect.lrx - intersectionRect.ulx) < (frameWidthFixed - 2 * CoversWidthSlack);
+                    if (!adjustAspectRatio && (viewportOrigin == G_EX_ORIGIN_NONE) && narrowerThanFrame && workload.widensView(fbPair.colorImage.address, intersectionRect)) {
+                        adjustAspectRatio = true;
+                    }
+                    if (adjustAspectRatio && narrowerThanFrame && proj.usesViewport()) {
+                        const interop::RSPViewport &viewport = drawData.rspViewports[proj.transformsIndex];
+                        if (std::fabs(viewport.scale.x) > 1e-3f) {
+                            const float viewMiddle = float(intersectionRect.ulx + intersectionRect.lrx) / 8.0f;
+                            projCenterX = (viewMiddle - viewport.translate.x) / viewport.scale.x;
+                        }
+                    }
                 }
             }
  
             float projRatioScale = adjustAspectRatio ? (1.0f / p.aspectRatioScale) : 1.0f;
+
+            // TEMP-DEBUG (Conker): FbLog, see common/rt64_fblog.h. Transforms shared by projections of several pairs are
+            // adjusted by whichever of them comes last here.
+            if (FbLog::frameLogged(workload.submissionFrame)) {
+                FbLog::print("[proj %llu] scene %zu pair %u proj %u type %d transforms %u aspectMode %u: projScissor " RT64_FBLOG_RECT_FMT " pairScissor " RT64_FBLOG_RECT_FMT " -> adjustAspectRatio %d interpolated %d",
+                    (unsigned long long)(workload.submissionFrame), sceneIndex, sceneProj.fbPairIndex, sceneProj.projectionIndex, int(proj.type), proj.transformsIndex, curProjGroup.aspectMode,
+                    RT64_FBLOG_RECT(proj.scissorRect), RT64_FBLOG_RECT(fbPair.scissorRect), adjustAspectRatio, (rigidBody != nullptr));
+            }
+
             interop::float4x4 &viewMatrix = drawData.modViewTransforms[proj.transformsIndex];
             interop::float4x4 &projMatrix = drawData.modProjTransforms[proj.transformsIndex];
             interop::float4x4 &viewProjMatrix = drawData.modViewProjTransforms[proj.transformsIndex];
@@ -112,7 +179,20 @@ namespace RT64 {
                 projMatrix = workload.debuggerCamera.projMatrix;
             }
 
-            adjustProjectionMatrix(projMatrix, projRatioScale);
+            adjustProjectionMatrix(projMatrix, projRatioScale, projCenterX);
+
+            // Conker: a view drawn anew elsewhere in the frame keeps its shape (rt64_conker_view_focus.h).
+            const float focusXScale = drawData.viewportFocusXScales[proj.transformsIndex];
+            const float focusYScale = drawData.viewportFocusYScales[proj.transformsIndex];
+            auto adjustProjectionShape = [focusXScale, focusYScale](interop::float4x4 &matrix) {
+                if ((focusXScale != 1.0f) || (focusYScale != 1.0f)) {
+                    for (int r = 0; r < 4; r++) {
+                        matrix[r][0] *= focusXScale;
+                        matrix[r][1] *= focusYScale;
+                    }
+                }
+            };
+            adjustProjectionShape(projMatrix);
 
             interop::float4x4 &prevViewTransform = drawData.prevViewTransforms[proj.transformsIndex];
             interop::float4x4 &prevProjTransform = drawData.prevProjTransforms[proj.transformsIndex];
@@ -120,9 +200,22 @@ namespace RT64 {
                 const interop::float4x4 curViewTransform = viewMatrix;
                 const interop::float4x4 curProjTransform = projMatrix;
                 interop::float4x4 adjustedPrevProj = *prevProjMatrix;
-                adjustProjectionMatrix(adjustedPrevProj, projRatioScale);
-                viewMatrix = rigidBody->lerp(p.curFrameWeight, *prevViewMatrix, curViewTransform, true);
-                prevViewTransform = rigidBody->lerp(p.prevFrameWeight, *prevViewMatrix, curViewTransform, true);
+                adjustProjectionMatrix(adjustedPrevProj, projRatioScale, projCenterX);
+                adjustProjectionShape(adjustedPrevProj);
+                if (rigidBody->lerpDecompose) {
+                    viewMatrix = rigidBody->lerp(p.curFrameWeight, *prevViewMatrix, curViewTransform, true);
+                    prevViewTransform = rigidBody->lerp(p.prevFrameWeight, *prevViewMatrix, curViewTransform, true);
+                }
+                else {
+                    // Interpolate the camera, not the view: a view matrix's translation is the world's origin seen
+                    // from the camera, so lerping it while the camera turns moves the in-between camera off its path,
+                    // by more the further the camera is from the origin. The world then shakes around what the camera
+                    // follows at the game's frame rate (Conker, most when the camera is close and turning quickly).
+                    const interop::float4x4 prevCamera = hlslpp::inverse(*prevViewMatrix);
+                    const interop::float4x4 curCamera = hlslpp::inverse(curViewTransform);
+                    viewMatrix = hlslpp::inverse(rigidBody->lerp(p.curFrameWeight, prevCamera, curCamera, true));
+                    prevViewTransform = hlslpp::inverse(rigidBody->lerp(p.prevFrameWeight, prevCamera, curCamera, true));
+                }
 
                 // We only interpolate the projection if the view matrix has been interpolated.
                 const bool interpolateProjection = rigidBody->lerpTranslation || rigidBody->lerpRotation;
@@ -144,6 +237,31 @@ namespace RT64 {
 
             interop::float4x4 &prevViewProjTransform = drawData.prevViewProjTransforms[proj.transformsIndex];
             prevViewProjTransform = hlslpp::mul(prevViewTransform, prevProjTransform);
+
+            // A shadow's silhouette (Conker's Bad Fur Day draws each into a 64 pixel wide 8-bit image, 0x800DE080, then
+            // lays it on the ground under the character as a texture): its camera is interpolated whole, each frame's
+            // scaled first so the place it's aimed at is at w = 1 (issue #76). The game aims the camera at the
+            // character anew every frame, from the light, and moves it nearer or further, zooming to match: standing
+            // still, its distance and zoom both doubled from one frame to the next, the silhouette the same size in
+            // both. View and projection interpolated apart, halfway each, were a camera neither frame had, and the
+            // shadow was drawn larger on the frames drawn in between. Scaled so, the cameras interpolate as the
+            // silhouette's points on the texture do near the character, as the shadow's texture coordinates on the
+            // ground are (GameFrame::matchTransform), and the two stay together.
+            const bool shadowSilhouette = (fbPair.colorImage.width == 64) && (fbPair.colorImage.siz == G_IM_SIZ_8b) && (proj.type == Projection::Type::Perspective);
+            if (shadowSilhouette && (prevProjMatrix != nullptr) && (prevViewMatrix != nullptr) && (rigidBody != nullptr) && (rigidBody->lerpTranslation || rigidBody->lerpRotation)) {
+                interop::float4x4 adjustedPrevProj = *prevProjMatrix;
+                adjustProjectionMatrix(adjustedPrevProj, projRatioScale, projCenterX);
+                const interop::float4x4 curProjTransform = drawData.projTransforms[proj.transformsIndex];
+                float prevDepth = 0.0f, curDepth = 0.0f;
+                if (aimedDepth(adjustedPrevProj, prevDepth) && aimedDepth(curProjTransform, curDepth)) {
+                    interop::float4x4 adjustedCurProj = curProjTransform;
+                    adjustProjectionMatrix(adjustedCurProj, projRatioScale, projCenterX);
+                    const interop::float4x4 prevAimed = hlslpp::mul(*prevViewMatrix, adjustedPrevProj) * (1.0f / prevDepth);
+                    const interop::float4x4 curAimed = hlslpp::mul(drawData.viewTransforms[proj.transformsIndex], adjustedCurProj) * (1.0f / curDepth);
+                    viewProjMatrix = lerpMatrix(prevAimed, curAimed, p.curFrameWeight);
+                    prevViewProjTransform = lerpMatrix(prevAimed, curAimed, p.prevFrameWeight);
+                }
+            }
         }
     }
 
diff --git a/src/render/rt64_render_target.cpp b/src/render/rt64_render_target.cpp
index 81917bc..34c6034 100644
--- a/src/render/rt64_render_target.cpp
+++ b/src/render/rt64_render_target.cpp
@@ -5,6 +5,7 @@
 #include "rt64_render_target.h"
 
 #include <algorithm>
+#include <cmath>
 
 #include "gbi/rt64_f3d.h"
 #include "shared/rt64_fb_common.h"
@@ -51,6 +52,13 @@ namespace RT64 {
         textureResolveDescSet.reset();
         filterDescSet.reset();
         fbWriteDescSet.reset();
+        for (auto &set : conkerBlurSets) {
+            set.reset();
+        }
+
+        conkerBlurSmall[0].reset();
+        conkerBlurSmall[1].reset();
+        conkerBlurFull.reset();
     }
 
     bool RenderTarget::resize(RenderWorker *worker, uint32_t newWidth, uint32_t newHeight) {
@@ -407,6 +415,132 @@ namespace RT64 {
         worker->commandList->dispatch(dispatchX, dispatchY, 1);
     }
 
+    // Conker: blurs the picture's top left blurWidth x blurHeight in place, in the texture the target is read from
+    // (getResolvedTexture: the resolved one with MSAA, which stays as it is until something is drawn into the target
+    // again). Shrunk by downsample (a box filter), blurred across and down by a Gaussian of sigma (in the shrunk
+    // picture's texels), then scaled back up bilinearly and copied in (ConkerBlurCS). For the pause menu's background
+    // (gEXConkerBlurFramebuffer, WorkloadQueue).
+    void RenderTarget::conkerBlur(RenderWorker *worker, const ShaderLibrary *shaderLibrary, uint32_t blurWidth, uint32_t blurHeight, uint32_t downsample, float sigma) {
+        assert(worker != nullptr);
+
+        blurWidth = std::min(blurWidth, width);
+        blurHeight = std::min(blurHeight, height);
+        downsample = std::max(downsample, 1U);
+        if ((texture == nullptr) || (blurWidth == 0) || (blurHeight == 0)) {
+            return;
+        }
+
+        resolveTarget(worker, shaderLibrary);
+
+        RenderTexture *picture = getResolvedTexture();
+        const uint32_t smallWidth = std::max((blurWidth + downsample - 1) / downsample, 1U);
+        const uint32_t smallHeight = std::max((blurHeight + downsample - 1) / downsample, 1U);
+        if ((conkerBlurFull == nullptr) || (conkerBlurRevision != textureRevision) || (conkerBlurWidth != blurWidth) || (conkerBlurHeight != blurHeight) || (conkerBlurDownsample != downsample)) {
+            const RenderTextureFlags flags = RenderTextureFlag::STORAGE | RenderTextureFlag::UNORDERED_ACCESS;
+            for (int i = 0; i < 2; i++) {
+                conkerBlurSmall[i] = worker->device->createTexture(RenderTextureDesc::Texture2D(smallWidth, smallHeight, 1, format, flags));
+                conkerBlurSmall[i]->setName("Render Target Conker Blur Small #" + std::to_string(addressForName));
+            }
+
+            conkerBlurFull = worker->device->createTexture(RenderTextureDesc::Texture2D(blurWidth, blurHeight, 1, format, flags));
+            conkerBlurFull->setName("Render Target Conker Blur #" + std::to_string(addressForName));
+
+            // The four passes: shrink, blur across, blur down, scale back up.
+            RenderTexture *inputs[4] = { picture, conkerBlurSmall[0].get(), conkerBlurSmall[1].get(), conkerBlurSmall[0].get() };
+            RenderTexture *outputs[4] = { conkerBlurSmall[0].get(), conkerBlurSmall[1].get(), conkerBlurSmall[0].get(), conkerBlurFull.get() };
+            for (int i = 0; i < 4; i++) {
+                conkerBlurSets[i] = std::make_unique<BoxFilterDescriptorSet>(worker->device);
+                conkerBlurSets[i]->setTexture(conkerBlurSets[i]->gInput, inputs[i], RenderTextureLayout::SHADER_READ);
+                conkerBlurSets[i]->setTexture(conkerBlurSets[i]->gOutput, outputs[i], RenderTextureLayout::GENERAL);
+            }
+
+            conkerBlurRevision = textureRevision;
+            conkerBlurWidth = blurWidth;
+            conkerBlurHeight = blurHeight;
+            conkerBlurDownsample = downsample;
+        }
+
+        const uint32_t BlockSize = 8;
+        auto dispatch = [&](uint32_t outputWidth, uint32_t outputHeight) {
+            worker->commandList->dispatch((outputWidth + BlockSize - 1) / BlockSize, (outputHeight + BlockSize - 1) / BlockSize, 1);
+        };
+
+        // Shrink, with the box filter.
+        struct BoxFilterCB {
+            interop::int2 Resolution;
+            interop::int2 ResolutionScale;
+            interop::int2 Misalignment;
+        };
+
+        BoxFilterCB boxFilterCB;
+        boxFilterCB.Resolution[0] = int32_t(blurWidth);
+        boxFilterCB.Resolution[1] = int32_t(blurHeight);
+        boxFilterCB.ResolutionScale[0] = int32_t(downsample);
+        boxFilterCB.ResolutionScale[1] = int32_t(downsample);
+        boxFilterCB.Misalignment[0] = 0;
+        boxFilterCB.Misalignment[1] = 0;
+        const RenderTextureBarrier shrinkBarriers[] = {
+            RenderTextureBarrier(picture, RenderTextureLayout::SHADER_READ),
+            RenderTextureBarrier(conkerBlurSmall[0].get(), RenderTextureLayout::GENERAL)
+        };
+
+        worker->commandList->barriers(RenderBarrierStage::COMPUTE, shrinkBarriers, uint32_t(std::size(shrinkBarriers)));
+
+        worker->commandList->setPipeline(shaderLibrary->boxFilter.pipeline.get());
+        worker->commandList->setComputePipelineLayout(shaderLibrary->boxFilter.pipelineLayout.get());
+        worker->commandList->setComputePushConstants(0, &boxFilterCB);
+        worker->commandList->setComputeDescriptorSet(conkerBlurSets[0]->get(), 0);
+        dispatch(smallWidth, smallHeight);
+
+        // Blur across, down, and scale back up.
+        struct ConkerBlurCB {
+            interop::uint2 InputResolution;
+            interop::uint2 OutputResolution;
+            uint32_t Mode;
+            uint32_t Radius;
+            float Sigma;
+            uint32_t Padding;
+        };
+
+        sigma = std::max(sigma, 0.1f);
+        const uint32_t radius = std::min(uint32_t(std::ceil(sigma * 3.0f)), 32U);
+        RenderTexture *passInputs[3] = { conkerBlurSmall[0].get(), conkerBlurSmall[1].get(), conkerBlurSmall[0].get() };
+        RenderTexture *passOutputs[3] = { conkerBlurSmall[1].get(), conkerBlurSmall[0].get(), conkerBlurFull.get() };
+        worker->commandList->setPipeline(shaderLibrary->conkerBlur.pipeline.get());
+        worker->commandList->setComputePipelineLayout(shaderLibrary->conkerBlur.pipelineLayout.get());
+        for (uint32_t pass = 0; pass < 3; pass++) {
+            ConkerBlurCB blurCB;
+            blurCB.InputResolution = { smallWidth, smallHeight };
+            blurCB.OutputResolution = (pass < 2) ? interop::uint2(smallWidth, smallHeight) : interop::uint2(blurWidth, blurHeight);
+            blurCB.Mode = pass;
+            blurCB.Radius = radius;
+            blurCB.Sigma = sigma;
+            blurCB.Padding = 0;
+            const RenderTextureBarrier passBarriers[] = {
+                RenderTextureBarrier(passInputs[pass], RenderTextureLayout::SHADER_READ),
+                RenderTextureBarrier(passOutputs[pass], RenderTextureLayout::GENERAL)
+            };
+
+            worker->commandList->barriers(RenderBarrierStage::COMPUTE, passBarriers, uint32_t(std::size(passBarriers)));
+
+            worker->commandList->setComputePushConstants(0, &blurCB);
+            worker->commandList->setComputeDescriptorSet(conkerBlurSets[pass + 1]->get(), 0);
+            dispatch(blurCB.OutputResolution[0], blurCB.OutputResolution[1]);
+        }
+
+        // Into the picture.
+        const RenderTextureBarrier copyBarriers[] = {
+            RenderTextureBarrier(conkerBlurFull.get(), RenderTextureLayout::COPY_SOURCE),
+            RenderTextureBarrier(picture, RenderTextureLayout::COPY_DEST)
+        };
+
+        worker->commandList->barriers(RenderBarrierStage::COPY, copyBarriers, uint32_t(std::size(copyBarriers)));
+
+        const RenderBox blurBox(0, 0, int32_t(blurWidth), int32_t(blurHeight));
+        worker->commandList->copyTextureRegion(RenderTextureCopyLocation::Subresource(picture), RenderTextureCopyLocation::Subresource(conkerBlurFull.get()), 0, 0, 0, &blurBox);
+        worker->commandList->barriers(RenderBarrierStage::GRAPHICS_AND_COMPUTE, RenderTextureBarrier(picture, RenderTextureLayout::SHADER_READ));
+    }
+
     void RenderTarget::resolveTarget(RenderWorker *worker, const ShaderLibrary *shaderLibrary) {
         if (!resolvedTextureDirty || !usesResolve()) {
             return;
diff --git a/src/render/rt64_render_target.h b/src/render/rt64_render_target.h
index 82d8a36..5f20fe8 100644
--- a/src/render/rt64_render_target.h
+++ b/src/render/rt64_render_target.h
@@ -35,6 +35,15 @@ namespace RT64 {
         std::unique_ptr<TextureCopyDescriptorSet> textureResolveDescSet;
         std::unique_ptr<BoxFilterDescriptorSet> filterDescSet;
         std::unique_ptr<FramebufferWriteDescriptorTextureSet> fbWriteDescSet;
+        // Conker: conkerBlur's pictures (two small ones and one the target's size) and the descriptor sets of its four
+        // passes, kept for the target's textures and the blurred area's size they were made for.
+        std::unique_ptr<RenderTexture> conkerBlurSmall[2];
+        std::unique_ptr<RenderTexture> conkerBlurFull;
+        std::unique_ptr<BoxFilterDescriptorSet> conkerBlurSets[4];
+        uint64_t conkerBlurRevision = 0;
+        uint32_t conkerBlurWidth = 0;
+        uint32_t conkerBlurHeight = 0;
+        uint32_t conkerBlurDownsample = 0;
         uint32_t addressForName = 0;
         uint32_t width = 0;
         uint32_t height = 0;
@@ -63,6 +72,7 @@ namespace RT64 {
         void clearColorTarget(RenderWorker *worker);
         void clearDepthTarget(RenderWorker *worker);
         void downsampleTarget(RenderWorker *worker, const ShaderLibrary *shaderLibrary);
+        void conkerBlur(RenderWorker *worker, const ShaderLibrary *shaderLibrary, uint32_t blurWidth, uint32_t blurHeight, uint32_t downsample, float sigma);
         void resolveTarget(RenderWorker *worker, const ShaderLibrary *shaderLibrary);
         void recordRasterResolve(RenderWorker *worker, const TextureCopyDescriptorSet *srcDescriptorSet, uint32_t x, uint32_t y, uint32_t width, uint32_t height, const ShaderLibrary *shaderLibrary);
         void markForResolve();
diff --git a/src/render/rt64_shader_library.cpp b/src/render/rt64_shader_library.cpp
index d1c5273..b4d8e15 100644
--- a/src/render/rt64_shader_library.cpp
+++ b/src/render/rt64_shader_library.cpp
@@ -19,6 +19,7 @@
 #include "shaders/FbWriteDepthCSMS.hlsl.spirv.h"
 #include "shaders/GaussianFilterRGB3x3CS.hlsl.spirv.h"
 #include "shaders/BoxFilterCS.hlsl.spirv.h"
+#include "shaders/ConkerBlurCS.hlsl.spirv.h"
 #include "shaders/BicubicScalingCS.hlsl.spirv.h"
 #include "shaders/HistogramAverageCS.hlsl.spirv.h"
 #include "shaders/HistogramClearCS.hlsl.spirv.h"
@@ -65,6 +66,7 @@
 #   include "shaders/FbWriteDepthCSMS.hlsl.dxil.h"
 #   include "shaders/GaussianFilterRGB3x3CS.hlsl.dxil.h"
 #   include "shaders/BoxFilterCS.hlsl.dxil.h"
+#   include "shaders/ConkerBlurCS.hlsl.dxil.h"
 #   include "shaders/BicubicScalingCS.hlsl.dxil.h"
 #   include "shaders/HistogramAverageCS.hlsl.dxil.h"
 #   include "shaders/HistogramClearCS.hlsl.dxil.h"
@@ -110,6 +112,7 @@
 #   include "shaders/FbWriteDepthCSMS.hlsl.metal.h"
 #   include "shaders/GaussianFilterRGB3x3CS.hlsl.metal.h"
 #   include "shaders/BoxFilterCS.hlsl.metal.h"
+#   include "shaders/ConkerBlurCS.hlsl.metal.h"
 #   include "shaders/BicubicScalingCS.hlsl.metal.h"
 #   include "shaders/HistogramAverageCS.hlsl.metal.h"
 #   include "shaders/HistogramClearCS.hlsl.metal.h"
@@ -282,6 +285,20 @@ namespace RT64 {
             boxFilter.pipeline = device->createComputePipeline(pipelineDesc);
         }
 
+        // Conker: the pause menu's blurred background (RenderTarget::conkerBlur), with the box filter's descriptor set.
+        {
+            BoxFilterDescriptorSet descriptorSet;
+            layoutBuilder.begin();
+            layoutBuilder.addPushConstant(0, 0, sizeof(uint32_t) * 8, RenderShaderStageFlag::COMPUTE);
+            layoutBuilder.addDescriptorSet(descriptorSet);
+            layoutBuilder.end();
+            conkerBlur.pipelineLayout = layoutBuilder.create(device);
+
+            std::unique_ptr<RenderShader> computeShader = device->createShader(CREATE_SHADER_INPUTS(ConkerBlurCSBlobDXIL, ConkerBlurCSBlobSPIRV, ConkerBlurCSBlobMSL, "CSMain", shaderFormat));
+            RenderComputePipelineDesc pipelineDesc(conkerBlur.pipelineLayout.get(), computeShader.get(), 8, 8, 1);
+            conkerBlur.pipeline = device->createComputePipeline(pipelineDesc);
+        }
+
         // Raytracing compose.
         {
             RaytracingComposeDescriptorSet descriptorSet(samplerLibrary);
diff --git a/src/render/rt64_shader_library.h b/src/render/rt64_shader_library.h
index 641f3ec..28b37fb 100644
--- a/src/render/rt64_shader_library.h
+++ b/src/render/rt64_shader_library.h
@@ -20,6 +20,7 @@ namespace RT64 {
         // All shaders.
         ShaderRecord bicubicScaling;
         ShaderRecord boxFilter;
+        ShaderRecord conkerBlur; // Conker: the pause menu's blurred background (RenderTarget::conkerBlur)
         ShaderRecord compose;
         ShaderRecord debug;
         ShaderRecord fbChangesClear;
diff --git a/src/render/rt64_texture_cache.cpp b/src/render/rt64_texture_cache.cpp
index 0848f3e..b99178d 100644
--- a/src/render/rt64_texture_cache.cpp
+++ b/src/render/rt64_texture_cache.cpp
@@ -23,6 +23,17 @@
 #define ONLY_USE_LOW_MIP_CACHE 0
 
 namespace RT64 {
+    // Conker: see rt64_texture_cache.h.
+    static std::atomic<bool> replacementsHiddenFlag{ false };
+
+    void setReplacementsHidden(bool hidden) {
+        replacementsHiddenFlag = hidden;
+    }
+
+    bool replacementsHidden() {
+        return replacementsHiddenFlag;
+    }
+
     // ReplacementMap
     
     static const interop::float2 IdentityScale = { 1.0f, 1.0f };
@@ -301,7 +312,7 @@ namespace RT64 {
         }
 
         textureIndex = it->second;
-        textureReplaced = replacementMapEnabled && (textureReplacements[textureIndex] != nullptr);
+        textureReplaced = replacementMapEnabled && !replacementsHidden() && (textureReplacements[textureIndex] != nullptr);
 
         if (textureReplaced) {
             textureScale = textureScales[textureIndex];
@@ -1298,6 +1309,7 @@ namespace RT64 {
             }
         }
 
+        bool found = false;
         for (int32_t i = int32_t(textureMap.replacementMap.fileSystemResolvedPaths.size()) - 1; i >= 0; i--) {
             const auto &fsResolvedPaths = textureMap.replacementMap.fileSystemResolvedPaths[i];
             uint32_t hashVersion = textureMap.replacementMap.fileSystemHashVersions[i];
@@ -1306,10 +1318,20 @@ namespace RT64 {
                 if (it != fsResolvedPaths.end()) {
                     // Stop searching for replacements as soon as we find one.
                     resolvedPaths.emplace_back(it->second);
+                    found = true;
                     break;
                 }
             }
         }
+
+        // Otherwise, a texture matched to a Rice-named pack as it was loaded.
+        if (!found && (exclusiveDbHash == 0) && riceReplacementsLoaded) {
+            std::unique_lock riceLock(riceMutex);
+            auto it = riceMatchedPaths.find(hash);
+            if (it != riceMatchedPaths.end()) {
+                resolvedPaths.emplace_back(it->second);
+            }
+        }
     }
 
     bool TextureCache::useTexture(uint64_t hash, uint64_t submissionFrame, uint32_t &textureIndex, interop::float2 &textureScale, interop::float3 &textureDimensions, bool &textureReplaced, bool &hasMipmaps, bool &shiftedByHalf) {
@@ -1394,6 +1416,56 @@ namespace RT64 {
         return true;
     }
 
+    bool TextureCache::hasRiceReplacements() const {
+        return riceReplacementsLoaded;
+    }
+
+    uint32_t TextureCache::getRiceGeneration() const {
+        return riceGeneration;
+    }
+
+    void TextureCache::addRiceReplacement(uint64_t hash, const std::vector<std::string> &riceKeys) {
+        // A pack's database replacing the texture comes first.
+        {
+            std::unique_lock lock(textureMapMutex);
+            for (const auto &fsResolvedPaths : textureMap.replacementMap.fileSystemResolvedPaths) {
+                if (fsResolvedPaths.find(hash) != fsResolvedPaths.end()) {
+                    return;
+                }
+            }
+        }
+
+        // The last pack with a file for one of its names, as with the databases.
+        ReplacementResolvedPath resolvedPath;
+        bool found = false;
+        {
+            std::unique_lock riceLock(riceMutex);
+            for (int32_t i = int32_t(riceFileSystemPaths.size()) - 1; (i >= 0) && !found; i--) {
+                for (const std::string &riceKey : riceKeys) {
+                    auto it = riceFileSystemPaths[i].find(riceKey);
+                    if (it != riceFileSystemPaths[i].end()) {
+                        resolvedPath = it->second;
+                        resolvedPath.textureHash = hash;
+                        riceMatchedPaths[hash] = resolvedPath;
+                        found = true;
+                        break;
+                    }
+                }
+            }
+        }
+
+        if (!found) {
+            return;
+        }
+
+        // A texture uploaded already (it was loaded before the pack) is checked for its replacement again. One not uploaded
+        // yet finds it in riceMatchedPaths when it is (addResolvedPaths), and this check does nothing to it (TextureMap::replace).
+        uploadQueueMutex.lock();
+        resolvedPathQueue.emplace_back(resolvedPath);
+        uploadQueueMutex.unlock();
+        uploadQueueChanged.notify_all();
+    }
+
     bool TextureCache::hasReplacement(uint64_t hash) {
         std::unique_lock lock(textureMapMutex);
         const auto &resolvedPaths = textureMap.replacementMap.fileSystemResolvedPaths;
@@ -1426,6 +1498,15 @@ namespace RT64 {
         // Clear the current set of textures that were sent to streaming threads.
         textureMap.replacementMap.fileSystemStreamSets.clear();
 
+        // Forget the Rice-named packs and the textures matched to them.
+        {
+            std::unique_lock riceLock(riceMutex);
+            riceFileSystemPaths.clear();
+            riceMatchedPaths.clear();
+            riceReplacementsLoaded = false;
+            riceGeneration++;
+        }
+
         // Clear the pending replacement checks for streamed textures.
         textureMap.replacementMap.fileSystemStreamResolvedPaths.clear();
 
@@ -1502,6 +1583,9 @@ namespace RT64 {
             }
         }
 
+        // Each file system's files by Rice hash, if its database's auto path is Rice.
+        std::vector<std::unordered_map<std::string, ReplacementResolvedPath>> ricePaths(fileSystems.size());
+
         // Load databases and low mipmap caches from the filesystems in reverse order.
         {
             loaderCommandList->begin();
@@ -1518,7 +1602,7 @@ namespace RT64 {
                         db = json::parse(databaseBytes.begin(), databaseBytes.end(), nullptr, true);
 
                         if (db.config.hashVersion <= TMEMHasher::CurrentHashVersion) {
-                            db.resolvePaths(fileSystems[i].get(), uint32_t(i), fileSystemResolvedPaths[i], false, nullptr, &fileSystemStreamSets[i]);
+                            db.resolvePaths(fileSystems[i].get(), uint32_t(i), fileSystemResolvedPaths[i], false, nullptr, &fileSystemStreamSets[i], &ricePaths[i]);
                             fileSystemHashVersions[i] = db.config.hashVersion;
                             knownHashVersions.insert(db.config.hashVersion);
 
@@ -1564,6 +1648,19 @@ namespace RT64 {
         textureMap.replacementMap.fileSystemStreamSets = std::move(fileSystemStreamSets);
         textureMap.replacementMap.fileSystemStreamResolvedPaths.resize(fileSystemCount);
 
+        {
+            std::unique_lock riceLock(riceMutex);
+            riceFileSystemPaths = std::move(ricePaths);
+            riceMatchedPaths.clear();
+            bool anyRicePaths = false;
+            for (const auto &fsRicePaths : riceFileSystemPaths) {
+                anyRicePaths = anyRicePaths || !fsRicePaths.empty();
+            }
+
+            riceReplacementsLoaded = anyRicePaths;
+            riceGeneration++;
+        }
+
         // Queue all textures that must be preloaded to the stream queues.
         bool texturesPreloaded = false;
         {
diff --git a/src/render/rt64_texture_cache.h b/src/render/rt64_texture_cache.h
index 9131697..9c74131 100644
--- a/src/render/rt64_texture_cache.h
+++ b/src/render/rt64_texture_cache.h
@@ -35,6 +35,12 @@ namespace interop {
 };
 
 namespace RT64 {
+    // Conker: the replacements (texture packs) hidden, the game's own textures shown, as the host asks (its
+    // Show Original Textures key): where the replacement map is used (the texture cache and the framebuffer
+    // renderer), as if it were turned off, without unloading the packs, so they come back at once.
+    void setReplacementsHidden(bool hidden);
+    bool replacementsHidden();
+
     struct TextureUpload {
         uint64_t hash;
         uint64_t creationFrame;
@@ -220,6 +226,14 @@ namespace RT64 {
         uint64_t streamLoadCount = 0;
         TextureMap textureMap;
         std::mutex textureMapMutex;
+
+        // Packs named for Rice (auto path Rice): each file system's files by Rice hash, and the textures matched to them
+        // as they were loaded (hle/rt64_rice_hash.h), looked up when a texture has no other replacement.
+        std::mutex riceMutex;
+        std::vector<std::unordered_map<std::string, ReplacementResolvedPath>> riceFileSystemPaths;
+        std::unordered_map<uint64_t, ReplacementResolvedPath> riceMatchedPaths;
+        std::atomic<bool> riceReplacementsLoaded = false;
+        std::atomic<uint32_t> riceGeneration = 0;
         RenderWorker *directWorker;
         RenderWorker *copyWorker;
         std::unique_ptr<RenderCommandList> loaderCommandList;
@@ -240,6 +254,14 @@ namespace RT64 {
         bool useTexture(uint64_t hash, uint64_t submissionFrame, uint32_t &textureIndex);
         bool addReplacement(uint64_t hash, const std::string &relativePath, ReplacementShift shift);
         bool hasReplacement(uint64_t hash);
+
+        // Whether a loaded pack is named for Rice, and a count that changes whenever the packs do.
+        bool hasRiceReplacements() const;
+        uint32_t getRiceGeneration() const;
+
+        // The texture with this hash has these Rice names (the most likely first): replace it with the file a Rice-named
+        // pack has for one of them, unless a pack's database already replaces it.
+        void addRiceReplacement(uint64_t hash, const std::vector<std::string> &riceKeys);
         void clearReplacementDirectories();
         void reloadReplacements(bool clearQueue, uint64_t exclusiveDbHash = 0);
         bool loadReplacementDirectory(const ReplacementDirectory &replacementDirectory);
diff --git a/src/render/rt64_vi_renderer.cpp b/src/render/rt64_vi_renderer.cpp
index b4ff4e9..cffd3a0 100644
--- a/src/render/rt64_vi_renderer.cpp
+++ b/src/render/rt64_vi_renderer.cpp
@@ -4,10 +4,62 @@
 
 #include "rt64_vi_renderer.h"
 
+#include <algorithm>
+#include <atomic>
+#include <cmath>
+#include <mutex>
+
+#include "common/rt64_conker_view_focus.h"
 #include "shared/rt64_hlsl.h"
 #include "shared/rt64_video_interface.h"
 
 namespace RT64 {
+    // Conker: the presentation crop (see rt64_vi_renderer.h), set from the game's thread and read on the renderer's.
+    static std::atomic<float> presentationCropShare{ 0.0f };
+
+    void setPresentationCrop(float shareEachSide) {
+        presentationCropShare = std::clamp(shareEachSide, 0.0f, 0.25f);
+    }
+
+    float presentationCrop() {
+        return presentationCropShare;
+    }
+
+    // Conker: the view focus drawn anew (see common/rt64_conker_view_focus.h), set from the game's thread and read
+    // on the workload's.
+    static std::mutex viewFocusMutex;
+    static ConkerViewFocus viewFocus;
+
+    void setViewFocusRedraw(bool on, int count, const float *rects, float frameWidth, float frameHeight,
+        uint32_t ownImage0, uint32_t ownImage1)
+    {
+        ConkerViewFocus focus;
+        focus.on = on && (count >= 1) && (count <= ConkerMaxFocusViews) && (rects != nullptr);
+        focus.count = focus.on ? count : 0;
+        for (int i = 0; i < focus.count; i++) {
+            const float *r = rects + i * 8;
+            focus.views[i] = { r[0], r[1], r[2], r[3], r[4], r[5], r[6], r[7] };
+            // A view with no size (or not a number) can't be mapped: nothing is focused then.
+            const ConkerFocusView &v = focus.views[i];
+            if (!((v.srcRight > v.srcLeft) && (v.srcBottom > v.srcTop) && (v.right > v.left) && (v.bottom > v.top))) {
+                focus.on = false;
+                focus.count = 0;
+                break;
+            }
+        }
+        focus.frameWidth = frameWidth;
+        focus.frameHeight = frameHeight;
+        focus.ownImages[0] = ownImage0;
+        focus.ownImages[1] = ownImage1;
+        std::scoped_lock lock(viewFocusMutex);
+        viewFocus = focus;
+    }
+
+    ConkerViewFocus conkerViewFocus() {
+        std::scoped_lock lock(viewFocusMutex);
+        return viewFocus;
+    }
+
     // VIRenderer
 
     VIRenderer::VIRenderer() { }
@@ -108,6 +160,18 @@ namespace RT64 {
         hlslpp::float4 viViewRect = vi.viewRectangle() * sdSize.xyxy;
         hlslpp::float4 viCropRect = vi.cropRectangle() * sdSize.xyxy;
 
+        // Conker: zoom the picture about its middle by as much both ways, so the share set to crop goes off each
+        // side; the scissor stays the picture's area, so what's zoomed past it is cut off.
+        const float crop = presentationCrop();
+        if (crop > 0.0f) {
+            const float zoom = 1.0f / (1.0f - 2.0f * crop);
+            const float width = float(viViewRect.z) * zoom;
+            const float height = float(viViewRect.w) * zoom;
+            const float x = float(viViewRect.x) - (width - float(viViewRect.z)) / 2.0f;
+            const float y = float(viViewRect.y) - (height - float(viViewRect.w)) / 2.0f;
+            viViewRect = hlslpp::float4(x, y, width, height);
+        }
+
         // Scale all the rectangles to the space of the Window.
         hlslpp::float2 topLeftViewport = fromSDtoHD({ float(viViewRect.x), float(viViewRect.y) }, sdSize, hdSize);
         hlslpp::float2 bottomRightViewport = fromSDtoHD({ float(viViewRect.x + viViewRect.z), float(viViewRect.y + viViewRect.w) }, sdSize, hdSize);
diff --git a/src/render/rt64_vi_renderer.h b/src/render/rt64_vi_renderer.h
index 8a3782a..6fd46b1 100644
--- a/src/render/rt64_vi_renderer.h
+++ b/src/render/rt64_vi_renderer.h
@@ -11,6 +11,13 @@
 #include "rt64_shader_library.h"
 
 namespace RT64 {
+    // Conker: how much of the picture's width to crop off each side when it's shown, as a share of that
+    // width (0 for none). The picture is zoomed about its middle by as much both ways, so it isn't stretched:
+    // as much comes off its top and bottom. Conker's 3D stops 2 of its frame's 292 pixels short of each side,
+    // a black border the N64 left for the TV's overscan (issue #72). Set by the game's host.
+    void setPresentationCrop(float shareEachSide);
+    float presentationCrop();
+
     struct VIRenderer {
         std::unique_ptr<VideoInterfaceDescriptorSet> descriptorSet;
         const RenderSampler *descriptorSetSampler = nullptr;
diff --git a/src/shaders/ConkerBlurCS.hlsl b/src/shaders/ConkerBlurCS.hlsl
new file mode 100644
index 0000000..5abf5f7
--- /dev/null
+++ b/src/shaders/ConkerBlurCS.hlsl
@@ -0,0 +1,60 @@
+//
+// RT64
+//
+
+// Conker: the pause menu's blurred background (RenderTarget::conkerBlur). One pass of three, by Mode:
+// 0 and 1 blur a picture across and down (a separable Gaussian, Radius texels each way), and 2 scales
+// the blurred picture back up to the target's size, bilinearly. Texels are read with Load, so no
+// sampler is involved and the picture's edges are clamped to.
+
+#define BLOCK_SIZE 8
+
+struct ConkerBlurCB {
+    uint2 InputResolution;
+    uint2 OutputResolution;
+    uint Mode;
+    uint Radius;
+    float Sigma;
+    uint Padding;
+};
+
+[[vk::push_constant]] ConstantBuffer<ConkerBlurCB> gConstants : register(b0);
+Texture2D<float4> gInput : register(t1);
+RWTexture2D<float4> gOutput : register(u2);
+
+float4 LoadClamped(int2 coord) {
+    int2 maxCoord = int2(gConstants.InputResolution) - int2(1, 1);
+    return gInput.Load(int3(clamp(coord, int2(0, 0), maxCoord), 0));
+}
+
+[numthreads(BLOCK_SIZE, BLOCK_SIZE, 1)]
+void CSMain(uint2 coord : SV_DispatchThreadID) {
+    if ((coord.x >= gConstants.OutputResolution.x) || (coord.y >= gConstants.OutputResolution.y)) {
+        return;
+    }
+
+    if (gConstants.Mode < 2) {
+        const int2 step = (gConstants.Mode == 0) ? int2(1, 0) : int2(0, 1);
+        const float twoSigmaSquared = 2.0f * gConstants.Sigma * gConstants.Sigma;
+        float4 sum = 0.0f;
+        float weightSum = 0.0f;
+        const int radius = int(gConstants.Radius);
+        for (int i = -radius; i <= radius; i++) {
+            const float weight = exp(-float(i * i) / twoSigmaSquared);
+            sum += LoadClamped(int2(coord) + step * i) * weight;
+            weightSum += weight;
+        }
+
+        gOutput[coord] = sum / weightSum;
+    }
+    else {
+        // The output texel's middle, in the input's texels.
+        const float2 scale = float2(gConstants.InputResolution) / float2(gConstants.OutputResolution);
+        const float2 position = (float2(coord) + 0.5f) * scale - 0.5f;
+        const int2 base = int2(floor(position));
+        const float2 t = position - float2(base);
+        const float4 top = lerp(LoadClamped(base), LoadClamped(base + int2(1, 0)), t.x);
+        const float4 bottom = lerp(LoadClamped(base + int2(0, 1)), LoadClamped(base + int2(1, 1)), t.x);
+        gOutput[coord] = lerp(top, bottom, t.y);
+    }
+}