WIP: Realtime Adaptive Snow

January 5, 1970 richard

Flythrough:

I encourage you to read through the thread in the UE4 forums, as I’ve already answered some interesting questions there and provided a little bit of insight.

A testversion of the snow can be downloaded here.

WIP Images and Videos (newest first):

Reworked almost every part of mask generation to be less clunky. Multiple material functions for easy modularity.

Usage demos with vertex color, adding an attribute to the system and changing the base material.

Added wetness:

Tested material on a Landscape with tessellation:

(Result: Tessellation not good on Landscape, maybe try Parallax Occlusion Mapping)

Added slower melting in shadows based on vertex normal and mean sun direction:

First test of the snow with one of Epic’s Open World Demo materials as base:

Research on how to do snow sparkles without creating a custom shading model:

Uncategorized

Graduation Project

January 4, 1970 richard

Practical Project for the Bachelor Honours Thesis

UE4, Blueprints, UMG, Proof of Concept

Trailer of the Final System:

This weather system manages different weather states and the transitions between them. It can control every parameters that is added to the system and can be used for every kind of art style.

While I created the entire interface functionality using UMG, all the graphical elements and icons were designed and created by Sümeyye Icel who was a fellow student.

Technical Features:

Creating a Custom Weather State

Here you can see how a custom weather state is created with the interface that was specifically created to control the system. This interface would not be accessable by the user in the final product. The new weather state integrates seamlessly with the existing states and can use it’s own specific transition curve to determine how the transition from other state to this one is happening.

Adding a new Parameter to the System

The following video shows, how a new parameter is integrated into the exsiting system. The parameters were authored in this proof of concept with a combination of a Google Spreadsheet and a Data Table in Unreal. At this point the system was focused on material parameters, therefore a Blueprint would create an instance of a struct and fill it with all nessecary data of a parameter. This resulted in an array of parameter structs that were used by the interface and the core system to set the values in a specific Material Parameter Collection (MPC) and the interface respectively. These MPCs could then be used in materials or it’s values could be accessed by another blueprint or code which would use these values to change gameplay behaviors.

A good example would be traction in a racing game when it’s raining. The traction could be controlled by the amount of rain specified by a weather state. Or you could create a traction parameter which could be controlled by changing weather independently of the rain amount.

Future of the System:

The system has in my opinion great potential and I want to create a more refined and advanced version in the future. This future version should be a plugin for both UE4 and Unity and should have very precise scientific calculations for the sun, moon and night sky positions. Further I would want to do more research on the transtition and using an AI with Markov Chains that is based on real world weather data to be able to do completely autonomous transitions between the defined weather states or even create states on the fly based on more general parameters like season, humidity and temperature.

If you want to know more, contact me or read the honours thesis. I also created a thread in the UE4 forums and started to create better snow for the second version of the system.

VFX

Unity Stylized VFX

January 3, 1970 richard

BlendAdd and Per-Particle Offset in Unity

Learning VFX, Unity3D 5, Stylized

After seeing this GDC talk on the VFX in Diablo III, I wanted to learn how to do something similar.

The lava-effect is based on the winning entry of Riot’s Art Contest on polycount in the category VFX.

To create the splines for the lava-effect I followed this amazing tutorial on editor friendly splines for Unity and did a few modifications so that they work with animations.

BlendAdd

At first I searched for a way to implement the Blend Mode mentioned in the talk. As it turns out, it is very easy to do and should be one of the default blend modes available in every larger engine.

Blend One OneMinusSrcAlpha

1	Blend One OneMinusSrcAlpha

Per-Particle Offset

After having the blend mode done in a custom Unity shader I went on to search for a way to realize the per-particle UV offset that was also mentioned in the GDC talk. Even though Unity has no way of doing per-particle UV offsets with the default particle system, my goal was, to find a solution that works without 3rd party plugins and using solely the default particles.

This workaroung for this problem is absolutely not the best one and I do not recommend using it for anything else than experimentation!

The only way I came up with, without having access to the Unity engine source code and using only the default particle system, was a simple script and a custom shader.

using UnityEngine;
using System.Collections;

public class PerParticleOffset : MonoBehaviour {

ParticleSystem psys;
ParticleSystem.Particle[] particles_S;
	
