1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
|
using UnityEngine;
using System.Linq;
using System.Collections.Generic;
using System.Collections;
using System.IO;
using System;
using DepthFirstScheduler;
#if UNITY_EDITOR
using UnityEditor;
#endif
namespace UniGLTF
{
public class TextureItem
{
private int m_textureIndex;
public Texture2D Texture
{
get
{
return m_textureLoader.Texture;
}
}
#region Texture converter
private Dictionary<string, Texture2D> m_converts = new Dictionary<string, Texture2D>();
public Dictionary<string, Texture2D> Converts
{
get { return m_converts; }
}
/// <summary>
///
/// </summary>
/// <param name="prop"></param>
/// <param name="smoothness">used only when converting MetallicRoughness maps</param>
/// <returns></returns>
public Texture2D ConvertTexture(string prop, float smoothnessOrRoughness = 1.0f)
{
var convertedTexture = Converts.FirstOrDefault(x => x.Key == prop);
if (convertedTexture.Value != null)
return convertedTexture.Value;
if (prop == "_BumpMap")
{
if (Application.isPlaying)
{
var converted = new NormalConverter().GetImportTexture(Texture);
m_converts.Add(prop, converted);
return converted;
}
else
{
#if UNITY_EDITOR
var textureAssetPath = AssetDatabase.GetAssetPath(Texture);
if (!string.IsNullOrEmpty(textureAssetPath))
{
TextureIO.MarkTextureAssetAsNormalMap(textureAssetPath);
}
else
{
Debug.LogWarningFormat("no asset for {0}", Texture);
}
#endif
return Texture;
}
}
if (prop == "_MetallicGlossMap")
{
var converted = new MetallicRoughnessConverter(smoothnessOrRoughness).GetImportTexture(Texture);
m_converts.Add(prop, converted);
return converted;
}
if (prop == "_OcclusionMap")
{
var converted = new OcclusionConverter().GetImportTexture(Texture);
m_converts.Add(prop, converted);
return converted;
}
return null;
}
#endregion
public bool IsAsset
{
private set;
get;
}
public IEnumerable<Texture2D> GetTexturesForSaveAssets()
{
if (!IsAsset)
{
yield return Texture;
}
if (m_converts.Any())
{
foreach (var texture in m_converts)
{
yield return texture.Value;
}
}
}
/// <summary>
/// Texture from buffer
/// </summary>
/// <param name="index"></param>
public TextureItem(int index, ITextureLoader textureLoader)
{
m_textureIndex = index;
m_textureLoader = textureLoader;
if(m_textureLoader == null)
{
throw new Exception("ITextureLoader is null.");
}
}
#if UNITY_EDITOR
/// <summary>
/// Texture from asset
/// </summary>
/// <param name="index"></param>
/// <param name="assetPath"></param>
/// <param name="textureName"></param>
public TextureItem(int index, UnityPath assetPath, string textureName)
{
m_textureIndex = index;
IsAsset = true;
m_textureLoader = new AssetTextureLoader(assetPath, textureName);
}
#endif
#region Process
ITextureLoader m_textureLoader;
public void Process(glTF gltf, IStorage storage)
{
ProcessOnAnyThread(gltf, storage);
ProcessOnMainThreadCoroutine(gltf).CoroutineToEnd();
}
public IEnumerator ProcessCoroutine(glTF gltf, IStorage storage)
{
ProcessOnAnyThread(gltf, storage);
yield return ProcessOnMainThreadCoroutine(gltf);
}
public void ProcessOnAnyThread(glTF gltf, IStorage storage)
{
m_textureLoader.ProcessOnAnyThread(gltf, storage);
}
public IEnumerator ProcessOnMainThreadCoroutine(glTF gltf)
{
using (m_textureLoader)
{
var textureType = TextureIO.GetglTFTextureType(gltf, m_textureIndex);
var colorSpace = TextureIO.GetColorSpace(textureType);
var isLinear = colorSpace == RenderTextureReadWrite.Linear;
yield return m_textureLoader.ProcessOnMainThread(isLinear, gltf.GetSamplerFromTextureIndex(m_textureIndex));
}
}
#endregion
struct ColorSpaceScope : IDisposable
{
bool m_sRGBWrite;
public ColorSpaceScope(RenderTextureReadWrite colorSpace)
{
m_sRGBWrite = GL.sRGBWrite;
switch (colorSpace)
{
case RenderTextureReadWrite.Linear:
GL.sRGBWrite = false;
break;
case RenderTextureReadWrite.sRGB:
default:
GL.sRGBWrite = true;
break;
}
}
public ColorSpaceScope(bool sRGBWrite)
{
m_sRGBWrite = GL.sRGBWrite;
GL.sRGBWrite = sRGBWrite;
}
public void Dispose()
{
GL.sRGBWrite = m_sRGBWrite;
}
}
#if UNITY_EDITOR && VRM_DEVELOP
[MenuItem("Assets/CopySRGBWrite", true)]
static bool CopySRGBWriteIsEnable()
{
return Selection.activeObject is Texture;
}
[MenuItem("Assets/CopySRGBWrite")]
static void CopySRGBWrite()
{
CopySRGBWrite(true);
}
[MenuItem("Assets/CopyNotSRGBWrite", true)]
static bool CopyNotSRGBWriteIsEnable()
{
return Selection.activeObject is Texture;
}
[MenuItem("Assets/CopyNotSRGBWrite")]
static void CopyNotSRGBWrite()
{
CopySRGBWrite(false);
}
static string AddPath(string path, string add)
{
return string.Format("{0}/{1}{2}{3}",
Path.GetDirectoryName(path),
Path.GetFileNameWithoutExtension(path),
add,
Path.GetExtension(path));
}
static void CopySRGBWrite(bool isSRGB)
{
var src = Selection.activeObject as Texture;
var texturePath = UnityPath.FromAsset(src);
var path = EditorUtility.SaveFilePanel("save prefab", "Assets",
Path.GetFileNameWithoutExtension(AddPath(texturePath.FullPath, ".sRGB")), "prefab");
var assetPath = UnityPath.FromFullpath(path);
if (!assetPath.IsUnderAssetsFolder)
{
return;
}
Debug.LogFormat("[CopySRGBWrite] {0} => {1}", texturePath, assetPath);
var renderTexture = new RenderTexture(src.width, src.height, 0,
RenderTextureFormat.ARGB32,
RenderTextureReadWrite.sRGB);
using (var scope = new ColorSpaceScope(isSRGB))
{
Graphics.Blit(src, renderTexture);
}
var dst = new Texture2D(src.width, src.height, TextureFormat.ARGB32, false,
RenderTextureReadWrite.sRGB == RenderTextureReadWrite.Linear);
dst.ReadPixels(new Rect(0, 0, src.width, src.height), 0, 0);
dst.Apply();
RenderTexture.active = null;
assetPath.CreateAsset(dst);
GameObject.DestroyImmediate(renderTexture);
}
#endif
public static Texture2D CopyTexture(Texture src, RenderTextureReadWrite colorSpace, Material material)
{
Texture2D dst = null;
var renderTexture = new RenderTexture(src.width, src.height, 0, RenderTextureFormat.ARGB32, colorSpace);
using (var scope = new ColorSpaceScope(colorSpace))
{
if (material != null)
{
Graphics.Blit(src, renderTexture, material);
}
else
{
Graphics.Blit(src, renderTexture);
}
}
dst = new Texture2D(src.width, src.height, TextureFormat.ARGB32, false, colorSpace == RenderTextureReadWrite.Linear);
dst.ReadPixels(new Rect(0, 0, src.width, src.height), 0, 0);
dst.name = src.name;
dst.anisoLevel = src.anisoLevel;
dst.filterMode = src.filterMode;
dst.mipMapBias = src.mipMapBias;
dst.wrapMode = src.wrapMode;
#if UNITY_2017_1_OR_NEWER
dst.wrapModeU = src.wrapModeU;
dst.wrapModeV = src.wrapModeV;
dst.wrapModeW = src.wrapModeW;
#endif
dst.Apply();
RenderTexture.active = null;
if (Application.isEditor)
{
GameObject.DestroyImmediate(renderTexture);
}
else
{
GameObject.Destroy(renderTexture);
}
return dst;
}
}
}
|
