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) { }