// Upgrade NOTE: excluded shader from OpenGL ES 2.0 because it uses non-square matrices
#pragma exclude_renderers gles


#define MaterialFloat float
#define MaterialFloat2 float2
#define MaterialFloat3 float3
#define MaterialFloat4 float4
#define MaterialFloat3x3 float3x3
#define MaterialFloat4x4 float4x4 
#define MaterialFloat4x3 float4x3 

#define LOOP UNITY_LOOP
#define UNROLL UNITY_UNROLL

/*struct FTexCoordScalesParams
{

	int2 PixelPosition;


	float4 OneOverDDU;
	float4 OneOverDDV;


	float MinScale;
	float MaxScale;

	float TexSample;


	float4 ScalesPerIndex;
};*/
#define FTexCoordScalesParams float2

struct FMaterialParticleParameters
{
	/** Relative time [0-1]. */
	half RelativeTime;
	/** Fade amount due to motion blur. */
	half MotionBlurFade;
	/** Random value per particle [0-1]. */
	half Random;
	/** XYZ: Direction, W: Speed. */
	half4 Velocity;
	/** Per-particle color. */
	half4 Color;
	/** Particle translated world space position and size(radius). */
	float4 TranslatedWorldPositionAndSize;
	/** Macro UV scale and bias. */
	half4 MacroUV;
	/** Dynamic parameter used by particle systems. */
	half4 DynamicParameter;
	/** mesh particle orientation */
	float4x4 LocalToWorld;

	#if USE_PARTICLE_SUBUVS
	/** SubUV texture coordinates*/
	MaterialFloat2 SubUVCoords[ 2 ];
	/** SubUV interpolation value*/
	MaterialFloat SubUVLerp;
	#endif

	/** The size of the particle. */
	float2 Size;
};

struct FPixelMaterialInputs
{
	MaterialFloat3 EmissiveColor;
	MaterialFloat Opacity;
	MaterialFloat OpacityMask;
	MaterialFloat3 BaseColor;
	MaterialFloat Metallic;
	MaterialFloat Specular;
	MaterialFloat Roughness;
	MaterialFloat3 Normal;
	MaterialFloat AmbientOcclusion;	
	MaterialFloat2 Refraction;
	MaterialFloat PixelDepthOffset;
	MaterialFloat Subsurface;	
	MaterialFloat ShadingModel;
	//4.25
	MaterialFloat Anisotropy;
	MaterialFloat3 Tangent;
};

struct FMaterialVertexParameters
{
	// Position in the translated world (VertexFactoryGetWorldPosition).
	// Previous position in the translated world (VertexFactoryGetPreviousWorldPosition) if
	//    computing material's output for previous frame (See {BasePassVertex,Velocity}Shader.usf).
	float3 WorldPosition;
	// TangentToWorld[2] is WorldVertexNormal
	half3x3 TangentToWorld;
#if USE_INSTANCING
	/** Per-instance properties. */
	float4x4 InstanceLocalToWorld;
	float3 InstanceLocalPosition;
	float4 PerInstanceParams;
	uint InstanceId;
	uint InstanceOffset;

#elif IS_MESHPARTICLE_FACTORY 
	/** Per-particle properties. */
	float4x4 InstanceLocalToWorld;
#endif
	// If either USE_INSTANCING or (IS_MESHPARTICLE_FACTORY && FEATURE_LEVEL >= FEATURE_LEVEL_SM4)
	// is true, PrevFrameLocalToWorld is a per-instance transform
	float4x4 PrevFrameLocalToWorld;

	float3 PreSkinnedPosition;
	float3 PreSkinnedNormal;

#if GPU_SKINNED_MESH_FACTORY
	float3 PreSkinOffset;
	float3 PostSkinOffset;
#endif

	half4 VertexColor;
#if NUM_MATERIAL_TEXCOORDS_VERTEX
	float2 TexCoords[ NUM_MATERIAL_TEXCOORDS_VERTEX ];
#if ES3_1_PROFILE
	float2 TexCoordOffset; // Offset for UV localization for large UV values
#endif
#endif

	/** Per-particle properties. Only valid for particle vertex factories. */
	FMaterialParticleParameters Particle;

	// Index into View.PrimitiveSceneData
	uint PrimitiveId;

#if WATER_MESH_FACTORY
	uint WaterWaveParamIndex;
#endif
};

struct FMaterialPixelParameters
{
	#if NUM_TEX_COORD_INTERPOLATORS
	float2 TexCoords[ NUM_TEX_COORD_INTERPOLATORS ];
	#endif

	/** Interpolated vertex color, in linear color space. */
	half4 VertexColor;//TBD

	/** Normalized world space normal. */
	half3 WorldNormal;

	/** Normalized world space reflected camera vector. */
	half3 ReflectionVector;

	/** Normalized world space camera vector, which is the vector from the point being shaded to the camera position. */
	half3 CameraVector;

	/** World space light vector, only valid when rendering a light function. */
	half3 LightVector;

	/**
	* Like SV_Position (.xy is pixel position at pixel center, z:DeviceZ, .w:SceneDepth)
	* using shader generated value SV_POSITION
	* Note: this is not relative to the current viewport.  RelativePixelPosition = MaterialParameters.SvPosition.xy - View.ViewRectMin.xy;
	*/
	float4 SvPosition;

	/** Post projection position reconstructed from SvPosition, before the divide by W. left..top -1..1, bottom..top -1..1  within the viewport, W is the SceneDepth */
	float4 ScreenPosition;

	half UnMirrored;

	half TwoSidedSign;

	/**
	* Orthonormal rotation-only transform from tangent space to world space
	* The transpose(TangentToWorld) is WorldToTangent, and TangentToWorld[2] is WorldVertexNormal
	*/
	half3x3 TangentToWorld;

