static string[] LoadRenderModelNames()
{
var results = new List <string>();
results.Add("None");
using (var holder = new SteamVR_RenderModel.RenderModelInterfaceHolder())
{
var renderModels = holder.instance;
if (renderModels != null)
{
uint count = renderModels.GetRenderModelCount();
for (uint i = 0; i < count; i++)
{
var buffer = new StringBuilder();
var requiredSize = renderModels.GetRenderModelName(i, buffer, 0);
if (requiredSize == 0)
{
continue;
}
buffer.EnsureCapacity((int)requiredSize);
renderModels.GetRenderModelName(i, buffer, requiredSize);
results.Add(buffer.ToString());
}
}
}
return(results.ToArray());
}
static string[] LoadRenderModelNames()
{
var results = new List<string>();
results.Add("None");
using (var holder = new SteamVR_RenderModel.RenderModelInterfaceHolder())
{
var renderModels = holder.instance;
if (renderModels != null)
{
uint count = renderModels.GetRenderModelCount();
for (uint i = 0; i < count; i++)
{
var buffer = new StringBuilder();
var requiredSize = renderModels.GetRenderModelName(i, buffer, 0);
if (requiredSize == 0)
continue;
buffer.EnsureCapacity((int)requiredSize);
renderModels.GetRenderModelName(i, buffer, requiredSize);
results.Add(buffer.ToString());
}
}
}
return results.ToArray();
}
private void OnRenderModelLoaded(SteamVR_RenderModel renderModel, bool succeess)
{
if (renderModel == this.renderModel)
{
this.textHintParent = new GameObject("Text Hints").transform;
this.textHintParent.SetParent(base.transform);
this.textHintParent.localPosition = Vector3.zero;
this.textHintParent.localRotation = Quaternion.identity;
this.textHintParent.localScale = Vector3.one;
using (SteamVR_RenderModel.RenderModelInterfaceHolder renderModelInterfaceHolder = new SteamVR_RenderModel.RenderModelInterfaceHolder())
{
CVRRenderModels instance = renderModelInterfaceHolder.instance;
if (instance != null)
{
string text = "Components for render model " + renderModel.index;
IEnumerator enumerator = renderModel.transform.GetEnumerator();
try
{
while (enumerator.MoveNext())
{
object obj = enumerator.Current;
Transform transform = (Transform)obj;
ulong componentButtonMask = instance.GetComponentButtonMask(renderModel.renderModelName, transform.name);
this.componentButtonMasks.Add(new KeyValuePair <string, ulong>(transform.name, componentButtonMask));
string text2 = text;
text = string.Concat(new object[]
{
text2,
"\n\t",
transform.name,
": ",
componentButtonMask
});
}
}
finally
{
IDisposable disposable;
if ((disposable = (enumerator as IDisposable)) != null)
{
disposable.Dispose();
}
}
this.HintDebugLog(text);
}
}
this.buttonHintInfos = new Dictionary <EVRButtonId, ControllerButtonHints.ButtonHintInfo>();
this.CreateAndAddButtonInfo(EVRButtonId.k_EButton_Axis1);
this.CreateAndAddButtonInfo(EVRButtonId.k_EButton_ApplicationMenu);
this.CreateAndAddButtonInfo(EVRButtonId.k_EButton_System);
this.CreateAndAddButtonInfo(EVRButtonId.k_EButton_Grip);
this.CreateAndAddButtonInfo(EVRButtonId.k_EButton_Axis0);
this.CreateAndAddButtonInfo(EVRButtonId.k_EButton_A);
this.ComputeTextEndTransforms();
this.initialized = true;
renderModel.gameObject.SetActive(false);
}
}
// Token: 0x06000DE0 RID: 3552 RVA: 0x00058476 File Offset: 0x00056676
private IEnumerator FreeRenderModel(IntPtr pRenderModel)
{
yield return(new WaitForSeconds(1f));
using (SteamVR_RenderModel.RenderModelInterfaceHolder renderModelInterfaceHolder = new SteamVR_RenderModel.RenderModelInterfaceHolder())
{
renderModelInterfaceHolder.instance.FreeRenderModel(pRenderModel);
yield break;
}
yield break;
}
//-------------------------------------------------
void OnRenderModelLoaded(SteamVR_RenderModel renderModel, bool succeess)
{
//Only initialize when the render model for the controller hints has been loaded
if (renderModel == this.renderModel)
{
textHintParent = new GameObject("Text Hints").transform;
textHintParent.SetParent(this.transform);
textHintParent.localPosition = Vector3.zero;
textHintParent.localRotation = Quaternion.identity;
textHintParent.localScale = Vector3.one;
//Get the button mask for each component of the render model
using (var holder = new SteamVR_RenderModel.RenderModelInterfaceHolder())
{
var renderModels = holder.instance;
if (renderModels != null)
{
string renderModelDebug = "Components for render model " + renderModel.index;
foreach (Transform child in renderModel.transform)
{
ulong buttonMask = renderModels.GetComponentButtonMask(renderModel.renderModelName, child.name);
componentButtonMasks.Add(new KeyValuePair <string, ulong>(child.name, buttonMask));
renderModelDebug += "\n\t" + child.name + ": " + buttonMask;
}
//Uncomment to show the button mask for each component of the render model
HintDebugLog(renderModelDebug);
}
}
buttonHintInfos = new Dictionary <EVRButtonId, ButtonHintInfo>();
CreateAndAddButtonInfo(EVRButtonId.k_EButton_SteamVR_Trigger);
CreateAndAddButtonInfo(EVRButtonId.k_EButton_ApplicationMenu);
CreateAndAddButtonInfo(EVRButtonId.k_EButton_System);
CreateAndAddButtonInfo(EVRButtonId.k_EButton_Grip);
CreateAndAddButtonInfo(EVRButtonId.k_EButton_SteamVR_Touchpad);
CreateAndAddButtonInfo(EVRButtonId.k_EButton_A);
ComputeTextEndTransforms();
initialized = true;
//Set the controller hints render model to not active
renderModel.gameObject.SetActive(false);
}
}
// Token: 0x06000DDE RID: 3550 RVA: 0x00057F6C File Offset: 0x0005616C
private bool SetModel(string renderModelName)
{
this.StripMesh(base.gameObject);
using (SteamVR_RenderModel.RenderModelInterfaceHolder renderModelInterfaceHolder = new SteamVR_RenderModel.RenderModelInterfaceHolder())
{
if (this.createComponents)
{
if (this.LoadComponents(renderModelInterfaceHolder, renderModelName))
{
this.UpdateComponents(renderModelInterfaceHolder.instance);
return(true);
}
Debug.Log("[" + base.gameObject.name + "] Render model does not support components, falling back to single mesh.");
}
if (!string.IsNullOrEmpty(renderModelName))
{
SteamVR_RenderModel.RenderModel renderModel = SteamVR_RenderModel.models[renderModelName] as SteamVR_RenderModel.RenderModel;
if (renderModel == null || renderModel.mesh == null)
{
CVRRenderModels instance = renderModelInterfaceHolder.instance;
if (instance == null)
{
return(false);
}
if (this.verbose)
{
Debug.Log("Loading render model " + renderModelName);
}
renderModel = this.LoadRenderModel(instance, renderModelName, renderModelName);
if (renderModel == null)
{
return(false);
}
SteamVR_RenderModel.models[renderModelName] = renderModel;
}
base.gameObject.AddComponent <MeshFilter>().mesh = renderModel.mesh;
base.gameObject.AddComponent <MeshRenderer>().sharedMaterial = renderModel.material;
return(true);
}
}
return(false);
}
public void UpdateComponents()
{
Transform transform = base.transform;
if (transform.childCount == 0)
{
return;
}
using (SteamVR_RenderModel.RenderModelInterfaceHolder renderModelInterfaceHolder = new SteamVR_RenderModel.RenderModelInterfaceHolder())
{
VRControllerState_t vRControllerState_t = (this.index == SteamVR_TrackedObject.EIndex.None) ? default(VRControllerState_t) : SteamVR_Controller.Input((int)this.index).GetState();
for (int i = 0; i < transform.childCount; i++)
{
Transform child = transform.GetChild(i);
CVRRenderModels instance = renderModelInterfaceHolder.instance;
if (instance == null)
{
break;
}
RenderModel_ComponentState_t renderModel_ComponentState_t = default(RenderModel_ComponentState_t);
RenderModel_ControllerMode_State_t renderModel_ControllerMode_State_t = default(RenderModel_ControllerMode_State_t);
if (instance.GetComponentState(this.renderModelName, child.name, ref vRControllerState_t, ref renderModel_ControllerMode_State_t, ref renderModel_ComponentState_t))
{
SteamVR_Utils.RigidTransform rigidTransform = new SteamVR_Utils.RigidTransform(renderModel_ComponentState_t.mTrackingToComponentRenderModel);
child.localPosition = rigidTransform.pos;
child.localRotation = rigidTransform.rot;
Transform transform2 = child.FindChild("attach");
if (transform2 != null)
{
SteamVR_Utils.RigidTransform rigidTransform2 = new SteamVR_Utils.RigidTransform(renderModel_ComponentState_t.mTrackingToComponentLocal);
transform2.position = transform.TransformPoint(rigidTransform2.pos);
transform2.rotation = transform.rotation * rigidTransform2.rot;
}
bool flag = (renderModel_ComponentState_t.uProperties & 2u) != 0u;
if (flag != child.gameObject.activeSelf)
{
child.gameObject.SetActive(flag);
}
}
}
}
}
// 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: 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);
}
private bool SetModel(string renderModelName)
{
this.StripMesh(base.gameObject);
using (SteamVR_RenderModel.RenderModelInterfaceHolder renderModelInterfaceHolder = new SteamVR_RenderModel.RenderModelInterfaceHolder())
{
if (this.createComponents)
{
if (this.LoadComponents(renderModelInterfaceHolder, renderModelName))
{
this.UpdateComponents();
bool result = true;
return result;
}
UnityEngine.Debug.Log("[" + base.gameObject.name + "] Render model does not support components, falling back to single mesh.");
}
if (!string.IsNullOrEmpty(renderModelName))
{
SteamVR_RenderModel.RenderModel renderModel = SteamVR_RenderModel.models[renderModelName] as SteamVR_RenderModel.RenderModel;
bool result;
if (renderModel == null || renderModel.mesh == null)
{
CVRRenderModels instance = renderModelInterfaceHolder.instance;
if (instance == null)
{
result = false;
return result;
}
if (this.verbose)
{
UnityEngine.Debug.Log("Loading render model " + renderModelName);
}
renderModel = this.LoadRenderModel(instance, renderModelName, renderModelName);
if (renderModel == null)
{
result = false;
return result;
}
SteamVR_RenderModel.models[renderModelName] = renderModel;
}
base.gameObject.AddComponent<MeshFilter>().mesh = renderModel.mesh;
base.gameObject.AddComponent<MeshRenderer>().sharedMaterial = renderModel.material;
result = true;
return result;
}
}
return false;
}