Beispiel #1
0
        private static byte DecodeRGTCValue(RGTCBlock inBlock, int x, int y, DXTxRGTCSignedness signedness)
        {
            int code = inBlock.Bits[(y * 4) + x];

            byte data0, data1;

            if (signedness == DXTxRGTCSignedness.Unsigned)
            {
                data0 = inBlock.Data0;
                data1 = inBlock.Data1;
            }
            else
            {
                data0 = (byte)(((sbyte)inBlock.Data0) + 128);
                data1 = (byte)(((sbyte)inBlock.Data1) + 128);
            }

            if (data0 > data1)
            {
                switch (code)
                {
                case 0x00: return(data0);

                case 0x01: return(data1);

                case 0x02: return((byte)((6 * data0 + 1 * data1) / 7));

                case 0x03: return((byte)((5 * data0 + 2 * data1) / 7));

                case 0x04: return((byte)((4 * data0 + 3 * data1) / 7));

                case 0x05: return((byte)((3 * data0 + 4 * data1) / 7));

                case 0x06: return((byte)((2 * data0 + 5 * data1) / 7));

                case 0x07: return((byte)((1 * data0 + 6 * data1) / 7));
                }
            }
            else
            {
                switch (code)
                {
                case 0x00: return(data0);

                case 0x01: return(data1);

                case 0x02: return((byte)((4 * data0 + 1 * data1) / 5));

                case 0x03: return((byte)((3 * data0 + 2 * data1) / 5));

                case 0x04: return((byte)((2 * data0 + 3 * data1) / 5));

                case 0x05: return((byte)((1 * data0 + 4 * data1) / 5));

                case 0x06: return(0x00);

                case 0x07: return(0xFF);
                }
            }

            throw new Exception("RGTC value decode exception; this shouldn't happen!");
        }
Beispiel #2
0
        private static byte[] DecodeRGTC2Block(EndianBinaryReader reader, PixelDataFormat inputFormat, DXTxRGTCBlockLayout blockLayout, DXTxRGTCSignedness signedness)
        {
            RGTCBlock inBlockRed   = new RGTCBlock(reader, blockLayout);
            RGTCBlock inBlockGreen = new RGTCBlock(reader, blockLayout);

            byte[] outData = new byte[(4 * 4) * 4];

            for (int y = 0; y < 4; y++)
            {
                for (int x = 0; x < 4; x++)
                {
                    int destOffset = (((y * 4) + x) * 4);
                    outData[destOffset + 0] = DecodeRGTCValue(inBlockRed, x, y, signedness);
                    outData[destOffset + 1] = DecodeRGTCValue(inBlockGreen, x, y, signedness);
                    outData[destOffset + 2] = 0x00;
                    outData[destOffset + 3] = 0xFF;
                }
            }

            return(outData);
        }
Beispiel #3
0
        private static byte[] DecodeDXT3Block(EndianBinaryReader reader, PixelDataFormat inputFormat, DXTxRGTCBlockLayout blockLayout, DXTxRGTCSignedness signedness)
        {
            DXT3Block inBlock = new DXT3Block(reader, blockLayout);

            byte[] outData = DecodeColorBlock(inBlock.Color, false, false);

            ulong alpha = inBlock.Alpha;

            for (int i = 0; i < outData.Length; i += 4)
            {
                outData[i + 3] = (byte)(((alpha & 0xF) << 4) | (alpha & 0xF));
                alpha        >>= 4;
            }

            return(outData);
        }
Beispiel #4
0
        private static byte[] DecodeDXT5Block(EndianBinaryReader reader, PixelDataFormat inputFormat, DXTxRGTCBlockLayout blockLayout, DXTxRGTCSignedness signedness)
        {
            DXT5Block inBlock = new DXT5Block(reader, blockLayout);

            byte[] outData = DecodeColorBlock(inBlock.Color, false, false);

            for (int y = 0; y < 4; y++)
            {
                for (int x = 0; x < 4; x++)
                {
                    byte code       = inBlock.Bits[(y * 4) + x];
                    int  destOffset = (((y * 4) + x) * 4) + 3;

                    if (inBlock.Alpha0 > inBlock.Alpha1)
                    {
                        switch (code)
                        {
                        case 0x00: outData[destOffset] = inBlock.Alpha0; break;

                        case 0x01: outData[destOffset] = inBlock.Alpha1; break;

                        case 0x02: outData[destOffset] = (byte)((6 * inBlock.Alpha0 + 1 * inBlock.Alpha1) / 7); break;

                        case 0x03: outData[destOffset] = (byte)((5 * inBlock.Alpha0 + 2 * inBlock.Alpha1) / 7); break;

                        case 0x04: outData[destOffset] = (byte)((4 * inBlock.Alpha0 + 3 * inBlock.Alpha1) / 7); break;

                        case 0x05: outData[destOffset] = (byte)((3 * inBlock.Alpha0 + 4 * inBlock.Alpha1) / 7); break;

                        case 0x06: outData[destOffset] = (byte)((2 * inBlock.Alpha0 + 5 * inBlock.Alpha1) / 7); break;

                        case 0x07: outData[destOffset] = (byte)((1 * inBlock.Alpha0 + 6 * inBlock.Alpha1) / 7); break;
                        }
                    }
                    else
                    {
                        switch (code)
                        {
                        case 0x00: outData[destOffset] = inBlock.Alpha0; break;

                        case 0x01: outData[destOffset] = inBlock.Alpha1; break;

                        case 0x02: outData[destOffset] = (byte)((4 * inBlock.Alpha0 + 1 * inBlock.Alpha1) / 5); break;

                        case 0x03: outData[destOffset] = (byte)((3 * inBlock.Alpha0 + 2 * inBlock.Alpha1) / 5); break;

                        case 0x04: outData[destOffset] = (byte)((2 * inBlock.Alpha0 + 3 * inBlock.Alpha1) / 5); break;

                        case 0x05: outData[destOffset] = (byte)((1 * inBlock.Alpha0 + 4 * inBlock.Alpha1) / 5); break;

                        case 0x06: outData[destOffset] = 0x00; break;

                        case 0x07: outData[destOffset] = 0xFF; break;
                        }
                    }
                }
            }

            return(outData);
        }
Beispiel #5
0
        private static byte[] DecodeDXT1Block(EndianBinaryReader reader, PixelDataFormat inputFormat, DXTxRGTCBlockLayout blockLayout, DXTxRGTCSignedness signedness)
        {
            DXT1Block inBlock = new DXT1Block(reader, blockLayout);

            return(DecodeColorBlock(inBlock, (inputFormat & PixelDataFormat.MaskChannels) != PixelDataFormat.ChannelsRgb, true));
        }