Curso de Unreal para Aximmetry. Sesión 6

Las dudas también que podéis tener por ahí. 00:00:01

Vale, acuérdate de la resolución de pantalla, que creo que está bien, ¿no? La veo bien. 00:00:04

Sí, Hernandota, tenemos esto. Tengo la lupa aquí preparada. 00:00:07

Hola. 00:00:12

Hola, hola. 00:00:13

Y tengo el web. 00:00:15

Se me ha salido. 00:00:16

Hola, hola. 00:00:18

Sí, sí, es que se me ha cerrado la versión de Moe, de repente. 00:00:20

¿Ah? 00:00:23

No sé si está... Vale, pues se está grabando. 00:00:24

Hola, hola, hola. 00:00:31

Ok. 00:00:33

Vale. Pues por ahí ya va encendiendo, ¿no? Una mesita. 00:00:38

Ya cuando queráis, ¿eh? 00:00:48

¿Sí? ¿Arrancamos? 00:00:50

Sí. 00:00:52

Vale. 00:00:52

Venga, perfecto. Pues nada, venga, dudas que tengáis por ahí antes de meternos en faena. 00:00:53

Me ha comentado un compañero que tenía curiosidad por ver cómo se renderizaba en ACES dentro de Unreal. 00:01:01

Entonces, es un proceso mecánico, pero es un poquito largo. 00:01:07

como íbamos un poquito a pillar de tiempo 00:01:10

le he comentado eso, que hay un tutorial 00:01:12

de William Fosher 00:01:14

que cuenta cómo hacerlo paso a paso 00:01:16

muy sencillito 00:01:19

se llama Unreal to DaVinci Resolve 00:01:20

Workflow 00:01:22

Haces a un Standard RGB, te explica las dos 00:01:23

maneras, en los dos 00:01:26

espacios de color 00:01:28

por si 00:01:29

os interesa 00:01:32

luego, Álvaro 00:01:34

tú tenías algo por ahí que comentar también, puede ser 00:01:36

Álvaro está afuera ahora 00:01:38

Acaba de salir. 00:01:40

Ah, acaba de salir. 00:01:41

Vale, pues estamos grabando. 00:01:42

Bueno, pues venga, yo voy avanzando y ahora cuando vuelva que me pregunte. 00:01:44

¿El resto tenéis algo que comentar? 00:01:48

¿Alguna dudilla? 00:01:50

No, no. 00:01:54

En principio no, ¿no? 00:01:55

Vale. 00:01:56

Venga, pues vamos a quitarnos las dos cosas que nos faltaban de la parte visual de Unreal 00:01:57

y nos metemos con Blueprints, que es la parte de programación gráfica. 00:02:02

¿Vale? 00:02:06

Que Dios os bendiga. 00:02:06

entonces, a ver 00:02:07

¿cómo metemos 00:02:11

un vídeo 00:02:13

en una geometría? 00:02:15

¿cuál es la forma para meter, por ejemplo 00:02:17

en la parte de abajo de la mesa 00:02:19

de nuestro set virtual 00:02:20

necesitamos meter un vídeo 00:02:23

entonces, para meter un vídeo 00:02:25

hay que 00:02:27

trabajar con una serie de assets 00:02:29

que todavía no habíamos trabajado 00:02:31

me voy a hacer una carpetita nueva 00:02:33

dentro de set virtual 00:02:35

botón derecho 00:02:36

new folder 00:02:39

07 barra baja 00:02:41

vídeos. 00:02:43

¿Vale? 00:02:45

Entonces la forma 00:02:47

para acceder a un vídeo externo 00:02:48

dentro de Unreal 00:02:50

y poder reproducirlo 00:02:52

es la siguiente. 00:02:53

Primero necesitamos 00:02:55

un 00:02:57

file media source 00:02:58

que se llama. 00:03:00

Es un asset que accede 00:03:01

a un vídeo 00:03:02

o a una secuencia de imágenes. 00:03:04

¿Vale? Existen esas dos tipologías. Bueno, existe alguna más, pero las más comunes son esas dos. 00:03:06

Entonces, si damos botón derecho en el Content Browser, tenemos un grupo de assets que se llama Media. 00:03:12

¿Vale? Dentro de Media está todo lo que necesitamos. 00:03:18

Entonces, el File Media Source permite reproducir archivos que son un solo archivo, 00:03:21

pues un AVI, un MP4, un MOV, por ejemplo, y el Image Media Source permite reproducir secuencias. 00:03:26

secuencias. Si son secuencias de PNG, secuencias de JPG, de BMP, lo que sea. Entonces vamos a probar los dos. El image, el file media source. El primero lo vamos a 00:03:33

llamar fms-video01. Entonces, ¿cómo funciona este asset? Estos assets hacen referencia a archivos externos. Esto funciona un poco diferente de como 00:03:47

funcionaba el resto de assets, porque si os acordáis yo os decía que cuando importábamos 00:04:03

un FBX, él traducía ese FBX a un archivo propio de Unreal, sin embargo aquí no, aquí 00:04:08

tiene que estar leyendo un archivo externo, entonces para que nosotros podamos tener esos 00:04:15

vídeos dentro del proyecto, tenemos que hacer una carpeta dentro del proyecto donde 00:04:19

arrastremos esos archivos, tanto las secuencias como los archivos normales, como los archivos 00:04:26

únicos vale entonces eso lo vamos a hacer ahora os acordáis que para saber dónde está mi carpeta 00:04:32

content dentro de windows aquí yo puedo hacer botón derecho show in explorer vale y esto me 00:04:38

abre windows en esa ubicación es esta entonces nos tenemos que venir una carpeta hacia atrás y 00:04:49

tenemos que crear una carpeta nueva en el proyecto que se llame movies vale botón derecho nuevo 00:04:55

carpeta. Y tiene que ser movies, la primera en mayúscula 00:05:01

y el resto en minúsculas. Y es aquí donde tengo 00:05:05

que meter los vídeos o las secuencias de imágenes que necesito. Esto 00:05:09

no es porque no lo pueda leer en otra ubicación, es porque luego 00:05:13

como vamos a empaquetar el proyecto para llevárnoslo a Ximetry 00:05:16

al empaquetarlo, si los vídeos que hemos metido no están dentro del proyecto 00:05:20

no los encuentra. Si estuviese en otra ubicación 00:05:25

Ahora lo podríamos leer, pero cuando nos lo llevemos a Ximetry, al empaquetarlo no se lo va a llevar, ¿vale? No lo va a coger. Entonces, por eso es preferible que lo metamos aquí, ¿vale? Entonces, me voy a meter aquí un vídeo. No sé. A ver qué vídeos tenemos por aquí. Voy a buscar alguno de los que tengo del set virtual. 00:05:29

A ver, podría valer cualquier vídeo, ¿vale? Aquí tenía algunos de estos de noticias, un mod de noticias, tenía el del ticker también. Voy a traerme estos dos de momento, me los copio y los meto en la ubicación del proyecto. 00:05:50

A ver, aquí en la parte de Garci, en el proyecto Garci en Movies, me copio aquí estos dos vídeos, ¿vale? 00:06:15

Tenemos estos dos, uno es un MOV y otro es un MP4, ¿vale? 00:06:29

Entonces, una vez que los tenemos aquí, esto no va a aparecer como tal dentro del proyecto, ¿vale? 00:06:34

Pero yo tengo que darle esa ubicación. 00:06:43

¿Cómo le doy esa ubicación? Pues muy sencillo. 00:06:46

en la parte de vídeos en el file media source que me acabo de crear tengo que abrirlo, lo abrimos y nos aparece esta ventanita, esta ventanita realmente no sirve para mucho, 00:06:49

simplemente sirve para darle la ubicación, entonces en estos tres puntitos aquí a la derecha le decimos que lo que quiere abrir este file media source es por ejemplo el vídeo este de news, 00:06:59

vale perfecto salvamos vale y entonces ahora una vez que tenemos la referencia al vídeo cómo hacemos que se reproduzca aquí pues tenemos que crear otro asset que es un media player va a ser el que reproduzca el vídeo por así decir entonces venimos botón derecho media media player y fijaros cuando voy a crear el media player aquí me dice 00:07:20

Additional Asset to Create and Link to the Media Player. 00:07:53

Video Output Media Texture Assets. 00:07:57

Esta es la clave. 00:08:00

Lo que vamos a crear es un reproductor que tiene asociado una textura que proyecta ese vídeo. 00:08:01

Y si creamos una textura que proyecta ese vídeo ya lo podemos meter en un material y asignárselo a una geometría. 00:08:07

¿No? Entonces le decimos que si queremos crear ese Media Texture Asset y lo llamamos Media Player barra baja video 01 y automáticamente se me crea también la textura que va a reproducir ese video ¿Vale? 00:08:14

Con lo cual, doble clic y fijaros, ahora ya en el media player, que es este que acabo de abrir, me aparece referenciado el file media source que he creado anteriormente, ¿vale? Entonces, si hacemos doble clic, nos reproduce el vídeo, ¿vale? ¿Bien? ¿Hasta ahora, más o menos, se entiende? 00:08:33

¿Vale? Perfecto. Perfecto. Pues entonces, una vez que tenemos eso, lo que tenemos que hacer es un material sencillito que nos permita reproducir esa textura, sin más. ¿Vale? Entonces, botón derecho, material, y lo llamo m barra baja, video. 00:08:51

este va a ser 00:09:13

mi material master 00:09:15

luego me iré creando 00:09:16

instancias 00:09:17

para diferentes vídeos 00:09:17

¿vale? 00:09:18

entonces 00:09:22

¿qué es lo que necesito 00:09:23

controlar? 00:09:24

pues necesito controlar 00:09:25

el tileado 00:09:26

de esa textura 00:09:27

por si no se adapta bien 00:09:28

al formato 00:09:29

para que lo pueda mover 00:09:30

y la intensidad 00:09:31

del emisivo 00:09:34

porque normalmente 00:09:35

las pantallas 00:09:35

emiten un poco de luz 00:09:36

¿no? 00:09:37

entonces 00:09:39

me traigo esta textura 00:09:39

la textura 00:09:41

esta media texture 00:09:42

que se acaba de crear 00:09:43

con el media player, me la traigo 00:09:44

por acá, vale 00:09:46

ahí está, ya lo tengo, fijaros yo ya tengo 00:09:47

el vídeo dentro del material 00:09:50

entonces que es lo que tengo que hacer 00:09:51

ahora tengo que conectar el RGB 00:09:54

al base color 00:09:56

y me tengo que crear con un 00:09:57

multiply, M 00:10:00

y clic izquierdo 00:10:02

un controlador del canal emisivo 00:10:03

vale 00:10:06

aquí le metemos 00:10:07

un parámetro 00:10:10

numérico, S y clic izquierdo 00:10:11

y le llamamos Emissive Int, de intensidad. 00:10:14

De primeras lo pongo en cero, ¿vale? 00:10:19

De primeras lo ponemos en cero, luego ya veremos qué intensidad le damos, 00:10:22

porque depende de la iluminación de la escena. 00:10:25

Aplicamos y me tengo que crear también un controlador de tileado, ¿vale? 00:10:30

Como normalmente las pantallas muchas veces no tienen el formato del vídeo, 00:10:35

lo ideal es que le demos un control en X y en Y de manera independiente, ¿vale? 00:10:39

Si os acordáis que eso lo teníamos hecho en nuestro material. 00:10:44

Entonces me lo voy a copiar de nuestro material y me lo voy a traer para acá. 00:10:48

Si vengo aquí a materiales, nosotros teníamos un material que se llama ATES, 00:10:52

que fue el que estuvimos haciendo y todo este controlador de tileado ya estaba hecho. 00:10:57

Por lo cual el de rotación, bueno, me lo voy a traer todo, venga. 00:11:04

Selecciono todo, control C, me vengo al otro material, control V. 00:11:07

Aquí tengo mi controlador de tileado con los mismos nombres y con todo. Lo conecto a la texturita y ya estaría. Este es mi material para reproducir vídeos. Entonces aplico y me creo una instancia de ese material que lo voy a llamar Video Table, por ejemplo, que va a ser el vídeo que va a estar colocado aquí en la mesa. 00:11:13

perdona Diego 00:11:45

una preguntita rápida 00:11:47

al copiar y pegar 00:11:49

desde un material a otro, desde los nodos a otro 00:11:51

entiendo que los parámetros 00:11:53

parametrizados, era el nombre 00:11:55

se mantienen, es decir que no hay que volverlos 00:11:57

a parametrizar 00:11:59

no, de hecho fijaros 00:12:00

si yo ahora me hago una instancia 00:12:03

de este que acabo de crear 00:12:05

createMaterialInstance y lo llamo 00:12:06

mi 00:12:09

videotable por ejemplo 00:12:09

o videodesk 00:12:13

Bueno, da igual. Y lo aplico aquí, ¿vale? Ahí tenemos el vídeo. Y si lo abro, aquí están todos los parámetros, ¿vale? 00:12:15

Tenemos el Emissive Intensity, que es el único que hemos creado, y luego el Offset en U y en V, el Scale en U y en V, y la Rotación. Están todos tal cual. 00:12:25

El cortar y pegar dentro de Unreal sirve para todo. Incluso sirve para lo que vamos a ver hoy, que son los Blueprints. 00:12:35

También tú te puedes hacer una red de nodos de programación y copiarlos de un sitio a otro simplemente con control-c, control-v, ¿vale? Entonces, ya tenemos esto. Fijaros, si yo ahora abro el media player y le doy doble clic al vídeo, el vídeo se reproduce, ¿vale? ¿Bien? 00:12:42

Pero claro, ¿qué pasa? Que el mapeado de esta pieza no coincide con el formato del vídeo, con lo cual tengo que escalarlo dentro del material para que se vea como yo quiero que se vea, que es así, ¿vale? Que la bola se vea redonda por lo menos. 00:13:04

Bueno, entonces, pues nada, hay que tocar la escala en V, 0,5, 0,2, 0,3, y una vez que la hemos escalado la tengo que subir. 00:13:19

Entonces tengo que darle un offset en V, ¿vale? Más o menos así podría valer, aproximadamente, ¿vale? 00:13:33

Y ahora que le doy intensidad al emisivo, si le damos un 1, un 5, tengo que subirlo bastante porque estábamos en unidades reales de iluminación, si os acordáis, 500, 1000, una cosa así. 00:13:42

Eso podría empezar a valer. Entonces ahora cuando le damos al media player se mueve. Pero es un rollo esto de tener que estar dándole al media player para que se vean los vídeos. 00:13:59

¿Yo cómo lo voy a hacer mejor? Con un sequencer. Yo quiero controlar el vídeo con una secuencia. Una secuencia de Unreal. 00:14:12

Entonces, para no tener que andar dándole al media player y dejando esto minimizado, lo que voy a hacer es crearme una secuencia, botón derecho, cinematics level sequence y lo llamo lsdeskvideo. 00:14:20

¿vale? os acordáis que 00:14:37

luego nosotros podríamos anidar secuencias 00:14:39

dentro de otras, entonces 00:14:41

si yo tengo una secuencia que reproduce este 00:14:43

vídeo, yo podría tener una secuencia general 00:14:45

en la que tuviera anidados todos los 00:14:47

vídeos y que se reprodujeran 00:14:49

todos a la vez ¿vale? 00:14:51

entonces ¿cómo hacemos para 00:14:56

controlar este vídeo desde un sequencer? 00:14:57

pues tenemos que venir a track 00:15:00

media track, ¿esto qué es lo que va a hacer? 00:15:01

va a crear un media player 00:15:04

parecido al que hemos hecho antes, bueno 00:15:05

parecido no, igual 00:15:07

vale, metemos un track 00:15:09

de media track y aquí 00:15:11

le tenemos que decir primero 00:15:13

en el más que queremos 00:15:15

meter el file media source 00:15:18

o sea la referencia al vídeo 00:15:19

que acabamos de crear 00:15:21

eso es lo primero, pero con esto no es 00:15:23

suficiente, vale 00:15:25

con esto no es suficiente, también tenemos que venir aquí 00:15:27

a la línea de tiempo, seleccionar el track 00:15:29

botón derecho 00:15:32

y en la parte de propiedades 00:15:33

le tengo que asignar la textura 00:15:36

que reproduce el vídeo, el Media Texture, ¿vale? 00:15:37

Entonces le damos aquí y aquí lo tengo, ¿vale? 00:15:42

Bien, más o menos, vale. 00:15:49

Entonces, ahora una vez que está asignado, 00:15:55

simplemente cuando reproducimos nuestro Sequencer 00:15:58

ya se reproduce el vídeo, ¿vale? 00:16:02

Es así. 00:16:06

Claro, el vídeo tiene mucha más duración 00:16:07

que lo que tenía nuestra secuencia en un primer momento, 00:16:09

entonces lo podríamos hacer un poquito más grande, ¿vale? Le damos y ahí tenemos la volada del mundo girando. ¿Bien? ¿Sigos? ¿Más o menos? 00:16:11

Ok, sí. Perfecto. Entonces, esto lo tendríamos que hacer, pero además lo que necesitamos es parametrizar la textura, ¿vale? Porque es esa textura a la que vamos a acceder luego desde Aximetry para poder poner cualquier vídeo, ¿vale? 00:16:22

Entonces vuelvo al material y le digo que esta textura va a ser un parámetro, botón derecho convert to parameter y lo llamo video output, video barra baja output, ¿vale? 00:16:41

Y este parámetro es al que yo voy a tener que acceder desde Blueprints para que Aximetry pueda cambiar cualquier video en esa ubicación, ¿vale? 00:17:03

¿Vale? Perfecto. Esto lo tendríamos que hacer también con el ticker, lo tendríamos que hacer con la pantalla y lo tendríamos que hacer con el zote. ¿Vale? Entonces, como ya tenemos nuestro material preparado, y os acordáis que el otro día habíamos hecho una serie de secuencias para ir lanzando, por ejemplo, la pantalla, ¿no? 00:17:11

aquí teníamos la pantalla 00:17:36

pues vamos a crearle un material para la pantalla 00:17:40

vale, entonces 00:17:42

para la pantalla voy a lanzar una secuencia 00:17:46

entonces dentro de movies 00:17:48

dentro de mi proyecto 00:17:52

en movies, vamos a traernos 00:17:54

una secuencia de imágenes 00:17:56

para que veáis que se puede meter también 00:17:57

entonces 00:18:02

pues no sé, aquí en el tablao 00:18:04

creo que tenía alguna 00:18:08

creo que tenía aquí 00:18:09

alguna 00:18:12

algún vídeo 00:18:12

este 00:18:15

es tan chulo 00:18:17

esto es una secuencia 00:18:18

de imágenes 00:18:18

¿vale? 00:18:19

entonces nada 00:18:21

me traigo esta carpetita 00:18:22

me la copio 00:18:23

y la meto 00:18:24

en la ubicación 00:18:26

del proyecto 00:18:26

del Garci 00:18:27

que está aquí 00:18:28

aquí 00:18:29

dentro de movies 00:18:35

control V 00:18:38

¿vale? 00:18:41

1,6 gigas 00:18:42

a lo mejor 00:18:43

este 00:18:44

esta es un poquito 00:18:44

pesada 00:18:45

de más 00:18:46

y esto puede hacer 00:18:47

que el proyecto 00:18:48

se ralentice también 00:18:48

¿vale? 00:18:49

porque tiene que cargar 00:18:50

un montón de imágenes. A lo mejor lo que hago es quitarle 00:18:51

la mitad 00:18:53

de los frames. Le voy a 00:18:55

dejar... Tiene 00:19:00

muchísimos frames. Entonces 00:19:02

le voy a quitar 00:19:04

desde aquí 00:19:06

hasta aquí. 00:19:08

Estos me los cargo, ¿vale? 00:19:11

Para que no pese tanto. Vale. 00:19:12

Ya tenemos eso. 00:19:16

Entonces, me voy a coger 00:19:19

esta ubicación, CTRL-C 00:19:20

y me vuelvo a mi proyecto. 00:19:22

Y le digo, ¿vale? 00:19:25

En mi carpeta de vídeos, ahora en lugar de un file media source, lo que necesito es un media image media source, ¿vale? 00:19:26

Image media source, barra baja, bueno, lo voy a poner en mayúsculas, image media source, barra baja, vídeo 02, ahí está. 00:19:40