	/**
	* Interpolated worldspace position of this pixel
	* todo: Make this TranslatedWorldPosition and also rename the VS/DS/HS WorldPosition to be TranslatedWorldPosition
	*/
	float3 AbsoluteWorldPosition;

	/**
	* Interpolated worldspace position of this pixel, centered around the camera
	*/
	float3 WorldPosition_CamRelative;

	/**
	* Interpolated worldspace position of this pixel, not including any world position offset or displacement.
	* Only valid if shader is compiled with NEEDS_WORLD_POSITION_EXCLUDING_SHADER_OFFSETS, otherwise just contains 0
	*/
	float3 WorldPosition_NoOffsets;

	/**
	* Interpolated worldspace position of this pixel, not including any world position offset or displacement.
	* Only valid if shader is compiled with NEEDS_WORLD_POSITION_EXCLUDING_SHADER_OFFSETS, otherwise just contains 0
	*/
	float3 WorldPosition_NoOffsets_CamRelative;

	/** Offset applied to the lighting position for translucency, used to break up aliasing artifacts. */
	half3 LightingPositionOffset;

	float AOMaterialMask;

	#if LIGHTMAP_UV_ACCESS
	float2	LightmapUVs;
	#endif

	#if USE_INSTANCING
	half4 PerInstanceParams;
	#endif

	// Index into View.PrimitiveSceneData
	uint PrimitiveId;

	/** Per-particle properties. Only valid for particle vertex factories. */
	FMaterialParticleParameters Particle;

	#if (ES2_PROFILE || ES3_1_PROFILE)
	float4 LayerWeights;
	#endif

	#if TEX_COORD_SCALE_ANALYSIS
	/** Parameters used by the MaterialTexCoordScales shader. */
	FTexCoordScalesParams TexCoordScalesParams;
	#endif

	#if POST_PROCESS_MATERIAL && (FEATURE_LEVEL <= FEATURE_LEVEL_ES3_1)
	/** Used in mobile custom pp material to preserve original SceneColor Alpha */
	half BackupSceneColorAlpha;
	#endif

	#if COMPILER_HLSL
	// Workaround for "error X3067: 'GetObjectWorldPosition': ambiguous function call"
	// Which happens when FMaterialPixelParameters and FMaterialVertexParameters have the same number of floats with the HLSL compiler ver 9.29.952.3111
	// Function overload resolution appears to identify types based on how many floats / ints / etc they contain
	uint Dummy;
	#endif

	FTexCoordScalesParams TexCoordScalesParams;

	float3 WorldTangent;
};

float4 View_TemporalAAParams;

//To be moved into InitializeExpressions
float UE_Material_PerFrameScalarExpression0;
float UE_Material_PerFrameScalarExpression1;

MaterialFloat3 ReflectionAboutCustomWorldNormal( FMaterialPixelParameters Parameters, MaterialFloat3 WorldNormal, bool bNormalizeInputNormal )
{
	if( bNormalizeInputNormal )
	{
		WorldNormal = normalize( WorldNormal );
	}

	return -Parameters.CameraVector + WorldNormal * dot( WorldNormal, Parameters.CameraVector ) * 2.0;
}
MaterialFloat4 ProcessMaterialColorTextureLookup(MaterialFloat4 TextureValue)
{
#if (ES2_PROFILE || ES3_1_PROFILE) && !METAL_PROFILE // Metal supports sRGB textures
	#if MOBILE_EMULATION
	if( View.MobilePreviewMode > 0.5f)
	{
		// undo HW srgb->lin
		TextureValue.rgb = pow(TextureValue.rgb, 1.0f / 2.2f); // TODO: replace with a more accurate lin -> sRGB conversion.
	}
	#endif

	// sRGB read approximation
	TextureValue.rgb *= TextureValue.rgb;
#endif 
	return TextureValue;
}
float  ProcessMaterialLinearGreyscaleTextureLookup( float  TextureValue )
{
	return TextureValue;
}

#if DECAL_PRIMITIVE

float3 TransformTangentNormalToWorld( in FMaterialPixelParameters Parameters, float3 TangentNormal )
{
	// To transform the normals use tranpose(Inverse(DecalToWorld)) = transpose(WorldToDecal)
	// But we want to only rotate the normals (we don't want to non-uniformaly scale them).
	// We assume the matrix is only a scale and rotation, and we remove non-uniform scale:
	float3 lengthSqr = { length2( DecalToWorld._m00_m01_m02 ),
		length2( DecalToWorld._m10_m11_m12 ),
		length2( DecalToWorld._m20_m21_m22 ) };

	float3 scale = rsqrt( lengthSqr );

	// Pre-multiply by the inverse of the non-uniform scale in DecalToWorld
	float4 ScaledNormal = float4( -TangentNormal.z * scale.x, TangentNormal.y * scale.y, TangentNormal.x * scale.z, 0.f );

	// Compute the normal 
	return normalize( mul( ScaledNormal, DecalToWorld ).xyz );
}

#else //DECAL_PRIMITIVE

float3 TransformTangentNormalToWorld( in FMaterialPixelParameters Parameters, float3 TangentNormal )
{
	return TangentNormal;// normalize( float3( TransformTangentVectorToWorld( Parameters.TangentToWorld, TangentNormal ) ) );
}

#endif //DECAL_PRIMITIVE

