private IEnumerator SetModelAsync(string newRenderModelName)
{
if (string.IsNullOrEmpty(newRenderModelName))
{
yield break;
}
// Pre-load all render models before asking for the data to create meshes.
CVRRenderModels renderModels = Headers.OpenVR.RenderModels;
if (renderModels == null)
{
yield break;
}
// Gather names of render models to pre-load.
string[] renderModelNames;
uint count = renderModels.GetComponentCount(newRenderModelName);
if (count > 0)
{
renderModelNames = new string[count];
for (int componentIndex = 0; componentIndex < count; componentIndex++)
{
uint capacity = renderModels.GetComponentName(newRenderModelName, (uint)componentIndex, null, 0);
if (capacity == 0)
{
continue;
}
var componentNameStringBuilder = new System.Text.StringBuilder((int)capacity);
if (renderModels.GetComponentName(newRenderModelName, (uint)componentIndex, componentNameStringBuilder, capacity) == 0)
{
continue;
}
string componentName = componentNameStringBuilder.ToString();
capacity = renderModels.GetComponentRenderModelName(newRenderModelName, componentName, null, 0);
if (capacity == 0)
{
continue;
}
var nameStringBuilder = new System.Text.StringBuilder((int)capacity);
if (renderModels.GetComponentRenderModelName(newRenderModelName, componentName, nameStringBuilder, capacity) == 0)
{
continue;
}
var s = nameStringBuilder.ToString();
// Only need to pre-load if not already cached.
if (!(models[s] is RenderModel model) || model.Mesh == null)
{
renderModelNames[componentIndex] = s;
}
}
}
else
{
// Only need to pre-load if not already cached.
if (!(models[newRenderModelName] is RenderModel model) || model.Mesh == null)
{
renderModelNames = new string[] { newRenderModelName };
}
// Token: 0x06000DE3 RID: 3555 RVA: 0x00058504 File Offset: 0x00056704
private bool LoadComponents(SteamVR_RenderModel.RenderModelInterfaceHolder holder, string renderModelName)
{
Transform transform = base.transform;
for (int i = 0; i < transform.childCount; i++)
{
Transform child = transform.GetChild(i);
child.gameObject.SetActive(false);
this.StripMesh(child.gameObject);
}
if (string.IsNullOrEmpty(renderModelName))
{
return(true);
}
CVRRenderModels instance = holder.instance;
if (instance == null)
{
return(false);
}
uint componentCount = instance.GetComponentCount(renderModelName);
if (componentCount == 0U)
{
return(false);
}
int num = 0;
while ((long)num < (long)((ulong)componentCount))
{
uint num2 = instance.GetComponentName(renderModelName, (uint)num, null, 0U);
if (num2 != 0U)
{
StringBuilder stringBuilder = new StringBuilder((int)num2);
if (instance.GetComponentName(renderModelName, (uint)num, stringBuilder, num2) != 0U)
{
transform = this.FindComponent(stringBuilder.ToString());
if (transform != null)
{
transform.gameObject.SetActive(true);
}
else
{
transform = new GameObject(stringBuilder.ToString()).transform;
transform.parent = base.transform;
transform.gameObject.layer = base.gameObject.layer;
Transform transform2 = new GameObject("attach").transform;
transform2.parent = transform;
transform2.localPosition = Vector3.zero;
transform2.localRotation = Quaternion.identity;
transform2.localScale = Vector3.one;
transform2.gameObject.layer = base.gameObject.layer;
}
transform.localPosition = Vector3.zero;
transform.localRotation = Quaternion.identity;
transform.localScale = Vector3.one;
num2 = instance.GetComponentRenderModelName(renderModelName, stringBuilder.ToString(), null, 0U);
if (num2 != 0U)
{
StringBuilder stringBuilder2 = new StringBuilder((int)num2);
if (instance.GetComponentRenderModelName(renderModelName, stringBuilder.ToString(), stringBuilder2, num2) != 0U)
{
SteamVR_RenderModel.RenderModel renderModel = SteamVR_RenderModel.models[stringBuilder2] as SteamVR_RenderModel.RenderModel;
if (renderModel == null || renderModel.mesh == null)
{
if (this.verbose)
{
Debug.Log("Loading render model " + stringBuilder2);
}
renderModel = this.LoadRenderModel(instance, stringBuilder2.ToString(), renderModelName);
if (renderModel == null)
{
goto IL_227;
}
SteamVR_RenderModel.models[stringBuilder2] = renderModel;
}
transform.gameObject.AddComponent <MeshFilter>().mesh = renderModel.mesh;
transform.gameObject.AddComponent <MeshRenderer>().sharedMaterial = renderModel.material;
}
}
}
}
IL_227:
num++;
}
return(true);
}
// 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;
}
// BUGBUG: PaulBro - workaround for Error: Unity SteamVR: Failed to load IVRRenderModels interface version IVRRenderModels_005
// See https://steamcommunity.com/app/358720/discussions/0/357286663674402763/
// private bool LoadComponents(RenderModelInterfaceHolder holder, string renderModelName)
private bool LoadComponents(CVRRenderModels renderModels, string renderModelName)
{
// Disable existing components (we will re-enable them if referenced by this new model).
// Also strip mesh filter and renderer since these will get re-added if the new component needs them.
var t = transform;
for (int i = 0; i < t.childCount; i++)
{
var child = t.GetChild(i);
child.gameObject.SetActive(false);
StripMesh(child.gameObject);
}
// If no model specified, we're done; return success.
if (string.IsNullOrEmpty(renderModelName))
{
return(true);
}
// BUGBUG: PaulBro - workaround for Error: Unity SteamVR: Failed to load IVRRenderModels interface version IVRRenderModels_005
//var renderModels = holder.instance;
if (renderModels == null)
{
return(false);
}
var count = renderModels.GetComponentCount(renderModelName);
if (count == 0)
{
return(false);
}
for (int i = 0; i < count; i++)
{
var capacity = renderModels.GetComponentName(renderModelName, (uint)i, null, 0);
if (capacity == 0)
{
continue;
}
var componentName = new System.Text.StringBuilder((int)capacity);
if (renderModels.GetComponentName(renderModelName, (uint)i, componentName, capacity) == 0)
{
continue;
}
// Create (or reuse) a child object for this component (some components are dynamic and don't have meshes).
t = FindComponent(componentName.ToString());
if (t != null)
{
t.gameObject.SetActive(true);
}
else
{
t = new GameObject(componentName.ToString()).transform;
t.parent = transform;
t.gameObject.layer = gameObject.layer;
// Also create a child 'attach' object for attaching things.
var attach = new GameObject(k_localTransformName).transform;
attach.parent = t;
attach.localPosition = Vector3.zero;
attach.localRotation = Quaternion.identity;
attach.localScale = Vector3.one;
attach.gameObject.layer = gameObject.layer;
}
// Reset transform.
t.localPosition = Vector3.zero;
t.localRotation = Quaternion.identity;
t.localScale = Vector3.one;
capacity = renderModels.GetComponentRenderModelName(renderModelName, componentName.ToString(), null, 0);
if (capacity == 0)
{
continue;
}
var componentRenderModelName = new System.Text.StringBuilder((int)capacity);
if (renderModels.GetComponentRenderModelName(renderModelName, componentName.ToString(), componentRenderModelName, capacity) == 0)
{
continue;
}
// Check the cache or load into memory.
var model = models[componentRenderModelName] as RenderModel;
if (model == null || model.mesh == null)
{
if (verbose)
{
Debug.Log("Loading render model " + componentRenderModelName);
}
model = LoadRenderModel(renderModels, componentRenderModelName.ToString(), renderModelName);
if (model == null)
{
continue;
}
models[componentRenderModelName] = model;
}
t.gameObject.AddComponent <MeshFilter>().mesh = model.mesh;
t.gameObject.AddComponent <MeshRenderer>().sharedMaterial = model.material;
}
return(true);
}
