texture.hpp

Go to the documentation of this file.

#pragma once
 
#include <math.h>
 
#include <cstring>
#include <map>
#include <vector>
 
#include "NNL/common/fixed_type.hpp"
#include "NNL/common/io.hpp"
#include "NNL/simple_asset/stexture.hpp"
#include "NNL/utility/static_vector.hpp"
 
namespace nnl {
namespace texture {

constexpr unsigned int kMinDimension = 1;
constexpr unsigned int kMinByteBufferWidth = 16;
constexpr unsigned int kMaxDimension = 1024;

constexpr std::size_t kMaxMipMapLvl = 7;

constexpr std::size_t kMaxTextureLvl = 1 + kMaxMipMapLvl;

enum class TextureFormat : u16 {
  kCLUT8 = 5,     
  kCLUT4 = 4,     
  kRGBA8888 = 3,  
  kRGBA4444 = 2,  
  kRGBA5551 = 1,  
  kRGB565 = 0     
};

enum class ClutFormat : u8 {
  kRGBA8888 = 3,  
  kRGBA4444 = 2,  
  kRGBA5551 = 1,  
  kRGB565 = 0     
};

enum class TextureFilter : u8 {
  kNearest = 0,  
  kLinear = 1,   
  // minifying only:
  kNearestMipmapNearest = 4,  
  kLinearMipmapNearest = 5,   
  kNearestMipmapLinear = 6,   
  kLinearMipmapLinear = 7     
};

struct TextureData {
  u16 width = 0;         
  u16 height = 0;        
  u16 buffer_width = 0;  
  Buffer bitmap_buffer;  
};

struct Texture {
  Buffer clut_buffer;                                            
  utl::static_vector<TextureData, kMaxTextureLvl> texture_data;  
  TextureFormat texture_format = TextureFormat::kCLUT8;          
  bool swizzled = true;                                          
  TextureFilter min_filter = TextureFilter::kLinearMipmapNearest;  
  TextureFilter mag_filter = TextureFilter::kLinear;               
  ClutFormat clut_format = ClutFormat::kRGBA8888;                  
};

using TextureContainer = std::vector<Texture>;

struct ConvertParam {
  TextureFormat texture_format = TextureFormat::kCLUT8;  
  ClutFormat clut_format = ClutFormat::kRGBA8888;        
  bool clut_dither = true;                               
  unsigned int max_mipmap_lvl = kMaxMipMapLvl;           
  bool gen_small_mipmap = false;                         
  unsigned int max_width_height = kMaxDimension / 2;     
  bool swizzle = true;  
};

std::vector<STexture> Convert(const TextureContainer& texture_container, bool mipmaps = false);

TextureContainer Convert(std::vector<STexture>&& images, const ConvertParam& texture_params = {});
 
TextureContainer Convert(std::vector<STexture>&& images, const std::vector<ConvertParam>& texture_params);

bool IsOfType(BufferView buffer);
 
bool IsOfType(const std::filesystem::path& path);
 
bool IsOfType(Reader& f);

TextureContainer Import(BufferView buffer);
 
TextureContainer Import(const std::filesystem::path& path);
 
TextureContainer Import(Reader& f);

[[nodiscard]] Buffer Export(const TextureContainer& texture_container);
 
void Export(const TextureContainer& texture_container, const std::filesystem::path& path);
 
void Export(const TextureContainer& texture_container, Writer& f);  // Main


Texture Convert(STexture&& image, const ConvertParam& tex_param = {});
STexture Convert(const Texture& texture, unsigned int level = 0);

Buffer ConvertRGB565ToRGBA8888(BufferView bitmap565);
Buffer ConvertRGBA5551ToRGBA8888(BufferView bitmap5551);
Buffer ConvertRGBA4444ToRGBA8888(BufferView bitmap4444);
Buffer ConvertRGBA8888ToRGBA4444(BufferView bitmap8888);
Buffer ConvertRGBA8888ToRGBA5551(BufferView bitmap8888);
Buffer ConvertRGBA8888ToRGB565(BufferView bitmap8888);
Buffer UnswizzleFromMem(BufferView texptr, u32 bufw, u32 height, u32 bytes_per_pixel);
Buffer SwizzleFromMem(Buffer& texptr, u32 bufw, u32 height, u32 bytes_per_pixel);
u32 QuickTexHash(BufferView data);
Buffer ConvertIndexed4To8(BufferView clut4, u32 width);
Buffer ConvertIndexed8To4(BufferView clut8, u32 width);
std::vector<SPixel> GeneratePaletteMedian(const STexture& source_image, std::size_t num_colors = 256);
std::vector<SPixel> GeneratePaletteNaive(const STexture& source_image, std::size_t num_colors = 256);
std::vector<u8> ApplyPalette(const STexture& image, const std::vector<SPixel>& palette, bool dither = true);

Buffer AlignBufferWidth(BufferView image_buffer, unsigned int width, unsigned int height, unsigned int bpp,
                        unsigned int buffer_width);
Buffer DealignBufferWidth(BufferView image_buffer, unsigned int width, unsigned int height, unsigned int bpp,
                          unsigned int buffer_width);
Buffer DeindexClut8ToRGBA8888(BufferView indexed_image, BufferView palette);

ConvertParam GenerateConvertParam(const Texture& texture);
std::vector<ConvertParam> GenerateConvertParam(const TextureContainer& texture_container);

 
namespace raw {


constexpr u32 kMagicBytes = 0x88'88'00'01;
 
constexpr u32 kColorEntriesInBlock = 16;
 
NNL_PACK(struct RHeader {
  u32 magic_bytes = kMagicBytes;  // 0x0
  u32 offset_textures = 0;        // 0x4
  u32 offset_texture_data = 0;    // 0x8
  u32 offset_clut_offsets = 0;    // 0xC
  u16 num_textures = 0;           // 0x10
  u16 num_texture_data = 0;       // 0x12
  u16 num_clut_offsets = 0;       // 0x14
  u16 unknown = 0;                // 0x16
});
 
static_assert(sizeof(RHeader) == 0x18);
 
NNL_PACK(struct RTexture {
  u16 texture_format = 0;           // 0x0
  u16 index_texture_data = 0;       // 0x2
  u8 num_texture_data_mipmaps = 0;  // 0x4
  u8 swizzled = false;              // 0x5
  u8 filter_minifying = 0;          // 0x6
  u8 filter_magnifying = 0;         // 0x7
  u16 index_clut = 0;               // 0x8
  u8 clut_load_size = 0;            // 0xA how many blocks of 16 colors to load
  u8 clut_format = 0;               // 0xB
});
 
static_assert(sizeof(RTexture) == 0xC);
 
NNL_PACK(struct RTextureData {
  u32 offset_bitmap = 0;   // 0x0
  u16 width = 0;           // 0x4
  u16 height = 0;          // 0x6
  u16 buffer_width = 0;    // 0x8
  u16 height_rounded = 0;  // 0xA same as height or rounded to 8 (filled dynamically)
  u32 size = 0;            // 0xC
  u32 address = 0;         // 0x10 filled dynamically
});
 
static_assert(sizeof(RTextureData) == 0x14);
 
struct RTextureContainer {
  RHeader header;
  std::vector<RTexture> textures;
  std::vector<RTextureData> texture_data;
  std::vector<u32> clut_offsets;
  // Maps of offsets (used in the structures above) to their data:
  std::map<u32, Buffer> bitmaps;
  std::map<u32, Buffer> cluts;
};
 
TextureContainer Convert(RTextureContainer&& rtexture_container);
 
RTextureContainer Parse(Reader& f);
}  // namespace raw
 
}  // namespace texture

}  // namespace nnl