The card window/depth effect shown is created using a Stencil Shader and Unity URP's Render Features. Using these features together allows us to pick and choose what is shown or hidden in the window from the Unity Editor.
These tornados are made entirely in EmberGen and then rendered and customized in Unity URP as an animated flipbook. EmberGen allows us to export emission and motion vecture textures which can be used in VFX Graph in Unity to smooth out the animation and control color.
The animation and interaction of each grass blade is processed using a Unity Bursted Job to make use of multiple cpu cores. The final results are then rendered with RenderMeshInstanced.
This customizable stylized water shader is made with Shader Graph using a few different techniques. We make use of the opaque and depth textures Unity provides of the scene to create refractions and depth fade/color. Time was spent reseraching existing planar reflection solutions for URP and we decided on using a script provided by Unity, editing it, and then incorporating into our Shader Graph.
Various fire effects made for games and shorts using different techniques. The cube fire is a particle system of cube meshes. The middle fire is a single texture that is procedurally generated using noise with Shader Graph. The first blue fire uses two animated flipbooks, one for fire and one for smoke, and is implemented in Unity's VFX Graph.
When creating voxel/lowpoly games and shorts we needed a solution for wind on foliage. This is a relatively simple Shader Graph that displaces the vertices of objects. We can control how far up or down on a plant the vertices are affected.
Animated cubes controlled via algorithms in code. In this example we are using Perlin Noise to move the cubes. The cubes are gpu instanced using Unity's DrawMeshInstanced method.
These laser walls were created for Re-Shyft as an added effect for when objects spawn into the world. It was a good experiment on transparencies and using a Depth Texture to create effects.
The portal effect shown is a combo of three systems. A distortion shadergraph using the fresnel effect, a particle system, and a script to control the effect and rotation.
These health bars are all GPU instanced and controlled via Material Property Blocks in Unity. The color and value of each health bar uses Instanced Properties. This lets us individually control the health bars colors and values while still drawing all of them in a single draw call. The shader is a Shader Graph that is then manually modified to include GPU / Property Instancing.
The video shown is the first part of our level generation system for our new major game. We created a scriptable object in Unity that we can stack algorithms together on in order to generate a texture that is then used to place environment tiles. In this example the two dark lines use a weighted random walk algorithm to move from either edge until they meet each other. Weighted random noise is then added on top of that and smoothed out using a Cellular Automata technique.