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; }