Extract utility functions and block structs to their own files
parent
cddea42f7e
commit
e0511f1aea
@ -0,0 +1,55 @@
|
||||
/* Python-rgbcx Texture Compression Library
|
||||
Copyright (C) 2021 Andrew Cassidy <drewcassidy@me.com>
|
||||
Partially derived from rgbcx.h written by Richard Geldreich 2020 <richgel99@gmail.com>
|
||||
and licenced under the public domain
|
||||
|
||||
This program is free software: you can redistribute it and/or modify
|
||||
it under the terms of the GNU Affero General Public License as published by
|
||||
the Free Software Foundation, either version 3 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
This program is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU Affero General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Affero General Public License
|
||||
along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#include "blocks.h"
|
||||
#include <algorithm>
|
||||
#include <cassert>
|
||||
|
||||
// region color32 implementation
|
||||
color32::color32(uint32_t vr, uint32_t vg, uint32_t vb, uint32_t va) { set(vr, vg, vb, va); }
|
||||
|
||||
uint8_t color32::operator[](uint32_t idx) const {
|
||||
assert(idx < 4);
|
||||
return c[idx];
|
||||
}
|
||||
|
||||
uint8_t &color32::operator[](uint32_t idx) {
|
||||
assert(idx < 4);
|
||||
return c[idx];
|
||||
}
|
||||
|
||||
void color32::set(uint8_t vr, uint8_t vg, uint8_t vb, uint8_t va) {
|
||||
c[0] = vr;
|
||||
c[1] = vg;
|
||||
c[2] = vb;
|
||||
c[3] = va;
|
||||
}
|
||||
|
||||
void color32::set_rgb(const color32 &other) {
|
||||
c[0] = other.c[0];
|
||||
c[1] = other.c[1];
|
||||
c[2] = other.c[2];
|
||||
}
|
||||
color32 color32::comp_min(const color32 &a, const color32 &b) {
|
||||
return color32(std::min(a[0], b[0]), std::min(a[1], b[1]), std::min(a[2], b[2]), std::min(a[3], b[3]));
|
||||
}
|
||||
color32 color32::comp_max(const color32 &a, const color32 &b) {
|
||||
return color32(std::max(a[0], b[0]), std::max(a[1], b[1]), std::max(a[2], b[2]), std::max(a[3], b[3]));
|
||||
}
|
||||
// endregion
|
||||
@ -0,0 +1,185 @@
|
||||
/* Python-rgbcx Texture Compression Library
|
||||
Copyright (C) 2021 Andrew Cassidy <drewcassidy@me.com>
|
||||
Partially derived from rgbcx.h written by Richard Geldreich 2020 <richgel99@gmail.com>
|
||||
and licenced under the public domain
|
||||
|
||||
This program is free software: you can redistribute it and/or modify
|
||||
it under the terms of the GNU Affero General Public License as published by
|
||||
the Free Software Foundation, either version 3 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
This program is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU Affero General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Affero General Public License
|
||||
along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
|
||||
#include "util.h"
|
||||
#include <cassert>
|
||||
#include <cstdint>
|
||||
|
||||
constexpr inline uint8_t DXT1SelectorBits = 2U;
|
||||
|
||||
struct color32 {
|
||||
union {
|
||||
struct {
|
||||
uint8_t r;
|
||||
uint8_t g;
|
||||
uint8_t b;
|
||||
uint8_t a;
|
||||
};
|
||||
|
||||
uint8_t c[4];
|
||||
|
||||
uint32_t m;
|
||||
};
|
||||
|
||||
color32() {}
|
||||
|
||||
color32(uint32_t vr, uint32_t vg, uint32_t vb, uint32_t va);
|
||||
|
||||
void set(uint8_t vr, uint8_t vg, uint8_t vb, uint8_t va);
|
||||
|
||||
void set_rgb(const color32 &other);
|
||||
|
||||
uint8_t operator[](uint32_t idx) const;
|
||||
uint8_t &operator[](uint32_t idx);
|
||||
|
||||
bool operator==(const color32 &rhs) const { return m == rhs.m; }
|
||||
|
||||
static color32 comp_min(const color32 &a, const color32 &b);
|
||||
static color32 comp_max(const color32 &a, const color32 &b);
|
||||
};
|
||||
|
||||
struct bc1_block {
|
||||
constexpr static inline size_t EndpointSize = 2;
|
||||
constexpr static inline size_t SelectorSize = 4;
|
||||
constexpr static inline uint8_t SelectorBits = 2;
|
||||
constexpr static inline uint8_t SelectorValues = 1 << SelectorBits;
|
||||
constexpr static inline uint8_t SelectorMask = SelectorValues - 1;
|
||||
|
||||
uint8_t m_low_color[EndpointSize];
|
||||
uint8_t m_high_color[EndpointSize];
|
||||
uint8_t m_selectors[SelectorSize];
|
||||
|
||||
inline uint32_t get_low_color() const { return m_low_color[0] | (m_low_color[1] << 8U); }
|
||||
inline uint32_t get_high_color() const { return m_high_color[0] | (m_high_color[1] << 8U); }
|
||||
inline bool is_3color() const { return get_low_color() <= get_high_color(); }
|
||||
inline void set_low_color(uint16_t c) {
|
||||
m_low_color[0] = static_cast<uint8_t>(c & 0xFF);
|
||||
m_low_color[1] = static_cast<uint8_t>((c >> 8) & 0xFF);
|
||||
}
|
||||
inline void set_high_color(uint16_t c) {
|
||||
m_high_color[0] = static_cast<uint8_t>(c & 0xFF);
|
||||
m_high_color[1] = static_cast<uint8_t>((c >> 8) & 0xFF);
|
||||
}
|
||||
inline uint32_t get_selector(uint32_t x, uint32_t y) const {
|
||||
assert((x < 4U) && (y < 4U));
|
||||
return (m_selectors[y] >> (x * SelectorBits)) & SelectorMask;
|
||||
}
|
||||
inline void set_selector(uint32_t x, uint32_t y, uint32_t val) {
|
||||
assert((x < 4U) && (y < 4U) && (val < 4U));
|
||||
m_selectors[y] &= (~(SelectorMask << (x * SelectorBits)));
|
||||
m_selectors[y] |= (val << (x * DXT1SelectorBits));
|
||||
}
|
||||
|
||||
static inline uint16_t pack_color(const color32 &color, bool scaled, uint32_t bias = 127U) {
|
||||
uint32_t r = color.r, g = color.g, b = color.b;
|
||||
if (scaled) {
|
||||
r = (r * 31U + bias) / 255U;
|
||||
g = (g * 63U + bias) / 255U;
|
||||
b = (b * 31U + bias) / 255U;
|
||||
}
|
||||
return static_cast<uint16_t>(minimum(b, 31U) | (minimum(g, 63U) << 5U) | (minimum(r, 31U) << 11U));
|
||||
}
|
||||
|
||||
static inline uint16_t pack_unscaled_color(uint32_t r, uint32_t g, uint32_t b) { return static_cast<uint16_t>(b | (g << 5U) | (r << 11U)); }
|
||||
|
||||
static inline void unpack_color(uint32_t c, uint32_t &r, uint32_t &g, uint32_t &b) {
|
||||
r = (c >> 11) & 31;
|
||||
g = (c >> 5) & 63;
|
||||
b = c & 31;
|
||||
|
||||
r = (r << 3) | (r >> 2);
|
||||
g = (g << 2) | (g >> 4);
|
||||
b = (b << 3) | (b >> 2);
|
||||
}
|
||||
|
||||
static inline void unpack_color_unscaled(uint32_t c, uint32_t &r, uint32_t &g, uint32_t &b) {
|
||||
r = (c >> 11) & 31;
|
||||
g = (c >> 5) & 63;
|
||||
b = c & 31;
|
||||
}
|
||||
};
|
||||
|
||||
struct bc4_block {
|
||||
constexpr static inline size_t EndpointSize = 1;
|
||||
constexpr static inline size_t SelectorSize = 6;
|
||||
constexpr static inline uint8_t SelectorBits = 3;
|
||||
constexpr static inline uint8_t SelectorValues = 1 << SelectorBits;
|
||||
constexpr static inline uint8_t SelectorMask = SelectorValues - 1;
|
||||
|
||||
uint8_t m_endpoints[EndpointSize * 2];
|
||||
uint8_t m_selectors[SelectorSize];
|
||||
|
||||
inline uint32_t get_low_alpha() const { return m_endpoints[0]; }
|
||||
inline uint32_t get_high_alpha() const { return m_endpoints[1]; }
|
||||
inline bool is_alpha6_block() const { return get_low_alpha() <= get_high_alpha(); }
|
||||
|
||||
inline uint64_t get_selector_bits() const {
|
||||
return ((uint64_t)((uint32_t)m_selectors[0] | ((uint32_t)m_selectors[1] << 8U) | ((uint32_t)m_selectors[2] << 16U) |
|
||||
((uint32_t)m_selectors[3] << 24U))) |
|
||||
(((uint64_t)m_selectors[4]) << 32U) | (((uint64_t)m_selectors[5]) << 40U);
|
||||
}
|
||||
|
||||
inline uint32_t get_selector(uint32_t x, uint32_t y, uint64_t selector_bits) const {
|
||||
assert((x < 4U) && (y < 4U));
|
||||
return (selector_bits >> (((y * 4) + x) * SelectorBits)) & (SelectorMask);
|
||||
}
|
||||
|
||||
static inline uint32_t get_block_values6(uint8_t *pDst, uint32_t l, uint32_t h) {
|
||||
pDst[0] = static_cast<uint8_t>(l);
|
||||
pDst[1] = static_cast<uint8_t>(h);
|
||||
pDst[2] = static_cast<uint8_t>((l * 4 + h) / 5);
|
||||
pDst[3] = static_cast<uint8_t>((l * 3 + h * 2) / 5);
|
||||
pDst[4] = static_cast<uint8_t>((l * 2 + h * 3) / 5);
|
||||
pDst[5] = static_cast<uint8_t>((l + h * 4) / 5);
|
||||
pDst[6] = 0;
|
||||
pDst[7] = 255;
|
||||
return 6;
|
||||
}
|
||||
|
||||
static inline uint32_t get_block_values8(uint8_t *pDst, uint32_t l, uint32_t h) {
|
||||
pDst[0] = static_cast<uint8_t>(l);
|
||||
pDst[1] = static_cast<uint8_t>(h);
|
||||
pDst[2] = static_cast<uint8_t>((l * 6 + h) / 7);
|
||||
pDst[3] = static_cast<uint8_t>((l * 5 + h * 2) / 7);
|
||||
pDst[4] = static_cast<uint8_t>((l * 4 + h * 3) / 7);
|
||||
pDst[5] = static_cast<uint8_t>((l * 3 + h * 4) / 7);
|
||||
pDst[6] = static_cast<uint8_t>((l * 2 + h * 5) / 7);
|
||||
pDst[7] = static_cast<uint8_t>((l + h * 6) / 7);
|
||||
return 8;
|
||||
}
|
||||
|
||||
static inline uint32_t get_block_values(uint8_t *pDst, uint32_t l, uint32_t h) {
|
||||
if (l > h)
|
||||
return get_block_values8(pDst, l, h);
|
||||
else
|
||||
return get_block_values6(pDst, l, h);
|
||||
}
|
||||
};
|
||||
|
||||
struct bc3_block {
|
||||
bc4_block alpha_block;
|
||||
bc1_block color_block;
|
||||
};
|
||||
|
||||
struct bc5_block {
|
||||
bc4_block r_block;
|
||||
bc4_block g_block;
|
||||
};
|
||||
@ -0,0 +1,74 @@
|
||||
/* Python-rgbcx Texture Compression Library
|
||||
Copyright (C) 2021 Andrew Cassidy <drewcassidy@me.com>
|
||||
Partially derived from rgbcx.h written by Richard Geldreich <richgel99@gmail.com>
|
||||
and licenced under the public domain
|
||||
|
||||
This program is free software: you can redistribute it and/or modify
|
||||
it under the terms of the GNU Affero General Public License as published by
|
||||
the Free Software Foundation, either version 3 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
This program is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU Affero General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Affero General Public License
|
||||
along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <cstdint>
|
||||
|
||||
static inline uint32_t iabs(int32_t i) { return (i < 0) ? static_cast<uint32_t>(-i) : static_cast<uint32_t>(i); }
|
||||
static inline uint64_t iabs(int64_t i) { return (i < 0) ? static_cast<uint64_t>(-i) : static_cast<uint64_t>(i); }
|
||||
|
||||
static inline uint8_t to_5(uint32_t v) {
|
||||
v = v * 31 + 128;
|
||||
return (uint8_t)((v + (v >> 8)) >> 8);
|
||||
}
|
||||
static inline uint8_t to_6(uint32_t v) {
|
||||
v = v * 63 + 128;
|
||||
return (uint8_t)((v + (v >> 8)) >> 8);
|
||||
}
|
||||
|
||||
static inline int scale_5_to_8(int v) { return (v << 3) | (v >> 2); }
|
||||
static inline int scale_6_to_8(int v) { return (v << 2) | (v >> 4); }
|
||||
|
||||
template <typename S> inline S maximum(S a, S b) { return (a > b) ? a : b; }
|
||||
template <typename S> inline S maximum(S a, S b, S c) { return maximum(maximum(a, b), c); }
|
||||
template <typename S> inline S maximum(S a, S b, S c, S d) { return maximum(maximum(maximum(a, b), c), d); }
|
||||
|
||||
template <typename S> inline S minimum(S a, S b) { return (a < b) ? a : b; }
|
||||
template <typename S> inline S minimum(S a, S b, S c) { return minimum(minimum(a, b), c); }
|
||||
template <typename S> inline S minimum(S a, S b, S c, S d) { return minimum(minimum(minimum(a, b), c), d); }
|
||||
|
||||
template <typename T> inline T square(T a) { return a * a; }
|
||||
|
||||
static inline float clampf(float value, float low, float high) {
|
||||
if (value < low)
|
||||
value = low;
|
||||
else if (value > high)
|
||||
value = high;
|
||||
return value;
|
||||
}
|
||||
static inline uint8_t clamp255(int32_t i) { return (uint8_t)((i & 0xFFFFFF00U) ? (~(i >> 31)) : i); }
|
||||
|
||||
template <typename S> inline S clamp(S value, S low, S high) { return (value < low) ? low : ((value > high) ? high : value); }
|
||||
static inline int32_t clampi(int32_t value, int32_t low, int32_t high) {
|
||||
if (value < low)
|
||||
value = low;
|
||||
else if (value > high)
|
||||
value = high;
|
||||
return value;
|
||||
}
|
||||
|
||||
static inline int squarei(int a) { return a * a; }
|
||||
static inline int absi(int a) { return (a < 0) ? -a : a; }
|
||||
|
||||
template <typename F> inline F lerp(F a, F b, F s) { return a + (b - a) * s; }
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
Loading…
Reference in New Issue