void ControllerLoader(params object[] args) { WVR_DeviceType type = (WVR_DeviceType)args[0]; GameObject controller = (GameObject)args[1]; if (device != type) { return; } physicalRaycaster = controller.AddComponent <PhysicsRaycaster>(); physicalRaycaster.eventMask = eventMask; switch (type) { case WVR_DeviceType.WVR_DeviceType_Controller_Left: evntSystem.GetComponent <WaveVR_ControllerInputModule>().LeftController = controller; break; case WVR_DeviceType.WVR_DeviceType_Controller_Right: evntSystem.GetComponent <WaveVR_ControllerInputModule>().RightController = controller; break; default: break; } }
private void PhysicRaycast(PhysicsRaycaster raycaster) { if (raycaster == null) { return; } List <RaycastResult> _raycast_results = new List <RaycastResult>(); raycaster.Raycast(pointerData, _raycast_results); RaycastResult _firstResult = FindFirstRaycast(_raycast_results); pointerData.pointerCurrentRaycast = _firstResult; //PrintDebugLog ("PhysicRaycast() first result = " + _firstResult); if (_firstResult.gameObject != null) { if (_firstResult.worldPosition == Vector3.zero) { _firstResult.worldPosition = GetIntersectionPosition( _firstResult.module.eventCamera, //_eventController.event_data.enterEventCamera, _firstResult ); pointerData.pointerCurrentRaycast = _firstResult; } pointerData.position = _firstResult.screenPosition; } }
protected override void Start() { base.Start(); // Create a new camera that will be used for raycasts //var obj = GameObject.Find("UI Camera"); //if (obj) //{ //uiCamera = obj.GetComponent<Camera>(); //raycaster = obj.GetComponent<PhysicsRaycaster>(); //} //else //{ uiCamera = new GameObject("UI Camera").AddComponent <Camera>(); // Added PhysicsRaycaster so that pointer events are sent to 3d objects raycaster = uiCamera.gameObject.AddComponent <PhysicsRaycaster>(); //} uiCamera.clearFlags = CameraClearFlags.Nothing; uiCamera.enabled = false; uiCamera.fieldOfView = 5; uiCamera.nearClipPlane = 0.01f; // Find canvases in the scene and assign our custom // UICamera to them var canvases = Resources.FindObjectsOfTypeAll <Canvas>(); foreach (var canvas in canvases) { canvas.worldCamera = uiCamera; } }
private void AddRaycaster() { if (SelectorCamera.objectReferenceValue != null) { DestroyImmediate(M.SelectorCamera.GetComponent <BaseRaycaster>()); var IRenderType = (ItemRenderer)ItemRendererType.enumValueIndex; switch (IRenderType) { case ItemRenderer.Mesh: PhysicsRaycaster Ph = M.SelectorCamera.gameObject.AddComponent <PhysicsRaycaster>(); Ph.eventMask = 32; break; case ItemRenderer.Sprite: Physics2DRaycaster Ph2d = M.SelectorCamera.gameObject.AddComponent <Physics2DRaycaster>(); Ph2d.eventMask = 32; break; case ItemRenderer.Canvas: break; default: break; } } }
private void Start() { SceneManager.sceneLoaded += OnSceneLoaded; _controllerDatas = new[] { new ControllerData { Device = _playerInputUpdater.RightHandInputDevice, GameObject = rightHandLaserPoint } }; // Create a new camera that will be used for raycasts UICamera = new GameObject("UI Camera").AddComponent <Camera>(); UICamera.transform.SetParent(transform, false); // Added PhysicsRaycaster so that pointer events are sent to 3d objects raycaster = UICamera.gameObject.AddComponent <PhysicsRaycaster>(); UICamera.clearFlags = CameraClearFlags.Nothing; UICamera.enabled = false; UICamera.fieldOfView = 5; UICamera.nearClipPlane = 0.01f; // Find canvases in the scene and assign our custom // UICamera to them }
private void PhysicRaycast(EventController event_controller, PhysicsRaycaster raycaster) { List <RaycastResult> _raycast_results = new List <RaycastResult>(); raycaster.Raycast(event_controller.event_data, _raycast_results); RaycastResult _firstResult = FindFirstRaycast(_raycast_results); event_controller.event_data.pointerCurrentRaycast = _firstResult; #if UNITY_EDITOR if (_firstResult.module != null) { //Debug.Log ("PhysicRaycast() device: " + event_controller.device + ", camera: " + _firstResult.module.eventCamera + ", first result = " + _firstResult); } #endif if (_firstResult.gameObject != null) { if (_firstResult.worldPosition == Vector3.zero) { _firstResult.worldPosition = GetIntersectionPosition( _firstResult.module.eventCamera, //_eventController.event_data.enterEventCamera, _firstResult ); event_controller.event_data.pointerCurrentRaycast = _firstResult; } event_controller.event_data.position = _firstResult.screenPosition; } }
private void CastToCenterOfScreen() { Camera _event_camera = Head.GetComponent <Camera> (); // center of screen gazeScreenPos2D.x = 0.5f * Screen.width; gazeScreenPos2D.y = 0.5f * Screen.height; gazeTargetPos = Vector3.zero; if (ringMesh != null) { ringMesh.RingPosition = gazeTargetPos; } ResetPointerEventData(); GraphicRaycast(_event_camera); PhysicsRaycaster phy_raycaster = null; phy_raycaster = Head.GetComponent <PhysicsRaycaster> (); if (phy_raycaster != null) { ResetPointerEventData(); PhysicsRaycast(phy_raycaster); } }
private void SetupEventController(EventController eventController, GameObject controller_model, LayerMask mask) { // Diactivate old controller, replace with new controller, activate new controller if (eventController.controller != null) { PrintDebugLog("SetupEventController() deactivate " + eventController.controller.name); eventController.controller.SetActive(false); } eventController.controller = controller_model; if (eventController.controller != null) { PrintDebugLog("SetupEventController() activate " + eventController.controller.name); eventController.controller.SetActive(true); // Get PhysicsRaycaster of controller. If none, add new one. PhysicsRaycaster _raycaster = eventController.controller.GetComponentInChildren <PhysicsRaycaster> (); if (_raycaster == null) { _raycaster = eventController.controller.AddComponent <PhysicsRaycaster> (); _raycaster.eventMask = mask; } // Get pointer and beam of controller. eventController.pointer = eventController.controller.GetComponentInChildren <WaveVR_ControllerPointer> (); eventController.beam = eventController.controller.GetComponentInChildren <WaveVR_Beam> (); Camera eventCam = eventController.controller.GetComponent <Camera>(); if (eventCam != null) { eventCam.enabled = false; } } }
public HitDetectionSystem(Contexts contexts, PhysicsRaycaster physicsRaycaster, ITickDeltaTimeStorage tickDeltaTimeStorage) { this.physicsRaycaster = physicsRaycaster; this.tickDeltaTimeStorage = tickDeltaTimeStorage; gameContext = contexts.serverGame; }
private void Awake() { physicsRaycaster = GetComponent <PhysicsRaycaster>(); CodeControl.Message.AddListener <CardGrabbedEvent>(OnCardGrabbed); CodeControl.Message.AddListener <CardDroppedEvent>(OnCardDropped); pointerEventData = new PointerEventData(EventSystem.current); }
private void AddRaycaster() { if (M.SelectorCamera) { DestroyImmediate(M.SelectorCamera.GetComponent <BaseRaycaster>()); switch (M.ItemRendererType) { case ItemRenderer.Mesh: PhysicsRaycaster Ph = M.SelectorCamera.gameObject.AddComponent <PhysicsRaycaster>(); Ph.eventMask = 32; break; case ItemRenderer.Sprite: Physics2DRaycaster Ph2d = M.SelectorCamera.gameObject.AddComponent <Physics2DRaycaster>(); Ph2d.eventMask = 32; break; case ItemRenderer.Canvas: break; default: break; } } }
/// <summary> /// Awake is called when the script instance is being loaded. /// </summary> private void Awake() { if (InventoryManager.m_Current != null) { //if(InventoryManager.DefaultSettings.debugMessages) // Debug.Log ("Multiple Inventory Manager in scene...this is not supported. Destroying instance!"); Destroy(gameObject); return; } else { InventoryManager.m_Current = this; if (EventSystem.current == null) { if (InventoryManager.DefaultSettings.debugMessages) { Debug.Log("Missing EventSystem in scene. Auto creating!"); } new GameObject("EventSystem", typeof(EventSystem), typeof(StandaloneInputModule)); } if (Camera.main != null && Camera.main.GetComponent <PhysicsRaycaster>() == null) { if (InventoryManager.DefaultSettings.debugMessages) { Debug.Log("Missing PhysicsRaycaster on Main Camera. Auto adding!"); } PhysicsRaycaster physicsRaycaster = Camera.main.gameObject.AddComponent <PhysicsRaycaster>(); physicsRaycaster.eventMask = Physics.DefaultRaycastLayers; } m_PrefabCache = new Dictionary <string, GameObject>(); UnityEngine.SceneManagement.SceneManager.activeSceneChanged += ChangedActiveScene; if (dontDestroyOnLoad) { if (transform.parent != null) { if (InventoryManager.DefaultSettings.debugMessages) { Debug.Log("Inventory Manager with DontDestroyOnLoad can't be a child transform. Unparent!"); } transform.parent = null; } DontDestroyOnLoad(gameObject); } if (InventoryManager.SavingLoading.autoSave) { StartCoroutine(RepeatSaving(InventoryManager.SavingLoading.savingRate)); } Physics.queriesHitTriggers = InventoryManager.DefaultSettings.queriesHitTriggers; if (InventoryManager.DefaultSettings.debugMessages) { Debug.Log("Inventory Manager initialized."); } } }
protected PhysicsRaycaster EnsurePhysicsRaycaster() { mPhysicsRaycaster = GetComponent <PhysicsRaycaster>(); if (mPhysicsRaycaster == null) { mPhysicsRaycaster = gameObject.AddComponent <PhysicsRaycaster>(); } return(mPhysicsRaycaster); }
private void Awake() { Instance = this; raycaster = GetComponent <PhysicsRaycaster>(); _mapMovement = _map.GetComponent <QuadTreeCameraMovement>(); Load(); }
//add physicsRaycaster to camera if it doesnt exist private void addPhysicsRaycaster() { PhysicsRaycaster physicsRaycaster = FindObjectOfType <PhysicsRaycaster>(); if (physicsRaycaster == null) { Camera.main.gameObject.AddComponent <PhysicsRaycaster>(); } }
protected override void InternalAwake() { this.gazeCamera = Camera.main; if (this.gazeCamera == null) { Debug.LogError("Could not find a camera that is tagged as \"Main Camera\""); return; } UpdateDataCollectors(); this.eventSystem = GetComponent <EventSystem>(); this.inputModule = GetComponent <GenericInputModule>(); var eventCameraObject = new GameObject("Event System Camera"); eventCameraObject.transform.SetParent(null); this.eventCamera = eventCameraObject.AddComponent <Camera>(); this.eventCamera.orthographic = true; this.eventCamera.orthographicSize = 0.05f; this.eventCamera.aspect = 1.0f; // make sure this is not a stereo camera this.eventCamera.stereoTargetEye = StereoTargetEyeMask.None; this.eventCamera.clearFlags = CameraClearFlags.SolidColor; this.eventCamera.renderingPath = RenderingPath.Forward; this.eventCamera.backgroundColor = Color.magenta * 0.25f; // color that is noticeable if not set correctly this.eventCamera.allowMSAA = false; this.eventCamera.allowHDR = false; this.eventCamera.nearClipPlane = .001f; this.eventCamera.farClipPlane = this.maxDistance; this.eventCamera.forceIntoRenderTexture = true; this.eventCamera.targetTexture = new RenderTexture(1, 1, 0); this.eventCameraScreenCenterPoint = new Vector3(eventCamera.rect.center.x, eventCamera.rect.center.y, eventCamera.nearClipPlane); // associate a raycaster for this eventSystem this.eventCameraRaycaster = this.eventCamera.gameObject.AddComponent <PhysicsRaycaster>(); this.eventCameraRaycaster.eventMask = this.eventCameraRaycaster.eventMask & ~(1 << LayerMask.NameToLayer("Ignore Raycast")); this.eventCameraRaycaster.enabled = false; // add physics raycaster to Main camera. this.gazeCameraRaycaster = this.gazeCamera.GetComponent <PhysicsRaycaster>(); if (this.gazeCameraRaycaster == null) { Debug.LogWarning("Adding Physics Raycaster(with Ignore Raycast mask) to Main camera. To remove this warning, add a Physics Raycaster component to the main camera."); this.gazeCameraRaycaster = this.gazeCamera.gameObject.AddComponent <PhysicsRaycaster>(); this.gazeCameraRaycaster.eventMask = this.eventCameraRaycaster.eventMask; this.gazeCameraRaycaster.enabled = false; } CheckForScreenSpaceChanges(this.gazeCamera); }
private void Awake() { mainCamera = Camera.main; physicsRaycaster = GetComponent <PhysicsRaycaster>(); CodeControl.Message.AddListener <CameraZoomChangeRequestEvent>(OnZoomChangeRequested); CodeControl.Message.AddListener <CameraPanStartRequestEvent>(OnCameraPanStartRequested); CodeControl.Message.AddListener <CameraPanEndRequestEvent>(OnCameraPanEndRequested); CodeControl.Message.AddListener <CameraRotateStartRequestEvent>(OnCameraRotateStartRequested); CodeControl.Message.AddListener <CameraRotateEndRequestEvent>(OnCameraRotateEnded); }
// Use this for initialization void Start() { Cursor.lockState = CursorLockMode.Locked; Cursor.visible = false; maestro = this.transform.parent.gameObject; raycaster = GetComponent <PhysicsRaycaster>(); crosshair.sprite = normalCrosshair; //ped = new PointerEventData(EventSystem.current); //ped.position = new Vector2(0.5f, 0.5f); }
private void AddRaycaster() { PhysicsRaycaster ray = gameObject.GetComponent <PhysicsRaycaster>(); if (ray == null) { ray = gameObject.AddComponent <PhysicsRaycaster>(); } LayerMask mask = -1; mask.value = LayerMask.GetMask("Default", "TransparentFX", "Water"); ray.eventMask = mask; }
protected override void Start() { base.Start(); // Create a new camera that will be used for raycasts UICamera = new GameObject("UI Camera").AddComponent <Camera>(); // Added PhysicsRaycaster so that pointer events are sent to 3d objects raycaster = UICamera.gameObject.AddComponent <PhysicsRaycaster>(); UICamera.clearFlags = CameraClearFlags.Nothing; UICamera.enabled = false; UICamera.fieldOfView = 5; UICamera.nearClipPlane = 0.01f; BindToVRUICam(); }
private void SetupEventController(EventController event_controller, GameObject controller_model) { LayerMask _mask = ~0; if (event_controller.controller != null) { PhysicsRaycaster _raycaster = event_controller.controller.GetComponentInChildren <PhysicsRaycaster> (); if (_raycaster != null) { _mask = _raycaster.eventMask; } } SetupEventController(event_controller, controller_model, _mask); }
// Adds the physics raycaster component // to the correct object in the hierarchy. private void AddPhysicsRaycasterToCamera(GameObject cardboardHead) { // Find existing raycaster. PhysicsRaycaster raycaster = cardboardHead.GetComponent <PhysicsRaycaster>(); // Otherwise, if (raycaster == null) { // Add the raycaster. raycaster = cardboardHead.AddComponent <PhysicsRaycaster>(); } // Remove Ignore Raycast layer from the event mask. raycaster.eventMask &= ~(1 << LayerMask.NameToLayer("Ignore Raycast")); }
static public EventListener Get(Component com) { PhysicsRaycaster raycaster = Camera.main.gameObject.GetComponent <PhysicsRaycaster>(); if (raycaster == null) { raycaster = Camera.main.gameObject.AddComponent <PhysicsRaycaster>(); } EventListener listener = com.GetComponent <EventListener>(); if (listener == null) { listener = com.gameObject.AddComponent <EventListener>(); } return(listener); }
static public UIEventListener Get(GameObject go) { PhysicsRaycaster raycaster = Camera.main.gameObject.GetComponent <PhysicsRaycaster>(); if (raycaster == null) { raycaster = Camera.main.gameObject.AddComponent <PhysicsRaycaster>(); } UIEventListener listener = go.GetComponent <UIEventListener>(); if (listener == null) { listener = go.AddComponent <UIEventListener>(); } return(listener); }
void OnEnable() { GazeInputModule.gazePointer = this; // create Physics Raycaster if this is attached to a camera Camera cam = transform.parent.GetComponent <Camera>(); if (cam != null) { PhysicsRaycaster raycaster = cam.GetComponent <PhysicsRaycaster>(); if (raycaster == null) { cam.gameObject.AddComponent <PhysicsRaycaster>(); } } }
public void OnSceneLoad(Scene scene, LoadSceneMode loadSceneMode) { if (HookCamera.Instance != null) { PhysicsRaycaster raycaster3D = HookCamera.Instance.GetComponent <PhysicsRaycaster>(); Physics2DRaycaster raycaster2D = HookCamera.Instance.GetComponent <Physics2DRaycaster>(); if (raycaster3D == null) { HookCamera.Instance.gameObject.AddComponent <PhysicsRaycaster>(); } if (raycaster2D == null) { HookCamera.Instance.gameObject.AddComponent <Physics2DRaycaster>(); } } }
public static int get_finalEventMask(IntPtr l) { int result; try { PhysicsRaycaster physicsRaycaster = (PhysicsRaycaster)LuaObject.checkSelf(l); LuaObject.pushValue(l, true); LuaObject.pushValue(l, physicsRaycaster.finalEventMask); result = 2; } catch (Exception e) { result = LuaObject.error(l, e); } return(result); }
public override void ActivateModule() { base.ActivateModule(); if (!activated) { // create event camera controllerCamera = new GameObject("Controller UI Camera").AddComponent <Camera>(); controllerCamera.clearFlags = CameraClearFlags.Depth; controllerCamera.cullingMask = layerMask; controllerCamera.depth = -100; controllerCamera.nearClipPlane = 0.05f; controllerCamera.farClipPlane = maxRange; controllerCamera.stereoTargetEye = StereoTargetEyeMask.None; PhysicsRaycaster prc = (PhysicsRaycaster)controllerCamera.gameObject.AddComponent <PhysicsRaycaster>(); prc.eventMask = layerMask; // assign event camera to all canvasses Canvas[] canvases = Resources.FindObjectsOfTypeAll <Canvas>(); foreach (Canvas canvas in canvases) { if (canvas.renderMode == RenderMode.WorldSpace) { canvas.worldCamera = controllerCamera; } } // create controller data strctures List <ControllerData> controllerDataList = new List <ControllerData>(); for (int idx = 0; idx < controllers.Length; idx++) { if (controllers[idx].trackedObject != null) { ControllerData data = new ControllerData(); data.transform = controllers[idx].trackedObject.transform; data.actionHandler = InputHandler.Find(controllers[idx].actionName); data.ray = controllers[idx].trackedObject.GetComponentInChildren <PointerRay>(); controllerDataList.Add(data); } } controllerData = controllerDataList.ToArray(); activated = true; } }
protected virtual void Start() { if (s_physicsRaycaster == null) { var camera = Camera.main; var cameraObject = camera.gameObject; s_physicsRaycaster = cameraObject.GetComponent <PhysicsRaycaster>() ?? cameraObject.AddComponent <PhysicsRaycaster>(); } if (EventSystem.current == null) { new GameObject( "EventSystem", typeof(EventSystem), typeof(StandaloneInputModule)); } }
public static int set_maxRayIntersections(IntPtr l) { int result; try { PhysicsRaycaster physicsRaycaster = (PhysicsRaycaster)LuaObject.checkSelf(l); int maxRayIntersections; LuaObject.checkType(l, 2, out maxRayIntersections); physicsRaycaster.maxRayIntersections = maxRayIntersections; LuaObject.pushValue(l, true); result = 1; } catch (Exception e) { result = LuaObject.error(l, e); } return(result); }