//These 2 are the Unity Normal unpacking functions
/*fixed3 UnpackNormalmapRGorAG( fixed4 packednormal )
{
	// This do the trick
	packednormal.x *= packednormal.w;

	fixed3 normal;
	normal.xy = packednormal.xy * 2 - 1;
	normal.z = sqrt( 1 - saturate( dot( normal.xy, normal.xy ) ) );
	return normal;
}
inline fixed3 UnpackNormal( fixed4 packednormal )
{
#if defined(UNITY_NO_DXT5nm)
	return packednormal.xyz * 2 - 1;
#else
	return UnpackNormalmapRGorAG( packednormal );
#endif
}*/
void swap( inout float x, inout float y )
{
	float temp = x;
	x = y;
	y = temp;
}
MaterialFloat4 UnpackNormalMap( MaterialFloat4 TextureSample )
{
	float3 Unpacked = UnpackNormal( TextureSample );
	//This is needed for textures that don't have flip Green channel on
	Unpacked.x *= -1;
	swap( Unpacked.x, Unpacked.y );
	return MaterialFloat4( Unpacked.xy, Unpacked.z, 1.0f );
}
SamplerState GetMaterialSharedSampler(SamplerState TextureSampler, SamplerState SharedSampler)
{
	return TextureSampler;
}
float3 GetActorWorldPosition()
{
	return UNITY_MATRIX_M[ 3 ];
}
float3 GetActorWorldPosition( uint PrimitiveId )
{
	return UNITY_MATRIX_M[ 3 ];
}
MaterialFloat4 Texture2DSample(Texture2D Tex, SamplerState Sampler, float2 UV)
{
#if COMPUTESHADER
	return tex2D( Tex, UV, 0);
#else
	#if HDRP
		return SAMPLE_TEXTURE2D(Tex, Sampler, UV);
	#else
		return tex2D(Tex, UV);
	#endif
#endif
}
MaterialFloat4 Texture2DSampleGrad( Texture2D Tex, SamplerState Sampler, float2 UV, MaterialFloat2 DDX, MaterialFloat2 DDY )
{
	#if HDRP
		return SAMPLE_TEXTURE2D( Tex, Sampler, UV );// , DDX, DDY );
	#else
		return tex2Dgrad( Tex, UV, DDX, DDY );
	#endif
}
MaterialFloat4 Texture2DSampleLevel( Texture2D Tex, SamplerState Sampler, float2 UV, MaterialFloat Mip )
{
	#if HDRP
		return SAMPLE_TEXTURE2D_LOD( Tex, Sampler, UV, Mip );
	#else
		//tex2Dlod( Tex, float3( UV, Mip ) );
		return tex2D( Tex, float3( UV, Mip ) );
	#endif
}
MaterialFloat4 TextureCubeSample( TextureCube Tex, SamplerState Sampler, float3 UV)
{
	//#if COMPUTESHADER
	//	return Tex.SampleLevel(Sampler, UV, 0);
	//#else
	#if HDRP
		return SAMPLE_TEXTURECUBE(Tex, Sampler, UV);
	#else
		return texCUBE(Tex, UV);
	#endif
	//#endif
}
MaterialFloat4 TextureCubeSampleBias( TextureCube Tex, SamplerState Sampler, float3 UV, MaterialFloat MipBias )
{
#if USE_FORCE_TEXTURE_MIP
	return texCUBEbias( Tex, float4( UV, 0 ) );
#else
	#if HDRP
		return SAMPLE_TEXTURECUBE_BIAS( Tex, Sampler, UV, MipBias );
	#else
		return texCUBEbias( Tex, float4( UV, MipBias ) );
	#endif
#endif
}
MaterialFloat4 TextureCubeSampleLevel( TextureCube Tex, SamplerState Sampler, float3 UV, MaterialFloat Mip )
{
	#if HDRP
		return SAMPLE_TEXTURECUBE_LOD( Tex, Sampler, UV, Mip );
	#else
		return texCUBElod( Tex, float4(UV, Mip) );
	#endif
}
float4  Texture2DSampleBias( Texture2D Tex, SamplerState Sampler, float2 UV, float  MipBias )
{
#if HDRP
	return SAMPLE_TEXTURE2D_BIAS( Tex, Sampler, UV, MipBias );
#else
	return tex2Dbias( Tex, float4( UV, 0, MipBias ) );
#endif
}
half3 GetMaterialNormalRaw(FPixelMaterialInputs PixelMaterialInputs)
{
	return PixelMaterialInputs.Normal;
}

half3 GetMaterialNormal(FMaterialPixelParameters Parameters, FPixelMaterialInputs PixelMaterialInputs)
{
	half3 RetNormal;

	RetNormal = GetMaterialNormalRaw(PixelMaterialInputs);
		
	#if (USE_EDITOR_SHADERS && !(ES2_PROFILE || ES3_1_PROFILE || ESDEFERRED_PROFILE)) || MOBILE_EMULATION
	{
		// this feature is only needed for development/editor - we can compile it out for a shipping build (see r.CompileShadersForDevelopment cvar help)
		half3 OverrideNormal = View.NormalOverrideParameter.xyz;

		#if !MATERIAL_TANGENTSPACENORMAL
			OverrideNormal = Parameters.TangentToWorld[2] * (1 - View.NormalOverrideParameter.w);
		#endif

		RetNormal = RetNormal * View.NormalOverrideParameter.w + OverrideNormal;
	}
	#endif

	return RetNormal;
}
MaterialFloat PositiveClampedPow( MaterialFloat X, MaterialFloat Y )
{
	return pow( max( X, 0.0f ), Y );
}
MaterialFloat2 PositiveClampedPow( MaterialFloat2 X, MaterialFloat2 Y )
{
	return pow( max( X, MaterialFloat2( 0.0f, 0.0f ) ), Y );
}
MaterialFloat3 PositiveClampedPow( MaterialFloat3 X, MaterialFloat3 Y )
{
	return pow( max( X, MaterialFloat3( 0.0f, 0.0f, 0.0f ) ), Y );
}
MaterialFloat4 PositiveClampedPow( MaterialFloat4 X, MaterialFloat4 Y )
{
	return pow( max( X, MaterialFloat4( 0.0f, 0.0f, 0.0f, 0.0f ) ), Y );
}

