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