swizzleinator 0.2.1

Texture swizzling/deswizzling library
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

pub mod ps;
pub mod xbox;

use core::{error::Error, fmt};

#[derive(Debug, Clone, Copy)]
pub enum TextureSlice {
    Source,
    Dest,
}

#[derive(Debug, Clone, Copy)]
pub enum SwizzleError {
    FormatOutOfRange(u32),
    OutOfBounds(TextureSlice),
}

impl Error for SwizzleError {}

impl fmt::Display for SwizzleError {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            SwizzleError::OutOfBounds(s) => write!(f, "slice {s:?} out of bounds"),
            SwizzleError::FormatOutOfRange(e) => write!(f, "format is out of range ({e})"),
        }
    }
}

/// This trait defines the function used to swizzle/tile image data
/// * `source` - Source image data.
/// * `dest` - Destination slice. When swizzling an image that has dimensions that are not a power of two,
///   it is recommended to make this larger than the size of the unswizzled texture, or else data could be lost.
/// * `dimensions` - Dimensions of the image: `(width, height, depth)`.
/// * `format` - Expected image format.
/// * `align_resolution` - Align the resolution of the image to the next power of two.
pub trait Swizzler {
    fn swizzle<T: Format>(
        source: &mut [u8],
        dest: &mut [u8],
        dimensions: (usize, usize, usize),
        format: T,
        align_resolution: bool,
    ) -> Result<(), SwizzleError>;
}

/// The trait that defines an interface to deswizzle/detile image data
/// * `source` - Source image data.
/// * `dest` - Destination slice, usually with the size `(width * height * depth * format.bpp()) / 8`.
/// * `dimensions` - Dimensions of the image: `(width, height, depth)`.
/// * `format` - Expected image format.
/// * `align_resolution` - Align the resolution of the image to the next power of two.
pub trait Deswizzler {
    fn deswizzle<T: Format>(
        source: &mut [u8],
        dest: &mut [u8],
        dimensions: (usize, usize, usize),
        format: T,
        align_resolution: bool,
    ) -> Result<(), SwizzleError>;
}

/// A trait that defines a given texture format
pub trait Format {
    fn bpp(&self) -> usize;

    fn block_size(&self) -> usize;

    fn pixel_block_size(&self) -> usize;

    fn is_compressed(&self) -> bool;

    fn x360_swap(&self) -> bool;
}

pub fn morton(t: usize, x: usize, y: usize) -> usize {
    let mut bit_position_x = 1;
    let mut bit_position_y = 1;
    let mut morton_code = t;
    let mut mask_x = x;
    let mut mask_y = y;
    let mut result_x = 0;
    let mut result_y = 0;

    while mask_x > 1 || mask_y > 1 {
        if mask_x > 1 {
            result_x += bit_position_x * (morton_code & 1);
            morton_code >>= 1;
            bit_position_x <<= 1;
            mask_x >>= 1;
        }
        if mask_y > 1 {
            result_y += bit_position_y * (morton_code & 1);
            morton_code >>= 1;
            bit_position_y <<= 1;
            mask_y >>= 1;
        }
    }

    result_y * x + result_x
}