Beispiel #1
0
            public void Generate(ShaderMixinSource mixin, ShaderMixinContext context)
            {
                context.Mixin(mixin, "BufferToTexture");
                if (context.GetParam(BufferToTextureKeys.AttributesIndirect) != null)
                {
                    foreach (var attr in context.GetParam(BufferToTextureKeys.AttributesIndirect))

                    {
                        {
                            var __mixinToCompose__ = (attr);
                            var __subMixin         = new ShaderMixinSource();
                            context.PushCompositionArray(mixin, "AttributesIndirect", __subMixin);
                            context.Mixin(__subMixin, __mixinToCompose__);
                            context.PopComposition();
                        }
                    }
                }
                if (context.GetParam(BufferToTextureKeys.AttributesTemp) != null)
                {
                    foreach (var attr in context.GetParam(BufferToTextureKeys.AttributesTemp))

                    {
                        {
                            var __mixinToCompose__ = (attr);
                            var __subMixin         = new ShaderMixinSource();
                            context.PushCompositionArray(mixin, "AttributesTemp", __subMixin);
                            context.Mixin(__subMixin, __mixinToCompose__);
                            context.PopComposition();
                        }
                    }
                }
                mixin.AddMacro("IndirectReadAndStoreMacro", context.GetParam(BufferToTextureKeys.IndirectReadAndStoreMacro));
                mixin.AddMacro("IndirectStoreMacro", context.GetParam(BufferToTextureKeys.IndirectStoreMacro));
            }
Beispiel #2
0
            public void Generate(ShaderMixinSource mixin, ShaderMixinContext context)
            {
                ShaderSourceCollection directLightGroups = context.GetParam(LightingKeys.DirectLightGroups);

                if (directLightGroups != null)
                {
                    foreach (ShaderSource directLightGroup in directLightGroups)

                    {
                        {
                            var __mixinToCompose__ = (directLightGroup);
                            var __subMixin         = new ShaderMixinSource();
                            context.PushCompositionArray(mixin, "directLightGroups", __subMixin);
                            context.Mixin(__subMixin, __mixinToCompose__);
                            context.PopComposition();
                        }
                    }
                }
                ShaderSourceCollection environmentLights = context.GetParam(LightingKeys.EnvironmentLights);

                if (environmentLights != null)
                {
                    foreach (ShaderSource environmentLight in environmentLights)

                    {
                        {
                            var __mixinToCompose__ = (environmentLight);
                            var __subMixin         = new ShaderMixinSource();
                            context.PushCompositionArray(mixin, "environmentLights", __subMixin);
                            context.Mixin(__subMixin, __mixinToCompose__);
                            context.PopComposition();
                        }
                    }
                }
            }
            public void Generate(ShaderMixinSource mixin, ShaderMixinContext context)
            {
                context.Mixin(mixin, "BufferToTextureColumns");
                if (context.GetParam(BufferToTextureKeys.Modifiers) != null)
                {
                    foreach (var attr in context.GetParam(BufferToTextureKeys.Modifiers))
                    {
                        {
                            var __mixinToCompose__ = (attr);
                            var __subMixin         = new ShaderMixinSource();
                            context.PushCompositionArray(mixin, "Modifiers", __subMixin);
                            context.Mixin(__subMixin, __mixinToCompose__);
                            context.PopComposition();
                        }
                    }
                }
                if (context.GetParam(BufferToTextureKeys.AttributesIndirect) != null)
                {
                    foreach (var attr in context.GetParam(BufferToTextureKeys.AttributesIndirect))

                    {
                        {
                            var __mixinToCompose__ = (attr);
                            var __subMixin         = new ShaderMixinSource();
                            context.PushCompositionArray(mixin, "AttributesIndirect", __subMixin);
                            context.Mixin(__subMixin, __mixinToCompose__);
                            context.PopComposition();
                        }
                    }
                }
            }
            public void Generate(ShaderMixinSource mixin, ShaderMixinContext context)
            {
                var directLightGroups = context.GetParam(LightingKeys.DirectLightGroups);
                if (directLightGroups != null)
                {
                    foreach(var directLightGroup in directLightGroups)

                    {

                        {
                            var __mixinToCompose__ = (directLightGroup);
                            var __subMixin = new ShaderMixinSource();
                            context.PushCompositionArray(mixin, "directLightGroups", __subMixin);
                            context.Mixin(__subMixin, __mixinToCompose__);
                            context.PopComposition();
                        }
                    }
                }
                var environmentLights = context.GetParam(LightingKeys.EnvironmentLights);
                if (environmentLights != null)
                {
                    foreach(var environmentLight in environmentLights)

                    {

                        {
                            var __mixinToCompose__ = (environmentLight);
                            var __subMixin = new ShaderMixinSource();
                            context.PushCompositionArray(mixin, "environmentLights", __subMixin);
                            context.Mixin(__subMixin, __mixinToCompose__);
                            context.PopComposition();
                        }
                    }
                }
            }
