Câmera localizável no UnityLocatable camera in Unity

Habilitando o recurso de câmera de vídeo fotográficoEnabling the capability for Photo Video Camera

A capacidade de "WebCam" deve ser declarada para que um aplicativo use a câmera.The "WebCam" capability must be declared for an app to use the camera.

  1. No editor do Unity, vá para as configurações do Player navegando até a página "Editar configurações do projeto > > Player"In the Unity Editor, go to the player settings by navigating to the "Edit > Project Settings > Player" page
  2. Clique na guia "Windows Store"Click the "Windows Store" tab
  3. Na seção "configurações de publicação > recursos", verifique os recursos de webcam e de microfoneIn the "Publishing Settings > Capabilities" section, check the WebCam and Microphone capabilities

Apenas uma única operação pode ocorrer com a câmera de cada vez.Only a single operation can occur with the camera at a time. Para determinar qual modo (foto, vídeo ou nenhum) a câmera está no momento, você pode verificar UnityEngine. XR. WSA. WebCam. Mode.To determine which mode (photo, video, or none) the camera is currently in, you can check UnityEngine.XR.WSA.WebCam.Mode.

Captura de fotosPhoto Capture

Namespace: UnityEngine. XR. WSA. webcamNamespace: UnityEngine.XR.WSA.WebCam
Tipo: o CaptureType: PhotoCapture

O tipo de captura de imagem permite que você faça ainda fotografias com a câmera de vídeo de fotos.The PhotoCapture type allows you to take still photographs with the Photo Video Camera. O padrão geral para usar o Capture para tirar uma foto é o seguinte:The general pattern for using PhotoCapture to take a photo is as follows:

  1. Criar um objeto do PocaptureCreate a PhotoCapture object
  2. Crie um objeto cameraparameters com as configurações desejadasCreate a CameraParameters object with the settings you want
  3. Iniciar o modo de foto via StartPhotoModeAsyncStart Photo Mode via StartPhotoModeAsync
  4. Tirar a foto desejadaTake the desired photo
    • adicional Interagir com essa imagem(optional) Interact with that picture
  5. Parar o modo de foto e limpar os recursosStop Photo Mode and clean up resources

Configuração comum para o CaptureCommon Set Up for PhotoCapture

Para todos os três usos, comece com as mesmas primeiras 3 etapas acimaFor all three uses, start with the same first 3 steps above

Comece criando um objeto do PocaptureStart by creating a PhotoCapture object

PhotoCapture photoCaptureObject = null;
   void Start()
   {
       PhotoCapture.CreateAsync(false, OnPhotoCaptureCreated);
   }

Em seguida, armazene seu objeto, defina seus parâmetros e inicie o modo de fotoNext, store your object, set your parameters, and start Photo Mode

void OnPhotoCaptureCreated(PhotoCapture captureObject)
   {
       photoCaptureObject = captureObject;

       Resolution cameraResolution = PhotoCapture.SupportedResolutions.OrderByDescending((res) => res.width * res.height).First();

       CameraParameters c = new CameraParameters();
       c.hologramOpacity = 0.0f;
       c.cameraResolutionWidth = cameraResolution.width;
       c.cameraResolutionHeight = cameraResolution.height;
       c.pixelFormat = CapturePixelFormat.BGRA32;

       captureObject.StartPhotoModeAsync(c, false, OnPhotoModeStarted);
   }

No final, você também usará o mesmo código de limpeza apresentado aquiIn the end, you will also use the same clean up code presented here

void OnStoppedPhotoMode(PhotoCapture.PhotoCaptureResult result)
   {
       photoCaptureObject.Dispose();
       photoCaptureObject = null;
   }

Após essas etapas, você pode escolher o tipo de foto a ser capturado.After these steps, you can choose which type of photo to capture.

Capturar uma foto em um arquivoCapture a Photo to a File

A operação mais simples é capturar uma foto diretamente em um arquivo.The simplest operation is to capture a photo directly to a file. A foto pode ser salva como um JPG ou um PNG.The photo can be saved as a JPG or a PNG.

Se você iniciou o modo de foto com êxito, tire uma foto e armazene-a em discoIf you successfully started photo mode, take a photo and store it on disk

private void OnPhotoModeStarted(PhotoCapture.PhotoCaptureResult result)
   {
       if (result.success)
       {
           string filename = string.Format(@"CapturedImage{0}_n.jpg", Time.time);
           string filePath = System.IO.Path.Combine(Application.persistentDataPath, filename);

           photoCaptureObject.TakePhotoAsync(filePath, PhotoCaptureFileOutputFormat.JPG, OnCapturedPhotoToDisk);
       }
       else
       {
           Debug.LogError("Unable to start photo mode!");
       }
   }

