XRCameraSubsystem.cs 24.9 KB
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579
using System;
using System.Collections.Generic;
using Unity.Collections;

#if UNITY_2020_2_OR_NEWER
using UnityEngine.SubsystemsImplementation;
#endif

namespace UnityEngine.XR.ARSubsystems
{
    /// <summary>
    /// Provides access to a device's camera.
    /// </summary>
    /// <remarks>
    /// The <c>XRCameraSubsystem</c> links a Unity <c>Camera</c> to a device camera for video overlay (pass-thru
    /// rendering). It also allows developers to query for environmental light estimation, when available.
    /// </remarks>
#if UNITY_2020_2_OR_NEWER
    public class XRCameraSubsystem : SubsystemWithProvider<XRCameraSubsystem, XRCameraSubsystemDescriptor, XRCameraSubsystem.Provider>
#else
    public abstract class XRCameraSubsystem : XRSubsystem<XRCameraSubsystemDescriptor>
#endif
    {
#if !UNITY_2020_2_OR_NEWER
        /// <summary>
        /// The provider created by the implementation that contains the required camera functionality.
        /// </summary>
        /// <value>
        /// The provider created by the implementation that contains the required camera functionality.
        /// </value>
        protected Provider provider { get; }
#endif

        /// <summary>
        /// Construct the <c>XRCameraSubsystem</c>.
        /// </summary>
        public XRCameraSubsystem()
        {
#if !UNITY_2020_2_OR_NEWER
            provider = CreateProvider();
            Debug.Assert(provider != null, "camera functionality provider cannot be null");
#endif
        }

        /// <summary>
        /// Gets the camera currently in use.
        /// </summary>
        /// <returns></returns>
        public Feature currentCamera => provider.currentCamera.Cameras();

        /// <summary>
        /// Get or set the requested camera, i.e., the <see cref="Feature.AnyCamera"/> bits.
        /// </summary>
        public Feature requestedCamera
        {
            get => provider.requestedCamera;
            set => provider.requestedCamera = value.Cameras();
        }

        /// <summary>
        /// Interface for providing camera functionality for the implementation.
        /// </summary>
        public class Provider
#if UNITY_2020_2_OR_NEWER
            : SubsystemProvider<XRCameraSubsystem>
#endif
        {
            /// <summary>
            /// An instance of the <see cref="XRCpuImage.Api"/> used to operate on <see cref="XRCpuImage"/> objects.
            /// </summary>
            public virtual XRCpuImage.Api cpuImageApi => null;

            /// <summary>
            /// Property to be implemented by the provder to get the material used by <c>XRCameraSubsystem</c> to
            /// render the camera texture.
            /// </summary>
            /// <returns>
            /// The material to render the camera texture.
            /// </returns>
            public virtual Material cameraMaterial => null;

            /// <summary>
            /// Property to be implemented by the provider to determine whether camera permission has been granted.
            /// </summary>
            /// <value>
            /// <c>true</c> if camera permission has been granted. Otherwise, <c>false</c>.
            /// </value>
            public virtual bool permissionGranted => false;

            /// <summary>
            /// Whether or not culling should be inverted during rendering. Some front-facing
            /// camera modes may require this.
            /// </summary>
            public virtual bool invertCulling => false;

            /// <summary>
            /// This property should get the actual camera facing direction.
            /// </summary>
            public virtual Feature currentCamera => Feature.None;

            /// <summary>
            /// This property should get or set the requested camera facing direction,
            /// that is, the <see cref="Feature.AnyCamera"/> bits.
            /// </summary>
            public virtual Feature requestedCamera
            {
                get => Feature.None;
                set { }
            }

            /// <summary>
            /// Method to be implemented by provider to start the camera for the subsystem.
            /// </summary>
#if UNITY_2020_2_OR_NEWER
            public override void Start() { }
#else
            public virtual void Start() { }
#endif

            /// <summary>
            /// Method to be implemented by provider to stop the camera for the subsystem.
            /// </summary>
#if UNITY_2020_2_OR_NEWER
            public override void Stop() { }
#else
            public virtual void Stop() { }
#endif

            /// <summary>
            /// Method to be implemented by provider to destroy the camera for the subsystem.
            /// </summary>
#if UNITY_2020_2_OR_NEWER
            public override void Destroy() { }
#else
            public virtual void Destroy() { }
#endif

            /// <summary>
            /// Method to be implemented by provider to get the camera frame for the subsystem.
            /// </summary>
            /// <param name="cameraParams">The current Unity <c>Camera</c> parameters.</param>
            /// <param name="cameraFrame">The current camera frame returned by the method.</param>
            /// <returns>
            /// <c>true</c> if the method successfully got a frame. Otherwise, <c>false</c>.
            /// </returns>
            public virtual bool TryGetFrame(
                XRCameraParams cameraParams,
                out XRCameraFrame cameraFrame)
            {
                cameraFrame = default(XRCameraFrame);
                return false;
            }

            /// <summary>
            /// Property to be implemented by the provider to get the current camera focus mode.
            /// </summary>
            public virtual bool autoFocusEnabled => false;

            /// <summary>
            /// Property to be implemented by the provider to get or set the focus mode for the camera.
            /// </summary>
            public virtual bool autoFocusRequested
            {
                get => false;
                set { }
            }

            /// <summary>
            /// Property to be implemented by the provider to get the current light estimation mode in use.
            /// </summary>
            public virtual Feature currentLightEstimation => Feature.None;

            /// <summary>
            /// Property to be implemented by the provider to get or set the light estimation mode.
            /// </summary>
            public virtual Feature requestedLightEstimation
            {
                get => Feature.None;
                set { }
            }

            /// <summary>
            /// Method to be implemented by the provider to get the camera intrinisics information.
            /// </summary>
            /// <param name="cameraIntrinsics">The camera intrinsics information returned from the method.</param>
            /// <returns>
            /// <c>true</c> if the method successfully gets the camera intrinsics information. Otherwise, <c>false</c>.
            /// </returns>
            public virtual bool TryGetIntrinsics(
                out XRCameraIntrinsics cameraIntrinsics)
            {
                cameraIntrinsics = default(XRCameraIntrinsics);
                return false;
            }

            /// <summary>
            /// Method to be implemented by the provider to query 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 virtual NativeArray<XRCameraConfiguration> GetConfigurations(XRCameraConfiguration defaultCameraConfiguration,
                                                                                Allocator allocator)
            {
                return new NativeArray<XRCameraConfiguration>(0, allocator);
            }

            /// <summary>
            /// Property to be implemented by the provider to query/set the current camera configuration.
            /// </summary>
            /// <value>
            /// The current camera configuration if it exists. Otherise, <c>null</c>.
            /// </value>
            /// <exception cref="System.NotSupportedException">Thrown when setting the current configuration if the
            /// implementation does not support camera configurations.</exception>
            /// <exception cref="System.ArgumentException">Thrown when setting the current configuration if the given
            /// configuration is not a valid, supported camera configuration.</exception>
            /// <exception cref="System.InvalidOperationException">Thrown when setting the current configuration if the
            /// implementation is unable to set the current camera configuration.</exception>
            public virtual XRCameraConfiguration? currentConfiguration
            {
                get => null;
                set => throw new NotSupportedException("setting current camera configuration is not supported by this implementation");
            }

            /// <summary>
            /// Get the <see cref="XRTextureDescriptor"/>s associated with the current
            /// <see cref="XRCameraFrame"/>.
            /// </summary>
            /// <returns>The current texture descriptors.</returns>
            /// <param name="defaultDescriptor">A default value which should
            /// be used to fill the returned array before copying in the
            /// real values. This ensures future additions to this struct
            /// are backwards compatible.</param>
            /// <param name="allocator">The allocator to use when creating
            /// the returned <c>NativeArray</c>.</param>
            public virtual NativeArray<XRTextureDescriptor> GetTextureDescriptors(
                XRTextureDescriptor defaultDescriptor,
                Allocator allocator)
            {
                return new NativeArray<XRTextureDescriptor>(0, allocator);
            }

            /// <summary>
            /// Method to be implemented by the provider to get the enabled and disabled shader keywords for the
            /// material.
            /// </summary>
            /// <param name="enabledKeywords">The keywords to enable for the material.</param>
            /// <param name="disabledKeywords">The keywords to disable for the material.</param>
            public virtual void GetMaterialKeywords(out List<string> enabledKeywords, out List<string> disabledKeywords)
            {
                enabledKeywords = null;
                disabledKeywords = null;
            }

            /// <summary>
            /// Method to be implemented by the provider to query for the latest native camera image.
            /// </summary>
            /// <param name="cameraImageCinfo">The metadata required to construct a <see cref="XRCpuImage"/></param>
            /// <returns>
            /// <c>true</c> if the camera image is acquired. Otherwise, <c>false</c>.
            /// </returns>
            /// <exception cref="System.NotSupportedException">Thrown if the implementation does not support camera
            /// image.</exception>
            public virtual bool TryAcquireLatestCpuImage(out XRCpuImage.Cinfo cameraImageCinfo)
            {
                throw new NotSupportedException("getting camera image is not supported by this implementation");
            }

            /// <summary>
            /// Create the camera material from the given camera shader name.
            /// </summary>
            /// <param name="cameraShaderName">The name of the camera shader.</param>
            /// <returns>
            /// The created camera material shader.
            /// </returns>
            /// <exception cref="System.InvalidOperationException">Thrown if the shader cannot be found or if a
            /// material cannot be created for the shader.</exception>
            protected Material CreateCameraMaterial(string cameraShaderName)
            {
                var shader = Shader.Find(cameraShaderName);
                if (shader == null)
                {
                    throw new InvalidOperationException($"Could not find shader named '{cameraShaderName}' required "
                                                        + $"for video overlay on camera subsystem.");
                }

                Material material = new Material(shader);
                if (material == null)
                {
                    throw new InvalidOperationException($"Could not create a material for shader named "
                                                        + $"'{cameraShaderName}' required for video overlay on camera "
                                                        + $"subsystem.");
                }

                return material;
            }

            /// <summary>
            /// Method to be implemented by the provider to handle any required platform-specifc functionality
            /// immediately before rendering the camera background. This method will always be called on the render
            /// thread and should only be called by the code responsible for executing background rendering on
            /// mobile AR platforms.
            /// </summary>
            /// <param name="id">Platform specific identifier.</param>
            public virtual void OnBeforeBackgroundRender(int id) {}
        }

