To keep snippets of code for Shaders. Just some stuff that I often use but also often forget because brain=poo

Unity Fragment Shader Cheat Sheet .cs

//https://neginfinity.bitbucket.io/   - a blog where I found how to do shadows for raymarched/raytraced primitives.
//https://docs.unity3d.com/Manual/SL-UnityShaderVariables.html
//https://github.com/TwoTailsGames/Unity-Built-in-Shaders/blob/master/CGIncludes/UnityCG.cginc - Most interesting stuff ;)
//https://github.com/TwoTailsGames/Unity-Built-in-Shaders/tree/master/CGIncludes
//https://docs.unity3d.com/Manual/SL-Shader.html
//http://developer.download.nvidia.com/CgTutorial/cg_tutorial_appendix_e.html
//https://unity3d.com/how-to/shader-profiling-and-optimization-tips
//https://docs.unity3d.com/Manual/SL-UnityShaderVariables.html
//http://www.deepskycolors.com/archive/2010/04/21/formulas-for-Photoshop-blending-modes.html
//http://www.iquilezles.org/blog/
//https://www.youtube.com/channel/UCcAlTqd9zID6aNX3TzwxJXg


// Material
 	    mat = new Material(shader);
            mat.hideFlags = HideFlags.HideAndDontSave;
            // Set blend mode to invert destination colors.
            mat.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.OneMinusDstColor);
            mat.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.Zero);
            // Turn off backface culling, depth writes, depth test.
            mat.SetInt("_Cull", (int)UnityEngine.Rendering.CullMode.Off);
            mat.SetInt("_ZWrite", 0);
            mat.SetInt("_ZTest", (int)UnityEngine.Rendering.CompareFunction.Always);

//Properties
	[PerRendererData][NoScaleOffset]_MainTex("Albedo", 2D) = "white" {} 
		// Image UI elements throw error in Build if Material(It's Shader) doesn't have _MainTex, so keep it here even if not used.
		// [PerRendererData] - For UI, to hide it from material inspector; 
		// [NoScaleOffset] - To Hide scale and offset editing window - usefult if they are not utilized in shader
		// Alternative Default Values: "white", "black", "gray", "bump", "red"
	[HDR]_Color("Color", Color) = (1,1,1,1)
	_SomeSlider("Reflectiveness or something", Range(0,1)) = 0
	[HideInInspector]_ProjTexPos("Screen Space Position", Vector) = (0,0,0,0)
		// [HideInInspector] - no need to show this in inspector
	_Test("Any value", float) = 1
		
	// Blend Modes:
		
		Blend SrcAlpha OneMinusSrcAlpha // Traditional transparency
		Blend One One // Additive
		Blend OneMinusDstColor One // Soft Additive
		
		
		
	// MULTICOMPILE & SHADER FEATURE
		shader_feature_local // Same as shader_feature, but only for current shader (if Set from Properties)
		multi_compile_local
	
		// Use _local when planning to use any of the following
	
		[KeywordEnum(None, Regular, Combined)]	BUMP ("Bump Map", Float) = 0
		#pragma shader_feature_local BUMP_NONE BUMP_REGULAR BUMP_COMBINED 
		
		//Toggle
		[Toggle(_BLABLA)] mattersWhenSettingInEditorFromScript ("Description for inspector.", Float) = 0  
		#pragma multi_compile_local ____ _BLABLA // Will Build all variations. (For changing via script) (___ = Also compile a version without any defines )
		#pragma shader_feature_local  ____ _BLABLA // Will Build only used variations. (Use this if you don't plan to change this from script)
		
		//Management from script
			// From script you can set this keywords
				if (isEnabled)
					material.EnableKeyword("_BLABLABLA");
				else 
					material.DisableKeyword("_BLABLABLA");
			// To make sure Unity Editor is showing it correctly:
				material.SetFloat("mattersWhenSettingInEditorFromScript", isEnabled ? 1 : 0);

			// You can also set it globally. But if Shader has it in it's properties, it will ignore the global value)
				Shader.EnableKeyword("_BLABLABLA")
		
		// Defines
			#define USE_FEATURE_X    // Must be before the include
			#include "Assets/FeatureCode.cginc"

			// Inside Feature Code
				#if defined(USE_FEATURE_X)
					// Feature code
				#endif
				
