unsigned int texel_count,

const uint8_t* partition_of_texel,

uint64_t bit_pattern[BIT_PATTERN_WORDS]

) {

// Clear the pattern

for (unsigned int i = 0; i < BIT_PATTERN_WORDS; i++)

{

bit_pattern[i] = 0;

}

// Store a mapping to reorder the raw partitions so that the partitions are ordered such

// that the lowest texel index in partition N is smaller than the lowest texel index in

// partition N + 1.

int mapped_index[BLOCK_MAX_PARTITIONS];

int map_weight_count = 0;

for (unsigned int i = 0; i < BLOCK_MAX_PARTITIONS; i++)

{

mapped_index[i] = -1;

}

for (unsigned int i = 0; i < texel_count; i++)

{

int index = partition_of_texel[i];

if (mapped_index[index] < 0)

{

mapped_index[index] = map_weight_count++;

}

uint64_t xlat_index = mapped_index[index];

bit_pattern[i >> 5] |= xlat_index << (2 * (i & 0x1F));

}

const uint64_t part1[BIT_PATTERN_WORDS],

const uint64_t part2[BIT_PATTERN_WORDS]

) {

return (part1[0] == part2[0])

#if BIT_PATTERN_WORDS > 1

&& (part1[1] == part2[1])

#endif

#if BIT_PATTERN_WORDS > 2

&& (part1[2] == part2[2])

#endif

#if BIT_PATTERN_WORDS > 3

&& (part1[3] == part2[3])

#endif

#if BIT_PATTERN_WORDS > 4

&& (part1[4] == part2[4])

#endif

#if BIT_PATTERN_WORDS > 5

&& (part1[5] == part2[5])

#endif

#if BIT_PATTERN_WORDS > 6

&& (part1[6] == part2[6])

#endif

;

uint32_t inp

) {

inp ^= inp >> 15;

// (2^4 + 1) * (2^7 + 1) * (2^17 - 1)

inp *= 0xEEDE0891;

inp ^= inp >> 5;

inp += inp << 16;

inp ^= inp >> 7;

inp ^= inp >> 3;

inp ^= inp << 6;

inp ^= inp >> 17;

return inp;

int seed,

int x,

int y,

int z,

int partition_count,

bool small_block

) {

// For small blocks bias the coordinates to get better distribution

if (small_block)

{

x <<= 1;

y <<= 1;

z <<= 1;

}

seed += (partition_count - 1) * 1024;

uint32_t rnum = hash52(seed);

uint8_t seed1 = rnum & 0xF;

uint8_t seed2 = (rnum >> 4) & 0xF;

uint8_t seed3 = (rnum >> 8) & 0xF;

uint8_t seed4 = (rnum >> 12) & 0xF;

uint8_t seed5 = (rnum >> 16) & 0xF;

uint8_t seed6 = (rnum >> 20) & 0xF;

uint8_t seed7 = (rnum >> 24) & 0xF;

uint8_t seed8 = (rnum >> 28) & 0xF;

uint8_t seed9 = (rnum >> 18) & 0xF;

uint8_t seed10 = (rnum >> 22) & 0xF;

uint8_t seed11 = (rnum >> 26) & 0xF;

uint8_t seed12 = ((rnum >> 30) | (rnum << 2)) & 0xF;

// Squaring all the seeds in order to bias their distribution towards lower values.

seed1 *= seed1;

seed2 *= seed2;

seed3 *= seed3;

seed4 *= seed4;

seed5 *= seed5;

seed6 *= seed6;

seed7 *= seed7;

seed8 *= seed8;

seed9 *= seed9;

seed10 *= seed10;

seed11 *= seed11;

seed12 *= seed12;

int sh1, sh2;

if (seed & 1)

{

sh1 = (seed & 2 ? 4 : 5);

sh2 = (partition_count == 3 ? 6 : 5);

}

else

{

sh1 = (partition_count == 3 ? 6 : 5);

sh2 = (seed & 2 ? 4 : 5);

}

int sh3 = (seed & 0x10) ? sh1 : sh2;

seed1 >>= sh1;

seed2 >>= sh2;

seed3 >>= sh1;

seed4 >>= sh2;

seed5 >>= sh1;

seed6 >>= sh2;

seed7 >>= sh1;

seed8 >>= sh2;

seed9 >>= sh3;

seed10 >>= sh3;

seed11 >>= sh3;

seed12 >>= sh3;

int a = seed1 * x + seed2 * y + seed11 * z + (rnum >> 14);

int b = seed3 * x + seed4 * y + seed12 * z + (rnum >> 10);

int c = seed5 * x + seed6 * y + seed9 * z + (rnum >> 6);

int d = seed7 * x + seed8 * y + seed10 * z + (rnum >> 2);

// Apply the saw

a &= 0x3F;

b &= 0x3F;

c &= 0x3F;

d &= 0x3F;

// Remove some of the components if we are to output < 4 partitions.

if (partition_count <= 3)

{

d = 0;

}

if (partition_count <= 2)

{

c = 0;

}

if (partition_count <= 1)

{

b = 0;

}

uint8_t partition;

if (a >= b && a >= c && a >= d)

{

partition = 0;

}

else if (b >= c && b >= d)

{

partition = 1;

}

else if (c >= d)

{

partition = 2;

}

else

{

partition = 3;

}

return partition;

block_size_descriptor& bsd,

unsigned int partition_count,

unsigned int partition_index,

unsigned int partition_remap_index,

partition_info& pi

) {

#if defined(ASTCENC_DECOMPRESS_ONLY)

// Suppress unused parameter warning

(void)partition_remap_index;

#endif

int texels_per_block = bsd.texel_count;

bool small_block = texels_per_block < 32;

uint8_t *partition_of_texel = pi.partition_of_texel;

// Assign texels to partitions

int texel_idx = 0;

int counts[BLOCK_MAX_PARTITIONS] { 0 };

for (unsigned int z = 0; z < bsd.dim_z; z++)

{

for (unsigned int y = 0; y < bsd.dim_y; y++)

{

for (unsigned int x = 0; x < bsd.dim_x; x++)

{

uint8_t part = select_partition(partition_index, x, y, z, partition_count, small_block);

pi.texels_of_partition[part][counts[part]++] = static_cast<uint8_t>(texel_idx++);

*partition_of_texel++ = part;

}

}

}

// Fill loop tail so we can overfetch later

for (unsigned int i = 0; i < partition_count; i++)

{

size_t ptex_count = counts[i];

size_t ptex_count_simd = round_up_to_simd_multiple_vla(ptex_count);

for (size_t j = ptex_count; j < ptex_count_simd; j++)

{

pi.texels_of_partition[i][j] = pi.texels_of_partition[i][ptex_count - 1];

}

}

// Populate the actual procedural partition count

if (counts[0] == 0)

{

pi.partition_count = 0;

}

else if (counts[1] == 0)

{

pi.partition_count = 1;

}

else if (counts[2] == 0)

{

pi.partition_count = 2;

}

else if (counts[3] == 0)

{

pi.partition_count = 3;

}

else

{

pi.partition_count = 4;

}

// Populate the partition index

pi.partition_index = static_cast<uint16_t>(partition_index);

for (unsigned int i = 0; i < BLOCK_MAX_PARTITIONS; i++)

{

pi.partition_texel_count[i] = static_cast<uint8_t>(counts[i]);

}

// Valid partitionings have texels in all of the requested partitions

bool valid = pi.partition_count == partition_count;

#if !defined(ASTCENC_DECOMPRESS_ONLY)

// Populate the coverage bitmaps for 2/3/4 partitions

uint64_t* bitmaps { nullptr };

if (partition_count == 2)

{

bitmaps = bsd.coverage_bitmaps_2[partition_remap_index];

}

else if (partition_count == 3)

{

bitmaps = bsd.coverage_bitmaps_3[partition_remap_index];

}

else if (partition_count == 4)

{

bitmaps = bsd.coverage_bitmaps_4[partition_remap_index];

}

if (bitmaps)

{

// Populate the partition coverage bitmap

for (unsigned int i = 0; i < partition_count; i++)

{

bitmaps[i] = 0ULL;

}

unsigned int texels_to_process = astc::min(bsd.texel_count, BLOCK_MAX_KMEANS_TEXELS);

for (unsigned int i = 0; i < texels_to_process; i++)

{

unsigned int idx = bsd.kmeans_texels[i];

bitmaps[pi.partition_of_texel[idx]] |= 1ULL << i;

}

}

#endif

return valid;

block_size_descriptor& bsd,

bool can_omit_partitionings,

unsigned int partition_count_cutoff,

unsigned int partition_count,

partition_info* ptab,

uint64_t* canonical_patterns

) {

unsigned int next_index = 0;

bsd.partitioning_count_selected[partition_count - 1] = 0;

bsd.partitioning_count_all[partition_count - 1] = 0;

// Mark all partitionings as unused; the loops below overwrite the entries

// that are actually kept. Partitionings dropped in self-decompress mode

// must retain this known-bad value so that decoding an unknown raw

// partition index does not result in a bad packed index.

for (unsigned int i = 0; i < BLOCK_MAX_PARTITIONINGS; i++)

{

bsd.partitioning_packed_index[partition_count - 2][i] = BLOCK_BAD_PARTITIONING;

}

// Skip tables larger than config max partition count if we can omit modes

if (can_omit_partitionings && (partition_count > partition_count_cutoff))

{

return;

}

// Iterate through twice

// - Pass 0: Keep selected partitionings

// - Pass 1: Keep non-selected partitionings (skip if in omit mode)

unsigned int max_iter = can_omit_partitionings ? 1 : 2;

// Tracker for things we built in the first iteration

uint8_t build[BLOCK_MAX_PARTITIONINGS] { 0 };

for (unsigned int x = 0; x < max_iter; x++)

{

for (unsigned int i = 0; i < BLOCK_MAX_PARTITIONINGS; i++)

{

// Don't include things we built in the first pass

if ((x == 1) && build[i])

{

continue;

}

bool keep_useful = generate_one_partition_info_entry(bsd, partition_count, i, next_index, ptab[next_index]);

if ((x == 0) && !keep_useful)

{

continue;

}

generate_canonical_partitioning(bsd.texel_count, ptab[next_index].partition_of_texel, canonical_patterns + next_index * BIT_PATTERN_WORDS);

bool keep_canonical = true;

for (unsigned int j = 0; j < next_index; j++)

{

bool match = compare_canonical_partitionings(canonical_patterns + next_index * BIT_PATTERN_WORDS, canonical_patterns + j * BIT_PATTERN_WORDS);

if (match)

{

keep_canonical = false;

break;

}

}

if (keep_useful && keep_canonical)

{

if (x == 0)

{

bsd.partitioning_packed_index[partition_count - 2][i] = static_cast<uint16_t>(next_index);

bsd.partitioning_count_selected[partition_count - 1]++;

bsd.partitioning_count_all[partition_count - 1]++;

build[i] = 1;

next_index++;

}

}

else

{

if (x == 1)

{

bsd.partitioning_packed_index[partition_count - 2][i] = static_cast<uint16_t>(next_index);

bsd.partitioning_count_all[partition_count - 1]++;

next_index++;

}

}

}

}

block_size_descriptor& bsd,

bool can_omit_partitionings,

unsigned int partition_count_cutoff

) {

partition_info* par_tab2 = bsd.partitionings;

partition_info* par_tab3 = par_tab2 + BLOCK_MAX_PARTITIONINGS;

partition_info* par_tab4 = par_tab3 + BLOCK_MAX_PARTITIONINGS;

partition_info* par_tab1 = par_tab4 + BLOCK_MAX_PARTITIONINGS;

generate_one_partition_info_entry(bsd, 1, 0, 0, *par_tab1);

bsd.partitioning_count_selected[0] = 1;

bsd.partitioning_count_all[0] = 1;

uint64_t* canonical_patterns = new uint64_t[BLOCK_MAX_PARTITIONINGS * BIT_PATTERN_WORDS];

build_partition_table_for_one_partition_count(bsd, can_omit_partitionings, partition_count_cutoff, 2, par_tab2, canonical_patterns);

build_partition_table_for_one_partition_count(bsd, can_omit_partitionings, partition_count_cutoff, 3, par_tab3, canonical_patterns);

build_partition_table_for_one_partition_count(bsd, can_omit_partitionings, partition_count_cutoff, 4, par_tab4, canonical_patterns);

delete[] canonical_patterns;