public List <GizmoHandleHoverData> GetAllHandlesHoverData(Ray hoverRay)
{
List <GizmoHandleHoverData> hoverDataCollection = new List <GizmoHandleHoverData>(10);
foreach (IGizmoHandle handle in _handles)
{
GizmoHandleHoverData hoverData = handle.GetHoverData(hoverRay);
if (hoverData != null)
{
hoverDataCollection.Add(hoverData);
}
}
return(hoverDataCollection);
}
private void OnCanHoverHandle(int handleId, Gizmo gizmo, GizmoHandleHoverData hoverData, YesNoAnswer answer)
{
if (handleId == HandleId && gizmo == Gizmo)
{
if (LookAndFeel.PlaneType == GizmoPlane3DType.Circle && Settings.IsCircleHoverCullEnabled)
{
Vector3 hoverNormal = (hoverData.HoverPoint - Position).normalized;
if (Gizmo.FocusCamera.IsPointFacingCamera(hoverData.HoverPoint, hoverNormal))
{
answer.Yes();
}
else
{
answer.No();
}
return;
}
}
answer.Yes();
}
/// <summary>
/// This function traverses the handle's 2D and 3D shapes and decides which one is hovered
/// by the specified ray. It then returns the hover information inside an instance of the
/// 'GizmoHandleHoverData' class. The ray should be created using the 'Camera.ScreenPointToRay'
/// function and it represents the ray which is cast out from the screen into the 3D scene.
/// The function will always give priority to 2D shapes. So for example, if the handle has
/// a 2D and a 3D shape, and the ray hovers both of them, only the 2D shape will be taken into
/// account.
/// </summary>
/// <param name="hoverRay">
/// The hover ray. This should be created using the 'Camera.ScreenPointToRay' function. The
/// function will convert the origin of the ray in screen space to detect the 2D shapes which
/// are hovered by the ray.
/// </param>
/// <returns>
/// If a shape is hovered by the input ray, the function returns an instance of the
/// 'GizmoHandleHoverData' class. Otherwise, it returns null. The function also returns
/// null if there are any subscribers to the 'CanHover' event that don't allow the handle
/// to be hovered.
/// </returns>
public GizmoHandleHoverData GetHoverData(Ray hoverRay)
{
float minDist = float.MaxValue;
GizmoHandleHoverData handleHoverData = null;
if (Is2DHoverable && Is2DVisible)
{
Vector2 screenRayOrigin = Gizmo.GetWorkCamera().WorldToScreenPoint(hoverRay.origin);
GizmoHandleShape2D hovered2DShape = null;
foreach (var shape in _2DShapes)
{
if (shape.IsVisible && shape.IsHoverable)
{
if (shape.Shape.ContainsPoint(screenRayOrigin))
{
float dist = (shape.Shape.GetEncapsulatingRect().center - screenRayOrigin).magnitude;
if (hovered2DShape == null || dist < minDist)
{
hovered2DShape = shape;
minDist = dist;
}
}
}
}
if (hovered2DShape != null)
{
handleHoverData = new GizmoHandleHoverData(hoverRay, this, screenRayOrigin);
if (CanHover != null)
{
var answer = new YesNoAnswer();
CanHover(Id, Gizmo, handleHoverData, answer);
if (answer.HasNo)
{
return(null);
}
}
return(handleHoverData);
}
}
if (Is3DHoverable && Is3DVisible)
{
minDist = float.MaxValue;
GizmoHandleShape3D hovered3DShape = null;
foreach (var shape in _3DShapes)
{
if (shape.IsVisible && shape.IsHoverable)
{
float t;
if (shape.Shape.Raycast(hoverRay, out t))
{
if (hovered3DShape == null || t < minDist)
{
hovered3DShape = shape;
minDist = t;
}
}
}
}
if (hovered3DShape != null)
{
handleHoverData = new GizmoHandleHoverData(hoverRay, this, minDist);
if (CanHover != null)
{
var answer = new YesNoAnswer();
CanHover(Id, Gizmo, handleHoverData, answer);
if (answer.HasNo)
{
return(null);
}
}
return(handleHoverData);
}
}
return(null);
}
public void Update_SystemCall()
{
foreach (var sceneGizmoCam in _sceneGizmoCameras)
{
sceneGizmoCam.Update_SystemCall();
}
_pipelineStage = GizmosEnginePipelineStage.Update;
IInputDevice inputDevice = RTInputDevice.Get.Device;
bool deviceHasPointer = inputDevice.HasPointer();
Vector3 inputDevicePos = inputDevice.GetPositionYAxisUp();
bool isUIHovered = RTScene.Get.IsAnyUIElementHovered();
bool canUpdateHoverInfo = _draggedGizmo == null && !isUIHovered;
if (canUpdateHoverInfo)
{
YesNoAnswer answer = new YesNoAnswer();
if (CanDoHoverUpdate != null)
{
CanDoHoverUpdate(answer);
}
if (answer.HasNo)
{
canUpdateHoverInfo = false;
}
}
if (canUpdateHoverInfo)
{
_hoveredGizmo = null;
_gizmoHoverInfo.Reset();
}
bool isDeviceInsideFocusCamera = deviceHasPointer && RTFocusCamera.Get.IsViewportHoveredByDevice(); //RTFocusCamera.Get.TargetCamera.pixelRect.Contains(inputDevicePos);
bool focusCameraCanRenderGizmos = IsRenderCamera(RTFocusCamera.Get.TargetCamera);
var hoverDataCollection = new List <GizmoHandleHoverData>(10);
foreach (var gizmo in _gizmos)
{
gizmo.OnUpdateBegin_SystemCall();
if (canUpdateHoverInfo && gizmo.IsEnabled &&
isDeviceInsideFocusCamera && deviceHasPointer && focusCameraCanRenderGizmos)
{
var handleHoverData = GetGizmoHandleHoverData(gizmo);
if (handleHoverData != null)
{
hoverDataCollection.Add(handleHoverData);
}
}
}
GizmoHandleHoverData hoverData = null;
if (canUpdateHoverInfo && hoverDataCollection.Count != 0)
{
SortHandleHoverDataCollection(hoverDataCollection, inputDevicePos);
hoverData = hoverDataCollection[0];
_hoveredGizmo = hoverData.Gizmo;
_gizmoHoverInfo.HandleId = hoverData.HandleId;
_gizmoHoverInfo.HandleDimension = hoverData.HandleDimension;
_gizmoHoverInfo.HoverPoint = hoverData.HoverPoint;
_gizmoHoverInfo.IsHovered = true;
}
foreach (var gizmo in _gizmos)
{
_gizmoHoverInfo.IsHovered = (gizmo == _hoveredGizmo);
gizmo.UpdateHandleHoverInfo_SystemCall(_gizmoHoverInfo);
gizmo.HandleInputDeviceEvents_SystemCall();
gizmo.OnUpdateEnd_SystemCall();
}
_pipelineStage = GizmosEnginePipelineStage.PostUpdate;
}