        /// <summary>
        /// Get the current focus mode in use by the provider.
        /// </summary>
        public bool autoFocusEnabled => provider.autoFocusEnabled;

        /// <summary>
        /// Get or set the focus mode for the camera.
        /// </summary>
        /// <value>
        /// The focus mode for the camera.
        /// </value>
        public bool autoFocusRequested
        {
            get => provider.autoFocusRequested;
            set => provider.autoFocusRequested = value;
        }

        /// <summary>
        /// Returns the current light estimation mode in use by the provider.
        /// </summary>
        /// <seealso cref="requestedLightEstimation"/>
        public Feature currentLightEstimation => provider.currentLightEstimation.LightEstimation();

        /// <summary>
        /// Get or set the requested light estimation mode.
        /// </summary>
        /// <value>
        /// The light estimation mode.
        /// </value>
        public Feature requestedLightEstimation
        {
            get => provider.requestedLightEstimation.LightEstimation();
            set => provider.requestedLightEstimation = value.LightEstimation();
        }

#if !UNITY_2020_2_OR_NEWER
        /// <summary>
        /// Start the camera subsystem.
        /// </summary>
        protected sealed override void OnStart() => provider.Start();

        /// <summary>
        /// Stop the camera subsystem.
        /// </summary>
        protected sealed override void OnStop() => provider.Stop();

