public static string GenerateMap(ShaderGenerate SG,ShaderEffect SE, ShaderLayer SL,string Map,ref int UVDimensions,ref int TypeDimensions){
if (TypeDimensions==3){
if (UVDimensions == 1)
Map = "float3("+Map+",0,0)";
if (UVDimensions == 2)
Map = "float3("+Map+",0)";
UVDimensions = 3;
return "(((float3("+SE.Inputs[0].GetMaskName()+".r,"+SE.Inputs[0].GetMaskName()+".g,"+SE.Inputs[0].GetMaskName()+".b))*"+SE.Inputs[1].Get()+"))";
}
if (TypeDimensions==2){
if (UVDimensions == 1)
Map = "float2("+Map+",0)";
if (UVDimensions<3){
UVDimensions = 2;
return "(((float2("+SE.Inputs[0].GetMaskName()+".r,"+SE.Inputs[0].GetMaskName()+".g))*"+SE.Inputs[1].Get()+"))";
}
else{
return "(((float3("+SE.Inputs[0].GetMaskName()+".r,"+SE.Inputs[0].GetMaskName()+".g,0))*"+SE.Inputs[1].Get()+"))";
}
}
if (TypeDimensions==1){
//if (UVDimensions==1)
return "((("+SE.Inputs[0].GetMaskName()+".r)*"+SE.Inputs[1].Get()+"))";
}
return Map;
}
public static void SetUsed(ShaderGenerate SG,ShaderEffect SE){
//Debug.Log(SG.UsedMasks.ContainsKey((ShaderLayerList)SE.Inputs[0].Obj));
if (SE.Inputs[0].Obj!=null&&SG.UsedMasks.ContainsKey((ShaderLayerList)SE.Inputs[0].Obj)){
SG.UsedMasks[(ShaderLayerList)SE.Inputs[0].Obj]++;
// Debug.Log(SG.UsedMasks[(ShaderLayerList)SE.Inputs[0].Obj]);
}
}
public static string GenerateMap(ShaderGenerate SG,ShaderEffect SE, ShaderLayer SL,string Map,ref int UVDimensions,ref int TypeDimensions){
if (TypeDimensions==3){
if (UVDimensions == 1)
Map = "float3("+Map+",0,0)";
if (UVDimensions == 2)
Map = "float3("+Map+",0)";
UVDimensions = 3;
if (SL.LayerType.Type==(int)LayerTypes.Noise)
return "("+Map+"+float3("+SE.Inputs[0].Get()+","+SE.Inputs[1].Get()+","+SE.Inputs[2].Get(1f/3f)+"))";
else
return "("+Map+"+float3("+SE.Inputs[0].Get()+","+SE.Inputs[1].Get()+","+SE.Inputs[2].Get(1f)+"))";
}
if (TypeDimensions==2){
if (UVDimensions == 1)
Map = "float2("+Map+",0)";
if (UVDimensions<3){
UVDimensions = 2;
return "("+Map+"+float2("+SE.Inputs[0].Get()+","+SE.Inputs[1].Get()+"))";
}
else{
return "("+Map+"+float3("+SE.Inputs[0].Get()+","+SE.Inputs[1].Get()+",0))";
}
}
if (TypeDimensions==1)
return "("+Map+"+("+SE.Inputs[0].Get()+"))";
return Map;
}
public static string GenerateWAlpha(ShaderGenerate SG,ShaderEffect SE, ShaderLayer SL,string Line,int Effect){
SE.Inputs[0].Float = Mathf.Round(SE.Inputs[0].Float);
if (SE.Inputs[0].Get()=="0")
return "fmod("+Line+",1)";
return "fmod("+Line+"*"+SE.Inputs[0].Get()+",1)";
}
public static string GenerateWAlpha(ShaderGenerate SG,ShaderEffect SE, ShaderLayer SL,string Line,int Effect){
string[] Colors = new string[]{"r","g","b","a"};
string Line1 = "(("+Line+"."+Colors[SE.Inputs[2].Type]+"-"+SL.StartNewBranch(SG,SL.GCUVs(SG,SE.Inputs[0].Get(),"0","0"),Effect)+"."+Colors[SE.Inputs[2].Type]+")*"+SE.Inputs[1].Get()+")";
string Line2 = "(("+Line+"."+Colors[SE.Inputs[2].Type]+"-"+SL.StartNewBranch(SG,SL.GCUVs(SG,"0",SE.Inputs[0].Get(),"0"),Effect)+"."+Colors[SE.Inputs[2].Type]+")*"+SE.Inputs[1].Get()+")";
//string retVal = "(float4("+Line1+","+Line2+","+"sqrt((1-pow("+Line1+",2)-pow("+Line2+",2))),"+Line+".a))";///2+0.5";
string retVal = "(float4("+Line1+","+Line2+",1,"+Line+".a))";///2+0.5";
return retVal;
}
public static string GenerateMap(ShaderGenerate SG,ShaderEffect SE, ShaderLayer SL,string Map,ref int UVDimensions,ref int TypeDimensions){
//return "float3("+((SE.Inputs[0].On)?"1-":"")+")";
if (UVDimensions==3)
return "float3("+((SE.Inputs[0].On)?"1-":"")+Map+".x,"+((SE.Inputs[1].On)?"1-":"")+Map+".y,"+((SE.Inputs[2].On)?"1-":"")+Map+".z)";
if (UVDimensions==2)
return "float2("+((SE.Inputs[0].On)?"1-":"")+Map+".x,"+((SE.Inputs[1].On)?"1-":"")+Map+".y)";
if (UVDimensions==1)
return ""+(((SE.Inputs[0].On)?"1-":"")+Map);
return Map;
}
public static string GenerateMap(ShaderGenerate SG,ShaderEffect SE, ShaderLayer SL,string Map,ref int UVDimensions,ref int TypeDimensions){
//return "float3("+((SE.Inputs[0].On)?"1-":"")+")";
string MapX = "0";
string MapY = "0";
//string MapZ = Map+".z";
//Debug.Log(UVDimensions);
bool UpSize1 = false;
if (UVDimensions==1&&TypeDimensions>1)
UpSize1 = true;
if (SE.Inputs[0].Type==0){
MapX = Map+".x";
if (!UpSize1)
MapY = Map+".y";
}
if (SE.Inputs[0].Type==1){
if (!UpSize1){
MapX = "1-"+Map+".y";
MapY = Map+".x";
}
else{
MapY = "1-"+Map+".x";
}
}
if (SE.Inputs[0].Type==2){
MapX = "1-"+Map+".x";
if (!UpSize1)
MapY = "1-"+Map+".y";
}
if (SE.Inputs[0].Type==3){
if (!UpSize1){
MapX = Map+".y";
MapY = "1-"+Map+".x";
}
else{
MapY = Map+".x";
}
}
if (UVDimensions==3)
return "float3("+MapX+","+MapY+","+Map+".z)";
if (UVDimensions==2)
return "float2("+MapX+","+MapY+")";
if (UVDimensions==1)
return "("+MapX+")";
return Map;
}
public static string GetAddBlurString(ShaderGenerate SG,ShaderLayer SL,ShaderEffect SE,int Effect,int XAdd,int YAdd){
string XAnti = "AntiAlias";//IN.screenPos.z/300";
string YAnti = XAnti;//"IN.screenPos.z";
//if (SE.Inputs[1].Input!=null)
string XX = ((float)XAdd/SE.Inputs[0].Float).ToString()+"*"+XAnti;
//if (SE.Inputs[2].Input!=null)
string YY = ((float)YAdd/SE.Inputs[0].Float).ToString()+"*"+YAnti;
//if (!SE.Inputs[0].On){
// if (SE.Inputs[1].Input!=null)
// YY = ((float)YAdd/SE.Inputs[0].Float).ToString()+"*"+XAnti;
//}
return "+("+SL.StartNewBranch(SG,SL.GCUVs(SG,XX,YY,"0"),Effect)+")";
//return OldColors[ShaderUtil.FlatArray(XX,YY,W,H)];
}
public static string GenerateMap(ShaderGenerate SG,ShaderEffect SE, ShaderLayer SL,string Map,ref int UVDimensions,ref int TypeDimensions){
if (!SE.Inputs[0].On){
if (UVDimensions==3)
return "("+Map+"*float3("+SE.Inputs[1].Get()+","+SE.Inputs[1].Get()+","+SE.Inputs[1].Get()+"))";
if (UVDimensions==2)
return "("+Map+"*float2("+SE.Inputs[1].Get()+","+SE.Inputs[1].Get()+"))";
if (UVDimensions==1)
return "("+Map+"*("+SE.Inputs[1].Get()+"))";
}
else{
if (UVDimensions==3)
return "("+Map+"*float3("+SE.Inputs[1].Get()+","+SE.Inputs[2].Get()+","+SE.Inputs[3].Get()+"))";
if (UVDimensions==2)
return "("+Map+"*float2("+SE.Inputs[1].Get()+","+SE.Inputs[2].Get()+"))";
if (UVDimensions==1)
return "("+Map+"*("+SE.Inputs[1].Get()+"))";
}
return Map;
}
public static string GenerateMap(ShaderGenerate SG,ShaderEffect SE, ShaderLayer SL,string Map,int UVDimensions,int TypeDimensions){
if (!SE.Inputs[0].On){
SE.Inputs[2].Float = SE.Inputs[1].Float;
SE.Inputs[3].Float = SE.Inputs[1].Float;
SE.Inputs[2].Input = SE.Inputs[1].Input;
SE.Inputs[3].Input = SE.Inputs[1].Input;
}
string Mapping="";
if (UVDimensions==3)
Mapping = "float3("+SE.Inputs[1].Get()+","+SE.Inputs[2].Get()+","+SE.Inputs[3].Get()+")";
if (UVDimensions==2)
Mapping = "float2("+SE.Inputs[1].Get()+","+SE.Inputs[2].Get()+")";
if (UVDimensions==1)
Mapping = "("+SE.Inputs[1].Get()+")";
if (Mapping!="")
return "(round("+Map+"/"+Mapping+")*"+Mapping+")";
return Map;
}
public static string GetAddBlurString(ShaderGenerate SG,ShaderLayer SL,ShaderEffect SE,int Effect,int XAdd,int YAdd){
string XX = ((float)XAdd*SE.Inputs[1].Float/SE.Inputs[4].Float).ToString();
string YY = ((float)YAdd*SE.Inputs[2].Float/SE.Inputs[4].Float).ToString();
if (!SE.Inputs[0].On){
YY = ((float)YAdd*SE.Inputs[1].Float/SE.Inputs[4].Float).ToString();
}
if (SE.Inputs[1].Input!=null)
XX = ((float)XAdd/SE.Inputs[4].Float).ToString()+"*"+SE.Inputs[1].Get();
if (SE.Inputs[2].Input!=null)
YY = ((float)YAdd/SE.Inputs[4].Float).ToString()+"*"+SE.Inputs[2].Get();
if (!SE.Inputs[0].On){
if (SE.Inputs[1].Input!=null)
YY = ((float)YAdd/SE.Inputs[4].Float).ToString()+"*"+SE.Inputs[1].Get();
}
return "+("+SL.StartNewBranch(SG,SL.GCUVs(SG,XX,YY,"0"),Effect)+")";
//return OldColors[ShaderUtil.FlatArray(XX,YY,W,H)];
}
public static string Generate(ShaderGenerate SG,ShaderEffect SE, ShaderLayer SL,string Line,int Effect){
if (!SL.IsVertex){
string retVal = "((("+Line+")";
int AddCount = 0;
for(int i = (int)(-SE.Inputs[0].Float);i<=(int)(SE.Inputs[0].Float);i+=2){
if (i!=0){retVal+=GetAddBlurString(SG,SL,SE,Effect,i,i);AddCount+=1;}}
for(int i = (int)(-SE.Inputs[0].Float);i<=(int)(SE.Inputs[0].Float);i+=2){
if (i!=0){retVal+=GetAddBlurString(SG,SL,SE,Effect,-i,-i);AddCount+=1;}}
for(int i = (int)(-SE.Inputs[0].Float);i<=(int)(SE.Inputs[0].Float);i+=2){
if (i!=0){retVal+=GetAddBlurString(SG,SL,SE,Effect,-i,i);AddCount+=1;}}
for(int i = (int)(-SE.Inputs[0].Float);i<=(int)(SE.Inputs[0].Float);i+=2){
if (i!=0){retVal+=GetAddBlurString(SG,SL,SE,Effect,i,-i);AddCount+=1;}}
for(int i = (int)(-SE.Inputs[0].Float);i<=(int)(SE.Inputs[0].Float);i++){
if (i!=0){retVal+=GetAddBlurString(SG,SL,SE,Effect,i,0);AddCount+=1;}}
for(int i = (int)(-SE.Inputs[0].Float);i<=(int)(SE.Inputs[0].Float);i++){
if (i!=0){retVal+=GetAddBlurString(SG,SL,SE,Effect,0,i);AddCount+=1;}}
retVal += ")/"+(AddCount+1).ToString()+")";
//+("+SL.GetSubPixel(SG,SL.GCUVs(SG,"0.01","0","0"),Effect)+"))/2)";
return retVal;
}
return Line;
}
public string GCPassMask_Real(ShaderGenerate SG,ShaderPass SP,float Dist){
string ShaderCode = "";
//SG.Reset();
int OldTransType = TransparencyType.Type;
// float OldTransAmount = TransparencyAmount.Float;
// ShaderInput OldTransInput = TransparencyAmount.Input;
TransparencyType.Type = 0;
if (TransparencyZWriteType.Type==0)
ShaderCode+="\nPass\n"
+"{\n"
+" Name \"ALPHAMASK\"\n"
+" ColorMask 0\n";
if (ShaderPassShells(SP))
ShaderCode+=" cull "+ShellsCull.CodeNames[ShellsCull.Type]+"\n";
else
ShaderCode+=" cull "+TechCull.CodeNames[TechCull.Type]+"\n";
ShaderCode+=GCLabTags(SP);
ShaderCode+=" CGPROGRAM\n\n";
ShaderCode+=GCUniforms(SG);
if (TransparencyZWriteType.Type==1){
ShaderCode+=GCPragma(SG,SP);
ShaderCode+=GCSurfaceOutput();
ShaderCode+=GCInputs(SG);
}
else{
ShaderCode+=" //The Shader Target defines the maximum capabilites of the shader (Number of math operators, texture reads, etc.)\n #pragma target "+((int)TechShaderTarget.Float).ToString()+".0\n"+
" //Tell Unity which parts of the shader affect the vertexes or the pixel colors.\n"+
" #pragma vertex vert\n"+
" #pragma fragment frag\n"+
" #include \"UnityCG.cginc\" //Include some base Unity stuff.\n";
}
ShaderCode+=GCFunctions(SG);
if (TransparencyZWriteType.Type==1)
ShaderCode+=GCLighting(SG,SP);
if (TransparencyZWriteType.Type==0)
ShaderCode+=GCVertexMask(SG,SP,Dist);
else
ShaderCode+=GCVertex(SG,SP,Dist);
if (TransparencyZWriteType.Type==0)
ShaderCode+=GCFragmentMask(SG,SP,Dist);
else
ShaderCode+=GCFragment(SG,SP,Dist);
ShaderCode+=" ENDCG\n";
if ((TransparencyZWriteType.Type==0))
ShaderCode+="}\n";
//if (TransparencyZWrite.On&&TransparencyZWriteType.Type==1){
TransparencyType.Type = OldTransType;
//}
return ShaderCode;
}
public static string GenerateWAlpha(ShaderGenerate SG,ShaderEffect SE, ShaderLayer SL,string Line,int Effect){
if (SE.Inputs[0].Get()=="0"&&SE.Inputs[0].Get()=="1")
return "saturate("+Line+")";
return "clamp("+Line+","+SE.Inputs[0].Get()+","+SE.Inputs[1].Get()+")";
}
public static string Generate(ShaderGenerate SG,ShaderEffect SE, ShaderLayer SL,string Line,int Effect){
return "("+Line+"/2+0.5)";///2+0.5)";
}
public string GCLayers(ShaderGenerate SG,string Name, ShaderLayerList SLs2,string CodeName,string EndTag,string Function,bool Parallax,bool UseEffects)
{
string ShaderCode = "";
if (SLs2.SLs.Count>0)
ShaderCode += " //Generate layers for the "+Name+" channel.\n";
int ShaderNumber = 0;
foreach (ShaderLayer SL in SLs2.SLs)
{
ShaderNumber+=1;
SL.LayerEffects.Reverse();
string Map = SL.GCUVs(SG);
SL.LayerEffects.Reverse();
SL.Parent = SLs2;
string PixelColor = SL.GCPixel(SG,Map)+"\n";
//if (EndTag!="")
//PixelColor+="."+EndTag;
//PixelColor = CodeName+" = "+PixelColor;
PixelColor += SL.GCCalculateMix(SG,CodeName,SL.GetSampleNameFirst(),Function,ShaderNumber)+"\n\n";
ShaderCode+=PixelColor;
}
return ShaderCode;
}
public static string GenerateAlpha(ShaderGenerate SG,ShaderEffect SE, ShaderLayer SL,string Line,int Effect){
return "pow("+Line+","+SE.Inputs[0].Get()+")";
}
public string GCUniforms(ShaderGenerate SG){
string ShaderCode = "//Make our inputs accessible by declaring them here.\n";
#if PRE_UNITY_5
if (DiffuseLightingType.Type==4){
ShaderCode+="samplerCUBE _Cube;\n";
}
#endif
foreach(ShaderInput SI in ShaderInputs){
if (SI.InEditor||SG.Temp){
if (SI.Type==0)
ShaderCode+=" sampler2D "+SI.Get()+";\n";
if (SI.Type==1&&(SI.Get()!="_SpecColor"))
ShaderCode+=" float4 "+SI.Get()+";\n";
if (SI.Type==2)
ShaderCode+=" samplerCUBE "+SI.Get()+";\n";
if (SI.Type==3||SI.Type==4)
ShaderCode+=" float "+SI.Get()+";\n";
}
}
if (SG.UsedGrabPass){
ShaderCode+="//Setup inputs for the grab pass texture and some meta information about it.\n"+
"sampler2D _GrabTexture;\n"+
"float4 _GrabTexture_TexelSize;\n";
}
if (SG.UsedDepthTexture){
ShaderCode+="//Setup inputs for the depth texture.\n"+
"sampler2D_float _CameraDepthTexture;\n";
}
if (SG.Temp){
ShaderCode+="//Setup some time stuff for the Shader Sandwich preview\n float4 _SSTime;\n"+
" float4 _SSSinTime;\n"+
" float4 _SSCosTime;\n";
}
return ShaderCode;
}
public string GCPragma(ShaderGenerate SG,ShaderPass SP)
{
string shaderCode = "";
if (ParallaxOn.On)
shaderCode+="//Set up some Parallax Occlusion Mapping Settings\n#define LINEAR_SEARCH "+(Math.Round(ParallaxBinaryQuality.Float/2)).ToString()+"\n"+
"#define BINARY_SEARCH "+ParallaxBinaryQuality.Get()+"\n";
shaderCode+=" #pragma surface frag_surf "+GCLightingName(SP);
if (ShellsOn.On||ShaderLayersVertex.Count>0||TessellationOn.On)
shaderCode+=" vertex:vert ";
if (!TransparencyReceive.On||!TransparencyOn.On)
shaderCode+=" addshadow ";
if (GCLightingName(SP)=="CLUnlit"){
#if UNITY_5
shaderCode+= " noforwardadd noambient novertexlights nolightmap nodynlightmap nodirlightmap";
#else
shaderCode+= " noforwardadd noambient novertexlights nolightmap nodirlightmap";
#endif
}
if ((TransparencyType.Type==1&&TransparencyOn.On&&!TransparencyReceive.On&&!(ShaderPassShells(SP)&&ShellsBlendMode.Type!=0)&&!(ShaderPassStandard(SP)&&BlendMode.Type!=0))&&!SG.Wireframe){
shaderCode+= " alpha";
#if UNITY_5
if (GCLightingName(SP)!="CLPBR_Standard"||!TransparencyPBR.On)
shaderCode+=":fade";
#endif
}
if (TransparencyReceive.On&&TransparencyOn.On)
shaderCode+=" keepalpha ";
if (MiscAmbient.On==false)
shaderCode+=" noambient";
if (MiscVertexLights.On==false)
shaderCode+=" novertexlights";
if (MiscLightmap.On==false){
#if UNITY_5
shaderCode+=" nolightmap nodynlightmap nodirlightmap";
#else
shaderCode+=" nolightmap nodirlightmap";
#endif
}
if (MiscFullShadows.On)
shaderCode+=" fullforwardshadows";
if (MiscHalfView.On)
shaderCode+=" halfasview";
if (!MiscForwardAdd.On)
shaderCode+=" noforwardadd";
#if UNITY_5
if (MiscInterpolateView.On)
shaderCode+=" interpolateview";
if (!MiscShadows.On)
shaderCode+=" noshadow";
#endif
if (TessellationOn.On){
shaderCode+=" tessellate:tess";
if (TessellationSmoothingAmount.Get()!="0"){
shaderCode+=" tessphong:"+TessellationSmoothingAmount.Get();
}
}
shaderCode=" //Set up Unity Surface Shader Settings.\n"+shaderCode+"\n";
shaderCode+="//The Shader Target defines the maximum capabilites of the shader (Number of math operators, texture reads, etc.)\n #pragma target "+((int)TechShaderTarget.Float).ToString()+".0\n";
if (TessellationOn.On)
shaderCode+="#include \"Tessellation.cginc\" //Include some Unity code for tessellation.\n";
return shaderCode;
}
public string GCFragmentMask(ShaderGenerate SG, ShaderPass SP,float Depth){
return " fixed4 frag() : SV_Target {\n"+
" return fixed4(1.0,0.0,0.0,1.0);\n"+
"}\n";
}
public string GCFragment(ShaderGenerate SG, ShaderPass SP,float Depth){
string ShaderCode = "";
ShaderCode+="\n";
ShaderCode+="//Generate the fragment shader (Operates on pixels)\n";
ShaderCode+="void frag_surf (Input IN, inout CSurfaceOutput o) {\n";
#if PRE_UNITY_5
if (DiffuseLightingType.Type==4){
ShaderCode+=@" o.worldRefl = IN.worldRefl;
";
}
#endif
if (!SG.Wireframe){
ShaderCode+=" float SSShellDepth = 1-"+Depth.ToString()+";\n";
ShaderCode+=" float SSParallaxDepth = 0;\n";
if (SG.UsedScreenPos)
ShaderCode+="IN.screenPos.xy /= IN.screenPos.w;\n";
//if (SG.TooManyTexcoords){
foreach (ShaderInput SI in ShaderInputs){
if (SI.Type==0)
{
if (SI.UsedMapType0==true||SI.UsedMapType1==true)
{
if (SG.TooManyTexcoords)
ShaderCode+=" float2 uv"+SI.Get()+" = IN.uvTexcoord;\n";
else
ShaderCode+=" float2 uv"+SI.Get()+" = IN.uv"+SI.Get()+";\n";
}
}
}
//}
ShaderCode+=" //Set reasonable defaults for the fragment outputs.\n o.Albedo = float3(0.8,0.8,0.8);\n"+
" float4 Emission = float4(0,0,0,0);\n";
if (GCLightingName(SP)=="CLPBR_Standard"){
if (SpecularOn.On)
ShaderCode+=" o.Smoothness = "+SpecularHardness.Get()+";\n";
else
ShaderCode+=" o.Smoothness = 0;\n";
}
else{
if (SpecularOn.On)
ShaderCode+=" o.Smoothness = "+SpecularHardness.Get()+"*2;\n";
else
ShaderCode+=" o.Smoothness = 0;\n";
}
//if (SG.UsedNormals||SG.UsedShellsNormals)
//ShaderCode+=" o.Normal = float3(0.5,0.5,1);\n";
if (SG.UsedNormals||SG.UsedShellsNormals)
ShaderCode+=" o.Normal = float3(0,0,1);\n";
ShaderCode+=" o.Alpha = 1.0;\n"+
" o.Occlusion = 1.0;\n"+
" o.Specular = float3(0.3,0.3,0.3);\n";
if (SG.UsedMapGenerate==true)
ShaderCode+=//" half2 UVy;\n"+
//" half2 UVx;\n"+
//" half2 UVz;\n\n"+
//" half4 TEXy;\n"+
//" half4 TEXx;\n"+
//" half4 TEXz;\n\n"+
//" half3 blend = normalize(abs(IN.worldNormal));\n";
" half3 blend = pow((abs(WorldNormalVector(IN, o.Normal))),5);\n blend /= blend.x+blend.y+blend.z;\n";
foreach(string Ty in ShaderSandwich.EffectsList){
bool IsUsed = false;
foreach (ShaderLayer SL in ShaderUtil.GetAllLayers()){
foreach(ShaderEffect SE in SL.LayerEffects)
{
if (Ty==SE.TypeS&&SE.Visible)
IsUsed = true;
}
}
if (IsUsed){
ShaderEffect NewEffect = ShaderEffect.CreateInstance<ShaderEffect>();
NewEffect.ShaderEffectIn(Ty);
if (ShaderEffect.GetMethod(NewEffect.TypeS,"GenerateStart")!=null)
ShaderCode+= (string)ShaderEffect.GetMethod(NewEffect.TypeS,"GenerateStart").Invoke(null,new object[]{SG})+"\n";
}
}
ShaderCode+="#PARALLAX";
ShaderCode+="#GENERATEMULTIUSEDBASES\n";
foreach(ShaderLayerList SLL in ShaderLayersMasks)
{
if (SG.UsedMasks[SLL]>0&&!SLL.IsLighting.On){
ShaderCode+=SLL.GCVariable();
ShaderCode+=GCLayers(SG,SLL.Name.Text,SLL,SLL.CodeName,SLL.EndTag.Text,SLL.Function,false,true);
}
}
if (ShaderPassStandard(SP)||ShaderPassMask(SP))
{
ShaderCode+=GCLayers(SG,"Normals",ShaderLayersNormal,"o.Normal","rgb","",false,true);
//if (SG.UsedNormals)
//ShaderCode+="o.Normal = (o.Normal-0.5)*2;\n";
if (TransparencyOn.On)
ShaderCode+=GCLayers(SG,"Alpha",ShaderLayersAlpha,"o.Alpha","a","",false,false);
if (TransparencyOn.On&&TransparencyType.Type==0){
ShaderCode+=" clip(o.Alpha-"+TransparencyAmount.Get()+");\n";
}
if (TransparencyOn.On&&TransparencyType.Type==1){
ShaderCode+=" o.Alpha *= "+TransparencyAmount.Get()+";\n";
}
ShaderCode+=GCLayers(SG,"Diffuse",ShaderLayersDiffuse,"o.Albedo","rgb","",false,true);
if (EmissionOn.On)
ShaderCode+=GCLayers(SG,"Emission",ShaderLayersEmission,"Emission","rgba","",false,true);
if (SpecularOn.On)
ShaderCode+=GCLayers(SG,"Gloss",ShaderLayersSpecular,"o.Specular","rgb","",false,true);
}
if (ShaderPassShells(SP))
{
ShaderCode+=GCLayers(SG,"Normals",ShaderLayersShellNormal,"o.Normal","rgb","",false,true);
//if (SG.UsedShellsNormals)
//ShaderCode+="o.Normal = (o.Normal-0.5)*2;\n";
if (TransparencyOn.On)
ShaderCode+=GCLayers(SG,"Alpha",ShaderLayersShellAlpha,"o.Alpha","a","",false,true);
if (TransparencyOn.On&&TransparencyType.Type==0){
ShaderCode+=" clip(o.Alpha-"+TransparencyAmount.Get()+");\n";
}
if (TransparencyOn.On&&TransparencyType.Type==1){
ShaderCode+=" o.Alpha *= "+TransparencyAmount.Get()+";\n";
}
ShaderCode+=GCLayers(SG,"Diffuse",ShaderLayersShellDiffuse,"o.Albedo","rgb","",false,true);
if (EmissionOn.On)
ShaderCode+=GCLayers(SG,"Emission",ShaderLayersShellEmission,"Emission","rgba","",false,true);
if (SpecularOn.On)
ShaderCode+=GCLayers(SG,"Gloss",ShaderLayersShellSpecular,"o.Specular","rgb","",false,true);
}
if (EmissionOn.On){
ShaderCode+=" o.Emission = Emission.rgb;\n";
if (EmissionType.Type==1)
ShaderCode+=" o.Emission*=o.Albedo;\n";
if (EmissionType.Type==2){
ShaderCode+=" o.Albedo *= 1-Emission.a;\n";
//ShaderCode+=" o.Emission = float3(0,0,0);\n";
}
}
}
ShaderCode+="}\n";
string GenMultiUseBases = "";
//int GenMultiUseBasesCount = 0;
/*foreach(KeyValuePair<string, int> entry in SG.UsedBases){
if (entry.Value>=2)
{
GenMultiUseBasesCount+=1;
GenMultiUseBases+="float4 MultiUse"+GenMultiUseBasesCount.ToString()+" = "+entry.Key+";//"+entry.Value.ToString()+"\n";
ShaderCode = ShaderCode.Replace(entry.Key,"MultiUse"+GenMultiUseBasesCount.ToString());
}
}*/
ShaderCode = ShaderCode.Replace("#GENERATEMULTIUSEDBASES",GenMultiUseBases);
ShaderCode = ShaderCode.Replace("#PARALLAX",GCParallax(SG));
SG.UsedBases.Clear();
return ShaderCode;
}
public string GCPass(ShaderGenerate SG,ShaderPass SP,float Dist){
return GCPass_Real(SG,SP,Dist);
}
public static string GenerateWAlpha(ShaderGenerate SG,ShaderEffect SE, ShaderLayer SL,string Line,int Effect){
return "(round("+Line+"*"+SE.Inputs[0].Get()+")/"+SE.Inputs[0].Get()+")";
}
public static string Generate(ShaderGenerate SG,ShaderEffect SE, ShaderLayer SL,string Line,int Effect){
return "(normalize("+Line+"))";
}
public string GCPassMask(ShaderGenerate SG,ShaderPass SP,float Dist){
if (TransparencyZWrite.On&&TransparencyOn.On&&TransparencyType.Type==1)
return GCPassMask_Real(SG,SP,Dist);
return "";
}
public string GCPass_Real(ShaderGenerate SG,ShaderPass SP,float Dist){
string ShaderCode = "";
//SG.Reset();
// int OldTransType = TransparencyType.Type;
float OldTransAmount = TransparencyAmount.Float;
ShaderInput OldTransInput = TransparencyAmount.Input;
if (TransparencyZWrite.On&&TransparencyZWriteType.Type==1){
TransparencyAmount.Float = 1f;
TransparencyAmount.Input = null;
}
ShaderCode+=" ZWrite On\n";
if (ShaderPassShells(SP)){
if (ShellsZWrite.On)
ShaderCode+=" ZWrite On\n";
else
ShaderCode+=" ZWrite Off\n";
}
if (TransparencyOn.On&&TransparencyType.Type==1&&TransparencyZWrite.On==false)
ShaderCode+=" ZWrite Off\n";
//else
//ShaderCode+=" ZWrite On\n";
if (ShaderPassBase(SP)){
if (ShaderPassShells(SP))
ShaderCode+=" cull "+ShellsCull.CodeNames[ShellsCull.Type]+"//Culling specifies which sides of the models faces to hide.\n";
else
ShaderCode+=" cull "+TechCull.CodeNames[TechCull.Type]+"//Culling specifies which sides of the models faces to hide.\n";
}
ShaderCode+=GCLabTags(SP);
ShaderCode+=" CGPROGRAM\n\n";
ShaderCode+=GCUniforms(SG);
ShaderCode+=GCPragma(SG,SP);
ShaderCode+=GCSurfaceOutput();
ShaderCode+=GCInputs(SG);
ShaderCode+=GCFunctions(SG);
ShaderCode+=GCLighting(SG,SP);
ShaderCode+=GCVertex(SG,SP,Dist);
ShaderCode+=GCFragment(SG,SP,Dist);
ShaderCode+=" ENDCG\n";
if (TransparencyZWrite.On&&TransparencyZWriteType.Type==1){
TransparencyAmount.Input = OldTransInput;
TransparencyAmount.Float = OldTransAmount;
}
return ShaderCode;
}
public static string GenerateAlpha(ShaderGenerate SG,ShaderEffect SE, ShaderLayer SL,string Line,int Effect){
return "("+Line+")";
}
public string GCParallax(ShaderGenerate SG){
string ShaderCode = "";
if (ParallaxOn.On&&SG.UsedParallax)
{
ShaderCode+="IN.viewDir = normalize(IN.viewDir);\n"+
" float3 view = IN.viewDir*(-1*"+ParallaxHeight.Get()+");\n";
//if (SG.UsedWorldPos==true)
if (SG.UsedWorldNormals&&SG.UsedWorldPos)
ShaderCode+=
" float3 worldView = IN.worldNormal*(-1*"+ParallaxHeight.Get()+");\n";
//" float3 worldView = WorldNormalVector(IN,IN.viewDir)*(-1*"+ParallaxHeight.Get()+");\n";
//shaderCode+=" float ray_intersect_rm(in v2f_surf IN, in float3 ds)\n";
//shaderCode+=" {\n"+
ShaderCode+="\n"+
" float size = 1.0/LINEAR_SEARCH; // stepping size\n"+
" float depth = 0;//pos\n"+
" int i;\n"+
" float Height = 1;\n"+
" for(i = 0; i < LINEAR_SEARCH-1; i++)// search until it steps over (Front to back)\n"+
" {\n"+
//" float4 t = tex2D(reliefmap,dp+ds*(depth)).a;\n"+
GCLayers(SG,"Parallax",ShaderLayersHeight,"Height","a","",true,true)+"\n"+
" \n"+
" if(depth < (1-Height))\n"+
" depth += size; \n"+
" }\n"+
" //depth = best_depth;\n"+
" for(i = 0; i < BINARY_SEARCH; i++) // look around for a closer match\n"+
" {\n"+
" size*=0.5;\n"+
" \n"+
//" float4 t = tex2D(reliefmap,dp+ds*(depth)).a;\n"+
GCLayers(SG,"Parallax",ShaderLayersHeight,"Height","a","",true,true)+"\n"+
" \n"+
" if(depth < (1-Height))\n"+
" depth += (2*size);\n"+
" \n"+
" depth -= size; \n"+
" }\n"+
" \nSSParallaxDepth = depth;\n";
//" return depth;\n";
//" }\n";
//ShaderCode+=" float depth = ray_intersect_rm(IN, view);\n";// distance(_WorldSpaceCameraPos, IN.worldPos)
string UvClipName = "uvTexcoord";
// string UvClipName2 = "";
foreach (ShaderInput SI in ShaderInputs){
if (SI.Type==0)
{
//if (SI.UsedMapTypeUv1==true||SI.UsedMapTypeUv2==true)
{
ShaderCode+=" uv"+SI.Get()+".xy += view.xy*depth;\n";
if ("uv"+SI.Get()+".zw"==SG.GeneralUV)
ShaderCode+=" uv"+SI.Get()+".zw += view.xy*depth;\n";
//if (SI.UsedMapTypeCube==true)
{
UvClipName = "uv"+SI.Get();
//UvClipName2 = SI.Get()+"_ST";
}
}
}
}
//UnityEngine.Debug.Log(SG.GeneralUV);
if (SG.GeneralUV=="uvTexcoord")
ShaderCode+="IN.uvTexcoord.xy += view.xy*depth;\n";
if (SG.UsedWorldNormals&&SG.UsedWorldPos)
ShaderCode+=" IN.worldPos += worldView*depth;\n";
if (ParallaxOn.On==true&&ParallaxSilhouetteClipping.On==true&&UvClipName!="")
{
/*ShaderCode+=" clip("+UvClipName+".x / "+UvClipName2+".x);\n"+
" clip("+UvClipName+".y / "+UvClipName2+".y);\n"+
" clip(-("+UvClipName+".x / "+UvClipName2+".x -1));\n"+
" clip(-("+UvClipName+".y / "+UvClipName2+".y -1));\n";*/
ShaderCode+=" clip(IN."+SG.GeneralUV+".x);\n"+
" clip(IN."+SG.GeneralUV+".y);\n"+
" clip(-(IN."+SG.GeneralUV+".x-1));\n"+
" clip(-(IN."+SG.GeneralUV+".y-1));\n";
}
}
SG.UsedBases.Clear();
return ShaderCode;
}
public static string Generate(ShaderGenerate SG,ShaderEffect SE, ShaderLayer SL,string Line,int Effect){
return "hsv2rgb(rgb2hsv("+Line+")+float3("+SE.Inputs[0].Get()+","+SE.Inputs[1].Get()+","+SE.Inputs[2].Get()+"))";
}
public string GCFragmentMask(ShaderGenerate SG, ShaderPass SP){
return GCFragmentMask(SG,SP,0f);
}
