> 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-es/scenes-sdk7/media/video-playing.md).

# Reproducción de video

Transmite video a una escena

Hay tres formas diferentes de mostrar un video en una escena:

* Subir un archivo de video como parte del contenido de la escena
* Transmitir el video desde una fuente externa
* Transmitir en vivo a través de Decentraland Cast

{% hint style="info" %}
**💡 Consejo**: En el [Scene Editor de Creator Hub](https://docs.decentraland.org/creator/content-creator-es/scene-editor/primeros-pasos/about-editor.md), puedes usar un **Video Player** [Smart Item](https://docs.decentraland.org/creator/content-creator-es/scene-editor/interactividad/smart-items.md) para hacerlo sin código.
{% endhint %}

En todos los casos, necesitarás:

* Una Entity con una [forma primitiva](https://docs.decentraland.org/creator/content-creator-es/scenes-sdk7/fundamentos-del-contenido-3d/shape-components.md) como un plano, un cubo o incluso un cono.
* Un [Material](https://docs.decentraland.org/creator/content-creator-es/scenes-sdk7/fundamentos-del-contenido-3d/materials.md) con una `VideoTexture` asignada a su textura
* Un `VideoPlayer` Component para controlar el estado del video.

## Consideraciones de rendimiento

Ten en cuenta que transmitir video exige un esfuerzo considerable a la máquina del jugador. Se recomienda evitar reproducir más de un video a la vez.

Si se reproducen demasiados videos al mismo tiempo en tu escena, el Engine pausará algunos. La prioridad para pausar una pantalla se determina según varios factores, como la proximidad al jugador, el tamaño y si la pantalla está dentro del campo de visión del jugador. El número máximo de videos simultáneos depende de la configuración de calidad del jugador.

* Baja: 1
* Media: 5
* Alta: 10

También recomendamos iniciar la reproducción del video cuando el jugador esté cerca o realice una acción para hacerlo. Empezar a reproducir un video cuando la escena se carga en el horizonte afectará innecesariamente el rendimiento mientras los jugadores visitan escenas vecinas.

Evita también transmitir videos con una resolución muy alta. No uses nada superior a *HD*.

También es ideal reproducir videos en materiales Basic (sin iluminación) para reducir la carga de rendimiento, como en todos los ejemplos de código siguientes.

## Mostrar un video

Las siguientes instrucciones se aplican a las tres opciones para mostrar videos:

1. Crea una Entity que sirva como pantalla de video. Añade a esta Entity un Component `MeshRenderer` para que tenga una forma visible.
2. Crea un Component `VideoPlayer` que haga referencia a una URL de streaming o a la ruta de un archivo de video. Aquí también puedes establecer el estado `playing` del video y su volumen. Este Component se puede asignar a la Entity de la pantalla de video o a cualquier otra Entity de la escena.
3. Crea un objeto `VideoTexture` y, en su propiedad `videoPlayerEntity` asigna la Entity que contiene el Component `VideoPlayer` .
4. Crea un `Material`, asígnalo a la Entity de la pantalla y establece su `texture` a la `VideoTexture` que creaste.

Este ejemplo usa un video almacenado localmente en una `/videos` carpeta del proyecto de la escena:

```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 un video desde una URL de streaming externa, modifica el paso 2 para que la `src` propiedad del componente `VideoPlayer` haga referencia a la 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,
})
```

Consulta [Live streaming](#live-streaming) para obtener detalles sobre cómo usar este tercer método alternativo.

## Acerca del streaming externo

La fuente del streaming debe ser una URL *https* (*http* no se admiten las URL).

Deberías poder pegar una URL que apunte a un video de la mayoría de los sitios de streaming populares. Ten en cuenta las condiciones del servicio de estas plataformas.

Para transmitir un archivo de video que tengas en tu equipo, lo más sencillo es subirlo a Google Drive público y pegar el enlace.

Otra opción es usar un proveedor de alojamiento administrado, como [Vimeo](https://vimeo.com/) , [Livepeer Studio](https://livepeer.studio/) o [Serraform](https://serraform.gitbook.io/streaming-docs/guides/decentraland-playback) donde pagas una tarifa al proveedor para que administre toda la infraestructura de streaming.

La opción más potente es configurar tu propio servidor con software gratuito, pero pagando el alojamiento en una 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) o [Cloudflare](https://www.cloudflare.com/products/cloudflare-stream/). Puedes implementar algo como [Node Media Server](https://github.com/illuspas/Node-Media-Server), que incluye la mayoría de lo que necesitas desde el principio.

Todas estas opciones tienen ventajas y desventajas según el caso. Evalúa cuál te conviene más teniendo en cuenta tus necesidades, conocimientos técnicos y presupuesto.

## Configurar OBS para transmitir correctamente

[OBS](https://obsproject.com/) es una herramienta popular y gratuita para gestionar tus streams.

Tanto si usas la clave de stream de un recinto como tu propio servidor RTMP, la configuración de OBS es importante para que la transmisión funcione correctamente. Procura tener una conexión estable y constante.

### Configuración sencilla de OBS

Se recomienda la siguiente configuración sencilla:

* Bitrate de 2500 kbps (funcionará en todos los espacios de Decentraland)
* Bitrate de audio de 160 kbps
* Ajuste preestablecido del codificador de video: Hardware NVENC
* Codificador de audio AAC
* Resolución máxima: 720 (cualquier valor superior causa problemas en DCL)
* Velocidad de fotogramas: 30 fps

{% hint style="warning" %}
**📔 Nota**: Asegúrate de desactivar la transmisión multipista en OBS. Puedes encontrar esta opción en Settings > Stream.
{% endhint %}

### Consejos para quienes empiezan a hacer streaming

* Es esencial hacer pruebas de sonido con antelación para probar la configuración en el espacio.
* Los errores pequeños, como equivocarse en un dígito de la clave de transmisión, son los que más probablemente harán que la transmisión falle.
* No superes una resolución de 720 ni un bitrate de 2500 kbps.

## Streaming en vivo

Puedes transmitir en directo desde tu cámara o compartir tu pantalla con la función [Transmisión en directo](https://docs.decentraland.org/creator/content-creator-es/scene-editor/operar-en-vivo/live-streaming.md) del elemento interactivo [Admin tools](https://docs.decentraland.org/creator/content-creator-es/scene-editor/operar-en-vivo/scene-admin.md) .

Este método de transmisión usa la misma arquitectura de comunicaciones que se utiliza para las comunicaciones en directo entre jugadores. Es fácil de configurar y tiene mucho menos retraso que la transmisión desde fuentes externas.

1. Añade un elemento interactivo [Admin tools](https://docs.decentraland.org/creator/content-creator-es/scene-editor/operar-en-vivo/scene-admin.md) a tu escena, así como un elemento interactivo [Video player](https://docs.decentraland.org/creator/content-creator-es/scene-editor/interactividad/video-screen.md) .
2. Publica tu escena en un World o en Genesis City.
3. Entra en la escena como jugador con permiso para usar Admin tools.
4. Abre la consola de administración, selecciona la pestaña **Video** y, luego, selecciona la función **Live** y haz clic en el botón **Get Stream Key** .
5. Copia la **Server URL** y la *Streaming key*\* en tu software de streaming (por ejemplo, OBS).
6. Pulsa el botón **Activate** para iniciar la transmisión.

En lugar de añadir un elemento interactivo Video player a tu escena, también puedes usar la URL `livekit-video://current-stream` como fuente de video para reproducir la transmisión en tu escena. Aun así, necesitarás Admin tools para obtener la clave de transmisión.

```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,
})
```

## Materiales de video

La mayoría de las veces, querrás reproducir videos en un [material Basic](https://docs.decentraland.org/creator/content-creator-es/scenes-sdk7/fundamentos-del-contenido-3d/materials.md#unlit-materials), sin iluminación, en lugar de un material PBR. Esto produce una imagen mucho más brillante y nítida, y ofrece un mejor rendimiento.

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

Por lo general, se recomienda reproducir videos en materiales Basic sin iluminación, ya que ofrecen un mejor rendimiento. Sin embargo, si quieres proyectar un video sobre un material PBR, ten en cuenta que las propiedades predeterminadas hacen que el video se vea bastante opaco. Puedes mejorarlo modificando otras propiedades del material. Estos son algunos ajustes recomendados para que el video destaque más:

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

{% hint style="info" %}
**💡 Consejo**: Como el video es una textura que se añade a un material, también puedes experimentar con otras propiedades de los materiales, como teñirlo con un color o añadir otras capas de textura, por ejemplo, para producir un efecto de pantalla sucia.

Consulta [materials](https://docs.decentraland.org/creator/content-creator-es/scenes-sdk7/fundamentos-del-contenido-3d/materials.md) para obtener más detalles.
{% endhint %}

## Acerca de los archivos de video

Se admiten los siguientes formatos de archivo:

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

Ten en cuenta que un archivo de video aumenta el tamaño total de la escena, por lo que los jugadores que entren en ella tardarán más en descargarla. El tamaño del video también podría hacer que superes las [limitaciones de la escena](https://docs.decentraland.org/creator/content-creator-es/scenes-sdk7/optimizacion/scene-limitations.md), ya que dispones de un máximo de 15 MB por parcela. Recomendamos comprimir el video tanto como sea posible para reducir el impacto.

También recomendamos empezar a reproducir el video cuando el jugador esté cerca o realice una acción que lo active. Empezar a reproducir un video cuando la escena se carga lejos, en el horizonte, afectará innecesariamente al rendimiento mientras los jugadores visitan escenas vecinas.

## Iniciar, pausar y detener un video

Para empezar a reproducir el video o pausarlo, establece la propiedad `playing` en *true* o *false*. Si `playing` se establece en false, el video se pausa en el último fotograma mostrado.

Puedes hacer que una pantalla se active y desactive al añadirle un evento de puntero, como se muestra a continuación:

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

Para detener el video y volver al primer fotograma, establece la propiedad `position` en 0. En el siguiente ejemplo, al hacer clic en el video, este se detiene.

```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 el reproductor de video

Las siguientes propiedades opcionales están disponibles para configurar el componente `VideoPlayer` :

* `playing`: Determina si el video se está reproduciendo. Si es false, el video está pausado.

{% hint style="warning" %}
**📔 Nota**: La cantidad de videos que pueden reproducirse al mismo tiempo es limitada y depende de la configuración de calidad del jugador. Si la escena reproduce más videos que ese límite, el Engine pausa los que tienen menor prioridad. Consulta [Consideraciones de rendimiento](#performance-considerations).
{% endhint %}

* `playbackRate`: Cambia la velocidad de reproducción del video. *1* de forma predeterminada.
* `volume`: Permite cambiar el volumen del audio. *1* de forma predeterminada.
* `position`: Permite establecer una posición inicial diferente en el video. Se expresa en segundos a partir del inicio original del video. *0* de forma predeterminada, lo que hace que comience desde el inicio real del video.
* `loop`: Boolean que determina si el video se reproduce continuamente en bucle o si se detiene después de reproducirse una vez. *false* de forma predeterminada.

## Reproducir varios videos

Para evitar problemas de rendimiento, mantén baja la cantidad de videos distintos que se reproducen al mismo tiempo; el motor solo permite un número limitado de videos simultáneos, según la configuración de calidad del jugador (consulta [Consideraciones de rendimiento](#performance-considerations)). Sin embargo, una escena puede reproducir varias copias de la misma textura de video en distintas pantallas. Esto no está restringido, ya que afecta al rendimiento considerablemente menos que reproducir videos distintos. Para reproducir el mismo video en varias entidades, simplemente asigna la misma instancia del objeto de textura de video a los componentes `Material` de cada entidad de pantalla.

```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,
})
```

Ten en cuenta que, en el ejemplo anterior, solo es necesario crear un componente `VideoPlayer` , que controla el estado de ambas pantallas de video. En este caso, el componente se asigna a la entidad `screen1` , pero también podría asignarse a cualquier otra entidad de la escena, no necesariamente a una de las pantallas.

## Eventos de video

Gestiona fácilmente los cambios de estado de un video para responder cuando empieza a reproducirse, se pausa, etc. Por ejemplo, puedes usar esto para reproducir animaciones perfectamente sincronizadas con un video y asegurarte de que comiencen al mismo tiempo que este.

Usa `videoEventsSystem.registerVideoEventsEntity` para definir una función que se ejecute cada vez que cambie el estado del video asignado a una entidad. Cada vez que cambie el estado, tu función puede comprobar el nuevo estado y responder en consecuencia.

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

El objeto videoEvent que se pasa como entrada a la función contiene las siguientes propiedades:

* `currentOffset` (*number*): El valor actual de la propiedad `position` del video. Este valor indica los segundos transcurridos desde el inicio original del video. *-1* si el video aún no ha comenzado a reproducirse.
* `state`: El nuevo estado del video, expresado como un valor del enum `VideoState` . Este enum puede tener los siguientes 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` (*number* ): La duración total del video en segundos. *-1* si se desconoce la duración.
* `timestamp` ( *number*): Una marca de tiempo *lamport* que se incrementa cada vez que cambia el estado del video.
* `tickNumber` (*number*): El momento en que ocurrió el evento, expresado como el número de ticks transcurridos desde que la escena empezó a ejecutarse.

Si vuelves a registrar una devolución de llamada en una Entity que ya tiene una (por ejemplo, para cambiar lo que ocurre al cambiar de estado), la nueva reemplaza a la anterior y se conserva el último estado notificado. Esto significa que la nueva devolución de llamada no se vuelve a invocar para un estado que ya se había notificado a la anterior.

### Comprobar si una Entity está registrada

Usa `videoEventsSystem.hasVideoEventsEntity()` para comprobar si una Entity ya tiene registrada una devolución de llamada de eventos de video.

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

### Último evento de video

Consulta el último cambio de estado de un video usando `videoEventsSystem.getVideoState()`. Esto devuelve el valor más reciente de `VideoEvent` para la entidad, o `undefined` si aún no se ha informado ningún evento. Puedes llamar a esto desde un sistema para consultar el estado del video en cada frame sin registrar un 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 en videos

Un truco útil para crear pantallas de video no rectangulares es aplicar una textura alfa sobre un plano. Puedes recortar parte del plano para darle la forma que quieras.

Usa la siguiente imagen para recortar el video en forma circular, con las esquinas transparentes.

![](https://1216664193-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://1216664193-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**: En versiones anteriores, la propiedad `alphaTexture` solo estaba presente en los materiales PBR. Actualmente, solo funciona en materiales básicos.
{% endhint %}

## Reproducir un video en un modelo glTF

Puedes reproducir un video en un modelo *glTF* usando el componente [GltfNodeModifiers](https://docs.decentraland.org/creator/content-creator-es/scenes-sdk7/fundamentos-del-contenido-3d/materials.md#modify-gltf-materials) . Consulta [Modificar materiales glTF](https://docs.decentraland.org/creator/content-creator-es/scenes-sdk7/fundamentos-del-contenido-3d/materials.md#modify-gltf-materials) para obtener más detalles.

Esto te permite reproducir videos en cualquier forma, no solo en planos. Por ejemplo, puedes reproducir videos en una pantalla curva o incluso en todo el cuerpo de un 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,
						}),
					},
				},
			},
		},
	],
})
```

El mapeado del video seguirá el mapeado UV original que usa el modelo. Esto significa que, si el modelo tiene una textura mapeada en una parte específica, el video se mapeará en esa misma parte.

También puedes usar el componente `GltfNodeModifiers` para reproducir un video solo en un Mesh específico dentro del modelo. Por ejemplo, puedes reproducirlo en una pared concreta de un edificio, aunque el modelo abarque todo el edificio. Consulta [Modificar materiales glTF](https://docs.decentraland.org/creator/content-creator-es/scenes-sdk7/fundamentos-del-contenido-3d/materials.md#modify-gltf-materials) para obtener más detalles.

## Audio espacial

De forma predeterminada, el video de un componente `VideoPlayer` es global, lo que significa que se oirá con un volumen constante en toda la escena. Si un jugador sale de la escena, no oirá la transmisión.

Para hacer que el audio sea espacial, establece la propiedad `spatial` en *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,
})
```

Ahora el video se escuchará desde la posición de la entidad que contiene el componente `VideoPlayer` , y se escuchará más fuerte a medida que el jugador se acerque.

Controla el audio espacial con las siguientes propiedades:

* `spatialMinDistance`: La distancia mínima a partir de la cual el audio se vuelve espacial. Si el jugador está más cerca, el audio se escuchará al volumen máximo. *0* de forma predeterminada.
* `spatialMaxDistance`: La distancia máxima a la que se escucha el audio. Si el jugador está más lejos, el audio se escuchará con volumen 0. *60* de forma predeterminada

```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**: Algunos formatos de video no admiten audio espacial. Asegúrate de que la transmisión esté codificada en *mp4*, *m4a*, o *mov*.
{% endhint %}

## Análisis de audio

Puedes leer datos de amplitud y frecuencia en tiempo real de la pista de audio de una entidad `VideoPlayer` para generar efectos visuales reactivos que se sincronicen con la banda sonora del video. Consulta [Análisis de audio](https://docs.decentraland.org/creator/content-creator-es/scenes-sdk7/media/audio-analysis.md).

{% hint style="info" %}
**💡 Consejo**: Para ver un video reproducido en un modelo GLTF en lugar de una primitiva, consulta la [`74,-8-gltfnodemodifier`](https://github.com/decentraland/sdk7-test-scenes/tree/main/scenes/74,-8-gltfnodemodifier) escena de prueba, que reproduce una transmisión HLS en nodos GLTF específicos mediante `GltfNodeModifiers` texturas de video.
{% 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-es/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.