Doble clic y esto es lo mismo. 00:19:50

Aquí lo que me pide solamente es la ruta, ¿vale? 00:19:53

Entonces le damos a los tres puntitos, selecciono la primera imagen y lo abro, ¿vale? Salvo. 00:19:55

Entonces, ¿qué pasa? Que necesito otro Media Player diferente. 00:20:06

Vamos a crear, botón derecho, Media, Media Player. 00:20:11

Y me dice lo mismo, ¿quieres que crea una textura asociada a ese vídeo? Sí. 00:20:16

Vale, entonces le llamamos Media Player, barra baja, vídeo 02. 00:20:20

y me ha creado una textura 00:20:25

ya asociada a eso, entonces dentro de este 00:20:27

media player yo tengo que elegir 00:20:29

el otro 00:20:31

el image media source 00:20:32

el de la secuencia, normalmente 00:20:36

en real se comen mejor secuencias de imágenes 00:20:37

que vídeos 00:20:39

que archivos de vídeo 00:20:41

suele costarle 00:20:43

menos comérselo, pero ya os digo 00:20:45

que el que realmente se come 00:20:48

bien los vídeos es 00:20:49

Aximetric, porque está pensado 00:20:51

específicamente para ese tipo de cosas, para que le entren señales de vídeo, salidas de vídeo, para que le entren archivos, ¿vale? 00:20:53

Unreal no funciona muy bien con vídeos, pero bueno, de cualquier manera. Vamos a crear una instancia de este material, lo llamo 00:21:00

OMI Video Screen, doble clic y lo que tengo que hacer simplemente es sustituir esta textura, ¿vale? Ahora le tengo que meter la textura que está reproduciendo el otro vídeo, que sería esta, ¿vale? Perfecto, entonces ahora ese material lo podríamos poner aquí, ¿vale? 00:21:16

Y ahora lo mismo, tengo que hacerme una secuencia para no depender del media player, de tener que estar haciendo play en el media player, me tengo que hacer una secuencia que se va a llamar ls screen video, botón derecho cinematics, level sequence, screen video, doble clic, nos sacamos en tracks el media track, 00:21:41

que es una réplica del media player 00:22:11

que hemos utilizado antes 00:22:14

le damos al más 00:22:15

le decimos que ahora lo que queremos reproducir 00:22:18

es un image media source 00:22:20

¿vale? 00:22:22

y le asignamos la textura 00:22:23

si no le asignamos la textura no va a funcionar 00:22:25

¿vale? 00:22:28

botón derecho 00:22:28

properties 00:22:29

y en la parte de media texture 00:22:30

veis que siempre de primeras está vacío 00:22:32

pues nada 00:22:34

se lo asigno 00:22:35

¿vale? 00:22:37

con eso debería ser suficiente 00:22:37

¿vale? 00:22:40

Entonces, ¿qué pasa? 00:22:42

Que como esto es un level sequence independiente del level sequence que me anima la pantalla, 00:22:44

la pantalla está aquí abajo, si os acordáis. 00:22:52

Entonces, cuando yo le doy al play, esto se reproduce. 00:22:55

¿Vale? 00:22:59

Si yo quisiese que se reprodujera a la vez que se anima, 00:23:01

pues tendría que venir a la secuencia de la pantalla, 00:23:06

que es esta, que lo que hacía era básicamente esta animación, meterle aquí un Subsequence Track 00:23:13

y dentro de este Subsequence decirle que el que quiero que me reproduzca a la vez es el Screen Video. 00:23:22

¿Vale? ¿Vale? Entonces cuando yo le doy al Play, se mueve. 00:23:30

Pero claro, esta animación es muy cortita, la longitud del vídeo es mucho más larga, ¿vale? 00:23:37

No tiene tanto sentido. Tendríamos que tener como una secuencia por encima que cogiera tanto la animación de la pantalla como el vídeo y que tuviese más longitud, ¿vale? 00:23:41

Esto no es muy relevante porque ya os digo que los vídeos los vais a meter directamente con Aximet, ¿vale? Esto simplemente para que sepáis cómo se hace y cómo se deja preparado, ¿vale? 00:23:50

me cargo la subsecuencia esta, ¿vale? Pero bueno, ya se ve un poquito como funciona todo esto, ¿no? 00:23:59

Muy bien, pues nada, aquí simplemente en función del vídeo que tengamos, si tiene más blancos o menos blancos, 00:24:07

pues tendríamos que ajustar la intensidad del emisivo, ¿vale? 00:24:14

si le damos un 500 00:24:18

o un 1000 00:24:23

o un 00:24:25

1000 00:24:28

un 2000 en este caso 00:24:30

porque es una imagen oscurita 00:24:32

ahí ya se empieza a ver un poquito 00:24:33

perfecto 00:24:35

Diego una pregunta 00:24:38

aumentar la emisión 00:24:39

no consume muchos recursos del procesador 00:24:43

porque es luz en tiempo real 00:24:46

y además cogiendo los colores del vídeo 00:24:47

en este caso no 00:24:49

porque estábamos en 00:24:51

el sistema de iluminación baqueada 00:24:53

aquí lo que está pasando es que el brillo de la pantalla 00:24:54

no está rebotando por la escena 00:24:57

vale 00:24:58

es simplemente un efecto visual 00:25:01

o sea, lo que brilla es esta geometría 00:25:02

pero la geometría que tiene alrededor no están recogiendo 00:25:05

esos rebotes de luz 00:25:07

vale, vale, vale 00:25:09

ok 00:25:10

vale 00:25:11

esto es todo trampa 00:25:11

entonces 00:25:14

vale, se entiende más o menos 00:25:17

cómo funciona esto 00:25:20

de los vídeos 00:25:21

dentro de Unreal 00:25:21

¿sí? 00:25:22

sí, sí 00:25:24

ok 00:25:25

perfecto 00:25:25

pues entonces 00:25:27

vamos con la parte de render 00:25:27

perdona 00:25:29

sí 00:25:30

una duda sería 00:25:31

cómo podrías meter 00:25:32

señal de vídeo 00:25:34

en tiempo real 00:25:35

quiero decir 00:25:36

conexiones en directo 00:25:36

con 00:25:37

con otras cosas 00:25:38

o sea 00:25:39

acá señal de una cámara 00:25:40

por ejemplo 00:25:41

una conexión en directo 00:25:41

vale 00:25:43

eso lo vamos a hacer 00:25:44

dentro de Axymetry 00:25:45

aquí también se puede hacer 00:25:46

es un poco más lioso 00:25:47

si queréis 00:25:49

os lo enseño 00:25:49

si queréis os lo enseño, venga 00:25:50

esto no estaba previsto 00:25:53

creo que tengo que 00:25:54

si es que es una pérdida de tiempo y que lo vamos a hacer directamente en 00:25:56

axiometría 00:25:59

no pasa nada 00:26:00

a ver, lo que pasa es que 00:26:03

voy a meter mi webcam dentro de la pantalla 00:26:05

¿vale? 00:26:07

pero me tengo que 00:26:09

apagar la webcam en TeamViewer 00:26:10

que eso no sé cómo se hace 00:26:13

así se hace, vale 00:26:16

entonces, fijaros 00:26:17

Yo lo que podría hacer es sacar la pantalla y decirle que lo que quiero que se reproduzca aquí es, me tendría que hacer un, a ver, si yo le doy aquí al media player, si le doy play, ¿se reproduce? 00:26:19

No, porque lo tengo ya con el otro Media Player. 00:26:43

Voy a quitarle un momento esto, ¿vale? 00:26:47

En el Screen Video voy a quitarle esto para que lo veáis. 00:26:53

A ver, saco la... 00:27:01

Esta es la animación de la pantalla, ¿vale? 00:27:07

Y ahora mismo lo que estamos reproduciendo aquí debería ser este vídeo que no se está reproduciendo. ¿Por qué no se está reproduciendo? A ver, una cosita, un momento. 00:27:10

Es que, fijaros, la forma de meter una señal aquí en Unreal es en el Media Player, en la parte de arriba de la izquierda, tenemos un desplegable que me permite meter señales de audio o de vídeo en tiempo real. 00:27:30

Entonces, si yo le digo que me coja ahora la cámara, yo estoy aquí, ¿vale? Entonces, esto es lo que tendría que reproducir ese AI, ¿vale? Con lo cual, vamos a ver si consigo hacerlo. Siempre me pasa igual con esto. 00:27:47

A ver, tenemos este material que es el video screen, se lo aplico y este material debería de tener este video input que es este de aquí, esto está. 00:28:06

creo que cuando lo he metido en el Sequencer se ha quedado bloqueado 00:28:27

entonces voy a hacer uno nuevo y se lo aplico 00:28:32

me voy a hacer un nuevo Media Player 00:28:35

aquí le digo que me crea una textura 00:28:40

lo llamo Media Player barra baja Webcam 00:28:43

me creo un nuevo material 00:28:48

a partir del Master 00:28:54

una instancia que se llame MI barra baja Webcam 00:28:56

y este es el que aplico aquí, ¿vale? 00:29:00

Ahora aquí le tengo que meter la textura que esté reproduciendo el nuevo Media Player, ¿vale? 00:29:07

El que acabo de crear, que de momento está vacía, ¿vale? 00:29:13

Ahí está. 00:29:18

Entonces, si yo me vengo aquí abajo y le digo que lo que quiero reproducir es, 00:29:20

en lugar de un Find Media Source o un Image Media Source, lo que quiero es una señal en directo, 00:29:27

me tengo que venir aquí y decirle que coja 00:29:32

mi cámara web 00:29:34

¿vale? y aquí estoy 00:29:36

¿bien? pero esto 00:29:37

es mucho más sencillo 00:29:42

en Aximetri, mucho más 00:29:44

¿vale? 00:29:45

está preparado para estar 00:29:47

he visto que recoge también fuentes NDI 00:29:49

¿no? por lo que he visto 00:29:52

si las tienes instaladas, si, yo es que tengo instaladas las 00:29:53

NDI tools 00:29:56

y todo esto son señales NDI 00:29:56

esto es vídeo IP 00:30:00

tú puedes emitir vídeo por 00:30:01

por la wifi, vamos 00:30:03

y también me está cogiendo mi tarjeta 00:30:04

capturadora, que es la Blackmagic 00:30:08

¿vale? y bueno, y un 00:30:10

plugin que tenía para la Canon de fotos 00:30:14

que también transformaba la Canon en una webcam 00:30:16

te pilla todo lo que tengas instalado 00:30:18

¿vale? ¿bien? 00:30:20

entonces, vamos a ver como renderizamos 00:30:26

vídeo, la parte de vídeo 00:30:29

es mecánica 00:30:30

también 00:30:33

la parte de vídeo es mecánica, para renderizar 00:30:34

tenemos que tener 00:30:37

activado un plugin que se llama Movie Render Cube. Tenemos que venir a Edit, Plugins y escribimos aquí Movie Render. Tenemos que tener activados estos dos, ¿vale? 00:30:38

Tanto el Movie Render Cube, que al final, como su propio nombre indica, es una cola de render, me va a permitir meter una serie de planos en una cola y cuando acabe uno 00:30:54

empieza a renderizarse otro y luego 00:31:04

tenemos que activar también este de aquí que son 00:31:06

los passes, los additional render 00:31:08

passes, esto me va a dar 00:31:10

passes de render que luego me puedan servir para 00:31:11

postproducción, vale 00:31:14

ahora vemos los que son pero hay que 00:31:15

activarlo y reiniciar 00:31:18

no os preocupéis 00:31:20

que luego cuando acabe la clase os subo este 00:31:29

proyecto ya para que lo tengáis preparado para la parte 00:31:31

de asimetria, no hace 00:31:33

falta que lo vayáis haciendo 00:31:35

entonces, como hacemos 00:31:36

nosotros para renderizar 00:31:41

cualquier plano 00:31:44

fijaros 00:31:45

teníamos por ejemplo 00:31:46

el shot 1 00:31:48

que era el plano general este larguísimo que hicimos el otro día 00:31:50

que venía por aquí 00:31:54

y se metía dentro 00:31:57

de la 00:32:01

este no, este es demasiado largo 00:32:01

vamos a probar con el otro, con el 2 00:32:04

que era este que salía aquí 00:32:07

el bicho bailando 00:32:09

teníamos el plano de vértigo y teníamos el objeto 00:32:10

este dando vueltas 00:32:13

vale 00:32:14

voy a poner esto aquí para que no se quede parado 00:32:17

el muñeco 00:32:22

vale, tenemos esto 00:32:23

¿cómo renderizo yo esto? 00:32:26

de una forma profesional 00:32:28

para luego poder meterle un poco de postproducción 00:32:30

pues muy fácil 00:32:32

tengo que venir aquí a la clapeta 00:32:34

en los tres puntitos y elegir 00:32:36

Movie Render Queue 00:32:38

y luego le doy al botón 00:32:39

el antiguo, el Movie Scene Capture 00:32:41

se suele utilizar para 00:32:44

hacer previsualizaciones ¿vale? ¿por qué? porque el resultado de render 00:32:46

que te da es bastante pobre ¿vale? sin embargo MovieRenderQ 00:32:50

nos permite acceder a los parámetros que nos permiten subir 00:32:54

la calidad del render a costa de tiempo de render, lógicamente 00:32:58

¿no? entonces le damos a la clapeta y nos aparece esta ventana 00:33:02

esta es la ventana de MovieRenderQ y esta es la cola 00:33:06

donde yo puedo ir apilando planos para que 00:33:10

pueda darle a render e irme a tomar cañas. 00:33:14

¿Vale? Porque si no 00:33:17

tengo que estar esperando a que acabe uno para lanzar 00:33:18

otro. Entonces 00:33:20

¿Cómo se configura esto? 00:33:22

Pues muy fácil. 00:33:24

Venimos aquí al botoncito que pone 00:33:26

settings and save 00:33:28

config y se nos abre otra 00:33:30

ventana. Esta ventana es la que 00:33:32

nos va a permitir configurar el render. 00:33:34

Es aquí donde tenemos que hacerlo de 00:33:36

laces, lo que me has preguntado antes. 00:33:37

¿Vale? En esta ventanita es donde trabaja 00:33:40

el William Foucher este para 00:33:42

para todo el proceso este 00:33:43

del espacio de color 00:33:46

pero bueno, más allá de eso 00:33:48

lo que tenemos que definir 00:33:50

aquí es lo siguiente 00:33:52

primero, en la parte 00:33:54

de output vamos a definir la resolución 00:33:56

en la que vamos a renderizar 00:33:59

nuestro vídeo, vale 00:34:00

si el formato 00:34:02

si la relación de aspecto ancho 00:34:04

y alto no corresponde con la relación 00:34:06

de aspecto que yo he puesto en mi cámara 00:34:08

lo que me va a crear son bandas negras 00:34:10

Se entiende, ¿no? 00:34:14

O sea, si quiero que me renderice el 100% de lo que tengo en la cámara, 00:34:16

la relación de aspecto al menos tiene que ser igual. 00:34:19

Porque si no, él me va a poner bandas negras. 00:34:22

Arriba, o sea, arriba y abajo, o a izquierda o derecha, 00:34:24

dependiendo de cuál sea la relación de aspecto. 00:34:28

Entonces, yo aquí, por ejemplo, le podría poner un 2K para probar. 00:34:30

¿Cuánto es 2K en píxeles? 00:34:37

2K resolution, esto es, a ver, 2560 x 1440, ¿no? 00:34:39

O vamos a ponérselo, 2560 x 1440, ¿vale? 00:34:51

Esto es un 2K. 00:35:00

Luego aquí yo puedo elegir mantener el frame rate que haya puesto en mi sequencer o sobreescribirlo, lo que yo quiera, ¿vale? 00:35:01

En principio, si no tocamos nada, 24 frames por segundo, ¿vale? 00:35:10

Luego, ¿qué tenemos que decidir también? 00:35:15

El directorio donde lo guardo. 00:35:18

El primero de todos de arriba es el directorio. 00:35:20

Entonces, le damos a los tres puntitos y le digo que me voy a hacer una carpetita que se llame renders. 00:35:23

Y aquí lo vamos a ir guardando, ¿vale? 00:35:36

Perfecto. 00:35:38

Este es mi output directory. 00:35:39

Luego aquí te dice el file format. Aquí en función de si estoy renderizando una secuencia o estoy renderizando un archivo de vídeo, se pondrá de una forma o se pondrá de otra. En principio, fijaros, el formato del nombre que le va a dar a los archivos de la secuencia es el nombre de la secuencia, punto, y el frame number, ¿vale? 00:35:41

Entonces, si mi secuencia en este caso se llama ls barra baja shot 02, pues aquí me va a poner ls barra baja shot 02 punto 00000, porque siempre empieza por el 0, ¿vale? 00:36:07

Y luego 1, 2, 3, en función del número de frames que tenga mi secuencia, ¿vale? 00:36:21

¿Se entiende, chicos? 00:36:27

Voy a encender la cámara. 00:36:29

¿Me dejará? 00:36:32

No, no me va a dejar porque la tengo seleccionada. 00:36:34

Así sí me deja. 00:36:36

Vale. 00:36:37

Entonces, esto es lo primero que hay que configurar. 00:36:39

¿Vale? 00:36:42

Lo siguiente. 00:36:43

¿Qué tipo de archivo necesito yo? 00:36:45

Ahora por defecto me viene una secuencia JPG. 00:36:47

Yo nunca suelo utilizar la secuencia JPG. 00:36:50

¿Vale? 00:36:52

Entonces me la cargo. 00:36:53

Y le doy al botoncito de Settings. 00:36:55

¿Aquí qué tenemos que meter? 00:36:57

Tenemos que meter la secuencia que nosotros queramos. 00:36:58

¿Vale? 00:37:03

Si lo que queremos es hacer postproducción, yo recomiendo que rendericéis en XR, ¿vale? Es un formato que tiene 32 bits y que te permite almacenar pases de render, ¿vale? Dentro del archivo. Esto tiene sus cosas buenas y sus cosas malas. 00:37:03

Tiene la ventaja de que tenemos toda la información de iluminación disponible en cada frame y tiene el contra de que pesan mucho, ¿vale? 00:37:21

Son archivos que suelen pesar mucho, entonces tenemos que tener discos duros de gran capacidad y muy rápidos para que esto funcione bien, ¿vale? 00:37:32

Entonces, vamos a poner EXR. 00:37:41

Una vez que ponemos EXR, veis que aquí a la derecha me salen algunas cosas que se pueden configurar. 00:37:43

primero, si le voy a meter pases de render 00:37:49

tengo que activarle el multilayer 00:37:52

sí o sí 00:37:53

y después hay aquí una serie de algoritmos de compresión 00:37:55

si le digo que no me lo comprima 00:37:58

probablemente cada frame 00:38:00

me pese 00:38:02

entre 300 y 800 megas 00:38:03

según la resolución 00:38:06

entonces imaginaros 00:38:08

lo que puede llegar a pesar 00:38:09

un proyecto completo renderizado 00:38:10

es una burrada 00:38:13

bueno, yo lo dejo 00:38:14

a vuestro criterio, ¿vale? 00:38:17

Yo normalmente suelo sacar el frame comprimido 00:38:20

en algoritmo PIZ, que bueno, te quita algo de calidad, 00:38:27

pero hace que pese bastante menos, ¿vale? 00:38:32

Eso ya cada uno que lo haga como considere. 00:38:34

Según lo que estéis acostumbrados también. 00:38:39

Cuando veáis el tutorial de William, 00:38:40

pues él le quita la compresión porque le gusta trabajar a tope 00:38:44

a todo lo que da la máquina 00:38:46

bueno, luego 00:38:48

settings, que más settings hay que meter 00:38:50

tenemos que meter un setting que se llama 00:38:52

Game Overrides 00:38:54

el Game Overrides que va a hacer 00:38:58

va a deshabilitar 00:39:00

todos los mecanismos de optimización 00:39:03

que tiene el visor, os acordáis 00:39:05

que decíamos que el visor 00:39:06

hacía lots, iba cambiando 00:39:08

la geometría en función de la distancia 00:39:10

a cámara, eso lo deshabilita, siempre 00:39:12

con esto, siempre me va a mostrar 00:39:14

la malla que más pesa 00:39:16

en todos los casos. También 00:39:17

