public override void IntersectWith(GShape gShape)
{
IntersectionResult res;
//if (gShape is GLine)
//{
// res = Intersection.ArcLine(this, (GLine)gShape);
// if (res.IntersectionPoints.Count == 0) return;
// IntersectionResults.Add(res);
//}
if (gShape is GRectangle)
{
new IntersectionResult();
foreach (var line in ((GRectangle)gShape).Lines)
{
res = Intersection.ArcLine(this, line);
if (res.IntersectionPoints.Count == 0)
{
return;
}
IntersectionResults.Add(res);
}
}
}
public bool ComputeIntersection(Vector3 source, Vector3 direction, ref IntersectionResults results)
{
var overlay = OpenVR.Overlay;
if (overlay == null)
{
return(false);
}
var input = new VROverlayIntersectionParams_t();
input.eOrigin = SteamVR_Render.instance.trackingSpace;
input.vSource.v0 = source.x;
input.vSource.v1 = source.y;
input.vSource.v2 = -source.z;
input.vDirection.v0 = direction.x;
input.vDirection.v1 = direction.y;
input.vDirection.v2 = -direction.z;
var output = new VROverlayIntersectionResults_t();
if (!overlay.ComputeOverlayIntersection(handle, ref input, ref output))
{
return(false);
}
results.point = new Vector3(output.vPoint.v0, output.vPoint.v1, -output.vPoint.v2);
results.normal = new Vector3(output.vNormal.v0, output.vNormal.v1, -output.vNormal.v2);
results.UVs = new Vector2(output.vUVs.v0, output.vUVs.v1);
results.distance = output.fDistance;
return(true);
}
public bool ComputeIntersection(Vector3 source, Vector3 direction, ref IntersectionResults results)
{
var overlay = OpenVR.Overlay;
if (overlay == null)
return false;
var input = new VROverlayIntersectionParams_t();
input.eOrigin = SteamVR_Render.instance.trackingSpace;
input.vSource.v0 = source.x;
input.vSource.v1 = source.y;
input.vSource.v2 = -source.z;
input.vDirection.v0 = direction.x;
input.vDirection.v1 = direction.y;
input.vDirection.v2 = -direction.z;
var output = new VROverlayIntersectionResults_t();
if (!overlay.ComputeOverlayIntersection(handle, ref input, ref output))
return false;
results.point = new Vector3(output.vPoint.v0, output.vPoint.v1, -output.vPoint.v2);
results.normal = new Vector3(output.vNormal.v0, output.vNormal.v1, -output.vNormal.v2);
results.UVs = new Vector2(output.vUVs.v0, output.vUVs.v1);
results.distance = output.fDistance;
return true;
}
public OverlayHitResult getUVs(Vector3 source, Vector3 direction)
{
var result = new IntersectionResults();
var hit = ComputeIntersection(source, direction, ref result);
return(new OverlayHitResult(hit, result));
}
/// <summary>
/// Determine Point On Region
/// </summary>
/// <param name="region">Region</param>
/// <param name="pointOnRegion">Point to be checked</param>
/// <param name="toleranceLevel">Tolerance Level</param>
/// <returns>Intersection Results</returns>
public static IntersectionResults IsPointOn(IRegion3D region, IPoint3D pointOnRegion, double toleranceLevel = MathConstants.ZeroWeak)
{
IntersectionResults regionResult = IsPointOn(region.Outline, pointOnRegion, toleranceLevel);
if (regionResult != IntersectionResults.Inside)
{
return(regionResult);
}
foreach (IPolyLine3D opening in region.Openings)
{
IntersectionResults openingResult = IsPointOn(opening, pointOnRegion, toleranceLevel);
if (openingResult == IntersectionResults.Inside)
{
return(IntersectionResults.OnInSideOpening);
}
else if (openingResult == IntersectionResults.Outside)
{
continue;
}
else
{
return(openingResult);
}
}
return(regionResult);
}
public override void IntersectWith(GShape gShape)
{
if (gShape is GCircle)
{
var res = Intersection.CircleLine((GCircle)gShape, this);
if (res.IntersectionPoints.Count > 0)
{
IntersectionResults.Add(res);
}
}
else if (gShape is GLine)
{
var res = Intersection.LineLine((GLine)gShape, this);
if (res.IntersectionPoints.Count > 0)
{
IntersectionResults.Add(res);
}
}
else if (gShape is GRectangle)
{
foreach (var line in ((GRectangle)gShape).Lines)
{
var res = Intersection.LineLine(line, this);
if (res.IntersectionPoints.Count > 0)
{
IntersectionResults.Add(res);
}
}
}
else if (gShape is GPolyLine)
{
foreach (var line in ((GPolyLine)gShape).Lines)
{
var res = Intersection.LineLine(line, this);
if (res.IntersectionPoints.Count > 0)
{
IntersectionResults.Add(res);
}
}
}
else if (gShape is GCurve)
{
var res = Intersection.CurveLine((GCurve)gShape, this);
if (res.IntersectionPoints.Count == 0)
{
return;
}
IntersectionResults.Add(res);
}
}
/// <summary>
/// Attempt to ComputerIntersection the HMD's Gaze and hit an Overlay
/// </summary>
/// <param name="changed"></param>
private void UpdateGaze(ref bool changed)
{
FindHMD();
var hit = false;
if (_hmdTracker != null && _hmdTracker.IsValid)
{
var result = new IntersectionResults();
hit = ComputeIntersection(_hmdTracker.gameObject.transform.localPosition, _hmdTracker.gameObject.transform.forward, ref result);
//Debug.Log("Hit! " + gameObject.name);
}
HandleAnimateOnGaze(hit, ref changed);
}
public bool ComputeIntersection(Vector3 source, Vector3 direction, ref IntersectionResults results)
{
var vr = SteamVR.instance;
var input = new VROverlayIntersectionParams_t();
input.eOrigin = SteamVR_Render.instance.trackingSpace;
input.vSource.v = new float[] { source.x, source.y, -source.z };
input.vDirection.v = new float[] { direction.x, direction.y, -direction.z };
var output = new VROverlayIntersectionResults_t();
if (!vr.overlay.ComputeOverlayIntersection(handle, ref input, ref output))
return false;
results.point = new Vector3(output.vPoint.v[0], output.vPoint.v[1], -output.vPoint.v[2]);
results.normal = new Vector3(output.vNormal.v[0], output.vNormal.v[1], -output.vNormal.v[2]);
results.UVs = new Vector2(output.vUVs.v[0], output.vUVs.v[1]);
results.distance = output.fDistance;
return true;
}
public bool GetPlayerPointingAtPositionOnScreen(out Vector2 uv)
{
if (Controllers.GetLocalPosition().magnitude < 0.01f)
{
uv = Vector2.zero;
return(false);
}
if (Current != null)
{
IntersectionResults result = new IntersectionResults();
if (Current.ComputeIntersection(Controllers.GetLocalPosition(), Controllers.GetLocalAimForward(), ref result))
{
uv = result.UVs;
return(true);
}
}
uv = Vector2.zero;
return(false);
}
public override void IntersectWith(GShape gShape)
{
IntersectionResult res;
if (gShape is GLine)
{
res = Intersection.CurveLine(this, (GLine)gShape);
if (res.IntersectionPoints.Count == 0)
{
return;
}
IntersectionResults.Add(res);
}
else if (gShape is GRectangle)
{
res = Intersection.CurveRectangle(this, (GRectangle)gShape);
if (res.IntersectionPoints.Count == 0)
{
return;
}
IntersectionResults.Add(res);
}
else if (gShape is GCurve)
{
res = Intersection.CurveCurve(this, (GCurve)gShape);
if (res.IntersectionPoints.Count == 0)
{
return;
}
IntersectionResults.Add(res);
}
}
public override void IntersectWith(GShape gShape)
{
IntersectionResult res;
if (gShape is GLine)
{
res = Intersection.ParabolaLine(this, (GLine)gShape);
if (res.IntersectionPoints.Count == 0)
{
return;
}
IntersectionResults.Add(res);
}
else if (gShape is GParabola)
{
res = Intersection.ParabolaParabola(this, (GParabola)gShape);
if (res.IntersectionPoints.Count == 0)
{
return;
}
IntersectionResults.Add(res);
}
else if (gShape is GCircle)
{
res = Intersection.ParabolaCircle(this, (GCircle)gShape);
if (res.IntersectionPoints.Count == 0)
{
return;
}
IntersectionResults.Add(res);
}
}
public bool ComputeIntersection(Vector3 source, Vector3 direction, ref IntersectionResults results)
{
var vr = SteamVR.instance;
var input = new VROverlayIntersectionParams_t();
input.eOrigin = SteamVR_Render.instance.trackingSpace;
input.vSource.v = new float[] { source.x, source.y, -source.z };
input.vDirection.v = new float[] { direction.x, direction.y, -direction.z };
var output = new VROverlayIntersectionResults_t();
if (!vr.overlay.ComputeOverlayIntersection(handle, ref input, ref output))
{
return(false);
}
results.point = new Vector3(output.vPoint.v[0], output.vPoint.v[1], -output.vPoint.v[2]);
results.normal = new Vector3(output.vNormal.v[0], output.vNormal.v[1], -output.vNormal.v[2]);
results.UVs = new Vector2(output.vUVs.v[0], output.vUVs.v[1]);
results.distance = output.fDistance;
return(true);
}
public OverlayHitResult(bool hit, IntersectionResults result)
{
Hit = hit;
Result = result;
}
private bool TestComputeIntersection(ulong handle, Transform point)
{
IntersectionResults results = new IntersectionResults();
return(SteamVR_Utils.ComputeIntersection(handle, point.position, point.forward, SteamVRManager.trackingSpace, ref results));
}
public static bool ComputeIntersection(ulong handle, Vector3 source, Vector3 direction, ETrackingUniverseOrigin trackingUniverseOrigin, ref IntersectionResults results)
{
var input = new VROverlayIntersectionParams_t {
eOrigin = trackingUniverseOrigin,
vSource = { v0 = source.x, v1 = source.y, v2 = -source.z },
vDirection = { v0 = direction.x, v1 = direction.y, v2 = -direction.z }
};
var output = new VROverlayIntersectionResults_t();
if (!OpenVR.Overlay.ComputeOverlayIntersection(handle, ref input, ref output))
{
return(false);
}
results.point = new Vector3(output.vPoint.v0, output.vPoint.v1, -output.vPoint.v2);
results.normal = new Vector3(output.vNormal.v0, output.vNormal.v1, -output.vNormal.v2);
results.UVs = new Vector2(output.vUVs.v0, output.vUVs.v1);
results.distance = output.fDistance;
return(true);
}
private bool CalculateIntersection(DPOverlayBase dpBase, out IntersectionResults results)
{
results = new IntersectionResults();
return(SteamVR_Utils.ComputeIntersection(dpBase.overlay.handle, pointer.position, pointer.forward, SteamVRManager.trackingSpace, ref results));
}
public override bool HandleInteractionDetection(out List <Vector3> cursorPositions)
{
cursorPositions = new List <Vector3>();
//DPOverlayBase closestOverlay;
List <DPLaserCollisionData> collisions = new List <DPLaserCollisionData>();
//bool foundOverlay = false;
//Foreach of the overlays
for (int i = 0; i < OverlayManager.I.overlays.Count; i++)
{
DPOverlayBase dpToTest = OverlayManager.I.overlays[i];
//Don't process invisible or non-interactable overlays
if (!dpToTest.overlay.shouldRender || !dpToTest.isInteractable)
{
continue;
}
//Ignore look/distance hiding overlays:
if (dpToTest.lookHidingActive || dpToTest.distanceHidingActive)
{
continue;
}
if (!isActivated && !dpToTest.alwaysInteract && !dpToTest.allowMultipuleInteractors)
{
continue;
}
//If the laser isn't activated, global interaction isn't activated, and the overlay doesn't want interaction when the bar is closed, just skip it.
//If the overlay supports multi-interact, it's possible we might want to enable this laser, so we don't skip this quite yet.
// ^^ if (!isActivated && !OverlayInteractionManager.interactionEnabled && !dpToTest.usePointInteraction && !dpToTest.allowMultipuleInteractors) continue;
//If the overlay anchor is the same as the interactor, skip
if (dpToTest.overlay.trackedDevice != DPOverlayTrackedDevice.None && dpToTest.overlay.trackedDevice == trackedDevice)
{
continue;
}
//If the laser intersects with the overlay
if (CalculateIntersection(dpToTest, out IntersectionResults hitResults))
{
//Add it to the list of possible intersections
collisions.Add(new DPLaserCollisionData()
{
results = hitResults, dpBase = dpToTest
});
}
}
//Actually handle interaction stuff once we find the closest collided overlay
if (collisions.Count >= 1)
{
//Find the closest collision data out of all the collisions
DPLaserCollisionData closest = collisions[0];
for (int j = 1; j < collisions.Count; j++)
{
if (collisions[j].results.distance < closest.results.distance)
{
closest = collisions[j];
}
}
//We've found the closest one, and can now interact.
mostRecentIntersection = closest.results;
//If interaction is not globally enabled, but the overlay has a flag for pointing interaction, we enable this laser.
if (!isActivated && !OverlayInteractionManager.interactionEnabled)
{
if (closest.dpBase.alwaysInteract)
{
//OverlayInteractionManager.I.TempEnableInteraction(inputSource);
//tempMultiInteractActive = true;
Activate(true);
if (closest.dpBase.alwaysInteractBlockInput)
{
OverlayInteractionManager.BlockInput(true);
}
//OverlayInteractionManager.I.
}
//Else, if interaction is not globally enabled, we return.
else
{
return(false);
}
}
//If we were using multi-touch on the old overlay, Disable the laser again:
if (targetDP != closest.dpBase && targetDP != null && OverlayInteractionManager.interactionEnabled && OverlayInteractionManager.I.primaryLaser != this)
{
multiInteractActive = false;
Disable();
}
//Activate the laser if it's not on and this overlay uses multi-interact:
if (OverlayInteractionManager.interactionEnabled && !isActivated && closest.dpBase.allowMultipuleInteractors)
{
multiInteractActive = true;
Activate(true);
}
else if (!isActivated)
{
return(false);
}
//HIT A NEW OVERLAY
//If we hit another overlay, disable interaction on the old overlay.
if (targetDP != closest.dpBase && targetDP != null)
{
targetDP.isBeingInteracted = false;
activatedTempEatClick = true;
//If interaction isn't globally enabled, we need to turn off this laser when we leave this overlay.
if (!OverlayInteractionManager.interactionEnabled && !TheBarManager.isOpened)
{
Disable();
if (OverlayInteractionManager.inputBlocked)
{
OverlayInteractionManager.BlockInput(false);
}
}
}
targetDP = closest.dpBase;
targetDP.isBeingInteracted = true;
isInteracting = true;
//Show the window bottom:
if (OverlayInteractionManager.I.primaryLaser == this)
{
DPToolbar.I.Target(targetDP);
}
targetDP.HandleColliderInteracted(this, new List <Vector2>()
{
closest.results.UVs
});
cursorPositions.Add(closest.results.point);
//return since we found an overlay for interaction
return(true);
}
//Else, we found no overlays to interact with, so reset the state:
//If we were temporarially interacting with a multi-touch overlay, disable this laser again.
if (OverlayInteractionManager.interactionEnabled && OverlayInteractionManager.I.primaryLaser != this)
{
multiInteractActive = false;
Disable();
}
if (targetDP != null)
{
targetDP.isBeingInteracted = false;
//If interaction isn't globally enabled, we need to turn off this laser when we leave this overlay.
if (!OverlayInteractionManager.interactionEnabled && !TheBarManager.isOpened)
{
Disable();
if (OverlayInteractionManager.inputBlocked)
{
OverlayInteractionManager.BlockInput(false);
}
}
}
targetDP = null;
isInteracting = false;
return(false);
}
/// <summary>
/// Calculate inner partial polyline by intersecting region and polyline
/// </summary>
/// <param name="region">IRegion3D</param>
/// <param name="innerPolyline">Polyline3D used to calculate inner partial polyline</param>
/// <param name="innerPolylineList">List of inner partial polyline prepared from the given polygon and polyline</param>
/// <returns>IntersectionResults</returns>
public static IntersectionResults Intersect(IRegion3D region, IPolyLine3D innerPolyline, ICollection <IPolyLine3D> innerPolylineList)
{
if (region == null || innerPolyline == null || innerPolylineList == null)
{
return(IntersectionResults.Undefined);
}
IPolyLine3D outerPolyline = region.Outline;
List <IPoint3D> listOfIntersectionPoint = new List <IPoint3D>();
Intersect(outerPolyline, innerPolyline, listOfIntersectionPoint);
foreach (IPolyLine3D opening in region.Openings)
{
Intersect(opening, innerPolyline, listOfIntersectionPoint);
}
if (listOfIntersectionPoint.Count < 1)
{
IPoint3D point = GetPointOnPolyLine(innerPolyline, 0.5);
return(IsPointOn(region, point));
}
SortedSet <double> relativePositionSet = new SortedSet <double>();
relativePositionSet.Add(0);
relativePositionSet.Add(1);
foreach (IPoint3D point in listOfIntersectionPoint)
{
double relativePosition = 0;
if (GetRelativePosition(innerPolyline, point, ref relativePosition))
{
if (!relativePositionSet.Contains(relativePosition))
{
relativePositionSet.Add(relativePosition);
}
}
}
IList <ISegment3D> splittedSegments = SplitPolyline(innerPolyline, relativePositionSet);
if (splittedSegments == null)
{
return(IntersectionResults.Undefined);
}
IntersectionResults interSectionResult = IntersectionResults.Undefined;
foreach (ISegment3D segment in splittedSegments)
{
IPoint3D point = new Point3D();
if (GetPointOnSegment(segment, 0.5, ref point))
{
IntersectionResults result = IsPointOn(region, point);
interSectionResult |= result;
if (result == IntersectionResults.Inside || result == IntersectionResults.OnBorderCurve)
{
IPolyLine3D polyline = new PolyLine3D();
if (innerPolylineList.Count < 1)
{
polyline.Add(segment);
}
else
{
IPolyLine3D existingPolyline = innerPolylineList.Last();
if (existingPolyline.Count < 1)
{
polyline.Add(segment);
}
else
{
if (existingPolyline.Count > 1)
{
ISegment3D lastSegment = existingPolyline.Segments.Last();
if (lastSegment.EndPoint.Equals(segment.StartPoint))
{
polyline = existingPolyline;
}
}
polyline.Add(segment);
}
}
if (!innerPolylineList.Contains(polyline))
{
innerPolylineList.Add(polyline);
}
}
}
}
if (innerPolylineList.Count < 1)
{
return(IntersectionResults.OnBorderNode | IntersectionResults.Outside);
}
return(interSectionResult);
}
public override void IntersectWith(GShape gShape)
{
IntersectionResult result;
if (gShape is GLine)
{
foreach (var line in Lines)
{
result = Intersection.LineLine((GLine)gShape, line);
if (result.IntersectionPoints.Count > 0)
{
IntersectionResults.Add(result);
}
}
}
else if (gShape is GCircle)
{
foreach (var line in Lines)
{
result = Intersection.CircleRectangle((GCircle)gShape, this);
if (result.IntersectionPoints.Count == 0)
{
return;
}
IntersectionResults.Add(result);
}
}
else if (gShape is GRectangle)
{
foreach (var line in Lines)
{
foreach (var recLine in ((GRectangle)gShape).Lines)
{
result = Intersection.LineLine(line, recLine);
if (result.IntersectionPoints.Count == 0)
{
continue;
}
IntersectionResults.Add(result);
}
}
}
else if (gShape is GPolyLine)
{
foreach (var line in Lines)
{
foreach (var pLine in ((GPolyLine)gShape).Lines)
{
result = Intersection.LineLine(line, pLine);
if (result.IntersectionPoints.Count == 0)
{
continue;
}
IntersectionResults.Add(result);
}
}
}
else if (gShape is GCurve)
{
result = Intersection.CurveRectangle((GCurve)gShape, this);
if (result.IntersectionPoints.Count == 0)
{
return;
}
IntersectionResults.Add(result);
}
}
public bool PollNextEvent(ref VREvent_t pEvent) => default; // 0x0000000180CC7510-0x0000000180CC7610 public bool ComputeIntersection(Vector3 source, Vector3 direction, ref IntersectionResults results) => default; // 0x0000000180CC7090-0x0000000180CC72D0
