[Add] All in one shader

Assets/Plugins/AllIn13DShader/Shaders/ShaderLibrary/AllIn13DShaderCore.hlsl

@@ -0,0 +1,558 @@
+#ifndef ALLIN13DSHADER_CORE_INCLUDED
+#define ALLIN13DSHADER_CORE_INCLUDED
+
+float4 GetBaseColor(EffectsData data)
+{
+	float4 res = float4(0, 0, 0, 1);
+
+#ifdef _TRIPLANAR_MAPPING_ON
+	float4 colFront = 0;
+	float4 colSide = 0;
+	float4 colTop = 0;
+	float4 colDown = 0;
+
+	#ifdef _STOCHASTIC_SAMPLING_ON
+		float2 dx = 0;
+		float2 dy = 0;
+
+		float stochasticScale = ACCESS_PROP_FLOAT(_StochasticScale);
+		float stochasticSkew = ACCESS_PROP_FLOAT(_StochasticSkew);
+		float4x3 stochasticOffsets_front = getStochasticOffsets(UV_FRONT(data), stochasticScale, stochasticSkew);
+		STOCHASTIC_SAMPLING_NO_DEF_DD(_MainTex, UV_FRONT(data), stochasticOffsets_front, colFront)
+	
+		float4x3 stochasticOffsets_side = getStochasticOffsets(UV_SIDE(data), stochasticScale, stochasticSkew);
+		STOCHASTIC_SAMPLING_NO_DEF_DD(_MainTex, UV_SIDE(data), stochasticOffsets_side, colSide)
+	
+		float4x3 stochasticOffsets_top = getStochasticOffsets(UV_TOP(data), stochasticScale, stochasticSkew);
+		STOCHASTIC_SAMPLING_NO_DEF_DD(_TriplanarTopTex, UV_TOP(data), stochasticOffsets_top, colTop)
+		
+		float4x3 stochasticOffsets_down = getStochasticOffsets(UV_DOWN(data), stochasticScale, stochasticSkew);
+		STOCHASTIC_SAMPLING_NO_DEF_DD(_MainTex, UV_DOWN(data), stochasticOffsets_down, colDown)
+	#else
+		colFront = SAMPLE_TEX2D(_MainTex, UV_FRONT(data));
+		colSide = SAMPLE_TEX2D(_MainTex, UV_SIDE(data));
+	
+		colTop = SAMPLE_TEX2D(_TriplanarTopTex, UV_TOP(data));
+		colDown = SAMPLE_TEX2D(_MainTex, UV_DOWN(data));
+	#endif
+	
+	float faceDown = smoothstep(ACCESS_PROP_FLOAT(_FaceDownCutoff), 1.0, UV_DOWN_WEIGHT(data));
+	colTop = lerp(colTop, colDown, faceDown);
+
+	colFront *= UV_FRONT_WEIGHT(data);
+	colSide *= UV_SIDE_WEIGHT(data);
+	colTop *= UV_TOP_WEIGHT(data);
+	
+	res = colFront + colSide + colTop;
+#else
+	#ifdef _STOCHASTIC_SAMPLING_ON
+		float4x3 stochasticOffsets = getStochasticOffsets(MAIN_UV(data), ACCESS_PROP_FLOAT(_StochasticScale), ACCESS_PROP_FLOAT(_StochasticSkew));
+		STOCHASTIC_SAMPLING(_MainTex, MAIN_UV(data), stochasticOffsets, res)
+	#else
+		res = SAMPLE_TEX2D(_MainTex, MAIN_UV(data));
+	#endif
+#endif
+
+	return res;
+}
+
+float3 GetNormalWS(EffectsData data, FragmentData i, AllIn1DecalData decalData)
+{
+	float3 res = data.normalWS;
+
+#ifdef _STOCHASTIC_SAMPLING_ON
+	float4x3 stochasticOffset = 0;
+	float2 dx = 0;
+	float2 dy = 0;
+#endif
+
+#ifdef _NORMAL_MAP_ON
+	#ifdef _TRIPLANAR_MAPPING_ON
+		#ifdef _TRIPLANARNORMALSPACE_LOCAL
+			float3 normalReference = data.normalOS;
+		#else 
+			float3 normalReference = data.normalWS;
+		#endif
+
+		float4 sampledNormal_side = 0;
+		float4 sampledNormal_top = 0;
+		float4 sampledNormal_front = 0;
+		float4 sampledNormal_down = 0;
+
+		#ifdef _STOCHASTIC_SAMPLING_ON
+			float stochasticScale	= ACCESS_PROP_FLOAT(_StochasticScale);
+			float stochasticSkew	= ACCESS_PROP_FLOAT(_StochasticSkew);	
+			float4x3 stochasticOffsets_side = getStochasticOffsets(NORMAL_UV_SIDE(data), stochasticScale, stochasticSkew);
+			STOCHASTIC_SAMPLING_NO_DEF_DD(_NormalMap, NORMAL_UV_SIDE(data), stochasticOffsets_side, sampledNormal_side)
+			
+			float4x3 stochasticOffsets_top = getStochasticOffsets(NORMAL_UV_TOP(data), stochasticScale, stochasticSkew);
+			STOCHASTIC_SAMPLING_NO_DEF_DD(_TriplanarTopNormalMap, NORMAL_UV_TOP(data), stochasticOffsets_top, sampledNormal_top)
+		
+			float4x3 stochasticOffsets_front = getStochasticOffsets(NORMAL_UV_FRONT(data), stochasticScale, stochasticSkew);
+			STOCHASTIC_SAMPLING_NO_DEF_DD(_NormalMap, NORMAL_UV_FRONT(data), stochasticOffsets_front, sampledNormal_front)
+		#else
+			sampledNormal_side	= SAMPLE_TEX2D(_NormalMap, NORMAL_UV_SIDE(data));
+			sampledNormal_top	= SAMPLE_TEX2D(_TriplanarTopNormalMap, NORMAL_UV_TOP(data));
+			sampledNormal_front = SAMPLE_TEX2D(_NormalMap, NORMAL_UV_FRONT(data));
+			sampledNormal_down	= SAMPLE_TEX2D(_NormalMap, UV_DOWN(data));
+		#endif
+		
+		float faceDown = smoothstep(ACCESS_PROP_FLOAT(_FaceDownCutoff), 1.0, UV_DOWN_WEIGHT(data));
+		sampledNormal_top = lerp(sampledNormal_top, sampledNormal_down, faceDown);
+		float tNormalYWeight = lerp(ACCESS_PROP_FLOAT(_TopNormalStrength), ACCESS_PROP_FLOAT(_NormalStrength), faceDown);
+
+		float3 tnormalX = UnpackNormal(sampledNormal_side);
+		tnormalX.xy *= ACCESS_PROP_FLOAT(_NormalStrength);
+
+		float3 tnormalY = UnpackNormal(sampledNormal_top);
+		tnormalY.xy *= tNormalYWeight;
+
+		float3 tnormalZ = UnpackNormal(sampledNormal_front);
+		tnormalZ.xy *= ACCESS_PROP_FLOAT(_NormalStrength);
+
+		tnormalX = float3(tnormalX.xy + normalReference.zy, normalReference.x);
+		tnormalY = float3(tnormalY.xy + normalReference.xz, normalReference.y);
+		tnormalZ = float3(tnormalZ.xy + normalReference.xy, normalReference.z);
+	
+		res = normalize(
+			tnormalX.zyx * UV_SIDE_WEIGHT(data) +
+			tnormalY.xzy * UV_TOP_WEIGHT(data) +
+			tnormalZ.xyz * UV_FRONT_WEIGHT(data)
+		);
+
+		#ifdef ALLIN1_DECALS_READY_TO_USE
+			res = lerp(decalData.normalTS, res, decalData.mask);
+		#endif
+
+	#else
+	
+		float4 sampledNormal = 0;
+		#ifdef _STOCHASTIC_SAMPLING_ON
+			float4x3 stochasticOffsets = getStochasticOffsets(MAIN_UV(data), ACCESS_PROP_FLOAT(_StochasticScale), ACCESS_PROP_FLOAT(_StochasticSkew));
+			STOCHASTIC_SAMPLING_NO_DEF_DD(_NormalMap, MAIN_UV(data), stochasticOffsets, sampledNormal)
+		#else
+			sampledNormal = SAMPLE_TEX2D(_NormalMap, MAIN_UV(data));
+		#endif
+		
+		float3 tnormal = UnpackNormal(sampledNormal);
+		tnormal.xy *= ACCESS_PROP_FLOAT(_NormalStrength); 
+		
+		#if defined(ALLIN1_DECALS_READY_TO_USE) && defined(ALLIN1_DECAL_MODE_SCREEN_SPACE)
+			tnormal = BlendingUnpackedNormals(tnormal, decalData.unpackedNormal);
+		#endif
+		
+		res.x = dot(i.tspace0, tnormal);
+		res.y = dot(i.tspace1, tnormal);
+		res.z = dot(i.tspace2, tnormal);
+    
+		#if defined(ALLIN1_DECALS_READY_TO_USE) && defined(ALLIN1_DECAL_MODE_DBUFFER)
+			res = lerp(decalData.normalTS, res, decalData.mask);
+		#endif
+	
+		res = normalize(res);
+	#endif
+
+	#if defined(_TEXTURE_BLENDING_ON)
+		
+		#ifdef _TEXTUREBLENDINGSOURCE_TEXTURE
+			float3 maskColor = SAMPLE_TEX2D(_TexBlendingMask, /*data.mainUV*/MAIN_UV(data)).rgb;
+		#else
+			float3 maskColor = data.vertexColor.rgb;
+		#endif
+
+		#ifdef _TEXTUREBLENDINGMODE_RGB
+			float2 texGUV = SIMPLE_CUSTOM_TRANSFORM_TEX(data.rawMainUV, _BlendingTextureG);
+			float2 texBUV = SIMPLE_CUSTOM_TRANSFORM_TEX(data.rawMainUV, _BlendingTextureB);
+			
+			float4 sampledNormalG = 0;
+			float4 sampledNormalB = 0;
+			#ifdef _STOCHASTIC_SAMPLING_ON
+				STOCHASTIC_SAMPLING_COMPLETE_NO_DEF_DD(_BlendingNormalMapG, texGUV, stochasticOffset, sampledNormalG)
+				STOCHASTIC_SAMPLING_COMPLETE_NO_DEF_DD(_BlendingNormalMapB, texBUV, stochasticOffset, sampledNormalB)
+			#else
+				sampledNormalG = SAMPLE_TEX2D(_BlendingNormalMapG, texGUV);
+				sampledNormalB = SAMPLE_TEX2D(_BlendingNormalMapB, texBUV);
+			#endif
+			
+			float3 tnormalG = UnpackNormal(sampledNormalG);
+			float3 tnormalB = UnpackNormal(sampledNormalB);
+			
+			float3 normalG = GetNormalWSFromNormalMap(
+				tnormalG, ACCESS_PROP_FLOAT(_NormalStrength), 
+				i.tspace0, i.tspace1, i.tspace2);
+
+			float3 normalB = GetNormalWSFromNormalMap(
+				tnormalB, ACCESS_PROP_FLOAT(_NormalStrength), 
+				i.tspace0, i.tspace1, i.tspace2);
+
+			res = normalize(lerp(res, normalG, maskColor.g));
+			res = normalize(lerp(res, normalB, maskColor.b));
+		#else
+			float2 texWhiteUV = SIMPLE_CUSTOM_TRANSFORM_TEX(data.rawMainUV, _BlendingTextureWhite);
+			
+			float4 sampledNormalWhite = 0;
+			#ifdef _STOCHASTIC_SAMPLING_ON
+				STOCHASTIC_SAMPLING_COMPLETE_NO_DEF_DD(_BlendingNormalMapWhite, texWhiteUV, stochasticOffset, sampledNormalWhite)
+			#else
+				sampledNormalWhite = SAMPLE_TEX2D(_BlendingNormalMapWhite, texWhiteUV);
+			#endif
+			
+			float3 tnormalWhite = UnpackNormal(sampledNormalWhite);
+			float3 normalWhite = GetNormalWSFromNormalMap(
+				tnormalWhite, ACCESS_PROP_FLOAT(_NormalStrength), 
+				i.tspace0, i.tspace1, i.tspace2);
+			float maskLuminosity = GetLuminanceRaw(float4(maskColor.rgb, 1.0));
+			maskLuminosity = saturate(maskLuminosity);
+			res = lerp(res, normalWhite, maskLuminosity);
+		#endif
+	#endif
+#endif
+
+
+
+
+	return res;
+}
+
+#if defined(_FLAT_NORMALS_ON)
+float3 GetFlatNormalWS(float3 originalNormal, float3 positionWS)
+{
+	float3 res = originalNormal;
+	float3 worldPosDDX = ddx(positionWS);
+	float3 worldPosDDY = ddy(positionWS);
+
+	float3 flatNormal = normalize(cross(worldPosDDY, worldPosDDX));
+
+	float3 blendedNormal = lerp(originalNormal, flatNormal, ACCESS_PROP_FLOAT(_FlatNormalsBlend));
+	blendedNormal = normalize(blendedNormal);
+	res = blendedNormal;
+
+	return res;
+}
+#endif
+
+
+EffectsData CalculateEffectsData_ShadowCaster(FragmentDataShadowCaster i)
+{
+	EffectsData res;
+	
+	INIT_EFFECTS_DATA(res)
+	
+	res.vertexColor = 1.0;
+	res.mainUV = SCALED_MAIN_UV(i);
+	res.rawMainUV = i.uv2;
+	res.shaderTime = i.shaderTime;
+	
+	res.uvMatrix = 0;
+	res.uvMatrix._m00_m01 = i.mainUV.xy;
+	res.normalOS = normalize(i.normalOS);
+	res.normalWS = normalize(i.normalWS);
+	
+	res.vertexOS = i.positionOS;
+	res.vertexWS = i.positionWS;
+	
+	return res;
+}
+
+EffectsData CalculateEffectsData(FragmentData i, AllIn1DecalData decalData)
+{
+	EffectsData res;
+	
+	res.vertexColor = float4(
+		VERTEX_COLOR_R(i), 
+		VERTEX_COLOR_G(i), 
+		VERTEX_COLOR_B(i), 
+		VERTEX_COLOR_A(i));
+
+	res.normalizedScreenSpaceUV = float2(0, 0);
+#ifdef URP_PASS
+	res.normalizedScreenSpaceUV = GetNormalizedScreenSpaceUV(i.pos);
+#endif
+
+	res.vertexColorLuminosity = GetLuminanceRaw(float4(res.vertexColor.r, res.vertexColor.g, res.vertexColor.b, 1.0));
+	res.vertexColorLuminosity = saturate(res.vertexColorLuminosity);
+
+	res.mainUV = SCALED_MAIN_UV(i);
+	res.rawMainUV = RAW_MAIN_UV(i);
+	
+	res.vertexOS = POSITION_OS(i);
+	res.vertexWS = POSITION_WS(i);
+	res.vertexVS = mul(UNITY_MATRIX_MV, float4(res.vertexOS, 1.0)).xyz;
+
+	res.normalOS = normalize(NORMAL_OS(i));
+	res.normalWS = normalize(i.normalWS);
+	res.viewDirWS = normalize(VIEWDIR_WS(i));
+
+	res.tangentWS = 0;
+	res.bitangentWS = 0;
+#ifdef REQUIRE_TANGENT_WS
+	res.tangentWS = normalize(TANGENT_WS(i));
+	res.bitangentWS = normalize(cross(res.normalWS.xyz, res.tangentWS.xyz));
+#endif
+
+#ifdef _NORMAL_MAP_ON
+	res.uv_normalMap = UV_NORMAL_MAP(i);
+#endif
+	
+	res.lightColor = GetMainLightColorRGB();
+	res.lightDir = GetMainLightDir(POSITION_WS(i));
+	
+	res.projPos = 0;
+	res.sceneDepthDiff = 0;
+	res.normalizedDepth = 0;
+#ifdef REQUIRE_SCENE_DEPTH
+	res.projPos = i.projPos;
+	res.sceneDepthDiff = GetSceneDepthDiff(i.projPos);
+	res.normalizedDepth = GetNormalizedDepth(i.projPos);
+#endif
+
+	res.pos = i.pos;
+
+	res.camDistance = 0;
+#ifdef REQUIRE_CAM_DISTANCE
+	float3 positionVS = mul(UNITY_MATRIX_V, float4(POSITION_WS(i), 1.0)).xyz;
+	res.camDistanceViewSpace = -positionVS.z;
+	res.camDistance = distance(POSITION_WS(i), _WorldSpaceCameraPos);
+#endif
+
+#ifdef _UV_DISTORTION_ON
+	res.uv_dist = SIMPLE_CUSTOM_TRANSFORM_TEX(i.mainUV.xy, _DistortTex);
+#endif
+
+	res.shaderTime = SHADER_TIME(i);
+	
+	res.uvMatrix = 0;
+	res.uvMatrix._m00_m01 = i.mainUV.xy;
+
+#ifdef _NORMAL_MAP_ON
+	res.uv_matrix_normalMap = 0;
+	MAIN_NORMAL_UV(res) = UV_NORMAL_MAP(i);
+#endif
+
+	res.uvDiff = UV_DIFF(i);
+	
+	res._ShadowCoord = i._ShadowCoord;
+
+#ifdef HAS_PBR_PROPERTIES
+	res.metallic = ACCESS_PROP_FLOAT(_Metallic) * decalData.MAOSAlpha + decalData.metallic;
+	res.smoothness = ACCESS_PROP_FLOAT(_Smoothness) * decalData.MAOSAlpha + decalData.smoothness;
+#endif
+	
+	return res;
+}
+
+
+float2 ApplyUVEffects_VertexStage(float2 inputUV, float3 vertexWS, float4 projPos, float3 shaderTime)
+{
+	float2 res = inputUV;
+
+#ifdef _SCREEN_SPACE_UV_ON
+	res = ScreenSpaceUV(res, vertexWS, projPos);
+#endif
+	
+#ifdef _SCROLL_TEXTURE_ON
+	res = ScrollTexture(res, shaderTime);
+#endif
+
+#ifdef _HAND_DRAWN_ON
+	res = HandDrawn(res, shaderTime);
+#endif
+
+	return res;
+}
+
+EffectsData ApplyUVEffects_FragmentStage(EffectsData data)
+{
+	EffectsData res = data;
+
+#ifdef _TRIPLANAR_MAPPING_ON
+	res = TriplanarMapping(res);
+#endif
+
+#ifdef _WAVE_UV_ON
+	res = WaveUV(res);
+#endif
+
+#ifdef _UV_DISTORTION_ON
+	res = UVDistortion(res);
+#endif
+
+#ifdef _PIXELATE_ON
+	res = Pixelate(res);
+#endif
+
+	return res;
+}
+
+float4 ApplyVertexEffects(float4 vertexOS, float3 normalOS, float3 shaderTime)
+{
+	float4 res = vertexOS;
+	
+#ifdef _VERTEX_SHAKE_ON
+	res.xyz = VertexShake(res.xyz, shaderTime);
+#endif
+
+#ifdef _VERTEX_INFLATE_ON
+	res.xyz = VertexInflate(res.xyz, normalOS, shaderTime);
+#endif
+
+#ifdef _VERTEX_DISTORTION_ON
+	res.xyz = VertexDistortion(res.xyz, normalOS, shaderTime);
+#endif
+
+#ifdef _VOXELIZE_ON
+	res.xyz = VertexVoxel(res.xyz);
+#endif
+
+#ifdef _GLITCH_ON
+	res.xyz = Glitch(res.xyz, shaderTime);
+#endif
+
+#ifdef _WIND_ON
+	res.xyz = Wind(res.xyz, shaderTime);
+#endif
+
+	return res;
+}
+
+float4 ApplyColorEffectsBeforeLighting(float4 inputColor, EffectsData data)
+{
+	float4 res = inputColor;
+
+#ifdef _ALBEDO_VERTEX_COLOR_ON
+	res = AlbedoVertexColor(res, data);
+#endif
+
+#ifdef _TEXTURE_BLENDING_ON
+	res = TextureBlending(res, data);
+#endif
+
+#ifdef _HOLOGRAM_ON
+	res = Hologram(res, data);
+#endif
+
+#ifdef _HEIGHT_GRADIENT_ON
+	res = HeightGradient(res, data);
+#endif
+
+#ifdef _HUE_SHIFT_ON
+	res.rgb = HueShift(res.rgb);
+#endif
+
+#ifdef _MATCAP_ON
+	float3 matcap = Matcap(data);
+	
+	#ifdef _MATCAPBLENDMODE_MULTIPLY
+		float3 colorWithMatcapApplied = res.rgb * matcap;
+	#else
+		float3 colorWithMatcapApplied = matcap;
+	#endif
+
+	res.rgb = lerp(res.rgb, colorWithMatcapApplied, ACCESS_PROP_FLOAT(_MatcapBlend));
+#endif
+
+#ifdef _POSTERIZE_ON
+	res.rgb = Posterize(res.rgb);
+#endif
+
+#ifdef _CONTRAST_BRIGHTNESS_ON
+	res.rgb = ContrastBrightness(res.rgb);
+#endif
+
+#if defined(_GREYSCALE_ON) && defined(_GREYSCALESTAGE_BEFORELIGHTING)
+	res.rgb = Greyscale(res.rgb);
+#endif
+
+#if defined(_RIM_LIGHTING_ON) && defined(_RIMLIGHTINGSTAGE_BEFORELIGHTING)
+	res.rgb = Rim(res.rgb, data);
+#endif
+
+#if defined(_COLOR_RAMP_ON) && defined(_COLORRAMPLIGHTINGSTAGE_BEFORELIGHTING)
+	res = ColorRamp(res, data);
+#endif
+
+#if defined(_RIM_LIGHTING_ON) && defined(_RIMLIGHTINGSTAGE_BEFORELIGHTINGLAST)
+	res.rgb = Rim(res.rgb, data);
+#endif
+	
+	return res;
+}
+
+float4 ApplyColorEffectsAfterLighting(float4 inputColor, EffectsData data)
+{
+	float4 res = inputColor;
+	
+#ifdef _SUBSURFACE_SCATTERING_ON
+	res = SubsurfaceScattering(inputColor, data);
+#endif
+
+#ifdef _HIT_ON
+	res = Hit(res);
+#endif
+
+#ifdef _HIGHLIGHTS_ON
+	res.rgb = Highlights(res.rgb, data);
+#endif
+
+#if defined(_DEPTH_COLORING_ON)
+	res = DepthColoring(res, data);
+#endif
+
+#if defined(_RIM_LIGHTING_ON) && defined(_RIMLIGHTINGSTAGE_AFTERLIGHTING)
+	res.rgb = Rim(res.rgb, data);
+#endif
+
+#if defined(_GREYSCALE_ON) && !defined(_GREYSCALESTAGE_BEFORELIGHTING)
+	res.rgb = Greyscale(res.rgb);
+#endif
+
+#ifdef _INTERSECTION_GLOW_ON
+	res.rgb = IntersectionGlow(res, data).rgb;
+#endif
+
+#if defined(_COLOR_RAMP_ON) && !defined(_COLORRAMPLIGHTINGSTAGE_BEFORELIGHTING)
+	res = ColorRamp(res, data);
+#endif
+
+	return res;
+}
+
+float4 ApplyAlphaEffects(float4 inputColor,
+	float2 uv, float2 uv2, float3 worldPos, 
+	float sceneDepthDiff, float camDistance, float4 screenPos)
+{
+	float4 res = inputColor;
+	
+#ifdef _FADE_ON
+		float2 selectedUV;
+		#if defined(_FADEUVSET_UV1)
+			selectedUV = uv;
+		#elif defined(_FADEUVSET_UV2)
+			selectedUV = uv2;
+		#else
+			selectedUV = worldPos.xy;
+		#endif
+		
+		res = Fade(res, selectedUV);
+	#endif
+#endif
+
+#ifdef _INTERSECTION_FADE_ON
+	res = IntersectionFade(res, sceneDepthDiff);
+#endif
+
+#ifdef _ALPHA_ROUND_ON
+	res.a = round(res.a);
+#endif
+
+	float camFadeDistanceNormalized = 1.0;
+#ifdef _FADE_BY_CAM_DISTANCE_ON
+	res = FadeByCamDistance(res, camDistance, camFadeDistanceNormalized);
+#endif
+
+#if defined(_DITHER_ON) && !defined(SHADOW_CASTER_PASS)
+	res = Dither_float4(res, screenPos, camFadeDistanceNormalized);
+#endif
+
+	return res;
+}

Assets/Plugins/AllIn13DShader/Shaders/ShaderLibrary/AllIn13DShaderCore.hlsl.meta

@@ -0,0 +1,14 @@
+fileFormatVersion: 2
+guid: 2dc05823453a1374da5366de267bb792
+ShaderIncludeImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 316173
+  packageName: All In 1 3D-Shader
+  packageVersion: 2.72
+  assetPath: Assets/Plugins/AllIn13DShader/Shaders/ShaderLibrary/AllIn13DShaderCore.hlsl
+  uploadId: 865720

Assets/Plugins/AllIn13DShader/Shaders/ShaderLibrary/AllIn13DShaderHelper_BIRP.hlsl

@@ -0,0 +1,445 @@
+#ifndef ALLIN13DSHADER_HELPER_BIRP_INCLUDED
+#define ALLIN13DSHADER_HELPER_BIRP_INCLUDED
+
+#include "AutoLight.cginc"
+
+#define OBJECT_TO_WORLD_MATRIX unity_ObjectToWorld
+
+//#if !defined(LIGHTMAP_ON) && defined(SHADOWS_SCREEN)
+//	#if defined(SHADOWS_SHADOWMASK) && !defined(UNITY_NO_SCREENSPACE_SHADOWS)
+//		#define ADDITIONAL_MASKED_DIRECTIONAL_SHADOWS 1
+//	#endif
+//#endif
+
+#ifdef REQUIRE_SCENE_DEPTH
+
+	UNITY_DECLARE_DEPTH_TEXTURE(_CameraDepthTexture);
+
+	float GetRawDepth(float4 projPos)
+	{
+		//float res = SAMPLE_DEPTH_TEXTURE_PROJ(_CameraDepthTexture, UNITY_PROJ_COORD(projPos));
+		float res = tex2Dproj(_CameraDepthTexture, projPos);
+		return res;
+	}
+
+	float GetLinearDepth01(float4 projPos)
+	{
+		float rawDepth = GetRawDepth(projPos);
+		float res = Linear01Depth (rawDepth);
+
+		return res;
+	}
+
+	float GetSceneDepthDiff(float4 projPos)
+	{
+		float rawDepth = GetRawDepth(projPos);
+		float res = LinearEyeDepth(rawDepth) - projPos.z;
+		return res;
+	}
+
+#endif
+
+float3 GetNormalWS(float3 normalOS)
+{
+	float3 normalWS = UnityObjectToWorldNormal(normalOS);
+	return normalWS;
+}
+
+float3 GetViewDirWS(float3 vertexWS)
+{
+	float3 res = UnityWorldSpaceViewDir(vertexWS);
+	return res;
+}
+
+float3 GetPositionVS(float3 positionOS)
+{
+	float3 res = UnityObjectToViewPos(positionOS);
+	return res;
+}
+
+float3 GetPositionWS(float4 positionOS)
+{
+	return mul(unity_ObjectToWorld, positionOS).xyz;
+}
+
+float3 GetPositionOS(float4 positionWS)
+{
+	return mul(unity_WorldToObject, positionWS);
+}
+
+float3 GetDirWS(float4 dirOS)
+{
+	return mul(unity_ObjectToWorld, float4(dirOS.xyz, 0));
+}
+
+float3 GetDirOSFloat3(float3 dirOS)
+{
+	return mul(unity_WorldToObject, float4(dirOS.xyz, 0));
+}
+
+float3 GetDirOS(float4 dirOS)
+{
+	return mul(unity_WorldToObject, dirOS);
+}
+
+float3 GetMainLightDir(float3 vertexWS)
+{
+#ifdef _LIGHTMODEL_FASTLIGHTING
+	float3 mainLightDir = global_lightDirection;
+#else
+	float3 mainLightDir = normalize(_WorldSpaceLightPos0.xyz - vertexWS * _WorldSpaceLightPos0.w);
+#endif
+
+	return mainLightDir;
+}
+
+float3 GetMainLightColorRGB()
+{
+#ifdef _LIGHTMODEL_FASTLIGHTING
+	float3 res = global_lightColor.rgb;
+#else
+	float3 res = _LightColor0.rgb;
+#endif
+
+	return res;
+}
+
+float2 GetSSAO(float2 normalizedScreenSpaceUV, float alpha)
+{
+	float2 res = float2(1, 1);
+	return res;
+}
+
+float FadeShadows (float3 worldPos, float shadowAtten, AllIn1GI gi) 
+{
+	float res = shadowAtten;
+#if defined(SHADOWS_SHADOWMASK)
+	float bakedAttenuation = UnitySampleBakedOcclusion(gi.uvLightmap, worldPos);
+	float zDist = dot(_WorldSpaceCameraPos.xyz - worldPos, UNITY_MATRIX_V[2].xyz);
+	float shadowFadeDistance = UnityComputeShadowFadeDistance(worldPos, zDist);
+	float shadowFade = UnityComputeShadowFade(shadowFadeDistance);
+	
+	res = UnityMixRealtimeAndBakedShadows(shadowAtten, bakedAttenuation, shadowFade);
+#endif
+
+	return res;
+}
+
+float GetShadowAttenuation(EffectsData effectsData, AllIn1GI gi)
+{ 
+	float res = 1;
+
+#if !defined(_LIGHTMODEL_FASTLIGHTING)
+	UNITY_LIGHT_ATTENUATION(attenuation, effectsData, effectsData.vertexWS);
+	#if !defined(FORWARD_ADD_PASS)
+		attenuation = FadeShadows(effectsData.vertexWS, attenuation, gi);
+	#endif
+	
+	res = attenuation;
+#endif
+
+	return res;
+}
+
+AllIn1LightData GetPointLightData(float3 vertexWS, float3 normalWS, float3 lightPositionWS, float3 lightColor, float pointLightAtten, EffectsData effectsData, AllIn1GI gi)
+{
+	AllIn1LightData lightData;
+
+	float3 lightVec = lightPositionWS - vertexWS;
+	float3 lightDir = normalize(lightVec);
+
+	float atten = 1 / (1 + dot(lightVec, lightVec) * pointLightAtten);
+
+	lightData.lightColor = lightColor;
+	lightData.lightDir = lightDir;
+	
+#ifdef _RECEIVE_SHADOWS_ON
+	lightData.realtimeShadow = GetShadowAttenuation(effectsData, gi);
+#else
+	lightData.realtimeShadow = 1.0;
+#endif
+	lightData.distanceAttenuation = atten;
+	
+	lightData.shadowColor = /*lerp(0, 1.0, lightData.realtimeShadow * lightData.distanceAttenuation)*/lightData.realtimeShadow;
+	lightData.layerMask = 1.0;
+
+	return lightData;
+}
+
+AllIn1LightData GetMainLightData(float3 vertexWS, EffectsData effectsData, AllIn1GI gi)
+{
+	AllIn1LightData lightData;
+	
+	#if defined(SUBTRACTIVE_LIGHTING)
+		lightData.lightColor = 0;
+		lightData.lightDir = GetMainLightDir(vertexWS);
+		lightData.realtimeShadow = 1.0;
+		lightData.distanceAttenuation = 1.0;
+		lightData.shadowColor = 1.0;
+	#else
+		lightData.lightColor = GetMainLightColorRGB();
+		lightData.lightDir = GetMainLightDir(vertexWS);
+
+		#if defined(_LIGHTMODEL_NONE)
+			lightData.realtimeShadow = 1.0;
+		#else
+			#ifdef _RECEIVE_SHADOWS_ON
+			lightData.realtimeShadow = GetShadowAttenuation(effectsData, gi);
+				#if defined(_RECEIVEDSHADOWSTYPE_STYLIZED) && !defined(FORWARD_ADD_PASS)
+					lightData.realtimeShadow = AntiAliasing(lightData.realtimeShadow, ACCESS_PROP_FLOAT(_ShadowCutoff));
+				#endif
+			#else
+			lightData.realtimeShadow = 1.0;
+			#endif
+		#endif
+		
+		#ifdef _LIGHTMODEL_FASTLIGHTING
+			lightData.shadowColor = 1.0;
+		#else
+			#ifdef FORWARD_ADD_PASS
+			lightData.shadowColor = lightData.realtimeShadow;
+			#else
+			lightData.shadowColor = lerp(SHADOW_COLOR, 1.0, lightData.realtimeShadow);
+			#endif
+		#endif
+
+		lightData.distanceAttenuation = 1.0;
+	#endif
+
+	lightData.layerMask = 1.0;
+
+	return lightData;
+}
+
+float3 GetPointLightPosition(int index)
+{
+	float3 pointLightPosition = float3(unity_4LightPosX0[index], unity_4LightPosY0[index], unity_4LightPosZ0[index]);
+	return pointLightPosition;
+}
+
+AllIn1LightData GetPointLightData(int index, float3 vertexWS, float3 normalWS, EffectsData effectsData, AllIn1GI gi)
+{
+	return GetPointLightData(vertexWS, normalWS, GetPointLightPosition(index), unity_LightColor[index], unity_4LightAtten0[index], effectsData, gi);
+}
+
+FragmentDataShadowCaster GetClipPosShadowCaster( /*VertexData v*/VertexData v, FragmentDataShadowCaster o)
+{
+	//float4 res = 0;
+//#if defined(SHADOWS_CUBE) && !defined(SHADOWS_CUBE_IN_DEPTH_TEX)
+//		// Rendering into point light (cubemap) shadows
+//		//#define TRANSFER_SHADOW_CASTER_NOPOS(o,opos) o.vec = mul(unity_ObjectToWorld, v.vertex).xyz - _LightPositionRange.xyz; opos = UnityObjectToClipPos(v.vertex);
+//		//#define SHADOW_CASTER_FRAGMENT(i) return UnityEncodeCubeShadowDepth ((length(i.vec) + unity_LightShadowBias.x) * _LightPositionRange.w);
+
+//		float3 vec = mul(unity_ObjectToWorld, v.vertex).xyz - _LightPositionRange.xyz;
+//		res = UnityObjectToClipPos(v.vertex);
+//#else
+//		// Rendering into directional or spot light shadows
+//	res = UnityClipSpaceShadowCasterPos(v.vertex, v.normal);
+//	res = UnityApplyLinearShadowBias(res);
+//	#endif
+
+	//res = UnityClipSpaceShadowCasterPos(v.vertex.xyz, v.normal);
+	//res = UnityApplyLinearShadowBias(res);
+	
+	TRANSFER_SHADOW_CASTER_NORMALOFFSET(o);
+	return o;
+	
+	//return res; 
+} 
+
+//float GetShadowAttenuation(FragmentData i, float3 vertexWS)
+//{
+//	//float shadowAttenuation = UNITY_SHADOW_ATTENUATION(i, vertexWS);
+
+//	//float3 lightCoord = mul(unity_WorldToLight, float4(vertexWS, 1)).xyz;
+// //   fixed shadow = UNITY_SHADOW_ATTENUATION(i, vertexWS);
+// //   float res = tex2D(_LightTexture0, dot(lightCoord, lightCoord).rr).r * shadow;
+
+//	/*TODO: Fix this*/
+//	//shadowAttenuation = 1.0;
+
+//	UNITY_LIGHT_ATTENUATION(attenuation, i, vertexWS);
+	
+//	return attenuation;
+//}
+
+ShadowCoordStruct GetShadowCoords(VertexData v, float4 clipPos, float3 vertexWS, float2 uvLightmap)
+{
+	ShadowCoordStruct res;
+
+	res.pos = clipPos;
+	res._ShadowCoord = 0;
+	
+	UNITY_TRANSFER_SHADOW(res, uvLightmap);
+	
+	return res;
+}
+ 
+float3 GetLightmap(float2 uvLightmap, EffectsData data)
+{
+	float3 res = 0.0;
+#if defined(_AFFECTED_BY_LIGHTMAPS_ON) && defined(LIGHTMAP_ON)
+	res = DecodeLightmap(UNITY_SAMPLE_TEX2D(unity_Lightmap, uvLightmap));
+	#ifdef SUBTRACTIVE_LIGHTING
+		float attenuation = GetShadowAttenuation(data);
+		float ndotl = saturate(dot(data.normalWS, _WorldSpaceLightPos0.xyz));
+		float3 shadowedLightEstimate =
+				ndotl * (1 - attenuation) * _LightColor0.rgb;
+		float3 subtractedLight = res - shadowedLightEstimate;
+		subtractedLight = max(subtractedLight, unity_ShadowColor.rgb);
+		subtractedLight = lerp(subtractedLight, res, _LightShadowData.x);
+	
+		res = subtractedLight;
+	#endif
+#endif
+
+	return res;
+}
+
+float3 GetAmbientColor(EffectsData data)
+{
+	float3 res = float3(0, 0, 0);
+
+#ifdef _CUSTOM_AMBIENT_LIGHT_ON
+	res = ACCESS_PROP_FLOAT4(_CustomAmbientColor).rgb;
+#else
+	res = ShadeSH9(float4(data.normalWS, 1.0));
+#endif
+	
+	return res;
+}
+
+AllIn1GI CalculateGI(float2 uvLightmap, EffectsData data)
+{
+	AllIn1GI res;
+	INIT_GI(res);
+
+#if defined(LIGHTMAP_ON)
+	res.diffuse = GetLightmap(uvLightmap, data);
+#else
+	res.diffuse = GetAmbientColor(data);
+#endif
+
+#if defined(SHADOWS_SHADOWMASK)
+	res.shadowMask = UnitySampleBakedOcclusion(uvLightmap, data.vertexWS);
+#endif
+
+	res.uvLightmap = uvLightmap;
+
+	return res;
+}
+
+//float GetFogFactor(FragmentData fragmentData)
+//{
+//	float res = 0;
+
+//#if defined(FOG_LINEAR) || defined(FOG_EXP) || defined(FOG_EXP2)
+//	UNITY_TRANSFER_FOG(fragmentData, fragmentData.pos);
+//	res = fragmentData.fogCoord;
+//#endif
+	
+//	return res;
+//}
+
+float GetFogFactor(float4 clipPos)
+{
+	float res = 0;
+#if defined(FOG_LINEAR) || defined(FOG_EXP) || defined(FOG_EXP2)
+	FogStruct fogStruct;
+	UNITY_TRANSFER_FOG(fogStruct, clipPos);
+	res = fogStruct.fogCoord;
+#endif
+	
+	return res;
+}
+
+
+#if defined(FOG_ENABLED)
+float4 CustomMixFog(float fogFactor, float4 col)
+{
+	float4 res = col;
+	UNITY_APPLY_FOG(fogFactor, res);
+	return res;
+}
+#endif
+
+#ifdef REFLECTIONS_ON
+
+float3 BoxProjection (
+	float3 direction, float3 position,
+	float4 cubemapPosition, float3 boxMin, float3 boxMax
+) {
+	#if UNITY_SPECCUBE_BOX_PROJECTION
+		UNITY_BRANCH
+		if (cubemapPosition.w > 0) {
+			float3 factors =
+				((direction > 0 ? boxMax : boxMin) - position) / direction;
+			float scalar = min(min(factors.x, factors.y), factors.z);
+			direction = direction * scalar + (position - cubemapPosition);
+		}
+	#endif
+	return direction;
+}
+
+float3 GetReflectionsSimple(float3 worldRefl, float cubeLod, float3 positionWS)
+{
+	float3 reflUV0 = BoxProjection(worldRefl, positionWS, unity_SpecCube0_ProbePosition, unity_SpecCube0_BoxMin, unity_SpecCube0_BoxMax);
+	float4 probe0HDR = UNITY_SAMPLE_TEXCUBE_LOD(unity_SpecCube0, reflUV0, cubeLod);
+	float3 probe0 = DecodeHDR(probe0HDR, unity_SpecCube0_HDR);
+
+
+	float3 res = probe0;
+#if UNITY_SPECCUBE_BLENDING
+	float interpolator = unity_SpecCube0_BoxMin.w;
+
+	if(interpolator < 0.99999)
+    {
+		float3 reflUV1 = BoxProjection(worldRefl, positionWS, unity_SpecCube1_ProbePosition, unity_SpecCube1_BoxMin, unity_SpecCube1_BoxMax);
+		float4 probe1HDR = UNITY_SAMPLE_TEXCUBE_SAMPLER_LOD(unity_SpecCube1, unity_SpecCube0, reflUV1, cubeLod);
+		float3 probe1 = DecodeHDR(probe1HDR, unity_SpecCube1_HDR);
+                    
+        res = lerp(probe1, probe0, interpolator);
+	}
+	else
+	{
+		res = probe0;
+	}
+#endif
+
+	return res;
+}
+
+float3 GetSkyColor(float3 positionWS, float2 normalizedScreenSpaceUV, 
+	float3 normalWS, float3 viewDirWS, float cubeLod)
+{
+	float3 worldRefl = normalize(reflect(-viewDirWS, normalWS));
+	
+	float3 res = GetReflectionsSimple(worldRefl, cubeLod, positionWS);
+
+#ifdef _REFLECTIONS_TOON
+	float posterizationLevel = lerp(2, 20, ACCESS_PROP_FLOAT(_ToonFactor));
+	res = floor(res * posterizationLevel) / posterizationLevel;
+#endif
+
+	res *= ACCESS_PROP_FLOAT(_ReflectionsAtten);
+
+	return res;
+}
+#endif
+
+float3 ShadeSH(float4 normalWS)
+{
+	float3 res = ShadeSH9(normalWS);
+	return res;
+}
+
+
+#define NUM_ADDITIONAL_LIGHTS 4;
+
+#define OBJECT_TO_CLIP_SPACE(v) UnityObjectToClipPos(v.vertex)
+#define OBJECT_TO_CLIP_SPACE_FLOAT4(pos) UnityObjectToClipPos(pos)
+#define ALLIN1_APPLY_CROSSFADE(input) \
+	float2 __vpos = i.projPos.xy / i.projPos.w * _ScreenParams.xy; \
+	UNITY_APPLY_DITHER_CROSSFADE(__vpos);
+
+#endif