hacían bitmapping. Iba haciendo una compresión 00:39:20

de resolución de texturas en función 00:39:22

de la distancia cámara. Lo deshabilita. 00:39:24

Me muestra siempre las 00:39:27

texturas a tope de calidad. 00:39:28

¿Qué más cosas hace? 00:39:31

Las sombras tienen un 00:39:32

umbral a partir del cual, según la 00:39:34

distancia, desaparecen. Bueno, pues con 00:39:36

esto siempre se ven las sombras 00:39:38

a toda la distancia. El 00:39:40

foliage, que es la herramienta que 00:39:42

se utiliza para hacer scatter, para repartir 00:39:44

piedras y para repartir césped y cosas 00:39:46

así, igual tiene un mecanismo de 00:39:48

optimización que es que a partir de cierta distancia 00:39:50

que se llama 00:39:52

cool distance, esa distancia 00:39:54

elimina todos los elementos 00:39:56

que estén a partir 00:39:58

de esa distancia, pues 00:40:00

con esto deshabilitamos eso también 00:40:02

todo lo que rendericemos con el 00:40:04

game overrides se va a ver hasta el infinito 00:40:06

esto que hace, pues que le cueste 00:40:08

más renderizarlo, al final 00:40:10

lo que va a pasar es que los render van a tratar 00:40:12

más en renderizarse, pero es una manera de 00:40:14

resetear los sistemas 00:40:16

de optimización que trae Unreal 00:40:18

configurados por defecto. 00:40:20

¿Vale? ¿Bien? ¿Más o menos? 00:40:22

¿Se entiende? 00:40:25

¿Hasta aquí? 00:40:27

Sí. 00:40:29

Perfecto. Más cosas 00:40:32

que tenemos que meter para 00:40:34

tener el render a tope de calidad. 00:40:35

Le tenemos que meter 00:40:38

el anti-aliasing. Claro, el 00:40:40

anti-aliasing es otro sistema 00:40:42

de optimización 00:40:43

de imagen que utiliza Unreal en tiempo 00:40:46

real, entonces 00:40:48

el anti-aliasing lo tenemos 00:40:48

que sobreescribir, veis que aquí pone 00:40:52

override anti-aliasing 00:40:53

tenemos que sobreescribirlo y decirle que no 00:40:55

utilice ningún 00:40:58

algoritmo de anti-aliasing 00:40:59

ninguno, vale, vamos a ir a full 00:41:01

esto va a hacer que las 00:41:03

las líneas diagonales 00:41:07

de nuestras imágenes no se 00:41:10

no tengan prácticamente diente de sierra 00:41:11

vale 00:41:14

pero va a hacer que le cueste más renderizar cada frame, evidentemente, ¿vale? 00:41:14

Y luego aquí tenemos dos parámetros que son muy importantes, estos dos. 00:41:20

Uno, el primero se llama Spatial Sample Count y el segundo se llama Temporal Sample Count. 00:41:26

¿Estos dos qué hacen? 00:41:32

Estos dos lo que van a hacer es dividir el espacio entre frame y frame en subframes. 00:41:34

Entonces, toda la información que tenga de subframes entre frame y frame, va a ser información que él va a utilizar para que el frame final, tanto el primero como el segundo, tengan más calidad. 00:41:41

Es un mecanismo que tiene el motor de render para tener información extra que le permita dar un render, dar un frame de mayor calidad visual. 00:41:53

Entonces, ¿para qué sirve el spatial sample count? 00:42:02

Para cuando tenemos planos que tengan desenfoque de profundidad de campo. 00:42:06

si nosotros queremos mejorar 00:42:10

la calidad del desenfoque de profundidad 00:42:12

de campo tenemos que subir este parámetro 00:42:15

luego 00:42:17

por el contrario si tenemos planos 00:42:18

que tienen motion blur, tienen elementos 00:42:20

moviéndose en la imagen y queremos 00:42:22

que el desenfoque de movimiento 00:42:25

se vea más definido y se vea 00:42:26

con más calidad el que tenemos 00:42:29

que subir es el temporal sample count 00:42:31

lo malo que tienen estos 00:42:33

es que uno multiplica al otro 00:42:35

con lo cual si yo tengo 00:42:36

por ejemplo 00:42:39

un poco de desenfoque 00:42:39

y bastante motion blur 00:42:42

yo podría poner 4 en 00:42:44

spatial y 8 en temporal 00:42:47

y esto que va a hacer 00:42:49

que el motor de render, aparte de renderizar 00:42:50

los frames que yo 00:42:53

tenía previstos, me renderice 00:42:55

entre medias de cada frame 00:42:57

32 subframes, 4 por 8 00:42:58

¿se entiende? 00:43:01

chicos, ¿se entiende esto? 00:43:03

entonces claro 00:43:08

cuanto más suba esto 00:43:12

más voy a tardar en renderizar 00:43:14

la secuencia 00:43:16

porque esto va a hacer 00:43:17

que yo vaya renderizando 00:43:19

más subframes 00:43:20

entre frame y frame 00:43:21

ahora lo vemos 00:43:22

¿vale? 00:43:23

entonces ¿qué es lo ideal? 00:43:25

que en función de cómo sea el plano 00:43:26

yo adapte estos parámetros 00:43:28

cuando yo quiero sacar 00:43:29

planos a mucha resolución 00:43:30

con mucha calidad 00:43:33

puedo llegar a subir esto 00:43:34

hasta pues no sé 00:43:36

32 por 64 00:43:38

pero claro, 32 por 64 00:43:41

¿cuántos subframes son? 00:43:43

un montón, ¿no? 00:43:44

dependiendo de cómo sea nuestra máquina de rápida 00:43:48

también me lo puedo llegar a permitir 00:43:50

32 por 64 00:43:51

son 2048 subframes 00:43:54

entre frames, son un montón 00:43:56

¿vale? entonces 00:43:58

cuidadito con esto 00:44:00

yo normalmente 00:44:02

suelo hacer pruebas en función de 00:44:04

de cómo sea el plano 00:44:06

pues suelo jugar con 4 y 8 en los primeros renders para hacer una prueba 00:44:07

y luego dependiendo de cómo sea el plano, subo como mucho a 16, ¿vale? 00:44:12

4 por 16 ya son un montón de subframes, ¿vale? 00:44:18

Pero tenerlo en cuenta. 00:44:21

Hacer pruebecitas con 4 y 4, con 4 y 8, 00:44:23

y luego ya cuando se vea lo que queréis que se vea, 00:44:27

le subís o el del motion blur o el del depth of field, 00:44:30

según cómo sea el plano, ¿vale? 00:44:33

Perfecto. 00:44:38

¿Qué más cosas tengo que añadir aquí a este preset de renderizado? Le tengo que meter también variables de consola. Las variables de consola son comandos que yo puedo meter en el motor que no están sujetos a ningún botón del editor. 00:44:38

O sea, con esto estoy hackeando un poco el sistema. O sea, estoy haciendo que el editor o que el motor funcione de una forma que no suele funcionar. ¿Para qué? Para conseguir más calidad, básicamente. 00:44:57

Entonces, ¿cuáles son las variables de consola que yo tengo que meter aquí para que mi imagen final se vea lo mejor posible? Pues para eso hay que ir a la documentación de Unreal. 00:45:10

Si yo pongo aquí, MovieRenderCube, ConsolVariables, y me meto aquí, esto es la documentación. Entonces, voy bajando, voy bajando, voy bajando. 00:45:20

Bueno, aquí os cuenta todo lo que os he contado yo, que tenéis que activar el plugin, que tenéis una serie de pases, que ahora vemos, ¿vale? 00:45:40

Bajamos, bajamos, bajamos, bajamos y llega un momento que tenemos una serie de variables de consola que mejoran la imagen. 00:45:49

No, esto es lo de los sample counts, ¿veis? Esto es lo mismo que os he contado yo. 00:45:59

Y luego aquí en la parte de variables de consola, aquí tenemos una serie de variables de consola. 00:46:05

todas estas son las que tendríamos que utilizar 00:46:10

si estuviéramos renderizando con Ray Tracing 00:46:13

pero como no estamos renderizando con Ray Tracing 00:46:15

en nuestro caso solamente vamos a coger 00:46:17

estas de aquí 00:46:19

estas son las que 00:46:20

tenemos que utilizar 00:46:23

vamos a subir 00:46:24

la calidad del 00:46:27

Motion Blur, vamos a subir la calidad del 00:46:29

Desktop Fill, vamos a subir la calidad 00:46:31

del Bloom y vamos a subir la calidad 00:46:33

del Tone Mapping, o sea de la curva 00:46:35

de compresión de rango dinámico 00:46:37

¿Vale? Entonces, ¿qué es lo que tengo que hacer? Pues básicamente cogerme este texto, control c, me voy al proyecto de Unreal y fijaros, en la parte de variables de consola yo tengo aquí un grupo que se llama console variables y tenemos un más. 00:46:39

Esto es un array que se llama. Es una lista. Entonces yo tengo que ir añadiendolas. 1, 2, 3, 4, 5 y 6. Son 6 las que vamos a meter. Entonces la primera es esta. Motion Blur Quality. 00:46:59

Y el valor que tiene preestablecido es 4, ¿vale? Pues lo pongo aquí, 4. El siguiente, ¿cuál es? Motion Blur separable. Me lo copio, CTRL-C y lo pego. 00:47:13

veis que me lo filtra 00:47:35

cuando yo lo escribo bien me aparece aquí abajo 00:47:37

y el valor es 1 00:47:39

pues 1 00:47:42

estos son los valores máximos 00:47:44

el siguiente cual es 00:47:45

desktop field quality 00:47:50

me lo copio 00:47:54

y me lo pego 00:47:56

y cual es el valor que viene 00:47:58

por defecto 4 00:48:02

pues 4 00:48:03

siguiente bloom quality 00:48:04

5 me lo copio 00:48:08

me lo pego 00:48:12

y le pongo un 5 00:48:13

perfecto 00:48:15

siguiente 00:48:17

tone mapper quality 00:48:19

me lo copio 00:48:20

me lo pego 00:48:22

y el valor es 1 00:48:24

y hay una última 00:48:26

variable de consola que no viene en la documentación 00:48:28

que a mi me gusta utilizarla 00:48:31

que es el screen percentage 00:48:33

de eso os he hablado en algún momento 00:48:34

suena lo del screen percentage 00:48:37

yo creo que no 00:48:38

no 00:48:40

Screen Percentage 00:48:41

este es, el Screen Percentage 00:48:44

que es, es un supersampleado 00:48:46

o subsampleado de imagen 00:48:48

que es lo que hace este valor 00:48:50

hace que si yo tengo por ejemplo 00:48:51

el 00:48:54

el output de mi render 00:48:56

a 1920x1080 00:48:58

si le pongo 00:49:01

1,25 00:49:03

lo que va a hacer es renderizarlo 00:49:04

un 25% más grande 00:49:06

para tener más información de píxeles 00:49:07

y luego me lo vuelve a reducir a mi tamaño, ¿vale? 00:49:10

Eso lo que hace es mejorar todo, mejorar los difuminados de las sombras, 00:49:14

mejorar los reflejos, mejorar un montón de cosas. 00:49:19

¿Pero qué pasa? Que le cuesta un 25% más renderizarlo, ¿vale? 00:49:22

Entonces yo normalmente esto lo suelo meter cuando tengo renders bajitos, 00:49:27

de 1920x1080, por ejemplo. 00:49:32

Si yo ya estoy renderizando en 2K o en 4K, no tiene tanto sentido. 00:49:35

que utilice este comando de consola 00:49:39

entonces yo este lo dejo aquí puesto 00:49:41

y le doy un 100 para que por lo menos 00:49:43

me renderice 00:49:45

el 100% de la resolución que estoy utilizando 00:49:47

y cuando 00:49:50

tengo que renderizar resoluciones 00:49:51

bajitas, le subo esto para que 00:49:53

el resultado final sea mejor 00:49:55

¿vale? veis que son un montón de capas 00:49:57

de calidad que le vamos 00:49:59

metiendo al render final para que al final el resultado 00:50:01

sea mejor que lo que tenemos en el 00:50:03

visor de Unreal ¿vale? 00:50:05

entonces 00:50:08

estas variables de consola 00:50:09

una vez que las hemos metido 00:50:10

las podemos activar 00:50:11

o desactivar 00:50:12

¿vale? 00:50:13

si queremos 00:50:15

vale 00:50:15

por último 00:50:17

y no menos 00:50:19

importante 00:50:21

yo me puedo sacar 00:50:22

un criptomate 00:50:25

¿sabéis lo que es un criptomate? 00:50:26

¿no? 00:50:29

es un pase de render 00:50:30

que me permite meter 00:50:32

en After Effects 00:50:33

o en Nuke 00:50:35

o en cualquier programa 00:50:35

de edición de vídeo 00:50:37

y hacer máscaras dinámicas 00:50:38

de cualquier objeto, ¿vale? 00:50:40

Me hace un mate de cualquier objeto. 00:50:42

Eso es interesante. 00:50:46

Eso se hace con el pase de object ID, 00:50:48

que está aquí, object ID, ¿vale? 00:50:54

Y este pase de object ID le tenemos que decir 00:50:56

que nos incluya los elementos traslúcidos de la escena. 00:51:00

Y esto me permite hacer máscaras de todo. 00:51:03

Me permite hacer una máscara por material, por actor, 00:51:06

por actor con jerarquía, por carpetas del World Outliner o por capas, ¿vale? 00:51:09

Yo normalmente lo dejo siempre en full. 00:51:15

Vamos a renderizar unos cuantos frames y vemos qué es lo que nos da, ¿vale? 00:51:17

Luego, si quisiéramos más pases de render, nosotros dentro del track de deferred rendering 00:51:23

tenemos aquí la posibilidad de sacar más pases de render. 00:51:29

En esos pases de render, si yo estoy sacando una secuencia EXR, les puedo decir que sean 32 bits también, ¿vale? Que es lo suyo. Entonces, si yo despliego additional post-process materials de primeras, yo tengo dos pases de render. 00:51:36

Uno es el World Depth, o sea, un pase de profundidad con el que yo puedo hacer diferentes cosas. En postproducción yo puedo hacer un desenfoque propio. Puedo aplicar una capa de ajuste a lo que está al fondo de la escena y que no afecte a lo que está en primer plano, cosas así. 00:51:52

¿vale? entonces para que funcionen 00:52:10

estos pases de render tenemos que habilitarlo 00:52:13

tenemos que decir enable 00:52:15

el siguiente que tenemos aquí es el motion vectors 00:52:16

esto es un pase de velocity 00:52:19

y me sirve para generar 00:52:21

motion blur en postproducción 00:52:23

¿vale? 00:52:25

¿qué más pases tenemos disponibles? 00:52:27

veis que esto es una lista ¿no? 00:52:29

entonces si yo quiero sacar 00:52:31

más pases de render le tengo que dar al más 00:52:33

me saco otro 00:52:35

y busco, claro ¿cuáles son 00:52:37

los pases de render que tengo disponibles? 00:52:39

Pues tengo que filtrarlos por nombre. 00:52:41

Si yo escribo aquí movie, 00:52:43

render, 00:52:45

todos los que ponen movie, render, 00:52:49

son pases de render. Tengo 00:52:51

el ambient occlusion, 00:52:53

el motion vector y el world depth, que ya los 00:52:55

tengo. El world normals, 00:52:57

me puedo sacar el pase 00:52:59

de normales de la escena entera, 00:53:01

si quisiera. El world 00:53:03

position, que esto lo que me da es una nube de 00:53:06

puntos de la escena que yo puedo utilizar 00:53:08

para colocar plates a diferentes 00:53:10

profundidades o a diferentes posiciones 00:53:13

dentro de la escena, esto se suele utilizar 00:53:15

con new, cuando hay que hacer mate 00:53:17

painting dinámico 00:53:18

el pase de posición y el pase de normales 00:53:19

es importante, ¿para qué? para saber 00:53:23

dónde está cada vértice 00:53:25

y hacia dónde mira su normal 00:53:27

¿se entiende? 00:53:28

bueno, yo no lo suelo 00:53:31

utilizar mucho porque intento 00:53:33

que la mayor parte de la postproducción se haga 00:53:35

en Unreal, pero hay gente que se saca 00:53:37

el render pelao y se hace 00:53:38

toda la postproducción en Unreal. 00:53:41

Entonces, esto es necesario para poder hacer 00:53:42

todo eso, ¿vale? 00:53:44

Yo normalmente, como mucho, mucho, mucho, 00:53:46

mucho, me saco 00:53:49

el pase de profundidad, 00:53:50

que es el World Depth, 00:53:53

y el pase de Ambient Occlusion. 00:53:54

Movie, Render 00:54:01

Queue, 00:54:02

Ambient Occlusion, ¿vale? 00:54:04

Y lo habilito, ¿vale? Me voy a sacar estos 00:54:06

tres, nada más. Todo esto, 00:54:08

al estar renderizando en un 00:54:11

formato xr se va a almacenar como una capa dentro de cada de cada frame vale bien más o menos se 00:54:12

entiende lo que os he contado vamos a probarlo de todas maneras vamos a ver cómo hacemos esto 00:54:21

entonces ahora una vez que tenemos todo esto ya configurado lo vamos a salvar le damos aquí 00:54:28

arriba en unsafe config y le decimos safe as preset y esto como lo como lo nombramos pues yo lo 00:54:33

nombraría como 2K 00:54:40

que es la resolución 00:54:42

barra baja 00:54:44

EXR 00:54:45

barra baja 00:54:46

multipass 00:54:47

¿qué es lo que se suele hacer? 00:54:50

lo ideal es que os creéis 00:54:52

varios presets 00:54:53

para los diferentes formatos 00:54:54

de exportación que necesitáis 00:54:57

yo me haría uno de XR 00:54:58

otro de Apple ProRes 00:54:59

otro de PNG 00:55:02

con diferentes resoluciones 00:55:04

para que no tengamos que estar 00:55:07

configurándolo todo el rato 00:55:08

¿Se entiende? 00:55:10

Vale. 00:55:11

Pues le damos a salvar. 00:55:12

Entonces. 00:55:15

Entonces. 00:55:18

Una vez que lo tenemos, aceptamos. 00:55:20

Y ya lo tenemos aquí. 00:55:23

¿Qué es lo que voy a hacer yo? 00:55:24

Para que no tarde mucho, voy a renderizar solo 4 frames. 00:55:25

¿Vale? 00:55:28

Venimos aquí. 00:55:30

Y le decimos que lo que queremos es... 00:55:31

Fijaros, me voy al principio de la animación. 00:55:38

y le digo 1, 2, 3 y 4 frames y le digo que esto sea el final de la animación, 4 frames solamente, le doy a la claqueta, veis que se queda guardado el último preset de render que yo tenga 00:55:40

y ya tengo aquí guardado también la ruta, con lo cual simplemente le doy al botón de render local y se lanza, fijaros esta es la pantalla de Movie Render Cube 00:56:00

¿Qué es lo que me está renderizando? 32 frames entre cada frame, ¿vale? Veis que aquí pone subsample, ¿vale? Pues me está renderizando frames de 2K y entre medias de cada frame me está renderizando 32 subframes, ¿vale? Para poder depurar la imagen. 00:56:12

ya está, ya hemos terminado 00:56:32

entonces 00:56:37

¿qué es lo que tenemos ahora? 00:56:39

pues tenemos 4 frames 00:56:41

que cada uno de ellos pesa 77 00:56:45

megas, ¿por qué? porque está comprimido 00:56:48

si lo hubiera dicho 00:56:50

que no quiero compresión probablemente 00:56:51

estos frames hubieran pesado 200 megas o por ahí 00:56:53

¿vale? 00:56:55

entonces 00:57:00

si me voy a 00:57:01

After Effects 00:57:04

y me traigo esta secuencia 00:57:06

Mientras se va abriendo pregunta, 00:57:16

me ha dado la sensación de que ha tardado bastante poco, ¿no? 00:57:18

Ha tardado muy poco. 00:57:21

Sí, sí. 00:57:23

A ver, depende también. 00:57:23

Si lo renderizas en 4K, tarda más. 00:57:26

Pero sí, suele tardar muy poquito. 00:57:29

Yo me he renderizado proyectos enteros en un día. 00:57:32

