// Mipmap-Compatible Texture Sampling Deblocking Shader Testbed - native C++/Direct3D 11 port.
// Copyright (C) 2026 Binomial LLC.  LICENSE: Apache 2.0
//
// Loads a Basis Universal .KTX2, transcodes it to BC7 (or uncompressed RGBA8 when BC7
// isn't usable -- see the GPU-format-selection comment in load_ktx2_texture() for
// the 4-alignment rules), uploads all mip
// levels, and renders it with a deblocking pixel shader (bin/deblock.hlsl).
// Port of the shader_deblocking_glfw OpenGL sample: same assets, same behavior, same
// controls, same shader logic -- only the graphics API layer changes.
//
// Usage: deblock_d3d11 <file.ktx2> [--bc7|--rgba32] [--nomips]
// Controls: arrows move, W/S zoom, A/D yaw, Q/E pitch, C cube/quad, B/T/P filter,
//           R reload shader, 1-8 toggle const0.xyzw/const1.xyzw, Space reset, Esc quit.
//           (1 = deblock on/off, 2 = edge visualization.)
//
// Dependencies: the C runtime, Win32, D3D11, D3DCompiler. The Basis Universal
// transcoder is compiled in directly (see CMakeLists.txt); nothing links against
// any other part of the repo.

#define WIN32_LEAN_AND_MEAN
#define NOMINMAX
#include <windows.h>
#include <d3d11.h>
#include <d3dcompiler.h>

#include <cstdio>
#include <cstdint>
#include <cstring>
#include <cmath>
#include <string>
#include <vector>
#include <fstream>
#include <sstream>

#include "basisu_transcoder.h"

#pragma comment(lib, "d3d11.lib")
#pragma comment(lib, "d3dcompiler.lib")

// Set to 1 to request the D3D11 debug layer (needs the Graphics Tools optional feature
// installed; falls back to a non-debug device when unavailable).
#ifdef _DEBUG
#define ENABLE_D3D_DEBUG 1
#else
#define ENABLE_D3D_DEBUG 0
#endif

template <typename T> static void safe_release(T*& p) { if (p) { p->Release(); p = nullptr; } }

// ---------------------------------------------------------------------------
// 8x8 debug font (g_debug_font8x8_basic from encoder/basisu_enc.cpp, ASCII 32-127).
// Bit order: pixel (x,y) set if (glyph[y] >> x) & 1  (LSB = leftmost, y=0 = top).
// ---------------------------------------------------------------------------
static const uint8_t g_font8x8[96][8] = {
 { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00}, // ' '
 { 0x18,0x3C,0x3C,0x18,0x18,0x00,0x18,0x00}, // '!'
 { 0x36,0x36,0x00,0x00,0x00,0x00,0x00,0x00}, // '"'
 { 0x36,0x36,0x7F,0x36,0x7F,0x36,0x36,0x00}, // '#'
 { 0x0C,0x3E,0x03,0x1E,0x30,0x1F,0x0C,0x00}, // '$'
 { 0x00,0x63,0x33,0x18,0x0C,0x66,0x63,0x00}, // '%'
 { 0x1C,0x36,0x1C,0x6E,0x3B,0x33,0x6E,0x00}, // '&'
 { 0x06,0x06,0x03,0x00,0x00,0x00,0x00,0x00}, // '''
 { 0x18,0x0C,0x06,0x06,0x06,0x0C,0x18,0x00}, // '('
 { 0x06,0x0C,0x18,0x18,0x18,0x0C,0x06,0x00}, // ')'
 { 0x00,0x66,0x3C,0xFF,0x3C,0x66,0x00,0x00}, // '*'
 { 0x00,0x0C,0x0C,0x3F,0x0C,0x0C,0x00,0x00}, // '+'
 { 0x00,0x00,0x00,0x00,0x00,0x0C,0x0C,0x06}, // ','
 { 0x00,0x00,0x00,0x3F,0x00,0x00,0x00,0x00}, // '-'
 { 0x00,0x00,0x00,0x00,0x00,0x0C,0x0C,0x00}, // '.'
 { 0x60,0x30,0x18,0x0C,0x06,0x03,0x01,0x00}, // '/'
 { 0x3E,0x63,0x73,0x7B,0x6F,0x67,0x3E,0x00}, // '0'
 { 0x0C,0x0E,0x0C,0x0C,0x0C,0x0C,0x3F,0x00}, // '1'
 { 0x1E,0x33,0x30,0x1C,0x06,0x33,0x3F,0x00}, // '2'
 { 0x1E,0x33,0x30,0x1C,0x30,0x33,0x1E,0x00}, // '3'
 { 0x38,0x3C,0x36,0x33,0x7F,0x30,0x78,0x00}, // '4'
 { 0x3F,0x03,0x1F,0x30,0x30,0x33,0x1E,0x00}, // '5'
 { 0x1C,0x06,0x03,0x1F,0x33,0x33,0x1E,0x00}, // '6'
 { 0x3F,0x33,0x30,0x18,0x0C,0x0C,0x0C,0x00}, // '7'
 { 0x1E,0x33,0x33,0x1E,0x33,0x33,0x1E,0x00}, // '8'
 { 0x1E,0x33,0x33,0x3E,0x30,0x18,0x0E,0x00}, // '9'
 { 0x00,0x0C,0x0C,0x00,0x00,0x0C,0x0C,0x00}, // ':'
 { 0x00,0x0C,0x0C,0x00,0x00,0x0C,0x0C,0x06}, // ';'
 { 0x18,0x0C,0x06,0x03,0x06,0x0C,0x18,0x00}, // '<'
 { 0x00,0x00,0x3F,0x00,0x00,0x3F,0x00,0x00}, // '='
 { 0x06,0x0C,0x18,0x30,0x18,0x0C,0x06,0x00}, // '>'
 { 0x1E,0x33,0x30,0x18,0x0C,0x00,0x0C,0x00}, // '?'
 { 0x3E,0x63,0x7B,0x7B,0x7B,0x03,0x1E,0x00}, // '@'
 { 0x0C,0x1E,0x33,0x33,0x3F,0x33,0x33,0x00}, // 'A'
 { 0x3F,0x66,0x66,0x3E,0x66,0x66,0x3F,0x00}, // 'B'
 { 0x3C,0x66,0x03,0x03,0x03,0x66,0x3C,0x00}, // 'C'
 { 0x1F,0x36,0x66,0x66,0x66,0x36,0x1F,0x00}, // 'D'
 { 0x7F,0x46,0x16,0x1E,0x16,0x46,0x7F,0x00}, // 'E'
 { 0x7F,0x46,0x16,0x1E,0x16,0x06,0x0F,0x00}, // 'F'
 { 0x3C,0x66,0x03,0x03,0x73,0x66,0x7C,0x00}, // 'G'
 { 0x33,0x33,0x33,0x3F,0x33,0x33,0x33,0x00}, // 'H'
 { 0x1E,0x0C,0x0C,0x0C,0x0C,0x0C,0x1E,0x00}, // 'I'
 { 0x78,0x30,0x30,0x30,0x33,0x33,0x1E,0x00}, // 'J'
 { 0x67,0x66,0x36,0x1E,0x36,0x66,0x67,0x00}, // 'K'
 { 0x0F,0x06,0x06,0x06,0x46,0x66,0x7F,0x00}, // 'L'
 { 0x63,0x77,0x7F,0x7F,0x6B,0x63,0x63,0x00}, // 'M'
 { 0x63,0x67,0x6F,0x7B,0x73,0x63,0x63,0x00}, // 'N'
 { 0x1C,0x36,0x63,0x63,0x63,0x36,0x1C,0x00}, // 'O'
 { 0x3F,0x66,0x66,0x3E,0x06,0x06,0x0F,0x00}, // 'P'
 { 0x1E,0x33,0x33,0x33,0x3B,0x1E,0x38,0x00}, // 'Q'
 { 0x3F,0x66,0x66,0x3E,0x36,0x66,0x67,0x00}, // 'R'
 { 0x1E,0x33,0x07,0x0E,0x38,0x33,0x1E,0x00}, // 'S'
 { 0x3F,0x2D,0x0C,0x0C,0x0C,0x0C,0x1E,0x00}, // 'T'
 { 0x33,0x33,0x33,0x33,0x33,0x33,0x3F,0x00}, // 'U'
 { 0x33,0x33,0x33,0x33,0x33,0x1E,0x0C,0x00}, // 'V'
 { 0x63,0x63,0x63,0x6B,0x7F,0x77,0x63,0x00}, // 'W'
 { 0x63,0x63,0x36,0x1C,0x1C,0x36,0x63,0x00}, // 'X'
 { 0x33,0x33,0x33,0x1E,0x0C,0x0C,0x1E,0x00}, // 'Y'
 { 0x7F,0x63,0x31,0x18,0x4C,0x66,0x7F,0x00}, // 'Z'
 { 0x1E,0x06,0x06,0x06,0x06,0x06,0x1E,0x00}, // '['
 { 0x03,0x06,0x0C,0x18,0x30,0x60,0x40,0x00}, // '\'
 { 0x1E,0x18,0x18,0x18,0x18,0x18,0x1E,0x00}, // ']'
 { 0x08,0x1C,0x36,0x63,0x00,0x00,0x00,0x00}, // '^'
 { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xFF}, // '_'
 { 0x0C,0x0C,0x18,0x00,0x00,0x00,0x00,0x00}, // '`'
 { 0x00,0x00,0x1E,0x30,0x3E,0x33,0x6E,0x00}, // 'a'
 { 0x07,0x06,0x06,0x3E,0x66,0x66,0x3B,0x00}, // 'b'
 { 0x00,0x00,0x1E,0x33,0x03,0x33,0x1E,0x00}, // 'c'
 { 0x38,0x30,0x30,0x3E,0x33,0x33,0x6E,0x00}, // 'd'
 { 0x00,0x00,0x1E,0x33,0x3F,0x03,0x1E,0x00}, // 'e'
 { 0x1C,0x36,0x06,0x0F,0x06,0x06,0x0F,0x00}, // 'f'
 { 0x00,0x00,0x6E,0x33,0x33,0x3E,0x30,0x1F}, // 'g'
 { 0x07,0x06,0x36,0x6E,0x66,0x66,0x67,0x00}, // 'h'
 { 0x0C,0x00,0x0E,0x0C,0x0C,0x0C,0x1E,0x00}, // 'i'
 { 0x30,0x00,0x30,0x30,0x30,0x33,0x33,0x1E}, // 'j'
 { 0x07,0x06,0x66,0x36,0x1E,0x36,0x67,0x00}, // 'k'
 { 0x0E,0x0C,0x0C,0x0C,0x0C,0x0C,0x1E,0x00}, // 'l'
 { 0x00,0x00,0x33,0x7F,0x7F,0x6B,0x63,0x00}, // 'm'
 { 0x00,0x00,0x1F,0x33,0x33,0x33,0x33,0x00}, // 'n'
 { 0x00,0x00,0x1E,0x33,0x33,0x33,0x1E,0x00}, // 'o'
 { 0x00,0x00,0x3B,0x66,0x66,0x3E,0x06,0x0F}, // 'p'
 { 0x00,0x00,0x6E,0x33,0x33,0x3E,0x30,0x78}, // 'q'
 { 0x00,0x00,0x3B,0x6E,0x66,0x06,0x0F,0x00}, // 'r'
 { 0x00,0x00,0x3E,0x03,0x1E,0x30,0x1F,0x00}, // 's'
 { 0x08,0x0C,0x3E,0x0C,0x0C,0x2C,0x18,0x00}, // 't'
 { 0x00,0x00,0x33,0x33,0x33,0x33,0x6E,0x00}, // 'u'
 { 0x00,0x00,0x33,0x33,0x33,0x1E,0x0C,0x00}, // 'v'
 { 0x00,0x00,0x63,0x6B,0x7F,0x7F,0x36,0x00}, // 'w'
 { 0x00,0x00,0x63,0x36,0x1C,0x36,0x63,0x00}, // 'x'
 { 0x00,0x00,0x33,0x33,0x33,0x3E,0x30,0x1F}, // 'y'
 { 0x00,0x00,0x3F,0x19,0x0C,0x26,0x3F,0x00}, // 'z'
 { 0x38,0x0C,0x0C,0x07,0x0C,0x0C,0x38,0x00}, // '{'
 { 0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x00}, // '|'
 { 0x07,0x0C,0x0C,0x38,0x0C,0x0C,0x07,0x00}, // '}'
 { 0x6E,0x3B,0x00,0x00,0x00,0x00,0x00,0x00}, // '~'
 { 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00}  // 127
};