Beispiel #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();
                }
            }
            public void Generate(ShaderMixinSourceTree mixin, ShaderMixinContext context)
            {
                context.Mixin(mixin, "A");

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

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

                {
                    var __subMixin = new ShaderMixinSourceTree()
                    {
                        Parent = mixin
                    };
                    context.PushCompositionArray(mixin, "SubComputes", __subMixin);
                    context.Mixin(__subMixin, "ABCSubEffect");
                    context.PopComposition();
                }
            }
Beispiel #7
0
            public void Generate(ShaderMixinSource mixin, ShaderMixinContext context)
            {
                context.Mixin(mixin, "VoxelVisualizationViewShader");
                if (context.GetParam(VoxelVisualizationViewShaderKeys.marcher) != null)
                {
                    {
                        var __mixinToCompose__ = context.GetParam(VoxelVisualizationViewShaderKeys.marcher);
                        var __subMixin         = new ShaderMixinSource();
                        context.PushComposition(mixin, "marcher", __subMixin);
                        context.Mixin(__subMixin, __mixinToCompose__);
                        context.PopComposition();
                    }
                }
                if (context.GetParam(MarchAttributesKeys.AttributeSamplers) != null)
                {
                    foreach (var attr in context.GetParam(MarchAttributesKeys.AttributeSamplers))

                    {
                        {
                            var __mixinToCompose__ = (attr);
                            var __subMixin         = new ShaderMixinSource();
                            context.PushCompositionArray(mixin, "AttributeSamplers", __subMixin);
                            context.Mixin(__subMixin, __mixinToCompose__);
                            context.PopComposition();
                        }
                    }
                }
            }
            public void Generate(ShaderMixinSource mixin, ShaderMixinContext context)
            {
                context.Mixin(mixin, "A");

                {
                    var __mixinToCompose__ = "ABCSubEffect";
                    var __subMixin         = new ShaderMixinSource();
                    context.PushComposition(mixin, "SubCompute1", __subMixin);
                    context.Mixin(__subMixin, __mixinToCompose__);
                    context.PopComposition();
                }

                {
                    var __mixinToCompose__ = "ABCSubEffect";
                    var __subMixin         = new ShaderMixinSource();
                    context.PushComposition(mixin, "SubCompute2", __subMixin);
                    context.Mixin(__subMixin, __mixinToCompose__);
                    context.PopComposition();
                }

                {
                    var __mixinToCompose__ = "ABCSubEffect";
                    var __subMixin         = new ShaderMixinSource();
                    context.PushCompositionArray(mixin, "SubComputes", __subMixin);
                    context.Mixin(__subMixin, __mixinToCompose__);
                    context.PopComposition();
                }
            }
Beispiel #9
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();
                }
            }
            public void Generate(ShaderMixinSourceTree mixin, ShaderMixinContext context)
            {
                context.CloneParentMixinToCurrent();
                context.Mixin(mixin, "DeferredShadowLightingShader");
                if (context.GetParam(ShadowMapParameters.FilterType) == ShadowMapFilterType.Nearest)

                {
                    var __subMixin = new ShaderMixinSourceTree()
                    {
                        Parent = mixin
                    };
                    context.PushCompositionArray(mixin, "shadows", __subMixin);
                    context.Mixin(__subMixin, "NearestFilterGroup");
                    context.PopComposition();
                }
                else if (context.GetParam(ShadowMapParameters.FilterType) == ShadowMapFilterType.PercentageCloserFiltering)

                {
                    var __subMixin = new ShaderMixinSourceTree()
                    {
                        Parent = mixin
                    };
                    context.PushCompositionArray(mixin, "shadows", __subMixin);
                    context.Mixin(__subMixin, "PcfGroup");
                    context.PopComposition();
                }
                else if (context.GetParam(ShadowMapParameters.FilterType) == ShadowMapFilterType.Variance)

                {
                    var __subMixin = new ShaderMixinSourceTree()
                    {
                        Parent = mixin
                    };
                    context.PushCompositionArray(mixin, "shadows", __subMixin);
                    context.Mixin(__subMixin, "VsmGroup");
                    context.PopComposition();
                }
            }
            public void Generate(ShaderMixinSourceTree mixin, ShaderMixinContext context)
            {
                context.CloneParentMixinToCurrent();

                {
                    var __subMixin = new ShaderMixinSourceTree()
                    {
                        Parent = mixin
                    };
                    context.PushCompositionArray(mixin, "lightingGroups", __subMixin);
                    context.Mixin(__subMixin, "ParadoxDeferredLightingSpotGroup");
                    context.PopComposition();
                }
            }
