Beispiel #1
0
            public void Generate(ShaderMixinSourceTree mixin, ShaderMixinContext context)
            {
                {
                    var __subMixin = new ShaderMixinSourceTree()
                    {
                        Name = "ShadowMapCaster"
                    };
                    context.BeginChild(__subMixin);
                    context.Mixin(__subMixin, "ShadowMapCaster");
                    context.EndChild();
                }
                if (context.GetParam(ShadowMapParameters.ShadowMaps) == null || context.GetParam(ShadowMapParameters.ShadowMaps).Length == 0)
                {
                    return;
                }
                context.Mixin(mixin, "ShadowMapReceiver");
                foreach (var ____1 in context.GetParam(ShadowMapParameters.ShadowMaps))

                {
                    context.PushParameters(____1);

                    {
                        var __subMixin = new ShaderMixinSourceTree()
                        {
                            Parent = mixin
                        };
                        context.PushCompositionArray(mixin, "shadows", __subMixin);
                        context.Mixin(__subMixin, "ShadowMapReceiverEffect");
                        context.PopComposition();
                    }
                    context.PopParameters();
                }
            }
Beispiel #2
0
            public void Generate(ShaderMixinSourceTree mixin, ShaderMixinContext context)
            {
                #line 14
                context.Mixin(mixin, "A");

                #line 15
                context.Mixin(mixin, "B");

                #line 16
                context.Mixin(mixin, "C");

                {
                    #line 18
                    var __subMixin = new ShaderMixinSourceTree()
                    {
                        Name = "Test", Parent = mixin
                    };
                    mixin.Children.Add(__subMixin);

                    #line 18
                    context.BeginChild(__subMixin);

                    #line 18
                    context.Mixin(__subMixin, "ChildClone");

                    #line 18
                    context.EndChild();
                }
            }
            public void Generate(ShaderMixinSourceTree mixin, ShaderMixinContext context)
            {
                {
                    #line 43
                    var __subMixin = new ShaderMixinSourceTree()
                    {
                        Name = "ParadoxGBufferShaderPass", Parent = mixin
                    };
                    mixin.Children.Add(__subMixin);

                    #line 43
                    context.BeginChild(__subMixin);

                    #line 43
                    context.Mixin(__subMixin, "ParadoxGBufferShaderPass");

                    #line 43
                    context.EndChild();
                }

                #line 47
                context.RemoveMixin(mixin, "NormalVSStream");

                #line 48
                context.RemoveMixin(mixin, "SpecularPowerMap");

                #line 49
                context.RemoveMixin(mixin, "SpecularPowerPerMesh");

                #line 52
                context.Mixin(mixin, "NormalVSGBuffer");

                #line 54
                context.Mixin(mixin, "SpecularPowerGBuffer");
            }
Beispiel #4
0
            public void Generate(ShaderMixinSourceTree mixin, ShaderMixinContext context)
            {
                {
                    #line 43
                    var __subMixin = new ShaderMixinSourceTree()
                    {
                        Name = "ShadowMapCaster", Parent = mixin
                    };
                    mixin.Children.Add(__subMixin);

                    #line 43
                    context.BeginChild(__subMixin);

                    #line 43
                    context.Mixin(__subMixin, "ShadowMapCaster");

                    #line 43
                    context.EndChild();
                }

                #line 45
                if (context.GetParam(ShadowMapParameters.ShadowMaps) == null || context.GetParam(ShadowMapParameters.ShadowMaps).Length == 0)

                    #line 46
                {
                    return;
                }

                #line 48
                context.Mixin(mixin, "ShadowMapReceiver");

                #line 53
                foreach (var ____1 in context.GetParam(ShadowMapParameters.ShadowMaps))

                {
                    #line 53
                    context.PushParameters(____1);

                    {
                        #line 55
                        var __subMixin = new ShaderMixinSourceTree()
                        {
                            Parent = mixin
                        };

                        #line 55
                        context.Mixin(__subMixin, "ShadowMapReceiverEffect");
                        mixin.Mixin.AddCompositionToArray("shadows", __subMixin.Mixin);
                    }

                    #line 53
                    context.PopParameters();
                }
            }
