UpkManager.Dds.DdsSaveConfig.GetSquishFlags C# (CSharp) Méthode

    internal SquishFlags GetSquishFlags() {
      SquishFlags squishFlags = SquishFlags.Unknown;
      //
      // Translate file format
      //
      switch(FileFormat) {
        case FileFormat.DXT1:
          squishFlags |= SquishFlags.Dxt1;
          break;
        case FileFormat.DXT3:
          squishFlags |= SquishFlags.Dxt3;
          break;
        case FileFormat.DXT5:
          squishFlags |= SquishFlags.Dxt5;
          break;
      }
      //
      // If this isn't a DXT file, then no flags
      //
      if (squishFlags == 0) return squishFlags;
      //
      // Translate compressor type
      //
      switch(CompressorType) {
        case 0:
          squishFlags |= SquishFlags.ColourClusterFit;
          break;
        case 1:
          squishFlags |= SquishFlags.ColourRangeFit;
          break;
        default:
          squishFlags |= SquishFlags.ColourIterativeClusterFit;
          break;
      }
      //
      // Translate error metric
      //
      if (ErrorMetric == 0) squishFlags |= SquishFlags.ColourMetricPerceptual;
      else squishFlags |= SquishFlags.ColourMetricUniform;
      //
      // Now the colour weighting state (only valid for cluster fit)
      //
      if ((CompressorType == 0) && WeightColorByAlpha) squishFlags |= SquishFlags.WeightColourByAlpha;

      return squishFlags;
    }

        public byte[] WriteMipMap(DdsMipMap mipMap, DdsSaveConfig saveConfig)
        {
            byte[] outputData;

            if (saveConfig.FileFormat >= FileFormat.DXT1 && saveConfig.FileFormat <= FileFormat.DXT5)
            {
                outputData = DdsSquish.CompressImage(mipMap.MipMap, mipMap.Width, mipMap.Height, saveConfig.GetSquishFlags(), null);
            }
            else
            {
                int pixelWidth = (int)header.PitchOrLinearSize / Width;

                int mipPitch = pixelWidth * mipMap.Width;

                outputData = new byte[mipPitch * mipMap.Height];

                outputData.Initialize();

                for (int i = 0; i < mipMap.MipMap.Length; i += 4)
                {
                    uint pixelData = 0;

                    byte R = mipMap.MipMap[i + 0];
                    byte G = mipMap.MipMap[i + 1];
                    byte B = mipMap.MipMap[i + 2];
                    byte A = mipMap.MipMap[i + 3];

                    switch (saveConfig.FileFormat)
                    {
                    case FileFormat.A8R8G8B8: {
                        pixelData = ((uint)A << 24) |
                                    ((uint)R << 16) |
                                    ((uint)G << 8) |
                                    ((uint)B << 0);
                        break;
                    }

                    case FileFormat.X8R8G8B8: {
                        pixelData = ((uint)R << 16) |
                                    ((uint)G << 8) |
                                    ((uint)B << 0);
                        break;
                    }

                    case FileFormat.A8B8G8R8: {
                        pixelData = ((uint)A << 24) |
                                    ((uint)B << 16) |
                                    ((uint)G << 8) |
                                    ((uint)R << 0);
                        break;
                    }

                    case FileFormat.X8B8G8R8: {
                        pixelData = ((uint)B << 16) |
                                    ((uint)G << 8) |
                                    ((uint)R << 0);
                        break;
                    }

                    case FileFormat.A1R5G5B5: {
                        pixelData = ((uint)(A != 0 ? 1 : 0) << 15) |
                                    ((uint)(R >> 3) << 10) |
                                    ((uint)(G >> 3) << 5) |
                                    ((uint)(B >> 3) << 0);
                        break;
                    }

                    case FileFormat.A4R4G4B4: {
                        pixelData = ((uint)(A >> 4) << 12) |
                                    ((uint)(R >> 4) << 8) |
                                    ((uint)(G >> 4) << 4) |
                                    ((uint)(B >> 4) << 0);
                        break;
                    }

                    case FileFormat.R8G8B8: {
                        pixelData = ((uint)R << 16) |
                                    ((uint)G << 8) |
                                    ((uint)B << 0);
                        break;
                    }

                    case FileFormat.R5G6B5: {
                        pixelData = ((uint)(R >> 3) << 11) |
                                    ((uint)(G >> 2) << 5) |
                                    ((uint)(B >> 3) << 0);
                        break;
                    }

                    case FileFormat.G8: {
                        pixelData = (uint)((R + G + B) / 3.0 + 0.5);

                        break;
                    }
                    }

                    int pixelOffset = i / 4 * pixelWidth;

                    for (int j = 0; j < pixelWidth; j++)
                    {
                        outputData[pixelOffset + j] = (byte)((pixelData >> (8 * j)) & 0xff);
                    }
                }
            }

            return(outputData);
        }