Assets/Plugins/AllIn13DShader/Shaders/ShaderLibrary/AllIn13DShaderHelper_BIRP.hlsl.meta

@@ -0,0 +1,14 @@
+fileFormatVersion: 2
+guid: 3b763fe4d437215438f3b41484c21752
+ShaderIncludeImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 316173
+  packageName: All In 1 3D-Shader
+  packageVersion: 2.72
+  assetPath: Assets/Plugins/AllIn13DShader/Shaders/ShaderLibrary/AllIn13DShaderHelper_BIRP.hlsl
+  uploadId: 865720

Assets/Plugins/AllIn13DShader/Shaders/ShaderLibrary/AllIn13DShaderHelper_URP.hlsl

@@ -0,0 +1,629 @@
+#ifndef ALLIN13DSHADER_HELPER_URP_INCLUDED
+#define ALLIN13DSHADER_HELPER_URP_INCLUDED
+
+#define NUM_ADDITIONAL_LIGHTS GetNumAdditionalLights();
+
+#define OBJECT_TO_WORLD_MATRIX GetObjectToWorldMatrix()
+
+#if defined(ALLIN1_DECALS_SUPPORT) && defined(_DBUFFER)
+	#define ALLIN1_DECALS_READY_TO_USE
+	
+	#if defined(_DBUFFER_MRT1) || defined(_DBUFFER_MRT2) || defined(_DBUFFER_MRT3)
+		#define ALLIN1_DECAL_MODE_DBUFFER
+	#else
+		#define ALLIN1_DECAL_MODE_SCREEN_SPACE
+	#endif
+#endif
+
+#ifdef REQUIRE_SCENE_DEPTH
+
+	#include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/DeclareDepthTexture.hlsl"
+	
+	float GetRawDepth(float4 projPos)
+	{
+		float res = SampleSceneDepth(projPos.xy / projPos.w);
+		return res;
+	}
+
+	float GetLinearDepth01(float4 projPos)
+	{
+		float rawDepth = GetRawDepth(projPos);
+		float res = Linear01Depth (rawDepth, _ZBufferParams);
+
+		return res;
+	}
+	
+	float GetSceneDepthDiff(float4 projPos)
+	{
+		float rawDepth = GetRawDepth(projPos);
+		float res = LinearEyeDepth(rawDepth, _ZBufferParams) - projPos.z;
+
+		return res;
+	}
+
+#endif
+
+float3 GetNormalWS(float3 normalOS)
+{
+	float3 normalWS = TransformObjectToWorldNormal(normalOS);
+	return normalWS;
+}
+
+float3 GetViewDirWS(float3 vertexWS)
+{
+	float3 res = GetWorldSpaceViewDir(vertexWS);
+	return res;
+}
+
+float3 GetPositionVS(float3 positionOS)
+{
+	float3 res = TransformWorldToView(positionOS);
+	return res;
+}
+
+float3 GetPositionWS(float4 positionOS)
+{
+	return TransformObjectToWorld(positionOS.xyz);
+}
+
+float3 GetPositionOS(float4 positionWS)
+{
+	return TransformWorldToObject(positionWS.xyz);
+
+}
+
+float3 GetDirWS(float4 dirOS)
+{
+	return TransformObjectToWorldDir(dirOS.xyz);
+}
+
+float3 GetDirOSFloat3(float3 dirOS)
+{
+	return TransformObjectToWorldDir(dirOS.xyz);
+}
+
+float3 GetDirOS(float4 dirOS)
+{
+	return GetDirOSFloat3(dirOS.xyz);
+}
+
+float3 GetMainLightDir(float3 vertexWS)
+{
+#ifdef _LIGHTMODEL_FASTLIGHTING
+	float3 res = global_lightDirection;
+#else
+	float3 res = GetMainLight().direction;
+#endif
+	
+	return res;
+}
+
+float3 GetMainLightColorRGB()
+{
+#ifdef _LIGHTMODEL_FASTLIGHTING
+	float3 res = global_lightColor.rgb;
+#else
+	float3 res = GetMainLight().color;
+#endif
+
+	return res;
+}
+
+float2 GetSSAO(float2 normalizedScreenSpaceUV, float alpha)
+{
+	AmbientOcclusionFactor aoFactorURP = GetScreenSpaceAmbientOcclusion(normalizedScreenSpaceUV);
+		
+#if defined(_ALLIN13D_SURFACE_TRANSPARENT)
+	float2 res = float2(1, 1);
+#else
+	float2 res = float2(aoFactorURP.directAmbientOcclusion, aoFactorURP.indirectAmbientOcclusion);
+#endif
+	
+	return res;
+}
+
+//normalWS needed for the equivalent method in BIRP
+//effectsData needed for the equivalent method in BIRP
+AllIn1LightData GetPointLightData(int index, float3 vertexWS, float3 normalWS, EffectsData effectsData, AllIn1GI gi)
+{
+	AllIn1LightData lightData;
+
+	Light additionalLight = GetAdditionalLight(index, vertexWS, gi.shadowMask);
+	lightData.lightColor = additionalLight.color;
+	lightData.lightDir = additionalLight.direction;
+
+#ifdef _CLUSTER_LIGHT_LOOP 
+	int lightIndex = index;
+#else
+	int lightIndex = GetPerObjectLightIndex(index);
+#endif
+
+#if defined(_LIGHT_COOKIES)
+    float3 cookieColor = SampleAdditionalLightCookie(lightIndex, effectsData.vertexWS);
+    lightData.lightColor *= cookieColor;
+#endif
+
+#ifdef _RECEIVE_SHADOWS_ON
+	lightData.realtimeShadow = additionalLight.shadowAttenuation;
+#else
+	lightData.realtimeShadow = 1.0;
+#endif
+	
+	lightData.distanceAttenuation = additionalLight.distanceAttenuation;
+	lightData.shadowColor = lightData.realtimeShadow;
+	lightData.layerMask = additionalLight.layerMask;
+	
+	return lightData;
+}
+
+AllIn1LightData GetMainLightData(float3 vertexWS, EffectsData effectsData, AllIn1GI gi)
+{
+	AllIn1LightData lightData;
+	
+#if defined(_LIGHTMODEL_NONE)
+	lightData.lightColor = float3(1.0, 1.0, 1.0);
+	lightData.lightDir = float3(0.0, 1.0, 0.0);
+	lightData.distanceAttenuation = 1.0;
+	lightData.shadowColor = 1.0;
+	lightData.realtimeShadow = 1.0;
+	lightData.layerMask = 1;
+#elif defined(_LIGHTMODEL_FASTLIGHTING)
+	lightData.lightColor = global_lightColor;
+	lightData.lightDir = global_lightDirection;
+	lightData.distanceAttenuation = 1.0;
+	lightData.shadowColor = 1.0;
+	lightData.realtimeShadow = 1.0;
+	lightData.layerMask = 1;
+#else
+	Light mainLight = GetMainLight(); 
+	lightData.lightColor = mainLight.color;
+	lightData.lightDir = mainLight.direction;
+
+	lightData.distanceAttenuation = mainLight.distanceAttenuation;
+	
+	float4 shadowCoords = TransformWorldToShadowCoord(vertexWS);
+	#ifdef _RECEIVE_SHADOWS_ON
+		lightData.realtimeShadow = MainLightRealtimeShadow(shadowCoords);
+		#if defined(_RECEIVEDSHADOWSTYPE_STYLIZED)
+			lightData.realtimeShadow = AntiAliasing(lightData.realtimeShadow, ACCESS_PROP_FLOAT(_ShadowCutoff));
+		#endif
+
+		float shadowFade = GetMainLightShadowFade(effectsData.vertexWS);
+		float shadowMask = 1.0;
+		#if defined(SHADOWS_SHADOWMASK)
+			shadowMask = gi.shadowMask.r;
+		#endif
+		lightData.realtimeShadow = lerp(lightData.realtimeShadow, shadowMask, shadowFade);
+	#else
+		lightData.realtimeShadow = 1.0;
+	#endif
+
+	lightData.shadowColor = lightData.realtimeShadow;
+	lightData.layerMask = mainLight.layerMask;
+
+	#if defined(_LIGHT_COOKIES)
+        float3 cookieColor = SampleMainLightCookie(effectsData.vertexWS);
+        lightData.lightColor *= cookieColor;
+    #endif
+#endif
+	
+	return lightData;
+}
+
+int GetNumAdditionalLights()
+{
+	return GetAdditionalLightsCount();
+}
+
+/*Needed for URP shadow caster pass*/
+float3 _LightDirection;
+float3 _LightPosition;
+/************/
+FragmentDataShadowCaster GetClipPosShadowCaster(VertexData v, FragmentDataShadowCaster input)
+{
+    float3 positionWS = TransformObjectToWorld(v.vertex.xyz);
+    float3 normalWS = TransformObjectToWorldNormal(v.normal);
+
+#if _CASTING_PUNCTUAL_LIGHT_SHADOW
+    float3 lightDirectionWS = normalize(_LightPosition - positionWS);
+#else
+    float3 lightDirectionWS = _LightDirection;
+#endif
+
+    float4 positionCS = TransformWorldToHClip(ApplyShadowBias(positionWS, normalWS, lightDirectionWS));
+
+#if UNITY_REVERSED_Z
+    positionCS.z = min(positionCS.z, UNITY_NEAR_CLIP_VALUE);
+#else
+    positionCS.z = max(positionCS.z, UNITY_NEAR_CLIP_VALUE);
+#endif
+
+	input.pos = positionCS;
+    return input;
+}
+
+ShadowCoordStruct GetShadowCoords(VertexData v, float4 clipPos, float3 vertexWS, float2 uvLightmap)
+{
+	ShadowCoordStruct res;
+
+	res._ShadowCoord = 0;
+	res.pos = clipPos;
+	
+	return res;
+}
+
+float GetShadowAttenuation(EffectsData data)
+{
+	float res = 1.0;
+
+#if !defined(_LIGHTMODEL_FASTLIGHTING)
+
+	float4 shadowCoords = TransformWorldToShadowCoord(data.vertexWS);
+
+	float mainLightShadow = MainLightRealtimeShadow(shadowCoords);
+	
+	//int numAdditionalLights = NUM_ADDITIONAL_LIGHTS;
+	//float additionalLightsShadows = 1.0;
+	res = mainLightShadow;
+	//for(int lightIndex = 0; lightIndex < numAdditionalLights; lightIndex++)
+	//{
+	//	Light additionalLight = GetAdditionalLight(lightIndex, vertexWS);
+	//	float additionalLightShadow = AdditionalLightRealtimeShadow(lightIndex, vertexWS/*, additionalLight.direction*/) * additionalLight.distanceAttenuation;
+		
+	//	res *= additionalLightShadow;
+	//}	
+#endif
+
+	return res;
+}
+
+//float GetShadowAttenuation(float3 vertexWS)
+//{
+//	float4 shadowCoords = TransformWorldToShadowCoord(vertexWS);
+//	float mainLightShadow = MainLightRealtimeShadow(shadowCoords);
+
+//	float res = mainLightShadow;
+//	int numAdditionalLights = NUM_ADDITIONAL_LIGHTS;
+//	for(int lightIndex = 0; lightIndex < numAdditionalLights; lightIndex++)
+//	{
+//		Light additionalLight = GetAdditionalLight(lightIndex, vertexWS);
+//		float additionalLightShadow = AdditionalLightRealtimeShadow(lightIndex, vertexWS) * additionalLight.distanceAttenuation;
+		
+//		res += additionalLightShadow;
+//	}
+	
+//	res = 1.0;
+//	return res;
+//}
+
+float3 GetLightmap(float2 uvLightmap, EffectsData data)
+{
+	float3 res = 0.0;
+
+#if defined(_AFFECTED_BY_LIGHTMAPS_ON) && defined(LIGHTMAP_ON)
+	res = SampleLightmap(uvLightmap, data.normalWS);
+	#ifdef SUBTRACTIVE_LIGHTING
+		AllIn1LightData mainLight = GetMainLightData(data.vertexWS, data);
+		float attenuation = mainLight.realtimeShadow;
+		float ndotl = saturate(dot(data.normalWS, mainLight.lightDir));
+		float3 shadowedLightEstimate =
+				ndotl * (1 - attenuation) * mainLight.lightColor.rgb;
+		float3 subtractedLight = res - shadowedLightEstimate;
+		subtractedLight = max(subtractedLight, _SubtractiveShadowColor.xyz);
+		subtractedLight = lerp(subtractedLight, res, attenuation);
+	
+		res = subtractedLight;
+	#endif
+#endif
+
+	return res;
+}
+
+uint AllIn1GetMeshRenderingLayer()
+{
+	uint res;
+	#if UNITY_VERSION >= 202230
+		res = GetMeshRenderingLayer();
+	#else
+		res = GetMeshRenderingLightLayer();
+	#endif
+	
+	return res;
+}
+
+float3 GetAmbientColor(EffectsData data)
+{
+	float3 res = float3(0, 0, 0);
+#if !defined(LIGHTMAP_ON)
+	#if defined(_CUSTOM_AMBIENT_LIGHT_ON)
+		res = ACCESS_PROP_FLOAT4(_CustomAmbientColor).rgb;
+	#else
+		#if defined(PROBE_VOLUMES_L1) || defined(PROBE_VOLUMES_L2)
+			half3 bakedGI;
+			float4 probeOcclusion;
+			EvaluateAdaptiveProbeVolume(data.vertexWS.xyz, data.normalWS.xyz, data.viewDirWS.xyz,
+									  data.projPos.xy, AllIn1GetMeshRenderingLayer(), 
+									  bakedGI, probeOcclusion);
+			res = bakedGI;
+		#else
+			res = SampleSH(data.normalWS);
+		#endif
+	#endif
+
+#endif
+
+	return res;
+}
+
+AllIn1GI CalculateGI(float2 uvLightmap, EffectsData data)
+{
+	AllIn1GI res;
+	INIT_GI(res);
+
+#if defined(LIGHTMAP_ON)
+	res.diffuse = GetLightmap(uvLightmap, data);
+#else
+	res.diffuse = GetAmbientColor(data);
+#endif
+
+#if defined(SHADOWS_SHADOWMASK)
+	res.shadowMask = SAMPLE_TEXTURE2D(unity_ShadowMask, samplerunity_ShadowMask, uvLightmap);
+#endif
+
+	return res;
+}
+
+float GetFogFactor(float4 clipPos)
+{
+	float res = 0;
+
+#if defined(FOG_LINEAR) || defined(FOG_EXP) || defined(FOG_EXP2)
+	res = ComputeFogFactor(clipPos.z);
+#endif
+
+	return res;
+}
+
+#if defined(FOG_ENABLED)
+float4 CustomMixFog(float fogFactor, float4 col)
+{
+	float4 res = col;
+	res.rgb = MixFog(res.rgb, fogFactor);
+	return res;
+}
+#endif
+
+void ConfigureDecalData(inout AllIn1DecalData allIn1Decal, float4 positionCS)
+{
+#if defined(_DBUFFER)
+	FETCH_DBUFFER(DBuffer, _DBufferTexture, int2(positionCS.xy));
+
+    DecalSurfaceData decalSurfaceData;
+    DECODE_FROM_DBUFFER(DBuffer, decalSurfaceData);
+
+	allIn1Decal.baseColor = decalSurfaceData.baseColor;
+	allIn1Decal.emissive = decalSurfaceData.emissive;
+	allIn1Decal.mask = step(0.1, allIn1Decal.baseColor.a);
+	allIn1Decal.mask = saturate(allIn1Decal.mask + decalSurfaceData.normalWS.w);
+	allIn1Decal.MAOSAlpha = decalSurfaceData.MAOSAlpha;
+	allIn1Decal.smoothness = decalSurfaceData.smoothness;
+	allIn1Decal.metallic = decalSurfaceData.metallic;
+
+	float4 normalTS = decalSurfaceData.normalWS; //Even if it's called normalWS, the content is a sampled normal map in tangent space
+
+	allIn1Decal.normalTS = lerp(normalTS, DEFAULT_NORMAL_MAP_VALUE, allIn1Decal.mask);
+	allIn1Decal.unpackedNormal = UnpackNormal(allIn1Decal.normalTS);
+#endif
+}
+
+#ifdef REFLECTIONS_ON
+
+float3 BoxProjection (
+	float3 direction, float3 position,
+	float4 cubemapPosition, float3 boxMin, float3 boxMax
+) {
+	#if UNITY_SPECCUBE_BOX_PROJECTION
+		UNITY_BRANCH
+		if (cubemapPosition.w > 0) {
+			float3 factors =
+				((direction > 0 ? boxMax : boxMin) - position) / direction;
+			float scalar = min(min(factors.x, factors.y), factors.z);
+			direction = direction * scalar + (position - cubemapPosition.xyz);
+		}
+	#endif
+	return direction;
+}
+
+float3 GetReflectionsSimple(float3 worldRefl, float cubeLod, float3 positionWS)
+{
+	half probe0Volume = CalculateProbeVolumeSqrMagnitude(unity_SpecCube0_BoxMin, unity_SpecCube0_BoxMax);
+    half probe1Volume = CalculateProbeVolumeSqrMagnitude(unity_SpecCube1_BoxMin, unity_SpecCube1_BoxMax);
+
+    half volumeDiff = probe0Volume - probe1Volume;
+    float importanceSign = unity_SpecCube1_BoxMin.w;
+
+	float desiredWeightProbe0 = CalculateProbeWeight(positionWS, unity_SpecCube0_BoxMin, unity_SpecCube0_BoxMax);
+    float desiredWeightProbe1 = CalculateProbeWeight(positionWS, unity_SpecCube1_BoxMin, unity_SpecCube1_BoxMax);
+
+	// A probe is dominant if its importance is higher
+    // Or have equal importance but smaller volume
+    bool probe0Dominant = importanceSign > 0.0f || (importanceSign == 0.0f && volumeDiff < -0.0001h);
+    bool probe1Dominant = importanceSign < 0.0f || (importanceSign == 0.0f && volumeDiff > 0.0001h);
+
+    float weightProbe0 = probe1Dominant ? min(desiredWeightProbe0, 1.0f - desiredWeightProbe1) : desiredWeightProbe0;
+    float weightProbe1 = probe0Dominant ? min(desiredWeightProbe1, 1.0f - desiredWeightProbe0) : desiredWeightProbe1;
+
+    float totalWeight = weightProbe0 + weightProbe1;
+
+    // If either probe 0 or probe 1 is dominant the sum of weights is guaranteed to be 1.
+    // If neither is dominant this is not guaranteed - only normalize weights if totalweight exceeds 1.
+    weightProbe0 /= max(totalWeight, 1.0f);
+    weightProbe1 /= max(totalWeight, 1.0f);
+
+	float3 res = 0;
+	if(weightProbe0 > 0.01)
+	{
+		float3 reflUV0 = BoxProjection(worldRefl, positionWS, unity_SpecCube0_ProbePosition, unity_SpecCube0_BoxMin.xyz, unity_SpecCube0_BoxMax.xyz);
+		float4 probe0HDR = SAMPLE_TEXTURECUBE_LOD(unity_SpecCube0, samplerunity_SpecCube0, reflUV0, cubeLod);
+		float3 probe0 = DecodeHDREnvironment(probe0HDR, unity_SpecCube0_HDR);
+
+		res += weightProbe0 * probe0;
+	}
+	if(weightProbe1 > 0.01f) 
+	{
+		float3 reflUV1 = BoxProjection(worldRefl, positionWS, unity_SpecCube1_ProbePosition, unity_SpecCube1_BoxMin.xyz, unity_SpecCube1_BoxMax.xyz);
+		float4 probe1HDR = SAMPLE_TEXTURECUBE_LOD(unity_SpecCube1, samplerunity_SpecCube0, reflUV1, cubeLod);
+		float3 probe1 = DecodeHDREnvironment(probe1HDR, unity_SpecCube1_HDR);
+
+		res += weightProbe1 * probe1;
+	}
+	if(totalWeight < 0.99)
+	{
+		float4 glossyEnvironmentHDR = SAMPLE_TEXTURECUBE_LOD(_GlossyEnvironmentCubeMap, sampler_GlossyEnvironmentCubeMap, worldRefl, cubeLod);
+		float3 glossyEnvironment = DecodeHDREnvironment(glossyEnvironmentHDR, _GlossyEnvironmentCubeMap_HDR);
+
+		res += (1.0f - totalWeight) * glossyEnvironment;
+	}
+
+	return res;
+}
+
+float3 GetReflectionsCluster(float3 positionWS, float2 normalizedScreenSpaceUV, float3 worldRefl, float cubeLod)
+{
+	float3 res = 0;
+	float3 irradiance = float3(0, 0, 0);
+	float mip = cubeLod;
+#if USE_CLUSTER_LIGHT_LOOP && CLUSTER_HAS_REFLECTION_PROBES
+	float totalWeight = 0.0f;
+	uint probeIndex;
+	ClusterIterator it = ClusterInit(normalizedScreenSpaceUV, positionWS, 1);
+	[loop] while (ClusterNext(it, probeIndex) && totalWeight < 0.99f)
+	{
+		probeIndex -= URP_FP_PROBES_BEGIN;
+
+		float weight = CalculateProbeWeight(positionWS, urp_ReflProbes_BoxMin[probeIndex], urp_ReflProbes_BoxMax[probeIndex]);
+		weight = min(weight, 1.0f - totalWeight);
+
+		half3 sampleVector = worldRefl;
+	#ifdef _REFLECTION_PROBE_BOX_PROJECTION
+			sampleVector = BoxProjectedCubemapDirection(worldRefl, positionWS, urp_ReflProbes_ProbePosition[probeIndex], urp_ReflProbes_BoxMin[probeIndex], urp_ReflProbes_BoxMax[probeIndex]);
+	#endif // _REFLECTION_PROBE_BOX_PROJECTION
+
+		uint maxMip = (uint)abs(urp_ReflProbes_ProbePosition[probeIndex].w) - 1;
+		half probeMip = min(mip, maxMip);
+		float2 uv = saturate(PackNormalOctQuadEncode(sampleVector) * 0.5 + 0.5);
+
+		float mip0 = floor(probeMip);
+		float mip1 = mip0 + 1;
+		float mipBlend = probeMip - mip0;
+		float4 scaleOffset0 = urp_ReflProbes_MipScaleOffset[probeIndex * 7 + (uint)mip0];
+		float4 scaleOffset1 = urp_ReflProbes_MipScaleOffset[probeIndex * 7 + (uint)mip1];
+
+		half3 irradiance0 = half4(SAMPLE_TEXTURE2D_LOD(urp_ReflProbes_Atlas, sampler_LinearClamp, uv * scaleOffset0.xy + scaleOffset0.zw, 0.0)).rgb;
+		half3 irradiance1 = half4(SAMPLE_TEXTURE2D_LOD(urp_ReflProbes_Atlas, sampler_LinearClamp, uv * scaleOffset1.xy + scaleOffset1.zw, 0.0)).rgb;
+		res += weight * lerp(irradiance0, irradiance1, mipBlend);
+		totalWeight += weight;
+	}
+#else
+	half probe0Volume = CalculateProbeVolumeSqrMagnitude(unity_SpecCube0_BoxMin, unity_SpecCube0_BoxMax);
+    half probe1Volume = CalculateProbeVolumeSqrMagnitude(unity_SpecCube1_BoxMin, unity_SpecCube1_BoxMax);
+
+    half volumeDiff = probe0Volume - probe1Volume;
+    float importanceSign = unity_SpecCube1_BoxMin.w;
+
+    // A probe is dominant if its importance is higher
+    // Or have equal importance but smaller volume
+    bool probe0Dominant = importanceSign > 0.0f || (importanceSign == 0.0f && volumeDiff < -0.0001h);
+    bool probe1Dominant = importanceSign < 0.0f || (importanceSign == 0.0f && volumeDiff > 0.0001h);
+
+    float desiredWeightProbe0 = CalculateProbeWeight(positionWS, unity_SpecCube0_BoxMin, unity_SpecCube0_BoxMax);
+    float desiredWeightProbe1 = CalculateProbeWeight(positionWS, unity_SpecCube1_BoxMin, unity_SpecCube1_BoxMax);
+
+    // Subject the probes weight if the other probe is dominant
+    float weightProbe0 = probe1Dominant ? min(desiredWeightProbe0, 1.0f - desiredWeightProbe1) : desiredWeightProbe0;
+    float weightProbe1 = probe0Dominant ? min(desiredWeightProbe1, 1.0f - desiredWeightProbe0) : desiredWeightProbe1;
+
+    float totalWeight = weightProbe0 + weightProbe1;
+
+    // If either probe 0 or probe 1 is dominant the sum of weights is guaranteed to be 1.
+    // If neither is dominant this is not guaranteed - only normalize weights if totalweight exceeds 1.
+    weightProbe0 /= max(totalWeight, 1.0f);
+    weightProbe1 /= max(totalWeight, 1.0f);
+
+    // Sample the first reflection probe
+    if (weightProbe0 > 0.01f)
+    {
+        half3 reflectVector0 = worldRefl;
+#ifdef _REFLECTION_PROBE_BOX_PROJECTION
+        reflectVector0 = BoxProjectedCubemapDirection(worldRefl, positionWS, unity_SpecCube0_ProbePosition, unity_SpecCube0_BoxMin, unity_SpecCube0_BoxMax);
+#endif // _REFLECTION_PROBE_BOX_PROJECTION
+
+        half4 encodedIrradiance = half4(SAMPLE_TEXTURECUBE_LOD(unity_SpecCube0, samplerunity_SpecCube0, reflectVector0, mip));
+
+        irradiance += weightProbe0 * DecodeHDREnvironment(encodedIrradiance, unity_SpecCube0_HDR);
+    }
+
+    // Sample the second reflection probe
+    if (weightProbe1 > 0.01f)
+    {
+        half3 reflectVector1 = worldRefl;
+#ifdef _REFLECTION_PROBE_BOX_PROJECTION
+        worldRefl = BoxProjectedCubemapDirection(worldRefl, positionWS, unity_SpecCube1_ProbePosition, unity_SpecCube1_BoxMin, unity_SpecCube1_BoxMax);
+#endif // _REFLECTION_PROBE_BOX_PROJECTION
+        half4 encodedIrradiance = half4(SAMPLE_TEXTURECUBE_LOD(unity_SpecCube1, samplerunity_SpecCube1, worldRefl, mip));
+
+        irradiance += weightProbe1 * DecodeHDREnvironment(encodedIrradiance, unity_SpecCube1_HDR);
+    }
+
+	res = irradiance;
+#endif
+
+    // Use any remaining weight to blend to environment reflection cube map
+    if (totalWeight < 0.99f)
+    {
+        half4 encodedIrradiance = half4(SAMPLE_TEXTURECUBE_LOD(_GlossyEnvironmentCubeMap, sampler_GlossyEnvironmentCubeMap, worldRefl, mip));
+
+        res += (1.0f - totalWeight) * DecodeHDREnvironment(encodedIrradiance, _GlossyEnvironmentCubeMap_HDR);
+    }
+	
+	return res;
+}
+
+float3 GetSkyColor(float3 positionWS, float2 normalizedScreenSpaceUV, float3 normalWS, float3 viewDirWS, float cubeLod)
+{
+	float3 worldRefl = normalize(reflect(-viewDirWS, normalWS));
+	float4 skyData = 0;
+	float3 res = 0;
+
+#ifdef _REFLECTION_PROBE_BLENDING
+	#if USE_CLUSTER_LIGHT_LOOP && CLUSTER_HAS_REFLECTION_PROBES
+		res = GetReflectionsCluster(positionWS, normalizedScreenSpaceUV, worldRefl, cubeLod);
+	#else
+		res = GetReflectionsSimple(worldRefl, cubeLod, positionWS);
+	#endif
+#else
+	res = GetReflectionsSimple(worldRefl, cubeLod, positionWS);
+#endif
+
+#ifdef _REFLECTIONS_TOON
+	float posterizationLevel = lerp(2, 20, ACCESS_PROP_FLOAT(_ToonFactor));
+	res = floor(res * posterizationLevel) / posterizationLevel;
+#endif
+
+	res *= ACCESS_PROP_FLOAT(_ReflectionsAtten);
+
+	return res;
+}
+#endif
+
+float3 ShadeSH(float4 normalWS)
+{
+	float3 res = SampleSH(normalWS.xyz);
+	return res;
+}
+
+#define OBJECT_TO_CLIP_SPACE(v) TransformObjectToHClip(v.vertex.xyz)
+#define OBJECT_TO_CLIP_SPACE_FLOAT4(pos) TransformObjectToHClip(pos.xyz)
+#define ALLIN1_APPLY_CROSSFADE(input) LODFadeCrossFade(input.pos);
+
+#endif

Assets/Plugins/AllIn13DShader/Shaders/ShaderLibrary/AllIn13DShaderHelper_URP.hlsl.meta

@@ -0,0 +1,14 @@
+fileFormatVersion: 2
+guid: 29e55f1233e1c0c4c8080ca68ec48682
+ShaderIncludeImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 316173
+  packageName: All In 1 3D-Shader
+  packageVersion: 2.72
+  assetPath: Assets/Plugins/AllIn13DShader/Shaders/ShaderLibrary/AllIn13DShaderHelper_URP.hlsl
+  uploadId: 865720