// ---------------------------------------------------------------------------
// Config / state
// ---------------------------------------------------------------------------
static int   WINDOW_WIDTH  = 1280;
static int   WINDOW_HEIGHT = 720;
static const float FOV_DEGREES = 90.0f;
static const float Z_MIN = 0.40f, Z_MAX = -50.0f;
static const float Z_SPEED = 1.0f, XY_SPEED = 0.75f, ROT_SPEED = 90.0f;

// D3D device / pipeline objects (created once in main).
static ID3D11Device*           g_dev = nullptr;
static ID3D11DeviceContext*    g_ctx = nullptr;
static IDXGISwapChain*         g_swapchain = nullptr;
static ID3D11RenderTargetView* g_rtv = nullptr;
static ID3D11Texture2D*        g_depth_tex = nullptr;
static ID3D11DepthStencilView* g_dsv = nullptr;
static ID3D11SamplerState*     g_samplers[3] = {};   // 0=point,1=bilinear,2=trilinear
static ID3D11RasterizerState*  g_raster = nullptr;   // CULL_NONE (the GL sample never enables culling)
static ID3D11DepthStencilState* g_depth_on = nullptr, * g_depth_off = nullptr;
static ID3D11BlendState*       g_blend_alpha = nullptr;
static ID3D11Buffer*           g_cbuffer = nullptr;
static bool                    g_quit = false;

struct State {
    float x = 0, y = 0, z = -3.0f, yaw = 0, pitch = 0;
    bool  cube = false;                        // false = quad, true = cube
    int   filter_mode = 1;                     // 0=point,1=bilinear,2=trilinear
    ID3D11VertexShader*  vs = nullptr;
    ID3D11PixelShader*   ps = nullptr;
    ID3D11InputLayout*   layout = nullptr;
    ID3D11Texture2D*          texture = nullptr;
    ID3D11ShaderResourceView* srv = nullptr;
    int    tex_w = 0, tex_h = 0;               // dims of the texture AS CREATED (padded on the BC7 round-up path)
    int    block_w = 12, block_h = 12;         // deblock filter block size (from the KTX2 header -- the SOURCE lattice)
    int    mip_count = 1;
    float  const0[4] = {0,0,0,0};
    float  const1[4] = {0,0,0,0};
    // source texture info (overlay line 1)
    int    info_orig_w = 0, info_orig_h = 0, info_mips = 0;
    int    info_block_w = 0, info_block_h = 0, info_deblock_id = 0;
    std::string info_fmt, info_gpu_fmt;
    // debug overlay
    ID3D11VertexShader*       debug_vs = nullptr;
    ID3D11PixelShader*        debug_ps = nullptr;
    ID3D11InputLayout*        debug_layout = nullptr;
    ID3D11Buffer*             debug_vb = nullptr, * debug_ib = nullptr;
    ID3D11Texture2D*          debug_tex = nullptr;
    ID3D11ShaderResourceView* debug_srv = nullptr;
    bool   debug_dirty = true;
    std::string shader_path;
};
static State g;
// Initial values (for Space reset).
static float INIT_CONST0[4] = {0,0,0,0};

static const char* filter_name(int m) { return m == 0 ? "POINT" : (m == 2 ? "TRILINEAR" : "BILINEAR"); }