Depois de capturar a foto para o disco, saia do modo de foto e limpe os objetosAfter capturing the photo to disk, exit photo mode and then clean up your objects

void OnCapturedPhotoToDisk(PhotoCapture.PhotoCaptureResult result)
   {
       if (result.success)
       {
           Debug.Log("Saved Photo to disk!");
           photoCaptureObject.StopPhotoModeAsync(OnStoppedPhotoMode);
       }
       else
       {
           Debug.Log("Failed to save Photo to disk");
       }
   }

Capturar uma foto para um Texture2DCapture a Photo to a Texture2D

Ao capturar dados para um Texture2D, o processo é extremamente semelhante à captura para o disco.When capturing data to a Texture2D, the process is extremely similar to capturing to disk.

Siga o processo de configuração acima.Follow the set up process above.

No OnPhotoModeStarted, Capture um quadro na memória.In OnPhotoModeStarted, capture a frame to memory.

private void OnPhotoModeStarted(PhotoCapture.PhotoCaptureResult result)
   {
       if (result.success)
       {
           photoCaptureObject.TakePhotoAsync(OnCapturedPhotoToMemory);
       }
       else
       {
           Debug.LogError("Unable to start photo mode!");
       }
   }

Em seguida, você aplicará o resultado a uma textura e usará o código de limpeza comum acima.You will then apply your result to a texture and use the common clean up code above.

void OnCapturedPhotoToMemory(PhotoCapture.PhotoCaptureResult result, PhotoCaptureFrame photoCaptureFrame)
   {
       if (result.success)
       {
           // Create our Texture2D for use and set the correct resolution
           Resolution cameraResolution = PhotoCapture.SupportedResolutions.OrderByDescending((res) => res.width * res.height).First();
           Texture2D targetTexture = new Texture2D(cameraResolution.width, cameraResolution.height);
           // Copy the raw image data into our target texture
           photoCaptureFrame.UploadImageDataToTexture(targetTexture);
           // Do as we wish with the texture such as apply it to a material, etc.
       }
       // Clean up
       photoCaptureObject.StopPhotoModeAsync(OnStoppedPhotoMode);
   }

Capture uma foto e interaja com os bytes brutosCapture a Photo and Interact with the Raw bytes

Para interagir com os bytes brutos de um quadro na memória, siga as mesmas etapas de configuração descritas acima e OnPhotoModeStarted como em capturando uma foto para um Texture2D.To interact with the raw bytes of an in memory frame, follow the same set up steps as above and OnPhotoModeStarted as in capturing a photo to a Texture2D. A diferença está em OnCapturedPhotoToMemory , em que você pode obter os bytes brutos e interagir com eles.The difference is in OnCapturedPhotoToMemory where you can get the raw bytes and interact with them.

Neste exemplo, você criará uma lista que pode ser processada ou aplicada a uma textura por meio de setPixels ()In this example, you will create a List which could be further processed or applied to a texture via SetPixels()

void OnCapturedPhotoToMemory(PhotoCapture.PhotoCaptureResult result, PhotoCaptureFrame photoCaptureFrame)
   {
       if (result.success)
       {
           List<byte> imageBufferList = new List<byte>();
           // Copy the raw IMFMediaBuffer data into our empty byte list.
           photoCaptureFrame.CopyRawImageDataIntoBuffer(imageBufferList);

           // In this example, we captured the image using the BGRA32 format.
           // So our stride will be 4 since we have a byte for each rgba channel.
           // The raw image data will also be flipped so we access our pixel data
           // in the reverse order.
           int stride = 4;
           float denominator = 1.0f / 255.0f;
           List<Color> colorArray = new List<Color>();
           for (int i = imageBufferList.Count - 1; i >= 0; i -= stride)
           {
               float a = (int)(imageBufferList[i - 0]) * denominator;
               float r = (int)(imageBufferList[i - 1]) * denominator;
               float g = (int)(imageBufferList[i - 2]) * denominator;
               float b = (int)(imageBufferList[i - 3]) * denominator;

               colorArray.Add(new Color(r, g, b, a));
           }
           // Now we could do something with the array such as texture.SetPixels() or run image processing on the list
       }
       photoCaptureObject.StopPhotoModeAsync(OnStoppedPhotoMode);
   }

Captura de vídeoVideo Capture

Namespace: UnityEngine. XR. WSA. webcamNamespace: UnityEngine.XR.WSA.WebCam
Tipo: VideoCaptureType: VideoCapture

