> For the complete documentation index, see [llms.txt](https://docs.decentraland.org/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.decentraland.org/creator/content-creator-pt/scenes-sdk7/media/video-playing.md).

# Reprodução de Vídeo

Transmita vídeo para uma scene

Existem três formas diferentes de apresentar um vídeo numa cena:

* Carregar um ficheiro de vídeo como parte do conteúdo da cena
* Transmitir o vídeo a partir de uma fonte externa
* Transmitir em direto através do Decentraland Cast

{% hint style="info" %}
**💡 Dica**: no [Scene Editor no Creator Hub](https://docs.decentraland.org/creator/content-creator-pt/scene-editor/primeiros-passos/about-editor.md), pode usar um **Video Player** [Smart Item](https://docs.decentraland.org/creator/content-creator-pt/scene-editor/interatividade/smart-items.md) para o fazer sem escrever código.
{% endhint %}

Em todos os casos, vai precisar de:

* Uma entidade com uma [forma primitiva](https://docs.decentraland.org/creator/content-creator-pt/scenes-sdk7/fundamentos-de-conteudo-3d/shape-components.md) como um plano, um cubo ou até mesmo um cone.
* Um [Material](https://docs.decentraland.org/creator/content-creator-pt/scenes-sdk7/fundamentos-de-conteudo-3d/materials.md) com uma `VideoTexture` atribuída à respetiva textura
* Um `VideoPlayer` Component para controlar o estado do vídeo.

## Considerações de desempenho

Tenha em conta que a transmissão de vídeo exige um esforço significativo da máquina do jogador. Recomenda-se evitar a reprodução de mais de um vídeo de cada vez.

Se estiverem a ser reproduzidos demasiados vídeos ao mesmo tempo na sua cena, alguns serão pausados pelo Engine. A prioridade de pausa de um ecrã é determinada com base em vários fatores, incluindo a proximidade do jogador, o tamanho e se o ecrã está no campo de visão do jogador. O número máximo de vídeos simultâneos depende das definições de qualidade do jogador.

* Baixa: 1
* Média: 5
* Alta: 10

Também recomendamos que o vídeo comece a ser reproduzido quando o jogador estiver por perto ou realizar uma ação para o iniciar. Começar a reproduzir um vídeo quando a sua cena é carregada muito longe, no horizonte, afetará desnecessariamente o desempenho enquanto os jogadores visitam cenas vizinhas.

Evite também transmitir vídeos com uma resolução muito alta. Não utilize nada acima de *HD*.

Também é ideal reproduzir vídeos em Materials Basic (sem iluminação) para reduzir o impacto no desempenho, como acontece em todos os exemplos de código abaixo.

## Apresentar um vídeo

As instruções seguintes aplicam-se às três opções para apresentar vídeos:

1. Crie uma entidade que servirá de ecrã de vídeo. Adicione a esta entidade um Component `MeshRenderer` para que tenha uma forma visível.
2. Crie um Component `VideoPlayer` que faça referência a um URL de transmissão ou ao caminho para um ficheiro de vídeo. Aqui também pode definir o estado `playing` do vídeo e o respetivo volume. Este Component pode ser atribuído à entidade do ecrã de vídeo ou a qualquer outra entidade da cena.
3. Crie um objeto `VideoTexture` e, na respetiva propriedade `videoPlayerEntity` atribua a entidade que contém o Component `VideoPlayer` .
4. Crie um `Material`, atribua-o à entidade do ecrã e defina a respetiva propriedade `texture` para o `VideoTexture` que criou.

Este exemplo usa um vídeo armazenado localmente numa `/videos` pasta do projeto da cena:

```ts
// #1
const screen = engine.addEntity()
MeshRenderer.setPlane(screen)
Transform.create(screen, { position: { x: 4, y: 1, z: 4 } })

// #2
VideoPlayer.create(screen, {
	src: 'videos/myVideo.mp4',
	playing: true,
})

// #3
const videoTexture = Material.Texture.Video({ videoPlayerEntity: screen })

// #4
Material.setBasicMaterial(screen, {
	texture: videoTexture,
})
```

Para usar um vídeo de um URL de streaming externo, altere o passo 2 para que a `src` propriedade no componente `VideoPlayer` aponte para o URL de streaming.

```ts
// #2
VideoPlayer.create(screen, {
	src: 'https://vz-7c61c1b5-d59.b-cdn.net/ccea595a-b910-4de6-b160-092819db021d/playlist.m3u8',
	playing: true,
})
```

Consulte [Transmissão em direto](#live-streaming) para saber como utilizar este terceiro método alternativo.

## Sobre o streaming externo

A origem do streaming tem de ser um URL *https*  (*http* não são suportados).

Deverá ser possível colar um URL que aponte para um vídeo na maioria dos sites populares de streaming de vídeo. Tenha em atenção os termos de serviço destas plataformas.

Para transmitir um ficheiro de vídeo que tem no seu computador, a forma mais fácil é carregá-lo para uma conta pública do Google Drive e colar o link.

Outra opção é utilizar um fornecedor de alojamento gerido, como [Vimeo](https://vimeo.com/) , [Livepeer Studio](https://livepeer.studio/) ou [Serraform](https://serraform.gitbook.io/streaming-docs/guides/decentraland-playback) onde paga uma taxa ao fornecedor para gerir toda a infraestrutura de streaming.

A opção mais avançada é configurar o seu próprio servidor, utilizando software gratuito e pagando pelo alojamento numa plataforma como [Digital Ocean](https://try.digitalocean.com/developerbrand/?_campaign=emea_brand_kw_en_cpc&_adgroup=digitalocean_exact_exact&_keyword=digitalocean&_device=c&_adposition=&_content=conversion&_medium=cpc&_source=bing\&msclkid=160bfc160a2a1bab9bbf9933594bd9c5\&utm_source=bing\&utm_medium=cpc\&utm_campaign=emea_brand_kw_en_cpc\&utm_term=digitalocean\&utm_content=DigitalOcean%20Exact_Exact) ou [Cloudflare](https://www.cloudflare.com/products/cloudflare-stream/). Pode implementar algo como o [Node Media Server](https://github.com/illuspas/Node-Media-Server), que oferece, logo à partida, a maior parte do que precisa.

Todas estas opções têm vantagens e desvantagens, consoante o cenário. Deve avaliar qual é a melhor para si, tendo em conta as suas necessidades, competências técnicas e orçamento.

## Configurar o OBS para transmitir com sucesso

[OBS](https://obsproject.com/) é uma ferramenta popular e gratuita para gerir as suas transmissões.

Quer esteja a utilizar uma chave de transmissão de um espaço ou o seu próprio servidor RTMP, as definições do OBS são importantes para o sucesso da sua transmissão. Procure garantir uma ligação estável e consistente.

### Configuração simples do OBS

Recomenda-se a seguinte configuração simples:

* Taxa de bits: 2500 kbps (compatível com todos os espaços do Decentraland)
* Taxa de bits do áudio: 160 kbps
* Predefinição do codificador de vídeo: Hardware NVENC
* Codificador de áudio: AAC
* Resolução máxima: 720 (qualquer valor superior causa problemas no DCL)
* Taxa de fotogramas: 30 fps

{% hint style="warning" %}
**📔 Nota**: Certifique-se de que desativa a transmissão Multitrack no OBS. Pode encontrar esta opção em Settings > Stream.
{% endhint %}

### Conselhos para quem está a começar a fazer transmissões

* É essencial fazer testes de áudio com antecedência para testar a configuração no espaço.
* Pequenos erros, como um algarismo errado na chave de transmissão, são os que mais provavelmente vão comprometer a transmissão.
* Não ultrapasse a resolução de 720 nem uma taxa de bits de 2500 kbps.

## Transmissão em direto

Pode fazer uma transmissão em direto a partir da sua câmara ou partilhar o ecrã através da funcionalidade [Live streaming](https://docs.decentraland.org/creator/content-creator-pt/scene-editor/operar-ao-vivo/live-streaming.md) do smart item [Admin tools](https://docs.decentraland.org/creator/content-creator-pt/scene-editor/operar-ao-vivo/scene-admin.md) .

Este método de transmissão usa a mesma arquitetura de comunicações que permite as comunicações em direto entre jogadores. É fácil de configurar e tem muito menos atraso do que a transmissão a partir de fontes externas.

1. Adicione um smart item [Admin tools](https://docs.decentraland.org/creator/content-creator-pt/scene-editor/operar-ao-vivo/scene-admin.md) à sua cena, bem como um smart item [Video player](https://docs.decentraland.org/creator/content-creator-pt/scene-editor/interatividade/video-screen.md) .
2. Publique a sua cena, num World ou em Genesis City.
3. Entre na cena como jogador com permissão para usar o Admin tools.
4. Abra a consola Admin, selecione o separador **Video** , depois selecione a funcionalidade **Live** e clique no botão **Get Stream Key** .
5. Copie o **Server URL** e a *Streaming key*\* para o seu software de transmissão (por exemplo, OBS).
6. Prima o botão **Activate** para iniciar a transmissão.

Em vez de adicionar um smart item Video player à sua cena, também pode usar o URL `livekit-video://current-stream` como fonte de vídeo para reproduzir a transmissão na sua cena. Continua a precisar do Admin tools para obter a chave de transmissão.

```ts
// #1
const screen = engine.addEntity()
MeshRenderer.setPlane(screen)
Transform.create(screen, { position: { x: 4, y: 1, z: 4 } })

// #2
VideoPlayer.create(screen, {
	src: `livekit-video://current-stream`,
	playing: true,
})

// #3
const videoTexture = Material.Texture.Video({ videoPlayerEntity: screen })

// #4
Material.setBasicMaterial(screen, {
	texture: videoTexture,
})
```

## Materiais de vídeo

Na maioria dos casos, vai querer reproduzir vídeos num [material Basic](https://docs.decentraland.org/creator/content-creator-pt/scenes-sdk7/fundamentos-de-conteudo-3d/materials.md#unlit-materials)sem iluminação, em vez de um material PBR. Isto resulta numa imagem muito mais brilhante e nítida e melhora o desempenho.

```ts
Material.setBasicMaterial(screen, {
	texture: videoTexture,
})
```

Geralmente, recomenda-se reproduzir vídeos em materiais Basic sem iluminação, pois isso melhora o desempenho. No entanto, se quiser projetar um vídeo num material PBR, tenha em conta que as propriedades predefinidas fazem com que o vídeo pareça bastante opaco. Pode melhorar este aspeto alterando outras propriedades do material. Eis algumas definições recomendadas para dar mais destaque ao vídeo:

```ts
Material.setPbrMaterial(screen, {
	texture: videoTexture,
	roughness: 1.0,
	specularIntensity: 0,
	metallic: 0,
	emissiveTexture: videoTexture,
	emissiveIntensity: 0.6,
	emissiveColor: Color3.White(),
})
```

{% hint style="info" %}
**💡 Dica**: Como o vídeo é uma textura adicionada a um Material, também pode experimentar outras propriedades dos Materials, como aplicar-lhe uma tonalidade ou adicionar outras camadas de textura, por exemplo, para produzir um efeito de ecrã sujo.

Consulte [materials](https://docs.decentraland.org/creator/content-creator-pt/scenes-sdk7/fundamentos-de-conteudo-3d/materials.md) para obter mais detalhes.
{% endhint %}

## Sobre ficheiros de vídeo

São suportados os seguintes formatos de ficheiro:

* *.mp4*
* *.ogg*
* *.webm*

Tenha em atenção que um ficheiro de vídeo aumenta o tamanho total da Scene, o que faz com que esta demore mais tempo a ser transferida para os jogadores que entram na sua Scene. O tamanho do vídeo também pode fazer com que ultrapasse as [limitações da Scene](https://docs.decentraland.org/creator/content-creator-pt/scenes-sdk7/otimizacao/scene-limitations.md), uma vez que tem um máximo de 15 MB por parcela. Recomendamos comprimir o vídeo tanto quanto possível, para minimizar este problema.

Também recomendamos que comece a reproduzir o vídeo quando o jogador estiver por perto ou realizar uma ação que o acione. Começar a reproduzir um vídeo quando a sua cena é carregada longe, no horizonte, afetará desnecessariamente o desempenho enquanto os jogadores visitam cenas vizinhas.

## Iniciar, pausar e parar um vídeo

Para começar a reproduzir o vídeo ou pausá-lo, defina a propriedade `playing` como *true* ou *false*. Se `playing` estiver definida como false, o vídeo é pausado no último fotograma apresentado.

Pode tornar um ecrã alternável adicionando-lhe um evento de ponteiro, como mostrado abaixo:

```ts
pointerEventsSystem.onPointerDown(
	{
		entity: screen,
		opts: { button: InputAction.IA_POINTER, hoverText: 'Play/Pause' },
	},
	function () {
		const videoPlayer = VideoPlayer.getMutable(screen)
		videoPlayer.playing = !videoPlayer.playing
	}
)
```

Para parar o vídeo e voltar ao primeiro fotograma, defina a propriedade `position` como 0. No exemplo seguinte, clicar no vídeo para-o.

```ts
pointerEventsSystem.onPointerDown(
	{
		entity: screen,
		opts: { button: InputAction.IA_POINTER, hoverText: 'STOP' },
	},
	function () {
		const videoPlayer = VideoPlayer.getMutable(screen)
		videoPlayer.playing = false
		videoPlayer.position = 0
	}
)
```

## Configurar o leitor de vídeo

As seguintes propriedades opcionais estão disponíveis para definir no componente `VideoPlayer` :

* `playing`: Determina se o vídeo está a ser reproduzido. Se for false, o vídeo fica pausado.

{% hint style="warning" %}
**📔 Nota**: Só é possível reproduzir um número limitado de vídeos ao mesmo tempo, dependendo das definições de qualidade do jogador. Se a cena reproduzir mais do que esse número, o Engine pausa os vídeos com menor prioridade. Consulte [Considerações sobre o desempenho](#performance-considerations).
{% endhint %}

* `playbackRate`: Altera a velocidade de reprodução do vídeo. *1* por predefinição.
* `volume`: Permite alterar o volume do áudio. *1* por predefinição.
* `position`: Permite definir uma posição inicial diferente no vídeo. É expressa em segundos desde o início original do vídeo. *0* por predefinição, o que faz com que comece no início efetivo do vídeo.
* `loop`: Booleano que determina se o vídeo é reproduzido continuamente em loop ou se para depois de ser reproduzido uma vez. *false* por predefinição.

## Reproduzir vários vídeos

Para evitar problemas de desempenho, mantenha reduzido o número de vídeos diferentes reproduzidos em simultâneo; o motor só permite um número limitado de vídeos simultâneos, dependendo das definições de qualidade do jogador (consulte [Considerações sobre o desempenho](#performance-considerations)). No entanto, uma cena pode reproduzir várias cópias da mesma textura de vídeo em vários ecrãs diferentes. Isto não é restringido, pois tem um impacto consideravelmente menor no desempenho do que reproduzir vídeos separados. Para reproduzir o mesmo vídeo em várias entidades, basta atribuir a mesma instância do objeto de textura de vídeo aos componentes `Material` de cada entidade de ecrã.

```ts
// #1
const screen1 = engine.addEntity()
MeshRenderer.setPlane(screen1)
Transform.create(screen1, { position: { x: 4, y: 1, z: 4 } })

const screen2 = engine.addEntity()
MeshRenderer.setPlane(screen2)
Transform.create(screen2, { position: { x: 6, y: 1, z: 4 } })

// #2
VideoPlayer.create(screen1, {
	src: 'https://vz-7c61c1b5-d59.b-cdn.net/ccea595a-b910-4de6-b160-092819db021d/playlist.m3u8',
	playing: true,
})

// #3
const videoTexture = Material.Texture.Video({ videoPlayerEntity: screen1 })

// #4
Material.setBasicMaterial(screen1, {
	texture: videoTexture,
})

Material.setBasicMaterial(screen2, {
	texture: videoTexture,
})
```

Note que, no exemplo acima, só é necessário criar um componente `VideoPlayer` , que controla o estado de ambos os ecrãs de vídeo. Neste caso, o componente é atribuído à entidade `screen1` , mas também poderia ser atribuído a qualquer outra entidade da cena, não necessariamente a um dos ecrãs.

## Eventos de vídeo

Trate facilmente as alterações de estado de um vídeo, respondendo, por exemplo, ao início da reprodução ou à pausa. Isto pode ser utilizado, por exemplo, para reproduzir animações em perfeita sincronização com um vídeo, garantindo que começam ao mesmo tempo que o vídeo.

Utilize `videoEventsSystem.registerVideoEventsEntity` para definir uma função que é executada sempre que o estado do vídeo atribuído a uma entidade muda. Sempre que o estado muda, a função pode verificar o novo estado e responder em conformidade.

```ts
import {
	engine,
	Entity,
	VideoPlayer,
	videoEventsSystem,
	VideoState,
} from '@dcl/sdk/ecs'

// ... Create videoPlayerEntity with VideoPlayer component, Transform, MeshRenderer.setPlane(), etc. ...

videoEventsSystem.registerVideoEventsEntity(
	videoPlayerEntity,
	function (videoEvent) {
		console.log(
			'video event - state: ' +
				videoEvent.state +
				'\ncurrent offset:' +
				videoEvent.currentOffset +
				'\nvideo length:' +
				videoEvent.videoLength
		)

		switch (videoEvent.state) {
			case VideoState.VS_READY:
				console.log('video event - video is READY')
				break
			case VideoState.VS_NONE:
				console.log('video event - video is in NO STATE')
				break
			case VideoState.VS_ERROR:
				console.log('video event - video ERROR')
				break
			case VideoState.VS_SEEKING:
				console.log('video event - video is SEEKING')
				break
			case VideoState.VS_LOADING:
				console.log('video event - video is LOADING')
				break
			case VideoState.VS_BUFFERING:
				console.log('video event - video is BUFFERING')
				break
			case VideoState.VS_PLAYING:
				console.log('video event - video started PLAYING')
				break
			case VideoState.VS_PAUSED:
				console.log('video event - video is PAUSED')
				break
		}
	}
)
```

O objeto videoEvent passado como entrada para a função contém as seguintes propriedades:

* `currentOffset` (*número*): O valor atual da `position` propriedade no vídeo. Este valor indica os segundos decorridos desde o início original do vídeo. *-1* se o vídeo ainda não tiver começado a ser reproduzido.
* `state`: O novo estado do vídeo, expresso como um valor do `VideoState` enum. Este enum pode ter os seguintes valores:
  * `VideoState.VS_READY`
  * `VideoState.VS_NONE`
  * `VideoState.VS_ERROR`
  * `VideoState.VS_SEEKING`
  * `VideoState.VS_LOADING`
  * `VideoState.VS_BUFFERING`
  * `VideoState.VS_PLAYING`
  * `VideoState.VS_PAUSED`
* `videoLength` (*número* ): A duração total do vídeo em segundos. *-1* se a duração for desconhecida.
* `timestamp` ( *número*): Um *lamport* timestamp que é incrementado sempre que o estado do vídeo muda.
* `tickNumber` (*número*): O momento em que o evento ocorreu, expresso como a contagem de ticks desde que a cena começou a ser executada.

Se voltar a registar um callback numa Entity que já tenha um (por exemplo, para alterar o que acontece quando o estado muda), o novo callback substitui o anterior e o último estado comunicado é preservado. Isto significa que o novo callback não é chamado novamente para um estado que já tenha sido comunicado ao callback anterior.

### Verificar se uma Entity está registada

Use `videoEventsSystem.hasVideoEventsEntity()` para verificar se uma Entity já tem um callback de eventos de vídeo registado.

```ts
if (videoEventsSystem.hasVideoEventsEntity(videoPlayerEntity)) {
	console.log('This entity already has a video event listener')
}
```

### Evento de vídeo mais recente

Consulte a última alteração de estado de um vídeo usando `videoEventsSystem.getVideoState()`. Isso retorna o valor mais recente de `VideoEvent` para a entidade, ou `undefined` se nenhum evento tiver sido reportado ainda. Você pode chamar isso em um sistema para verificar o estado do vídeo a cada frame sem registrar um callback.

```ts
function mySystem() {
	const latestVideoEvent = videoEventsSystem.getVideoState(videoPlayerEntity)
	if (!latestVideoEvent) return

	console.log(`state: ${latestVideoEvent.state}
    \ncurrentOffset: ${latestVideoEvent.currentOffset}
    \nvideoLength: ${latestVideoEvent.videoLength}`)
}
```

## Máscaras alfa em vídeos

Um truque interessante para criar telas de vídeo não retangulares é aplicar uma textura alfa sobre um plano. Você pode recortar parte do plano no formato que quiser.

Use a imagem a seguir para recortar o vídeo em formato circular, com cantos transparentes.

![](https://2402076176-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FoPnXBby9S6MrsW83Y9qZ%2Fuploads%2Fgit-blob-ee3e152f3312f46d04d8640b44f42f1254e26f3b%2Fcircle_mask.webp?alt=media)

```ts
const videoTexture = Material.Texture.Video({
	videoPlayerEntity: screen,
})
const alphaMask = Material.Texture.Common({
	src: 'assets/scene/circle_mask.png',
	wrapMode: TextureWrapMode.TWM_MIRROR,
})

Material.setBasicMaterial(screen, {
	texture: videoTexture,
	alphaTexture: alphaMask,
})
```

![](https://2402076176-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FoPnXBby9S6MrsW83Y9qZ%2Fuploads%2Fgit-blob-901568ee2ece2fed1734c93716d4c7069869c47c%2Fcircular-video-screen.webp?alt=media)

{% hint style="warning" %}
**📔 Nota**: Nas versões anteriores, a propriedade `alphaTexture` só estava presente em materiais PBR. Atualmente, ela só funciona em materiais básicos.
{% endhint %}

## Reproduzir um vídeo em um modelo glTF

Você pode reproduzir um vídeo em um modelo *glTF* usando o componente [GltfNodeModifiers](https://docs.decentraland.org/creator/content-creator-pt/scenes-sdk7/fundamentos-de-conteudo-3d/materials.md#modify-gltf-materials) . Consulte [Modificar materiais glTF](https://docs.decentraland.org/creator/content-creator-pt/scenes-sdk7/fundamentos-de-conteudo-3d/materials.md#modify-gltf-materials) para saber mais.

Isso permite reproduzir vídeos em qualquer formato, não apenas em planos. Por exemplo, você pode reproduzir vídeos em uma tela curva ou até mesmo no corpo inteiro de um NPC.

```ts
const myEntity = engine.addEntity()

GltfContainer.create(myEntity, {
	src: 'models/myModel.glb',
})

Transform.create(myEntity, {
	position: Vector3.create(4, 0, 4),
})

VideoPlayer.create(myEntity, {
	src: 'https://vz-7c61c1b5-d59.b-cdn.net/ccea595a-b910-4de6-b160-092819db021d/playlist.m3u8',
	playing: true,
})

GltfNodeModifiers.create(myEntity, {
	modifiers: [
		{
			path: '',
			material: {
				material: {
					$case: 'pbr',
					pbr: {
						texture: Material.Texture.Video({
							videoPlayerEntity: myEntity,
						}),
					},
				},
			},
		},
	],
})
```

O mapeamento do vídeo seguirá o mapeamento UV original usado pelo modelo. Isso significa que, se o modelo tiver uma textura mapeada para uma parte específica, o vídeo será mapeado para essa mesma parte.

Você também pode usar o componente `GltfNodeModifiers` para reproduzir um vídeo apenas em uma malha específica dentro do modelo. Por exemplo, você pode reproduzi-lo em uma parede específica de um edifício, mesmo que o modelo abranja o edifício inteiro. Consulte [Modificar materiais glTF](https://docs.decentraland.org/creator/content-creator-pt/scenes-sdk7/fundamentos-de-conteudo-3d/materials.md#modify-gltf-materials) para saber mais.

## Áudio espacial

Por padrão, o vídeo de um componente `VideoPlayer` tem áudio global, o que significa que será ouvido com volume constante em toda a cena. Se um jogador sair da cena, não ouvirá o streaming.

Para tornar o áudio espacial, defina a propriedade `spatial` como *true*.

```ts
VideoPlayer.create(entity, {
	src: 'https://player.vimeo.com/progressive_redirect/playback/1145666916/rendition/540p/file.mp4%20%28540p%29.mp4?loc=external&signature=db1cd6946851313cb8f7be60d1f6c30af0902bcc46fdae0ba2a06e5fdf44c329',
	playing: true,
	spatial: true,
})
```

Agora, o vídeo será ouvido a partir da posição da entidade que possui o `VideoPlayer` componente, e ficará mais alto à medida que o jogador se aproximar dele.

Controle o áudio espacial com as seguintes propriedades:

* `spatialMinDistance`: a distância mínima a partir da qual o áudio se torna espacial. Se o jogador estiver mais perto, o áudio será ouvido no volume máximo. *0* por predefinição.
* `spatialMaxDistance`: a distância máxima a partir da qual o áudio é ouvido. Se o jogador estiver mais longe, o áudio será ouvido com volume 0. *60* por predefinição

```ts
const videoPlayerEntity = engine.addEntity()

Transform.create(videoPlayerEntity, {
	position: Vector3.create(8, 2, 8),
})

VideoPlayer.create(videoPlayerEntity, {
	src: 'https://player.vimeo.com/progressive_redirect/playback/1145666916/rendition/540p/file.mp4%20%28540p%29.mp4?loc=external&signature=db1cd6946851313cb8f7be60d1f6c30af0902bcc46fdae0ba2a06e5fdf44c329',
	playing: true,
	spatial: true,
	spatialMinDistance: 5,
	spatialMaxDistance: 10,
})

MeshRenderer.setPlane(videoPlayerEntity)

Material.setBasicMaterial(videoPlayerEntity, {
	texture: Material.Texture.Video({ videoPlayerEntity: videoPlayerEntity }),
})
```

{% hint style="warning" %}
**📔 Nota**: Alguns formatos de vídeo não suportam áudio espacial. Certifique-se de que a stream está codificada em *mp4*, *m4a*, ou *mov*.
{% endhint %}

## Análise de áudio

Pode ler dados de amplitude e frequência em tempo real da faixa de áudio de uma entidade `VideoPlayer` para controlar elementos visuais reativos que se sincronizam com a banda sonora do vídeo. Consulte [Análise de áudio](https://docs.decentraland.org/creator/content-creator-pt/scenes-sdk7/media/audio-analysis.md).

{% hint style="info" %}
**💡 Sugestão**: Para ver um vídeo reproduzido num modelo GLTF em vez de num elemento primitivo, consulte a cena de teste [`74,-8-gltfnodemodifier`](https://github.com/decentraland/sdk7-test-scenes/tree/main/scenes/74,-8-gltfnodemodifier) , que reproduz uma stream HLS em nós GLTF específicos utilizando `GltfNodeModifiers` texturas de vídeo.
{% endhint %}


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation by asking a question.

Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters:

```
GET https://docs.decentraland.org/creator/content-creator-pt/scenes-sdk7/media/video-playing.md?ask=<question>&goal=<user_goal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.