/** Get the per-instance random value when instancing */
float GetPerInstanceRandom(FMaterialPixelParameters Parameters)
{
#if USE_INSTANCING
	return Parameters.PerInstanceParams.x;
#else
	return 0.5;
#endif
}
float3 GetObjectWorldPosition( FMaterialPixelParameters Parameters )
{
	//TODO
	//return Primitive.ObjectWorldPositionAndRadius.xyz;
	return float3( 0, 0, 0 );
}

MaterialFloat ProcessMaterialGreyscaleTextureLookup( MaterialFloat TextureValue )
{
#if (ES2_PROFILE || ES3_1_PROFILE) && !METAL_PROFILE // Metal supports R8 sRGB
#if MOBILE_EMULATION
	if ( View.MobilePreviewMode > 0.5f )
	{
		// undo HW srgb->lin
		TextureValue = pow( TextureValue, 1.0f / 2.2f ); // TODO: replace with a more accurate lin -> sRGB conversion.
	}
#endif
	// sRGB read approximation
	TextureValue *= TextureValue;
#endif 
	return TextureValue;
}
float3 GetWorldPosition_NoMaterialOffsets( FMaterialPixelParameters Parameters )
{
	return Parameters.WorldPosition_NoOffsets;
}
float3 GetWorldPosition( FMaterialPixelParameters Parameters )
{
	return Parameters.AbsoluteWorldPosition;
}
MaterialFloat4 ProcessMaterialLinearColorTextureLookup( MaterialFloat4 TextureValue )
{
	return TextureValue;
}
float  StoreTexCoordScale( in out FTexCoordScalesParams Params, float2 UV, int TextureReferenceIndex )
{
	/*float GPUScaleX = length( ddx( UV ) );
	float GPUScaleY = length( ddy( UV ) );

	if ( TextureReferenceIndex >= 0 && TextureReferenceIndex <  32 )
	{
		float OneOverCPUScale = OneOverCPUTexCoordScales[ TextureReferenceIndex / 4 ][ TextureReferenceIndex % 4 ];

		int TexCoordIndex = TexCoordIndices[ TextureReferenceIndex / 4 ][ TextureReferenceIndex % 4 ];

		float GPUScale = min( GPUScaleX * GetComponent( Params.OneOverDDU, TexCoordIndex ), GPUScaleY * GetComponent( Params.OneOverDDV, TexCoordIndex ) );


		const bool bUpdateMinMax = ( OneOverCPUScale > 0 && ( AnalysisParams.x == -1 || AnalysisParams.x == TextureReferenceIndex ) );
		Params.MinScale = bUpdateMinMax ? min( Params.MinScale, GPUScale * OneOverCPUScale ) : Params.MinScale;
		Params.MaxScale = bUpdateMinMax ? max( Params.MaxScale, GPUScale * OneOverCPUScale ) : Params.MaxScale;


		const bool bUpdateScale = ( AnalysisParams.y  && Params.PixelPosition.x / 32 == TextureReferenceIndex / 4 );
		Params.ScalesPerIndex[ TextureReferenceIndex % 4 ] = bUpdateScale ? min( Params.ScalesPerIndex[ TextureReferenceIndex % 4 ], GPUScale ) : Params.ScalesPerIndex[ TextureReferenceIndex % 4 ];
	}*/
	return 1.f;
}
float  StoreTexSample( in out FTexCoordScalesParams Params, float4 C, int TextureReferenceIndex )
{
	//Params.TexSample = AnalysisParams.x == TextureReferenceIndex ? lerp( .4f, 1.f, saturate( Luminance( C.rgb ) ) ) : Params.TexSample;

	return 1.f;
}
float3 RotateAboutAxis( float4 NormalizedRotationAxisAndAngle, float3 PositionOnAxis, float3 Position )
{

	float3 ClosestPointOnAxis = PositionOnAxis + NormalizedRotationAxisAndAngle.xyz * dot( NormalizedRotationAxisAndAngle.xyz, Position - PositionOnAxis );

	float3 UAxis = Position - ClosestPointOnAxis;
	float3 VAxis = cross( NormalizedRotationAxisAndAngle.xyz, UAxis );
	float CosAngle;
	float SinAngle;
	sincos( NormalizedRotationAxisAndAngle.w, SinAngle, CosAngle );

	float3 R = UAxis * CosAngle + VAxis * SinAngle;

	float3 RotatedPosition = ClosestPointOnAxis + R;

	return RotatedPosition - Position;
}
float2 SvPositionToBufferUV( float4 SvPosition )
{
	return SvPosition.xy * View_BufferSizeAndInvSize.zw;
}
float2 GetSceneTextureUV( FMaterialPixelParameters Parameters )
{
	return SvPositionToBufferUV( Parameters.SvPosition );
}
MaterialFloat UnMirror( MaterialFloat Coordinate, FMaterialPixelParameters Parameters )
{
	return ( ( Coordinate )*( Parameters.UnMirrored )*0.5 + 0.5 );
}
MaterialFloat2 UnMirrorU( MaterialFloat2 UV, FMaterialPixelParameters Parameters )
{
	return MaterialFloat2( UnMirror( UV.x, Parameters ), UV.y );
}
MaterialFloat2 UnMirrorV( MaterialFloat2 UV, FMaterialPixelParameters Parameters )
{
	return MaterialFloat2( UV.x, UnMirror( UV.y, Parameters ) );
}
MaterialFloat2 UnMirrorUV( MaterialFloat2 UV, FMaterialPixelParameters Parameters )
{
	return MaterialFloat2( UnMirror( UV.x, Parameters ), UnMirror( UV.y, Parameters ) );
}
float4 GetScreenPosition( FMaterialPixelParameters Parameters )
{
	return Parameters.ScreenPosition;
}
float GetPixelDepth(FMaterialPixelParameters Parameters)
{
	//FLATTEN
	//if (View.ViewToClip[3][3] < 1.0f)
	//{
		// Perspective
		return GetScreenPosition(Parameters).w;
	//}
	//else
	//{
	//	// Ortho
	//	return ConvertFromDeviceZ(GetScreenPosition(Parameters).z);
	//}
}
uint Mod( uint a, uint b )
{

	return a % b;
}

