public override unsafe NativeArray <XRRaycastHit> Raycast(
XRRaycastHit defaultRaycastHit,
Vector2 screenPoint,
TrackableType trackableTypeMask,
Allocator allocator)
{
void *hitBuffer;
int hitCount, elementSize;
UnityARCore_raycast_acquireHitResults(
screenPoint,
trackableTypeMask,
out hitBuffer,
out hitCount,
out elementSize);
try
{
return(NativeCopyUtility.PtrToNativeArrayWithDefault <XRRaycastHit>(
defaultRaycastHit,
hitBuffer, elementSize,
hitCount, allocator));
}
finally
{
UnityARCore_raycast_releaseHitResults(hitBuffer);
}
}
/// <summary>
/// Gets the human body pose 2D joints for the current frame.
/// </summary>
/// <param name="defaultHumanBodyPose2DJoint">The default value for the body pose 2D joint.</param>
/// <param name="screenWidth">The width of the screen, in pixels.</param>
/// <param name="screenHeight">The height of the screen, in pixels.</param>
/// <param name="screenOrientation">The orientation of the device so that the joint positions may be
/// adjusted as required.</param>
/// <param name="allocator">The allocator to use for the returned array memory.</param>
/// <returns>
/// The array of body pose 2D joints.
/// </returns>
/// <remarks>
/// The returned array may be empty if the system does not detect a human in the camera image.
/// </remarks>
public override unsafe NativeArray <XRHumanBodyPose2DJoint> GetHumanBodyPose2DJoints(XRHumanBodyPose2DJoint defaultHumanBodyPose2DJoint,
int screenWidth,
int screenHeight,
ScreenOrientation screenOrientation,
Allocator allocator)
{
var joints = NativeApi.UnityARKit_HumanBodyProvider_AcquireHumanBodyPose2DJoints(screenWidth,
screenHeight,
screenOrientation,
out int length,
out int elementSize);
try
{
var returnJoints = NativeCopyUtility.PtrToNativeArrayWithDefault(defaultHumanBodyPose2DJoint,
joints, elementSize, length,
allocator);
return(returnJoints);
}
finally
{
NativeApi.UnityARKit_HumanBodyProvider_ReleaseHumanBodyPose2DJoints(joints);
}
}
/// <summary>
/// Gets the texture descriptors associated with th current camera
/// frame.
/// </summary>
/// <returns>The texture descriptors.</returns>
/// <param name="defaultDescriptor">Default descriptor.</param>
/// <param name="allocator">Allocator.</param>
public unsafe override NativeArray <XRTextureDescriptor> GetTextureDescriptors(
XRTextureDescriptor defaultDescriptor,
Allocator allocator)
{
int length, elementSize;
var textureDescriptors = NativeApi.UnityARKit_Camera_AcquireTextureDescriptors(
out length, out elementSize);
try
{
return(NativeCopyUtility.PtrToNativeArrayWithDefault(
defaultDescriptor,
textureDescriptors, elementSize, length, allocator));
}
finally
{
NativeApi.UnityARKit_Camera_ReleaseTextureDescriptors(textureDescriptors);
}
}
/// <summary>
/// Get changes to the passed XRReferencePoint
/// </summary>
/// <param name="defaultReferencePoint">The XRReferencePoint to get changes for.</param>
/// <param name="allocator">Reference to the allocator for the XRReferencePoint.</param>
/// <returns></returns>
public override unsafe TrackableChanges <XRReferencePoint> GetChanges(
XRReferencePoint defaultReferencePoint,
Allocator allocator)
{
int addedCount, updatedCount, removedCount, elementSize;
void *addedPtr, updatedPtr, removedPtr;
var context = NativeApi.UnityWindowsMR_refPoints_acquireChanges(
out addedPtr, out addedCount,
out updatedPtr, out updatedCount,
out removedPtr, out removedCount,
out elementSize);
try
{
// Yes, this is an extra copy, but the hit is small compared with the code needed to get rid of it.
// If this becomes a problem we can eliminate the extra copy by doing something similar to
// NativeCopyUtility.PtrToNativeArrayWithDefault only with a pre-allocated array properties
// from using the TrackableChanges(int, int, int allocator) constructor.
var added = NativeCopyUtility.PtrToNativeArrayWithDefault <XRReferencePoint>(defaultReferencePoint, addedPtr, elementSize, addedCount, allocator);
var updated = NativeCopyUtility.PtrToNativeArrayWithDefault <XRReferencePoint>(defaultReferencePoint, updatedPtr, elementSize, updatedCount, allocator);
var removed = NativeCopyUtility.PtrToNativeArrayWithDefault <TrackableId>(default(TrackableId), removedPtr, elementSize, removedCount, allocator);
var ret = TrackableChanges <XRReferencePoint> .CopyFrom(
added,
updated,
removed,
allocator);
added.Dispose();
updated.Dispose();
removed.Dispose();
return(ret);
}
finally
{
NativeApi.UnityWindowsMR_refPoints_releaseChanges(context);
}
}
/// <summary>
/// Queries the supported camera configurations.
/// </summary>
/// <param name="defaultCameraConfiguration">A default value used to fill the returned array before copying
/// in real values. This ensures future additions to this struct are backwards compatible.</param>
/// <param name="allocator">The allocation strategy to use for the returned data.</param>
/// <returns>
/// The supported camera configurations.
/// </returns>
public override NativeArray <XRCameraConfiguration> GetConfigurations(XRCameraConfiguration defaultCameraConfiguration,
Allocator allocator)
{
int configurationsCount;
int configurationSize;
IntPtr configurations = NativeApi.UnityARCore_Camera_AcquireConfigurations(out configurationsCount,
out configurationSize);
try
{
unsafe
{
return(NativeCopyUtility.PtrToNativeArrayWithDefault(defaultCameraConfiguration,
(void *)configurations,
configurationSize, configurationsCount,
allocator));
}
}
finally
{
NativeApi.UnityARCore_Camera_ReleaseConfigurations(configurations);
}
}