O VideoCapture funciona de forma semelhante à do Capture.VideoCapture functions very similarly to PhotoCapture. As duas únicas diferenças são que você deve especificar um valor de quadros por segundo (FPS) e só pode salvar diretamente no disco como um arquivo. mp4.The only two differences are that you must specify a Frames Per Second (FPS) value and you can only save directly to disk as an .mp4 file. As etapas para usar o VideoCapture são as seguintes:The steps to use VideoCapture are as follows:

  1. Criar um objeto VideoCaptureCreate a VideoCapture object
  2. Crie um objeto cameraparameters com as configurações desejadasCreate a CameraParameters object with the settings you want
  3. Iniciar o modo de vídeo via StartVideoModeAsyncStart Video Mode via StartVideoModeAsync
  4. Iniciar gravação de vídeoStart recording video
  5. Parar de gravar vídeoStop recording video
  6. Parar o modo de vídeo e limpar os recursosStop Video Mode and clean up resources

Comece criando nosso objeto VideoCapture VideoCapture m_VideoCapture = NULL;Start by creating our VideoCapture object VideoCapture m_VideoCapture = null;

void Start ()
   {
       VideoCapture.CreateAsync(false, OnVideoCaptureCreated);
   }

Em seguida, configure os parâmetros desejados para a gravação e o início.Next, set up the parameters you will want for the recording and start.

void OnVideoCaptureCreated (VideoCapture videoCapture)
   {
       if (videoCapture != null)
       {
           m_VideoCapture = videoCapture;

           Resolution cameraResolution = VideoCapture.SupportedResolutions.OrderByDescending((res) => res.width * res.height).First();
           float cameraFramerate = VideoCapture.GetSupportedFrameRatesForResolution(cameraResolution).OrderByDescending((fps) => fps).First();

           CameraParameters cameraParameters = new CameraParameters();
           cameraParameters.hologramOpacity = 0.0f;
           cameraParameters.frameRate = cameraFramerate;
           cameraParameters.cameraResolutionWidth = cameraResolution.width;
           cameraParameters.cameraResolutionHeight = cameraResolution.height;
           cameraParameters.pixelFormat = CapturePixelFormat.BGRA32;

           m_VideoCapture.StartVideoModeAsync(cameraParameters,
                                               VideoCapture.AudioState.None,
                                               OnStartedVideoCaptureMode);
       }
       else
       {
           Debug.LogError("Failed to create VideoCapture Instance!");
       }
   }

Depois de iniciado, inicie a gravaçãoOnce started, begin the recording

void OnStartedVideoCaptureMode(VideoCapture.VideoCaptureResult result)
   {
       if (result.success)
       {
           string filename = string.Format("MyVideo_{0}.mp4", Time.time);
           string filepath = System.IO.Path.Combine(Application.persistentDataPath, filename);

           m_VideoCapture.StartRecordingAsync(filepath, OnStartedRecordingVideo);
       }
   }

Após o início da gravação, você pode atualizar sua interface do usuário ou comportamentos para habilitar a interrupção.After recording has started, you could update your UI or behaviors to enable stopping. Aqui você acabou de fazer logon.Here you just log.

void OnStartedRecordingVideo(VideoCapture.VideoCaptureResult result)
   {
       Debug.Log("Started Recording Video!");
       // We will stop the video from recording via other input such as a timer or a tap, etc.
   }

Em um ponto posterior, você desejará parar a gravação.At a later point, you will want to stop the recording. Isso pode acontecer de uma entrada de temporizador ou de usuário, por exemplo.This could happen from a timer or user input, for instance.

// The user has indicated to stop recording
   void StopRecordingVideo()
   {
       m_VideoCapture.StopRecordingAsync(OnStoppedRecordingVideo);
   }

Depois que a gravação for interrompida, pare o modo de vídeo e limpe os recursos.Once the recording has stopped, stop video mode and clean up your resources.

void OnStoppedRecordingVideo(VideoCapture.VideoCaptureResult result)
   {
       Debug.Log("Stopped Recording Video!");
       m_VideoCapture.StopVideoModeAsync(OnStoppedVideoCaptureMode);
   }

   void OnStoppedVideoCaptureMode(VideoCapture.VideoCaptureResult result)
   {
       m_VideoCapture.Dispose();
       m_VideoCapture = null;
   }

Painel de controle daTroubleshooting

  • Não há resoluções disponíveisNo resolutions are available
    • Verifique se a capacidade de webcam está especificada no seu projeto.Ensure the WebCam capability is specified in your project.

Veja tambémSee Also