示例#1
0
            public override int GetHashCode()
            {
                unchecked
                {
                    var hc = 17L;

                    hc = hc * 21 + GenericArgumentType.GetHashCode();
                    hc = hc * 21 + InstanceType.GetHashCode();

                    return(((int)(hc >> 32)) ^ (int)hc);
                }
            }
示例#2
0
 public bool Equals(SerializerKey other)
 => GenericArgumentType.Equals(other.GenericArgumentType) &&
 InstanceType.Equals(other.InstanceType);
示例#3
0
        private static void AddFuncions(Scope scope)
        {
            var varyingAll = new GenericArgumentType("TAll", new TypeClass[] { TypeClass.Matrix, TypeClass.Vector, TypeClass.Scalar },
                                                     new ShaderType[] { ShaderType.Bool, ShaderType.Float, ShaderType.Int });

            var varyingAllFloat = new GenericArgumentType("TFloat", new TypeClass[] { TypeClass.Matrix, TypeClass.Vector, TypeClass.Scalar },
                                                          new ShaderType[] { ShaderType.Float });
            var varyingAllInt = new GenericArgumentType("TInt", new TypeClass[] { TypeClass.Matrix, TypeClass.Vector, TypeClass.Scalar },
                                                        new ShaderType[] { ShaderType.Int });
            var varyingAllBool = new GenericArgumentType("TBool", new TypeClass[] { TypeClass.Matrix, TypeClass.Vector, TypeClass.Scalar },
                                                         new ShaderType[] { ShaderType.Bool });

            var varyingAllFloatInt = new GenericArgumentType("TFloatInt", new TypeClass[] { TypeClass.Matrix, TypeClass.Vector, TypeClass.Scalar },
                                                             new ShaderType[] { ShaderType.Int, ShaderType.Float });

            var varyingVectorFloat = new GenericArgumentType("TVectorFloat", new TypeClass[] { TypeClass.Vector },
                                                             new ShaderType[] { ShaderType.Float });
            var varyingVectorFloatInt = new GenericArgumentType("TVectorFloatInt", new TypeClass[] { TypeClass.Vector },
                                                                new ShaderType[] { ShaderType.Float, ShaderType.Int });

            var varyingMatrix = new GenericArgumentType("Matrix", new TypeClass[] { TypeClass.Matrix },
                                                        new ShaderType[] { ShaderType.Float, ShaderType.Int });

            #region Math Functions
            scope.AddFunction(new GenericFunctionDefinition("acos", varyingAllFloat, new ParameterDeclaration(varyingAllFloat, "x", 0)).WithArgs(varyingAllFloat));
            scope.AddFunction(new GenericFunctionDefinition("asin", varyingAllFloat, new ParameterDeclaration(varyingAllFloat, "x", 0)).WithArgs(varyingAllFloat));
            scope.AddFunction(new GenericFunctionDefinition("sin", varyingAllFloat, new ParameterDeclaration(varyingAllFloat, "x", 0)).WithArgs(varyingAllFloat));
            scope.AddFunction(new GenericFunctionDefinition("cos", varyingAllFloat, new ParameterDeclaration(varyingAllFloat, "x", 0)).WithArgs(varyingAllFloat));
            scope.AddFunction(new GenericFunctionDefinition("tan", varyingAllFloat, new ParameterDeclaration(varyingAllFloat, "x", 0)).WithArgs(varyingAllFloat));
            scope.AddFunction(new GenericFunctionDefinition("tanh", varyingAllFloat, new ParameterDeclaration(varyingAllFloat, "x", 0)).WithArgs(varyingAllFloat));
            scope.AddFunction(new GenericFunctionDefinition("atan", varyingAllFloat, new ParameterDeclaration(varyingAllFloat, "x", 0)).WithArgs(varyingAllFloat));
            scope.AddFunction(new GenericFunctionDefinition("atan2", varyingAllFloat,
                                                            new ParameterDeclaration(varyingAllFloat, "x", 0),
                                                            new ParameterDeclaration(varyingAllFloat, "y", 1))
                              .WithArgs(varyingAllFloat));
            scope.AddFunction(new GenericFunctionDefinition("ceil", varyingAllFloat, new ParameterDeclaration(varyingAllFloat, "x", 0)).WithArgs(varyingAllFloat));
            scope.AddFunction(new GenericFunctionDefinition("atan2", varyingAllFloat, new ParameterDeclaration(varyingAllFloat, "x", 0)).WithArgs(varyingAllFloat));
            scope.AddFunction(new GenericFunctionDefinition("cosh", varyingAllFloat, new ParameterDeclaration(varyingAllFloat, "x", 0)).WithArgs(varyingAllFloat));
            scope.AddFunction(new GenericFunctionDefinition("exp", varyingAllFloat, new ParameterDeclaration(varyingAllFloat, "x", 0)).WithArgs(varyingAllFloat));
            scope.AddFunction(new GenericFunctionDefinition("exp2", varyingAllFloat, new ParameterDeclaration(varyingAllFloat, "x", 0)).WithArgs(varyingAllFloat));
            scope.AddFunction(new GenericFunctionDefinition("floor", varyingAllFloat, new ParameterDeclaration(varyingAllFloat, "x", 0)).WithArgs(varyingAllFloat));
            scope.AddFunction(new GenericFunctionDefinition("fmod", varyingAllFloat,
                                                            new ParameterDeclaration(varyingAllFloat, "x", 0),
                                                            new ParameterDeclaration(varyingAllFloat, "y", 1)).WithArgs(varyingAllFloat));
            scope.AddFunction(new GenericFunctionDefinition("frac", varyingAllFloat, new ParameterDeclaration(varyingAllFloat, "x", 0)).WithArgs(varyingAllFloat));
            scope.AddFunction(new GenericFunctionDefinition("frexp", varyingAllFloat,
                                                            new ParameterDeclaration(varyingAllFloat, "x", 0),
                                                            new ParameterDeclaration(varyingAllFloat, "exp", 1)).WithArgs(varyingAllFloat));
            scope.AddFunction(new GenericFunctionDefinition("ldexp", varyingAllFloat,
                                                            new ParameterDeclaration(varyingAllFloat, "x", 0),
                                                            new ParameterDeclaration(varyingAllFloat, "exp", 1)).WithArgs(varyingAllFloat));
            scope.AddFunction(new GenericFunctionDefinition("log", varyingAllFloat, new ParameterDeclaration(varyingAllFloat, "x", 0)).WithArgs(varyingAllFloat));
            scope.AddFunction(new GenericFunctionDefinition("log10", varyingAllFloat, new ParameterDeclaration(varyingAllFloat, "x", 0)).WithArgs(varyingAllFloat));
            scope.AddFunction(new GenericFunctionDefinition("log2", varyingAllFloat, new ParameterDeclaration(varyingAllFloat, "x", 0)).WithArgs(varyingAllFloat));
            scope.AddFunction(new GenericFunctionDefinition("pow", varyingAllFloat,
                                                            new ParameterDeclaration(varyingAllFloat, "x", 0),
                                                            new ParameterDeclaration(varyingAllFloat, "y", 1)).WithArgs(varyingAllFloat));
            scope.AddFunction(new GenericFunctionDefinition("radians", varyingAllFloat, new ParameterDeclaration(varyingAllFloat, "x", 0)).WithArgs(varyingAllFloat));
            scope.AddFunction(new GenericFunctionDefinition("round", varyingAllFloat, new ParameterDeclaration(varyingAllFloat, "x", 0)).WithArgs(varyingAllFloat));
            scope.AddFunction(new GenericFunctionDefinition("sqrt", varyingAllFloat, new ParameterDeclaration(varyingAllFloat, "x", 0)).WithArgs(varyingAllFloat));
            scope.AddFunction(new GenericFunctionDefinition("rsqrt", varyingAllFloat, new ParameterDeclaration(varyingAllFloat, "x", 0)).WithArgs(varyingAllFloat));
            scope.AddFunction(new GenericFunctionDefinition("saturate", varyingAllFloat, new ParameterDeclaration(varyingAllFloat, "x", 0)).WithArgs(varyingAllFloat));
            scope.AddFunction(new GenericFunctionDefinition("rsqrt", varyingAllFloat, new ParameterDeclaration(varyingAllFloat, "x", 0)).WithArgs(varyingAllFloat));
            scope.AddFunction(new GenericFunctionDefinition("sinh", varyingAllFloat, new ParameterDeclaration(varyingAllFloat, "x", 0)).WithArgs(varyingAllFloat));
            #endregion

            #region Utilities
            scope.AddFunction(new GenericFunctionDefinition("abs", varyingAllFloatInt, new ParameterDeclaration(varyingAllFloatInt, "x", 0)).WithArgs(varyingAllFloatInt));
            scope.AddFunction(new GenericFunctionDefinition("all", Boolean, new ParameterDeclaration(varyingAll, "x", 0)).WithArgs(varyingAll));
            scope.AddFunction(new GenericFunctionDefinition("any", Boolean, new ParameterDeclaration(varyingAll, "x", 0)).WithArgs(varyingAll));
            scope.AddFunction(new GenericFunctionDefinition("clamp", varyingAllFloatInt,
                                                            new ParameterDeclaration(varyingAllFloatInt, "x"),
                                                            new ParameterDeclaration(varyingAllFloatInt, "min"),
                                                            new ParameterDeclaration(varyingAllFloatInt, "max")).WithArgs(varyingAllFloatInt));
            scope.AddFunction(new GenericFunctionDefinition("clip", Void, new ParameterDeclaration(varyingAll, "x", 0)).WithArgs(varyingAll));
            scope.AddFunction(new GenericFunctionDefinition("ddx", varyingAllFloat, new ParameterDeclaration(varyingAllFloat, "x", 0)).WithArgs(varyingAllFloat));
            scope.AddFunction(new GenericFunctionDefinition("ddy", varyingAllFloat, new ParameterDeclaration(varyingAllFloat, "x", 0)).WithArgs(varyingAllFloat));
            scope.AddFunction(new GenericFunctionDefinition("fwidth", varyingAllFloat, new ParameterDeclaration(varyingAllFloat, "x", 0)).WithArgs(varyingAllFloat));
            scope.AddFunction(new GenericFunctionDefinition("isfinite", Boolean, new ParameterDeclaration(varyingAllFloat, "x", 0)).WithArgs(varyingAllFloat));
            scope.AddFunction(new GenericFunctionDefinition("isnan", Boolean, new ParameterDeclaration(varyingAllFloat, "x", 0)).WithArgs(varyingAllFloat));
            scope.AddFunction(new GenericFunctionDefinition("isinf", Boolean, new ParameterDeclaration(varyingAllFloat, "x", 0)).WithArgs(varyingAllFloat));
            scope.AddFunction(new GenericFunctionDefinition("max", varyingAllFloatInt,
                                                            new ParameterDeclaration(varyingAllFloatInt, "x"),
                                                            new ParameterDeclaration(varyingAllFloatInt, "y")).WithArgs(varyingAllFloatInt));
            scope.AddFunction(new GenericFunctionDefinition("min", varyingAllFloatInt,
                                                            new ParameterDeclaration(varyingAllFloatInt, "x"),
                                                            new ParameterDeclaration(varyingAllFloatInt, "y")).WithArgs(varyingAllFloatInt));
            scope.AddFunction(new GenericFunctionDefinition("noise", Float, new ParameterDeclaration(varyingVectorFloat, "x", 0)).WithArgs(varyingVectorFloat));

            scope.AddFunction(new GenericFunctionDefinition("lerp", varyingAllFloat,
                                                            new ParameterDeclaration(varyingAllFloat, "x", 0),
                                                            new ParameterDeclaration(varyingAllFloat, "y", 0),
                                                            new ParameterDeclaration(Float, "s", 0)).WithArgs(varyingAllFloat));

            scope.AddFunction(new GenericFunctionDefinition("smoothstep", varyingAllFloat,
                                                            new ParameterDeclaration(varyingAllFloat, "min", 0),
                                                            new ParameterDeclaration(varyingAllFloat, "max", 0),
                                                            new ParameterDeclaration(Float, "x", 0)).WithArgs(varyingAllFloat));

            scope.AddFunction(new GenericFunctionDefinition("step", varyingAllFloat,
                                                            new ParameterDeclaration(varyingAllFloat, "y", 0),
                                                            new ParameterDeclaration(varyingAllFloat, "x", 0)).WithArgs(varyingAllFloat));

            scope.AddFunction(new GenericFunctionDefinition("trunc", varyingAllFloat,
                                                            new ParameterDeclaration(varyingAllFloat, "x", 0)).WithArgs(varyingAllFloat));

            scope.AddFunction(new StdFunctionDeclaration("lit", scope.GetType("float4"),
                                                         new ParameterDeclaration(Float, "n_dot_l"),
                                                         new ParameterDeclaration(Float, "n_dot_h"),
                                                         new ParameterDeclaration(Float, "m")));

            #endregion

            #region Vector Functions
            scope.AddFunction(new GenericFunctionDefinition("dot", Float,
                                                            new ParameterDeclaration(varyingVectorFloatInt, "x"),
                                                            new ParameterDeclaration(varyingVectorFloatInt, "y")).WithArgs(varyingVectorFloatInt));

            scope.AddFunction(new StdFunctionDeclaration("cross", scope.GetType("float3"),
                                                         new ParameterDeclaration(scope.GetType("float3"), "x"),
                                                         new ParameterDeclaration(scope.GetType("float3"), "y")));

            scope.AddFunction(new GenericFunctionDefinition("length", Float,
                                                            new ParameterDeclaration(varyingVectorFloat, "x")).WithArgs(varyingVectorFloat));

            scope.AddFunction(new GenericFunctionDefinition("reflect", varyingVectorFloat,
                                                            new ParameterDeclaration(varyingVectorFloat, "i"),
                                                            new ParameterDeclaration(varyingVectorFloat, "n")).WithArgs(varyingVectorFloat));

            scope.AddFunction(new GenericFunctionDefinition("refract", varyingVectorFloat,
                                                            new ParameterDeclaration(varyingVectorFloat, "i"),
                                                            new ParameterDeclaration(varyingVectorFloat, "n"),
                                                            new ParameterDeclaration(Float, "refractionIndex")).WithArgs(varyingVectorFloat));

            scope.AddFunction(new GenericFunctionDefinition("distance", Float,
                                                            new ParameterDeclaration(varyingVectorFloat, "x"),
                                                            new ParameterDeclaration(varyingVectorFloat, "y")).WithArgs(varyingVectorFloat));

            scope.AddFunction(new GenericFunctionDefinition("normalize", varyingVectorFloat,
                                                            new ParameterDeclaration(varyingVectorFloat, "x")).WithArgs(varyingVectorFloat));

            #endregion

            #region Matrix Functions

            scope.AddFunction(new GenericFunctionDefinition("transpose", varyingMatrix,
                                                            new ParameterDeclaration(varyingMatrix, "x")).WithArgs(varyingMatrix));

            scope.AddFunction(new GenericFunctionDefinition("mul", varyingMatrix,
                                                            new ParameterDeclaration(varyingMatrix, "x"),
                                                            new ParameterDeclaration(varyingMatrix, "y")).WithArgs(varyingMatrix));

            scope.AddFunction(new StdFunctionDeclaration("mul", scope.GetType("float2"),
                                                         new ParameterDeclaration(scope.GetType("float2"), "x"),
                                                         new ParameterDeclaration(scope.GetType("float2x2"), "y")));

            scope.AddFunction(new StdFunctionDeclaration("mul", scope.GetType("float3"),
                                                         new ParameterDeclaration(scope.GetType("float3"), "x"),
                                                         new ParameterDeclaration(scope.GetType("float3x3"), "y")));

            scope.AddFunction(new StdFunctionDeclaration("mul", scope.GetType("float4"),
                                                         new ParameterDeclaration(scope.GetType("float4"), "x"),
                                                         new ParameterDeclaration(scope.GetType("float4x4"), "y")));

            //scope.AddFunction(new StdFunctionDeclaration("mul", scope.GetType("float"),
            //    new ParameterDeclaration(scope.GetType("float3"), "x"),
            //    new ParameterDeclaration(scope.GetType("float3"), "y")));

            //scope.AddFunction(new StdFunctionDeclaration("mul", scope.GetType("float"),
            //    new ParameterDeclaration(scope.GetType("float4"), "x"),
            //    new ParameterDeclaration(scope.GetType("float4"), "y")));

            //scope.AddFunction(new StdFunctionDeclaration("mul", scope.GetType("float"),
            //    new ParameterDeclaration(scope.GetType("float"), "x"),
            //    new ParameterDeclaration(scope.GetType("float"), "y")));

            #endregion

            #region Aritmetic Operators

            scope.AddFunction(new GenericFunctionDefinition("+", varyingAllFloatInt,
                                                            new ParameterDeclaration(varyingAllFloatInt, "x"),
                                                            new ParameterDeclaration(varyingAllFloatInt, "y")).WithArgs(varyingAllFloatInt));

            scope.AddFunction(new GenericFunctionDefinition("-", varyingAllFloatInt,
                                                            new ParameterDeclaration(varyingAllFloatInt, "x"),
                                                            new ParameterDeclaration(varyingAllFloatInt, "y")).WithArgs(varyingAllFloatInt));

            scope.AddFunction(new GenericFunctionDefinition("*", varyingAllFloatInt,
                                                            new ParameterDeclaration(varyingAllFloatInt, "x"),
                                                            new ParameterDeclaration(varyingAllFloatInt, "y")).WithArgs(varyingAllFloatInt));

            scope.AddFunction(new GenericFunctionDefinition("/", varyingAllFloatInt,
                                                            new ParameterDeclaration(varyingAllFloatInt, "x"),
                                                            new ParameterDeclaration(varyingAllFloatInt, "y")).WithArgs(varyingAllFloatInt));

            scope.AddFunction(new GenericFunctionDefinition("-", varyingAllFloatInt,
                                                            new ParameterDeclaration(varyingAllFloatInt, "x")).WithArgs(varyingAllFloatInt));

            #endregion

            #region Relational Operators
            var matchType = new DimentionMatchType("bool", scope);

            scope.AddFunction(new GenericFunctionDefinition("<", matchType,
                                                            new ParameterDeclaration(varyingAllFloatInt, "x"),
                                                            new ParameterDeclaration(varyingAllFloatInt, "y")).WithArgs(varyingAllFloatInt));

            scope.AddFunction(new GenericFunctionDefinition(">", matchType,
                                                            new ParameterDeclaration(varyingAllFloatInt, "x"),
                                                            new ParameterDeclaration(varyingAllFloatInt, "y")).WithArgs(varyingAllFloatInt));

            scope.AddFunction(new GenericFunctionDefinition("<=", matchType,
                                                            new ParameterDeclaration(varyingAllFloatInt, "x"),
                                                            new ParameterDeclaration(varyingAllFloatInt, "y")).WithArgs(varyingAllFloatInt));

            scope.AddFunction(new GenericFunctionDefinition(">=", matchType,
                                                            new ParameterDeclaration(varyingAllFloatInt, "x"),
                                                            new ParameterDeclaration(varyingAllFloatInt, "y")).WithArgs(varyingAllFloatInt));

            scope.AddFunction(new GenericFunctionDefinition("==", matchType,
                                                            new ParameterDeclaration(varyingAllFloatInt, "x"),
                                                            new ParameterDeclaration(varyingAllFloatInt, "y")).WithArgs(varyingAllFloatInt));

            scope.AddFunction(new GenericFunctionDefinition("!=", matchType,
                                                            new ParameterDeclaration(varyingAllFloatInt, "x"),
                                                            new ParameterDeclaration(varyingAllFloatInt, "y")).WithArgs(varyingAllFloatInt));

            #endregion

            #region Logical Operators

            scope.AddFunction(new GenericFunctionDefinition("!", matchType,
                                                            new ParameterDeclaration(varyingAllBool, "x")).WithArgs(varyingAllBool));


            scope.AddFunction(new GenericFunctionDefinition("&&", varyingAllBool,
                                                            new ParameterDeclaration(varyingAllBool, "x"),
                                                            new ParameterDeclaration(varyingAllBool, "y")).WithArgs(varyingAllBool));

            scope.AddFunction(new GenericFunctionDefinition("||", varyingAllBool,
                                                            new ParameterDeclaration(varyingAllBool, "x"),
                                                            new ParameterDeclaration(varyingAllBool, "y")).WithArgs(varyingAllBool));

            scope.AddFunction(new GenericFunctionDefinition("^", varyingAllBool,
                                                            new ParameterDeclaration(varyingAllBool, "x"),
                                                            new ParameterDeclaration(varyingAllBool, "y")).WithArgs(varyingAllBool));

            #endregion
        }