private void InitializeVaryingsWithDefaultValues(ShaderGenerationContext context)
{
var vertexInput = context.KeywordMap.GetKeyword <KeywordVertexInput>();
var fragmentInput = context.KeywordMap.GetKeyword <KeywordFragmentInput>();
bool hasDefinedFragmentShader = !IsDefault;
var attributesToInit = new List <AttributeConfig>();
var vertexAttributes = vertexInput.GetAttributes();
foreach (var fragmentAttribute in fragmentInput.GetAttributes())
{
if (fragmentAttribute.AttributeType == AttributeType.Anonymous || fragmentAttribute.AttributeType == AttributeType.Position)
{
continue;
}
if (vertexAttributes.Any(vertexAttribute => fragmentAttribute == vertexAttribute))
{
attributesToInit.Add(fragmentAttribute);
}
}
foreach (AttributeConfig config in attributesToInit)
{
context.WriteLineIndented($"output.__VARYINGS{config.AttributeType.ToString().ToUpper()} = input.__ATTRIBUTES{config.AttributeType.ToString().ToUpper()};");
}
}
public virtual void Write(ShaderGenerationContext context)
{
AddPassRequiredAttributes(GetRequiredPassAttributes(context));
AddPassKeywords(GetRequiredPassKeywords(context));
context.LogShaderSection($"Generated Data Struct {AttributeStructName}");
context.WriteLine($"struct {AttributeStructName}");
context.WriteLine("{");
context.WriteIndented((c) =>
{
for (int i = 0; i < _attributes.Count; i++)
{
AttributeConfig config = _attributes[i];
if (config.AttributeType != AttributeType.Anonymous)
{
c.WriteLine($"#define __{AttributeStructName.ToUpper()}{config.AttributeType.ToString().ToUpper()} {config.Name}");
}
config.WriteAttributeDefinition(c, i, this is KeywordFragmentInput);
}
});
foreach (string keyword in _keywords)
{
context.WriteLine(keyword);
}
context.WriteLine("};");
context.Newine();
}
public override void Write(ShaderGenerationContext context)
{
base.Write(context);
if (GetAttribute(AttributeType.Position).UserDefined)
{
throw new KeywordMap.ShaderGenerationException("You are not supposed to manipulate the clip space position manually. Use SETPOSITIONOS(float3) or SETPOSITIONWS(float3) instead to ensure compatibility with all templates");
}
}
public void Write(ShaderGenerationContext context)
{
if (!IsDefault)
{
context.WriteLine("HLSLINCLUDE");
context.WriteLine("#define _NormalMap");
context.WriteLine("ENDHLSL");
}
}
internal void GeneratePasses(ShaderGenerationContext context)
{
context.WriteLine("SubShader{");
var passes = GetShaderModel();
context.WriteIndented(passes.Write);
context.WriteLine("}");
}
public override void Write(ShaderGenerationContext context)
{
context.WriteLine("#define UNITY_SHADER_NO_UPGRADE 1");
context.LogShaderSection("Vertex Shader");
context.WriteIndented(WriteInnerVertexShader);
context.WriteLine("}");
}
public override void GeneratePasses(ShaderGenerationContext context, out ShaderPass mainPass, out List <ShaderPass> additionalPasses)
{
mainPass = new ShaderPassLitForward();
additionalPasses = new List <ShaderPass>()
{
new ShaderPassShadow(),
new ShaderPassDepthOnly(),
new ShaderPassLitMeta(),
};
}
public virtual void Write(ShaderGenerationContext context)
{
if (IsDefault || !context.CurrentPass.IsMainPass)
{
return;
}
context.LogShaderSection("FinalColor Code Block");
context.WriteLine("float4 finalColor = __color;");
context.WriteLine(_parsedCode);
context.WriteLine("__color = finalColor;");
}
public void Write(ShaderGenerationContext context)
{
context.WriteLine($"#define __SAMPLETEXTURE{Name.ToUpper()}(uv) ");
if (KeywordProperty.HasProperty(context, PropertyType.Texture, Name))
{
context.Write($"tex2D({Name}, uv)");
context.WriteLine($"#define __HASETEXTURE{Name.ToUpper()} True");
}
else
{
context.Write($" float4({DefaultValue.x}, {DefaultValue.y}, {DefaultValue.z}, {DefaultValue.w})");
}
}
public static bool HasProperty(ShaderGenerationContext context, PropertyType propertyType, string name)
{
var allProperties = context.KeywordMap.GetMultiKeywords <KeywordProperty>();
foreach (KeywordProperty property in allProperties)
{
if (property._propertyName == name)
{
return(true);
}
}
return(false);
}
public override void Write(ShaderGenerationContext context)
{
if (IsDefault)
{
AddFragmentShaderRequiredAttributes(context);
}
if (_attributes.Any(pair => pair.AttributeType == AttributeType.Anonymous))
{
throw new KeywordMap.ShaderGenerationException("Can't Vertex Attribute needs an explicit AttributeType");
}
base.Write(context);
}
private void AddFragmentShaderRequiredAttributes(ShaderGenerationContext context)
{
var fragmentAttributes = context.KeywordMap.GetKeyword <KeywordFragmentInput>().GetAttributes();
foreach (AttributeConfig fragmentAttribute in fragmentAttributes)
{
if (fragmentAttribute.AttributeType == AttributeType.Anonymous || fragmentAttribute.AttributeType == AttributeType.Position)
{
continue;
}
_attributes.Add(fragmentAttribute);
}
}
private void WriteInnerVertexShader(ShaderGenerationContext context)
{
context.WriteLine("Varyings vert(Attributes input){");
context.WriteLine(" Varyings output = (Varyings)0;");
context.WriteLine("VertexPositionInputs __vertexPositionInputs = GetVertexPositionInputs(input.__ATTRIBUTESPOSITION);");
InitializeVaryingsWithDefaultValues(context);
context.WriteLine(context.CurrentPass.GetVertexShaderHeader());
base.Write(context);
context.WriteLine(context.CurrentPass.GetVertexShaderFooter());
context.WriteLine("output.__VARYINGSPOSITION = __vertexPositionInputs.positionCS;");
context.WriteLine(" return output;");
}
public override void Write(ShaderGenerationContext context)
{
context.LogShaderSection("Fragment Shader");
//todo it migh be more performant to only output a float3 for opaque shaders
context.WriteLine($"{context.CurrentPass.FragmentReturnFormat} frag(Varyings input) : COLOR{{");
context.WriteIndented(WriteFragmentShaderHeader);
base.Write(context);
context.WriteIndented(WriteFragmentShaderFooter);
context.KeywordMap.GetKeyword <KeywordModifyFinalColor>().Write(context);
context.WriteLineIndented("return __color;");
context.WriteLine("}");
}
public void Write(ShaderGenerationContext context)
{
context.KeywordMap.GetKeyword <KeywordQueue>().Write(context);
//todo workaround for now
context.KeywordMap.GetKeyword <KeywordHasNormalMap>().Write(context);
context.WriteLine("HLSLINCLUDE");
context.WriteLine("#include \"Packages/com.henningboat.thshader/ShaderLibrary/Common.cginc\"");
foreach (ShaderModelTexture modelTexture in OptionalShaderModelTextures)
{
modelTexture.Write(context);
}
context.KeywordMap.GetMultiKeywords <KeywordDefine>().ForEach(keyword => keyword.Write(context));
context.KeywordMap.GetMultiKeywords <KeywordProperty>().ForEach(keyword => keyword.Write(context, false));
context.WriteLine(ShaderPass.ReadSourceFile(context, SubShaderHeader));
context.WriteLine("ENDHLSL");
GeneratePasses(context, out ShaderPass mainPass, out List <ShaderPass> additionalPasses);
if (context.SourceMap.CustomPasses.Count > 0)
{
foreach (SourceMap.ShaderPassSource customPass in context.SourceMap.CustomPasses)
{
context.WriteIndented(buildContext => mainPass.WritePass(buildContext, this, customPass));
}
}
else
{
context.WriteIndented(buildContext => mainPass.WritePass(buildContext, this, null));
}
foreach (ShaderPass pass in additionalPasses)
{
context.WriteIndented(buildContext => pass.WritePass(buildContext, this, null));
}
}
public void WriteAttributeDefinition(ShaderGenerationContext context, int attributeIndex, bool isFragmentShader)
{
context.WriteLine($"{DataTypeAndDimensionsString} {Name} : ");
if (AttributeType == AttributeType.Anonymous)
{
context.Write($"COLOR1{attributeIndex}");
}
else
{
if (isFragmentShader && AttributeType == AttributeType.Position)
{
context.Write("SV_POSITION");
}
else
{
context.Write(AttributeType.ToString().ToUpper());
}
}
context.Write(";");
}
public override void GeneratePasses(ShaderGenerationContext context, out ShaderPass mainPass, out List <ShaderPass> additionalPasses)
{
mainPass = new ShaderUnlitPass();
additionalPasses = new List <ShaderPass>();
}
private void WriteFragmentShaderHeader(ShaderGenerationContext context)
{
context.WriteLine(context.CurrentPass.GetFragmentShaderHeader());
context.Newine();
}
internal override void WritePass(ShaderGenerationContext context, ShaderModel config, SourceMap.ShaderPassSource passSpecificCode)
{
context.WriteLine($"UsePass \"{_passName}\"");
}
public virtual void Write(ShaderGenerationContext context)
{
context.LogShaderSection("User Written Code");
context.WriteLine(_parsedCode);
}
public void Write(ShaderGenerationContext context)
{
context.WriteLine($"Tags{{\"Queue\" = \"{FirstLineArguments}\"}}");
}
internal override void Write(ShaderGenerationContext context)
{
context.WriteLine($"{Name} True");
}
public void Write(ShaderGenerationContext context)
{
context.WriteLine($"#define {FirstLineArguments}");
}
protected override List <string> GetRequiredPassKeywords(ShaderGenerationContext context)
{
return(context.CurrentPass.RequiredFragmentKeywords);
}
public abstract void GeneratePasses(ShaderGenerationContext context, out ShaderPass mainPass, out List <ShaderPass> additionalPasses);
protected abstract List <string> GetRequiredPassKeywords(ShaderGenerationContext context);
public void Write(ShaderGenerationContext context, bool propertyDefinition)
{
if (IsDefault)
{
return;
}
if (propertyDefinition)
{
switch (_propertyType)
{
case PropertyType.Texture:
context.WriteLine($"{_propertyName} (\"{_propertyName}\", 2D) = \"\"{{}}");
break;
case PropertyType.Float:
context.WriteLine($"{_propertyName} (\"{_propertyName}\", Float) = {_defaultValue}");
break;
case PropertyType.Float2:
case PropertyType.Float3:
case PropertyType.Float4:
context.WriteLine($"{_propertyName} (\"{_propertyName}\", Vector) = {_defaultValue}");
break;
case PropertyType.Color:
context.WriteLine($"{_propertyName} (\"{_propertyName}\", Color) = {_defaultValue}");
break;
default:
throw new ArgumentOutOfRangeException();
}
}
else
{
switch (_propertyType)
{
case PropertyType.Texture:
context.WriteLine($"sampler2D {_propertyName};");
break;
case PropertyType.Float:
context.WriteLine($"float {_propertyName};");
break;
case PropertyType.Float2:
context.WriteLine($"float2 {_propertyName};");
break;
case PropertyType.Float3:
context.WriteLine($"float3 {_propertyName};");
break;
case PropertyType.Float4:
case PropertyType.Color:
context.WriteLine($"float4 {_propertyName};");
break;
default:
throw new ArgumentOutOfRangeException();
}
}
}
protected override List <AttributeConfig> GetRequiredPassAttributes(ShaderGenerationContext context)
{
return(context.CurrentPass.RequiredFragmentAttributes);
}
protected abstract List <AttributeConfig> GetRequiredPassAttributes(ShaderGenerationContext context);