Menú

Mostrar Mensajes

Esta sección te permite ver todos los mensajes escritos por este usuario. Ten en cuenta que sólo puedes ver los mensajes escritos en zonas a las que tienes acceso en este momento.

Mostrar Mensajes Menú

Mensajes - _davidlopez29

#1
Recursos / [TIPS] Unity Tips en una linea
Marzo 29, 2020, 01:36:10 PM
Cita de: francoe1 date=15849156911 - Verificar si un objecto es nullo mediante ? crea un objeto que indica si el valor es nulo o igual al default y el valor en si, esto genera una sobre carga de memoria por lo que usarlo dentro del Update generara bastante basura. Lo mejor es utilizar el simple flag de siempre en casos de constanste actualización y hacerlo con "is null" if (obj is null) o if (!(obj is null)). Sin embargo esta aplicación tiene sentido en Eventos donde los registros pueden contener una referencia nulas.
   
   
      2 - Los String con Format complex utilizando "$" son mucho mas complicados para el CLR, costosa, y con mayor cantidad de memoria derrochada, que la simple concatenación. Para crear String lo mejor es utilizar StringBuilder. Sin embargo, para realizar la concatenación esto es mas practico y simple, anteriormente se utilizar String.Format que tenia un costo mayor y era bastante menos practico.
   
   
      ¡En resumen, estos tips son para practicidad sacrificando rendmiento y recursos!
   
   
      Los otros me parecen bien, esta bueno tener estos tips de forma sintetica, y que cada cual busque por su cuenta el ¿POR QUE? - 
   


Como dices, tienes razón en el punto 1, esto es muy útil sobre todo en eventos o debugs rapidos, en el resto de casos supone un sobrecoste de comprobación de nulidad. En el segundo caso es sobre todo útil para debugs que no serán compilados (de hecho en los ejemplos que pongo los uso de esta manera). Pero es bueno tu aporte, muchas gracias! :) 
#2
En esta entrada vamos a aprender a crear nuestro primer shader Vertex/Fragment en Unity. Iremos paso a paso hasta terminar creando nuestra propia bandera con ondulación:
 



 


Requisitos



Para crear este proyecto podemos usar cualquier versión de Unity 2018/2019/2020 siempre y cuando a la hora de crear el proyecto usemos la plantilla de 3D (Built-in Render Pipeline)
 


Antes de pasar al código, creo que es necesario que definamos qué es un shader y las partes que lo componen.
 


¿Que es un Shader?



Un shader es un contenedor de instrucciones que se envían a la GPU para mostrar los elementos que tenemos en pantalla. Al igual que el script de un personaje contiene las instrucciones para que este se mueva o gire, el shader contiene información sobre el color o los vértices de un objeto. 
 


Al igual que para escribir comportamientos Unity usa C#, para escribir shaders Unity usa su lenguaje llamado Shaderlab. A su vez Shaderlab permite escribir fragmentos de código en CG (C for Graphics) que es donde realmente estará el código del shader en sí. El lenguaje CG fue desarrollado por Nvidia y Microsoft y es compatible tanto con OpenGL como con DirectX. Veremos más adelante en profundidad las partes que componen Shaderlab y CG.
 


Tipos de Shaders



En Unity tenemos dos opciones a la hora de crear un shader. 
 



  •    


          Surface shaders: podemos definirlo como una "plantilla" creada por Unity para facilitarnos gran parte del trabajo aunque dando menos control sobre el resultado final. 
       



  •    


          Vertex/Fragment shaders: el código que existe bajo la capa de Surface anterior. Tiene mayor complejidad pero ofrece mayor control sobre el resultado. 
       




En esta entrada nos centraremos en estos últimos, ya que el paso a Surface (o a ShaderGraph) es mucho más productiva si conocemos los conceptos del Vertex/Fragment. 
 


Fases del Pipeline



Para conseguir mostrar un objeto de juego (3D) por pantalla (2D) se requiere de un proceso con varias fases. Ese proceso es llamado Rendering Pipeline. Para que sea más sencillo de entender, voy a resumir los pasos para centrarnos en los que nos interesa ahora. 
 



 
 
 


Básicamente tenemos dos funciones que podemos modificar:
 



  •    


          Vertex: En esta función podemos modificar datos relativos al mesh, principalmente la posición de los vértices, de ahí su nombre. Consta de una entrada de datos (como la posición de los vértices mencionada o las uvs) y produce una salida que será el input de la función fragment.
       



  •    


          Fragment: En esta función obtenemos los datos recibidos después de convertir las coordenadas del objeto en coordenadas de pantalla. Por ello todas las modificaciones aquí son a nivel de coordenadas de pantalla. Por ejemplo el color, su transparencia etc. 
       




Esta explicación es muy superficial y muy rápida, puedes encontrar más información aquí:
 


https://en.wikipedia.org/wiki/Graphics_pipeline
 


 
 


Una vez explicado esto, vamos a pasar a la parte práctica. Abrimos por fin Unity y creamos el proyecto con la plantilla de 3D que comentamos (Built-in Render Pipeline). 
 


Partes de un Shader en Unity



Para empezar vamos a crear una nueva escena. La abrimos y creamos un nuevo Shader Unlit:
 



 
 
 


Le ponemos de nombre FlagEffect por ejemplo y creamos un Material que lo use. Ahora crearemos un cubo en la escena y le colocamos las siguiente posición, rotación y escala:
 



 
 
 


Creamos ahora un Plano, le arrastramos nuestro material y lo colocamos en:
 



 
 
 


Si todo ha ido bien deberás tener algo así. Puedes ajustarlo tú a tu gusto (aunque ten cuidado al girarlo ya que podrías no tener el resultado esperado al final)
 



 
 
 


Una vez creada nuestra bandera, vamos a abrir el shader FlagEffect. Vamos a borrar todo el contenido y vamos a ir conociendo sus partes poco a poco. Esta sería la estructura del shader con la que deberías empezar:
 



 


 
 



  •    


          Shader: La carpeta donde se registrará nuestro shader.
       



  •    


          Properties: Son las variables que podemos crear y ver a través del inspector del material. Cuando en un inspector ves una cajita para la textura, un botón para el color o un campo con un valor numérico aquí es donde se deben crear. La sintaxis es la siguiente: NombreVar ("TextoInspector",TipoVariable) = ValorPorDefecto Aquí podemos ver las diferentes propiedades que podemos crear en Unity: https://docs.unity3d.com/Manual/SL-Properties.html 
       



  •    


          SubShader: El contenido del shader estará aquí dentro.
       



  •    


          Pass: Cada llamada de pintado que haremos. Cada una tendrá sus funciones Vertex y Fragment. Por defecto solo tendremos y necesitaremos una. Aquí es donde estará el código,  acotado entre la pauta de inicio y de fin de CG que vemos en la imagen. 
       



  •    


          Fallback: no es obligatorio aunque es recomendable. Si nuestro shader no es compatible con la plataforma en la que corra, se llamará a otro shader para evitar que se vea rosa. Pero para nuestras pruebas recomiendo borrar la línea. De esta forma si tenemos algún problema con nuestro shader podremos verlo directamente (de otra forma puede que llame al Fallback y no lo veamos rosa). 
       




