Add files using upload-large-folder tool

kujiale_0042/Materials/OmniUe4Function.mdl

@@ -1,1413 +1,3 @@
-/***************************************************************************************************
- * Copyright 2020 NVIDIA Corporation. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- *  * Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- *  * Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *  * Neither the name of NVIDIA CORPORATION nor the names of its
- *    contributors may be used to endorse or promote products derived
- *    from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
- * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
- * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
- * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- **************************************************************************************************/
-
-//* 1.0.1 - using absolute import paths when importing standard modules
-
-mdl 1.6;
-
-import ::df::*;
-import ::state::*;
-import ::math::*;
-import ::tex::*;
-import ::anno::*;
-
-
-export float3 convert_to_left_hand(float3 vec3, uniform bool up_z = true, uniform bool is_position = true)
-[[
-    anno::description("convert from RH to LH"),
-	anno::noinline()
-]]
-{
-	float4x4 ZupConversion = float4x4(
-		1.0f, 0.0f, 0.0f, 0.0f,
-		0.0f, -1.0f, 0.0f, 0.0f,
-		0.0f, 0.0f, 1.0f, 0.0f,
-		0.0f, 0.0f, 0.0f, 1.0f
-	);
-
-	float4x4 YupConversion = float4x4(
-		1.0f, 0.0f, 0.0f, 0.0f,
-		0.0f, 0.0f, 1.0f, 0.0f,
-		0.0f, 1.0f, 0.0f, 0.0f,
-		0.0f, 0.0f, 0.0f, 1.0f
-	);
-
-	float4 vec4 = float4(vec3.x, vec3.y, vec3.z, is_position ? 1.0f : 0.0f);
-
-	vec4 = vec4 * (up_z ? ZupConversion : YupConversion);
-
-	return float3(vec4.x, vec4.y, vec4.z);
-}
-
-export float3 transform_vector_from_tangent_to_world(float3 vector, 
-													uniform bool up_z = true, 
-													float3 tangent_u = state::texture_tangent_u(0),
-    												float3 tangent_v = state::texture_tangent_v(0))
-[[
-    anno::description("Transform vector from tangent space to world space"),
-    anno::noinline()
-]]
-{
-	/* flip_tangent_v */
-    return  convert_to_left_hand(
-			tangent_u * vector.x - tangent_v * vector.y + state::normal() * vector.z, 
-			up_z, false);
-}
-
-export float3 transform_vector_from_world_to_tangent(float3 vector, 
-													uniform bool up_z = true,
-													float3 tangent_u = state::texture_tangent_u(0),
-													float3 tangent_v = state::texture_tangent_v(0))
-[[
-    anno::description("Transform vector from world space to tangent space"),
-    anno::noinline()
-]]
-{
-	float3 vecRH = convert_to_left_hand(vector, up_z, false);
-	/* flip_tangent_v */
-	return 	vecRH.x * float3(tangent_u.x, -tangent_v.x, state::normal().x) +
-        	vecRH.y * float3(tangent_u.y, -tangent_v.y, state::normal().y) +
-        	vecRH.z * float3(tangent_u.z, -tangent_v.z, state::normal().z);
-}
-
-export float4 unpack_normal_map(
-    float4 texture_sample = float4(0.0, 0.0, 1.0, 1.0)
-    )
-[[
-    anno::description("Unpack a normal stored in a normal map"),
-    anno::noinline()
-]]
-{
-    float2 normal_xy = float2(texture_sample.x, texture_sample.y);
-
-	normal_xy = normal_xy * float2(2.0,2.0) - float2(1.0,1.0);
-	float normal_z = math::sqrt( math::saturate( 1.0 - math::dot( normal_xy, normal_xy ) ) );
-	return float4( normal_xy.x, normal_xy.y, normal_z, 1.0 );
-}
-
-// for get color value from normal.
-export float4 pack_normal_map(
-    float4 texture_sample = float4(0.0, 0.0, 1.0, 1.0)
-    )
-[[
-    anno::description("Pack to color from a normal")
-]]
-{
-    float2 return_xy = float2(texture_sample.x, texture_sample.y);
-
-	return_xy = (return_xy + float2(1.0,1.0)) / float2(2.0,2.0);
-	
-	return float4( return_xy.x, return_xy.y, 0.0, 1.0 );
-}
-
-export float4 greyscale_texture_lookup(
-    float4 texture_sample = float4(0.0, 0.0, 0.0, 1.0)
-    )
-[[
-    anno::description("Sampling a greyscale texture"),
-    anno::noinline()
-]]
-{
-    return float4(texture_sample.x, texture_sample.x, texture_sample.x, texture_sample.x);
-}     
-
-export float3 pixel_normal_world_space(uniform bool up_z = true)
-[[
-    anno::description("Pixel normal in world space"),
-    anno::noinline()
-]]
-{
-    return convert_to_left_hand(state::transform_normal(state::coordinate_internal,state::coordinate_world,state::normal()), up_z, false);
-}
-
-export float3 vertex_normal_world_space(uniform bool up_z = true)
-[[
-    anno::description("Vertex normal in world space"),
-    anno::noinline()
-]]
-{
-    return convert_to_left_hand(state::transform_normal(state::coordinate_internal,state::coordinate_world,state::normal()), up_z, false);
-}
-
-export float3 landscape_normal_world_space(uniform bool up_z = true)
-[[
-    anno::description("Landscape normal in world space")
-]]
-{
-	float3 normalFromNormalmap = math::floor((::vertex_normal_world_space(up_z) * 0.5 + 0.5) * 255.0) / 255.0 * 2.0 - 1.0;
-	
-	float2 normalXY = float2(normalFromNormalmap.x, normalFromNormalmap.y);
-	return float3(normalXY.x, normalXY.y, math::sqrt(math::saturate(1.0 - math::dot(normalXY, normalXY))));
-}
-
-// Different implementation specific between mdl and hlsl for smoothstep
-export float smoothstep(float a, float b, float l)
-{
-	if (a < b)
-	{
-		return math::smoothstep(a, b, l);
-	}
-	else if (a > b)
-	{
-		return 1.0 - math::smoothstep(b, a, l);
-	}
-	else
-	{
-		return l <= a ? 0.0 : 1.0;
-	}
-}
-
-export float2 smoothstep(float2 a, float2 b, float2 l)
-{
-	return float2(smoothstep(a.x, b.x, l.x), smoothstep(a.y, b.y, l.y));
-}
-
-export float3 smoothstep(float3 a, float3 b, float3 l)
-{
-	return float3(smoothstep(a.x, b.x, l.x), smoothstep(a.y, b.y, l.y), smoothstep(a.z, b.z, l.z));
-}
-
-export float4 smoothstep(float4 a, float4 b, float4 l)
-{
-	return float4(smoothstep(a.x, b.x, l.x), smoothstep(a.y, b.y, l.y), smoothstep(a.z, b.z, l.z), smoothstep(a.w, b.w, l.w));
-}
-
-export float2 smoothstep(float2 a, float2 b, float l)
-{
-	return float2(smoothstep(a.x, b.x, l), smoothstep(a.y, b.y, l));
-}
-
-export float3 smoothstep(float3 a, float3 b, float l)
-{
-	return float3(smoothstep(a.x, b.x, l), smoothstep(a.y, b.y, l), smoothstep(a.z, b.z, l));
-}
-
-export float4 smoothstep(float4 a, float4 b, float l)
-{
-	return float4(smoothstep(a.x, b.x, l), smoothstep(a.y, b.y, l), smoothstep(a.z, b.z, l), smoothstep(a.w, b.w, l));
-}
-
-export float2 smoothstep(float a, float b, float2 l)
-{
-	return float2(smoothstep(a, b, l.x), smoothstep(a, b, l.y));
-}
-
-export float3 smoothstep(float a, float b, float3 l)
-{
-	return float3(smoothstep(a, b, l.x), smoothstep(a, b, l.y), smoothstep(a, b, l.z));
-}
-
-export float4 smoothstep(float a, float b, float4 l)
-{
-	return float4(smoothstep(a, b, l.x), smoothstep(a, b, l.y), smoothstep(a, b, l.z), smoothstep(a, b, l.w));
-}
-
-//------------------ Random from UE4 -----------------------
-float length2(float3 v)
-{
-	return math::dot(v, v);
-}
-
-float3 GetPerlinNoiseGradientTextureAt(uniform texture_2d PerlinNoiseGradientTexture, float3 v)
-{
-	const float2 ZShear = float2(17.0f, 89.0f);
-
-	float2 OffsetA = v.z * ZShear;
-	float2 TexA = (float2(v.x, v.y) + OffsetA + 0.5f) / 128.0f;
-	float4 PerlinNoise = tex::lookup_float4(PerlinNoiseGradientTexture,float2(TexA.x,1.0-TexA.y),tex::wrap_repeat,tex::wrap_repeat);
-	return float3(PerlinNoise.x, PerlinNoise.y, PerlinNoise.z) * 2.0 - 1.0;
-}
-
-float3 SkewSimplex(float3 In)
-{
-	return In + math::dot(In, float3(1.0 / 3.0f) );
-}
-float3 UnSkewSimplex(float3 In)
-{
-	return In - math::dot(In, float3(1.0 / 6.0f) );
-}
-
-// 3D random number generator inspired by PCGs (permuted congruential generator)
-// Using a **simple** Feistel cipher in place of the usual xor shift permutation step
-// @param v = 3D integer coordinate
-// @return three elements w/ 16 random bits each (0-0xffff).
-// ~8 ALU operations for result.x    (7 mad, 1 >>)
-// ~10 ALU operations for result.xy  (8 mad, 2 >>)
-// ~12 ALU operations for result.xyz (9 mad, 3 >>)
-
-//TODO: uint3
-int3 Rand3DPCG16(int3 p)
-{
-	// taking a signed int then reinterpreting as unsigned gives good behavior for negatives
-	//TODO: uint3
-	int3 v = int3(p);
-
-	// Linear congruential step. These LCG constants are from Numerical Recipies
-	// For additional #'s, PCG would do multiple LCG steps and scramble each on output
-	// So v here is the RNG state
-	v = v * 1664525 + 1013904223;
-
-	// PCG uses xorshift for the final shuffle, but it is expensive (and cheap
-	// versions of xorshift have visible artifacts). Instead, use simple MAD Feistel steps
-	//
-	// Feistel ciphers divide the state into separate parts (usually by bits)
-	// then apply a series of permutation steps one part at a time. The permutations
-	// use a reversible operation (usually ^) to part being updated with the result of
-	// a permutation function on the other parts and the key.
-	//
-	// In this case, I'm using v.x, v.y and v.z as the parts, using + instead of ^ for
-	// the combination function, and just multiplying the other two parts (no key) for 
-	// the permutation function.
-	//
-	// That gives a simple mad per round.
-	v.x += v.y*v.z;
-	v.y += v.z*v.x;
-	v.z += v.x*v.y;
-	v.x += v.y*v.z;
-	v.y += v.z*v.x;
-	v.z += v.x*v.y;
-
-	// only top 16 bits are well shuffled
-	return v >> 16;
-}
-
-// Wraps noise for tiling texture creation
-// @param v = unwrapped texture parameter
-// @param bTiling = true to tile, false to not tile
-// @param RepeatSize = number of units before repeating
-// @return either original or wrapped coord
-float3 NoiseTileWrap(float3 v,  bool bTiling, float RepeatSize)
-{
-	return bTiling ? (math::frac(v / RepeatSize) * RepeatSize) : v;
-}
-
-// Evaluate polynomial to get smooth transitions for Perlin noise
-// only needed by Perlin functions in this file
-// scalar(per component): 2 add, 5 mul
-float4 PerlinRamp(float4 t)
-{
-	return t * t * t * (t * (t * 6 - 15) + 10); 
-}
-
-// Blum-Blum-Shub-inspired pseudo random number generator
-// http://www.umbc.edu/~olano/papers/mNoise.pdf
-// real BBS uses ((s*s) mod M) with bignums and M as the product of two huge Blum primes
-// instead, we use a single prime M just small enough not to overflow
-// note that the above paper used 61, which fits in a half, but is unusably bad
-// @param Integer valued floating point seed
-// @return random number in range [0,1)
-// ~8 ALU operations (5 *, 3 frac)
-float RandBBSfloat(float seed)
-{
-	float BBS_PRIME24 = 4093.0;
-	float s = math::frac(seed / BBS_PRIME24);
-	s = math::frac(s * s * BBS_PRIME24);
-	s = math::frac(s * s * BBS_PRIME24);
-	return s;
-}
-
-// Modified noise gradient term
-// @param seed - random seed for integer lattice position
-// @param offset - [-1,1] offset of evaluation point from lattice point
-// @return gradient direction (xyz) and contribution (w) from this lattice point
-float4 MGradient(int seed, float3 offset)
-{
-	//TODO uint
-	int rand = Rand3DPCG16(int3(seed,0,0)).x;
-	int3 MGradientMask = int3(0x8000, 0x4000, 0x2000);
-	float3 MGradientScale = float3(1.0 / 0x4000, 1.0 / 0x2000, 1.0 / 0x1000);
-	float3 direction = float3(int3(rand, rand, rand) & MGradientMask) * MGradientScale - 1;
-	return float4(direction.x, direction.y, direction.z, math::dot(direction, offset));
-}
-
-// compute Perlin and related noise corner seed values
-// @param v = 3D noise argument, use float3(x,y,0) for 2D or float3(x,0,0) for 1D
-// @param bTiling = true to return seed values for a repeating noise pattern
-// @param RepeatSize = integer units before tiling in each dimension
-// @param seed000-seed111 = hash function seeds for the eight corners
-// @return fractional part of v
-struct SeedValue
-{
-	float3 fv = float3(0);
-	float seed000 = 0;
-	float seed001 = 0;
-	float seed010 = 0;
-	float seed011 = 0;
-	float seed100 = 0;
-	float seed101 = 0;
-	float seed110 = 0;
-	float seed111 = 0;
-};
-
-SeedValue NoiseSeeds(float3 v, bool bTiling, float RepeatSize)
-{
-	SeedValue seeds;
-	seeds.fv = math::frac(v);
-	float3 iv = math::floor(v);
-
-	const float3 primes = float3(19, 47, 101);
-
-	if (bTiling)
-	{	// can't algebraically combine with primes
-		seeds.seed000 = math::dot(primes, NoiseTileWrap(iv, true, RepeatSize));
-		seeds.seed100 = math::dot(primes, NoiseTileWrap(iv + float3(1, 0, 0), true, RepeatSize));
-		seeds.seed010 = math::dot(primes, NoiseTileWrap(iv + float3(0, 1, 0), true, RepeatSize));
-		seeds.seed110 = math::dot(primes, NoiseTileWrap(iv + float3(1, 1, 0), true, RepeatSize));
-		seeds.seed001 = math::dot(primes, NoiseTileWrap(iv + float3(0, 0, 1), true, RepeatSize));
-		seeds.seed101 = math::dot(primes, NoiseTileWrap(iv + float3(1, 0, 1), true, RepeatSize));
-		seeds.seed011 = math::dot(primes, NoiseTileWrap(iv + float3(0, 1, 1), true, RepeatSize));
-		seeds.seed111 = math::dot(primes, NoiseTileWrap(iv + float3(1, 1, 1), true, RepeatSize));
-	}
-	else
-	{	// get to combine offsets with multiplication by primes in this case
-		seeds.seed000 = math::dot(iv, primes);
-		seeds.seed100 = seeds.seed000 + primes.x;
-		seeds.seed010 = seeds.seed000 + primes.y;
-		seeds.seed110 = seeds.seed100 + primes.y;
-		seeds.seed001 = seeds.seed000 + primes.z;
-		seeds.seed101 = seeds.seed100 + primes.z;
-		seeds.seed011 = seeds.seed010 + primes.z;
-		seeds.seed111 = seeds.seed110 + primes.z;
-	}
-
-	return seeds;
-}
-
-struct SimplexWeights
-{
-	float4 Result = float4(0);
-	float3 PosA = float3(0);
-	float3 PosB = float3(0);
-	float3 PosC = float3(0);
-	float3 PosD = float3(0);
-};
-
-// Computed weights and sample positions for simplex interpolation
-// @return float4(a,b,c, d) Barycentric coordinate defined as Filtered = Tex(PosA) * a + Tex(PosB) * b + Tex(PosC) * c + Tex(PosD) * d
-SimplexWeights ComputeSimplexWeights3D(float3 OrthogonalPos)
-{
-	SimplexWeights weights;
-	float3 OrthogonalPosFloor = math::floor(OrthogonalPos);
-
-	weights.PosA = OrthogonalPosFloor;
-	weights.PosB = weights.PosA + float3(1, 1, 1);
-
-	OrthogonalPos -= OrthogonalPosFloor;
-
-	float Largest = math::max(OrthogonalPos.x, math::max(OrthogonalPos.y, OrthogonalPos.z));
-	float Smallest = math::min(OrthogonalPos.x, math::min(OrthogonalPos.y, OrthogonalPos.z));
-
-	weights.PosC = weights.PosA + float3(Largest == OrthogonalPos.x, Largest == OrthogonalPos.y, Largest == OrthogonalPos.z);
-	weights.PosD = weights.PosA + float3(Smallest != OrthogonalPos.x, Smallest != OrthogonalPos.y, Smallest != OrthogonalPos.z);
-
-	float RG = OrthogonalPos.x - OrthogonalPos.y;
-	float RB = OrthogonalPos.x - OrthogonalPos.z;
-	float GB = OrthogonalPos.y - OrthogonalPos.z;
-
-	weights.Result.z = 
-		  math::min(math::max(0, RG), math::max(0, RB))		// X
-		+ math::min(math::max(0, -RG), math::max(0, GB))		// Y
-		+ math::min(math::max(0, -RB), math::max(0, -GB));	// Z
-	
-	weights.Result.w = 
-		  math::min(math::max(0, -RG), math::max(0, -RB))		// X
-		+ math::min(math::max(0, RG), math::max(0, -GB))		// Y
-		+ math::min(math::max(0, RB), math::max(0, GB));		// Z
-
-	weights.Result.y = Smallest;
-	weights.Result.x = 1.0f - weights.Result.y - weights.Result.z - weights.Result.w;
-
-	return weights;
-}
-
-// filtered 3D gradient simple noise (few texture lookups, high quality)
-// @param v >0
-// @return random number in the range -1 .. 1
-float SimplexNoise3D_TEX(uniform texture_2d PerlinNoiseGradientTexture, float3 EvalPos)
-{
-	float3 OrthogonalPos = SkewSimplex(EvalPos);
-
-	SimplexWeights Weights = ComputeSimplexWeights3D(OrthogonalPos);
-
-	// can be optimized to 1 or 2 texture lookups (4 or 8 channel encoded in 32 bit)
-	float3 A = GetPerlinNoiseGradientTextureAt(PerlinNoiseGradientTexture, Weights.PosA);
-	float3 B = GetPerlinNoiseGradientTextureAt(PerlinNoiseGradientTexture, Weights.PosB);
-	float3 C = GetPerlinNoiseGradientTextureAt(PerlinNoiseGradientTexture, Weights.PosC);
-	float3 D = GetPerlinNoiseGradientTextureAt(PerlinNoiseGradientTexture, Weights.PosD);
-	
-	Weights.PosA = UnSkewSimplex(Weights.PosA);
-	Weights.PosB = UnSkewSimplex(Weights.PosB);
-	Weights.PosC = UnSkewSimplex(Weights.PosC);
-	Weights.PosD = UnSkewSimplex(Weights.PosD);
-
-	float DistanceWeight;
-
-	DistanceWeight = math::saturate(0.6f - length2(EvalPos - Weights.PosA));	DistanceWeight *= DistanceWeight; DistanceWeight *= DistanceWeight;
-	float a = math::dot(A, EvalPos - Weights.PosA) * DistanceWeight;
-	DistanceWeight = math::saturate(0.6f - length2(EvalPos - Weights.PosB));	DistanceWeight *= DistanceWeight; DistanceWeight *= DistanceWeight;
-	float b = math::dot(B, EvalPos - Weights.PosB) * DistanceWeight;
-	DistanceWeight = math::saturate(0.6f - length2(EvalPos - Weights.PosC));	DistanceWeight *= DistanceWeight; DistanceWeight *= DistanceWeight;
-	float c = math::dot(C, EvalPos - Weights.PosC) * DistanceWeight;
-	DistanceWeight = math::saturate(0.6f - length2(EvalPos - Weights.PosD));	DistanceWeight *= DistanceWeight; DistanceWeight *= DistanceWeight;
-	float d = math::dot(D, EvalPos - Weights.PosD) * DistanceWeight;
-
-	return 32 * (a + b + c + d);
-}
-
-// filtered 3D noise, can be optimized
-// @param v = 3D noise argument, use float3(x,y,0) for 2D or float3(x,0,0) for 1D
-// @param bTiling = repeat noise pattern
-// @param RepeatSize = integer units before tiling in each dimension
-// @return random number in the range -1 .. 1
-float GradientNoise3D_TEX(uniform texture_2d PerlinNoiseGradientTexture, float3 v, bool bTiling, float RepeatSize)
-{
-	bTiling = true;
-	float3 fv = math::frac(v);
-	float3 iv0 = NoiseTileWrap(math::floor(v), bTiling, RepeatSize);
-	float3 iv1 = NoiseTileWrap(iv0 + 1, bTiling, RepeatSize);
-
-	const int2 ZShear = int2(17, 89);
-	
-	float2 OffsetA = iv0.z * ZShear;
-	float2 OffsetB = OffsetA + ZShear;	// non-tiling, use relative offset
-	if (bTiling)						// tiling, have to compute from wrapped coordinates
-	{
-		OffsetB = iv1.z * ZShear;
-	}
-
-	// Texture size scale factor
-	float ts = 1 / 128.0f;
-
-	// texture coordinates for iv0.xy, as offset for both z slices
-	float2 TexA0 = (float2(iv0.x, iv0.y) + OffsetA + 0.5f) * ts;
-	float2 TexB0 = (float2(iv0.x, iv0.y) + OffsetB + 0.5f) * ts;
-
-	// texture coordinates for iv1.xy, as offset for both z slices
-	float2 TexA1 = TexA0 + ts;	// for non-tiling, can compute relative to existing coordinates
-	float2 TexB1 = TexB0 + ts;
-	if (bTiling)				// for tiling, need to compute from wrapped coordinates
-	{
-		TexA1 = (float2(iv1.x, iv1.y) + OffsetA + 0.5f) * ts;
-		TexB1 = (float2(iv1.x, iv1.y) + OffsetB + 0.5f) * ts;
-	}
-
-
-	// can be optimized to 1 or 2 texture lookups (4 or 8 channel encoded in 8, 16 or 32 bit)
-	float4 PerlinNoise = tex::lookup_float4(PerlinNoiseGradientTexture,float2(TexA0.x,1.0-TexA0.y),tex::wrap_repeat,tex::wrap_repeat);
-	float3 PerlinNoiseColor = float3(PerlinNoise.x, PerlinNoise.y, PerlinNoise.z);
-	float3 A = PerlinNoiseColor * 2 - 1;
-	PerlinNoise = tex::lookup_float4(PerlinNoiseGradientTexture,float2(TexA1.x,1.0-TexA0.y),tex::wrap_repeat,tex::wrap_repeat);
-	PerlinNoiseColor = float3(PerlinNoise.x, PerlinNoise.y, PerlinNoise.z);
-	float3 B = PerlinNoiseColor * 2 - 1;
-	PerlinNoise = tex::lookup_float4(PerlinNoiseGradientTexture,float2(TexA0.x,1.0-TexA1.y),tex::wrap_repeat,tex::wrap_repeat);
-	PerlinNoiseColor = float3(PerlinNoise.x, PerlinNoise.y, PerlinNoise.z);
-	float3 C = PerlinNoiseColor * 2 - 1;
-	PerlinNoise = tex::lookup_float4(PerlinNoiseGradientTexture,float2(TexA1.x,1.0-TexA1.y),tex::wrap_repeat,tex::wrap_repeat);
-	PerlinNoiseColor = float3(PerlinNoise.x, PerlinNoise.y, PerlinNoise.z);
-	float3 D = PerlinNoiseColor * 2 - 1;
-	PerlinNoise = tex::lookup_float4(PerlinNoiseGradientTexture,float2(TexB0.x,1.0-TexB0.y),tex::wrap_repeat,tex::wrap_repeat);
-	PerlinNoiseColor = float3(PerlinNoise.x, PerlinNoise.y, PerlinNoise.z);
-	float3 E = PerlinNoiseColor * 2 - 1;
-	PerlinNoise = tex::lookup_float4(PerlinNoiseGradientTexture,float2(TexB1.x,1.0-TexB0.y),tex::wrap_repeat,tex::wrap_repeat);
-	PerlinNoiseColor = float3(PerlinNoise.x, PerlinNoise.y, PerlinNoise.z);
-	float3 F = PerlinNoiseColor * 2 - 1;
-	PerlinNoise = tex::lookup_float4(PerlinNoiseGradientTexture,float2(TexB0.x,1.0-TexB1.y),tex::wrap_repeat,tex::wrap_repeat);
-	PerlinNoiseColor = float3(PerlinNoise.x, PerlinNoise.y, PerlinNoise.z);
-	float3 G = PerlinNoiseColor * 2 - 1;
-	PerlinNoise = tex::lookup_float4(PerlinNoiseGradientTexture,float2(TexB1.x,1.0-TexB1.y),tex::wrap_repeat,tex::wrap_repeat);
-	PerlinNoiseColor = float3(PerlinNoise.x, PerlinNoise.y, PerlinNoise.z);
-	float3 H = PerlinNoiseColor * 2 - 1;
-
-	float a = math::dot(A, fv - float3(0, 0, 0));
-	float b = math::dot(B, fv - float3(1, 0, 0));
-	float c = math::dot(C, fv - float3(0, 1, 0));
-	float d = math::dot(D, fv - float3(1, 1, 0));
-	float e = math::dot(E, fv - float3(0, 0, 1));
-	float f = math::dot(F, fv - float3(1, 0, 1));
-	float g = math::dot(G, fv - float3(0, 1, 1));
-	float h = math::dot(H, fv - float3(1, 1, 1));
-
-	float4 Weights = PerlinRamp(math::frac(float4(fv.x, fv.y, fv.z, 0)));
-	
-	float i = math::lerp(math::lerp(a, b, Weights.x), math::lerp(c, d, Weights.x), Weights.y);
-	float j = math::lerp(math::lerp(e, f, Weights.x), math::lerp(g, h, Weights.x), Weights.y);
-
-	return math::lerp(i, j, Weights.z);
-}
-
-// @return random number in the range -1 .. 1
-// scalar: 6 frac, 31 mul/mad, 15 add, 
-float FastGradientPerlinNoise3D_TEX(uniform texture_3d PerlinNoise3DTexture, float3 xyz)
-{
-	// needs to be the same value when creating the PerlinNoise3D texture
-	float Extent = 16;
-
-	// last texel replicated and needed for filtering
-	// scalar: 3 frac, 6 mul
-	xyz = math::frac(xyz / (Extent - 1)) * (Extent - 1);
-
-	// scalar: 3 frac
-	float3 uvw = math::frac(xyz);
-	// = floor(xyz);
-	// scalar: 3 add
-	float3 p0 = xyz - uvw;
-//	float3 f = math::pow(uvw, 2) * 3.0f - math::pow(uvw, 3) * 2.0f;	// original perlin hermite (ok when used without bump mapping)
-	// scalar: 2*3 add 5*3 mul
-	float4 pr = PerlinRamp(float4(uvw.x, uvw.y, uvw.z, 0));
-	float3 f = float3(pr.x, pr.y, pr.z);	// new, better with continues second derivative for bump mapping
-	// scalar: 3 add
-	float3 p = p0 + f;
-	// scalar: 3 mad
-	// TODO: need reverse???
-	float4 NoiseSample = tex::lookup_float4(PerlinNoise3DTexture, p / Extent + 0.5f / Extent);	// +0.5f to get rid of bilinear offset
-
-	// reconstruct from 8bit (using mad with 2 constants and dot4 was same instruction count)
-	// scalar: 4 mad, 3 mul, 3 add 
-	float3 n = float3(NoiseSample.x, NoiseSample.y, NoiseSample.z) * 255.0f / 127.0f - 1.0f;
-	float d = NoiseSample.w * 255.f - 127;
-	return math::dot(xyz, n) - d;
-}
-
-// Perlin-style "Modified Noise"
-// http://www.umbc.edu/~olano/papers/index.html#mNoise
-// @param v = 3D noise argument, use float3(x,y,0) for 2D or float3(x,0,0) for 1D
-// @param bTiling = repeat noise pattern
-// @param RepeatSize = integer units before tiling in each dimension
-// @return random number in the range -1 .. 1
-float GradientNoise3D_ALU(float3 v, bool bTiling, float RepeatSize)
-{
-	SeedValue seeds = NoiseSeeds(v, bTiling, RepeatSize);
-
-	float rand000 = MGradient(int(seeds.seed000), seeds.fv - float3(0, 0, 0)).w;
-	float rand100 = MGradient(int(seeds.seed100), seeds.fv - float3(1, 0, 0)).w;
-	float rand010 = MGradient(int(seeds.seed010), seeds.fv - float3(0, 1, 0)).w;
-	float rand110 = MGradient(int(seeds.seed110), seeds.fv - float3(1, 1, 0)).w;
-	float rand001 = MGradient(int(seeds.seed001), seeds.fv - float3(0, 0, 1)).w;
-	float rand101 = MGradient(int(seeds.seed101), seeds.fv - float3(1, 0, 1)).w;
-	float rand011 = MGradient(int(seeds.seed011), seeds.fv - float3(0, 1, 1)).w;
-	float rand111 = MGradient(int(seeds.seed111), seeds.fv - float3(1, 1, 1)).w;
-
-	float4 Weights = PerlinRamp(float4(seeds.fv.x, seeds.fv.y, seeds.fv.z, 0));
-
-	float i = math::lerp(math::lerp(rand000, rand100, Weights.x), math::lerp(rand010, rand110, Weights.x), Weights.y);
-	float j = math::lerp(math::lerp(rand001, rand101, Weights.x), math::lerp(rand011, rand111, Weights.x), Weights.y);
-	return math::lerp(i, j, Weights.z);
-}
-
-// 3D value noise - used to be incorrectly called Perlin noise
-// @param v = 3D noise argument, use float3(x,y,0) for 2D or float3(x,0,0) for 1D
-// @param bTiling = repeat noise pattern
-// @param RepeatSize = integer units before tiling in each dimension
-// @return random number in the range -1 .. 1
-float ValueNoise3D_ALU(float3 v, bool bTiling, float RepeatSize)
-{
-	SeedValue seeds = NoiseSeeds(v, bTiling, RepeatSize);
-
-	float rand000 = RandBBSfloat(seeds.seed000) * 2 - 1;
-	float rand100 = RandBBSfloat(seeds.seed100) * 2 - 1;
-	float rand010 = RandBBSfloat(seeds.seed010) * 2 - 1;
-	float rand110 = RandBBSfloat(seeds.seed110) * 2 - 1;
-	float rand001 = RandBBSfloat(seeds.seed001) * 2 - 1;
-	float rand101 = RandBBSfloat(seeds.seed101) * 2 - 1;
-	float rand011 = RandBBSfloat(seeds.seed011) * 2 - 1;
-	float rand111 = RandBBSfloat(seeds.seed111) * 2 - 1;
-	
-	float4 Weights = PerlinRamp(float4(seeds.fv.x, seeds.fv.y, seeds.fv.z, 0));
-	
-	float i = math::lerp(math::lerp(rand000, rand100, Weights.x), math::lerp(rand010, rand110, Weights.x), Weights.y);
-	float j = math::lerp(math::lerp(rand001, rand101, Weights.x), math::lerp(rand011, rand111, Weights.x), Weights.y);
-	return math::lerp(i, j, Weights.z);
-}
-
-// 3D jitter offset within a voronoi noise cell
-// @param pos - integer lattice corner
-// @return random offsets vector
-float3 VoronoiCornerSample(float3 pos, int Quality)
-{
-	// random values in [-0.5, 0.5]
-	float3 noise = float3(Rand3DPCG16(int3(pos))) / 0xffff - 0.5;
-
-	// quality level 1 or 2: searches a 2x2x2 neighborhood with points distributed on a sphere
-	// scale factor to guarantee jittered points will be found within a 2x2x2 search
-	if (Quality <= 2)
-	{
-		return math::normalize(noise) * 0.2588;
-	}
-
-	// quality level 3: searches a 3x3x3 neighborhood with points distributed on a sphere
-	// scale factor to guarantee jittered points will be found within a 3x3x3 search
-	if (Quality == 3)
-	{
-		return math::normalize(noise) * 0.3090;
-	}
-
-	// quality level 4: jitter to anywhere in the cell, needs 4x4x4 search
-	return noise;
-}
-
-// compare previous best with a new candidate
-// not producing point locations makes it easier for compiler to eliminate calculations when they're not needed
-// @param minval = location and distance of best candidate seed point before the new one
-// @param candidate = candidate seed point
-// @param offset = 3D offset to new candidate seed point
-// @param bDistanceOnly = if true, only set maxval.w with distance, otherwise maxval.w is distance and maxval.xyz is position
-// @return position (if bDistanceOnly is false) and distance to closest seed point so far
-float4 VoronoiCompare(float4 minval, float3 candidate, float3 offset, bool bDistanceOnly)
-{
-	if (bDistanceOnly)
-	{
-		return float4(0, 0, 0, math::min(minval.w, math::dot(offset, offset)));
-	}
-	else
-	{
-		float newdist = math::dot(offset, offset);
-		return newdist > minval.w ? minval : float4(candidate.x, candidate.y, candidate.z, newdist);
-	}
-}
-
-// 220 instruction Worley noise
-float4 VoronoiNoise3D_ALU(float3 v, int Quality, bool bTiling, float RepeatSize, bool bDistanceOnly)
-{
-	float3 fv = math::frac(v),  fv2 = math::frac(v + 0.5);
-	float3 iv = math::floor(v), iv2 = math::floor(v + 0.5);
-
-	// with initial minimum distance = infinity (or at least bigger than 4), first min is optimized away
-	float4 mindist = float4(0,0,0,100);
-	float3 p, offset;
-
-	// quality level 3: do a 3x3x3 search
-	if (Quality == 3)
-	{
-		int offset_x;
-		int offset_y;
-		int offset_z;
-		for (offset_x = -1; offset_x <= 1; ++offset_x)
-		{
-			for (offset_y = -1; offset_y <= 1; ++offset_y)
-			{
-				for (offset_z = -1; offset_z <= 1; ++offset_z)
-				{
-					offset = float3(offset_x, offset_y, offset_z);
-					p = offset + VoronoiCornerSample(NoiseTileWrap(iv2 + offset, bTiling, RepeatSize), Quality);
-					mindist = VoronoiCompare(mindist, iv2 + p, fv2 - p, bDistanceOnly);
-				}
-			}
-		}
-	}
-
-	// everybody else searches a base 2x2x2 neighborhood
-	else
-	{
-		int offset_x;
-		int offset_y;
-		int offset_z;
-		for (offset_x = 0; offset_x <= 1; ++offset_x)
-		{
-			for (offset_y = 0; offset_y <= 1; ++offset_y)
-			{
-				for (offset_z = 0; offset_z <= 1; ++offset_z)
-				{
-					offset = float3(offset_x, offset_y, offset_z);
-					p = offset + VoronoiCornerSample(NoiseTileWrap(iv + offset, bTiling, RepeatSize), Quality);
-					mindist = VoronoiCompare(mindist, iv + p, fv - p, bDistanceOnly);
-
-					// quality level 2, do extra set of points, offset by half a cell
-					if (Quality == 2)
-					{
-						// 467 is just an offset to a different area in the random number field to avoid similar neighbor artifacts
-						p = offset + VoronoiCornerSample(NoiseTileWrap(iv2 + offset, bTiling, RepeatSize) + 467, Quality);
-						mindist = VoronoiCompare(mindist, iv2 + p, fv2 - p, bDistanceOnly);
-					}
-				}
-			}
-		}
-	}
-
-	// quality level 4: add extra sets of four cells in each direction
-	if (Quality >= 4)
-	{
-		int offset_x;
-		int offset_y;
-		int offset_z;	
-		for (offset_x = -1; offset_x <= 2; offset_x += 3)
-		{
-			for (offset_y = 0; offset_y <= 1; ++offset_y)
-			{
-				for (offset_z = 0; offset_z <= 1; ++offset_z)
-				{
-					offset = float3(offset_x, offset_y, offset_z);
-					// along x axis
-					p = offset + VoronoiCornerSample(NoiseTileWrap(iv + offset, bTiling, RepeatSize), Quality);
-					mindist = VoronoiCompare(mindist, iv + p, fv - p, bDistanceOnly);
-
-					// along y axis
-					p = float3(offset.y, offset.z, offset.x) + VoronoiCornerSample(NoiseTileWrap(iv + float3(offset.y, offset.z, offset.x), bTiling, RepeatSize), Quality);
-					mindist = VoronoiCompare(mindist, iv + p, fv - p, bDistanceOnly);
-
-					// along z axis
-					p = float3(offset.z, offset.x, offset.y) + VoronoiCornerSample(NoiseTileWrap(iv + float3(offset.z, offset.x, offset.y), bTiling, RepeatSize), Quality);
-					mindist = VoronoiCompare(mindist, iv + p, fv - p, bDistanceOnly);
-				}
-			}
-		}
-	}
-
-	// transform squared distance to real distance
-	return float4(mindist.x, mindist.y, mindist.z, math::sqrt(mindist.w));
-}
-
-// Coordinates for corners of a Simplex tetrahedron
-// Based on McEwan et al., Efficient computation of noise in GLSL, JGT 2011
-// @param v = 3D noise argument
-// @return 4 corner locations
-float4x3 SimplexCorners(float3 v)
-{
-	// find base corner by skewing to tetrahedral space and back
-	float3 tet = math::floor(v + v.x/3 + v.y/3 + v.z/3);
-	float3 base = tet - tet.x/6 - tet.y/6 - tet.z/6;
-	float3 f = v - base;
-
-	// Find offsets to other corners (McEwan did this in tetrahedral space,
-	// but since skew is along x=y=z axis, this works in Euclidean space too.)
-	float3 g = math::step(float3(f.y,f.z,f.x), float3(f.x,f.y,f.z)), h = 1 - float3(g.z, g.x, g.y);
-	float3 a1 = math::min(g, h) - 1.0 / 6.0, a2 = math::max(g, h) - 1.0 / 3.0;
-
-	// four corners
-	return float4x3(base, base + a1, base + a2, base + 0.5);
-}
-
-// Improved smoothing function for simplex noise
-// @param f = fractional distance to four tetrahedral corners
-// @return weight for each corner
-float4 SimplexSmooth(float4x3 f)
-{
-	const float scale = 1024. / 375.;	// scale factor to make noise -1..1
-	float4 d = float4(math::dot(f[0], f[0]), math::dot(f[1], f[1]), math::dot(f[2], f[2]), math::dot(f[3], f[3]));
-	float4 s = math::saturate(2 * d);
-	return (1 * scale + s*(-3 * scale + s*(3 * scale - s*scale)));
-}
-
-// Derivative of simplex noise smoothing function
-// @param f = fractional distanc eto four tetrahedral corners
-// @return derivative of smoothing function for each corner by x, y and z
-float3x4 SimplexDSmooth(float4x3 f)
-{
-	const float scale = 1024. / 375.;	// scale factor to make noise -1..1
-	float4 d = float4(math::dot(f[0], f[0]), math::dot(f[1], f[1]), math::dot(f[2], f[2]), math::dot(f[3], f[3]));
-	float4 s = math::saturate(2 * d);
-	s = -12 * scale + s*(24 * scale - s * 12 * scale);
-
-	return float3x4(
-		s * float4(f[0][0], f[1][0], f[2][0], f[3][0]),
-		s * float4(f[0][1], f[1][1], f[2][1], f[3][1]),
-		s * float4(f[0][2], f[1][2], f[2][2], f[3][2]));
-}
-
-// Simplex noise and its Jacobian derivative
-// @param v = 3D noise argument
-// @param bTiling = whether to repeat noise pattern
-// @param RepeatSize = integer units before tiling in each dimension, must be a multiple of 3
-// @return float3x3 Jacobian in J[*].xyz, vector noise in J[*].w
-//     J[0].w, J[1].w, J[2].w is a Perlin-style simplex noise with vector output, e.g. (Nx, Ny, Nz)
-//     J[i].x is X derivative of the i'th component of the noise so J[2].x is dNz/dx
-// You can use this to compute the noise, gradient, curl, or divergence:
-//   float3x4 J = JacobianSimplex_ALU(...);
-//   float3 VNoise = float3(J[0].w, J[1].w, J[2].w);	// 3D noise
-//   float3 Grad = J[0].xyz;							// gradient of J[0].w
-//   float3 Curl = float3(J[1][2]-J[2][1], J[2][0]-J[0][2], J[0][1]-J[1][2]);
-//   float Div = J[0][0]+J[1][1]+J[2][2];
-// All of these are confirmed to compile out all unneeded terms.
-// So Grad of X doesn't compute Y or Z components, and VNoise doesn't do any of the derivative computation.
-float3x4 JacobianSimplex_ALU(float3 v, bool bTiling, float RepeatSize)
-{
-	int3 MGradientMask = int3(0x8000, 0x4000, 0x2000);
-	float3 MGradientScale = float3(1. / 0x4000, 1. / 0x2000, 1. / 0x1000);
-
-	// corners of tetrahedron
-	float4x3 T = SimplexCorners(v);
-	// TODO: uint3
-	int3 rand = int3(0);
-	float4x3 gvec0 = float4x3(1.0);
-	float4x3 gvec1 = float4x3(1.0);
-	float4x3 gvec2 = float4x3(1.0);
-	float4x3 fv = float4x3(1.0);
-	float3x4 grad = float3x4(1.0);
-
-	// processing of tetrahedral vertices, unrolled
-	// to compute gradient at each corner
-	fv[0] = v - T[0];
-	rand = Rand3DPCG16(int3(math::floor(NoiseTileWrap(6 * T[0] + 0.5, bTiling, RepeatSize))));
-	gvec0[0] = float3(int3(rand.x,rand.x,rand.x) & MGradientMask) * MGradientScale - 1;
-	gvec1[0] = float3(int3(rand.y,rand.y,rand.y) & MGradientMask) * MGradientScale - 1;
-	gvec2[0] = float3(int3(rand.z,rand.z,rand.z) & MGradientMask) * MGradientScale - 1;
-	grad[0][0] = math::dot(gvec0[0], fv[0]);
-	grad[1][0] = math::dot(gvec1[0], fv[0]);
-	grad[2][0] = math::dot(gvec2[0], fv[0]);
-
-	fv[1] = v - T[1];
-	rand = Rand3DPCG16(int3(math::floor(NoiseTileWrap(6 * T[1] + 0.5, bTiling, RepeatSize))));
-	gvec0[1] = float3(int3(rand.x,rand.x,rand.x) & MGradientMask) * MGradientScale - 1;
-	gvec1[1] = float3(int3(rand.y,rand.y,rand.y) & MGradientMask) * MGradientScale - 1;
-	gvec1[1] = float3(int3(rand.z,rand.z,rand.z) & MGradientMask) * MGradientScale - 1;
-	grad[0][1] = math::dot(gvec0[1], fv[1]);
-	grad[1][1] = math::dot(gvec1[1], fv[1]);
-	grad[2][1] = math::dot(gvec2[1], fv[1]);
-
-	fv[2] = v - T[2];
-	rand = Rand3DPCG16(int3(math::floor(NoiseTileWrap(6 * T[2] + 0.5, bTiling, RepeatSize))));
-	gvec0[2] = float3(int3(rand.x,rand.x,rand.x) & MGradientMask) * MGradientScale - 1;
-	gvec1[2] = float3(int3(rand.y,rand.y,rand.y) & MGradientMask) * MGradientScale - 1;
-	gvec2[2] = float3(int3(rand.z,rand.z,rand.z) & MGradientMask) * MGradientScale - 1;
-	grad[0][2] = math::dot(gvec0[2], fv[2]);
-	grad[1][2] = math::dot(gvec1[2], fv[2]);
-	grad[2][2] = math::dot(gvec2[2], fv[2]);
-
-	fv[3] = v - T[3];
-	rand = Rand3DPCG16(int3(math::floor(NoiseTileWrap(6 * T[3] + 0.5, bTiling, RepeatSize))));
-	gvec0[3] = float3(int3(rand.x,rand.x,rand.x) & MGradientMask) * MGradientScale - 1;
-	gvec1[3] = float3(int3(rand.y,rand.y,rand.y) & MGradientMask) * MGradientScale - 1;
-	gvec2[3] = float3(int3(rand.z,rand.z,rand.z) & MGradientMask) * MGradientScale - 1;
-	grad[0][3] = math::dot(gvec0[3], fv[3]);
-	grad[1][3] = math::dot(gvec1[3], fv[3]);
-	grad[2][3] = math::dot(gvec2[3], fv[3]);
-
-	// blend gradients
-	float4 sv = SimplexSmooth(fv);
-	float3x4 ds = SimplexDSmooth(fv);
-
-	float3x4 jacobian = float3x4(1.0);
-	float3 vec0 = gvec0*sv + grad[0]*ds; // NOTE: mdl is column major, convert from UE4 (row major)
-	jacobian[0] = float4(vec0.x, vec0.y, vec0.z, math::dot(sv, grad[0]));
-	float3 vec1 = gvec1*sv + grad[1]*ds;
-	jacobian[1] = float4(vec1.x, vec1.y, vec1.z, math::dot(sv, grad[1]));
-	float3 vec2 = gvec2*sv + grad[2]*ds;
-	jacobian[2] = float4(vec2.x, vec2.y, vec2.z, math::dot(sv, grad[2]));
-
-	return jacobian;
-}
-
-// While RepeatSize is a float here, the expectation is that it would be largely integer values coming in from the UI. The downstream logic assumes
-// floats for all called functions (NoiseTileWrap) and this prevents any float-to-int conversion errors from automatic type conversion.
-float Noise3D_Multiplexer(uniform texture_2d PerlinNoiseGradientTexture, uniform texture_3d PerlinNoise3DTexture, int Function, float3 Position, int Quality, bool bTiling, float RepeatSize)
-{
-	// verified, HLSL compiled out the switch if Function is a constant
-	switch(Function)
-	{
-		case 0:
-			return SimplexNoise3D_TEX(PerlinNoiseGradientTexture, Position);
-		case 1:
-			return GradientNoise3D_TEX(PerlinNoiseGradientTexture, Position, bTiling, RepeatSize);
-		case 2:
-			return FastGradientPerlinNoise3D_TEX(PerlinNoise3DTexture, Position);
-		case 3:
-			return GradientNoise3D_ALU(Position, bTiling, RepeatSize);
-		case 4:
-			return ValueNoise3D_ALU(Position, bTiling, RepeatSize);
-		case 5:
-			return VoronoiNoise3D_ALU(Position, Quality, bTiling, RepeatSize, true).w * 2.0 - 1.0;
-	}
-	return 0;
-}
-//----------------------------------------------------------
-
-export float noise(uniform texture_2d PerlinNoiseGradientTexture, uniform texture_3d PerlinNoise3DTexture, float3 Position, float Scale, float Quality, float Function, float Turbulence, float Levels, float OutputMin, float OutputMax, float LevelScale, float FilterWidth, float Tiling, float RepeatSize)
-[[
-    anno::description("Noise"),
-    anno::noinline()
-]]
-{
-	Position *= Scale;
-	FilterWidth *= Scale;
-
-	float Out = 0.0f;
-	float OutScale = 1.0f;
-	float InvLevelScale = 1.0f / LevelScale;
-	
-	int iFunction(Function);
-	int iQuality(Quality);
-	int iLevels(Levels);
-	bool bTurbulence(Turbulence);
-	bool bTiling(Tiling);
-	
-	for(int i = 0; i < iLevels; ++i)
-	{
-		// fade out noise level that are too high frequent (not done through dynamic branching as it usually requires gradient instructions)
-		OutScale *= math::saturate(1.0 - FilterWidth);
-
-		if(bTurbulence)
-		{
-			Out += math::abs(Noise3D_Multiplexer(PerlinNoiseGradientTexture, PerlinNoise3DTexture, iFunction, Position, iQuality, bTiling, RepeatSize)) * OutScale;
-		}
-		else
-		{
-			Out += Noise3D_Multiplexer(PerlinNoiseGradientTexture, PerlinNoise3DTexture, iFunction, Position, iQuality, bTiling, RepeatSize) * OutScale;
-		}
-
-		Position *= LevelScale;
-		RepeatSize *= LevelScale;
-		OutScale *= InvLevelScale;
-		FilterWidth *= LevelScale;
-	}
-
-	if(!bTurbulence)
-	{
-		// bring -1..1 to 0..1 range
-		Out = Out * 0.5f + 0.5f;
-	}
-
-	// Out is in 0..1 range
-	return math::lerp(OutputMin, OutputMax, Out);
-}
-
-// Material node for noise functions returning a vector value
-// @param LevelScale usually 2 but higher values allow efficient use of few levels
-// @return in user defined range (OutputMin..OutputMax)
-export float4 vector4_noise(float3 Position, float Quality, float Function, float Tiling, float TileSize)
-[[
-    anno::description("Vector Noise"),
-    anno::noinline()
-]]
-{
-	float4 result = float4(0,0,0,1);
-	float3 ret = float3(0);
-	int iQuality = int(Quality);
-	int iFunction = int(Function);
-	bool bTiling = Tiling > 0.0;
-	
-	float3x4 Jacobian = JacobianSimplex_ALU(Position, bTiling, TileSize);	// compiled out if not used
-
-	// verified, HLSL compiled out the switch if Function is a constant
-	switch (iFunction)
-	{
-	case 0:	// Cellnoise
-		ret = float3(Rand3DPCG16(int3(math::floor(NoiseTileWrap(Position, bTiling, TileSize))))) / 0xffff;
-		result = float4(ret.x, ret.y, ret.z, 1);
-		break;
-	case 1: // Color noise
-		ret = float3(Jacobian[0].w, Jacobian[1].w, Jacobian[2].w);
-		result = float4(ret.x, ret.y, ret.z, 1);
-		break;
-	case 2: // Gradient
-		result = Jacobian[0];
-		break;
-	case 3: // Curl
-		ret = float3(Jacobian[2][1] - Jacobian[1][2], Jacobian[0][2] - Jacobian[2][0], Jacobian[1][0] - Jacobian[0][1]);
-		result = float4(ret.x, ret.y, ret.z, 1);
-		break;
-	case 4: // Voronoi
-		result = VoronoiNoise3D_ALU(Position, iQuality, bTiling, TileSize, false);
-		break;
-	}
-	return result;
-}
-
-export float3 vector3_noise(float3 Position, float Quality, float Function, float Tiling, float TileSize)
-[[
-    anno::description("Vector Noise float3 version"),
-    anno::noinline()
-]]
-{
-	float4 noise = vector4_noise(Position, Quality, Function, Tiling, TileSize);
-	return float3(noise.x, noise.y, noise.z);
-}
-
-
-// workaround for ue4 fresnel (without supporting for camera vector) : replacing it with 0.0, means facing to the view
-export float fresnel(float exponent [[anno::unused()]], float base_reflect_fraction [[anno::unused()]], float3 normal [[anno::unused()]])
-[[
-    anno::description("Fresnel"),
-    anno::noinline()
-]]
-{
-	return 0.0;
-}
-
-export float fresnel_function(float3 normal_vector [[anno::unused()]], float3 camera_vector [[anno::unused()]], 
-                                bool invert_fresnel [[anno::unused()]], float power [[anno::unused()]], 
-                                bool use_cheap_contrast [[anno::unused()]], float cheap_contrast_dark [[anno::unused()]], float cheap_contrast_bright [[anno::unused()]], 
-                                bool clamp_fresnel_dot_product [[anno::unused()]])
-[[
-    anno::description("Fresnel Function"),
-    anno::noinline()
-]]
-{
-	return 0.0;
-}
-
-export float3 camera_vector(uniform bool up_z = true)
-[[
-    anno::description("Camera Vector"),
-    anno::noinline()
-]]
-{
-	// assume camera postion is 0,0,0
-	return math::normalize(float3(0) - convert_to_left_hand(state::transform_point(state::coordinate_internal,state::coordinate_world,state::position()), up_z));
-}
-
-export float pixel_depth()
-[[
-    anno::description("Pixel Depth"),
-    anno::noinline()
-]]
-{
-	return 256.0f;
-}
-
-export float scene_depth()
-[[
-    anno::description("Scene Depth")
-]]
-{
-	return 65500.0f;
-}
-
-export float3 scene_color()
-[[
-    anno::description("Scene Color")
-]]
-{
-	return float3(1.0f);
-}
-
-export float4 vertex_color()
-[[
-    anno::description("Vertex Color"),
-    anno::noinline()
-]]
-{
-	return float4(1.0f);
-}
-
-export float4 vertex_color_from_coordinate(int VertexColorCoordinateIndex)
-[[
-    anno::description("Vertex Color for float2 PrimVar"),
-    anno::noinline()
-]]
-{
-	// Kit only supports 4 uv sets, 2 uvs are available to vertex color. if vertex color index is invalid, output the constant WHITE color intead
-	return (VertexColorCoordinateIndex > 2) ? float4(1.0f) : float4(state::texture_coordinate(VertexColorCoordinateIndex).x, state::texture_coordinate(VertexColorCoordinateIndex).y, state::texture_coordinate(VertexColorCoordinateIndex+1).x, state::texture_coordinate(VertexColorCoordinateIndex+1).y);
-}
-
-export float3 camera_position()
-[[
-    anno::description("Camera Position"),
-    anno::noinline()
-]]
-{
-	return float3(1000.0f, 0, 0);
-}
-
-export float3 rotate_about_axis(float4 NormalizedRotationAxisAndAngle, float3 PositionOnAxis, float3 Position)
-[[
-    anno::description("Rotates Position about the given axis by the given angle")
-]]
-{
-	// Project Position onto the rotation axis and find the closest point on the axis to Position
-	float3 NormalizedRotationAxis = float3(NormalizedRotationAxisAndAngle.x,NormalizedRotationAxisAndAngle.y,NormalizedRotationAxisAndAngle.z);
-	float3 ClosestPointOnAxis = PositionOnAxis + NormalizedRotationAxis * math::dot(NormalizedRotationAxis, Position - PositionOnAxis);
-	// Construct orthogonal axes in the plane of the rotation
-	float3 UAxis = Position - ClosestPointOnAxis;
-	float3 VAxis = math::cross(NormalizedRotationAxis, UAxis);
-	float[2] SinCosAngle = math::sincos(NormalizedRotationAxisAndAngle.w);
-	// Rotate using the orthogonal axes
-	float3 R = UAxis * SinCosAngle[1] + VAxis * SinCosAngle[0];
-	// Reconstruct the rotated world space position
-	float3 RotatedPosition = ClosestPointOnAxis + R;
-	// Convert from position to a position offset
-	return RotatedPosition - Position;
-}
-
-export float2 rotate_scale_offset_texcoords(float2 InTexCoords, float4 InRotationScale, float2 InOffset)
-[[
-    anno::description("Returns a float2 texture coordinate after 2x2 transform and offset applied")
-]]
-{
-	return float2(math::dot(InTexCoords, float2(InRotationScale.x, InRotationScale.y)), math::dot(InTexCoords, float2(InRotationScale.z, InRotationScale.w))) + InOffset;
-}
-
-export float3 reflection_custom_world_normal(float3 WorldNormal, bool bNormalizeInputNormal, uniform bool up_z = true)
-[[
-    anno::description("Reflection vector about the specified world space normal")
-]]
-{
-	if (bNormalizeInputNormal)
-	{
-		WorldNormal = math::normalize(WorldNormal);
-	}
-
-	return -camera_vector(up_z) + WorldNormal * math::dot(WorldNormal, camera_vector(up_z)) * 2.0;
-}
-
-export float3 reflection_vector(uniform bool up_z = true)
-[[
-    anno::description("Reflection Vector"),
-    anno::noinline()
-]]
-{
-    float3 normal = convert_to_left_hand(state::transform_normal(state::coordinate_internal,state::coordinate_world,state::normal()), up_z, false);
-	return reflection_custom_world_normal(normal, false, up_z);
-}
-
-export float dither_temporalAA(float AlphaThreshold = 0.5f, float Random = 1.0f [[anno::unused()]])
-[[
-    anno::description("Dither TemporalAA"),
-    anno::noinline()
-]]
-{
-	return AlphaThreshold;
-}
-
-export float3 black_body( float Temp )
-[[
-    anno::description("Black Body"),
-	anno::noinline()
-]]
-{
-	float u = ( 0.860117757f + 1.54118254e-4f * Temp + 1.28641212e-7f * Temp*Temp ) / ( 1.0f + 8.42420235e-4f * Temp + 7.08145163e-7f * Temp*Temp );
-	float v = ( 0.317398726f + 4.22806245e-5f * Temp + 4.20481691e-8f * Temp*Temp ) / ( 1.0f - 2.89741816e-5f * Temp + 1.61456053e-7f * Temp*Temp );
-
-	float x = 3*u / ( 2*u - 8*v + 4 );
-	float y = 2*v / ( 2*u - 8*v + 4 );
-	float z = 1 - x - y;
-
-	float Y = 1;
-	float X = Y/y * x;
-	float Z = Y/y * z;
-
-	float3x3 XYZtoRGB = float3x3(
-		float3(3.2404542, -1.5371385, -0.4985314),
-		float3(-0.9692660,  1.8760108,  0.0415560),
-		float3(0.0556434, -0.2040259,  1.0572252)
-	);
-
-	return XYZtoRGB * float3( X, Y, Z ) * math::pow( 0.0004 * Temp, 4 );
-}
-
-export float per_instance_random(uniform texture_2d PerlinNoiseGradientTexture, int NumberInstances)
-[[
-    anno::description("Per Instance Random"),
-	anno::noinline()
-]]
-{
-	float weight = state::object_id() / float(NumberInstances);	
-	return NumberInstances == 0 ? 0.0 : tex::lookup_float4(PerlinNoiseGradientTexture, float2(weight, 1.0 - weight), tex::wrap_repeat, tex::wrap_repeat).x;
-}
-
-//------------------ Hair from UE4 -----------------------
-float3 hair_absorption_to_color(float3 A)
-{
-	const float B = 0.3f;
-	float b2 = B * B;
-	float b3 = B * b2;
-	float b4 = b2 * b2;
-	float b5 = B * b4;
-	float D = (5.969f - 0.215f * B + 2.532f * b2 - 10.73f * b3 + 5.574f * b4 + 0.245f * b5);
-	return math::exp(-math::sqrt(A) * D);
-}
-
-float3 hair_color_to_absorption(float3 C)
-{
-	const float B = 0.3f;
-	float b2 = B * B;
-	float b3 = B * b2;
-	float b4 = b2 * b2;
-	float b5 = B * b4;
-	float D = (5.969f - 0.215f * B + 2.532f * b2 - 10.73f * b3 + 5.574f * b4 + 0.245f * b5);
-	return math::pow(math::log(C) / D, 2.0f);
-}
-
-export float3 get_hair_color_from_melanin(float InMelanin, float InRedness, float3 InDyeColor)
-[[
-    anno::description("Hair Color")
-]]
-{
-	InMelanin = math::saturate(InMelanin);
-	InRedness = math::saturate(InRedness);
-	float Melanin		= -math::log(math::max(1 - InMelanin, 0.0001f));
-	float Eumelanin 	= Melanin * (1 - InRedness);
-	float Pheomelanin = Melanin * InRedness;
-
-	float3 DyeAbsorption = hair_color_to_absorption(math::saturate(InDyeColor));
-	float3 Absorption = Eumelanin * float3(0.506f, 0.841f, 1.653f) + Pheomelanin * float3(0.343f, 0.733f, 1.924f);
-
-	return hair_absorption_to_color(Absorption + DyeAbsorption);
-}
-
-export float3 local_object_bounds_min()
-[[
-    anno::description("Local Object Bounds Min"),
-	anno::noinline()
-]]
-{
-	return float3(0.0);
-}
-
-export float3 local_object_bounds_max()
-[[
-    anno::description("Local Object Bounds Max"),
-	anno::noinline()
-]]
-{
-	return float3(100.0);
-}
-
-export float3 object_bounds()
-[[
-    anno::description("Object Bounds"),
-	anno::noinline()
-]]
-{
-	return float3(100.0);
-}
-
-export float object_radius()
-[[
-    anno::description("Object Radius"),
-	anno::noinline()
-]]
-{
-	return 100.0f;
-}
-
-export float3 object_world_position(uniform bool up_z = true)
-[[
-    anno::description("Object World Position"),
-	anno::noinline()
-]]
-{
-	return convert_to_left_hand(state::transform_point(state::coordinate_internal,state::coordinate_world,state::position()), up_z)*state::meters_per_scene_unit()*100.0;
-}
-
-export float3 object_orientation()
-[[
-    anno::description("Object Orientation"),
-	anno::noinline()
-]]
-{
-	return float3(0);
-}
-
-export float rcp(float x)
-[[
-    anno::description("hlsl rcp"),
-	anno::noinline()
-]]
-{
-	return 1.0f / x;
-}
-
-export float2 rcp(float2 x)
-[[
-    anno::description("hlsl rcp"),
-	anno::noinline()
-]]
-{
-	return 1.0f / x;
-}
-
-export float3 rcp(float3 x)
-[[
-    anno::description("hlsl rcp"),
-	anno::noinline()
-]]
-{
-	return 1.0f / x;
-}
-
-export float4 rcp(float4 x)
-[[
-    anno::description("hlsl rcp"),
-	anno::noinline()
-]]
-{
-	return 1.0f / x;
-}
-
-export int BitFieldExtractI32(int Data, int Size, int Offset)
-[[
-    anno::description("BitFieldExtractI32 int"),
-	anno::noinline()
-]]
-{
-	Size &= 3;
-	Offset &= 3;
-
-	if (Size == 0)
-		return 0;
-	else if (Offset + Size < 32)
-		return (Data << (32 - Size - Offset)) >> (32 - Size);
-	else
-		return Data >> Offset;
-}
-
-export int BitFieldExtractI32(float Data, float Size, float Offset)
-[[
-    anno::description("BitFieldExtractI32 float"),
-	anno::noinline()
-]]
-{
-	return BitFieldExtractI32(int(Data), int(Size), int(Offset));
-}
-
-export int BitFieldExtractU32(float Data, float Size, float Offset)
-[[
-    anno::description("BitFieldExtractU32 float"),
-	anno::noinline()
-]]
-{
-	return BitFieldExtractI32(Data, Size, Offset);
-}
-
-export int BitFieldExtractU32(int Data, int Size, int Offset)
-[[
-    anno::description("BitFieldExtractU32 int"),
-	anno::noinline()
-]]
-{
-	return BitFieldExtractI32(Data, Size, Offset);
-}
-
-export float3 EyeAdaptationInverseLookup(float3 LightValue, float Alpha)
-[[
-    anno::description("EyeAdaptationInverseLookup"),
-	anno::noinline()
-]]
-{
-	float Adaptation = 1.0f;
-
-	// When Alpha=0.0, we want to multiply by 1.0. when Alpha = 1.0, we want to multiply by 1/Adaptation.
-	// So the lerped value is:
-	//     LerpLogScale = Lerp(log(1),log(1/Adaptaiton),T)
-	// Which is simplified as:
-	//     LerpLogScale = Lerp(0,-log(Adaptation),T)
-	//     LerpLogScale = -T * logAdaptation;
-
-	float LerpLogScale = -Alpha * math::log(Adaptation);
-	float Scale = math::exp(LerpLogScale);
-	return LightValue * Scale;
-}
+version https://git-lfs.github.com/spec/v1
+oid sha256:edd3067b28e9e123c8140a132c6cc33a8c555def0a7b22b50e174e5f26532ff3
+size 50693