Beispiel #5
0
            public void Generate(ShaderMixinSourceTree mixin, ShaderMixinContext context)
            {
                if (context.GetParam(LightingKeys.CastShadows))

                {
                    var __subMixin = new ShaderMixinSourceTree()
                    {
                        Name = "ShadowMapCaster"
                    };
                    context.BeginChild(__subMixin);
                    context.Mixin(__subMixin, "ShadowMapCaster");
                    context.EndChild();
                }
            }
Beispiel #6
0
            public void Generate(ShaderMixinSourceTree mixin, ShaderMixinContext context)
            {
                context.Mixin(mixin, "ParadoxBaseShader");

                {
                    var __subMixin = new ShaderMixinSourceTree()
                    {
                        Name = "ParadoxGBufferShaderPass"
                    };
                    context.BeginChild(__subMixin);
                    context.Mixin(__subMixin, "ParadoxGBufferShaderPass");
                    context.EndChild();
                }
            }
Beispiel #7
0
            public void Generate(ShaderMixinSourceTree mixin, ShaderMixinContext context)
            {
                context.Mixin(mixin, "CustomShader");

                {
                    var __subMixin = new ShaderMixinSourceTree()
                    {
                        Name = "CustomSubEffect"
                    };
                    context.BeginChild(__subMixin);
                    context.Mixin(__subMixin, "CustomSubEffect");
                    context.EndChild();
                }
            }
            public void Generate(ShaderMixinSourceTree mixin, ShaderMixinContext context)
            {
                context.Mixin(mixin, "A");
                context.Mixin(mixin, "B");
                context.Mixin(mixin, "C");

                {
                    var __subMixin = new ShaderMixinSourceTree()
                    {
                        Name = "Test"
                    };
                    context.BeginChild(__subMixin);
                    context.Mixin(__subMixin, "ChildClone");
                    context.EndChild();
                }
            }
 public void Generate(ShaderMixinSourceTree mixin, ShaderMixinContext context)
 {
     {
         var __subMixin = new ShaderMixinSourceTree()
         {
             Name = "ParadoxGBufferShaderPass"
         };
         context.BeginChild(__subMixin);
         context.Mixin(__subMixin, "ParadoxGBufferShaderPass");
         context.EndChild();
     }
     context.RemoveMixin(mixin, "NormalVSStream");
     context.RemoveMixin(mixin, "SpecularPowerMap");
     context.RemoveMixin(mixin, "SpecularPowerPerMesh");
     context.Mixin(mixin, "NormalVSGBuffer");
     context.Mixin(mixin, "SpecularPowerGBuffer");
 }
Beispiel #10
0
            public void Generate(ShaderMixinSourceTree mixin, ShaderMixinContext context)
            {
                context.Mixin(mixin, "A");
                if (context.GetParam(TestParameters.TestCount) == 0)
                {
                    context.Mixin(mixin, "B");
                }

                {
                    var __subMixin = new ShaderMixinSourceTree()
                    {
                        Name = "ChildParamsMixin"
                    };
                    context.BeginChild(__subMixin);
                    context.Mixin(__subMixin, "ChildParamsMixin");
                    context.EndChild();
                }
                if (context.GetParam(TestParameters.TestCount) == 0)
                {
                    context.Mixin(mixin, "C");
                }
            }
Beispiel #11
0
            public void Generate(ShaderMixinSourceTree mixin, ShaderMixinContext context)
            {
                #line 24
                context.Mixin(mixin, "A");

                #line 25
                if (context.GetParam(TestParameters.TestCount) == 0)

                    #line 26
                {
                    context.Mixin(mixin, "B");
                }

                {
                    #line 28
                    var __subMixin = new ShaderMixinSourceTree()
                    {
                        Name = "ChildParamsMixin", Parent = mixin
                    };
                    mixin.Children.Add(__subMixin);

                    #line 28
                    context.BeginChild(__subMixin);

                    #line 28
                    context.Mixin(__subMixin, "ChildParamsMixin");

                    #line 28
                    context.EndChild();
                }

                #line 30
                if (context.GetParam(TestParameters.TestCount) == 0)

                    #line 31
                {
                    context.Mixin(mixin, "C");
                }
            }