Y lo de los subframes, 00:57:38

¿puede llegar un momento en el que merezca la pena sobremuestrear, 00:57:40

es decir, renderizar a 48 fotogramas por segundo? 00:57:43

porque los subframes obviamente 00:57:45

él los usa para calcular, pero no quedan 00:57:47

registrados. 00:57:49

Sí, hay veces que yo 00:57:52

me lo renderizo a 60 frames 00:57:54

y luego ya lo adapto. 00:57:55

O si quieres hacer un slow motion 00:57:58

o cosas así, pues te lo puedes renderizar 00:58:00

a un frame rate mayor. 00:58:01

Entonces, voy a importarme 00:58:05

estos 00:58:07

cuatro frames. 00:58:12

Le digo que es una secuencia 00:58:16

OpenXR y me la importo. 00:58:18

Aquí la tengo. Ahora, en 32 bits, creo una composición. Aquí la tenemos. Entonces, esto se supone que tiene, si yo me saco aquí una capa de ajuste, Adjustment Layer, y le metemos aquí un efecto de exposición 32 bits, 00:58:20

exposición 32 bits 00:58:49

que es este 00:58:51

se supone que nosotros aquí tenemos 00:58:52

todo el rango dinámico de la imagen disponible 00:58:56

¿vale? 00:58:59

está sin clampear 00:59:01

y aparte de eso 00:59:03

si yo me duplico esta capa 00:59:04

control c, control v 00:59:07

y le aplico 00:59:08

el xr 00:59:11

extractor 00:59:13

se llama 00:59:16

este me permite acceder 00:59:16

a las capas 00:59:19

que tenga almacenadas, ¿vale? 00:59:21

Tenemos el Ambient Occlusion, el Motion Vectors 00:59:23

y el World Depth, ¿vale? 00:59:26

Perfecto. 00:59:30

El Ambient Occlusion, ¿veis? 00:59:32

Es la información de Ambient Occlusion. 00:59:34

Esto lo podríamos meter multiplicado 00:59:36

por encima de la imagen final 00:59:38

para darle un poquito más de fuerza 00:59:40

a las sombras de contacto, si quisiéramos. 00:59:41

Tenemos también el World Depth. 00:59:45

Y el World Depth, básicamente, lo que tiene es... 00:59:48

es una capa que me da 00:59:52

en escala de grises la profundidad de la escena 00:59:57

yo con esto puedo aplicar efectos a determinada 01:00:00

profundidad según la cámara 01:00:07

le puedo decir, vale, quiero que solo la parte 01:00:10

del muro esté más expuesta, pues esto lo utilizo como máscara 01:00:15

para otro efecto, vale, bien, se entiende 01:00:18

chicos? Sí, sí. Vale, pues esto es una de las cosas, pero otra de las cosas interesantes es lo que os decía antes del 01:00:23

criptomate. Yo aquí tengo un efecto, bueno, esto lo suele tener todos los programas. El criptomate, si yo lo aplico, fijaros lo que 01:00:31

pasa. De repente tengo una máscara dinámica de cada parte de la escena. Entonces, si yo hago control botón, no, botón derecho, esto es una 01:00:41

máscara de este objeto 01:00:51

o si hago así, esto es una máscara 01:00:53

de ese objeto y veis que coge toda la información 01:00:55

de motion blur y todo 01:00:58

en la máscara, entonces 01:00:59

con botón derecho yo puedo crear 01:01:01

máscaras dinámicas de cada parte 01:01:03

de la 01:01:06

escena y una vez que 01:01:07

lo tengo seleccionado, le puedo 01:01:09

decir que me muestre el matte 01:01:12

only y esto lo meto como 01:01:13

como máscara 01:01:15

de luminancia 01:01:17

¿vale? ¿se entiende? 01:01:18

Esto me permite también seleccionar solo esa parte. Si yo apago esto, podría tener una máscara perfecta solo de ese elemento. Y si le doy a colores, con el botón derecho voy seleccionando partes diferenciadas de mi composición. 01:01:21

bajo mi punto de vista 01:01:48

el CryptoMatter es lo que mejor funciona 01:01:51

a nivel de pases, dentro del render 01:01:53

de Unreal 01:01:55

porque me permite luego hacer selecciones complejas 01:01:56

con muy poco esfuerzo 01:01:59

¿vale? 01:02:00

¿bien? 01:02:02

¿estás seleccionando con el botón derecho? 01:02:05

¿y puedes seleccionar varias capas 01:02:07

a la vez? 01:02:09

con shift 01:02:11

y botón derecho 01:02:14

puedes seleccionar varias capas 01:02:15

esto está brutal 01:02:16

¿vale? 01:02:19

bien, pues 01:02:21

esto es 01:02:22

esto es lo que se puede hacer 01:02:24

¿vale? 01:02:26

realmente no es perfecto 01:02:28

pero está bastante bien 01:02:30

para ser un motor de render en tiempo real 01:02:31

está bastante bien 01:02:33

¿vale? 01:02:34

entonces 01:02:41

llegados a este punto 01:02:42

ya os he contado todo lo que se puede hacer con Unreal 01:02:45

a nivel visual 01:02:48

vámonos a la parte de Blueprints 01:02:49

esto si que es gracioso 01:02:51

esta parte si que es cachonda 01:02:53

entonces 01:02:56

claro 01:02:58

yo ahora que tengo que hacer 01:03:00

tengo que coger las animaciones que tenía hechas 01:03:01

de las pantallas, de los totems, del ticker 01:03:04

y lo tengo que preparar 01:03:06

para que yo lo pueda lanzar desde axymetry 01:03:08

¿no? 01:03:10

esa es un poco la idea 01:03:11

para que yo en axymetry pueda crear un botón 01:03:12

en el cual yo le de 01:03:16

y la pantalla aparezca 01:03:18

O que yo le dé y aparezca el ticker, o que yo le dé y aparezca el tótem, ¿vale? Entonces, para hacer eso necesitamos programar, ¿vale? Pero yo no soy programador. Entonces, Unreal tiene una herramienta que se llama Blueprints, que es de programación gráfica mediante nodos, que nos permite realizar todas esas operaciones, ¿vale? 01:03:20

entonces voy a haceros 01:03:37

una pequeña introducción teórica 01:03:40

a los blueprints, o sea, intentaros 01:03:42

contar blueprints 01:03:44

en lo que me queda de clase es un esfuerzo 01:03:45

de abstracción, porque es una parte 01:03:49

de Unreal muy grande, ¿vale? 01:03:50

pero voy a intentar por lo menos contaros lo que os puede 01:03:52

hacer falta para la parte de 01:03:54

Aximetry, no sé si alguno de los que estamos aquí 01:03:56

sabemos programar, a lo mejor Álvaro 01:03:58

sí que tiene más ideas, o a lo mejor 01:04:00

Álvaro no está, que eso puede pasar 01:04:04

también 01:04:06

estoy por aquí, por aquí 01:04:07

pero vamos, tenemos a Seymour que también ha trasteado 01:04:09

vale, perfecto, pues muchos de los 01:04:11

conceptos que os voy a contar seguro que os suenan 01:04:13

vale, entonces 01:04:15

saco un momento el whiteboard 01:04:17

y os cuento 01:04:19

un poco de que va 01:04:21

esto de los blueprints, vale 01:04:23

que tiene Swahel 01:04:25

¿qué son los blueprints? 01:04:26

blueprints 01:04:37

los blueprints realmente 01:04:38

son elementos que contienen programación propia, ¿vale? 01:04:41

Programación propia, ¿vale? 01:04:50

Pero esto por detrás lo que tiene es código, ¿vale? 01:04:56

Pero nosotros lo vamos a ver en formato gráfico, 01:04:59

gráfico en forma de nodos, ¿vale? 01:05:06

Es un sistema nodal, es muy parecido 01:05:09

a lo que hemos visto en la parte de materiales, ¿vale? 01:05:11

¿Vale? Entonces, existen muchísimas tipologías de blueprints. Algunos ya están creados, ¿vale? Están bien en el motor de manera nativa y otros los tenemos que crear nosotros. 01:05:15

Entonces, como los tenemos que crear nosotros, los posibles blueprints que pueda haber son infinitos, ¿vale? Pero la clasificación principal de estas tipologías de blueprints es la siguiente. 01:05:31

tipos de Blueprint, tipos de BP, BP es la abreviatura de Blueprint, por un lado vamos a tener el Level Blueprint, el Level Blueprint es un Blueprint, 01:05:42

o sea, un elemento que tiene programación propia que está asociado al nivel, con lo cual no es un Asset, como tal, se almacena dentro del Asset del nivel, 01:05:58

Está asociado al nivel. Y como tal, sirve para crear interactividades o automatizaciones con actores. Porque si os acordáis, el nivel no es nada más que un contenedor de actores. 01:06:07

¿vale? 01:06:28

sirve para trastear a nivel de programación 01:06:30

con los actores de ese nivel 01:06:32

o sea, el level blueprint de mi nivel 01:06:34

actual no puede hacer nada 01:06:36

con los actores que estén en otro nivel 01:06:38

¿vale? 01:06:40

esa es la 01:06:43

esa es la 01:06:44

realidad 01:06:45

entonces está guay porque me permite hacer 01:06:46

muchas cosas con todos los actores del 01:06:50

nivel pero no es muy flexible porque si 01:06:52

yo me programo algo y me lo quiero 01:06:54

llevar a otro nivel, me lo tengo que 01:06:56

copiar y pegar, o si me lo quiero llevar 01:06:58

a otro proyecto, me tengo que emigrar el nivel 01:07:00

completo. ¿No? 01:07:02

¿Se entiende esto? 01:07:04

Bueno, no sé si se entiende, pero 01:07:06

es así. 01:07:08

Y luego, existe otra tipología 01:07:10

de Blueprints, que son los Blueprint Class, 01:07:12

las clases. Estos 01:07:14

son Assets del 01:07:18

Content Browser, ¿vale? 01:07:20

Entonces, yo puedo arrastrar 01:07:24

un Blueprint Class al nivel, 01:07:26

pero como la programación ya no está dentro 01:07:28

del level blueprint, sino que está dentro del asset, esto me lo puedo llevar a cualquier proyecto o a cualquier nivel sin necesidad de tener que copiarme 01:07:30

todo el árbol de nodos, ¿vale? Es más flexible, porque como es un asset, como os digo, me lo podría llevar a cualquier proyecto y la programación se mantiene 01:07:39

dentro de ese asset, ¿vale? 01:07:52

Bien, más o menos. 01:07:55

Dos tipologías. 01:07:58

Nosotros ya hemos visto algún blueprint. 01:08:00

Hemos visto el camera shake, ¿verdad? 01:08:01

Para hacer vibraciones en la cámara. 01:08:04

Eso es un blueprint class que viene ya determinado 01:08:07

dentro de Unreal, ¿vale? 01:08:10

Entonces nosotros ahora de primeras para aprender 01:08:12

lo que vamos a hacer es trastear con actores 01:08:15

dentro del level blueprint, 01:08:17

pero todo lo que os cuente del level blueprint 01:08:18

luego se puede aplicar a Blueprint Class 01:08:20

¿vale? entonces 01:08:23

¿qué es? ¿cuál va a ser 01:08:25

el funcionamiento principal? 01:08:27

de los 01:08:29

Blueprints, nosotros vamos a establecer siempre 01:08:31

siempre un sistema 01:08:33

causa-efecto ¿vale? 01:08:35

sistema 01:08:39

causa 01:08:39

efecto 01:08:41

entonces 01:08:44

a efectos 01:08:48

de programación la causa 01:08:50

lo vamos a llamar evento 01:08:52

evento 01:08:56

cuando pasa algo 01:08:57

cuando algo cambia 01:08:58

sucede algo 01:09:01

¿vale? 01:09:03

entonces 01:09:05

lo primero que tenemos que entender 01:09:06

es que dentro de Unreal 01:09:08

hay un montón de tipologías de eventos 01:09:09

diferentes 01:09:11

pensad que esto es un videojuego 01:09:12

lo que estamos 01:09:15

lo que estamos creando 01:09:16

en cierta manera 01:09:18

entonces 01:09:19

¿Qué tipologías de evento tenemos dentro de Unreal? Pues un montón, por ejemplo, las teclas, cada una de las teclas del teclado puede ser un evento, que yo pulse la W y se encienda una luz, ¿no? Eso es una tipología de evento, las teclas. 01:09:21

Entonces, el ratón tiene el botón izquierdo, el botón derecho, el botón central, la rueda cuando rueda, cuando desplazo el ratón de izquierda a derecha o de arriba a abajo, ¿no? Las teclas, el ratón, eso es otra tipología de eventos que yo puedo utilizar para desencadenar cosas, ¿no? 01:09:36

¿Qué más cosas tenemos? Nosotros podemos establecer eventos que estén sujetos a colisiones, o sea, que cuando yo entre dentro de un volumen pase algo y que cuando yo salga de ese volumen pase otra cosa, ¿vale? 01:09:58

Muchas veces eso se utiliza para abrir puertas o para encender luces. Cuando yo me acerco al ascensor, se enciende una luz y se abre una puerta. Pues eso no está sujeto a un botón, está sujeto a un elemento espacial, ¿vale? 01:10:15

esto se llaman triggers 01:10:30

trigger volume 01:10:32

de hecho, triggers 01:10:34

trigger volume 01:10:36

¿qué otras tipologías 01:10:38

de evento podemos llegar 01:10:40

a tener? 01:10:42

pues por ejemplo que algo pase 01:10:44

cuando yo arranco el juego, cuando le doy al 01:10:46

play, ¿no? ¿para qué sirve 01:10:48

el, esto se llama event 01:10:50

begin play 01:10:52

esto para que 01:10:53

esto para qué sirve 01:10:56

pues normalmente 01:11:00

sirve para 01:11:01

establecer estados iniciales 01:11:03

si yo quiero que cuando arranque el juego todas las luces 01:11:06

estén apagadas 01:11:08

pues lo asocio al event begin play 01:11:09

¿vale? 01:11:12

begin play 01:11:15

y luego hay otro que se llama 01:11:16

event tick 01:11:19

que lo que hace es 01:11:21

hacer comprobaciones cada vez 01:11:24

que renderizamos un frame, claro 01:11:26

Si cada vez que renderizo un frame estoy comprobando cosas, ¿eso para qué me sirve? Para evaluar estados, para evaluar algo que pueda cambiar en cualquier momento. Entonces, yo lo estoy comprobando todo el rato y si cambia, puedo hacer ese cambio en tiempo real. ¿Se entiende? Vale, pues vamos a ver cómo utilizamos todo esto. 01:11:27

vamos a ver como utilizamos 01:11:48

todo esto, para eso 01:11:50

nos vamos a abrir un proyecto nuevo 01:11:52

¿vale? porque el que tenemos 01:11:54

tiene 01:11:56

bueno, antes de abrir 01:11:58

un proyecto nuevo, vamos a dejar 01:12:00

preparada la programación 01:12:02

de lo que necesitamos operar dentro de Aximetry 01:12:03

que básicamente son los movimientos 01:12:06

de las pantallas ¿vale? 01:12:08

vamos a dejar eso preparado y luego nos abrimos 01:12:10

otro proyecto más sencillito 01:12:12

con el que vamos a hacer alguna prueba de todo esto 01:12:14

que os acabo de contar 01:12:16

Entonces, fijaros, me salgo del Cinematic Viewport, que ahora mismo ya no me hace falta, y me voy al Level Blueprint. 01:12:20

¿Dónde está el Level Blueprint? Aquí, en este botoncito que veis aquí, lo abro y pongo Open Level Blueprint. 01:12:31

Perfecto. Esto que veis aquí es el Interface del Level Blueprint. 01:12:38

¿Qué es lo que tenemos aquí? Pues tenemos, por un lado, el panel de MyBlueprint, que lo que me va a dar es una especie de resumen de los nodos que yo estoy utilizando aquí y de las variables que yo vaya creando, que todavía no sabemos lo que son, ¿vale? 01:12:44

Y de las macros y de las funciones y de otra serie de cosas. ¿Vale? Entonces veis que de primeras, cuando yo hablo del Level Blueprint, tengo ya el Begin Play y el Event Tick. ¿Por qué? Porque suelen ser nodos que se utilizan muy a menudo. ¿Vale? 01:13:02

¿Vale? Entonces, ¿qué es lo que tengo que dejar yo preparado? Pues tengo que dejar preparado el movimiento de las pantallas. Como os decía antes, el Level Blueprint solo puede interactuar con actores de nivel. 01:13:17

Entonces, para que yo pueda acceder a un Sequencer, yo tengo que crear una referencia de ese Sequencer dentro del nivel, ¿vale? Con lo cual, yo me tengo que sacar una referencia del Level Sequence Screen, del Level Sequence Sticker y del Level Sequence Totem a la escena. 01:13:35

Lo arrastro, 1, 2 y 3. Estas son las tres referencias a las tres secuencias que yo quiero controlar de manera interactiva desde el Level Sequence. 01:13:53

¿Vale? Entonces, fijaros, ¿cómo lo hacemos? Muy fácil, con cualquiera de estas secuencias seleccionadas, botón derecho y veis que aquí me pone create a reference to ls barra baja totem, pues esta burbujita de aquí contiene la información de ese actor y ese actor apunta a la secuencia, ¿vale? 01:14:07

Entonces me tengo que sacar referencia de estos tres, selecciono otra, botón derecho, create reference to ls picker y selecciono la otra, botón derecho, reference to ls screen. 01:14:39

Vale, perfecto. Yo ya tengo la referencia de cada una de estas tres secuencias, ¿vale? Entonces, ¿ahora qué es lo que necesito hacer? Necesito tener la posibilidad de hacer play o de hacer play reverse. ¿Para qué? Para que aparezca la pantalla y desaparezca. 01:14:55

entonces, en este caso 01:15:16

si tiro, vamos a ver 01:15:19

cómo funcionan los nodos 01:15:21

cómo funcionan estos nodos 01:15:23

este nodo es un nodo de información 01:15:25

y estos nodos son 01:15:27

nodos de eventos, ¿cómo funciona 01:15:29

todo esto? pues muy fácil 01:15:31

si veis que algo no está 01:15:33

claro, me podéis interrumpir 01:15:37

que yo entiendo que esta parte 01:15:39

es un poco más abstracta 01:15:42

¿cómo funcionan los nodos? 01:15:44

pues los nodos hay de tres tipologías 01:15:49

básicamente. Tienen todo en forma de caja o de burbujita y tienen dos tipos de pines. 01:15:51

Tenemos nodos que son de principio de la cadena, que suelen ser así. Tenemos nodos que son 01:16:01

intermedios, que suelen ser así. Y tenemos nodos que son del final de la cadena, que 01:16:09

solo son capaces de recibir información, ¿vale? Que suelen ser así. Solemos tener 01:16:18

dos tipologías de pin. Tenemos un pin 01:16:24

que es el pin de ejecución, que son los triangulitos estos 01:16:28

y pines de información. La información hay de muchos 01:16:31

tipos. Hay información 01:16:39

de texto, hay información de tipo vector 01:16:41

si yo quiero dar por ejemplo unas coordenadas 01:16:47

hay información de tipo float, que es simplemente un número con decimales 01:16:49

Hay información booleana que simplemente establece una condición de sí o no o de verdadero o falso. Hay muchos tipos y cada uno de esos tipos tiene un color diferente, ¿vale? Entonces nosotros, según la tipología de nodo que saquemos, pues vamos a tener nodos iniciales, finales o intermedios, ¿vale? 01:16:54

intermedios 01:17:19

y 01:17:22

lo que va a pasar es que nosotros siempre vamos a 01:17:24

ejecutar la secuencia 01:17:27

en un sentido 01:17:29

de izquierda a derecha, o sea 01:17:31

cuando yo pinche en el triangulito 01:17:32

y conecte este con este 01:17:35

el sentido de ejecución va a ser 01:17:37

que se ejecuta primero este 01:17:39

y luego este, y cuando yo conecte 01:17:41

este con este, pues el siguiente 01:17:43

que se va a ejecutar va a ser esto 01:17:45

a efectos prácticos va a parecer que se está ejecutando 01:17:46

todo al mismo tiempo porque la ejecución 01:17:49

son milisegundos 01:17:51