        /// <summary>
        /// Destroy the camera subsystem.
        /// </summary>
        protected sealed override void OnDestroyed() => provider.Destroy();
#endif

        /// <summary>
        /// Gets the <see cref="XRTextureDescriptor"/>s associated with the
        /// current frame. The caller owns the returned <c>NativeArray</c>
        /// and is responsible for calling <c>Dispose</c> on it.
        /// </summary>
        /// <returns>An array of texture descriptors.</returns>
        /// <param name="allocator">The allocator to use when creating
        /// the returned <c>NativeArray</c>.</param>
        public NativeArray<XRTextureDescriptor> GetTextureDescriptors(
            Allocator allocator)
        {
            return provider.GetTextureDescriptors(
                default(XRTextureDescriptor),
                allocator);
        }

        /// <summary>
        /// Get the material used by <c>XRCameraSubsystem</c> to render the camera texture.
        /// </summary>
        /// <value>
        /// The material to render the camera texture.
        /// </value>
        public Material cameraMaterial => provider.cameraMaterial;

        /// <summary>
        /// Method to be called on the render thread to handle any required platform-specifc functionality
        /// immediately before rendering the camera background. This method will always be called on the render
        /// thread and should only be called by the code responsible for executing background rendering on
        /// mobile AR platforms.
        /// </summary>
        /// <param name="id">Platform specific identifier.</param>
        public void OnBeforeBackgroundRender(int id)
        {
            provider.OnBeforeBackgroundRender(id);
        }

