Scarfski/basis_universal
1
0
Fork 0
mirror of https://github.com/BinomialLLC/basis_universal.git synced 2026-07-24 15:09:03 +00:00
Code Issues Packages Projects Releases Wiki Activity
Files
master
basis_universal/shader_deblocking_d3d11/main.cpp
Richard Geldreich 306ff5f951 minor change
2026-07-02 22:55:40 -04:00

984 lines
49 KiB
C++
Raw Permalink Blame History

// 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;
}
Reference in New Issue View Git Blame Copy Permalink