¿vale? pero realmente 01:17:52

el orden en el que se ejecutan las cosas 01:17:55

es importante ¿vale? 01:17:57

esto a nivel de ejecución y luego a nivel de información 01:17:59

cada nodo me va 01:18:01

a recibir información 01:18:03

y a sacar información 01:18:04

¿vale? 01:18:06

acordaros de que los 01:18:09

pinners de información son redonditos 01:18:10

y los pinners de ejecución son triangulares 01:18:12

¿vale? 01:18:15

bien, más o menos, ¿se entiende esto chicos? 01:18:17

más o menos 01:18:19

vamos a ver cómo funciona 01:18:22

entonces 01:18:24

yo tengo con vosotros hoy hasta las 2 01:18:27

vale, perfecto 01:18:33

entonces lo que os decía 01:18:35

como estoy en el level blueprint 01:18:36

en el level blueprint yo solo puedo trabajar con actores 01:18:38

con referencias a actores 01:18:41

yo estas secuencias que necesito controlar 01:18:42

me las he sacado al nivel 01:18:45

y voy a empezar a 01:18:47

operar con ellas 01:18:49

entonces yo que es lo que tengo que hacer 01:18:50

el sistema que tiene 01:18:53

Unreal para encontrar los nodos 01:18:54

es muy intuitivo ¿por qué? porque se llama 01:18:56

context 01:18:58

sensitive o sea 01:18:59

cuando yo tiro de una bolita 01:19:02

en este caso es una bolita de información 01:19:04

de color azul 01:19:06

yo tiro y suelto 01:19:07

me va a filtrar solo los nodos 01:19:10

que yo pueda utilizar con ese 01:19:12

tipo de información y con ese tipo 01:19:14

de nodo ¿vale? o sea no me va a mostrar 01:19:16

todas las posibilidades si yo quisiera ver todos los nodos posibles tendría que quitarle el context sensitive vale pero yo normalmente esto nunca lo quito porque yo no quiero 01:19:19

los nodos que no puedo utilizar vale entonces yo aquí que es lo que voy a buscar un play vale yo lo que quiero hacer es un play sequence player vale y fijaros que 01:19:29

cuando yo creo el Play Sequence Player, además del actor, se me ha creado otra burbujita que se llama componente. Esto es un componente. ¿Qué son los componentes 01:19:44

dentro de Blueprints? Pues son los parámetros que no forman parte exclusivamente del actor. ¿Os acordáis al principio de los principios que os decía que los actores 01:19:56

son contenedores vacíos que hacen referencia a cosas vale pues un actor como punto de partida 01:20:06

los únicos parámetros que tiene son las transformaciones y un parámetro que se llama 01:20:14

hidden in game para que se vea o no se vea cuando nosotros le demos al play que es lo mismo que pasa 01:20:19

que cuando le damos a la g en el editor que desaparecen los helpers vale entonces todos 01:20:24

los parámetros que no son de actor o sea todo lo que no es transformaciones o hidden in game son 01:20:30

parámetros específicos de ese tipo de actor vale pues esos parámetros específicos están dentro del 01:20:37

componente de hecho si yo selecciono cualquiera de estas secuencias fijaros que encima de sus 01:20:42

detalles yo tengo el actor que es la instancia y luego justo debajo un root component vale pues 01:20:49

Entonces todos los parámetros que no sean ni transformación ni hidden in game están dentro del componente. Por eso yo cuando quiero buscar el play de la secuencia, claro el play de la secuencia es un parámetro específico de la secuencia y eso está dentro del componente. 01:20:56

Por eso se me crea automáticamente esta otra burbuja. ¿Vale? Entonces, ¿yo qué es lo que quiero hacer con esta secuencia? Quiero reproducirla al derecho y Play Reverse. ¿Vale? Play Reverse. Vale, perfecto. 01:21:11

Perfecto. Entonces, esto es lo que yo voy a tener que ejecutar con un botón cuando esté en Aximetry. ¿Vale? ¿Bien? Entonces, ¿eso cómo se hace? Pues dentro de Aximetry, claro, como esto es el Unreal de Aximetry, aquí tenemos una serie de nodos que son específicos de Aximetry. 01:21:29

¿Vale? Entonces si yo doy botón derecho y busco 01:21:50

AximetryFigure 01:21:54

¿Vale? 01:21:57

Este nodo es el que va a servir 01:22:01

para que yo pueda ejecutar el play o el play reverse 01:22:03

Entonces toda esta parte os la va a contar Rafa 01:22:07

¿Vale? Por eso yo no quiero emplear mucho tiempo en esto 01:22:09

porque esto os lo va a contar Rafa, pero nosotros ya vamos a dejar preparadas 01:22:12

estas burbujitas para que Rafa las pueda conectar 01:22:16

y las podáis usar en Aximetry ¿Vale? 01:22:18

Entonces, voy a hacer lo mismo con estas dos, si yo tiro de aquí y busco play, tengo el play sequence player, perfecto, pues voy a poder hacer play y si tiro de aquí otra vez voy a poder hacer play reverse, ¿vale? 01:22:20

Ya está. Y con este, lo mismo, tiro de él, pongo play, así, tiro otra vez de la bolita, si escribo reverse, play reverse, ¿vale? Ahí está. 01:22:38

Entonces, de momento, lo dejamos así, no tocamos nada, ¿vale? Cuando llegue Rafa, terminará de conectar estos nodos para que los podáis utilizar en la parte de Aximetri, ¿vale? 01:23:04

compilamos, veis que cada vez que hago 01:23:14

un cambio en el editor 01:23:16

tengo que darle a compilar para ver 01:23:18

si hay algún error, vale, si no luego 01:23:20

no va a funcionar 01:23:22

el botoncito de aquí arriba de la izquierda compile 01:23:23

tiene que estar en verde para que funcione todo, vale 01:23:26

salvamos 01:23:28

de momento esto lo dejamos 01:23:30

así, nos vamos 01:23:32

a abrir otro proyecto, un proyecto más sencillito 01:23:34

este lo vamos a abrir de Unreal 01:23:36

nativo, no lo vamos a abrir de Unreal 01:23:38

de Aximetry, porque lo que os quiero contar son cosas 01:23:40

básicas de Blueprints, vale 01:23:42

entonces abrimos el 01:23:44

el Epic Games Launcher 01:23:47

abrimos el Epic Games Launcher 01:23:50

y en la parte de Library 01:24:01

en la versión 5.3 nativa de Unreal 01:24:05

le damos a Launch 01:24:09

vamos a lanzar esta versión de Unreal 01:24:10

esta la voy a salvar y la voy a cerrar de momento 01:24:13

esta es la que luego subiré para que la tengáis 01:24:19

entonces cuando nosotros lanzamos una versión de Unreal 01:24:21

Aquí tenemos una serie de templates, ¿vale? Entonces le damos al template de juegos y nos vamos a hacer un template de third person character, ¿vale? ¿Por qué? Porque este ya viene con una serie de cosas configuradas que me ayudan a contaros la parte de Blueprint, ¿vale? 01:24:30

Entonces, Games, Third Person, le damos una ubicación, en mi caso va a ser las clases del Garci, ¿vale? Y lo voy a llamar MyFirstBlueprint y lo creo. Ahí estamos. 01:24:47

Entonces, esto que nos va a abrir, nos va a abrir un proyecto base template de Unreal, ¿vale? Este proyecto base template de Unreal, fijaros, es muy sencillito, tiene una serie de colisionadores creados, ¿veis? Estas son las colisiones que tiene la escena, player collision. 01:25:14

Y lo que pasa es que cuando yo le doy al play, que es el modo juego, me aparece un personaje, que es el third person character, que me permite moverlo. Si le doy al espacio salto, se ve. Este es el modo juego, el modo play. Es el modo play cuando yo veo lo que está pasando con los blueprints. 01:25:42

¿Por qué? Porque hasta ahora hemos estado trabajando en el editor. Esto ya es el modo juego. Esto es lo que yo vería cuando empaquete el juego y se lo mande a mi cliente. Entonces, cuando nosotros trabajamos en Aximetry, estamos trabajando todo el rato en modo runtime, en modo juego. Por eso, lo que se tiene que ver bien es lo que pasa cuando le doy al play, no lo que veo cuando estoy en el editor. 01:26:08

que debería de ser lo mismo, pero a veces no es lo mismo, ¿vale? 01:26:32

Entonces, lo que os decía, vamos a ver, por ejemplo, por ejemplo, por ejemplo, 01:26:36

si yo arrastro una esfera, una esfera al nivel, yo tengo esta esfera aquí, 01:26:45

la escalo un poquito, la voy a escalar en los tres ejes para verla bien 01:26:57

Y me voy a Level Blueprint y me traigo una referencia. La referencia me la puedo traer o seleccionando el actor y dando botón derecho, Create a Reference o directamente pinchando y arrastrando. 01:27:03

vale 01:27:21

entonces 01:27:22

si yo por ejemplo 01:27:25

quisiera 01:27:28

hacer que esta esfera 01:27:29

fuese invisible 01:27:32

¿cómo lo haríamos en el editor? 01:27:33

¿a quién se le ocurre? 01:27:35

si yo quisiera invisibilizar esto 01:27:38

¿cómo lo haríamos? 01:27:40

¿alguien? 01:27:47

¿sí? ¿no? 01:27:49

bueno 01:27:50

normalmente lo hacemos con el ojito 01:27:51

¿no? 01:27:53

pero hay un parámetro 01:27:55

dentro de este actor 01:27:57

Si yo pongo visible aquí en el buscador, visible, hay un parámetro de visibility, ¿vale? Es lo mismo. Hace exactamente lo mismo. Entonces, si yo quisiera hacer esto a nivel de blueprints, tendría que venir a mi referencia, tirar y buscar visible. 01:27:58

Y resulta que hay uno de los nodos que se llama setVisibility. Como el setVisibility es un parámetro que no es específico del actor, sino que es específico de la malla estática, que es lo que es una esfera, tengo que sacar el componente. 01:28:22

Entonces, fijaros, veis que este nodo tiene set visibility, un pin de ejecución, un target, que es la geometría a la que está haciendo referencia, y luego un new visibility. 01:28:40

Claro, new visibility veis que tiene un color rojo. El color rojo de información es la información booleana. ¿Por qué? Porque la visibilidad solo puede estar o visible o no visible. ¿Vale? Solo puede ser o verdadero o falso. 01:28:56

Entonces, fijaros, ¿yo qué es lo que quiero? 01:29:10

Yo quiero que cuando arranque la experiencia y yo le dé al play, que es este botoncito aquí, la esfera esté invisible, no se vea, ¿vale? 01:29:14

Con lo cual me saco el bearing play, event bearing play, y lo conecto aquí, ¿vale? 01:29:23

Esto, cada vez que yo le dé al play, se va a ejecutar este nodo, y este nodo hace referencia a este actor, ¿vale? 01:29:32

¿Y qué es lo que va a establecer? Que el parámetro visibility esté apagado. Si le diera este check, estaría encendido. ¿Se entiende esto? Vale, pero yo quiero que cuando arranque la experiencia esto esté apagado. 01:29:39

Y ahora, si cojo este nodo y hago control D, le voy a decir que esté encendido. Le tengo que decir que haga referencia al mismo target. Pero ¿cuándo quiero que se encienda? Cuando yo quiera. Cuando le dé, por ejemplo, a la tecla T. 01:29:53

¿Vale? Entonces, ¿cómo me saco yo un evento que desencadene que este nodo se ejecute? Pues muy fácil, botón derecho y escribo T espacio keyboard, ¿vale? Y aquí tenemos la letra T. ¿Veis que tengo todos los comandos del teclado disponibles en Blueprint? Pues me saco la T. 01:30:15

Y la T, ¿qué tiene? Tiene la posibilidad de ejecutarse cuando presiono la tecla o cuando la suelto. ¿Vale? Press o Release. ¿Vale? Press o Release. 01:30:39

entonces fijaros 01:30:54

yo podría decirle que cuando presione 01:30:57

la tecla se encienda 01:30:59

y que cuando la suelte 01:31:00

se vuelva a apagar 01:31:02

¿vale? 01:31:04

hago esto, compilo 01:31:06

y fijaros lo que pasa 01:31:08

si yo ahora le doy al play 01:31:10

de primeras la esfera no está 01:31:13

¿no? 01:31:15

la esfera no está, pero bueno yo cuando me acerco 01:31:16

por aquí, veis que me choco 01:31:19

me estoy chocando contra algo 01:31:21

porque no la estoy viendo pero el colisionador está, ¿vale? 01:31:22

Entonces, si yo le doy a la T, la veo. 01:31:26

Y si suelto la T, desaparece, ¿vale? 01:31:30

Se ve, ¿no? 01:31:34

Si yo quisiera tener una referencia visual de lo que está pasando, 01:31:36

yo podría venirme al level blueprint y decirle, vale, 01:31:39

hay un nodo que se llama print string. 01:31:45

Estos nodos sirven para hacer debug de la escena. 01:31:49

O sea, para saber lo que está pasando. 01:31:52

Entonces, si yo, cuando se ejecuta este nodo, escribo aquí, esfera invisible, control D. 01:31:55

Y cuando se ejecuta este nodo, escribo aquí, esfera visible. 01:32:07

Fijaros lo que pasa. 01:32:18

Compilo, le doy al play. 01:32:19

Y aquí arriba me pone esfera invisible. 01:32:22

Pero cuando yo le doy a la T, esfera visible, invisible, visible, invisible, visible, invisible, cada vez que yo voy pulsando o soltando la T, ¿vale? La tecla T, en este caso. 01:32:24

Pero esto es un poco rollo, ¿no? O sea, yo lo que quiero es que cuando lo pulso una vez pase una cosa y cuando pulso otra vez pase otra cosa, ¿vale? 01:32:40

Entonces, ¿cómo lo hacemos? 01:32:48

Pues vengo al Level Blueprint. 01:32:57

Vengo al Level Blueprint y lo que voy a hacer es utilizar otro nodo. 01:33:00

Un nodo que se llama Flip Flop. 01:33:04

¿Qué es un Flip Flop? 01:33:07

Un conmutador, básicamente. 01:33:09

Entonces, ¿cómo utilizo este conmutador? 01:33:12

Voy a eliminar estas dos ligaduras con Alt y Click. 01:33:14

Igual que en el editor de materiales, ¿vale? 01:33:18

Y lo que hago es conectar la tecla presionada al flip-flop. ¿Qué va a pasar? Que cuando haga el primer clic, él va a ejecutar la A y cuando haga el segundo clic, él va a ejecutar la B. ¿Vale? ¿Se entiende, chicos? 01:33:20

fijaros, yo puedo hacer también 01:33:38

debug de los nodos 01:33:43

si yo vengo aquí arriba a la derecha y le digo que me hago 01:33:44

un debug de este 01:33:47

nivel, del third person map 01:33:49

y me lo dejo 01:33:50

por aquí, fijaros lo que 01:33:53

está pasando, cuando yo le doy al play 01:33:56

veis que 01:33:58

lo primero que se ha ejecutado es esto 01:34:00

porque está conectado al begin play 01:34:02

¿vale? 01:34:04

ahora, si yo hago click 01:34:07

en el visor, puedo jugar 01:34:08

¿vale? y cuando yo juego 01:34:10

si le doy a la T 01:34:12

veis lo que está pasando ¿no? cada vez que le doy a la T 01:34:14

se ejecuta una parte 01:34:21

o la otra de la cadena 01:34:23

de la secuencia 01:34:25

¿por qué? porque lo tengo conectado 01:34:27

a un flip flop ¿vale? 01:34:29

¿se va entendiendo chicos? 01:34:34

esto es un poco abstracto pero luego 01:34:35

es súper útil y súper intuitivo 01:34:36

¿vale? 01:34:38

esfera visible, esfera invisible 01:34:42

perfecto 01:34:43

Vale. Entonces, ¿qué más cosas podemos hacer? Se pueden hacer muchas cosas con esto. Un montón de cosas. ¿Qué más cosas se pueden hacer? Podemos hacer, por ejemplo, que una luz se encienda. 01:34:46

primero necesito tener una luz en la escena 01:35:06

me saco por ejemplo un spotlight 01:35:10

me saco un spotlight 01:35:13

lo giro un poquito para que apunte a la esfera 01:35:18

le doy un poquito de caña a la intensidad 01:35:22

así, ¿vale? 01:35:25

yo tengo esto, perfecto 01:35:31

entonces, yo necesito tener 01:35:36

una referencia de esta luz en mi level blueprint 01:35:39

¿no? con lo cual 01:35:42

A ver, disculpad un segundito que tengo que mandar un mini mensaje. 01:35:47

A ver. 01:36:02

Vale, perfecto. 01:36:04

Entonces, yo necesito tener una referencia de esta luz dentro de mi Level Blueprint. 01:36:07

Con lo cual, vuelvo a mi Level Blueprint. 01:36:13

Están aquí todos mis nodos y me traigo esta luz, ¿vale? 01:36:18

Esta es mi luz. 01:36:23

Entonces, ¿yo qué es lo que quiero hacer aquí? 01:36:25

Pues quiero, por ejemplo, apagarla. Entonces lo mismo, tiro y busco Visibility, Set Visibility. 01:36:27

Veis que en este caso la visibilidad de la luz está dentro de un componente, pero el componente es diferente. 01:36:41

¿Por qué? Porque esto es una luz y esto es una malla. Aquí pone Static Mesh Component y aquí pone Light Component. 01:36:49

¿Por qué? Porque aparte de la visibilidad, yo aquí voy a tener intensidad, color, radio de atenuación, todos los parámetros que hemos visto de las luces. Sin embargo, la malla lo que va a tener es el slot de la malla, el slot del material, ¿vale? Todo lo relativo a la static mesh, ¿vale? 01:36:54

Se entiende que el actor tiene una serie de parámetros que son la transformación y el hidden in game y el resto de parámetros están asociados al componente, ¿vale? 01:37:14

Entonces, si yo quiero encender o apagar una luz, yo lo que podría hacer es lo siguiente, lo podría supeditar a un evento tipo teclado, pero yo no quiero eso. 01:37:26

Yo lo que quiero ahora es, fijaros, esto se complica un poco. Saco el Place Actors y busco mi Trigger Volume. Este Trigger Volume, ¿qué es lo que va a determinar? 01:37:40

veis que esto es un volumen parecido al volumen de postproducción 01:37:56

o al volumen de light mask que habíamos visto 01:38:00

vale, pues fijaros 01:38:03

si yo pongo este volumen más o menos en la zona 01:38:05

de la luz 01:38:09

y lo hago un poquito más grande 01:38:12

con la escala, una cosa así 01:38:14

voy a mover el player start que es donde arranca 01:38:22

el jugador, lo voy a poner por aquí 01:38:26

fijaros, con este elemento 01:38:29

seleccionado 01:38:32

yo puedo crear un evento 01:38:33

específico, ¿vale? 01:38:35

con ese elemento seleccionado 01:38:38

si yo doy botón derecho 01:38:39

aquí arriba pone 01:38:41

Add Event for Trigger Volume 01:38:42

si yo lo despliego, tengo 01:38:45

eventos de colisión 01:38:47

entonces los dos principales eventos de colisión 01:38:49

que tenemos son el Begin Overlap 01:38:51

y el End Overlap, o sea 01:38:53

que pase algo 01:38:55

cuando yo entre en el volumen 01:38:57

o que pase algo cuando yo salga del volumen, ¿vale? 01:38:59

Entonces voy a sacarme el Beguin Overlap 01:39:03

y me voy a sacar también el End Overlap, estos dos. 01:39:04

Entonces, ¿yo qué es lo que quiero? 01:39:13

Que de primeras, cuando arranque el juego, 01:39:15

la visibilidad de la luz sea apagado. 01:39:18

Eso significa que lo tengo que conectar a la cadena del Beguin Play, ¿vale? 01:39:21

Entonces, cuando yo dé a Play, se ejecuta esto. 01:39:24

significa que la luz de primeras se apaga 01:39:26

¿vale? y ahora tiro de aquí 01:39:30

y me saco otro set visibility 01:39:33

y aquí le digo que la luz esté encendida 01:39:35

¿vale? new visibility true 01:39:40

activado, entonces yo lo que quiero es que 01:39:43

de primeras se apaga 01:39:46

