gctex 0.3.12

gctex is a Rust crate designed for encoding and decoding texture formats used in the Nintendo GameCube and Wii games. The library provides C bindings, making it useful in both Rust and C/C++ based projects.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146

#ifndef RII_ENCODER_H
#define RII_ENCODER_H

#include <stddef.h>
#include <stdint.h>

#ifdef __cplusplus
extern "C" {
#endif

//! Computes the size of a simple image
uint32_t rii_compute_image_size(uint32_t format, uint32_t width,
                                uint32_t height);

//! Computes the size of a mipmapped image
uint32_t rii_compute_image_size_mip(uint32_t format, uint32_t width,
                                    uint32_t height, uint32_t number_of_images);

//! Encode from raw 32-bit color to the specified format
void rii_encode(uint32_t format, void* dst, uint32_t dst_len, const void* src,
                uint32_t src_len, uint32_t width, uint32_t height);

//! Decode from the specified format to raw 32-bit color
void rii_decode(void* dst, uint32_t dst_len, const void* src, uint32_t src_len,
                uint32_t width, uint32_t height, uint32_t texformat,
                const void* tlut, uint32_t tlut_len, uint32_t tlutformat);

//! Returns the length of the string. Will be no more than 256.
int32_t gctex_get_version_unstable_api(char* buf, uint32_t len);

//
// Implementations
//

void rii_encode_cmpr(void* dst, uint32_t dst_len, const void* src,
                     uint32_t src_len, uint32_t width, uint32_t height);

void rii_encode_i4(void* dst, uint32_t dst_len, const void* src,
                   uint32_t src_len, uint32_t width, uint32_t height);

void rii_encode_i8(void* dst, uint32_t dst_len, const void* src,
                   uint32_t src_len, uint32_t width, uint32_t height);

void rii_encode_ia4(void* dst, uint32_t dst_len, const void* src,
                    uint32_t src_len, uint32_t width, uint32_t height);

void rii_encode_ia8(void* dst, uint32_t dst_len, const void* src,
                    uint32_t src_len, uint32_t width, uint32_t height);

void rii_encode_rgb565(void* dst, uint32_t dst_len, const void* src,
                       uint32_t src_len, uint32_t width, uint32_t height);

void rii_encode_rgb5a3(void* dst, uint32_t dst_len, const void* src,
                       uint32_t src_len, uint32_t width, uint32_t height);

void rii_encode_rgba8(void* dst, uint32_t dst_len, const void* src,
                      uint32_t src_len, uint32_t width, uint32_t height);

#ifdef __cplusplus
}
#endif

#ifdef __cplusplus

#include <array>
#include <span>
#include <string>
#include <vector>

namespace gctex {

//! Get the library version.
static inline std::string get_version() {
  std::string s;
  s.resize(1024);
  int32_t len = gctex_get_version_unstable_api(&s[0], s.size());
  if (len <= 0 || len > s.size()) {
    return "Unable to query";
  }
  s.resize(len);
  return s;
}

//! Computes the size of a simple image
static inline uint32_t compute_image_size(uint32_t format, uint32_t width,
                                          uint32_t height) {
  return ::rii_compute_image_size(format, width, height);
}

//! Computes the size of a mipmapped image
static inline uint32_t compute_image_size_mip(uint32_t format, uint32_t width,
                                              uint32_t height,
                                              uint32_t number_of_images) {
  return ::rii_compute_image_size_mip(format, width, height, number_of_images);
}

#ifndef GCTEX_DO_NOT_DEFINE_SPAN_APIS

//! Encode from raw 32-bit color to the specified format
static inline void encode_into(uint32_t format, std::span<uint8_t> dst,
                               std::span<const uint8_t> src, uint32_t width,
                               uint32_t height) {
  ::rii_encode(format, dst.data(), dst.size(), src.data(), src.size(), width,
               height);
}

//! Encode from raw 32-bit color to the specified format
static inline std::vector<uint8_t> encode(uint32_t format,
                                          std::span<const uint8_t> src,
                                          uint32_t width, uint32_t height) {
  std::vector<uint8_t> dst(::rii_compute_image_size(format, width, height));
  ::rii_encode(format, dst.data(), dst.size(), src.data(), src.size(), width,
               height);
  return dst;
}

//! Decode from the specified format to raw 32-bit color
static inline void decode_into(std::span<uint8_t> dst,
                               std::span<const uint8_t> src, uint32_t width,
                               uint32_t height, uint32_t texformat,
                               std::span<const uint8_t> tlut,
                               uint32_t tlutformat) {
  std::array<u8, 1> bruh{};
  if (tlut.size() == 0) {
    tlut = bruh;
  }
  ::rii_decode(dst.data(), dst.size(), src.data(), src.size(), width, height,
               texformat, tlut.data(), tlut.size(), tlutformat);
}

//! Decode from the specified format to raw 32-bit color
static inline std::vector<uint8_t>
decode(std::span<const uint8_t> src, uint32_t width, uint32_t height,
       uint32_t texformat, std::span<const uint8_t> tlut, uint32_t tlutformat) {
  std::vector<uint8_t> dst(width * height * 4);
  ::rii_decode(dst.data(), dst.size(), src.data(), src.size(), width, height,
               texformat, tlut.data(), tlut.size(), tlutformat);
  return dst;
}

#endif

} // namespace gctex
#endif

#endif /* RII_ENCODER_H */