Hässliche reuden ranz Map-Begrenzung

3d Prototyp/Assets/AssetPacks/Barrier Pack/Shaders/Contrast Stretch.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: a40c1b84cf7fe418bae97a29041b85a4

3d Prototyp/Assets/AssetPacks/Barrier Pack/Shaders/Contrast Stretch/Adaptation.shader

@@ -0,0 +1,68 @@
+// Calculates adaptation to minimum/maximum luminance values,
+// based on "currently adapted" and "new values to adapt to"
+// textures (both 1x1).
+
+Shader "Hidden/Contrast Stretch Adaptation" {
+Properties {
+	_MainTex ("Base (RGB)", 2D) = "white" {}
+	_CurTex ("Base (RGB)", 2D) = "white" {}
+}
+
+Category {
+	SubShader {
+		Pass {
+			ZTest Always Cull Off ZWrite Off
+				
+CGPROGRAM
+#pragma vertex vert_img
+#pragma fragment frag
+#include "UnityCG.cginc"
+
+uniform sampler2D _MainTex; // currently adapted to
+uniform sampler2D _CurTex; // new value to adapt to
+uniform float4 _AdaptParams; // x=adaptLerp, y=limitMinimum, z=limitMaximum
+
+float4 frag (v2f_img i) : SV_Target  {
+	// value is: max, min
+	float2 valAdapted = tex2D(_MainTex, i.uv).xy;
+	float2 valCur = tex2D(_CurTex, i.uv).xy;
+	
+	// Calculate new adapted values: interpolate
+	// from valAdapted to valCur by script-supplied amount.
+	//
+	// Because we store adaptation levels in a simple 8 bit/channel
+	// texture, we might not have enough precision - the interpolation
+	// amount might be too small to change anything, and we'll never
+	// arrive at the needed values.
+	//
+	// So we make sure the change we do is at least 1/255th of the
+	// color range - this way we'll always change the value.
+	const float kMinChange = 1.0/255.0;
+	float2 delta = (valCur-valAdapted) * _AdaptParams.x;
+	delta.x = sign(delta.x) * max( kMinChange, abs(delta.x) );
+	delta.y = sign(delta.y) * max( kMinChange, abs(delta.y) );
+
+	float4 valNew;
+	valNew.xy = valAdapted + delta;
+	
+	// Impose user limits on maximum/minimum values
+	valNew.x = max( valNew.x, _AdaptParams.z );
+	valNew.y = min( valNew.y, _AdaptParams.y );
+	
+	// Optimization so that our final apply pass is faster:
+	// z = max-min (plus a small amount to prevent division by zero)
+	valNew.z = valNew.x - valNew.y + 0.01;
+	// w = min/(max-min)
+	valNew.w = valNew.y / valNew.z;
+	
+	return valNew;
+}
+ENDCG
+
+		}
+	}
+}
+
+Fallback off
+
+}

3d Prototyp/Assets/AssetPacks/Barrier Pack/Shaders/Contrast Stretch/Adaptation.shader.meta

@@ -0,0 +1,4 @@
+fileFormatVersion: 2
+guid: 257bc83cbeb544540bd0e558aa9b1383
+ShaderImporter:
+  userData: 

3d Prototyp/Assets/AssetPacks/Barrier Pack/Shaders/Contrast Stretch/Apply.shader