kujiale_0042/Materials/OmniUe4Translucent.mdl

@@ -1,233 +1,3 @@
-/***************************************************************************************************
- * Copyright 2020 NVIDIA Corporation. All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- *  * Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- *  * Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- *  * Neither the name of NVIDIA CORPORATION nor the names of its
- *    contributors may be used to endorse or promote products derived
- *    from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
- * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
- * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
- * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- **************************************************************************************************/
-
-//* 1.0.0 - first version
-//* 1.0.1 - Emissive color affected by opacity
-//        - Support opacity mask
-//* 1.0.2 - Unlit translucent
-//* 1.0.3 - specular bsdf instead of microfacet ggx smith bsdf
-//* 1.0.4 - using absolute import paths when importing standard modules
-
-mdl 1.3;
-
-import ::df::*;
-import ::state::*;
-import ::math::*;
-import ::tex::*;
-import ::anno::*;
-
-float emissive_multiplier()
-[[
-    anno::description("the multiplier to convert UE4 emissive to raw data"),
-    anno::noinline()
-]]
-{
-    return 20.0f * 128.0f;
-}
-
-color get_translucent_tint(color base_color, float opacity)
-[[
-    anno::description("base color of UE4 translucent"),
-    anno::noinline()
-]]
-{
-	return math::lerp(color(1.0), base_color, opacity);
-}
-
-// Just for UE4 distilling
-float get_translucent_opacity(float opacity)
-[[
-	anno::noinline()
-]]
-{
-	return opacity;
-}
-
-color get_emissive_intensity(color emissive, float opacity)
-[[
-    anno::description("emissive color of UE4 translucent"),
-    anno::noinline()
-]]
-{
-	return emissive * opacity;
-}
-
-float3 tangent_space_normal(
-    float3 normal = float3(0.0,0.0,1.0),
-    float3 tangent_u = state::texture_tangent_u(0),
-	float3 tangent_v = state::texture_tangent_v(0)
-)
-[[
-    anno::description("Interprets the vector in tangent space"),
-    anno::noinline()
-]]
-{
-    return math::normalize(
-        tangent_u * normal.x -
-        tangent_v * normal.y + /* flip_tangent_v */
-        state::normal() * (normal.z));
-}
-
-float3 world_space_normal(
-    float3 normal = float3(0.0,0.0,1.0),
-    float3 tangent_u = state::texture_tangent_u(0),
-    float3 tangent_v = state::texture_tangent_v(0)
-)
-[[
-    anno::description("Interprets the vector in world space"),
-    anno::noinline()
-]]
-{
-    return tangent_space_normal(
-        math::normalize(
-        normal.x * float3(tangent_u.x, tangent_v.x, state::normal().x) -
-        normal.y * float3(tangent_u.y, tangent_v.y, state::normal().y) +
-        normal.z * float3(tangent_u.z, tangent_v.z, state::normal().z)),
-        tangent_u,
-        tangent_v
-    );
-}
-
-export material OmniUe4Translucent(
-	float3 base_color = float3(0.0, 0.0, 0.0),
-	float metallic = 0.0,
-	float roughness = 0.5,
-	float specular = 0.5,
-	float3 normal = float3(0.0,0.0,1.0),
-    uniform bool enable_opacity = true,
-	float opacity = 1.0,
-    float opacity_mask = 1.0,
-	float3 emissive_color = float3(0.0, 0.0, 0.0),
-	float3 displacement = float3(0.0),
-	uniform float refraction = 1.0,
-	uniform bool two_sided = false,
-	uniform bool is_tangent_space_normal = true,
-	uniform bool is_unlit = false
-)
-[[
-	anno::display_name("Omni UE4 Translucent"),
-	anno::description("Omni UE4 Translucent, supports UE4 Translucent shading model"),
-	anno::version( 1, 0, 0),
-	anno::author("NVIDIA CORPORATION"), 
-	anno::key_words(string[]("omni", "UE4", "omniverse", "translucent"))
-]]
- = let {     
-	color final_base_color = math::saturate(base_color);
-	float final_metallic = math::min(math::max(metallic, 0.0f), 0.99f);
-	float final_roughness = math::saturate(roughness);
-	float final_specular = math::saturate(specular);
-	color final_emissive_color = math::max(emissive_color, 0.0f) * emissive_multiplier(); /*factor for converting ue4 emissive to raw value*/
-	float final_opacity = math::saturate(opacity);
-	float3 final_normal = math::normalize(normal);
- 
- 
-  // - compute final roughness by squaring the "roughness" parameter
-   float alpha = final_roughness * final_roughness;
-   // reduce the reflectivity at grazing angles to avoid "dark edges" for high roughness due to the layering
-   float grazing_refl = math::max((1.0 - final_roughness), 0.0);
-
-	float3 the_normal =  is_unlit ? state::normal() : 
-							(is_tangent_space_normal ? 
-                            tangent_space_normal(
-                                            normal:         final_normal,
-                                            tangent_u:      state::texture_tangent_u(0),
-                                            tangent_v:      state::texture_tangent_v(0)
-                            ) : world_space_normal(
-                                            normal:         final_normal,
-                                            tangent_u:      state::texture_tangent_u(0),
-                                            tangent_v:      state::texture_tangent_v(0)
-                            ));
-
-   // for the dielectric component we layer the glossy component on top of the diffuse one,
-   // the glossy layer has no color tint
-       
-   bsdf dielectric_component = df::custom_curve_layer(
-       weight: final_specular,
-       normal_reflectivity: 0.08,
-       grazing_reflectivity: grazing_refl,
-       layer: df::microfacet_ggx_smith_bsdf(roughness_u: alpha),
-       base: df::diffuse_reflection_bsdf(tint: final_base_color));
-
-   // the metallic component doesn't have a diffuse component, it's only glossy
-   // base_color is applied to tint it
-   bsdf metallic_component = df::microfacet_ggx_smith_bsdf(tint: final_base_color, roughness_u: alpha);
-
-   // final BSDF is a linear blend between dielectric and metallic component
-   bsdf dielectric_metal_mix =
-       df::normalized_mix(
-           components:
-               df::bsdf_component[](
-                   df::bsdf_component(
-                       component: metallic_component,
-                       weight: final_metallic),
-                   df::bsdf_component(
-                       component: dielectric_component,
-                       weight: 1.0-final_metallic)
-               )
-       );
- 
-	bsdf frosted_bsdf = df::specular_bsdf(
-									tint: color(1),
-									mode: df::scatter_reflect_transmit
-									);							
-	
-	bsdf final_mix_bsdf =
-	   is_unlit ? df::specular_bsdf(
-							tint: get_translucent_tint(base_color: final_base_color, opacity: final_opacity),
-							mode: df::scatter_reflect_transmit
-							)
-	   : df::normalized_mix(
-           components:
-               df::bsdf_component[](
-                   df::bsdf_component(
-                       component: dielectric_metal_mix,
-                       weight: get_translucent_opacity(final_opacity)),
-                   df::bsdf_component(
-                       component: frosted_bsdf,
-                       weight: 1.0-get_translucent_opacity(final_opacity))
-               )
-       );
-} 
-in material(
-	thin_walled: two_sided, // Graphene?
-	ior: color(refraction), //refraction
-	surface: material_surface(
-		scattering: final_mix_bsdf,
-		emission:
-            material_emission (
-                emission:  df::diffuse_edf (),
-                intensity: get_emissive_intensity(emissive: final_emissive_color, opacity: final_opacity)
-                )
-	),
-	
-	geometry: material_geometry(
-		displacement: displacement,
-		normal: the_normal,
-        cutout_opacity: enable_opacity ? opacity_mask : 1.0
-	)	
-);
+version https://git-lfs.github.com/spec/v1
+oid sha256:f8f8398c2f421a2176827f7012a80f65a03c0bd2067d768e2094a4350f67a0af
+size 8535

