A game about forced loneliness, made by TACStudios
tacstudios.tngl.sh
1using System;
2using Unity.Collections;
3using UnityEditor.AssetImporters;
4using UnityEngine;
5
6namespace UnityEditor.U2D.Common
7{
8 internal interface ITextureSettings
9 {
10 void FillTextureGenerationSettings(ref TextureGenerationSettings settings);
11 }
12
13
14 [Serializable]
15 internal class TextureSettings : ITextureSettings
16 {
17 [SerializeField]
18 bool m_ColorTexture;
19 [SerializeField]
20 bool m_Readable;
21 [SerializeField]
22 TextureImporterNPOTScale m_NPOTScale;
23 [SerializeField]
24 FilterMode m_FilterMode;
25 [SerializeField]
26 int m_Aniso;
27 [SerializeField]
28 bool m_EnablePostProcessor;
29 [SerializeField]
30 SecondarySpriteTexture[] m_SecondaryTextures;
31 [SerializeField]
32 TextureImporterSwizzle m_SwizzleR = TextureImporterSwizzle.R;
33 [SerializeField]
34 TextureImporterSwizzle m_SwizzleG = TextureImporterSwizzle.G;
35 [SerializeField]
36 TextureImporterSwizzle m_SwizzleB = TextureImporterSwizzle.B;
37 [SerializeField]
38 TextureImporterSwizzle m_SwizzleA = TextureImporterSwizzle.A;
39
40 public TextureSettings()
41 {
42 colorTexture = true;
43 readable = false;
44 npotScale = TextureImporterNPOTScale.None;
45 filterMode = FilterMode.Bilinear;
46 aniso = 1;
47 }
48
49 public TextureSettings(string assetPath, bool enablePostProcessor, bool colorTexture, bool readable, TextureImporterNPOTScale npotScale, FilterMode filterMode, int aniso, bool sourceContainsAlpha, bool sourceWasHDR)
50 {
51 this.assetPath = assetPath;
52 this.enablePostProcessor = enablePostProcessor;
53 this.colorTexture = colorTexture;
54 this.readable = readable;
55 this.npotScale = npotScale;
56 this.filterMode = filterMode;
57 this.aniso = aniso;
58 this.containsAlpha = sourceContainsAlpha;
59 this.hdr = sourceWasHDR;
60 }
61
62 public bool colorTexture { get { return m_ColorTexture; } set { m_ColorTexture = value; } } //sRGBTexture
63 public bool readable { get { return m_Readable; } set { m_Readable = value; } }
64 public TextureImporterNPOTScale npotScale { get { return m_NPOTScale; } set { m_NPOTScale = value; } }
65 public FilterMode filterMode { get { return m_FilterMode; } set { m_FilterMode = value; } }
66 public int aniso
67 {
68 get { return m_Aniso; }
69 set { m_Aniso = value; }
70 }
71 public bool enablePostProcessor
72 {
73 get { return m_EnablePostProcessor; }
74 set { m_EnablePostProcessor = value; }
75 }
76
77 public string assetPath { get; set; }
78 public bool containsAlpha { get; set; }
79 public bool hdr { get; set; }
80 public TextureImporterSwizzle swizzleR { get { return m_SwizzleR; } set { m_SwizzleR = value; } }
81 public TextureImporterSwizzle swizzleG { get { return m_SwizzleG; } set { m_SwizzleG = value; } }
82 public TextureImporterSwizzle swizzleB { get { return m_SwizzleB; } set { m_SwizzleB = value; } }
83 public TextureImporterSwizzle swizzleA { get { return m_SwizzleA; } set { m_SwizzleA = value; } }
84 public SecondarySpriteTexture[] secondaryTextures { get { return m_SecondaryTextures;} set { m_SecondaryTextures = value; } }
85
86 void ITextureSettings.FillTextureGenerationSettings(ref TextureGenerationSettings settings)
87 {
88 settings.textureImporterSettings.sRGBTexture = colorTexture;
89 settings.textureImporterSettings.readable = readable;
90 settings.textureImporterSettings.npotScale = npotScale;
91 settings.textureImporterSettings.filterMode = filterMode;
92 settings.textureImporterSettings.aniso = aniso;
93 settings.assetPath = assetPath;
94 settings.enablePostProcessor = enablePostProcessor;
95 settings.sourceTextureInformation.containsAlpha = containsAlpha;
96 settings.sourceTextureInformation.hdr = hdr;
97 settings.secondarySpriteTextures = secondaryTextures;
98 settings.textureImporterSettings.swizzleR = m_SwizzleR;
99 settings.textureImporterSettings.swizzleG = m_SwizzleG;
100 settings.textureImporterSettings.swizzleB = m_SwizzleB;
101 settings.textureImporterSettings.swizzleA = m_SwizzleA;
102 }
103 }
104
105 [Serializable]
106 internal class TextureSpriteSettings : ITextureSettings
107 {
108 [SerializeField]
109 string m_PackingTag;
110 public string packingTag
111 {
112 get { return m_PackingTag; }
113 set { m_PackingTag = value; }
114 }
115
116 [SerializeField]
117 float m_PixelsPerUnit;
118 public float pixelsPerUnit
119 {
120 get { return m_PixelsPerUnit; }
121 set { m_PixelsPerUnit = value; }
122 }
123
124 [SerializeField]
125 SpriteMeshType m_MeshType;
126 public SpriteMeshType meshType
127 {
128 get { return m_MeshType; }
129 set { m_MeshType = value; }
130 }
131
132 [SerializeField]
133 uint m_ExtrudeEdges;
134 public uint extrudeEdges
135 {
136 get { return m_ExtrudeEdges; }
137 set { m_ExtrudeEdges = value; }
138 }
139
140 public bool qualifyForPacking { get; set; }
141 public SpriteImportData[] spriteSheetData { get; set; }
142
143 public TextureSpriteSettings()
144 {
145 packingTag = "";
146 pixelsPerUnit = 100;
147 meshType = SpriteMeshType.Tight;
148 extrudeEdges = 1;
149 }
150
151 public TextureSpriteSettings(string packingTag, int pixelsPerUnit, SpriteMeshType meshType, uint extrudeEdges, bool qualifyForPacking, SpriteImportData[] spriteSheetData = null)
152 {
153 this.packingTag = packingTag;
154 this.pixelsPerUnit = pixelsPerUnit;
155 this.meshType = meshType;
156 this.extrudeEdges = extrudeEdges;
157 this.qualifyForPacking = qualifyForPacking;
158 this.spriteSheetData = spriteSheetData;
159 }
160
161 void ITextureSettings.FillTextureGenerationSettings(ref TextureGenerationSettings settings)
162 {
163 settings.textureImporterSettings.spritePixelsPerUnit = pixelsPerUnit;
164 settings.textureImporterSettings.spriteMeshType = meshType;
165 settings.textureImporterSettings.spriteExtrude = extrudeEdges;
166 settings.spritePackingTag = packingTag;
167 settings.qualifyForSpritePacking = qualifyForPacking;
168 settings.spriteImportData = spriteSheetData;
169 }
170 }
171
172 [Serializable]
173 internal class TextureWrapSettings : ITextureSettings
174 {
175 [SerializeField]
176 TextureWrapMode m_WrapMode;
177 [SerializeField]
178 TextureWrapMode m_WrapModeU;
179 [SerializeField]
180 TextureWrapMode m_WrapModeV;
181 [SerializeField]
182 TextureWrapMode m_WrapModeW;
183
184 public TextureWrapSettings()
185 {
186 wrapMode = wrapModeU = wrapModeV = wrapModeW = TextureWrapMode.Repeat;
187 }
188
189 public TextureWrapSettings(TextureWrapMode wrapMpde, TextureWrapMode wrapModeU, TextureWrapMode wrapModeV, TextureWrapMode wrapModeW)
190 {
191 this.wrapMode = wrapMode;
192 this.wrapModeU = wrapModeU;
193 this.wrapModeV = wrapModeV;
194 this.wrapModeW = wrapModeW;
195 }
196
197 public TextureWrapMode wrapMode { get { return m_WrapMode; } set { m_WrapMode = value; } }
198 public TextureWrapMode wrapModeU { get { return m_WrapModeU; } set { m_WrapModeU = value; } }
199 public TextureWrapMode wrapModeV { get { return m_WrapModeV; } set { m_WrapModeV = value; } }
200 public TextureWrapMode wrapModeW { get { return m_WrapModeW; } set { m_WrapModeW = value; } }
201
202 void ITextureSettings.FillTextureGenerationSettings(ref TextureGenerationSettings settings)
203 {
204 settings.textureImporterSettings.wrapMode = wrapMode;
205 settings.textureImporterSettings.wrapModeU = wrapModeU;
206 settings.textureImporterSettings.wrapModeV = wrapModeV;
207 settings.textureImporterSettings.wrapModeW = wrapModeW;
208 }
209 }
210
211 [Serializable]
212 internal class TextureAlphaSettings : ITextureSettings
213 {
214 [SerializeField]
215 float m_AlphaTolerance;
216 public float alphaTolerance
217 {
218 get { return m_AlphaTolerance; }
219 set { m_AlphaTolerance = value; }
220 }
221
222 [SerializeField]
223 TextureImporterAlphaSource m_AlphaSource;
224 public TextureImporterAlphaSource alphaSource
225 {
226 get { return m_AlphaSource; }
227 set { m_AlphaSource = value; }
228 }
229
230 public TextureAlphaSettings()
231 {
232 alphaTolerance = 0.5f;
233 alphaSource = TextureImporterAlphaSource.FromInput;
234 }
235
236 public TextureAlphaSettings(TextureImporterAlphaSource alphaSource, float alphaTolerance)
237 {
238 this.alphaTolerance = alphaTolerance;
239 this.alphaSource = alphaSource;
240 }
241
242 void ITextureSettings.FillTextureGenerationSettings(ref TextureGenerationSettings settings)
243 {
244 settings.textureImporterSettings.alphaIsTransparency = alphaSource != TextureImporterAlphaSource.None;
245 settings.textureImporterSettings.alphaSource = alphaSource;
246 settings.textureImporterSettings.alphaTestReferenceValue = alphaTolerance;
247 }
248 }
249
250 [Serializable]
251 internal class TextureMipmapSettings : ITextureSettings
252 {
253 [SerializeField]
254 TextureImporterMipFilter m_Filter;
255 public TextureImporterMipFilter filter
256 {
257 get { return m_Filter; }
258 set { m_Filter = value; }
259 }
260
261 [SerializeField]
262 bool m_BorderMipmap;
263 public bool borderMipmap
264 {
265 get { return m_BorderMipmap; }
266 set { m_BorderMipmap = value; }
267 }
268
269 [SerializeField]
270 bool m_Fadeout;
271 public bool fadeout
272 {
273 get { return m_Fadeout; }
274 set { m_Fadeout = value; }
275 }
276
277 [SerializeField]
278 bool m_PreserveCoverage;
279 public bool preserveCoverage
280 {
281 get { return m_PreserveCoverage; }
282 set { m_PreserveCoverage = value; }
283 }
284
285 [SerializeField]
286 int m_FadeDistanceStart;
287 public int fadeDistanceStart
288 {
289 get { return m_FadeDistanceStart; }
290 set { m_FadeDistanceStart = value; }
291 }
292
293 [SerializeField]
294 int m_FadeDistanceEnd;
295 public int fadeDistanceEnd
296 {
297 get { return m_FadeDistanceEnd; }
298 set { m_FadeDistanceEnd = value; }
299 }
300
301 [SerializeField]
302 bool m_StreamingMipmaps;
303 public bool streamingMipmaps
304 {
305 get { return m_StreamingMipmaps; }
306 set { m_StreamingMipmaps = value; }
307 }
308
309 [SerializeField]
310 int m_StreamingMipmapsPriority;
311 public int streamingMipmapsPriority
312 {
313 get { return m_StreamingMipmapsPriority; }
314 set { m_StreamingMipmapsPriority = value; }
315 }
316
317 public TextureMipmapSettings()
318 {
319 filter = TextureImporterMipFilter.BoxFilter;
320 borderMipmap = false;
321 fadeout = false;
322 preserveCoverage = false;
323 fadeDistanceStart = 1;
324 fadeDistanceEnd = 3;
325 }
326
327 public TextureMipmapSettings(TextureImporterMipFilter filter, bool borderMipmap, bool fadeout, bool preserveCoverage, int fadeDistanceStart, int fadeDistanceEnd, bool streamingMipmaps, int streamingMipmapsPriority)
328 {
329 this.filter = filter;
330 this.borderMipmap = borderMipmap;
331 this.fadeout = fadeout;
332 this.preserveCoverage = preserveCoverage;
333 this.fadeDistanceStart = fadeDistanceStart;
334 this.fadeDistanceEnd = fadeDistanceEnd;
335 this.streamingMipmaps = streamingMipmaps;
336 this.streamingMipmapsPriority = streamingMipmapsPriority;
337 }
338
339 void ITextureSettings.FillTextureGenerationSettings(ref TextureGenerationSettings settings)
340 {
341 settings.textureImporterSettings.mipmapEnabled = true;
342 settings.textureImporterSettings.mipmapFilter = filter;
343 settings.textureImporterSettings.borderMipmap = borderMipmap;
344 settings.textureImporterSettings.fadeOut = fadeout;
345 settings.textureImporterSettings.mipmapFadeDistanceStart = fadeDistanceStart;
346 settings.textureImporterSettings.mipmapFadeDistanceEnd = fadeDistanceEnd;
347 settings.textureImporterSettings.mipMapsPreserveCoverage = preserveCoverage;
348 settings.textureImporterSettings.streamingMipmaps = streamingMipmaps;
349 settings.textureImporterSettings.streamingMipmapsPriority = streamingMipmapsPriority;
350 }
351 }
352
353 [Serializable]
354 internal class TextureNormalSettings : ITextureSettings
355 {
356 [SerializeField]
357 TextureImporterNormalFilter m_Filter;
358 public TextureImporterNormalFilter filter
359 {
360 get { return m_Filter; }
361 set { m_Filter = value; }
362 }
363
364 [SerializeField]
365 bool m_GenerateFromGrayScale;
366 public bool generateFromGrayScale
367 {
368 get { return m_GenerateFromGrayScale; }
369 set { m_GenerateFromGrayScale = value; }
370 }
371
372 [SerializeField]
373 float m_Bumpiness;
374 public float bumpiness
375 {
376 get { return m_Bumpiness; }
377 set { m_Bumpiness = value; }
378 }
379
380 public TextureNormalSettings()
381 {
382 filter = TextureImporterNormalFilter.Standard;
383 generateFromGrayScale = false;
384 bumpiness = 0.25f;
385 }
386
387 public TextureNormalSettings(TextureImporterNormalFilter filter, bool generateFromGrayScale, float bumpiness)
388 {
389 this.filter = filter;
390 this.generateFromGrayScale = generateFromGrayScale;
391 this.bumpiness = bumpiness;
392 }
393
394 void ITextureSettings.FillTextureGenerationSettings(ref TextureGenerationSettings settings)
395 {
396 settings.textureImporterSettings.normalMapFilter = filter;
397 settings.textureImporterSettings.convertToNormalMap = generateFromGrayScale;
398 settings.textureImporterSettings.heightmapScale = bumpiness;
399 }
400 }
401
402 // If this is provided, textureType will be cubemap
403 [Serializable]
404 internal class TextureCubemapSettings : ITextureSettings
405 {
406 [SerializeField]
407 TextureImporterCubemapConvolution m_Convolution;
408 public TextureImporterCubemapConvolution convolution
409 {
410 get { return m_Convolution; }
411 set { m_Convolution = value; }
412 }
413
414 [SerializeField]
415 TextureImporterGenerateCubemap m_Mode;
416 public TextureImporterGenerateCubemap mode
417 {
418 get { return m_Mode; }
419 set { m_Mode = value; }
420 }
421
422 [SerializeField]
423 bool m_Seamless;
424 public bool seamless
425 {
426 get { return m_Seamless; }
427 set { m_Seamless = value; }
428 }
429 public TextureCubemapSettings()
430 {
431 convolution = TextureImporterCubemapConvolution.None;
432 mode = TextureImporterGenerateCubemap.AutoCubemap;
433 seamless = false;
434 }
435
436 public TextureCubemapSettings(TextureImporterCubemapConvolution convolution, TextureImporterGenerateCubemap mode, bool seamless)
437 {
438 this.convolution = convolution;
439 this.mode = mode;
440 this.seamless = seamless;
441 }
442
443 void ITextureSettings.FillTextureGenerationSettings(ref TextureGenerationSettings settings)
444 {
445 settings.textureImporterSettings.textureShape = TextureImporterShape.TextureCube;
446 settings.textureImporterSettings.cubemapConvolution = convolution;
447 settings.textureImporterSettings.generateCubemap = mode;
448 settings.textureImporterSettings.seamlessCubemap = seamless;
449 }
450 }
451
452 internal static class TextureGeneratorHelper
453 {
454 public static TextureGenerationOutput GenerateTextureSprite(NativeArray<Color32> buffer, int bufferWidth, int bufferHeight, TextureSettings settings, TextureImporterPlatformSettings platformSettings,
455 TextureSpriteSettings spriteSettings, TextureAlphaSettings alphaSettings = null, TextureMipmapSettings mipmapSettings = null, TextureWrapSettings wrapSettings = null)
456 {
457 if (alphaSettings == null)
458 alphaSettings = new TextureAlphaSettings(TextureImporterAlphaSource.FromInput, 0.5f);
459 if (wrapSettings == null)
460 wrapSettings = new TextureWrapSettings(TextureWrapMode.Clamp, TextureWrapMode.Clamp, TextureWrapMode.Clamp, TextureWrapMode.Clamp);
461
462 return GenerateTexture(buffer, bufferWidth, bufferHeight, TextureImporterType.Sprite, platformSettings, settings, spriteSettings, alphaSettings, mipmapSettings, wrapSettings);
463 }
464
465 public static TextureGenerationOutput GenerateLightmap(NativeArray<Color32> buffer, int bufferWidth, int bufferHeight, TextureSettings settings, TextureImporterPlatformSettings platformSettings,
466 TextureMipmapSettings mipmapSettings = null, TextureWrapSettings wrapSettings = null)
467 {
468 settings.colorTexture = true;
469 return GenerateTexture(buffer, bufferWidth, bufferHeight, TextureImporterType.Lightmap, platformSettings, settings, mipmapSettings, wrapSettings);
470 }
471
472 public static TextureGenerationOutput GenerateCookie(NativeArray<Color32> buffer, int bufferWidth, int bufferHeight, TextureSettings settings, TextureImporterPlatformSettings platformSettings,
473 TextureAlphaSettings alphaSettings = null, TextureMipmapSettings mipmapSettings = null, TextureCubemapSettings cubemapSettings = null, TextureWrapSettings wrapSettings = null)
474 {
475 return GenerateTexture(buffer, bufferWidth, bufferHeight, TextureImporterType.Cookie, platformSettings, settings, alphaSettings, mipmapSettings, cubemapSettings, wrapSettings);
476 }
477
478 public static TextureGenerationOutput GenerateNormalMap(NativeArray<Color32> buffer, int bufferWidth, int bufferHeight, TextureSettings settings, TextureImporterPlatformSettings platformSettings,
479 TextureNormalSettings normalSettings, TextureMipmapSettings mipmapSettings = null, TextureCubemapSettings cubemapSettings = null, TextureWrapSettings wrapSettings = null)
480 {
481 settings.colorTexture = false;
482 return GenerateTexture(buffer, bufferWidth, bufferHeight, TextureImporterType.NormalMap, platformSettings, settings, normalSettings, mipmapSettings, cubemapSettings, wrapSettings);
483 }
484
485 public static TextureGenerationOutput GenerateTextureGUI(NativeArray<Color32> buffer, int bufferWidth, int bufferHeight, TextureSettings settings, TextureImporterPlatformSettings platformSettings,
486 TextureAlphaSettings alphaSettings = null, TextureMipmapSettings mipmapSettings = null, TextureWrapSettings wrapSettings = null)
487 {
488 settings.colorTexture = false;
489 if (wrapSettings == null)
490 wrapSettings = new TextureWrapSettings(TextureWrapMode.Clamp, TextureWrapMode.Clamp, TextureWrapMode.Clamp, TextureWrapMode.Clamp);
491 return GenerateTexture(buffer, bufferWidth, bufferHeight, TextureImporterType.GUI, platformSettings, settings, alphaSettings, mipmapSettings, wrapSettings);
492 }
493
494 public static TextureGenerationOutput GenerateTextureSingleChannel(NativeArray<Color32> buffer, int bufferWidth, int bufferHeight, TextureSettings settings, TextureImporterPlatformSettings platformSettings,
495 TextureAlphaSettings alphaSettings = null, TextureMipmapSettings mipmapSettings = null, TextureCubemapSettings cubemapSettings = null, TextureWrapSettings wrapSettings = null)
496 {
497 settings.colorTexture = false;
498 return GenerateTexture(buffer, bufferWidth, bufferHeight, TextureImporterType.SingleChannel, platformSettings, settings, alphaSettings, mipmapSettings, cubemapSettings, wrapSettings);
499 }
500
501 public static TextureGenerationOutput GenerateTextureCursor(NativeArray<Color32> buffer, int bufferWidth, int bufferHeight, TextureSettings settings, TextureImporterPlatformSettings platformSettings,
502 TextureAlphaSettings alphaSettings = null, TextureMipmapSettings mipmapSettings = null, TextureWrapSettings wrapSettings = null)
503 {
504 if (alphaSettings == null)
505 alphaSettings = new TextureAlphaSettings(TextureImporterAlphaSource.FromInput, 0.5f);
506 if (wrapSettings == null)
507 wrapSettings = new TextureWrapSettings(TextureWrapMode.Clamp, TextureWrapMode.Clamp, TextureWrapMode.Clamp, TextureWrapMode.Clamp);
508
509 return GenerateTexture(buffer, bufferWidth, bufferHeight, TextureImporterType.Cursor, platformSettings, settings, alphaSettings, mipmapSettings, wrapSettings);
510 }
511
512 public static TextureGenerationOutput GenerateTextureDefault(NativeArray<Color32> buffer, int bufferWidth, int bufferHeight, TextureSettings settings, TextureImporterPlatformSettings platformSettings,
513 TextureAlphaSettings alphaSettings = null, TextureMipmapSettings mipmapSettings = null, TextureCubemapSettings cubemapSettings = null, TextureWrapSettings wrapSettings = null)
514 {
515 if (mipmapSettings == null)
516 mipmapSettings = new TextureMipmapSettings(TextureImporterMipFilter.BoxFilter, false, false, false, 1, 3, false, 0);
517
518 return GenerateTexture(buffer, bufferWidth, bufferHeight, TextureImporterType.Default, platformSettings, settings, alphaSettings, mipmapSettings, cubemapSettings, wrapSettings);
519 }
520
521 static TextureGenerationOutput GenerateTexture(NativeArray<Color32> imageBuffer, int imageBufferWidth, int imageBufferHeight, TextureImporterType type, TextureImporterPlatformSettings platformSettings, params ITextureSettings[] otherSettings)
522 {
523 var textureGenerationSettings = new TextureGenerationSettings();
524 textureGenerationSettings.platformSettings = platformSettings;
525
526 textureGenerationSettings.sourceTextureInformation = new SourceTextureInformation();
527 textureGenerationSettings.sourceTextureInformation.height = imageBufferHeight;
528 textureGenerationSettings.sourceTextureInformation.width = imageBufferWidth;
529
530 textureGenerationSettings.textureImporterSettings = new TextureImporterSettings();
531 textureGenerationSettings.textureImporterSettings.textureType = type;
532 textureGenerationSettings.textureImporterSettings.textureShape = TextureImporterShape.Texture2D;
533
534 textureGenerationSettings.textureImporterSettings.alphaIsTransparency = false;
535 textureGenerationSettings.textureImporterSettings.convertToNormalMap = false;
536 textureGenerationSettings.textureImporterSettings.mipmapEnabled = false;
537 textureGenerationSettings.textureImporterSettings.sRGBTexture = true;
538 textureGenerationSettings.textureImporterSettings.readable = false;
539 textureGenerationSettings.textureImporterSettings.fadeOut = false;
540 textureGenerationSettings.textureImporterSettings.wrapMode = TextureWrapMode.Repeat;
541 textureGenerationSettings.textureImporterSettings.wrapModeU = TextureWrapMode.Repeat;
542 textureGenerationSettings.textureImporterSettings.wrapModeV = TextureWrapMode.Repeat;
543 textureGenerationSettings.textureImporterSettings.wrapModeW = TextureWrapMode.Repeat;
544 textureGenerationSettings.textureImporterSettings.swizzleR = TextureImporterSwizzle.R;
545 textureGenerationSettings.textureImporterSettings.swizzleG = TextureImporterSwizzle.G;
546 textureGenerationSettings.textureImporterSettings.swizzleB = TextureImporterSwizzle.B;
547 textureGenerationSettings.textureImporterSettings.swizzleA = TextureImporterSwizzle.A;
548
549
550 foreach (var otherSetting in otherSettings)
551 {
552 if (otherSetting != null)
553 otherSetting.FillTextureGenerationSettings(ref textureGenerationSettings);
554 }
555 return TextureGenerator.GenerateTexture(textureGenerationSettings, imageBuffer);
556 }
557
558 static public TextureSettings ExtractTextureSettings(this TextureImporterSettings tis)
559 {
560 var ts = new TextureSettings();
561 ts.colorTexture = tis.sRGBTexture;
562 ts.readable = tis.readable;
563 ts.npotScale = tis.npotScale;
564 ts.filterMode = tis.filterMode;
565 ts.aniso = tis.aniso;
566 ts.swizzleR = tis.swizzleR;
567 ts.swizzleG = tis.swizzleG;
568 ts.swizzleB = tis.swizzleB;
569 ts.swizzleA = tis.swizzleA;
570 return ts;
571 }
572
573 static public TextureSpriteSettings ExtractTextureSpriteSettings(this TextureImporterSettings tis)
574 {
575 var ts = new TextureSpriteSettings();
576 ts.pixelsPerUnit = tis.spritePixelsPerUnit;
577 ts.meshType = tis.spriteMeshType;
578 ts.extrudeEdges = tis.spriteExtrude;
579 return ts;
580 }
581
582 static public TextureWrapSettings ExtractTextureWrapSettings(this TextureImporterSettings tis)
583 {
584 var ts = new TextureWrapSettings();
585 ts.wrapMode = tis.wrapMode;
586 ts.wrapModeU = tis.wrapModeU;
587 ts.wrapModeV = tis.wrapModeV;
588 ts.wrapModeW = tis.wrapModeW;
589 return ts;
590 }
591
592 static public TextureAlphaSettings ExtractTextureAlphaSettings(this TextureImporterSettings settings)
593 {
594 if (settings.alphaIsTransparency == false)
595 return null;
596
597 var ts = new TextureAlphaSettings();
598 ts.alphaSource = settings.alphaSource;
599 ts.alphaTolerance = settings.alphaTestReferenceValue;
600 return ts;
601 }
602
603 static public TextureMipmapSettings ExtractTextureMipmapSettings(this TextureImporterSettings settings)
604 {
605 if (!settings.mipmapEnabled)
606 return null;
607
608 var ts = new TextureMipmapSettings();
609 ts.filter = settings.mipmapFilter;
610 ts.borderMipmap = settings.borderMipmap;
611 ts.fadeout = settings.fadeOut;
612 ts.fadeDistanceStart = settings.mipmapFadeDistanceStart;
613 ts.fadeDistanceEnd = settings.mipmapFadeDistanceEnd;
614 ts.preserveCoverage = settings.mipMapsPreserveCoverage;
615 ts.streamingMipmaps = settings.streamingMipmaps;
616 ts.streamingMipmapsPriority = settings.streamingMipmapsPriority;
617 return ts;
618 }
619
620 static public TextureNormalSettings ExtractTextureNormalSettings(this TextureImporterSettings settings)
621 {
622 var ts = new TextureNormalSettings();
623 ts.filter = settings.normalMapFilter;
624 ts.generateFromGrayScale = settings.convertToNormalMap;
625 ts.bumpiness = settings.heightmapScale;
626 return ts;
627 }
628
629 static public TextureCubemapSettings ExtractTextureCubemapSettings(this TextureImporterSettings settings)
630 {
631 if (settings.textureShape != TextureImporterShape.TextureCube)
632 return null;
633 var ts = new TextureCubemapSettings();
634 ts.convolution = settings.cubemapConvolution;
635 ts.mode = settings.generateCubemap;
636 ts.seamless = settings.seamlessCubemap;
637 return ts;
638 }
639 }
640}