Hello everybody…
I watched this video on Youtube, from unite, about the new ShaderFX within the new Maya LT
I have no idea how to make these shaders work in Unity as the video says, can anyone help me?
Any tips?
Thank you very much!
----------------------------------------- Header ------------------------------------------
float2 ShadowFilterTaps[10]
<
string UIWidget = "None";
> = {float2(-0.84052, -0.073954), float2(-0.326235, -0.40583), float2(-0.698464, 0.457259), float2(-0.203356, 0.620585), float2(0.96345, -0.194353), float2(0.473434, -0.480026), float2(0.519454, 0.767034), float2(0.185461, -0.894523), float2(0.507351, 0.064963), float2(-0.321932, 0.595435)};
// ----------------------------------- Per Frame --------------------------------------
float4x4 viewI : ViewInverse < string UIWidget = "None"; >;
// --------------------------------------- Per Object -----------------------------------------
float4x4 world : World < string UIWidget = "None"; >;
float4x4 wvp : WorldViewProjection < string UIWidget = "None"; >;
// ----------------------------------- Lights --------------------------------------
int Light0Type : LIGHTTYPE
<
string UIName = "Light 0 Type";
float UIMin = 0;
float UIMax = 5;
float UIStep = 1;
string Object = "Light 0";
> = {0};
int Light1Type : LIGHTTYPE
<
string UIName = "Light 1 Type";
float UIMin = 0;
float UIMax = 5;
float UIStep = 1;
string Object = "Light 1";
> = {0};
int Light2Type : LIGHTTYPE
<
string UIName = "Light 2 Type";
float UIMin = 0;
float UIMax = 5;
float UIStep = 1;
string Object = "Light 2";
> = {0};
float3 Light0Color : LIGHTCOLOR
<
string UIName = "Light 0 Color";
string UIWidget = "ColorPicker";
string Object = "Light 0";
> = { 1.0, 1.0, 1.0};
float3 Light1Color : LIGHTCOLOR
<
string UIName = "Light 1 Color";
string UIWidget = "ColorPicker";
string Object = "Light 1";
> = { 1.0, 1.0, 1.0};
float3 Light2Color : LIGHTCOLOR
<
string UIName = "Light 2 Color";
string UIWidget = "ColorPicker";
string Object = "Light 2";
> = { 1.0, 1.0, 1.0};
float Light0Intensity : LIGHTINTENSITY
<
string UIName = "Light 0 Intensity";
float UIMin = 0;
float UIStep = 0.1;
string Object = "Light 0";
> = 1.0;
float Light1Intensity : LIGHTINTENSITY
<
string UIName = "Light 1 Intensity";
float UIMin = 0;
float UIStep = 0.1;
string Object = "Light 1";
> = 1.0;
float Light2Intensity : LIGHTINTENSITY
<
string UIName = "Light 2 Intensity";
float UIMin = 0;
float UIStep = 0.1;
string Object = "Light 2";
> = 1.0;
float3 Light0Pos : POSITION
<
string UIName = "Light 0 Position";
string Space = "World";
string Object = "Light 0";
> = {1.0, 1.0, 1.0};
float3 Light1Pos : POSITION
<
string UIName = "Light 1 Position";
string Space = "World";
string Object = "Light 1";
> = {1.0, 1.0, 1.0};
float3 Light2Pos : POSITION
<
string UIName = "Light 2 Position";
string Space = "World";
string Object = "Light 2";
> = {1.0, 1.0, 1.0};
float3 Light0Dir : DIRECTION
<
string UIName = "Light 0 Direction";
string Space = "World";
string Object = "Light 0";
> = {0.0, -1.0, 0.0};
float3 Light1Dir : DIRECTION
<
string UIName = "Light 1 Direction";
string Space = "World";
string Object = "Light 1";
> = {0.0, -1.0, 0.0};
float3 Light2Dir : DIRECTION
<
string UIName = "Light 2 Direction";
string Space = "World";
string Object = "Light 2";
> = {0.0, -1.0, 0.0};
float Light0Attenuation : DECAYRATE
<
string UIName = "Light 0 Decay";
float UIMin = 0;
float UIStep = 1;
string Object = "Light 0";
> = 0.0;
float Light1Attenuation : DECAYRATE
<
string UIName = "Light 1 Decay";
float UIMin = 0;
float UIStep = 1;
string Object = "Light 1";
> = 0.0;
float Light2Attenuation : DECAYRATE
<
string UIName = "Light 2 Decay";
float UIMin = 0;
float UIStep = 1;
string Object = "Light 2";
> = 0.0;
float Light0ConeAngle : HOTSPOT
<
string UIName = "Light 0 ConeAngle";
float UIMin = 0;
float UIMax = 1.571;
float UIStep = 0.05;
string Space = "World";
string Object = "Light 0";
> = 0.46;
float Light1ConeAngle : HOTSPOT
<
string UIName = "Light 1 ConeAngle";
float UIMin = 0;
float UIMax = 1.571;
float UIStep = 0.05;
string Space = "World";
string Object = "Light 1";
> = 0.46;
float Light2ConeAngle : HOTSPOT
<
string UIName = "Light 2 ConeAngle";
float UIMin = 0;
float UIMax = 1.571;
float UIStep = 0.05;
string Space = "World";
string Object = "Light 2";
> = 0.46;
float Light0Falloff : FALLOFF
<
string UIName = "Light 0 Penumbra Angle";
float UIMin = 0;
float UIMax = 1.571;
float UIStep = 0.05;
string Object = "Light 0";
> = 0.7;
float Light1Falloff : FALLOFF
<
string UIName = "Light 1 Penumbra Angle";
float UIMin = 0;
float UIMax = 1.571;
float UIStep = 0.05;
string Object = "Light 1";
> = 0.7;
float Light2Falloff : FALLOFF
<
string UIName = "Light 2 Penumbra Angle";
float UIMin = 0;
float UIMax = 1.571;
float UIStep = 0.05;
string Object = "Light 2";
> = 0.7;
bool Light0ShadowOn : SHADOWFLAG
<
string UIName = "Light 0 Shadow";
string Object = "Light 0";
> = true;
bool Light1ShadowOn : SHADOWFLAG
<
string UIName = "Light 1 Shadow";
string Object = "Light 1";
> = true;
bool Light2ShadowOn : SHADOWFLAG
<
string UIName = "Light 2 Shadow";
string Object = "Light 2";
> = true;
float4x4 Light0ViewPrj : SHADOWMAPMATRIX
<
string Object = "Light 0";
string UIName = "Light 0 Matrix";
string UIWidget = "None";
>;
float4x4 Light1ViewPrj : SHADOWMAPMATRIX
<
string Object = "Light 1";
string UIName = "Light 1 Matrix";
string UIWidget = "None";
>;
float4x4 Light2ViewPrj : SHADOWMAPMATRIX
<
string Object = "Light 2";
string UIName = "Light 2 Matrix";
string UIWidget = "None";
>;
float3 Light0ShadowColor : SHADOWCOLOR
<
string UIName = "Light 0 Shadow Color";
string Object = "Light 0";
> = {0, 0, 0};
float3 Light1ShadowColor : SHADOWCOLOR
<
string UIName = "Light 1 Shadow Color";
string Object = "Light 1";
> = {0, 0, 0};
float3 Light2ShadowColor : SHADOWCOLOR
<
string UIName = "Light 2 Shadow Color";
string Object = "Light 2";
> = {0, 0, 0};
float3 Light3Pos : POSITION
<
string UIName = "Light 3 Position";
string Space = "World";
string Object = "Light 3";
> = {1.0, 1.0, 1.0};
float3 Light3Dir : DIRECTION
<
string UIName = "Light 3 Direction";
string Space = "World";
string Object = "Light 3";
> = {0.0, -1.0, 0.0};
// ---------------------------------------- Textures -----------------------------------------
Texture2D Light0ShadowMap : SHADOWMAP
<
string ResourceName = "";
string UIName = "ShadowMap";
string ResourceType = "2D";
string UIWidget = "None";
string Object = "Light 0";
>;
Texture2D Light1ShadowMap : SHADOWMAP
<
string ResourceName = "";
string UIName = "ShadowMap";
string ResourceType = "2D";
string UIWidget = "None";
string Object = "Light 1";
>;
Texture2D Light2ShadowMap : SHADOWMAP
<
string ResourceName = "";
string UIName = "ShadowMap";
string ResourceType = "2D";
string UIWidget = "None";
string Object = "Light 2";
>;
sampler2D Light0ShadowMapSampler = sampler_state
{
Texture = <Light0ShadowMap>;
MinFilter = Point;
MagFilter = Point;
AddressU = BORDER;
AddressV = BORDER;
AddressW = BORDER;
BorderColor = float4(1.0,1.0,1.0,1.0);
};
sampler2D Light1ShadowMapSampler = sampler_state
{
Texture = <Light1ShadowMap>;
MinFilter = Point;
MagFilter = Point;
AddressU = BORDER;
AddressV = BORDER;
AddressW = BORDER;
BorderColor = float4(1.0,1.0,1.0,1.0);
};
sampler2D Light2ShadowMapSampler = sampler_state
{
Texture = <Light2ShadowMap>;
MinFilter = Point;
MagFilter = Point;
AddressU = BORDER;
AddressV = BORDER;
AddressW = BORDER;
BorderColor = float4(1.0,1.0,1.0,1.0);
};
// ---------------------------------------- Functions -----------------------------------------
int GetLightType(int ActiveLightIndex)
{
if (ActiveLightIndex == 0)
return Light0Type;
else if (ActiveLightIndex == 1)
return Light1Type;
else
return Light2Type;
}
float3 GetLightColor(int ActiveLightIndex)
{
if (ActiveLightIndex == 0)
return Light0Color;
else if (ActiveLightIndex == 1)
return Light1Color;
else
return Light2Color;
}
float GetLightIntensity(int ActiveLightIndex)
{
if (ActiveLightIndex == 0)
return Light0Intensity;
else if (ActiveLightIndex == 1)
return Light1Intensity;
else
return Light2Intensity;
}
float3 GetLightPos(int ActiveLightIndex)
{
if (ActiveLightIndex == 0)
return Light0Pos;
else if (ActiveLightIndex == 1)
return Light1Pos;
else
return Light2Pos;
}
float3 GetLightDir(int ActiveLightIndex)
{
if (ActiveLightIndex == 0)
return Light0Dir;
else if (ActiveLightIndex == 1)
return Light1Dir;
else
return Light2Dir;
}
float GetLightAttenuation(int ActiveLightIndex)
{
if (ActiveLightIndex == 0)
return Light0Attenuation;
else if (ActiveLightIndex == 1)
return Light1Attenuation;
else
return Light2Attenuation;
}
float GetLightConeAngle(int ActiveLightIndex)
{
if (ActiveLightIndex == 0)
return Light0ConeAngle;
else if (ActiveLightIndex == 1)
return Light1ConeAngle;
else
return Light2ConeAngle;
}
float GetLightFalloff(int ActiveLightIndex)
{
if (ActiveLightIndex == 0)
return Light0Falloff;
else if (ActiveLightIndex == 1)
return Light1Falloff;
else
return Light2Falloff;
}
bool GetLightShadowOn(int ActiveLightIndex)
{
if (ActiveLightIndex == 0)
return Light0ShadowOn;
else if (ActiveLightIndex == 1)
return Light1ShadowOn;
else
return Light2ShadowOn;
}
float4x4 GetLightViewPrj(int ActiveLightIndex)
{
if (ActiveLightIndex == 0)
return Light0ViewPrj;
else if (ActiveLightIndex == 1)
return Light1ViewPrj;
else
return Light2ViewPrj;
}
Texture2D GetLightShadowMap(int ActiveLightIndex)
{
if (ActiveLightIndex == 0)
return Light0ShadowMap;
else if (ActiveLightIndex == 1)
return Light1ShadowMap;
else
return Light2ShadowMap;
}
float4 SampleFromShadowMap( int ActiveLightIndex, float2 UVs)
{
if (ActiveLightIndex == 0)
return tex2Dlod(Light0ShadowMapSampler, UVs, 0);
else if (ActiveLightIndex == 1)
return tex2Dlod(Light1ShadowMapSampler, UVs, 0);
else
return tex2Dlod(Light2ShadowMapSampler, UVs, 0);
}
float3 GetLightShadowColor(int ActiveLightIndex)
{
if (ActiveLightIndex == 0)
return Light0ShadowColor;
else if (ActiveLightIndex == 1)
return Light1ShadowColor;
else
return Light2ShadowColor;
}
// -------------------------------------- APP and DATA --------------------------------------
struct APPDATA
{
float3 Position : POSITION;
float3 Normal : NORMAL;
};
struct SHADERDATA
{
float4 Position : POSITION;
float4 Normal : TEXCOORD0;
float4 WorldPosition : TEXCOORD1;
};
// -------------------------------------- AmbientLightFunction --------------------------------------
struct AmbientLightOutput
{
float3 LightColor;
};
AmbientLightOutput AmbientLightFunction(int ActiveLightIndex, float3 AlbedoColor, float3 LightColor, float LightIntensity)
{
AmbientLightOutput OUT;
float3 MulOp = (LightIntensity * (AlbedoColor * LightColor));
OUT.LightColor = MulOp;
return OUT;
}
// -------------------------------------- GetLightVectorFunction --------------------------------------
struct GetLightVectorOutput
{
float3 Result;
};
GetLightVectorOutput GetLightVectorFunction(int ActiveLightIndex, float3 LightPosition, float3 VertexWorldPosition, int LightType, float3 LightDirection)
{
GetLightVectorOutput OUT;
bool IsDirectionalLight = (LightType == 4);
float3 LerpOp = lerp((LightPosition - VertexWorldPosition), -(LightDirection), IsDirectionalLight);
float3 NegateOp = -(LerpOp);
OUT.Result = NegateOp;
return OUT;
}
// -------------------------------------- LambertDiffuseFunction --------------------------------------
struct LambertDiffuseOutput
{
float3 Color;
};
LambertDiffuseOutput LambertDiffuseFunction(int ActiveLightIndex, float3 AlbedoColor, float3 Normal, float3 LightVector)
{
LambertDiffuseOutput OUT;
float SatOp = saturate(dot(Normal, LightVector));
float3 Diffuse = (AlbedoColor * SatOp);
OUT.Color = Diffuse;
return OUT;
}
// -------------------------------------- LightDecayFunction --------------------------------------
struct LightDecayOutput
{
float Attenuation;
};
LightDecayOutput LightDecayFunction(int ActiveLightIndex, float3 LightVectorUN, float Attenuation)
{
LightDecayOutput OUT;
bool IsAttenuationUsed = (Attenuation > 0.001);
float DecayContribution500 = 0.0;
if (IsAttenuationUsed)
{
float PowOp = pow(length(LightVectorUN), Attenuation);
float DivOp = (1.0 / PowOp);
DecayContribution500 = DivOp;
}
else
{
DecayContribution500 = 1.0;
}
OUT.Attenuation = DecayContribution500;
return OUT;
}
// -------------------------------------- LightConeAngleFunction --------------------------------------
struct LightConeAngleOutput
{
float ConeAngle;
};
LightConeAngleOutput LightConeAngleFunction(int ActiveLightIndex, float3 LightVector, float3 LightDirection, float ConeAngle, float ConeFalloff)
{
LightConeAngleOutput OUT;
float CosOp = cos(max(ConeFalloff, ConeAngle));
float DotOp = dot(LightVector, -(LightDirection));
float SmoothStepOp = smoothstep(CosOp, cos(ConeAngle), DotOp);
OUT.ConeAngle = SmoothStepOp;
return OUT;
}
// -------------------------------------- ShadowMapFunction --------------------------------------
struct ShadowMapOutput
{
float LightGain;
};
ShadowMapOutput ShadowMapFunction(int ActiveLightIndex, float4x4 LightViewPrj, Texture2D ShadowMap, float ShadowMapBias, float3 VertexWorldPosition)
{
ShadowMapOutput OUT;
float IfElseOp419 = 0.0;
float4 VectorConstruct = float4(VertexWorldPosition.x, VertexWorldPosition.y, VertexWorldPosition.z, 1.0);
float4 MulOp = mul(VectorConstruct, LightViewPrj);
float3 DivOp = (MulOp.xyz / MulOp.w);
if (DivOp.x > -1.0 DivOp.x < 1.0 DivOp.y > -1.0 DivOp.y < 1.0 DivOp.z > 0.0 DivOp.z < 1.0)
{
float Val = 0.5;
float2 AddOp = ((DivOp.xy * Val) + Val);
float SubOp = (DivOp.z - (ShadowMapBias / MulOp.w));
float ShadowTotal = 0.0;
for(int i=0; i<10; i+=1)
{
float2 MulOp459 = (ShadowFilterTaps[i] * 0.00195313);
float4 Sampler = SampleFromShadowMap(ActiveLightIndex, (AddOp + MulOp459));
float IfElseOp413 = ((SubOp - Sampler.x) >= 0.0) ? (0.0) : (0.1);
ShadowTotal += IfElseOp413;
}
IfElseOp419 = ShadowTotal;
}
else
{
IfElseOp419 = 1.0;
}
OUT.LightGain = IfElseOp419;
return OUT;
}
// -------------------------------------- LightContributionFunction --------------------------------------
struct LightContributionOutput
{
float3 Light;
};
LightContributionOutput LightContributionFunction(int ActiveLightIndex, float3 VertexWorldPosition, float3 LightVectorUN)
{
LightContributionOutput OUT;
float _LightIntensity = GetLightIntensity(ActiveLightIndex);
int _LightType = GetLightType(ActiveLightIndex);
bool IsDirectionalLight = (_LightType == 4);
float DecayMul547 = 0.0;
if (IsDirectionalLight)
{
DecayMul547 = 1.0;
}
else
{
float LightAttenuation = GetLightAttenuation(ActiveLightIndex);
LightDecayOutput LightDecay494 = LightDecayFunction(ActiveLightIndex, LightVectorUN, LightAttenuation);
DecayMul547 = LightDecay494.Attenuation;
}
bool IsSpotLight = (_LightType == 2);
float ConeMul549 = 1.0;
if (IsSpotLight)
{
float3 NormOp = normalize(LightVectorUN);
float3 _LightDir = GetLightDir(ActiveLightIndex);
float _LightConeAngle = GetLightConeAngle(ActiveLightIndex);
float _LightFalloff = GetLightFalloff(ActiveLightIndex);
LightConeAngleOutput LightConeAngle349 = LightConeAngleFunction(ActiveLightIndex, NormOp, -_LightDir, _LightConeAngle, _LightFalloff);
ConeMul549 = LightConeAngle349.ConeAngle;
}
bool _LightShadowOn = GetLightShadowOn(ActiveLightIndex);
float ShadowMul550 = 1.0;
if (_LightShadowOn)
{
float4x4 _LightViewPrj = GetLightViewPrj(ActiveLightIndex);
Texture2D _LightShadowMap = GetLightShadowMap(ActiveLightIndex);
ShadowMapOutput ShadowMap398 = ShadowMapFunction(ActiveLightIndex, _LightViewPrj, _LightShadowMap, 0.01, VertexWorldPosition);
float3 _LightShadowColor = GetLightShadowColor(ActiveLightIndex);
float ShadowColorMix = lerp(ShadowMap398.LightGain, 1.0, _LightShadowColor.x);
ShadowMul550 = ShadowColorMix;
}
float DecayShadowConeMul = (DecayMul547 * (ConeMul549 * ShadowMul550));
float3 LightColor = GetLightColor(ActiveLightIndex);
float3 MulItensity = (_LightIntensity * (DecayShadowConeMul * LightColor));
OUT.Light = MulItensity;
return OUT;
}
// -------------------------------------- BlinnSpecularFunction --------------------------------------
struct BlinnSpecularOutput
{
float3 SpecularColor;
};
BlinnSpecularOutput BlinnSpecularFunction(int ActiveLightIndex, float3 LightVector, float3 Normal, float3 CameraVector, float SpecularPower, float3 SpecularColor)
{
BlinnSpecularOutput OUT;
float3 NormOp = normalize((LightVector + CameraVector));
float SatOp = saturate(dot(Normal, NormOp));
float3 BlinnSpec = (pow(SatOp, SpecularPower) * SpecularColor);
float SatOp920 = saturate(dot(Normal, LightVector));
float3 MulOp = (BlinnSpec * SatOp920);
OUT.SpecularColor = MulOp;
return OUT;
}
// -------------------------------------- DesaturateColorFunction --------------------------------------
struct DesaturateColorOutput
{
float DesaturateColor;
};
DesaturateColorOutput DesaturateColorFunction(int ActiveLightIndex, float3 Color)
{
DesaturateColorOutput OUT;
float3 Col = float3(0.300008,0.6,0.100008);
float DotOp = dot(saturate(Color), Col.xyz);
OUT.DesaturateColor = DotOp;
return OUT;
}
// -------------------------------------- FresnelFunction --------------------------------------
struct FresnelOutput
{
float FresnelMultiplier;
};
FresnelOutput FresnelFunction(float3 CameraVector, float3 Normal, float Min, float Max, float Strenght)
{
FresnelOutput OUT;
float OneMinusOp = (1.0 - dot(CameraVector, Normal));
float SubOp = (saturate(OneMinusOp) - Min);
float SubOp1202 = (max(Max, Min) - Min);
float SatOp = saturate((SubOp / SubOp1202));
float MulOp = (SatOp * Strenght);
OUT.FresnelMultiplier = MulOp;
return OUT;
}
// -------------------------------------- GetLightVectorFunction --------------------------------------
GetLightVectorOutput GetLightVectorFunction(float3 LightPosition, float3 VertexWorldPosition, int LightType, float3 LightDirection)
{
GetLightVectorOutput OUT;
bool IsDirectionalLight = (LightType == 4);
float3 LerpOp = lerp((LightPosition - VertexWorldPosition), -(LightDirection), IsDirectionalLight);
float3 NegateOp = -(LerpOp);
OUT.Result = NegateOp;
return OUT;
}
// -------------------------------------- RimLightFunction --------------------------------------
struct RimLightOutput
{
float3 Color;
};
RimLightOutput RimLightFunction(float Fresnel, float3 LightVector, float3 Normal, float3 AlbedoColor, float3 FresnelColorTint)
{
RimLightOutput OUT;
float DotOp = dot(Normal, -(LightVector));
float MulOp = (Fresnel * saturate(DotOp));
float3 MulOp1275 = ((AlbedoColor + FresnelColorTint) * MulOp);
OUT.Color = MulOp1275;
return OUT;
}
// -------------------------------------- DesaturateColorFunction --------------------------------------
DesaturateColorOutput DesaturateColorFunction(float3 Color)
{
DesaturateColorOutput OUT;
float3 Col = float3(0.300008,0.6,0.100008);
float DotOp = dot(saturate(Color), Col.xyz);
OUT.DesaturateColor = DotOp;
return OUT;
}
// -------------------------------------- ShaderVertex --------------------------------------
SHADERDATA ShaderVertex(APPDATA IN)
{
SHADERDATA OUT;
OUT.Position = float4(IN.Position, 1);
float3 MulOp = mul(IN.Normal, ((float3x3)world));
float3 NormalN = normalize(MulOp);
float4 WorldNormal = float4(NormalN.x, NormalN.y, NormalN.z, 1.0);
OUT.Normal = WorldNormal;
float4 WorldPos = mul(OUT.Position, world);
OUT.WorldPosition = WorldPos;
float4 WVSpace = mul(OUT.Position, wvp);
OUT.Position = WVSpace;
return OUT;
}
// -------------------------------------- ShaderPixel --------------------------------------
struct PIXELDATA
{
float4 Color : Color0;
};
PIXELDATA ShaderPixel(SHADERDATA IN, bool FrontFace : VFACE)
{
PIXELDATA OUT;
float InvertSatMask = (1.0 - saturate(0.0));
float3 Color = float3(0.0,0.134048,0.666667);
float3 ReplaceDiffuseWithReflection = (InvertSatMask * Color.xyz);
float3 NormOp = normalize(IN.Normal.xyz);
float3 FlippedNormals = lerp(-(NormOp), NormOp, FrontFace);
float ClampOpacity = saturate(1.0);
float3 CameraPosition = viewI[3].xyz;
float3 CamVec = (CameraPosition - IN.WorldPosition.xyz);
float3 CamVecNorm = normalize(CamVec);
float4 LightLoopTotal11 = float4(0,0,0,0);
for (int ActiveLightIndex = 0; ActiveLightIndex < 3; ++ActiveLightIndex)
{
int _LightType = GetLightType(ActiveLightIndex);
bool IsAmbientLight = (_LightType == 5);
float4 IfAmbientLight334 = float4(0, 0, 0, 0);
if (IsAmbientLight)
{
float3 LightColor = GetLightColor(ActiveLightIndex);
float _LightIntensity = GetLightIntensity(ActiveLightIndex);
AmbientLightOutput AmbientLight339 = AmbientLightFunction(ActiveLightIndex, ReplaceDiffuseWithReflection, LightColor, _LightIntensity);
float3 AmbientLightAndAO = (1.0 * AmbientLight339.LightColor);
float4 VectorConstruct = float4(AmbientLightAndAO.x, AmbientLightAndAO.y, AmbientLightAndAO.z, 0.0);
IfAmbientLight334 = VectorConstruct;
}
else
{
float3 NoTranslucency = float3(0.0,0.0,0.0);
float3 _LightPos = GetLightPos(ActiveLightIndex);
float3 _LightDir = GetLightDir(ActiveLightIndex);
GetLightVectorOutput GetLightVector789 = GetLightVectorFunction(ActiveLightIndex, _LightPos, IN.WorldPosition.xyz, _LightType, -_LightDir);
float3 LightVecNorm = normalize(GetLightVector789.Result);
LambertDiffuseOutput LambertDiffuse765 = LambertDiffuseFunction(ActiveLightIndex, ReplaceDiffuseWithReflection, FlippedNormals, LightVecNorm);
LightContributionOutput LightContribution347 = LightContributionFunction(ActiveLightIndex, IN.WorldPosition.xyz, GetLightVector789.Result);
float3 AddTranslucency = (NoTranslucency.xyz + (LambertDiffuse765.Color * LightContribution347.Light));
float3 Col = float3(1.0,1.0,1.0);
BlinnSpecularOutput BlinnSpecular908 = BlinnSpecularFunction(ActiveLightIndex, LightVecNorm, FlippedNormals, CamVecNorm, 20.0, Col.xyz);
float3 SpecLightIntensity = (LightContribution347.Light * BlinnSpecular908.SpecularColor);
float3 Diffuse_Spec = ((AddTranslucency * ClampOpacity) + SpecLightIntensity);
DesaturateColorOutput DesaturateColor611 = DesaturateColorFunction(ActiveLightIndex, SpecLightIntensity);
float4 Color_Alpha = float4(Diffuse_Spec.x, Diffuse_Spec.y, Diffuse_Spec.z, DesaturateColor611.DesaturateColor);
IfAmbientLight334 = Color_Alpha;
}
float4 ApplyWeight345 = IfAmbientLight334;
LightLoopTotal11 += ApplyWeight345;
}
float3 NoReflection = float3(0.0,0.0,0.0);
float3 ReflectXmask = (0.0 * NoReflection.xyz);
float3 CamVec1247 = (CameraPosition - IN.WorldPosition.xyz);
FresnelOutput Fresnel1196 = FresnelFunction(CamVec1247, NormOp, 0.295775, 0.0, 14.0);
GetLightVectorOutput GetLightVector1303 = GetLightVectorFunction(Light3Pos, IN.WorldPosition.xyz, Light0Type, -Light3Dir);
float3 Col = float3(1.0,1.0,1.0);
float3 Col1282 = float3(1.0,1.0,1.0);
RimLightOutput RimLight1270 = RimLightFunction(Fresnel1196.FresnelMultiplier, GetLightVector1303.Result, NormOp, Col.xyz, Col1282.xyz);
float3 DefaultIBLColor = float3(0.0,0.0,0.0);
float3 PreMultipliedAlpha = ((RimLight1270.Color + DefaultIBLColor.xyz) * ClampOpacity);
float3 AddReflection = (ReflectXmask + PreMultipliedAlpha);
DesaturateColorOutput DesaturateColor314 = DesaturateColorFunction(ReflectXmask);
float OpacityAndReflection = (ClampOpacity + DesaturateColor314.DesaturateColor);
float4 TotalAmbientAndOpacity = float4(AddReflection.x, AddReflection.y, AddReflection.z, OpacityAndReflection);
float4 LightLoopAndAfterLoop = (LightLoopTotal11 + TotalAmbientAndOpacity);
OUT.Color = LightLoopAndAfterLoop;
return OUT;
}
// -------------------------------------- technique T0 ---------------------------------------
technique T0
{
pass P0
{
VertexShader = compile vs_3_0 ShaderVertex();
PixelShader = compile ps_3_0 ShaderPixel();
}
}
Look what it generates
[Edit]To be fair, this was probably the .fx file output, you should try the Cg output
I was sceptical when I heard that. Now I’m almost crying. Not sure if it’s from laughter or pure sadness.
It is possible to make it compile without errors, but it takes more work to actually make it run correctly.
- Put Unity in DX11 mode
- Create a basic Fragment/ Vertex shader
- #pragma vertex ShaderVertex
- #pragma fragment ShaderPixel
- Use Shader Model 5 #pragma target 5.0
- Wrap the ShaderFX code in CGINCLUDE and ENDCG and paste it before the Pass tag
- Make the 3 uses of tex2Dlod use float4(UVs,0,0) as second parameter and remove the last parameter.
- Compile and admire the shaded geometry being black and oddly shaped because it’s not using Unity’s Matrices, lighting and shading data.
You can probably make it work better by replacing the HLSL specific stuff. But to be honest, if Autodesk really want to promote this for use with Unity, they should simply write a Shaderlab + Cg exporter. In the meantime you can take a look at Strumpy Shader Editor and ShaderForge
Humm… I agree, Autodesk should make it more compatible, it is a very useful tool if it works right…
Thank you very much for your reply, I will try it tonight when I get home… 
And this ShaderForge seems amazing, I am going to take a look at that 
Thank you very much! o/