// Unity's main Build-In parameters
_WorldSpaceCameraPos
_WorldSpaceLightPos0   - Main Directional Light Direction
_ProjectionParams   w - clip length, can be used for fog
// PRecision & PErformance
		#pragma fragmentoption ARB_precision_hint_fastest  // or ARB_precision_hint_nicest
		// On some devices makes no difference. Nicest - if shader depends on precise calculations
					
//*****COMMON OPERATORS/FUNCTIONS*****
	fwidth(x), ddx(x), ddy(x) // The only operation that lets you get info on pixels "Next Door". It tells difference of pixels in this block (https://www.programmersought.com/article/71564489650/). 
	y = saturate(x); // Clamp x between 0 and 1
	floor(); // return smallest int part
	x % 1 // get fraction part
	log(Y)/log(X); // LOGxY   (LOGxY = Z | means that X to the power of Z equals Y | Log base X of Y is the power you need to raise X to get Y)
	atan(x,y) // returns an angle in [-Pi +Pi] range)	
	smoothstep (a, b , t); // Basically allows us to remap t from ab space to 01 space but with smoothing;
				// Returns 0 if t<a<b; 1 if t>b>a, interpolates in-between; Will reverse if b<a;
	x*x*(3.0 - (2.0*x)); // To apply smoothing when 0<=x<=1. (When applied to the function below will produce smoothstep).
	sharpstep(a, b, x) => saturate((x - a)/(b - a)); // Remap X to [A,B] sharply.

	float cheapstep(float x) {  // https://www.shadertoy.com/view/4ldSD2
	    x = 1.0 - x*x;	// MAD
	    x = 1.0 - x*x;	// MAD
	    return x;
	}

	step(a, x) // returns 1 if x>a, 0 - otherwise
		
	normal = normalize(cross(ddy(worldPos),ddx(worldPos)));	
				
	_MainTex_TexelSize // x,y=1.0/Size |  zw=width,length
	_MainTex_ST // x,y = Tiling,  z,w = Offset
	_ScreenParams // x is the width of the camera’s target texture in pixels
			//, y is the height of the camera’s target texture in pixels, z is 1.0 + 1.0/width and w is 1.0 + 1.0/height.

// Object center
	float4 objectOrigin = mul(_Object2World, float4(0.0,0.0,0.0,1.0) );
		
// Billboard Shader
	
	Use "DisableBatching" = "True" or GPUInstancing
	
float3x3 m = UNITY_MATRIX_M;
float objectScale = length(float3( m[0][0], m[1][0], m[2][0]));

o.pos = mul(UNITY_MATRIX_P,
		mul(UNITY_MATRIX_MV, float4(0.0, 0.0, 0.0, 1.0))
		+ float4(v.vertex.x, v.vertex.y, 0.0, 0.0)
* float4(objectScale, objectScale, 1.0, 1.0)
);
		
		
//*****COOL MATH*****
		

		
	// Circle from Uv
		float2 uv = (i.texcoord - 0.5);
		uv *= uv;
		float circle = smoothstep(0.25-softness, 0.25, uv.x + uv.y);
	
	// Nice sharp point light with smooth falloff
		sizeCoefficient/ distanceFromCenter;
	// Follaff in two direction
		1 / (abs(CENTER - position)*SHARPNESS + 0.01);
		
	// Gyroid 
 	float sdGyroid(float3 pos, float scale, float thickness, float bias) {
		pos *= scale;
    		return abs(dot(sin(pos), cos(pos.zxy))+bias)/scale - thickness;
	}
	
	// Optimisation when converting formulas
		float3 vec = float3(x,x,x);
		dot(vec,vec) = x * x * 3;

// Using smoothstep with ddx, ddy, fwidth
	const SMOOTHNESS = 5; // usually can be left constant after configured
	float offset = fwidth(uv);  // To see how big the image is on the screen (Bigger => Sharper transition)
	float pixelSmoothBox =  smoothstep(1, 1 - offset * SMOOTHNESS , distanceToEdge);


// Vertex Position Offset in World Space
	float4 worldPos = mul(unity_ObjectToWorld, float4(v.vertex.xyz, 1));
	// modify World Position
	v.vertex = mul(unity_WorldToObject, float4(worldPos.xyz, v.vertex.w));
	o.pos = UnityObjectToClipPos(v.vertex); // don't forget
	
// View Direction
  	float3 viewDir : TEXCOORD0; //v2f
  	o.viewDir.xyz = WorldSpaceViewDir(v.vertex); // vert
  	i.viewDir.xyz = normalize(i.viewDir.xyz); //frag

