Fix particle sizes, and add tools for comparing renderers

Particles: Direct3D 9's size limit evidently isn't the documented 64 pixels; unclamped (up to 2048) they match the client's renderer. A compare view shows the left half's scene over the right half, both renderers side by side; %TEMP%\t5de-renderer-view.txt switches views and %TEMP%\t5de-renderer-shaders\fixed_function.hlsl replaces the shaders while the client runs. The renderer process runs from a copy, so the program can be replaced meanwhile. The adapter recognizes only the textures and buffers it made (others reach the client renderer unchanged) and logs the others and render targets.

Co-Authored-By: Claude Opus 5.5 <[email protected]>

renderer/main.cpp

@@ -84,15 +84,90 @@ HWND create_child_window(HWND parent)
                            0, 0, 1, 1, parent, nullptr, windowClass.hInstance, nullptr);
 }
 
-// Where the child window goes in the client's 3D view.
-RECT placement(HWND parent, View view)
+// The view, as the adapter set it, or as %TEMP%\t5de-renderer-view.txt says while the client runs (off, split, full
+// or compare): for comparing the renderers without restarting the client. Read every second or so.
+View current_view(View adapter)
 {
-    RECT client{};
-    GetClientRect(parent, &client);
-    if (view == View::Split) {
-        client.left = client.right / 2;
+    static View view = adapter;
+    static ULONGLONG checked = 0;
+    if (GetTickCount64() - checked < 1000) {
+        return view;
     }
-    return client;
+    checked = GetTickCount64();
+    view = adapter;
+    wchar_t temp[MAX_PATH + 1];
+    const DWORD length = GetTempPathW(MAX_PATH + 1, temp);
+    if (length == 0 || length > MAX_PATH) {
+        return view;
+    }
+    const HANDLE file = CreateFileW((std::filesystem::path(temp) / L"t5de-renderer-view.txt").c_str(), GENERIC_READ,
+                                    FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, nullptr, OPEN_EXISTING,
+                                    FILE_ATTRIBUTE_NORMAL, nullptr);
+    if (file == INVALID_HANDLE_VALUE) {
+        return view;
+    }
+    char text[16] = {};
+    DWORD read = 0;
+    ReadFile(file, text, sizeof(text) - 1, &read, nullptr);
+    CloseHandle(file);
+    const std::string_view setting(text, std::strcspn(text, "\r\n "));
+    view = setting == "off"       ? View::Off
+           : setting == "split"   ? View::Split
+           : setting == "full"    ? View::Full
+           : setting == "compare" ? View::Compare
+                                  : adapter;
+    return view;
+}
+
+// Shader changes to try while the client runs: %TEMP%\t5de-renderer-shaders\fixed_function.hlsl, if there is
+// one, replaces the built-in shaders, and is read again when it changes (checked every second or so).
+void reload_shaders(t5de::Scene& scene)
+{
+    static ULONGLONG checked = 0;
+    static std::filesystem::file_time_type loaded{};
+    if (GetTickCount64() - checked < 1000) {
+        return;
+    }
+    checked = GetTickCount64();
+    std::error_code error;
+    const auto path = std::filesystem::temp_directory_path(error) / L"t5de-renderer-shaders" / L"fixed_function.hlsl";
+    const auto modified = std::filesystem::last_write_time(path, error);
+    if (error || modified == loaded) {
+        return;
+    }
+    const HANDLE file = CreateFileW(path.c_str(), GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE, nullptr,
+                                    OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, nullptr);
+    if (file == INVALID_HANDLE_VALUE) {
+        return;
+    }
+    std::string source(static_cast<std::size_t>(std::filesystem::file_size(path, error)), ' ');
+    DWORD read = 0;
+    ReadFile(file, source.data(), static_cast<DWORD>(source.size()), &read, nullptr);
+    CloseHandle(file);
+    source.resize(read);
+    loaded = modified;
+    scene.setShaderSource(std::move(source));
+    info("shaders reloaded from {}", path.string());
+}
+
+// Where the child window goes in the client's 3D view, and where in the 3D view its scene starts (offset).
+struct Placement {
+    RECT window{};
+    int offset = 0;
+};
+
+Placement placement(HWND parent, View view)
+{
+    Placement place;
+    GetClientRect(parent, &place.window);
+    if (view == View::Split || view == View::Compare) {
+        place.window.left = place.window.right / 2;
+    }
+    place.offset = view == View::Compare ? 0 : place.window.left;
+    if (view == View::Off) {
+        place.window = {};
+    }
+    return place;
 }
 
 } // namespace
@@ -203,18 +278,25 @@ int WINAPI wWinMain(HINSTANCE, HINSTANCE, PWSTR, int)
         }
 
         // Follow the client's 3D view's size.
-        const RECT place = placement(clientWindow, channel->view);
+        const auto [place, offset] = placement(clientWindow, current_view(channel->view));
         const int width = place.right - place.left;
         const int height = place.bottom - place.top;
-        if (std::memcmp(&place, &placed, sizeof(RECT)) != 0 && width > 0 && height > 0) {
-            SetWindowPos(window, nullptr, place.left, place.top, width, height, SWP_NOZORDER | SWP_NOACTIVATE);
-            swapChain->Resize(static_cast<Uint32>(width), static_cast<Uint32>(height));
+        if (std::memcmp(&place, &placed, sizeof(RECT)) != 0) {
             placed = place;
-            info("drawing {}x{} at {} in the client's 3D view", width, height, place.left);
+            if (width > 0 && height > 0) {
+                SetWindowPos(window, nullptr, place.left, place.top, width, height,
+                             SWP_NOZORDER | SWP_NOACTIVATE | SWP_SHOWWINDOW);
+                swapChain->Resize(static_cast<Uint32>(width), static_cast<Uint32>(height));
+                info("drawing {}x{} at {} in the client's 3D view, its scene from {}", width, height, place.left, offset);
+            } else {
+                ShowWindow(window, SW_HIDE);
+                info("hidden");
+            }
         }
+        reload_shaders(scene);
         LARGE_INTEGER start, end;
         QueryPerformanceCounter(&start);
-        if (scene.execute(std::span(frame).first(complete), place.left, width > 0 && height > 0)) {
+        if (scene.execute(std::span(frame).first(complete), offset, width > 0 && height > 0)) {
             swapChain->Present(0);
             QueryPerformanceCounter(&end);
             drawTime += static_cast<double>(end.QuadPart - start.QuadPart) / static_cast<double>(frequency.QuadPart);