uint2 Mod( uint2 a, uint2 b )
{

	return a % b;
}

uint3 Mod( uint3 a, uint3 b )
{

	return a % b;
}
float CalcSceneDepth( float2 ScreenUV )
{
	return 0.0f;
}
float CalcSceneDepth( uint2 PixelPos )
{
	return 0.0f;
}
float2 ScreenPositionToBufferUV( float4 ScreenPosition )
{
	float4 View_ScreenPositionScaleBias = float4( 1, 1, 0, 0 );//TODO

	return float2( ScreenPosition.xy / ScreenPosition.w * View_ScreenPositionScaleBias.xy + View_ScreenPositionScaleBias.wz );
}
float2  ScreenAlignedPosition( float4 ScreenPosition )
{
	return  float2 ( ScreenPositionToBufferUV( ScreenPosition ) );
}
float4 VoronoiCompare(float4 minval, float3 candidate, float3 offset, bool bDistanceOnly)
{
	if (bDistanceOnly)
	{
		return float4( 0, 0, 0, min(minval.w, dot(offset, offset)) );
	}
	else
	{
		float newdist = dot(offset, offset);
		return newdist > minval.w ? minval : float4( candidate, newdist );
	}
}

uint3 Rand3DPCG16(int3 p)
{
	// taking a signed int then reinterpreting as unsigned gives good behavior for negatives
	uint3 v = uint3( 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 * 1664525u + 1013904223u;

	// 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 >> 16u;
}
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 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 normalize(noise) * 0.3090;
	}

	// quality level 4: jitter to anywhere in the cell, needs 4x4x4 search
	return noise;
}
float3 NoiseTileWrap(float3 v, bool bTiling, float RepeatSize)
{
	return bTiling ? ( frac(v / RepeatSize) * RepeatSize ) : v;
}
// 220 instruction Worley noise
float4 VoronoiNoise3D_ALU(float3 v, int Quality, bool bTiling, float RepeatSize, bool bDistanceOnly)
{
	float3 fv = frac(v), fv2 = frac(v + 0.5);
	float3 iv = floor(v), iv2 = 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)
	{
		UNROLL for (offset.x = -1; offset.x <= 1; ++offset.x)
		{
			UNROLL for (offset.y = -1; offset.y <= 1; ++offset.y)
			{
				UNROLL for (offset.z = -1; offset.z <= 1; ++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
	{
		UNROLL for (offset.x = 0; offset.x <= 1; ++offset.x)
		{
			UNROLL for (offset.y = 0; offset.y <= 1; ++offset.y)
			{
				UNROLL for (offset.z = 0; offset.z <= 1; ++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)
	{
		UNROLL for (offset.x = -1; offset.x <= 2; offset.x += 3)
		{
			UNROLL for (offset.y = 0; offset.y <= 1; ++offset.y)
			{
				UNROLL for (offset.z = 0; offset.z <= 1; ++offset.z)
				{
					// along x axis
					p = offset.xyz + VoronoiCornerSample(NoiseTileWrap(iv + offset.xyz, bTiling, RepeatSize), Quality);
					mindist = VoronoiCompare(mindist, iv + p, fv - p, bDistanceOnly);

					// along y axis
					p = offset.yzx + VoronoiCornerSample(NoiseTileWrap(iv + offset.yzx, bTiling, RepeatSize), Quality);
					mindist = VoronoiCompare(mindist, iv + p, fv - p, bDistanceOnly);

					// along z axis
					p = offset.zxy + VoronoiCornerSample(NoiseTileWrap(iv + offset.zxy, bTiling, RepeatSize), Quality);
					mindist = VoronoiCompare(mindist, iv + p, fv - p, bDistanceOnly);
				}
			}
		}
	}

	// transform squared distance to real distance
	return float4( mindist.xyz, sqrt(mindist.w) );
}
float Noise3D_Multiplexer(int Function, float3 Position, int Quality, bool bTiling, uint RepeatSize)
{
	// verified, HLSL compiled out the switch if Function is a constant
	//switch (Function)
	//{
	//	case 0:
	//		return SimplexNoise3D_TEX(Position);
	//	case 1:
	//		return GradientNoise3D_TEX(Position, bTiling, RepeatSize);
	//	case 2:
	//		return FastGradientPerlinNoise3D_TEX(Position);
	//	case 3:
	//		return GradientNoise3D_ALU(Position, bTiling, RepeatSize);
	//	case 4:
	//		return ValueNoise3D_ALU(Position, bTiling, RepeatSize);
		//default:
	return VoronoiNoise3D_ALU(Position, Quality, bTiling, RepeatSize, true).w * 2. - 1.;
	//}
	//return 0;
}

// @param LevelScale usually 2 but higher values allow efficient use of few levels
// @return in user defined range (OutputMin..OutputMax)
MaterialFloat MaterialExpressionNoise(float3 Position, float Scale, int Quality, int Function, bool bTurbulence, uint Levels, float OutputMin, float OutputMax, float LevelScale, float FilterWidth, bool bTiling, float RepeatSize)
{
	Position *= Scale;
	FilterWidth *= Scale;

	float Out = 0.0f;
	float OutScale = 1.0f;
	float InvLevelScale = 1.0f / LevelScale;

	LOOP for (uint i = 0; i < Levels; ++i)
	{
		// fade out noise level that are too high frequent (not done through dynamic branching as it usually requires gradient instructions)
		OutScale *= saturate(1.0 - FilterWidth);

		if (bTurbulence)
		{
			Out += abs(Noise3D_Multiplexer(Function, Position, Quality, bTiling, RepeatSize)) * OutScale;
		}
		else
		{
			Out += Noise3D_Multiplexer(Function, Position, Quality, 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 lerp(OutputMin, OutputMax, Out);
}

#define NUM_CUSTOM_PRIMITIVE_DATA 8 // Num float4s used for custom data. Must match FCustomPrimitiveData::NumCustomPrimitiveDataFloat4s in SceneTypes.h

struct FPrimitiveSceneData
{
	float4x4 LocalToWorld;
	float4 InvNonUniformScaleAndDeterminantSign;
	float4 ObjectWorldPositionAndRadius;
	float4x4 WorldToLocal;
	float4x4 PreviousLocalToWorld;
	float4x4 PreviousWorldToLocal;
	float3 ActorWorldPosition;
	float UseSingleSampleShadowFromStationaryLights;
	float3 ObjectBounds;
	float LpvBiasMultiplier;
	float DecalReceiverMask;
	float PerObjectGBufferData;
	float UseVolumetricLightmapShadowFromStationaryLights;
	float DrawsVelocity;
	float4 ObjectOrientation;
	float4 NonUniformScale;
	float3 LocalObjectBoundsMin;
	uint LightingChannelMask;
	float3 LocalObjectBoundsMax;
	uint LightmapDataIndex;
	float3 PreSkinnedLocalBoundsMin;
	int SingleCaptureIndex;
	float3 PreSkinnedLocalBoundsMax;
	uint OutputVelocity;
	float4 CustomPrimitiveData[ NUM_CUSTOM_PRIMITIVE_DATA ];
};

// Stride of a single primitive's data in float4's, must match C++
#define PRIMITIVE_SCENE_DATA_STRIDE 35

// Fetch from scene primitive buffer
FPrimitiveSceneData GetPrimitiveData( uint PrimitiveId )
{
	// Note: layout must match FPrimitiveSceneShaderData in C++
	// Relying on optimizer to remove unused loads

	FPrimitiveSceneData PrimitiveData;
	uint PrimitiveBaseOffset = PrimitiveId * PRIMITIVE_SCENE_DATA_STRIDE;
	PrimitiveData.LocalToWorld[ 0 ] = View.PrimitiveSceneData[ PrimitiveBaseOffset + 0 ];
	PrimitiveData.LocalToWorld[ 1 ] = View.PrimitiveSceneData[ PrimitiveBaseOffset + 1 ];
	PrimitiveData.LocalToWorld[ 2 ] = View.PrimitiveSceneData[ PrimitiveBaseOffset + 2 ];
	PrimitiveData.LocalToWorld[ 3 ] = View.PrimitiveSceneData[ PrimitiveBaseOffset + 3 ];

	PrimitiveData.InvNonUniformScaleAndDeterminantSign = View.PrimitiveSceneData[ PrimitiveBaseOffset + 4 ];
	PrimitiveData.ObjectWorldPositionAndRadius = View.PrimitiveSceneData[ PrimitiveBaseOffset + 5 ];

	PrimitiveData.WorldToLocal[ 0 ] = View.PrimitiveSceneData[ PrimitiveBaseOffset + 6 ];
	PrimitiveData.WorldToLocal[ 1 ] = View.PrimitiveSceneData[ PrimitiveBaseOffset + 7 ];
	PrimitiveData.WorldToLocal[ 2 ] = View.PrimitiveSceneData[ PrimitiveBaseOffset + 8 ];
	PrimitiveData.WorldToLocal[ 3 ] = View.PrimitiveSceneData[ PrimitiveBaseOffset + 9 ];

	PrimitiveData.PreviousLocalToWorld[ 0 ] = View.PrimitiveSceneData[ PrimitiveBaseOffset + 10 ];
	PrimitiveData.PreviousLocalToWorld[ 1 ] = View.PrimitiveSceneData[ PrimitiveBaseOffset + 11 ];
	PrimitiveData.PreviousLocalToWorld[ 2 ] = View.PrimitiveSceneData[ PrimitiveBaseOffset + 12 ];
	PrimitiveData.PreviousLocalToWorld[ 3 ] = View.PrimitiveSceneData[ PrimitiveBaseOffset + 13 ];

	PrimitiveData.PreviousWorldToLocal[ 0 ] = View.PrimitiveSceneData[ PrimitiveBaseOffset + 14 ];
	PrimitiveData.PreviousWorldToLocal[ 1 ] = View.PrimitiveSceneData[ PrimitiveBaseOffset + 15 ];
	PrimitiveData.PreviousWorldToLocal[ 2 ] = View.PrimitiveSceneData[ PrimitiveBaseOffset + 16 ];
	PrimitiveData.PreviousWorldToLocal[ 3 ] = View.PrimitiveSceneData[ PrimitiveBaseOffset + 17 ];

	PrimitiveData.ActorWorldPosition = View.PrimitiveSceneData[ PrimitiveBaseOffset + 18 ].xyz;
	PrimitiveData.UseSingleSampleShadowFromStationaryLights = View.PrimitiveSceneData[ PrimitiveBaseOffset + 18 ].w;

	PrimitiveData.ObjectBounds = View.PrimitiveSceneData[ PrimitiveBaseOffset + 19 ].xyz;
	PrimitiveData.LpvBiasMultiplier = View.PrimitiveSceneData[ PrimitiveBaseOffset + 19 ].w;

	PrimitiveData.DecalReceiverMask = View.PrimitiveSceneData[ PrimitiveBaseOffset + 20 ].x;
	PrimitiveData.PerObjectGBufferData = View.PrimitiveSceneData[ PrimitiveBaseOffset + 20 ].y;
	PrimitiveData.UseVolumetricLightmapShadowFromStationaryLights = View.PrimitiveSceneData[ PrimitiveBaseOffset + 20 ].z;
	PrimitiveData.DrawsVelocity = View.PrimitiveSceneData[ PrimitiveBaseOffset + 20 ].w;

	PrimitiveData.ObjectOrientation = View.PrimitiveSceneData[ PrimitiveBaseOffset + 21 ];
	PrimitiveData.NonUniformScale = View.PrimitiveSceneData[ PrimitiveBaseOffset + 22 ];

	PrimitiveData.LocalObjectBoundsMin = View.PrimitiveSceneData[ PrimitiveBaseOffset + 23 ].xyz;
	PrimitiveData.LightingChannelMask = asuint( View.PrimitiveSceneData[ PrimitiveBaseOffset + 23 ].w );

	PrimitiveData.LocalObjectBoundsMax = View.PrimitiveSceneData[ PrimitiveBaseOffset + 24 ].xyz;
	PrimitiveData.LightmapDataIndex = asuint( View.PrimitiveSceneData[ PrimitiveBaseOffset + 24 ].w );

	PrimitiveData.PreSkinnedLocalBoundsMin = View.PrimitiveSceneData[ PrimitiveBaseOffset + 25 ].xyz;
	PrimitiveData.SingleCaptureIndex = asuint( View.PrimitiveSceneData[ PrimitiveBaseOffset + 25 ].w );

	PrimitiveData.PreSkinnedLocalBoundsMax = View.PrimitiveSceneData[ PrimitiveBaseOffset + 26 ].xyz;
	PrimitiveData.OutputVelocity = asuint( View.PrimitiveSceneData[ PrimitiveBaseOffset + 26 ].w );

	UNROLL
		for( int i = 0; i < NUM_CUSTOM_PRIMITIVE_DATA; i++ )
		{
			PrimitiveData.CustomPrimitiveData[ i ] = View.PrimitiveSceneData[ PrimitiveBaseOffset + 27 + i ];
		}

	return PrimitiveData;
}
float2 SvPositionToViewportUV( float4 SvPosition )
{
	// can be optimized from 2SUB+2MUL to 2MAD
	float2 PixelPos = SvPosition.xy - View.ViewRectMin.xy;

	return PixelPos.xy * View.ViewSizeAndInvSize.zw;
}

#if POST_PROCESS_MATERIAL

float2 GetPixelPosition( FMaterialPixelParameters Parameters )
{
	return Parameters.SvPosition.xy - float2( PostProcessOutput_ViewportMin );
}

float2 GetViewportUV( FMaterialPixelParameters Parameters )
{
	return GetPixelPosition( Parameters ) * PostProcessOutput_ViewportSizeInverse;
}

#else

float2 GetPixelPosition( FMaterialPixelParameters Parameters )
{
	return Parameters.SvPosition.xy - float2( View.ViewRectMin.xy );
}

float2 GetViewportUV( FMaterialPixelParameters Parameters )
{
	return SvPositionToViewportUV( Parameters.SvPosition );
}

#endif
float2 CalcScreenUVFromOffsetFraction( float4 ScreenPosition, float2 OffsetFraction )
{
	float2 NDC = ScreenPosition.xy / ScreenPosition.w;
	// Apply the offset in NDC space so that it is consistent regardless of scene color buffer size
	// Clamp to valid area of the screen to avoid reading garbage
	//@todo - soft clamp
	float2 OffsetNDC = clamp( NDC + OffsetFraction * float2( 2, -2 ), -.999f, .999f );
	return float2( OffsetNDC * ResolvedView.ScreenPositionScaleBias.xy + ResolvedView.ScreenPositionScaleBias.wz );
}
float3 DecodeSceneColorForMaterialNode( float2 ScreenUV )
{
#if !defined(SceneColorCopyTexture)
	// Hit proxies rendering pass doesn't have access to valid render buffers
	return float3( 0.0f, 0.0f, 0.0f );
#else
	float4 EncodedSceneColor = Texture2DSample( SceneColorCopyTexture, SceneColorCopySampler, ScreenUV );

	// Undo the function in EncodeSceneColorForMaterialNode
	float3 SampledColor = pow( EncodedSceneColor.rgb, 4 ) * 10;

#if USE_PREEXPOSURE
	SampledColor *= View.OneOverPreExposure.xxx;
#endif

	return SampledColor;
#endif
}

float3 MaterialExpressionBlackBody( float Temp )
{
	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 =
	{
		 3.2404542, -1.5371385, -0.4985314,
		-0.9692660,  1.8760108,  0.0415560,
		 0.0556434, -0.2040259,  1.0572252
	};

	return mul( XYZtoRGB, float3( X, Y, Z ) ) * pow( 0.0004 * Temp, 4 );
}

#define DDX ddx
#define DDY ddy

float GetPerInstanceFadeAmount( FMaterialPixelParameters Parameters )
{
#if USE_INSTANCING
	return float( Parameters.PerInstanceParams.y );
#else
	return float( 1.0 );
#endif
}

MaterialFloat3x3 GetLocalToWorld3x3( uint PrimitiveId )
{
	//return (MaterialFloat3x3)GetPrimitiveData( PrimitiveId ).LocalToWorld;
	return (MaterialFloat3x3)Primitive.LocalToWorld;
}

MaterialFloat3x3 GetLocalToWorld3x3()
{
	return (MaterialFloat3x3)Primitive.LocalToWorld;
}

MaterialFloat3 TransformLocalVectorToWorld( FMaterialPixelParameters Parameters, MaterialFloat3 InLocalVector )
{
	return mul( InLocalVector, GetLocalToWorld3x3( Parameters.PrimitiveId ) );
}
float3 TransformLocalPositionToWorld( FMaterialPixelParameters Parameters, float3 InLocalPosition )
{
	//return mul( float4( InLocalPosition, 1 ), GetPrimitiveData( Parameters.PrimitiveId ).LocalToWorld ).xyz;
	return mul( float4( InLocalPosition, 1 ), Primitive.LocalToWorld ).xyz;
}

bool GetShadowReplaceState()
{
#ifdef SHADOW_DEPTH_SHADER
	return true;
#else
	return false;
#endif
}

float IsShadowDepthShader()
{
	return GetShadowReplaceState() ? 1.0f : 0.0f;
}

float3 GetTranslatedWorldPosition( FMaterialPixelParameters Parameters )
{
	return Parameters.WorldPosition_CamRelative;
}
float GetDistanceToNearestSurfaceGlobal( float3 Position )
{
	//Distance to nearest DistanceField voxel I think ?
	return 1000.0f;
}
float2 RotateScaleOffsetTexCoords( float2 InTexCoords, float4 InRotationScale, float2 InOffset )
{
	return float2( dot( InTexCoords, InRotationScale.xy ), dot( InTexCoords, InRotationScale.zw ) ) + InOffset;
}
float2 GetTanHalfFieldOfView()
{
	//@return tan(View.FieldOfViewWideAngles * .5)
	//return float2( View.ClipToView[ 0 ][ 0 ], View.ClipToView[ 1 ][ 1 ] );
	float EmulatedFOV = 3.14f / 2.0f;
	return float2( EmulatedFOV, EmulatedFOV );
}
float Pow2( float x )
{
	return x * x;
}
float3 HairAbsorptionToColor( float3 A, float B = 0.3f )
{
	const float b2 = B * B;
	const float b3 = B * b2;
	const float b4 = b2 * b2;
	const float b5 = B * b4;
	const float D = ( 5.969f - 0.215f * B + 2.532f * b2 - 10.73f * b3 + 5.574f * b4 + 0.245f * b5 );
	return exp( -sqrt( A ) * D );
}
float3 HairColorToAbsorption( float3 C, float B = 0.3f )
{
	const float b2 = B * B;
	const float b3 = B * b2;
	const float b4 = b2 * b2;
	const float b5 = B * b4;
	const float D = ( 5.969f - 0.215f * B + 2.532f * b2 - 10.73f * b3 + 5.574f * b4 + 0.245f * b5 );
	return Pow2( log( C ) / D );
}
float3 GetHairColorFromMelanin( float InMelanin, float InRedness, float3 InDyeColor )
{
	InMelanin = saturate( InMelanin );
	InRedness = saturate( InRedness );
	const float Melanin = -log( max( 1 - InMelanin, 0.0001f ) );
	const float Eumelanin = Melanin * ( 1 - InRedness );
	const float Pheomelanin = Melanin * InRedness;

	const float3 DyeAbsorption = HairColorToAbsorption( saturate( InDyeColor ) );
	const float3 Absorption = Eumelanin * float3( 0.506f, 0.841f, 1.653f ) + Pheomelanin * float3( 0.343f, 0.733f, 1.924f );

	return HairAbsorptionToColor( Absorption + DyeAbsorption );
}

float3 MaterialExpressionGetHairColorFromMelanin( float Melanin, float Redness, float3 DyeColor )
{
	return GetHairColorFromMelanin( Melanin, Redness, DyeColor );
}
bool GetRayTracingQualitySwitch()
{
#if RAYHITGROUPSHADER
	return true;
#else
	return false;
#endif
}
MaterialFloat2 GetDefaultSceneTextureUV( FMaterialPixelParameters Parameters, uint SceneTextureId )
{
	return float2( 0, 0 );
}
float4 SceneTextureLookup( float2 UV, int SceneTextureIndex, bool bFiltered )
{
	return float4( 0, 0, 0, 0 );
}
float3 MaterialExpressionAtmosphericLightVector( FMaterialPixelParameters Parameters )
{
#if MATERIAL_ATMOSPHERIC_FOG
	return ResolvedView.AtmosphereLightDirection[ 0 ].xyz;
#else
	return float3( 0.f, 0.f, 0.f );
#endif
}

#if TEX_COORD_SCALE_ANALYSIS
	#define MaterialStoreTexCoordScale(Parameters, UV, TextureReferenceIndex) StoreTexCoordScale(Parameters.TexCoordScalesParams, UV, TextureReferenceIndex)
	#define MaterialStoreTexSample(Parameters, UV, TextureReferenceIndex) StoreTexSample(Parameters.TexCoordScalesParams, UV, TextureReferenceIndex)
#else
	#define MaterialStoreTexCoordScale(Parameters, UV, TextureReferenceIndex) 1.0f
	#define MaterialStoreTexSample(Parameters, UV, TextureReferenceIndex) 1.0f
#endif