@@ -0,0 +1,57 @@
+// Upgrade NOTE: replaced 'mul(UNITY_MATRIX_MVP,*)' with 'UnityObjectToClipPos(*)'
+
+// Final pass in the contrast stretch effect: apply
+// color stretch to the original image, based on currently
+// adapted to minimum/maximum luminances.
+
+Shader "Hidden/Contrast Stretch Apply" {
+Properties {
+	_MainTex ("Base (RGB)", 2D) = "white" {}
+	_AdaptTex ("Base (RGB)", 2D) = "white" {}
+}
+
+Category {
+	SubShader {
+		Pass {
+			ZTest Always Cull Off ZWrite Off
+				
+CGPROGRAM
+#pragma vertex vert
+#pragma fragment frag
+#include "UnityCG.cginc"
+
+struct v2f {
+	float4 pos		: SV_POSITION;
+	float2 uv[2]	: TEXCOORD0;
+}; 
+
+uniform sampler2D _MainTex;
+uniform sampler2D _AdaptTex;
+
+v2f vert (appdata_img v)
+{
+	v2f o;
+	o.pos = UnityObjectToClipPos (v.vertex);
+	o.uv[0] = MultiplyUV (UNITY_MATRIX_TEXTURE0, v.texcoord);
+	o.uv[1] = float2(0.5,0.5);
+	return o;
+}
+
+float4 frag (v2f i) : SV_Target
+{
+	float4 col = tex2D(_MainTex, i.uv[0]);
+	float4 adapted = tex2D(_AdaptTex, i.uv[1]);
+	float vmul = 1.0 / adapted.z;
+	float vadd = -adapted.w;
+	col.rgb = col.rgb * vmul + vadd;	
+	return col;
+}
+ENDCG
+
+		}
+	}
+}
+
+Fallback off
+
+}

3d Prototyp/Assets/AssetPacks/Barrier Pack/Shaders/Contrast Stretch/Apply.shader.meta

@@ -0,0 +1,4 @@
+fileFormatVersion: 2
+guid: f4901f25d4e1542589348bbb89563d8e
+ShaderImporter:
+  userData: 

3d Prototyp/Assets/AssetPacks/Barrier Pack/Shaders/Contrast Stretch/Luminance.shader

@@ -0,0 +1,35 @@
+// Outputs luminance (grayscale) of the input image _MainTex
+
+Shader "Hidden/Contrast Stretch Luminance" {
+	
+Properties {
+	_MainTex ("Base (RGB)", 2D) = "white" {}
+}
+
+Category {
+	SubShader {
+		Pass {
+			ZTest Always Cull Off ZWrite Off
+				
+CGPROGRAM
+#pragma vertex vert_img
+#pragma fragment frag
+#include "UnityCG.cginc"
+
+uniform sampler2D _MainTex;
+
+float4 frag (v2f_img i) : SV_Target
+{
+	float4 col = tex2D(_MainTex, i.uv);
+	col.rgb = Luminance(col.rgb) * (1+col.a*2);
+	return col;
+}
+ENDCG
+
+		}
+	}
+}
+
+Fallback off
+
+}

3d Prototyp/Assets/AssetPacks/Barrier Pack/Shaders/Contrast Stretch/Luminance.shader.meta

@@ -0,0 +1,4 @@
+fileFormatVersion: 2
+guid: befbb4b9c320b4b18a08ef7afb93b6c9
+ShaderImporter:
+  userData: 

3d Prototyp/Assets/AssetPacks/Barrier Pack/Shaders/Contrast Stretch/MinMaxReduction.shader

@@ -0,0 +1,67 @@
+// Upgrade NOTE: replaced 'mul(UNITY_MATRIX_MVP,*)' with 'UnityObjectToClipPos(*)'
+
+// Reduces input image (_MainTex) by 2x2.
+// Outputs maximum value in R, minimum in G.
+Shader "Hidden/Contrast Stretch Reduction" {
+
+Properties {
+	_MainTex ("Base (RGB)", 2D) = "white" {}
+}
+
+Category {
+	SubShader {
+		Pass {
+			ZTest Always Cull Off ZWrite Off
+				
+CGPROGRAM
+#pragma vertex vert
+#pragma fragment frag
+#include "UnityCG.cginc"
+
+struct v2f { 
+	float4 position : SV_POSITION;  
+	float2 uv[4]    : TEXCOORD0;
+}; 
+
+uniform sampler2D _MainTex;
+
+v2f vert (appdata_img v) {
+	v2f o;
+	o.position = UnityObjectToClipPos (v.vertex);
+	float2 uv = MultiplyUV (UNITY_MATRIX_TEXTURE0, v.texcoord);
+	
+	// Compute UVs to sample 2x2 pixel block.
+	o.uv[0] = uv + float2(0,0);
+	o.uv[1] = uv + float2(0,1);
+	o.uv[2] = uv + float2(1,0);
+	o.uv[3] = uv + float2(1,1);
+	return o;
+}
+
+float4 frag (v2f i) : SV_Target
+{
+	// Sample pixel block
+	float4 v00 = tex2D(_MainTex, i.uv[0]);
+	float2 v01 = tex2D(_MainTex, i.uv[1]).xy;
+	float2 v10 = tex2D(_MainTex, i.uv[2]).xy;
+	float2 v11 = tex2D(_MainTex, i.uv[3]).xy;
+	
+	float4 res;
+	// output x: maximum of the four values
+	res.x = max( max(v00.x,v01.x), max(v10.x,v11.x) );
+	// output y: minimum of the four values
+	res.y = min( min(v00.y,v01.y), min(v10.y,v11.y) );
+	// output zw unchanged from the first pixel
+	res.zw = v00.zw;
+	
+	return res;
+}
+ENDCG
+
+		}
+	}
+}
+
+Fallback off
+
+}

