Câmera de foto/vídeo no Unity

Habilitando a capacidade de acesso à câmera

A funcionalidade "WebCam" deve ser declarada para que um aplicativo use a câmera.

1. No Editor do Unity, acesse as configurações do player navegando até a página "Editar > Player de Configurações > do Projeto"
2. Selecione a guia "Windows Store"
3. Na seção "Funcionalidades de Configurações > de Publicação", marcar os recursos WebCam e Microfone

Somente uma única operação pode ocorrer com a câmera por vez. Você pode marcar com UnityEngine.XR.WSA.WebCam.Mode qual modo a câmera está atualmente no Unity 2018 e anterior ou UnityEngine.Windows.WebCam.Mode no Unity 2019 e posterior. Os modos disponíveis são foto, vídeo ou nenhum.

Captura de fotos

Namespace (antes do Unity 2019):UnityEngine.XR.WSA.WebCam
Namespace (Unity 2019 e posterior):UnityEngine.Windows.WebCam
Type:PhotoCapture

O tipo PhotoCapture permite que você tire fotos ainda com a Câmera de Vídeo de Fotos. O padrão geral para usar o PhotoCapture para tirar uma foto é o seguinte:

1. Criar um objeto PhotoCapture
2. Criar um objeto CameraParameters com as configurações desejadas
3. Iniciar o modo de foto por meio de StartPhotoModeAsync
4. Tire a foto desejada
   • (opcional) Interagir com essa imagem
5. Parar o modo de foto e limpo recursos

Configuração comum para PhotoCapture

Para todos os três usos, comece com as mesmas três primeiras etapas acima

Comece criando um objeto PhotoCapture

private void Start()
{
    PhotoCapture.CreateAsync(false, OnPhotoCaptureCreated);
}

Em seguida, armazene seu objeto, defina seus parâmetros e inicie o Modo de Foto

private PhotoCapture photoCaptureObject = null;

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 limpo apresentado aqui

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

Após essas etapas, você pode escolher qual tipo de foto capturar.

Capturar uma foto para um arquivo

A operação mais simples é capturar uma foto diretamente em um arquivo. A foto pode ser salva como JPG ou PNG.

Se você iniciou com êxito o modo de foto, tire uma foto e armazene-a em disco

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 no disco, saia do modo de foto e limpo seus objetos

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 em um Texture2D com localização

Ao capturar dados em um Texture2D, o processo é semelhante à captura em disco.

Siga o processo de instalação acima.

Em OnPhotoModeStarted, capture um quadro na memória.

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 comum limpo acima.

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);
}

Câmera localizável

Para colocar essa textura na cena e exibi-la usando as matrizes de câmera localizáveis, adicione o seguinte código a OnCapturedPhotoToMemory no result.success marcar:

if (photoCaptureFrame.hasLocationData)
{
    photoCaptureFrame.TryGetCameraToWorldMatrix(out Matrix4x4 cameraToWorldMatrix);

    Vector3 position = cameraToWorldMatrix.GetColumn(3) - cameraToWorldMatrix.GetColumn(2);
    Quaternion rotation = Quaternion.LookRotation(-cameraToWorldMatrix.GetColumn(2), cameraToWorldMatrix.GetColumn(1));

    photoCaptureFrame.TryGetProjectionMatrix(Camera.main.nearClipPlane, Camera.main.farClipPlane, out Matrix4x4 projectionMatrix);
}

O Unity forneceu um código de exemplo para aplicar a matriz de projeção a um sombreador específico em seus fóruns.

Capturar uma foto e interagir com os bytes brutos

Para interagir com os bytes brutos de um quadro na memória, siga as mesmas etapas de configuração acima e OnPhotoModeStarted como na captura de uma foto em um Texture2D. A diferença está em OnCapturedPhotoToMemory , em que você pode obter os bytes brutos e interagir com eles.

Neste exemplo, você criará uma Lista para ser processada ou aplicada a uma textura por meio de 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ídeo

Namespace (antes do Unity 2019):UnityEngine.XR.WSA.WebCam
Namespace (Unity 2019 e posterior):UnityEngine.Windows.WebCam
Type:VideoCapture

O VideoCapture funciona de forma semelhante ao PhotoCapture. As duas únicas diferenças são que você deve especificar um valor fps (quadros por segundo) e só pode salvar diretamente no disco como um arquivo .mp4. As etapas para usar o VideoCapture são as seguintes:

1. Criar um objeto VideoCapture
2. Criar um objeto CameraParameters com as configurações desejadas
3. Iniciar o modo de vídeo por meio de StartVideoModeAsync
4. Iniciar gravação de vídeo
5. Parar gravação de vídeo
6. Parar o modo de vídeo e limpo recursos

Comece criando nosso objeto VideoCapture VideoCapturem_VideoCapture = nulo;

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

Em seguida, configure os parâmetros desejados para a gravação e o início.

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!");
    }
}

Uma vez iniciada, inicie a gravação

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);
    }
}

Depois que a gravação for iniciada, você poderá atualizar a interface do usuário ou os comportamentos para habilitar a interrupção. Aqui você apenas registra.

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á interromper a gravação usando um temporizador ou entrada do usuário, por exemplo.

// 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 limpo seus recursos.

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;
}

Solução de problemas

• Nenhuma resolução está disponível
  • Verifique se a funcionalidade da WebCam está especificada em seu projeto.

Próximo ponto de verificação de desenvolvimento

Se você estiver seguindo o percurso de ponto de verificação de desenvolvimento do Unity que apresentamos, você está no meio da exploração dos recursos e APIs da plataforma Realidade Misturada. Deste ponto, você pode prosseguir para o próximo tópico:

Ponto de foco

Ou vá diretamente para a implantação de seu aplicativo em um dispositivo ou emulador:

Implantar no HoloLens ou Windows Mixed Reality headsets imersivos

Você sempre pode voltar para os pontos de verificação de desenvolvimento do Unity a qualquer momento.

Confira também

• Exemplo de câmera localizável
• Visão geral da câmera localizável
• Câmera localizável com exemplos de C++
• Captura de realidade mista
• Captura de realidade misturada para desenvolvedores
• Introdução à captura de mídia
• Exemplo de acompanhamento facial holográfico