Beispiel #12
0
            public void Generate(ShaderMixinSource mixin, ShaderMixinContext context)
            {
                context.Mixin(mixin, "ColorTransformGroupShader");
                foreach (var colorTransform in context.GetParam(ColorTransformGroupKeys.Transforms))

                {
                    {
                        var __mixinToCompose__ = "ColorTransformCompose";
                        var __subMixin         = new ShaderMixinSource();
                        context.PushCompositionArray(mixin, "Transforms", __subMixin);
                        context.Mixin(__subMixin, __mixinToCompose__);
                        context.PopComposition();
                    }
                }
            }
            public void Generate(ShaderMixinSource mixin, ShaderMixinContext context)
            {
                context.Mixin(mixin, "ColorTransformGroupShader");
                foreach(var colorTransform in context.GetParam(ColorTransformGroupKeys.Transforms))

                {

                    {
                        var __mixinToCompose__ = "ColorTransformCompose";
                        var __subMixin = new ShaderMixinSource();
                        context.PushCompositionArray(mixin, "Transforms", __subMixin);
                        context.Mixin(__subMixin, __mixinToCompose__);
                        context.PopComposition();
                    }
                }
            }
Beispiel #14
0
            public void Generate(ShaderMixinSource mixin, ShaderMixinContext context)
            {
                context.Mixin(mixin, "LightVoxelShader");
                if (context.GetParam(LightVoxelShaderKeys.diffuseMarcher) != null)
                {
                    {
                        var __mixinToCompose__ = context.GetParam(LightVoxelShaderKeys.diffuseMarcher);
                        var __subMixin         = new ShaderMixinSource();
                        context.PushComposition(mixin, "diffuseMarcher", __subMixin);
                        context.Mixin(__subMixin, __mixinToCompose__);
                        context.PopComposition();
                    }
                }
                if (context.GetParam(LightVoxelShaderKeys.specularMarcher) != null)
                {
                    {
                        var __mixinToCompose__ = context.GetParam(LightVoxelShaderKeys.specularMarcher);
                        var __subMixin         = new ShaderMixinSource();
                        context.PushComposition(mixin, "specularMarcher", __subMixin);
                        context.Mixin(__subMixin, __mixinToCompose__);
                        context.PopComposition();
                    }
                }
                if (context.GetParam(MarchAttributesKeys.AttributeSamplers) != null)
                {
                    foreach (var attr in context.GetParam(MarchAttributesKeys.AttributeSamplers))

                    {
                        {
                            var __mixinToCompose__ = (attr);
                            var __subMixin         = new ShaderMixinSource();
                            context.PushCompositionArray(mixin, "AttributeSamplers", __subMixin);
                            context.Mixin(__subMixin, __mixinToCompose__);
                            context.PopComposition();
                        }
                    }
                }
            }
Beispiel #15
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");
                    }
                }
            }
            public void Generate(ShaderMixinSource mixin, ShaderMixinContext context)
            {
                context.Mixin(mixin, "XenkoEffectBase");
                var extensionPixelStageSurfaceShaders = context.GetParam(MaterialKeys.PixelStageSurfaceShaders);

                if (extensionPixelStageSurfaceShaders != null)
                {
                    context.Mixin(mixin, "MaterialSurfacePixelStageCompositor");

                    {
                        var __mixinToCompose__ = (extensionPixelStageSurfaceShaders);
                        var __subMixin         = new ShaderMixinSource();
                        context.PushComposition(mixin, "materialPixelStage", __subMixin);
                        context.Mixin(__subMixin, __mixinToCompose__);
                        context.PopComposition();
                    }

                    {
                        var __mixinToCompose__ = context.GetParam(MaterialKeys.PixelStageStreamInitializer);
                        var __subMixin         = new ShaderMixinSource();
                        context.PushComposition(mixin, "streamInitializerPixelStage", __subMixin);
                        context.Mixin(__subMixin, __mixinToCompose__);
                        context.PopComposition();
                    }
                    var extensionPixelStageSurfaceFilter = context.GetParam(MaterialKeys.PixelStageSurfaceFilter);
                    if (extensionPixelStageSurfaceFilter != null)
                    {
                        context.Mixin(mixin, (extensionPixelStageSurfaceFilter));
                    }
                }
                var directLightGroups = context.GetParam(LightingKeys.DirectLightGroups);

                if (directLightGroups != null)
                {
                    foreach (var directLightGroup in directLightGroups)

                    {
                        {
                            var __mixinToCompose__ = (directLightGroup);
                            var __subMixin         = new ShaderMixinSource();
                            context.PushCompositionArray(mixin, "directLightGroups", __subMixin);
                            context.Mixin(__subMixin, __mixinToCompose__);
                            context.PopComposition();
                        }
                    }
                }
                var environmentLights = context.GetParam(LightingKeys.EnvironmentLights);

                if (environmentLights != null)
                {
                    foreach (var environmentLight in environmentLights)

                    {
                        {
                            var __mixinToCompose__ = (environmentLight);
                            var __subMixin         = new ShaderMixinSource();
                            context.PushCompositionArray(mixin, "environmentLights", __subMixin);
                            context.Mixin(__subMixin, __mixinToCompose__);
                            context.PopComposition();
                        }
                    }
                }
            }
            public void Generate(ShaderMixinSource mixin, ShaderMixinContext context)
            {
                context.Mixin(mixin, "A");

                {
                    var __mixinToCompose__ = "ABCSubEffect";
                    var __subMixin = new ShaderMixinSource();
                    context.PushComposition(mixin, "SubCompute1", __subMixin);
                    context.Mixin(__subMixin, __mixinToCompose__);
                    context.PopComposition();
                }

                {
                    var __mixinToCompose__ = "ABCSubEffect";
                    var __subMixin = new ShaderMixinSource();
                    context.PushComposition(mixin, "SubCompute2", __subMixin);
                    context.Mixin(__subMixin, __mixinToCompose__);
                    context.PopComposition();
                }

                {
                    var __mixinToCompose__ = "ABCSubEffect";
                    var __subMixin = new ShaderMixinSource();
                    context.PushCompositionArray(mixin, "SubComputes", __subMixin);
                    context.Mixin(__subMixin, __mixinToCompose__);
                    context.PopComposition();
                }
            }
            public void Generate(ShaderMixinSource mixin, ShaderMixinContext context)
            {
                context.Mixin(mixin, "ParadoxEffectBase");
                var extensionPixelStageSurfaceShaders = context.GetParam(MaterialKeys.PixelStageSurfaceShaders);
                if (extensionPixelStageSurfaceShaders != null)
                {
                    context.Mixin(mixin, "MaterialSurfacePixelStageCompositor");

                    {
                        var __mixinToCompose__ = (extensionPixelStageSurfaceShaders);
                        var __subMixin = new ShaderMixinSource();
                        context.PushComposition(mixin, "materialPixelStage", __subMixin);
                        context.Mixin(__subMixin, __mixinToCompose__);
                        context.PopComposition();
                    }

                    {
                        var __mixinToCompose__ = context.GetParam(MaterialKeys.PixelStageStreamInitializer);
                        var __subMixin = new ShaderMixinSource();
                        context.PushComposition(mixin, "streamInitializerPixelStage", __subMixin);
                        context.Mixin(__subMixin, __mixinToCompose__);
                        context.PopComposition();
                    }
                    var extensionPixelStageSurfaceFilter = context.GetParam(MaterialKeys.PixelStageSurfaceFilter);
                    if (extensionPixelStageSurfaceFilter != null)
                    {
                        context.Mixin(mixin, (extensionPixelStageSurfaceFilter));
                    }
                }
                var directLightGroups = context.GetParam(LightingKeys.DirectLightGroups);
                if (directLightGroups != null)
                {
                    foreach(var directLightGroup in directLightGroups)

                    {

                        {
                            var __mixinToCompose__ = (directLightGroup);
                            var __subMixin = new ShaderMixinSource();
                            context.PushCompositionArray(mixin, "directLightGroups", __subMixin);
                            context.Mixin(__subMixin, __mixinToCompose__);
                            context.PopComposition();
                        }
                    }
                }
                var environmentLights = context.GetParam(LightingKeys.EnvironmentLights);
                if (environmentLights != null)
                {
                    foreach(var environmentLight in environmentLights)

                    {

                        {
                            var __mixinToCompose__ = (environmentLight);
                            var __subMixin = new ShaderMixinSource();
                            context.PushCompositionArray(mixin, "environmentLights", __subMixin);
                            context.Mixin(__subMixin, __mixinToCompose__);
                            context.PopComposition();
                        }
                    }
                }
            }