// World Normal
	o.normal.xyz = normalize(UnityObjectToWorldNormal(v.normal)); // vert

// World Position
	float3 wpos : TEXCOORD3;
	o.wpos = mul(unity_ObjectToWorld, v.vertex).xyz;
	// ------- To Modify In World Space:
		v.vertex += mul(unity_WorldToObject, offx,offy,offz, 0);

// Distance to camera
 	float toCamera = length(_WorldSpaceCameraPos - i.worldPos.xyz) - _ProjectionParams.y;

// Screen Position
	float4 screenPos : TEXCOORD1;                   // v2f (TEXCOORD can be 0,1,2, etc - the obly rule is to avoid duplication)
	o.screenPos = ComputeScreenPos(o.pos);       	// vert
	float2 screenUV = i.screenPos.xy / i.screenPos.w;     // frag (Returns in 01 range (if on screen))
	
 // Reflect:
  	float dotprod = max(0, dot(worldNormal, i.viewDir.xyz));
	float3 reflected = normalize(i.viewDir.xyz - 2 * (dotprod)*worldNormal);
	
// Random ()Hash
	float hash11(float p) {
	    p = fract(p * .1031);
	    p *= p + 33.33;
	    p *= p + p;
	    return fract(p);
	}
		
// Distance to a line:
	inline float DistToLine(float3 pos, float3 a, float3 b) {
		float3 pa = pos - a;
		float3 ba = b - a;
		float t = saturate(dot(pa, ba)/dot(ba,ba));
		return length(pa - ba * t);
	}

// Rotation (Pivot in center)
	
	float2 Rot(float2 uv, float angle) {
		float si = sin(angle);
		float co = cos(angle);
		return float2(co * uv.x - si * uv.y, si * uv.x + co * uv.y);
	}
	
	// Rotate By Quaternion
	float3 RotateVec(in float3 vec, in float4 q)
	{
		float3 crossA = cross(q.xyz, vec) + q.w * vec;
		vec += 2 * cross(q.xyz, crossA);
		return vec;
	}

	// Get Rotation from DDX DDY
	 float2 rotation = normalize(ddx(uv));

// Get Angle:
	const float pii = 3.14159265359;
	const float pi2 = pii * 2;
	float2 uv = i.texcoord.xy - 0.5;
	float angle = (atan2(uv.x, uv.y) + pii) / pi2
	
	// Clock Effect (how to wrap around 0)
	float clock = 0.1f/min(
			abs(time - pixelAngle),
			pi2 - abs(time - pixelAngle));

// Get Angle in 01 space
	// Option A:
	    float2 uv = IN.texcoord.xy - 0.5;
            const float PI2 = 3.14159265359 *2;
            float pixel_angle = atan2(uv.x, uv.y)/ PI2 + 0.5;
            float pixel_distance = length(uv)* 2;
            float2 uv2 = float2(pixel_angle, pixel_distance);

	// Option B: (Dont't remember but I think this helped me avoid some artifacs in some case)
	const float PI2 = 3.14159265359 * 2;
	float angle = atan2(-uv.x, -uv.y)+0.001;
	angle = saturate(max(angle,
		PI2 + min(0, angle)
		- max(0, angle*999999)
		)/ PI2);

// Cos/Sin to 01 space

	float lerp = (_CosTime.z + 1) * 0.5; // Time.x,y,z,w - from slowest to fastest
		
// Matrixes 
	// Rotate vector
	float3 wrldNormal = mul(unity_ObjectToWorld, float4(objNormal, 0));
	// Rotate point
	float3 wrldPos = mul(unity_ObjectToWorld, float4(objPos, 1));

					//*****SAMPLING*****
	
// To Apply Offset
	//#define TRANSFORM_TEX(uv,_NameTex) (uv.xy * _NameTex_ST.xy + _NameTex_ST.zw)
	uv = uv*_MainTex_ST.xy + _MainTex_ST.zw;  // _MainTex_ST needs to be defined in the variables section (not the Parameters section)
  	o.uv = TRANSFORM_TEX(v.texcoord, _MainTex); // Tile Offset needs to be declared (the line above)

// To do POINT Sampling (undo bilinear filtering):
	float4 _MainTex_TexelSize; // Texture Size (zw = width,heigth ; xy = 1/width, 1/height)
	float2 pointUV = (floor(uv * _MainTex_TexelSize.zw) + 0.5) * _MainTex_TexelSize.xy;