cuando yo entro se enciende 01:39:49

y cuando yo salgo se apaga 01:39:52

¿se entiende lo que acabo de hacer? 01:39:54

Es un comportamiento sencillo. 01:39:58

Vamos a ver cómo funciona. 01:40:01

Compilo, le doy al play y fijaros, cuando yo me acerco a ti se enciende la luz y cuando salgo se apaga. 01:40:03

¿Vale? 01:40:13

Se enciende y si encima le doy a la T aparece mi luz. 01:40:15

¿Vale? 01:40:22

Se enciende, se apaga. 01:40:22

Se enciende, se apaga. 01:40:24

¿Vale? 01:40:26

¿Bien? 01:40:27

¿Todo bien hasta aquí chicos? 01:40:30

¿Más o menos? 01:40:31

¿Se va entendiendo lo que pasa? 01:40:32

Diego, te iba a preguntar 01:40:33

se pueden dejar también comentarios 01:40:36

tipo, no sé si lo le escribo 01:40:37

sí, sí, sí, igual 01:40:40

si yo vengo aquí, por ejemplo 01:40:42

y si me quiero ordenar esto un poco 01:40:44

pues puedo decirle 01:40:46

estos nodos con la C 01:40:47

son las luces 01:40:49

o esto de aquí son 01:40:51

la esfera 01:40:54

por ejemplo, ¿vale? 01:40:56

eso lo podríamos hacer 01:40:58

y también podríamos venir a un nodo 01:40:59

y cuando le damos botón derecho aquí pone Note Comment, podríamos decir, este me enciende la luz, la luz, por ejemplo, 01:41:01

y se queda como un bocadillo encima del nodo con una aclaración, ¿vale? Perfecto. 01:41:15

Entonces, ¿qué más cosas se pueden hacer? Por ejemplo, si yo quisiera cambiar el color de la luz, 01:41:26

podría tirar de aquí 01:41:32

y buscar un set color 01:41:35

¿vale? set light color 01:41:38

¿cómo quiero yo cambiar el color? 01:41:41

pues por ejemplo 01:41:46

veis que esto es muy parecido, tiene un new light color 01:41:47

pero veis que el color de información es diferente, es azul 01:41:50

¿por qué? porque los colores 01:41:53

es un tipo diferente a las booleanas 01:41:56

¿Vale? Las booleanas son rojas, solo puedo hacer sí o no, pero los colores cuando yo hago clic aquí pues tengo la rueda cromática. ¿Vale? Entonces vamos a decirle que de primeras cuando haga play se ponga en blanco la luz. ¿Vale? Cuando haga play. 01:42:00

que después 01:42:18

control D 01:42:21

cuando pase algo 01:42:23

se ponga verde 01:42:26

la luz 01:42:27

y que después 01:42:28

cuando pase algo 01:42:30

se ponga morada 01:42:32

¿vale? 01:42:34

¿qué pasa? 01:42:36

que ahora ya tengo tres opciones 01:42:37

ya no puedo trabajar 01:42:39

con un flip flop 01:42:40

¿no? 01:42:41

porque un flip flop 01:42:42

solo me hace A o B 01:42:43

A o B 01:42:45

todo el rato 01:42:46

entonces 01:42:46

Cuando tenemos más de dos opciones, necesito tirar de otro nodo que se llama multigate. ¿El multigate qué me permite hacer? Pues me permite añadir pines de ejecución por aquí. 01:42:47

entonces si yo le doy al más 01:43:06

aquí ya tendría el 0, el 1 01:43:07

y el 2, vale 01:43:10

entonces 01:43:11

para que cuando yo empiece a operar con esto 01:43:13

esto parezca un loop 01:43:16

¿cuál es el comportamiento que yo necesito? 01:43:18

pues si se pone blanco 01:43:21

al hacer Benin Play 01:43:23

yo quiero que la primera vez que le dé 01:43:24

se ponga verde 01:43:26

que la segunda vez que le dé se ponga 01:43:28

morado y que la tercera 01:43:30

se vuelva a poner blanco 01:43:32

¿vale? 01:43:34

¿entendéis la lógica, chicos? 01:43:36

Sí. 01:43:40

Vale. 01:43:43

Entonces, esto lo tenemos que 01:43:44

conectar a un evento 01:43:46

de otro tipo. Bueno, 01:43:50

podríamos darle otra tecla, por ejemplo, 01:43:52

la Y. 01:43:54

Y, Y, 01:43:54

espacio keyboard. 01:43:56

¿Vale? Entonces, esto debería 01:43:58

de estar por aquí. 01:44:02

A ver. 01:44:04

La Y, 01:44:06

Y a ver dónde está. Aquí está. Vale. La saco y yo quiero que cada vez que le dé a la Y, él me haga 0, 1 y 2. Pero además quiero que esté en loop. ¿Ves que me da la opción de que luego empiece otra vez por el primero? Vale. Vamos a probarlo. 01:44:07

compilo y me está dando un error 01:44:24

¿por qué me da un error? 01:44:27

fijaros, me está diciendo 01:44:29

que no tengo conectado 01:44:31

el target, no sabe a qué actor 01:44:33

tiene que apuntar, con lo cual 01:44:36

tengo que enchufar el componente al target 01:44:37

y el componente 01:44:40

al target 01:44:41

lo bueno de dar a compilar es que me dice 01:44:42

si está todo bien conectado 01:44:45

o si me falta alguna conexión 01:44:47

¿vale? 01:44:49

salvamos 01:44:52

Entonces, vamos a probarlo. Le doy al play, yo estoy aquí fuera, si le doy a la T, aparece la esfera, o desaparece, ¿vale? 01:44:53

Si me meto dentro del volumen, se enciende la luz, ¿vale? Y la T sigue funcionando, ¿vale? 01:45:05

Si yo entro o salgo, se enciende, y una vez que está encendido, si le doy a la Y, verde, morado y blanco, ¿vale? 01:45:11

¿Vale? ¿Bien? ¿Se entiende, no? Es bastante intuitivo. Perfecto. Muy bien. Entonces, ahora, vamos a traernos el plugin de materiales a este proyecto. 01:45:21

El plugin de materiales os acordáis que lo teníamos que poner al mismo nivel que la carpeta content, ¿vale? Entonces, botón derecho, show in explorer, ¿vale? Lo tengo que poner aquí a este nivel. 01:45:45

entonces me vengo al otro proyecto 01:45:58

que tiene los plugins, control c 01:46:01

y 01:46:02

control v 01:46:04

vale, para que esto me lo reconozca 01:46:07

tengo que apagar y encender el proyecto 01:46:09

salvo 01:46:10

tengo que tener activado el show engine 01:46:13

content, cierro 01:46:16

y lo vuelvo a abrir 01:46:18

a ver 01:46:20

voy a cerrar el after effects que ya no me hace 01:46:29

falta, vale 01:46:33

aquí los tengo los plugins, vale entonces 01:46:38

me voy a sacar 01:46:40

una de las mallas que está en el plugin 01:46:41

que es el dragón este, ¿vale? 01:46:44

Este dragón 01:46:47

lo coloco aquí. 01:46:48

Perfecto. 01:46:53

90. 01:46:56

Muy bien. 01:46:57

Vale. 01:47:01

Ahora, vamos a empezar a hacer 01:47:02

modificaciones de movimiento 01:47:04

por blueprints, ¿vale? 01:47:07

¿Cómo hacemos esto? 01:47:09

Pues muy sencillo. 01:47:12

Antes de ponernos a hacer modificaciones 01:47:18

con blueprints 01:47:20

necesito que entendáis 01:47:20

un par de conceptos, ¿vale? 01:47:23

Necesito que entendáis qué son las coordenadas globales, relativas y locales, ¿vale? 01:47:25

Entonces, si sacamos nuestra pizarrita, tenemos coordenadas globales, relativas y locales. 01:47:35

¿Por qué? Porque luego las transformaciones que vamos a poder hacer en Blueprints van a ser globales, relativas o locales. 01:48:05

¿Vale? Perfecto. Las globales son las que coinciden con las coordenadas del mundo, ¿vale? Estas son las world. Y aquí lo que tenemos que tener claro es que el eje que mira para adelante es el X y a efectos de Blueprint se va a llamar forward vector, ¿vale? Forward. 01:48:11

El que mira para la derecha, me he confundido, es el Y y este se llama Right Vector, ¿vale? Y el que mira para arriba es el Z y se va a llamar Up Vector, ¿vale? 01:48:42

Entonces, estas son las globales. Las globales son las que tenemos siempre aquí abajo, ¿vale? Si yo giro, ¿veis? Tengo un gizmo que me indica cuáles son las coordenadas del mundo, ¿vale? Pues yo voy a poder mover, rotar o escalar los objetos en base a las coordenadas globales, si quiero, ¿vale? 01:49:00

Luego, ¿las relativas cuáles son? Van a ser las que yo tenga cuando un objeto esté atachado a otro, cuando haya una relación parent-child, ¿vale? 01:49:19

Entonces, lo que va a pasar ahí es que si el parent gira, el forward vector y el right vector cambian de orientación, ¿no? ¿Vale? 01:49:36

Entonces las relativas son esas y luego las locales van a ser las que yo tenga al girar o desplazar el objeto, ¿vale? Van a ser las propias del objeto, vamos a verlo, propias. 01:49:46

vamos a duplicar este objeto 01:49:59

me lo duplico 01:50:05

y le digo a este 01:50:08

que sea 01:50:10

un child 01:50:12

del de arriba, de hecho vamos a cambiarle el nombre 01:50:15

dragón 01:50:17

parent para que se entienda 01:50:17

mejor y dragón 01:50:21

child para que se entienda mejor 01:50:22

vale, ahí está 01:50:24

entonces, las coordenadas 01:50:27

globales de este objeto 01:50:30

son las que vienen aquí, 650, 570, 0. 01:50:31

De hecho, si quiero que sean números enteros, me la podría llevar a 600, 600, ¿vale? 01:50:38

En esta escena, el 00 de la escena es esta esquina de aquí abajo, ¿vale? 01:50:45

Entonces, lo que yo tengo son 600 centímetros hasta aquí y 600 centímetros hasta aquí, ¿vale? 01:50:52

6 metros. 01:50:59

Entonces, las coordenadas globales de este objeto son 600, 600 y 90 grados en Z, ¿vale? Está girado 90 grados con respecto a la orientación global del mundo, ¿bien? ¿Se entiende eso? 01:50:59

fijaros, cuando yo selecciono el otro 01:51:18

lo que me está diciendo 01:51:21

es que sus coordenadas 01:51:23

son 100 01:51:27

simplemente 100, 0, 0 01:51:28

¿por qué? porque él tiene 01:51:31

100 centímetros con respecto 01:51:32

al padre, ¿vale? 01:51:35

si yo quisiera saber 01:51:37

cuáles son las del mundo 01:51:38

podría cambiarlo y me va a decir que son 01:51:40

600, 700, 0 01:51:43

tiene sentido, ¿no? 01:51:45

vale, entonces cuando 01:51:49

yo introduzco una variación de transformación en este objeto 01:51:51

como está dependiendo de otro, voy a tener en cuenta que sus 01:51:55

coordenadas tienen que ser estas. Luego, si yo me 01:51:59

duplico con Alt este dragón de aquí y yo le hago una modificación 01:52:04

de este estilo y me vengo aquí arriba y 01:52:08

cambio de coordenadas del mundo a coordenadas locales 01:52:15

las coordenadas locales son estas. ¿Se entiende? 01:52:18

se entiende que ahora han girado los ejes 01:52:24

y cuando yo giro, giro con respecto 01:52:28

a la última modificación 01:52:30

no a las del mundo, ¿bien? 01:52:32

se entiende 01:52:37

más o menos, coordenadas globales 01:52:38

coordenadas relativas y coordenadas locales 01:52:40

¿sí? 01:52:42

vale, pues esto es lo que nosotros vamos 01:52:44

a utilizar para desplazar objetos 01:52:46

¿vale? 01:52:48

entonces, me cargo este dragón 01:52:50

me lo cargo 01:52:52

voy a venir aquí 01:52:53

y le voy a cambiar el material a este para identificarlo un poquito mejor, ¿vale? 01:52:55

Me vengo al material que ya tiene, que es este, botón derecho y me creo una instancia. 01:53:01

Y esa instancia se la aplico a este de aquí. 01:53:07

Y básicamente lo que voy a hacer es cambiarle los colores. 01:53:10

Porque si no, va a ser más difícil de ver. 01:53:13

Le digo que esto sea azul y que esto sea morado, por ejemplo, ¿vale? 01:53:16

y ya tenemos un dragón marroncito que es el padre y un dragón azul que es el hijo, ¿vale? 01:53:22

Perfecto, entonces, fijaros, yo ahora me vengo a mi Level Blueprint 01:53:29

y me traigo una referencia del dragón padre, de este, botón derecho, Create, Reference, perfecto. 01:53:36

¿Qué es lo que tengo que hacer yo aquí ahora? 01:53:55

Pues tengo que tirar de aquí y buscar un nodo que se llama set location, set location, set, set, set, set, tengo varios, ¿vale? 01:53:57

Set, ¿veis que? Yo aquí tengo set world location, set relative location y también tengo lo que se llama add actor local offset. 01:54:13

aquí se están viendo las tres tipologías de coordenada 01:54:22

que os comentaba, la global, la del mundo 01:54:25

la relativa que es con respecto al padre 01:54:28

y la local que es con respecto 01:54:32

a la última modificación de transformación que haya sufrido el objeto 01:54:34

¿vale? entonces yo ahora mismo lo que quiero 01:54:37

meterle es un set world 01:54:40

location ¿vale? 01:54:44

perfecto, entonces 01:54:46

el set world location fijaros 01:54:49

lo que me está pidiendo es una nueva localización X y Z con respecto al mundo, ¿vale? 01:54:51

Entonces, si yo quisiera, por ejemplo, que este dragón se moviera a este punto, 01:54:59

que este punto es el punto 600, 500, 0, tendría que venir aquí y decirle, vale, 01:55:05

quiero que cuando algo pase esto se vaya al 600, 500, 0. 01:55:18

¿Vale? Entonces vamos a sacar un evento de teclado también. 01:55:25

La U. 01:55:30

Entonces le doy U espacio keyboard. 01:55:31

Y yo quiero que cuando pulse la U, este dragón se mueva a estas coordenadas. 01:55:36

¿Vale? 01:55:43

Así de sencillo. 01:55:44

Compilamos. 01:55:46

Si yo le doy al play, estoy aquí. 01:55:48

Ahí están mis dragones. 01:55:52

si yo le doy a la U 01:55:53

no me hace ni caso 01:55:55

¿por qué no me está haciendo ni caso? 01:55:58

vale 01:56:01

para que los objetos se muevan 01:56:01

hay que cambiarle la movilidad a movible 01:56:05

si están estáticos no funcionan 01:56:07

¿vale? 01:56:08

entonces este objeto tiene que estar en movible 01:56:09

y este objeto también tiene que estar en movible 01:56:11

¿vale? 01:56:15

ahora 01:56:18

le doy al play 01:56:19

estoy jugando 01:56:20

si yo le doy a la U 01:56:21

ves que cambia de posición 01:56:24

¿no? 01:56:26

vale, pero y si yo quisiera 01:56:28

que después de eso 01:56:30

se moviera a otra 01:56:31

localización, ¿cómo podría hacerlo? 01:56:33

con el flip flop 01:56:37

vengo aquí al open level blueprint 01:56:38

y le digo, vale, yo quiero que la primera 01:56:42

vez que le dé pase una cosa, pero que la segunda 01:56:44

pase otra 01:56:46

pues venga 01:56:47

entonces, me saco un flip flop 01:56:49

este no, perdón 01:56:52

Click, flop, este de aquí, conecto esto aquí, voy un poco rápido, pero es que no tengo mucho tiempo para contaros esto. 01:56:58

Entonces, la primera vez me lo mueves aquí y la segunda me lo mueves a otra ubicación, control C, control V. 01:57:12

Y ahora quiero que en lugar de a 600 me lo muevas al 300 en I, ¿vale? 01:57:18

y compilamos, me dice 01:57:29

hay un error, ¿qué es lo que falta? 01:57:31

que le conecte el target, no sé 01:57:33

qué actor es el que tengo que mover 01:57:35

lo conectamos 01:57:37

compilo y salvo 01:57:39

entonces le doy al play 01:57:41

la primera vez que le doy al AU se mueve ahí 01:57:43

la segunda vez que le doy al AU se mueve aquí 01:57:47

si le doy otra vez, como es un flip-flop 01:57:50

se mueve aquí, ¿vale? 01:57:52

se ve, ¿no? 01:57:55

lo que está pasando 01:57:56

si nosotros dejamos la ventana abierta 01:57:57

y ponemos aquí que queremos 01:57:59

debuguear este mapa 01:58:02

lo puedo ver 01:58:04

en tiempo real, le doy al play 01:58:07

y lo que pasa es que 01:58:09

cuando le doy al lado una vez 01:58:11

se mueve a ese punto y la segunda vez 01:58:13

se mueve a ese punto y la primera vez 01:58:15

se mueve al anterior 01:58:18

¿se ve chicos? 01:58:19

¿lo que está pasando? 01:58:22

si 01:58:24

esto con respecto a las 01:58:24

coordenadas globales 01:58:28

Si yo lo que quisiera es tocar las coordenadas relativas, tendría que venir aquí, traerme un objeto que tenga coordenadas relativas, que es el child, botón derecho, me crea una referencia y le digo que lo que quiero hacer ahora es setRelativeLocation, por ejemplo. 01:58:29

¿Vale? Perfecto. Entonces aquí 01:58:53

las coordenadas que yo le meta aquí tienen que ser con respecto al padre, no con respecto 01:59:00

al mundo. ¿Vale? Control-C, Control-V 01:59:04

conecto el target y me saco otra tecla 01:59:07

que puede ser la J, por ejemplo. J 01:59:12

espacio keyboard. Y me saco otro flip-flop 01:59:16

Control-D. Control-D es igual que Control-C, Control-V 01:59:22

¿Vale? Pero más corto. Entonces, la primera vez yo quiero que esto se mueva, por ejemplo, para acá hasta aquí. Eso sería 100 menos 100. ¿Vale? Pues la primera vez quiero que esto sea 100 menos 100. 01:59:26

y la segunda vez quiero que esto sea 200 menos 300, por ejemplo, vale, la A pasa esto y la B pasa esto, y compilo, vale, entonces, si yo vengo aquí y le digo que lo quiero debuguear, 01:59:45

Lo que tendríamos es lo siguiente, me lo tengo que traer otra vez al mismo punto en el que estaba al principio, si yo le doy al play, con la U hacemos modificaciones con respecto al mundo y con la J hago modificaciones con respecto al parent, ¿vale? 02:00:10

bien 02:00:35

perfecto 02:00:37

pero 02:00:40

¿cómo podría hacer yo 02:00:41

para que 02:00:43

el dragón 02:00:43

girara 02:00:45

indefinidamente? 02:00:46

¿qué se os ocurre? 02:00:47

¿qué podríamos hacer? 02:00:48

¿pero al pulsar una tecla? 02:00:54

no 02:00:57

con otro tipo de evento 02:00:57

que os he contado 02:01:00

pero que todavía no he utilizado 02:01:01

el que se actualiza 02:01:02

en cada fotograma 02:01:06

eso es 02:01:07

el event tick 02:01:08

con el event tick 02:01:10

nosotros podríamos hacer 02:01:11

que en cada fotograma 02:01:12

le añadieramos 02:01:14

un grado 02:01:16

al giro, por ejemplo. 02:01:17

Vamos a hacerlo. 02:01:21

Si nosotros, por ejemplo, tenemos 02:01:23

el Dragon Parent y nos 02:01:25

sacamos el 02:01:28

Add 02:01:29

Local 02:01:30

Rotation 02:01:32

y le digo que 02:01:35

necesito el Event Tick 02:01:37

y que en Z quiero que 02:01:41

cada vez que 02:01:43

renderice un frame le añado un grado 02:01:45

al giro en Z 02:01:47

me traigo el event tick 02:01:48

que si no está aquí 02:01:51

me lo puedo sacar 02:01:52

botón derecho 02:01:54

tick, event tick 02:01:57

aquí está 02:02:00

