public void GetSupportedCameraConfigurationsWithFilter(
ARCoreCameraConfigFilter cameraConfigFilter,
IntPtr cameraConfigListHandle, List <IntPtr> supportedCameraConfigHandles,
List <CameraConfig> supportedCameraConfigs, DeviceCameraDirection cameraFacingDirection)
{
IntPtr cameraConfigFilterHandle = _nativeSession.CameraConfigFilterApi.Create(
cameraFacingDirection,
cameraConfigFilter);
ExternApi.ArSession_getSupportedCameraConfigsWithFilter(
_nativeSession.SessionHandle,
cameraConfigFilterHandle,
cameraConfigListHandle);
_nativeSession.CameraConfigFilterApi.Destroy(cameraConfigFilterHandle);
supportedCameraConfigHandles.Clear();
supportedCameraConfigs.Clear();
int listSize = _nativeSession.CameraConfigListApi.GetSize(cameraConfigListHandle);
for (int i = 0; i < listSize; i++)
{
IntPtr cameraConfigHandle = _nativeSession.CameraConfigApi.Create();
_nativeSession.CameraConfigListApi.GetItemAt(
cameraConfigListHandle, i, cameraConfigHandle);
supportedCameraConfigHandles.Add(cameraConfigHandle);
supportedCameraConfigs.Add(CreateCameraConfig(cameraConfigHandle));
}
}
public void GetSupportedCameraConfigurations(
IntPtr cameraConfigListHandle, List <IntPtr> supportedCameraConfigHandles,
List <CameraConfig> supportedCameraConfigs, DeviceCameraDirection cameraFacingDirection)
{
ExternApi.ArSession_getSupportedCameraConfigs(
m_NativeSession.SessionHandle, cameraConfigListHandle);
supportedCameraConfigHandles.Clear();
supportedCameraConfigs.Clear();
int listSize = m_NativeSession.CameraConfigListApi.GetSize(cameraConfigListHandle);
for (int i = 0; i < listSize; i++)
{
IntPtr cameraConfigHandle = m_NativeSession.CameraConfigApi.Create();
m_NativeSession.CameraConfigListApi.GetItemAt(
cameraConfigListHandle, i, cameraConfigHandle);
// Skip camera config that has a different camera facing direction.
DeviceCameraDirection configDirection =
m_NativeSession.CameraConfigApi.GetFacingDirection(cameraConfigHandle)
.ToDeviceCameraDirection();
if (configDirection != cameraFacingDirection)
{
continue;
}
supportedCameraConfigHandles.Add(cameraConfigHandle);
supportedCameraConfigs.Add(_CreateCameraConfig(cameraConfigHandle));
}
}
private CameraConfig CreateCameraConfig(IntPtr cameraConfigHandle)
{
DeviceCameraDirection facingDirection =
_nativeSession.CameraConfigApi.GetFacingDirection(cameraConfigHandle);
int imageWidth = 0;
int imageHeight = 0;
int textureWidth = 0;
int textureHeight = 0;
int minFps = 0;
int maxFps = 0;
CameraConfigDepthSensorUsage depthSensorUsage =
_nativeSession.CameraConfigApi.GetDepthSensorUsage(cameraConfigHandle);
CameraConfigStereoCameraUsage stereoCameraUsage =
_nativeSession.CameraConfigApi.GetStereoCameraUsage(cameraConfigHandle);
_nativeSession.CameraConfigApi.GetImageDimensions(
cameraConfigHandle, out imageWidth, out imageHeight);
_nativeSession.CameraConfigApi.GetTextureDimensions(
cameraConfigHandle, out textureWidth, out textureHeight);
_nativeSession.CameraConfigApi.GetFpsRange(
cameraConfigHandle, out minFps, out maxFps);
return(new CameraConfig(
facingDirection,
new Vector2(imageWidth, imageHeight),
new Vector2(textureWidth, textureHeight),
minFps,
maxFps,
stereoCameraUsage,
depthSensorUsage));
}
public IntPtr Create(
DeviceCameraDirection direction,
ARCoreCameraConfigFilter filter)
{
IntPtr cameraConfigFilterHandle = IntPtr.Zero;
ExternApi.ArCameraConfigFilter_create(
_nativeSession.SessionHandle, ref cameraConfigFilterHandle);
ExternApi.ArCameraConfigFilter_setFacingDirection(
_nativeSession.SessionHandle, cameraConfigFilterHandle, direction);
if (filter != null)
{
if (filter.TargetCameraFramerate != null)
{
ExternApi.ArCameraConfigFilter_setTargetFps(_nativeSession.SessionHandle,
cameraConfigFilterHandle, ConvertToFpsFilter(filter.TargetCameraFramerate));
}
if (filter.DepthSensorUsage != null)
{
ExternApi.ArCameraConfigFilter_setDepthSensorUsage(_nativeSession.SessionHandle,
cameraConfigFilterHandle, ConvertToDepthFilter(filter.DepthSensorUsage));
}
if (filter.StereoCameraUsage != null)
{
ExternApi.ArCameraConfigFilter_setStereoCameraUsage(
_nativeSession.SessionHandle, cameraConfigFilterHandle,
ConvertToStereoFilter(filter.StereoCameraUsage));
}
}
return(cameraConfigFilterHandle);
}
// switch camera button event..
public void SwitchCameraButtonEvent()
{
//DeviceCameraDirection = DeviceCameraDirection.BackFacing;
if (DeviceCameraDirection.BackFacing == DeviceCameraDirection)
{
DeviceCameraDirection = DeviceCameraDirection.FrontFacing;
}
else if (DeviceCameraDirection.FrontFacing == DeviceCameraDirection)
{
DeviceCameraDirection = DeviceCameraDirection.BackFacing;
}
}
public DeviceCameraDirection GetFacingDirection(IntPtr cameraConfigHandle)
{
DeviceCameraDirection direction = DeviceCameraDirection.BackFacing;
if (InstantPreviewManager.IsProvidingPlatform)
{
InstantPreviewManager.LogLimitedSupportMessage("access ARCamera facing direction");
return(direction);
}
ExternApi.ArCameraConfig_getFacingDirection(
_nativeSession.SessionHandle, cameraConfigHandle, ref direction);
return(direction);
}
internal CameraConfig(
DeviceCameraDirection facingDirection,
Vector2 imageSize,
Vector2 textureSize,
int minFPS,
int maxFPS,
CameraConfigStereoCameraUsage stereoCamera,
CameraConfigDepthSensorUsage depthSensor) : this()
{
FacingDirection = facingDirection;
ImageSize = imageSize;
TextureSize = textureSize;
MinFPS = minFPS;
MaxFPS = maxFPS;
DepthSensorUsage = depthSensor;
StereoCameraUsage = stereoCamera;
}
private void _SetCameraDirection(DeviceCameraDirection cameraDirection)
{
// The camera direction has not changed.
if (m_CachedCameraDirection.HasValue && m_CachedCameraDirection.Value == cameraDirection)
{
return;
}
if (InstantPreviewManager.IsProvidingPlatform && cameraDirection == DeviceCameraDirection.BackFacing)
{
return;
}
else if (InstantPreviewManager.IsProvidingPlatform)
{
InstantPreviewManager.LogLimitedSupportMessage("enable front-facing (selfie) camera");
m_CachedCameraDirection = DeviceCameraDirection.BackFacing;
if (SessionComponent != null)
{
SessionComponent.DeviceCameraDirection = DeviceCameraDirection.BackFacing;
}
return;
}
if (OnSessionSetEnabled != null)
{
OnSessionSetEnabled(false);
}
var apiCameraDirection = cameraDirection == DeviceCameraDirection.BackFacing ?
ApiPrestoDeviceCameraDirection.BackFacing : ApiPrestoDeviceCameraDirection.FrontFacing;
ExternApi.ArPresto_setDeviceCameraDirection(apiCameraDirection);
m_CachedCameraDirection = cameraDirection;
if (OnSessionSetEnabled != null)
{
OnSessionSetEnabled(true);
}
}
private bool SetCameraDirection(DeviceCameraDirection cameraDirection)
{
// The camera direction has not changed.
if (_cachedCameraDirection.HasValue &&
_cachedCameraDirection.Value == cameraDirection)
{
return(false);
}
if (InstantPreviewManager.IsProvidingPlatform &&
cameraDirection == DeviceCameraDirection.BackFacing)
{
return(false);
}
else if (InstantPreviewManager.IsProvidingPlatform)
{
InstantPreviewManager.LogLimitedSupportMessage(
"enable front-facing (selfie) camera");
_cachedCameraDirection = DeviceCameraDirection.BackFacing;
if (SessionComponent != null)
{
SessionComponent.DeviceCameraDirection = DeviceCameraDirection.BackFacing;
}
return(false);
}
_cachedCameraDirection = cameraDirection;
ApiPrestoStatus prestoStatus = ApiPrestoStatus.Uninitialized;
ExternApi.ArPresto_getStatus(ref prestoStatus);
if (prestoStatus == ApiPrestoStatus.ErrorInvalidCameraConfig)
{
// if the session is paused by invalid camera configuration,
// attempt to recover by changing the camera direction:
OnBeforeResumeSession(_cachedSessionHandle);
}
return(true);
}
public static extern void ArCameraConfig_getFacingDirection(
IntPtr sessionHandle, IntPtr cameraConfigHandle,
ref DeviceCameraDirection facingDirection);
public static extern void ArCameraConfigFilter_setFacingDirection(
IntPtr session, IntPtr filter, DeviceCameraDirection facing_direction_filter);
