mirror of
https://github.com/tangerineturtle1/NX2navi.git
synced 2026-11-15 19:19:58 -04:00
89 lines
6.9 KiB
C
89 lines
6.9 KiB
C
// CPU-side texture code: block-linear <-> linear copies, ASTC decode, NVN format -> VkFormat. Vulkan memory and
|
|
// the texture objects are in vk_memory.c and vk_texture.c.
|
|
#pragma once
|
|
#include <stdbool.h>
|
|
#include <stddef.h>
|
|
#include <stdint.h>
|
|
#include "nvn_obj.h"
|
|
#include "nvn_tex.h"
|
|
#include "vk.h"
|
|
|
|
// ---- tex_deswizzle.c ----
|
|
// Block-linear <-> linear for one level and layer of a texture. The linear side is laid out by block rows: dst_pitch
|
|
// bytes per row (>= row bytes of the level), compressed formats one block row per row, 3D textures slice k at
|
|
// dst + k * dst_pitch * block rows. LINEAR / LINEAR_RENDER_TARGET storage is copied by pitch. Multisampled and BUFFER
|
|
// textures return -1; success returns 0.
|
|
int nvn_deswizzle(const nvn_texdesc *d, unsigned level, unsigned layer, const void *src_storage, void *dst_linear,
|
|
size_t dst_pitch);
|
|
int nvn_swizzle(const nvn_texdesc *d, unsigned level, unsigned layer, const void *src_linear, size_t src_pitch,
|
|
void *dst_storage);
|
|
// nvn_deswizzle with a large level's block-linear copy split over the par_jobs pool (tex_bl_copy_mt): the same bytes.
|
|
// For the texture upload, which runs on a drawing thread; the caller keeps the storage mapped until it returns.
|
|
int nvn_deswizzle_mt(const nvn_texdesc *d, unsigned level, unsigned layer, const void *src_storage, void *dst_linear,
|
|
size_t dst_pitch);
|
|
// One box of a level and layer, [x, x + wb) bytes by [y, y + h) block rows of slice z (3D textures), between the storage
|
|
// and caller rows of pitch bytes, touching nothing else of the level: ReadTexels / WriteTexels of a region cost the
|
|
// region, not the level. Same textures as nvn_deswizzle; -1 for others and for a box outside the level.
|
|
int nvn_texels_box(const nvn_texdesc *d, unsigned level, unsigned layer, uint32_t x, uint32_t y, uint32_t z, uint32_t wb,
|
|
uint32_t h, void *storage, void *rows, size_t pitch, int to_linear);
|
|
// Byte offset of (x byte, y block row, z slice) inside one level of block height 2^th and block depth 2^td GOBs.
|
|
uint64_t nvn_bl_offset(uint32_t x, uint32_t y, uint32_t z, uint32_t row_bytes, uint32_t rows, unsigned th, unsigned td);
|
|
// Geometry of a level as the two functions above use it; -1 for textures they reject.
|
|
int nvn_deswizzle_geom(const nvn_texdesc *d, unsigned level, unsigned layer, uint32_t *row_bytes, uint32_t *rows,
|
|
uint32_t *slices, uint64_t *base, unsigned *th, unsigned *td, uint32_t *bpb);
|
|
// The copy loop on its own, for callers that know the level geometry (bl points at the level's first byte).
|
|
void tex_bl_copy(uint8_t *bl, uint8_t *lin, size_t pitch, uint32_t row_bytes, uint32_t rows, uint32_t slices,
|
|
unsigned th, unsigned td, int to_linear);
|
|
// tex_bl_copy with a level of 1 MiB or more split into bands of rows over the par_jobs pool; the same bytes.
|
|
void tex_bl_copy_mt(uint8_t *bl, uint8_t *lin, size_t pitch, uint32_t row_bytes, uint32_t rows, uint32_t slices,
|
|
unsigned th, unsigned td, int to_linear);
|
|
|
|
// ---- tex_astc.c ----
|
|
// ASTC LDR 2D to RGBA8, bit-exact with astcenc's 8-bit decode. blocks: row-major 16-byte blocks covering
|
|
// ceil(width/bw) x ceil(height/bh); rgba_out: width*height*4 bytes. srgb only selects the sRGB endpoint expansion.
|
|
// Error blocks and HDR content decode to magenta.
|
|
void astc_decode_ldr(const uint8_t *blocks, uint32_t width, uint32_t height, uint32_t bw, uint32_t bh, bool srgb,
|
|
uint8_t *rgba_out);
|
|
bool astc_decode_block(const uint8_t block[16], uint32_t bw, uint32_t bh, bool srgb, uint8_t *rgba_out);
|
|
// Whether the block decodes to alpha 255 in every texel; mostly from its header, blocks of the endpoint modes with
|
|
// alpha by a decode (counted in *decoded).
|
|
bool astc_block_opaque(const uint8_t block[16], uint32_t bw, uint32_t bh, bool srgb, uint32_t *decoded);
|
|
// The first of the n blocks (16 bytes each) that is not opaque, or that took *decoded past max_decoded; n when none
|
|
// is. dst (optional): all n blocks are copied there too, as by memcpy, the rest also after a block that is not opaque.
|
|
uint64_t astc_blocks_opaque(const uint8_t *blocks, uint64_t n, uint32_t bw, uint32_t bh, bool srgb, uint32_t max_decoded,
|
|
uint32_t *decoded, uint8_t *dst);
|
|
// tex_astc_mt.c: astc_blocks_opaque with the blocks of a large texture spread over the decode workers, each also
|
|
// copying its part to dst when given; whether every block is opaque (and *decoded stayed within max_decoded, summed
|
|
// over the workers).
|
|
bool astc_blocks_opaque_mt(const uint8_t *blocks, uint64_t n, uint32_t bw, uint32_t bh, bool srgb, uint32_t max_decoded,
|
|
uint32_t *decoded, uint8_t *dst);
|
|
// tex_astc_mt.c: the same bytes as astc_decode_ldr, large images split by block rows over a worker pool; blocks.
|
|
void astc_decode_ldr_mt(const uint8_t *blocks, uint32_t width, uint32_t height, uint32_t bw, uint32_t bh, bool srgb,
|
|
uint8_t *rgba_out);
|
|
|
|
// ---- vk_formats.c ----
|
|
typedef struct TexVkFormat {
|
|
VkFormat vk; // format of the image created on this GPU
|
|
VkFormat ideal; // format the NVN format maps to by itself; differs from vk after a fallback
|
|
VkFormatFeatureFlags need; // optimal-tiling features vk must report for sampling and upload
|
|
uint8_t expand_rgb; // 3-component format: the upload expands each texel to 4 components (alpha / integer 1)
|
|
uint8_t alpha_one; // "X" format: sample alpha as 1 (view swizzle)
|
|
uint8_t chan[4]; // nonzero chan[0]: vk stands in with another component order; chan[i] is the
|
|
// NVN_TEXTURE_SWIZZLE_R..A selector of the image component holding R, G, B, A
|
|
uint8_t astc_bw, astc_bh; // nonzero: ASTC decoded into vk (RGBA8, same colour space) by vk_astc.c or tex_astc.c;
|
|
// zero for native ASTC (vk == ideal, raw blocks as for BC)
|
|
uint8_t astc_srgb;
|
|
uint8_t astc_bc; // ASTC decoded and then encoded on the GPU (vk_astc.c): 1 BC3 (NX2NAVI_ASTC_BC),
|
|
// 2 BC1 for a texture whose every block decodes opaque (vk_texture.c "ASTC as BC1")
|
|
uint8_t depth, stencil; // aspect flags of depth / stencil formats
|
|
const char *note; // why a fallback or an expansion was chosen; NULL when the mapping is direct
|
|
const char *reason; // unmapped formats only: why there is no Vulkan format
|
|
} TexVkFormat;
|
|
|
|
// 1 when nvn_format (an NVNformat value) has a Vulkan mapping, 0 otherwise (out->reason says why). The mapping is
|
|
// fixed per device: ASTC decodes to RGBA8 unless vk_astc_native (NX2NAVI_ASTC) takes the format as it is, D24S8 is
|
|
// D32S8, DEPTH24 is D32. Whether the GPU reports the features is a separate question (tex_vk_format_supported).
|
|
int tex_vk_format(int nvn_format, TexVkFormat *out);
|
|
// 1 when vk_ctx()->phys reports every bit of f->need for f->vk in optimal tiling. Needs vk_init().
|
|
int tex_vk_format_supported(const TexVkFormat *f);
|