// Smooth Pixelation Sampling (Looks really cool)
	
	float2 perfTex = (floor(IN.texcoord.xy * _MainTex_TexelSize.zw) + 0.5) * _MainTex_TexelSize.xy;
	float2 off = (IN.texcoord.xy - perfTex);
        float wigth = length(fwidth(IN.texcoord.xy));
        float size = 0.01 / wigth;
	off = off * saturate((abs(off) * _MainTex_TexelSize.zw) * size * 2 - (size - 1));
        perfTex  += off;

	// To Also get the border:
	float2 diff = (abs(off) * _MainTex_TexelSize.zw);
	edge = saturate((diff * 2 - 1)*sharpness*0.1 + 1); // In some usages the are between pixels contains other pixels, then border needs to be less sharp to fully cover that area.
	float border = max(edge.x, edge.y);

// To Get MipLevel
	_MainTex_TexelSize.zw *= modifier; // Optional

	float2 px = _MainTex_TexelSize.z * ddx(uv);
	float2 py = _MainTex_TexelSize.w * ddy(uv);

	return (max(0, 0.5 * log2(max(dot(px, px), dot(py, py)))));

// Lerp between two transparent textures
	col.rgb = lerp(col1.rgb * col1.a, col2.rgb * col2.a, transition);
	col.a = lerp(col1.a, col2.a, transition);
	col.rgb /= col.a + 0.001;
// Parallax

	//v2f:
	float3 tangentViewDir : TEXCOORD5; // 5 or whichever is free

	//vert:
	float3x3 objectToTangent = float3x3(
		v.tangent.xyz,
		cross(v.normal, v.tangent.xyz) * v.tangent.w,
		v.normal
	);
	o.tangentViewDir = mul(objectToTangent, ObjSpaceViewDir(v.vertex));
	
	//frag
	i.tangentViewDir = normalize(i.tangentViewDir);
	i.tangentViewDir.xy /= (i.tangentViewDir.z + 0.42); 
		// or ..... /= (abs(o.tangentViewDir.z) + 0.42); to work on both sides of a plane
	uv -= i.tangentViewDir.xy * height;
		// Optionally multiply by Fresnel

					//********** SCREEN SPACE EFFECTS

// Tile a square to fill the screen:
	//f2v
		float2 screenParams : TEXCOORD1;
		float4 screenPos : TEXCOORD2;
	//vert:
		o.screenParams = float2(max(_ScreenParams.x / _ScreenParams.y, 1), max(1, _ScreenParams.y / _ScreenParams.x));
		o.screenPos = ComputeScreenPos(o.pos);
	//frag:
		i.screenPos.xy /= i.screenPos.w;
		float2 fitToScreen = i.screenPos.xy * i.screenParams;
		float4 col = tex2D(_MainTex, fitToScreen * tilsesCount); 

// Fit Sprite Sampling to Fill Screen Without stretching the texture:
	// In script (Could also be done in vert function):
 		float screenAspect = ((float)Screen.width) / Screen.height;
            	float texAspect = ((float)bgTex.width) / bgTex.height;

            	  Vector2 aspectCorrection = Vector2.one;

		if (screenAspect > texAspect)
			aspectCorrection.y = (texAspect / screenAspect);
		    else
			aspectCorrection.x = (screenAspect / texAspect);
	// In Shader   
		float2 uv = (screenUV.xy - 0.5)*aspectCorrection.xy + 0.5;
	
			// **** FOR LIGHT/COLOR SHADING
 
  // Tangent Transformation:
  	float3 tspace0 : TEXCOORD3;
	float3 tspace1 : TEXCOORD4;
	float3 tspace2 : TEXCOORD5;
  
  	// ...... vert
		float3 wTangent = UnityObjectToWorldDir(v.tangent.xyz);
		float tangentSign = v.tangent.w * unity_WorldTransformParams.w;
		float3 wBitangent = cross(wNormal, wTangent) * tangentSign;
		o.tspace0 = half3(wTangent.x, wBitangent.x, wNormal.x);
		o.tspace1 = half3(wTangent.y, wBitangent.y, wNormal.y);
		o.tspace2 = half3(wTangent.z, wBitangent.z, wNormal.z);
   
   	// ..... frag
		float3 tnormal = UnpackNormal(tex2D(_BumpMap, TRANSFORM_TEX(i.texcoord, _BumpMap)));
    		worldNormal.x = dot(i.tspace0, tnormal);
		worldNormal.y = dot(i.tspace1, tnormal);
		worldNormal.z = dot(i.tspace2, tnormal);