pues yo conecto esto 02:02:01

entiendo que solo puede haber uno 02:02:04

en 02:02:06

solo puede haber uno 02:02:07

exacto 02:02:11

compilamos 02:02:12

y vemos que pasa 02:02:14

fijaros que el event tick está todo el rato lanzando ejecuciones, todo el rato, si yo le doy al play, el parent gira, ¿vale? 02:02:16

Entonces el resto funcionan igual, con la U yo cambio las transformaciones y con la J cambio la transformación relativa, ¿vale? 02:02:28

Pero mientras tanto, mi dragón sigue girando, ¿vale? 02:02:41

Uy, me he subido encima de un dragón, sin querer. 02:02:47

Bueno, no pasa nada, me puedo bajar. 02:02:51

Vale. 02:02:55

Sí, pregunta, a lo mejor lo vas a explicar ahora, pero le has dicho que cambie, ¿cuánto? ¿un grado? 02:02:57

Un grado en cada frame, sí. 02:03:03

Claro, y esto supongo que será igual que en Unity, no podemos depender del número de fotogramas, 02:03:05

pero claro, son 360 grados 02:03:09

un grado por fotograma 02:03:11

a 60 fotogramas por segundo 02:03:13

estamos hablando de 60 grados por segundo 02:03:15

pero no podemos 02:03:17

depender de la velocidad de fotogramas 02:03:19

por segundo 02:03:21

por eso mismo 02:03:22

tendríamos que hacer 02:03:25

una traducción 02:03:27

a delta seconds 02:03:29

¿vale? 02:03:30

claro, lo que pasa es que eso ya es 02:03:33

un pelín más complejo 02:03:35

si quiero dejarlo ahí 02:03:36

Unity es el time delta time pero es el mismo concepto 02:03:39

es el mismo concepto 02:03:41

por eso mismo el event tick 02:03:43

te permite sacar este dato 02:03:45

de información para que nosotros podamos controlar 02:03:47

exactamente cuanto gira porque si no 02:03:49

lo que dice Álvaro 02:03:51

menudo lío 02:03:52

vale entonces 02:03:54

si yo además de que gire 02:03:56

quiero que suba 02:03:58

hacia arriba le podría decir 02:04:01

que 02:04:03

le quiero dar un add 02:04:04

local 02:04:07

offset. ¿Vale? 02:04:08

Un desplazamiento. 02:04:12

Y si lo conecto aquí, se va a estar actualizando 02:04:14

en cada frame. ¿Cuánto quiero que suba? 02:04:16

Pues le puedo dar a lo mejor 02:04:19

un centímetro 02:04:20

en cada frame. ¿Vale? Vamos a ver qué pasa. 02:04:21

Yo le doy al play 02:04:27

y de repente 02:04:28

mis dragones se me van para arriba. 02:04:29

¿Vale? 02:04:32

Y esto 02:04:34

me 02:04:35

Y esto me lleva a explicaros el concepto de variable. 02:04:36

Y si yo quisiera volver al estado inicial del dragón, ¿cómo podría hacerlo? 02:04:44

Esto es como cuando yo coloco una taza de café en la mesa, la muevo y quiero volver a ponerla exactamente en la misma posición. 02:04:50

¿Cómo podríamos hacer eso? 02:04:57

¿Qué se os ocurre? 02:05:02

tendríamos que almacenar la información 02:05:02

de posición inicial cuando yo le doy al play 02:05:11

para luego poder acceder a ella y replicarla 02:05:15

y eso es una variable, ese es el concepto de variable 02:05:17

las variables son contenedores de información que nosotros podemos 02:05:22

o cambiar o almacenar para poder consultarla 02:05:26

entonces si nosotros nos creamos una variable 02:05:30

aquí le damos al más y yo lo llamo posición inicial dragón, dragón, parent, tienen que ser nombres que nos ayuden, si yo a esta variable la llamo 002, pasado mañana ya no sé qué información está almacenando, 02:05:34

¿Vale? Tienen que ser nombres que sean lógicos. Entonces, ¿qué tipología de variable? Fijaros que cuando yo abro esto, aquí tengo un montón de tipos de información diferente. Yo la información que necesito es la posición y la posición es un vector. X, Y, Z. ¿Vale? 02:05:55

Entonces le doy naturaleza de vector y ¿qué es lo que necesito? Almacenarla cuando le doy al play, ¿no? Por lo cual yo podría coger el dragón parent, control D, me duplico la referencia y hago uso de un nodo que se llama get actor. 02:06:11

GetActorLocation, ¿vale? Con esto lo que voy a hacer es tener acceso a la posición del actor, ¿vale? Pero ¿cuándo? Cuando le doy al play. 02:06:42

Entonces, yo tendría que venir a ver dónde está todo esto, GetActorLocation, y coger mi variable, arrastrarla a la escena y decir que la quiero establecer. 02:06:54

establecer, veis que cuando yo tiro de una 02:07:08

variable y la arrastro a la escena puedo hacer get 02:07:10

o set 02:07:12

el set sirve para cambiar 02:07:12

y el get sirve para 02:07:15

consultar información 02:07:17

entonces yo ahora quiero establecerla 02:07:19

quiero establecer 02:07:22

la posición actual del 02:07:24

actor cuando 02:07:26

cuando le doy al play, entonces el play 02:07:27

viene por aquí 02:07:30

y se enchufa por aquí 02:07:30

entonces cuando yo le doy al play 02:07:33

me guardo la localización del actor 02:07:35

y cuando yo 02:07:38

le doy 02:07:40

a ver, ¿cómo hacemos esto? 02:07:42

¿cómo hacemos esto? 02:07:46

esto está rotando 02:07:48

y está moviéndose 02:07:49

entonces yo me tendría que hacer otra variable 02:07:51

que sea la rotación original del actor 02:07:53

¿vale? 02:07:55

entonces, eso es otro vector 02:07:57

fijaros 02:07:59

la información de la rotación es esta 02:08:02

Entonces, ¿yo qué es lo que tengo que hacer? Tendría que establecer también una variable que fuese la rotación inicial DragonParent. 02:08:06

dragon parent, voy a escribirlo bien, y esta tiene que ser, tiene que ser, tiene que ser un rotator, ¿vale? 02:08:31

La información en este caso es un rotator, porque en lugar de ser números son grados, ¿vale? 02:08:46

Y compilamos. Entonces de aquí lo que voy a hacer es sacarme un get actor, actor rotation, actor rotation y ejecutarlo con un set. Voy a establecer esa posición inicial cuando le demos al play. 02:08:51

aquí 02:09:15

bien 02:09:18

con esto ya tenemos almacenada la posición y la rotación 02:09:20

cuando le damos al play 02:09:23

perdón por la pregunta 02:09:25

pero la variable de tipo rotator 02:09:27

es un quaternion 02:09:29

no sé lo que es un quaternion 02:09:30

vale, nadie sabe lo que es un quaternion 02:09:33

vale, vale, pues nada 02:09:35

perdón antes de hacerla, muy bien 02:09:36

no he dicho nada 02:09:38

vale, fijaros, cuando yo tengo 02:09:39

nodos de este tipo 02:09:42

y tengo aquí las tres coordenadas, 02:09:44

yo siempre puedo hacer un botón derecho, 02:09:47

split, struct, pin. 02:09:50

¿Para qué? 02:09:52

Para que me permita meter información 02:09:52

de uno solo de los ejes. 02:09:54

¿Vale? 02:09:56

Igual que aquí. 02:09:57

Botón derecho, split, struct, pin. 02:09:58

Entonces yo podría variar solamente 02:10:00

lo que está cambiando. 02:10:03

¿Vale? 02:10:05

Si quisiera. 02:10:07

¿Vale? 02:10:09

Entonces, ¿qué es lo que podría hacer yo ahora? 02:10:10

Pues que el EventDict pase por un flip-flop, ¿vale? 02:10:14

En el cual, a ver, no, no, no, no, esto no me gusta. 02:10:24

A ver, un momentito, voy a mirar la chuleta, que me hice aquí una comprobación el otro día, ¿vale? 02:10:42

con la rotación 02:10:51

nosotros tenemos 02:10:55

el dragón 02:11:10

rotando y yo lo que 02:11:13

quiero es que cuando le de 02:11:15

a una tecla 02:11:16

recupere 02:11:22

su posición 02:11:24

original, que la tengo almacenada 02:11:26

aquí, entonces yo lo que me 02:11:28

tengo que sacar ahora es 02:11:30

esa variable 02:11:32

esa variable con un get 02:11:33

¿Vale? Tengo que obtener esa información tanto de posición como de rotación. ¿Vale? Me la saco aquí con un get. ¿Vale? Y yo lo que quiero es que cada vez que yo pulse una tecla, por ejemplo la P, P keyboard, me la enchufo aquí, la primera vez le vamos a decir set rotation y set location. 02:11:37

¿Vale? 02:12:17

Tenemos que hacer, sacando de aquí, un set actor. 02:12:19

No, esto no es un actor. 02:12:32

El actor es este. 02:12:34

Vale. 02:12:36

Entonces, vamos a hacer una cosa. 02:12:36

Vamos a hacer una cosa. 02:12:38

Vamos a hacer una cosa. 02:12:42

La rotación. 02:12:43

Me estoy liando con esto un poquito. 02:12:47

A ver. 02:12:50

Esto está rotando todo el rato. 02:12:52

le estamos metiendo un grado y un centímetro 02:12:54

y yo lo que quiero es devolverlo 02:12:57

pero esto añade, ¿vale? 02:12:59

le estamos añadiendo grados 02:13:00

y añadiendo 02:13:02

y añadiendo 02:13:03

desfase de posición 02:13:06

con lo cual yo lo que tengo que hacer ahora es 02:13:09

establecer, ¿vale? 02:13:11

entonces 02:13:13

cogemos el actor 02:13:14

que es este 02:13:16

y le digo set 02:13:17

actor location 02:13:19

Actor 02:13:21

Location 02:13:24

Y también necesito un 02:13:26

Set Actor Rotation 02:13:28

Set 02:13:30

Actor 02:13:32

Rotation 02:13:34

Rotation 02:13:35

Pero claro, este de aquí 02:13:37

Sería la posición 02:13:46

Inicial 02:13:48

Y este de aquí sería la 02:13:48

Rotación inicial 02:13:51

Que tiene el actor 02:13:53

entonces 02:13:55

una pregunta 02:13:56

aquí no sería necesario 02:13:57

flip flop 02:13:59

¿no? 02:13:59

solo lo que es hacer una vez 02:14:00

claro 02:14:01

ahora de momento no haría 02:14:02

pero yo 02:14:03

a mí lo que me gustaría 02:14:03

es crear 02:14:04

una variable 02:14:05

que establezca 02:14:07

si el objeto 02:14:08

está en movimiento 02:14:09

o no 02:14:09

¿vale? 02:14:10

entonces 02:14:12

para eso 02:14:13

es necesario 02:14:14

crear una variable 02:14:16

que se llama 02:14:18

isDragonParent 02:14:20

moving 02:14:26

y le pongo también 02:14:27

una interrogación. 02:14:29

Esta tipología tiene que ser 02:14:32

de tipo booleano, porque solo la respuesta 02:14:33

solo puede ser sí o no. 02:14:36

¿Vale? Entonces, ¿cómo funciona 02:14:38

esto? Para esto 02:14:40

necesito 02:14:41

crear un branch. 02:14:43

¿Vale? El branch 02:14:46

es el equivalente a un if en 02:14:47

programación. 02:14:50

Branch. ¿Vale? 02:14:52

Entonces, 02:14:54

Lo que va a pasar aquí es que yo voy a tener en el true esto de aquí. 02:14:55

A ver, ¿cómo era? 02:15:06

Set actor location, set actor rotation. 02:15:08

Uf, me estoy liando un montón. 02:15:12

A ver si me acuerdo. 02:15:14

Yo necesito meterle aquí una condición y que esa condición esté controlada por esta variable. 02:15:19

Tengo que traer el get. 02:15:27

Vale. 02:15:29

¿Vale? Entonces el true o false yo lo voy a controlar con esta variable, con lo cual cada vez que yo le dé a este botón solo va a ser true cuando esta condición esté en true y cada vez que yo le dé a este botón solo va a ser false cuando esta condición esté en false. 02:15:30

Nosotros, cuando le damos a compilar, podemos seleccionar cualquier variable y establecer un estado inicial también, ¿vale? 02:15:51

Entonces, de primeras, lo que le damos a decir es que queremos establecer esta rotación y esta posición, ¿vale? 02:15:59

Ahí. 02:16:15

Vale. 02:16:18

¿Esto sirve de algo? 02:16:20

creo que no 02:16:21

a ver un momento, voy a hacer una prueba rápida 02:16:23

voy a eliminar esto 02:16:25

para ver si funciona 02:16:30

lo de la posición inicial 02:16:33

esto está rotando 02:16:34

a su rollo y yo de repente le doy a este botón 02:16:37

y debería de bajar 02:16:39

vale 02:16:42

vamos a hacer una prueba 02:16:44

a la P 02:16:46

le damos al play, esto sube 02:16:48

si yo le doy a la P, baja 02:16:52

vale, funciona 02:16:54

además veis que recupera 02:16:56

la posición y la rotación 02:16:59

vale 02:17:01

perfecto 02:17:02

bien 02:17:06

esto funciona 02:17:06

entonces yo para qué quería 02:17:08

hacer lo del branch 02:17:11

claro porque el branch 02:17:12

al final 02:17:15

lo que hace es replicar 02:17:15

el comportamiento 02:17:16

de un flip flop 02:17:17

pero 02:17:18

con cierto grado de control 02:17:19

vale 02:17:22

yo por ejemplo 02:17:23

pero esto ya es por 02:17:26

yo por ejemplo 02:17:27

lo que le haría es preguntarle si llega 02:17:28

a dos metros, vuelve a la posición inicial 02:17:30

que es un poco como 02:17:32

podrías hacerlo por programación, que es claro 02:17:33

yo lo he trasladado todo al código 02:17:36

si tu posición 02:17:37

actual es mayor de 02:17:39

dos metros en Z 02:17:42

pues vuelve a tu posición inicial 02:17:44

con lo cual estaría subiendo 02:17:46

y volviendo al inicio constantemente 02:17:47

claro, es que nosotros luego 02:17:49

tenemos nodos matemáticos que nos permiten 02:17:52

establecer si un valor es mayor que 02:17:54

o menor que 02:17:56

o mayor o igual, cosas así 02:17:57

que nos permitan hacer ese tipo de operaciones 02:18:00

pero vamos, eso se lo dejamos al programador 02:18:02

no te preocupes 02:18:04

entonces, lo que yo os quería contar 02:18:05

ahora, es como poder operar 02:18:08

todo el tema este de las pantallas 02:18:10

que hemos hecho antes, entonces, por ejemplo 02:18:11

si yo 02:18:14

vengo aquí 02:18:16

y me creo un planito 02:18:17

me creo un planito 02:18:19

os voy a contar como animar un objeto 02:18:24

sin necesidad de sequencer, vale 02:18:26

Si yo me traigo aquí un plan, le doy la vuelta, lo subo, le voy a dar escala 0.9, 1.6, para que sea 16.9, ¿vale? 02:18:28

Tenemos esto. 02:18:47

Entonces, si yo lo que quiero hacer es que esto sea una pantalla que suba y que baje, 02:18:49

Lo podría hacer con un Sequencer y lanzarlo como hemos visto en el otro proyecto o lo podríamos mover con un Timeline, ¿vale? Fijaros, ahora me traigo una, esto lo vamos a llamar Screen, Screen, ¿vale? Y esto nos lo vamos a traer como referencia a nuestro Level Blueprint, aquí. 02:18:54

Y entonces, botón derecho, Create Reference. Perfecto. Con lo cual, ¿yo qué es lo que quiero? Quiero establecer Set Location. ¿Vale? Set Actor Location, por ejemplo. 02:19:19

Entonces, ¿cuál es la posición inicial que yo necesito? 02:19:43

La posición inicial que yo necesito es que la pantalla no se vea, ¿no? 02:19:47

Yo quiero que cuando arranque, la pantalla esté aquí, ¿vale? 02:19:55

Y eso es esta de aquí, ¿vale? 02:19:59

¿Qué pasa? 02:20:03

Que nosotros, dentro de Blueprints, tenemos un Lerp también. 02:20:04

Nosotros podríamos establecer una interpolación entre una localización y otra. 02:20:10

¿Vale? Entonces, ¿cómo lo podríamos hacer? Pues, por ejemplo, podríamos sacarnos una variable que fuese la localización de la pantalla, ¿vale? Por ejemplo, una forma muy rápida de hacerte una variable es coger uno de los pines de información, ¿vale? Y decirle botón derecho, promote tu variable, ¿vale? 02:20:16

Esto podría ser la variable de posición de mi pantalla. 02:20:44

Entonces, yo la llamo así, la nombro así. 02:20:50

Y veis que automáticamente ya me pone la naturaleza de información que necesita. 02:20:52

Esto lo llamamos screen position. 02:20:57

Screen position. 02:21:01

Entonces, ¿qué posición necesito yo al principio? 02:21:04

Esta, ¿vale? 02:21:08

Con lo cual, podría venir y decirle, vale, 02:21:09

pues vamos a hacer un set 02:21:12

de esta variable en el begin play 02:21:14

que tenga esas coordenadas 02:21:16

¿vale? viene por aquí 02:21:18

el begin play 02:21:20

si no quieres estar todo el rato 02:21:21

siguiendo la dirección 02:21:24

del begin play tenemos otro nodo 02:21:26

que se llama sequence que me permite 02:21:28

hacer cosas en paralelo 02:21:31

entonces yo podría 02:21:33

venir aquí, conectar 02:21:34

esto y que por aquí arriba 02:21:36

pasase otra cosa en paralelo 02:21:38

Entonces podría venir ahí y decirle, vale, yo quiero establecer set screen position en estas coordenadas que es 1160, 770, 1160, 770 y la otra es menos 100. 02:21:40

menos 100. Entonces yo 02:22:12

hago play y coloco esta variable 02:22:15

ahí. Y como 02:22:18

esta variable 02:22:19

está generándose 02:22:20

en todo momento, 02:22:24

¿vale? 02:22:27

Ya la tengo aquí colocada. Entonces esto 02:22:27

es lo que 02:22:29

yo hago al darle al play. ¿Vale? 02:22:31

Y ahora, 02:22:33

¿qué es lo que necesito? Necesito 02:22:35

un nodo que me 02:22:40

permita hacer una interpolación. 02:22:42

¿Vale? 02:22:44

Yo necesito un nodo que me permita hacer una interpolación. ¿Entre qué y qué? Vamos a verlo. Ese nodo se llama Timeline. Timeline. Timeline. Timeline. Add Timeline. ¿Vale? 02:22:45

Y este timeline lo vamos a llamar, pues no lo sé, Screen Transition, Transition, Transition, Transition, ¿vale? Perfecto. 02:23:04

Entonces, ¿yo qué es lo que voy a hacer con esto? Pues fijaros, tengo que entrar dentro, ¿vale? 02:23:22

Le voy a decir, entro dentro y dentro, ¿veis que yo puedo ir y venir del timeline? Yo me tengo que crear un track y este track va a ser un float, ¿vale? La longitud de este float va a ser de un segundo, por ejemplo, ¿vale? Uno, ¿vale? 02:23:30

cero. 02:24:00

Ahora me creo otro, botón derecho, 02:24:02

y a este le digo que esté en el 1, 02:24:07

1, ¿vale? 02:24:10

Y tengo esto, tengo una curva que va de 0 a 1 en un segundo, ¿vale? 02:24:13

Perfecto. 02:24:18

Entonces, esa información, 02:24:20

esa información yo se la tengo que meter a un lerp, ¿vale? 02:24:21

Entonces, 02:24:31

¿Qué es lo que necesito? 02:24:31

Un lerp que sirva para introducir 02:24:35

información de vector. 02:24:37

Este play, o sea, cuando yo lanzo 02:24:41

esta transición entre 0 y 1, lo puedo poner con una tecla. 02:24:43

Por ejemplo, p espacio keyboard. 02:24:46

Keyboard. 02:24:50

Esta, por ejemplo. Entonces, cuando yo le dé, 02:24:53

hace play entre 0 y 1 en un segundo. 02:24:56