Beispiel #12
0
            public void Generate(ShaderMixinSourceTree mixin, ShaderMixinContext context)
            {
                {
                    #line 19
                    var __subMixin = new ShaderMixinSourceTree()
                    {
                        Name = "GBufferShaderPass", Parent = mixin
                    };
                    mixin.Children.Add(__subMixin);

                    #line 19
                    context.BeginChild(__subMixin);

                    #line 19
                    context.Mixin(__subMixin, "GBufferShaderPass");

                    #line 19
                    context.EndChild();
                }

                #line 22
                context.RemoveMixin(mixin, "PositionVSStream");

                #line 23
                context.RemoveMixin(mixin, "NormalVSStream");

                #line 24
                context.RemoveMixin(mixin, "SpecularPowerPerMesh");

                #line 27
                context.Mixin(mixin, "NormalVSGBuffer");

                #line 28
                context.Mixin(mixin, "PositionVSGBuffer");

                #line 29
                context.Mixin(mixin, "SpecularPowerGBuffer");
            }
Beispiel #13
0
            public void Generate(ShaderMixinSourceTree mixin, ShaderMixinContext context)
            {
                #line 40
                context.Mixin(mixin, "ParadoxBaseShader");

                {
                    #line 41
                    var __subMixin = new ShaderMixinSourceTree()
                    {
                        Name = "ParadoxGBufferShaderPass", Parent = mixin
                    };
                    mixin.Children.Add(__subMixin);

                    #line 41
                    context.BeginChild(__subMixin);

                    #line 41
                    context.Mixin(__subMixin, "ParadoxGBufferShaderPass");

                    #line 41
                    context.EndChild();
                }
            }
Beispiel #14
0
            public void Generate(ShaderMixinSourceTree mixin, ShaderMixinContext context)
            {
                #line 68
                if (context.GetParam(LightingKeys.CastShadows))

                {
                        #line 69
                    var __subMixin = new ShaderMixinSourceTree()
                    {
                        Name = "ShadowMapCaster", Parent = mixin
                    };
                    mixin.Children.Add(__subMixin);

                        #line 69
                    context.BeginChild(__subMixin);

                        #line 69
                    context.Mixin(__subMixin, "ShadowMapCaster");

                        #line 69
                    context.EndChild();
                }
            }
            public void Generate(ShaderMixinSourceTree mixin, ShaderMixinContext context)
            {
                context.Mixin(mixin, "PositionVSGBuffer");
                context.Mixin(mixin, "NormalVSGBuffer");
                context.Mixin(mixin, "BRDFDiffuseBase");
                context.Mixin(mixin, "BRDFSpecularBase");

                {
                    var __subMixin = new ShaderMixinSourceTree()
                    {
                        Parent = mixin
                    };
                    context.PushComposition(mixin, "DiffuseColor", __subMixin);
                    context.Mixin(__subMixin, "ComputeBRDFColorFresnel");
                    context.PopComposition();
                }

                {
                    var __subMixin = new ShaderMixinSourceTree()
                    {
                        Parent = mixin
                    };
                    context.PushComposition(mixin, "DiffuseLighting", __subMixin);
                    context.Mixin(__subMixin, "ComputeBRDFDiffuseLambert");
                    context.PopComposition();
                }

                {
                    var __subMixin = new ShaderMixinSourceTree()
                    {
                        Parent = mixin
                    };
                    context.PushComposition(mixin, "SpecularColor", __subMixin);
                    context.Mixin(__subMixin, "ComputeBRDFColor");
                    context.PopComposition();
                }

                {
                    var __subMixin = new ShaderMixinSourceTree()
                    {
                        Parent = mixin
                    };
                    context.PushComposition(mixin, "SpecularLighting", __subMixin);
                    context.Mixin(__subMixin, "ParadoxDeferredSpecular");
                    context.PopComposition();
                }

                {
                    var __subMixin = new ShaderMixinSourceTree()
                    {
                        Name = "ParadoxShadowPrepassLighting"
                    };
                    context.BeginChild(__subMixin);
                    context.Mixin(__subMixin, "ParadoxShadowPrepassLighting");
                    context.EndChild();
                }
                context.Mixin(mixin, "DeferredLightingShader");

                {
                    var __subMixin = new ShaderMixinSourceTree()
                    {
                        Name = "ParadoxDirectPrepassLighting"
                    };
                    context.BeginChild(__subMixin);
                    context.Mixin(__subMixin, "ParadoxDirectPrepassLighting");
                    context.EndChild();
                }

                {
                    var __subMixin = new ShaderMixinSourceTree()
                    {
                        Name = "ParadoxSpotPrepassLighting"
                    };
                    context.BeginChild(__subMixin);
                    context.Mixin(__subMixin, "ParadoxSpotPrepassLighting");
                    context.EndChild();
                }

                {
                    var __subMixin = new ShaderMixinSourceTree()
                    {
                        Name = "ParadoxPointPrepassLighting"
                    };
                    context.BeginChild(__subMixin);
                    context.Mixin(__subMixin, "ParadoxPointPrepassLighting");
                    context.EndChild();
                }
            }