        /// <summary>
        /// Returns the camera intrinsics information.
        /// </summary>
        /// <param name="cameraIntrinsics">The camera intrinsics information returned from the method.</param>
        /// <returns>
        /// <c>true</c> if the method successfully gets the camera intrinsics information. Otherwise, <c>false</c>.
        /// </returns>
        public bool TryGetIntrinsics(out XRCameraIntrinsics cameraIntrinsics)
        {
            return provider.TryGetIntrinsics(out cameraIntrinsics);
        }

        /// <summary>
        /// Queries for the supported camera configurations.
        /// </summary>
        /// <param name="allocator">The allocation strategy to use for the returned data.</param>
        /// <returns>
        /// The supported camera configurations.
        /// </returns>
        public NativeArray<XRCameraConfiguration> GetConfigurations(Allocator allocator)
        {
            return provider.GetConfigurations(default(XRCameraConfiguration), allocator);
        }

        /// <summary>
        /// The current camera configuration.
        /// </summary>
        /// <value>
        /// The current camera configuration if it exists. Otherise, <c>null</c>.
        /// </value>
        /// <exception cref="System.NotSupportedException">Thrown when setting the current configuration if the
        /// implementation does not support camera configurations.</exception>
        /// <exception cref="System.ArgumentNullException">Thrown when setting the current configuration if the given
        /// configuration is <c>null</c>.</exception>
        /// <exception cref="System.ArgumentException">Thrown when setting the current configuration if the given
        /// configuration is not a supported camera configuration.</exception>
        /// <exception cref="System.InvalidOperationException">Thrown when setting the current configuration if the
        /// implementation is unable to set the current camera configuration.</exception>
        public virtual XRCameraConfiguration? currentConfiguration
        {
            get => provider.currentConfiguration;
            set
            {
                if (value == null)
                {
                    throw new ArgumentNullException("value", "cannot set the camera configuration to null");
                }

                provider.currentConfiguration = value;
            }
        }

        /// <summary>
        /// Whether to invert the culling mode during rendering. Some front-facing
        /// camera modes may require this.
        /// </summary>
        public bool invertCulling => provider.invertCulling;

#if !UNITY_2020_2_OR_NEWER
        /// <summary>
        /// Method for the implementation to create the camera functionality provider.
        /// </summary>
        /// <returns>
        /// The camera functionality provider.
        /// </returns>
        protected abstract Provider CreateProvider();
#endif

        /// <summary>
        /// Get the latest frame from the provider.
        /// </summary>
        /// <param name="cameraParams">The Unity <c>Camera</c> parameters.</param>
        /// <param name="frame">The camera frame to be populated if the subsystem is running and successfully provides
        /// the latest camera frame.</param>
        /// <returns>
        /// <c>true</c> if the camera frame is successfully returned. Otherwise, <c>false</c>.
        /// </returns>
        public bool TryGetLatestFrame(
            XRCameraParams cameraParams,
            out XRCameraFrame frame)
        {
            if (running && provider.TryGetFrame(cameraParams, out frame))
            {
                return true;
            }

            frame = default(XRCameraFrame);
            return false;
        }

        /// <summary>
        /// Determines whether camera permission has been granted.
        /// </summary>
        /// <value>
        /// <c>true</c> if camera permission has been granted. Otherwise, <c>false</c>.
        /// </value>
        public bool permissionGranted => provider.permissionGranted;

