rt64.patch

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 79dfc38..237a00d 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"
diff --git a/include/rt64_extended_gbi.h b/include/rt64_extended_gbi.h
index d387090..75ab87d 100644
--- a/include/rt64_extended_gbi.h
+++ b/include/rt64_extended_gbi.h
@@ -113,6 +113,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
diff --git a/src/common/rt64_common.h b/src/common/rt64_common.h
index f79adbf..6e0a6f9 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_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_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..428208c 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;
diff --git a/src/hle/rt64_framebuffer_manager.cpp b/src/hle/rt64_framebuffer_manager.cpp
index d7caa12..60112aa 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);
@@ -908,6 +929,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_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..1f5e54a 100644
--- a/src/hle/rt64_game_frame.cpp
+++ b/src/hle/rt64_game_frame.cpp
@@ -296,7 +296,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 +313,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++;
+                    }
                 }
             }
 
@@ -486,6 +512,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 +746,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 +808,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 +819,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_queue.cpp b/src/hle/rt64_present_queue.cpp
index 7de5b69..2ef2ef5 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() {
@@ -402,6 +411,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_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..c2c7517 100644
--- a/src/hle/rt64_rsp.cpp
+++ b/src/hle/rt64_rsp.cpp
@@ -4,7 +4,9 @@
 
 #include "rt64_rsp.h"
 
+#include <algorithm>
 #include <cassert>
+#include <cmath>
 
 #include "../include/rt64_extended_gbi.h"
 #include "common/rt64_common.h"
@@ -427,6 +429,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);
     }
@@ -506,13 +717,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 +736,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 +953,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 +1079,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;
         }
@@ -1152,6 +1395,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..782ed13 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;
@@ -254,6 +276,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..9102bbf 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);
@@ -1611,6 +1657,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;
diff --git a/src/hle/rt64_workload.cpp b/src/hle/rt64_workload.cpp
index b4c85f5..3e5f75e 100644
--- a/src/hle/rt64_workload.cpp
+++ b/src/hle/rt64_workload.cpp
@@ -4,7 +4,23 @@
 
 #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;
+    }
+
     // Common functions.
 
     static uint64_t roundUp(uint64_t value, uint64_t powerOf2Alignment) {
@@ -315,6 +331,55 @@ 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;
+        return (viewRect.ulx <= pairScissor.ulx + CoversWidthViewportSlack) && (viewRect.lrx >= pairScissor.lrx - CoversWidthViewportSlack) &&
+            (viewRect.width(true, true) > viewRect.height(true, true));
+    }
+
+    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..392867f 100644
--- a/src/hle/rt64_workload.h
+++ b/src/hle/rt64_workload.h
@@ -23,6 +23,13 @@
 #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();
+
     struct DrawData {
         std::vector<float> posFloats;
         std::vector<float> velFloats;
@@ -234,6 +241,8 @@ 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;
@@ -253,5 +262,16 @@ 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), 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..e6c0eae 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);
 
@@ -986,7 +1049,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..cf6687f 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"
@@ -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,48 @@ 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;
+            }
+
+            const FixedRect viewPairScissor = viewPair.wideningScissor();
+            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;
+                }
+
+                const FixedRect &comparedScissor = viewPairScissor.isNull() ? viewProj.scissorRect : viewPairScissor;
+                const bool widened = (viewRect.ulx <= comparedScissor.ulx + CoversWidthViewportSlack) && (viewRect.lrx >= comparedScissor.lrx - CoversWidthViewportSlack) &&
+                    (viewRect.width(true, true) > viewRect.height(true, true));
+                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 +1560,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 +1639,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 +1737,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 +1758,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 +1837,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..c8cc898 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,7 @@ namespace RT64 {
                 projMatrix = workload.debuggerCamera.projMatrix;
             }
 
-            adjustProjectionMatrix(projMatrix, projRatioScale);
+            adjustProjectionMatrix(projMatrix, projRatioScale, projCenterX);
 
             interop::float4x4 &prevViewTransform = drawData.prevViewTransforms[proj.transformsIndex];
             interop::float4x4 &prevProjTransform = drawData.prevProjTransforms[proj.transformsIndex];
@@ -120,9 +187,21 @@ 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);
+                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 +223,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_texture_cache.cpp b/src/render/rt64_texture_cache.cpp
index 0848f3e..a153536 100644
--- a/src/render/rt64_texture_cache.cpp
+++ b/src/render/rt64_texture_cache.cpp
@@ -1298,6 +1298,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 +1307,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 +1405,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 +1487,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 +1572,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 +1591,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 +1637,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..488e5be 100644
--- a/src/render/rt64_texture_cache.h
+++ b/src/render/rt64_texture_cache.h
@@ -220,6 +220,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 +248,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..3edef2f 100644
--- a/src/render/rt64_vi_renderer.cpp
+++ b/src/render/rt64_vi_renderer.cpp
@@ -4,10 +4,24 @@
 
 #include "rt64_vi_renderer.h"
 
+#include <algorithm>
+#include <atomic>
+
 #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;
+    }
+
     // VIRenderer
 
     VIRenderer::VIRenderer() { }
@@ -108,6 +122,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;