private Expression WidenType <T>(Expression source)
{
var tref = ShaderDefinition.ToCecil(typeof(T));
var n = new ObjectCreateExpression(AstBuilder.ConvertType(tref), new[] { source.Clone() });
return(n);
}
public Shader(ShaderDefinition ShaderDefinition, Engine Engine)
{
this.engine = Engine;
VertexShaderCompilationResult = CompileVertexShader(ShaderDefinition.GetVertexShaderDetails().Filename, ShaderDefinition.GetVertexShaderDetails().EntryPoint);
PixelShaderCompilationResult = CompilePixelShader(ShaderDefinition.GetPixelShaderDetails().Filename, ShaderDefinition.GetPixelShaderDetails().EntryPoint);
if (VertexShaderCompilationResult.HasErrors)
{
throw new ShaderCompilationException(VertexShaderCompilationResult.Message);
}
if (PixelShaderCompilationResult.HasErrors)
{
throw new ShaderCompilationException(PixelShaderCompilationResult.Message);
}
this.VertexShader = new VertexShader(engine.GraphicsServices.GetService <Device>(), VertexShaderCompilationResult.Bytecode);
this.PixelShader = new PixelShader(engine.GraphicsServices.GetService <Device>(), PixelShaderCompilationResult.Bytecode);
InputLayout = new InputLayout(
engine.GraphicsServices.GetService <Device>(),
ShaderSignature.GetInputSignature(VertexShaderCompilationResult.Bytecode),
ShaderDefinition.GetInputElements());
this.InputElementStride = ShaderDefinition.GetInputElementStride();
string[] cbNames = ShaderDefinition.GetConstantBufferNames();
for (int i = 0; i < cbNames.Length; i++)
{
constantBufferSlots.Add(cbNames[i], i);
}
}
public void ShaderChanged(ShaderDefinition shaderDefinition, int index)
{
string name = shaderDefinition.Path;
Process pProcess = new Process
{
StartInfo =
{
FileName = mgcbPathExe,
Arguments = "/importer:EffectImporter /processor:EffectProcessor /processorParam:DebugMode=Auto /build:" + name + ".fx",
CreateNoWindow = true,
WorkingDirectory = contentBuiltPath,
UseShellExecute = false,
RedirectStandardError = true,
RedirectStandardOutput = true
}
};
//Get program output
string stdError = null;
StringBuilder stdOutput = new StringBuilder();
pProcess.OutputDataReceived += (sender, args) => stdOutput.Append(args.Data);
try
{
pProcess.Start();
pProcess.BeginOutputReadLine();
stdError = pProcess.StandardError.ReadToEnd();
pProcess.WaitForExit();
string builtPath = contentBuiltPath + "/" + name + ".xnb";
string movePath = contentExecutablePath + name + ".xnb";
File.Copy(builtPath, movePath, true);
File.Delete(builtPath);
ContentManager newTemp = new ContentManager(TempContent.ServiceProvider, TempContent.RootDirectory);
shaderDefinition.Effect.Dispose();
shaderDefinition.Effect = newTemp.Load <Effect>(shaderDefinition.Path);
shaderDefinition.HasChanged = true;
ShaderCollection[index] = shaderDefinition;
}
catch (Exception e)
{
//todo log
}
finally
{
}
}
/// <summary>
/// Redirects the invocation to the explicitly specified method
/// </summary>
protected Func <MethodDefinition, InvocationExpression, StringBuilder> Redirect(Expression <Action> wrapper)
{
var fun = ShaderDefinition.ToCecil(((MethodCallExpression)wrapper.Body).Method);
CheckWarnings(fun);
return((m, i) =>
{
// replace the current node with a call to fun and process again
i.RemoveAnnotations(typeof(MethodDefinition));
i.RemoveAnnotations(typeof(MethodReference));
i.AddAnnotation(fun);
return i.AcceptVisitor(this, 0);
});
}
/// <summary>
/// Redirects the invocation to the specified class, by searching for a
/// method with the specified name if given or same name otherwise
/// matching the original method signature.
/// </summary>
/// <returns></returns>
protected Func <MethodDefinition, InvocationExpression, StringBuilder> Redirect <T>(string name = null)
{
var t = ShaderDefinition.ToCecil(typeof(T));
return((m, i) =>
{
var redirected = t.Methods.Single(j => j.Name == (name ?? m.Name) &&
SameSignature(j, m));
CheckWarnings(redirected);
i.RemoveAnnotations(typeof(MethodDefinition));
i.RemoveAnnotations(typeof(MethodReference));
i.AddAnnotation(redirected);
return i.AcceptVisitor(this, 0);
});
}
private StringBuilder TextureLod(MethodDefinition m, InvocationExpression i)
{
Debug.Assert(i.Arguments.Count == 3);
var args = i.Arguments.ToArray();
var sampler = args[0];
var pos = args[1];
var lod = args[2];
var tref = ShaderDefinition.ToCecil(typeof(ShaderDefinition.vec4));
var zero = new PrimitiveExpression("0.0f");
var newPos = new ObjectCreateExpression(AstBuilder.ConvertType(tref), new[] { pos.Clone(), zero, lod.Clone() });
var result = new StringBuilder();
return(result.Append("tex2Dlod(").Append(ArgsToString(new[] { sampler, newPos })).Append(")"));
}
public void ProcessShaderSet(ShaderSetProcessorInput input)
{
var shaderDefinition = new ShaderDefinition();
foreach (var resource in input.Model.AllResources)
{
try
{
var resourceBinding = CreateResourceBinding(input.Model, resource);
shaderDefinition.ResourceBindings.Add(resourceBinding);
}
catch (Exception ex)
{
throw new Exception($"Could not create resource binding for set {input.SetName}, resource {resource.Name}, value type {resource.ValueType.Name}", ex);
}
}
var path = Path.Combine(UserArgs, input.SetName + ".json");
var json = shaderDefinition.ToJson();
File.WriteAllText(path, json);
}
private ShaderDefinition ParseFile(DataFileInfo file)
{
var lines = File.ReadAllLines(file.FullPath);
var shaderParams = new List<ShaderParam>();
var i = -1;
bool inFunctionBody = false;
foreach (var line in lines)
{
i++;
if (line.Contains("{"))
inFunctionBody = true;
if (line.Contains("}"))
inFunctionBody = false;
if(inFunctionBody)
continue;
foreach (var shaderParamType in _shaderParamTypes)
{
string paramName;
if (IsParamDeclaration(line, shaderParamType, out paramName))
{
shaderParams.Add(CreateParam(paramName, lines, i, shaderParamType));
}
}
}
var shaderName = file.PropertyName.Replace(file.ExtensionInfo.Extension, "");
var exitCondition = new Func<string, int, bool>((line, index) => index == lines.Length - 1);
var description = GetValue("description", lines, 0, 1, exitCondition);
var shaderDef = new ShaderDefinition(file, shaderName, description, shaderParams);
return shaderDef;
}
private IEnumerable<string> GenerateConstructor(ShaderDefinition shader)
{
var result = new List<string>
{
"public " + shader.Name + " ()",
"\t:base(ResourceContext.GetEffect(@\"" + shader.File.RelativePath + "\"))",
"{",
};
result.AddRange(GenerateParamInitialisations(shader.Params));
result.Add("}");
result.Add("");
return result.Select(line => "\t" + line);
}
private string[] GenerateClass(ShaderDefinition shader)
{
var code = new List<string>
{
"/// <summary>" + shader.Description + "</summary>",
"public class " + shader.Name + " : " + "Shader",
"{"
};
code.AddRange(GenerateConstructor(shader));
code.AddRange(GenerateClassProperties(shader.Params));
code.Add("}");
return code.ToArray();
}
public TextureShader(ShaderDefinition ShaderDefinition, Engine Engine) : base(ShaderDefinition, Engine)
{
}
public HlslVisitor()
{
Handlers = new Dictionary <Expression <Action>, Func <MethodDefinition, InvocationExpression, StringBuilder> >(new HandlerComparer())
{
{ () => ShaderDefinition.Discard(), KeywordDiscard },
#region Trigonometry
{ () => ShaderDefinition.Radians(_float), ToLower },
{ () => ShaderDefinition.Radians(vec2), ToLower },
{ () => ShaderDefinition.Radians(vec3), ToLower },
{ () => ShaderDefinition.Radians(vec4), ToLower },
{ () => ShaderDefinition.Degrees(_float), ToLower },
{ () => ShaderDefinition.Degrees(vec2), ToLower },
{ () => ShaderDefinition.Degrees(vec3), ToLower },
{ () => ShaderDefinition.Degrees(vec4), ToLower },
{ () => ShaderDefinition.Sin(_float), ToLower },
{ () => ShaderDefinition.Sin(vec2), ToLower },
{ () => ShaderDefinition.Sin(vec3), ToLower },
{ () => ShaderDefinition.Sin(vec4), ToLower },
{ () => ShaderDefinition.Cos(_float), ToLower },
{ () => ShaderDefinition.Cos(vec2), ToLower },
{ () => ShaderDefinition.Cos(vec3), ToLower },
{ () => ShaderDefinition.Cos(vec4), ToLower },
{ () => ShaderDefinition.Tan(_float), ToLower },
{ () => ShaderDefinition.Tan(vec2), ToLower },
{ () => ShaderDefinition.Tan(vec3), ToLower },
{ () => ShaderDefinition.Tan(vec4), ToLower },
{ () => ShaderDefinition.Asin(_float), ToLower },
{ () => ShaderDefinition.Asin(vec2), ToLower },
{ () => ShaderDefinition.Asin(vec3), ToLower },
{ () => ShaderDefinition.Asin(vec4), ToLower },
{ () => ShaderDefinition.Acos(_float), ToLower },
{ () => ShaderDefinition.Acos(vec2), ToLower },
{ () => ShaderDefinition.Acos(vec3), ToLower },
{ () => ShaderDefinition.Acos(vec4), ToLower },
{ () => ShaderDefinition.Atan2(_float, _float), ToLower },
{ () => ShaderDefinition.Atan2(vec2, vec2), ToLower },
{ () => ShaderDefinition.Atan2(vec3, vec3), ToLower },
{ () => ShaderDefinition.Atan2(vec4, vec4), ToLower },
{ () => ShaderDefinition.Atan(_float), ToLower },
{ () => ShaderDefinition.Atan(vec2), ToLower },
{ () => ShaderDefinition.Atan(vec3), ToLower },
{ () => ShaderDefinition.Atan(vec4), ToLower },
{ () => ShaderDefinition.Sinh(_float), ToLower },
{ () => ShaderDefinition.Sinh(vec2), ToLower },
{ () => ShaderDefinition.Sinh(vec3), ToLower },
{ () => ShaderDefinition.Sinh(vec4), ToLower },
{ () => ShaderDefinition.Cosh(_float), ToLower },
{ () => ShaderDefinition.Cosh(vec2), ToLower },
{ () => ShaderDefinition.Cosh(vec3), ToLower },
{ () => ShaderDefinition.Cosh(vec4), ToLower },
{ () => ShaderDefinition.Tanh(_float), ToLower },
{ () => ShaderDefinition.Tanh(vec2), ToLower },
{ () => ShaderDefinition.Tanh(vec3), ToLower },
{ () => ShaderDefinition.Tanh(vec4), ToLower },
{ () => ShaderDefinition.Asinh(_float), Redirect <Workarounds.Trigonometric>() },
{ () => ShaderDefinition.Asinh(vec2), Redirect <Workarounds.Trigonometric>() },
{ () => ShaderDefinition.Asinh(vec3), Redirect <Workarounds.Trigonometric>() },
{ () => ShaderDefinition.Asinh(vec4), Redirect <Workarounds.Trigonometric>() },
{ () => ShaderDefinition.Acosh(_float), Redirect <Workarounds.Trigonometric>() },
{ () => ShaderDefinition.Acosh(vec2), Redirect <Workarounds.Trigonometric>() },
{ () => ShaderDefinition.Acosh(vec3), Redirect <Workarounds.Trigonometric>() },
{ () => ShaderDefinition.Acosh(vec4), Redirect <Workarounds.Trigonometric>() },
{ () => ShaderDefinition.Atanh(_float), Redirect <Workarounds.Trigonometric>() },
{ () => ShaderDefinition.Atanh(vec2), Redirect <Workarounds.Trigonometric>() },
{ () => ShaderDefinition.Atanh(vec3), Redirect <Workarounds.Trigonometric>() },
{ () => ShaderDefinition.Atanh(vec4), Redirect <Workarounds.Trigonometric>() },
{ () => ShaderDefinition.SinCos(_float, out _float, out _float), ToLower },
{ () => ShaderDefinition.SinCos(vec2, out vec2, out vec2), ToLower },
{ () => ShaderDefinition.SinCos(vec3, out vec3, out vec3), ToLower },
{ () => ShaderDefinition.SinCos(vec4, out vec4, out vec4), ToLower },
#endregion
#region Exponential
{ () => ShaderDefinition.Pow(_float, _float), ToLower },
{ () => ShaderDefinition.Pow(vec2, vec2), ToLower },
{ () => ShaderDefinition.Pow(vec3, vec3), ToLower },
{ () => ShaderDefinition.Pow(vec4, vec4), ToLower },
{ () => ShaderDefinition.Exp(_float), ToLower },
{ () => ShaderDefinition.Exp(vec2), ToLower },
{ () => ShaderDefinition.Exp(vec3), ToLower },
{ () => ShaderDefinition.Exp(vec4), ToLower },
{ () => ShaderDefinition.Log(_float), ToLower },
{ () => ShaderDefinition.Log(vec2), ToLower },
{ () => ShaderDefinition.Log(vec3), ToLower },
{ () => ShaderDefinition.Log(vec4), ToLower },
{ () => ShaderDefinition.Exp2(_float), ToLower },
{ () => ShaderDefinition.Exp2(vec2), ToLower },
{ () => ShaderDefinition.Exp2(vec3), ToLower },
{ () => ShaderDefinition.Exp2(vec4), ToLower },
{ () => ShaderDefinition.Log2(_float), ToLower },
{ () => ShaderDefinition.Log2(vec2), ToLower },
{ () => ShaderDefinition.Log2(vec3), ToLower },
{ () => ShaderDefinition.Log2(vec4), ToLower },
{ () => ShaderDefinition.Sqrt(_float), ToLower },
{ () => ShaderDefinition.Sqrt(vec2), ToLower },
{ () => ShaderDefinition.Sqrt(vec3), ToLower },
{ () => ShaderDefinition.Sqrt(vec4), ToLower },
{ () => ShaderDefinition.InverseSqrt(_float), ToLower },
{ () => ShaderDefinition.InverseSqrt(vec2), ToLower },
{ () => ShaderDefinition.InverseSqrt(vec3), ToLower },
{ () => ShaderDefinition.InverseSqrt(vec4), ToLower },
// HLSL does not define Sqrt / InverseSqrt on doubles and we should treat this
// as an error rather than emulate with precision loss,
// because the double version normally gets explicitly requested
{ () => ShaderDefinition.Log10(_float), ToLower },
{ () => ShaderDefinition.Log10(vec2), ToLower },
{ () => ShaderDefinition.Log10(vec3), ToLower },
{ () => ShaderDefinition.Log10(vec4), ToLower },
{ () => ShaderDefinition.Exp10(_float), Redirect <Workarounds.Exponential>() },
{ () => ShaderDefinition.Exp10(vec2), Redirect <Workarounds.Exponential>() },
{ () => ShaderDefinition.Exp10(vec3), Redirect <Workarounds.Exponential>() },
{ () => ShaderDefinition.Exp10(vec4), Redirect <Workarounds.Exponential>() },
#endregion
#region Geometric
{ () => ShaderDefinition.Length(_float), ToLower },
{ () => ShaderDefinition.Length(vec2), ToLower },
{ () => ShaderDefinition.Length(vec3), ToLower },
{ () => ShaderDefinition.Length(vec4), ToLower },
// No double support for HLSL
{ () => ShaderDefinition.Distance(_float, _float), ToLower },
{ () => ShaderDefinition.Distance(vec2, vec2), ToLower },
{ () => ShaderDefinition.Distance(vec3, vec3), ToLower },
{ () => ShaderDefinition.Distance(vec4, vec4), ToLower },
// No double support for HLSL
{ () => ShaderDefinition.Dot(_float, _float), ToLower },
{ () => ShaderDefinition.Dot(vec2, vec2), ToLower },
{ () => ShaderDefinition.Dot(vec3, vec3), ToLower },
{ () => ShaderDefinition.Dot(vec4, vec4), ToLower },
// No double support for HLSL
{ () => ShaderDefinition.Cross(vec3, vec3), ToLower },
// No double support for HLSL
{ () => ShaderDefinition.Normalize(_float), ToLower },
{ () => ShaderDefinition.Normalize(vec2), ToLower },
{ () => ShaderDefinition.Normalize(vec3), ToLower },
{ () => ShaderDefinition.Normalize(vec4), ToLower },
// No double support for HLSL
{ () => ShaderDefinition.FaceForward(_float, _float, _float), ToLower },
{ () => ShaderDefinition.FaceForward(vec2, vec2, vec2), ToLower },
{ () => ShaderDefinition.FaceForward(vec3, vec3, vec3), ToLower },
{ () => ShaderDefinition.FaceForward(vec4, vec4, vec4), ToLower },
// No double support for HLSL
{ () => ShaderDefinition.Reflect(_float, _float), ToLower },
{ () => ShaderDefinition.Reflect(vec2, vec2), ToLower },
{ () => ShaderDefinition.Reflect(vec3, vec3), ToLower },
{ () => ShaderDefinition.Reflect(vec4, vec4), ToLower },
// No double support for HLSL
{ () => ShaderDefinition.Refract(_float, _float, _float), Refract },
{ () => ShaderDefinition.Refract(vec2, vec2, _float), Refract },
{ () => ShaderDefinition.Refract(vec3, vec3, _float), Refract },
{ () => ShaderDefinition.Refract(vec4, vec4, _float), Refract },
// No double support for HLSL
#endregion
#region Common
{ () => ShaderDefinition.Abs(_float), ToLower },
{ () => ShaderDefinition.Abs(vec2), ToLower },
{ () => ShaderDefinition.Abs(vec3), ToLower },
{ () => ShaderDefinition.Abs(vec4), ToLower },
{ () => ShaderDefinition.Abs(_int), ToLower },
{ () => ShaderDefinition.Abs(ivec2), ToLower },
{ () => ShaderDefinition.Abs(ivec3), ToLower },
{ () => ShaderDefinition.Abs(ivec4), ToLower },
// No double support for HLSL
{ () => ShaderDefinition.Floor(_float), ToLower },
{ () => ShaderDefinition.Floor(vec2), ToLower },
{ () => ShaderDefinition.Floor(vec3), ToLower },
{ () => ShaderDefinition.Floor(vec4), ToLower },
// No double support for HLSL
{ () => ShaderDefinition.Trunc(_float), ToLower },
{ () => ShaderDefinition.Trunc(vec2), ToLower },
{ () => ShaderDefinition.Trunc(vec3), ToLower },
{ () => ShaderDefinition.Trunc(vec4), ToLower },
// No double support for HLSL
{ () => ShaderDefinition.Round(_float), ToLower },
{ () => ShaderDefinition.Round(vec2), ToLower },
{ () => ShaderDefinition.Round(vec3), ToLower },
{ () => ShaderDefinition.Round(vec4), ToLower },
// No double support for HLSL
// genType RoundEven(genType x) unsupported atm
// genDType RoundEven(genDType x) unsupport
{ () => ShaderDefinition.Ceiling(_float), Rename("ceil") },
{ () => ShaderDefinition.Ceiling(vec2), Rename("ceil") },
{ () => ShaderDefinition.Ceiling(vec3), Rename("ceil") },
{ () => ShaderDefinition.Ceiling(vec4), Rename("ceil") },
// No double support for HLSL
{ () => ShaderDefinition.Fraction(_float), Rename("frac") },
{ () => ShaderDefinition.Fraction(vec2), Rename("frac") },
{ () => ShaderDefinition.Fraction(vec3), Rename("frac") },
{ () => ShaderDefinition.Fraction(vec4), Rename("frac") },
// No double support for HLSL
{ () => ShaderDefinition.Min(_float, _float), ToLower },
// TODO: these overloads need WidenType
// { () => ShaderDefinition.Min(vec2, _float), ToLower },
// { () => ShaderDefinition.Min(vec3, _float), ToLower },
// { () => ShaderDefinition.Min(vec4, _float), ToLower },
{ () => ShaderDefinition.Min(vec2, vec2), ToLower },
{ () => ShaderDefinition.Min(vec3, vec3), ToLower },
{ () => ShaderDefinition.Min(vec4, vec4), ToLower },
// No double support for HLSL
{ () => ShaderDefinition.Min(_int, _int), ToLower },
// TODO: these overloads need WidenType
//{ () => ShaderDefinition.Min(ivec2, _int), ToLower },
//{ () => ShaderDefinition.Min(ivec3, _int), ToLower },
//{ () => ShaderDefinition.Min(ivec4, _int), ToLower },
{ () => ShaderDefinition.Min(ivec2, ivec2), ToLower },
{ () => ShaderDefinition.Min(ivec3, ivec3), ToLower },
{ () => ShaderDefinition.Min(ivec4, ivec4), ToLower },
// No uint support for HLSL
{ () => ShaderDefinition.Max(_float, _float), ToLower },
// TODO: these overloads need WidenType
// { () => ShaderDefinition.Max(vec2, _float), ToLower },
// { () => ShaderDefinition.Max(vec3, _float), ToLower },
// { () => ShaderDefinition.Max(vec4, _float), ToLower },
{ () => ShaderDefinition.Max(vec2, vec2), ToLower },
{ () => ShaderDefinition.Max(vec3, vec3), ToLower },
{ () => ShaderDefinition.Max(vec4, vec4), ToLower },
// No double support for HLSL
{ () => ShaderDefinition.Max(_int, _int), ToLower },
// TODO: these overloads need WidenType
//{ () => ShaderDefinition.Max(ivec2, _int), ToLower },
//{ () => ShaderDefinition.Max(ivec3, _int), ToLower },
//{ () => ShaderDefinition.Max(ivec4, _int), ToLower },
{ () => ShaderDefinition.Max(ivec2, ivec2), ToLower },
{ () => ShaderDefinition.Max(ivec3, ivec3), ToLower },
{ () => ShaderDefinition.Max(ivec4, ivec4), ToLower },
// No uint support for HLSL
{ () => ShaderDefinition.Clamp(_float, _float, _float), ToLower },
// TODO: these overloads need WidenType
// { () => ShaderDefinition.Clamp(vec2, _float, _float), ToLower },
// { () => ShaderDefinition.Clamp(vec3, _float, _float), ToLower },
// { () => ShaderDefinition.Clamp(vec4, _float, _float), ToLower },
{ () => ShaderDefinition.Clamp(vec2, vec2, vec2), ToLower },
{ () => ShaderDefinition.Clamp(vec3, vec3, vec3), ToLower },
{ () => ShaderDefinition.Clamp(vec4, vec4, vec4), ToLower },
// No double support for HLSL
{ () => ShaderDefinition.Clamp(_int, _int, _int), ToLower },
// TODO: these overloads need WidenType
//{ () => ShaderDefinition.Clamp(ivec2, _int, _int), ToLower },
//{ () => ShaderDefinition.Clamp(ivec3, _int, _int), ToLower },
//{ () => ShaderDefinition.Clamp(ivec4, _int, _int), ToLower },
{ () => ShaderDefinition.Clamp(ivec2, ivec2, ivec2), ToLower },
{ () => ShaderDefinition.Clamp(ivec3, ivec3, ivec3), ToLower },
{ () => ShaderDefinition.Clamp(ivec4, ivec4, ivec4), ToLower },
// No uint support for HLSL
{ () => ShaderDefinition.Lerp(_float, _float, _float), ToLower },
// TODO: these overloads need WidenType
// { () => ShaderDefinition.Lerp(vec2, vec2, _float), ToLower },
// { () => ShaderDefinition.Lerp(vec3, vec3, _float), ToLower },
// { () => ShaderDefinition.Lerp(vec4, vec4, _float), ToLower },
{ () => ShaderDefinition.Lerp(vec2, vec2, vec2), ToLower },
{ () => ShaderDefinition.Lerp(vec3, vec3, vec3), ToLower },
{ () => ShaderDefinition.Lerp(vec4, vec4, vec4), ToLower },
// No double support for HLSL
// No bool support for HLSL
{ () => ShaderDefinition.Step(_float, _float), ToLower },
// TODO: these overloads need WidenType
// { () => ShaderDefinition.Step(_float, vec2), ToLower },
// { () => ShaderDefinition.Step(_float, vec3), ToLower },
// { () => ShaderDefinition.Step(_float, vec4), ToLower },
{ () => ShaderDefinition.Step(vec2, vec2), ToLower },
{ () => ShaderDefinition.Step(vec3, vec3), ToLower },
{ () => ShaderDefinition.Step(vec4, vec4), ToLower },
// No double support for HLSL
{ () => ShaderDefinition.SmoothStep(_float, _float, _float), ToLower },
// TODO: these overloads need WidenType
// { () => ShaderDefinition.SmoothStep(_float, _float, vec2), ToLower },
// { () => ShaderDefinition.SmoothStep(_float, _float, vec3), ToLower },
// { () => ShaderDefinition.SmoothStep(_float, _float, vec4), ToLower },
{ () => ShaderDefinition.SmoothStep(vec2, vec2, vec2), ToLower },
{ () => ShaderDefinition.SmoothStep(vec3, vec3, vec3), ToLower },
{ () => ShaderDefinition.SmoothStep(vec4, vec4, vec4), ToLower },
// No double support for HLSL
{ () => ShaderDefinition.IsNaN(_float), ToLower },
// TODO: these overloads need special handling as they return only 1 bool not a bvec!
// even worse: documentation doesn't tell what the result is...
//{ () => ShaderDefinition.IsNaN(vec2), ToLower },
//{ () => ShaderDefinition.IsNaN(vec3), ToLower },
//{ () => ShaderDefinition.IsNaN(vec4), ToLower },
// No double support for HLSL
{ () => ShaderDefinition.IsInfinity(_float), ToLower },
// TODO: these overloads need special handling as they return only 1 bool not a bvec!
// even worse: documentation doesn't tell what the result is...
//{ () => ShaderDefinition.IsInfinity(vec2), ToLower },
//{ () => ShaderDefinition.IsInfinity(vec3), ToLower },
//{ () => ShaderDefinition.IsInfinity(vec4), ToLower },
// No double support for HLSL
{ () => ShaderDefinition.FusedMultiplyAdd(_float, _float, _float), Rename("mad") },
{ () => ShaderDefinition.FusedMultiplyAdd(vec2, vec2, vec2), Rename("mad") },
{ () => ShaderDefinition.FusedMultiplyAdd(vec3, vec3, vec3), Rename("mad") },
{ () => ShaderDefinition.FusedMultiplyAdd(vec4, vec4, vec4), Rename("mad") },
// No double support for HLSL
#endregion
#region Derivative
{ () => ShaderDefinition.DeriveTowardsX(_float), Rename("ddx") },
{ () => ShaderDefinition.DeriveTowardsX(vec2), Rename("ddx") },
{ () => ShaderDefinition.DeriveTowardsX(vec3), Rename("ddx") },
{ () => ShaderDefinition.DeriveTowardsX(vec4), Rename("ddx") },
{ () => ShaderDefinition.DeriveTowardsY(_float), Rename("ddy") },
{ () => ShaderDefinition.DeriveTowardsY(vec2), Rename("ddy") },
{ () => ShaderDefinition.DeriveTowardsY(vec3), Rename("ddy") },
{ () => ShaderDefinition.DeriveTowardsY(vec4), Rename("ddy") },
#endregion
#region Noise
{ () => ShaderDefinition.Noise1(_float), Rename("noise") },
{ () => ShaderDefinition.Noise1(vec2), Rename("noise") },
{ () => ShaderDefinition.Noise1(vec3), Rename("noise") },
{ () => ShaderDefinition.Noise1(vec4), Rename("noise") },
// Noise2 3 and 4 needs emulation
#endregion
{ () => ShaderDefinition.Texture(sampler2D, vec2), Rename("tex2D") },
// we need to wrap this into tex2DBias(sampler, new vec4(vec2, 0.0, float)
//{ () => ShaderDefinition.texture(sampler2D, vec2, _float), Redirect<Workarounds.Texture>("tex2Dbias") },
{ () => ShaderDefinition.TextureGrad(sampler2D, vec2, vec2, vec2), Rename("tex2Dgrad") },
{ () => ShaderDefinition.TextureLod(sampler2D, vec2, _float), TextureLod }
};
}
public StandardShader(ShaderDefinition ShaderDefinition, Engine Engine) : base(ShaderDefinition, Engine)
{
}
