Space Puck Shader

Energy.shader

// Upgrade NOTE: replaced 'mul(UNITY_MATRIX_MVP,*)' with 'UnityObjectToClipPos(*)'



Shader "Unlit/Energy"
{
	Properties	//Defines the properties for the shader, shown the GUI and used by the SubShader. Default values are defined here. 
	{
		_MainTex ("Texture", 2D) = "white" {}
		_MainColor ("Color", Color) = (0.5, 0.5, 0.5, 1)
		_Multiplier ("Multiplier", float) = 1
		_WaveStrength ("Wave Strength", float) = 1
		_Speed ("Speed", range(0.1,6)) = 1 
		_Amp ("Amplitude", float) = 1 
		_Offset ("Offset", float) = 0.2
	}
	SubShader	//Where the actual shader starts.  References the properties or game values. 
	{
		Tags { //How the engine treats the shader, just for wildcards like transparency and stuff. 
			"IgnoreProjector" = "True"
			"Queue" = "Transparent"
			"RenderType" = "Transparent"
		}


		Pass	//The "Shader shader bit" -Dickie 2017 You can have multiple passes which can work with or in place of other passes. The bit that controls the mesh and meterial. Pretty much...
		{	

			//Blend One One		Addative shading
			Blend SrcAlpha OneMinusSrcAlpha //Using the Alpha channel in 8 Bit, not 1 Bit. 
			Cull Off //Turn off back face culling, Cull back/front. Front would be used for outlines. 
			ZWrite Off	//Writing to the Z-buffer, can be used for masking with lighting with Z-Test. 

			CGPROGRAM //Starting the CG code, talking in hard numbers and moving away from pre-compiled wrappers. 
			#pragma vertex vert	//Defining shader as Vertex shader, not surface shader (which is actually just a fancy fragment shader)
			#pragma fragment frag //So the Vert/Frag bit is what we're calling each thing. Vertex could be called "Steve" or "Vertex the 3rd"

			#include "UnityCG.cginc" //Refering to an external script that holds functions and such. Such as storing a wind function for grass and trees. 	

			struct appdata //Calling model from information from the game. 
			{
				float4 vertex : POSITION;
				float2 uv : TEXCOORD0; //Call UV data
				float3 normal : NORMAL;
			};

			struct v2f //Storing vertex information so it can be read by the fragment shader
			{
				float2 uv : TEXCOORD0;
				float4 vertex : SV_POSITION;
				float sine : TEXCOORD1;
				float offsetsine : TEXCOORD2;
			};

			sampler2D _MainTex;
			float4 _MainTex_ST; //Float is defining the type of variable you're using
			float _Multiplier;	//_Thing is calling the properties to used by the Pass
			float4 _MainColor;	//This is hard core CG lingo
			float _WaveStrength;
			float _Speed;
			float _Amp;
			float _Offset;
			
			v2f vert (appdata v)//You're plugging App Data in and calling it V, which is then used as Vertex Data, and then sending that to v2f
			{
				v2f o; //Creating a variable to define V2F, sure.
				o.sine = sin(_Time.y*_Speed + v.uv.x*_Amp);	//_Time is time, _Time.x is half speed, and Time.y is real time. Getting a wave and storing it. 
				o.offsetsine = sin((_Time.y+_Offset)*2*_Speed + v.uv.x*_Amp)*2;
				v.vertex.xyz += o.sine * (_WaveStrength*v.normal); //How much you effect the Vertex Pos with the Sine wave
				o.vertex = UnityObjectToClipPos(v.vertex);	//Converting the vertices from local space to world space. 
				//float3 normalDir = UnityObjectToWorldNormal(v.normal);
				
				o.uv = TRANSFORM_TEX(v.uv, _MainTex); //Defining texture size and offset using the float4
				return o; //The end of the function, here is the v2f, goodbye my child :,(
			}
			
			fixed4 frag (v2f i, float facing : VFACE) : COLOR //Affecting the faces that are rendered. 
			{
				float isFrontFace = (facing >= 0 ? 1 : 0); //Only I know what this does. It's a secret. 
				float faceSign = (facing >= 0 ? 1 : -1);
				// sample the texture
				// return i.sine;

				fixed4 col = tex2D(_MainTex, i.uv); //Creating the Col variable, Calling texture and UV data
				col.rgb *= _MainColor; //Takes and defines the RGB data from the texture, affects the alpha by the multiplier, then applies the colour tint. 
				col.a *= saturate(col.a*(_Multiplier*i.offsetsine) + col.a);
				return col; //Wrap that shit
			}
			ENDCG //We done!
		}
	}
}