Una vez tenemos la plantilla básica, vamos a añadir las funciones de Vertex y Fragment y los input/output necesarios. Vamos a empezar creando estos últimos. Como vimos anteriormente vamos a necesitar una entrada a la función Vertex y una salida de ella. También necesitamos una salida de la función fragment. Para esto usaremos struct de C (que se declaran igual que en C#). 
 



 


Ahora vamos a necesitar las funciones Vertex y Fragment. La primera tendrá como parámetro su input y devolverá el output. La Fragment tendrá como parámetro el output del vertex.
 



 


Hasta aquí simplemente tenemos las funciones creadas con sus correspondientes inputs/ouputs configurados (aunque vacíos).  Si vamos a Unity veremos nuestro material rosa y eso es debido a que el shader cree que nuestras funciones son diferentes a las Vertex/Fragment. Tenemos que decirle mediante un #pragma que la función de vertex se llama vert en nuestro código y que la función fragment se llama frag. Puedes ponerle otro nombre a las funciones sin problema, siempre que en esta conexión lo pongas bien: 
 



 


De esta forma ya no tendremos problemas con nuestro shader, salvo por el pequeño problema de que no se ve nada. 
 


Inputs y Outputs



En este apartado vamos a rellenar nuestros structs de datos con la información que necesitamos en nuestras funciones de vert y frag. Dependiendo del shader que estemos creando vamos a necesitar más o menos datos dentro de los inputs. Por ejemplo si solamente queremos cambiar el color del objeto a rojo, no necesitamos datos de UV. Podemos ver todos los datos que podemos usar en cada función aquí:
 


https://docs.unity3d.com/Manual/SL-VertexProgramInputs.html
 


En nuestro caso vamos a necesitar para las ondulaciones de la bandera, la posición de los vértices y las coordenadas de uv del modelo. Para ello vamos a crear estas dos variables dentro de vertexInput y de vertexOutput.
 



 


Lo que aparece después de los dos puntos es la semántica y es necesario para conectar los datos. En el artículo anterior de Unity explica esto más detenidamente*
 


* Te darás cuenta de que Unity en el output usa SV_Position, que simplemente es un valor de sistema que lo hace más compatible con los sistemas actuales, para facilitar el entendimiento lo he obviado y he usado el POSITION
 


Llegados a este punto voy a explicar rápidamente los tipos de variables que podemos usar dentro de CG. Como ves he usado fixed2 y fixed4. El número al final hace referencia a vectores de 2 y 4 datos. Sería algo similar a un Vector2 o un Vector4. El tipo fixed es el tipo de menos coste y de menor precisión. Estarás acostumbrado a ver float o int. Estos también pueden ser usados de la misma forma que fixed. Aquí puedes ver los tipos de datos:
 


https://docs.unity3d.com/Manual/SL-DataTypesAndPrecision.html
 
También puedes crear matrices siguiendo la misma lógica, la sintaxis sería "float4x4",siendo los valores del final las filas y las columnas.
 
Una vez tenemos el vertex con los datos, vamos a pasar al fragment. Este simplemente necesitará un valor, el color final del pixel. 
 



 


En este caso usaremos SV_Target que es el que Unity recomienda por defecto. Como he dicho tienes más información acerca de la semántica en los enlaces anteriores. Como normalmente el fragment solo tiene un valor de devolución, puedes optimizar y borrar el struct de output cambiando el frag de la siguiente manera. 
 



 


El resultado es el mismo que el anterior pero en menos pasos. Ahora vamos a rellenar nuestra función de vertex. Pero antes vamos a necesitar incluir funciones que Unity nos ofrece para facilitarnos el trabajo. Como hemos dicho antes, vamos a convertir la posicion 3D del objeto en posición de pantalla. Para esto vamos a usar una función de Unity llamada UnityObjectToClipPos. Esta función recibe la posición de los vértices y devuelve las posiciones en espacio de pantalla para después usarlas en la función fragment. Para poder usarla vamos a incluir esta línea debajo de los #pragma.
 



 


El #include sigue la misma lógica que los using en C#, de esta forma podemos hacer uso de funciones que Unity tiene preparadas (como la que hemos comentado antes). 
 


Ahora en la función vertex vamos a igualar el output que devolveremos a lo que la función UnityObjectToClipPos nos devuelva. De esta forma convertiremos los vértices para el fragment. También vamos a igualar de momento las uv del input y del output, aunque las usaremos justo ahora.
 



 
 
 


Procedemos ahora a mover por fin los vértices. Para esto vamos a necesitar conocer por un lado la variable interna _Time que posee Unity, similar a Time.deltaTime. Esta es un Vector4 con diferentes tipos de tiempo en cada una. Aquí podemos ver más información de esa y de otras variables internas de Unity:
 



 


Por otro lado vamos a hacer uso de la función seno de CG para las ondulaciones. Creamos una nueva función en nuestro shader, de nombre flag que devuelva un fixed4. Además tendrá como parámetros la vertexPosition y las uv. Tened en cuenta que el shader compila de arriba hacia abajo, asique si escribís vuestra función al final y la usáis antes, dará error. Siempre tenéis que crear vuestras funciones antes de usarlas (a diferencia de C# por ejemplo). 
 



 


ahora dentro vamos a ir sumando a la vertexPosition el seno de _Time.y (el tiempo por defecto).Lo igualamos en la función vert al o.vertex quedando así: 
 



 
 
 


Estamos simplemente moviendo los vértices del input y asignándoles al output. Posteriormente convertimos con el UnityObjectToClipPos y seteamos las uv del input al output. Si probamos el efecto, vemos el movimiento pero no es lo que queremos.
 



 
 
 


Esto es debido a que el seno en Time es constante por lo que siempre se mueve de forma uniforme. Vamos a añadir el valor de uv.x (valor de 0 a 1) y restarle el Time para conseguir el efecto que queremos. 
 



 


 
 


De esta forma funciona, pero vamos a necesitar ajustarlo. Para esto vamos a crear tres propiedades de tipo Range. Esto es similar al atributo Range de Unity para los valores numéricos en C#. Te permite mostrar un float en el inspector del material y moverlo con un slider entre dos valores.
 


 
 
 
 


Ahora podrás ver las tres variables en el editor. Pero para poder usarlas tenemos que declararlas en CG con el mismo nombre que tengan en la propiedad (_Speed,_Frecuency, _Amplitude).  Usaremos el tipo fixed. Estas variables las vamos a usar de la siguiente forma:
 



  •    


          Speed: va a multiplicar al _Time.y para acelerar y reducir la velocidad.
       



  •    


          Frecuency: va a multiplicar a la resta entre uv.x y la multiplicación del Time y la speed. Justo antes de hacer el seno.
       



  •    


          Amplitude: multiplica al valor una vez el seno se ha calculado.
       




Estos son los tres cálculos básicos a la hora de modificar la ondulación. Grábalos en tu mente (o apuntalo mejor) porque los usarás muchas más veces en tu vida. 
 




 
 


Si todo ha ido bien, podrás ajustar los valores como quieras para mejorar la ondulación. Aquí puedes ver mi configuración:
 
 
 


Solo nos quedan dos pasos para terminar. El primero es hacer que la bandera se pegue al poste y no ondule. Esto es muy fácil de conseguir teniendo las referencias de uv.x que, como dijimos van de 0 a 1. Solo tenemos que multiplicar el seno que tenemos por la uv.x.
 



 


De esta forma anclamos la bandera, consiguiendo que la ondulación vaya de mayor a menor fuerza desde el poste (gracias al valor entre 0 y 1 de uv.x)
 


Lo otro que nos queda es añadirle color. Aquí voy a poner dos opciones, la primera es la básica, añadir un color sin más. Si estás cansado y no quieres continuar es la opción que te recomiendo. Podrás volver otro día para ver la segunda opción. En la segunda opción usaré un lerp para darle a la bandera 3 colores diferentes en función de la Y de su UV.
 


Añadir color básico



Simplemente tendrás que añadir una propiedad _Color y una variable de CG para conectarla (al igual que la _Speed y los demás valores anteriores). En este caso el color tiene cuatro valores, así que usaremos fixed4.
 



 
 
 


Y en la función frag devolvemos el color a pelo.
 



 
 
 


Añadir color avanzado



Si venimos del básico vamos a borrar la propiedad de color (o cambiarle el nombre) y crear otras tres diferentes. Estas se llamarán ColorTop, ColorMiddle, ColorBotton (o el nombre que tu quieras). Estos tres colores serán las tres franjas que tendrá la bandera. 
 



 



 
 
 


Ahora creamos una función nueva encima de frag con el nombre getPixelColor que devolverá un fixed4. Esta función analizará la posición de la uv en Y (la necesita como parámetro) y haciendo uso de la función lerp y step nos devuelve un color u otro. 
 



 
 
 


¿Qué hacen realmente cada una de estas funciones?
 


Puede ser complicado de leer tal y como está, pero solo necesitas saber lo que hace para entenderlo. La función lerp interpola entre dos valores con un valor t. Cuando t es 0 devuelve el primer valor y cuando es 1 devuelve el segundo valor, devolviendo valores intermedios. En nuestro caso no queremos valores intermedios, queremos una interpolación directa dado un valor de referencia. El valor de referencia será ⅓ ya que tenemos 3 franjas. La función step tiene dos parámetros, si el primero es mayor que el segundo, devuelve 1, si es menor devuelve 0. Esto unido al lerp hace que en valores superiores a 0.33 pero inferiores a 0.66 se coloree del color del centro. Y de igual forma en valores superiores e inferiores. 
 



 
 
 


Con esto hemos llegado al final de la entrada. Si tienes cualquier duda con esto déjamela en los comentarios. 
 


PD: Si queréis que la bandera se muestre en ambas caras, tendréis que cambiar un valor del Cull. Esto es fácil de hacer pero da para otra entrada junto a otros añadidos como el Blend el ZTest o el ZWrite. De momento para que te quede perfecto, solamente tendrás que añadir junto antes del Pass (o dentro del Pass antes de CGPROGRAM) la siguiente linea:
 



 
Con Cull en Off no ocultará ninguna cara. 
 
 
 


Nos vemos en la próxima entrada. 

#3
Recursos / [TIPS] Unity Tips en una linea
Marzo 22, 2020, 02:19:32 PM

https://twitter.com/_davidlopez29/status/1232341128910950400
 
#4
Recursos / [TUTORIAL] Crea tu propia carta 3D
Enero 22, 2020, 08:33:21 PM
Introducción 
 






En esta ocasión vamos a crear una Carta con un efecto 3D similar a la que vemos en el gif anterior. Para ello vamos a partir de un proyecto donde tenemos preparados los assets necesarios. Este proyecto podemos descargarlo desde aquí:
 


URL: https://drive.google.com/open?id=19J6lgCA-DH28lMu9dmntk1K5l3lPE66f
 


Una vez descargado vamos a abrirlo desde el Unity Hub. Este proyecto está creado con la versión 2019.2.9f1 asique podría ser incompatible con versiones anteriores. Una vez abierto vamos a tener una escena llamada "Sample Scene" y una serie de carpetas con los modelos,sprites,prefabs... necesarios. Además contamos con los paquetes TextMeshPro y PostProcessing que usaremos a lo largo del tutorial. Puedes acceder en todo momento a los paquetes usados a través del Package Manager. 
 


Preparando el proyecto
 


En primer lugar vamos a abrir la escena "Sample Scene" y vamos a arrastrar en ella el prefab "Hornet" dentro a la ventana de Hierarchy. Verás que aparece en rosa, eso es debido a que no tenemos aún ajustado el Render Pipeline. Vamos a empezar por ahí.
 


Vamos a crear una carpeta Settings donde colocaremos aquellos ajustes globales del proyecto. Siéntete libre de elegir otro nombre, yo siempre soy malisimo poniéndolos. Una vez creada vamos crear una configuración pulsando click derecho y Create/Rendering/LightweightRenderPipeline/PipelineAsets.
 




Elige el nombre que quieras y seleccionalo para verlo en la ventana de Inspector. Aquí tenemos los ajustes del Render Pipeline. La configuración es muy intuitiva y prácticamente todo hace lo que indica. En nuestro caso solamente vamos a activar el HDR y el antialiasing. Lo demás no lo tocaremos, aunque esto va de experimentar, así que "rómpelo" a tu gusto. 
 




Una vez creado vamos a añadirlo a nuestro proyecto, para ello vamos a irnos a ProjectSettings/Graphics y lo colocamos en el hueco de Scriptable Render Pipeline Settings. 
 




Hecho esto si volvemos a la escena podemos ver que el color rosa ha desaparecido. Aunque ahora se verán blanco. No te preocupes que ese será nuestro siguiente paso.
 


También verás que hay una luz añadida dentro del prefab de Hornet. Está configurada por mi pero llegado el punto puedes quitarla o cambiarla como quieras. 
 
 
 


Creación de Shaders
 


Vamos a darle color a nuestros objetos ahora. Como has podido ver todos los objetos están en blanco. Eso es porque nuestros shaders y materiales están por defecto. Para nuestro objetivo vamos a necesitar crear un shader con la herramienta Shader Graph. Esta ya viene por defecto en todos los proyectos que usen el Scriptable Render Pipeline nuevo. Para ello vamos a crear una nueva carpeta llamada Shaders y vamos a crear un nuevo Shader PBR (Create/Shader/PBR Graph).
 




Puedes ponerle el nombre que quieras, en mi caso lo he llamado Standard_SG (ya he dicho que soy muy malo poniendo nombres). 
 


Vamos a seleccionarlo y abrirlo. No es el objetivo de este taller aprender a usar ShaderGraph, asique no voy a pararme en explicar el contenido, aunque como veréis es muy fácil e intuitivo lo que haremos. Crearemos las siguientes variables:
 




Conectaremos al Albedo un Sampler de una textura y la multiplicaremos por un color. Cómo veis el shader es lo más simple posible.
 




Haremos lo mismo en el canal de Emission para poder ajustar la emisión de algunos objetos posteriormente. 
 




Pulsamos en Save arriba a la izquierda y cerramos. Ya tenemos nuestro shader creado pero tenemos un problema que veremos a continuación.
 


 
 


Stencil Buffers
 


Para obtener el efecto que buscamos tenemos que conocer el concepto de Stencil Buffer. Con ellos podemos principalmente renderizar unas partes de un objeto y descartar otras. Aquí podemos obtener más información:
 


https://docs.unity3d.com/Manual/SL-Stencil.html
 


https://www.ronja-tutorials.com/2018/08/18/stencil-buffers.html
 


El objetivo es mantener "invisible" un objeto y que cuando este se encuentre en la "visión" de otro objeto, se muestre. Vamos a necesitar por dos shaders:
 



  •    


          Uno que leerá del stencil buffer y se dibujará solo donde el búfer tenga un valor específico, en cualquier otro lugar se descartará. 
       



  •    


          Por otro, un shader que permanerá siempre invisible y que solamente mostrará aquellos valores específicos que coincidan con el stencil buffer.
       




Para el primer solo necesitamos añadir unas líneas, pero actualmente no es posible hacerlo a través del ShaderGraph. Por lo que vamos a realizar una transcripción del Shader Graph al código. Para esto vamos crear un nuevo Shader Unlit pero esta vez no será de ShaderGraph.
 




Le ponemos de nombre Standard_StencilRead por ejemplo y lo abrimos. Mientras se abre vamos a volver al Shader Graph y vamos a realizar la copia del código del shader. Para ello nos vamos al PBR Master Node y con el botón derecho seleccionamos Copy Shader.
 




Una vez copiado vamos a pegarlo en nuestro reciente nuevo shader unlit creado, sobreescribiendo todo lo que este tuviese. También deberás cambiar la primera línea y ponerle tu la dirección y el nombre que elegimos antes. En mi caso lo he guardado en MyShaders con el nombre Standard_StencilRead.
 




Ahora tenemos el mismo shader de Shader Graph pero en código para poder modificarlo. Vamos a necesitar añadir una nueva propiedad que será el valor específico del stencil. Simplemente dentro de properties al final, debajo del Color añadimos lo siguiente: 
 


[IntRange] _Stencil ("Stencil Value", Range(0,255))= 0


Quedando de la siguiente manera: 
 




Por último vamos a necesitar añadir los ajustes del Stencil debajo de los Tags antes de los diferentes pases. 
 




Esto hará que sólo cuando tengamos el valor de referencia, el objeto se muestre. Podemos obtener más información sobre la sintaxis y el contenido en los enlaces que anteriores. 
 


Ya podemos guardar el shader y volver a Unity. Tenemos preparado nuestro primer Shader. Para el segundo simplemente creamos otro shader unlit de nombre StencilWrite por ejemplo. Este estará siempre invisible y servirá para mostrar los objetos que compartan valor de referencia. Abrimos el shader y lo modificamos de la siguiente forma:
 




En properties añadimos el valor de Stencil como con el anterior y eliminamos cualquier otra propiedad (normalmente textura) ya que este shader queremos que se muestre totalmente invisible. 
 
 
 




Añadimos el Stencil y le decimos que esté siempre comparando y si en algún momento el valor de referencia es el mismo, lo reemplace. 
 




Ahora le decimos al buffer de profundidad que no se escriba (por ser un objeto que será invisible) y cambiamos el modo de Blend. Podemos obtener más y mejor información de esto aquí:
 


https://docs.unity3d.com/Manual/SL-Blend.html
 


También eliminamos todos los añadidos de Fogs por defecto de Unity y aquellas referencias a texturas que no nos interesan. Por último hacemos que la función frag devuelva siempre 0, ya que como hemos comentado esto se muestra siempre como invisible. 
 


Con esto tenemos todo listo para pasar al montaje de la carta. 
 


PD: Asegurate también de que lo tienes en la misma ruta que el anterior. Esto no es necesario, pero te facilitará encontrarlo más adelante. En mi caso al igual que antes, esta en la ruta MyShaders. 
 




 
 


Montaje de la carta
 


Para empezar vamos a cambiar por fin el blanco de nuestra escena, para ello vamos a irnos a Materials/Hornet y seleccionando todo vamos a elegir nuestro Shader (en este caso el Standard_StencilRead)
 




Ahora tendremos que arrastrar las texturas requeridas (Main Texture y Emission Texture) si procede y establecer el MainColor en blanco (tened cuidado que el alfa no este a 0) y el EmissionColor en negro. En el caso que no tengamos texturas (como en el caso del personaje Hornet) simplemente cambiale el MainColor a tu gusto. Puedes hacerlo similar al original o ponerle tu propia versión. Así quedaría el del grass_material por ejemplo:
 




O el dress_material, que no tendría textura:
 




Sigue estas pautas en los demás materiales. El stencil value lo cambiaremos más adelante, de momento necesitamos ver en pantalla todo y no solo cuando este a través de nuestro "marco".. Una vez terminado debería de quedarte algo similar a esto:
 




Ahora vamos a crear un nuevo objeto en la escena llamado Card y lo ponemos en la posición 0,0,0. Ahora buscamos el Sprite "cover" dentro de Sprites y lo arrastramos dentro de Card. Le damos el tamaño a nuestro gusto. Este será el envoltorio de la carta. 
 



 
 
 


Ahora vamos a crear un Quad dentro de Card. Le ponemos de nombre StencilMask y lo colocamos en la posición 0,0,0 también. Este será nuestro marco a través del que se verá nuestra Hornet. Para poder ajustarlo vamos a tener que configurar ya el valor de referencia del stencil así como crear un nuevo material StencilWrite para nuestro quad recién creado. Vamos a empezar por esto último, crearemos un nuevo material con el shader StencilWrite. Lo colocamos dentro de Materials para tenerlo ordenado. A este material le vamos a poner en el valor de Stencil el valor 2 por ejemplo. Es simplemente un valor referencia, mientras tanto el receptor como el emisor tengan el mismo, funcionará. 
 




Una vez configurado vamos a arrastrarlo al StencilMask (o cambiamos el material dentro de MeshRenderer) para colocarselo. Veréis que se ha vuelto invisible, eso es que funciona como debería. Por último vamos a irnos a los materiales StencilRead que configuramos anteriormente y vamos a ponerles el mismo valor de referencia al Stencil. Seleccionamos todos o uno a uno y en Stencil Value le colocamos 2. 
 




Ahora debería de volverse todo invisible en la escena quedando solo la carta en negro. Vamos a desactivar de momento la carta llamada "cover" (o el nombre que tu le hayas puesto) de la ventana de Hierarchy. No se ve nada pero no es un error. Ahora mismo todos los shaders tienen el mismo Render Queue por lo que nuestro efecto no está funcionando.  Más información de esto aquí:
 


https://docs.unity3d.com/Manual/SL-SubShaderTags.html
 


 Sabiendo esto solamente tendremos que asegurarnos que nuestro StencilWrite se renderice antes. Vamos a nuestro material y le restamos 1 al RenderQueue.
 




Con esto ya deberiamos tener visible nuestro modelo únicamente cuando estemos viendolo a través de nuestro quad. 
 




Ahora volvemos a activar el cover para ajustar la carta y el hueco como queramos. Al activarlo verás que tapa la visión a través del quad. No te preocupes, simplemente ve a los ajustes del SpriteRenderer del cover y cambia el MaskInteraction a Visible Outside Mask. 
 




Ahora ajustamos el Quad hasta tener el tamaño que deseemos. Una vez confirmado podemos probar a girar en la escena alrededor de la carta para comprobar el efecto. 
 



 
 
 


Para organizar mejor la escena vamos a colocar el objeto Hornet dentro de Card y vamos a crear un prefab para tenerlo guardado. Gracias a los Nested Prefab ya podemos hacer prefabs dentro de prefabs, asique nos viene genial.  
 


Ahora solo nos falta añadirle algo de texto. Vamos a usar TextMeshPro para esto. Pulsamos botón derecho y creamos un nuevo texto en 3D. 
 




Vamos a empezar por el nombre de la carta, por lo que le ponemos de nombre al text "Name" por ejemplo. Vamos a escribir el texto del nombre en el apartado Text y vamos mover y escalar el objeto colocándolo donde más nos guste. En mi caso he decidido ponerlo arriba. 
 




Vereis que no se ve cuando lo colocamos en la zona de la carta. Eso es por el orden de renderizado que tienen. Vamos a abrir los ajustes extra del texto (extra settings) y vamos a subirle el orden in layer a 1. 
 




Con esto conseguimos verlo, pero existe un problema, que el texto aparece también por detrás. Esto lo solucionaremos más adelante ya que tendremos que añadir un script simple para que active el culling. 
 


Llegados a este punto me he dado cuenta de que la carta está colocada del revés y el nombre por la parte trasera se ve invertido. En nuestro caso podemos solucionarlo rápido ya por delante la carta no se ve afectada. Simplemente nos vamos al objeto "cover" y marcamos Flip X. De esta forma la parte de atrás estará perfecta.  
 




En el caso de que tuvieras una imagen diferente deberías tener cuidado ya que la carta es la misma tanto en la partal como en la dorsal. Todo se dará la vuelta. Si quieres tener un control más exacto, deberás tener una carta delantera y otra trasera, cada una con su ajustes (y quizás optimizada para no pintar dos cada cara). 
 


Vamos a guardar el avance, aplicamos el prefab y guardamos escena. Deberíamos tener algo similar en estos momentos:
 



 
 
 


Vamos a crear ahora otro texto para colocarlo en la parte de debajo. Duplicamos el objeto Name con Control+D y cambiamos el nombre a Description. Movemos el objeto a nuestro gusto, en mi caso lo coloque en la parte de abajo, centrado. Puedes tocar los ajustes del TextMesh que son maravillosos, sobre todo si has trabajado con el deprecado Text. 
 


Si queremos podemos cambiar la fuente. Para ello simplemente tendrás que descargarla de internet (o obtenerla de otra forma) y meterla dentro de Unity. Una vez dentro no es simplemente arrastrarla. Para poder usarla en TextMesh necesitarás crear un atlas de la fuente. Pero es fácil de hacer, simplemente abre la ventana Font Asset Creator desde WIndows/TextMeshPro.
 




Selecciona la fuente y pulsa Generate Font Atlas (si quieres cambiar algún otro ajuste puedes hacerlo, pero ten cuidado. Más información sobre esto aquí: http://digitalnativestudios.com/textmeshpro/docs/font/ ) 
 


Una vez generada simplemente guárdala donde quieras y luego colócala en el texto dentro de Main Settings:
 



 
 
 


Una vez tengamos la descripción vamos a guardar el prefab y a colocar los Post Procesos. Para ello Vamos a ir a la cámara y vamos a asegurarnos que tiene añadido un Post Process Layer. Esto es imprescindible para poder continuar. También vamos a activar a antialiasing FXAA y vamos a crear un nuevo layer PostProcessing para posteriormente usarlo en el Volume. 
 




Ahora vamos a crear un nuevo objeto en la escena. Le vamos a añadir el componente Post Process Volume. Vamos a marcar IsGlobal porque solo tendremos este para toda la escena y vamos a seleccionar un profile. En nuestro caso no tenemos ninguno creado, asique le daremos a New.
 




Ahora simplemente asegurate de que este objeto está en el Layer PostProcessing
 




De otra forma no funcionará y no podremos ver ningún cambio. 
 


Una vez configurado podremos ir añadiendo efectos ya creados por Unity o crear los nuestros propios. En este caso vamos a usar dos creados, el Bloom y el Color Grading. Pulsamos en Add Effect y seleccionamos uno y después el otro. 
 




Aquí puedes sacar tu lado artístico y elegir la configuración que más te guste. En mi caso después de una serie de pruebas quedó así:
 






En este punto deberías tener algo similar a esto. Si no es así asegúrate de que el material del lazo tiene un emission color bien configurado. 
 



 
 
 


Por último nos queda solucionar el error del texto por ambas caras. Para eso simplemente vamos a crear un script con el nombre CullingTextMeshPro o el que querais y vamos a dejar solo la función Awake con el siguiente código:
 



 
 
 


De esta forma al darle al Play el texto automáticamente hará culling y no se renderiza por detrás. Estuve informándome sobre otras formas de hacer esto, pero las respuesta de Unity fueron que esta era la forma. Pero si conocéis otra forma contactad conmigo y lo actualizo.
 
 
 


Espero que os haya gustado y hayáis aprendido cosas nuevas que al final es el objetivo esto. Cualquier duda contacta conmigo via twitter: https://twitter.com/_davidlopez29 o por aquí
 


Hasta pronto!

#5
Scripting / Como guardar datos
Octubre 29, 2019, 12:47:36 AM
Cita de: mutoit date=1572254771Muchas gracias ! 
   


Si quieres profundizar, este tuto es muy completo. 
 
http://unity-dev.blogspot.com/2016/05/serializacion.html
#6
Interfaz / Consulta - Articulación de objetos
Octubre 29, 2019, 12:44:17 AM
Conoces los Physics Joints? creo que es justo lo que buscas. No se si hablas de 2D o 3D pero hay componentes para ambas opciones. Aquí hay un vídeo que te puede ayudar a encontrar el que más útil en tu caso:
 


   
eature=oembed">

 
 
#7
Recursos / [TIPS] Unity Tips en una linea
Octubre 29, 2019, 12:24:00 AM
 
 


  •    Puedes asegurarte de que una variable no es nula añadiendo '?' antes de acceder a ella.



               
 
 
 



  •    


          Puedes crear strings con variables dentro añadiendo '$' delante y las variables entre corchetes.
       




               
 
 
 



  •    


          Puedes sacar un material de un shader concreto creándolo con el shader seleccionado. 
       




                
 


 
 


 
 





  •    


          Puedes cambiar la respuesta de Unity cuando realizas cambios en un script mientras estás en Play. Sólo tienes que ir a Edit/Preferences/General
       




               

 
 



  •    


          Puedes cambiar la configuración del orden de transparencia desde Project Settings/Graphics. Muy útil para juegos 2D donde quieras controlar el orden de pintado en función de su Y.
       




                 

#8
Recursos / [TIPS] Unity Tips en una linea
Octubre 25, 2019, 02:32:48 PM


Voy a reunir pequeños tips de Unity que se pueden resumir en pocas frases. Esta lista se irá agrandando poco a poco en el futuro. Podéis añadir los vuestros si queréis. La idea es TIP + imagen representativa. 
 



  •    


          Puede usar el atributo MenuItem para agregar menús contextuales que pueden llamar a funciones estáticas. Además, si desea crear teclas de acceso rápido, puede agregar caracteres especiales ("%" para ctrl, "#" para shift, "&" para alt) 
       




               
 


              
 
 
 



  •    


          Recuerde guardar las cadenas repetidas en una variable constante.
       




             
 
 
 



  •    


          Verifique que su sistema de partículas tenga un culling automático. Si no tiene,revise las razones o use CullingGroup
       



             
 
 
 


  •    


          Puede usar el atributo ContextMenu para probar su código en la ventana del editor
       



           
 


 
 



  •    No olvide optimizar sus Animators con el modo de selección. Esto deshabilita la animación cuando no son visibles.



           
 


 

#9
Cuando tienes una gran cantidad de sprites en tu proyecto, es una buena práctica (por no decir que es obligatorio) organizarlas todas en torno a un Sprite Atlas. Esto te ayudará a ahorrar memoria en tiempo de ejecución además de a reducir los tiempos de acceso a ellas. Para crear un Sprite Atlas, puedes hacerlo desde botón derecho en vista de proyecto y Create/SpriteAtlas. Una vez creado simplemente tienes que seleccionarlo y agregar todos los sprites que necesites. 
 

 
 
 



 
 
 


Puedes probar las opciones para ver los resultados. Ten en cuenta que tamaños muy altos de Sprite Atlas no son compatibles con algunos targets. 
 
Puedes activar, desactivar o limitar  el uso de Sprite Atlas desde ProjectSetting/Editor.
 
Espero que os sea útil. Hasta la próxima

#10
Unity cada vez que creas un nuevo script, sea del tipo que sea, siempre consulta un archivo plantilla para generarlo. Por eso siempre tenemos añadido, por ejemplo, la función Start y Update, o creada la clase en función del nombre que le pongas al Script. Pero eso puedes modificarlo fácilmente. Simplemente dirígete a la siguiente ubicación: 
 


 
 


Será diferente según la versión de Unity que uses. Ahí podemos ver todos las plantillas, simplemente abrimos la que queramos modificar. 
 



 


Ahora podéis añadir una cabecera de Copyright o quitar las funciones Start y Update (que si no hay que tenerlas vacías). Ya las añadirás tu cuando las tengas que usar. 
 
Espero que os sea útil. Hasta la próxima

#11
Recursos / [TUTORIAL] Introducción a Shader Graph
Octubre 25, 2019, 02:26:49 AM
 
 


Water Toon
 


Este será la última parte del tutorial introductorio. Así que para acabar os traigo un shader de agua estilizada. 
 



 
 
 


Para empezar, como en los anteriores, creamos un nuevo shader PBR Graph con su material correspondiente y se lo asignamos a un plano creado en la escena. Antes de entrar en profundidad con el shader, necesitamos poder acceder desde dentro a una textura de profundidad de la cámara. Esto veremos posteriormente que lo usamos para el efecto que producen los objetos que están dentro del agua. Si revisamos el gif, vemos que los pies y parte de la caja están dentro del agua. Para poder activar el acceso, simplemente tendremos que ir al asset que controla el LWRP. Puedes localizarlo rápidamente en Project Settings/Graphics.
 



 


Si pinchas en el asset, te llevará a él en la ventana Project. Selecciónalo y en el inspector activa el toggle Depth Texture.
 



 
 
 


Una vez activado, podemos abrir el editor de nuestro nuevo shader y ponernos a trabajar con él. Vamos a establecer en el PBR Master (en el engranaje) el tipo de surface Transparente, ya que el agua a diferencia de los anteriores sí que debe serlo. Aunque puedes probar posteriormente con diferentes valores para ver el resultado.
 



 


Para el desplazamiento de vértices vamos a basarnos en el anterior ejemplo. Podemos copiarlo o volver a crearlo si recuerdas el mecanismo. Simplemente añadimos a la posición del vértice la normal multiplicada por el ruido. En esta ocasión, vamos a usar otro tipo de ruido con el nodo Gradient Noise. Para nuestro efecto de agua es más útil ya que ofrece más fuerza en las frecuencias altas, que usaremos para las olas. 
 



 
 
 


Como ves he creado las variables necesarias para poder editarlas desde el propio material. Ahora simplemente necesitamos añadir algo de movimiento a las olas. Para eso, ya conocemos el nodo de tiempo. Vamos a multiplicarlo por el nodo de ruido. Para ello necesitamos un nodo auxiliar de UV que nos permita mover las coordenadas. Ese nodo es el de Tiling and Offset. Lo añadimos y conectamos el nodo de tiempo. Luego conectamos la salida a la entrada de UV del ruido. 
 



 


He añadido un Multiply para controlar la variable tiempo por editor también. Con esto tendríamos el efecto de olas simulado. Puedes cambiar los ajustes desde el editor a tu gusto. 
 
Ahora pasaremos a la parte del color. Para el efecto de la espuma de las olas vamos a volver a usar un ruido, esta vez el Simple Noise nos valdría, aunque se libre de elegir, incluso puedes probar con Voronoi u otros si quieres. Al igual que con el efecto de oleaje, necesitaremos mover las Uvs con el Tilling and Offset y el Time. 
 



 
 
 


Para poder simular el efecto de espuma estilizada, usaremos el ya conocido Step. Con el limpiaremos la textura de ruido con el valor de entrada del Step. Además podemos multiplicar la salida del Step para cambiar el color de la espuma. Todo esto siempre haciendo uso de variables para poder editarlas posteriormente. Repito mucho esto, pero es muy importante poder cambiar tú o la persona encargada de eso los ajustes sin necesidad de abrir el shader. 
 
 
 



 
 
 


Solo faltó crear una variable para la entrada del Step, siéntete libre de hacerlo tú si lo crees necesario.  En mi caso las espumas son blancas, así que no se aprecia el cambio con la multiplicación pero no tiene porqué ser así. 
 


Solo faltaría añadir el efecto de profundidad y darle color. Por otro lado buscamos el nodo Scene Depth qué es el que guarda la textura de profundidad de la cámara (lo que activamos anteriormente vamos). Una vez añadido, vamos a cambiar el Sampling Mode a Eye. Esto nos dará la profundidad convertida en unidades de espacio ocular. Esta textura la vamos a dividir por un valor para poder controlar su profundidad. Con esto a mayor denominador, más profundidad se consigue y viceversa. Podremos verlo posteriormente modificando el valor. Por último vamos a crear un Lerp para mezclar el color según la profundidad obtenida(con dos colores). 
 



 
 
 


Solo faltaría conectar las dos partes con un nodo Add y conectarlo a la entrada de Albedo. 
 



 
 
 


Con esto tendríamos nuestro efecto terminado. 
 
 
 


Espero que os sea útil y cualquier cosa no dudéis en preguntar.

#12
Recursos / [TUTORIAL] Introducción a Shader Graph
Octubre 24, 2019, 10:31:14 PM
Vertex Displacement
 


Este ejemplo servirá de introducción para el desplazamiento de vértices.
 



 
 
 


Vamos a crear un nuevo shader, con su material correspondiente y lo vamos a aplicar en una esfera añadida a la escena. Colocamos la esfera visible para la cámara y comenzamos. Para el desplazamiento de vértices vamos a usar la primera de las entradas del Master Node, ya sea el PBR Graph o el Unlit Graph. Para este ejemplo usaremos el PBR Graph pero es indiferente. 
 


Para poder mover los vértices, simplemente tenemos que usar el nodo Position para saber la posición y sumarle el desplazamiento. En este caso usaremos un desplazamiento en dirección a su Normal. 
 



 


Tendremos que asegurarnos de que el espacio en el que estamos trabajando está en relación al objeto y no al mundo. Esto podemos configurarlo en la variable Space del nodo. Con esto tendríamos un desplazamiento simple de los vértices. Pero es un desplazamiento constante, vamos a añadirle ruido y movimiento con los nodos Noise y Time que vimos anteriormente. 
 



 
 
 


Ahora tenemos un efecto mucho mejor. Pero el movimiento está basado totalmente en el ruido que obtenemos, sin tener en cuenta cual es la posición actual del vértice. Para que tenga en cuenta la posición del vértice y se modifique en función de esta, simplemente sumamos a la Posición el Tiempo y lo conectamos con el Ruido. 
 



 
 
 


Ahora hemos conseguido el efecto que queríamos. Cada vértice se mueve en función de su posición y del ruido que generamos. Si queremos cambiar la intensidad podemos usar el nodo Remap. Este nodo dado un valor mínimo y máximo de entrada, interpola el valor entre dos valores de salida mínimo y máximos. Por ejemplo en este caso, la salida del Simple Noise está entre 0(negro) y 1 (blanco). Estos dos valores serían la entrada al Remap. Si los valores de salida fueran 0 y 10, en los valores en los que el ruido entrase con valor 0.7,saldría interpolado entre 0 y 10, es decir saldría como 7. 
 



 
 
 


Como vemos, ahora el efecto se intensifica en función de la salida que establezcas en el Remap. Recuerda guardar las variables en la Blackboard para poder cambiar los valores desde el propio material posteriormente. 
 
Para acabar podemos hacer lo que queramos con el color. Podríamos simplemente asignarle una textura o crear un portal como en los anteriores casos. En este caso para no alargarlo, vamos a usar un simple Voronoi junto a un Color para dar el efecto que vimos en el gif. 
 



 
 
 


Es prácticamente lo mismo que hicimos en el anterior shader, colocamos el Lerp y le seteamos los dos colores.
 
Espero que os sea útil y cualquier cosa no dudéis en preguntar. 

#13
Recursos / [TUTORIAL] Introducción a Shader Graph
Octubre 24, 2019, 08:04:19 PM
Portal Effect
 


El siguiente efecto es un portal muy simple inspirado un poco en la serie Rick and Morty:
 



 


 
 


Para este efecto, a diferencia del anterior, vamos a crear un Shader Unlit Graph. La diferencia es que el PBR Graph incluye cálculos de iluminación avanzados entre otras cosas, cosa que el Unlit no. 
 



 


Este nodo Master como vemos, sólo tiene entradas para color y alpha. Una vez creado el shader, vamos a añadir un Quad a la escena con un nuevo material con nuestro shader.  Colocamos la cámara para poder verlo y hacemos el Quad del tamaño que desees hacer el portal. Podrás cambiarlo posteriormente.
 



 
 
 


Una vez creado abrimos el shader. Lo primero que queremos es crear una máscara circular para darle el efecto ovalado y no tener el rectángulo actual. Esto es simple, simplemente creamos un nodo de forma tipo elipse(Procedural/Shape/Elipse). Cambiamos el tamaño a 1 en ambas dimensiones y colocamos la salida del nodo en el Alpha del Master.  Como en el anterior shader, sacamos un integer del AlphaClip y lo colocamos a 1.
 


 
 
 
 


Si guardamos y probamos podemos ver que ahora es una elipse en vez de un rectángulo (cambia el color en el Unlit Master directamente si no lo consigues ver). 
 


Para seguir vamos a hacer uso de dos nodos, que combinados, dan justo el efecto que buscamos. El primero de ellos es un nodo de ruido,Voronoi. La explicación de Voronoi se saldría del objetivo de este tutorial asique si te interesa te dejo un enlace de un artículo que lo explica muy bien: https://www.abc.es/ciencia/abci-diagrama-voronoi-forma-matematica-dividir-mundo-201704241101_noticia.html 
 


Junto al nodo de Voronoi vamos a usar un nodo de movimiento de UV, en este caso por Twirl que hace que las UV giren.
 



 


 Uniendo el nodo de Twirl al nodo de obtendremos lo siguiente:
 



 


 
 


Puedes cambiar las variables de entrada de ambos nodos para que configurar el efecto a tu gusto. También sería una buena práctica crear propiedades para poder configuraras luego desde editor. 
 


Ahora solo falta que gire, para conseguir este efecto necesitamos acudir a otro modificador de UV, en este caso el nodo Rotate. Este nodo se coloca en la entrada de UV del Twirl y nos permitirá controlar el giro de este. 
 



 
 
 


Podremos controlar el giro con la entrada Rotation del nodo Rotate. Llegados a este punto vamos a hacer uso de un nodo muy importante, que quizás se me olvidó comentar en la lección pasada. Es el nodo Time, el cual nos permite usar diferentes tipos de tiempo según lo necesitemos. Creamos entonces un nodo Time y conectamos la salida Time (el tiempo por defecto) a la entrada de Rotation. 
 



 
 
 


Como ves, si queremos controlar el tiempo simplemente podemos guardar una variable que multiplique el tiempo y esa salida la conectamos al Rotate. Puedes experimentar con los demás tipos de tiempo para ver lo que ocurre con cada uno.
 


Ahora ya solo necesitamos añadirle color. Puedes notar que el Voronoi tiene dos salidas, te animo a que pruebes el efecto con ambas, ya que son el mismo concepto pero de diferentes estilos. Yo me voy a quedar para este con la salida Cells, que le da un toque más estilizado. Al igual que con el anterior, vamos a hacer uso del nodo Lerp que nos ayudará a convertir los colores negros y blancos en los colores que nosotros queramos. Creamos dos colores, para poder editarlos más adelante y los colocamos en las entradas A y B del nodo de Lerp. 
 


 
 


Con esto el efecto estaría terminado. Vamos a añadirle unos detalles extra para mejorar el efecto. Podemos sacar un nodo Step del Voronoi. En este caso he usado la salida por defecto para poder apurar más el Step. Ponemos un valor pequeño en la entrada del Step para darle un toque sutil simplemente. Lo multiplicamos por el color que quieras, en mi caso blanco y posteriormente lo añadimos a lo que teníamos hasta ahora. Siéntete libre de modificar los valores a tu gusto para darle el tu propio toque. 
 



 
 
 


Espero que os sea útil. Cualquier duda que tengas no dudes en dejarla. Hasta la próxima. 

#14
Recursos / [TUTORIAL] Introducción a Shader Graph
Octubre 24, 2019, 06:28:25 PM
Hola a todos, mi nombre es David y este es el primero de una serie de tutoriales sobre Unity3D. Esta iniciativa surge del programa Unity Student Ambassador y están creados por mi inicialmente para workshops presenciales. Los he adaptado a este formato pero si tienes cualquier duda no dudes en preguntarme. Espero que os guste.
 
Introducción
 
¿Que es Shader Graph?
 


La creación de shaders en Unity ha sido tradicionalmente el terreno de juego de personas con habilidades para programar. Shader Graph abre el campo para artistas y otros miembros del equipo para que la creación de shaders sea mucho más sencilla. Solo conecta nodos en una red gráfica y podrás ver los cambios al instante.
 
 
 


Requisitos
 


El Shader Graph está disponible desde Unity 2018.1. Está diseñado para funcionar con otra característica de Unity 2018.1: Scriptable Render Pipeline (SRP). Por lo tanto, no puede usarlo con el Built-In Unity Renderer. Tiene por tanto soporte tanto para LWRP como para HDRP (o para su propio SRP). 
 


Para este tutorial usaré la versión 2019.2.9f1. 
 


 
 


¡Comencemos!
 


Lo primero que necesitamos es abrir Unity y crear un nuevo proyecto. Asegúrese de que elige usar el nuevo SRP. En nuestro caso elegiremos el LWRP.

 
Confirmamos y esperamos que Unity lo prepare todo. Una vez dentro de Unity ya podemos ponernos a trabajar. Por defecto debería tener incluido el paquete Shader Graph. Puedes comprobar ese y otros paquetes instalados en Windows/Package Manager. 
 
 
 
Nuestro primer Shader
 
En la ventana Project, pulsamos el botón y elegimos Create/Shader/PBR Graph. Si queréis conocer más acerca del PBR está es una buena guía: https://blog.teamtreehouse.com/beginners-guide-physically-based-rendering-unity

 
 
 


Nombramos el archivo con el nombre que queráis. En este caso le llamaremos Standard_Color. Ya tendríamos nuestro primer Shader creado, vamos abrirlo. Lo seleccionamos y en la ventana Inspector pulsamos Open Shader Editor.
 


 
 
 
 


Si todo ha ido bien, deberíamos ver esto:
 



 


Dentro del Shader Editor podemos ver tres sectores claramente diferenciados:
 



  •    


          PBR Master Node: Es el nodo principal, al que acaban llegando todos los demás. Es el encargado de mostrar las características en el material. 
       



  •    


          BlackBoard: Puedes activarlo y desactivarlo arriba a la derecha. Es donde creas y guardas las propiedades que necesitas usar. Encontrarás Colores, Vectores, Texturas etc... Estas pueden aparecer en el inspector del material para ser usadas más adelante. 
       



  •    


          Preview: Es la previsualización actual de la entrada del PBR Master Node. Puedes cambiar el tipo de renderización pulsando el botón derecho. (Cubo, quad,sphere...) 
       





Una vez conocemos las partes vamos a añadirle funcionalidad a nuestro nuevo Shader. Comencemos añadiendo color. Vamos a abrir el Blackboard y vamos a pulsar en el +. Con esto podremos crear una variable de entre las que Shader Graph nos ofrece. En este caso elegiremos Color. Ahora podremos cambiarle el nombre, pero en nuestro caso lo dejaremos tal y como está, con el nombre Color, que al fin y al cabo es lo que será para nosotros. 
 



 
 
 


El toggle de Exposed indica si quieres que esa variable aparezca posteriormente en el material para ser editada de forma rápida. En nuestro caso así lo queremos así que la dejamos marcada. En Default puedes elegir el color que desees por defecto, como he dicho podrás cambiarlo después en el material pero si quieres ver como queda en el Shader Editor tendrás que cambiarlo aquí. Por último el Mode te permite establecer el color como HDR. Puedes hacer efectos realmente atractivos con esto pero de momento lo dejaremos como está. 
 
Una vez creado nuestro Color vamos a arrastrarlo hacia el Grid donde esta el PBR Master y lo soltamos. 
 



 
 
 
Como vemos este nodo Color solo tiene una salida, conectamos la salida con la entrada de Albedo. Si habías cambiado el color default verás que la Preview ahora aparece de otro color. Sino puedes ir ahora y cambiarlo. Una vez hecho esto pulsamos arriba a la izquierda en Save Asset y podemos cerrar el editor. 
 
Ahora solo nos falta ver nuestro shader en pantalla. Para esto añadimos una esfera a la escena y creamos un nuevo material. Le pondremos de nombre Standard_Color_MAT, por ejemplo. Una vez creado el material, lo seleccionamos y en el desplegable del Shader elegimos ShaderGraph/Standard_Color o como llamases a tu Shader. Arrastramos nuestro nuevo material y lo soltamos encima de la esfera y ... 
 



 
 
 


Ahora podemos cambiar cambiar desde el Material el Color, ya que anteriormente lo activamos. 
 
 
 


Nodos importantes
 


Antes de continuar el tutorial voy a explicar algunos de los nodos más usados ya que los vamos a usar más adelante. Me dejo muchos pero para esta introducción son suficientes:
 



  •    


          Math Basic: Son las operaciones matemáticas más comunes. Suma, División, Multiplicación, Resta ...
       



  •    


          UV: Son nodos que actúan sobre las coordenadas de uv. Podemos rotarlas, moverlas y darle algunos efectos como el Twirl o Spherize. Veremos un ejemplo más adelante. 
       



  •    


          Shapes: Son texturas generadas proceduralmente dentro del editor. Podemos crear círculos, rectángulos, polígonos etc... 
       



  •    


          One Minus: es simplemente la operación 1 - x. Es muy útil como veremos más tarde, tanto que tiene su propio nodo. 
       



  •    


          Noise: es un nodo generador de ruido. Veremos también su uso más adelante. 
       



  •    


          Step: es un nodo que dado un valor entre 0 y 1, compara la entrada con ese valor y devuelve 0 si es menor y 1 si es mayor. Por ejemplo: si nuestro valor es 0.4, todos los valores por encima que entren en el nodo, serán convertidos a 1 y todos los inferiores serán 0. 
       



  •    


          Dot: es un nodo que calcula el Producto Escalar entre vectores. Devuelve 1 si apuntan exactamente en la misma dirección, -1 si apuntan en direcciones completamente opuestas y 0 si los vectores son perpendiculares.
       



  •    


          Lerp: es un nodo que devuelve el resultado de la interpolación lineal entre las dos entradas en función de la entrada T. El valor de la entrada T está sujeto al rango de 0 a 1. Por ejemplo, cuando el valor de la entrada T es 0, el valor de retorno es igual al valor de la entrada A , cuando es 1, el valor de retorno es igual al valor de la entrada B y cuando es 0.5, el valor de retorno es el punto medio de la dos entradas A y B .
       



 
 


  
 


 
 


Dissolve Shader
 


Una vez conocemos los nodos más importantes, vamos a hacer un Shader algo más complejo que el anterior. Vamos a crear un efecto que disuelva el objeto haciendo que desaparezca y aparezca a nuestro gusto:
 



 
 
 


Para esto volvemos a crear un nuevo Shader y le ponemos de nombre Dissolve. Lo abrimos y seleccionando el PBR Master pulsamos en el icono del engranaje. 
 



 
 
 


Aquí vamos a encontrar algunos ajustes interesantes como si el objeto es Opaco o Transparente. En este caso lo dejaremos como está (Opaque) y lo único que marcaremos será el Two Sided. Esto hará que el objeto pinte también sus caras internas, lo que conlleva eso sí, un coste extra. Tenlo en cuenta en el futuro, en este caso para el Cubo en cuestión, nos interesa que las caras internas también se vean cuando está disolviendo. 
 
Una vez marcado, vamos a crear algunas variables que usaremos. En primer lugar necesitaremos un valor comprendido entre 0 y 1 que se encargue de llevar el progreso disuelto. Será 0 cuando el objeto se vea por completo y 1 cuando esté completamente disuelto. Para eso en el BlackBoard crearemos un Vector1(que no es más que un simple número) y lo nombraremos como Dissolve Value por ejemplo. Para facilitarnos el trabajo, podemos cambiar el tipo de número con Mode. En nuestro caso está comprendido entre 0 y 1 por lo que elegiremos Slider y rellenaremos el min y el max con esos valores. 
 



 
 
 


A su vez, necesitaremos también un Color para el objeto, como en nuestro anterior Shader y un Color diferente para la parte que se esté disolviendo. Creamos ambas variables, estableciendo el Color para disolver cómo HDR si quieres que brille como el del gif (necesitarás también tener el paquete de post procesos y activar el Bloom). Por último necesitaremos un valor que indique el grosor que tendrá el dissolve. Podemos revisar el Gif para ver el grosor que tiene la parte que se está disolviendo. Creadas todas las variables en mi caso quedó así:
 



 
 
 


Para el efecto de disolver necesitamos en primer lugar una textura que genere ruido donde las zonas negras indiquen lo que llevamos disuelto y las zonas blancas lo que nos queda por disolver. Por suerte, como vimos antes, tenemos un nodo de ruido perfecto para este uso: Simple Noise, asique lo añadimos. Podemos cambiar el valor de Scale del nodo a nuestro gusto. Cuanto menor sea el valor más "zoom" hará el ruido. También vamos a necesitar el nodo Step que si tenías dudas de su uso, en este caso lo vas a entender perfectamente. Ahora unimos la salida de Simple Noise a la entrada Edge del Step.
 
 
 



 
 
 


Ahora podemos cambiar el valor del Step entre 0 y 1 para ver su utilidad real. Los valores de ruido que estén por debajo de ese valor devolverán 0 y los que estén por encima devolverán 1. Es decir cuando el Step sea 0 el objeto no se verá y cuando sea 1 se verá completamente. Justo lo que queremos que ocurra. Simplemente conectamos nuestra variable DissolveValue a la entrada In del Step. Para hacer pruebas vamos a colocar la salida del Step en el Albedo del PBR Master. 
 
 
 



 


Vamos a guardar y vamos a Añadir un cubo a nuestra escena. Crearemos un material con nuestro shader y se lo colocaremos al cubo. En nuestro material podremos cambiar el valor del DissolveValue. Como vemos el efecto se acerca a lo que buscamos, aunque tenemos dos problemas. Primero no se está disolviendo realmente ya que está pasando de negro a blanco simplemente. Y segundo que el efecto está al contrario, cuando el DissolveValue vale 0 debería verse el objeto completo y cuando está a 1 indica que el objeto está completamente disuelto. Vamos a volver a abrir el Shader Editor para solucionar ambas cosas. Primero vamos a hacer que la parte negra se convierta en transparente. Para ello simplemente tienes que conectar la salida del Step con el Alpha del PBR Master. También tendrás que activar el AlphaClip. Aunque el valor que entra por defecto es 1 tendrás que ponerle tu el valor a través de un nodo. Simplemente crea un nodo Integer (que es un número sin decimal) y conectalo a AlphaClip.
 



 
 
 


Para el segundo problema simplemente usaremos el nodo que comentamos anteriormente. OneMinus. Si a 1 le restamos el DissolveValue obtendremos la parte contraria, que es justo lo que necesitamos. 
 



 


Si guardamos y probamos comprobamos nuestro material ahora podemos ver que funciona como queriamos. Se disuelve de blanco a negro con el ruido que creamos. Solo nos falta añadirle color. Para ello volvemos al editor. Necesitamos pintar el borde que se disuelve y a raíz de ahí lo que tengamos a un lado del borde lo borramos y lo demás lo pintamos del color normal. Una forma de encontrar el borde es sumar el DissolveValue y el borde y restar por un lado el Step de la suma y por otro el Step del DissolveValue solo. Es más fácil de entender con una imagen (para que sea más visual he cambiado el valor default del Dissolve Value a 0.5):
 



 


 
 


Como vemos ahora tenemos el borde diferenciado, pero no lo estamos usando. Lo que vamos a hacer es pintar con los colores que creamos al principio. Una buena forma de hacerlo es usar Lerp. Podemos hacer que si la resta es 1(blanco) se coloree con el Color del Borde y si es 0(negro) el color sea el normal. Y esa salida del Lerp la conectamos a Albedo. 
 



 
 
 
Ahora podemos guardar y probar el shader. Si todo ha ido bien debería funcionar como esperábamos. Puedes cambiar a tu gusto los valores del material, como los colores o el borde. 
 
Si eres perfeccionista te darás cuenta de que si el borde es muy grande, pueden quedar algunos restos al disolverse. Esto podemos arreglarlo con un simple cambio. Sumando el valor del borde al dissolve antes de hacer el OneMinus. 
 
 
 



 


También podrías crear una variable para el Scale del Simple Noise. Así tendrías un valor más que podrías modificar desde fuera sin tener que cambiar el shader. Por último vamos a añadir una textura que se añada al color, así lo podremos usar en más objetos. Simplemente crea una variable de tipo Texture2D y arrastrala al grid con los demás nodos. Tendrás que sacar un nodo llamado Sample Texture 2D y arrastrar la textura a la entrada correspondiente. Luego solo queda multiplicar por el color normal y sustituirlo en la entrada A del Lerp anterior. 
 



 
Guardamos y desde el inspector del material añadimos la textura que queramos y habríamos terminado. 
 
No es la única forma de hacer este efecto, hay muchas otras, esta es la forma que yo usé. Espero que os sea útil. Cualquier duda que tengáis hacérmela saber y estaré encantado de ayudaros.  Nos vemos en el siguiente.

#15
Eventos / Unity Spain Game Jam
Julio 23, 2019, 06:49:03 PM
Hola a todos! 
No soy muy activo en el foro. Tampoco en el grupo de Telegram. Aún así de vez en cuando participo y una de las veces quizás me vine arriba y propuse la idea de crear una jam para la comunidad. Realmente me encanta el concepto de Game Jam. Si alguno no sabe lo que es (teniendo en cuenta que este foro es muy diverso, es posible), una Game Jam es un evento donde se te da un tiempo concreto para que realicesun videojuego. Para hacerlo más entretenido se añaden una serie de alicientes, como puede ser una temática en la que basar dicho videojuego o unas reglas que debes cumplir. Una vez termines el juego, lo compartes con los demás y entre todos votamos los mejores en una serie de categorías! Para mi una muy buena forma de demostrar lo que tienes y puedes hacer en un periodo de tiempo concreto. Al final si todo sale bien tendrás un juego/prototipo terminado y si no sale bien pues habrás aprendido muchas más cosas de las que esperabas en un principio.
Por eso, os invito a todos a que participeis. Información de la JAM:
Me gustaría que participase gente de todo tipo, independientemente de su nivel de conocimiento. Al final se trata de divertirse y aprender. Por ello, he pensado que la Jam durará más tiempo del habitual (suelen durar 48 horas).FECHA: 22 de Agosto - 31 de AgostoTEMA: Invisibility
 
Además del tema, habrá una serie de "extras" que si se cumplen se valorarán positivamente, pero que no son obligatorios.Categorías para votar:
 

  •    Diseño


  •    Programación


  •    Arte


  •    Sonido


  •    Originalidad


  •    Adaptación al tema


  •    Extras.



Más adelante pondré más información. Podéis apuntaros ya, desde aquí: https://itch.io/jam/unityspainjam