// Token: 0x06000DEB RID: 3563 RVA: 0x00058A0C File Offset: 0x00056C0C
private RenderModel_t MarshalRenderModel(IntPtr pRenderModel)
{
if (Environment.OSVersion.Platform == PlatformID.MacOSX || Environment.OSVersion.Platform == PlatformID.Unix)
{
RenderModel_t_Packed renderModel_t_Packed = (RenderModel_t_Packed)Marshal.PtrToStructure(pRenderModel, typeof(RenderModel_t_Packed));
RenderModel_t result = default(RenderModel_t);
renderModel_t_Packed.Unpack(ref result);
return(result);
}
return((RenderModel_t)Marshal.PtrToStructure(pRenderModel, typeof(RenderModel_t)));
}
/// <summary>
/// Helper function to handle the inconvenient fact that the packing for RenderModel_t is
/// different on Linux/OSX (4) than it is on Windows (8)
/// </summary>
/// <param name="pRenderModel">native pointer to the RenderModel_t</param>
/// <returns></returns>
private RenderModel_t MarshalRenderModel(IntPtr pRenderModel)
{
if ((Environment.OSVersion.Platform == PlatformID.MacOSX) || (Environment.OSVersion.Platform == PlatformID.Unix))
{
var packedModel = (RenderModel_t_Packed)Marshal.PtrToStructure(pRenderModel, typeof(RenderModel_t_Packed));
RenderModel_t model = new RenderModel_t();
packedModel.Unpack(ref model);
return(model);
}
return((RenderModel_t)Marshal.PtrToStructure(pRenderModel, typeof(RenderModel_t)));
}
public static GLRenderModel Create(string name, RenderModel_t renderModel, RenderModel_TextureMap_t diffuseTexture)
{
// create and bind a VAO to hold the state for this model
int vao = OpenGLUtil.CreateVertexArrayObject();
GL.BindVertexArray(vao);
// populate the vertex buffer
int vbo = OpenGLUtil.CreateBufferObject();
GL.BindBuffer(BufferTarget.ArrayBuffer, vbo);
GL.BufferData(BufferTarget.ArrayBuffer, Marshal.SizeOf <RenderModel_Vertex_t>() * (int)renderModel.unVertexCount, renderModel.rVertexData, BufferUsageHint.StaticDraw);
// identity the components in teh vertex buffer
GL.EnableVertexAttribArray(0);
GL.VertexAttribPointer(0, 3, VertexAttribPointerType.Float, false, Marshal.SizeOf <RenderModel_Vertex_t>(), Marshal.OffsetOf <RenderModel_Vertex_t>("vPosition")); // this might have to be size of 4?
GL.EnableVertexAttribArray(1);
GL.VertexAttribPointer(1, 3, VertexAttribPointerType.Float, false, Marshal.SizeOf <RenderModel_Vertex_t>(), Marshal.OffsetOf <RenderModel_Vertex_t>("vNormal"));
GL.EnableVertexAttribArray(2);
GL.VertexAttribPointer(2, 2, VertexAttribPointerType.Float, false, Marshal.SizeOf <RenderModel_Vertex_t>(), Marshal.OffsetOf <RenderModel_Vertex_t>("rfTextureCoord0"));
// create and populate the index buffer
int indexBuffer = OpenGLUtil.CreateBufferObject();
GL.BindBuffer(BufferTarget.ElementArrayBuffer, indexBuffer);
GL.BufferData(BufferTarget.ElementArrayBuffer, Marshal.SizeOf <ushort>() * (int)renderModel.unTriangleCount * 3, renderModel.rIndexData, BufferUsageHint.StaticDraw);
GL.BindVertexArray(0);
// create and populate the texture
int texture = OpenGLUtil.CreateTexture();
GL.BindTexture(TextureTarget.Texture2D, texture);
GL.TexImage2D(TextureTarget.Texture2D, 0, PixelInternalFormat.Rgba, diffuseTexture.unWidth, diffuseTexture.unHeight,
0, PixelFormat.Rgba, PixelType.UnsignedByte, diffuseTexture.rubTextureMapData);
GL.GenerateMipmap(GenerateMipmapTarget.Texture2D);
GL.TexParameterI(TextureTarget.Texture2D, TextureParameterName.TextureWrapS, new[] { (int)TextureParameterName.ClampToEdge });
GL.TexParameterI(TextureTarget.Texture2D, TextureParameterName.TextureWrapT, new[] { (int)TextureParameterName.ClampToEdge });
GL.TexParameterI(TextureTarget.Texture2D, TextureParameterName.TextureMagFilter, new[] { (int)TextureMagFilter.Linear });
GL.TexParameterI(TextureTarget.Texture2D, TextureParameterName.TextureMinFilter, new[] { (int)TextureMinFilter.LinearMipmapLinear });
// *****missing stuff about anisotropy ***** // not sure if this is right
float largest = GL.GetFloat((GetPName)0x84FF);
GL.TexParameter(TextureTarget.Texture2D, (TextureParameterName)0x84FE, largest);
GL.BindTexture(TextureTarget.Texture2D, 0);
return(new GLRenderModel(vbo, indexBuffer, vao, texture, (int)renderModel.unTriangleCount * 3, name));
}
/// <summary>
/// Helper function to handle the inconvenient fact that the packing for RenderModel_t is
/// different on Linux/OSX (4) than it is on Windows (8)
/// </summary>
/// <param name="pRenderModel">native pointer to the RenderModel_t</param>
/// <returns></returns>
private RenderModel_t MarshalRenderModel(System.IntPtr pRenderModel)
{
#if UNITY_STANDALONE
if ((System.Environment.OSVersion.Platform == System.PlatformID.MacOSX) ||
(System.Environment.OSVersion.Platform == System.PlatformID.Unix))
{
var packedModel = (RenderModel_t_Packed)Marshal.PtrToStructure(pRenderModel, typeof(RenderModel_t_Packed));
RenderModel_t model = new RenderModel_t();
packedModel.Unpack(ref model);
return(model);
}
else
{
return((RcenderModel_t)Marshal.PtrToStructure(pRenderModel, typeof(RenderModel_t)));
}
#else
return((RenderModel_t)Marshal.PtrToStructure(pRenderModel, typeof(RenderModel_t)));
#endif
}
static RenderModel LoadRenderModel(string renderModelName)
{
var error = HmdError.None;
if (!SteamVR.active)
{
OpenVR.Init(ref error);
if (error != HmdError.None)
{
return(null);
}
}
var pRenderModels = OpenVR.GetGenericInterface(OpenVR.IVRRenderModels_Version, ref error);
if (pRenderModels == System.IntPtr.Zero || error != HmdError.None)
{
if (!SteamVR.active)
{
OpenVR.Shutdown();
}
return(null);
}
var renderModels = new CVRRenderModels(pRenderModels);
var renderModel = new RenderModel_t();
if (!renderModels.LoadRenderModel(renderModelName, ref renderModel))
{
Debug.LogError("Failed to load render model " + renderModelName);
if (!SteamVR.active)
{
OpenVR.Shutdown();
}
return(null);
}
var vertices = new Vector3[renderModel.unVertexCount];
var normals = new Vector3[renderModel.unVertexCount];
var uv = new Vector2[renderModel.unVertexCount];
var type = typeof(RenderModel_Vertex_t);
for (int iVert = 0; iVert < renderModel.unVertexCount; iVert++)
{
var ptr = new System.IntPtr(renderModel.rVertexData.ToInt64() + iVert * Marshal.SizeOf(type));
var vert = (RenderModel_Vertex_t)Marshal.PtrToStructure(ptr, type);
vertices[iVert] = new Vector3(vert.vPosition.v[0], vert.vPosition.v[1], -vert.vPosition.v[2]);
normals[iVert] = new Vector3(vert.vNormal.v[0], vert.vNormal.v[1], -vert.vNormal.v[2]);
uv[iVert] = new Vector2(vert.rfTextureCoord[0], vert.rfTextureCoord[1]);
}
int indexCount = (int)renderModel.unTriangleCount * 3;
var indices = new short[indexCount];
Marshal.Copy(renderModel.rIndexData, indices, 0, indices.Length);
var triangles = new int[indexCount];
for (int iTri = 0; iTri < renderModel.unTriangleCount; iTri++)
{
triangles[iTri * 3 + 0] = (int)indices[iTri * 3 + 2];
triangles[iTri * 3 + 1] = (int)indices[iTri * 3 + 1];
triangles[iTri * 3 + 2] = (int)indices[iTri * 3 + 0];
}
var mesh = new Mesh();
mesh.vertices = vertices;
mesh.normals = normals;
mesh.uv = uv;
mesh.triangles = triangles;
mesh.Optimize();
//mesh.hideFlags = HideFlags.DontUnloadUnusedAsset;
var textureMapData = new byte[renderModel.diffuseTexture.unWidth * renderModel.diffuseTexture.unHeight * 4]; // RGBA
Marshal.Copy(renderModel.diffuseTexture.rubTextureMapData, textureMapData, 0, textureMapData.Length);
var colors = new Color32[renderModel.diffuseTexture.unWidth * renderModel.diffuseTexture.unHeight];
int iColor = 0;
for (int iHeight = 0; iHeight < renderModel.diffuseTexture.unHeight; iHeight++)
{
for (int iWidth = 0; iWidth < renderModel.diffuseTexture.unWidth; iWidth++)
{
var r = textureMapData[iColor++];
var g = textureMapData[iColor++];
var b = textureMapData[iColor++];
var a = textureMapData[iColor++];
colors[iHeight * renderModel.diffuseTexture.unWidth + iWidth] = new Color32(r, g, b, a);
}
}
var texture = new Texture2D(renderModel.diffuseTexture.unWidth, renderModel.diffuseTexture.unHeight, TextureFormat.ARGB32, true);
texture.SetPixels32(colors);
texture.Apply();
//texture.hideFlags = HideFlags.DontUnloadUnusedAsset;
renderModels.FreeRenderModel(ref renderModel);
if (!SteamVR.active)
{
OpenVR.Shutdown();
}
return(new RenderModel(mesh, texture));
}
public abstract bool LoadRenderModel(string pchRenderModelName,ref RenderModel_t pRenderModel);
public abstract void FreeRenderModel(ref RenderModel_t pRenderModel);
public override bool LoadRenderModel(string pchRenderModelName,ref RenderModel_t pRenderModel)
{
CheckIfUsable();
bool result = VRNativeEntrypoints.VR_IVRRenderModels_LoadRenderModel(m_pVRRenderModels,pchRenderModelName,ref pRenderModel);
return result;
}
public override void FreeRenderModel(ref RenderModel_t pRenderModel)
{
CheckIfUsable();
VRNativeEntrypoints.VR_IVRRenderModels_FreeRenderModel(m_pVRRenderModels,ref pRenderModel);
}
// Token: 0x06000DDD RID: 3549 RVA: 0x00057F55 File Offset: 0x00056155
private IEnumerator SetModelAsync(string renderModelName)
{
if (string.IsNullOrEmpty(renderModelName))
{
yield break;
}
using (SteamVR_RenderModel.RenderModelInterfaceHolder holder = new SteamVR_RenderModel.RenderModelInterfaceHolder())
{
CVRRenderModels renderModels = holder.instance;
if (renderModels == null)
{
yield break;
}
uint componentCount = renderModels.GetComponentCount(renderModelName);
string[] renderModelNames;
if (componentCount > 0U)
{
renderModelNames = new string[componentCount];
int num = 0;
while ((long)num < (long)((ulong)componentCount))
{
uint num2 = renderModels.GetComponentName(renderModelName, (uint)num, null, 0U);
if (num2 != 0U)
{
StringBuilder stringBuilder = new StringBuilder((int)num2);
if (renderModels.GetComponentName(renderModelName, (uint)num, stringBuilder, num2) != 0U)
{
num2 = renderModels.GetComponentRenderModelName(renderModelName, stringBuilder.ToString(), null, 0U);
if (num2 != 0U)
{
StringBuilder stringBuilder2 = new StringBuilder((int)num2);
if (renderModels.GetComponentRenderModelName(renderModelName, stringBuilder.ToString(), stringBuilder2, num2) != 0U)
{
string text = stringBuilder2.ToString();
SteamVR_RenderModel.RenderModel renderModel = SteamVR_RenderModel.models[text] as SteamVR_RenderModel.RenderModel;
if (renderModel == null || renderModel.mesh == null)
{
renderModelNames[num] = text;
}
}
}
}
}
num++;
}
}
else
{
SteamVR_RenderModel.RenderModel renderModel2 = SteamVR_RenderModel.models[renderModelName] as SteamVR_RenderModel.RenderModel;
if (renderModel2 == null || renderModel2.mesh == null)
{
renderModelNames = new string[]
{
renderModelName
};
}
else
{
renderModelNames = new string[0];
}
}
for (;;)
{
bool flag = false;
foreach (string text2 in renderModelNames)
{
if (!string.IsNullOrEmpty(text2))
{
IntPtr zero = IntPtr.Zero;
EVRRenderModelError evrrenderModelError = renderModels.LoadRenderModel_Async(text2, ref zero);
if (evrrenderModelError == EVRRenderModelError.Loading)
{
flag = true;
}
else if (evrrenderModelError == EVRRenderModelError.None)
{
RenderModel_t renderModel_t = this.MarshalRenderModel(zero);
Material material = SteamVR_RenderModel.materials[renderModel_t.diffuseTextureId] as Material;
if (material == null || material.mainTexture == null)
{
IntPtr zero2 = IntPtr.Zero;
evrrenderModelError = renderModels.LoadTexture_Async(renderModel_t.diffuseTextureId, ref zero2);
if (evrrenderModelError == EVRRenderModelError.Loading)
{
flag = true;
}
}
}
}
}
if (!flag)
{
break;
}
yield return(new WaitForSeconds(0.1f));
}
renderModels = null;
renderModelNames = null;
}
SteamVR_RenderModel.RenderModelInterfaceHolder holder = null;
bool arg = this.SetModel(renderModelName);
SteamVR_Events.RenderModelLoaded.Send(this, arg);
yield break;
yield break;
}
// Token: 0x06000DDF RID: 3551 RVA: 0x00058090 File Offset: 0x00056290
private SteamVR_RenderModel.RenderModel LoadRenderModel(CVRRenderModels renderModels, string renderModelName, string baseName)
{
IntPtr zero = IntPtr.Zero;
EVRRenderModelError evrrenderModelError;
for (;;)
{
evrrenderModelError = renderModels.LoadRenderModel_Async(renderModelName, ref zero);
if (evrrenderModelError != EVRRenderModelError.Loading)
{
break;
}
SteamVR_RenderModel.Sleep();
}
if (evrrenderModelError != EVRRenderModelError.None)
{
Debug.LogError(string.Format("Failed to load render model {0} - {1}", renderModelName, evrrenderModelError.ToString()));
return(null);
}
RenderModel_t renderModel_t = this.MarshalRenderModel(zero);
Vector3[] array = new Vector3[renderModel_t.unVertexCount];
Vector3[] array2 = new Vector3[renderModel_t.unVertexCount];
Vector2[] array3 = new Vector2[renderModel_t.unVertexCount];
Type typeFromHandle = typeof(RenderModel_Vertex_t);
int num = 0;
while ((long)num < (long)((ulong)renderModel_t.unVertexCount))
{
RenderModel_Vertex_t renderModel_Vertex_t = (RenderModel_Vertex_t)Marshal.PtrToStructure(new IntPtr(renderModel_t.rVertexData.ToInt64() + (long)(num * Marshal.SizeOf(typeFromHandle))), typeFromHandle);
array[num] = new Vector3(renderModel_Vertex_t.vPosition.v0, renderModel_Vertex_t.vPosition.v1, -renderModel_Vertex_t.vPosition.v2);
array2[num] = new Vector3(renderModel_Vertex_t.vNormal.v0, renderModel_Vertex_t.vNormal.v1, -renderModel_Vertex_t.vNormal.v2);
array3[num] = new Vector2(renderModel_Vertex_t.rfTextureCoord0, renderModel_Vertex_t.rfTextureCoord1);
num++;
}
uint num2 = renderModel_t.unTriangleCount * 3U;
short[] array4 = new short[num2];
Marshal.Copy(renderModel_t.rIndexData, array4, 0, array4.Length);
int[] array5 = new int[num2];
int num3 = 0;
while ((long)num3 < (long)((ulong)renderModel_t.unTriangleCount))
{
array5[num3 * 3] = (int)array4[num3 * 3 + 2];
array5[num3 * 3 + 1] = (int)array4[num3 * 3 + 1];
array5[num3 * 3 + 2] = (int)array4[num3 * 3];
num3++;
}
Mesh mesh = new Mesh();
mesh.vertices = array;
mesh.normals = array2;
mesh.uv = array3;
mesh.triangles = array5;
Material material = SteamVR_RenderModel.materials[renderModel_t.diffuseTextureId] as Material;
if (material == null || material.mainTexture == null)
{
IntPtr zero2 = IntPtr.Zero;
for (;;)
{
evrrenderModelError = renderModels.LoadTexture_Async(renderModel_t.diffuseTextureId, ref zero2);
if (evrrenderModelError != EVRRenderModelError.Loading)
{
break;
}
SteamVR_RenderModel.Sleep();
}
if (evrrenderModelError == EVRRenderModelError.None)
{
RenderModel_TextureMap_t renderModel_TextureMap_t = this.MarshalRenderModel_TextureMap(zero2);
Texture2D texture2D = new Texture2D((int)renderModel_TextureMap_t.unWidth, (int)renderModel_TextureMap_t.unHeight, TextureFormat.ARGB32, false);
if (SystemInfo.graphicsDeviceType == GraphicsDeviceType.Direct3D11)
{
texture2D.Apply();
for (;;)
{
evrrenderModelError = renderModels.LoadIntoTextureD3D11_Async(renderModel_t.diffuseTextureId, texture2D.GetNativeTexturePtr());
if (evrrenderModelError != EVRRenderModelError.Loading)
{
break;
}
SteamVR_RenderModel.Sleep();
}
}
else
{
byte[] array6 = new byte[(int)(renderModel_TextureMap_t.unWidth * renderModel_TextureMap_t.unHeight * '\u0004')];
Marshal.Copy(renderModel_TextureMap_t.rubTextureMapData, array6, 0, array6.Length);
Color32[] array7 = new Color32[(int)(renderModel_TextureMap_t.unWidth * renderModel_TextureMap_t.unHeight)];
int num4 = 0;
for (int i = 0; i < (int)renderModel_TextureMap_t.unHeight; i++)
{
for (int j = 0; j < (int)renderModel_TextureMap_t.unWidth; j++)
{
byte r = array6[num4++];
byte g = array6[num4++];
byte b = array6[num4++];
byte a = array6[num4++];
array7[i * (int)renderModel_TextureMap_t.unWidth + j] = new Color32(r, g, b, a);
}
}
texture2D.SetPixels32(array7);
texture2D.Apply();
}
material = new Material((this.shader != null) ? this.shader : Shader.Find("Standard"));
material.mainTexture = texture2D;
SteamVR_RenderModel.materials[renderModel_t.diffuseTextureId] = material;
renderModels.FreeTexture(zero2);
}
else
{
Debug.Log("Failed to load render model texture for render model " + renderModelName);
}
}
base.StartCoroutine(this.FreeRenderModel(zero));
return(new SteamVR_RenderModel.RenderModel(mesh, material));
}
// return true if is done
private bool DoLoadModelJob(CVRRenderModels vrRenderModels, string modelName, Dictionary <int, Texture2D> texturesCache, ref IntPtr modelPtr, ref IntPtr texturePtr, ref IntPtr d3d11TexturePtr)
{
if (string.IsNullOrEmpty(modelName))
{
return(true);
}
EVRRenderModelError error;
Model model;
if (!s_modelsCache.TryGetValue(modelName, out model))
{
switch (error = vrRenderModels.LoadRenderModel_Async(modelName, ref modelPtr))
{
default:
Debug.LogError("[" + m_jobID + "]+" + (Time.frameCount - m_startFrame) + " LoadRenderModel_Async failed! " + System.IO.Path.GetFileName(modelName) + " EVRRenderModelError=" + error);
return(true);
case EVRRenderModelError.Loading:
if (s_verbose)
{
Debug.Log("[" + m_jobID + "]+" + (Time.frameCount - m_startFrame) + " LoadRenderModel_Async loading... " + System.IO.Path.GetFileName(modelName));
}
return(false);
case EVRRenderModelError.None:
if (s_verbose)
{
Debug.Log("[" + m_jobID + "]+" + (Time.frameCount - m_startFrame) + " LoadRenderModel_Async succeed! " + System.IO.Path.GetFileName(modelName));
}
RenderModel_t modelData = MarshalRenderModel(modelPtr);
var vertices = new Vector3[modelData.unVertexCount];
var normals = new Vector3[modelData.unVertexCount];
var uv = new Vector2[modelData.unVertexCount];
Type type = typeof(RenderModel_Vertex_t);
for (int iVert = 0; iVert < modelData.unVertexCount; iVert++)
{
var ptr = new IntPtr(modelData.rVertexData.ToInt64() + iVert * Marshal.SizeOf(type));
var vert = (RenderModel_Vertex_t)Marshal.PtrToStructure(ptr, type);
vertices[iVert] = new Vector3(vert.vPosition.v0, vert.vPosition.v1, -vert.vPosition.v2);
normals[iVert] = new Vector3(vert.vNormal.v0, vert.vNormal.v1, -vert.vNormal.v2);
uv[iVert] = new Vector2(vert.rfTextureCoord0, vert.rfTextureCoord1);
}
var indexCount = (int)modelData.unTriangleCount * 3;
var indices = new short[indexCount];
Marshal.Copy(modelData.rIndexData, indices, 0, indices.Length);
var triangles = new int[indexCount];
for (int iTri = 0; iTri < modelData.unTriangleCount; iTri++)
{
triangles[iTri * 3 + 0] = indices[iTri * 3 + 2];
triangles[iTri * 3 + 1] = indices[iTri * 3 + 1];
triangles[iTri * 3 + 2] = indices[iTri * 3 + 0];
}
model = new Model()
{
textureID = modelData.diffuseTextureId,
mesh = new Mesh()
{
hideFlags = HideFlags.HideAndDontSave,
vertices = vertices,
normals = normals,
uv = uv,
triangles = triangles,
},
};
s_modelsCache.Add(modelName, model);
break;
}
}
Texture2D texture;
if (!texturesCache.TryGetValue(model.textureID, out texture))
{
switch (error = vrRenderModels.LoadTexture_Async(model.textureID, ref texturePtr))
{
default:
Debug.LogError("[" + m_jobID + "]+" + (Time.frameCount - m_startFrame) + " LoadTexture_Async failed! " + System.IO.Path.GetFileName(modelName) + "[" + model.textureID + "] EVRRenderModelError=" + error);
return(true);
case EVRRenderModelError.Loading:
if (s_verbose)
{
Debug.Log("[" + m_jobID + "]+" + (Time.frameCount - m_startFrame) + " LoadTexture_Async loading... " + System.IO.Path.GetFileName(modelName) + "[" + model.textureID + "]");
}
return(false);
case EVRRenderModelError.None:
if (s_verbose)
{
Debug.Log("[" + m_jobID + "]+" + (Time.frameCount - m_startFrame) + " LoadTexture_Async succeed! " + System.IO.Path.GetFileName(modelName) + "[" + model.textureID + "]");
}
var textureMap = MarshalRenderModelTextureMap(texturePtr);
texture = new Texture2D(textureMap.unWidth, textureMap.unHeight, TextureFormat.RGBA32, false);
if (SystemInfo.graphicsDeviceType == GraphicsDeviceType.Direct3D11)
{
texture.Apply();
d3d11TexturePtr = texture.GetNativeTexturePtr();
}
else
{
var textureMapData = new byte[textureMap.unWidth * textureMap.unHeight * 4]; // RGBA
Marshal.Copy(textureMap.rubTextureMapData, textureMapData, 0, textureMapData.Length);
var colors = new Color32[textureMap.unWidth * textureMap.unHeight];
int iColor = 0;
for (int iHeight = 0; iHeight < textureMap.unHeight; iHeight++)
{
for (int iWidth = 0; iWidth < textureMap.unWidth; iWidth++)
{
var r = textureMapData[iColor++];
var g = textureMapData[iColor++];
var b = textureMapData[iColor++];
var a = textureMapData[iColor++];
colors[iHeight * textureMap.unWidth + iWidth] = new Color32(r, g, b, a);
}
}
texture.SetPixels32(colors);
texture.Apply();
}
texturesCache.Add(model.textureID, texture);
break;
}
}
if (d3d11TexturePtr != IntPtr.Zero)
{
while (true)
{
switch (error = vrRenderModels.LoadIntoTextureD3D11_Async(model.textureID, d3d11TexturePtr))
{
default:
Debug.LogError("[" + m_jobID + "]+" + (Time.frameCount - m_startFrame) + " LoadIntoTextureD3D11_Async failed! " + System.IO.Path.GetFileName(modelName) + " EVRRenderModelError=" + error);
d3d11TexturePtr = IntPtr.Zero;
return(true);
case EVRRenderModelError.Loading:
if (s_verbose)
{
Debug.Log("[" + m_jobID + "]+" + (Time.frameCount - m_startFrame) + " LoadIntoTextureD3D11_Async loading... " + System.IO.Path.GetFileName(modelName) + "[" + model.textureID + "]");
}
break;
case EVRRenderModelError.None:
if (s_verbose)
{
Debug.Log("[" + m_jobID + "]+" + (Time.frameCount - m_startFrame) + " LoadIntoTextureD3D11_Async succeed! " + System.IO.Path.GetFileName(modelName));
}
d3d11TexturePtr = IntPtr.Zero;
return(true);
}
// FIXME: LoadIntoTextureD3D11_Async blocks main thread? Crashes when not calling it in while loop
#if !UNITY_METRO
System.Threading.Thread.Sleep(1);
#endif
}
}
return(true);
}