        /// <summary>
        /// Get the enabled and disabled shader keywords for the material.
        /// </summary>
        /// <param name="enabledKeywords">The keywords to enable for the material.</param>
        /// <param name="disabledKeywords">The keywords to disable for the material.</param>
        public void GetMaterialKeywords(out List<string> enabledKeywords, out List<string> disabledKeywords)
            => provider.GetMaterialKeywords(out enabledKeywords, out disabledKeywords);

        /// <summary>
        /// Attempts to acquire the latest camera image. This provides direct access to the raw pixel data, as well as
        /// to utilities to convert to RGB and Grayscale formats. This method is obsolete. Use
        /// <see cref="TryAcquireLatestCpuImage"/> instead.
        /// </summary>
        /// <remarks>
        /// The returned <see cref="XRCpuImage"/> must be disposed to avoid resource leaks.
        /// </remarks>
        /// <param name="cpuImage">A valid <see cref="XRCpuImage"/> if this method returns <c>true</c>.</param>
        /// <returns>Returns `true` if the image was acquired. Returns `false` otherwise.</returns>
        /// <exception cref="System.NotSupportedException">Thrown if the implementation does not support camera image.
        /// </exception>
        [Obsolete("Use TryAcquireLatestCpuImage instead. (2020-05-19)")]
        public bool TryGetLatestImage(out XRCpuImage cpuImage) => TryAcquireLatestCpuImage(out cpuImage);

        /// <summary>
        /// Attempts to acquire the latest camera image. This provides direct access to the raw pixel data, as well as
        /// to utilities to convert to RGB and Grayscale formats.
        /// </summary>
        /// <remarks>
        /// The returned <see cref="XRCpuImage"/> must be disposed to avoid resource leaks.
        /// </remarks>
        /// <param name="cpuImage">A valid <see cref="XRCpuImage"/> if this method returns <c>true</c>.</param>
        /// <returns>Returns `true` if the image was acquired. Returns `false` otherwise.</returns>
        /// <exception cref="System.NotSupportedException">Thrown if the implementation does not support camera image.
        /// </exception>
        public bool TryAcquireLatestCpuImage(out XRCpuImage cpuImage)
        {
            if (provider.cpuImageApi != null && provider.TryAcquireLatestCpuImage(out var cinfo))
            {
                cpuImage = new XRCpuImage(provider.cpuImageApi, cinfo);
                return true;
            }

            cpuImage = default;
            return false;
        }

        /// <summary>
        /// Registers a camera subsystem implementation based on the given subsystem parameters.
        /// </summary>
        /// <param name="cameraSubsystemParams">The parameters defining the camera subsystem functionality implemented
        /// by the subsystem provider.</param>
        /// <returns>
        /// <c>true</c> if the subsystem implementation is registered. Otherwise, <c>false</c>.
        /// </returns>
        /// <exception cref="System.ArgumentException">Thrown when the values specified in the
        /// <see cref="XRCameraSubsystemCinfo"/> parameter are invalid. Typically, this will occur
        /// <list type="bullet">
        /// <item>
        /// <description>if <see cref="XRCameraSubsystemCinfo.id"/> is <c>null</c> or empty</description>
        /// </item>
        /// <item>
        /// <description>if <see cref="XRCameraSubsystemCinfo.implementationType"/> is <c>null</c></description>
        /// </item>
        /// <item>
        /// <description>if <see cref="XRCameraSubsystemCinfo.implementationType"/> does not derive from the
        /// <see cref="XRCameraSubsystem"/> class
        /// </description>
        /// </item>
        /// </list>
        /// </exception>
        public static bool Register(XRCameraSubsystemCinfo cameraSubsystemParams)
        {
            XRCameraSubsystemDescriptor cameraSubsystemDescriptor = XRCameraSubsystemDescriptor.Create(cameraSubsystemParams);
#if UNITY_2020_2_OR_NEWER
            SubsystemDescriptorStore.RegisterDescriptor(cameraSubsystemDescriptor);
            return true;
#else
            return SubsystemRegistration.CreateDescriptor(cameraSubsystemDescriptor);
#endif
        }
    }
}