	// Use this for initialization
	void Start () {
		psys = gameObject.GetComponent<ParticleSystem>();
		particles_S = new ParticleSystem.Particle[psys.maxParticles];
	}
	
	// Update is called once per frame

	void LateUpdate () {

		int partNUM = psys.GetParticles(particles_S);

		for (int i = 0; i < partNUM; i++)
		{
			//Calculate the current lifetime of the particle.
			float pLifeTime = particles_S[i].startLifetime - particles_S[i].lifetime;
			float pRealLifeTime = 1 / particles_S[i].startLifetime * pLifeTime;

			Color32 newcolor = new Color32(255,255,255,255);

			//R is used for gradient over lifetime.
			newcolor.r = (byte)(pRealLifeTime * 255);

			//G maybe used for color by speed.
			newcolor.g = (byte)(255);

			//B is used for random uv offset in x.
			if (particles_S[i].startColor.b == (byte)255) 
			{
				newcolor.b = (byte)(Random.Range(0, 254));
			}
			else
			{
				newcolor.b = particles_S[i].startColor.b;
			}

			//A is used for random uv offset in y.
			if (particles_S[i].startColor.a == (byte)255) 
			{
				newcolor.a = (byte)(Random.Range(0, 254));
			}
			else
			{
				newcolor.a = particles_S[i].startColor.a;
			}

			particles_S[i].startColor = newcolor;
			
		}

		psys.SetParticles(particles_S, partNUM);
	}
}

using UnityEngine;

using System.Collections;

