wow-blp 0.7.0

Parser and encoder for World of Warcraft BLP texture files with DXT compression support
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

//! Integration tests for BLP file parsing and encoding

use wow_blp::convert::{
    AlphaBits, BlpOldFormat, BlpTarget, FilterType, blp_to_image, image_to_blp,
};

#[test]
fn test_round_trip_blp1_raw1() {
    use image::DynamicImage;

    // Create a test image
    let test_image = DynamicImage::new_rgba8(64, 64);

    // Convert to BLP
    let make_mipmaps = false;
    let target = BlpTarget::Blp1(BlpOldFormat::Raw1 {
        alpha_bits: AlphaBits::NoAlpha,
    });

    let blp = image_to_blp(
        test_image.clone(),
        make_mipmaps,
        target,
        FilterType::Nearest,
    )
    .expect("Failed to convert image to BLP");

    // Save to memory buffer
    let buffer = wow_blp::encode::encode_blp(&blp).expect("Failed to encode BLP");

    // Load back from buffer
    let loaded_blp = wow_blp::parser::parse_blp(&buffer).expect("Failed to parse BLP");

    // Convert back to image
    let result_image = blp_to_image(&loaded_blp, 0).expect("Failed to convert BLP to image");

    // Basic validation
    assert_eq!(result_image.width(), 64);
    assert_eq!(result_image.height(), 64);
}

#[test]
fn test_raw1_1bit_alpha_scaling() {
    use image::DynamicImage;

    // Create a test image with checkerboard alpha pattern
    let mut img = image::RgbaImage::new(64, 64);
    for (x, y, pixel) in img.enumerate_pixels_mut() {
        let alpha = if (x + y) % 2 == 0 { 255 } else { 0 };
        *pixel = image::Rgba([128, 128, 128, alpha]);
    }
    let test_image = DynamicImage::ImageRgba8(img);

    // Convert to BLP with 1-bit alpha
    let make_mipmaps = false;
    let target = BlpTarget::Blp1(BlpOldFormat::Raw1 {
        alpha_bits: AlphaBits::Bit1,
    });

    let blp = image_to_blp(
        test_image.clone(),
        make_mipmaps,
        target,
        FilterType::Nearest,
    )
    .expect("Failed to convert image to BLP");

    // Save to memory buffer
    let buffer = wow_blp::encode::encode_blp(&blp).expect("Failed to encode BLP");

    // Load back from buffer
    let loaded_blp = wow_blp::parser::parse_blp(&buffer).expect("Failed to parse BLP");

    // Convert back to image
    let result_image = blp_to_image(&loaded_blp, 0).expect("Failed to convert BLP to image");
    let result_rgba = result_image.to_rgba8();

    // Verify alpha is scaled to 0 or 255
    for (x, y, pixel) in result_rgba.enumerate_pixels() {
        let expected_alpha = if (x + y) % 2 == 0 { 255 } else { 0 };
        assert_eq!(
            pixel[3], expected_alpha,
            "Alpha at ({}, {}) should be {} but was {}",
            x, y, expected_alpha, pixel[3]
        );
    }
}

#[test]
fn test_raw1_4bit_alpha_scaling() {
    use image::DynamicImage;

    // Create a test image with various alpha values
    let mut img = image::RgbaImage::new(64, 64);
    for (x, y, pixel) in img.enumerate_pixels_mut() {
        // Create a gradient of alpha values
        let alpha = ((x as u16 * 255) / 63) as u8;
        *pixel = image::Rgba([128, 128, 128, alpha]);
    }
    let test_image = DynamicImage::ImageRgba8(img);

    // Convert to BLP with 4-bit alpha
    let make_mipmaps = false;
    let target = BlpTarget::Blp1(BlpOldFormat::Raw1 {
        alpha_bits: AlphaBits::Bit4,
    });

    let blp = image_to_blp(
        test_image.clone(),
        make_mipmaps,
        target,
        FilterType::Nearest,
    )
    .expect("Failed to convert image to BLP");

    // Save to memory buffer
    let buffer = wow_blp::encode::encode_blp(&blp).expect("Failed to encode BLP");

    // Load back from buffer
    let loaded_blp = wow_blp::parser::parse_blp(&buffer).expect("Failed to parse BLP");

    // Convert back to image
    let result_image = blp_to_image(&loaded_blp, 0).expect("Failed to convert BLP to image");
    let result_rgba = result_image.to_rgba8();

    // Verify alpha is scaled properly (4-bit -> 8-bit via multiplying by 17)
    for (x, _, pixel) in result_rgba.enumerate_pixels() {
        // The original alpha was quantized to 4 bits, then scaled back up
        // We should get values like 0, 17, 34, 51, 68, ... 255
        // Check that alpha is a valid scaled 4-bit value
        let alpha = pixel[3];
        assert!(
            alpha % 17 == 0,
            "Alpha {} at x={} is not a valid scaled 4-bit value",
            alpha, x
        );
    }
}