Assets/Plugins/AllIn13DShader/Shaders/ShaderLibrary/AllIn13DShaderLight.hlsl

@@ -0,0 +1,347 @@
+#ifndef ALLIN13DSHADER_LIGHT_INCLUDED
+#define ALLIN13DSHADER_LIGHT_INCLUDED
+
+
+#if ALLIN1_USE_FORWARD_PLUS
+    #define LIGHT_LOOP_BEGIN_ALLIN13D(lightCount, data) { \
+    uint lightIndex; \
+    ClusterIterator _urp_internal_clusterIterator = ClusterInit(data.normalizedScreenSpaceUV, data.vertexWS, 0); \
+    [loop] while (ClusterNext(_urp_internal_clusterIterator, lightIndex)) { \
+        lightIndex += URP_FP_DIRECTIONAL_LIGHTS_COUNT; \
+        ALLIN1_FORWARD_PLUS_SUBTRACTIVE_LIGHT_CHECK
+    #define LIGHT_LOOP_END_ALLIN13D } }
+#else
+    #define LIGHT_LOOP_BEGIN_ALLIN13D(lightCount, data) \
+	if(lightCount > 0) { \
+    for (uint lightIndex = 0u; lightIndex < lightCount; ++lightIndex) {
+    #define LIGHT_LOOP_END_ALLIN13D } }
+#endif
+
+float GetMainLightIntensity()
+{
+	return length(GetMainLightColorRGB());
+}
+
+#if defined(_SHADINGMODEL_PBR) || defined(_SPECULARMODEL_ANISOTROPIC) || defined(_SPECULARMODEL_ANISOTROPICTOON)
+	#include "../ShaderLibrary/AllIn13DShader_BRDF.hlsl"
+#endif
+
+float3 GetBitangentWS(float4 tangentOS, float3 tangentWS, float3 normalWS)
+{
+    float tangentSign = tangentOS.w * unity_WorldTransformParams.w;
+    float3 res = cross(normalWS, tangentWS) * tangentSign;
+    return res;
+}
+
+float3 DiffuseTerm(AllIn1LightData lightData, float3 normal, float isAdditionalLight)
+{
+	float rawNdotL = dot(normal, lightData.lightDir);
+	float3 lightModel = 0;
+	float3 lightColor = lightData.lightColor.rgb * lightData.distanceAttenuation * lightData.shadowColor.rgb;
+
+#if !defined(FORWARD_ADD_PASS)
+	#if defined(_LIGHTMODEL_HALFLAMBERT) || defined(_LIGHTMODEL_FAKEGI) || defined(_LIGHTMODEL_TOONRAMP)
+		lightColor = isAdditionalLight > 0 ? lightColor : lightData.lightColor.rgb;
+		rawNdotL = isAdditionalLight > 0 ? rawNdotL : rawNdotL * GetLuminance(lightData.shadowColor.rgb);
+	#endif
+#endif
+
+#if defined(_LIGHTMODEL_CLASSIC)
+	float NdotL = saturate(rawNdotL);
+	lightModel = NdotL;
+
+#elif defined(_LIGHTMODEL_TOON)
+	float NdotL = saturate(rawNdotL);
+	lightModel = smoothstep(ACCESS_PROP_FLOAT(_ToonCutoff), ACCESS_PROP_FLOAT(_ToonCutoff) + ACCESS_PROP_FLOAT(_ToonSmoothness), NdotL); 
+
+#elif defined(_LIGHTMODEL_TOONRAMP)
+	float NdotL = (rawNdotL * 0.5) + 0.5;
+	lightModel = SAMPLE_TEX2D_LOD(_ToonRamp, float4(NdotL, 0, 0, 0)).rgb;
+
+#elif defined(_LIGHTMODEL_HALFLAMBERT)
+	float NdotL = saturate(rawNdotL);
+	float halfLambertTerm = (NdotL * ACCESS_PROP_FLOAT(_HalfLambertWrap)) + (1 - ACCESS_PROP_FLOAT(_HalfLambertWrap));
+	lightModel = halfLambertTerm * halfLambertTerm;
+
+#elif defined(_LIGHTMODEL_FAKEGI)
+	float NdotL = saturate(rawNdotL);
+	lightModel = (NdotL * ACCESS_PROP_FLOAT(_HardnessFakeGI)) + 1.0 - ACCESS_PROP_FLOAT(_HardnessFakeGI);
+
+#elif defined(_LIGHTMODEL_FASTLIGHTING)
+	lightModel = saturate(rawNdotL);
+
+#endif
+	
+	float3 res = lightModel * lightColor;
+
+    return res;
+}
+
+#ifdef SPECULAR_ON
+
+float3 SpecularTerm(float3 objectColor, AllIn1LightData lightData, 
+		float3 normalWS, float3 tangentWS, float3 bitangentWS,
+		float3 viewDirWS, float glossiness, float2 mainUV, float4 specularTex)
+{
+	float3 lightColor = lightData.lightColor.rgb * lightData.distanceAttenuation * lightData.shadowColor.rgb;
+    float3 reflectionDir = reflect(-lightData.lightDir, normalWS);
+    float rawVdotL = dot(viewDirWS, reflectionDir);
+	
+    float3 specularModel = 0;
+	
+
+#if defined(_SPECULARMODEL_CLASSIC) || defined(_SPECULARMODEL_TOON)
+	float3 halfVector = normalize(viewDirWS + lightData.lightDir);
+	float NdotH = saturate(dot(normalWS, halfVector));
+	float specularIntensity = pow(NdotH, glossiness);
+	
+#elif defined(_SPECULARMODEL_ANISOTROPIC) || defined(_SPECULARMODEL_ANISOTROPICTOON)
+	float3 H = normalize(viewDirWS + lightData.lightDir);
+
+	float TdotH = saturate(dot(tangentWS, H));
+	float BdotH = saturate(dot(bitangentWS, H));
+
+	float TdotV = saturate(dot(tangentWS, viewDirWS));
+	float BdotV = saturate(dot(bitangentWS, viewDirWS));
+
+	float TdotL = saturate(dot(tangentWS, lightData.lightDir));
+	float BdotL = saturate(dot(bitangentWS, lightData.lightDir));
+
+	float NdotH = saturate(dot(normalWS, H));
+	float NdotL = saturate(dot(normalWS, lightData.lightDir));
+	float NdotV = saturate(dot(normalWS, viewDirWS));
+
+	float VdotH = saturate(dot(viewDirWS, H));
+
+	float anisotropy = ACCESS_PROP_FLOAT(_Anisotropy);
+	float anisoShininess = ACCESS_PROP_FLOAT(_AnisoShininess);
+	float at = max((1 - anisoShininess) * (1.0 + anisotropy), 0.001);
+	float ab = max((1 - anisoShininess) * (1.0 - anisotropy), 0.001);
+
+	float3 specularIntensity = SpecularAnisoTerm(
+		at, ab, 
+		float3(1.0, 1.0, 1.0), 
+		NdotH, NdotV, NdotL,
+		TdotV, BdotV, 
+		TdotL, BdotL, 
+		TdotH, BdotH,
+		H, tangentWS.xyz, bitangentWS.xyz) * NdotL;
+
+	specularIntensity = saturate(specularIntensity);
+#endif
+
+#if defined(_SPECULARMODEL_ANISOTROPICTOON) || defined(_SPECULARMODEL_TOON)
+	float specularSmoothness = max(ACCESS_PROP_FLOAT(_SpecularToonSmoothness), 0.001);
+	specularIntensity = smoothstep(ACCESS_PROP_FLOAT(_SpecularToonCutoff), ACCESS_PROP_FLOAT(_SpecularToonCutoff) + specularSmoothness, specularIntensity);
+#endif
+
+	specularModel = specularIntensity * lightColor;
+	float3 res = specularModel * ACCESS_PROP_FLOAT(_SpecularAtten) * specularTex.r;
+	
+	return res;
+}
+
+float3 SpecularTerm_Basic(float3 objectColor, AllIn1LightData lightData, 
+		float3 normalWS, float3 tangentWS, float3 bitangentWS, float3 viewDirWS, float2 mainUV, float4 specularTex)
+{
+	float3 res = SpecularTerm(objectColor, lightData,
+		normalWS, tangentWS, bitangentWS,
+		viewDirWS, ACCESS_PROP_FLOAT(_Shininess) * ACCESS_PROP_FLOAT(_Shininess), mainUV, specularTex);
+	return res;
+}
+
+#endif
+
+float3 RimTermOperation(float3 normalWS, float3 viewDirWS, float minRim, float maxRim, float rimAttenuation, float3 rimColor)
+{
+	float NdotV = saturate(dot(normalWS, viewDirWS));
+	float rimIntensity = (1 - NdotV);
+	rimIntensity = smoothstep(minRim, maxRim, rimIntensity) * rimAttenuation;
+
+	float3 res = rimIntensity * rimColor;
+	return res;
+}
+
+float3 DirectLighting(float3 objectColor, EffectsData effectsData, AllIn1LightData lightData, float4 specularTex, float isAdditionalLight)
+{
+	float3 res = 0;
+
+	float3 diffuseTerm = DiffuseTerm(lightData, effectsData.normalWS, isAdditionalLight) * objectColor;
+	
+#if defined(_CUSTOM_SHADOW_COLOR_ON) && !defined(FORWARD_ADD_PASS)
+	float shadowT = saturate(lightData.realtimeShadow + 1.0 - global_shadowColor.a);
+	diffuseTerm = lerp(global_shadowColor, diffuseTerm, shadowT);
+#endif
+	
+	float3 specularTerm = 0;
+#ifdef SPECULAR_ON
+	
+	float NdotL = saturate(dot(effectsData.normalWS, lightData.lightDir));
+
+    specularTerm = SpecularTerm_Basic(objectColor, lightData,
+		effectsData.normalWS, effectsData.tangentWS, effectsData.bitangentWS, 
+		effectsData.viewDirWS, effectsData.mainUV, specularTex) * NdotL;
+#endif
+	
+	res = diffuseTerm + specularTerm;
+
+	return res;
+}
+
+float3 DirectLighting(float3 objectColor, float2 ssaoFactor, EffectsData effectsData, AllIn1GI gi)
+{
+	AllIn1LightData mainLightData = GetMainLightData(effectsData.vertexWS, effectsData, gi);
+
+
+	float3 res = objectColor;
+	float4 specularTex = float4(1, 1, 1, 1);
+
+#ifdef ALLIN1_USE_LIGHT_LAYERS
+	uint meshRenderingLayers = AllIn1GetMeshRenderingLayer();
+	res = 0;
+	if (IsMatchingLightLayer(mainLightData.layerMask, meshRenderingLayers))
+	{
+		res = objectColor;
+#endif
+
+#ifdef SPECULAR_ON
+	specularTex = SAMPLE_TEX2D(_SpecularMap, effectsData.mainUV);
+#endif
+
+	res = DirectLighting(objectColor, effectsData, mainLightData, specularTex, 0);
+
+#ifdef ALLIN1_USE_LIGHT_LAYERS
+		}
+#endif
+
+
+
+#if defined(ADDITIONAL_LIGHT_LOOP) && !defined(_LIGHTMODEL_FASTLIGHTING)
+	// Additional light loop for non-main directional lights. This block is specific to Forward+.
+	#if USE_CLUSTER_LIGHT_LOOP
+	UNITY_LOOP for (uint lightIndex = 0; lightIndex < min(URP_FP_DIRECTIONAL_LIGHTS_COUNT, MAX_VISIBLE_LIGHTS); lightIndex++)
+	{
+		AllIn1LightData additionalLightData = GetPointLightData(lightIndex, effectsData.vertexWS, effectsData.normalWS, effectsData, gi);
+		#ifdef ALLIN1_USE_LIGHT_LAYERS
+		if (IsMatchingLightLayer(additionalLightData.layerMask, meshRenderingLayers))
+		{
+		#endif
+			res += DirectLighting(objectColor, effectsData, additionalLightData, specularTex, 1);
+		#ifdef ALLIN1_USE_LIGHT_LAYERS
+		}
+		#endif
+	}
+	#endif
+	
+	uint numAdditionalLights = NUM_ADDITIONAL_LIGHTS;
+	LIGHT_LOOP_BEGIN_ALLIN13D(numAdditionalLights, effectsData)
+		AllIn1LightData additionalLightData = GetPointLightData(lightIndex, effectsData.vertexWS, effectsData.normalWS, effectsData, gi);
+	#ifdef ALLIN1_USE_LIGHT_LAYERS
+		if (IsMatchingLightLayer(additionalLightData.layerMask, meshRenderingLayers))
+		{
+	#endif
+		res += DirectLighting(objectColor, effectsData, additionalLightData, specularTex, 1);
+	#ifdef ALLIN1_USE_LIGHT_LAYERS
+		}
+	#endif
+
+	LIGHT_LOOP_END_ALLIN13D
+#endif
+
+	res *= ssaoFactor.x;
+
+	return res;
+}
+
+float3 IndirectLighting_Basic(float3 objectColor, float2 ssaoFactor, EffectsData effectsData, AllIn1GI gi)
+{
+	//float3 ambientColor = GetAmbientColor(effectsData);
+
+	float3 ao = 1.0;
+
+	float3 reflections = 0;
+#ifdef REFLECTIONS_ON
+	reflections = GetSkyColor(effectsData.vertexWS, effectsData.normalizedScreenSpaceUV, effectsData.normalWS, effectsData.viewDirWS, 1.0);
+#endif
+	
+	float3 indirectLighting = /*(ambientColor + lightmap)*/gi.diffuse * objectColor;
+	indirectLighting += reflections;
+
+	indirectLighting *= ssaoFactor.y;
+
+	return indirectLighting;
+}
+
+float3 CalculateLighting_Basic(float3 objectColor, float alpha, EffectsData effectsData, AllIn1GI gi)
+{
+	float2 ssaoFactor = GetSSAO(effectsData.normalizedScreenSpaceUV.xy, alpha); 
+
+	float3 directLighting = DirectLighting(objectColor, ssaoFactor, effectsData, gi);
+	
+	
+	float3 indirectLighting = 0;	
+	//We add IndirectLighting only once
+#ifndef FORWARD_ADD_PASS
+	indirectLighting = IndirectLighting_Basic(objectColor, ssaoFactor, effectsData, gi);
+	
+	#ifdef _AOMAP_ON
+		float3 aoMapValue = GetAOMapTerm(effectsData.mainUV);
+		indirectLighting *= aoMapValue;
+	#endif
+#endif
+
+	float3 res = directLighting + indirectLighting;
+
+	return res;
+}
+
+#ifdef _SHADINGMODEL_PBR
+float3 CalculateLighting_MetallicWorkflow(
+	float3 vertexWS, 
+	float3 normalWS, float3 tangentWS, float3 bitangentWS, 
+	float3 objectColor, float alpha,
+	float3 shadows, float3 ambientCol, float3 viewDirWS, 
+	float2 mainUV, FragmentData fragmentData, EffectsData effectsData, AllIn1GI gi)
+{
+	float3 res = CalculateLighting_PBR(objectColor, alpha, effectsData, gi);
+
+	return res;
+}
+
+#endif
+
+float3 CalculateLighting(float3 vertexWS, 
+	float3 normalWS, float3 tangentWS, float3 bitangentWS, 
+	float3 objectColor, float alpha,
+	float shadows, float3 ambientCol, float3 viewDirWS, 
+	float2 mainUV,
+	float3 lightColor, float3 lightDir,
+	FragmentData fragmentData, float lightAtten, EffectsData effectsData, 
+	AllIn1GI gi)
+{
+#ifdef _CUSTOM_SHADOW_COLOR_ON
+	float3 shadowColor = lerp(1.0, global_shadowColor, 1 - shadows);
+#else
+	float3 shadowColor = shadows;
+#endif
+	
+	float3 res = 0;
+#ifdef _LIGHTMODEL_FASTLIGHTING
+	res = CalculateLighting_Basic(objectColor, alpha, effectsData, gi);
+#else
+	#ifdef _SHADINGMODEL_PBR
+		res = CalculateLighting_MetallicWorkflow(
+			vertexWS, 
+			normalWS, tangentWS, bitangentWS, 
+			objectColor, alpha, 
+			shadowColor, ambientCol, viewDirWS, 
+			mainUV, fragmentData, effectsData, gi);
+	#else
+		res = CalculateLighting_Basic(objectColor, alpha, effectsData, gi);
+	#endif
+#endif
+	
+	return res;
+}
+
+#endif

Assets/Plugins/AllIn13DShader/Shaders/ShaderLibrary/AllIn13DShaderLight.hlsl.meta

@@ -0,0 +1,14 @@
+fileFormatVersion: 2
+guid: a8bd53a2a522aa9488877a9bb281ec11
+ShaderIncludeImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 316173
+  packageName: All In 1 3D-Shader
+  packageVersion: 2.72
+  assetPath: Assets/Plugins/AllIn13DShader/Shaders/ShaderLibrary/AllIn13DShaderLight.hlsl
+  uploadId: 865720

Assets/Plugins/AllIn13DShader/Shaders/ShaderLibrary/AllIn13DShaderLightAddPass.hlsl

@@ -0,0 +1,122 @@
+#ifndef ALLIN13DSHADER_LIGHT_ADD_PASS_INCLUDED
+#define ALLIN13DSHADER_LIGHT_ADD_PASS_INCLUDED
+
+#include "../ShaderLibrary/AllIn13DShader_BasePass.hlsl"
+
+float4 CalculateLightingAdd(float3 vertexWS, float3 normalWS, float3 viewDirWS, 
+	float4 objectColor, float shadows, 
+	float2 mainUV,
+	FragmentData fragmentData, EffectsData effectsData, 
+	AllIn1GI gi)
+{
+	float4 col = float4(0, 0, 0, objectColor.a);
+	col.rgb = CalculateLighting(vertexWS, 
+		normalWS, 0, 0, 
+		objectColor.rgb, objectColor.a,
+		0, 0, viewDirWS, 
+		mainUV, 
+		0, 1.0, fragmentData, 1.0, effectsData, 
+		gi);
+
+	return col;
+}
+
+FragmentData BasicVertexAdd(VertexData v)
+{
+	FragmentData o;
+
+	UNITY_SETUP_INSTANCE_ID(v);
+    UNITY_TRANSFER_INSTANCE_ID(v, o);
+	UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(o); 
+	
+	v.vertex = ApplyVertexEffects(v.vertex, v.normal, 0);
+
+	
+	POSITION_WS(o) = GetPositionWS(v.vertex);
+
+	o.normalWS = GetNormalWS(v.normal);
+
+	VIEWDIR_WS(o) = GetViewDirWS(POSITION_WS(o));
+	
+	SCALED_MAIN_UV(o) = SIMPLE_CUSTOM_TRANSFORM_TEX(v.uv, _MainTex);
+	RAW_MAIN_UV(o) = v.uv;
+	
+	o.pos = OBJECT_TO_CLIP_SPACE(v);
+
+	ShadowCoordStruct shadowCoordStruct = GetShadowCoords(v, o.pos, POSITION_WS(o), v.uvLightmap);
+	o._ShadowCoord = shadowCoordStruct._ShadowCoord;
+
+	FOGCOORD(o) = GetFogFactor(o.pos);
+
+#if defined(LIGHTMAP_ON) || defined(SHADOWS_SHADOWMASK)
+	UV_LIGHTMAP(o) = v.uvLightmap * unity_LightmapST.xy + unity_LightmapST.zw;
+#else
+	UV_LIGHTMAP(o) = v.uvLightmap;
+#endif
+
+#ifdef REQUIRE_TANGENT_WS
+	float3 tangentWS = GetDirWS(float4(v.tangent.xyz, 0));
+	float3 bitangentWS = GetBitangentWS(v.tangent, tangentWS, o.normalWS);
+	INIT_T_SPACE(o.normalWS)
+#endif
+
+	return o;
+}
+
+float4 BasicFragmentAdd(FragmentData i) : SV_Target
+{
+	UNITY_SETUP_INSTANCE_ID(i);
+	UNITY_SETUP_STEREO_EYE_INDEX_POST_VERTEX(i);
+
+#ifdef _LIGHTMODEL_FASTLIGHTING
+	float4 additiveRes = 0;
+#else
+
+	AllIn1DecalData decalData;
+	INIT_DECAL_DATA(decalData)
+
+#ifdef ALLIN1_DECALS_READY_TO_USE
+	ConfigureDecalData(decalData, i.pos);
+#endif
+
+	EffectsData data = CalculateEffectsData(i, decalData);
+
+	data = ApplyUVEffects_FragmentStage(data);
+	data.normalWS = GetNormalWS(data, i, decalData);
+
+	float4 objectColor = GetBaseColor(data);
+
+	float3 normalOS = data.normalOS;
+	float3 normalWS = data.normalWS;
+	float3 viewDirWS = data.viewDirWS;
+	
+	objectColor *= ACCESS_PROP_FLOAT4(_Color);
+	objectColor = ApplyColorEffectsBeforeLighting(objectColor, data);
+
+	float4 col = objectColor;
+
+	AllIn1GI gi = CalculateGI(UV_LIGHTMAP(i), data);
+	col = CalculateLightingAdd(POSITION_WS(i), normalWS, VIEWDIR_WS(i), objectColor, 1.0, i.mainUV, i, data, gi);
+	
+	col = ApplyAlphaEffects(col,
+		i.mainUV, UV_LIGHTMAP(i), data.vertexWS,
+		0, data.camDistance, data.projPos);
+
+#ifdef _ALPHA_CUTOFF_ON
+	clip((col.a - ACCESS_PROP_FLOAT(_AlphaCutoffValue)) - 0.001);
+#endif	
+
+	col = ApplyColorEffectsAfterLighting(col, data);
+	col.a *= ACCESS_PROP_FLOAT(_GeneralAlpha);
+
+#if defined(FOG_ENABLED)
+	col = CustomMixFog(FOGCOORD(i), col); 
+#endif
+
+	float4 additiveRes = col * col.a;
+#endif
+	
+	return additiveRes;
+}
+
+#endif

Assets/Plugins/AllIn13DShader/Shaders/ShaderLibrary/AllIn13DShaderLightAddPass.hlsl.meta

@@ -0,0 +1,14 @@
+fileFormatVersion: 2
+guid: db308fac201edba41b72ab235b924391
+ShaderIncludeImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 316173
+  packageName: All In 1 3D-Shader
+  packageVersion: 2.72
+  assetPath: Assets/Plugins/AllIn13DShader/Shaders/ShaderLibrary/AllIn13DShaderLightAddPass.hlsl
+  uploadId: 865720

Assets/Plugins/AllIn13DShader/Shaders/ShaderLibrary/AllIn13DShader_AlphaEffects.hlsl

@@ -0,0 +1,73 @@
+#ifndef ALLIN13DSHADER_ALPHA_EFFECTS
+#define ALLIN13DSHADER_ALPHA_EFFECTS
+
+#ifdef _FADE_ON
+//<EffectsCode id=FADE>
+//<EffectVersion kw=_FADE_BURN_ON suffix=Burn>
+float4 Fade(float4 inputColor, float2 uv)
+{
+	float4 res = inputColor;
+	
+	float2 fadeUV = SIMPLE_CUSTOM_TRANSFORM_TEX(uv, _FadeTex);
+	float fadeSample = SAMPLE_TEX2D(_FadeTex, fadeUV).r;
+	
+	fadeSample = pow(saturate(fadeSample), ACCESS_PROP_FLOAT(_FadePower));
+
+#ifdef _FADE_BURN_ON
+	float fadeAmount = lerp(ACCESS_PROP_FLOAT(_FadeAmount) - ACCESS_PROP_FLOAT(_FadeTransition) - ACCESS_PROP_FLOAT(_FadeBurnWidth), 1.0, ACCESS_PROP_FLOAT(_FadeAmount));
+	float fade = smoothstep(fadeAmount, fadeAmount + ACCESS_PROP_FLOAT(_FadeTransition), fadeSample);
+
+	float fadePlusBurn = smoothstep(fadeAmount + ACCESS_PROP_FLOAT(_FadeBurnWidth), fadeAmount + ACCESS_PROP_FLOAT(_FadeBurnWidth) + ACCESS_PROP_FLOAT(_FadeTransition), fadeSample);
+	
+	float diff = saturate(fade - fadePlusBurn);
+	
+	float3 burnColor = diff * ACCESS_PROP_FLOAT4(_FadeBurnColor).rgb;
+
+	res.rgb += burnColor;
+#else
+	float fadeAmount = lerp(ACCESS_PROP_FLOAT(_FadeAmount) - ACCESS_PROP_FLOAT(_FadeTransition), 1.0, ACCESS_PROP_FLOAT(_FadeAmount));
+	float fade = smoothstep(fadeAmount, fadeAmount + ACCESS_PROP_FLOAT(_FadeTransition), fadeSample);
+#endif
+	
+	res.a *= fade;
+
+	return res;
+}
+//</EffectsCode>
+#endif
+
+#ifdef _INTERSECTION_FADE_ON
+float4 IntersectionFade(float4 inputColor, float sceneDepthDiff)
+{
+	float4 res = inputColor;
+
+	res.a *= saturate(ACCESS_PROP_FLOAT(_IntersectionFadeFactor) * sceneDepthDiff);
+
+	return res;
+}
+#endif
+
+#ifdef _FADE_BY_CAM_DISTANCE_ON
+//<EffectsCode id=FADE_BY_CAM_DISTANCE>
+float4 FadeByCamDistance(float4 inputColor, float camDistance, out float camFadeDistanceNormalized)
+{
+	float4 res = inputColor;
+
+	float t = 0;
+#ifdef _FADE_BY_CAM_DISTANCE_NEAR_FADE
+	t = 1 - smoothstep(ACCESS_PROP_FLOAT(_MinDistanceToFade), ACCESS_PROP_FLOAT(_MaxDistanceToFade), camDistance);
+#else
+	t = smoothstep(ACCESS_PROP_FLOAT(_MinDistanceToFade), ACCESS_PROP_FLOAT(_MaxDistanceToFade), camDistance);
+#endif
+
+	
+	res.a = lerp(res.a, 0, t);
+
+	camFadeDistanceNormalized = t;
+
+	return res;
+}
+//</EffectsCode>
+#endif
+
+#endif

Assets/Plugins/AllIn13DShader/Shaders/ShaderLibrary/AllIn13DShader_AlphaEffects.hlsl.meta

@@ -0,0 +1,14 @@
+fileFormatVersion: 2
+guid: 2c256809ff632974b99ea50fa0ab61a3
+ShaderIncludeImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 316173
+  packageName: All In 1 3D-Shader
+  packageVersion: 2.72
+  assetPath: Assets/Plugins/AllIn13DShader/Shaders/ShaderLibrary/AllIn13DShader_AlphaEffects.hlsl
+  uploadId: 865720

Assets/Plugins/AllIn13DShader/Shaders/ShaderLibrary/AllIn13DShader_BRDF.hlsl

@@ -0,0 +1,518 @@
+#ifndef ALLIN13DSHADER_BRDF
+#define ALLIN13DSHADER_BRDF
+
+/************/
+#define MEDIUMP_FLT_MAX    65504.0
+#define saturateMediump(x) min(x, MEDIUMP_FLT_MAX)
+#define MIN_ROUGHNESS 0.01
+
+struct BDRFPerLightData
+{
+	float3 H;
+	float3 L;
+
+	float3 lightColor;
+	float distanceAttenuation;
+	float3 shadowColor;
+	float3 correctedLightColor;
+
+	float rawNdotL;
+	float correctedRawNdotL;
+	float NdotL;
+	float TdotL;
+	float BdotL;
+
+	float NdotH;
+	float TdotH;
+	float BdotH;
+
+	float VdotH;
+	float LdotH;
+	float LdotH_2;
+
+	float LdotV;
+
+	float3 F;
+	float3 kS;
+	float3 kD;
+};
+
+struct BDRFCommonData
+{
+	float3 N;
+	float3 T;
+	float3 B;
+	float3 V;
+
+	float NdotV;
+	float TdotV;
+	float BdotV;
+
+	float metallic;
+	float smoothness;
+	float roughness;
+	float roughness_2;
+	float cubeLod;
+
+	float3 F0;
+
+	float2 mainUV;
+
+	float3 positionWS;
+	float2 normalizedScreenSpaceUV;
+};
+
+float D_GGX_Anisotropic(float NoH, const float3 h,
+        const float3 t, const float3 b, float at, float ab) {
+   
+	//TODO: Pass TdotH and BdotH through parameters
+	float ToH = dot(t, h);
+    float BoH = dot(b, h);
+    float a2 = at * ab;
+    float3 v = float3(ab * ToH, at * BoH, a2 * NoH);
+    float v2 = dot(v, v);
+    float w2 = a2 / v2;
+    return a2 * w2 * w2 * (1.0 / ALLIN13DSHADER_PI);
+}
+
+float V_SmithGGXCorrelated_Anisotropic(float at, float ab, float ToV, float BoV,
+        float ToL, float BoL, float NoV, float NoL) {
+    float lambdaV = NoL * length(float3(at * ToV, ab * BoV, NoV));
+    float lambdaL = NoV * length(float3(at * ToL, ab * BoL, NoL));
+    float v = 0.5 / (lambdaV + lambdaL);
+    return saturateMediump(v);
+}
+/************/
+
+float DistributionGGX(float a, float NdotH)
+{
+	float a2     = max(a*a, MIN_ROUGHNESS * MIN_ROUGHNESS);
+	float NdotH2 = NdotH*NdotH;
+	
+	float num   = a2;
+	float denom = (NdotH2 * (a2 - 1.0) + 1.0);
+	denom = ALLIN13DSHADER_PI * denom * denom;
+	
+	return num / denom;
+}
+
+float GeometrySchlickGGX(float NdotV, float roughness)
+{
+	float r = (roughness + 1.0);
+	float k = (r*r) / 8.0;
+
+	float num   = NdotV;
+	float denom = NdotV * (1.0 - k) + k;
+	
+	return num / denom;
+}
+
+float GeometrySmith(float NdotV, float NdotL, float roughness)
+{
+	float ggx2  = GeometrySchlickGGX(NdotV, roughness);
+	float ggx1  = GeometrySchlickGGX(NdotL, roughness);
+
+	return ggx1 * ggx2;
+}
+
+float3 fresnelSchlick(float3 F0, float VdotH)
+{
+	float OneMinusVdotH = 1 - VdotH;
+	float OneMinusVdotH_5 = OneMinusVdotH * OneMinusVdotH * OneMinusVdotH * OneMinusVdotH * OneMinusVdotH;
+	return F0 + (1.0 - F0) * OneMinusVdotH_5;
+}
+
+float3 fresnelSchlickRoughness(float cosTheta, float3 F0, float roughness)
+{
+	float oneMinusRoughness = 1.0 - roughness;
+	float oneMinusCosTheta = 1.0 - cosTheta;
+
+	return F0 + (max(oneMinusRoughness, F0) - F0) * pow(clamp(oneMinusCosTheta, 0.0, 1.0), 5.0);
+}
+
+inline float3 FresnelLerp (float3 F0, float3 F90, float cosA)
+{
+    float t = Pow_5 (1 - cosA);   // ala Schlick interpoliation
+    return lerp (F0, F90, t);
+}
+
+//Cook Torrance
+float3 SpecularTerm(float a, float roughness, float3 F, float NdotH, float NdotV, float NdotL, float VdotH)
+{
+	float D		= DistributionGGX(a, NdotH);
+	float G		= GeometrySmith(NdotV, NdotL, roughness);
+	float3 numerator = 4.0 * D * G * F;
+
+	float denominator = 4 * NdotV * NdotL;
+	denominator = max(denominator, 0.0001);
+
+	float3 res = numerator / denominator;
+	return res;
+}
+
+
+float3 SpecularAnisoTerm(
+	float at, float ab, 
+	float3 F, 
+	float NdotH, float NdotV, float NdotL, 
+	float TdotV, float BdotV, 
+	float TdotL, float BdotL, 
+	float TdotH, float BdotH, 
+	float3 H, float3 T, float3 B)
+{
+	float D		= D_GGX_Anisotropic(NdotH, H, T, B, at, ab);
+	float V		= V_SmithGGXCorrelated_Anisotropic(
+					at, ab, 
+					TdotV, BdotV, 
+					TdotL, BdotL,
+					NdotV, NdotL); 
+
+	float3 res = D * V * F;
+
+	return res;
+}
+
+float3 SpecularIBL(float3 positionWS, float2 normalizedScreenSpaceUV, float3 normalWS, float3 viewDirWS, float cubeLod)
+{
+	float3 res = 0;
+	
+#ifdef REFLECTIONS_ON
+	res = GetSkyColor(positionWS, normalizedScreenSpaceUV, normalWS, viewDirWS, cubeLod);
+#endif
+	return res;
+}
+
+float3 DiffuseTerm(float LdotH, float LdotV, float NdotL, float roughness, float3 colorDiffuse)
+{
+	float LdotH_2 = LdotH * LdotH;
+
+	float f0 = 1.0;
+	float f90 = 0.5 + 2*(roughness * LdotH_2);
+
+	float3 fDiffuse = lerp(f0, f90, NdotL) * lerp(f0, f90, LdotV);
+
+	float3 res = (colorDiffuse / ALLIN13DSHADER_PI) * fDiffuse;
+	return res;
+}
+
+float3 DiffuseTerm02(float NdotV, float NdotL, float LdotH, float perceptualRoughness, float3 albedo)
+{
+    float fd90 = 0.5 + 2 * LdotH * LdotH * perceptualRoughness;
+    // Two schlick fresnel term
+    float lightScatter   = (1 + (fd90 - 1) * Pow_5(1 - NdotL));
+    float viewScatter    = (1 + (fd90 - 1) * Pow_5(1 - NdotV));
+
+	float3 res = (albedo /*/ ALLIN13DSHADER_PI*/) * lightScatter * viewScatter;
+	return res;
+}
+
+float3 IndirectLighting(float3 albedo, float3 specularColor, EffectsData effectsData, BDRFCommonData commonData, AllIn1GI gi)
+{
+	float3 N = commonData.N;
+	float3 V = commonData.V;
+
+	//float3 ambientColor = GetAmbientColor(effectsData);
+	float3 diffuse = gi.diffuse * albedo;
+
+	float3 F = fresnelSchlickRoughness(commonData.NdotV, commonData.F0, commonData.roughness);
+	float3 kS = F;
+	float3 specular = 0;
+#ifdef REFLECTIONS_ON
+	float3 specularIBL = SpecularIBL(commonData.positionWS, commonData.normalizedScreenSpaceUV, N, V, commonData.cubeLod);
+	
+	//float reflectionLuminance = GetLuminance(float4(specularIBL, 1.0));
+	//specularIBL = lerp(diffuse, specularIBL, smoothstep(0.0, 0.1, reflectionLuminance * (1 - commonData.roughness)));
+	
+	//TODO: Intermediate _Metallic values looks weird
+	float F_factor = 1 - commonData.metallic;
+	specular = specularIBL * lerp(1.0, F, F_factor);
+#else
+	specular = lerp(diffuse * 0.25, diffuse, (1 - commonData.roughness));
+#endif
+
+	float3 kD = 1.0 - kS;
+	kD *= 1.0 - commonData.metallic;
+
+	float3 indirectDiffuse = kD * diffuse;
+	
+	//TODO: Some problems with specularColor
+	float3 indirectSpecular = specular * specularColor;
+
+	
+	float3 res = indirectDiffuse + indirectSpecular;
+
+	return res;
+}
+
+
+float3 DirectDiffuse_PBR(float3 albedo, BDRFCommonData commonData, BDRFPerLightData perLightData, AllIn1LightData lightData)
+{	
+	float3 diffuseTerm = DiffuseTerm02(commonData.NdotV, perLightData.NdotL, perLightData.LdotH, commonData.roughness, albedo);
+	
+	float correctedNdotL = saturate(perLightData.correctedRawNdotL);
+	float3 directDiffuse = 0;
+#if defined(_LIGHTMODEL_CLASSIC)
+	directDiffuse = diffuseTerm * perLightData.kD * perLightData.correctedLightColor * correctedNdotL;
+#elif defined(_LIGHTMODEL_HALFLAMBERT)
+	float NdotL = saturate(perLightData.correctedRawNdotL);
+	float halfLambertTerm = (NdotL * ACCESS_PROP_FLOAT(_HalfLambertWrap)) + (1 - ACCESS_PROP_FLOAT(_HalfLambertWrap));
+	float halfLambertTerm_2 = halfLambertTerm * halfLambertTerm;
+	directDiffuse = diffuseTerm * halfLambertTerm_2 * perLightData.correctedLightColor;
+#elif defined(_LIGHTMODEL_FAKEGI)
+	float fakeGI = (correctedNdotL * ACCESS_PROP_FLOAT(_HardnessFakeGI)) + 1.0 - ACCESS_PROP_FLOAT(_HardnessFakeGI);
+	directDiffuse = diffuseTerm * fakeGI * perLightData.correctedLightColor;
+#elif defined(_LIGHTMODEL_TOON)
+	directDiffuse = diffuseTerm * perLightData.kD * perLightData.correctedLightColor * correctedNdotL;
+	float toonFactor = smoothstep(ACCESS_PROP_FLOAT(_ToonCutoff), ACCESS_PROP_FLOAT(_ToonCutoff) + ACCESS_PROP_FLOAT(_ToonSmoothness), correctedNdotL);
+	directDiffuse *= toonFactor;
+#elif defined(_LIGHTMODEL_TOONRAMP)
+	float3 rampLight = SAMPLE_TEX2D_LOD(_ToonRamp, float4((perLightData.correctedRawNdotL * 0.5) + 0.5, 0, 0, 0)).rgb;
+	directDiffuse = diffuseTerm * perLightData.kD * perLightData.correctedLightColor * rampLight;
+	//float diffuseTermLuminance = GetLuminance(directDiffuse);
+	//directDiffuse = SAMPLE_TEX2D(_ToonRamp, float2(diffuseTermLuminance, diffuseTermLuminance)).rgb;
+#endif
+	
+	return directDiffuse;
+}
+
+#ifdef SPECULAR_ON
+float3 DirectSpecular_PBR(float3 specularColor, BDRFCommonData commonData, BDRFPerLightData perLightData, AllIn1LightData lightData, float4 specularMap)
+{
+	float3 specularTerm = 0;
+
+	//float4 specularMap = SAMPLE_TEX2D(_SpecularMap, commonData.mainUV);
+
+	#if defined(_SPECULARMODEL_CLASSIC)
+		specularTerm = SpecularTerm(commonData.roughness_2, commonData.roughness, perLightData.F, perLightData.NdotH, commonData.NdotV, perLightData.NdotL, perLightData.VdotH);
+	#elif defined(_SPECULARMODEL_TOON)
+		specularTerm = SpecularTerm(commonData.roughness_2, commonData.roughness, perLightData.F, perLightData.NdotH, commonData.NdotV, perLightData.NdotL, perLightData.VdotH);
+		specularTerm = smoothstep(ACCESS_PROP_FLOAT(_SpecularToonCutoff), ACCESS_PROP_FLOAT(_SpecularToonCutoff) + ACCESS_PROP_FLOAT(_SpecularToonSmoothness), specularTerm);
+	#elif defined(_SPECULARMODEL_ANISOTROPIC) || defined(_SPECULARMODEL_ANISOTROPICTOON)
+		//https://google.github.io/filament/Filament.html?utm_source=chatgpt.com#materialsystem/anisotropicmodel
+		float aniso = ACCESS_PROP_FLOAT(_Anisotropy);
+		float at = max((1 - ACCESS_PROP_FLOAT(_AnisoShininess)) * (1.0 + aniso), 0.001);
+		float ab = max((1 - ACCESS_PROP_FLOAT(_AnisoShininess)) * (1.0 - aniso), 0.001);
+
+		specularTerm = SpecularAnisoTerm(at, ab, perLightData.F, 
+											perLightData.NdotH, commonData.NdotV, perLightData.NdotL, 
+											commonData.TdotV, commonData.BdotV, perLightData.TdotL, 
+											perLightData.BdotL, perLightData.TdotH, perLightData.BdotH, 
+											perLightData.H, commonData.T, commonData.B);
+		specularTerm = saturate(specularTerm);
+
+		#if defined(_SPECULARMODEL_ANISOTROPICTOON)
+			float specularSmoothness = max(ACCESS_PROP_FLOAT(_SpecularToonSmoothness), 0.001);
+			specularTerm = smoothstep(ACCESS_PROP_FLOAT(_SpecularToonCutoff), ACCESS_PROP_FLOAT(_SpecularToonCutoff) + specularSmoothness, specularTerm);
+		#endif
+	#endif
+
+	specularTerm *= specularMap.r;
+
+	float3 directSpecular = specularTerm * specularColor * ACCESS_PROP_FLOAT(_SpecularAtten) * perLightData.correctedLightColor * perLightData.NdotL;
+	return directSpecular;
+}
+#endif
+
+float3 DirectLighting_PBR(float3 albedo, BDRFCommonData commonData, BDRFPerLightData perLightData, AllIn1LightData lightData, float4 specularMap)
+{
+	float3 diffuseTerm = DirectDiffuse_PBR(albedo, commonData, perLightData, lightData);
+
+	float3 specularColor = lerp(1.0, albedo, commonData.metallic);
+
+	float3 specularTerm = 0;
+#ifdef SPECULAR_ON
+	specularTerm = DirectSpecular_PBR(specularColor, commonData, perLightData, lightData, specularMap);
+#endif
+
+	float3 directLight = diffuseTerm + specularTerm;
+	return directLight;
+}
+
+BDRFCommonData CreateCommonBDRFData(float3 albedo, EffectsData effectsData)
+{
+	BDRFCommonData res;
+
+	res.N = effectsData.normalWS;
+	res.T = effectsData.tangentWS;
+	res.B = effectsData.bitangentWS;
+	res.V =  normalize(_WorldSpaceCameraPos.xyz - effectsData.vertexWS);
+
+	res.metallic = effectsData.metallic;
+	float smoothness = effectsData.smoothness;
+#ifdef _METALLIC_MAP_ON
+	float4 metallicMapColor = SAMPLE_TEX2D(_MetallicMap, effectsData.mainUV);
+
+	float metallicMapValue = metallicMapColor.r;
+	res.metallic *= metallicMapValue;
+	res.metallic = saturate(res.metallic);
+
+	float glossMapValue = metallicMapColor.a;
+	smoothness *= glossMapValue;
+	smoothness = saturate(smoothness);
+#endif
+
+	res.smoothness = lerp(0, 0.95, smoothness);
+
+	res.roughness = (1 - res.smoothness);
+	res.roughness_2 = res.roughness * res.roughness;
+	res.cubeLod = res.roughness * 8;
+
+	res.NdotV = max(dot(res.N, res.V), 0.0);
+	res.TdotV = max(dot(res.T, res.V), 0.0);
+	res.BdotV = max(dot(res.B, res.V), 0.0);
+
+
+	float3 f0 = 0.04;
+	f0 = lerp(f0, albedo, res.metallic);
+
+	res.F0 = f0;
+
+	res.mainUV = effectsData.mainUV;
+
+	res.positionWS = effectsData.vertexWS;
+	res.normalizedScreenSpaceUV = effectsData.normalizedScreenSpaceUV;
+
+	return res;
+}
+
+BDRFPerLightData CreatePerLightData(BDRFCommonData commonData, AllIn1LightData lightData, float isAdditionalLight)
+{
+	BDRFPerLightData res;
+
+	float oneMinusMetallic = 1 - commonData.metallic;
+
+	res.L = lightData.lightDir;
+	
+	res.lightColor = lightData.lightColor.rgb;
+	res.distanceAttenuation = lightData.distanceAttenuation;
+	res.shadowColor = lightData.shadowColor.rgb;
+	res.correctedLightColor = lightData.lightColor.rgb * lightData.distanceAttenuation * lightData.shadowColor.rgb;
+
+	res.H = normalize(commonData.V + res.L);
+
+	res.NdotH = max(dot(commonData.N, res.H), 0.0);
+	res.rawNdotL = dot(commonData.N, res.L);
+	res.correctedRawNdotL = res.rawNdotL;
+	#if !defined(FORWARD_ADD_PASS)
+		#if defined(_LIGHTMODEL_HALFLAMBERT) || defined(_LIGHTMODEL_FAKEGI) || defined(_LIGHTMODEL_TOONRAMP)
+			res.correctedLightColor = isAdditionalLight > 0 ? res.correctedLightColor : res.lightColor;
+			res.correctedRawNdotL = isAdditionalLight > 0 ? res.correctedRawNdotL : res.correctedRawNdotL * GetLuminance(lightData.shadowColor.rgb);
+		#endif
+	#endif
+
+	res.NdotL = max(res.rawNdotL, 0.0);
+	res.TdotL = max(dot(commonData.T, res.L), 0.0);
+	res.BdotL = max(dot(commonData.B, res.L), 0.0);
+
+	res.VdotH = max(dot(commonData.V, res.H), 0.0);
+	res.TdotH = max(dot(commonData.T, res.H), 0.0);
+	res.BdotH = max(dot(commonData.B, res.H), 0.0);
+
+	res.LdotV = max(dot(res.L, commonData.V), 0.0);
+	res.LdotH = max(dot(res.L, res.H), 0.0);
+
+	res.LdotH_2 = res.LdotH * res.LdotH;
+
+	res.F = fresnelSchlick(commonData.F0, res.VdotH);
+	res.kS = res.F;
+	res.kD = (1.0 - res.kS) * oneMinusMetallic;
+
+	return res;
+}
+
+float3 CalculateLighting_PBR(float3 albedo, float alpha, EffectsData effectsData, AllIn1GI gi)
+{
+	BDRFCommonData commonData = CreateCommonBDRFData(albedo, effectsData);
+
+	float3 specularColor = lerp(1.0, albedo, commonData.metallic);
+
+	AllIn1LightData mainLightData = GetMainLightData(effectsData.vertexWS, effectsData, gi);
+
+
+	float3 directLighting = albedo;
+	float4 specularMap = float4(1, 1, 1, 1);
+
+
+#ifdef ALLIN1_USE_LIGHT_LAYERS
+	uint meshRenderingLayers = AllIn1GetMeshRenderingLayer();
+	directLighting = 0;
+	if (IsMatchingLightLayer(mainLightData.layerMask, meshRenderingLayers))
+	{
+		directLighting = albedo;
+#endif
+	BDRFPerLightData perLightData_mainLight = CreatePerLightData(commonData, mainLightData, 0.0);
+
+#ifdef SPECULAR_ON
+	specularMap = SAMPLE_TEX2D(_SpecularMap, commonData.mainUV);
+#endif
+
+	directLighting = DirectLighting_PBR(albedo, commonData, perLightData_mainLight, mainLightData, specularMap);
+
+#ifdef ALLIN1_USE_LIGHT_LAYERS
+	}
+#endif
+
+#if defined(ADDITIONAL_LIGHT_LOOP) && !defined(_LIGHTMODEL_FASTLIGHTING)
+	// Additional light loop for non-main directional lights. This block is specific to Forward+.
+	#if USE_CLUSTER_LIGHT_LOOP
+	UNITY_LOOP for (uint lightIndex = 0; lightIndex < min(URP_FP_DIRECTIONAL_LIGHTS_COUNT, MAX_VISIBLE_LIGHTS); lightIndex++)
+	{
+		AllIn1LightData additionalLightData = GetPointLightData(lightIndex, effectsData.vertexWS, effectsData.normalWS, effectsData, gi);
+		#ifdef ALLIN1_USE_LIGHT_LAYERS
+		if (IsMatchingLightLayer(additionalLightData.layerMask, meshRenderingLayers))
+		{
+		#endif
+			BDRFPerLightData perLightData_additionalLight = CreatePerLightData(commonData, additionalLightData, 1.0);
+			directLighting += DirectLighting_PBR(albedo, commonData, perLightData_additionalLight, additionalLightData, specularMap);
+		#ifdef ALLIN1_USE_LIGHT_LAYERS
+		}
+		#endif
+	}
+	#endif
+	
+	
+	uint numAdditionalLights = NUM_ADDITIONAL_LIGHTS;
+	LIGHT_LOOP_BEGIN_ALLIN13D(numAdditionalLights, effectsData)
+		AllIn1LightData additionalLightData = GetPointLightData(lightIndex, effectsData.vertexWS, effectsData.normalWS, effectsData, gi);
+	#ifdef ALLIN1_USE_LIGHT_LAYERS
+		
+		uint meshRenderingLayers = AllIn1GetMeshRenderingLayer();
+		if (IsMatchingLightLayer(additionalLightData.layerMask, meshRenderingLayers))
+		{ 
+	#endif
+		BDRFPerLightData perLightData_additionalLight = CreatePerLightData(commonData, additionalLightData, 1.0);
+		directLighting += DirectLighting_PBR(albedo, commonData, perLightData_additionalLight, additionalLightData, specularMap);
+
+	#ifdef ALLIN1_USE_LIGHT_LAYERS
+		}
+	#endif
+
+	LIGHT_LOOP_END_ALLIN13D
+#endif
+	
+	float2 ssaoFactor = GetSSAO(effectsData.normalizedScreenSpaceUV.xy, alpha);
+	
+	float3 res = directLighting * ssaoFactor.x;
+
+	
+	
+	//We add IndirectLighting only once
+#ifndef FORWARD_ADD_PASS
+	#if defined(_CUSTOM_SHADOW_COLOR_ON)
+		float shadowT = saturate(mainLightData.realtimeShadow + 1.0 - global_shadowColor.a);
+		res = lerp(global_shadowColor, res, shadowT);
+	#endif
+
+	float3 ao = 1.0;
+	#ifdef _AOMAP_ON
+		ao = GetAOMapTerm(effectsData.mainUV);
+	#endif
+
+	float3 indirectLighting = IndirectLighting(albedo, specularColor, effectsData, commonData, gi);
+	res += (indirectLighting) * ao * ssaoFactor.y;
+#endif
+
+	return res;
+}
+
+#endif

Assets/Plugins/AllIn13DShader/Shaders/ShaderLibrary/AllIn13DShader_BRDF.hlsl.meta

@@ -0,0 +1,14 @@
+fileFormatVersion: 2
+guid: 48d6d644a14e13f469715bc1a7d738df
+ShaderIncludeImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 316173
+  packageName: All In 1 3D-Shader
+  packageVersion: 2.72
+  assetPath: Assets/Plugins/AllIn13DShader/Shaders/ShaderLibrary/AllIn13DShader_BRDF.hlsl
+  uploadId: 865720

Assets/Plugins/AllIn13DShader/Shaders/ShaderLibrary/AllIn13DShader_BasePass.hlsl

@@ -0,0 +1,252 @@
+#ifndef ALLIN13DSHADER_BASE_PASS_INCLUDED
+#define ALLIN13DSHADER_BASE_PASS_INCLUDED
+
+FragmentData BasicVertex(VertexData v)
+{
+	FragmentData o;
+	
+	UNITY_SETUP_INSTANCE_ID(v);
+    UNITY_TRANSFER_INSTANCE_ID(v, o);
+	UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(o); 
+
+#ifdef _SPHERIZE_NORMALS_ON
+	float3 normalOS = normalize(v.vertex);
+#else
+	float3 normalOS = v.normal;
+#endif
+
+	o.interpolator_01 = 0; 
+
+#ifdef _USE_CUSTOM_TIME
+	SHADER_TIME(o) = allIn13DShader_globalTime.xyz + ACCESS_PROP_FLOAT(_TimingSeed);
+#else
+	SHADER_TIME(o) = _Time.xyz + ACCESS_PROP_FLOAT(_TimingSeed);
+#endif
+
+	float3 originalVertex = v.vertex.xyz;
+	
+	v.vertex = ApplyVertexEffects(v.vertex, normalOS, SHADER_TIME(o));
+#ifdef _RECALCULATE_NORMALS_ON
+	float3 tangentNeighbour = originalVertex + normalize(v.tangent.xyz) * RECALCULATE_NORMAL_OFFSET;
+	float3 bitangent = normalize(cross(v.normal, v.tangent.xyz));
+	float3 bitangentNeightbour = originalVertex + bitangent * RECALCULATE_NORMAL_OFFSET;
+
+	tangentNeighbour = ApplyVertexEffects(float4(tangentNeighbour, 1.0), normalOS, SHADER_TIME(o)).xyz;
+	bitangentNeightbour = ApplyVertexEffects(float4(bitangentNeightbour, 1.0), normalOS, SHADER_TIME(o)).xyz;
+
+	float3 correctedTangent = normalize(tangentNeighbour - v.vertex.xyz);
+	float3 correctedBitangent = normalize(bitangentNeightbour - v.vertex.xyz);
+
+	v.tangent = float4(correctedTangent, v.tangent.w);
+	normalOS = normalize(cross(correctedTangent, correctedBitangent));
+#endif
+
+
+	POSITION_OS(o) = v.vertex.xyz;
+	NORMAL_OS(o) = normalOS;
+	POSITION_WS(o) = GetPositionWS(v.vertex);
+
+	o.normalWS = GetNormalWS(normalOS);
+
+	o.pos = OBJECT_TO_CLIP_SPACE(v);
+
+	
+	
+	VIEWDIR_WS(o) = GetViewDirWS(POSITION_WS(o));
+	
+	float4 projPos = 0;
+	
+	
+#if defined(REQUIRE_SCREEN_POS)
+	o.projPos = ComputeScreenPos(o.pos);
+	
+	#if defined(REQUIRE_SCENE_DEPTH)
+		o.projPos.z = ComputeEyeDepth(POSITION_WS(o));
+	#endif
+	
+	projPos = o.projPos;
+#endif
+
+	float2 uv = v.uv;
+	uv = ApplyUVEffects_VertexStage(uv, POSITION_WS(o), projPos, SHADER_TIME(o));
+	
+	UV_DIFF(o) = uv - v.uv;
+
+	SCALED_MAIN_UV(o) = CUSTOM_TRANSFORM_TEX(v.uv, UV_DIFF(o), _MainTex);
+	RAW_MAIN_UV(o) = uv;
+	
+	o.interpolator_02 = 0;
+
+
+#if defined(REQUIRE_TANGENT_WS)
+	float3 tangentWS = GetDirWS(float4(v.tangent.xyz, 0));
+	float3 bitangentWS = GetBitangentWS(v.tangent, tangentWS, o.normalWS);
+	INIT_T_SPACE(o.normalWS)
+
+	UV_NORMAL_MAP(o) = CUSTOM_TRANSFORM_TEX(v.uv, UV_DIFF(o), _NormalMap);
+#endif
+
+	ShadowCoordStruct shadowCoordStruct = GetShadowCoords(v, o.pos, POSITION_WS(o), v.uvLightmap);
+	o._ShadowCoord = shadowCoordStruct._ShadowCoord;
+
+#ifdef LIGHTMAP_ON
+	UV_LIGHTMAP(o) = v.uvLightmap * unity_LightmapST.xy + unity_LightmapST.zw;
+#else
+	UV_LIGHTMAP(o) = v.uvLightmap;
+#endif
+	FOGCOORD(o) = GetFogFactor(o.pos);
+
+#ifdef _EMISSION_ON
+	UV_EMISSION_MAP(o) = SIMPLE_CUSTOM_TRANSFORM_TEX(v.uv, _EmissionMap); 
+#endif
+
+
+	//Vertex Color initialization
+	VERTEX_COLOR_R(o) = v.vertexColor.r;	
+	VERTEX_COLOR_G(o) = v.vertexColor.g;
+	VERTEX_COLOR_B(o) = v.vertexColor.b;
+	VERTEX_COLOR_A(o) = v.vertexColor.a;
+
+	return o;
+}
+
+float4 BasicFragment(
+	FragmentData i
+	#ifdef _WRITE_RENDERING_LAYERS
+		#if UNITY_VERSION >= 60020000
+			, out uint outRenderingLayers : SV_Target1
+		#else
+			, out float4 outRenderingLayers : SV_Target1
+		#endif
+	#endif
+	) : SV_Target
+{
+	UNITY_SETUP_INSTANCE_ID(i);
+	UNITY_SETUP_STEREO_EYE_INDEX_POST_VERTEX(i);
+
+	#if defined(LOD_FADE_CROSSFADE)
+		ALLIN1_APPLY_CROSSFADE(i)
+	#endif
+	
+	AllIn1DecalData decalData;
+	INIT_DECAL_DATA(decalData);
+
+#ifdef ALLIN1_DECALS_READY_TO_USE
+	ConfigureDecalData(decalData, i.pos);
+#endif
+
+
+#if defined(_FLAT_NORMALS_ON)
+	i.normalWS = GetFlatNormalWS(i.normalWS, POSITION_WS(i));
+	#if defined(REQUIRE_TANGENT_WS)
+		i.tspace0 = float3(i.tspace0.x, i.tspace0.y, i.normalWS.x);
+		i.tspace1 = float3(i.tspace1.x, i.tspace1.y, i.normalWS.y);
+		i.tspace2 = float3(i.tspace2.x, i.tspace2.y, i.normalWS.z);
+	#endif
+#endif
+
+	EffectsData data = CalculateEffectsData(i, decalData);
+	
+	data = ApplyUVEffects_FragmentStage(data);
+
+
+	data.normalWS = GetNormalWS(data, i, decalData);
+
+
+
+#ifdef _NORMAL_MAP_ON
+	data.bitangentWS = normalize(cross(data.normalWS, data.tangentWS));
+#endif
+
+	float4 objectColor = GetBaseColor(data);
+
+	float3 normalOS = data.normalOS;
+	float3 normalWS = data.normalWS;
+	float3 viewDirWS = data.viewDirWS;
+
+	float sceneDepthDiff = 1.0;
+	float normalizedDepth = 0;
+#ifdef REQUIRE_SCENE_DEPTH
+	sceneDepthDiff = GetSceneDepthDiff(i.projPos);
+	normalizedDepth = GetNormalizedDepth(i.projPos);
+#endif
+
+	float camDistance = 0;
+#ifdef REQUIRE_CAM_DISTANCE
+	camDistance = distance(POSITION_WS(i), _WorldSpaceCameraPos);
+#endif
+	
+	objectColor *= ACCESS_PROP_FLOAT4(_Color);
+	objectColor = ApplyColorEffectsBeforeLighting(objectColor, data);
+
+#ifdef ALLIN1_DECALS_READY_TO_USE
+	objectColor.rgb = objectColor.rgb * decalData.baseColor.a + decalData.baseColor.rgb;
+#endif
+
+	float4 col = objectColor;
+	
+
+
+	AllIn1GI gi = CalculateGI(UV_LIGHTMAP(i), data);
+	float3 lightmap = GetLightmap(UV_LIGHTMAP(i), data);
+#if defined(_AFFECTED_BY_LIGHTMAPS_ON) && defined(_LIGHTMAP_COLOR_CORRECTION_ON)
+	lightmap = LightmapColorCorrection(lightmap);
+#endif
+
+
+	float3 ambientColor = GetAmbientColor(data);
+
+#ifdef LIGHT_ON
+	float3 mainLightColor = GetMainLightColorRGB();
+	float3 mainLightDir = GetMainLightDir(POSITION_WS(i));
+
+	col.rgb = CalculateLighting(
+		POSITION_WS(i),
+		normalWS, data.tangentWS, data.bitangentWS,
+		objectColor.rgb, objectColor.a,
+		1.0, ambientColor, viewDirWS, 
+		SCALED_MAIN_UV(i), mainLightColor, mainLightDir, i, 1.0, data, 
+		gi); 
+#else
+	float2 ssaoFactor = GetSSAO(data.normalizedScreenSpaceUV.xy, objectColor.a);
+	col.rgb = IndirectLighting_Basic(objectColor.rgb, ssaoFactor, data, gi);
+#endif
+	
+#ifdef _EMISSION_ON
+	float2 emissionUV = SIMPLE_CUSTOM_TRANSFORM_TEX(MAIN_UV(data), _EmissionMap);
+	float4 emissionMapCol = SAMPLE_TEX2D(_EmissionMap, emissionUV);
+	float4 emissionCol = emissionMapCol * ACCESS_PROP_FLOAT4(_EmissionColor) * ACCESS_PROP_FLOAT(_EmissionSelfGlow);
+
+	emissionCol.rgb += decalData.emissive;
+
+	col.rgb += emissionCol.rgb;
+#endif
+	
+	col = ApplyAlphaEffects(col, 
+		SCALED_MAIN_UV(i), UV_LIGHTMAP(i), data.vertexWS, 
+		sceneDepthDiff, data.camDistance, data.projPos); 
+
+#ifdef _ALPHA_CUTOFF_ON
+	clip((col.a - ACCESS_PROP_FLOAT(_AlphaCutoffValue)) - 0.001);
+#endif	
+
+	col = ApplyColorEffectsAfterLighting(col, data);
+	col.a *= ACCESS_PROP_FLOAT(_GeneralAlpha);
+	
+#if defined(FOG_ENABLED)
+	col = CustomMixFog(FOGCOORD(i), col);
+#endif
+
+#if defined(_WRITE_RENDERING_LAYERS)
+	#if UNITY_VERSION >= 60020000
+		outRenderingLayers = EncodeMeshRenderingLayer();
+	#else
+		uint renderingLayers = AllIn1GetMeshRenderingLayer();
+		outRenderingLayers = float4(EncodeMeshRenderingLayer(renderingLayers), 0, 0, 0);
+	#endif
+#endif
+
+	return col;
+}
+
+#endif /*ALLIN13DSHADER_BASE_PASS_INCLUDED*/

Assets/Plugins/AllIn13DShader/Shaders/ShaderLibrary/AllIn13DShader_BasePass.hlsl.meta

@@ -0,0 +1,14 @@
+fileFormatVersion: 2
+guid: 3f95914655851fb429e79f8b41ef5cf0
+ShaderIncludeImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 316173
+  packageName: All In 1 3D-Shader
+  packageVersion: 2.72
+  assetPath: Assets/Plugins/AllIn13DShader/Shaders/ShaderLibrary/AllIn13DShader_BasePass.hlsl
+  uploadId: 865720

Assets/Plugins/AllIn13DShader/Shaders/ShaderLibrary/AllIn13DShader_BufferPropertiesDeclaration.hlsl

@@ -0,0 +1,364 @@
+#ifndef ALLIN13DSHADER_BUFFERPROPERTIESDECLARATION
+#define ALLIN13DSHADER_BUFFERPROPERTIESDECLARATION
+
+DECLARE_PROPERTY_FLOAT4(_MainTex_ST)
+DECLARE_PROPERTY_FLOAT4(_Color)
+DECLARE_PROPERTY_FLOAT(_GeneralAlpha)
+DECLARE_PROPERTY_FLOAT(_TimingSeed)
+
+#if defined(REQUIRE_TANGENT_WS) || defined(ALWAYS_DECLARE_PROPERTY)
+	DECLARE_PROPERTY_FLOAT4(_NormalMap_ST)
+	DECLARE_PROPERTY_FLOAT(_NormalStrength)
+	#if defined(_TRIPLANAR_MAPPING_ON) || defined(ALWAYS_DECLARE_PROPERTY)
+		DECLARE_PROPERTY_FLOAT(_TopNormalStrength)
+	#endif
+#endif
+
+#if defined(_FLAT_NORMALS_ON) || defined(ALWAYS_DECLARE_PROPERTY)
+	DECLARE_PROPERTY_FLOAT(_FlatNormalsBlend)
+#endif
+
+#if defined(_SHADINGMODEL_PBR) || defined(_SPECULARMODEL_ANISOTROPIC) || defined(_SPECULARMODEL_ANISOTROPICTOON) || defined(ALWAYS_DECLARE_PROPERTY)
+	#define HAS_PBR_PROPERTIES
+	DECLARE_PROPERTY_FLOAT(_Metallic)
+	DECLARE_PROPERTY_FLOAT(_Smoothness)
+#endif
+
+#if defined(_LIGHTMODEL_TOON) || defined(ALWAYS_DECLARE_PROPERTY)
+	DECLARE_PROPERTY_FLOAT(_ToonCutoff)
+	DECLARE_PROPERTY_FLOAT(_ToonSmoothness)
+#endif
+
+#if defined(_LIGHTMODEL_HALFLAMBERT) || defined(ALWAYS_DECLARE_PROPERTY)
+	DECLARE_PROPERTY_FLOAT(_HalfLambertWrap)
+#endif
+
+#if defined(_LIGHTMODEL_FAKEGI) || defined(ALWAYS_DECLARE_PROPERTY)
+	DECLARE_PROPERTY_FLOAT(_HardnessFakeGI)
+#endif
+
+#if defined(SPECULAR_ON) || defined(ALWAYS_DECLARE_PROPERTY)
+	DECLARE_PROPERTY_FLOAT(_SpecularAtten)
+	DECLARE_PROPERTY_FLOAT(_Shininess)
+		
+	DECLARE_PROPERTY_FLOAT(_Anisotropy)
+	DECLARE_PROPERTY_FLOAT(_AnisoShininess)
+#endif
+
+#if (defined(_AFFECTED_BY_LIGHTMAPS_ON) && defined(_LIGHTMAP_COLOR_CORRECTION_ON)) || defined(ALWAYS_DECLARE_PROPERTY)
+	DECLARE_PROPERTY_FLOAT(_HueShiftLM)
+	DECLARE_PROPERTY_FLOAT(_HueSaturationLM)
+	DECLARE_PROPERTY_FLOAT(_HueBrightnessLM)
+	DECLARE_PROPERTY_FLOAT(_ContrastLM)
+	DECLARE_PROPERTY_FLOAT(_BrightnessLM)
+#endif
+
+#if defined(_RECEIVE_SHADOWS_ON)
+	DECLARE_PROPERTY_FLOAT(_ShadowCutoff)
+#endif
+
+#if defined(_CUSTOM_AMBIENT_LIGHT_ON) || defined(ALWAYS_DECLARE_PROPERTY)
+	DECLARE_PROPERTY_FLOAT4(_CustomAmbientColor)
+#endif
+
+#if defined(_SPECULARMODEL_TOON) || defined(_SPECULARMODEL_ANISOTROPICTOON) || defined(ALWAYS_DECLARE_PROPERTY)
+	DECLARE_PROPERTY_FLOAT(_SpecularToonCutoff)
+	DECLARE_PROPERTY_FLOAT(_SpecularToonSmoothness)
+#endif
+
+#if defined(_AOMAP_ON) || defined(ALWAYS_DECLARE_PROPERTY)
+	DECLARE_PROPERTY_FLOAT4(_AOMap_ST)
+	DECLARE_PROPERTY_FLOAT(_AOMapStrength)
+	DECLARE_PROPERTY_FLOAT(_AOContrast)
+	DECLARE_PROPERTY_FLOAT4(_AOColor)
+#endif
+
+#if defined(REFLECTIONS_ON) || defined(ALWAYS_DECLARE_PROPERTY)
+	DECLARE_PROPERTY_FLOAT(_ReflectionsAtten)
+	#if defined(_REFLECTIONS_TOON) || defined(ALWAYS_DECLARE_PROPERTY)
+		DECLARE_PROPERTY_FLOAT(_ToonFactor)
+	#endif 
+#endif
+
+#if defined(_CONTRAST_BRIGHTNESS_ON) || defined(ALWAYS_DECLARE_PROPERTY)
+	DECLARE_PROPERTY_FLOAT(_Contrast)
+	DECLARE_PROPERTY_FLOAT(_Brightness)
+#endif
+
+#if defined(_HEIGHT_GRADIENT_ON) || defined(ALWAYS_DECLARE_PROPERTY)
+	DECLARE_PROPERTY_FLOAT(_MinGradientHeight)
+	DECLARE_PROPERTY_FLOAT(_MaxGradientHeight)
+	DECLARE_PROPERTY_FLOAT4(_GradientHeightColor01)
+	DECLARE_PROPERTY_FLOAT4(_GradientHeightColor02)
+#endif
+
+#if defined(_INTERSECTION_GLOW_ON) || defined(ALWAYS_DECLARE_PROPERTY)
+	DECLARE_PROPERTY_FLOAT(_DepthGlowDist)
+	DECLARE_PROPERTY_FLOAT(_DepthGlowPower)
+	DECLARE_PROPERTY_FLOAT4(_DepthGlowColor)
+	DECLARE_PROPERTY_FLOAT(_DepthGlowColorIntensity)
+	DECLARE_PROPERTY_FLOAT(_DepthGlowGlobalIntensity)
+#endif
+
+#if defined(_INTERSECTION_FADE_ON) || defined(ALWAYS_DECLARE_PROPERTY)
+	DECLARE_PROPERTY_FLOAT(_IntersectionFadeFactor)
+#endif
+
+#if defined(_HIGHLIGHTS_ON) || defined(ALWAYS_DECLARE_PROPERTY)
+	DECLARE_PROPERTY_FLOAT4(_HighlightsColor)
+	DECLARE_PROPERTY_FLOAT(_HighlightsStrength)
+	DECLARE_PROPERTY_FLOAT(_HighlightCutoff)
+	DECLARE_PROPERTY_FLOAT(_HighlightSmoothness)
+	DECLARE_PROPERTY_FLOAT3(_HighlightOffset)
+#endif
+
+#if defined(_RIM_LIGHTING_ON) || defined(ALWAYS_DECLARE_PROPERTY)
+	DECLARE_PROPERTY_FLOAT4(_RimColor)
+	DECLARE_PROPERTY_FLOAT(_RimAttenuation)
+	DECLARE_PROPERTY_FLOAT(_MinRim)
+	DECLARE_PROPERTY_FLOAT(_MaxRim)
+	DECLARE_PROPERTY_FLOAT3(_RimOffset)
+#endif
+
+#if defined(_HUE_SHIFT_ON) || defined(ALWAYS_DECLARE_PROPERTY)
+	DECLARE_PROPERTY_FLOAT(_HueShift)
+	DECLARE_PROPERTY_FLOAT(_HueSaturation)
+	DECLARE_PROPERTY_FLOAT(_HueBrightness)
+#endif
+
+#if defined(_HIT_ON) || defined(ALWAYS_DECLARE_PROPERTY)
+	DECLARE_PROPERTY_FLOAT4(_HitColor)
+	DECLARE_PROPERTY_FLOAT(_HitGlow)
+	DECLARE_PROPERTY_FLOAT(_HitBlend)
+#endif
+
+#if defined(_STOCHASTIC_SAMPLING_ON) || defined(ALWAYS_DECLARE_PROPERTY)
+	DECLARE_PROPERTY_FLOAT(_StochasticScale)
+	DECLARE_PROPERTY_FLOAT(_StochasticSkew)
+#endif
+
+#if defined(_VERTEX_SHAKE_ON) || defined(ALWAYS_DECLARE_PROPERTY)
+	DECLARE_PROPERTY_FLOAT4(_ShakeSpeed)
+	DECLARE_PROPERTY_FLOAT(_ShakeSpeedMult)
+	DECLARE_PROPERTY_FLOAT4(_ShakeMaxDisplacement)
+	DECLARE_PROPERTY_FLOAT(_ShakeBlend)
+#endif
+
+#if defined(_FADE_ON) || defined(ALWAYS_DECLARE_PROPERTY)
+	DECLARE_PROPERTY_FLOAT4(_FadeTex_ST)
+	DECLARE_PROPERTY_FLOAT(_FadeAmount)
+	DECLARE_PROPERTY_FLOAT(_FadePower)
+	DECLARE_PROPERTY_FLOAT(_FadeTransition)
+	#if defined(_FADE_BURN_ON) || defined(ALWAYS_DECLARE_PROPERTY)
+		DECLARE_PROPERTY_FLOAT4(_FadeBurnColor)
+		DECLARE_PROPERTY_FLOAT(_FadeBurnWidth)
+		DECLARE_PROPERTY_FLOAT(_BurnCutoff)
+		DECLARE_PROPERTY_FLOAT(_BurnSmoothness)
+	#endif
+#endif
+
+#if defined(_FADE_BY_CAM_DISTANCE_ON) || defined(ALWAYS_DECLARE_PROPERTY)
+	DECLARE_PROPERTY_FLOAT(_MinDistanceToFade)
+	DECLARE_PROPERTY_FLOAT(_MaxDistanceToFade)
+#endif
+
+#if defined(_DITHER_ON) || defined(ALWAYS_DECLARE_PROPERTY)
+	DECLARE_PROPERTY_FLOAT(_DitherScale)
+#endif
+
+#if defined(_VERTEX_INFLATE_ON) || defined(ALWAYS_DECLARE_PROPERTY)
+	DECLARE_PROPERTY_FLOAT(_MinInflate)
+	DECLARE_PROPERTY_FLOAT(_MaxInflate)
+	DECLARE_PROPERTY_FLOAT(_InflateBlend)
+#endif
+
+#if defined(_VERTEX_DISTORTION_ON) || defined(ALWAYS_DECLARE_PROPERTY)
+	DECLARE_PROPERTY_FLOAT4(_VertexDistortionNoiseTex_ST)
+	DECLARE_PROPERTY_FLOAT(_VertexDistortionAmount)
+	DECLARE_PROPERTY_FLOAT(_VertexDistortionNoiseSpeedX)
+	DECLARE_PROPERTY_FLOAT(_VertexDistortionNoiseSpeedY)
+#endif
+
+#if defined(_VOXELIZE_ON) || defined(ALWAYS_DECLARE_PROPERTY)
+	DECLARE_PROPERTY_FLOAT(_VoxelSize)
+	DECLARE_PROPERTY_FLOAT(_VoxelBlend)
+#endif
+
+#if defined(_GLITCH_ON) || defined(ALWAYS_DECLARE_PROPERTY)
+	DECLARE_PROPERTY_FLOAT(_GlitchTiling)
+	DECLARE_PROPERTY_FLOAT(_GlitchAmount)
+	DECLARE_PROPERTY_FLOAT3(_GlitchOffset)
+	DECLARE_PROPERTY_FLOAT(_GlitchSpeed)
+	DECLARE_PROPERTY_FLOAT(_GlitchWorldSpace)
+#endif
+
+#if defined(_WIND_ON) || defined(ALWAYS_DECLARE_PROPERTY)
+	DECLARE_PROPERTY_FLOAT(_WindAttenuation)
+	#if defined(_USE_WIND_VERTICAL_MASK) || defined(ALWAYS_DECLARE_PROPERTY)
+		DECLARE_PROPERTY_FLOAT(_WindVerticalMaskMinY)
+		DECLARE_PROPERTY_FLOAT(_WindVerticalMaskMaxY)
+	#endif
+#endif
+
+#if defined(_COLOR_RAMP_ON) || defined(ALWAYS_DECLARE_PROPERTY)
+	DECLARE_PROPERTY_FLOAT(_ColorRampLuminosity)
+	DECLARE_PROPERTY_FLOAT(_ColorRampBlend)
+	DECLARE_PROPERTY_FLOAT(_ColorRampScrollSpeed)
+	DECLARE_PROPERTY_FLOAT(_ColorRampTiling)
+#endif
+
+#if defined(_ALBEDO_VERTEX_COLOR_ON) || defined(ALWAYS_DECLARE_PROPERTY)
+	DECLARE_PROPERTY_FLOAT(_VertexColorBlending)
+#endif
+
+
+
+//Texture blending properties declaration
+#if defined(ALWAYS_DECLARE_PROPERTY)
+	DECLARE_PROPERTY_FLOAT4(_BlendingTextureG_ST)
+	DECLARE_PROPERTY_FLOAT4(_BlendingTextureB_ST)
+
+	DECLARE_PROPERTY_FLOAT4(_BlendingTextureWhite_ST)
+
+	DECLARE_PROPERTY_FLOAT4(_TexBlendingMask_ST)
+			
+	DECLARE_PROPERTY_FLOAT(_BlendingMaskCutoffG)
+	DECLARE_PROPERTY_FLOAT(_BlendingMaskSmoothnessG)
+
+	DECLARE_PROPERTY_FLOAT(_BlendingMaskCutoffB)
+	DECLARE_PROPERTY_FLOAT(_BlendingMaskSmoothnessB)
+
+	DECLARE_PROPERTY_FLOAT(_BlendingMaskCutoffWhite)
+	DECLARE_PROPERTY_FLOAT(_BlendingMaskSmoothnessWhite)
+#else
+	#if defined(_TEXTURE_BLENDING_ON)
+		#if defined(_TEXTUREBLENDINGMODE_RGB)
+			DECLARE_PROPERTY_FLOAT4(_BlendingTextureG_ST)
+			DECLARE_PROPERTY_FLOAT4(_BlendingTextureB_ST)
+		#else
+			DECLARE_PROPERTY_FLOAT4(_BlendingTextureWhite_ST)
+			DECLARE_PROPERTY_FLOAT(_BlendingMaskCutoffWhite)
+			DECLARE_PROPERTY_FLOAT(_BlendingMaskSmoothnessWhite)
+		#endif
+
+		DECLARE_PROPERTY_FLOAT(_BlendingMaskCutoffG)
+		DECLARE_PROPERTY_FLOAT(_BlendingMaskSmoothnessG)
+
+		DECLARE_PROPERTY_FLOAT(_BlendingMaskCutoffB)
+		DECLARE_PROPERTY_FLOAT(_BlendingMaskSmoothnessB)
+
+		#if defined(_TEXTUREBLENDINGSOURCE_TEXTURE)
+			DECLARE_PROPERTY_FLOAT4(_TexBlendingMask_ST)
+		#endif
+	#endif
+#endif
+//
+
+#if defined(_GREYSCALE_ON) || defined(ALWAYS_DECLARE_PROPERTY)
+	DECLARE_PROPERTY_FLOAT(_GreyscaleLuminosity)
+	DECLARE_PROPERTY_FLOAT4(_GreyscaleTintColor)
+	DECLARE_PROPERTY_FLOAT(_GreyscaleBlending)
+#endif
+
+#if defined(_POSTERIZE_ON) || defined(ALWAYS_DECLARE_PROPERTY)
+	DECLARE_PROPERTY_FLOAT(_PosterizeNumColors)
+	DECLARE_PROPERTY_FLOAT(_PosterizeGamma)
+#endif
+
+#if defined(_HAND_DRAWN_ON) || defined(ALWAYS_DECLARE_PROPERTY)
+	DECLARE_PROPERTY_FLOAT(_HandDrawnAmount)
+	DECLARE_PROPERTY_FLOAT(_HandDrawnSpeed)
+#endif
+
+#if defined(_MATCAP_ON) || defined(ALWAYS_DECLARE_PROPERTY)
+	DECLARE_PROPERTY_FLOAT(_MatcapIntensity)
+	DECLARE_PROPERTY_FLOAT(_MatcapBlend)
+#endif
+
+#if defined(_SCREEN_SPACE_UV_ON) || defined(ALWAYS_DECLARE_PROPERTY)
+	DECLARE_PROPERTY_FLOAT(_ScaleWithCameraDistance)
+#endif
+
+#if defined(_SCROLL_TEXTURE_ON) || defined(ALWAYS_DECLARE_PROPERTY)
+	DECLARE_PROPERTY_FLOAT(_ScrollTextureX)
+	DECLARE_PROPERTY_FLOAT(_ScrollTextureY)
+#endif
+
+#if defined(_UV_DISTORTION_ON) || defined(ALWAYS_DECLARE_PROPERTY)
+	DECLARE_PROPERTY_FLOAT4(_DistortTex_ST)
+
+	DECLARE_PROPERTY_FLOAT(_DistortAmount)
+	DECLARE_PROPERTY_FLOAT(_DistortTexXSpeed)
+	DECLARE_PROPERTY_FLOAT(_DistortTexYSpeed)
+#endif
+	
+#if defined(_PIXELATE_ON) || defined(ALWAYS_DECLARE_PROPERTY)
+	DECLARE_PROPERTY_FLOAT(_PixelateSize)
+	DECLARE_PROPERTY_FLOAT4(_MainTex_TexelSize)
+#endif
+
+#if defined(_EMISSION_ON) || defined(ALWAYS_DECLARE_PROPERTY)
+	DECLARE_PROPERTY_FLOAT(_EmissionSelfGlow)
+	DECLARE_PROPERTY_FLOAT4(_EmissionMap_ST)
+	DECLARE_PROPERTY_FLOAT4(_EmissionColor)
+#endif
+
+#if defined(_WAVE_UV_ON) || defined(ALWAYS_DECLARE_PROPERTY)
+	DECLARE_PROPERTY_FLOAT(_WaveAmount)
+	DECLARE_PROPERTY_FLOAT(_WaveSpeed)
+	DECLARE_PROPERTY_FLOAT(_WaveStrength)
+	DECLARE_PROPERTY_FLOAT(_WaveX)
+	DECLARE_PROPERTY_FLOAT(_WaveY)
+#endif
+
+#if defined(_HOLOGRAM_ON) || defined(ALWAYS_DECLARE_PROPERTY)
+
+	DECLARE_PROPERTY_FLOAT4(_HologramColor)
+	DECLARE_PROPERTY_FLOAT3(_HologramLineDirection)
+	DECLARE_PROPERTY_FLOAT(_HologramBaseAlpha)
+		
+	DECLARE_PROPERTY_FLOAT(_HologramScrollSpeed)
+	DECLARE_PROPERTY_FLOAT(_HologramFrequency)
+	DECLARE_PROPERTY_FLOAT(_HologramAlpha)
+
+	DECLARE_PROPERTY_FLOAT(_HologramAccentSpeed)
+	DECLARE_PROPERTY_FLOAT(_HologramAccentFrequency)
+	DECLARE_PROPERTY_FLOAT(_HologramAccentAlpha)
+
+	DECLARE_PROPERTY_FLOAT(_HologramLineCenter)
+	DECLARE_PROPERTY_FLOAT(_HologramLineSpacing)
+	DECLARE_PROPERTY_FLOAT(_HologramLineSmoothness)
+#endif
+
+#if defined(_TRIPLANAR_MAPPING_ON) || defined(ALWAYS_DECLARE_PROPERTY)
+	DECLARE_PROPERTY_FLOAT4(_TriplanarTopTex_ST)
+	DECLARE_PROPERTY_FLOAT4(_TriplanarTopNormalMap_ST)
+
+	DECLARE_PROPERTY_FLOAT(_FaceDownCutoff)
+	DECLARE_PROPERTY_FLOAT(_TriplanarSharpness)
+
+	DECLARE_PROPERTY_FLOAT4(_TriplanarNoiseTex_ST)
+	DECLARE_PROPERTY_FLOAT(_TriplanarTransitionPower)
+#endif
+
+#if defined(_SUBSURFACE_SCATTERING_ON) || defined(ALWAYS_DECLARE_PROPERTY)
+	DECLARE_PROPERTY_FLOAT(_NormalInfluence)
+	DECLARE_PROPERTY_FLOAT(_SSSPower)
+	DECLARE_PROPERTY_FLOAT(_SSSFrontPower)
+	DECLARE_PROPERTY_FLOAT(_SSSAtten)
+	DECLARE_PROPERTY_FLOAT(_SSSFrontAtten)
+	DECLARE_PROPERTY_FLOAT4(_SSSColor)
+#endif
+
+#if defined(_ALPHA_CUTOFF_ON) || defined(ALWAYS_DECLARE_PROPERTY)
+	DECLARE_PROPERTY_FLOAT(_AlphaCutoffValue)
+#endif
+
+#if defined(OUTLINE_ON) || defined(ALWAYS_DECLARE_PROPERTY)
+	DECLARE_PROPERTY_FLOAT4(_OutlineColor)
+	DECLARE_PROPERTY_FLOAT(_OutlineThickness)
+	DECLARE_PROPERTY_FLOAT(_MaxCameraDistance)
+	DECLARE_PROPERTY_FLOAT(_MaxFadeDistance)
+#endif
+
+#endif //ALLIN13DSHADER_BUFFERPROPERTIESDECLARATION

Assets/Plugins/AllIn13DShader/Shaders/ShaderLibrary/AllIn13DShader_BufferPropertiesDeclaration.hlsl.meta

@@ -0,0 +1,14 @@
+fileFormatVersion: 2
+guid: b5f70f4432d35e445a1292b96d6f55bd
+ShaderIncludeImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 316173
+  packageName: All In 1 3D-Shader
+  packageVersion: 2.72
+  assetPath: Assets/Plugins/AllIn13DShader/Shaders/ShaderLibrary/AllIn13DShader_BufferPropertiesDeclaration.hlsl
+  uploadId: 865720

Assets/Plugins/AllIn13DShader/Shaders/ShaderLibrary/AllIn13DShader_CommonFunctions.hlsl

@@ -0,0 +1,252 @@
+#ifndef ALLIN13DSHADER_COMMON_FUNCTIONS
+#define ALLIN13DSHADER_COMMON_FUNCTIONS
+
+#define ALLIN13DSHADER_PI            3.14159265359f
+#define ALLIN13DSHADER_TWO_PI        6.28318530718f
+#define ALLIN13DSHADER_FOUR_PI       12.56637061436f
+#define ALLIN13DSHADER_INV_PI        0.31830988618f
+#define ALLIN13DSHADER_INV_TWO_PI    0.15915494309f
+#define ALLIN13DSHADER_INV_FOUR_PI   0.07957747155f
+#define ALLIN13DSHADER_HALF_PI       1.57079632679f
+#define ALLIN13DSHADER_INV_HALF_PI   0.636619772367f
+
+#define CUSTOM_TRANSFORM_TEX(uv, increment, name) ((uv.xy + increment.xy) * ACCESS_PROP_FLOAT4(name##_ST).xy/*ACCESS_PROP_TILING_AND_OFFSET(name##_ST).xy*/ + ACCESS_PROP_FLOAT4(name##_ST).zw/*ACCESS_PROP_TILING_AND_OFFSET(name##_ST).zw*/)
+#define SIMPLE_CUSTOM_TRANSFORM_TEX(uv, name) uv.xy * ACCESS_PROP_FLOAT4(name##_ST).xy/*ACCESS_PROP_TILING_AND_OFFSET(name##_ST).xy*/ + /*ACCESS_PROP_FLOAT4(name##_ST).zw*/ACCESS_PROP_TILING_AND_OFFSET(name##_ST).zw
+
+#define DEFAULT_NORMAL_MAP_VALUE float4(1, 0.5, 0.5, 0.5)
+
+#ifdef _CUSTOM_SHADOW_COLOR_ON
+	#define SHADOW_COLOR global_shadowColor
+#else
+	#define SHADOW_COLOR 0
+#endif
+
+float Pow_5(float x)
+{
+	float x2 = x * x;
+	float res = x2 * x2 * x;
+	return res;
+}
+
+float EaseOutQuint(float x) 
+{
+	return 1 - Pow_5(1 - x);
+}
+
+float RemapFloat(float inValue, float inMin, float inMax, float outMin, float outMax)
+{
+	return outMin + (inValue - inMin) * (outMax - outMin) / (inMax - inMin);
+}
+
+float3 RemapFloat3(float3 inValue, float3 inMin, float3 inMax, float3 outMin, float3 outMax)
+{
+	float3 res = 
+		float3
+		(
+			RemapFloat(inValue.x, inMin.x, inMax.x, outMin.x, outMax.x),
+			RemapFloat(inValue.y, inMin.y, inMax.y, outMin.y, outMax.y),
+			RemapFloat(inValue.z, inMin.z, inMax.z, outMin.z, outMax.z)
+		);
+
+	return res;
+}
+
+float GetLuminanceRaw(float4 col)
+{
+	float res = 0.3 * col.r + 0.59 * col.g + 0.11 * col.b;
+	res *= col.a;
+	return res;
+}
+
+float GetLuminance(float4 col)
+{
+	return GetLuminanceRaw(col);
+}
+
+float GetLuminance(float3 col)
+{
+	return GetLuminance(float4(col, 1.0));
+}
+
+float noise(float2 p)
+{
+    return frac(sin(dot(p, float2(12.9898, 78.233))) * 43758.5453);
+}
+
+float noise2D(float2 p)
+{
+    float2 ip = floor(p);
+    float2 fp = frac(p);
+    fp = fp * fp * (3 - 2 * fp);
+                
+    float n00 = noise(ip);
+    float n01 = noise(ip + float2(0, 1));
+    float n10 = noise(ip + float2(1, 0));
+    float n11 = noise(ip + float2(1, 1));
+                
+    return lerp(lerp(n00, n01, fp.y), lerp(n10, n11, fp.y), fp.x);
+}
+
+//hash for randomness
+float2 hash2D2D(float2 s)
+{
+	//magic numbers
+	return frac(sin(fmod(float2(dot(s, float2(127.1, 311.7)), dot(s, float2(269.5, 183.3))), 3.14159)) * 43758.5453);
+}
+
+//float4x3 getStochasticOffsets(float2 uv, float scale = 3.464, float skewAmount = 0.57735027)
+float4x3 getStochasticOffsets(float2 uv, float scale, float skewAmount)
+{
+	//triangle vertices and blend weights
+	//BW_vx[0...2].xyz = triangle verts
+	//BW_vx[3].xy = blend weights (z is unused)
+	float4x3 BW_vx;
+    
+	//uv transformed into triangular grid space with UV scaled by approximation of 2*sqrt(3)
+	float2 skewUV = mul(float2x2(1.0, 0.0, -skewAmount, 1.15470054), uv * scale);
+    
+	//vertex IDs and barycentric coords
+	float2 vxID = float2(floor(skewUV));
+	float3 barry = float3(frac(skewUV), 0);
+	barry.z = 1.0 - barry.x - barry.y;
+    
+	BW_vx = ((barry.z > 0) ?
+		float4x3(float3(vxID, 0), float3(vxID + float2(0, 1), 0), float3(vxID + float2(1, 0), 0), barry.zyx) :
+		float4x3(float3(vxID + float2(1, 1), 0), float3(vxID + float2(1, 0), 0), float3(vxID + float2(0, 1), 0), float3(-barry.z, 1.0 - barry.y, 1.0 - barry.x)));
+
+	return BW_vx;
+}
+
+#ifdef _NORMAL_MAP_ON
+float3 GetNormalWSFromNormalMap(float3 tnormal, float normalStrength, 
+	float3 tspace0, float3 tspace1, float3 tspace2)
+{
+	tnormal.xy *= normalStrength; 
+
+	float3 res = 0;
+	res.x = dot(tspace0, tnormal);
+	res.y = dot(tspace1, tnormal);
+	res.z = dot(tspace2, tnormal);
+    
+	res = normalize(res);
+
+	return res;
+}
+
+//float3 GetNormalWSFromNormalMap(sampler2D normalMap, float2 uv, float normalStrength, 
+//	float3 tspace0, float3 tspace1, float3 tspace2)
+//{
+//	float3 tnormal = UnpackNormal(SAMPLE_TEX2D(normalMap, uv));
+	
+//	return GetNormalWSFromNormalMap(tnormal, normalStrength, tspace0, tspace1, tspace2);
+	
+//	//tnormal.xy *= normalStrength; 
+
+//	//float3 res = 0;
+//	//res.x = dot(tspace0, tnormal);
+//	//res.y = dot(tspace1, tnormal);
+//	//res.z = dot(tspace2, tnormal);
+    
+//	//res = normalize(res);
+
+//	//return res;
+//}
+#endif
+
+float3 BlendingUnpackedNormals(float3 unpackedNormal0, float3 unpackedNormal1)
+{
+	float2 unpackedBlendedNormalXY	= unpackedNormal0.xy + unpackedNormal1.xy;
+	float unpackedBlendedNormalZ	= unpackedNormal0.z * unpackedNormal1.z;
+
+	float3 res	= normalize(float3(unpackedBlendedNormalXY.x, unpackedBlendedNormalXY.y, unpackedBlendedNormalZ));
+	return res;
+}
+
+#ifdef REQUIRE_SCENE_DEPTH
+float ComputeEyeDepth(float3 vertexWS)
+{
+	float3 positionVS = mul(UNITY_MATRIX_V, float4(vertexWS, 1.0)).xyz;
+	float res = -positionVS.z;
+	
+	return res;
+}
+
+float GetNormalizedDepth(float4 projPos)
+{
+	float nearClip = _ProjectionParams.y + global_MinDepth;
+	float farClip = nearClip + global_DepthZoneLength;
+
+	float cameraRange = farClip - nearClip;
+		
+	float distanceToNearClip = projPos.z - global_MinDepth;
+		
+	float res = distanceToNearClip / cameraRange;
+	
+	res = saturate(res);
+	
+	return res;
+}
+
+float GetEyeDepth(float3 vertexVS)
+{
+	return -vertexVS.z;
+}
+
+#endif
+
+#ifdef _AOMAP_ON
+
+float3 GetAOMapTerm(float2 uv)
+{
+	float aoTex = SAMPLE_TEX2D(_AOMap, uv).r;
+	
+	//float ao = smoothstep(ACCESS_PROP_FLOAT(_AOContrast), 1 - ACCESS_PROP_FLOAT(_AOContrast), aoTex);
+	float3 ao = max(0, (aoTex - float3(0.5, 0.5, 0.5)) * ACCESS_PROP_FLOAT(_AOContrast) + float3(0.5, 0.5, 0.5));
+
+	ao = saturate(ao + 1 - ACCESS_PROP_FLOAT(_AOMapStrength));
+	float3 res = lerp(ACCESS_PROP_FLOAT4(_AOColor).rgb, 1, ao);
+	return res;
+}
+
+#endif
+
+#ifdef _DITHER_ON
+float4 Dither_float4(float4 input, float4 screenPos, float normalizedDistance)
+{
+	static const float DITHER_THRESHOLDS[16] =
+	{
+		0.0, 0.5, 0.125, 0.625,
+		0.75, 0.25, 0.875, 0.375,
+		0.1875, 0.6875, 0.0625, 0.5625,
+		0.9375, 0.4375, 0.8125, 0.3125
+	 };
+
+	float2 screenUV = screenPos.xy / screenPos.w;
+	screenUV = screenUV * 0.5 + 0.5;
+    
+	float2 pixelPos = screenUV * _ScreenParams.xy * ACCESS_PROP_FLOAT(_DitherScale);
+	uint index = (uint(pixelPos.x) & 3) * 4 + (uint(pixelPos.y) & 3);
+    
+	float dither = DITHER_THRESHOLDS[index] * normalizedDistance;
+    
+	float4 result = input;
+	result.a = saturate(result.a - dither);
+	return result;
+}
+#endif
+
+float AntiAliasing(float gradient, float cutOff)
+{
+	cutOff = max(0.01, cutOff);
+	float gradientCutOff = cutOff - gradient;
+
+	float2 ddxVector = float2(ddx(gradientCutOff), ddy(gradientCutOff));
+
+	float res = gradientCutOff / length(ddxVector);
+
+	res = saturate(0.5 - res);
+
+	return res;
+}
+
+#endif

Assets/Plugins/AllIn13DShader/Shaders/ShaderLibrary/AllIn13DShader_CommonFunctions.hlsl.meta

@@ -0,0 +1,14 @@
+fileFormatVersion: 2
+guid: 1d321d03d59fab041814ba51da72831d
+ShaderIncludeImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 316173
+  packageName: All In 1 3D-Shader
+  packageVersion: 2.72
+  assetPath: Assets/Plugins/AllIn13DShader/Shaders/ShaderLibrary/AllIn13DShader_CommonFunctions.hlsl
+  uploadId: 865720

Assets/Plugins/AllIn13DShader/Shaders/ShaderLibrary/AllIn13DShader_CommonStructs.hlsl

@@ -0,0 +1,380 @@
+#ifndef ALLIN13DSHADER_COMMON_STRUCTS
+#define ALLIN13DSHADER_COMMON_STRUCTS
+
+#define T_SPACE_PROPERTIES(n1, n2, n3) float3 tspace0 : TEXCOORD##n1; float3 tspace1 : TEXCOORD##n2; float3 tspace2 : TEXCOORD##n3;
+#define INIT_T_SPACE(normalWS) \
+	o.tspace0 = float3(tangentWS.x, bitangentWS.x, normalWS.x); \
+	o.tspace1 = float3(tangentWS.y, bitangentWS.y, normalWS.y); \
+	o.tspace2 = float3(tangentWS.z, bitangentWS.z, normalWS.z);
+
+
+#define INIT_DECAL_DATA(decalData) \
+	decalData.baseColor = float4(0, 0, 0, 1); \
+	decalData.normalTS = float4(0, 0, 0, 0); \
+	decalData.emissive = 0; \
+	decalData.mask = 0; \
+	decalData.unpackedNormal = float3(0, 0, 0); \
+	decalData.smoothness = 0; \
+	decalData.metallic = 0; \
+	decalData.MAOSAlpha = 1;
+	
+#define INIT_EFFECTS_DATA(data) \
+	data.mainUV = float2(0, 0); \
+	data.rawMainUV = float2(0, 0); \
+	data.normalizedScreenSpaceUV = float2(0, 0); \
+	data.vertexColor = float4(1, 1, 1, 1); \
+	data.vertexColorLuminosity = 1.0; \
+	data.vertexOS = float3(0, 0, 0); \
+	data.vertexWS = float3(0, 0, 0); \
+	data.vertexVS = float3(0, 0, 0); \
+	data.normalOS = float3(0, 1, 0); \
+	data.normalWS = float3(0, 1, 0); \
+	data.viewDirWS = float3(0, 0, -1); \
+	data.tangentWS = float3(1, 0, 0); \
+	data.bitangentWS = float3(0, 1, 0); \
+	data.projPos = float4(0, 0, 0, 0); \
+	data.pos = float4(0, 0, 0, 0); \
+	data.lightColor = float3(1, 1, 1); \
+	data.lightDir = float3(0, -1, 1); \
+	data.sceneDepthDiff = 1.0; \
+	data.normalizedDepth = 0; \
+	data.camDistance = 0; \
+	data.camDistanceViewSpace = 0; \
+	data.shaderTime = float3(0, 0, 0); \
+	data.uv_dist = float2(0, 0); \
+	data.uvMatrix = 0; \
+	data.uv_matrix_normalMap = 0; \
+	data.uv_normalMap = 0; \
+	data.uvDiff = 0; \
+	data._ShadowCoord = 0; \
+	data.metallic = 0; \
+	data.smoothness = 1;
+
+#define INIT_GI(gi) \
+	gi.diffuse = float3(0, 0, 0); \
+	gi.shadowMask = float4(0, 0, 0, 0); \
+	gi.uvLightmap = float2(0, 0);
+
+
+#define UV_FRONT(data) data.uvMatrix._m00_m01
+#define UV_FRONT_WEIGHT(data) data.uvMatrix._m02
+
+#define UV_SIDE(data) data.uvMatrix._m10_m11
+#define UV_SIDE_WEIGHT(data) data.uvMatrix._m12
+
+#define UV_TOP(data) data.uvMatrix._m20_m21
+#define UV_TOP_WEIGHT(data) data.uvMatrix._m22
+
+#define UV_DOWN(data) data.uvMatrix._m30_m31
+#define UV_DOWN_WEIGHT(data) data.uvMatrix._m32
+
+#define MAIN_UV(data) data.uvMatrix._m00_m01
+
+//Main UV
+#define SCALED_MAIN_UV(input)	input.mainUV.xy
+#define RAW_MAIN_UV(input)		input.mainUV.zw
+
+//Tangent WS
+#define TANGENT_WS(input) float3(input.tspace0.x, input.tspace1.x, input.tspace2.x)
+
+//Interpolator 01
+#define UV_LIGHTMAP(input) input.interpolator_01.xy
+#define UV_DIFF(input) input.interpolator_01.zw
+
+//Interpolator 02
+#define UV_NORMAL_MAP(input) input.interpolator_02.xy
+#define UV_EMISSION_MAP(input) input.interpolator_02.zw
+
+//Interpolator 03
+#define SHADER_TIME(input) input.interpolator_03.xyz
+#define FOGCOORD(input) input.interpolator_03.w
+
+//Interpolator 04
+#define NORMAL_OS(input) input.interpolator_04.xyz
+#define VERTEX_COLOR_R(input) input.interpolator_04.w
+
+//Interpolator 05
+#define POSITION_OS(input) input.interpolator_05.xyz
+#define VERTEX_COLOR_G(input) input.interpolator_05.w
+
+//Interpolator 06
+#define POSITION_WS(input) input.interpolator_06.xyz
+#define VERTEX_COLOR_B(input) input.interpolator_06.w
+
+//Interpolator 07
+#define VIEWDIR_WS(input) input.interpolator_07.xyz
+#define VERTEX_COLOR_A(input) input.interpolator_07.w
+
+
+#ifdef _NORMAL_MAP_ON
+	#define NORMAL_UV_FRONT(data) data.uv_matrix_normalMap._m00_m01
+	#define NORMAL_UV_SIDE(data) data.uv_matrix_normalMap._m10_m11
+	#define NORMAL_UV_TOP(data) data.uv_matrix_normalMap._m20_m21
+
+	#define MAIN_NORMAL_UV(data) data.uv_matrix_normalMap._m00_m01
+#endif
+
+
+#ifdef _NORMAL_MAP_ON
+	#ifdef _TRIPLANAR_MAPPING_ON
+		#define DISPLACE_ALL_UVS(data, displacementAmount) \
+			UV_FRONT(data) += displacementAmount; \
+			UV_SIDE(data) += displacementAmount; \
+			UV_TOP(data) += displacementAmount; \
+			UV_DOWN(data) += displacementAmount; \
+			NORMAL_UV_FRONT(data) += displacementAmount; \
+			NORMAL_UV_SIDE(data) += displacementAmount; \
+			NORMAL_UV_TOP(data) += displacementAmount; \
+			data.rawMainUV += displacementAmount;
+			
+		#define QUANTIZE_ALL_UVS(data, quantizeFactor) \
+			UV_FRONT(data)	= floor(UV_FRONT(data)	* quantizeFactor) / quantizeFactor; \
+			UV_SIDE(data)	= floor(UV_SIDE(data)	* quantizeFactor) / quantizeFactor; \
+			UV_TOP(data)	= floor(UV_TOP(data)	* quantizeFactor) / quantizeFactor; \
+			UV_DOWN(data)	= floor(UV_DOWN(data)	* quantizeFactor) / quantizeFactor; \
+			NORMAL_UV_FRONT(data)	= floor(NORMAL_UV_FRONT(data)	* quantizeFactor) / quantizeFactor; \
+			NORMAL_UV_SIDE(data)	= floor(NORMAL_UV_SIDE(data)	* quantizeFactor) / quantizeFactor; \
+			NORMAL_UV_TOP(data)		= floor(NORMAL_UV_TOP(data)		* quantizeFactor) / quantizeFactor; \
+			data.rawMainUV = floor(data.rawMainUV * quantizeFactor) / quantizeFactor;
+		
+		#define FLOOR_ALL_UVS(data) \
+			UV_FRONT(data)	= floor(UV_FRONT(data)); \
+			UV_SIDE(data)	= floor(UV_SIDE(data)); \
+			UV_TOP(data)	= floor(UV_TOP(data)); \
+			UV_DOWN(data)	= floor(UV_DOWN(data)); \
+			NORMAL_UV_FRONT(data)	= floor(NORMAL_UV_FRONT(data)); \
+			NORMAL_UV_SIDE(data)	= floor(NORMAL_UV_SIDE(data)); \
+			NORMAL_UV_TOP(data)		= floor(NORMAL_UV_TOP(data)); \
+			data.rawMainUV = floor(data.rawMainUV);
+	#else
+		#define QUANTIZE_ALL_UVS(data, quantizeFactor) \
+			MAIN_UV(data) = floor(MAIN_UV(data) * quantizeFactor) / quantizeFactor; \
+			MAIN_NORMAL_UV(data) = floor(MAIN_NORMAL_UV(data) * quantizeFactor) / quantizeFactor; \
+			data.rawMainUV = floor(data.rawMainUV * quantizeFactor) / quantizeFactor;
+			
+		#define DISPLACE_ALL_UVS(data, displacementAmount) \
+			MAIN_UV(data) += displacementAmount; \
+			MAIN_NORMAL_UV(data) += displacementAmount; \
+			data.rawMainUV += displacementAmount;
+	#endif
+#else
+	#ifdef _TRIPLANAR_MAPPING_ON
+		#define DISPLACE_ALL_UVS(data, displacementAmount) \
+			data.uvMatrix._m00_m01 += displacementAmount; \
+			data.uvMatrix._m10_m11 += displacementAmount; \
+			data.uvMatrix._m20_m21 += displacementAmount; \
+			data.uvMatrix._m30_m31 += displacementAmount; \
+			data.rawMainUV += displacementAmount;
+			
+		#define QUANTIZE_ALL_UVS(data, quantizeFactor) \
+			data.uvMatrix._m00_m01 = floor(data.uvMatrix._m00_m01 * quantizeFactor) / quantizeFactor; \
+			data.uvMatrix._m10_m11 = floor(data.uvMatrix._m10_m11 * quantizeFactor) / quantizeFactor; \
+			data.uvMatrix._m20_m21 = floor(data.uvMatrix._m20_m21 * quantizeFactor) / quantizeFactor; \
+			data.uvMatrix._m30_m31 = floor(data.uvMatrix._m30_m31 * quantizeFactor) / quantizeFactor; \
+			data.rawMainUV = floor(data.rawMainUV * quantizeFactor) / quantizeFactor;
+	#else
+		#define DISPLACE_ALL_UVS(data, displacementAmount) \
+			MAIN_UV(data)	+= displacementAmount; \
+			data.rawMainUV	+= displacementAmount;
+			
+		#define QUANTIZE_ALL_UVS(data, quantizeFactor) \
+			MAIN_UV(data) = floor(MAIN_UV(data) * quantizeFactor) / quantizeFactor; \
+			data.rawMainUV = floor(data.rawMainUV * quantizeFactor) / quantizeFactor;
+	#endif
+#endif
+
+#define RECALCULATE_NORMAL_OFFSET 0.01
+
+struct AllIn1LightData
+{
+	float3 lightColor;
+	float3 lightDir;
+	float realtimeShadow;
+	float4 shadowColor;
+	float distanceAttenuation;
+	uint layerMask;
+};
+
+struct AllIn1DecalData
+{
+	float4 baseColor;
+	float4 normalTS;
+	float3 emissive;
+	float mask;
+	float3 unpackedNormal;
+	float smoothness;
+	float metallic;
+	float MAOSAlpha;
+};
+
+struct ShadowCoordStruct
+{
+	float4 _ShadowCoord : TEXCOORD0;
+	float4 pos : TEXCOORD1;
+};
+
+struct FogStruct
+{
+	float fogCoord : TEXCOORD0;
+};
+
+struct VertexData
+{
+	float4 vertex		: POSITION; 
+	float2 uv			: TEXCOORD0;
+	float2 uvLightmap	: TEXCOORD1;
+	float3 normal		: NORMAL;
+	float4 tangent		: TANGENT;
+	float4 vertexColor	: COLOR;
+
+	UNITY_VERTEX_INPUT_INSTANCE_ID
+};
+
+struct FragmentDataOutline
+{
+	float4 pos	: SV_POSITION;
+	float2 mainUV	: TEXCOORD0;
+	float3 normalWS : TEXCOORD1;
+	
+	float4 interpolator_01 : TEXCOORD2;
+	float4 interpolator_02 : TEXCOORD3;
+	float4 interpolator_03 : TEXCOORD4;
+
+	float3 positionWS : TEXCOORD5;
+
+	UNITY_VERTEX_INPUT_INSTANCE_ID
+	UNITY_VERTEX_OUTPUT_STEREO
+};
+
+struct FragmentData
+{
+	float4 pos	: SV_POSITION;
+	float4 mainUV	: TEXCOORD0;
+	
+	float3 normalWS : TEXCOORD1;
+
+	float4 interpolator_01 : TEXCOORD2;
+	float4 interpolator_02 : TEXCOORD3;
+	float4 interpolator_03 : TEXCOORD4;
+	float4 interpolator_04 : TEXCOORD5;
+	float4 interpolator_05 : TEXCOORD6;
+	float4 interpolator_06 : TEXCOORD7;
+	float4 interpolator_07 : TEXCOORD8;
+
+#ifdef REQUIRE_TANGENT_WS
+	T_SPACE_PROPERTIES(9, 10, 11)
+#endif
+
+#if defined(REQUIRE_SCENE_DEPTH) || defined(LOD_FADE_CROSSFADE)
+	float4 projPos : TEXCOORD12;
+#endif
+	
+	float4 _ShadowCoord : TEXCOORD13;
+
+	UNITY_VERTEX_INPUT_INSTANCE_ID
+	UNITY_VERTEX_OUTPUT_STEREO
+};
+
+struct FragmentDataShadowCaster
+{
+	float4 pos	: SV_POSITION;
+	float4 positionOS : TEXCOORD1;
+	float2 mainUV : TEXCOORD2;
+	float3 positionWS : TEXCOORD3;
+	float2 uv2 : TEXCOORD4;
+	float3 shaderTime : TEXCOORD5;
+	float3 normalOS : TEXCOORD6;
+	float3 normalWS : TEXCOORD7;
+	
+	UNITY_VERTEX_INPUT_INSTANCE_ID	
+	UNITY_VERTEX_OUTPUT_STEREO 
+};
+
+struct TriplanarData
+{
+	float2 uv_triplanar_front;
+	float2 uv_triplanar_side;
+	float2 uv_triplanar_top;
+};
+
+struct AllIn1GI
+{
+	float3 diffuse;
+	float4 shadowMask;
+	float2 uvLightmap;
+};
+
+//<AllIn1Struct name=EffectsData>
+struct EffectsData
+{
+	float2 mainUV;
+	float2 rawMainUV;
+
+	float2 normalizedScreenSpaceUV;
+
+	float4 vertexColor;
+	float vertexColorLuminosity;
+
+	float3 vertexOS;
+	float3 vertexWS;
+	float3 vertexVS;
+	float3 normalOS;
+	float3 normalWS;
+	float3 viewDirWS;
+
+	float3 tangentWS;
+	float3 bitangentWS;
+
+	float4 projPos;
+	float4 pos; //Patch to fix the error when UNITY_LIGHT_ATTENUATION is expanded
+	
+	float3 lightColor;
+	float3 lightDir;
+	
+	float sceneDepthDiff;
+	float normalizedDepth;
+	float camDistance;
+	float camDistanceViewSpace;
+	float3 shaderTime;
+
+	float2 uv_dist;
+	
+	float4x3 uvMatrix;
+	float4x3 uv_matrix_normalMap;
+	float2 uv_normalMap;
+
+	float2 uvDiff;
+
+	float4 _ShadowCoord;
+
+	float metallic;
+	float smoothness;
+};
+//</AllIn1Struct>
+
+#ifdef _TRIPLANAR_MAPPING_ON
+float3 GetTriplanarWeights(float3 normal, float2 uv)
+{
+	float3 weights = abs(normal);
+
+	float transition = 0.0;
+#ifdef _TRIPLANAR_NOISE_TRANSITION_ON
+	float2 scaleUV = ACCESS_PROP_FLOAT4(_TriplanarNoiseTex_ST).xy;
+	transition = SAMPLE_TEX2D(_TriplanarNoiseTex, uv * scaleUV).r;
+	transition = (transition - 0.5) * 2.0;
+	transition *= ACCESS_PROP_FLOAT(_TriplanarTransitionPower);
+	
+	normal.xz = lerp(float2(-0.5, -0.5), float2(0.5, 0.5), transition);
+	
+	normal = normalize(normal);
+	weights = abs(normal);
+#endif
+	
+	weights = pow(weights, ACCESS_PROP_FLOAT(_TriplanarSharpness));
+	weights = weights / (weights.x + weights.y + weights.z);
+	
+	return weights;
+}
+#endif
+
+#endif

Assets/Plugins/AllIn13DShader/Shaders/ShaderLibrary/AllIn13DShader_CommonStructs.hlsl.meta

@@ -0,0 +1,14 @@
+fileFormatVersion: 2
+guid: accf6894604f8af4f8d2f5226925f2cb
+ShaderIncludeImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 316173
+  packageName: All In 1 3D-Shader
+  packageVersion: 2.72
+  assetPath: Assets/Plugins/AllIn13DShader/Shaders/ShaderLibrary/AllIn13DShader_CommonStructs.hlsl
+  uploadId: 865720

Assets/Plugins/AllIn13DShader/Shaders/ShaderLibrary/AllIn13DShader_Features.hlsl

@@ -0,0 +1,226 @@
+#ifndef ALLIN13DSHADER_FEATURES
+#define ALLIN13DSHADER_FEATURES
+
+#if defined(INSTANCING_ON) && !defined(PROCEDURAL_INSTANCING_ON)
+	#define ALLIN13D_GPU_INSTANCING
+#endif
+
+#if defined(UNITY_DOTS_INSTANCING_ENABLED) || defined(URP_PASS)
+	#define ALWAYS_DECLARE_PROPERTY
+#endif
+
+#if defined(ALLIN13D_GPU_INSTANCING)
+	#define BATCHING_BUFFER_START	UNITY_INSTANCING_BUFFER_START(UnityPerMaterial)
+	#define BATCHING_BUFFER_END		UNITY_INSTANCING_BUFFER_END(UnityPerMaterial)
+
+#else
+	#if defined(URP_PASS) && !defined(PROCEDURAL_INSTANCING_ON)
+		#define BATCHING_BUFFER_START	CBUFFER_START(UnityPerMaterial)
+		#define BATCHING_BUFFER_END		CBUFFER_END
+	#else
+		#define BATCHING_BUFFER_START
+		#define BATCHING_BUFFER_END	
+	#endif
+#endif
+
+//GetMeshRenderingLightLayer
+#if defined(URP_PASS) && defined(ALLIN1_LIGHT_LAYERS_SUPPORT)
+	#define ALLIN1_USE_LIGHT_LAYERS
+#endif
+
+#ifdef URP_PASS
+	#define DECLARE_TEX2D(texName) \
+		TEXTURE2D(texName); \
+		SAMPLER(sampler_##texName);
+
+	#define SAMPLE_TEX2D(texName, uv)		SAMPLE_TEXTURE2D(texName, sampler_##texName, uv)
+	#define SAMPLE_TEX2D_DERIVATIVES(texName, uv, ddx, ddy) SAMPLE_TEXTURE2D_GRAD(texName, sampler_##texName, uv, ddx, ddy)
+	#define SAMPLE_TEX2D_LOD(texName, uv)	SAMPLE_TEXTURE2D_LOD(texName, sampler_##texName, uv.xy, 0)
+	#define SAMPLE_TEX2D_PROJ(texName, uv)	SAMPLE_TEXTURE2D(texName, sampler##texName, uv.xy/uv.w)
+#else
+	#define DECLARE_TEX2D(texName)	sampler2D texName;
+
+	#define SAMPLE_TEX2D(texName, uv)						tex2D(texName, uv)
+	#define SAMPLE_TEX2D_DERIVATIVES(texName, uv, ddx, ddy) tex2D(texName, uv, ddx, ddy)
+	#define SAMPLE_TEX2D_LOD(texName, uv)					tex2Dlod(texName, uv)
+	#define SAMPLE_TEX2D_PROJ(texName, uv)					tex2Dproj(texName, uv)
+#endif
+
+#define STOCHASTIC_SAMPLING_NO_DEF_DD(texName, uv, stochasticOffset, res) \
+	dx = ddx(uv);\
+	dy = ddy(uv);\
+	res = mul(SAMPLE_TEX2D_DERIVATIVES(texName, uv + hash2D2D(stochasticOffset[0].xy), dx, dy), stochasticOffset[3].x) + \
+		mul(SAMPLE_TEX2D_DERIVATIVES(texName, uv + hash2D2D(stochasticOffset[1].xy), dx, dy), stochasticOffset[3].y) + \
+		mul(SAMPLE_TEX2D_DERIVATIVES(texName, uv + hash2D2D(stochasticOffset[2].xy), dx, dy), stochasticOffset[3].z);
+	
+#define STOCHASTIC_SAMPLING(texName, uv, stochasticOffset, res) \
+	float2 dx = 0;\
+	float2 dy = 0;\
+	STOCHASTIC_SAMPLING_NO_DEF_DD(texName, uv, stochasticOffset, res)
+			
+#define STOCHASTIC_SAMPLING_COMPLETE_NO_DEF_DD(texName, uv, stochasticOffsetName, res) \
+	stochasticOffset = getStochasticOffsets(uv, ACCESS_PROP_FLOAT(_StochasticScale), ACCESS_PROP_FLOAT(_StochasticSkew));\
+	STOCHASTIC_SAMPLING_NO_DEF_DD(texName, uv, stochasticOffsetName, res)
+	
+#define STOCHASTIC_SAMPLING_COMPLETE(texName, uv, stochasticOffset, res) \
+	stochasticOffset = getStochasticOffsets(uv, ACCESS_PROP_FLOAT(_StochasticScale), ACCESS_PROP_FLOAT(_StochasticSkew));\
+	STOCHASTIC_SAMPLING(texName, uv, stochasticOffsetName, res)
+
+
+#if defined(PROCEDURAL_INSTANCING_ON)
+	#define DECLARE_PROPERTY_FLOAT(name)	float name;
+	#define DECLARE_PROPERTY_FLOAT2(name)	float2 name;
+	#define DECLARE_PROPERTY_FLOAT3(name)	float3 name;
+	#define DECLARE_PROPERTY_FLOAT4(name)	float4 name;
+#else
+	#if (defined(INSTANCING_ON) || defined(PROCEDURAL_INSTANCING_ON)) && !defined(URP_PASS)
+		#define DECLARE_PROPERTY_FLOAT(name)	UNITY_DEFINE_INSTANCED_PROP(float, name)
+		#define DECLARE_PROPERTY_FLOAT2(name)	UNITY_DEFINE_INSTANCED_PROP(float2, name)
+		#define DECLARE_PROPERTY_FLOAT3(name)	UNITY_DEFINE_INSTANCED_PROP(float3, name)
+		#define DECLARE_PROPERTY_FLOAT4(name)	UNITY_DEFINE_INSTANCED_PROP(float4, name)
+	#else
+		#define DECLARE_PROPERTY_FLOAT(name)	float name;
+		#define DECLARE_PROPERTY_FLOAT2(name)	float2 name;
+		#define DECLARE_PROPERTY_FLOAT3(name)	float3 name;
+		#define DECLARE_PROPERTY_FLOAT4(name)	float4 name;
+	#endif
+#endif
+
+
+//------ Shader features --------
+#pragma shader_feature_local_fragment _ALLIN13D_SURFACE_TRANSPARENT
+#if !defined(ALLIN1_SHADER_VARIANT)
+	#include_with_pragmas "../ShaderLibrary/AllIn13DShader_ShaderFeatures.hlsl"
+#endif
+//------------------------------
+
+#if defined(_SPECULARMODEL_CLASSIC) || defined(_SPECULARMODEL_TOON) || defined(_SPECULARMODEL_ANISOTROPIC) || defined(_SPECULARMODEL_ANISOTROPICTOON)
+	#define SPECULAR_ON
+#else
+	#if !defined(_SPECULARMODEL_NONE)
+		#define _SPECULARMODEL_NONE
+	#endif
+#endif
+
+#if defined(_LIGHTMODEL_CLASSIC) || defined(_LIGHTMODEL_TOON) || defined(_LIGHTMODEL_TOONRAMP) || defined(_LIGHTMODEL_HALFLAMBERT) || defined(_LIGHTMODEL_FAKEGI) || defined(_LIGHTMODEL_FASTLIGHTING)
+	#define LIGHT_ON
+#else
+	#if !defined(_LIGHTMODEL_NONE)
+		#define _LIGHTMODEL_NONE
+	#endif
+#endif
+
+#if (!defined(FORWARD_ADD_PASS) && defined(BIRP_PASS)) || defined(URP_PASS)
+	#define ADDITIONAL_LIGHT_LOOP
+#endif
+
+#if defined(URP_PASS)
+	#if defined(ALLIN1_FOG_SUPPORT) && defined(_FOG_ON)
+		#define FOG_ENABLED
+	#endif
+#elif defined(BIRP_PASS)
+	#if defined(_FOG_ON)
+		#define FOG_ENABLED
+	#endif
+#endif
+
+//#pragma shader_feature_local _REFLECTIONS_NONE _REFLECTIONS_CLASSIC _REFLECTIONS_TOON
+
+#if defined(_REFLECTIONS_CLASSIC) || defined(_REFLECTIONS_TOON)
+	#define REFLECTIONS_ON
+#else
+	#if !defined(_REFLECTIONS_NONE)
+		#define _REFLECTIONS_NONE
+	#endif
+#endif
+
+#if !defined(_OUTLINETYPE_NONE)
+	#define OUTLINE_ON
+#endif
+
+#if defined(_INTERSECTION_GLOW_ON) || defined(_SCREEN_SPACE_UV_ON) || defined(_INTERSECTION_FADE_ON) || defined(_DEPTH_COLORING_ON) || defined(_DITHER_ON)
+	#define REQUIRE_SCENE_DEPTH
+#endif
+
+#if defined(REQUIRE_SCENE_DEPTH) || defined(LOD_FADE_CROSSFADE)
+	#define REQUIRE_SCREEN_POS
+#endif
+
+#if defined(_SCREEN_SPACE_UV_ON) || defined(REQUIRE_SCENE_DEPTH) || defined(_FADE_BY_CAM_DISTANCE_ON)
+	#define REQUIRE_CAM_DISTANCE
+#endif
+
+#if defined(_SPECULARMODEL_ANISOTROPIC) || defined(_SPECULARMODEL_ANISOTROPICTOON) || defined(_NORMAL_MAP_ON)
+	#define REQUIRE_TANGENT_WS
+#endif
+
+#if defined(URP_PASS)
+	#if defined(LIGHTMAP_ON) && defined(LIGHTMAP_SHADOW_MIXING)
+		#define SUBTRACTIVE_LIGHTING
+	#endif
+#else
+	#if defined(LIGHTMAP_ON) && defined(SHADOWS_SCREEN) && defined(LIGHTMAP_SHADOW_MIXING) && !defined(SHADOWS_SHADOWMASK)
+		#define SUBTRACTIVE_LIGHTING
+	#endif
+#endif
+
+//Dependencies
+#if !defined(LIGHT_ON)
+	#undef REFLECTIONS_ON
+	#undef _NORMAL_MAP_ON
+	#undef SPECULAR_ON
+#endif
+
+#include "../ShaderLibrary/AllIn13DShader_GlobalPropertiesAndTexturesDeclaration.hlsl"
+
+
+//-------- Properties Buffer -----------
+
+BATCHING_BUFFER_START
+	#include "../ShaderLibrary/AllIn13DShader_BufferPropertiesDeclaration.hlsl"
+BATCHING_BUFFER_END
+
+
+#ifdef UNITY_DOTS_INSTANCING_ENABLED
+	#undef DECLARE_PROPERTY_FLOAT	
+	#undef DECLARE_PROPERTY_FLOAT2
+	#undef DECLARE_PROPERTY_FLOAT3
+	#undef DECLARE_PROPERTY_FLOAT4
+	#undef ALLIN13DSHADER_BUFFERPROPERTIESDECLARATION
+
+	#define DECLARE_PROPERTY_FLOAT(name)	UNITY_DOTS_INSTANCED_PROP_OVERRIDE_SUPPORTED(float, name)
+	#define DECLARE_PROPERTY_FLOAT2(name)	UNITY_DOTS_INSTANCED_PROP_OVERRIDE_SUPPORTED(float2, name)
+	#define DECLARE_PROPERTY_FLOAT3(name)	UNITY_DOTS_INSTANCED_PROP_OVERRIDE_SUPPORTED(float3, name)
+	#define DECLARE_PROPERTY_FLOAT4(name)	UNITY_DOTS_INSTANCED_PROP_OVERRIDE_SUPPORTED(float4, name) 
+
+	UNITY_DOTS_INSTANCING_START(MaterialPropertyMetadata) 
+	#include "../ShaderLibrary/AllIn13DShader_BufferPropertiesDeclaration.hlsl"
+	UNITY_DOTS_INSTANCING_END(MaterialPropertyMetadata)
+#endif
+
+//----------------------------------
+
+#if defined(UNITY_DOTS_INSTANCING_ENABLED)
+	#define ACCESS_PROP_FLOAT(name)				UNITY_ACCESS_DOTS_INSTANCED_PROP_WITH_DEFAULT(float, name)
+	#define ACCESS_PROP_FLOAT2(name)			UNITY_ACCESS_DOTS_INSTANCED_PROP_WITH_DEFAULT(float2, name)
+	#define ACCESS_PROP_FLOAT3(name)			UNITY_ACCESS_DOTS_INSTANCED_PROP_WITH_DEFAULT(float3, name)
+	#define ACCESS_PROP_FLOAT4(name)			UNITY_ACCESS_DOTS_INSTANCED_PROP_WITH_DEFAULT(float4, name)
+	#define ACCESS_PROP_TILING_AND_OFFSET(name) UNITY_ACCESS_DOTS_INSTANCED_PROP_WITH_CUSTOM_DEFAULT(float4, name, float4(1, 1, 0, 0))
+
+#elif defined(ALLIN13D_GPU_INSTANCING)
+	#define ACCESS_PROP_FLOAT(name)		UNITY_ACCESS_INSTANCED_PROP(UnityPerMaterial, name)
+	#define ACCESS_PROP_FLOAT2(name)	UNITY_ACCESS_INSTANCED_PROP(UnityPerMaterial, name)
+	#define ACCESS_PROP_FLOAT3(name)	UNITY_ACCESS_INSTANCED_PROP(UnityPerMaterial, name)
+	#define ACCESS_PROP_FLOAT4(name)	UNITY_ACCESS_INSTANCED_PROP(UnityPerMaterial, name)
+	#define ACCESS_PROP_TILING_AND_OFFSET(name) UNITY_ACCESS_INSTANCED_PROP(UnityPerMaterial, name)
+
+#else
+	#define ACCESS_PROP_FLOAT(name)			name
+	#define ACCESS_PROP_FLOAT2(name)		name
+	#define ACCESS_PROP_FLOAT3(name)		name
+	#define ACCESS_PROP_FLOAT4(name)		name
+	#define ACCESS_PROP_TILING_AND_OFFSET(name)	name
+
+#endif
+
+#endif

Assets/Plugins/AllIn13DShader/Shaders/ShaderLibrary/AllIn13DShader_Features.hlsl.meta

@@ -0,0 +1,14 @@
+fileFormatVersion: 2
+guid: 27dc0b905bafffe47966f6ec1e846e00
+ShaderIncludeImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 316173
+  packageName: All In 1 3D-Shader
+  packageVersion: 2.72
+  assetPath: Assets/Plugins/AllIn13DShader/Shaders/ShaderLibrary/AllIn13DShader_Features.hlsl
+  uploadId: 865720

Assets/Plugins/AllIn13DShader/Shaders/ShaderLibrary/AllIn13DShader_FeaturesURP.hlsl

@@ -0,0 +1,145 @@
+#ifndef ALLIN13DSHADER_FEATURESURP
+#define ALLIN13DSHADER_FEATURESURP
+
+#ifdef ALLIN1_DOTS_INSTANCING_SUPPORT
+	#pragma target 4.5
+#else
+	#pragma target 3.0
+#endif
+
+
+#if defined(ALLIN1_FORWARD_PASS)
+	#ifdef ALLIN1_GPU_INSTANCING_SUPPORT
+		#pragma multi_compile_instancing
+	#endif
+
+	#ifdef ALLIN1_DOTS_INSTANCING_SUPPORT 
+		#pragma multi_compile _ DOTS_INSTANCING_ON
+	#endif
+
+	#ifdef ALLIN1_FOG_SUPPORT
+		#if UNITY_VERSION >= 60020000
+			#include_with_pragmas "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Fog.hlsl"
+		#else
+			#pragma multi_compile_fog
+		#endif
+	#endif
+
+	#ifdef ALLIN1_CAST_SHADOWS_SUPPORT
+		#pragma multi_compile _ _MAIN_LIGHT_SHADOWS _MAIN_LIGHT_SHADOWS_CASCADE _MAIN_LIGHT_SHADOWS_SCREEN
+		#pragma multi_compile _ _SHADOWS_SOFT
+	#endif
+
+	#ifdef ALLIN1_SSO_SUPPORT
+		#pragma multi_compile_fragment _ _SCREEN_SPACE_OCCLUSION
+	#endif
+
+	#ifdef ALLIN1_ADDITIONAL_LIGHTS_SUPPORT
+		#pragma multi_compile _ _ADDITIONAL_LIGHTS_VERTEX _ADDITIONAL_LIGHTS
+		#pragma multi_compile_fragment _ _ADDITIONAL_LIGHT_SHADOWS
+	#endif
+
+	#ifdef ALLIN1_REFLECTIONS_PROBES_SUPPORT_UNITY6
+		#pragma multi_compile_fragment _ _REFLECTION_PROBE_BLENDING
+		#pragma multi_compile_fragment _ _REFLECTION_PROBE_BOX_PROJECTION
+		#pragma multi_compile_fragment _ _REFLECTION_PROBE_ATLAS
+	#endif
+
+	#ifdef ALLIN1_ADAPTATIVE_PROBE_VOLUMES_UNITY6
+		#if UNITY_VERSION >= 60000000
+			#include_with_pragmas "Packages/com.unity.render-pipelines.universal/ShaderLibrary/ProbeVolumeVariants.hlsl"
+		#endif
+	#endif
+
+	#ifdef ALLIN1_LIGHT_LAYERS_SUPPORT
+		#pragma multi_compile _ _LIGHT_LAYERS
+	#endif
+
+	#ifdef ALLIN1_SHADOW_MASK_SUPPORT
+		#pragma multi_compile _ SHADOWS_SHADOWMASK // v10+ only
+	#endif
+
+	#ifdef ALLIN1_FORWARD_PLUS_SUPPORT_UNITY6
+		#if UNITY_VERSION >= 60020000
+			#define ALLIN1_USE_FORWARD_PLUS						USE_CLUSTER_LIGHT_LOOP
+			#define ALLIN1_FORWARD_PLUS_SUBTRACTIVE_LIGHT_CHECK	CLUSTER_LIGHT_LOOP_SUBTRACTIVE_LIGHT_CHECK
+			
+			#pragma multi_compile _ _CLUSTER_LIGHT_LOOP
+		#else
+			#define ALLIN1_USE_FORWARD_PLUS						USE_FORWARD_PLUS
+			#define ALLIN1_FORWARD_PLUS_SUBTRACTIVE_LIGHT_CHECK	FORWARD_PLUS_SUBTRACTIVE_LIGHT_CHECK
+
+			#pragma multi_compile _ _FORWARD_PLUS
+		#endif
+	#endif
+
+	#ifdef ALLIN1_LIGHTMAPS_SUPPORT
+		#pragma multi_compile _ LIGHTMAP_SHADOW_MIXING // v10+ only, renamed from "_MIXED_LIGHTING_SUBTRACTIVE"
+		#pragma multi_compile _ LIGHTMAP_ON
+		#pragma multi_compile _ DIRLIGHTMAP_COMBINED
+	#endif
+
+	#ifdef ALLIN1_LIGHT_COOKIES_SUPPORT
+		#pragma multi_compile_fragment _ _LIGHT_COOKIES
+	#endif
+
+	#ifdef ALLIN1_DECALS_SUPPORT
+		#pragma multi_compile_fragment _ _DBUFFER_MRT1 _DBUFFER_MRT2 _DBUFFER_MRT3
+	#endif
+	
+	#ifdef ALLIN1_LODCROSSFADE_SUPPORT
+		#pragma multi_compile _ LOD_FADE_CROSSFADE
+	#endif
+
+#elif defined(SHADOW_CASTER_PASS)
+	#pragma multi_compile_fwdadd_fullshadows
+	
+	#ifdef ALLIN1_GPU_INSTANCING_SUPPORT
+		#pragma multi_compile_instancing
+	#endif
+
+	#ifdef ALLIN1_DOTS_INSTANCING_SUPPORT
+		#pragma multi_compile _ DOTS_INSTANCING_ON
+	#endif
+
+	#pragma multi_compile_vertex _ _CASTING_PUNCTUAL_LIGHT_SHADOW
+
+#elif defined(ALLIN1_DEPTH_ONLY_PASS)
+	#ifdef ALLIN1_GPU_INSTANCING_SUPPORT
+		#pragma multi_compile_instancing
+	#endif
+
+	#ifdef ALLIN1_DOTS_INSTANCING_SUPPORT
+		#pragma multi_compile _ DOTS_INSTANCING_ON
+	#endif
+
+#elif defined(ALLIN1_DEPTH_NORMALS_PASS)
+	#ifdef ALLIN1_GPU_INSTANCING_SUPPORT
+		#pragma multi_compile_instancing
+	#endif
+
+	#ifdef ALLIN1_DOTS_INSTANCING_SUPPORT
+		#pragma multi_compile _ DOTS_INSTANCING_ON
+	#endif
+
+#elif defined(ALLIN1_OUTLINE_PASS)
+	#ifdef ALLIN1_GPU_INSTANCING_SUPPORT
+		#pragma multi_compile_instancing
+	#endif
+
+	#ifdef ALLIN1_DOTS_INSTANCING_SUPPORT
+		#pragma multi_compile _ DOTS_INSTANCING_ON
+	#endif
+
+	#ifdef ALLIN1_FOG_SUPPORT
+		#if UNITY_VERSION >= 60020000
+			#include_with_pragmas "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Fog.hlsl"
+		#else
+			#pragma multi_compile_fog
+		#endif
+	#endif
+	
+#endif
+
+
+#endif //ALLIN13DSHADER_FEATURESURP

Assets/Plugins/AllIn13DShader/Shaders/ShaderLibrary/AllIn13DShader_FeaturesURP.hlsl.meta

@@ -0,0 +1,14 @@
+fileFormatVersion: 2
+guid: eabe5d205fb5e244c9e9a4db44ae53f6
+ShaderIncludeImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 316173
+  packageName: All In 1 3D-Shader
+  packageVersion: 2.72
+  assetPath: Assets/Plugins/AllIn13DShader/Shaders/ShaderLibrary/AllIn13DShader_FeaturesURP.hlsl
+  uploadId: 865720

Assets/Plugins/AllIn13DShader/Shaders/ShaderLibrary/AllIn13DShader_FeaturesURP_Defines.hlsl

@@ -0,0 +1,15 @@
+#ifndef ALLIN13DSHADER_FEATURESURP_DEFINES
+#define ALLIN13DSHADER_FEATURESURP_DEFINES
+
+#define ALLIN1_GPU_INSTANCING_SUPPORT
+#define ALLIN1_FOG_SUPPORT
+#define ALLIN1_LIGHTMAPS_SUPPORT
+#define ALLIN1_ADDITIONAL_LIGHTS_SUPPORT
+#define ALLIN1_CAST_SHADOWS_SUPPORT
+#define ALLIN1_SHADOW_MASK_SUPPORT
+#define ALLIN1_FORWARD_PLUS_SUPPORT_UNITY6
+#define ALLIN1_ADAPTATIVE_PROBE_VOLUMES_UNITY6
+#define ALLIN1_SSO_SUPPORT
+
+
+#endif //ALLIN13DSHADER_FEATURESURP_DEFINES

Assets/Plugins/AllIn13DShader/Shaders/ShaderLibrary/AllIn13DShader_FeaturesURP_Defines.hlsl.meta

@@ -0,0 +1,14 @@
+fileFormatVersion: 2
+guid: dbe4d28eefee6bc44a32ba4795821c1a
+ShaderIncludeImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 316173
+  packageName: All In 1 3D-Shader
+  packageVersion: 2.72
+  assetPath: Assets/Plugins/AllIn13DShader/Shaders/ShaderLibrary/AllIn13DShader_FeaturesURP_Defines.hlsl
+  uploadId: 865720

Assets/Plugins/AllIn13DShader/Shaders/ShaderLibrary/AllIn13DShader_FragmentEffects.hlsl

@@ -0,0 +1,411 @@
+#ifndef ALLIN13DSHADER_FRAGMENT_EFFECTS
+#define ALLIN13DSHADER_FRAGMENT_EFFECTS
+
+//<EffectsCode>
+float3 HueShift(float3 inputColor, float hueShift, float hueSaturation, float hueBrightness)
+{
+	float3 res = inputColor;
+
+	float cosHsv = hueBrightness * hueSaturation * cos(hueShift * 3.14159265 / 180);
+	float sinHsv = hueBrightness * hueSaturation * sin(hueShift * 3.14159265 / 180);
+	res.r = (.299 * hueBrightness + .701 * cosHsv + .168 * sinHsv) * inputColor.x
+		+ (.587 * hueBrightness - .587 * cosHsv + .330 * sinHsv) * inputColor.y
+		+ (.114 * hueBrightness - .114 * cosHsv - .497 * sinHsv) * inputColor.z;
+	res.g = (.299 * hueBrightness - .299 * cosHsv - .328 * sinHsv) *inputColor.x
+		+ (.587 * hueBrightness + .413 * cosHsv + .035 * sinHsv) * inputColor.y
+		+ (.114 * hueBrightness - .114 * cosHsv + .292 * sinHsv) * inputColor.z;
+	res.b = (.299 * hueBrightness - .3 * cosHsv + 1.25 * sinHsv) * inputColor.x
+		+ (.587 * hueBrightness - .588 * cosHsv - 1.05 * sinHsv) * inputColor.y
+		+ (.114 * hueBrightness + .886 * cosHsv - .203 * sinHsv) * inputColor.z;
+
+	return res;
+}
+
+float3 ContrastBrightness(float3 inputColor, float contrast, float brightness)
+{
+	float3 res = max(0, (inputColor - float3(0.5, 0.5, 0.5)) * contrast + float3(0.5, 0.5, 0.5) + brightness);
+	return res;
+}
+
+
+#if defined(_AFFECTED_BY_LIGHTMAPS_ON) && defined(_LIGHTMAP_COLOR_CORRECTION_ON)
+float3 LightmapColorCorrection(float3 lightmap)
+{
+	float3 res = lightmap;
+
+	res = HueShift(res, ACCESS_PROP_FLOAT(_HueShiftLM), ACCESS_PROP_FLOAT(_HueSaturationLM), ACCESS_PROP_FLOAT(_HueBrightnessLM));
+	res = ContrastBrightness(res, ACCESS_PROP_FLOAT(_ContrastLM), ACCESS_PROP_FLOAT(_BrightnessLM));
+
+	return res;
+}
+#endif
+//</EffectsCode>
+
+#ifdef _HUE_SHIFT_ON
+float3 HueShift(float3 inputColor)
+{
+	float3 res = HueShift(inputColor, ACCESS_PROP_FLOAT(_HueShift), ACCESS_PROP_FLOAT(_HueSaturation), ACCESS_PROP_FLOAT(_HueBrightness));
+	return res;
+}
+#endif
+
+
+#ifdef _ALBEDO_VERTEX_COLOR_ON
+float4 AlbedoVertexColor(float4 inputColor, EffectsData data)
+{
+	float4 res = inputColor;
+
+#ifdef _ALBEDOVERTEXCOLORMODE_MULTIPLY
+	float3 multipliedColor = res.rgb * data.vertexColor.rgb;
+	res.rgb = lerp(res.rgb, multipliedColor, ACCESS_PROP_FLOAT(_VertexColorBlending));
+#else
+	res.rgb = lerp(inputColor.rgb, data.vertexColor.rgb, ACCESS_PROP_FLOAT(_VertexColorBlending));
+#endif
+
+	return res;
+}
+#endif
+
+#if defined(_TEXTURE_BLENDING_ON)
+float4 TextureBlending(float4 inputColor, EffectsData data)
+{
+	float4 res = inputColor;
+
+	#if defined(_TEXTUREBLENDINGSOURCE_TEXTURE)
+		float2 blendingMaskUV = SIMPLE_CUSTOM_TRANSFORM_TEX(data.rawMainUV, _TexBlendingMask);
+		float3 maskColor = SAMPLE_TEX2D(_TexBlendingMask, blendingMaskUV).rgb;
+		#if defined(_TEXTUREBLENDINGMODE_RGB)
+			float maskG = smoothstep(ACCESS_PROP_FLOAT(_BlendingMaskCutoffG), ACCESS_PROP_FLOAT(_BlendingMaskCutoffG) + ACCESS_PROP_FLOAT(_BlendingMaskSmoothnessG), maskColor.g);
+			float maskB = smoothstep(ACCESS_PROP_FLOAT(_BlendingMaskCutoffB), ACCESS_PROP_FLOAT(_BlendingMaskCutoffB) + ACCESS_PROP_FLOAT(_BlendingMaskSmoothnessB), maskColor.b);
+			maskColor = float3(1.0, maskG, maskB);
+		#else 
+			float maskBlackAndWhite = smoothstep(ACCESS_PROP_FLOAT(_BlendingMaskCutoffWhite), ACCESS_PROP_FLOAT(_BlendingMaskCutoffWhite) + ACCESS_PROP_FLOAT(_BlendingMaskSmoothnessWhite), maskColor.r);
+			maskColor = float3(maskBlackAndWhite, maskBlackAndWhite, maskBlackAndWhite);
+		#endif
+	#else
+		float3 maskColor = data.vertexColor.rgb;
+		float maskG = smoothstep(ACCESS_PROP_FLOAT(_BlendingMaskCutoffG), ACCESS_PROP_FLOAT(_BlendingMaskCutoffG) + ACCESS_PROP_FLOAT(_BlendingMaskSmoothnessG), maskColor.g);
+		float maskB = smoothstep(ACCESS_PROP_FLOAT(_BlendingMaskCutoffB), ACCESS_PROP_FLOAT(_BlendingMaskCutoffB) + ACCESS_PROP_FLOAT(_BlendingMaskSmoothnessB), maskColor.b);
+		
+		maskColor.g = maskG;
+		maskColor.b = maskB;
+	#endif
+
+	#ifdef _STOCHASTIC_SAMPLING_ON
+		float2 dx = 0;
+		float2 dy = 0;
+			
+		float stochasticScale	= ACCESS_PROP_FLOAT(_StochasticScale);
+		float stochasticSkew	= ACCESS_PROP_FLOAT(_StochasticSkew);
+	#endif
+	
+	#ifdef _TEXTUREBLENDINGMODE_RGB
+		float2 texGUV = SIMPLE_CUSTOM_TRANSFORM_TEX(data.rawMainUV, _BlendingTextureG);
+		float2 texBUV = SIMPLE_CUSTOM_TRANSFORM_TEX(data.rawMainUV, _BlendingTextureB);
+
+		float4 texG = 0;
+		float4 texB = 0;
+		#ifdef _STOCHASTIC_SAMPLING_ON		
+			float4x3 stochasticOffsets_G = getStochasticOffsets(texGUV, stochasticScale, stochasticSkew);
+			STOCHASTIC_SAMPLING_NO_DEF_DD(_BlendingTextureG, texGUV, stochasticOffsets_G, texG)
+		
+			float4x3 stochasticOffsets_B = getStochasticOffsets(texBUV, stochasticScale, stochasticSkew);
+			STOCHASTIC_SAMPLING_NO_DEF_DD(_BlendingTextureB, texGUV, stochasticOffsets_B, texB)
+		#else
+			texG = SAMPLE_TEX2D(_BlendingTextureG, texGUV);
+			texB = SAMPLE_TEX2D(_BlendingTextureB, texBUV);
+		#endif
+	
+		res = lerp(res, texG, maskColor.g);
+		res = lerp(res, texB, maskColor.b);
+	#else
+		float2 texWhiteUV = SIMPLE_CUSTOM_TRANSFORM_TEX(data.rawMainUV, _BlendingTextureWhite);
+		
+		float4 texWhite = 0;
+		#ifdef _STOCHASTIC_SAMPLING_ON
+			float4x3 stochasticOffsets_W = getStochasticOffsets(texWhiteUV, stochasticScale, stochasticSkew);
+			STOCHASTIC_SAMPLING_NO_DEF_DD(_BlendingTextureWhite, texWhiteUV, stochasticOffsets_W, texWhite)
+		#else
+			texWhite = SAMPLE_TEX2D(_BlendingTextureWhite, texWhiteUV);
+		#endif
+		
+		res = lerp(res, texWhite, maskColor.r); 
+	#endif
+
+	return res;
+}
+#endif
+
+
+#ifdef _HOLOGRAM_ON
+float4 Hologram(float4 inputColor, EffectsData data)
+{
+	float4 res = inputColor;
+
+	float3 dir = normalize(ACCESS_PROP_FLOAT3(_HologramLineDirection).xyz);
+                
+    // Calculate primary hologram pattern using direction projection
+    float3 scrollPos1 = data.vertexWS * ACCESS_PROP_FLOAT(_HologramFrequency) + (data.shaderTime.y * ACCESS_PROP_FLOAT(_HologramScrollSpeed));
+    float3 scrollUV1 = frac(scrollPos1);
+
+	float projectedValue1 = dot(scrollUV1, normalize(dir));
+    float distance1 = abs(projectedValue1 - ACCESS_PROP_FLOAT(_HologramLineCenter)) * ACCESS_PROP_FLOAT(_HologramLineSpacing);
+    float gradientMask1 = 1 - distance1;
+    gradientMask1 = pow(saturate(gradientMask1), ACCESS_PROP_FLOAT(_HologramLineSmoothness));
+    gradientMask1 = max(gradientMask1, ACCESS_PROP_FLOAT(_HologramBaseAlpha));
+	
+	// Calculate accent line pattern using direction projection
+    float3 scrollPos2 = data.vertexWS * ACCESS_PROP_FLOAT(_HologramAccentFrequency) + (data.shaderTime.y * ACCESS_PROP_FLOAT(_HologramAccentSpeed));
+    float3 scrollUV2 = frac(scrollPos2);
+
+	float projectedValue2 = dot(scrollUV2, normalize(dir));
+    float distance2 = abs(projectedValue2 - ACCESS_PROP_FLOAT(_HologramLineCenter)) * ACCESS_PROP_FLOAT(_HologramLineSpacing);
+    float gradientMask2 = 1 - distance2;
+    gradientMask2 = pow(saturate(gradientMask2), ACCESS_PROP_FLOAT(_HologramLineSmoothness));
+
+	// Combine both patterns
+    float combinedMask = saturate(gradientMask1 * ACCESS_PROP_FLOAT(_HologramAlpha) + gradientMask2 * ACCESS_PROP_FLOAT(_HologramAccentAlpha));
+                
+    float4 finalColor = ACCESS_PROP_FLOAT4(_HologramColor);
+    finalColor.a = combinedMask * ACCESS_PROP_FLOAT4(_HologramColor).a;
+
+	res *= finalColor;
+
+	return res;
+}
+#endif
+
+#ifdef _MATCAP_ON
+
+float3 Matcap(EffectsData data)
+{
+#ifdef _NORMAL_MAP_ON
+	float3 normalMapOS = normalize(mul(UNITY_MATRIX_IT_MV, float4(data.normalWS, 0.0)).xyz);
+	float3 normalVS = normalize(mul(UNITY_MATRIX_MV, float4(normalMapOS, 0.0)).xyz);
+#else
+	float3 normalVS = normalize(mul(UNITY_MATRIX_MV, float4(data.normalOS, 0.0)).xyz);
+#endif
+
+	float3 positionVSDir = normalize(GetPositionVS(data.vertexOS));
+
+	float3 normalCrossPosition = cross(positionVSDir, normalVS);
+
+	float u = (-normalCrossPosition.y * 0.5) + 0.5;
+	float v = (normalCrossPosition.x * 0.5) + 0.5;
+
+	float2 matcapUV = float2(u, v);
+	float3 res = SAMPLE_TEX2D(_MatcapTex, matcapUV).rgb * ACCESS_PROP_FLOAT(_MatcapIntensity);
+	return res;
+}
+#endif
+
+
+#ifdef _COLOR_RAMP_ON
+float4 ColorRamp(float4 inputColor, EffectsData data)
+{
+	float luminance = GetLuminance(inputColor);
+	luminance = saturate(luminance + ACCESS_PROP_FLOAT(_ColorRampLuminosity));
+
+	float2 rampUV = float2(luminance, 0);
+	rampUV.x *= ACCESS_PROP_FLOAT(_ColorRampTiling);
+	rampUV.x += frac(data.shaderTime.x * ACCESS_PROP_FLOAT(_ColorRampScrollSpeed));
+
+	float3 colorRamp = SAMPLE_TEX2D(_ColorRampTex, rampUV).rgb;
+	float3 resRGB = lerp(inputColor.rgb, colorRamp, ACCESS_PROP_FLOAT(_ColorRampBlend));
+
+	float4 res = float4(resRGB, inputColor.a);
+
+	return res;	
+}
+#endif
+
+#ifdef _HIT_ON
+
+float4 Hit(float4 inputColor)
+{
+	float3 resRGB = lerp(inputColor.rgb, ACCESS_PROP_FLOAT4(_HitColor).rgb * ACCESS_PROP_FLOAT(_HitGlow), ACCESS_PROP_FLOAT(_HitBlend));
+	float4 res = float4(resRGB, inputColor.a);
+	return res;
+}
+
+#endif
+#ifdef _RIM_LIGHTING_ON
+float3 Rim(float3 inputColorRGB, EffectsData data)
+{
+	float3 rimOffset = ACCESS_PROP_FLOAT3(_RimOffset);
+	float rimIntensity = 0;
+    
+	UNITY_BRANCH
+	if(dot(rimOffset, rimOffset) > 0.001f) //If we have an offset we calculate it
+	{
+		float3 viewSpaceOffset = mul((float3x3)UNITY_MATRIX_V, -rimOffset);
+		float3 normalizedViewDir = normalize(data.viewDirWS);
+		float3 biasedViewDir = normalize(normalizedViewDir + viewSpaceOffset);
+		float NdotV = saturate(dot(data.normalWS, biasedViewDir));
+		rimIntensity = smoothstep(ACCESS_PROP_FLOAT(_MinRim), ACCESS_PROP_FLOAT(_MaxRim), 1 - NdotV) * ACCESS_PROP_FLOAT(_RimAttenuation);
+	}
+	else //Otherwise we take quick path
+	{
+		float3 normalizedViewDir = normalize(data.viewDirWS);
+		float NdotV = saturate(dot(data.normalWS, normalizedViewDir));
+		rimIntensity = smoothstep(ACCESS_PROP_FLOAT(_MinRim), ACCESS_PROP_FLOAT(_MaxRim), 1 - NdotV) * ACCESS_PROP_FLOAT(_RimAttenuation);
+	}
+    
+	return lerp(inputColorRGB, ACCESS_PROP_FLOAT4(_RimColor).rgb, rimIntensity);
+}
+#endif
+
+#ifdef _GREYSCALE_ON
+float3 Greyscale(float3 inputColorRGB)
+{
+	float3 res = inputColorRGB;
+	float luminance = GetLuminance(res);
+	luminance = saturate(luminance + ACCESS_PROP_FLOAT(_GreyscaleLuminosity));
+	res = lerp(res, luminance * ACCESS_PROP_FLOAT4(_GreyscaleTintColor).rgb, ACCESS_PROP_FLOAT(_GreyscaleBlending));
+	
+	return res;
+}
+#endif
+
+#ifdef _POSTERIZE_ON
+float3 Posterize(float3 inputColorRGB)
+{
+	float3 res		= inputColorRGB;
+	float gamma		= ACCESS_PROP_FLOAT(_PosterizeGamma);
+	float numColors = ACCESS_PROP_FLOAT(_PosterizeNumColors);
+	res.rgb = pow(res.rgb, gamma) * numColors;
+	res.rgb = floor(res.rgb) / numColors;
+	res.rgb = pow(res.rgb, 1.0 / gamma);
+	
+	return res;
+}
+#endif
+
+#ifdef _HIGHLIGHTS_ON
+float3 Highlights(float3 inputColorRGB, EffectsData data)
+{
+	float3 normalizedLightDir = normalize(data.lightDir);
+	float3 offsetLightDir = normalize(normalizedLightDir + ACCESS_PROP_FLOAT3(_HighlightOffset));
+	float3 normalizedViewDir = normalize(data.viewDirWS);
+
+	float NdotL = saturate(dot(data.normalWS, offsetLightDir));
+	float NdotV = saturate(dot(data.normalWS, normalizedViewDir));
+	float rimFactor = 1.0 - NdotV;
+    
+	float highlightCutoff		= ACCESS_PROP_FLOAT(_HighlightCutoff);
+	float highlightSmoothness	= ACCESS_PROP_FLOAT(_HighlightSmoothness);
+	float highlightsIntensity	= smoothstep(highlightCutoff, highlightCutoff + highlightSmoothness, rimFactor);
+    
+	float3 highlights = highlightsIntensity * NdotL * ACCESS_PROP_FLOAT4(_HighlightsColor).rgb * ACCESS_PROP_FLOAT(_HighlightsStrength);
+
+	return inputColorRGB * (highlights + 1);
+}
+#endif
+
+#ifdef _CONTRAST_BRIGHTNESS_ON
+float3 ContrastBrightness(float3 inputColorRGB)
+{
+	float3 res = ContrastBrightness(inputColorRGB, ACCESS_PROP_FLOAT(_Contrast), ACCESS_PROP_FLOAT(_Brightness));
+	return res;
+}
+#endif
+
+#ifdef _HEIGHT_GRADIENT_ON
+float4 HeightGradient(float4 inputColor, EffectsData data)
+{
+	float4 res = inputColor;
+
+	
+	#ifdef _HEIGHTGRADIENTPOSITIONSPACE_WORLD
+		float3 selectedPos = data.vertexWS;
+	#else
+		float3 selectedPos = data.vertexOS;
+	#endif
+
+	float gradient = RemapFloat(selectedPos.y, ACCESS_PROP_FLOAT(_MinGradientHeight), ACCESS_PROP_FLOAT(_MaxGradientHeight), 0.0, 1.0);
+	gradient = saturate(gradient);
+
+	float4 gradientColor = lerp(ACCESS_PROP_FLOAT4(_GradientHeightColor01), ACCESS_PROP_FLOAT4(_GradientHeightColor02), gradient);
+
+	res *= gradientColor;
+
+	return res;
+}
+#endif
+
+#ifdef _INTERSECTION_GLOW_ON
+float4 IntersectionGlow(float4 inputColor, EffectsData data)
+{
+	float4 res = inputColor;
+
+	float depthGlowMask = saturate(ACCESS_PROP_FLOAT(_DepthGlowDist) * pow(max(0, 1 - data.sceneDepthDiff), ACCESS_PROP_FLOAT(_DepthGlowPower)));
+
+	res.rgb = lerp(res.rgb, ACCESS_PROP_FLOAT(_DepthGlowGlobalIntensity) * res.rgb, depthGlowMask);
+	res.rgb += ACCESS_PROP_FLOAT4(_DepthGlowColor).rgb * ACCESS_PROP_FLOAT(_DepthGlowColorIntensity) * depthGlowMask * res.a;
+
+	return res;
+}
+#endif
+
+#ifdef _DEPTH_COLORING_ON
+
+float4 DepthColoring(float4 inputColor, EffectsData data)
+{
+	float4 res = inputColor;
+	
+	float eyeDepth = GetEyeDepth(data.vertexVS);
+	float eyeDepth01 = smoothstep(global_MinDepth, global_MinDepth + global_DepthZoneLength, eyeDepth);
+	eyeDepth01 = pow(eyeDepth01, global_DepthGradientFallOff);
+
+#ifdef FORWARD_ADD_PASS
+	res *= (1 - eyeDepth01);
+#else
+	float4 depthCol = SAMPLE_TEX2D(global_DepthGradient, float2(eyeDepth01, 0));
+	res = lerp(res, depthCol, depthCol.a);
+#endif
+
+	
+
+	return res;
+}
+
+#endif
+
+#ifdef _SUBSURFACE_SCATTERING_ON
+float4 SubsurfaceScattering(float4 inputColor, EffectsData data)
+{
+	float4 res = inputColor;
+
+	float4 sssMapColor = SAMPLE_TEX2D(_SSSMap, data.mainUV);
+
+	//Why do we need to add 1000 for this to look good?
+	float3 lightColor = GetMainLightColorRGB() * 5;
+	float lightIntensity = GetMainLightIntensity();
+
+	float3 normalizedViewDir = normalize(data.viewDirWS);
+	float3 scatterNormal = (data.normalWS * ACCESS_PROP_FLOAT(_NormalInfluence)) + data.lightDir;
+	scatterNormal = -normalize(scatterNormal);
+    
+	float VdotScatterNormal = saturate(dot(scatterNormal, normalizedViewDir));
+
+	float sssPower = max(1.0, ACCESS_PROP_FLOAT(_SSSPower));
+	float backScatterFactor = pow(VdotScatterNormal, sssPower);
+
+	float frontScatter = saturate(dot(data.normalWS, data.lightDir)); // How directly light hits surface
+	float frontVdotN = 1.0 - saturate(dot(normalizedViewDir, data.normalWS)); // Fresnel-like front falloff
+	frontVdotN = pow(frontVdotN, ACCESS_PROP_FLOAT(_SSSFrontPower));
+	float frontScatterFactor = frontScatter * frontVdotN * ACCESS_PROP_FLOAT(_SSSFrontAtten);
+
+	float scatterIntensity = max(backScatterFactor, frontScatterFactor) * ACCESS_PROP_FLOAT(_SSSAtten) * sssMapColor.r;
+    
+	// Simulate wavelength-dependent scattering with original scatter calculation
+	float3 deepScatterColor = float3(1.0, 0.3, 0.2);
+	float3 scatterColor = scatterIntensity * lightColor.rgb * lightIntensity * ACCESS_PROP_FLOAT4(_SSSColor).rgb;
+	scatterColor *= lerp(float3(1,1,1), deepScatterColor, VdotScatterNormal);
+    
+	res.rgb += scatterColor * inputColor.rgb;
+	return res;
+}
+#endif
+
+#endif

Assets/Plugins/AllIn13DShader/Shaders/ShaderLibrary/AllIn13DShader_FragmentEffects.hlsl.meta

@@ -0,0 +1,14 @@
+fileFormatVersion: 2
+guid: 2a5af0d8118cd0d4d8efc233725d9bc2
+ShaderIncludeImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 316173
+  packageName: All In 1 3D-Shader
+  packageVersion: 2.72
+  assetPath: Assets/Plugins/AllIn13DShader/Shaders/ShaderLibrary/AllIn13DShader_FragmentEffects.hlsl
+  uploadId: 865720

Assets/Plugins/AllIn13DShader/Shaders/ShaderLibrary/AllIn13DShader_GlobalPropertiesAndTexturesDeclaration.hlsl

@@ -0,0 +1,119 @@
+#ifndef ALLIN13DSHADER_GLOBALPROPERTIESANDTEXTURESDECLARATION
+#define ALLIN13DSHADER_GLOBALPROPERTIESANDTEXTURESDECLARATION
+
+DECLARE_TEX2D(_MainTex)
+
+#if defined(_TEXTURE_BLENDING_ON)
+	#if defined(_TEXTUREBLENDINGMODE_RGB)
+		DECLARE_TEX2D(_BlendingTextureG)
+		DECLARE_TEX2D(_BlendingTextureB)
+	#else
+		DECLARE_TEX2D(_BlendingTextureWhite)
+	#endif
+
+	#if defined(_TEXTUREBLENDINGSOURCE_TEXTURE)
+		DECLARE_TEX2D(_TexBlendingMask)
+	#endif
+
+	#if defined(_NORMAL_MAP_ON)
+		#if defined(_TEXTUREBLENDINGMODE_RGB)
+			DECLARE_TEX2D(_BlendingNormalMapG)
+			DECLARE_TEX2D(_BlendingNormalMapB)
+		#else
+			DECLARE_TEX2D(_BlendingNormalMapWhite)
+		#endif
+	#endif
+#endif
+
+#if defined(REQUIRE_TANGENT_WS)
+	DECLARE_TEX2D(_NormalMap)
+#endif
+
+#if defined(_COLOR_RAMP_ON)
+	DECLARE_TEX2D(_ColorRampTex)
+#endif
+
+// ----- Global Properties
+float global_MinDepth;
+float global_DepthZoneLength;
+float global_DepthGradientFallOff;
+
+#if defined(REQUIRE_SCENE_DEPTH)
+	DECLARE_TEX2D(global_DepthGradient)
+#endif
+
+#if defined(_CUSTOM_SHADOW_COLOR_ON)
+	float4 global_shadowColor;
+#endif
+
+float4 allIn13DShader_globalTime;
+
+#if defined(_LIGHTMODEL_FASTLIGHTING)
+	float3 global_lightDirection;
+	float4 global_lightColor;
+#endif
+
+#if defined(_WIND_ON)
+	DECLARE_TEX2D(global_windNoiseTex)
+	float global_windForce;
+	float2 global_noiseSpeed;
+	float global_useWindDir;
+	float3 global_windDir;
+	float global_minWindValue;
+	float global_maxWindValue;
+	float global_windWorldSize;
+#endif
+//------------------------
+
+#if defined(_SHADINGMODEL_PBR)
+	#if defined(_METALLIC_MAP_ON)
+		DECLARE_TEX2D(_MetallicMap)
+	#endif
+#endif
+
+#if defined(SPECULAR_ON)
+	DECLARE_TEX2D(_SpecularMap)
+#endif
+
+#if defined(_LIGHTMODEL_TOONRAMP)
+	DECLARE_TEX2D(_ToonRamp)
+#endif
+
+#if defined(_AOMAP_ON)
+	DECLARE_TEX2D(_AOMap)
+#endif
+
+#if defined(_SUBSURFACE_SCATTERING_ON)
+	DECLARE_TEX2D(_SSSMap)
+#endif
+
+#if defined(_FADE_ON)
+	DECLARE_TEX2D(_FadeTex)
+#endif
+
+#if defined(_VERTEX_DISTORTION_ON) || defined(URP_PASS)
+	DECLARE_TEX2D(_VertexDistortionNoiseTex)
+#endif
+
+#if defined(_MATCAP_ON)
+	DECLARE_TEX2D(_MatcapTex)
+#endif
+
+#if defined(_UV_DISTORTION_ON)
+	DECLARE_TEX2D(_DistortTex)
+#endif
+
+#if defined(_EMISSION_ON)
+	DECLARE_TEX2D(_EmissionMap)
+#endif
+
+#if defined(_TRIPLANAR_MAPPING_ON)
+	DECLARE_TEX2D(_TriplanarTopTex)
+	DECLARE_TEX2D(_TriplanarTopNormalMap)
+
+	#if defined(_TRIPLANAR_NOISE_TRANSITION_ON)
+		DECLARE_TEX2D(_TriplanarNoiseTex);
+	#endif
+#endif
+
+#endif //ALLIN13DSHADER_GLOBALPROPERTIESANDTEXTURESDECLARATION

Assets/Plugins/AllIn13DShader/Shaders/ShaderLibrary/AllIn13DShader_GlobalPropertiesAndTexturesDeclaration.hlsl.meta

@@ -0,0 +1,14 @@
+fileFormatVersion: 2
+guid: b6385c57e3a576042a81507b908422f1
+ShaderIncludeImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 316173
+  packageName: All In 1 3D-Shader
+  packageVersion: 2.72
+  assetPath: Assets/Plugins/AllIn13DShader/Shaders/ShaderLibrary/AllIn13DShader_GlobalPropertiesAndTexturesDeclaration.hlsl
+  uploadId: 865720

Assets/Plugins/AllIn13DShader/Shaders/ShaderLibrary/AllIn13DShader_OutlinePass.hlsl

@@ -0,0 +1,140 @@
+#ifndef ALLIN13DSHADER_OUTLINE_PASS_INCLUDED
+#define ALLIN13DSHADER_OUTLINE_PASS_INCLUDED
+
+#if defined(_OUTLINETYPE_SIMPLE) || defined(_OUTLINETYPE_FADEWITHDISTANCE)
+	#define OUTLINE_FACTOR 0.01
+#else 
+	#define OUTLINE_FACTOR 1.0
+#endif
+
+float3 GetObjectScale()
+{
+    float3 res = float3(length(float3(UNITY_MATRIX_M[0].x, UNITY_MATRIX_M[1].x, UNITY_MATRIX_M[2].x)),
+                             length(float3(UNITY_MATRIX_M[0].y, UNITY_MATRIX_M[1].y, UNITY_MATRIX_M[2].y)),
+                             length(float3(UNITY_MATRIX_M[0].z, UNITY_MATRIX_M[1].z, UNITY_MATRIX_M[2].z)));
+	
+    return res;
+}
+
+#ifdef OUTLINE_ON
+float4 Outline_Constant(float4 vertexPos, float3 normalOS, float3 thicknessScaled)
+{
+    float3 vertexWS = GetPositionWS(vertexPos);
+    float3 vertexToCameraWS = _WorldSpaceCameraPos.xyz - vertexWS;
+	
+    float distanceToCamera = length(vertexToCameraWS);
+	
+    float4 res = vertexPos;
+	
+    float normalizedDistanceToCamera = distanceToCamera / ACCESS_PROP_FLOAT(_MaxCameraDistance);
+    float displacement = thicknessScaled.x * normalizedDistanceToCamera;
+	res.xyz += normalOS * displacement;
+
+    return res;
+}
+
+float4 Outline_Simple(float4 vertexPos, float3 normalOS, float3 thicknessScaled)
+{
+    float4 res = vertexPos;
+	
+    res.xyz += normalOS * thicknessScaled;
+    return res;
+}
+
+float4 Outline_FadeWithDistance(float4 vertexPos, float3 normalOS, float3 thicknessScaled)
+{
+	float4 res = vertexPos;
+	
+	float3 vertexWS = GetPositionWS(vertexPos);
+	float3 vertexToCameraWS = _WorldSpaceCameraPos.xyz - vertexWS;
+	float distanceToCamera = length(vertexToCameraWS);
+	
+	float normalizedDistanceToCamera = saturate(distanceToCamera / ACCESS_PROP_FLOAT(_MaxFadeDistance));
+	float3 correctedThickness = (1 - normalizedDistanceToCamera) * thicknessScaled;
+	
+	res.xyz += normalOS * correctedThickness;
+	return res;
+}
+#endif
+
+FragmentDataOutline OutlinePass_Vertex(VertexData v)
+{
+	FragmentDataOutline o;
+
+	o.interpolator_01 = 0;
+	o.interpolator_02 = 0;
+	o.interpolator_03 = 0;
+
+	UNITY_SETUP_INSTANCE_ID(v);
+    UNITY_TRANSFER_INSTANCE_ID(v, o);
+	UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(o); 
+
+#if defined(OUTLINE_ON)
+    float3 _Object_Scale = GetObjectScale();
+    float3 thicknessScaled = (ACCESS_PROP_FLOAT(_OutlineThickness) / _Object_Scale) * OUTLINE_FACTOR;
+#endif
+	
+#if defined(_SPHERIZE_NORMALS_ON)
+	float3 normalOS = normalize(v.vertex);
+#else
+	float3 normalOS = v.normal;
+#endif
+
+#if defined(_USE_CUSTOM_TIME)
+	SHADER_TIME(o) = allIn13DShader_globalTime.xyz + ACCESS_PROP_FLOAT(_TimingSeed);
+#else
+	SHADER_TIME(o) = _Time.xyz + ACCESS_PROP_FLOAT(_TimingSeed);
+#endif
+
+	v.vertex = ApplyVertexEffects(v.vertex, normalOS, SHADER_TIME(o));
+
+#if defined(_OUTLINETYPE_SIMPLE)
+	v.vertex = Outline_Simple(v.vertex, v.normal, thicknessScaled);
+#elif defined(_OUTLINETYPE_CONSTANT)
+    v.vertex = Outline_Constant(v.vertex, v.normal, thicknessScaled);
+#elif defined(_OUTLINETYPE_FADEWITHDISTANCE)
+	v.vertex = Outline_FadeWithDistance(v.vertex, v.normal, thicknessScaled);
+#endif
+	
+	o.normalWS = GetNormalWS(v.normal);
+	o.mainUV = SIMPLE_CUSTOM_TRANSFORM_TEX(v.uv, _MainTex);
+	o.pos = OBJECT_TO_CLIP_SPACE(v);
+	o.positionWS = GetPositionWS(v.vertex);
+	UV_LIGHTMAP(o) = v.uvLightmap;
+
+	FOGCOORD(o) = GetFogFactor(o.pos);
+	
+	return o;
+}
+
+float4 OutlinePass_Fragment(FragmentDataOutline i) : SV_Target
+{
+	UNITY_SETUP_INSTANCE_ID(i);
+	UNITY_SETUP_STEREO_EYE_INDEX_POST_VERTEX(i);
+
+	float4 col = float4(0, 0, 0, 0);
+	
+#ifdef OUTLINE_ON
+	col = ACCESS_PROP_FLOAT4(_OutlineColor);
+#endif
+
+	float camDistance = distance(i.positionWS, _WorldSpaceCameraPos); 
+	float4 screenPos = ComputeScreenPos(i.pos);
+	col = ApplyAlphaEffects(col,
+		SCALED_MAIN_UV(i), UV_LIGHTMAP(i), i.positionWS,
+		1.0, camDistance, screenPos);
+
+#ifdef _ALPHA_CUTOFF_ON
+	clip((col.a - ACCESS_PROP_FLOAT(_AlphaCutoffValue)) - 0.001);
+#endif	
+
+#if defined(FOG_ENABLED)
+	col = CustomMixFog(FOGCOORD(i), col);
+#endif
+
+	col.a *= ACCESS_PROP_FLOAT(_GeneralAlpha);
+
+	return col;
+}
+
+#endif

Assets/Plugins/AllIn13DShader/Shaders/ShaderLibrary/AllIn13DShader_OutlinePass.hlsl.meta

@@ -0,0 +1,14 @@
+fileFormatVersion: 2
+guid: bd358394d45cd1d43a4b76562dc0d11b
+ShaderIncludeImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 316173
+  packageName: All In 1 3D-Shader
+  packageVersion: 2.72
+  assetPath: Assets/Plugins/AllIn13DShader/Shaders/ShaderLibrary/AllIn13DShader_OutlinePass.hlsl
+  uploadId: 865720

Assets/Plugins/AllIn13DShader/Shaders/ShaderLibrary/AllIn13DShader_ShaderFeatures.hlsl

@@ -0,0 +1,104 @@
+#ifndef ALLIN13DSHADER_SHADERFEATURES_
+#define ALLIN13DSHADER_SHADERFEATURES_
+
+#pragma shader_feature_local _LIGHTMODEL_NONE
+#pragma shader_feature_local _LIGHTMODEL_CLASSIC
+#pragma shader_feature_local _LIGHTMODEL_TOON
+#pragma shader_feature_local _LIGHTMODEL_TOONRAMP
+#pragma shader_feature_local _LIGHTMODEL_HALFLAMBERT
+#pragma shader_feature_local _LIGHTMODEL_FAKEGI
+#pragma shader_feature_local _LIGHTMODEL_FASTLIGHTING
+#pragma shader_feature_local _SHADINGMODEL_BASIC
+#pragma shader_feature_local _SHADINGMODEL_PBR
+#pragma shader_feature_local _METALLIC_MAP_ON
+#pragma shader_feature_local _SPECULARMODEL_NONE
+#pragma shader_feature_local _SPECULARMODEL_CLASSIC
+#pragma shader_feature_local _SPECULARMODEL_TOON
+#pragma shader_feature_local _SPECULARMODEL_ANISOTROPIC
+#pragma shader_feature_local _SPECULARMODEL_ANISOTROPICTOON
+#pragma shader_feature_local _REFLECTIONS_NONE
+#pragma shader_feature_local _REFLECTIONS_CLASSIC
+#pragma shader_feature_local _REFLECTIONS_TOON
+#pragma shader_feature_local _NORMAL_MAP_ON
+#pragma shader_feature_local _FLAT_NORMALS_ON
+#pragma shader_feature_local _CUSTOM_SHADOW_COLOR_ON
+#pragma shader_feature_local _AFFECTED_BY_LIGHTMAPS_ON
+#pragma shader_feature_local _LIGHTMAP_COLOR_CORRECTION_ON
+#pragma shader_feature_local _CUSTOM_AMBIENT_LIGHT_ON
+#pragma shader_feature_local _CAST_SHADOWS_ON
+#pragma shader_feature_local _RECEIVE_SHADOWS_ON
+#pragma shader_feature_local _RECEIVEDSHADOWSTYPE_CLASSIC
+#pragma shader_feature_local _RECEIVEDSHADOWSTYPE_STYLIZED
+#pragma shader_feature_local _COLOR_RAMP_ON
+#pragma shader_feature_local _COLORRAMPLIGHTINGSTAGE_BEFORELIGHTING
+#pragma shader_feature_local _COLORRAMPLIGHTINGSTAGE_AFTERLIGHTING
+#pragma shader_feature_local _AOMAP_ON
+#pragma shader_feature_local _HIGHLIGHTS_ON
+#pragma shader_feature_local _RIM_LIGHTING_ON
+#pragma shader_feature_local _RIMLIGHTINGSTAGE_BEFORELIGHTING
+#pragma shader_feature_local _RIMLIGHTINGSTAGE_BEFORELIGHTINGLAST
+#pragma shader_feature_local _RIMLIGHTINGSTAGE_AFTERLIGHTING
+#pragma shader_feature_local _GREYSCALE_ON
+#pragma shader_feature_local _GREYSCALESTAGE_BEFORELIGHTING
+#pragma shader_feature_local _GREYSCALESTAGE_AFTERLIGHTING
+#pragma shader_feature_local _POSTERIZE_ON
+#pragma shader_feature_local _HUE_SHIFT_ON
+#pragma shader_feature_local _EMISSION_ON
+#pragma shader_feature_local _HOLOGRAM_ON
+#pragma shader_feature_local _MATCAP_ON
+#pragma shader_feature_local _MATCAPBLENDMODE_MULTIPLY
+#pragma shader_feature_local _MATCAPBLENDMODE_REPLACE
+#pragma shader_feature_local _HIT_ON
+#pragma shader_feature_local _CONTRAST_BRIGHTNESS_ON
+#pragma shader_feature_local _HEIGHT_GRADIENT_ON
+#pragma shader_feature_local _HEIGHTGRADIENTPOSITIONSPACE_LOCAL
+#pragma shader_feature_local _HEIGHTGRADIENTPOSITIONSPACE_WORLD
+#pragma shader_feature_local _INTERSECTION_GLOW_ON
+#pragma shader_feature_local _ALBEDO_VERTEX_COLOR_ON
+#pragma shader_feature_local _ALBEDOVERTEXCOLORMODE_MULTIPLY
+#pragma shader_feature_local _ALBEDOVERTEXCOLORMODE_REPLACE
+#pragma shader_feature_local _TRIPLANAR_MAPPING_ON
+#pragma shader_feature_local _TRIPLANARNORMALSPACE_LOCAL
+#pragma shader_feature_local _TRIPLANARNORMALSPACE_WORLD
+#pragma shader_feature_local _TRIPLANAR_NOISE_TRANSITION_ON
+#pragma shader_feature_local _TEXTURE_BLENDING_ON
+#pragma shader_feature_local _TEXTUREBLENDINGSOURCE_VERTEXCOLOR
+#pragma shader_feature_local _TEXTUREBLENDINGSOURCE_TEXTURE
+#pragma shader_feature_local _TEXTUREBLENDINGMODE_RGB
+#pragma shader_feature_local _TEXTUREBLENDINGMODE_BLACKANDWHITE
+#pragma shader_feature_local _DEPTH_COLORING_ON
+#pragma shader_feature_local _SUBSURFACE_SCATTERING_ON
+#pragma shader_feature_local _ALPHA_CUTOFF_ON
+#pragma shader_feature_local _FADE_ON
+#pragma shader_feature_local _FADEUVSET_UV1
+#pragma shader_feature_local _FADEUVSET_UV2
+#pragma shader_feature_local _FADEUVSET_WORLD_SPACE
+#pragma shader_feature_local _FADE_BURN_ON
+#pragma shader_feature_local _INTERSECTION_FADE_ON
+#pragma shader_feature_local _ALPHA_ROUND_ON
+#pragma shader_feature_local _FADE_BY_CAM_DISTANCE_ON
+#pragma shader_feature_local _FADE_BY_CAM_DISTANCE_NEAR_FADE
+#pragma shader_feature_local _DITHER_ON
+#pragma shader_feature_local _VERTEX_SHAKE_ON
+#pragma shader_feature_local _VERTEX_INFLATE_ON
+#pragma shader_feature_local _VERTEX_DISTORTION_ON
+#pragma shader_feature_local _VOXELIZE_ON
+#pragma shader_feature_local _GLITCH_ON
+#pragma shader_feature_local _RECALCULATE_NORMALS_ON
+#pragma shader_feature_local _WIND_ON
+#pragma shader_feature_local _USE_WIND_VERTICAL_MASK
+#pragma shader_feature_local _SCROLL_TEXTURE_ON
+#pragma shader_feature_local _SCREEN_SPACE_UV_ON
+#pragma shader_feature_local _PIXELATE_ON
+#pragma shader_feature_local _STOCHASTIC_SAMPLING_ON
+#pragma shader_feature_local _WAVE_UV_ON
+#pragma shader_feature_local _HAND_DRAWN_ON
+#pragma shader_feature_local _UV_DISTORTION_ON
+#pragma shader_feature_local _OUTLINETYPE_NONE
+#pragma shader_feature_local _OUTLINETYPE_SIMPLE
+#pragma shader_feature_local _OUTLINETYPE_CONSTANT
+#pragma shader_feature_local _OUTLINETYPE_FADEWITHDISTANCE
+#pragma shader_feature_local _FOG_ON
+
+
+#endif //ALLIN13DSHADER_SHADERFEATURES_

Assets/Plugins/AllIn13DShader/Shaders/ShaderLibrary/AllIn13DShader_ShaderFeatures.hlsl.meta

@@ -0,0 +1,14 @@
+fileFormatVersion: 2
+guid: 9c2f0a067529e8f4ebff5b3d9b328a73
+ShaderIncludeImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 316173
+  packageName: All In 1 3D-Shader
+  packageVersion: 2.72
+  assetPath: Assets/Plugins/AllIn13DShader/Shaders/ShaderLibrary/AllIn13DShader_ShaderFeatures.hlsl
+  uploadId: 865720

Assets/Plugins/AllIn13DShader/Shaders/ShaderLibrary/AllIn13DShader_ShadowCasterPass.hlsl

@@ -0,0 +1,78 @@
+#ifndef ALLIN13DSHADER_SHADOW_CASTER_PASS_INCLUDED
+#define ALLIN13DSHADER_SHADOW_CASTER_PASS_INCLUDED
+
+FragmentDataShadowCaster BasicVertexShadowCaster(VertexData v)
+{
+	FragmentDataShadowCaster o;
+
+	UNITY_SETUP_INSTANCE_ID(v);
+    UNITY_TRANSFER_INSTANCE_ID(v, o);
+	UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(o); 
+
+#ifdef _USE_CUSTOM_TIME
+	float3 shaderTime = allIn13DShader_globalTime.xyz + ACCESS_PROP_FLOAT(_TimingSeed);
+#else
+	float3 shaderTime = _Time.xyz + ACCESS_PROP_FLOAT(_TimingSeed);
+#endif
+
+	v.vertex = ApplyVertexEffects(v.vertex, v.normal, shaderTime);
+	
+
+	float2 uv = v.uv;
+	uv = ApplyUVEffects_VertexStage(uv, o.positionWS, 0, shaderTime);
+	
+	o.mainUV.xy = SIMPLE_CUSTOM_TRANSFORM_TEX(uv, _MainTex);
+	o.positionOS = v.vertex;
+	o.positionWS = GetPositionWS(v.vertex);
+	o.uv2 = v.uvLightmap;
+	o.shaderTime = shaderTime;
+	o.normalOS = v.normal;
+	o.normalWS = GetNormalWS(v.normal);
+
+	
+	o = GetClipPosShadowCaster(v, o);
+
+	return o;
+}
+
+float4 BasicFragmentShadowCaster(FragmentDataShadowCaster i) : SV_Target
+{
+	UNITY_SETUP_INSTANCE_ID(i);
+	UNITY_SETUP_STEREO_EYE_INDEX_POST_VERTEX(i);
+
+
+#if !defined(_CAST_SHADOWS_ON)
+	#if defined(BIRP_PASS)
+		if (unity_LightShadowBias.z != 0.0) discard;
+	#else
+		discard;
+	#endif
+#endif
+	
+	EffectsData data = CalculateEffectsData_ShadowCaster(i);
+	data = ApplyUVEffects_FragmentStage(data);
+
+	float4 col = SAMPLE_TEX2D(_MainTex, i.mainUV.xy);
+
+	
+	float camDistance = distance(i.positionWS, _WorldSpaceCameraPos);
+	
+	float4 screenPos = ComputeScreenPos(i.pos);
+	
+	col = ApplyAlphaEffects(col,
+		i.mainUV, i.uv2, data.vertexWS,
+		1.0, camDistance, screenPos);
+
+	col.a *= ACCESS_PROP_FLOAT(_GeneralAlpha);
+
+	float alphaClip = saturate(col.a);
+#ifdef _ALPHA_CUTOFF_ON
+	alphaClip -= ACCESS_PROP_FLOAT(_AlphaCutoffValue);
+#endif
+
+	clip(alphaClip - 0.001);
+
+	return 0;
+}
+
+#endif

Assets/Plugins/AllIn13DShader/Shaders/ShaderLibrary/AllIn13DShader_ShadowCasterPass.hlsl.meta

@@ -0,0 +1,14 @@
+fileFormatVersion: 2
+guid: 4039a3685bcd9c247ae99b74dc66ca82
+ShaderIncludeImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 316173
+  packageName: All In 1 3D-Shader
+  packageVersion: 2.72
+  assetPath: Assets/Plugins/AllIn13DShader/Shaders/ShaderLibrary/AllIn13DShader_ShadowCasterPass.hlsl
+  uploadId: 865720

Assets/Plugins/AllIn13DShader/Shaders/ShaderLibrary/AllIn13DShader_URP_DepthNormalsPass.hlsl

@@ -0,0 +1,150 @@
+#ifndef ALLIN13DSHADER_URP_DEPTH_NORMALS_PASS_INCLUDED
+#define ALLIN13DSHADER_URP_DEPTH_NORMALS_PASS_INCLUDED
+
+	struct DepthNormalsVertexData
+	{
+		float4 positionOS	: POSITION;
+		float3 normal		: NORMAL;
+		float2 uv			: TEXCOORD0;
+		float2 uvLightmap : TEXCOORD1;
+		float4 tangent		: TANGENT;
+		UNITY_VERTEX_INPUT_INSTANCE_ID
+	};
+
+	struct DepthNormalsFragmentData
+	{
+		float4 positionCS		: SV_POSITION;
+		float3 normalWS			: TEXCOORD1;
+		float4 mainUV			: TEXCOORD2;
+		float4 interpolator_01	: TEXCOORD3;
+		float4 interpolator_02	: TEXCOORD4;
+
+#ifdef REQUIRE_SCENE_DEPTH
+		float4 projPos : TEXCOORD5;
+#endif
+
+		float3 positionWS : TEXCOORD6;
+
+#ifdef REQUIRE_TANGENT_WS
+		T_SPACE_PROPERTIES(7, 8, 9)
+#endif
+
+		UNITY_VERTEX_INPUT_INSTANCE_ID
+		UNITY_VERTEX_OUTPUT_STEREO
+	};
+
+	DepthNormalsFragmentData DepthNormalsVertex(DepthNormalsVertexData input)
+	{
+		DepthNormalsFragmentData o;
+
+		UNITY_SETUP_INSTANCE_ID(input);
+		UNITY_TRANSFER_INSTANCE_ID(input, o);
+		UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(o); 
+
+		
+		o.interpolator_01 = float4(0, 0, 0, 0);
+		o.interpolator_02 = float4(0, 0, 0, 0);
+		o.mainUV = float4(0, 0, 0, 0);
+		SCALED_MAIN_UV(o) = CUSTOM_TRANSFORM_TEX(input.uv, UV_DIFF(o), _MainTex); 
+		UV_LIGHTMAP(o) = input.uvLightmap;
+
+#ifdef _SPHERIZE_NORMALS_ON
+		float3 normalOS = normalize(input.positionOS);
+#else
+		float3 normalOS = input.normal;
+#endif
+		
+#ifdef _USE_CUSTOM_TIME
+		float3 shaderTime = allIn13DShader_globalTime.xyz + ACCESS_PROP_FLOAT(_TimingSeed);
+#else
+		float3 shaderTime = _Time.xyz + ACCESS_PROP_FLOAT(_TimingSeed);
+#endif
+		
+		input.positionOS = ApplyVertexEffects(input.positionOS, normalOS, shaderTime);
+		
+		o.positionCS = TransformObjectToHClip(input.positionOS.xyz);
+		o.normalWS = GetNormalWS(input.normal);
+		o.positionWS = GetPositionWS(input.positionOS);
+
+#if defined(REQUIRE_TANGENT_WS)
+		float3 tangentWS = GetDirWS(float4(input.tangent.xyz, 0));
+		float3 bitangentWS = GetBitangentWS(input.tangent, tangentWS, o.normalWS);
+		INIT_T_SPACE(o.normalWS)
+
+		UV_NORMAL_MAP(o) = CUSTOM_TRANSFORM_TEX(input.uv, UV_DIFF(o), _NormalMap);
+#endif
+
+
+	
+		float4 projPos = 0;
+#ifdef REQUIRE_SCENE_DEPTH
+		o.projPos = ComputeScreenPos(o.positionCS);
+
+		float3 positionWS = GetPositionWS(input.positionOS);
+		o.projPos.z = ComputeEyeDepth(positionWS);
+		projPos = o.projPos;
+#endif
+
+		return o;
+	}
+
+	float4 DepthNormalsFragment(
+		DepthNormalsFragmentData input
+		#ifdef _WRITE_RENDERING_LAYERS
+			#if UNITY_VERSION >= 60020000
+				, out uint outRenderingLayers : SV_Target1
+			#else
+				, out float4 outRenderingLayers : SV_Target1
+			#endif
+		#endif
+	) : SV_TARGET
+	{
+		UNITY_SETUP_INSTANCE_ID(input);
+		UNITY_SETUP_STEREO_EYE_INDEX_POST_VERTEX(input);
+
+		float4 baseColor = SAMPLE_TEX2D(_MainTex, input.mainUV.xy);
+
+		float3 normalWS = normalize(input.normalWS);
+		float4 res = float4(normalWS, 1.0);
+
+		#ifdef _NORMAL_MAP_ON
+			float3 tangentWS = normalize(TANGENT_WS(input));
+			float3 bitangentWS = normalize(cross(normalWS, tangentWS));
+
+			float4 sampledNormal = SAMPLE_TEX2D(_NormalMap, input.mainUV);
+		
+			float3 tnormal = UnpackNormal(sampledNormal);
+			tnormal.xy *= ACCESS_PROP_FLOAT(_NormalStrength); 
+
+			res.x = dot(input.tspace0, tnormal);
+			res.y = dot(input.tspace1, tnormal);
+			res.z = dot(input.tspace2, tnormal);
+    
+			res = normalize(res);
+			res.w = 0;
+		#endif
+
+		float camDistance = distance(input.positionWS, _WorldSpaceCameraPos); 
+		float4 screenPos = ComputeScreenPos(input.positionCS); 
+		baseColor = ApplyAlphaEffects(baseColor, 
+			SCALED_MAIN_UV(input), UV_LIGHTMAP(input), input.positionWS, 
+			1.0, camDistance, screenPos);
+
+		float alphaClip = saturate(baseColor.a);
+		#ifdef _ALPHA_CUTOFF_ON
+			clip((alphaClip - ACCESS_PROP_FLOAT(_AlphaCutoffValue)) - 0.01);
+		#endif
+
+		#if defined(_WRITE_RENDERING_LAYERS)
+			#if UNITY_VERSION >= 60020000
+				outRenderingLayers = EncodeMeshRenderingLayer();
+			#else
+				uint renderingLayers = AllIn1GetMeshRenderingLayer();
+				outRenderingLayers = float4(EncodeMeshRenderingLayer(renderingLayers), 0, 0, 0);
+			#endif
+		#endif
+
+		return res;
+	}
+
+#endif

Assets/Plugins/AllIn13DShader/Shaders/ShaderLibrary/AllIn13DShader_URP_DepthNormalsPass.hlsl.meta

@@ -0,0 +1,14 @@
+fileFormatVersion: 2
+guid: cee3f31d4e663a84c83d7cb65d3af22b
+ShaderIncludeImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 316173
+  packageName: All In 1 3D-Shader
+  packageVersion: 2.72
+  assetPath: Assets/Plugins/AllIn13DShader/Shaders/ShaderLibrary/AllIn13DShader_URP_DepthNormalsPass.hlsl
+  uploadId: 865720

Assets/Plugins/AllIn13DShader/Shaders/ShaderLibrary/AllIn13DShader_URP_DepthOnlyPass.hlsl

@@ -0,0 +1,65 @@
+#ifndef ALLIN13DSHADER_URP_DEPTHONLYPASS
+#define ALLIN13DSHADER_URP_DEPTHONLYPASS
+
+struct DepthOnlyVertexData
+{
+    float4 positionOS     : POSITION;
+	float2 uv : TEXCOORD0;
+	float2 uvLightmap : TEXCOORD1;
+    UNITY_VERTEX_INPUT_INSTANCE_ID
+};
+
+struct DepthOnlyFragmentData
+{
+    float4 positionCS   : SV_POSITION;
+	float3 positionWS : TEXCOORD1;
+	float4 mainUV	: TEXCOORD2;
+	float4 interpolator_01 : TEXCOORD3;
+
+    UNITY_VERTEX_INPUT_INSTANCE_ID
+    UNITY_VERTEX_OUTPUT_STEREO
+};
+
+DepthOnlyFragmentData DepthOnlyVertex(DepthOnlyVertexData input)
+{
+	DepthOnlyFragmentData res;
+
+	UNITY_SETUP_INSTANCE_ID(input);
+	UNITY_TRANSFER_INSTANCE_ID(input, res);
+	UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(res); 
+
+	res.interpolator_01 = float4(0, 0, 0, 0);
+	res.mainUV = float4(0, 0, 0, 0);
+	UV_LIGHTMAP(res) = input.uvLightmap;
+	SCALED_MAIN_UV(res) = CUSTOM_TRANSFORM_TEX(input.uv, UV_DIFF(res), _MainTex);
+
+	res.positionWS = GetPositionWS(input.positionOS);
+	res.positionCS = TransformObjectToHClip(input.positionOS.xyz);
+
+	return res;
+}
+
+float DepthOnlyFragment(DepthOnlyFragmentData input) : SV_TARGET
+{
+	UNITY_SETUP_INSTANCE_ID(input);
+    UNITY_SETUP_STEREO_EYE_INDEX_POST_VERTEX(input);
+	
+	float4 screenPos = ComputeScreenPos(input.positionCS);
+	float camDistance = distance(input.positionWS, _WorldSpaceCameraPos);
+	float4 baseColor = SAMPLE_TEX2D(_MainTex, input.mainUV.xy);
+	baseColor = ApplyAlphaEffects(baseColor, 
+		SCALED_MAIN_UV(input), UV_LIGHTMAP(input), input.positionWS, 
+		1.0, camDistance, screenPos);
+
+	float alphaClip = saturate(baseColor.a);
+	#ifdef _ALPHA_CUTOFF_ON
+		clip((alphaClip - ACCESS_PROP_FLOAT(_AlphaCutoffValue)) - 0.01);
+	#endif
+
+	
+	
+	
+	return input.positionCS.z;
+}
+
+#endif

Assets/Plugins/AllIn13DShader/Shaders/ShaderLibrary/AllIn13DShader_URP_DepthOnlyPass.hlsl.meta

@@ -0,0 +1,14 @@
+fileFormatVersion: 2
+guid: 6ed0ae91c0725fb4fb02d352183233aa
+ShaderIncludeImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 316173
+  packageName: All In 1 3D-Shader
+  packageVersion: 2.72
+  assetPath: Assets/Plugins/AllIn13DShader/Shaders/ShaderLibrary/AllIn13DShader_URP_DepthOnlyPass.hlsl
+  uploadId: 865720

Assets/Plugins/AllIn13DShader/Shaders/ShaderLibrary/AllIn13DShader_URP_MetaPass.hlsl

@@ -0,0 +1,61 @@
+#ifndef ALLIN13DSHADER_URP_METAPASS
+#define ALLIN13DSHADER_URP_METAPASS
+
+struct Attributes
+{
+    float4 positionOS   : POSITION;
+    float3 normalOS     : NORMAL;
+    float2 uv0          : TEXCOORD0;
+    float2 uv1          : TEXCOORD1;
+    float2 uv2          : TEXCOORD2;
+    UNITY_VERTEX_INPUT_INSTANCE_ID
+};
+
+struct Varyings
+{
+    float4 positionCS   : SV_POSITION;
+    float2 uv           : TEXCOORD0;
+#ifdef EDITOR_VISUALIZATION
+    float2 VizUV        : TEXCOORD1;
+    float4 LightCoord   : TEXCOORD2;
+#endif
+};
+
+//#include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/UniversalMetaPass.hlsl"
+#include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/MetaInput.hlsl"
+
+
+Varyings AllIn1VertexMeta(Attributes input)
+{
+    Varyings output = (Varyings)0;
+    output.positionCS = UnityMetaVertexPosition(input.positionOS.xyz, input.uv1, input.uv2);
+    //output.uv = TRANSFORM_TEX(input.uv0, _BaseMap);
+	output.uv = input.uv0;
+#ifdef EDITOR_VISUALIZATION
+    UnityEditorVizData(input.positionOS.xyz, input.uv0, input.uv1, input.uv2, output.VizUV, output.LightCoord);
+#endif
+    return output;
+}
+
+half4 AllIn1FragmentMeta(Varyings input) : SV_Target 
+{
+    float2 uv = input.uv;
+
+    MetaInput metaInput;
+	metaInput.Albedo = ACCESS_PROP_FLOAT4(_Color).rgb * SAMPLE_TEXTURE2D(_MainTex, sampler__MainTex, uv).rgb;
+
+	metaInput.Emission = float3(0, 0, 0);
+#ifdef _EMISSION_ON
+	metaInput.Emission = SAMPLE_TEX2D(_EmissionMap, uv) * ACCESS_PROP_FLOAT4(_EmissionColor) * ACCESS_PROP_FLOAT(_EmissionSelfGlow);
+#endif
+
+#ifdef EDITOR_VISUALIZATION
+    metaInput.VizUV = input.VizUV;
+    metaInput.LightCoord = input.LightCoord;
+#endif
+
+	float4 res = UnityMetaFragment(metaInput);
+	return res;
+}
+
+#endif //Directional Lightmaps

Assets/Plugins/AllIn13DShader/Shaders/ShaderLibrary/AllIn13DShader_URP_MetaPass.hlsl.meta

@@ -0,0 +1,14 @@
+fileFormatVersion: 2
+guid: d65cbf5bc1a04414395a9adf70ae01ba
+ShaderIncludeImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 316173
+  packageName: All In 1 3D-Shader
+  packageVersion: 2.72
+  assetPath: Assets/Plugins/AllIn13DShader/Shaders/ShaderLibrary/AllIn13DShader_URP_MetaPass.hlsl
+  uploadId: 865720

Assets/Plugins/AllIn13DShader/Shaders/ShaderLibrary/AllIn13DShader_UVEffects.hlsl

@@ -0,0 +1,213 @@
+#ifndef ALLIN13DSHADER_UV_EFFECTS
+#define ALLIN13DSHADER_UV_EFFECTS
+
+#ifdef _SCROLL_TEXTURE_ON
+//<EffectsCode id=SCROLL_TEXTURE>
+float2 ScrollTexture(float2 inputUV, float3 shaderTime)
+{
+	float2 res = inputUV;
+
+	res.x += (shaderTime.x * ACCESS_PROP_FLOAT(_ScrollTextureX)) % 1;
+	res.y += (shaderTime.x * ACCESS_PROP_FLOAT(_ScrollTextureY)) % 1;
+
+	return res;
+}
+//</EffectsCode>
+#endif
+
+#ifdef _WAVE_UV_ON
+//<EffectsCode id=WAVE_UV, initial_param_name=initialValue, return_type=float2>
+//<Replace from=res.mainUV to=initialValue>
+EffectsData WaveUV(EffectsData data)
+{
+	EffectsData res = data;
+
+	float2 uvWaveDiff = float2(ACCESS_PROP_FLOAT(_WaveX) * ACCESS_PROP_FLOAT4(_MainTex_ST).x, ACCESS_PROP_FLOAT(_WaveY) * ACCESS_PROP_FLOAT4(_MainTex_ST).y) - res.mainUV;
+	
+	uvWaveDiff.x *= _ScreenParams.x / _ScreenParams.y;
+	float waveTime = data.shaderTime.y;
+	float angWave = (sqrt(dot(uvWaveDiff, uvWaveDiff)) * ACCESS_PROP_FLOAT(_WaveAmount)) - ((waveTime *  ACCESS_PROP_FLOAT(_WaveSpeed) % 360.0));
+
+	uvWaveDiff = normalize(uvWaveDiff) * sin(angWave) * (ACCESS_PROP_FLOAT(_WaveStrength) / 1000.0);
+	DISPLACE_ALL_UVS(res, uvWaveDiff);
+
+	return res;
+}
+//</EffectsCode>
+#endif
+
+#ifdef _SCREEN_SPACE_UV_ON
+float2 ScreenSpaceUV(float2 inputUV, float3 vertexWS, float4 projPos)
+{
+	float2 res = inputUV;
+
+	float aspect = _ScreenParams.x / _ScreenParams.y;
+	
+	float4 pivotCS = OBJECT_TO_CLIP_SPACE_FLOAT4(float4(0, 0, 0, 1)); 
+	pivotCS.xy /= pivotCS.w;
+	pivotCS.y *= -1;
+	pivotCS.xy += 1.0;
+	pivotCS.xy *= 0.5;
+	
+	float3 positionVS = mul(UNITY_MATRIX_V, float4(vertexWS, 1.0)).xyz;
+	
+	float2 screenUV = (projPos.xy / projPos.w);
+	screenUV -= 0.5;
+	screenUV.x *= aspect;
+	
+	
+	float2 screenUVMinusPivot = screenUV - pivotCS.xy;
+	float2 stableUVs = (screenUV - pivotCS.xy + 0.5) * -positionVS.z;
+	stableUVs *= 0.1;
+	
+	res = lerp(screenUV, stableUVs, ACCESS_PROP_FLOAT(_ScaleWithCameraDistance));
+	return res;
+}
+#endif
+
+#ifdef _HAND_DRAWN_ON
+//<EffectsCode id=HAND_DRAWN>
+float2 HandDrawn(float2 inputUV, float3 shaderTime)
+{
+	float2 uvCopy = inputUV;
+	float2 res = inputUV;
+
+
+	float drawnSpeed = (floor(frac(shaderTime.x) * 20 * ACCESS_PROP_FLOAT(_HandDrawnSpeed)) / ACCESS_PROP_FLOAT(_HandDrawnSpeed)) * ACCESS_PROP_FLOAT(_HandDrawnSpeed);
+	uvCopy.x = sin((uvCopy.x * ACCESS_PROP_FLOAT(_HandDrawnAmount) + drawnSpeed) * 4);
+	uvCopy.y = cos((uvCopy.y * ACCESS_PROP_FLOAT(_HandDrawnAmount) + drawnSpeed) * 4);
+	res = lerp(res, res + uvCopy, 0.0005 * ACCESS_PROP_FLOAT(_HandDrawnAmount));
+	
+	return res;
+}
+//</EffectsCode>
+#endif
+
+
+#ifdef _TRIPLANAR_MAPPING_ON
+EffectsData TriplanarMapping(EffectsData input)
+{
+	EffectsData res = input;
+
+	float2 uvDiff = input.uvDiff;
+
+	#ifdef _TRIPLANARNORMALSPACE_LOCAL
+		float3 normal = res.normalOS;
+		float3 position = res.vertexOS;
+	#else
+		float3 normal = res.normalWS;
+		float3 position = res.vertexWS;
+
+		uvDiff *= 10.0;
+	#endif
+
+	float3 triplanarWeights = GetTriplanarWeights(normal, input.mainUV);
+
+	float2 positionXY = position.xy;
+	float2 positionZY = position.zy;
+	float2 positionXZ = position.xz;
+
+	res.uvMatrix._m00_m01 = CUSTOM_TRANSFORM_TEX(positionXY, uvDiff, _MainTex); //Front
+	res.uvMatrix._m02 = triplanarWeights.z;
+
+	res.uvMatrix._m10_m11 = CUSTOM_TRANSFORM_TEX(positionZY, uvDiff, _MainTex); //Side
+	res.uvMatrix._m12 = triplanarWeights.x;
+
+	res.uvMatrix._m20_m21 = CUSTOM_TRANSFORM_TEX(positionXZ, uvDiff, _TriplanarTopTex); //Top
+	res.uvMatrix._m22 = triplanarWeights.y;
+
+	res.uvMatrix._m30_m31 = CUSTOM_TRANSFORM_TEX(positionXZ, uvDiff, _MainTex); //Down
+	res.uvMatrix._m32 = 1 - normal.y;
+
+#ifdef _NORMAL_MAP_ON
+	float2 frontUV_normal_Z = CUSTOM_TRANSFORM_TEX(position.xy, uvDiff, _MainTex); //Front - Z facing plane
+	float2 sideUV_normal_X = CUSTOM_TRANSFORM_TEX(position.zy, uvDiff, _MainTex); //Side - X facing plane
+	float2 topUV_normal_Y = CUSTOM_TRANSFORM_TEX(position.xz, uvDiff, _TriplanarTopTex); //Top - Y facing plane
+
+	res.uv_matrix_normalMap._m00_m01 = frontUV_normal_Z; //Front
+	res.uv_matrix_normalMap._m02 = triplanarWeights.z;
+
+	res.uv_matrix_normalMap._m10_m11 = sideUV_normal_X; //Side
+	res.uv_matrix_normalMap._m12 = triplanarWeights.x;
+
+	res.uv_matrix_normalMap._m20_m21 = topUV_normal_Y; //Top
+	res.uv_matrix_normalMap._m22 = triplanarWeights.y;
+#endif
+
+	return res;
+}
+#endif
+
+#ifdef _UV_DISTORTION_ON
+//<EffectsCode id=UV_DISTORTION, initial_param_name=initialValue, return_type=float2>
+EffectsData UVDistortion(EffectsData data)
+{
+	EffectsData res = data;
+	
+	float2 distortTexUV = data.uv_dist;
+	
+	distortTexUV.x += frac((data.shaderTime.x) * ACCESS_PROP_FLOAT(_DistortTexXSpeed));
+	distortTexUV.y += frac((data.shaderTime.x) * ACCESS_PROP_FLOAT(_DistortTexYSpeed));
+	
+	float4 distortTexCol = SAMPLE_TEX2D_LOD(_DistortTex, float4(distortTexUV.x, distortTexUV.y, 0, 0));
+	float distortAmnt = (distortTexCol.r - 0.5) * 0.2 * ACCESS_PROP_FLOAT(_DistortAmount);
+	
+	DISPLACE_ALL_UVS(res, distortAmnt);
+
+	return res;
+}
+//</EffectsCode>
+#endif
+
+#ifdef _PIXELATE_ON
+//<EffectsCode id=PIXELATE, initial_param_name=initialValue, return_type=float2>
+EffectsData Pixelate(EffectsData data)
+{
+	EffectsData res = data;
+
+	half aspectRatio = ACCESS_PROP_FLOAT4(_MainTex_TexelSize).x / ACCESS_PROP_FLOAT4(_MainTex_TexelSize).y;
+	half2 pixelSize = float2(ACCESS_PROP_FLOAT(_PixelateSize), ACCESS_PROP_FLOAT(_PixelateSize) * aspectRatio);
+	
+	QUANTIZE_ALL_UVS(res, pixelSize)
+	return res;
+}
+//</EffectsCode>
+#endif
+
+//#ifdef _STOCHASTIC_SAMPLING_ON
+//EffectsData StochasticSamplingOn(EffectsData data)
+//{
+//	EffectsData res = data;
+	
+//	float2 UV = MAIN_UV(data);
+	
+//	//triangle vertices and blend weights
+//	//BW_vx[0...2].xyz = triangle verts
+//	//BW_vx[3].xy = blend weights (z is unused)
+//	float4x3 BW_vx;
+ 
+//	//uv transformed into triangular grid space with UV scaled by approximation of 2*sqrt(3)
+//	float2 skewUV = mul(float2x2 (1.0 , 0.0 , -0.57735027 , 1.15470054), UV * 3.464);
+ 
+//	//vertex IDs and barycentric coords
+//	float2 vxID = float2 (floor(skewUV));
+//	float3 barry = float3 (frac(skewUV), 0);
+//	barry.z = 1.0-barry.x-barry.y;
+ 
+//	BW_vx = ((barry.z>0) ? 
+//		float4x3(float3(vxID, 0), float3(vxID + float2(0, 1), 0), float3(vxID + float2(1, 0), 0), barry.zyx) :
+//		float4x3(float3(vxID + float2 (1, 1), 0), float3(vxID + float2 (1, 0), 0), float3(vxID + float2 (0, 1), 0), float3(-barry.z, 1.0-barry.y, 1.0-barry.x)));
+ 
+//	//calculate derivatives to avoid triangular grid artifacts
+//	float2 dx = ddx(UV);
+//	float2 dy = ddy(UV);
+ 
+//	float4 newUVs = mul(tex2D(tex, UV + hash2D2D(BW_vx[0].xy), dx, dy), BW_vx[3].x) +
+//			mul(tex2D(tex, UV + hash2D2D(BW_vx[1].xy), dx, dy), BW_vx[3].y) + 
+//			mul(tex2D(tex, UV + hash2D2D(BW_vx[2].xy), dx, dy), BW_vx[3].z);
+
+//	return res;
+//}
+//#endif
+
+#endif

Assets/Plugins/AllIn13DShader/Shaders/ShaderLibrary/AllIn13DShader_UVEffects.hlsl.meta

@@ -0,0 +1,14 @@
+fileFormatVersion: 2
+guid: d61ca1c3b2921b4458b28e3b02288808
+ShaderIncludeImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 316173
+  packageName: All In 1 3D-Shader
+  packageVersion: 2.72
+  assetPath: Assets/Plugins/AllIn13DShader/Shaders/ShaderLibrary/AllIn13DShader_UVEffects.hlsl
+  uploadId: 865720

Assets/Plugins/AllIn13DShader/Shaders/ShaderLibrary/AllIn13DShader_VertexEffects.hlsl

@@ -0,0 +1,138 @@
+#ifndef ALLIN13DSHADER_VERTEX_EFFECTS
+#define ALLIN13DSHADER_VERTEX_EFFECTS
+
+#ifdef _VERTEX_SHAKE_ON
+float3 VertexShake(float3 vertexPos, float3 shaderTime)
+{
+	float3 res = vertexPos;
+    
+	float3 speedOffset = float3(1.0f, 1.13f, 1.07f) * ACCESS_PROP_FLOAT(_ShakeSpeedMult);
+	float3 displacement = sin(shaderTime.y * ACCESS_PROP_FLOAT4(_ShakeSpeed).xyz * speedOffset) * ACCESS_PROP_FLOAT4(_ShakeMaxDisplacement).xyz;
+	displacement *= ACCESS_PROP_FLOAT(_ShakeBlend);
+    
+	res += displacement;
+
+	return res;
+}
+#endif
+
+#ifdef _VERTEX_INFLATE_ON
+float3 VertexInflate(float3 vertexPos, float3 normalOS, float3 shaderTime)
+{
+	float3 res = vertexPos;
+
+	float inflateValue = lerp(ACCESS_PROP_FLOAT(_MinInflate), ACCESS_PROP_FLOAT(_MaxInflate), ACCESS_PROP_FLOAT(_InflateBlend));
+	res += normalOS * inflateValue;
+	
+	return res;
+}
+#endif
+
+#ifdef _VERTEX_DISTORTION_ON
+float3 VertexDistortion(float3 vertexPos, float3 normalOS, float3 shaderTime)
+{
+	float3 res = vertexPos;
+	
+	float noisePower = 1.0;
+
+	float2 noiseUV = SIMPLE_CUSTOM_TRANSFORM_TEX(vertexPos.xy, _VertexDistortionNoiseTex);
+	float4 correctedNoiseUV = float4(noiseUV.x, noiseUV.y, 0, 0);
+	
+	correctedNoiseUV.x += frac(shaderTime.x * ACCESS_PROP_FLOAT(_VertexDistortionNoiseSpeedX));
+	correctedNoiseUV.y += frac(shaderTime.x * ACCESS_PROP_FLOAT(_VertexDistortionNoiseSpeedY));
+
+	noisePower = SAMPLE_TEX2D_LOD(_VertexDistortionNoiseTex, correctedNoiseUV).r;
+
+	res += normalOS * noisePower * ACCESS_PROP_FLOAT(_VertexDistortionAmount);
+	
+	return res;
+}
+#endif
+
+#ifdef _VOXELIZE_ON
+float3 VertexVoxel(float3 vertexPos)
+{
+	float3 voxelizedPosition = round(vertexPos * ACCESS_PROP_FLOAT(_VoxelSize)) / ACCESS_PROP_FLOAT(_VoxelSize);
+	return lerp(vertexPos, voxelizedPosition, ACCESS_PROP_FLOAT(_VoxelBlend));
+}
+#endif
+
+#ifdef _GLITCH_ON
+float3 Glitch(float3 vertexPos, float3 shaderTime)
+{
+	float3 res = vertexPos;
+
+	float3 glitchDir = GetDirOSFloat3(ACCESS_PROP_FLOAT3(_GlitchOffset));
+
+	float3 scale = float3(length(OBJECT_TO_WORLD_MATRIX[0].xyz),
+					length(OBJECT_TO_WORLD_MATRIX[1].xyz),
+					length(OBJECT_TO_WORLD_MATRIX[2].xyz));
+	float pos = ACCESS_PROP_FLOAT(_GlitchWorldSpace) ? mul(OBJECT_TO_WORLD_MATRIX, float4(vertexPos, 1.0)).y : vertexPos.y;
+	float time = shaderTime.y * ACCESS_PROP_FLOAT(_GlitchSpeed);
+	
+	// Add high frequency noise to the main UV
+    float2 glitchUV = float2(pos * ACCESS_PROP_FLOAT(_GlitchTiling) + time, time * 0.89);
+    float mainNoise = noise2D(glitchUV);
+    float fastNoise = noise2D(glitchUV * 2.5 + float2(time * 3.7, 0));
+    mainNoise = mainNoise * 0.6 + fastNoise * 0.4;
+
+	float2 periodicUV = float2(time * 0.5, time * 0.14);
+    float periodicNoise = saturate(noise2D(periodicUV) + 0.1);
+                
+    float detailNoise = noise2D(float2(20.0 * glitchUV.x, glitchUV.y));
+                
+    float glitchValue = (2.0 * mainNoise - 1.0) * periodicNoise;
+    glitchValue += glitchValue * lerp(0, saturate(2.0 * detailNoise - 1.0), 2.0);
+
+	res += (glitchDir / scale) * glitchValue * ACCESS_PROP_FLOAT(_GlitchAmount);
+
+	return res;
+}
+#endif
+
+#ifdef _RECALCULATE_NORMALS_ON
+float3 RecalculateNormal(float3 originalVertex, float3 normal, float3 tangent)
+{
+	return normal;
+}
+#endif
+
+#ifdef _WIND_ON
+float3 Wind(float3 vertexPos, float3 shaderTime)
+{
+	float3 res = vertexPos;
+
+	float windMask = 1.0;
+	#ifdef _USE_WIND_VERTICAL_MASK
+	windMask = RemapFloat(vertexPos.y, ACCESS_PROP_FLOAT(_WindVerticalMaskMinY), ACCESS_PROP_FLOAT(_WindVerticalMaskMaxY), 0, 1);
+	#endif
+
+	float3 vertexWS = GetPositionWS(float4(vertexPos, 1.0));
+	
+	float2 windNoiseUV = float2(vertexWS.x, vertexWS.z) / global_windWorldSize;
+	windNoiseUV += global_noiseSpeed * shaderTime.x; 
+	windNoiseUV = frac(windNoiseUV);
+
+	float3 windNoise = SAMPLE_TEX2D_LOD(global_windNoiseTex, float4(windNoiseUV.x, windNoiseUV.y, 0, 0));
+	windNoise = RemapFloat3(windNoise, 0, 1, global_minWindValue, global_maxWindValue);
+	
+	if(global_useWindDir)
+	{
+		windNoise = (windNoise.x + windNoise.y + windNoise.z) / 3;
+	}
+
+	float3 windDisplacement = windNoise * global_windForce * windMask * global_windDir;
+	windDisplacement = lerp(0, windDisplacement, ACCESS_PROP_FLOAT(_WindAttenuation));
+
+	windDisplacement.y = 0;
+	
+	float3 positionWS = GetPositionWS(float4(res, 1.0));
+	positionWS += windDisplacement;
+	
+	res = GetPositionOS(float4(positionWS, 1.0));
+	
+	return res;
+}
+#endif
+
+#endif

Assets/Plugins/AllIn13DShader/Shaders/ShaderLibrary/AllIn13DShader_VertexEffects.hlsl.meta

@@ -0,0 +1,14 @@
+fileFormatVersion: 2
+guid: 6d625c6ff0d698c4cad5f90150312f70
+ShaderIncludeImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 316173
+  packageName: All In 1 3D-Shader
+  packageVersion: 2.72
+  assetPath: Assets/Plugins/AllIn13DShader/Shaders/ShaderLibrary/AllIn13DShader_VertexEffects.hlsl
+  uploadId: 865720