public class PerParticleOffset : MonoBehaviour {

ParticleSystem psys;

ParticleSystem.Particle[] particles_S;

// Use this for initialization

void Start () {

psys = gameObject.GetComponent<ParticleSystem>();

particles_S = new ParticleSystem.Particle[psys.maxParticles];

}

// Update is called once per frame

void LateUpdate () {

int partNUM = psys.GetParticles(particles_S);

for (int i = 0; i < partNUM; i++)

{

//Calculate the current lifetime of the particle.

float pLifeTime = particles_S[i].startLifetime - particles_S[i].lifetime;

float pRealLifeTime = 1 / particles_S[i].startLifetime * pLifeTime;

Color32 newcolor = new Color32(255,255,255,255);

//R is used for gradient over lifetime.

newcolor.r = (byte)(pRealLifeTime * 255);

//G maybe used for color by speed.

newcolor.g = (byte)(255);

//B is used for random uv offset in x.

if (particles_S[i].startColor.b == (byte)255)

{

newcolor.b = (byte)(Random.Range(0, 254));

}

else

{

newcolor.b = particles_S[i].startColor.b;

}

//A is used for random uv offset in y.

if (particles_S[i].startColor.a == (byte)255)

{

newcolor.a = (byte)(Random.Range(0, 254));

}

else

{

newcolor.a = particles_S[i].startColor.a;

}

particles_S[i].startColor = newcolor;

}

psys.SetParticles(particles_S, partNUM);

}

It uses the Blue and Alpha channel of the initial color to offset along U and V for each particle individually. This on the other hand makes the particle Color over Lifetime and Color by Speed unusable as anything else than values of 1 would change the offsets. To compensate this I created the shader with two additional color parameters. One for a lifetime of 0 and one for a lifetime of 1 and used the Red channel of the initial color as lifetime input, to have at least a linear transition between a start and end color. The same could be done for Color by Speed which would use the Green channel of the initial color and another two color parameters in the shader.

Shader "Particles/PPOffset"
{
	Properties
	{
		_MainTex ("Maks1", 2D) = "white" {}
		_GradientA("GradientA", Color) = (0, 0, 0, 1)
		_GradientB("GradientB", Color) = (0, 0, 0, 1)
		[Enum(One,1,SrcAlpha,5)] _SrcBlend ("SrcBlend", Float) = 1
		[Enum(OneMinusSrcAlpha,10,DstAlpha,7)] _DstBlend ("DstBlend", Float) = 7
		_AmountX ("AmountX", Float) = 0
		_AmountY ("AmountY", Float) = 0
		_PanSpeed ("PanSpeed", Float) = 0
	}
	SubShader
	{
		//Transparent
		Tags
		{
			"Queue" = "Transparent"
			"IgnoreProjectors" = "True"
			"RenderType" = "Transparent"
		}

		Lighting Off
		ZWrite Off
		Cull Off

		Blend [_SrcBlend] [_DstBlend]
		
		Pass
		{
			CGPROGRAM
			#pragma vertex vert
			#pragma fragment frag
			// make fog work
			#pragma multi_compile_fog
			
			#include "UnityCG.cginc"

			//Init shader parameters
			//Textures
			sampler2D _MainTex;
			float4 _MainTex_ST;
					
			//Colors
			half4 _GradientA;
			half4 _GradientB;

			//Other
			float _AmountX;
			float _AmountY;
			float _PanSpeed;

			struct appdata
			{
				float4 vertex : POSITION;
				float2 uv0 : TEXCOORD0;
				float4 color : COLOR;

			};

			struct v2f
			{
				float4 color : COLOR;
				float2 uv0 : TEXCOORD0;
				float4 vertex : SV_POSITION;
			};
			

			
			v2f vert (appdata v)
			{
				v2f o;
				o.vertex = mul(UNITY_MATRIX_MVP, v.vertex);
		
				//Get Random UV offset from vertex color. 
				//This is set per particle in the script.
				_MainTex_ST.z += v.color.b;
				_MainTex_ST.w += v.color.a;
				
				//Pan UV coordinates based on _Amount and _PanSpeed.
				_MainTex_ST.z += (_Time.y * _AmountX) * _PanSpeed;
				_MainTex_ST.w += (_Time.y * _AmountY) * _PanSpeed;
				
				//Transform UV coordinates with the input of _MainTex (Tiling / Offset).
				o.uv0.xy = TRANSFORM_TEX(v.uv0, _MainTex);
				o.color = v.color;
				
				return o;
			}
			
			float4 frag (v2f i) : COLOR
			{
				// sample the texture
				fixed4 tex = tex2D(_MainTex, i.uv0);

				//Color over Lifetime lerp based on per particle vertex color.
				//Currently supports only 2 colors at positions 0 and 1.
				half4 lerpS = lerp(_GradientA, _GradientB, i.color.r);

				return half4(lerpS * tex);
			}
			ENDCG
		}
	}
}

100

101

102

103

104

105

106

Shader "Particles/PPOffset"

{

Properties

{

_MainTex ("Maks1", 2D) = "white" {}

_GradientA("GradientA", Color) = (0, 0, 0, 1)

_GradientB("GradientB", Color) = (0, 0, 0, 1)

[Enum(One,1,SrcAlpha,5)] _SrcBlend ("SrcBlend", Float) = 1

[Enum(OneMinusSrcAlpha,10,DstAlpha,7)] _DstBlend ("DstBlend", Float) = 7

_AmountX ("AmountX", Float) = 0

_AmountY ("AmountY", Float) = 0

_PanSpeed ("PanSpeed", Float) = 0

}

SubShader

{

//Transparent

Personal Projects

January 2, 1970 richard

Partial Reproduction of an Architectural Visualization by Koola

Date: around 8. Sept. 2014

After seeing this video by koola I wanted to find out, what it takes to create a similar indoor scene and learn about sunlight shining through windows without using a directional light.

One-Day-Project : Whisky Glass

Date: 19. Sept. 2015

Modelled in Maya, Displacement Map sculpted with Z-Brush, Rendered with V-Ray

Glass_Small02_mod

Uncategorized

Student Team Project – Racing Game

January 1, 1970 richard

Bachelor Team Project – “OffLimits”

Time trial racing game, UnrealEngine4, Prototype

Responsibilities:

Blueprint programming
- Gameplay
- Custom vehicle movement
- User interface functionality
VFX for vehicle and environment
Vehicle Design

This is the second project I convinced my team to use version control. I decided to use Perforce as it is integrated into UE4 by default and handles large asset sizes pretty well. As we were a team of artists I had to teach everyone the basic principles of version control and how to apply them using Perforce.

Gameplay:

Technical Features:

Custom Vehicle Movement

The custom vehicle movement uses the default UE4 physics and forces. The green arrows/dots show the points at which the forces for the hovering are applied.