private void InitController(int index)
{
if (controller == null)
{
controller = SteamVR_Controller.Input(index);
gameObject.AddComponent <SteamVR_TrackedObject>().index = (SteamVR_TrackedObject.EIndex)index;
//
// Update and show SteamVR_RenderModel
//
if (createRenderModel)
{
renderModel = new GameObject("SteamVR_RenderModel").AddComponent <SteamVR_RenderModel>();
renderModel.transform.parent = transform;
renderModel.transform.localPosition = Vector3.zero;
renderModel.transform.localRotation = Quaternion.identity;
renderModel.transform.localScale = Vector3.one;
}
else
{
renderModel = GetComponentInChildren <SteamVR_RenderModel>();
}
if (renderModel != null)
{
renderModel.modelOverride = null;
renderModel.index = (SteamVR_TrackedObject.EIndex)index;
renderModel.enabled = true;
renderModel.UpdateModel();
}
this.BroadcastMessage("OnHandInitialized", index, SendMessageOptions.DontRequireReceiver); // let child objects know we've initialized
}
}
private void RenderModelLoaded(SteamVR_RenderModel renderModel, bool success)
{
if (success && modelsToInitialize.Contains(renderModel))
{
modelsToInitialize.Remove(renderModel);
}
}
public override void Start()
{
base.Start();
SteamVR_Render.instance.transform.parent = gameObject.transform;
m_LeftModel = m_LeftHand.GetComponentInChildren <SteamVR_RenderModel>(); // TODO: AddComponent at runtime and remove it from the prefab (requires the steam device model loading to work properly in editor)
m_RightModel = m_RightHand.GetComponentInChildren <SteamVR_RenderModel>();
}
protected void Awake()
{
renderModelLoadedAction = SteamVR_Events.RenderModelLoadedAction(OnRenderModelLoaded);
if (handPrefab != null)
{
handInstance = GameObject.Instantiate(handPrefab);
handInstance.transform.parent = this.transform;
handInstance.transform.localPosition = Vector3.zero;
handInstance.transform.localRotation = Quaternion.identity;
handInstance.transform.localScale = handPrefab.transform.localScale;
handSkeleton = handInstance.GetComponent <SteamVR_Behaviour_Skeleton>();
handSkeleton.updatePose = false;
handRenderers = handInstance.GetComponentsInChildren <Renderer>();
if (displayHandByDefault == false)
{
SetHandVisibility(false);
}
handAnimator = handInstance.GetComponentInChildren <Animator>();
}
if (controllerPrefab != null)
{
controllerInstance = GameObject.Instantiate(controllerPrefab);
controllerInstance.transform.parent = this.transform;
controllerInstance.transform.localPosition = Vector3.zero;
controllerInstance.transform.localRotation = Quaternion.identity;
controllerInstance.transform.localScale = controllerPrefab.transform.localScale;
controllerRenderModel = controllerInstance.GetComponent <SteamVR_RenderModel>();
}
}
private void Action(SteamVR_RenderModel arg0, bool arg1)
{
InteractionTechnique interactionTechnique = TaskController.Instance.GetInteractionTechnique();
if (interactionTechnique && !interactionTechnique.moveHoverPoint)
{
return;
}
Hand hand = arg0.GetComponentInParent <Hand>();
if (!hand)
{
return;
}
Transform hoverPoint = hand.transform.Find("HoverPoint");
if (!hoverPoint)
{
return;
}
if (arg0.renderModelName.Contains("vive_cosmos"))
{
hoverPoint.localPosition = ViveCosmosHoverPointPosition;
}
else if (arg0.renderModelName.Contains("controller_vive"))
{
hoverPoint.localPosition = ViveProHoverPointPosition;
}
}
public bool SetActiveController(SVControllerType activeController)
{
if (activeController == SVControllerType.SVController_Left &&
SVControllerManager.leftControllerActive)
{
return(false);
}
if (activeController == SVControllerType.SVController_Right &&
SVControllerManager.rightControllerActive)
{
return(false);
}
this.activeController = activeController;
#if USES_STEAM_VR
this.activeControllerDevice = Controller(activeController);
this.activeRenderModel = SteamController(this.activeController).GetComponentInChildren <SteamVR_RenderModel>();
#endif
if (this.activeController == SVControllerType.SVController_Right)
{
SVControllerManager.rightControllerActive = true;
}
else
{
SVControllerManager.leftControllerActive = true;
}
return(true);
}
//-------------------------------------------------
void Update()
{
// Only update one per frame
if (lastFrameUpdated == Time.renderedFrameCount)
{
return;
}
lastFrameUpdated = Time.renderedFrameCount;
// SpawnRenderModel overflow
if (spawnRenderModelUpdateIndex >= spawnRenderModels.Count)
{
spawnRenderModelUpdateIndex = 0;
}
// Perform update
if (spawnRenderModelUpdateIndex < spawnRenderModels.Count)
{
SteamVR_RenderModel renderModel = spawnRenderModels[spawnRenderModelUpdateIndex].renderModels[0];
if (renderModel != null)
{
renderModel.UpdateComponents(OpenVR.RenderModels);
}
}
spawnRenderModelUpdateIndex++;
}
protected override void OnAwake()
{
var sphere = GameObject.CreatePrimitive(PrimitiveType.Sphere);
sphere.transform.SetParent(transform, false);
var sphere2 = GameObject.CreatePrimitive(PrimitiveType.Sphere);
sphere2.transform.SetParent(transform, false);
transform.localScale = 0.3f * Vector3.one;
transform.localScale = new Vector3(0.2f, 0.2f, 0.4f);
sphere.transform.localScale = Vector3.one * 0.3f;
sphere.transform.localPosition = Vector3.forward * 0.5f;
sphere2.transform.localScale = Vector3.one * 0.3f;
sphere2.transform.localPosition = Vector3.up * 0.5f;
GetComponent <Collider>().isTrigger = true;
// Disable head camera, which is usually used for screen output
model = new GameObject("Model").AddComponent <SteamVR_RenderModel>();
model.transform.SetParent(VR.Camera.SteamCam.head, false);
model.shader = VR.Context.Materials.StandardShader;
model.SetDeviceIndex((int)OpenVR.k_unTrackedDeviceIndex_Hmd);
model.gameObject.layer = LayerMask.NameToLayer(VR.Context.InvisibleLayer);
var cam = gameObject.AddComponent <Camera>();
cam.depth = 1;
cam.nearClipPlane = 0.3f;
cam.cullingMask = int.MaxValue & ~VR.Context.UILayerMask;
transform.position = S_Position;
transform.rotation = S_Rotation;
}
//protected SteamVR_Events.Action renderModelLoadedAction;
//protected void Awake()
//{
// renderModelLoadedAction = SteamVR_Events.RenderModelLoadedAction(OnRenderModelLoaded);
//}
//private void OnRenderModelLoaded(SteamVR_RenderModel loadedRenderModel, bool success)
//{
// print(1);
//}
void Start()
{
if (!PivotPoser)
{
PivotPoser = new GameObject().transform;
}
PivotPoser.hideFlags = HideFlags.HideInHierarchy;
if (!ToolTransform)
{
ToolTransform = new GameObject().transform;
}
ToolTransform.hideFlags = HideFlags.HideInHierarchy;
if (GetComponent <SteamVR_Behaviour_Pose>())
{
handType = GetComponent <SteamVR_Behaviour_Pose>().inputSource;
}
else
{
Debug.LogError("no SteamVR_Behaviour_Pose on this object");
}
if (GetComponentInChildren <SteamVR_Behaviour_Skeleton>())
{
skeleton = GetComponentInChildren <SteamVR_Behaviour_Skeleton>();
}
if (GetComponentInChildren <SteamVR_RenderModel>())
{
RenderModel = GetComponentInChildren <SteamVR_RenderModel>();
StartCoroutine(HideControllerCoroutine());
}
skeleton.BlendToSkeleton();
}
private SteamVR_TrackedObject.EIndex GetModelType()
{
Transform model = transform.parent.Find("Model");
SteamVR_RenderModel m = model.GetComponent <SteamVR_RenderModel>();
return(m.index);
}
private void OnRenderModelLoaded(SteamVR_RenderModel renderModel, bool success)
{
Assert.IsNotNull(renderModel);
if (renderModel != _sourceModel)
{
Restore();
return;
}
if (!success)
{
Restore();
return;
}
var tip = _sourceModel.FindComponent("tip");
if (tip != null)
{
Assert.IsTrue(tip.childCount >= 1);
var attach = tip.GetChild(0);
Assert.IsNotNull(attach);
_origin = attach;
_selfTransform.position = _origin.position + _currentOffset;
_selfTransform.rotation = _origin.rotation;
}
else
{
Restore();
}
}
private IEnumerator MigrateModel(SteamVR_RenderModel model, IVRAvatarHand hand)
{
var controllerVisual = hand.Transform.GetComponentInChildren <VRAvatarController>(includeInactive: true);
yield return(new WaitUntil(() => model.transform.childCount != 1));
if (controllerVisual == null)
{
model.SetMeshRendererState(false);
yield break;
}
model.transform.SetParent(controllerVisual.transform);
model.transform.localPosition = Vector3.zero;
model.transform.localRotation = Quaternion.identity;
switch (XRDeviceUtils.GetDeviceModelType())
{
case EDeviceModelType.HtcVive:
case EDeviceModelType.HtcViveCosmos:
case EDeviceModelType.HtcVivePro:
hand.Anchor.transform.localPosition += new Vector3(0, 0, -0.1f);
model.transform.localPosition = new Vector3(0, 0, 0.1f);
break;
}
var pointerVisual = controllerVisual.GetComponentInChildren <LaserPointerVisual>(includeInactive: true);
pointerVisual.Bind(hand.InputDevice.Pointer);
hand.InputDevice.Pointer.Transform = pointerVisual.transform;
}
//-------------------------------------------------
private void OnRenderModelLoaded(SteamVR_RenderModel renderModel, bool success)
{
if (renderModel != this.renderModel)
{
return;
}
Transform bodyTransform = transform.Find("body");
if (bodyTransform != null)
{
bodyMeshRenderer = bodyTransform.GetComponent <MeshRenderer>();
bodyMeshRenderer.material = highLightMaterial;
bodyMeshRenderer.enabled = false;
}
Transform trackingHatTransform = transform.Find("trackhat");
if (trackingHatTransform != null)
{
trackingHatMeshRenderer = trackingHatTransform.GetComponent <MeshRenderer>();
trackingHatMeshRenderer.material = highLightMaterial;
trackingHatMeshRenderer.enabled = false;
}
foreach (Transform child in transform)
{
if ((child.name != "body") && (child.name != "trackhat"))
{
Destroy(child.gameObject);
}
}
renderModelLoaded = true;
}
/// <summary>
/// Call this method when the RenderModelLoaded event is triggered.
/// </summary>
/// <param name="args">SteamVR_RenderModel renderModel, bool success</param>
void OnControllerLoaded(SteamVR_RenderModel renderModel, bool success)
{
if (!success)
{
return;
}
UpdateControllerTexture(albedoTexture, renderModel.gameObject.transform);
}
private void OnRenderModelLoaded(SteamVR_RenderModel model, bool connected)
{
Renderer[] renderers = model.gameObject.GetComponentsInChildren <MeshRenderer>();
foreach (Renderer renderer in renderers)
{
renderer.material = controllerMaterial;
}
}
private void Awake()
{
pose = GetComponent <SteamVR_Behaviour_Pose>();
joint = GetComponent <FixedJoint>();
skeleton = GetComponentInChildren <SteamVR_Behaviour_Skeleton>();
handRenderer = skeleton.GetComponentInChildren <Animator>().GetComponentInChildren <SkinnedMeshRenderer>();
controllerRenderer = GetComponentInChildren <SteamVR_RenderModel>();
}
protected override void OnEnable()
{
render = GetComponent <SteamVR_RenderModel>();
SteamVR_Events.RenderModelLoaded.AddListener(HandleRenderLoaded);
base.OnEnable();
}
/// <summary>
/// Call this method, when the "render_model_loaded" event is triggered.
/// </summary>
/// <param name="args">bool success, SteamVR_RenderModel model</param>
/*void OnControllerLoaded(params object[] args)
* {
* if ((bool)args[1])
* {
* SteamVR_RenderModel controllerRenderModel = (SteamVR_RenderModel)args[0];
* UpdateControllerTexture(newBodyTexture, controllerRenderModel.gameObject.transform);
* }
* } */
void OnControllerLoaded(SteamVR_RenderModel renderModel, bool success)
{
// if (success)
// {
Debug.Log("changing Texture");
UpdateControllerTexture(newBodyTexture, renderModel.gameObject.transform);
// }
}
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);
}
}
public void ShowModel()
{
SteamVR_RenderModel model = GetComponentInChildren <SteamVR_RenderModel>();
if (model)
{
model.gameObject.SetActive(true);
}
}
void OnHandInitialized( int deviceIndex )
{
renderModel = new GameObject( "SteamVR_RenderModel" ).AddComponent<SteamVR_RenderModel>();
renderModel.transform.parent = transform;
renderModel.transform.localPosition = Vector3.zero;
renderModel.transform.localRotation = Quaternion.identity;
renderModel.SetDeviceIndex( deviceIndex );
renderModel.gameObject.SetActive( false );
}
void OnHandInitialized(int deviceIndex)
{
renderModel = new GameObject("SteamVR_RenderModel").AddComponent <SteamVR_RenderModel>();
renderModel.transform.parent = transform;
renderModel.transform.localPosition = Vector3.zero;
renderModel.transform.localRotation = Quaternion.identity;
renderModel.SetDeviceIndex(deviceIndex);
renderModel.gameObject.SetActive(false);
}
// Token: 0x06001330 RID: 4912 RVA: 0x0006B7A8 File Offset: 0x000699A8
public override void SetControllerRenderModelWheel(GameObject renderModel, bool state)
{
SteamVR_RenderModel component = renderModel.GetComponent <SteamVR_RenderModel>();
if (component != null)
{
component.controllerModeState.bScrollWheelVisible = state;
}
}
// Token: 0x0600132F RID: 4911 RVA: 0x0006B77C File Offset: 0x0006997C
public override GameObject GetControllerRenderModel(VRTK_ControllerReference controllerReference)
{
SteamVR_RenderModel componentInChildren = controllerReference.actual.GetComponentInChildren <SteamVR_RenderModel>();
if (!(componentInChildren != null))
{
return(null);
}
return(componentInChildren.gameObject);
}
void Awake()
{
ButtonDataSet = new Dictionary <string, ButtonObjectData>();
_TrackedController = GetComponent <SteamVR_TrackedObject>();
h_hover = Animator.StringToHash("Hover");
h_press = Animator.StringToHash("Press");
model = GetComponentInChildren <SteamVR_RenderModel>();
}
private void RenderModelLoaded(params object[] args)
{
SteamVR_RenderModel renderModel = (SteamVR_RenderModel)args[0];
bool success = (bool)args[1];
if ((int)renderModel.index == DeviceIndex)
{
RenderModelInitialized = true;
}
}
/// <summary>
/// Assign the correct custom model to a tracked device, or enable its SteamVR_RenderModel if a custom model is
/// not provided. Set the PrimaryDeviceBehaviourPose or NonDominantDeviceBehaviourPose with the related SteamVR SteamVR_Behaviour_Pose.
/// </summary>
/// <remarks>Should generally be used in SteamVR_Behaviour_Pose Unity Events, or called by a SteamVR broadcast message.</remarks>
public void AssignController(SteamVR_Behaviour_Pose steamVRBehaviourPose)
{
int deviceIndex = steamVRBehaviourPose.GetDeviceIndex();
if (deviceIndex == -1)
{
return;
}
// Remove any previously parented model to prevent two models from getting parented to one device.
Transform parentedModel = steamVRBehaviourPose.GetComponentsInChildren <Transform>()
.FirstOrDefault(x => x == _primaryDeviceModel || x == _nonDominantDeviceModel);
if (parentedModel != null)
{
parentedModel.parent = null;
parentedModel.gameObject.SetActive(false);
}
string controllerModelName = GetControllerProperty(deviceIndex, ETrackedDeviceProperty.Prop_ModelNumber_String).ToLower();
SteamVR_RenderModel steamVRRenderModel = steamVRBehaviourPose.GetComponentInChildren <SteamVR_RenderModel>(true);
if (controllerModelName.Contains(_primaryDeviceModelName.ToLower()))
{
if (_primaryDeviceModel != null)
{
PrimaryDeviceBehaviourPose = steamVRBehaviourPose;
_primaryDeviceModel.position = steamVRBehaviourPose.transform.position;
_primaryDeviceModel.rotation = steamVRBehaviourPose.transform.rotation;
_primaryDeviceModel.parent = steamVRBehaviourPose.transform;
_primaryDeviceModel.gameObject.SetActive(true);
steamVRRenderModel.gameObject.SetActive(false);
}
else
{
steamVRRenderModel.gameObject.SetActive(true);
}
}
else
{
if (_nonDominantDeviceModel != null)
{
NonDominantDeviceBehaviourPose = steamVRBehaviourPose;
_nonDominantDeviceModel.position = steamVRBehaviourPose.transform.position;
_nonDominantDeviceModel.rotation = steamVRBehaviourPose.transform.rotation;
_nonDominantDeviceModel.parent = steamVRBehaviourPose.transform;
_nonDominantDeviceModel.gameObject.SetActive(true);
steamVRRenderModel.gameObject.SetActive(false);
}
else
{
steamVRRenderModel.gameObject.SetActive(true);
}
}
}
/// <summary>
/// Call this method when the RenderModelLoaded event is triggered.
/// </summary>
/// <param name="args">SteamVR_RenderModel renderModel, bool success</param>
void OnControllerLoaded(SteamVR_RenderModel renderModel, bool success)
{
if (!success)
{
return;
}
if (gameObject == renderModel.gameObject)
{
UpdateControllerTexture(newBodyTexture, renderModel.gameObject.transform);
}
}
public void CleanUpModelObj()
{
if (m_modelObj != null)
{
#if VIU_STEAMVR
m_renderModel = null;
#endif
Destroy(m_modelObj);
m_modelObj = null;
}
}
private void Awake()
{
SteamVR_TrackedController controller = GetComponent <SteamVR_TrackedController>();
controller.TriggerClicked += OnTriggerCliked;
controller.TriggerUnclicked += OnTriggerUncliked;
renderModel = GetComponentInChildren <SteamVR_RenderModel>();
draggables = FindObjectsOfType <DraggableObject>();
}
void Start()
{
//controllerTracker = GetComponent<ZEDControllerTracker>();
#if ZED_STEAM_VR
renderModel = GetComponent <SteamVR_RenderModel>();
if (!renderModel)
{
renderModel = gameObject.AddComponent <SteamVR_RenderModel>();
}
#endif
}
void Awake()
{
if ( hoverSphereTransform == null )
{
hoverSphereTransform = this.transform;
}
//
// Find render model and deactivate until we know which controller we're tracking
//
renderModel = GetComponentInChildren<SteamVR_RenderModel>();
if ( ( renderModel != null ) && ( renderModel.gameObject != gameObject ) )
{
renderModel.gameObject.SetActive( false );
}
}
private void InitController( int index )
{
if ( controller == null )
{
controller = SteamVR_Controller.Input( index );
gameObject.AddComponent<SteamVR_TrackedObject>().index = (SteamVR_TrackedObject.EIndex)index;
//
// Update and show SteamVR_RenderModel
//
if ( createRenderModel )
{
renderModel = new GameObject( "SteamVR_RenderModel" ).AddComponent<SteamVR_RenderModel>();
renderModel.transform.parent = transform;
renderModel.transform.localPosition = Vector3.zero;
renderModel.transform.localRotation = Quaternion.identity;
renderModel.transform.localScale = Vector3.one;
}
else
{
renderModel = GetComponentInChildren<SteamVR_RenderModel>();
}
if ( renderModel != null )
{
renderModel.modelOverride = null;
renderModel.index = (SteamVR_TrackedObject.EIndex)index;
renderModel.enabled = true;
renderModel.UpdateModel();
}
this.BroadcastMessage( "OnHandInitialized", index, SendMessageOptions.DontRequireReceiver ); // let child objects know we've initialized
}
}
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)
{
UnityEngine.Debug.Log("Loading render model " + stringBuilder2);
}
renderModel = this.LoadRenderModel(instance, stringBuilder2.ToString(), renderModelName);
if (renderModel == null)
{
goto IL_265;
}
SteamVR_RenderModel.models[stringBuilder2] = renderModel;
}
transform.gameObject.AddComponent<MeshFilter>().mesh = renderModel.mesh;
transform.gameObject.AddComponent<MeshRenderer>().sharedMaterial = renderModel.material;
}
}
}
}
IL_265:
num++;
}
return true;
}
