Static Public Member Functions
static CMPRBlock	compressDXT1a (ARGBPixel *img, int imgX, int imgY, int imgW, int imgH)

static CMPRBlock	optimalCompressDXT1a (ARGBPixel rgba)

Static Public Attributes
static readonly byte[,]	OMatch5

static readonly byte[,]	OMatch6

Member Function Documentation

◆ compressDXT1a()

static CMPRBlock BrawlLib.Imaging.NVDXT.compressDXT1a	(	ARGBPixel *	img,
		int	imgX,
		int	imgY,
		int	imgW,
		int	imgH
	)

inlinestatic

        {
            uint* pData = stackalloc uint[16];
            ARGBPixel* pBlock = (ARGBPixel*) pData;
 
            bool hasAlpha = false;
            bool isSingle = true;
 
            ARGBPixel p;
            ARGBPixel* sPtr = img + (imgX + imgY * imgW);
            int index = 0;
            for (int y = 0; y < 4; y++)
            {
                for (int x = 0; x < 4; x++)
                {
                    p = sPtr[x + y * imgW];
                    pBlock[index++] = p;
                    if (p != pBlock[0])
                    {
                        isSingle = false;
                    }
 
                    if (p.A < 128)
                    {
                        hasAlpha = true;
                    }
                }
            }
 
            if (isSingle)
            {
                return optimalCompressDXT1a(sPtr[0]);
            }
 
            if (!hasAlpha)
            {
                return compressDXT1(pBlock);
            }
 
            // @@ Handle single RGB, with varying alpha? We need tables for single color compressor in 3 color mode.
            //else if (rgba.isSingleColorNoAlpha()) { ... }
 
            float* pointData = stackalloc float[48];
            Vector3* points = (Vector3*) pointData;
 
            // read block
            //Vector3 block[16];
            int num = extractColorBlockRGBA(pBlock, points);
 
            // find min and max colors
            Vector3 maxColor, minColor;
            findMinMaxColorsBox(points, num, &maxColor, &minColor);
 
            selectDiagonal(points, num, &maxColor, &minColor);
 
            insetBBox(&maxColor, &minColor);
 
            ushort color0 = roundAndExpand(&maxColor);
            ushort color1 = roundAndExpand(&minColor);
 
            if (color0 < color1)
            {
                Vector3 t = maxColor;
                maxColor = minColor;
                minColor = t;
                VoidPtr.Swap(&color0, &color1);
            }
 
            CMPRBlock block = new CMPRBlock();
            block._root0._data = color1;
            block._root1._data = color0;
            block._lookup = computeIndices3(pBlock, &maxColor, &minColor);
 
            //    optimizeEndPoints(block, dxtBlock);
 
            return block;
        }

◆ optimalCompressDXT1a()

static CMPRBlock BrawlLib.Imaging.NVDXT.optimalCompressDXT1a ( ARGBPixel rgba )

inlinestatic

        {
            if (rgba.A < 128)
            {
                CMPRBlock block = new CMPRBlock();
                block._root0._data = 0;
                block._root1._data = 0;
                block._lookup = 0xFFFFFFFF;
                return block;
            }
 
            return optimalCompressDXT1(rgba);
        }

Member Data Documentation

◆ OMatch5

readonly byte [,] BrawlLib.Imaging.NVDXT.OMatch5

static

◆ OMatch6

readonly byte [,] BrawlLib.Imaging.NVDXT.OMatch6