Beispiel #16
0
            public void Generate(ShaderMixinSourceTree mixin, ShaderMixinContext context)
            {
                context.Mixin(mixin, "XenkoBaseShader");

                {
                    var __subMixin = new ShaderMixinSourceTree() { Name = "XenkoGBufferShaderPass" };
                    context.BeginChild(__subMixin);
                    context.Mixin(__subMixin, "XenkoGBufferShaderPass");
                    context.EndChild();
                }
            }
            public void Generate(ShaderMixinSourceTree mixin, ShaderMixinContext context)
            {
                #line 188
                context.Mixin(mixin, "PositionVSGBuffer");

                #line 189
                context.Mixin(mixin, "NormalVSGBuffer");

                #line 190
                context.Mixin(mixin, "BRDFDiffuseBase");

                #line 191
                context.Mixin(mixin, "BRDFSpecularBase");

                {
                    #line 192
                    var __subMixin = new ShaderMixinSourceTree()
                    {
                        Parent = mixin
                    };

                    #line 192
                    context.Mixin(__subMixin, "ComputeBRDFColorFresnel");
                    mixin.Mixin.AddComposition("DiffuseColor", __subMixin.Mixin);
                }

                {
                    #line 193
                    var __subMixin = new ShaderMixinSourceTree()
                    {
                        Parent = mixin
                    };

                    #line 193
                    context.Mixin(__subMixin, "ComputeBRDFDiffuseLambert");
                    mixin.Mixin.AddComposition("DiffuseLighting", __subMixin.Mixin);
                }

                {
                    #line 194
                    var __subMixin = new ShaderMixinSourceTree()
                    {
                        Parent = mixin
                    };

                    #line 194
                    context.Mixin(__subMixin, "ComputeBRDFColor");
                    mixin.Mixin.AddComposition("SpecularColor", __subMixin.Mixin);
                }

                {
                    #line 195
                    var __subMixin = new ShaderMixinSourceTree()
                    {
                        Parent = mixin
                    };

                    #line 195
                    context.Mixin(__subMixin, "ParadoxDeferredSpecular");
                    mixin.Mixin.AddComposition("SpecularLighting", __subMixin.Mixin);
                }

                {
                    #line 197
                    var __subMixin = new ShaderMixinSourceTree()
                    {
                        Name = "ParadoxShadowPrepassLighting", Parent = mixin
                    };
                    mixin.Children.Add(__subMixin);

                    #line 197
                    context.BeginChild(__subMixin);

                    #line 197
                    context.Mixin(__subMixin, "ParadoxShadowPrepassLighting");

                    #line 197
                    context.EndChild();
                }

                #line 199
                context.Mixin(mixin, "DeferredLightingShader");

                {
                    #line 201
                    var __subMixin = new ShaderMixinSourceTree()
                    {
                        Name = "ParadoxDirectPrepassLighting", Parent = mixin
                    };
                    mixin.Children.Add(__subMixin);

                    #line 201
                    context.BeginChild(__subMixin);

                    #line 201
                    context.Mixin(__subMixin, "ParadoxDirectPrepassLighting");

                    #line 201
                    context.EndChild();
                }

                {
                    #line 203
                    var __subMixin = new ShaderMixinSourceTree()
                    {
                        Name = "ParadoxSpotPrepassLighting", Parent = mixin
                    };
                    mixin.Children.Add(__subMixin);

                    #line 203
                    context.BeginChild(__subMixin);

                    #line 203
                    context.Mixin(__subMixin, "ParadoxSpotPrepassLighting");

                    #line 203
                    context.EndChild();
                }

                {
                    #line 205
                    var __subMixin = new ShaderMixinSourceTree()
                    {
                        Name = "ParadoxPointPrepassLighting", Parent = mixin
                    };
                    mixin.Children.Add(__subMixin);

                    #line 205
                    context.BeginChild(__subMixin);

                    #line 205
                    context.Mixin(__subMixin, "ParadoxPointPrepassLighting");

                    #line 205
                    context.EndChild();
                }
            }