// Shadow
    SHADOW_COORDS(2)
    TRANSFER_SHADOW(o);
    float shadow = SHADOW_ATTENUATION(i);

// Color Bleed (https://www.quizcanners.com/single-post/2018/04/02/Color-Bleeding-in-Shader)
	float3 mix = col.gbr + col.brg;
	col.rgb += mix * mix*amount; // amount = 0.02



//Get proximity to culling edge (to apply fog as far as possible, for example)
	float dist01 = 1- saturate((_ProjectionParams.z - length(o.worldPos.xyz - _WorldSpaceCameraPos.xyz)) / _ProjectionParams.z);

// Using Depth 
	// vert:
	o.screenPos = ComputeScreenPos(o.pos); 
	COMPUTE_EYEDEPTH(o.screenPos.z);

	// frag:
	float2 screenUV = i.screenPos.xy / i.screenPos.w; 
	float depth = SAMPLE_DEPTH_TEXTURE(_CameraDepthTexture, screenUV);
	float sceneZ = LinearEyeDepth(UNITY_SAMPLE_DEPTH(depth));
	
		// Solve contact A
			float partZ = i.screenPos.z;
			float fade = smoothstep(0,1, _Softness (sceneZ - partZ));
		// Variant:
			float distance = -mul(UNITY_MATRIX_V, float4(newPos,1)).z;
			float fade = saturate(distance - partZ);
	

// Decal (Uses camera depth)
	float2 screenUv = i.screenPos.xy / i.screenPos.w;

	float3 ray = normalize(i.worldPos - _WorldSpaceCameraPos);
	float orthoToPresp = dot(ray, -UNITY_MATRIX_V[2].xyz);

	float depth = SAMPLE_DEPTH_TEXTURE(_CameraDepthTexture, screenPos);
	depth = Linear01Depth(depth) * _ProjectionParams.z / orthoToPresp; // Getting distance from camera

	float3 projectedPos = _WorldSpaceCameraPos + ray * depth;
	float3 cubeSpacePos = mul(unity_WorldToObject, float4(projectedPos,1)).xyz; // xz + 0.5 could be used for UV

// Normal vector for Decal
	float3 normal = normalize(cross(ddy(cubeSpacePos), ddx(cubeSpacePos))); // From Target Surface
	float3 textureNormal = normalize(mul(float3(bumpMap.r, 0.5, bumpMap.g), unity_WorldToObject)); // From Bump Map

// Sample Shadow at Random position	
float GetShadowAttenuation(float3 worldPos)
{
#if defined(SHADOWS_CUBE)
    {
        unityShadowCoord3 shadowCoord = worldPos - _LightPositionRange.xyz;
        float result = UnitySampleShadowmap(shadowCoord);
        return result;
    }
#elif defined(SHADOWS_SCREEN)
    {
#ifdef UNITY_NO_SCREENSPACE_SHADOWS
        unityShadowCoord4 shadowCoord = mul(unity_WorldToShadow[0], worldPos);
#else
        unityShadowCoord4 shadowCoord = ComputeScreenPos(mul(UNITY_MATRIX_VP, float4(worldPos, 1.0)));
#endif
        float result = unitySampleShadow(shadowCoord);
        return result;
    }
#elif defined(SHADOWS_DEPTH) && defined(SPOT)
    {
        unityShadowCoord4 shadowCoord = mul(unity_WorldToShadow[0], float4(worldPos, 1.0));
        float result = UnitySampleShadowmap(shadowCoord);
        return result;
    }
#else
    return 1.0;
#endif  
}

// To Output shadow from Shadow Pass
float CalculateShadowDepth(float3 worldPos)
{
	float4 projPos = mul(UNITY_MATRIX_VP, float4(worldPos, 1));
	projPos = UnityApplyLinearShadowBias(projPos);
	return projPos.z / projPos.w;
}

// To output depth from fragment function
float CalculateFragmentDepth(float3 worldPos)
{
	float4 depthVec = mul(UNITY_MATRIX_VP, float4(worldPos, 1.0));
	return depthVec.z / depthVec.w;
}

This is great, thanks for sharing. 👍