Function FindBestPattern

cmp_core/shaders/bc6_encode_kernel.cpp:2262–2388

}

CGU_FLOAT FindBestPattern(BC6H_Encode_local* BC6H_data, CGU_BOOL TwoRegionShapes, CGU_INT8 shape_pattern, CGU_FLOAT quality)
{
    // Index bit size for the patterns been used.
    // All two zone shapes have 3 bits per color, max index value < 8
    // All one zone shapes gave 4 bits per color, max index value < 16
    CGU_INT8  Index_BitSize        = TwoRegionShapes ? 8 : 16;
    CGU_INT8  max_subsets          = TwoRegionShapes ? 2 : 1;
    CGU_FLOAT direction[NCHANNELS] = {};
    CGU_FLOAT step                 = 0;

    BC6H_data->region        = max_subsets;
    BC6H_data->index         = 0;
    BC6H_data->d_shape_index = shape_pattern;
    memset((CGU_UINT8*)BC6H_data->partition, 0, sizeof(BC6H_data->partition));
    memset((CGU_UINT8*)BC6H_data->shape_indices, 0, sizeof(BC6H_data->shape_indices));

    // Get the pattern to encode with
    Partition(shape_pattern,          // Shape pattern we want to get
              BC6H_data->din,         // Input data
              BC6H_data->partition,   // Returns the patterned shape data
              BC6H_data->entryCount,  // counts the number of pixel used in each subset region num of 0's amd 1's
              max_subsets,            // Table Shapes to use eithe one regions 1 or two regions 2
              3);                     // rgb no alpha always = 3

    CGU_FLOAT error[MAX_SUBSETS] = {0.0, CMP_FLOAT_MAX, CMP_FLOAT_MAX};
    CGU_INT   BestOutB           = 0;
    CGU_FLOAT BestError;         //the lowest error from vector direction quantization
    CGU_FLOAT BestError_endpts;  //the lowest error from endpoints extracted from the vector direction quantization

    CGU_FLOAT outB[2][2][MAX_SUBSET_SIZE][MAX_DIMENSION_BIG]  = {};
    CGU_INT   shape_indicesB[2][MAX_SUBSETS][MAX_SUBSET_SIZE] = {};

    for (CGU_INT subset = 0; subset < max_subsets; subset++)
    {
        error[0] += optQuantAnD_d(BC6H_data->partition[subset],   // input data
                                  BC6H_data->entryCount[subset],  // number of input points above (not clear about 1, better to avoid)
                                  Index_BitSize,                  // number of clusters on the ramp, 8  or 16
                                  shape_indicesB[0][subset],      // output index, if not all points of the ramp used, 0 may not be assigned
                                  outB[0][subset],                // resulting quantization
                                  direction,                      // direction vector of the ramp (check normalization)
                                  &step,                          // step size (check normalization)
                                  3,                              // number of channels (always 3 = RGB for BC6H)
                                  quality                         // Quality set number of retry to get good end points
                                                                  // Max retries = MAX_TRY = 4000 when Quality is 1.0
                                                                  // Min = 0 and default with quality 0.05 is 200 times
        );
    }

    BestError = error[0];
    BestOutB  = 0;

    // The following code is almost complete - runs very slow and not sure if % of improvement is justified..
#ifdef USE_SHAKERHD
    // Valid only for 2 region shapes
    if ((max_subsets > 1) && (quality > 0.80))
    {
        CGU_INT tempIndices[MAX_SUBSET_SIZE] = {};
        // CGU_INT     temp_epo_code[2][2][MAX_DIMENSION_BIG];