// ---------------------------------------------------------------------------
// 4x4 matrices (row-major with column-vector convention, exactly like the GL and
// Python samples; see set_uniforms() for the single transpose at cbuffer-write time).
// Reimplemented locally on purpose -- depending on DirectXMath would save ~50 lines
// and cost the reader SIMD alignment rules and header dependencies. Zero-dependency,
// one-file readability is a deliberate property of this sample family.
// ---------------------------------------------------------------------------
struct Mat4 { float m[16]; };
static Mat4 mat_identity() { Mat4 r{}; for (int i=0;i<4;i++) r.m[i*4+i]=1.0f; return r; }
static Mat4 mat_mul(const Mat4& a, const Mat4& b) {
    Mat4 r{};
    for (int i=0;i<4;i++) for (int j=0;j<4;j++) { float s=0; for(int k=0;k<4;k++) s+=a.m[i*4+k]*b.m[k*4+j]; r.m[i*4+j]=s; }
    return r;
}
// D3D convention: clip-space depth runs 0..1 (GL runs -1..1), so m[10]/m[14] here
// intentionally differ from the GL sample's mat_perspective -- this is not a bug.
static Mat4 mat_perspective(float fov_deg, float aspect, float znear, float zfar) {
    Mat4 m{};
    float f = 1.0f / std::tan((fov_deg * 3.14159265358979f / 180.0f) / 2.0f);
    m.m[0*4+0] = f / aspect;
    m.m[1*4+1] = f;
    m.m[2*4+2] = zfar / (znear - zfar);
    m.m[2*4+3] = (zfar * znear) / (znear - zfar);
    m.m[3*4+2] = -1.0f;
    return m;
}
static Mat4 mat_translate(float x, float y, float z) {
    Mat4 m = mat_identity(); m.m[0*4+3]=x; m.m[1*4+3]=y; m.m[2*4+3]=z; return m;
}
static Mat4 mat_rot_y(float deg) {
    Mat4 m = mat_identity(); float r=deg*3.14159265358979f/180.0f, c=std::cos(r), s=std::sin(r);
    m.m[0*4+0]=c; m.m[0*4+2]=s; m.m[2*4+0]=-s; m.m[2*4+2]=c; return m;
}
static Mat4 mat_rot_x(float deg) {
    Mat4 m = mat_identity(); float r=deg*3.14159265358979f/180.0f, c=std::cos(r), s=std::sin(r);
    m.m[1*4+1]=c; m.m[1*4+2]=-s; m.m[2*4+1]=s; m.m[2*4+2]=c; return m;
}
static Mat4 mat_transpose(const Mat4& a) {
    Mat4 r{}; for (int i=0;i<4;i++) for (int j=0;j<4;j++) r.m[i*4+j]=a.m[j*4+i]; return r;
}

// ---------------------------------------------------------------------------
// Shader loading (bin/deblock.hlsl, compiled at runtime so developers can edit it
// and press R, exactly as they can with shader.glsl in the GL sample).
// ---------------------------------------------------------------------------
static std::string read_file(const std::string& path) {
    std::ifstream f(path, std::ios::binary);
    if (!f) return std::string();
    std::ostringstream ss; ss << f.rdbuf(); return ss.str();
}

static ID3DBlob* compile_hlsl_file(const std::string& path, const char* entry, const char* target) {
    // Byte-to-wchar widen: fine for the ASCII "deblock.hlsl" path this sample uses,
    // but it mangles non-ASCII paths -- use MultiByteToWideChar(CP_UTF8,...) if you
    // adapt this to load shaders from arbitrary (possibly Unicode) asset paths.
    std::wstring wpath(path.begin(), path.end());
    ID3DBlob* code = nullptr, * errors = nullptr;
    // Warnings print but do not fail the compile: the R-key hot-reload workflow
    // shouldn't refuse an experimental edit over an unused variable. (The shipped
    // shader is verified warning-clean offline with fxc /WX.)
    UINT flags = D3DCOMPILE_ENABLE_STRICTNESS;
    HRESULT hr = D3DCompileFromFile(wpath.c_str(), nullptr, D3D_COMPILE_STANDARD_FILE_INCLUDE,
                                    entry, target, flags, 0, &code, &errors);
    if (errors) { fprintf(stderr, "%s (%s):\n%s\n", FAILED(hr) ? "SHADER ERROR" : "SHADER WARNING",
                          entry, (const char*)errors->GetBufferPointer()); errors->Release(); }
    if (FAILED(hr)) { safe_release(code); return nullptr; }
    return code;
}

