Paradox Game Engine  v1.0.0 beta06
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Events Macros Pages
DxtTexLib.cs
Go to the documentation of this file.
1 // Copyright (c) 2014 Silicon Studio Corp. (http://siliconstudio.co.jp)
2 // This file is distributed under GPL v3. See LICENSE.md for details.
3 using System;
4 using System.Collections.Generic;
5 using System.Linq;
6 using System.Text;
7 using System.IO;
8 using System.Runtime.InteropServices;
9 using SiliconStudio.Core.Diagnostics;
10 using SiliconStudio.TextureConverter.DxtWrapper;
11 using SiliconStudio.TextureConverter.Requests;
12 
13 namespace SiliconStudio.TextureConverter.TexLibraries
14 {
15 
16  /// <summary>
17  /// Class containing the needed native Data used by DirectXTex Tool
18  /// </summary>
19  internal class DxtTextureLibraryData : ITextureLibraryData
20  {
21  /// <summary>
22  /// An image helper provided by DirectXTex Tool
23  /// </summary>
24  public ScratchImage Image;
25 
26  /// <summary>
27  /// The metadata
28  /// </summary>
29  public TexMetadata Metadata;
30 
31  /// <summary>
32  /// The sub images (every mipmap, every array members)
33  /// </summary>
34  public Image[] DxtImages;
35  }
36 
37  /// <summary>
38  /// Peforms requests from <see cref="TextureTool" /> using DirectXTex Tool.
39  /// </summary>
40  internal class DxtTexLib : ITexLibrary
41  {
42  private static Logger Log = GlobalLogger.GetLogger("DxtTexLib");
43 
44  /// <summary>
45  /// Initializes a new instance of the <see cref="DxtTexLib"/> class.
46  /// </summary>
47  public DxtTexLib() {}
48 
49  /// <summary>
50  /// Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources. Nothing in this case
51  /// </summary>
52  public void Dispose()
53  {
54  }
55 
56  public void Dispose(TexImage image)
57  {
58  DxtTextureLibraryData libraryData = (DxtTextureLibraryData)image.LibraryData[this];
59 
60  if (libraryData.Image == null && libraryData.DxtImages != null)
61  {
62  ScratchImage img = new ScratchImage();
63  img.InitializeFromImages(libraryData.DxtImages, libraryData.DxtImages.Length);
64  img.Release();
65  }
66  else
67  {
68  libraryData.Image.Dispose();
69  }
70  }
71 
72 
73  public void StartLibrary(TexImage image)
74  {
75  if (image.LibraryData.ContainsKey(this) && ((DxtTextureLibraryData)image.LibraryData[this]).DxtImages[0].pixels.Equals(image.Data)) return;
76 
77  DxtTextureLibraryData libraryData = new DxtTextureLibraryData();
78  image.LibraryData[this] = libraryData;
79 
80  DXGI_FORMAT format = RetrieveNativeFormat(image.Format);
81 
82  libraryData.DxtImages = new Image[image.SubImageArray.Length];
83 
84  for (int i = 0; i < image.SubImageArray.Length; ++i)
85  {
86  libraryData.DxtImages[i] = new Image(image.SubImageArray[i].Width, image.SubImageArray[i].Height, format, image.SubImageArray[i].RowPitch, image.SubImageArray[i].SlicePitch, image.SubImageArray[i].Data);
87  }
88 
89  switch (image.Dimension)
90  {
91  case TexImage.TextureDimension.Texture1D:
92  libraryData.Metadata = new TexMetadata(image.Width, image.Height, image.Depth, image.ArraySize, image.MipmapCount, 0, 0, format, TEX_DIMENSION.TEX_DIMENSION_TEXTURE1D); break;
93  case TexImage.TextureDimension.Texture2D:
94  libraryData.Metadata = new TexMetadata(image.Width, image.Height, image.Depth, image.ArraySize, image.MipmapCount, 0, 0, format, TEX_DIMENSION.TEX_DIMENSION_TEXTURE2D); break;
95  case TexImage.TextureDimension.Texture3D:
96  libraryData.Metadata = new TexMetadata(image.Width, image.Height, image.Depth, image.ArraySize, image.MipmapCount, 0, 0, format, TEX_DIMENSION.TEX_DIMENSION_TEXTURE3D); break;
97  case TexImage.TextureDimension.TextureCube:
98  libraryData.Metadata = new TexMetadata(image.Width, image.Height, image.Depth, image.ArraySize, image.MipmapCount, TEX_MISC_FLAG.TEX_MISC_TEXTURECUBE, 0, format, TEX_DIMENSION.TEX_DIMENSION_TEXTURE2D); break;
99  }
100 
101  libraryData.Image = null;
102 
103  }
104 
105  public void EndLibrary(TexImage image)
106  {
107  if (!image.LibraryData.ContainsKey(this)) return;
108  UpdateImage(image, (DxtTextureLibraryData)image.LibraryData[this]);
109  }
110 
111  public bool CanHandleRequest(TexImage image, IRequest request)
112  {
113  switch (request.Type)
114  {
115  case RequestType.Loading:
116  LoadingRequest loader = (LoadingRequest)request;
117  return loader.Mode==LoadingRequest.LoadingMode.FilePath && Path.GetExtension(loader.FilePath).Equals(".dds");
118 
119  case RequestType.Compressing:
120  CompressingRequest compress = (CompressingRequest)request;
121  return SupportFormat(compress.Format) && SupportFormat(image.Format);
122 
123  case RequestType.Export:
124  return SupportFormat(image.Format) && Path.GetExtension(((ExportRequest)request).FilePath).Equals(".dds");
125 
126  case RequestType.Rescaling:
127  RescalingRequest rescale = (RescalingRequest)request;
128  return rescale.Filter == Filter.Rescaling.Box || rescale.Filter == Filter.Rescaling.Bicubic || rescale.Filter == Filter.Rescaling.Bicubic || rescale.Filter == Filter.Rescaling.Nearest;
129 
130  case RequestType.Decompressing:
131  return SupportFormat(image.Format);
132 
133  case RequestType.PreMultiplyAlpha:
134  case RequestType.MipMapsGeneration:
135  case RequestType.NormalMapGeneration:
136  return true;
137 
138  default:
139  return false;
140  }
141  }
142 
143  public void Execute(TexImage image, IRequest request)
144  {
145  DxtTextureLibraryData libraryData = image.LibraryData.ContainsKey(this) ? (DxtTextureLibraryData)image.LibraryData[this] : null;
146 
147  switch (request.Type)
148  {
149  case RequestType.Loading:
150  Load(image, libraryData, (LoadingRequest)request);
151  break;
152  case RequestType.Compressing:
153  Compress(image, libraryData, (CompressingRequest)request);
154  break;
155  case RequestType.Export:
156  Export(image, libraryData, (ExportRequest)request);
157  break;
158  case RequestType.Decompressing:
159  Decompress(image, libraryData);
160  break;
161  case RequestType.MipMapsGeneration:
162  GenerateMipMaps(image, libraryData, (MipMapsGenerationRequest)request);
163  break;
164  case RequestType.Rescaling:
165  Rescale(image, libraryData, (RescalingRequest)request);
166  break;
167  case RequestType.NormalMapGeneration:
168  GenerateNormalMap(image, libraryData, (NormalMapGenerationRequest)request);
169  break;
170  case RequestType.PreMultiplyAlpha:
171  PreMultiplyAlpha(image, libraryData);
172  break;
173  default:
174  Log.Error("DxtTexLib (DirectXTex) can't handle this request: " + request.Type);
175  throw new TextureToolsException("DxtTexLib (DirectXTex) can't handle this request: " + request.Type);
176  }
177  }
178 
179  /// <summary>
180  /// Loads the specified image.
181  /// </summary>
182  /// <param name="image">The image.</param>
183  /// <param name="libraryData">The library data.</param>
184  /// <param name="loader">The loader.</param>
185  /// <exception cref="TexLibraryException">Loading dds file failed</exception>
186  private void Load(TexImage image, DxtTextureLibraryData libraryData, LoadingRequest loader)
187  {
188  Log.Info("Loading " + loader.FilePath + " ...");
189 
190  libraryData = new DxtTextureLibraryData();
191  image.LibraryData[this] = libraryData;
192 
193  libraryData.Image = new ScratchImage();
194  libraryData.Metadata = new TexMetadata();
195  HRESULT hr = Utilities.LoadDDSFile(loader.FilePath, DDS_FLAGS.DDS_FLAGS_NONE, out libraryData.Metadata, libraryData.Image);
196 
197  if (hr != HRESULT.S_OK)
198  {
199  Log.Error("Loading dds file " + loader.FilePath + " failed: " + hr);
200  throw new TextureToolsException("Loading dds file " + loader.FilePath + " failed: " + hr);
201  }
202 
203  libraryData.DxtImages = libraryData.Image.GetImages();
204 
205  image.DisposingLibrary = this;
206 
207  if (libraryData.Metadata.miscFlags == TEX_MISC_FLAG.TEX_MISC_TEXTURECUBE)
208  {
209  image.Dimension = TexImage.TextureDimension.TextureCube;
210  }
211  else
212  {
213  switch (libraryData.Metadata.dimension)
214  {
215  case TEX_DIMENSION.TEX_DIMENSION_TEXTURE1D:
216  image.Dimension = TexImage.TextureDimension.Texture1D; break;
217  case TEX_DIMENSION.TEX_DIMENSION_TEXTURE2D:
218  image.Dimension = TexImage.TextureDimension.Texture2D; break;
219  case TEX_DIMENSION.TEX_DIMENSION_TEXTURE3D:
220  image.Dimension = TexImage.TextureDimension.Texture3D; break;
221  }
222  }
223 
224  UpdateImage(image, libraryData);
225  }
226 
227 
228  /// <summary>
229  /// Compresses the specified image.
230  /// </summary>
231  /// <param name="image">The image.</param>
232  /// <param name="libraryData">The library data.</param>
233  /// <param name="request">The request.</param>
234  /// <exception cref="TextureToolsException">Compression failed</exception>
235  private void Compress(TexImage image, DxtTextureLibraryData libraryData, CompressingRequest request)
236  {
237  Log.Info("Converting/Compressing with " + request.Format + " ...");
238 
239  if(libraryData.DxtImages == null || libraryData.DxtImages.Length == 0)
240  return;
241 
242  ScratchImage scratchImage = new ScratchImage();
243 
244  HRESULT hr;
245  if (Tools.IsCompressed(request.Format))
246  {
247  var topImage = libraryData.DxtImages[0];
248  if (topImage.width % 4 != 0 || topImage.height % 4 != 0)
249  throw new TextureToolsException(string.Format("The provided texture cannot be compressed into format '{0}' " +
250  "because its top resolution ({1}-{2}) is not a multiple of 4.", request.Format, topImage.width, topImage.height));
251 
252  hr = Utilities.Compress(libraryData.DxtImages, libraryData.DxtImages.Length, ref libraryData.Metadata,
253  RetrieveNativeFormat(request.Format), TEX_COMPRESS_FLAGS.TEX_COMPRESS_DEFAULT, 0.5f, scratchImage);
254  }
255  else
256  {
257  hr = Utilities.Convert(libraryData.DxtImages, libraryData.DxtImages.Length, ref libraryData.Metadata,
258  RetrieveNativeFormat(request.Format), TEX_FILTER_FLAGS.TEX_FILTER_DEFAULT, 0.5f, scratchImage);
259  }
260 
261 
262  if (hr != HRESULT.S_OK)
263  {
264  Log.Error("Compression failed: " + hr);
265  throw new TextureToolsException("Compression failed: " + hr);
266  }
267 
268  if (image.DisposingLibrary != null) image.DisposingLibrary.Dispose(image);
269 
270  // Updating attributes
271  libraryData.Image = scratchImage;
272  libraryData.DxtImages = libraryData.Image.GetImages();
273  libraryData.Metadata = libraryData.Image.metadata;
274  image.DisposingLibrary = this;
275 
276  UpdateImage(image, libraryData);
277  }
278 
279 
280  /// <summary>
281  /// Rescales the specified image.
282  /// </summary>
283  /// <param name="image">The image.</param>
284  /// <param name="libraryData">The library data.</param>
285  /// <param name="request">The request.</param>
286  /// <exception cref="TexLibraryException">Rescaling failed</exception>
287  private void Rescale(TexImage image, DxtTextureLibraryData libraryData, RescalingRequest request)
288  {
289  int width = request.ComputeWidth(image);
290  int height = request.ComputeHeight(image);
291 
292  Log.Info("Rescaling to " + width + "x" + height + " ...");
293 
294  TEX_FILTER_FLAGS filter;
295  switch(request.Filter)
296  {
297  case Filter.Rescaling.Bilinear:
298  filter = TEX_FILTER_FLAGS.TEX_FILTER_LINEAR;
299  break;
300  case Filter.Rescaling.Bicubic:
301  filter = TEX_FILTER_FLAGS.TEX_FILTER_CUBIC;
302  break;
303  case Filter.Rescaling.Box:
304  filter = TEX_FILTER_FLAGS.TEX_FILTER_FANT;
305  break;
306  case Filter.Rescaling.Nearest:
307  filter = TEX_FILTER_FLAGS.TEX_FILTER_POINT;
308  break;
309  default:
310  filter = TEX_FILTER_FLAGS.TEX_FILTER_FANT;
311  break;
312  }
313 
314  ScratchImage scratchImage = new ScratchImage();
315  HRESULT hr = Utilities.Resize(libraryData.DxtImages, libraryData.DxtImages.Length, ref libraryData.Metadata, width, height, filter, scratchImage);
316 
317  if (hr != HRESULT.S_OK)
318  {
319  Log.Error("Rescaling failed: " + hr);
320  throw new TextureToolsException("Rescaling failed: " + hr);
321  }
322 
323  // Freeing Memory
324  if (image.DisposingLibrary != null) image.DisposingLibrary.Dispose(image);
325 
326  // Updating image data
327  image.Rescale(width, height);
328 
329  libraryData.Image = scratchImage;
330  libraryData.DxtImages = libraryData.Image.GetImages();
331  libraryData.Metadata = libraryData.Image.metadata;
332  image.DisposingLibrary = this;
333 
334  UpdateImage(image, libraryData);
335  }
336 
337 
338  /// <summary>
339  /// Decompresses the specified image.
340  /// </summary>
341  /// <param name="image">The image.</param>
342  /// <param name="libraryData">The library data.</param>
343  /// <exception cref="TexLibraryException">Decompression failed</exception>
344  private void Decompress(TexImage image, DxtTextureLibraryData libraryData)
345  {
346  Log.Info("Decompressing texture ...");
347  ScratchImage scratchImage = new ScratchImage();
348  HRESULT hr = Utilities.Decompress(libraryData.DxtImages, libraryData.DxtImages.Length, ref libraryData.Metadata, DXGI_FORMAT.DXGI_FORMAT_R8G8B8A8_UNORM, scratchImage);
349 
350  if (hr != HRESULT.S_OK)
351  {
352  Log.Error("Decompression failed: " + hr);
353  throw new TextureToolsException("Decompression failed: " + hr);
354  }
355 
356  // Freeing Memory
357  if (image.DisposingLibrary != null) image.DisposingLibrary.Dispose(image);
358 
359  libraryData.Image = scratchImage;
360  libraryData.DxtImages = libraryData.Image.GetImages();
361  libraryData.Metadata = libraryData.Image.metadata;
362  image.DisposingLibrary = this;
363 
364  UpdateImage(image, libraryData);
365  }
366 
367 
368  /// <summary>
369  /// Generates the mip maps.
370  /// </summary>
371  /// <param name="image">The image.</param>
372  /// <param name="libraryData">The library data.</param>
373  /// <param name="request">The request.</param>
374  /// <exception cref="TexLibraryException">
375  /// Not implemented !
376  /// or
377  /// Mipmaps generation failed
378  /// </exception>
379  private void GenerateMipMaps(TexImage image, DxtTextureLibraryData libraryData, MipMapsGenerationRequest request)
380  {
381  Log.Info("Generating Mipmaps ... ");
382 
383  var filter = TEX_FILTER_FLAGS.TEX_FILTER_DEFAULT;
384  switch (request.Filter)
385  {
386  case Filter.MipMapGeneration.Nearest:
387  filter |= TEX_FILTER_FLAGS.TEX_FILTER_POINT;
388  break;
389  case Filter.MipMapGeneration.Linear:
390  filter |= TEX_FILTER_FLAGS.TEX_FILTER_LINEAR;
391  break;
392  case Filter.MipMapGeneration.Cubic:
393  filter |= TEX_FILTER_FLAGS.TEX_FILTER_CUBIC;
394  break;
395  case Filter.MipMapGeneration.Box:
396  filter |= TEX_FILTER_FLAGS.TEX_FILTER_FANT;
397  break;
398  default:
399  filter |= TEX_FILTER_FLAGS.TEX_FILTER_FANT;
400  break;
401  }
402 
403  HRESULT hr;
404  var scratchImage = new ScratchImage();
405  if (libraryData.Metadata.dimension == TEX_DIMENSION.TEX_DIMENSION_TEXTURE3D)
406  {
407  Log.Info("Only the box and nearest(point) filters are supported for generating Mipmaps with 3D texture.");
408  if ((filter & TEX_FILTER_FLAGS.TEX_FILTER_FANT) == 0 && (filter & TEX_FILTER_FLAGS.TEX_FILTER_POINT) == 0)
409  {
410  filter = (TEX_FILTER_FLAGS)((int)filter & 0xf00000);
411  filter |= TEX_FILTER_FLAGS.TEX_FILTER_FANT;
412  }
413  hr = Utilities.GenerateMipMaps3D(libraryData.DxtImages, libraryData.DxtImages.Length, ref libraryData.Metadata, filter, 0, scratchImage);
414  }
415  else
416  {
417  hr = Utilities.GenerateMipMaps(libraryData.DxtImages, libraryData.DxtImages.Length, ref libraryData.Metadata, filter, 0, scratchImage);
418  }
419 
420  if (hr != HRESULT.S_OK)
421  {
422  Log.Error("Mipmaps generation failed: " + hr);
423  throw new TextureToolsException("Mipmaps generation failed: " + hr);
424  }
425 
426  // Freeing Memory
427  if (image.DisposingLibrary != null) image.DisposingLibrary.Dispose(image);
428 
429  libraryData.Image = scratchImage;
430  libraryData.Metadata = libraryData.Image.metadata;
431  libraryData.DxtImages = libraryData.Image.GetImages();
432  image.DisposingLibrary = this;
433 
434  UpdateImage(image, libraryData);
435  }
436 
437 
438  /// <summary>
439  /// Exports the specified image.
440  /// </summary>
441  /// <param name="image">The image.</param>
442  /// <param name="libraryData">The library data.</param>
443  /// <param name="request">The request.</param>
444  /// <exception cref="TexLibraryException">
445  /// Exporting texture failed
446  /// </exception>
447  private void Export(TexImage image, DxtTextureLibraryData libraryData, ExportRequest request)
448  {
449  Log.Info("Exporting to " + request.FilePath + " ...");
450 
451  if (request.MinimumMipMapSize > 1 && request.MinimumMipMapSize <= libraryData.Metadata.width && request.MinimumMipMapSize <= libraryData.Metadata.height) // if a mimimun mipmap size was requested
452  {
453  TexMetadata metadata = libraryData.Metadata;
454  Image[] dxtImages;
455 
456  if (image.Dimension == TexImage.TextureDimension.Texture3D)
457  {
458 
459  int newMipMapCount = 0; // the new mipmap count
460  int ct = 0; // ct will contain the number of SubImages per array element that we need to keep
461  int curDepth = image.Depth << 1;
462  for (int i = 0; i < image.MipmapCount; ++i)
463  {
464  curDepth = curDepth > 1 ? curDepth >>= 1 : curDepth;
465 
466  if (libraryData.DxtImages[ct].width <= request.MinimumMipMapSize || libraryData.DxtImages[ct].height <= request.MinimumMipMapSize)
467  {
468  ct += curDepth;
469  ++newMipMapCount;
470  break;
471  }
472  ++newMipMapCount;
473  ct += curDepth;
474  }
475 
476  int SubImagePerArrayElement = image.SubImageArray.Length / image.ArraySize; // number of SubImage in each texture array element.
477 
478  // Initializing library native data according to the new mipmap level
479  metadata.mipLevels = newMipMapCount;
480  dxtImages = new Image[metadata.arraySize * ct];
481 
482  int ct2 = 0;
483  for (int i = 0; i < image.ArraySize; ++i)
484  {
485  for (int j = 0; j < ct; ++j)
486  {
487  dxtImages[ct2] = libraryData.DxtImages[j + i * SubImagePerArrayElement];
488  ++ct2;
489  }
490  }
491  }
492  else
493  {
494  int newMipMapCount = libraryData.Metadata.mipLevels;
495  for (int i = libraryData.Metadata.mipLevels - 1; i > 0; --i) // looking for the mipmap level corresponding to the minimum size requeted.
496  {
497  if (libraryData.DxtImages[i].width >= request.MinimumMipMapSize || libraryData.DxtImages[i].height >= request.MinimumMipMapSize)
498  {
499  break;
500  }
501  --newMipMapCount;
502  }
503 
504  // Initializing library native data according to the new mipmap level
505  metadata.mipLevels = newMipMapCount;
506  dxtImages = new Image[metadata.arraySize * newMipMapCount];
507 
508  // Assigning the right sub images for the texture to be exported (no need for memory to be adjacent)
509  int gap = libraryData.Metadata.mipLevels - newMipMapCount;
510  int j = 0;
511  for (int i = 0; i < dxtImages.Length; ++i)
512  {
513  if (i == newMipMapCount || (i > newMipMapCount && i%newMipMapCount == 0)) j += gap;
514  dxtImages[i] = libraryData.DxtImages[j];
515  ++j;
516  }
517  }
518 
519  HRESULT hr = Utilities.SaveToDDSFile(dxtImages, dxtImages.Length, ref metadata, DDS_FLAGS.DDS_FLAGS_NONE, request.FilePath);
520 
521  if (hr != HRESULT.S_OK)
522  {
523  Log.Error("Exporting texture failed: " + hr);
524  throw new TextureToolsException("Exporting texture failed: " + hr);
525  }
526  }
527  else
528  {
529  HRESULT hr = Utilities.SaveToDDSFile(libraryData.DxtImages, libraryData.DxtImages.Length, ref libraryData.Metadata, DDS_FLAGS.DDS_FLAGS_NONE, request.FilePath);
530 
531  if (hr != HRESULT.S_OK)
532  {
533  Log.Error("Exporting texture failed: " + hr);
534  throw new TextureToolsException("Exporting texture failed: " + hr);
535  }
536  }
537 
538  image.Save(request.FilePath);
539  }
540 
541 
542  /// <summary>
543  /// Generates the normal map.
544  /// </summary>
545  /// <param name="image">The image.</param>
546  /// <param name="libraryData">The library data.</param>
547  /// <param name="request">The request.</param>
548  /// <exception cref="TexLibraryException">Failed to generate the normal map</exception>
549  public void GenerateNormalMap(TexImage image, DxtTextureLibraryData libraryData, NormalMapGenerationRequest request)
550  {
551  Log.Info("Generating Normal Map ... ");
552 
553  ScratchImage scratchImage = new ScratchImage();
554 
555  HRESULT hr = Utilities.ComputeNormalMap(libraryData.DxtImages, libraryData.DxtImages.Length, ref libraryData.Metadata, CNMAP_FLAGS.CNMAP_CHANNEL_RED, request.Amplitude, DXGI_FORMAT.DXGI_FORMAT_R8G8B8A8_UNORM, scratchImage);
556 
557  if (hr != HRESULT.S_OK)
558  {
559  Log.Error("Failed to generate the normal map : " + hr);
560  throw new TextureToolsException("Failed to generate the normal map : " + hr);
561  }
562 
563  // Creating new TexImage with the normal map data.
564  request.NormalMap = new TexImage();
565  DxtTextureLibraryData normalMapLibraryData = new DxtTextureLibraryData();
566  request.NormalMap.LibraryData[this] = normalMapLibraryData;
567  normalMapLibraryData.DxtImages = scratchImage.GetImages();
568  normalMapLibraryData.Metadata = scratchImage.metadata;
569  normalMapLibraryData.Image = scratchImage;
570 
571  UpdateImage(request.NormalMap, normalMapLibraryData);
572  request.NormalMap.DisposingLibrary = this;
573  }
574 
575 
576  /// <summary>
577  /// Premultiplies the alpha.
578  /// </summary>
579  /// <param name="image">The image.</param>
580  /// <param name="libraryData">The library data.</param>
581  public void PreMultiplyAlpha(TexImage image, DxtTextureLibraryData libraryData)
582  {
583  Log.Info("Premultiplying alpha ... ");
584 
585  ScratchImage scratchImage = new ScratchImage();
586 
587  HRESULT hr = Utilities.PremultiplyAlpha(libraryData.DxtImages, libraryData.DxtImages.Length, ref libraryData.Metadata, TEX_PREMULTIPLY_ALPHA_FLAGS.TEX_PMALPHA_DEFAULT, scratchImage);
588 
589  if (hr != HRESULT.S_OK)
590  {
591  Log.Error("Failed to premultiply the alpha : " + hr);
592  throw new TextureToolsException("Failed to premultiply the alpha : " + hr);
593  }
594 
595  // Freeing Memory
596  if (image.DisposingLibrary != null) image.DisposingLibrary.Dispose(image);
597 
598  libraryData.Image = scratchImage;
599  libraryData.Metadata = libraryData.Image.metadata;
600  libraryData.DxtImages = libraryData.Image.GetImages();
601  image.DisposingLibrary = this;
602 
603  UpdateImage(image, libraryData);
604  }
605 
606 
607  /// <summary>
608  /// Retrieves the native format from <see cref="SiliconStudio.Paradox.Graphics.PixelFormat"/>.
609  /// </summary>
610  /// <param name="format">The format.</param>
611  /// <returns>The corresponding <see cref="DXGI_FORMAT"/></returns>
612  private DXGI_FORMAT RetrieveNativeFormat(SiliconStudio.Paradox.Graphics.PixelFormat format)
613  {
614  return (DXGI_FORMAT)format;
615  }
616 
617 
618  public bool SupportBGRAOrder()
619  {
620  return true;
621  }
622 
623 
624  /// <summary>
625  /// Updates the <see cref="TexImage"/> image with the native library data.
626  /// </summary>
627  /// <param name="image">The image.</param>
628  /// <param name="libraryData">The library data.</param>
629  private void UpdateImage(TexImage image, DxtTextureLibraryData libraryData)
630  {
631  int dataSize = 0;
632 
633  image.SubImageArray = new TexImage.SubImage[libraryData.DxtImages.Length];
634  for (int i = 0; i < libraryData.DxtImages.Length; ++i)
635  {
636  image.SubImageArray[i] = new TexImage.SubImage();
637  image.SubImageArray[i].Data = libraryData.DxtImages[i].pixels;
638  image.SubImageArray[i].DataSize = libraryData.DxtImages[i].slicePitch;
639  image.SubImageArray[i].Width = libraryData.DxtImages[i].width;
640  image.SubImageArray[i].Height = libraryData.DxtImages[i].height;
641  image.SubImageArray[i].RowPitch = libraryData.DxtImages[i].rowPitch;
642  image.SubImageArray[i].SlicePitch = libraryData.DxtImages[i].slicePitch;
643  dataSize += image.SubImageArray[i].SlicePitch;
644  }
645 
646  image.Data = libraryData.DxtImages[0].pixels;
647  image.DataSize = dataSize;
648  image.Width = libraryData.Metadata.width;
649  image.Height = libraryData.Metadata.height;
650  image.Depth = libraryData.Metadata.depth;
651  image.RowPitch = libraryData.DxtImages[0].rowPitch;
652  image.Format = (SiliconStudio.Paradox.Graphics.PixelFormat) libraryData.Metadata.format;
653  image.MipmapCount = libraryData.Metadata.mipLevels;
654  image.ArraySize = libraryData.Metadata.arraySize;
655  image.SlicePitch = libraryData.DxtImages[0].slicePitch;
656  }
657 
658 
659  /// <summary>
660  /// Determines whether this requested format is supported.
661  /// </summary>
662  /// <param name="format">The format.</param>
663  /// <returns>
664  /// <c>true</c> if the formats is supported; otherwise, <c>false</c>.
665  /// </returns>
666  private bool SupportFormat(SiliconStudio.Paradox.Graphics.PixelFormat format)
667  {
668  return ((int) (format) >= 1 && (int) (format) <= 115);
669  }
670  }
671 }
DirectX::GenerateMipMaps
HRESULT GenerateMipMaps(_In_ const Image &baseImage, _In_ DWORD filter, _In_ size_t levels, _Inout_ ScratchImage &mipChain, _In_ bool allow1D=false)
SiliconStudio.Core.Diagnostics.Logger
Base implementation for ILogger.
Definition: Logger.cs:10
DirectX::metadata
_In_ size_t _In_ const TexMetadata & metadata
Definition: DirectXTexP.h:116
DirectX::switch
switch(inFormat)
Definition: DirectXTexDDS.cpp:734
DirectX::Decompress
HRESULT Decompress(_In_ const Image &cImage, _In_ DXGI_FORMAT format, _Out_ ScratchImage &image)
DirectX::format
_In_ size_t _In_ size_t _In_ DXGI_FORMAT format
Definition: DirectXTexP.h:175
SiliconStudio.Core.Diagnostics.Log
Output message to log right away.
SiliconStudio.Paradox.Graphics.PixelFormat
PixelFormat
Defines various types of pixel formats.
Definition: PixelFormat.cs:32
DirectX::Compress
HRESULT Compress(_In_ const Image &srcImage, _In_ DXGI_FORMAT format, _In_ DWORD compress, _In_ float alphaRef, _Out_ ScratchImage &cImage)