{

const int width = 256;

const int height = 256;

const int max_iter = 1000;

// Create a more interesting color palette

uint8_t palette[256][3];

for (int i = 0; i < 256; i++)

{

if (i < 64)

{

// Blue to cyan transition

palette[i][0] = static_cast<uint8_t>(0); // Red component

palette[i][1] = static_cast<uint8_t>(i * 4); // Green component

palette[i][2] = static_cast<uint8_t>(255); // Blue component

}

else if (i < 128)

{

// Cyan to green transition

palette[i][0] = static_cast<uint8_t>(0); // Red component

palette[i][1] = static_cast<uint8_t>(255); // Green component

palette[i][2] = static_cast<uint8_t>(255 - (i - 64) * 4); // Blue component

}

else if (i < 192)

{

// Green to yellow transition

palette[i][0] = static_cast<uint8_t>((i - 128) * 4); // Red component

palette[i][1] = static_cast<uint8_t>(255); // Green component

palette[i][2] = static_cast<uint8_t>(0); // Blue component

}

else

{

// Yellow to red transition

palette[i][0] = static_cast<uint8_t>(255); // Red component

palette[i][1] = static_cast<uint8_t>(255 - (i - 192) * 4); // Green component

palette[i][2] = static_cast<uint8_t>(0); // Blue component

}

}

// Iterate over each pixel in the image

for (int px = 0; px < width; px++)

{

for (int py = 0; py < height; py++)

{

double x0 = (px - width / 2.0) * 4.0 / width;

double y0 = (py - height / 2.0) * 4.0 / height;

double zx = 0.0;

double zy = 0.0;

double zx_squared = 0.0;

double zy_squared = 0.0;

double x_temp;

int iter;

for (iter = 0; iter < max_iter; iter++)

{

zx_squared = zx * zx;

zy_squared = zy * zy;

if (zx_squared + zy_squared > 4.0) break;

// Update z = z^2 + c, but split into real and imaginary parts

x_temp = zx_squared - zy_squared + x0;

zy = 2.0 * zx * zy + y0;

zx = x_temp;

}

// Map the number of iterations to a color in the palette

int color_idx = iter % 256;

// Set the pixel color in the image

img.set_clipped(px, py, vec4F(((float)palette[color_idx][0])/128.0f, ((float)palette[color_idx][1])/128.0f, ((float)palette[color_idx][2])/128.0f));

}

}

{

const uint32_t W = 512, H = 512;

image img(W, H);

for (uint32_t y = 0; y < H; y++)

for (uint32_t x = 0; x < W; x++)

img(x, y).set(0, y >> 1, x >> 1, ((x ^ y) & 1) ? 255 : 0);

basisu::vector<image> source_images;

source_images.push_back(img);

size_t file_size = 0;

uint32_t quality_level = 255;

// basis_compress() is a simple wrapper around the basis_compressor_params and basis_compressor classes.

void* pKTX2_data = basis_compress(

basist::basis_tex_format::cETC1S,

source_images,

quality_level | cFlagSRGB | cFlagGenMipsClamp | cFlagThreaded | cFlagPrintStats | cFlagDebug | cFlagPrintStatus | cFlagUseOpenCL | cFlagKTX2, 0.0f,

&file_size,

nullptr);

if (!pKTX2_data)

return false;

if (!write_data_to_file("test_etc1s.ktx2", pKTX2_data, file_size))

{

basis_free_data(pKTX2_data);

return false;

}

basis_free_data(pKTX2_data);

return true;

{

const uint32_t W = 512, H = 512;

image img(W, H);

for (uint32_t y = 0; y < H; y++)

for (uint32_t x = 0; x < W; x++)

img(x, y).set(x >> 1, y >> 1, 0, 255);

basisu::vector<image> source_images;

source_images.push_back(img);

size_t file_size = 0;

// basis_compress() is a simple wrapper around the basis_compressor_params and basis_compressor classes.

void* pKTX2_data = basis_compress(

basist::basis_tex_format::cUASTC_LDR_4x4,

source_images,

cFlagThreaded | cFlagPrintStats | cFlagDebug | cFlagPrintStatus | cFlagKTX2, 0.0f,

&file_size,

nullptr);

if (!pKTX2_data)

return false;

if (!write_data_to_file("test_uastc_ldr_4x4.ktx2", pKTX2_data, file_size))

{

basis_free_data(pKTX2_data);

return false;

}

basis_free_data(pKTX2_data);

return true;

{

const uint32_t W = 256, H = 256;

imagef img(W, H);

#if 1

create_mandelbrot(img);

#else

#endif

basis_compressor_params params;

params.m_hdr = true;

params.m_source_images_hdr.push_back(img);

params.m_uastc_hdr_4x4_options.set_quality_level(3);

params.m_debug = true;

//params.m_debug_images = true;

params.m_status_output = true;

params.m_compute_stats = true;

params.m_create_ktx2_file = true;

params.m_write_output_basis_or_ktx2_files = true;

params.m_out_filename = "test_uastc_hdr.ktx2";

params.m_perceptual = true;

#if 1

// Create a job pool containing 7 total threads (the calling thread plus 6 additional threads).

// A job pool must be created, even if threading is disabled.

const uint32_t NUM_THREADS = 7;

job_pool jp(NUM_THREADS);

params.m_pJob_pool = &jp;

params.m_multithreading = true;

#else

#endif

basis_compressor comp;

if (!comp.init(params))

return false;

basisu::basis_compressor::error_code ec = comp.process();

if (ec != basisu::basis_compressor::cECSuccess)

return false;

return true;

{

// Note: The encoder already initializes the transcoder, but if you haven't initialized the encoder you MUST call this function to initialize the transcoder.

basist::basisu_transcoder_init();

// Read the .KTX2 file's data into memory.

uint8_vec ktx2_file_data;

if (!read_file_to_vec("test_uastc_hdr.ktx2", ktx2_file_data))

return false;

// Create the KTX2 transcoder object.

basist::ktx2_transcoder transcoder;

// Initialize the transcoder.

if (!transcoder.init(ktx2_file_data.data(), ktx2_file_data.size_u32()))

return false;

const uint32_t width = transcoder.get_width();

const uint32_t height = transcoder.get_height();

printf("Texture dimensions: %ux%u, levels: %u\n", width, height, transcoder.get_levels());

// This example only transcodes UASTC HDR textures.

if (!transcoder.is_hdr())

return false;

// Begin transcoding (this will be a no-op with UASTC HDR textures, but you still need to do it. For ETC1S it'll unpack the global codebooks.)

transcoder.start_transcoding();

// Transcode to BC6H and write a BC6H .DDS file.

{

gpu_image tex(texture_format::cBC6HUnsigned, width, height);

bool status = transcoder.transcode_image_level(0, 0, 0,

tex.get_ptr(), tex.get_total_blocks(),

basist::transcoder_texture_format::cTFBC6H, 0);

if (!status)

return false;

gpu_image_vec tex_vec;

tex_vec.push_back(tex);

if (!write_compressed_texture_file("test_uastc_hdr_bc6h.dds", tex_vec, false))

return false;

}

// Transcode to ASTC HDR 4x4 and write a ASTC 4x4 HDR .astc file.

{

gpu_image tex(texture_format::cASTC_HDR_4x4, width, height);

bool status = transcoder.transcode_image_level(0, 0, 0,

tex.get_ptr(), tex.get_total_blocks(),

basist::transcoder_texture_format::cTFASTC_HDR_4x4_RGBA, 0);

if (!status)

return false;

if (!write_astc_file("test_uastc_hdr_astc.astc", tex.get_ptr(), 4, 4, tex.get_pixel_width(), tex.get_pixel_height()))

return false;

}

// Transcode to RGBA HALF and write an .EXR file.

{

basisu::vector<uint16_t> half_img(width * 4 * height);

bool status = transcoder.transcode_image_level(0, 0, 0,

half_img.get_ptr(), half_img.size_u32() / 4,

basist::transcoder_texture_format::cTFRGBA_HALF, 0);

if (!status)

return false;

// Convert FP16 (half float) image to 32-bit float

imagef float_img(transcoder.get_width(), transcoder.get_height());

for (uint32_t y = 0; y < transcoder.get_height(); y++)

{

for (uint32_t x = 0; x < transcoder.get_height(); x++)

{

float_img(x, y).set(

basist::half_to_float(half_img[(x + y * width) * 4 + 0]),

basist::half_to_float(half_img[(x + y * width) * 4 + 1]),

basist::half_to_float(half_img[(x + y * width) * 4 + 2]),

1.0f);

}

}

if (!write_exr("test_uastc_hdr_rgba_half.exr", float_img, 3, 0))

return false;

}

return true;

{

printf("block_unpack_and_transcode_example:\n");

for (uint32_t test_block_iter = 0; test_block_iter < NUM_TEST_BLOCKS; test_block_iter++)

{

printf("-- Test block %u:\n", test_block_iter);

const uint8_t* pASTC_blk = &g_test_blocks[test_block_iter * 2 + 0][0];

const uint8_t* pBC6H_blk = &g_test_blocks[test_block_iter * 2 + 1][0];

// Unpack the physical ASTC block to logical.

// Note this is a full ASTC block unpack, and is not specific to UASTC. It does not verify that the block follows the UASTC HDR spec, only ASTC.

astc_helpers::log_astc_block log_blk;

bool status = astc_helpers::unpack_block(pASTC_blk, log_blk, 4, 4);

assert(status);

if (!status)

{

fprintf(stderr, "Could not unpack ASTC HDR block!\n");

return false;

}

// Print out basic block configuration.

printf("Solid color: %u\n", log_blk.m_solid_color_flag_hdr);

if (!log_blk.m_solid_color_flag_hdr)

{

printf("Num partitions: %u\n", log_blk.m_num_partitions);

printf("CEMs: %u %u\n", log_blk.m_color_endpoint_modes[0], log_blk.m_color_endpoint_modes[1]);

printf("Weight ISE range: %u\n", log_blk.m_weight_ise_range);

printf("Endpoint ISE range: %u\n", log_blk.m_endpoint_ise_range);

}

// Try to transcode this block to BC6H. This will fail if the block is not UASTC HDR.

basist::bc6h_block transcoded_bc6h_blk;

status = basist::astc_hdr_transcode_to_bc6h(*(const basist::astc_blk*)pASTC_blk, transcoded_bc6h_blk);

if (!status)

printf("!");

assert(status);

// Make sure our transcoded BC6H block matches the unexpected block from the UASTC HDR spec.

if (memcmp(&transcoded_bc6h_blk, pBC6H_blk, 16) == 0)

{

printf("Block transcoded OK\n");

}

else

{

fprintf(stderr, "Block did NOT transcode as expected\n");

return false;

}

} // test_block_iter

printf("Transcode test OK\n");

return true;

{

printf("fuzz_uastc_hdr_transcoder_test:\n");

basisu::rand rg;

rg.seed(2000);

#ifdef __SANITIZE_ADDRESS__

const uint32_t NUM_TRIES = 100000000;

#else

const uint32_t NUM_TRIES = 2000000;

#endif

for (uint32_t t = 0; t < NUM_TRIES; t++)

{

basist::astc_blk astc_blk;

if (rg.frand(0.0f, 1.0f) < .3f)

{

// Fully random block

for (uint32_t k = 0; k < 16; k++)

((uint8_t*)&astc_blk)[k] = rg.byte();

}

else

{

// Take a UASTC HDR block and corrupt it

uint32_t test_block_index = rg.irand(0, NUM_TEST_BLOCKS - 1);

const uint8_t* pGood_ASTC_blk = &g_test_blocks[test_block_index * 2 + 0][0];

memcpy(&astc_blk, pGood_ASTC_blk, 16);

const uint32_t num_regions = rg.irand(1, 3);

for (uint32_t k = 0; k < num_regions; k++)

{

if (rg.bit())

{

// Flip a set of random bits

const uint32_t bit_index = rg.irand(0, 127);

const uint32_t num_bits = rg.irand(1, 128 - 127);

assert((bit_index + num_bits) <= 128);

for (uint32_t i = 0; i < num_bits; i++)

{

uint32_t bit_ofs = bit_index + i;

assert(bit_ofs < 128);

uint32_t bit_mask = 1 << (bit_ofs & 7);

uint32_t byte_ofs = bit_ofs >> 3;

assert(byte_ofs < 16);

((uint8_t*)&astc_blk)[byte_ofs] ^= bit_mask;

}

}

else

{

// Set some bits to random values

const uint32_t bit_index = rg.irand(0, 127);

const uint32_t num_bits = rg.irand(1, 128 - 127);

assert((bit_index + num_bits) <= 128);

for (uint32_t i = 0; i < num_bits; i++)

{

uint32_t bit_ofs = bit_index + i;

assert(bit_ofs < 128);

uint32_t bit_mask = 1 << (bit_ofs & 7);

uint32_t byte_ofs = bit_ofs >> 3;

assert(byte_ofs < 16);

((uint8_t*)&astc_blk)[byte_ofs] &= ~bit_mask;

if (rg.bit())

((uint8_t*)&astc_blk)[byte_ofs] |= bit_mask;

}

}

} // k

}

basist::bc6h_block bc6h_blk;

bool status = basist::astc_hdr_transcode_to_bc6h(astc_blk, bc6h_blk);

if (!(t % 100000))

printf("%u %u\n", t, status);

}

printf("OK\n");

{

if (gridX < 1) gridX = 1;

if (gridY < 1) gridY = 1;

const int vxCountX = gridX + 1;

const int vxCountY = gridY + 1;

const int stride = vxCountX;

const int w = src.get_width();

const int h = src.get_height();

dst.resize(w, h);

dst.set_all(g_black_color);

basisu::vector<vec2F> verts(vxCountX * vxCountY);

basisu::vector<vec2F> uvs(vxCountX * vxCountY);

basisu::vector<color_rgba> cols(vxCountX * vxCountY);

for (int gy = 0; gy <= gridY; ++gy)

{

for (int gx = 0; gx <= gridX; ++gx)

{

float x = (gx / float(gridX)) * (w - 1);

float y = (gy / float(gridY)) * (h - 1);

float rx = x;

float ry = y;

if (randomize)

{

rx += rnd.frand(-maxOffset, maxOffset);

ry += rnd.frand(-maxOffset, maxOffset);

}

verts[gy * stride + gx] = { rx, ry };

float u = gx / float(gridX);

float v = gy / float(gridY);

u = std::max(0.0f, std::min(1.0f, u));

v = std::max(0.0f, std::min(1.0f, v));

uvs[gy * stride + gx] = { u, v };

color_rgba c(g_white_color);

cols[gy * stride + gx] = c;

}

}

for (int gy = 0; gy < gridY; ++gy)

{

for (int gx = 0; gx < gridX; ++gx)

{

int i0 = gy * stride + gx;

int i1 = i0 + 1;

int i2 = i0 + stride;

int i3 = i2 + 1;

tri2 tA;

tA.p0 = verts[i0]; tA.p1 = verts[i1]; tA.p2 = verts[i3];

tA.t0 = uvs[i0]; tA.t1 = uvs[i1]; tA.t2 = uvs[i3];

tA.c0 = cols[i0]; tA.c1 = cols[i1]; tA.c2 = cols[i3];

draw_tri2(dst, &src, tA, randomize);

tri2 tB;

tB.p0 = verts[i0]; tB.p1 = verts[i3]; tB.p2 = verts[i2];

tB.t0 = uvs[i0]; tB.t1 = uvs[i3]; tB.t2 = uvs[i2];

tB.c0 = cols[i0]; tB.c1 = cols[i3]; tB.c2 = cols[i2];

draw_tri2(dst, &src, tB, randomize);

} // gx

} // by

{

cETC1S = 0,

cUASTC_LDR_4x4 = 1,

cUASTC_HDR_4x4 = 2,

cASTC_HDR_6x6 = 3,

cUASTC_HDR_6x6 = 4,

cASTC_LDR = 5,

cXUASTC_LDR = 6,

cXUBC7 = 7,

cTOTAL

{

printf("Random XUASTC/ASTC LDR 4x4-12x12 compression test:\n");

const uint32_t num_images = 18;

image test_images[num_images + 1];

for (uint32_t i = 0; i < num_images; i++)

{

if (!load_png(fmt_string("../test_files/kodim{02}.png", 1 + i).c_str(), test_images[i]))

{

fmt_error_printf("Failed loading a PNG file from ../test_files!\n");

return false;

}

}

const uint32_t N = 16;

//const uint32_t N = 10000;

//const uint32_t N = 5000000;

const uint32_t MAX_WIDTH = 512, MAX_HEIGHT = 512;

const bool xuastc_or_astc_only = false;

const bool xubc7_only = false;

const bool xuastc_astc_or_xubc7_only = false; // randomly pick XUASTC LDR, ASTC LDR, or XUBC7

basisu::rand rnd;

float lowest_psnr1 = BIG_FLOAT_VAL, lowest_psnr2 = BIG_FLOAT_VAL;

struct result

{

uint32_t m_seed;

basist::basis_tex_format m_fmt;

float m_psnr1;

float m_psnr2;

};

basisu::vector<result> results;

for (uint32_t i = 0; i < N; i++)

{

uint32_t seed = 741019868 + i;

fmt_printf("------------------------------ Seed: {}\n", seed);

rnd.seed(seed);

const uint32_t w = rnd.irand(1, MAX_WIDTH);

const uint32_t h = rnd.irand(1, MAX_HEIGHT);

const bool mips = rnd.bit();

const bool use_a = rnd.bit();

fmt_printf("Trying {}x{}, mips: {}, use_a: {}\n", w, h, mips, use_a);

// Chose a random codec/block size to test

basist::basis_tex_format tex_mode = basist::basis_tex_format::cETC1S;

bool is_hdr = false;

uint32_t rnd_codec_class = rnd.irand(0, (uint32_t)codec_class::cTOTAL - 1);

// TODO - make this a command line

if (xuastc_or_astc_only)

{

// Restrict to the LDR block codecs: XUASTC LDR, ASTC LDR

switch (rnd.irand(0, 1))

{

case 0: rnd_codec_class = (uint32_t)codec_class::cXUASTC_LDR; break;

case 1: rnd_codec_class = (uint32_t)codec_class::cASTC_LDR; break;

default: assert(0); break;

}

}

else if (xubc7_only)

{

rnd_codec_class = (uint32_t)codec_class::cXUBC7;

}

else if (xuastc_astc_or_xubc7_only)

{

// Restrict to: XUASTC LDR, ASTC LDR, or XUBC7 (randomly)

switch (rnd.irand(0, 2))

{

case 0: rnd_codec_class = (uint32_t)codec_class::cXUASTC_LDR; break;

case 1: rnd_codec_class = (uint32_t)codec_class::cASTC_LDR; break;

default: rnd_codec_class = (uint32_t)codec_class::cXUBC7; break;

}

}

//rnd_codec_class = (uint32_t)codec_class::cXUASTC_LDR;

//rnd_codec_class = (uint32_t)codec_class::cETC1S;

switch (rnd_codec_class)

{

case (uint32_t)codec_class::cETC1S:

{

tex_mode = basist::basis_tex_format::cETC1S;

break;

}

case (uint32_t)codec_class::cUASTC_LDR_4x4:

{

tex_mode = basist::basis_tex_format::cUASTC_LDR_4x4;

break;

}

case (uint32_t)codec_class::cUASTC_HDR_4x4:

{

tex_mode = basist::basis_tex_format::cUASTC_HDR_4x4;

is_hdr = true;

break;

}

case (uint32_t)codec_class::cASTC_HDR_6x6:

{

tex_mode = basist::basis_tex_format::cASTC_HDR_6x6;

is_hdr = true;

break;

}

case (uint32_t)codec_class::cUASTC_HDR_6x6:

{

tex_mode = basist::basis_tex_format::cUASTC_HDR_6x6_INTERMEDIATE;

is_hdr = true;

break;

}

case (uint32_t)codec_class::cASTC_LDR:

{

// ASTC LDR 4x4-12x12

const uint32_t block_variant = rnd.irand(0, astc_helpers::NUM_ASTC_BLOCK_SIZES - 1);

tex_mode = (basist::basis_tex_format)((uint32_t)basist::basis_tex_format::cASTC_LDR_4x4 + block_variant);

break;

}

case (uint32_t)codec_class::cXUASTC_LDR:

{

// XUASTC LDR 4x4-12x12

const uint32_t block_variant = rnd.irand(0, astc_helpers::NUM_ASTC_BLOCK_SIZES - 1);

tex_mode = (basist::basis_tex_format)((uint32_t)basist::basis_tex_format::cXUASTC_LDR_4x4 + block_variant);

break;

}

case (uint32_t)codec_class::cXUBC7:

{

// XUBC7 supercompressed BC7 (always 4x4, LDR)

tex_mode = basist::basis_tex_format::cXUBC7;

break;

}

default:

assert(0);

tex_mode = basist::basis_tex_format::cETC1S;

break;

}

fmt_printf("Testing basis_tex_format={}\n", (uint32_t)tex_mode);

size_t comp_size = 0;

// Create random LDR source image to compress

image src_img;

src_img.resize(w, h, w, color_rgba(rnd.byte(), rnd.byte(), rnd.byte(), use_a ? rnd.byte() : 255));

if (rnd.irand(0, 7) >= 1)

{

const uint32_t nt = rnd.irand(0, 1000);

for (uint32_t k = 0; k < nt; k++)

{

color_rgba c(rnd.byte(), rnd.byte(), rnd.byte(), use_a ? rnd.byte() : 255);

uint32_t r = rnd.irand(0, 25);

if (r == 0)

{

uint32_t xs = rnd.irand(0, w - 1);

uint32_t xe = rnd.irand(0, w - 1);

if (xs > xe)

std::swap(xs, xe);

uint32_t ys = rnd.irand(0, h - 1);

uint32_t ye = rnd.irand(0, h - 1);

if (ys > ye)

std::swap(ys, ye);

src_img.fill_box(xs, ys, xe - xs + 1, ye - ys + 1, c);

}

else if (r <= 5)

{

uint32_t xs = rnd.irand(0, w - 1);

uint32_t xe = rnd.irand(0, w - 1);

uint32_t ys = rnd.irand(0, h - 1);

uint32_t ye = rnd.irand(0, h - 1);

basisu::draw_line(src_img, xs, ys, xe, ye, c);

}

else if (r == 6)

{

uint32_t cx = rnd.irand(0, w - 1);

uint32_t cy = rnd.irand(0, h - 1);

uint32_t ra = rnd.irand(0, 100);

basisu::draw_circle(src_img, cx, cy, ra, c);

}

else if (r < 10)

{

uint32_t x = rnd.irand(0, w - 1);

uint32_t y = rnd.irand(0, h - 1);

uint32_t sx = rnd.irand(1, 3);

uint32_t sy = rnd.irand(1, 3);

uint32_t l = rnd.irand(1, 10);

char buf[32] = {};

for (uint32_t j = 0; j < l; j++)

buf[j] = (char)rnd.irand(32, 127);

src_img.debug_text(x, y, sx, sy, c, nullptr, rnd.bit(), "%s", buf);

}

else if (r < 12)

{

uint32_t xs = rnd.irand(0, w - 1);

uint32_t ys = rnd.irand(0, h - 1);

uint32_t xl = rnd.irand(1, 100);

uint32_t yl = rnd.irand(1, 100);

uint32_t xe = minimum<int>(xs + xl - 1, w - 1);

uint32_t ye = minimum<int>(ys + yl - 1, h - 1);

color_rgba cols[4];

cols[0] = c;

for (uint32_t j = 1; j < 4; j++)

cols[j] = color_rgba(rnd.byte(), rnd.byte(), rnd.byte(), use_a ? rnd.byte() : 255);

const bool a_only = rnd.bit();

const bool rgb_only = rnd.bit();

const bool noise_flag = rnd.irand(0, 9) == 0;

for (uint32_t y = ys; y <= ye; y++)

{

float fy = (ye != ys) ? (float(y - ys) / float(ye - ys)) : 0;

for (uint32_t x = xs; x <= xe; x++)

{

float fx = (xe != xs) ? (float(x - xs) / float(xe - xs)) : 0;

color_rgba q;

if (noise_flag)

{

for (uint32_t j = 0; j < 4; j++)

q[j] = rnd.byte();

}

else

{

for (uint32_t j = 0; j < 4; j++)

{

float lx0 = lerp((float)cols[0][j], (float)cols[1][j], fx);

float lx1 = lerp((float)cols[2][j], (float)cols[3][j], fx);

int ly = (int)std::round(lerp(lx0, lx1, fy));

q[j] = (uint8_t)clamp(ly, 0, 255);

}

}

if (a_only)

src_img(x, y).a = q.a;

else if (rgb_only)

{

src_img(x, y).r = q.r;

src_img(x, y).g = q.g;

src_img(x, y).b = q.b;

}

else

src_img(x, y) = q;

} // x

} // y

}

else if ((r < 20) && (num_images))

{

uint32_t image_index = rnd.irand(0, num_images - 1);

const image& img = test_images[image_index];

if (img.get_width())

{

float tw = (float)rnd.irand(1, minimum<int>(128, img.get_width()));

float th = (float)rnd.irand(1, minimum<int>(128, img.get_height()));

float u = (float)rnd.irand(0, img.get_width() - (int)tw);

float v = (float)rnd.irand(0, img.get_height() - (int)th);

u /= (float)img.get_width();

v /= (float)img.get_height();

tw /= (float)img.get_width();

th /= (float)img.get_height();

float dx = (float)rnd.irand(0, src_img.get_width() - 1);

float dy = (float)rnd.irand(0, src_img.get_height() - 1);

float dw = (float)rnd.irand(1, minimum<int>(256, img.get_width()));

float dh = (float)rnd.irand(1, minimum<int>(256, img.get_height()));

tri2 tri;

tri.p0.set(dx, dy);

tri.t0.set(u, v);

tri.p1.set(dx + dw, dy);

tri.t1.set(u + tw, v);

tri.p2.set(dx + dw, dy + dh);

tri.t2.set(u + tw, v + th);

bool alpha_blend = rnd.bit();

if (alpha_blend)

{

tri.c0.set(rnd.irand(100, 255), rnd.irand(100, 255), rnd.irand(100, 255), rnd.irand(1, 255));

tri.c1.set(rnd.irand(100, 255), rnd.irand(100, 255), rnd.irand(100, 255), rnd.irand(1, 255));

tri.c2.set(rnd.irand(100, 255), rnd.irand(100, 255), rnd.irand(100, 255), rnd.irand(1, 255));

}

else

{

tri.c0 = g_white_color;

tri.c1 = g_white_color;

tri.c2 = g_white_color;

}

draw_tri2(src_img, &img, tri, alpha_blend);

tri.p0.set(dx, dy);

tri.t0.set(u, v);

tri.p1.set(dx + dw, dy + dh);

tri.t1.set(u + tw, v + th);

tri.c1 = tri.c2;

tri.p2.set(dx, dy + dh);

tri.t2.set(u, v + th);

tri.c2.set(rnd.irand(100, 255), rnd.irand(100, 255), rnd.irand(100, 255), rnd.irand(1, 255));

draw_tri2(src_img, &img, tri, alpha_blend);

}

}

else

{

src_img(rnd.irand(0, w - 1), rnd.irand(0, h - 1)) = c;

}