3d Prototyp/Assets/AssetPacks/Barrier Pack/Shaders/Contrast Stretch/MinMaxReduction.shader.meta

@@ -0,0 +1,4 @@
+fileFormatVersion: 2
+guid: 57b33a14b6d5347c5a85c36f6cb3b280
+ShaderImporter:
+  userData: 

3d Prototyp/Assets/AssetPacks/Barrier Pack/Shaders/GlobalFog.shader

@@ -0,0 +1,188 @@
+// Upgrade NOTE: replaced 'mul(UNITY_MATRIX_MVP,*)' with 'UnityObjectToClipPos(*)'
+
+Shader "Hidden/GlobalFog" {
+Properties {
+	_MainTex ("Base (RGB)", 2D) = "black" {}
+}
+
+CGINCLUDE
+
+	#include "UnityCG.cginc"
+
+	uniform sampler2D _MainTex;
+	uniform sampler2D_float _CameraDepthTexture;
+	
+	// x = fog height
+	// y = FdotC (CameraY-FogHeight)
+	// z = k (FdotC > 0.0)
+	// w = a/2
+	uniform float4 _HeightParams;
+	
+	// x = start distance
+	uniform float4 _DistanceParams;
+	
+	int4 _SceneFogMode; // x = fog mode, y = use radial flag
+	float4 _SceneFogParams;
+	#ifndef UNITY_APPLY_FOG
+	half4 unity_FogColor;
+	half4 unity_FogDensity;
+	#endif	
+
+	uniform float4 _MainTex_TexelSize;
+	
+	// for fast world space reconstruction
+	uniform float4x4 _FrustumCornersWS;
+	uniform float4 _CameraWS;
+
+	struct v2f {
+		float4 pos : SV_POSITION;
+		float2 uv : TEXCOORD0;
+		float2 uv_depth : TEXCOORD1;
+		float4 interpolatedRay : TEXCOORD2;
+	};
+	
+	v2f vert (appdata_img v)
+	{
+		v2f o;
+		half index = v.vertex.z;
+		v.vertex.z = 0.1;
+		o.pos = UnityObjectToClipPos(v.vertex);
+		o.uv = v.texcoord.xy;
+		o.uv_depth = v.texcoord.xy;
+		
+		#if UNITY_UV_STARTS_AT_TOP
+		if (_MainTex_TexelSize.y < 0)
+			o.uv.y = 1-o.uv.y;
+		#endif				
+		
+		o.interpolatedRay = _FrustumCornersWS[(int)index];
+		o.interpolatedRay.w = index;
+		
+		return o;
+	}
+	
+	// Applies one of standard fog formulas, given fog coordinate (i.e. distance)
+	half ComputeFogFactor (float coord)
+	{
+		float fogFac = 0.0;
+		if (_SceneFogMode.x == 1) // linear
+		{
+			// factor = (end-z)/(end-start) = z * (-1/(end-start)) + (end/(end-start))
+			fogFac = coord * _SceneFogParams.z + _SceneFogParams.w;
+		}
+		if (_SceneFogMode.x == 2) // exp
+		{
+			// factor = exp(-density*z)
+			fogFac = _SceneFogParams.y * coord; fogFac = exp2(-fogFac);
+		}
+		if (_SceneFogMode.x == 3) // exp2
+		{
+			// factor = exp(-(density*z)^2)
+			fogFac = _SceneFogParams.x * coord; fogFac = exp2(-fogFac*fogFac);
+		}
+		return saturate(fogFac);
+	}
+
+	// Distance-based fog
+	float ComputeDistance (float3 camDir, float zdepth)
+	{
+		float dist; 
+		if (_SceneFogMode.y == 1)
+			dist = length(camDir);
+		else
+			dist = zdepth * _ProjectionParams.z;
+		// Built-in fog starts at near plane, so match that by
+		// subtracting the near value. Not a perfect approximation
+		// if near plane is very large, but good enough.
+		dist -= _ProjectionParams.y;
+		return dist;
+	}
+
+	// Linear half-space fog, from https://www.terathon.com/lengyel/Lengyel-UnifiedFog.pdf
+	float ComputeHalfSpace (float3 wsDir)
+	{
+		float3 wpos = _CameraWS + wsDir;
+		float FH = _HeightParams.x;
+		float3 C = _CameraWS;
+		float3 V = wsDir;
+		float3 P = wpos;
+		float3 aV = _HeightParams.w * V;
+		float FdotC = _HeightParams.y;
+		float k = _HeightParams.z;
+		float FdotP = P.y-FH;
+		float FdotV = wsDir.y;
+		float c1 = k * (FdotP + FdotC);
+		float c2 = (1-2*k) * FdotP;
+		float g = min(c2, 0.0);
+		g = -length(aV) * (c1 - g * g / abs(FdotV+1.0e-5f));
+		return g;
+	}
+
+	half4 ComputeFog (v2f i, bool distance, bool height) : SV_Target
+	{
+		half4 sceneColor = tex2D(_MainTex, i.uv);
+		
+		// Reconstruct world space position & direction
+		// towards this screen pixel.
+		float rawDepth = SAMPLE_DEPTH_TEXTURE(_CameraDepthTexture,i.uv_depth);
+		float dpth = Linear01Depth(rawDepth);
+		float4 wsDir = dpth * i.interpolatedRay;
+		float4 wsPos = _CameraWS + wsDir;
+
+		// Compute fog distance
+		float g = _DistanceParams.x;
+		if (distance)
+			g += ComputeDistance (wsDir, dpth);
+		if (height)
+			g += ComputeHalfSpace (wsDir);
+
+		// Compute fog amount
+		half fogFac = ComputeFogFactor (max(0.0,g));
+		// Do not fog skybox
+		if (rawDepth >= 0.999999)
+			fogFac = 1.0;
+		//return fogFac; // for debugging
+		
+		// Lerp between fog color & original scene color
+		// by fog amount
+		return lerp (unity_FogColor, sceneColor, fogFac);
+	}
+
+ENDCG
+
+SubShader
+{
+	ZTest Always Cull Off ZWrite Off Fog { Mode Off }
+
+	// 0: distance + height
+	Pass
+	{
+		CGPROGRAM
+		#pragma vertex vert
+		#pragma fragment frag
+		half4 frag (v2f i) : SV_Target { return ComputeFog (i, true, true); }
+		ENDCG
+	}
+	// 1: distance
+	Pass
+	{
+		CGPROGRAM
+		#pragma vertex vert
+		#pragma fragment frag
+		half4 frag (v2f i) : SV_Target { return ComputeFog (i, true, false); }
+		ENDCG
+	}
+	// 2: height
+	Pass
+	{
+		CGPROGRAM
+		#pragma vertex vert
+		#pragma fragment frag
+		half4 frag (v2f i) : SV_Target { return ComputeFog (i, false, true); }
+		ENDCG
+	}
+}
+
+Fallback off
+
+}

3d Prototyp/Assets/AssetPacks/Barrier Pack/Shaders/GlobalFog.shader.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: 70d8568987ac0499f952b54c7c13e265
+timeCreated: 1488827370
+licenseType: Store
+ShaderImporter:
+  defaultTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: