コード例 #1
0
            public void Generate(ShaderMixinSource mixin, ShaderMixinContext context)
            {
                context.Mixin(mixin, "A");
                context.Mixin(mixin, "B");
                context.Mixin(mixin, "C");
                int x = 1;

                foreach (var ____1 in context.GetParam(TestParameters.subParameters))

                {
                    context.PushParameters(____1);
                    if (context.GetParam(SubParameters.param1))
                    {
                        context.Mixin(mixin, "C" + x);
                    }
                    x++;
                    context.PopParameters();
                }

                {
                    context.PushParameters(context.GetParam(TestParameters.subParam1));
                    if (context.GetParam(SubParameters.param2) == 1)
                    {
                        context.Mixin(mixin, "D");
                    }
                    context.PopParameters();
                }
            }
コード例 #2
0
            public void Generate(ShaderMixinSource mixin, ShaderMixinContext context)
            {
                context.Mixin(mixin, "A");
                context.Mixin(mixin, "B");
                context.Mixin(mixin, "C");
                int x = 1;
                foreach(var ____1 in context.GetParam(TestParameters.subParameters))

                {
                    context.PushParameters(____1);
                    if (context.GetParam(SubParameters.param1))
                    {
                        context.Mixin(mixin, "C" + x);
                    }
                    x++;
                    context.PopParameters();
                }

                {
                    context.PushParameters(context.GetParam(TestParameters.subParam1));
                    if (context.GetParam(SubParameters.param2) == 1)
                    {
                        context.Mixin(mixin, "D");
                    }
                    context.PopParameters();
                }
            }
コード例 #3
0
            public void Generate(ShaderMixinSourceTree mixin, ShaderMixinContext context)
            {
                #line 23
                context.Mixin(mixin, "A");

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

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

                #line 27

                #line 27
                int x = 1;

                #line 28
                foreach (var ____1 in context.GetParam(TestParameters.subParameters))

                {
                    #line 28
                    context.PushParameters(____1);

                    #line 30
                    if (context.GetParam(SubParameters.param1))
                    {
                        #line 32
                        context.Mixin(mixin, "C" + x);
                    }

                    #line 35
                    x++;

                    #line 28
                    context.PopParameters();
                }

                {
                    #line 38
                    context.PushParameters(context.GetParam(TestParameters.subParam1));

                    #line 41
                    if (context.GetParam(SubParameters.param2) == 1)
                    {
                        #line 43
                        context.Mixin(mixin, "D");
                    }

                    #line 38
                    context.PopParameters();
                }
            }
コード例 #4
0
ファイル: ShadowMaps.cs プロジェクト: slagusev/paradox
            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();
                }
            }
コード例 #5
0
            public void Generate(ShaderMixinSourceTree mixin, ShaderMixinContext context)
            {
                context.Mixin(mixin, "ShaderBase");
                context.Mixin(mixin, "ImageEffectShader");
                mixin.Mixin.AddMacro("TEXTURECUBE_BLEND_COUNT", context.GetParam(CubemapBlendRenderer.CubemapCount));
                if (context.GetParam(CubemapBlendRenderer.UseMultipleRenderTargets))
                {
                    context.Mixin(mixin, "CubemapBlenderMRT");
                }
                else
                {
                    context.Mixin(mixin, "CubemapBlender");
                }
                foreach (var ____1 in context.GetParam(CubemapBlendRenderer.Cubemaps))

                {
                    context.PushParameters(____1);

                    {
                        var __subMixin = new ShaderMixinSourceTree()
                        {
                            Parent = mixin
                        };
                        context.PushCompositionArray(mixin, "Cubemaps", __subMixin);
                        context.Mixin(__subMixin, "CubemapFace", context.GetParam(CubemapBlendRenderer.CubemapKey));
                        context.PopComposition();
                    }
                    context.PopParameters();
                }
            }
コード例 #6
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();
                }
            }
コード例 #7
0
            public void Generate(ShaderMixinSource mixin, ShaderMixinContext context)
            {
                context.Mixin(mixin, "ToneMapShader", context.GetParam(ToneMapKeys.AutoKey), context.GetParam(ToneMapKeys.AutoExposure), context.GetParam(ToneMapKeys.UseLocalLuminance));
                context.PushParameters(context.GetParam(ToneMapKeys.Operator).Parameters);

                {
                    var __mixinToCompose__ = context.GetParam(ColorTransformKeys.Shader);
                    var __subMixin         = new ShaderMixinSource();
                    context.PushComposition(mixin, "ToneMapOperator", __subMixin);
                    context.Mixin(__subMixin, __mixinToCompose__);
                    context.PopComposition();
                }
                context.PopParameters();
            }
コード例 #8
0
            public void Generate(ShaderMixinSourceTree mixin, ShaderMixinContext context)
            {
                #line 15
                context.Mixin(mixin, "ShaderBase");

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

                #line 19
                mixin.Mixin.AddMacro("TEXTURECUBE_BLEND_COUNT", context.GetParam(CubemapBlendRenderer.CubemapCount));

                #line 21
                if (context.GetParam(CubemapBlendRenderer.UseMultipleRenderTargets))

                    #line 22
                {
                    context.Mixin(mixin, "CubemapBlenderMRT");
                }

                #line 24
                else

                    #line 24
                {
                    context.Mixin(mixin, "CubemapBlender");
                }

                #line 26
                foreach (var ____1 in context.GetParam(CubemapBlendRenderer.Cubemaps))

                {
                    #line 26
                    context.PushParameters(____1);

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

                        #line 28
                        context.Mixin(__subMixin, "CubemapFace", context.GetParam(CubemapBlendRenderer.CubemapKey));
                        mixin.Mixin.AddCompositionToArray("Cubemaps", __subMixin.Mixin);
                    }

                    #line 26
                    context.PopParameters();
                }
            }
コード例 #9
0
            public void Generate(ShaderMixinSource mixin, ShaderMixinContext context)
            {
                context.Mixin(mixin, "ToneMapShader", context.GetParam(ToneMapKeys.AutoKey), context.GetParam(ToneMapKeys.AutoExposure));
                context.PushParameters(context.GetParam(ToneMapKeys.Operator).Parameters);

                {
                    var __mixinToCompose__ = context.GetParam(ColorTransformKeys.Shader);
                    var __subMixin = new ShaderMixinSource();
                    context.PushComposition(mixin, "ToneMapOperator", __subMixin);
                    context.Mixin(__subMixin, __mixinToCompose__);
                    context.PopComposition();
                }
                context.PopParameters();
            }
コード例 #10
0
            public void Generate(ShaderMixinSource mixin, ShaderMixinContext context)
            {
                context.Mixin(mixin, "ColorTransformGroupShader");
                foreach (var colorTransform in context.GetParam(ColorTransformGroupKeys.Transforms))

                {
                    context.PushParameters(colorTransform.Parameters);

                    {
                        var __mixinToCompose__ = "ColorTransformCompose";
                        var __subMixin         = new ShaderMixinSource();
                        context.PushCompositionArray(mixin, "Transforms", __subMixin);
                        context.Mixin(__subMixin, __mixinToCompose__);
                        context.PopComposition();
                    }
                    context.PopParameters();
                }
            }
コード例 #11
0
            public void Generate(ShaderMixinSource mixin, ShaderMixinContext context)
            {
                context.Mixin(mixin, "ColorTransformGroupShader");
                foreach(var colorTransform in context.GetParam(ColorTransformGroupKeys.Transforms))

                {
                    context.PushParameters(colorTransform.Parameters);

                    {
                        var __mixinToCompose__ = "ColorTransformCompose";
                        var __subMixin = new ShaderMixinSource();
                        context.PushCompositionArray(mixin, "Transforms", __subMixin);
                        context.Mixin(__subMixin, __mixinToCompose__);
                        context.PopComposition();
                    }
                    context.PopParameters();
                }
            }
コード例 #12
0
            public void Generate(ShaderMixinSourceTree mixin, ShaderMixinContext context)
            {
                #line 145
                context.Mixin(mixin, "BRDFDiffuseBase");

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

                #line 148
                if (context.GetParam(MaterialParameters.AlbedoDiffuse) != null)
                {
                    #line 150
                    context.Mixin(mixin, "AlbedoDiffuseBase");

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

                        #line 151
                        context.Mixin(__subMixin, context.GetParam(MaterialParameters.AlbedoDiffuse));
                        mixin.Mixin.AddComposition("albedoDiffuse", __subMixin.Mixin);
                    }

                    #line 153
                    if (context.GetParam(LightingKeys.MaxDirectionalLights) > 0 || context.GetParam(LightingKeys.MaxSpotLights) > 0 || context.GetParam(LightingKeys.MaxPointLights) > 0 || (context.GetParam(LightingKeys.ReceiveShadows) && context.GetParam(ShadowMapParameters.ShadowMaps) != null && context.GetParam(ShadowMapParameters.ShadowMaps).Length > 0))
                    {
                        #line 155
                        if (context.GetParam(LightingKeys.MaxDirectionalLights) > 0 || context.GetParam(LightingKeys.MaxSpotLights) > 0 || context.GetParam(LightingKeys.MaxPointLights) > 0)
                        {
                            #line 157
                            context.Mixin(mixin, "GroupShadingBase");

                            #line 159
                            if (context.GetParam(LightingKeys.MaxDirectionalLights) > 0)

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

                                    #line 160
                                context.Mixin(__subMixin, "ParadoxDirectionalLightsShader");
                                mixin.Mixin.AddCompositionToArray("ShadingGroups", __subMixin.Mixin);
                            }

                            #line 161
                            if (context.GetParam(LightingKeys.MaxSpotLights) > 0)

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

                                    #line 162
                                context.Mixin(__subMixin, "ParadoxSpotLightsShader");
                                mixin.Mixin.AddCompositionToArray("ShadingGroups", __subMixin.Mixin);
                            }

                            #line 163
                            if (context.GetParam(LightingKeys.MaxPointLights) > 0)

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

                                    #line 164
                                context.Mixin(__subMixin, "ParadoxPointLightsShader");
                                mixin.Mixin.AddCompositionToArray("ShadingGroups", __subMixin.Mixin);
                            }
                        }

                        #line 166
                        if (context.GetParam(LightingKeys.ReceiveShadows) && context.GetParam(ShadowMapParameters.ShadowMaps) != null && context.GetParam(ShadowMapParameters.ShadowMaps).Length > 0)
                        {
                            #line 168
                            context.Mixin(mixin, "ShadowMapReceiver");

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

                            {
                                #line 169
                                context.PushParameters(____1);

                                #line 171
                                if (context.GetParam(ShadowMapParameters.LightType) == LightType.Directional)

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

                                        #line 172
                                    context.Mixin(__subMixin, "ParadoxDirectionalShadowLightsShader");
                                    mixin.Mixin.AddCompositionToArray("shadows", __subMixin.Mixin);
                                }

                                #line 173
                                else
#line 173
                                if (context.GetParam(ShadowMapParameters.LightType) == LightType.Spot)

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

                                        #line 174
                                    context.Mixin(__subMixin, "ParadoxSpotShadowLightsShader");
                                    mixin.Mixin.AddCompositionToArray("shadows", __subMixin.Mixin);
                                }

                                #line 169
                                context.PopParameters();
                            }
                        }

                        #line 178
                        if (context.GetParam(MaterialParameters.DiffuseModel) == MaterialDiffuseModel.None || context.GetParam(MaterialParameters.DiffuseModel) == MaterialDiffuseModel.Lambert)
                        {
                            {
                                #line 180
                                var __subMixin = new ShaderMixinSourceTree()
                                {
                                    Parent = mixin
                                };

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

                        #line 182
                        else
#line 182
                        if (context.GetParam(MaterialParameters.DiffuseModel) == MaterialDiffuseModel.OrenNayar)
                        {
                            {
                                #line 184
                                var __subMixin = new ShaderMixinSourceTree()
                                {
                                    Parent = mixin
                                };

                                #line 184
                                context.Mixin(__subMixin, "ComputeBRDFDiffuseOrenNayar");
                                mixin.Mixin.AddComposition("DiffuseLighting", __subMixin.Mixin);
                            }
                        }
                    }

                    #line 188
                    else
                    {
                        #line 189
                        context.Mixin(mixin, "AlbedoFlatShading");
                    }
                }
            }
コード例 #13
0
            public void Generate(ShaderMixinSourceTree mixin, ShaderMixinContext context)
            {
                context.Mixin(mixin, "BRDFDiffuseBase");
                context.Mixin(mixin, "BRDFSpecularBase");
                if (context.GetParam(MaterialParameters.AlbedoDiffuse) != null)
                {
                    context.Mixin(mixin, "AlbedoDiffuseBase");

                    {
                        var __subMixin = new ShaderMixinSourceTree()
                        {
                            Parent = mixin
                        };
                        context.PushComposition(mixin, "albedoDiffuse", __subMixin);
                        context.Mixin(__subMixin, context.GetParam(MaterialParameters.AlbedoDiffuse));
                        context.PopComposition();
                    }
                    if (context.GetParam(LightingKeys.MaxDirectionalLights) > 0 || context.GetParam(LightingKeys.MaxSpotLights) > 0 || context.GetParam(LightingKeys.MaxPointLights) > 0 || (context.GetParam(LightingKeys.ReceiveShadows) && context.GetParam(ShadowMapParameters.ShadowMaps) != null && context.GetParam(ShadowMapParameters.ShadowMaps).Length > 0))
                    {
                        if (context.GetParam(LightingKeys.MaxDirectionalLights) > 0 || context.GetParam(LightingKeys.MaxSpotLights) > 0 || context.GetParam(LightingKeys.MaxPointLights) > 0)
                        {
                            context.Mixin(mixin, "GroupShadingBase");
                            if (context.GetParam(LightingKeys.MaxDirectionalLights) > 0)

                            {
                                var __subMixin = new ShaderMixinSourceTree()
                                {
                                    Parent = mixin
                                };
                                context.PushCompositionArray(mixin, "ShadingGroups", __subMixin);
                                context.Mixin(__subMixin, "ParadoxDirectionalLightsShader");
                                context.PopComposition();
                            }
                            if (context.GetParam(LightingKeys.MaxSpotLights) > 0)

                            {
                                var __subMixin = new ShaderMixinSourceTree()
                                {
                                    Parent = mixin
                                };
                                context.PushCompositionArray(mixin, "ShadingGroups", __subMixin);
                                context.Mixin(__subMixin, "ParadoxSpotLightsShader");
                                context.PopComposition();
                            }
                            if (context.GetParam(LightingKeys.MaxPointLights) > 0)

                            {
                                var __subMixin = new ShaderMixinSourceTree()
                                {
                                    Parent = mixin
                                };
                                context.PushCompositionArray(mixin, "ShadingGroups", __subMixin);
                                context.Mixin(__subMixin, "ParadoxPointLightsShader");
                                context.PopComposition();
                            }
                        }
                        if (context.GetParam(LightingKeys.ReceiveShadows) && context.GetParam(ShadowMapParameters.ShadowMaps) != null && context.GetParam(ShadowMapParameters.ShadowMaps).Length > 0)
                        {
                            context.Mixin(mixin, "ShadowMapReceiver");
                            foreach (var ____1 in context.GetParam(ShadowMapParameters.ShadowMaps))

                            {
                                context.PushParameters(____1);
                                if (context.GetParam(ShadowMapParameters.LightType) == LightType.Directional)

                                {
                                    var __subMixin = new ShaderMixinSourceTree()
                                    {
                                        Parent = mixin
                                    };
                                    context.PushCompositionArray(mixin, "shadows", __subMixin);
                                    context.Mixin(__subMixin, "ParadoxDirectionalShadowLightsShader");
                                    context.PopComposition();
                                }
                                else if (context.GetParam(ShadowMapParameters.LightType) == LightType.Spot)

                                {
                                    var __subMixin = new ShaderMixinSourceTree()
                                    {
                                        Parent = mixin
                                    };
                                    context.PushCompositionArray(mixin, "shadows", __subMixin);
                                    context.Mixin(__subMixin, "ParadoxSpotShadowLightsShader");
                                    context.PopComposition();
                                }
                                context.PopParameters();
                            }
                        }
                        if (context.GetParam(MaterialParameters.DiffuseModel) == MaterialDiffuseModel.None || context.GetParam(MaterialParameters.DiffuseModel) == MaterialDiffuseModel.Lambert)
                        {
                            {
                                var __subMixin = new ShaderMixinSourceTree()
                                {
                                    Parent = mixin
                                };
                                context.PushComposition(mixin, "DiffuseLighting", __subMixin);
                                context.Mixin(__subMixin, "ComputeBRDFDiffuseLambert");
                                context.PopComposition();
                            }
                        }
                        else if (context.GetParam(MaterialParameters.DiffuseModel) == MaterialDiffuseModel.OrenNayar)
                        {
                            {
                                var __subMixin = new ShaderMixinSourceTree()
                                {
                                    Parent = mixin
                                };
                                context.PushComposition(mixin, "DiffuseLighting", __subMixin);
                                context.Mixin(__subMixin, "ComputeBRDFDiffuseOrenNayar");
                                context.PopComposition();
                            }
                        }
                    }
                    else
                    {
                        context.Mixin(mixin, "AlbedoFlatShading");
                    }
                }
            }