// Compiles deblock.hlsl (VSMain/PSMain), and on success replaces the current
// shaders + input layout. On failure the previous shaders are kept.
static bool load_shader(const std::string& path) {
    ID3DBlob* vsb = compile_hlsl_file(path, "VSMain", "vs_5_0");
    if (!vsb) return false;
    ID3DBlob* psb = compile_hlsl_file(path, "PSMain", "ps_5_0");
    if (!psb) { vsb->Release(); return false; }

    ID3D11VertexShader* vs = nullptr; ID3D11PixelShader* ps = nullptr; ID3D11InputLayout* layout = nullptr;
    bool ok = SUCCEEDED(g_dev->CreateVertexShader(vsb->GetBufferPointer(), vsb->GetBufferSize(), nullptr, &vs)) &&
              SUCCEEDED(g_dev->CreatePixelShader(psb->GetBufferPointer(), psb->GetBufferSize(), nullptr, &ps));
    if (ok) {
        const D3D11_INPUT_ELEMENT_DESC il[] = {
            { "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0,  D3D11_INPUT_PER_VERTEX_DATA, 0 },
            { "TEXCOORD", 0, DXGI_FORMAT_R32G32_FLOAT,    0, 12, D3D11_INPUT_PER_VERTEX_DATA, 0 },
        };
        ok = SUCCEEDED(g_dev->CreateInputLayout(il, 2, vsb->GetBufferPointer(), vsb->GetBufferSize(), &layout));
    }
    vsb->Release(); psb->Release();
    if (!ok) { safe_release(vs); safe_release(ps); safe_release(layout); return false; }

    safe_release(g.vs); safe_release(g.ps); safe_release(g.layout);
    g.vs = vs; g.ps = ps; g.layout = layout;
    printf("Shader compiled successfully.\n");
    return true;
}
static void reload_shader() {
    if (!load_shader(g.shader_path))
        fprintf(stderr, "Shader reload failed, keeping previous shader.\n");
}

// ---------------------------------------------------------------------------
// GPU format selection.
// On desktop D3D11 there is no ASTC or ETC support, so the GL sample's
// ASTC -> BC7 -> ETC2 -> RGBA8 ladder collapses to BC7 -> RGBA8.
//
// IMPORTANT (D3D11 limitation): BC1-7 require the BASE mip level's width AND height
// to be multiples of 4 -- CreateTexture2D fails otherwise, and unlike D3D12 (which has
// the optional UnalignedBlockTexturesSupported feature) D3D11 has no opt-out. So:
//
//   base 4-aligned                  -> BC7, full mip chain.
//   NOT 4-aligned, mipmapped        -> uncompressed RGBA8. No reliable BC workaround
//        exists here: rounding the base up changes the dims D3D derives for every
//        smaller mip (floor(alignedDim/2^L) vs floor(origDim/2^L)), so the transcoded
//        mip data no longer lines up with what the API expects.
//   NOT 4-aligned, single level     -> STILL BC7: create the texture with dims rounded
//        up to a multiple of 4 and upload the transcoded blocks as-is. This is sound
//        because the data already is that size -- the transcoder emits complete 4x4
//        blocks and the encoder filled the padding by duplicating edge rows/columns.
//        We deliberately render the padded texture at UV 0..1 (no UV cropping): the
//        few duplicated edge texels are harmless for a viewer, and it keeps the quad
//        and shader math trivial. (An engine that needs exact bounds would instead
//        scale its UVs by origDim/alignedDim.)
//
// Note this affects the GPU STORAGE format only. The deblock filter block size always
// comes from the file's native ASTC/XUASTC block size, independent of the GPU storage
// format's block size (e.g. BC7 stores 4x4 blocks but we still filter the original
// 12x12 lattice).
// ---------------------------------------------------------------------------
enum PreferFormat { PREF_NONE, PREF_BC7, PREF_RGBA32 };

static std::string ktx2_format_name(basist::ktx2_transcoder& tc) {
    int bw = tc.get_block_width(), bh = tc.get_block_height();
    char buf[64];
    if (tc.is_etc1s()) return "ETC1S";
    if (tc.is_uastc()) return "UASTC LDR 4x4";
    if (tc.is_xuastc_ldr()) { snprintf(buf,sizeof(buf),"XUASTC LDR %dx%d",bw,bh); return buf; }
    if (tc.is_astc_ldr())   { snprintf(buf,sizeof(buf),"ASTC LDR %dx%d",bw,bh); return buf; }
    if (tc.is_xubc7()) return "XUBC7";
    if (tc.is_hdr_4x4()) return "UASTC HDR 4x4";
    if (tc.is_hdr_6x6()) { snprintf(buf,sizeof(buf),"HDR 6x6 %dx%d",bw,bh); return buf; }
    if (tc.is_hdr()) return "HDR";
    snprintf(buf,sizeof(buf),"basis_fmt %d",(int)tc.get_basis_tex_format());
    return buf;
}

// Load + transcode a KTX2 into a D3D11 texture + SRV. Returns true on success.
// Build-new-then-swap: the new texture is fully constructed before the old one is
// released, so a failed load leaves the previous image on screen.
static bool load_ktx2_texture(const std::string& path, PreferFormat pref, bool no_mips) {
    printf("Loading KTX2: %s\n", path.c_str());
    std::vector<uint8_t> data;
    {
        std::ifstream f(path, std::ios::binary);
        if (!f) { fprintf(stderr, "ERROR: could not open '%s'\n", path.c_str()); return false; }
        f.seekg(0, std::ios::end); std::streamoff sz = f.tellg(); f.seekg(0);
        data.resize((size_t)sz); f.read((char*)data.data(), sz);
    }

    basist::ktx2_transcoder tc;
    if (!tc.init(data.data(), (uint32_t)data.size())) { fprintf(stderr, "ERROR: ktx2_transcoder.init failed\n"); return false; }

    // This sample handles LDR textures only.
    if (tc.is_hdr()) {
        fprintf(stderr, "ERROR: '%s' is an HDR texture; this sample supports LDR textures only.\n", path.c_str());
        return false;
    }

    const basist::basis_tex_format basis_fmt = tc.get_basis_tex_format();
    const int file_bw = (int)tc.get_block_width();
    const int file_bh = (int)tc.get_block_height();
    const int levels  = (int)tc.get_levels();
    const int base_w  = (int)tc.get_width();
    const int base_h  = (int)tc.get_height();
    // --nomips: upload only the base level (level 0) instead of the full mip chain.
    // Note this also re-enables the BC7 round-up path for non-4-aligned files, since
    // the created texture then has a single level.
    const int load_levels = no_mips ? 1 : levels;

    using TF = basist::transcoder_texture_format;
    auto supported = [&](TF f){ return basist::basis_is_format_supported(f, basis_fmt); };

    const bool base_4_aligned = ((base_w % 4) == 0) && ((base_h % 4) == 0);
    const bool bc7_usable = supported(TF::cTFBC7_RGBA) && (base_4_aligned || load_levels == 1);

    bool use_bc7 = bc7_usable;
    if (pref == PREF_RGBA32) use_bc7 = false;
    if (pref == PREF_BC7 && !bc7_usable) {
        printf("  Note: BC7 not usable for this file (non-4-aligned base with mipmaps?); using RGBA8.\n");
        use_bc7 = false;
    }
    if (use_bc7 && !base_4_aligned)
        printf("  Note: non-4-aligned single-level texture; rounding dims up to 4 for BC7 (padding is encoder-duplicated edge texels).\n");

    const TF tfmt = use_bc7 ? TF::cTFBC7_RGBA : TF::cTFRGBA32;
    const DXGI_FORMAT dxgi_fmt = use_bc7 ? DXGI_FORMAT_BC7_UNORM : DXGI_FORMAT_R8G8B8A8_UNORM;
    // UNORM on purpose, never BC7_UNORM_SRGB / R8G8B8A8_UNORM_SRGB: the whole pipeline
    // samples the stored sRGB-encoded bytes verbatim and writes them straight out with
    // no linear->sRGB encode, matching the GL and WebGL versions. An sRGB format here
    // would make the hardware decode sRGB->linear on sample and the output would
    // display far too dark. Do not "upgrade" this.

    // Texture dims as created: padded up to the block grid on the BC7 round-up path.
    const int tex_w = use_bc7 ? ((base_w + 3) & ~3) : base_w;
    const int tex_h = use_bc7 ? ((base_h + 3) & ~3) : base_h;

    const uint32_t deblock_id = tc.get_deblocking_filter_index();
    std::string fmt_name = ktx2_format_name(tc);
    const char* gpu_fmt_name = use_bc7 ? "DXGI_FORMAT_BC7_UNORM" : "DXGI_FORMAT_R8G8B8A8_UNORM";
    printf("  Source     : %dx%d  levels=%d  fmt=%s\n", base_w, base_h, levels, fmt_name.c_str());
    printf("  GPU format : %s%s\n", gpu_fmt_name, (use_bc7 && !base_4_aligned) ? "  (dims rounded up to 4)" : "");
    printf("  Deblock    : %s  filter block=%dx%d\n", deblock_id==1?"ON":"off", file_bw, file_bh);

    if (!tc.start_transcoding()) { fprintf(stderr, "ERROR: start_transcoding failed\n"); return false; }

    // Transcode every level up front, then create the texture with one
    // D3D11_SUBRESOURCE_DATA per level (immutable -- the sample never re-uploads).
    std::vector<std::vector<uint8_t>> level_data(load_levels);
    std::vector<D3D11_SUBRESOURCE_DATA> subs(load_levels);
    const uint32_t bpb = basist::basis_get_bytes_per_block_or_pixel(tfmt);
    for (int lvl = 0; lvl < load_levels; lvl++) {
        basist::ktx2_image_level_info info;
        if (!tc.get_image_level_info(info, lvl, 0, 0)) { fprintf(stderr,"ERROR: get_image_level_info failed (lvl %d)\n",lvl); return false; }
        const uint32_t ow = info.m_orig_width, oh = info.m_orig_height;
        const uint32_t out_size = basist::basis_compute_transcoded_image_size_in_bytes(tfmt, ow, oh);
        const uint32_t out_units = out_size / bpb; // blocks (BC7) or pixels (RGBA32)
        level_data[lvl].resize(out_size);
        // Disable CPU deblocking: the GPU shader performs it (no double-filtering).
        if (!tc.transcode_image_level(lvl, 0, 0, level_data[lvl].data(), out_units, tfmt,
                                      basist::cDecodeFlagsNoDeblockFiltering)) {
            fprintf(stderr, "ERROR: transcode_image_level failed (lvl %d)\n", lvl); return false;
        }
        // SysMemPitch: bytes per block-row for BC7 (the transcoder emits ceil(ow/4)
        // complete blocks per row), bytes per pixel-row for RGBA32.
        subs[lvl].pSysMem = level_data[lvl].data();
        subs[lvl].SysMemPitch = use_bc7 ? ((ow + 3) / 4) * 16 : ow * 4;
        subs[lvl].SysMemSlicePitch = 0;
    }

    D3D11_TEXTURE2D_DESC td{};
    td.Width = (UINT)tex_w; td.Height = (UINT)tex_h;
    td.MipLevels = (UINT)load_levels; td.ArraySize = 1;
    td.Format = dxgi_fmt;
    td.SampleDesc.Count = 1;
    td.Usage = D3D11_USAGE_IMMUTABLE;
    td.BindFlags = D3D11_BIND_SHADER_RESOURCE;

    ID3D11Texture2D* tex = nullptr; ID3D11ShaderResourceView* srv = nullptr;
    HRESULT hr = g_dev->CreateTexture2D(&td, subs.data(), &tex);
    if (FAILED(hr)) { fprintf(stderr, "ERROR: CreateTexture2D failed (0x%08X)\n", (unsigned)hr); return false; }
    hr = g_dev->CreateShaderResourceView(tex, nullptr, &srv);
    if (FAILED(hr)) { tex->Release(); fprintf(stderr, "ERROR: CreateShaderResourceView failed (0x%08X)\n", (unsigned)hr); return false; }

    // Success: swap in the new texture, then release the old one.
    safe_release(g.srv); safe_release(g.texture);
    g.texture = tex; g.srv = srv;
    g.tex_w = tex_w; g.tex_h = tex_h;
    g.block_w = file_bw; g.block_h = file_bh;
    g.mip_count = load_levels;
    g.const0[0] = (deblock_id == 1) ? 1.0f : 0.0f;
    INIT_CONST0[0] = g.const0[0];
    g.info_orig_w = base_w; g.info_orig_h = base_h; g.info_mips = levels;
    g.info_block_w = file_bw; g.info_block_h = file_bh; g.info_deblock_id = (int)deblock_id;
    g.info_fmt = fmt_name; g.info_gpu_fmt = use_bc7 ? "BC7" : "RGBA8";
    printf("  Uploaded %d mip level(s)%s.\n", load_levels,
           no_mips ? "  (--nomips: base level only)" : "");
    return true;
}

// ---------------------------------------------------------------------------
// Geometry (position float3 + uv float2, interleaved -- same as the GL sample).
// ---------------------------------------------------------------------------
static ID3D11Buffer* g_quad_vb = nullptr, * g_quad_ib = nullptr;
static ID3D11Buffer* g_cube_vb = nullptr, * g_cube_ib = nullptr;
static int g_cube_index_count = 0;

static ID3D11Buffer* make_buffer(const void* data, size_t bytes, UINT bind) {
    D3D11_BUFFER_DESC bd{}; bd.ByteWidth = (UINT)bytes; bd.Usage = D3D11_USAGE_IMMUTABLE; bd.BindFlags = bind;
    D3D11_SUBRESOURCE_DATA sd{}; sd.pSysMem = data;
    ID3D11Buffer* b = nullptr;
    if (FAILED(g_dev->CreateBuffer(&bd, &sd, &b))) return nullptr;
    return b;
}
static void create_quad(float aspect) {
    float hw, hh;
    if (aspect >= 1.0f) { hw=1.0f; hh=1.0f/aspect; } else { hw=aspect; hh=1.0f; }
    // UV origin: standard D3D -- (0,0) = top-left = first uploaded row. KTX2 mip data
    // is stored top-row-first, so the quad maps v 0..1 top-to-bottom with NO flip
    // (top vertices get v=0). Note these UVs are identical to the GL sample's: both
    // APIs treat row 0 of the uploaded data as v=0, and neither projection flips y,
    // so the same mapping is correct in both. Verify at bring-up that the test
    // images render right-side up.
    float v[] = {
        -hw,-hh,0.0f, 0.0f,1.0f,  hw,-hh,0.0f, 1.0f,1.0f,
         hw, hh,0.0f, 1.0f,0.0f, -hw, hh,0.0f, 0.0f,0.0f,
    };
    uint32_t idx[] = {0,1,2, 0,2,3};
    g_quad_vb = make_buffer(v, sizeof(v), D3D11_BIND_VERTEX_BUFFER);
    g_quad_ib = make_buffer(idx, sizeof(idx), D3D11_BIND_INDEX_BUFFER);
}
static void create_cube() {
    const float h=0.5f;
    float v[] = {
        // front (z=+h)
        -h,-h, h, 0,1,  h,-h, h, 1,1,  h, h, h, 1,0, -h, h, h, 0,0,
        // back (z=-h)
         h,-h,-h, 0,1, -h,-h,-h, 1,1, -h, h,-h, 1,0,  h, h,-h, 0,0,
        // right (x=+h)
         h,-h, h, 0,1,  h,-h,-h, 1,1,  h, h,-h, 1,0,  h, h, h, 0,0,
        // left (x=-h)
        -h,-h,-h, 0,1, -h,-h, h, 1,1, -h, h, h, 1,0, -h, h,-h, 0,0,
        // top (y=+h)
        -h, h, h, 0,1,  h, h, h, 1,1,  h, h,-h, 1,0, -h, h,-h, 0,0,
        // bottom (y=-h)
        -h,-h,-h, 0,1,  h,-h,-h, 1,1,  h,-h, h, 1,0, -h,-h, h, 0,0,
    };
    std::vector<uint32_t> idx;
    for (int i=0;i<6;i++){ int b=i*4; idx.insert(idx.end(),{(uint32_t)b,(uint32_t)b+1,(uint32_t)b+2,(uint32_t)b,(uint32_t)b+2,(uint32_t)b+3}); }
    g_cube_vb = make_buffer(v, sizeof(v), D3D11_BIND_VERTEX_BUFFER);
    g_cube_ib = make_buffer(idx.data(), idx.size()*sizeof(uint32_t), D3D11_BIND_INDEX_BUFFER);
    g_cube_index_count = (int)idx.size();
}

// ---------------------------------------------------------------------------
// Debug text overlay (8x8 font rasterized to an RGBA texture, drawn as a quad --
// same approach and layout as the GL sample).
// ---------------------------------------------------------------------------
static const int OVL_W = 1280, OVL_H = 84, FONT_SCALE = 2, LINE_ADV = 20;
// The overlay's tiny shaders are embedded here (not in deblock.hlsl) so the
// deliverable shader file stays purely the deblocking operator.
static const char* DEBUG_HLSL =
    "struct VSO { float4 pos : SV_Position; float2 uv : TEXCOORD0; };\n"
    "VSO VSMain(float2 pos : POSITION, float2 uv : TEXCOORD0) {\n"
    "    VSO o; o.pos = float4(pos, 0.0, 1.0); o.uv = uv; return o; }\n"
    "Texture2D tex : register(t0); SamplerState samp : register(s0);\n"
    "float4 PSMain(VSO i) : SV_Target { return tex.Sample(samp, i.uv); }\n";

static void blit_char(std::vector<uint8_t>& buf, int px, int py, char ch) {
    int c = (unsigned char)ch; if (c<32 || c>127) c='.';
    const uint8_t* glyph = g_font8x8[c-32];
    for (int y=0;y<8;y++) for (int x=0;x<8;x++) {
        if (!((glyph[y]>>x)&1)) continue;
        for (int sy=0;sy<FONT_SCALE;sy++) for (int sx=0;sx<FONT_SCALE;sx++) {
            int X=px+x*FONT_SCALE+sx, Y=py+y*FONT_SCALE+sy;
            if (X<0||X>=OVL_W||Y<0||Y>=OVL_H) continue;
            uint8_t* d=&buf[(Y*OVL_W+X)*4]; d[0]=255;d[1]=255;d[2]=255;d[3]=255;
        }
    }
}
static void update_debug_text() {
    if (!g.debug_dirty) return;
    std::vector<uint8_t> buf(OVL_W*OVL_H*4);
    for (size_t i=0;i<buf.size();i+=4){ buf[i]=0;buf[i+1]=0;buf[i+2]=0;buf[i+3]=180; }

    char l0[256], l1[256], l2[256];
    snprintf(l0,sizeof(l0),"Res:%dx%d  Mips:%d  Block:%dx%d  DeblockID:%d  Fmt:%s  GPU:%s",
             g.info_orig_w,g.info_orig_h,g.info_mips,g.info_block_w,g.info_block_h,g.info_deblock_id,
             g.info_fmt.c_str(),g.info_gpu_fmt.c_str());
    snprintf(l1,sizeof(l1),"Mode:%-4s Filter:%-9s Deblock:[%d%d%d%d][%d%d%d%d]",
             g.cube?"CUBE":"QUAD", filter_name(g.filter_mode),
             (int)g.const0[0],(int)g.const0[1],(int)g.const0[2],(int)g.const0[3],
             (int)g.const1[0],(int)g.const1[1],(int)g.const1[2],(int)g.const1[3]);
    snprintf(l2,sizeof(l2),"X:%+5.1f Y:%+5.1f Z:%5.1f Yaw:%+6.1f Pitch:%+6.1f", g.x,g.y,g.z,g.yaw,g.pitch);
    // Kept short so it fits the overlay width (OVL_W / (8*FONT_SCALE) chars). Full
    // controls are in --help and the README.
    const char* l3 = "Move:Arrows/WS Rot:ADQE C:cube B/T/P:filter 1:deblk 2:edge R:reload Spc:reset";
    const char* lines[4] = {l0,l1,l2,l3};

    for (int li=0; li<4; li++) {
        int py = 2 + li*LINE_ADV;
        int px = 4;
        for (const char* p=lines[li]; *p; ++p) { blit_char(buf, px, py, *p); px += 8*FONT_SCALE; }
    }

    D3D11_MAPPED_SUBRESOURCE map{};
    if (SUCCEEDED(g_ctx->Map(g.debug_tex, 0, D3D11_MAP_WRITE_DISCARD, 0, &map))) {
        for (int y = 0; y < OVL_H; y++)
            memcpy((uint8_t*)map.pData + y * map.RowPitch, &buf[y * OVL_W * 4], OVL_W * 4);
        g_ctx->Unmap(g.debug_tex, 0);
    }
    g.debug_dirty = false;
}
static bool init_debug() {
    ID3DBlob* vsb = nullptr, * psb = nullptr, * errs = nullptr;
    if (FAILED(D3DCompile(DEBUG_HLSL, strlen(DEBUG_HLSL), "debug_overlay", nullptr, nullptr,
                          "VSMain", "vs_5_0", 0, 0, &vsb, &errs))) {
        if (errs) { fprintf(stderr, "OVERLAY VS ERROR:\n%s\n", (const char*)errs->GetBufferPointer()); errs->Release(); }
        return false;
    }
    safe_release(errs);
    if (FAILED(D3DCompile(DEBUG_HLSL, strlen(DEBUG_HLSL), "debug_overlay", nullptr, nullptr,
                          "PSMain", "ps_5_0", 0, 0, &psb, &errs))) {
        if (errs) { fprintf(stderr, "OVERLAY PS ERROR:\n%s\n", (const char*)errs->GetBufferPointer()); errs->Release(); }
        vsb->Release(); return false;
    }
    safe_release(errs);
    bool ok = SUCCEEDED(g_dev->CreateVertexShader(vsb->GetBufferPointer(), vsb->GetBufferSize(), nullptr, &g.debug_vs)) &&
              SUCCEEDED(g_dev->CreatePixelShader(psb->GetBufferPointer(), psb->GetBufferSize(), nullptr, &g.debug_ps));
    if (ok) {
        const D3D11_INPUT_ELEMENT_DESC il[] = {
            { "POSITION", 0, DXGI_FORMAT_R32G32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0 },
            { "TEXCOORD", 0, DXGI_FORMAT_R32G32_FLOAT, 0, 8, D3D11_INPUT_PER_VERTEX_DATA, 0 },
        };
        ok = SUCCEEDED(g_dev->CreateInputLayout(il, 2, vsb->GetBufferPointer(), vsb->GetBufferSize(), &g.debug_layout));
    }
    vsb->Release(); psb->Release();
    if (!ok) return false;

    D3D11_BUFFER_DESC bd{}; bd.ByteWidth = 16*sizeof(float); bd.Usage = D3D11_USAGE_DYNAMIC;
    bd.BindFlags = D3D11_BIND_VERTEX_BUFFER; bd.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
    if (FAILED(g_dev->CreateBuffer(&bd, nullptr, &g.debug_vb))) return false;
    uint32_t idx[] = {0,1,2, 0,2,3};
    g.debug_ib = make_buffer(idx, sizeof(idx), D3D11_BIND_INDEX_BUFFER);
    if (!g.debug_ib) return false;

    D3D11_TEXTURE2D_DESC td{};
    td.Width = OVL_W; td.Height = OVL_H; td.MipLevels = 1; td.ArraySize = 1;
    td.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
    td.SampleDesc.Count = 1;
    td.Usage = D3D11_USAGE_DYNAMIC;
    td.BindFlags = D3D11_BIND_SHADER_RESOURCE;
    td.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
    if (FAILED(g_dev->CreateTexture2D(&td, nullptr, &g.debug_tex))) return false;
    if (FAILED(g_dev->CreateShaderResourceView(g.debug_tex, nullptr, &g.debug_srv))) return false;
    return true;
}
static void draw_debug_text() {
    if (!g.debug_vs) return;
    update_debug_text();
    // Top-left rect of OVL_W x OVL_H pixels in NDC (data row 0 = top => top uv.v=0).
    float w = (float)OVL_W / WINDOW_WIDTH * 2.0f, h = (float)OVL_H / WINDOW_HEIGHT * 2.0f;
    float verts[] = {
        -1.0f,      1.0f,     0.0f, 0.0f,
        -1.0f + w,  1.0f,     1.0f, 0.0f,
        -1.0f + w,  1.0f - h, 1.0f, 1.0f,
        -1.0f,      1.0f - h, 0.0f, 1.0f,
    };
    D3D11_MAPPED_SUBRESOURCE map{};
    if (SUCCEEDED(g_ctx->Map(g.debug_vb, 0, D3D11_MAP_WRITE_DISCARD, 0, &map))) {
        memcpy(map.pData, verts, sizeof(verts));
        g_ctx->Unmap(g.debug_vb, 0);
    }
    const float blend_factor[4] = {0,0,0,0};
    g_ctx->OMSetBlendState(g_blend_alpha, blend_factor, 0xFFFFFFFF);
    g_ctx->OMSetDepthStencilState(g_depth_off, 0);
    g_ctx->IASetInputLayout(g.debug_layout);
    UINT stride = 4*sizeof(float), offset = 0;
    g_ctx->IASetVertexBuffers(0, 1, &g.debug_vb, &stride, &offset);
    g_ctx->IASetIndexBuffer(g.debug_ib, DXGI_FORMAT_R32_UINT, 0);
    g_ctx->VSSetShader(g.debug_vs, nullptr, 0);
    g_ctx->PSSetShader(g.debug_ps, nullptr, 0);
    g_ctx->PSSetShaderResources(0, 1, &g.debug_srv);
    g_ctx->PSSetSamplers(0, 1, &g_samplers[0]); // point filtering for crisp text
    g_ctx->DrawIndexed(6, 0, 0);
    g_ctx->OMSetBlendState(nullptr, blend_factor, 0xFFFFFFFF);
    g_ctx->OMSetDepthStencilState(g_depth_on, 0);
}

// ---------------------------------------------------------------------------
// Swap chain / render target (re)creation.
// ---------------------------------------------------------------------------
static bool create_backbuffer_views() {
    ID3D11Texture2D* bb = nullptr;
    if (FAILED(g_swapchain->GetBuffer(0, __uuidof(ID3D11Texture2D), (void**)&bb))) return false;
    HRESULT hr = g_dev->CreateRenderTargetView(bb, nullptr, &g_rtv);
    bb->Release();
    if (FAILED(hr)) return false;

    D3D11_TEXTURE2D_DESC dd{};
    dd.Width = (UINT)WINDOW_WIDTH; dd.Height = (UINT)WINDOW_HEIGHT;
    dd.MipLevels = 1; dd.ArraySize = 1;
    dd.Format = DXGI_FORMAT_D24_UNORM_S8_UINT;
    dd.SampleDesc.Count = 1;
    dd.Usage = D3D11_USAGE_DEFAULT;
    dd.BindFlags = D3D11_BIND_DEPTH_STENCIL;
    if (FAILED(g_dev->CreateTexture2D(&dd, nullptr, &g_depth_tex))) return false;
    if (FAILED(g_dev->CreateDepthStencilView(g_depth_tex, nullptr, &g_dsv))) return false;
    return true;
}
static void resize_backbuffer(int w, int h) {
    if (!g_swapchain || w <= 0 || h <= 0) return;
    WINDOW_WIDTH = w; WINDOW_HEIGHT = h;
    g_ctx->OMSetRenderTargets(0, nullptr, nullptr);
    safe_release(g_rtv); safe_release(g_dsv); safe_release(g_depth_tex);
    g_swapchain->ResizeBuffers(0, (UINT)w, (UINT)h, DXGI_FORMAT_UNKNOWN, 0);
    if (!create_backbuffer_views())
        fprintf(stderr, "ERROR: backbuffer view recreation failed after resize\n");
    g.debug_dirty = true;
}

// ---------------------------------------------------------------------------
// Input
// ---------------------------------------------------------------------------
static LRESULT CALLBACK wnd_proc(HWND hwnd, UINT msg, WPARAM wp, LPARAM lp) {
    switch (msg) {
        case WM_CLOSE: case WM_DESTROY: g_quit = true; PostQuitMessage(0); return 0;
        case WM_SIZE:
            if (wp != SIZE_MINIMIZED) resize_backbuffer((int)LOWORD(lp), (int)HIWORD(lp));
            return 0;
        case WM_KEYDOWN: {
            if (lp & (1 << 30)) return 0; // ignore auto-repeat (GL sample acts on PRESS only)
            switch (wp) {
                case VK_ESCAPE: g_quit = true; break;
                case 'R': reload_shader(); break;
                case 'B': g.filter_mode=1; g.debug_dirty=true; printf("Filter: BILINEAR\n"); break;
                case 'T': g.filter_mode=2; g.debug_dirty=true; printf("Filter: TRILINEAR\n"); break;
                case 'P': g.filter_mode=0; g.debug_dirty=true; printf("Filter: POINT\n"); break;
                case 'C': g.cube=!g.cube; g.debug_dirty=true; break;
                case '1': g.const0[0]=1.0f-g.const0[0]; g.debug_dirty=true; break;
                case '2': g.const0[1]=1.0f-g.const0[1]; g.debug_dirty=true; break;
                case '3': g.const0[2]=1.0f-g.const0[2]; g.debug_dirty=true; break;
                case '4': g.const0[3]=1.0f-g.const0[3]; g.debug_dirty=true; break;
                case '5': g.const1[0]=1.0f-g.const1[0]; g.debug_dirty=true; break;
                case '6': g.const1[1]=1.0f-g.const1[1]; g.debug_dirty=true; break;
                case '7': g.const1[2]=1.0f-g.const1[2]; g.debug_dirty=true; break;
                case '8': g.const1[3]=1.0f-g.const1[3]; g.debug_dirty=true; break;
                case VK_SPACE:
                    g.x=0;g.y=0;g.z=-3.0f;g.yaw=0;g.pitch=0;
                    for(int i=0;i<4;i++){g.const0[i]=INIT_CONST0[i];g.const1[i]=0;}
                    g.debug_dirty=true; printf("Reset to initial state\n"); break;
            }
            return 0;
        }
    }
    return DefWindowProcA(hwnd, msg, wp, lp);
}
static bool key_down(int vk) { return (GetAsyncKeyState(vk) & 0x8000) != 0; }
static void process_held_keys(HWND hwnd, float dt) {
    if (GetForegroundWindow() != hwnd) return; // GetAsyncKeyState is global; only react when focused
    if (key_down(VK_SHIFT)) dt *= 1.0f/3.0f;
    bool moved=false;
    if (key_down('W')) {g.z+=Z_SPEED*dt;moved=true;}
    if (key_down('S')) {g.z-=Z_SPEED*dt;moved=true;}
    if (key_down(VK_LEFT))  {g.x+=XY_SPEED*dt;moved=true;}
    if (key_down(VK_RIGHT)) {g.x-=XY_SPEED*dt;moved=true;}
    if (key_down(VK_UP))    {g.y+=XY_SPEED*dt;moved=true;}
    if (key_down(VK_DOWN))  {g.y-=XY_SPEED*dt;moved=true;}
    if (key_down('A')) {g.yaw+=ROT_SPEED*dt;moved=true;}
    if (key_down('D')) {g.yaw-=ROT_SPEED*dt;moved=true;}
    if (key_down('Q')) {g.pitch+=ROT_SPEED*dt;moved=true;}
    if (key_down('E')) {g.pitch-=ROT_SPEED*dt;moved=true;}
    if (g.z < Z_MAX) g.z=Z_MAX; if (g.z > Z_MIN) g.z=Z_MIN;
    if (moved) g.debug_dirty=true;
}

// ---------------------------------------------------------------------------
// Main
// ---------------------------------------------------------------------------
struct CBData {          // must match cbuffer SceneConstants in deblock.hlsl (16-byte rules)
    float mvp[16];
    float texSize[4];
    float lodInfo[4];    // x = maxLod, yzw = padding
    float const0[4];
    float const1[4];
};

static void set_uniforms() {
    Mat4 proj = mat_perspective(FOV_DEGREES, (float)WINDOW_WIDTH/WINDOW_HEIGHT, 0.001f, 100.0f);
    Mat4 model = mat_mul(mat_mul(mat_translate(g.x,g.y,g.z), mat_rot_y(g.yaw)), mat_rot_x(g.pitch));
    Mat4 mvp = mat_mul(proj, model);

    CBData cb{};
    // One transpose at write time: the CPU math is row-major (like the GL sample,
    // which uploaded with transpose=GL_TRUE); HLSL's default cbuffer majority is
    // column-major, so the transpose here makes mul(mvp, v) in the shader see the
    // same matrix the GL shader saw.
    Mat4 mvp_t = mat_transpose(mvp);
    memcpy(cb.mvp, mvp_t.m, sizeof(cb.mvp));
    cb.texSize[0]=(float)g.tex_w; cb.texSize[1]=(float)g.tex_h;
    cb.texSize[2]=(float)g.block_w; cb.texSize[3]=(float)g.block_h;
    cb.lodInfo[0]=(float)(g.mip_count-1);
    memcpy(cb.const0, g.const0, sizeof(cb.const0));
    memcpy(cb.const1, g.const1, sizeof(cb.const1));

    D3D11_MAPPED_SUBRESOURCE map{};
    if (SUCCEEDED(g_ctx->Map(g_cbuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &map))) {
        memcpy(map.pData, &cb, sizeof(cb));
        g_ctx->Unmap(g_cbuffer, 0);
    }
}

int main(int argc, char** argv) {
    // First non-flag argument is the .ktx2 path. Optional --bc7/--rgba32 flags set a
    // PREFERRED GPU format (used if usable, else the default BC7 -> RGBA8 ladder).
    std::string ktx2_path;
    PreferFormat pref = PREF_NONE;
    bool no_mips = false;
    for (int i = 1; i < argc; i++) {
        std::string a = argv[i];
        if      (a == "--bc7")                pref = PREF_BC7;
        else if (a == "--rgba32" || a == "--rgba8") pref = PREF_RGBA32;
        else if (a == "--nomips")             no_mips = true;
        else if (!a.empty() && a[0] == '-')   fprintf(stderr, "WARNING: ignoring unknown option '%s'\n", a.c_str());
        else if (ktx2_path.empty())           ktx2_path = a;
    }
    if (ktx2_path.empty()) {
        printf("Usage: %s <file.ktx2> [--bc7|--rgba32] [--nomips]\n", argv[0]);
        printf("  A format flag prefers that GPU format if usable for this file,\n");
        printf("  otherwise the default BC7 -> RGBA8 ladder applies (BC7 requires a\n");
        printf("  4-aligned base mip, or a single-level texture -- see load_ktx2_texture).\n");
        printf("  --nomips loads only the base mip level (level 0) instead of all levels.\n");
        printf("  The shader is loaded from deblock.hlsl in the working directory.\n");
        printf("  Note: LDR textures only; HDR .ktx2 files are not supported.\n");
        return 1;
    }

    basist::basisu_transcoder_init();

    // Window.
    WNDCLASSEXA wc{}; wc.cbSize = sizeof(wc);
    wc.style = CS_HREDRAW | CS_VREDRAW;
    wc.lpfnWndProc = wnd_proc;
    wc.hInstance = GetModuleHandleA(nullptr);
    wc.hCursor = LoadCursor(nullptr, IDC_ARROW);
    wc.lpszClassName = "deblock_d3d11_wc";
    RegisterClassExA(&wc);

    RECT r{0,0,WINDOW_WIDTH,WINDOW_HEIGHT};
    AdjustWindowRect(&r, WS_OVERLAPPEDWINDOW, FALSE);
    HWND hwnd = CreateWindowA(wc.lpszClassName, "Deblock Shader Testbed (C++/D3D11)",
                              WS_OVERLAPPEDWINDOW | WS_VISIBLE, CW_USEDEFAULT, CW_USEDEFAULT,
                              r.right - r.left, r.bottom - r.top, nullptr, nullptr, wc.hInstance, nullptr);
    if (!hwnd) { fprintf(stderr, "ERROR: window creation failed\n"); return 1; }

    // Device + swap chain. Non-sRGB backbuffer on purpose (see the format comment in
    // load_ktx2_texture): the pipeline passes sRGB-encoded bytes through verbatim.
    DXGI_SWAP_CHAIN_DESC scd{};
    scd.BufferCount = 2;
    scd.BufferDesc.Width = (UINT)WINDOW_WIDTH; scd.BufferDesc.Height = (UINT)WINDOW_HEIGHT;
    scd.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
    scd.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
    scd.OutputWindow = hwnd;
    scd.SampleDesc.Count = 1;
    scd.Windowed = TRUE;
    scd.SwapEffect = DXGI_SWAP_EFFECT_FLIP_DISCARD;

    const D3D_FEATURE_LEVEL want_fl = D3D_FEATURE_LEVEL_11_0; // BC7 requires FL 11_0
    D3D_FEATURE_LEVEL got_fl{};
    UINT dev_flags = 0;
#if ENABLE_D3D_DEBUG
    dev_flags |= D3D11_CREATE_DEVICE_DEBUG;
#endif
    HRESULT hr = D3D11CreateDeviceAndSwapChain(nullptr, D3D_DRIVER_TYPE_HARDWARE, nullptr, dev_flags,
                                               &want_fl, 1, D3D11_SDK_VERSION, &scd,
                                               &g_swapchain, &g_dev, &got_fl, &g_ctx);
#if ENABLE_D3D_DEBUG
    if (FAILED(hr)) {
        // The debug layer needs the "Graphics Tools" optional feature; retry without it.
        fprintf(stderr, "WARNING: D3D11 debug layer unavailable; retrying without it\n");
        dev_flags &= ~D3D11_CREATE_DEVICE_DEBUG;
        hr = D3D11CreateDeviceAndSwapChain(nullptr, D3D_DRIVER_TYPE_HARDWARE, nullptr, dev_flags,
                                           &want_fl, 1, D3D11_SDK_VERSION, &scd,
                                           &g_swapchain, &g_dev, &got_fl, &g_ctx);
    }
#endif
    if (FAILED(hr)) { fprintf(stderr, "ERROR: D3D11CreateDeviceAndSwapChain failed (0x%08X)\n", (unsigned)hr); return 1; }
    printf("Direct3D 11, feature level 0x%04X%s\n", (unsigned)got_fl,
           (dev_flags & D3D11_CREATE_DEVICE_DEBUG) ? "  (debug layer active)" : "");

    if (!create_backbuffer_views()) { fprintf(stderr, "ERROR: backbuffer view creation failed\n"); return 1; }

    // Fixed-function state.
    {
        D3D11_RASTERIZER_DESC rd{}; rd.FillMode = D3D11_FILL_SOLID;
        rd.CullMode = D3D11_CULL_NONE; // the GL sample never enables face culling
        rd.DepthClipEnable = TRUE;
        g_dev->CreateRasterizerState(&rd, &g_raster);

        D3D11_DEPTH_STENCIL_DESC dd{};
        dd.DepthEnable = TRUE; dd.DepthWriteMask = D3D11_DEPTH_WRITE_MASK_ALL; dd.DepthFunc = D3D11_COMPARISON_LESS;
        g_dev->CreateDepthStencilState(&dd, &g_depth_on);
        dd.DepthEnable = FALSE; dd.DepthWriteMask = D3D11_DEPTH_WRITE_MASK_ZERO;
        g_dev->CreateDepthStencilState(&dd, &g_depth_off);

        D3D11_BLEND_DESC bd{};
        bd.RenderTarget[0].BlendEnable = TRUE;
        bd.RenderTarget[0].SrcBlend = D3D11_BLEND_SRC_ALPHA;
        bd.RenderTarget[0].DestBlend = D3D11_BLEND_INV_SRC_ALPHA;
        bd.RenderTarget[0].BlendOp = D3D11_BLEND_OP_ADD;
        bd.RenderTarget[0].SrcBlendAlpha = D3D11_BLEND_ONE;
        bd.RenderTarget[0].DestBlendAlpha = D3D11_BLEND_ZERO;
        bd.RenderTarget[0].BlendOpAlpha = D3D11_BLEND_OP_ADD;
        bd.RenderTarget[0].RenderTargetWriteMask = D3D11_COLOR_WRITE_ENABLE_ALL;
        g_dev->CreateBlendState(&bd, &g_blend_alpha);

        // Three sampler states matching the GL sample's P/B/T modes, all CLAMP.
        D3D11_SAMPLER_DESC sd{};
        sd.AddressU = sd.AddressV = sd.AddressW = D3D11_TEXTURE_ADDRESS_CLAMP;
        sd.MaxLOD = D3D11_FLOAT32_MAX;
        sd.Filter = D3D11_FILTER_MIN_MAG_MIP_POINT;        g_dev->CreateSamplerState(&sd, &g_samplers[0]);
        sd.Filter = D3D11_FILTER_MIN_MAG_LINEAR_MIP_POINT; g_dev->CreateSamplerState(&sd, &g_samplers[1]);
        sd.Filter = D3D11_FILTER_MIN_MAG_MIP_LINEAR;       g_dev->CreateSamplerState(&sd, &g_samplers[2]);

        D3D11_BUFFER_DESC cbd{}; cbd.ByteWidth = sizeof(CBData); cbd.Usage = D3D11_USAGE_DYNAMIC;
        cbd.BindFlags = D3D11_BIND_CONSTANT_BUFFER; cbd.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
        g_dev->CreateBuffer(&cbd, nullptr, &g_cbuffer);
    }

    // Try deblock.hlsl in the cwd, else next to the executable.
    g.shader_path = "deblock.hlsl";
    if (read_file(g.shader_path).empty()) {
        std::string a = argv[0]; size_t s = a.find_last_of("/\\");
        if (s != std::string::npos) g.shader_path = a.substr(0,s+1) + "deblock.hlsl";
    }
    if (!load_shader(g.shader_path)) return 1;

    if (!load_ktx2_texture(ktx2_path, pref, no_mips)) return 1;

    g.filter_mode = 2; // trilinear default

    create_quad((float)g.tex_w / (float)g.tex_h);
    create_cube();
    if (!init_debug()) fprintf(stderr, "WARNING: debug overlay init failed (continuing without it)\n");

    const float clear_color[4] = {0.2f, 0.2f, 0.2f, 1.0f};
    LARGE_INTEGER qpf, last, now; QueryPerformanceFrequency(&qpf); QueryPerformanceCounter(&last);

    while (!g_quit) {
        MSG msg;
        while (PeekMessageA(&msg, nullptr, 0, 0, PM_REMOVE)) {
            TranslateMessage(&msg);
            DispatchMessageA(&msg);
        }
        if (g_quit) break;

        QueryPerformanceCounter(&now);
        float dt = (float)((double)(now.QuadPart - last.QuadPart) / (double)qpf.QuadPart);
        last = now;
        if (dt > 0.1f) dt = 0.1f; // cap after a stall (occluded window / compositor) to avoid a teleport
        process_held_keys(hwnd, dt);

        // If the backbuffer views were lost (a resize-time creation failure), skip
        // drawing but keep presenting so the loop stays vsync-throttled.
        if (!g_rtv || !g_dsv) { g_swapchain->Present(1, 0); continue; }

        D3D11_VIEWPORT vp{}; vp.Width = (float)WINDOW_WIDTH; vp.Height = (float)WINDOW_HEIGHT; vp.MaxDepth = 1.0f;
        g_ctx->RSSetViewports(1, &vp);
        g_ctx->RSSetState(g_raster);
        g_ctx->OMSetRenderTargets(1, &g_rtv, g_dsv);
        g_ctx->ClearRenderTargetView(g_rtv, clear_color);
        g_ctx->ClearDepthStencilView(g_dsv, D3D11_CLEAR_DEPTH | D3D11_CLEAR_STENCIL, 1.0f, 0);
        g_ctx->OMSetDepthStencilState(g_depth_on, 0);

        set_uniforms();
        g_ctx->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
        g_ctx->IASetInputLayout(g.layout);
        g_ctx->VSSetShader(g.vs, nullptr, 0);
        g_ctx->PSSetShader(g.ps, nullptr, 0);
        g_ctx->VSSetConstantBuffers(0, 1, &g_cbuffer);
        g_ctx->PSSetConstantBuffers(0, 1, &g_cbuffer);
        g_ctx->PSSetShaderResources(0, 1, &g.srv);
        g_ctx->PSSetSamplers(0, 1, &g_samplers[g.filter_mode]);

        UINT stride = 5*sizeof(float), offset = 0;
        if (g.cube) {
            g_ctx->IASetVertexBuffers(0, 1, &g_cube_vb, &stride, &offset);
            g_ctx->IASetIndexBuffer(g_cube_ib, DXGI_FORMAT_R32_UINT, 0);
            g_ctx->DrawIndexed((UINT)g_cube_index_count, 0, 0);
        } else {
            g_ctx->IASetVertexBuffers(0, 1, &g_quad_vb, &stride, &offset);
            g_ctx->IASetIndexBuffer(g_quad_ib, DXGI_FORMAT_R32_UINT, 0);
            g_ctx->DrawIndexed(6, 0, 0);
        }

        draw_debug_text();

        g_swapchain->Present(1, 0); // vsync, like the GL sample's swap interval 1
    }

    // Intentionally no explicit release of the D3D objects / device / swap chain:
    // process exit reclaims everything. A real app should hold these in RAII wrappers
    // (or ComPtr) and release them -- don't copy this teardown-by-exit pattern.
    printf("Done.\n");
    return 0;
}