public void GenerateNodeFunction(FunctionRegistry registry, GraphContext graphContext, GenerationMode generationMode)
{
if (generationMode == GenerationMode.Preview)
{
registry.ProvideFunction(GetFunctionName(), s =>
{
s.AppendLine("Gradient {0} ()",
GetFunctionName());
using (s.BlockScope())
{
s.AppendLine("Gradient g;");
s.AppendLine("g.type = _{0}_Type;", GetVariableNameForNode());
s.AppendLine("g.colorsLength = _{0}_ColorsLength;", GetVariableNameForNode());
s.AppendLine("g.alphasLength = _{0}_AlphasLength;", GetVariableNameForNode());
for (int i = 0; i < 8; i++)
{
s.AppendLine("g.colors[{0}] = _{1}_ColorKey{0};", i, GetVariableNameForNode());
}
for (int i = 0; i < 8; i++)
{
s.AppendLine("g.alphas[{0}] = _{1}_AlphaKey{0};", i, GetVariableNameForNode());
}
s.AppendLine("return g;", true);
}
});
}
else
{
registry.ProvideFunction(GetFunctionName(), s =>
{
s.AppendLine("Gradient {0} ()",
GetFunctionName());
using (s.BlockScope())
{
GradientUtils.GetGradientDeclaration(m_Gradient, ref s);
s.AppendLine("return g;", true);
}
});
}
}
public override void CollectPreviewMaterialProperties(List <PreviewProperty> properties)
{
base.CollectPreviewMaterialProperties(properties);
properties.Add(new PreviewProperty(PropertyType.Vector1)
{
name = string.Format("_{0}_Type", GetVariableNameForNode()),
floatValue = (int)m_Gradient.mode
});
properties.Add(new PreviewProperty(PropertyType.Vector1)
{
name = string.Format("_{0}_ColorsLength", GetVariableNameForNode()),
floatValue = m_Gradient.colorKeys.Length
});
properties.Add(new PreviewProperty(PropertyType.Vector1)
{
name = string.Format("_{0}_AlphasLength", GetVariableNameForNode()),
floatValue = m_Gradient.alphaKeys.Length
});
for (int i = 0; i < 8; i++)
{
properties.Add(new PreviewProperty(PropertyType.Vector4)
{
name = string.Format("_{0}_ColorKey{1}", GetVariableNameForNode(), i),
vector4Value = i < m_Gradient.colorKeys.Length ? GradientUtils.ColorKeyToVector(m_Gradient.colorKeys[i]) : Vector4.zero
});
}
for (int i = 0; i < 8; i++)
{
properties.Add(new PreviewProperty(PropertyType.Vector2)
{
name = string.Format("_{0}_AlphaKey{1}", GetVariableNameForNode(), i),
vector4Value = i < m_Gradient.alphaKeys.Length ? GradientUtils.AlphaKeyToVector(m_Gradient.alphaKeys[i]) : Vector2.zero
});
}
}
public override void GetPreviewProperties(List <PreviewProperty> properties, string name)
{
properties.Add(new PreviewProperty(PropertyType.Vector1)
{
name = string.Format("{0}_Type", name),
floatValue = (int)value.mode
});
properties.Add(new PreviewProperty(PropertyType.Vector1)
{
name = string.Format("{0}_ColorsLength", name),
floatValue = value.colorKeys.Length
});
properties.Add(new PreviewProperty(PropertyType.Vector1)
{
name = string.Format("{0}_AlphasLength", name),
floatValue = value.alphaKeys.Length
});
for (int i = 0; i < 8; i++)
{
properties.Add(new PreviewProperty(PropertyType.Vector4)
{
name = string.Format("{0}_ColorKey{1}", name, i),
vector4Value = i < value.colorKeys.Length ? GradientUtils.ColorKeyToVector(value.colorKeys[i]) : Vector4.zero
});
}
for (int i = 0; i < 8; i++)
{
properties.Add(new PreviewProperty(PropertyType.Vector2)
{
name = string.Format("{0}_AlphaKey{1}", name, i),
vector4Value = i < value.alphaKeys.Length ? GradientUtils.AlphaKeyToVector(value.alphaKeys[i]) : Vector2.zero
});
}
}
public override string GetPropertyDeclarationString(string delimiter = ";")
{
if (m_OverrideMembers)
{
ShaderStringBuilder s = new ShaderStringBuilder();
s.AppendLine("Gradient Unity{0} ()",
referenceName);
using (s.BlockScope())
{
s.AppendLine("Gradient g;");
s.AppendLine("g.type = {0}_Type;", m_OverrideSlotName);
s.AppendLine("g.colorsLength = {0}_ColorsLength;", m_OverrideSlotName);
s.AppendLine("g.alphasLength = {0}_AlphasLength;", m_OverrideSlotName);
for (int i = 0; i < 8; i++)
{
s.AppendLine("g.colors[{0}] = {1}_ColorKey{0};", i, m_OverrideSlotName);
}
for (int i = 0; i < 8; i++)
{
s.AppendLine("g.alphas[{0}] = {1}_AlphaKey{0};", i, m_OverrideSlotName);
}
s.AppendLine("return g;", true);
}
return(s.ToString());
}
else
{
ShaderStringBuilder s = new ShaderStringBuilder();
s.AppendLine("Gradient Unity{0} ()", referenceName);
using (s.BlockScope())
{
GradientUtils.GetGradientDeclaration(value, ref s);
s.AppendLine("return g;", true);
}
return(s.ToString());
}
}
public void SetMaterialPropertyBlockValue(Material mat)
{
if ((propType == PropertyType.Texture2D || propType == PropertyType.Texture2DArray || propType == PropertyType.Texture3D) && textureValue != null)
{
mat.SetTexture(name, m_ClassData.textureValue);
}
else if (propType == PropertyType.Cubemap && cubemapValue != null)
{
mat.SetTexture(name, m_ClassData.cubemapValue);
}
else if (propType == PropertyType.Color)
{
mat.SetColor(name, m_StructData.colorValue);
}
else if (propType == PropertyType.Vector2 || propType == PropertyType.Vector3 || propType == PropertyType.Vector4)
{
mat.SetVector(name, m_StructData.vector4Value);
}
else if (propType == PropertyType.Vector1)
{
mat.SetFloat(name, m_StructData.floatValue);
}
else if (propType == PropertyType.Boolean)
{
mat.SetFloat(name, m_StructData.booleanValue ? 1 : 0);
}
else if (propType == PropertyType.Matrix2 || propType == PropertyType.Matrix3 || propType == PropertyType.Matrix4)
{
mat.SetMatrix(name, m_StructData.matrixValue);
}
else if (propType == PropertyType.Gradient)
{
mat.SetFloat(string.Format("{0}_Type", name), (int)m_ClassData.gradientValue.mode);
mat.SetFloat(string.Format("{0}_ColorsLength", name), m_ClassData.gradientValue.colorKeys.Length);
mat.SetFloat(string.Format("{0}_AlphasLength", name), m_ClassData.gradientValue.alphaKeys.Length);
for (int i = 0; i < 8; i++)
{
mat.SetVector(string.Format("{0}_ColorKey{1}", name, i), i < m_ClassData.gradientValue.colorKeys.Length ? GradientUtils.ColorKeyToVector(m_ClassData.gradientValue.colorKeys[i]) : Vector4.zero);
}
for (int i = 0; i < 8; i++)
{
mat.SetVector(string.Format("{0}_AlphaKey{1}", name, i), i < m_ClassData.gradientValue.alphaKeys.Length ? GradientUtils.AlphaKeyToVector(m_ClassData.gradientValue.alphaKeys[i]) : Vector2.zero);
}
}
}
public override void AddDefaultProperty(PropertyCollector properties, GenerationMode generationMode)
{
var matOwner = owner as AbstractMaterialNode;
if (matOwner == null)
{
throw new Exception(string.Format("Slot {0} either has no owner, or the owner is not a {1}", this, typeof(AbstractMaterialNode)));
}
if (generationMode == GenerationMode.Preview)
{
properties.AddShaderProperty(new Vector1ShaderProperty()
{
overrideReferenceName = string.Format("{0}_Type", matOwner.GetVariableNameForSlot(id)),
value = (int)value.mode,
generatePropertyBlock = false
});
properties.AddShaderProperty(new Vector1ShaderProperty()
{
overrideReferenceName = string.Format("{0}_ColorsLength", matOwner.GetVariableNameForSlot(id)),
value = value.colorKeys.Length,
generatePropertyBlock = false
});
properties.AddShaderProperty(new Vector1ShaderProperty()
{
overrideReferenceName = string.Format("{0}_AlphasLength", matOwner.GetVariableNameForSlot(id)),
value = value.alphaKeys.Length,
generatePropertyBlock = false
});
for (int i = 0; i < 8; i++)
{
properties.AddShaderProperty(new Vector4ShaderProperty()
{
overrideReferenceName = string.Format("{0}_ColorKey{1}", matOwner.GetVariableNameForSlot(id), i),
value = i < value.colorKeys.Length ? GradientUtils.ColorKeyToVector(value.colorKeys[i]) : Vector4.zero,
generatePropertyBlock = false
});
}
for (int i = 0; i < 8; i++)
{
properties.AddShaderProperty(new Vector4ShaderProperty()
{
overrideReferenceName = string.Format("{0}_AlphaKey{1}", matOwner.GetVariableNameForSlot(id), i),
value = i < value.alphaKeys.Length ? GradientUtils.AlphaKeyToVector(value.alphaKeys[i]) : Vector2.zero,
generatePropertyBlock = false
});
}
}
var prop = new GradientShaderProperty();
prop.overrideReferenceName = matOwner.GetVariableNameForSlot(id);
prop.generatePropertyBlock = false;
prop.value = value;
if (generationMode == GenerationMode.Preview)
{
prop.OverrideMembers(matOwner.GetVariableNameForSlot(id));
}
properties.AddShaderProperty(prop);
}
protected override string ConcreteSlotValueAsVariable()
{
return(GradientUtils.GetGradientValue(value, true, ""));
}
public void GenerateNodeCode(ShaderGenerator visitor, GraphContext graphContext, GenerationMode generationMode)
{
var graph = owner as GraphData;
var property = graph.properties.FirstOrDefault(x => x.guid == propertyGuid);
if (property == null)
{
return;
}
if (property is Vector1ShaderProperty)
{
var result = string.Format("{0} {1} = {2};"
, precision
, GetVariableNameForSlot(OutputSlotId)
, property.referenceName);
visitor.AddShaderChunk(result, true);
}
else if (property is Vector2ShaderProperty)
{
var result = string.Format("{0}2 {1} = {2};"
, precision
, GetVariableNameForSlot(OutputSlotId)
, property.referenceName);
visitor.AddShaderChunk(result, true);
}
else if (property is Vector3ShaderProperty)
{
var result = string.Format("{0}3 {1} = {2};"
, precision
, GetVariableNameForSlot(OutputSlotId)
, property.referenceName);
visitor.AddShaderChunk(result, true);
}
else if (property is Vector4ShaderProperty)
{
var result = string.Format("{0}4 {1} = {2};"
, precision
, GetVariableNameForSlot(OutputSlotId)
, property.referenceName);
visitor.AddShaderChunk(result, true);
}
else if (property is ColorShaderProperty)
{
var result = string.Format("{0}4 {1} = {2};"
, precision
, GetVariableNameForSlot(OutputSlotId)
, property.referenceName);
visitor.AddShaderChunk(result, true);
}
else if (property is BooleanShaderProperty)
{
var result = string.Format("{0} {1} = {2};"
, precision
, GetVariableNameForSlot(OutputSlotId)
, property.referenceName);
visitor.AddShaderChunk(result, true);
}
else if (property is Matrix2ShaderProperty)
{
var result = string.Format("{0}2x2 {1} = {2};"
, precision
, GetVariableNameForSlot(OutputSlotId)
, property.referenceName);
visitor.AddShaderChunk(result, true);
}
else if (property is Matrix3ShaderProperty)
{
var result = string.Format("{0}3x3 {1} = {2};"
, precision
, GetVariableNameForSlot(OutputSlotId)
, property.referenceName);
visitor.AddShaderChunk(result, true);
}
else if (property is Matrix4ShaderProperty)
{
var result = string.Format("{0}4x4 {1} = {2};"
, precision
, GetVariableNameForSlot(OutputSlotId)
, property.referenceName);
visitor.AddShaderChunk(result, true);
}
else if (property is SamplerStateShaderProperty)
{
SamplerStateShaderProperty samplerStateProperty = property as SamplerStateShaderProperty;
var result = string.Format("SamplerState {0} = {1}_{2}_{3};"
, GetVariableNameForSlot(OutputSlotId)
, samplerStateProperty.referenceName
, samplerStateProperty.value.filter
, samplerStateProperty.value.wrap);
visitor.AddShaderChunk(result, true);
}
else if (property is GradientShaderProperty)
{
if (generationMode == GenerationMode.Preview)
{
var result = string.Format("Gradient {0} = {1};"
, GetVariableNameForSlot(OutputSlotId)
, GradientUtils.GetGradientForPreview(property.referenceName));
visitor.AddShaderChunk(result, true);
}
else
{
var result = string.Format("Gradient {0} = {1};"
, GetVariableNameForSlot(OutputSlotId)
, property.referenceName);
visitor.AddShaderChunk(result, true);
}
}
}
public void GenerateNodeCode(ShaderStringBuilder sb, GraphContext graphContext, GenerationMode generationMode)
{
var graph = owner as GraphData;
var property = graph.properties.FirstOrDefault(x => x.guid == propertyGuid);
if (property == null)
{
return;
}
if (property is Vector1ShaderProperty)
{
var result = string.Format("$precision {0} = {1};"
, GetVariableNameForSlot(OutputSlotId)
, property.referenceName);
sb.AppendLine(result);
}
else if (property is Vector2ShaderProperty)
{
var result = string.Format("$precision2 {0} = {1};"
, GetVariableNameForSlot(OutputSlotId)
, property.referenceName);
sb.AppendLine(result);
}
else if (property is Vector3ShaderProperty)
{
var result = string.Format("$precision3 {0} = {1};"
, GetVariableNameForSlot(OutputSlotId)
, property.referenceName);
sb.AppendLine(result);
}
else if (property is Vector4ShaderProperty)
{
var result = string.Format("$precision4 {0} = {1};"
, GetVariableNameForSlot(OutputSlotId)
, property.referenceName);
sb.AppendLine(result);
}
else if (property is ColorShaderProperty)
{
var result = string.Format("$precision4 {0} = {1};"
, GetVariableNameForSlot(OutputSlotId)
, property.referenceName);
sb.AppendLine(result);
}
else if (property is BooleanShaderProperty)
{
var result = string.Format("$precision {0} = {1};"
, GetVariableNameForSlot(OutputSlotId)
, property.referenceName);
sb.AppendLine(result);
}
else if (property is Matrix2ShaderProperty)
{
var result = string.Format("$precision2x2 {0} = {1};"
, GetVariableNameForSlot(OutputSlotId)
, property.referenceName);
sb.AppendLine(result);
}
else if (property is Matrix3ShaderProperty)
{
var result = string.Format("$precision3x3 {0} = {1};"
, GetVariableNameForSlot(OutputSlotId)
, property.referenceName);
sb.AppendLine(result);
}
else if (property is Matrix4ShaderProperty)
{
var result = string.Format("$precision4x4 {0} = {1};"
, GetVariableNameForSlot(OutputSlotId)
, property.referenceName);
sb.AppendLine(result);
}
else if (property is SamplerStateShaderProperty)
{
SamplerStateShaderProperty samplerStateProperty = property as SamplerStateShaderProperty;
var result = string.Format("SamplerState {0} = {1};"
, GetVariableNameForSlot(OutputSlotId)
, samplerStateProperty.referenceName);
sb.AppendLine(result);
}
else if (property is GradientShaderProperty)
{
if (generationMode == GenerationMode.Preview)
{
var result = string.Format("Gradient {0} = {1};"
, GetVariableNameForSlot(OutputSlotId)
, GradientUtils.GetGradientForPreview(property.referenceName));
sb.AppendLine(result);
}
else
{
var result = string.Format("Gradient {0} = {1};"
, GetVariableNameForSlot(OutputSlotId)
, property.referenceName);
sb.AppendLine(result);
}
}
}
public void GenerateNodeCode(ShaderStringBuilder sb, GraphContext graphContext, GenerationMode generationMode)
{
if (generationMode.IsPreview())
{
sb.AppendLine("Gradient {0} = {1};", GetVariableNameForSlot(outputSlotId), GradientUtils.GetGradientForPreview(GetVariableNameForNode()));
}
else
{
sb.AppendLine("Gradient {0} = {1}", GetVariableNameForSlot(outputSlotId), GradientUtils.GetGradientValue(gradient, true, ";"));
}
}
protected override string ConcreteSlotValueAsVariable(AbstractMaterialNode.OutputPrecision precision)
{
return(GradientUtils.GetGradientValue(value, precision, true, ""));
}
