public void SetMaterialUniforms(Shader shader, RMaterial?previousMaterial, List <string> attributeNames)
{
// TODO: This code could be moved to the constructor.
if (genericMaterial == null || shouldUpdateTexturesAndSamplers)
{
// Don't update this every frame since accessing the database is slow.
// TODO: This may need to be updated more frequently if materials are eventually reassignable to new mesh objects.
// TODO: The actual in game check is more complicated, and involves checking names, subindex, and usage.
var hasRequiredAttributes = ShaderValidation.IsValidAttributeList(ShaderLabel, attributeNames);
genericMaterial = CreateGenericMaterial(hasRequiredAttributes);
shouldUpdateTexturesAndSamplers = false;
}
if (uniformBlock == null)
{
uniformBlock = new UniformBlock(shader, "MaterialParams")
{
BlockBinding = 1
};
SetMaterialParams(uniformBlock);
}
if (shouldUpdateUniformBlock)
{
SetMaterialParams(uniformBlock);
shouldUpdateUniformBlock = false;
}
// Update the uniform values.
genericMaterial.SetShaderUniforms(shader, previousMaterial?.genericMaterial);
uniformBlock.BindBlock(shader);
}
private void LinkProgramSetUpVariables()
{
GL.LinkProgram(Id);
LinkStatusIsOk = ShaderValidation.GetProgramLinkStatus(Id);
TryLoadShaderVariables();
}
public void InvalidShaderLabel()
{
CollectionAssert.AreEqual(new List <string>
{
"Position0",
"Normal0",
"Tangent0",
},
ShaderValidation.GetAttributes("SFX_PBS_0000000000000000"));
}
public void ValidShaderLabel()
{
CollectionAssert.AreEqual(
new List <string> {
"colorSet2",
"map1",
},
ShaderValidation.GetAttributes("SFX_PBS_1b01000008008a68_opaque")
);
}
public void ValidLabelAndAttributeListDifferentOrder()
{
Assert.IsTrue(ShaderValidation.IsValidAttributeList("SFX_PBS_0100000008008269_opaque",
new string[] {
"Normal0",
"Position0",
"map1",
"Tangent0",
})
);
}
public void ValidShaderLabelNoTag()
{
CollectionAssert.AreEqual(
new List <string> {
"opaque",
"sort",
"far",
"near"
},
ShaderValidation.GetRenderPasses("SFX_PBS_010002000800824f")
);
}
/// <summary>
/// Creates and compiles a shader object from <paramref name="shaderSource"/>.
/// </summary>
/// <param name="shaderSource">The shader's GLSL source code</param>
/// <param name="shaderType">determines which shader stage this shader will be used for when linking the program.</param>
public ShaderObject(string shaderSource, ShaderType shaderType) : base(GL.CreateShader(shaderType))
{
ShaderType = shaderType;
if (!string.IsNullOrEmpty(shaderSource))
{
GL.ShaderSource(Id, shaderSource);
GL.CompileShader(Id);
}
WasCompiledSuccessfully = ShaderValidation.GetShaderObjectCompileStatus(Id);
}
public void MissingAttribute()
{
Assert.IsFalse(ShaderValidation.IsValidAttributeList("SFX_PBS_1b01000008008a68_opaque",
new string[] {
"Position0",
"Normal0",
"Tangent0",
"colorSet1",
"colorSet2"
})
);
}
public void InvalidShaderLabel()
{
Assert.IsFalse(ShaderValidation.IsValidAttributeList("SFX_PBS_1b01000008008a68",
new string[] {
"Position0",
"Normal0",
"Tangent0",
"map1",
"colorSet1",
"colorSet2"
})
);
}
public void MissingParameter()
{
Assert.IsFalse(ShaderValidation.IsValidParameterList("SFX_PBS_0000000000000080_opaque",
new MatlEnums.ParamId[] {
MatlEnums.ParamId.RasterizerState0,
MatlEnums.ParamId.CustomVector13,
MatlEnums.ParamId.CustomVector8,
MatlEnums.ParamId.Texture0,
MatlEnums.ParamId.Sampler0,
MatlEnums.ParamId.Texture9,
MatlEnums.ParamId.Sampler9,
})
);
}
public void InvalidShaderLabel()
{
Assert.IsFalse(ShaderValidation.IsValidParameterList("SFX_PBS_0000000000000080_invalid",
new MatlEnums.ParamId[] {
MatlEnums.ParamId.RasterizerState0,
MatlEnums.ParamId.BlendState0,
MatlEnums.ParamId.CustomVector13,
MatlEnums.ParamId.CustomVector8,
MatlEnums.ParamId.Texture0,
MatlEnums.ParamId.Sampler0,
MatlEnums.ParamId.Texture9,
MatlEnums.ParamId.Sampler9,
})
);
}
public void ValidLabelAndParameterListDifferentOrder()
{
Assert.IsTrue(ShaderValidation.IsValidParameterList("SFX_PBS_0000000000000080_opaque",
new MatlEnums.ParamId[] {
MatlEnums.ParamId.CustomVector8,
MatlEnums.ParamId.BlendState0,
MatlEnums.ParamId.Sampler0,
MatlEnums.ParamId.RasterizerState0,
MatlEnums.ParamId.Texture9,
MatlEnums.ParamId.Texture0,
MatlEnums.ParamId.CustomVector13,
MatlEnums.ParamId.Sampler9,
})
);
}
public void ValidShaderLabel()
{
CollectionAssert.AreEqual(
new List <MatlEnums.ParamId> {
MatlEnums.ParamId.RasterizerState0,
MatlEnums.ParamId.BlendState0,
MatlEnums.ParamId.CustomVector13,
MatlEnums.ParamId.CustomVector8,
MatlEnums.ParamId.Texture0,
MatlEnums.ParamId.Sampler0,
MatlEnums.ParamId.Texture9,
MatlEnums.ParamId.Sampler9,
},
ShaderValidation.GetParameters("SFX_PBS_0000000000000080_opaque")
);
}
public bool TryLoadProgramFromBinary(byte[] programBinary, BinaryFormat binaryFormat)
{
try
{
// Linking isn't necessary when loading a program binary.
GL.ProgramBinary(Id, binaryFormat, programBinary, programBinary.Length);
}
catch (AccessViolationException)
{
// The binary is corrupt or the wrong format.
return(false);
}
LinkStatusIsOk = ShaderValidation.GetProgramLinkStatus(Id);
TryLoadShaderVariables();
return(true);
}
public RMaterial(string materialLabel, string shaderLabel, int index)
{
MaterialLabel = materialLabel;
ShaderLabel = shaderLabel;
Index = index;
IsValidShaderLabel = ShaderValidation.IsValidShaderLabel(ShaderLabel);
// This is faster than accessing the database multiple times.
var attributes = ShaderValidation.GetAttributes(ShaderLabel);
HasColorSet1 = attributes.Contains("colorSet1");
HasColorSet2 = attributes.Contains("colorSet2");
HasColorSet3 = attributes.Contains("colorSet3");
HasColorSet4 = attributes.Contains("colorSet4");
HasColorSet5 = attributes.Contains("colorSet5");
HasColorSet6 = attributes.Contains("colorSet6");
HasColorSet7 = attributes.Contains("colorSet7");
}
private static Material CreateMaterial(MatlEntry entry, int index)
{
var idColor = UniqueColors.IndexToColor(index);
var material = new Material(entry)
{
MaterialIdColor = new SolidColorBrush(Color.FromArgb(255,
(byte)idColor.X,
(byte)idColor.Y,
(byte)idColor.Z)),
ShaderAttributeNames = string.Join(", ", ShaderValidation.GetAttributes(entry.ShaderLabel)),
ShaderParameterNames = string.Join(", ", ShaderValidation.GetParameters(entry.ShaderLabel).Select(p => p.ToString()).ToList()),
RenderPasses = ShaderValidation.GetRenderPasses(entry.ShaderLabel)
};
AddAttributesToMaterial(entry, material);
return(material);
}
public void MissingTag()
{
Assert.IsTrue(ShaderValidation.IsValidShaderLabel("SFX_PBS_1b01000008008a68"));
}
public void InvalidShaderLabel()
{
CollectionAssert.AreEqual(new List <string>(), ShaderValidation.GetAttributes("SFX_PBS_0000000000000000"));
}
public void ValidLabel()
{
Assert.IsTrue(ShaderValidation.IsValidShaderLabel("SFX_PBS_1b01000008008a68_opaque"));
}
public void InvalidAttribute()
{
Assert.IsFalse(ShaderValidation.HasAttribute("SFX_PBS_0100000008008269_opaque", "colorSet1"));
}
public void ValidAttributeAndLabel()
{
Assert.IsTrue(ShaderValidation.HasAttribute("SFX_PBS_0100000008008269_opaque", "map1"));
}
public void InvalidLabel()
{
Assert.IsFalse(ShaderValidation.HasAttribute("SFX_PBS_1b01000008008a68_invalid", "colorSet1"));
}
public void MissingTag()
{
Assert.IsTrue(ShaderValidation.HasAttribute("SFX_PBS_0100000008008269", "map1"));
}
public void InvalidLabel()
{
Assert.IsFalse(ShaderValidation.IsValidShaderLabel("SFX_PBS_0000000000000000_opaque"));
}
public void InvalidTag()
{
Assert.IsFalse(ShaderValidation.IsValidShaderLabel("SFX_PBS_1b01000008008a68_invalid"));
}
public void InvalidShaderLabel()
{
CollectionAssert.AreEqual(new List <MatlEnums.ParamId>(), ShaderValidation.GetParameters("SFX_PBS_0000000000000000"));
}
public void TerryShaders()
{
// Test DLC characters.
Assert.IsTrue(ShaderValidation.IsValidShaderLabel("SFX_PBS_010000000808866b_opaque"));
Assert.IsTrue(ShaderValidation.IsValidShaderLabel("SFX_PBS_0100000008018669_sort"));
}
public static IEnumerable <Shader> FindIllegalShaders(GameObject target)
{
return(ShaderValidation.FindIllegalShaders(target, ShaderWhiteList));
}
