/// <summary>
/// I really, really want to make this asynchronous so that we can load render models on the fly without interupting the experience.
/// I need to look more into how we can accomplish this without casuing errors in OpenGL.
/// </summary>
/// <returns></returns>
public static GLRenderModels Create(OpenVRScene scene)
{
const int retryInterval = 10;
var models = new Dictionary <int, GLRenderModel>();
foreach (int trackedDeviceIndex in OpenVRUtil.DeviceIndexes)
{
if (trackedDeviceIndex == OpenVR.k_unTrackedDeviceIndex_Hmd)
{
continue; // dont want to render the actual HMD! it would block your face! (yep i did that)
}
if (!scene.IsConnected(trackedDeviceIndex))
{
continue;
}
string renderModelName =
scene.DeviceInfo(trackedDeviceIndex, ETrackedDeviceProperty.Prop_RenderModelName_String)
.Validate(propErr => new InvalidOperationException($"Failed to retrieve prop name for connected tracked device: {propErr}"));
// load render model async
IntPtr renderModelPtr = IntPtr.Zero;
EVRRenderModelError rmErr = EVRRenderModelError.Loading;
while (rmErr == EVRRenderModelError.Loading) // is this seriously how im supposed to do this? no callback?
{
rmErr = OpenVR.RenderModels.LoadRenderModel_Async(renderModelName, ref renderModelPtr);
Thread.Sleep(retryInterval); // async seems to be breaking opengl!?
//await Task.Delay(retryInterval); // try again every 0.1 seconds
}
if (rmErr != EVRRenderModelError.None || renderModelPtr == IntPtr.Zero)
{
throw new InvalidOperationException($"Failed to load Render Model: {renderModelName}");
}
var renderModel = (RenderModel_t)Marshal.PtrToStructure(renderModelPtr, typeof(RenderModel_t));
// load the render texture async
IntPtr texturePtr = IntPtr.Zero;
rmErr = EVRRenderModelError.Loading;
while (rmErr == EVRRenderModelError.Loading) // is this seriously how im supposed to do this? no callback?
{
rmErr = OpenVR.RenderModels.LoadTexture_Async(renderModel.diffuseTextureId, ref texturePtr);
Thread.Sleep(retryInterval); // async seems to be breaking opengl?
//await Task.Delay(retryInterval); // try again every 0.1 seconds
}
if (rmErr != EVRRenderModelError.None || texturePtr == IntPtr.Zero)
{
throw new InvalidOperationException($"Failed to load texture for Render Model: {renderModelName}");
}
var diffuseTexture = (RenderModel_TextureMap_t)Marshal.PtrToStructure(texturePtr, typeof(RenderModel_TextureMap_t));
models[trackedDeviceIndex] = GLRenderModel.Create(renderModelName, renderModel, diffuseTexture);
OpenVR.RenderModels.FreeRenderModel(renderModelPtr);
OpenVR.RenderModels.FreeTexture(texturePtr);
}
return(new GLRenderModels(scene, models));
}
// 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;
}
public string GetRenderModelErrorNameFromEnum(EVRRenderModelError error)
{
IntPtr result = FnTable.GetRenderModelErrorNameFromEnum(error);
return Marshal.PtrToStringAnsi(result);
}
public uint GetRenderModelOriginalPath(string pchRenderModelName,System.Text.StringBuilder pchOriginalPath,uint unOriginalPathLen,ref EVRRenderModelError peError)
{
uint result = FnTable.GetRenderModelOriginalPath(pchRenderModelName,pchOriginalPath,unOriginalPathLen,ref peError);
return result;
}
public uint GetRenderModelThumbnailURL(string pchRenderModelName,System.Text.StringBuilder pchThumbnailURL,uint unThumbnailURLLen,ref EVRRenderModelError peError)
{
uint result = FnTable.GetRenderModelThumbnailURL(pchRenderModelName,pchThumbnailURL,unThumbnailURLLen,ref peError);
return result;
}
public uint GetRenderModelOriginalPath(string pchRenderModelName, StringBuilder pchOriginalPath, uint unOriginalPathLen, ref EVRRenderModelError peError) => default; // 0x00000001811DF590-0x00000001811DF5C0 public string GetRenderModelErrorNameFromEnum(EVRRenderModelError error) => default; // 0x00000001811DF4E0-0x00000001811DF560
public uint GetRenderModelThumbnailURL(string pchRenderModelName, StringBuilder pchThumbnailURL, uint unThumbnailURLLen, ref EVRRenderModelError peError) => default; // 0x00000001811DF5C0-0x00000001811DF5F0 public uint GetRenderModelOriginalPath(string pchRenderModelName, StringBuilder pchOriginalPath, uint unOriginalPathLen, ref EVRRenderModelError peError) => default; // 0x00000001811DF590-0x00000001811DF5C0
public bool RenderModelHasComponent(string pchRenderModelName, string pchComponentName) => default; // 0x00000001811DF650-0x00000001811DF680 public uint GetRenderModelThumbnailURL(string pchRenderModelName, StringBuilder pchThumbnailURL, uint unThumbnailURLLen, ref EVRRenderModelError peError) => default; // 0x00000001811DF5C0-0x00000001811DF5F0
// Token: 0x06001FDF RID: 8159 RVA: 0x0009E21F File Offset: 0x0009C41F
public string GetRenderModelErrorNameFromEnum(EVRRenderModelError error)
{
return(Marshal.PtrToStringAnsi(this.FnTable.GetRenderModelErrorNameFromEnum(error)));
}
// Token: 0x06001FDE RID: 8158 RVA: 0x0009E208 File Offset: 0x0009C408
public uint GetRenderModelOriginalPath(string pchRenderModelName, StringBuilder pchOriginalPath, uint unOriginalPathLen, ref EVRRenderModelError peError)
{
return(this.FnTable.GetRenderModelOriginalPath(pchRenderModelName, pchOriginalPath, unOriginalPathLen, ref peError));
}
// Token: 0x06001FDD RID: 8157 RVA: 0x0009E1F1 File Offset: 0x0009C3F1
public uint GetRenderModelThumbnailURL(string pchRenderModelName, StringBuilder pchThumbnailURL, uint unThumbnailURLLen, ref EVRRenderModelError peError)
{
return(this.FnTable.GetRenderModelThumbnailURL(pchRenderModelName, pchThumbnailURL, unThumbnailURLLen, ref peError));
}
public static RenderModelException Make(EVRRenderModelError errorCode)
{
string message = OpenVR.RenderModels.GetRenderModelErrorNameFromEnum(errorCode);
return(new RenderModelException(message, errorCode));
}
public RenderModelException(string message, EVRRenderModelError errorCode) : base(message)
{
this.errorCode = errorCode;
}