Entonces, ahora, yo me saco un lerp 02:24:59

Un ler de transformación de vectores, ¿vale? 02:25:03

Y esta información es la que le va a entrar al setActorLocation, ¿vale? 02:25:08

Perfecto. 02:25:14

Entonces, el alfa de este ler tiene que ser la información del timeline. 02:25:17

Y el A y el B tienen que ser el punto inicial y el punto final de ese actor, ¿vale? 02:25:22

Y esto se tiene que estar ejecutando en todo momento. 02:25:28

¿Vale? A ver, a ver, a ver, un momentito. El event tick, este de aquí, ¿vale? Tiene que estar comprobando en todo momento si esto cambia. Cuando esto empieza a cambiar es cuando se mueve, ¿vale? ¿Se entiende esto más o menos, chicos, lo que estoy haciendo? ¿Bien? Esto es un poco más lioso ya, ¿no? 02:25:33

que lo del principio 02:26:02

bueno vamos a probar a ver si funciona 02:26:05

realmente esto tampoco se utiliza tanto 02:26:06

porque normalmente nosotros siempre animamos 02:26:08

con el sequencer y lo lanzamos directamente 02:26:10

con el sequencer que lo podríamos hacer también 02:26:12

vale entonces la posición 02:26:14

inicial cual es esta de aquí 02:26:16

vale vamos a meterle 02:26:18

que pase del punto A 02:26:20

que es 1160 02:26:22

770 02:26:24

menos 02:26:26

100 al 02:26:28

pues vamos a ver 02:26:32

solamente habrá que subirlo en Z 02:26:34

aquí por ejemplo 02:26:36

que sería 120 02:26:38

vale 02:26:39

1160 02:26:40

700 02:26:45

y 120 02:26:46

por ejemplo 02:26:50

compilamos 02:26:51

y vemos lo que pasa 02:26:53

cuando yo le doy a la P 02:26:55

se debería adelantar 02:26:57

ah no, perdón 02:26:59

no tiene que estar conectado con el 02:27:01

con el event 02:27:03

tiene que estar conectado con el update 02:27:04

del timeline, ¿vale? Cuando el timeline 02:27:07

se actualiza es cuando esto 02:27:10

se ejecuta, ¿vale? Es así 02:27:12

como tiene que estar, ¿vale? 02:27:14

Evidentemente con un 02:27:18

timeline yo me puedo crear diferentes 02:27:19

tracks, ¿vale? 02:27:21

Y utilizar esto para diferentes cosas, 02:27:23

¿vale? No tiene por qué ser solo una. 02:27:25

Entonces, compilo, 02:27:28

salvo, y vemos 02:27:30

lo que pasa. 02:27:31

Yo me vengo por aquí, esto va a ir a su rollo, 02:27:33

y si yo le doy a la P, 02:27:35

no, es la P 02:27:37

vale, la movilidad está puesta como está aquí 02:27:38

va a pasar lo mismo que con el dragón 02:27:41

le tengo que decir que se mueva 02:27:43

vale 02:27:45

entonces, comprobamos 02:27:48

comprobamos 02:27:51

que la P 02:27:53

es la que hace de trigger 02:27:56

de toda esta cadena 02:27:58

lo pongo aquí para que veamos el 02:27:59

para que veamos el 02:28:03

el proceso 02:28:07

y si yo le doy al play 02:28:09

le doy a la P 02:28:14

ahí lo tenemos 02:28:16

claro 02:28:18

pero yo quiero 02:28:19

que haga 02:28:20

este recorrido 02:28:21

de ida 02:28:22

y el recorrido 02:28:22

inverso 02:28:24

de vuelta 02:28:25

a ver cómo se puede hacer eso 02:28:27

cómo se puede hacer eso 02:28:28

tendría que 02:28:32

coger este mismo nodo 02:28:35

control C 02:28:38

control V 02:28:40

cambiarle este valor 02:28:41

120 02:28:44

menos 100 02:28:45

sacar esto 02:28:48

y uff 02:28:52

no, esto es más complejo de lo que parece 02:28:57

el alfa tendría que ser el mismo 02:29:00

y cuando se tendría que ejecutar esto 02:29:04

play 02:29:08

ah bueno, le puedo dar un reverse 02:29:09

aquí, estoy idiota 02:29:12

claro, pero para eso necesito un flip flop 02:29:14

flip flop 02:29:17

La primera vez me ejecuta el play y la segunda vez me ejecuta el play reverse, ¿vale? 02:29:20

Y además tendría que poner este elemento de primeras aquí abajo que no se viera, ¿vale? 02:29:26

Salvamos, le doy al play y cuando yo le doy a la P aparece y desaparece. 02:29:36

Además veis que la P es también la que devolvía el dragón a su posición inicial, ¿vale? 02:29:44

Bien, ¿se entiende más o menos? Vale, pues vamos a ver cómo se haría esto con la secuencia, que es lo mismo que hemos dejado programado en nuestro proyecto de set virtual, ¿vale? 02:29:49

Nos venimos aquí, nos creamos una secuencia, Cinematic Level Sequence, lo llamamos LS barra baja, Screen, Screen, ahí estamos, doble clic, me traigo la referencia de este actor, 02:30:02

le decimos que queremos funcionar en 24 frames por segundo 02:30:24

que la posición inicial de transformación sea esta 02:30:31

con un intro para que me cree los keyframes 02:30:34

activamos el auto key 02:30:37

me voy a 24 frames 02:30:40

le digo que esto es el final de la animación 02:30:45

y que lo que yo quiero es que esto suba para acá 02:30:48

¿vale? 02:30:52

hasta aquí 02:30:53

más o menos, vale, entonces lo que tenemos es play y play reverse, perfecto, entonces, bueno la parte de curvas creo que nos la he contado, verdad, os suena que hayamos hablado de curvas dentro del sequencer, vale, bueno pues os hago una pequeña introducción a curvas para que sepáis donde está, si queremos tocar las curvas de cualquier keyframe que hayamos creado tenemos que darle a este botoncito, vale, 02:30:54

esto nos abre 02:31:24

un editor de curvas 02:31:26

básicamente entonces que es lo único que está animado 02:31:30

en esta malla el eje Z 02:31:32

si yo vengo aquí 02:31:33

y me voy a localización eje Z 02:31:35

veis se me filtra 02:31:38

entonces yo lo que 02:31:39

quiero aquí es que estos dos 02:31:42

no tengan esta curva de animación 02:31:44

sino que al principio vaya más rápido 02:31:46

y que luego vaya decelerando 02:31:48

vale 02:31:50

entonces para hacer 02:31:51

es muy sencillo. Seleccionamos los dos keyframes, les decimos que queremos que sean keyframes 02:31:54

asimétricos, selecciono uno y lo subo. ¿Vale? Sería algo así. También podemos hacer zoom 02:32:01

en la selección. Si selecciono dos keyframes y le damos a este botoncito, ¿veis? Nos hace 02:32:13

zoom solamente en esos keyframes que están seleccionados. ¿Vale? Entonces, si yo quisiese 02:32:17

que la deceleración 02:32:23

fuese más pronunciada 02:32:24

en esta zona 02:32:26

podría coger 02:32:26

este 02:32:27

este controlador 02:32:28

y moverlo 02:32:30

¿vale? 02:32:31

si me quiero mover 02:32:32

en horizontal 02:32:33

o en vertical 02:32:34

pulso shift 02:32:35

¿vale? 02:32:37

y además 02:32:39

así 02:32:40

lo que hacemos es 02:32:40

jugar con la tangente 02:32:41

¿vale? 02:32:42

entonces 02:32:43

este de aquí 02:32:44

lo podría subir 02:32:45

un poquito más 02:32:46

y ya tendríamos eso 02:32:47

con lo cual 02:32:48

si me vengo 02:32:49

al principio de la animación 02:32:50

tengo esto 02:32:51

y ves que hace como una deceleración 02:32:52

cuando llega, ¿no? 02:32:55

Play, reverse 02:32:58

y play. 02:32:59

Vale, pues si yo quisiera operar esto, 02:33:02

si yo quisiera operar esto desde Blueprints, 02:33:04

lo que tendría que hacer es 02:33:08

sacar un actor, ¿vale? 02:33:10

Sacar la secuencia escena, 02:33:13

traerme una referencia al level Blueprint, 02:33:16

traerme una referencia al level Blueprint, 02:33:21

esta parte la voy a desconectar vale con la con la secuencia como actor seleccionada me 02:33:22

traigo una referencia con botón derecho me saco el play esto lo que hemos hecho en el 02:33:36

proyecto del set antes y me saco el play river play rivers tienen que salir del 02:33:45

componente lógicamente y me pongo aquí un flip flop vale ahí estamos 02:33:56

Perfecto. Con la A lo saco y con la B lo oculto, ¿vale? Con la P le doy al play y con la P sale y con la P se retira, ¿vale? 02:34:04

¿Pero qué está pasando? Aquí hay una cosa que os tengo que contar, que es importante. Es que el elemento, cuando nosotros lo animamos, tiene un parámetro que es el que define qué pasa con ese objeto cuando ha terminado la animación. 02:34:20

Entonces, para que la animación mantenga el estado final que le hemos dado, se lo tenemos que especificar. 02:34:38

Botón derecho, propiedades, y veis que aquí tiene una opción que se llama when finished, cuando acaba. 02:34:45

Pues cuando acaba le tenemos que decir que mantenga el estado, porque si no, está reapareciendo todo el rato, cada vez que le damos al play. 02:34:52

¿vale? entonces 02:34:59

ahora que le hemos hecho eso 02:35:04

si le damos al play 02:35:06

bueno, lo que tengo que hacer es 02:35:07

cerrar esto 02:35:10

le doy al play 02:35:11

y cuando le doy al AP 02:35:13

aparece y cuando le doy al AP 02:35:15

desaparece ¿vale? 02:35:17

¿bien? ¿se entiende 02:35:20

más o menos chicos? 02:35:23

si 02:35:25

yo creo que estamos ya 02:35:26

los dragones 02:35:31

van por ahí arriba 02:35:33

si le doy a la P vuelve a su sitio 02:35:34

bueno 02:35:38

más o menos se entiende un poco 02:35:42

esto de los blueprints, es muy rápido 02:35:44

meteros esto en hora y media 02:35:46

es demasiado a lo mejor 02:35:47

pero bueno, sí que quería que 02:35:49

por lo menos tuvieseis una primera toma de contacto 02:35:52

con todo esto 02:35:55

para cuando tengáis que hacer cositas más complejas 02:35:56

por lo menos que os suene, y que si hacéis un tutorial 02:35:58

pues que os suenen un poco los conceptos 02:36:00

¿vale? 02:36:02

evidentemente, yo si tuviese 02:36:05

que hacer todas estas cosas, probablemente 02:36:06

no las haría en el Level Blueprint, me haría un 02:36:08

Blueprint Class, ¿vale? 02:36:10

Fijaros, si 02:36:13

yo, por ejemplo, me creo 02:36:14

un botón derecho, Blueprint 02:36:16

Class, y me 02:36:18

creo un actor vacío, ¿vale? Estas son 02:36:20

todas las tipologías que tenemos de Blueprint, 02:36:22

bueno, no todas, estas son las más comunes. 02:36:25

Aquí abajo las tenemos 02:36:27

todas, en el buscador, pero si yo me 02:36:28

quiero hacer un Blueprint sencillo, vacío, 02:36:30

que sea 02:36:33

un BP barra baja, 02:36:34

rotaping 02:36:36

rotaping 02:36:38

dragon 02:36:40

me lo crearía así 02:36:41

doble clic 02:36:47

se me abre 02:36:49

el blueprint class 02:36:50

que veis que también tiene un event graph 02:36:52

igual que el del blueprint 02:36:54

y yo lo que tendría que hacer básicamente aquí 02:36:55

es decirle 02:36:58

primero que quiero añadir un static mesh 02:36:59

a este blueprint 02:37:02

los blueprint nos sirven para hacer 02:37:06

elementos compuestos 02:37:08

¿Vale? Que tengan mallas, que tengan cámaras, etcétera, etcétera. Entonces, para mí esto va a ser el Dragon Mesh. ¿Vale? Y cuando lo tengo seleccionado, veis que yo aquí a la derecha tengo un slot para la malla. ¿Vale? Pues voy a seleccionarlo y lo meto aquí. ¿Vale? Lo metemos aquí. Ahí tengo el Dragon ya creado. 02:37:10

compilo y fijaros en el viewport 02:37:33

yo ya tengo un blueprint que tiene una malla 02:37:36

adentro y que esa malla es la malla 02:37:38

de un dragón, vale 02:37:40

entonces yo podría 02:37:42

venir aquí y decir 02:37:44

vale pues este va a ser mi rotating 02:37:46

dragon, es un blueprint 02:37:48

ya no es una malla, es una malla 02:37:50

que contiene un blueprint, perdón al revés 02:37:52

es un blueprint que contiene una malla 02:37:54

vale, entonces para 02:37:56

decirle yo a este dragón que rote 02:37:58

lo que tendría que hacer es venir al event graph 02:38:00

Sacarme una referencia de la malla y decirle que le quiero añadir a local rotation, ¿vale? 02:38:03

¿Cuánto? Pues no lo sé. 02:38:16

Vamos a establecerlo con una variable y lo conecto al event tick, ¿vale? 02:38:20

Lo conecto al event tick. 02:38:26

Veis que aquí en el delta rotation tengo los tres. 02:38:28

Los voy a desplegar. 02:38:30

botón derecho, split, struct pin y yo lo único que quiero tocar es la Z 02:38:32

¿vale? entonces si yo aquí me creo 02:38:37

una variable que sea 02:38:40

pues como la podríamos llamar 02:38:43

angle amount 02:38:48

de primeras compilo y le digo que el valor por defecto 02:38:55

será 0 para que no rote ¿vale? 02:39:02

de primeras 02:39:04

cero para que no rote 02:39:06

perfecto 02:39:09

entonces si yo 02:39:11

abro esto 02:39:15

fijaros 02:39:17

el dragón no está rotando 02:39:19

si yo pulso shift f1 02:39:21

me saca el ratón 02:39:23

y estando en play 02:39:25

yo podría venir aquí 02:39:26

y seleccionar 02:39:30

mi dragón 02:39:31

a ver donde está 02:39:33

rotatingDragon 02:39:34

¿dónde está? 02:39:36

¿dónde estás? 02:39:39

aquí está 02:39:39

rotatingDragon 02:39:40

vale 02:39:41

yo lo que quiero 02:39:41

es que esa variable 02:39:43

esté disponible 02:39:45

cuando yo esté 02:39:46

en el juego 02:39:47

¿cómo se hace eso? 02:39:48

me salgo del modo juego 02:39:50

me meto otra vez aquí 02:39:52

le digo que esta variable 02:39:55

quiero que se vea 02:39:56

¿vale? 02:39:57

eso se llama 02:40:00

hacer una variable 02:40:00

instanceEditable 02:40:02

¿por qué? 02:40:03

porque todas las instancias de este blueprint que estén en el nivel van a tener disponible ese parámetro. 02:40:04

Fijaros, ahora yo cuando lo selecciono tengo aquí un parámetro que se llama angle amount, ¿verdad? 02:40:13

Entonces, si a este le digo que tenga 1, a este le digo que tenga 5, a este le digo que tenga 0, como está, 02:40:19

y a este le digo que tenga 10, fijaros, salgo, le doy al play y cada uno está girando con una velocidad diferente, ¿vale? 02:40:27

Es la misma variable, pero como son instancias independientes, yo puedo cambiar ese valor, ¿vale? 02:40:39

¿Entiende? 02:40:46

Entonces, si yo ahora pulso Shift F1 para que me aparezca el ratón, yo podría elegir cualquiera de estas 02:40:48

y cambiarle ese valor, ¿vale? 02:40:57

Este que está girando, le digo que esté en 0 y se para, 02:41:02

o le digo que se ponga en 10 y gira más rápido. 02:41:05

Si le digo 50, pues se pone a girar como un loco, ¿vale? 02:41:08

¿Veis un poco la diferencia entre un Blueprint Class y el Level Blueprint? 02:41:14

Al final, lo bueno de esto es que yo tengo acceso a todas las variables 02:41:18

en cada instancia y además lo bueno de esto es que lo que yo programe 02:41:22

en el Blueprint Class me lo puedo llevar a otro proyecto 02:41:26

sin necesidad de migrarme 02:41:28

el nivel completo 02:41:30

¿Vale? ¿Se entiende 02:41:31

chicos? ¿Más o menos? 02:41:34

Hombre, yo sí 02:41:38

Bueno 02:41:39

Pues yo creo que más o menos 02:41:44

esto es lo que os quería contar de Blueprints 02:41:46

para que tengáis una idea aproximada porque al final 02:41:48

ya vais a ver que 02:41:50

las cosas 02:41:51

que se suelen parametrizar 02:41:54

para axiometría son cosas muy sencillas. 02:41:56

Suelen ser elementos que suben y bajan 02:41:58

o a lo mejor 02:42:00

la intensidad de una luz, 02:42:02

por ejemplo. 02:42:04

Si yo, por ejemplo, 02:42:06

o el color de una luz, 02:42:08

que ya lo hemos hecho, 02:42:10

eso es lo que se suele parametrizar 02:42:13

para axiometría. Y luego ya si se meten en cosas más 02:42:14

complejas, normalmente lo que suele haber es un programador 02:42:16

que te cree toda esa programación 02:42:18

y que luego tú tengas acceso a ella mediante 02:42:20

axiometría. De todas maneras, 02:42:22

si se os ocurren cosas 02:42:24

bizarras que programar, Rafa 02:42:26

probablemente tenga una solución 02:42:28

para eso. Él tampoco es programador, pero sí que le ha 02:42:30

tocado pelearse mucho con este tipo 02:42:32

de historias, ¿vale? 02:42:34

Así que bueno. 02:42:37

Yo creo que 02:42:40

lo vamos a dejar aquí 02:42:40

porque 02:42:41

no me quiero meter en más líos de 02:42:43

blueprints, que al final lo que va a hacer es liaros 02:42:46

más. Pero bueno, si me dices, Álvaro, que 02:42:48

más o menos se ven las correspondencias 02:42:50

con lo que hacéis en Unity, con eso me vale. 02:42:52

Sí, sí, sí. De hecho 02:42:57

es más intuitivo con los blue frames 02:42:58

en Unity hacen un lerp 02:43:01

es un dolor, y aquí ya he visto lo fácil que es 02:43:03

perfecto 02:43:05

los lerps se utilizan para todo 02:43:07

para hacer transiciones entre colores 02:43:09

entre posiciones, entre rotaciones 02:43:11

entre lo que sea, porque al final es 02:43:13

interpolación lineal 02:43:15

entre dos estados 02:43:17

muy bien chicos, pues nada, pues os subo 02:43:18

entonces el último proyecto 02:43:24

que teníamos a Drive 02:43:26

que es 02:43:28

este de aquí 02:43:29

bueno, os puedo subir los dos si queréis 02:43:31

así tenéis también el ejemplo de Blueprints 02:43:33

ya programado 02:43:35

y nada, con lo que sea 02:43:36

me decís 02:43:40

estoy a vuestra disposición 02:43:41

y si necesitáis algún 02:43:43

que miremos la posibilidad 02:43:45

de algún escenario 02:43:47

para la gente de cine o lo que sea, igual 02:43:49

me decís y lo hablamos 02:43:51

¿vale? 02:43:54

vale, vamos a ver 02:43:55

y nada, gracias por 02:43:56

soportar toda esta chapa 02:43:59

infame que os acabo de soltar 02:44:01

espero que os haya gustado el curso 02:44:02

y que sigáis 02:44:05

evolucionando en Anriado si es posible 02:44:06

gracias 02:44:08

habrá que volver sobre ello pero 02:44:10

por lo menos una idea la tenemos 02:44:12

muy bien 02:44:14

un placer 02:44:16

venga muchas gracias 02:44:18

adiós 02:44:20

adiós 02:44:22

Curso de Unreal para Aximmetry. Sesión 6 - Contenido educativo

Del mismo autor…

Vídeo cumpleaños

Vídeo Cumpleaños

Navidad 25-26

Cuentacuentos 25-26

Otoño 25-26

La selva 25-26

Halloween 25-26