Ejemplo n.º 1
0
        public SingleColourFit(ColourSet colours, SquishFlags flags) : base(colours, flags)
        {
            //
            // grab the single colour
            //
            Vec3[] values = colours.Points;

            colour[0] = (byte)ColourBlock.FloatToInt(255.0f * values[0].X, 255);
            colour[1] = (byte)ColourBlock.FloatToInt(255.0f * values[0].Y, 255);
            colour[2] = (byte)ColourBlock.FloatToInt(255.0f * values[0].Z, 255);
            //
            // initialise the best error
            //
            bestError = Int32.MaxValue;
        }
Ejemplo n.º 2
0
 protected override unsafe void Compress4(byte *block)
 {
     //
     // build the table of lookups
     //
     SingleColourLookup[][] lookups =
     {
         SingleColourLookups.Lookup_5_4,
         SingleColourLookups.Lookup_6_4,
         SingleColourLookups.Lookup_5_4
     };
     //
     // find the best end-points and index
     //
     computeEndPoints(lookups);
     //
     // build the block if we win
     //
     if (error < bestError)
     {
         //
         // remap the indices
         //
         byte[] indices = new byte[16];
         //
         // The c++ passed a pointer to index and that pointer was used as an array.  If the RemapIndices method
         // throws an IndexOutOfRangeException, then it was definitely a bug in the c++.
         //
         colours.RemapIndices(new byte[] { index }, indices);
         //
         // save the block
         //
         ColourBlock.WriteColourBlock4(start, end, indices, block);
         //
         // save the error
         //
         bestError = error;
     }
 }
Ejemplo n.º 3
0
        private static unsafe void compressAlphaDxt3(byte *rgba, int mask, byte *block)
        {
            byte *bytes = block;

            //
            // quantise and pack the alpha values pairwise
            //
            for (int i = 0; i < 8; ++i)
            {
                //
                // quantise down to 4 bits
                //
                float alpha1 = rgba[8 * i + 3] * (15.0f / 255.0f);
                float alpha2 = rgba[8 * i + 7] * (15.0f / 255.0f);

                int quant1 = ColourBlock.FloatToInt(alpha1, 15);
                int quant2 = ColourBlock.FloatToInt(alpha2, 15);
                //
                // set alpha to zero where masked
                //
                int bit1 = 1 << (2 * i);
                int bit2 = 1 << (2 * i + 1);

                if ((mask & bit1) == 0)
                {
                    quant1 = 0;
                }
                if ((mask & bit2) == 0)
                {
                    quant2 = 0;
                }
                //
                // pack into the byte
                //
                bytes[i] = (byte)(quant1 | (quant2 << 4));
            }
        }
Ejemplo n.º 4
0
        protected override unsafe void Compress4(byte *block)
        {
            //
            // cache some values
            //
            int count = colours.Count;

            Vec3[] values = colours.Points;
            //
            // create a codebook
            //
            Vec3[] codes = new Vec3[4];

            codes[0] = start;
            codes[1] = end;
            codes[2] = 2.0f / 3.0f * start + 1.0f / 3.0f * end;
            codes[3] = 1.0f / 3.0f * start + 2.0f / 3.0f * end;
            //
            // match each point to the closest code
            //
            byte[] closest = new byte[16];

            float error = 0.0f;

            for (int i = 0; i < count; ++i)
            {
                //
                // find the closest code
                //
                float dist = Single.MaxValue;

                int idx = 0;

                for (int j = 0; j < 4; ++j)
                {
                    float d = Vec3.LengthSquared(metric * (values[i] - codes[j]));

                    if (d < dist)
                    {
                        dist = d;

                        idx = j;
                    }
                }
                //
                // save the index
                //
                closest[i] = (byte)idx;
                //
                // accumulate the error
                //
                error += dist;
            }
            //
            // save this scheme if it wins
            //
            if (error < bestError)
            {
                //
                // remap the indices
                //
                byte[] indices = new byte[16];

                colours.RemapIndices(closest, indices);
                //
                // save the block
                //
                ColourBlock.WriteColourBlock4(start, end, indices, block);
                //
                // save the error
                //
                bestError = error;
            }
        }