kujiale_0042/Materials/WorldGridMaterial.mdl

@@ -1,77 +1,3 @@
-mdl 1.6;
-
-import ::math::*;
-import ::state::*;
-import ::tex::*;
-import ::anno::*;
-import ::scene::*;
-using .::OmniUe4Function import *;
-using .::OmniUe4Base import *;
-
-export annotation sampler_color();
-export annotation sampler_normal();
-export annotation sampler_grayscale();
-export annotation sampler_alpha();
-export annotation sampler_masks();
-export annotation sampler_distancefield();
-export annotation dither_masked_off();
-export annotation world_space_normal();
-
-export material WorldGridMaterial(
-	int MaxTexCoordIndex = 3
-	[[
-		anno::hidden()
-	]])
- = 
-	let {
-	float3 WorldPositionOffset_mdl = float3(0.0,0.0,0.0);
-	float2 CustomizedUV0_mdl = float2(state::texture_coordinate(math::min(0,MaxTexCoordIndex)).x,1.0-state::texture_coordinate(math::min(0,MaxTexCoordIndex)).y);
-
-	float2 Local0 = (CustomizedUV0_mdl / 2.0);
-	float2 Local1 = (Local0 / 0.05);
-	float4 Local2 = ::unpack_normal_map(tex::lookup_float4(texture_2d("./Textures/T_Default_Material_Grid_N.png",::tex::gamma_linear),float2(Local1.x,1.0-Local1.y),tex::wrap_repeat,tex::wrap_repeat));
-	float3 Local3 = (float3(Local2.x,Local2.y,Local2.z) * float3(0.3,0.3,1.0));
-
-	float3 Normal_mdl = Local3;
-
-	float2 Local4 = (CustomizedUV0_mdl * 20.0);
-	float4 Local5 = tex::lookup_float4(texture_2d("./Textures/T_Default_Material_Grid_M.png",::tex::gamma_linear),float2(Local4.x,1.0-Local4.y),tex::wrap_repeat,tex::wrap_repeat);
-	float Local6 = math::lerp(0.4,1.0,Local5.x);
-	float Local7 = (1.0 - Local6);
-	float2 Local8 = (Local0 / 0.1);
-	float4 Local9 = tex::lookup_float4(texture_2d("./Textures/T_Default_Material_Grid_M.png",::tex::gamma_linear),float2(Local8.x,1.0-Local8.y),tex::wrap_repeat,tex::wrap_repeat);
-	float Local10 = math::lerp(Local9.y,1.0,0.0);
-	float Local11 = math::lerp(Local6,Local7,Local10);
-	float4 Local12 = tex::lookup_float4(texture_2d("./Textures/T_Default_Material_Grid_M.png",::tex::gamma_linear),float2(Local0.x,1.0-Local0.y),tex::wrap_repeat,tex::wrap_repeat);
-	float Local13 = math::lerp(Local9.y,0.0,0.0);
-	float Local14 = (Local12.y + Local13);
-	float Local15 = math::lerp(Local14,0.5,0.5);
-	float Local16 = math::lerp(0.295,0.66,Local15);
-	float Local17 = (Local16 * 0.5);
-	float Local18 = (Local11 * Local17);
-	float Local19 = math::lerp(0.0,0.5,Local12.y);
-	float Local20 = math::lerp(0.7,1.0,Local9.y);
-	float Local21 = math::lerp(Local20,1.0,0.0);
-	float Local22 = (Local21 * 1.0);
-	float Local23 = (Local19 + Local22);
-	float Local24 = math::min(math::max(Local23,0.0),1.0);
-
-	float3 EmissiveColor_mdl = float3(0.0,0.0,0.0);
-	float OpacityMask_mdl = 1.0;
-	float3 BaseColor_mdl = float3(Local18,Local18,Local18);
-	float Metallic_mdl = 0.0;
-	float Specular_mdl = 0.5;
-	float Roughness_mdl = Local24;
-	float SurfaceThickness_mdl = 0.01;
-
-	} in
-		::OmniUe4Base(
-			base_color: BaseColor_mdl,
-			metallic: Metallic_mdl,
-			roughness: Roughness_mdl,
-			specular: Specular_mdl,
-			normal: Normal_mdl,
-			opacity: OpacityMask_mdl,
-			emissive_color: EmissiveColor_mdl,
-			displacement: WorldPositionOffset_mdl,
-			two_sided: false);
+version https://git-lfs.github.com/spec/v1
+oid sha256:d9a289a30070c90a3500f832985c683c133587bfdcab00ccf3a2af35d8fa25fe
+size 3108