Пример #1
0
            /// <summary>
            /// Initializes a new instance of the <see cref="PhongMaterialVariables"/> class.
            /// </summary>
            /// <param name="manager">The manager.</param>
            /// <param name="technique">The technique.</param>
            /// <param name="materialCore">The material core.</param>
            /// <param name="materialPassName">Name of the material pass.</param>
            /// <param name="wireframePassName">Name of the wireframe pass.</param>
            /// <param name="materialOITPassName">Name of the material oit pass.</param>
            /// <param name="wireframeOITPassName">Name of the wireframe oit pass.</param>
            /// <param name="shadowPassName">Name of the shadow pass.</param>
            /// <param name="tessellationPassName">Name of the tessellation pass.</param>
            /// <param name="tessellationOITPassName">Name of the tessellation oit pass.</param>
            /// <param name="depthPassName">Name of the depth pass</param>
            public PhongMaterialVariables(IEffectsManager manager, IRenderTechnique technique, PhongMaterialCore materialCore,
                                          string materialPassName        = DefaultPassNames.Default, string wireframePassName    = DefaultPassNames.Wireframe,
                                          string materialOITPassName     = DefaultPassNames.OITPass, string wireframeOITPassName = DefaultPassNames.WireframeOITPass,
                                          string shadowPassName          = DefaultPassNames.ShadowPass,
                                          string tessellationPassName    = DefaultPassNames.MeshTriTessellation,
                                          string tessellationOITPassName = DefaultPassNames.MeshTriTessellationOIT,
                                          string depthPassName           = DefaultPassNames.DepthPrepass)
                : base(manager, technique, DefaultMeshConstantBufferDesc, materialCore)
            {
                this.material      = materialCore;
                texDiffuseSlot     = texAlphaSlot = texDisplaceSlot = texNormalSlot = -1;
                samplerDiffuseSlot = samplerDisplaceSlot = samplerShadowSlot = -1;
                textureManager     = manager.MaterialTextureManager;
                statePoolManager   = manager.StateManager;

                MaterialPass        = technique[materialPassName];
                MaterialOITPass     = technique[materialOITPassName];
                ShadowPass          = technique[shadowPassName];
                WireframePass       = technique[wireframePassName];
                WireframeOITPass    = technique[wireframeOITPassName];
                TessellationPass    = technique[tessellationPassName];
                TessellationOITPass = technique[tessellationOITPassName];
                DepthPass           = technique[depthPassName];
                UpdateMappings(MaterialPass);
                EnableTessellation  = materialCore.EnableTessellation;
                currentMaterialPass = EnableTessellation ? TessellationPass : MaterialPass;
                currentOITPass      = EnableTessellation ? TessellationOITPass : MaterialOITPass;
            }
 /// <summary>
 ///
 /// </summary>
 /// <param name="technique"></param>
 /// <returns></returns>
 protected override bool OnAttach(IRenderTechnique technique)
 {
     DefaultShaderPass = technique[DefaultShaderPassName];
     ShadowPass        = technique[DefaultShadowPassName];
     CreateRasterState(rasterDescription, true);
     return(true);
 }
        private void UpdateMappings(ShaderPass shaderPass)
        {
            if (currentPass == shaderPass)
            {
                return;
            }
            currentPass = shaderPass;
            for (int i = 0; i < shaderPass.Shaders.Count; ++i)
            {
                var shader = shaderPass.Shaders[i];
                if (shader.IsNULL || !EnumHelper.HasFlag(Constants.CanBindTextureStages, shader.ShaderType))
                {
                    continue;
                }
                int idx = shaderPass.Shaders[i].ShaderType.ToIndex();
                TextureBindingMap[idx][DiffuseIdx]  = shader.ShaderResourceViewMapping.TryGetBindSlot(ShaderDiffuseTexName);
                TextureBindingMap[idx][AlphaIdx]    = shader.ShaderResourceViewMapping.TryGetBindSlot(ShaderAlphaTexName);
                TextureBindingMap[idx][NormalIdx]   = shader.ShaderResourceViewMapping.TryGetBindSlot(ShaderNormalTexName);
                TextureBindingMap[idx][DisplaceIdx] = shader.ShaderResourceViewMapping.TryGetBindSlot(ShaderDisplaceTexName);

                SamplerBindingMap[idx][DiffuseIdx]  = shader.SamplerMapping.TryGetBindSlot(ShaderSamplerDiffuseTexName);
                SamplerBindingMap[idx][AlphaIdx]    = shader.SamplerMapping.TryGetBindSlot(ShaderSamplerAlphaTexName);
                SamplerBindingMap[idx][NormalIdx]   = shader.SamplerMapping.TryGetBindSlot(ShaderSamplerNormalTexName);
                SamplerBindingMap[idx][DisplaceIdx] = shader.SamplerMapping.TryGetBindSlot(ShaderSamplerDisplaceTexName);
                SamplerBindingMap[idx][ShadowIdx]   = shader.SamplerMapping.TryGetBindSlot(ShaderSamplerShadowMapName);
            }
        }
Пример #4
0
        public override void Render(RenderContext context, DeviceContextProxy deviceContext)
        {
            if (!materialVariables.UpdateMaterialStruct(deviceContext, ref ModelMatrix, Matrix.SizeInBytes))
            {
                return;
            }
            int slot = 0;

            buffer.AttachBuffers(deviceContext, ref slot, EffectTechnique.EffectsManager);
            cubeBackPass.BindShader(deviceContext);
            cubeBackPass.BindStates(deviceContext, StateType.All);
            var back = context.RenderHost.RenderBuffer.FullResRenderTargetPool.Get(global::SharpDX.DXGI.Format.R16G16B16A16_Float);

            BindTarget(null, back, deviceContext, (int)context.ActualWidth, (int)context.ActualHeight);
            deviceContext.DrawIndexed(buffer.IndexBuffer.ElementCount, 0, 0);
            context.RenderHost.SetDefaultRenderTargets(false);
            var pass = materialVariables.GetPass(RenderType.Opaque, context);

            if (pass != volumePass)
            {
                volumePass  = pass;
                backTexSlot = volumePass.PixelShader.ShaderResourceViewMapping.TryGetBindSlot(DefaultBufferNames.VolumeBack);
            }
            materialVariables.BindMaterialResources(context, deviceContext, pass);
            volumePass.PixelShader.BindTexture(deviceContext, backTexSlot, back);
            volumePass.BindShader(deviceContext);
            volumePass.BindStates(deviceContext, StateType.All);
            deviceContext.DrawIndexed(buffer.IndexBuffer.ElementCount, 0, 0);
            volumePass.PixelShader.BindTexture(deviceContext, backTexSlot, null);
            context.RenderHost.RenderBuffer.FullResRenderTargetPool.Put(global::SharpDX.DXGI.Format.R16G16B16A16_Float, back);
        }
 /// <summary>
 /// <see cref="IEffectMaterialVariables.BindMaterialTextures(DeviceContext, ShaderPass)"/>
 /// </summary>
 /// <param name="context"></param>
 /// <param name="shaderPass"></param>
 /// <returns></returns>
 public bool BindMaterialTextures(DeviceContext context, ShaderPass shaderPass)
 {
     if (material == null)
     {
         return(false);
     }
     UpdateMappings(shaderPass);
     if (HasTextures)
     {
         for (int i = 0; i < shaderPass.Shaders.Count; ++i)
         {
             var shader = shaderPass.Shaders[i];
             if (shader.IsNULL || !EnumHelper.HasFlag(Constants.CanBindTextureStages, shader.ShaderType))
             {
                 continue;
             }
             OnBindMaterialTextures(context, shader);
         }
     }
     if (RenderShadowMap)
     {
         shaderPass.GetShader(ShaderStage.Pixel).BindSampler(context, SamplerBindingMap[ShaderStage.Pixel.ToIndex()][NUMSAMPLERS - 1], SamplerResources[NUMSAMPLERS - 1]);
     }
     return(true);
 }
Пример #6
0
 protected override void OnRender(RenderContext context, DeviceContextProxy deviceContext)
 {
     ShaderPass pass = MaterialVariables.GetPass(this, context);
     if (pass.IsNULL)
     { return; }
     pass.BindShader(deviceContext);
     pass.BindStates(deviceContext, DefaultStateBinding);
     if (!BindMaterialTextures(deviceContext, pass))
     {
         return;
     }
     if (context.RenderHost.IsShadowMapEnabled)
     {
         pass.PixelShader.BindTexture(deviceContext, shadowMapSlot, context.SharedResource.ShadowView);
     }
     DynamicReflector?.BindCubeMap(deviceContext);
     OnDraw(deviceContext, InstanceBuffer);
     DynamicReflector?.UnBindCubeMap(deviceContext);
     if (RenderWireframe && WireframePass != ShaderPass.NullPass)
     {
         if (RenderType == RenderType.Transparent && context.IsOITPass)
         {
             pass = WireframeOITPass;
         }
         else
         {
             pass = WireframePass;
         }
         pass.BindShader(deviceContext, false);
         pass.BindStates(deviceContext, DefaultStateBinding);
         deviceContext.SetRasterState(RasterStateWireframe);
         OnDraw(deviceContext, InstanceBuffer);
     }
 }
Пример #7
0
        /// <summary>
        /// Called when [attach].
        /// </summary>
        /// <param name="technique">The technique.</param>
        /// <returns></returns>
        protected override bool OnAttach(IRenderTechnique technique)
        {
            if (base.OnAttach(technique))
            {
                VertexLayout = technique.Layout;
                updatePass   = technique[DefaultParticlePassNames.Update];
                insertPass   = technique[DefaultParticlePassNames.Insert];
                renderPass   = technique[DefaultParticlePassNames.Default];
                #region Get binding slots
                currentStateSlot = updatePass.GetShader(ShaderStage.Compute).UnorderedAccessViewMapping.TryGetBindSlot(CurrentSimStateUAVBufferName);
                newStateSlot     = updatePass.GetShader(ShaderStage.Compute).UnorderedAccessViewMapping.TryGetBindSlot(NewSimStateUAVBufferName);

                renderStateSlot = renderPass.GetShader(ShaderStage.Vertex).ShaderResourceViewMapping.TryGetBindSlot(SimStateBufferName);
                textureSlot     = renderPass.GetShader(ShaderStage.Pixel).ShaderResourceViewMapping.TryGetBindSlot(ShaderTextureBufferName);
                samplerSlot     = renderPass.GetShader(ShaderStage.Pixel).SamplerMapping.TryGetBindSlot(ShaderTextureSamplerName);
                #endregion
                perFrameCB = technique.ConstantBufferPool.Register(DefaultBufferNames.ParticleFrameCB, ParticlePerFrame.SizeInBytes);
                insertCB   = technique.ConstantBufferPool.Register(DefaultBufferNames.ParticleCreateParameters, ParticleInsertParameters.SizeInBytes);
                if (isInitialParticleChanged)
                {
                    OnInitialParticleChanged(ParticleCount);
                }
                textureSampler = Collect(technique.EffectsManager.StateManager.Register(SamplerDescription));
                OnTextureChanged();
                OnBlendStateChanged();
                return(true);
            }
            else
            {
                return(false);
            }
        }
Пример #8
0
            private void UpdateMappings(ShaderPass shaderPass)
            {
                texDiffuseSlot     = shaderPass.PixelShader.ShaderResourceViewMapping.TryGetBindSlot(DefaultBufferNames.DiffuseMapTB);
                texEmissiveSlot    = shaderPass.PixelShader.ShaderResourceViewMapping.TryGetBindSlot(DefaultBufferNames.EmissiveTB);
                texNormalSlot      = shaderPass.PixelShader.ShaderResourceViewMapping.TryGetBindSlot(DefaultBufferNames.NormalMapTB);
                texRMSlot          = shaderPass.PixelShader.ShaderResourceViewMapping.TryGetBindSlot(DefaultBufferNames.RMMapTB);
                texAOSlot          = shaderPass.PixelShader.ShaderResourceViewMapping.TryGetBindSlot(DefaultBufferNames.AOMapTB);
                texShadowSlot      = shaderPass.PixelShader.ShaderResourceViewMapping.TryGetBindSlot(DefaultBufferNames.ShadowMapTB);
                texIrradianceSlot  = shaderPass.PixelShader.ShaderResourceViewMapping.TryGetBindSlot(DefaultBufferNames.IrradianceMap);
                texSSAOSlot        = shaderPass.PixelShader.ShaderResourceViewMapping.TryGetBindSlot(DefaultBufferNames.SSAOMapTB);
                texEnvironmentSlot = shaderPass.PixelShader.ShaderResourceViewMapping.TryGetBindSlot(DefaultBufferNames.CubeMapTB);
                samplerSurfaceSlot = shaderPass.PixelShader.SamplerMapping.TryGetBindSlot(DefaultSamplerStateNames.SurfaceSampler);
                samplerIBLSlot     = shaderPass.PixelShader.SamplerMapping.TryGetBindSlot(DefaultSamplerStateNames.IBLSampler);
                samplerShadowSlot  = shaderPass.PixelShader.SamplerMapping.TryGetBindSlot(DefaultSamplerStateNames.ShadowMapSampler);

                if (!shaderPass.DomainShader.IsNULL && material.EnableTessellation)
                {
                    texDisplaceSlot     = shaderPass.DomainShader.ShaderResourceViewMapping.TryGetBindSlot(DefaultBufferNames.DisplacementMapTB);
                    samplerDisplaceSlot = shaderPass.DomainShader.SamplerMapping.TryGetBindSlot(DefaultSamplerStateNames.DisplacementMapSampler);
                }
                else
                {
                    texDisplaceSlot     = shaderPass.VertexShader.ShaderResourceViewMapping.TryGetBindSlot(DefaultBufferNames.DisplacementMapTB);
                    samplerDisplaceSlot = shaderPass.VertexShader.SamplerMapping.TryGetBindSlot(DefaultSamplerStateNames.DisplacementMapSampler);
                }
            }
Пример #9
0
        internal ShaderPassCollection(DeviceContext context, Shader shader, ShaderTechnique technique)
        {
            _passes = new ShaderPass[technique.PassCount];

            for (int i = 0; i < _passes.Length; i++)
                _passes[i] = new ShaderPass(context, shader, shader.Effect.GetPass(technique.Handle, i), i);
        }
        protected override void OnRender(RenderContext context, DeviceContextProxy deviceContext)
        {
            ShaderPass pass = MaterialVariables.GetPass(RenderType, context);

            if (pass.IsNULL)
            {
                return;
            }
            MaterialVariables.UpdateMaterialStruct(deviceContext, ref modelStruct);
            pass.BindShader(deviceContext);
            pass.BindStates(deviceContext, DefaultStateBinding);
            if (!materialVariables.BindMaterial(context, deviceContext, pass))
            {
                return;
            }

            DynamicReflector?.BindCubeMap(deviceContext);
            DrawIndexed(deviceContext, GeometryBuffer.IndexBuffer, InstanceBuffer);
            DynamicReflector?.UnBindCubeMap(deviceContext);
            if (RenderWireframe && !WireframePass.IsNULL)
            {
                if (RenderType == RenderType.Transparent && context.IsOITPass)
                {
                    pass = WireframeOITPass;
                }
                else
                {
                    pass = WireframePass;
                }
                pass.BindShader(deviceContext, false);
                pass.BindStates(deviceContext, DefaultStateBinding);
                deviceContext.SetRasterState(RasterStateWireframe);
                DrawIndexed(deviceContext, GeometryBuffer.IndexBuffer, InstanceBuffer);
            }
        }
            public GenericMaterialVariable(IEffectsManager manager, IRenderTechnique technique,
                                           GenericMaterialCore materialCore, ConstantBufferDescription constantBufferDescription,
                                           string materialShaderPassName = DefaultPassNames.Default,
                                           string shadowShaderPassName   = DefaultPassNames.ShadowPass,
                                           string wireframePassName      = DefaultPassNames.Wireframe,
                                           string depthPassName          = DefaultPassNames.DepthPrepass)
                : base(manager, technique, constantBufferDescription, materialCore)
            {
                this.materialCore = materialCore;
                materialPass      = technique[materialShaderPassName];
                shadowPass        = technique[shadowShaderPassName];
                wireframePass     = technique[wireframePassName];
                depthPass         = technique[depthPassName];
                shaderResources   = new KeyValuePair <int, ShaderResourceViewProxy> [materialPass.PixelShader.ShaderResourceViewMapping.Count];

                for (var i = 0; i < materialPass.PixelShader.ShaderResourceViewMapping.Count; ++i)
                {
                    var mapping = materialPass.PixelShader.ShaderResourceViewMapping.Mappings[i];
                    resourceIdxDict.Add(mapping.Value.Description.Name, i);
                    shaderResources[i] = new KeyValuePair <int, ShaderResourceViewProxy>(mapping.Key, null);
                }

                samplerResources = new KeyValuePair <int, SamplerStateProxy> [materialPass.PixelShader.SamplerMapping.Count];

                for (var i = 0; i < materialPass.PixelShader.SamplerMapping.Count; ++i)
                {
                    var mapping = materialPass.PixelShader.SamplerMapping.Mappings[i];
                    samplerIdxDict.Add(mapping.Value.Name, i);
                    samplerResources[i] = new KeyValuePair <int, SamplerStateProxy>(mapping.Key, null);
                }


                materialCore.UpdatingResource += MaterialCore_UpdatingResource;
            }
Пример #12
0
 protected override bool OnAttach(IRenderTechnique technique)
 {
     DefaultShaderPass = technique[DefaultPassNames.Default];
     samplerSlot       = DefaultShaderPass.PixelShader.SamplerMapping.TryGetBindSlot(DefaultSamplerStateNames.ShadowMapSampler);
     shadowMapSlot     = DefaultShaderPass.PixelShader.ShaderResourceViewMapping.TryGetBindSlot(DefaultBufferNames.ShadowMapTB);
     shadowSampler     = Collect(technique.EffectsManager.StateManager.Register(DefaultSamplers.ShadowSampler));
     return(true);
 }
Пример #13
0
 /// <summary>
 /// Initializes a new instance of the <see cref="PassOnlyMaterialVariable"/> class.
 /// </summary>
 /// <param name="passName">Name of the pass.</param>
 /// <param name="technique">The technique.</param>
 /// <param name="shadowPassName">Name of the shadow pass.</param>
 /// <param name="wireframePassName">Name of the wireframe pass.</param>
 public PassOnlyMaterialVariable(string passName, IRenderTechnique technique, string shadowPassName = DefaultPassNames.ShadowPass, string wireframePassName = DefaultPassNames.Wireframe)
     : base(technique.EffectsManager, technique, DefaultMeshConstantBufferDesc, null)
 {
     this.passName = passName;
     MaterialPass  = technique[passName];
     ShadowPass    = technique[shadowPassName];
     WireframePass = technique[wireframePassName];
 }
Пример #14
0
 protected override bool OnAttach(IRenderTechnique technique)
 {
     buffer          = Collect(new VolumeCubeBufferModel());
     buffer.Geometry = BoxMesh;
     buffer.Topology = PrimitiveTopology.TriangleList;
     cubeBackPass    = technique[DefaultPassNames.Backface];
     return(true);
 }
Пример #15
0
 protected override bool OnAttach(IRenderTechnique technique)
 {
     spritePass  = technique[DefaultPassNames.Default];
     texSlot     = spritePass.PixelShader.ShaderResourceViewMapping.TryGetBindSlot(DefaultBufferNames.SpriteTB);
     samplerSlot = spritePass.PixelShader.SamplerMapping.TryGetBindSlot(DefaultSamplerStateNames.SpriteSampler);
     sampler     = Collect(EffectTechnique.EffectsManager.StateManager.Register(DefaultSamplers.PointSamplerWrap));
     return(true);
 }
Пример #16
0
 /// <summary>
 /// Initializes a new instance of the <see cref="LineMaterialVariable"/> class.
 /// </summary>
 /// <param name="manager">The manager.</param>
 /// <param name="technique">The technique.</param>
 /// <param name="materialCore">The material core.</param>
 /// <param name="linePassName">Name of the line pass.</param>
 /// <param name="shadowPassName">Name of the shadow pass.</param>
 public LineMaterialVariable(IEffectsManager manager, IRenderTechnique technique, LineMaterialCore materialCore,
                             string linePassName = DefaultPassNames.Default, string shadowPassName = DefaultPassNames.ShadowPass)
     : base(manager, technique, DefaultPointLineConstantBufferDesc, materialCore)
 {
     LinePass      = technique[linePassName];
     ShadowPass    = technique[shadowPassName];
     this.material = materialCore;
 }
Пример #17
0
        ActiveFields GetActiveFieldsFromMasterNode(ToonMasterNode masterNode, ShaderPass pass)
        {
            var activeFields     = new ActiveFields();
            var baseActiveFields = activeFields.baseInstance;

            // Graph Vertex
            if (masterNode.IsSlotConnected(ToonMasterNode.PositionSlotId) ||
                masterNode.IsSlotConnected(ToonMasterNode.VertNormalSlotId) ||
                masterNode.IsSlotConnected(ToonMasterNode.VertTangentSlotId) ||
                masterNode.IsSlotConnected(ToonMasterNode.OutlineWidthSlotId)
                )
            {
                baseActiveFields.Add("features.graphVertex");
            }

            // Graph Pixel (always enabled)
            baseActiveFields.Add("features.graphPixel");

            if (masterNode.IsSlotConnected(ToonMasterNode.AlphaThresholdSlotId) ||
                masterNode.GetInputSlots <Vector1MaterialSlot> ().First(x => x.id == ToonMasterNode.AlphaThresholdSlotId).value > 0.0f)
            {
                baseActiveFields.Add("AlphaClip");
            }

            if (masterNode.model == ToonMasterNode.Model.Specular)
            {
                baseActiveFields.Add("SpecularSetup");
            }

            if (masterNode.IsSlotConnected(ToonMasterNode.NormalSlotId))
            {
                baseActiveFields.Add("Normal");
            }

            // Keywords for transparent
            // #pragma shader_feature _SURFACE_TYPE_TRANSPARENT
            if (masterNode.surfaceType != SurfaceType.Opaque)
            {
                // transparent-only defines
                baseActiveFields.Add("SurfaceType.Transparent");

                // #pragma shader_feature _ _BLENDMODE_ALPHA _BLENDMODE_ADD _BLENDMODE_PRE_MULTIPLY
                if (masterNode.alphaMode == AlphaMode.Alpha)
                {
                    baseActiveFields.Add("BlendMode.Alpha");
                }
                else if (masterNode.alphaMode == AlphaMode.Additive)
                {
                    baseActiveFields.Add("BlendMode.Add");
                }
                else if (masterNode.alphaMode == AlphaMode.Premultiply)
                {
                    baseActiveFields.Add("BlendMode.Premultiply");
                }
            }

            return(activeFields);
        }
Пример #18
0
 protected override bool OnAttach(IRenderTechnique technique)
 {
     FXAAPass    = technique[DefaultPassNames.FXAAPass];
     LUMAPass    = technique[DefaultPassNames.LumaPass];
     textureSlot = FXAAPass.PixelShader.ShaderResourceViewMapping.TryGetBindSlot(DefaultBufferNames.DiffuseMapTB);
     samplerSlot = FXAAPass.PixelShader.SamplerMapping.TryGetBindSlot(DefaultSamplerStateNames.SurfaceSampler);
     sampler     = Collect(technique.EffectsManager.StateManager.Register(DefaultSamplers.LinearSamplerClampAni1));
     return(true);
 }
Пример #19
0
 /// <summary>
 /// Initializes a new instance of the <see cref="PointMaterialVariable"/> class.
 /// </summary>
 /// <param name="manager">The manager.</param>
 /// <param name="technique">The technique.</param>
 /// <param name="materialCore">The material core.</param>
 /// <param name="defaultPassName">Default pass name</param>
 public PointMaterialVariable(IEffectsManager manager, IRenderTechnique technique, PointMaterialCore materialCore,
                              string defaultPassName = DefaultPassNames.Default)
     : base(manager, technique, DefaultPointLineConstantBufferDesc, materialCore)
 {
     PointPass     = technique[defaultPassName];
     ShadowPass    = technique[DefaultPassNames.ShadowPass];
     DepthPass     = technique[DefaultPassNames.DepthPrepass];
     this.material = materialCore;
 }
Пример #20
0
        internal ShaderPassCollection(DeviceContext context, Shader shader, ShaderTechnique technique)
        {
            _passes = new ShaderPass[technique.PassCount];

            for (int i = 0; i < _passes.Length; i++)
            {
                _passes[i] = new ShaderPass(context, shader, shader.Effect.GetPass(technique.Handle, i), i);
            }
        }
 /// <summary>
 /// Called when [attach].
 /// </summary>
 /// <param name="technique">The technique.</param>
 /// <returns></returns>
 protected override bool OnAttach(IRenderTechnique technique)
 {
     DefaultShaderPass = technique.EffectsManager[DefaultRenderTechniqueNames.ScreenDuplication][DefaultPassNames.Default];
     CursorShaderPass  = technique.EffectsManager[DefaultRenderTechniqueNames.ScreenDuplication][DefaultPassNames.ScreenQuad];
     textureBindSlot   = DefaultShaderPass.PixelShader.ShaderResourceViewMapping.TryGetBindSlot(DefaultBufferNames.DiffuseMapTB);
     samplerBindSlot   = DefaultShaderPass.PixelShader.SamplerMapping.TryGetBindSlot(DefaultSamplerStateNames.SurfaceSampler);
     textureSampler    = technique.EffectsManager.StateManager.Register(DefaultSamplers.ScreenDupSampler);
     return(Initialize(technique.EffectsManager));
 }
Пример #22
0
        private static bool GenerateShaderPass(CustomMasterNode masterNode, ShaderPass pass, GenerationMode mode, ShaderGenerator result, List <string> sourceAssetDependencyPaths)
        {
            // UniversalShaderGraphUtilities.SetRenderState(masterNode.SurfaceType, masterNode.AlphaMode, masterNode.TwoSided.isOn, ref pass);

            var activeFields = GetActiveFieldsFromMasterNode(masterNode, pass);

            return(ShaderGraph.GenerationUtils.GenerateShaderPass(masterNode, pass, mode, activeFields, result, sourceAssetDependencyPaths,
                                                                  UniversalShaderGraphResources.s_Dependencies, UniversalShaderGraphResources.s_ResourceClassName, UniversalShaderGraphResources.s_AssemblyName));
        }
Пример #23
0
 protected override bool OnAttach(IRenderTechnique technique)
 {
     pass        = technique[passName];
     textureSlot = pass.PixelShader.ShaderResourceViewMapping.TryGetBindSlot(DefaultBufferNames.DiffuseMapTB);
     samplerSlot = pass.PixelShader.SamplerMapping.TryGetBindSlot(DefaultSamplerStateNames.SurfaceSampler);
     UpdateTexture(texture);
     UpdateSampler();
     return(true);
 }
Пример #24
0
 public override void GeneratePasses(ShaderGenerationContext context, out ShaderPass mainPass, out List <ShaderPass> additionalPasses)
 {
     mainPass         = new ShaderPassLitForward();
     additionalPasses = new List <ShaderPass>()
     {
         new ShaderPassShadow(),
         new ShaderPassDepthOnly(),
         new ShaderPassLitMeta(),
     };
 }
 protected override bool OnAttach(IRenderTechnique technique)
 {
     screenQuadPass = technique[DefaultPassNames.Default];
     colorTexIndex  = screenQuadPass.PixelShader.ShaderResourceViewMapping.TryGetBindSlot(DefaultBufferNames.OITColorTB);
     alphaTexIndex  = screenQuadPass.PixelShader.ShaderResourceViewMapping.TryGetBindSlot(DefaultBufferNames.OITAlphaTB);
     samplerIndex   = screenQuadPass.PixelShader.SamplerMapping.TryGetBindSlot(DefaultSamplerStateNames.SurfaceSampler);
     targetSampler  = technique.EffectsManager.StateManager.Register(DefaultSamplers.LinearSamplerWrapAni1);
     RenderCount    = 0;
     return(true);
 }
 public VolumeMaterialVariable(IEffectsManager manager, IRenderTechnique technique, VolumeTextureMaterialCoreBase <T> material,
                               string volumePassName = DefaultPassNames.Default)
     : base(manager, technique, DefaultVolumeConstantBufferDesc, material)
 {
     this.material = material;
     volumePass    = technique[volumePassName];
     texSlot       = volumePass.PixelShader.ShaderResourceViewMapping.TryGetBindSlot(DefaultBufferNames.VolumeTB);
     gradientSlot  = volumePass.PixelShader.ShaderResourceViewMapping.TryGetBindSlot(DefaultBufferNames.ColorStripe1DXTB);
     samplerSlot   = volumePass.PixelShader.SamplerMapping.TryGetBindSlot(DefaultSamplerStateNames.VolumeSampler);
 }
        bool GenerateShaderPass(ToonMasterNode masterNode, ShaderPass pass, GenerationMode mode, ShaderGenerator result, List <string> sourceAssetDependencyPaths)
        {
            UniversalShaderGraphUtilities.SetRenderState(masterNode.surfaceType, masterNode.alphaMode, masterNode.twoSided.isOn, ref pass);

            // apply master node options to active fields
            var activeFields = GetActiveFieldsFromMasterNode(masterNode, pass);

            return(ShaderGraph.GenerationUtils.GenerateShaderPass(masterNode, pass, mode, activeFields, result, sourceAssetDependencyPaths,
                                                                  UniversalShaderGraphResources.s_Dependencies, UniversalShaderGraphResources.s_ResourceClassName, UniversalShaderGraphResources.s_AssemblyName));
        }
Пример #28
0
 void Start()
 {
     radiusDelta = radius;
     meshFilter  = GetComponentInChildren <MeshFilter>();
     shaderPass  = GetComponentInChildren <ShaderPass>();
     // shaderPass.Print(colorTexture as Texture2D);
     positionTexture = new Texture2D(width, height, TextureFormat.RGBAFloat, false);
     BakeBackground();
     BakePosition();
 }
Пример #29
0
 /// <summary>
 /// Initializes a new instance of the <see cref="PostEffectMeshOutlineBlurCore"/> class.
 /// </summary>
 public PostEffectBlurCore(ShaderPass blurVerticalPass, ShaderPass blurHorizontalPass, int textureSlot, int samplerSlot,
                           SamplerStateDescription sampler, IEffectsManager manager)
 {
     screenBlurPassVertical   = blurVerticalPass;
     screenBlurPassHorizontal = blurHorizontalPass;
     this.textureSlot         = textureSlot;
     this.samplerSlot         = samplerSlot;
     this.sampler             = manager.StateManager.Register(sampler);
     modelCB = new ConstantBufferComponent(new ConstantBufferDescription(DefaultBufferNames.BorderEffectCB, BorderEffectStruct.SizeInBytes));
 }
            protected override void OnInitialPropertyBindings()
            {
                AddPropertyBinding(nameof(PBRMaterialCore.AlbedoColor), () => { WriteValue(PhongPBRMaterialStruct.DiffuseStr, material.AlbedoColor); });
                AddPropertyBinding(nameof(PBRMaterialCore.EmissiveColor), () => { WriteValue(PhongPBRMaterialStruct.EmissiveStr, material.EmissiveColor); });
                AddPropertyBinding(nameof(PBRMaterialCore.MetallicFactor), () => { WriteValue(PhongPBRMaterialStruct.ConstantMetallic, material.MetallicFactor); });
                AddPropertyBinding(nameof(PBRMaterialCore.RoughnessFactor), () => { WriteValue(PhongPBRMaterialStruct.RoughnessStr, material.RoughnessFactor); });
                AddPropertyBinding(nameof(PBRMaterialCore.AmbientOcclusionFactor), () => { WriteValue(PhongPBRMaterialStruct.AmbientOcclusionStr, material.AmbientOcclusionFactor); });
                AddPropertyBinding(nameof(PBRMaterialCore.ReflectanceFactor), () => { WriteValue(PhongPBRMaterialStruct.ReflectanceStr, material.ReflectanceFactor); });

                AddPropertyBinding(nameof(PBRMaterialCore.ClearCoatStrength), () => { WriteValue(PhongPBRMaterialStruct.ClearCoatStr, material.ClearCoatStrength); });

                AddPropertyBinding(nameof(PBRMaterialCore.ClearCoatRoughness), () => { WriteValue(PhongPBRMaterialStruct.ClearCoatRoughnessStr, material.ClearCoatRoughness); });

                AddPropertyBinding(nameof(PBRMaterialCore.RenderAlbedoMap), () => { WriteValue(PhongPBRMaterialStruct.HasDiffuseMapStr, material.RenderAlbedoMap && TextureResources[AlbedoMapIdx] != null ? 1 : 0); });
                AddPropertyBinding(nameof(PBRMaterialCore.RenderEmissiveMap), () => { WriteValue(PhongPBRMaterialStruct.HasEmissiveMapStr, material.RenderEmissiveMap && TextureResources[EmissiveMapIdx] != null ? 1 : 0); });
                AddPropertyBinding(nameof(PBRMaterialCore.RenderNormalMap), () => { WriteValue(PhongPBRMaterialStruct.HasNormalMapStr, material.RenderNormalMap && TextureResources[NormalMapIdx] != null ? 1 : 0); });
                AddPropertyBinding(nameof(PBRMaterialCore.RenderDisplacementMap), () => { WriteValue(PhongPBRMaterialStruct.HasDisplacementMapStr, material.RenderDisplacementMap && TextureResources[DisplaceMapIdx] != null ? 1 : 0); });
                AddPropertyBinding(nameof(PBRMaterialCore.RenderIrradianceMap), () => { WriteValue(PhongPBRMaterialStruct.HasIrradianceMapStr, material.RenderIrradianceMap && TextureResources[IrradianceMapIdx] != null ? 1 : 0); });
                AddPropertyBinding(nameof(PBRMaterialCore.RenderRoughnessMetallicMap), () => { WriteValue(PhongPBRMaterialStruct.HasRMMapStr, material.RenderRoughnessMetallicMap && TextureResources[RMMapIdx] != null ? 1 : 0); });
                AddPropertyBinding(nameof(PBRMaterialCore.RenderAmbientOcclusionMap), () => { WriteValue(PhongPBRMaterialStruct.HasAOMapStr, material.RenderAmbientOcclusionMap && TextureResources[AOMapIdx] != null ? 1 : 0); });
                AddPropertyBinding(nameof(PBRMaterialCore.EnableAutoTangent), () => { WriteValue(PhongPBRMaterialStruct.EnableAutoTangent, material.EnableAutoTangent); });
                AddPropertyBinding(nameof(PBRMaterialCore.DisplacementMapScaleMask), () => { WriteValue(PhongPBRMaterialStruct.DisplacementMapScaleMaskStr, material.DisplacementMapScaleMask); });
                AddPropertyBinding(nameof(PBRMaterialCore.RenderShadowMap), () => { WriteValue(PhongPBRMaterialStruct.RenderShadowMapStr, material.RenderShadowMap ? 1 : 0); });
                AddPropertyBinding(nameof(PBRMaterialCore.RenderEnvironmentMap), () => { WriteValue(PhongPBRMaterialStruct.HasCubeMapStr, material.RenderEnvironmentMap ? 1 : 0); });
                AddPropertyBinding(nameof(PBRMaterialCore.MaxTessellationDistance), () => { WriteValue(PhongPBRMaterialStruct.MaxTessDistanceStr, material.MaxTessellationDistance); });
                AddPropertyBinding(nameof(PBRMaterialCore.MinTessellationDistance), () => { WriteValue(PhongPBRMaterialStruct.MinTessDistanceStr, material.MinTessellationDistance); });
                AddPropertyBinding(nameof(PBRMaterialCore.MaxDistanceTessellationFactor), () => { WriteValue(PhongPBRMaterialStruct.MaxDistTessFactorStr, material.MaxDistanceTessellationFactor); });
                AddPropertyBinding(nameof(PBRMaterialCore.MinDistanceTessellationFactor), () => { WriteValue(PhongPBRMaterialStruct.MinDistTessFactorStr, material.MinDistanceTessellationFactor); });
                AddPropertyBinding(nameof(PBRMaterialCore.UVTransform), () =>
                {
                    Matrix m = material.UVTransform;
                    WriteValue(PhongPBRMaterialStruct.UVTransformR1Str, m.Column1);
                    WriteValue(PhongPBRMaterialStruct.UVTransformR2Str, m.Column2);
                });
                AddPropertyBinding(nameof(PBRMaterialCore.AlbedoMap), () => { CreateTextureView(material.AlbedoMap, AlbedoMapIdx); TriggerPropertyAction(nameof(PBRMaterialCore.RenderAlbedoMap)); });
                AddPropertyBinding(nameof(PBRMaterialCore.EmissiveMap), () => { CreateTextureView(material.EmissiveMap, EmissiveMapIdx); TriggerPropertyAction(nameof(PBRMaterialCore.RenderEmissiveMap)); });
                AddPropertyBinding(nameof(PBRMaterialCore.NormalMap), () => { CreateTextureView(material.NormalMap, NormalMapIdx); TriggerPropertyAction(nameof(PBRMaterialCore.RenderNormalMap)); });
                AddPropertyBinding(nameof(PBRMaterialCore.IrradianceMap), () => { CreateTextureView(material.IrradianceMap, IrradianceMapIdx); TriggerPropertyAction(nameof(PBRMaterialCore.RenderIrradianceMap)); });
                AddPropertyBinding(nameof(PBRMaterialCore.DisplacementMap), () => { CreateTextureView(material.DisplacementMap, DisplaceMapIdx); TriggerPropertyAction(nameof(PBRMaterialCore.RenderDisplacementMap)); });
                AddPropertyBinding(nameof(PBRMaterialCore.RoughnessMetallicMap), () => { CreateTextureView(material.RoughnessMetallicMap, RMMapIdx); TriggerPropertyAction(nameof(PBRMaterialCore.RenderRoughnessMetallicMap)); });
                AddPropertyBinding(nameof(PBRMaterialCore.AmbientOcculsionMap), () => { CreateTextureView(material.AmbientOcculsionMap, AOMapIdx); TriggerPropertyAction(nameof(PBRMaterialCore.RenderAmbientOcclusionMap)); });
                AddPropertyBinding(nameof(PBRMaterialCore.SurfaceMapSampler), () => { CreateSampler(material.SurfaceMapSampler, SurfaceSamplerIdx); });
                AddPropertyBinding(nameof(PBRMaterialCore.IBLSampler), () => { CreateSampler(material.IBLSampler, IBLSamplerIdx); });
                AddPropertyBinding(nameof(PBRMaterialCore.DisplacementMapSampler), () => { CreateSampler(material.DisplacementMapSampler, DisplaceSamplerIdx); });
                AddPropertyBinding(nameof(PBRMaterialCore.EnableTessellation), () =>
                {
                    currentMaterialPass = material.EnableTessellation ? TessMaterialPass : MaterialPass;
                    UpdateMappings(MaterialPass);
                    currentMaterialOITPass = material.EnableTessellation ? TessMaterialOITPass : MaterialOITPass;
                });

                WriteValue(PhongPBRMaterialStruct.RenderPBR, true); // Make sure to set this flag
                AddPropertyBinding(nameof(PBRMaterialCore.EnableFlatShading), () => { WriteValue(PhongPBRMaterialStruct.RenderFlat, material.EnableFlatShading); });
                AddPropertyBinding(nameof(PBRMaterialCore.VertexColorBlendingFactor), () => { WriteValue(PhongPBRMaterialStruct.VertColorBlending, material.VertexColorBlendingFactor); });
            }
Пример #31
0
        private static bool GenerateShaderPass(SpriteLitMasterNode masterNode, ShaderPass pass, GenerationMode mode, ShaderGenerator result, List <string> sourceAssetDependencyPaths)
        {
            UniversalShaderGraphUtilities.SetRenderState(SurfaceType.Transparent, AlphaMode.Alpha, true, ref pass);

            // apply master node options to active fields
            var activeFields = GetActiveFieldsFromMasterNode(masterNode, pass);

            // use standard shader pass generation
            return(ShaderGraph.GenerationUtils.GenerateShaderPass(masterNode, pass, mode, activeFields, result, sourceAssetDependencyPaths,
                                                                  UniversalShaderGraphResources.s_Dependencies, UniversalShaderGraphResources.s_ResourceClassName, UniversalShaderGraphResources.s_AssemblyName));
        }
Пример #32
0
	public string GCLighting(ShaderGenerate SG,ShaderPass SP){
		string shaderCode = "";
		string TempStr1;
		string TempStr2;
		string NormalizeNormals = "";
		//if (SG.UsedWorldNormals==false)
		//NormalizeNormals="	s.Normal = normalize(s.Normal);\n";
		string DiffusePart = "";
		string SpecularPart = "";
		string CustomPartD = "";
		string CustomPartS = "";
		string CustomPartA = "";
		string CustomPart = "";
		string Multiplier = "";
		ShaderLayersLightingAll.CodeName="123ASD$#%";
		ShaderLayersLightingAll.NameUnique.Text="LightingAllDiffuse";
		ShaderLayersLightingAll.EndTag.Text="rgba";
		ShaderLayersLightingDiffuse.CodeName="123ASD$#%";
		ShaderLayersLightingDiffuse.NameUnique.Text="LightingDiffuse";
		ShaderLayersLightingDiffuse.EndTag.Text="rgba";
		ShaderLayersLightingSpecular.CodeName="123ASD$#%";
		ShaderLayersLightingSpecular.NameUnique.Text="LightingSpecular";
		ShaderLayersLightingSpecular.EndTag.Text="rgba";
		CustomPartD = GCLayers(SG,"LightingDiffuse",ShaderLayersLightingAll,"c","rgba","",false,true).Replace("123ASD$#%","c");
		CustomPartD += GCLayers(SG,"LightingDiffuse",ShaderLayersLightingDiffuse,"c","rgba","",false,true).Replace("123ASD$#%","c");
		if (SpecularOn.On){
			//ShaderLayersLightingAll.CodeName="spec";
			ShaderLayersLightingSpecular.EndTag.Text="rgb";
			ShaderLayersLightingAll.EndTag.Text="rgb";
			ShaderLayersLightingAll.NameUnique.Text="LightingAllSpecular";
			CustomPartS = GCLayers(SG,"LightingAllSpecular",ShaderLayersLightingAll,"Spec","rgb","",false,true).Replace("123ASD$#%","Spec");
			CustomPartS += GCLayers(SG,"LightingSpecular",ShaderLayersLightingSpecular,"Spec","rgb","",false,true).Replace("123ASD$#%","Spec");
			if (DiffuseLightingType.Type!=5)
			CustomPart = CustomPartD+"\n"+CustomPartS+"\nc.rgb = c.rgb*s.Albedo+Spec;\n";
			else
			CustomPart = CustomPartD+"\n"+CustomPartS+"\n";
		}
		else{
			if (DiffuseLightingType.Type!=5)
			CustomPart = CustomPartD+"\n"+CustomPartS+"\nc.rgb = c.rgb*s.Albedo;\n";
			else
			CustomPart = CustomPartD+"\n"+CustomPartS+"\n\n";
		}
		ShaderLayersLightingAll.NameUnique.Text="LightingDirect";
		ShaderLayersLightingAmbient.EndTag.Text="rgb";
		ShaderLayersLightingAmbient.CodeName="gi.indirect.diffuse";
		ShaderLayersLightingAmbient.NameUnique.Text="LightingIndirect";
		CustomPartA = GCLayers(SG,"LightingIndirect",ShaderLayersLightingAmbient,"gi.indirect.diffuse","rgb","",false,true).Replace("123ASD$#%","gi.indirect.diffuse");
		if ((DiffuseLightingType.Type==0||DiffuseLightingType.Type==4)&&UsesShellLighting(SP))
		{
			DiffusePart = NormalizeNormals;
			if (DiffuseNormals.Get()=="1")
			DiffusePart += "	half NdotL = 1; //Disabled using normals, so just set this to 1.\n";
			else if (DiffuseNormals.Get()=="0")
			DiffusePart += "	half NdotL = max (0, dot (s.Normal, lightDir)); //Calculate the dot of the faces normal and the lights direction. This means a lower number the further the angle of the face is from the light source.\n";
			else
			DiffusePart += "	half NdotL = lerp(max (0, dot (s.Normal, lightDir)),1,"+DiffuseNormals.Get()+"); //Calculate the dot of the faces normal and the lights direction. This means a lower number the further the angle of the face is from the light source. Finally, we blend this with the default value of 1 (Due to no normals being turned up)\n";
			
			DiffusePart += "	half4 c;\n"+
			"	c.rgb = lightColor * atten * NdotL"+Multiplier+"; //Output the final RGB color by multiplying the surfaces color with the light color, then by the distance from the light (or some function of it), and finally by the Dot of the normal and the light direction.\n"+
			"	c.a = s.Alpha; //Set the output alpha to the surface Alpha.\n";
		}			//#ifdef UNITY_GLOBAL_ILLUMINATION_INCLUDED
		if ((DiffuseLightingType.Type==1)&&UsesShellLighting(SP))
		{

			TempStr1 = DiffuseSetting1.Get();
			DiffusePart=NormalizeNormals+
			"	\n"+
			"	half roughness2=("+TempStr1+"*2)*("+TempStr1+"*2);\n"+
			"	half2 AandB = roughness2/(roughness2 + float2(0.33,0.09));//Computing some constants\n"+
			"	half2 oren_nayar = float2(1, 0) + float2(-0.5, 0.45) * AandB;\n"+
			"	\n"+
			"	//Theta and phi\n"+
			"	half2 cos_theta = saturate(float2(dot(s.Normal,lightDir),dot(s.Normal,viewDir)));\n"+
			"	half2 cos_theta2 = cos_theta * cos_theta;\n"+
			"	half sin_theta = sqrt((1-cos_theta2.x)*(1-cos_theta2.y));\n"+
			"	half3 light_plane = normalize(lightDir - cos_theta.x*s.Normal);\n"+
			"	half3 view_plane = normalize(viewDir - cos_theta.y*s.Normal);\n"+
			"	half cos_phi = saturate(dot(light_plane, view_plane));\n"+
			"	 \n"+
			"	//composition\n"+
			"	half diffuse_oren_nayar = cos_phi * sin_theta / max(cos_theta.x, cos_theta.y);\n"+
			"	 \n"+
			"	half diffuse = cos_theta.x * (oren_nayar.x + oren_nayar.y * diffuse_oren_nayar);\n"+
			"	half4 c;\n"+
			"	c.rgb = lightColor.rgb*(max(0,diffuse) * atten"+Multiplier+");\n"+
			"	c.a = s.Alpha;\n";
		}		
		if (DiffuseLightingType.Type==2&&UsesShellLighting(SP))
		{
			DiffusePart=NormalizeNormals+
			"	half4 c;\n"+
			"	half3 Surf1 = lightColor.rgb * (max(0,dot (s.Normal, lightDir)) * atten"+Multiplier+");//Calculate lighting the standard way (See Diffuse lighting modes comments).\n";


			TempStr1 = DiffuseSetting1.Get();
			TempStr2 = DiffuseSetting2.Get();
			DiffusePart+="	half3 Surf2 = lightColor.rgb * (max(0,dot (-s.Normal, lightDir)* "+TempStr1+"/2.0 + "+TempStr1+"/2.0) * atten"+Multiplier+");//Calculate diffuse lighting with inverted normals while taking the Wrap Amount into consideration.\n"+
			"	c.rgb = Surf1+(Surf2*(0.8-abs(dot(normalize(s.Normal), normalize(lightDir))))*"+TempStr1+" * "+TempStr2+".rgb);//Combine the two lightings together, by adding the standard one with the inverted one.\n"+
			//"	c.rgb = 1-dot(normalize(s.Normal), normalize(lightDir));\n"+
			//"	c.rgb = Surf1+(Surf2*"+TempStr1+" * "+TempStr2+".rgb);\n"+
			"	c.a = s.Alpha;\n";
		}
		if (DiffuseLightingType.Type==5&&UsesShellLighting(SP))
		{
			DiffusePart=NormalizeNormals+
			"	half4 c;\n"+
			"	//Just pass the color and alpha without adding any lighting.\n"+
			"	c.rgb = float3(1,1,1);\n"+
			"	c.a = s.Alpha;\n";
		}	
		if (DiffuseLightingType.Type==3||!UsesShellLighting(SP))
		{
			DiffusePart=NormalizeNormals+
			"	half4 c;\n"+
			"	//Just pass the color and alpha without adding any lighting.\n"+
			"	c.rgb = float3(1,1,1);\n"+
			"	c.a = s.Alpha;\n";
		}		


		if (SpecularOn.On&&UsesShellLighting(SP))
		{
			TempStr1 = SpecularOffset.Get();
			if (TempStr1=="0")
			TempStr1 = "";
			else
			TempStr1 = "+float3(sin((float)"+TempStr1+"),cos((float)"+TempStr1+"),tan((float)"+TempStr1+"))";
			SpecularPart="	float3 Spec;\n";
			if (SpecularLightingType.Type==0)
			{
				SpecularPart+="	half3 h = normalize (lightDir + viewDir"+TempStr1+");	\n"+	
				"	float nh = max (0, dot (s.Normal, h));\n"+
				"	Spec = pow (nh, s.Smoothness*128.0) * s.Specular;\n";
			}		
			if (SpecularLightingType.Type==1)
			{
				SpecularPart+="	Spec = (dot(reflect(-lightDir, s.Normal),viewDir"+TempStr1+"));\n"+	
				"	Spec = pow(max(0.0,Spec),s.Smoothness*128.0) * s.Specular;\n";
			}		
			if (SpecularLightingType.Type==2)
			{
				SpecularPart+="	Spec = abs(dot(s.Normal,reflect(-lightDir, -viewDir"+TempStr1+")));\n"+
				//"Spec = Spec;\n"+
				"	Spec = (half3(1.0f,1.0f,1.0f)-(pow(sqrt(Spec),2 - s.Smoothness)));\n"+
				"	Spec = saturate(Spec)*s.Specular;";
			}					
			SpecularPart+="	Spec = Spec * atten * 2 * lightColor.rgb;\n";

			//TempStr1 = SpecularColor.Get();				
			//SpecularPart+="	Spec = Spec * "+TempStr1+".rgb;\n";
			if (SpecularEnergy.On==true)
			SpecularPart+="	Spec = Spec * ((((s.Smoothness*128.0f)+9.0f)/("+(9.0f*3.14f).ToString()+"))/9.0f);\n";
			//SpecularPart+="	c.rgb+=Spec;\n";
		}
		bool U4 = false;
		#if PRE_UNITY_5
		U4 = true;
		#endif
		if (!(GCLightingName(SP)=="CLPBR_Standard"&&U4)){
			shaderCode+="//Generate simpler lighting code:\n"+
			"half4 Lighting"+GCLightingName(SP)+" (CSurfaceOutput s, half3 lightDir, half3 viewDir, half atten) {\n";
			shaderCode+="	half3 SSlightColor = _LightColor0.rgb;\n";
			shaderCode+="	half3 lightColor = _LightColor0.rgb;\n";
			shaderCode+="	half3 SSnormal = s.Normal;\n"+
			"	half3 SSalbedo = s.Albedo;\n"+
			"	half3 SSspecular = s.Specular;\n"+
			"	half3 SSemission = s.Emission;\n"+
			"	half SSalpha = s.Alpha;\n";
			
			foreach(ShaderLayerList SLL in ShaderLayersMasks)
			{
				if (SG.UsedMasks[SLL]>0&&SLL.IsLighting.On){
					shaderCode+=SLL.GCVariable();
					shaderCode+=GCLayers(SG,SLL.Name.Text,SLL,SLL.CodeName,SLL.EndTag.Text,SLL.Function,false,true);
				}
			}
			shaderCode+=DiffusePart;
			shaderCode+=SpecularPart;
			shaderCode+=CustomPart;
			shaderCode += "	\n"+
			"	return c;\n"+
			"}\n";
		}
		shaderCode+="#ifdef UNITY_GLOBAL_ILLUMINATION_INCLUDED\n";
			if (!U4)
			shaderCode+="#include \"UnityPBSLighting.cginc\" //Include some PBS stuff.\n";
		if (SG.GI&&GCLightingName(SP)!="CLUnlit"&&GCLightingName(SP)!="CLPBR_Standard"){
			shaderCode+="//Generate lighting code for each GI part:\n"+
			"half4 Lighting"+GCLightingName(SP)+"Light (CSurfaceOutput s, half3 viewDir, UnityLight light) {\n";
			shaderCode+="	half3 SSlightColor = _LightColor0;\n"+
			"	half3 lightColor = _LightColor0;\n"+
			"	half3 lightDir = light.dir;\n"+
			"	half3 atten = light.color/_LightColor0;\n"+
			"	half3 SSnormal = s.Normal;\n"+
			"	half3 SSalbedo = s.Albedo;\n"+
			"	half3 SSspecular = s.Specular;\n"+
			"	half3 SSemission = s.Emission;\n"+
			"	half SSalpha = s.Alpha;\n";
			//if (SG.Temp){
				foreach(ShaderLayerList SLL in ShaderLayersMasks)
				{
					if (SG.UsedMasks[SLL]>0&&SLL.IsLighting.On){
						shaderCode+=SLL.GCVariable();
						shaderCode+=GCLayers(SG,SLL.Name.Text,SLL,SLL.CodeName,SLL.EndTag.Text,SLL.Function,false,true);
					}
				}
				shaderCode+=DiffusePart.Replace("* atten","");
				shaderCode+=SpecularPart.Replace("* atten","");
				shaderCode+=CustomPart.Replace("* atten","");
			//}
			/*else{
				shaderCode+=DiffusePart.Replace("* atten * 2","");
				shaderCode+=SpecularPart.Replace("* atten * 2","");
			}*/
			shaderCode += "\n"+
			"	return c;\n"+
			"}";
			shaderCode+="\n"+
			"//Generate some other Lighting code. It calls the previous lighting code a few times for different lights depending on lightmapping modes and other things.\n"+
			"half4 Lighting"+GCLightingName(SP)+" (CSurfaceOutput s, half3 viewDir, UnityGI gi) {\n"+
			"	half4 c;\n"+
			"	c = Lighting"+GCLightingName(SP)+"Light(s,viewDir,gi.light);\n"+
			"	#if defined(DIRLIGHTMAP_SEPARATE)\n"+
			"		#ifdef LIGHTMAP_ON\n"+
			"			c += Lighting"+GCLightingName(SP)+"Light(s,viewDir,gi.light2);\n"+
			"		#endif\n"+
			"		#ifdef DYNAMICLIGHTMAP_ON\n"+
			"			c += Lighting"+GCLightingName(SP)+"Light(s,viewDir,gi.light3);\n"+
			"		#endif\n"+
			"	#endif\n"+
			"	half3 SSlightColor = _LightColor0;\n"+
			"	half3 lightColor = _LightColor0;\n"+
			"	half3 lightDir = gi.light.dir;\n"+
			"	half3 atten = gi.light.color/_LightColor0;\n"+
			"	half3 SSnormal = s.Normal;\n"+
			"	half3 SSalbedo = s.Albedo;\n"+
			"	half3 SSspecular = s.Specular;\n"+
			"	half3 SSemission = s.Emission;\n"+
			"	half SSalpha = s.Alpha;\n";
			
			foreach(ShaderLayerList SLL in ShaderLayersMasks)
			{
				if (SG.UsedMasks[SLL]>0&&SLL.IsLighting.On){
					shaderCode+=SLL.GCVariable();
					shaderCode+=GCLayers(SG,SLL.Name.Text,SLL,SLL.CodeName,SLL.EndTag.Text,SLL.Function,false,true);
				}
			}			
			
			//if (!SG.Temp)
			shaderCode += "\n"+
			"	#ifdef UNITY_LIGHT_FUNCTION_APPLY_INDIRECT\n"+
			CustomPartA+"\n"+
			"		c.rgb += s.Albedo * gi.indirect.diffuse;\n"+
			"	#endif\n";		
			shaderCode+="	return c;\n"+
			"}\n"+
			"";
			
			
			shaderCode+="\n//Some weird Unity stuff for GI calculation (I think?).\n"+
			"inline void Lighting"+GCLightingName(SP)+"_GI (CSurfaceOutput s,UnityGIInput data,inout UnityGI gi){\n";
			if (SpecularOn.On){
				shaderCode+="#if UNITY_VERSION >= 520\n"+
							"	UNITY_GI(gi, s, data);\n"+
							"#else\n"+
							"	gi = UnityGlobalIllumination (data, 1.0, s.Smoothness, s.Normal,false);\n"+
							"#endif\n";
							//"}\n";
				
				
				
				//"	gi = UnityGlobalIllumination (data, 1.0, s.Smoothness, s.Normal, false);";
			}
			else{
				shaderCode+="#if UNITY_VERSION >= 520\n"+
							"	UNITY_GI(gi, s, data);\n"+
							"#else\n"+
							"	gi = UnityGlobalIllumination (data, 1.0, 0.0, s.Normal,false);\n"+
							"#endif\n";
							//"}\n";
				
				
				//"	gi = UnityGlobalIllumination (data, 1.0, 0.0, s.Normal, false);";
			}
			shaderCode+="\n"+
			"}\n";
		}
		else
		if (GCLightingName(SP)=="CLPBR_Standard"){

			ShaderLayersLightingAll.CodeName="123ASD$#%";
			ShaderLayersLightingAll.EndTag.Text="rgb";
			ShaderLayersLightingAll.NameUnique.Text="LightingSpecular";
			ShaderLayersLightingDiffuse.CodeName="123ASD$#%";
			ShaderLayersLightingDiffuse.EndTag.Text="rgb";
			ShaderLayersLightingSpecular.CodeName="123ASD$#%";
			ShaderLayersLightingSpecular.EndTag.Text="rgb";
			ShaderLayersLightingAmbient.CodeName="123ASD$#%";
			ShaderLayersLightingAmbient.EndTag.Text="rgb";
			CustomPartS = GCLayers(SG,"LightingAllSpecular",ShaderLayersLightingAll,"specularColor","rgb","",false,true).Replace("123ASD$#%","specularColor")+GCLayers(SG,"LightingSpecular",ShaderLayersLightingSpecular,"specularColor","rgb","",false,true).Replace("123ASD$#%","specularColor");
			
			ShaderLayersLightingAll.NameUnique.Text="LightingDiffuse";
			CustomPartD = GCLayers(SG,"LightingAllDiffuse",ShaderLayersLightingAll,"lightColor","rgb","",false,true).Replace("123ASD$#%","lightColor")+GCLayers(SG,"LightingDiffuse",ShaderLayersLightingDiffuse,"lightColor","rgb","",false,true).Replace("123ASD$#%","lightColor");
			CustomPartA = GCLayers(SG,"LightingAmbient",ShaderLayersLightingAmbient,"gi.diffuse","rgb","",false,true).Replace("123ASD$#%","gi.diffuse");
			ShaderLayersLightingAll.NameUnique.Text="LightingDirect";
			shaderCode+="//Include a bunch of PBS Code from files UnityPBSLighting.cginc and UnityStandardBRDF.cginc for the purpose of custom lighting effects.\n";
			shaderCode+=@"
half4 BRDF1_Unity_PBSSS (half3 diffColor, half3 specColor, half oneMinusReflectivity, half oneMinusRoughness,
	half3 normal, half3 viewDir,
	UnityLight light, UnityIndirect gi)
{"+
			"\n	half3 SSlightColor = _LightColor0;\n"+
			"	half3 lightDir = light.dir;\n"+
			"	half3 atten = light.color/_LightColor0;\n"+
			"	half3 SSnormal = normal;\n"+
			"	half3 SSalbedo = diffColor;\n"+
			"	half3 SSspecular = specColor;\n"+
			"	half3 SSemission = float3(0,0,0);\n"+
			"	half SSalpha = 1;\n";
	foreach(ShaderLayerList SLL in ShaderLayersMasks)
	{
		if (SG.UsedMasks[SLL]>0&&SLL.IsLighting.On){
			shaderCode+=SLL.GCVariable();
			shaderCode+=GCLayers(SG,SLL.Name.Text,SLL,SLL.CodeName,SLL.EndTag.Text,SLL.Function,false,true);
		}
	}
shaderCode+=@"
	half roughness = 1-oneMinusRoughness;
	half3 halfDir = normalize (light.dir + viewDir);

	half nl = light.ndotl;
	half nh = BlinnTerm (normal, halfDir);
	half nv = DotClamped (normal, viewDir);
	half lv = DotClamped (light.dir, viewDir);
	half lh = DotClamped (light.dir, halfDir);

#if UNITY_BRDF_GGX
	half V = SmithGGXVisibilityTerm (nl, nv, roughness);
	half D = GGXTerm (nh, roughness);
#else
	half V = SmithBeckmannVisibilityTerm (nl, nv, roughness);
	half D = NDFBlinnPhongNormalizedTerm (nh, RoughnessToSpecPower (roughness));
#endif

	half nlPow5 = Pow5 (1-nl);
	half nvPow5 = Pow5 (1-nv);
	half Fd90 = 0.5 + 2 * lh * lh * roughness;
	half disneyDiffuse = (1 + (Fd90-1) * nlPow5) * (1 + (Fd90-1) * nvPow5);
	
	// HACK: theoretically we should divide by Pi diffuseTerm and not multiply specularTerm!
	// BUT 1) that will make shader look significantly darker than Legacy ones
	// and 2) on engine side Non-important lights have to be divided by Pi to in cases when they are injected into ambient SH
	// NOTE: multiplication by Pi is part of single constant together with 1/4 now
";
	if (U4)
	shaderCode+=@"half specularTerm = max(0, (V * D * nl));// Torrance-Sparrow model, Fresnel is applied later (for optimization reasons)";
	else
	shaderCode+=@"half specularTerm = max(0, (V * D * nl) * unity_LightGammaCorrectionConsts_PIDiv4);// Torrance-Sparrow model, Fresnel is applied later (for optimization reasons)";
	
	shaderCode+=@"
	half diffuseTerm = disneyDiffuse * nl;
	
	half grazingTerm = saturate(oneMinusRoughness + (1-oneMinusReflectivity));
	";
	
	if (U4)
	shaderCode+=@"half3 lightColor = (light.color * diffuseTerm);";
	else
	shaderCode+="\n"+CustomPartA+@"
	half3 lightColor = (gi.diffuse + light.color * diffuseTerm);";
	
	shaderCode+=@"
	half3 specularColor = specularTerm*light.color * FresnelTerm (specColor, lh)+(gi.specular * FresnelLerp (specColor, grazingTerm, nv));
"+CustomPartD+"\n"+CustomPartS+@"
    half3 color =	diffColor * lightColor
                    + specularColor;

	return half4(color, 1);
}			
			
// Based on Minimalist CookTorrance BRDF
// Implementation is slightly different from original derivation: http://www.thetenthplanet.de/archives/255
//
// * BlinnPhong as NDF
// * Modified Kelemen and Szirmay-​Kalos for Visibility term
// * Fresnel approximated with 1/LdotH
half4 BRDF2_Unity_PBSSS (half3 diffColor, half3 specColor, half oneMinusReflectivity, half oneMinusRoughness,
	half3 normal, half3 viewDir,
	UnityLight light, UnityIndirect gi)
{
	half3 halfDir = normalize (light.dir + viewDir);"+
			"\n	half3 SSlightColor = _LightColor0;\n"+
			"	half3 lightDir = light.dir;\n"+
			"	half3 atten = light.color/_LightColor0;\n"+
			"	half3 SSnormal = normal;\n"+
			"	half3 SSalbedo = diffColor;\n"+
			"	half3 SSspecular = specColor;\n"+
			"	half3 SSemission = float3(0,0,0);\n"+
			"	half SSalpha = 1;\n";
	foreach(ShaderLayerList SLL in ShaderLayersMasks)
	{
		if (SG.UsedMasks[SLL]>0&&SLL.IsLighting.On){
			shaderCode+=SLL.GCVariable();
			shaderCode+=GCLayers(SG,SLL.Name.Text,SLL,SLL.CodeName,SLL.EndTag.Text,SLL.Function,false,true);
		}
	}
	shaderCode+=@"

	half nl = light.ndotl;
	half nh = BlinnTerm (normal, halfDir);
	half nv = DotClamped (normal, viewDir);
	half lh = DotClamped (light.dir, halfDir);

	half roughness = 1-oneMinusRoughness;
	half specularPower = RoughnessToSpecPower (roughness);
	// Modified with approximate Visibility function that takes roughness into account
	// Original ((n+1)*N.H^n) / (8*Pi * L.H^3) didn't take into account roughness 
	// and produced extremely bright specular at grazing angles

	// HACK: theoretically we should divide by Pi diffuseTerm and not multiply specularTerm!
	// BUT 1) that will make shader look significantly darker than Legacy ones
	// and 2) on engine side Non-important lights have to be divided by Pi to in cases when they are injected into ambient SH
	// NOTE: multiplication by Pi is cancelled with Pi in denominator

	half invV = lh * lh * oneMinusRoughness + roughness * roughness; // approx ModifiedKelemenVisibilityTerm(lh, 1-oneMinusRoughness);
	half invF = lh;
	half specular = ((specularPower + 1) * pow (nh, specularPower)) / (unity_LightGammaCorrectionConsts_8 * invV * invF + 1e-4f); // @TODO: might still need saturate(nl*specular) on Adreno/Mali

	half grazingTerm = saturate(oneMinusRoughness + (1-oneMinusReflectivity));
	
	half3 lightColor = light.color * nl;
	half3 specularColor = specular * specColor * lightColor + gi.specular * FresnelLerpFast (specColor, grazingTerm, nv);
	";
	
	if (!U4)
	shaderCode+="\n"+CustomPartA+@"
	lightColor += gi.diffuse;
	";
	
	shaderCode+=@"
"+CustomPartD+"\n"+CustomPartS+@"
	
	half3 color =	diffColor* lightColor + specularColor;

	return half4(color, 1);
}"+

  /*  half3 color =	diffColor * lightColor
                    + specularColor;
    half3 color =	(diffColor + specular * specColor) * light.color * nl
    				+ gi.diffuse * diffColor
					+ gi.specular * FresnelLerpFast (specColor, grazingTerm, nv);*/
@"

// Old school, not microfacet based Modified Normalized Blinn-Phong BRDF
// Implementation uses Lookup texture for performance
//
// * Normalized BlinnPhong in RDF form
// * Implicit Visibility term
// * No Fresnel term
//
// TODO: specular is too weak in Linear rendering mode
half4 BRDF3_Unity_PBSSS (half3 diffColor, half3 specColor, half oneMinusReflectivity, half oneMinusRoughness,
	half3 normal, half3 viewDir,
	UnityLight light, UnityIndirect gi)
{
	half LUT_RANGE = 16.0; // must match range in NHxRoughness() function in GeneratedTextures.cpp"+
			"\n	half3 SSlightColor = _LightColor0;\n"+
			"	half3 lightDir = light.dir;\n"+
			"	half3 atten = light.color/_LightColor0;\n"+
			"	half3 SSnormal = normal;\n"+
			"	half3 SSalbedo = diffColor;\n"+
			"	half3 SSspecular = specColor;\n"+
			"	half3 SSemission = float3(0,0,0);\n"+
			"	half SSalpha = 1;\n";
	foreach(ShaderLayerList SLL in ShaderLayersMasks)
	{
		if (SG.UsedMasks[SLL]>0&&SLL.IsLighting.On){
			shaderCode+=SLL.GCVariable();
			shaderCode+=GCLayers(SG,SLL.Name.Text,SLL,SLL.CodeName,SLL.EndTag.Text,SLL.Function,false,true);
		}
	}
	shaderCode+=@"

	half3 reflDir = reflect (viewDir, normal);
	half3 halfDir = normalize (light.dir + viewDir);

	half nl = light.ndotl;
	half nh = BlinnTerm (normal, halfDir);
	half nv = DotClamped (normal, viewDir);

	// Vectorize Pow4 to save instructions
	half2 rlPow4AndFresnelTerm = Pow4 (half2(dot(reflDir, light.dir), 1-nv));  // use R.L instead of N.H to save couple of instructions
	half rlPow4 = rlPow4AndFresnelTerm.x; // power exponent must match kHorizontalWarpExp in NHxRoughness() function in GeneratedTextures.cpp
	half fresnelTerm = rlPow4AndFresnelTerm.y;
";
if (U4)
shaderCode+="#if 0 // Lookup texture to save instructions\n";
else
shaderCode+="#if 1 // Lookup texture to save instructions\n";

shaderCode+=@"
	half specular = tex2D(unity_NHxRoughness, half2(rlPow4, 1-oneMinusRoughness)).UNITY_ATTEN_CHANNEL * LUT_RANGE;
#else
	half roughness = 1-oneMinusRoughness;
	half n = RoughnessToSpecPower (roughness) * .25;
	half specular = (n + 2.0) / (2.0 * UNITY_PI * UNITY_PI) * pow(dot(reflDir, light.dir), n) * nl;// / unity_LightGammaCorrectionConsts_PI;
	//half specular = (1.0/(UNITY_PI*roughness*roughness)) * pow(dot(reflDir, light.dir), n) * nl;// / unity_LightGammaCorrectionConsts_PI;
#endif
	half grazingTerm = saturate(oneMinusRoughness + (1-oneMinusReflectivity));

	half3 lightColor = light.color * nl;
	half3 specularColor = specular * specColor * lightColor + gi.specular * lerp (specColor, grazingTerm, fresnelTerm);";
	
	if (!U4)
	shaderCode+="\n"+CustomPartA+"\nlightColor += gi.diffuse;	\n";
	
	shaderCode+=""+CustomPartD+"\n"+CustomPartS+@"
	
    half3 color =	diffColor* lightColor + specularColor;

	return half4(color, 1);
}
#if !defined (UNITY_BRDF_PBSSS) // allow to explicitly override BRDF in custom shader
	#if (SHADER_TARGET < 30) || defined(SHADER_API_PSP2)
		// Fallback to low fidelity one for pre-SM3.0
		#define UNITY_BRDF_PBSSS BRDF3_Unity_PBSSS
	#elif defined(SHADER_API_MOBILE)
		// Somewhat simplified for mobile
		#define UNITY_BRDF_PBSSS BRDF2_Unity_PBSSS
	#else
		// Full quality for SM3+ PC / consoles
		#define UNITY_BRDF_PBSSS BRDF1_Unity_PBSSS
	#endif
#endif";
if (U4)
shaderCode+="\n//Generate lighting code similar to the Unity Standard Shader. Not gonna deny, I have no clue how much of it works.\n"+
			"half4 LightingCLPBR_Standard (CSurfaceOutput s, half3 lightDir, half3 viewDir, half atten) {\n"+@"
	UnityLight l;
	l.color = _LightColor0.rgb*atten;
	/*#ifndef USING_DIRECTIONAL_LIGHT
			lightDir = normalize(_WorldSpaceLightPos0.xyz - s.worldPos);
		#else
			lightDir = _WorldSpaceLightPos0.xyz;
	#endif*/
	l.dir = (lightDir);
	l.ndotl = max (0, dot (s.Normal, l.dir));
	UnityIndirect l2;
	l2.diffuse = s.worldRefl*0.0001;
	float mip = pow(1-s.Smoothness,3.0/4.0) * UNITY_SPECCUBE_LOD_STEPS;
	half4 rgbm = texCUBElod(_Cube, float4(s.worldRefl,mip));
	l2.specular = rgbm;//texCUBELOD(_Cube,s.worldRefl);
	#if !defined(UNITY_PASS_FORWARDBASE)
		l2.specular = float3(0,0,0);
	#endif
	//l2.diffuse = 0;
	half3 lightColor = _LightColor0.rgb;//CSurfaceOutput s, half3 viewDir, UnityGI gi){
	s.Normal = normalize(s.Normal);
	// energy conservation
	half oneMinusReflectivity;
	s.Albedo = EnergyConservationBetweenDiffuseAndSpecular (s.Albedo, s.Specular, /*out*/ oneMinusReflectivity);
	// shader relies on pre-multiply alpha-blend (_SrcBlend = One, _DstBlend = OneMinusSrcAlpha)
	// this is necessary to handle transparency in physically correct way - only diffuse component gets affected by alpha
	half outputAlpha;
	s.Albedo = PreMultiplyAlpha (s.Albedo, s.Alpha, oneMinusReflectivity, /*out*/ outputAlpha);
	half4 c = UNITY_BRDF_PBSSS (s.Albedo, s.Specular, oneMinusReflectivity, s.Smoothness, s.Normal, viewDir, l, l2);
	//c.rgb += UNITY_BRDF_GI (s.Albedo, s.Specular, oneMinusReflectivity, s.Smoothness, s.Normal, viewDir, s.Occlusion, gi);
	c.a = outputAlpha;
	//c.rgb *= s.worldRefl;
	c.rgb+=l2.diffuse;
	return c;
	}
";
else
shaderCode+="\n//Generate lighting code similar to the Unity Standard Shader. Not gonna deny, I have no clue how much of it works.\n"+
			"half4 LightingCLPBR_Standard (CSurfaceOutput s, half3 viewDir, UnityGI gi){\n"+
			"	s.Normal = normalize(s.Normal);\n"+
			"	// energy conservation\n"+
			"	half oneMinusReflectivity;\n"+
			"	s.Albedo = EnergyConservationBetweenDiffuseAndSpecular (s.Albedo, s.Specular, /*out*/ oneMinusReflectivity);\n"+

			"	// shader relies on pre-multiply alpha-blend (_SrcBlend = One, _DstBlend = OneMinusSrcAlpha)\n"+
			"	// this is necessary to handle transparency in physically correct way - only diffuse component gets affected by alpha\n"+
			"	half outputAlpha;\n"+
			"	s.Albedo = PreMultiplyAlpha (s.Albedo, s.Alpha, oneMinusReflectivity, /*out*/ outputAlpha);\n"+

			"	half4 c = UNITY_BRDF_PBSSS (s.Albedo, s.Specular, oneMinusReflectivity, s.Smoothness, s.Normal, viewDir, gi.light, gi.indirect);\n"+
			"	c.rgb += UNITY_BRDF_GI (s.Albedo, s.Specular, oneMinusReflectivity, s.Smoothness, s.Normal, viewDir, s.Occlusion, gi);\n"+
			"	c.a = outputAlpha;\n"+
			"	return c;\n"+
			"}\n";
		if (!U4){
		shaderCode+="\n"+
		"inline void Lighting"+GCLightingName(SP)+"_GI (CSurfaceOutput s,UnityGIInput data,inout UnityGI gi){\n";
			if (SpecularOn.On){
				shaderCode+="#if UNITY_VERSION >= 520\n"+
							"	UNITY_GI(gi, s, data);\n"+
							"#else\n"+
							"	gi = UnityGlobalIllumination (data, 1.0, s.Smoothness, s.Normal);\n"+
							"#endif\n";
							//"}\n";
			}
			else{
				shaderCode+="#if UNITY_VERSION >= 520\n"+
							"	UNITY_GI(gi, s, data);\n"+
							"#else\n"+
							"	gi = UnityGlobalIllumination (data, 1.0, 0.0, s.Normal);\n"+
							"#endif\n";
							//"}\n";
			}
		shaderCode+="\n"+
		"}\n";
		}
		}
		shaderCode+="#endif\n";
		return shaderCode;
	}
Пример #33
0
	public bool UsesShellLighting(ShaderPass SP){
		if (ShaderPassShells(SP)){
			if (ShellsLighting.On)
			return true;
			
			return false;
		}
		return true;
	}
Пример #34
0
	public string GCLabTags(ShaderPass SP)
	{
		string ShaderCode = "";
		ShaderCode += "	blend off //Disabled blending (No Transparency)\n";
		if (!SG.Wireframe){
			if (MiscFog.On==false)
			ShaderCode+="Fog {Mode Off}\n";	
			
			if (TransparencyReceive.On&&TransparencyOn.On)
			ShaderCode+="blend SrcAlpha OneMinusSrcAlpha//Standard Transparency\nZWrite Off\n";
			
			if (ShaderPassShells(SP)&&ShellsBlendMode.Type==1)
			ShaderCode+="blend One One//Add Blend Mode\n";
			if (ShaderPassShells(SP)&&ShellsBlendMode.Type==2)
			ShaderCode+="blend DstColor Zero//Multiply Blend Mode\n";
			
			if (ShaderPassStandard(SP)&&BlendMode.Type==1&&TransparencyType.Type==1&&TransparencyOn.On)
			ShaderCode+="blend One One//Add Blend Mode\n";
			if (ShaderPassStandard(SP)&&BlendMode.Type==2&&TransparencyType.Type==1&&TransparencyOn.On)
			ShaderCode+="blend DstColor Zero//Multiply Blend Mode\n";
		}

		return ShaderCode;
	}
Пример #35
0
	public string GCPass_Real(ShaderGenerate SG,ShaderPass SP,float Dist){
		string ShaderCode = "";
		//SG.Reset();
//		int OldTransType = TransparencyType.Type;
		float OldTransAmount = TransparencyAmount.Float;
		ShaderInput OldTransInput = TransparencyAmount.Input;
		if (TransparencyZWrite.On&&TransparencyZWriteType.Type==1){
			TransparencyAmount.Float = 1f;
			TransparencyAmount.Input = null;
		}
		
		ShaderCode+="	ZWrite On\n";
		if (ShaderPassShells(SP)){
			if (ShellsZWrite.On)
			ShaderCode+="	ZWrite On\n";
			else
			ShaderCode+="	ZWrite Off\n";
		}

			if (TransparencyOn.On&&TransparencyType.Type==1&&TransparencyZWrite.On==false)
			ShaderCode+="	ZWrite Off\n";
			//else
			//ShaderCode+="	ZWrite On\n";

		if (ShaderPassBase(SP)){
			if (ShaderPassShells(SP))
			ShaderCode+="	cull "+ShellsCull.CodeNames[ShellsCull.Type]+"//Culling specifies which sides of the models faces to hide.\n";
			else
			ShaderCode+="	cull "+TechCull.CodeNames[TechCull.Type]+"//Culling specifies which sides of the models faces to hide.\n";
		}
		ShaderCode+=GCLabTags(SP);

		ShaderCode+="	CGPROGRAM\n\n";
		ShaderCode+=GCUniforms(SG);
		ShaderCode+=GCPragma(SG,SP);
		ShaderCode+=GCSurfaceOutput();
		ShaderCode+=GCInputs(SG);
		ShaderCode+=GCFunctions(SG);
		ShaderCode+=GCLighting(SG,SP);
		ShaderCode+=GCVertex(SG,SP,Dist);
		ShaderCode+=GCFragment(SG,SP,Dist);

		ShaderCode+="	ENDCG\n";

		
		if (TransparencyZWrite.On&&TransparencyZWriteType.Type==1){
			TransparencyAmount.Input = OldTransInput;
			TransparencyAmount.Float = OldTransAmount;
		}

		return ShaderCode;
	}
Пример #36
0
	public bool ShaderPassBase(ShaderPass SP){
		if (SP == ShaderPass.Base||SP == ShaderPass.ShellBase||ShaderPassMask(SP))
		return true;
		return false;
	}
Пример #37
0
	public string GCVertex(ShaderGenerate SG, ShaderPass SP, float Dist){
		SG.InVertex = true;
		string shaderCode = "";
		if (Dist>0||ShaderLayersVertex.Count>0||ShellsOn.On||TessellationOn.On)
shaderCode+=@"//Create a struct for the inputs of the vertex shader which includes whatever Shader Sandwich might need.
	struct appdata_min {
	float4 vertex : POSITION;
	float4 tangent : TANGENT;
	float3 normal : NORMAL;
	float4 texcoord : TEXCOORD0;
	float4 texcoord1 : TEXCOORD1;
	#ifdef UNITY_GLOBAL_ILLUMINATION_INCLUDED
	#ifndef U4Imposter
	float4 texcoord2 : TEXCOORD2;
	#endif
	#endif
	fixed4 color : COLOR;
};";
		if (TessellationOn.On){
		if (TessellationType.Type==0){
			shaderCode+=@"		float4 tess (appdata_min v0, appdata_min v1, appdata_min v2)
		{
			return "+TessellationQuality.Get()+@";
		}
";
		}
		if (TessellationType.Type==1){
			shaderCode+=@"		float4 tess (appdata_min v0, appdata_min v1, appdata_min v2)
		{
			float3 pos0 = mul(_Object2World,v0.vertex).xyz;
			float3 pos1 = mul(_Object2World,v1.vertex).xyz;
			float3 pos2 = mul(_Object2World,v2.vertex).xyz;
			float4 tess;
			tess.x = distance(pos1, pos2)*"+TessellationQuality.Get()+@";
			tess.y = distance(pos2, pos0)*"+TessellationQuality.Get()+@";
			tess.z = distance(pos0, pos1)*"+TessellationQuality.Get()+@";
			tess.w = (tess.x + tess.y + tess.z) / 3.0f;
";
			if (TessellationFalloff.Get()!="1")
			shaderCode+="			return pow(tess/50,"+TessellationFalloff.Get()+")*50;\n";
			else
			shaderCode+="			return tess;\n";
			shaderCode+="		}\n";
		}
		if (TessellationType.Type==2){
			shaderCode+=@"		float4 tess (appdata_min v0, appdata_min v1, appdata_min v2)
		{
";
			if (TessellationFalloff.Get()!="1")
			shaderCode+="			return pow(UnityEdgeLengthBasedTess (v0.vertex, v1.vertex, v2.vertex, (51-"+TessellationQuality.Get()+")*2)/50,"+TessellationFalloff.Get()+")*50;\n";
			else
			shaderCode+="			return UnityEdgeLengthBasedTess (v0.vertex, v1.vertex, v2.vertex, (51-"+TessellationQuality.Get()+")*2);\n";
			shaderCode+="		}";
		}
		}
		
		shaderCode+="\n";
		//"void vert (inout appdata_full v, out Input o) {\n"+
		if (Dist>0||ShaderLayersVertex.Count>0||ShellsOn.On||TessellationOn.On){
			shaderCode+="//Generate the vertex shader\n"+
			"void vert (inout appdata_min v) {\n";
			//"	UNITY_INITIALIZE_OUTPUT(Input, o);\n";
			//if (SG.GeneralUV=="Texcoord"&&SG.UsedGenericUV){
			//	shaderCode+="	o.Texcoord = v.texcoord;\n";
			//}
			shaderCode+=GCVertexInternal(SG,SP,Dist);
			shaderCode+="}\n";
		}
		SG.InVertex = false;
		SG.UsedBases.Clear();
		return shaderCode;
	}
Пример #38
0
 internal void addPass(ShaderPass hblur)
 {
     throw new NotImplementedException();
 }
Пример #39
0
	public string GCLightingName(ShaderPass SP){
		if (UsesShellLighting(SP))
		return "CL"+ShaderUtil.CodeName(DiffuseLightingType.Names[DiffuseLightingType.Type]);
		else
		return "CLUnlit";
	}
Пример #40
0
	public string GCPragma(ShaderGenerate SG,ShaderPass SP)
	{
		string shaderCode = "";
		if (ParallaxOn.On)
		shaderCode+="//Set up some Parallax Occlusion Mapping Settings\n#define LINEAR_SEARCH "+(Math.Round(ParallaxBinaryQuality.Float/2)).ToString()+"\n"+
		"#define BINARY_SEARCH "+ParallaxBinaryQuality.Get()+"\n";

			shaderCode+="	#pragma surface frag_surf "+GCLightingName(SP);
			if (ShellsOn.On||ShaderLayersVertex.Count>0||TessellationOn.On)
			shaderCode+=" vertex:vert ";
			if (!TransparencyReceive.On||!TransparencyOn.On)
			shaderCode+=" addshadow ";
			
			if (GCLightingName(SP)=="CLUnlit"){
			#if UNITY_5
			shaderCode+= " noforwardadd noambient novertexlights nolightmap nodynlightmap nodirlightmap";
			#else
			shaderCode+= " noforwardadd noambient novertexlights nolightmap nodirlightmap";
			#endif
			}
			if ((TransparencyType.Type==1&&TransparencyOn.On&&!TransparencyReceive.On&&!(ShaderPassShells(SP)&&ShellsBlendMode.Type!=0)&&!(ShaderPassStandard(SP)&&BlendMode.Type!=0))&&!SG.Wireframe){
				shaderCode+= " alpha";
				#if UNITY_5
				if (GCLightingName(SP)!="CLPBR_Standard"||!TransparencyPBR.On)
				shaderCode+=":fade";
				#endif
			}
			if (TransparencyReceive.On&&TransparencyOn.On)
			shaderCode+=" keepalpha ";
			if (MiscAmbient.On==false)
				shaderCode+=" noambient";
			if (MiscVertexLights.On==false)
				shaderCode+=" novertexlights";
			if (MiscLightmap.On==false){
				#if UNITY_5
				shaderCode+=" nolightmap nodynlightmap nodirlightmap";
				#else
				shaderCode+=" nolightmap nodirlightmap";
				#endif
			}
			if (MiscFullShadows.On)
				shaderCode+=" fullforwardshadows";
			if (MiscHalfView.On)
				shaderCode+=" halfasview";
			if (!MiscForwardAdd.On)
				shaderCode+=" noforwardadd";
			#if UNITY_5
			if (MiscInterpolateView.On)
				shaderCode+=" interpolateview";
			if (!MiscShadows.On)
				shaderCode+=" noshadow";
			#endif
			if (TessellationOn.On){
				shaderCode+=" tessellate:tess";
				if (TessellationSmoothingAmount.Get()!="0"){
					shaderCode+=" tessphong:"+TessellationSmoothingAmount.Get();
				}
			}
			
			shaderCode=" //Set up Unity Surface Shader Settings.\n"+shaderCode+"\n";
		
		shaderCode+="//The Shader Target defines the maximum capabilites of the shader (Number of math operators, texture reads, etc.)\n	#pragma target "+((int)TechShaderTarget.Float).ToString()+".0\n";
		if (TessellationOn.On)
		shaderCode+="#include \"Tessellation.cginc\" //Include some Unity code for tessellation.\n";
		return shaderCode;
	}
Пример #41
0
	public string GCFragmentMask(ShaderGenerate SG, ShaderPass SP,float Depth){
		return " fixed4 frag() : SV_Target {\n"+
			"    return fixed4(1.0,0.0,0.0,1.0);\n"+
			"}\n";
	}
Пример #42
0
	public string GCFragment(ShaderGenerate SG, ShaderPass SP,float Depth){
		string ShaderCode = "";

		ShaderCode+="\n";
		ShaderCode+="//Generate the fragment shader (Operates on pixels)\n";
		ShaderCode+="void frag_surf (Input IN, inout CSurfaceOutput o) {\n";
		
		#if PRE_UNITY_5
		if (DiffuseLightingType.Type==4){
		ShaderCode+=@"	o.worldRefl = IN.worldRefl;
		";
		}
		#endif
if (!SG.Wireframe){
		ShaderCode+="	float SSShellDepth = 1-"+Depth.ToString()+";\n";
		ShaderCode+="	float SSParallaxDepth = 0;\n";
		
		if (SG.UsedScreenPos)
		ShaderCode+="IN.screenPos.xy /= IN.screenPos.w;\n";
		

		//if (SG.TooManyTexcoords){
			foreach (ShaderInput SI in ShaderInputs){
				if (SI.Type==0)
				{
					if (SI.UsedMapType0==true||SI.UsedMapType1==true)
					{
						if (SG.TooManyTexcoords)
							ShaderCode+="	float2 uv"+SI.Get()+" = IN.uvTexcoord;\n";
						else
							ShaderCode+="	float2 uv"+SI.Get()+" = IN.uv"+SI.Get()+";\n";
					}
				}				
			}
		//}
		

		ShaderCode+="	//Set reasonable defaults for the fragment outputs.\n		o.Albedo = float3(0.8,0.8,0.8);\n"+
		"		float4 Emission = float4(0,0,0,0);\n";
		
		if (GCLightingName(SP)=="CLPBR_Standard"){
			if (SpecularOn.On)
				ShaderCode+="		o.Smoothness = "+SpecularHardness.Get()+";\n";
			else
				ShaderCode+="		o.Smoothness = 0;\n";
		}
		else{
			if (SpecularOn.On)
				ShaderCode+="		o.Smoothness = "+SpecularHardness.Get()+"*2;\n";
			else
				ShaderCode+="		o.Smoothness = 0;\n";
		}
		//if (SG.UsedNormals||SG.UsedShellsNormals)
		//ShaderCode+="	o.Normal = float3(0.5,0.5,1);\n";
		if (SG.UsedNormals||SG.UsedShellsNormals)
		ShaderCode+="		o.Normal = float3(0,0,1);\n";
		ShaderCode+="		o.Alpha = 1.0;\n"+
		"		o.Occlusion = 1.0;\n"+
		"		o.Specular = float3(0.3,0.3,0.3);\n";

		if (SG.UsedMapGenerate==true)
		ShaderCode+=//"	half2 UVy;\n"+
		//"	half2 UVx;\n"+
		//"	half2 UVz;\n\n"+
		//"	half4 TEXy;\n"+					
		//"	half4 TEXx;\n"+					
		//"	half4 TEXz;\n\n"+
		//"	half3 blend = normalize(abs(IN.worldNormal));\n";
		"	half3 blend = pow((abs(WorldNormalVector(IN, o.Normal))),5);\n	blend /= blend.x+blend.y+blend.z;\n";
		foreach(string Ty in ShaderSandwich.EffectsList){
			bool IsUsed = false;
			foreach (ShaderLayer SL in ShaderUtil.GetAllLayers()){
				foreach(ShaderEffect SE in SL.LayerEffects)
				{
					if (Ty==SE.TypeS&&SE.Visible)
					IsUsed = true;
				}
			}
			if (IsUsed){
				ShaderEffect NewEffect = ShaderEffect.CreateInstance<ShaderEffect>();
				NewEffect.ShaderEffectIn(Ty);
				if (ShaderEffect.GetMethod(NewEffect.TypeS,"GenerateStart")!=null)
				ShaderCode+= (string)ShaderEffect.GetMethod(NewEffect.TypeS,"GenerateStart").Invoke(null,new object[]{SG})+"\n";
			}
		}
		
		ShaderCode+="#PARALLAX";
		ShaderCode+="#GENERATEMULTIUSEDBASES\n";

		foreach(ShaderLayerList SLL in ShaderLayersMasks)
		{
			if (SG.UsedMasks[SLL]>0&&!SLL.IsLighting.On){
				ShaderCode+=SLL.GCVariable();
				ShaderCode+=GCLayers(SG,SLL.Name.Text,SLL,SLL.CodeName,SLL.EndTag.Text,SLL.Function,false,true);
			}
		}		
		if (ShaderPassStandard(SP)||ShaderPassMask(SP))
		{
			ShaderCode+=GCLayers(SG,"Normals",ShaderLayersNormal,"o.Normal","rgb","",false,true);
			//if (SG.UsedNormals)
			//ShaderCode+="o.Normal = (o.Normal-0.5)*2;\n";
			if (TransparencyOn.On)
			ShaderCode+=GCLayers(SG,"Alpha",ShaderLayersAlpha,"o.Alpha","a","",false,false);

			if (TransparencyOn.On&&TransparencyType.Type==0){
				ShaderCode+="	clip(o.Alpha-"+TransparencyAmount.Get()+");\n";
			}
			if (TransparencyOn.On&&TransparencyType.Type==1){
				ShaderCode+="	o.Alpha *= "+TransparencyAmount.Get()+";\n";
			}
			ShaderCode+=GCLayers(SG,"Diffuse",ShaderLayersDiffuse,"o.Albedo","rgb","",false,true);
			if (EmissionOn.On)
			ShaderCode+=GCLayers(SG,"Emission",ShaderLayersEmission,"Emission","rgba","",false,true);
			if (SpecularOn.On)
			ShaderCode+=GCLayers(SG,"Gloss",ShaderLayersSpecular,"o.Specular","rgb","",false,true);
		}		
		if (ShaderPassShells(SP))
		{
			ShaderCode+=GCLayers(SG,"Normals",ShaderLayersShellNormal,"o.Normal","rgb","",false,true);
			//if (SG.UsedShellsNormals)
			//ShaderCode+="o.Normal = (o.Normal-0.5)*2;\n";
			
			if (TransparencyOn.On)
			ShaderCode+=GCLayers(SG,"Alpha",ShaderLayersShellAlpha,"o.Alpha","a","",false,true);

			if (TransparencyOn.On&&TransparencyType.Type==0){
				ShaderCode+="	clip(o.Alpha-"+TransparencyAmount.Get()+");\n";
			}

			if (TransparencyOn.On&&TransparencyType.Type==1){
				ShaderCode+="	o.Alpha *= "+TransparencyAmount.Get()+";\n";
			}
			ShaderCode+=GCLayers(SG,"Diffuse",ShaderLayersShellDiffuse,"o.Albedo","rgb","",false,true);

			if (EmissionOn.On)
			ShaderCode+=GCLayers(SG,"Emission",ShaderLayersShellEmission,"Emission","rgba","",false,true);
			
			if (SpecularOn.On)
			ShaderCode+=GCLayers(SG,"Gloss",ShaderLayersShellSpecular,"o.Specular","rgb","",false,true);
		}
		if (EmissionOn.On){
			ShaderCode+="	o.Emission = Emission.rgb;\n";
			if (EmissionType.Type==1)
				ShaderCode+="	o.Emission*=o.Albedo;\n";
			if (EmissionType.Type==2){
				ShaderCode+="	o.Albedo *= 1-Emission.a;\n";
				//ShaderCode+="	o.Emission = float3(0,0,0);\n";
			}
		}
}
		ShaderCode+="}\n";
		string GenMultiUseBases = "";
		//int GenMultiUseBasesCount = 0;
		/*foreach(KeyValuePair<string, int> entry in SG.UsedBases){
			if (entry.Value>=2)
			{
				GenMultiUseBasesCount+=1;
				GenMultiUseBases+="float4 MultiUse"+GenMultiUseBasesCount.ToString()+" = "+entry.Key+";//"+entry.Value.ToString()+"\n";
				ShaderCode = ShaderCode.Replace(entry.Key,"MultiUse"+GenMultiUseBasesCount.ToString());
			}
		}*/
		ShaderCode = ShaderCode.Replace("#GENERATEMULTIUSEDBASES",GenMultiUseBases);
		ShaderCode = ShaderCode.Replace("#PARALLAX",GCParallax(SG));
		SG.UsedBases.Clear();
		return ShaderCode;
	}
Пример #43
0
	public string GCFragmentMask(ShaderGenerate SG, ShaderPass SP){
		return GCFragmentMask(SG,SP,0f);
	}
Пример #44
0
	public string GCPassMask_Real(ShaderGenerate SG,ShaderPass SP,float Dist){
		string ShaderCode = "";
		//SG.Reset();
		int OldTransType = TransparencyType.Type;
//		float OldTransAmount = TransparencyAmount.Float;
//		ShaderInput OldTransInput = TransparencyAmount.Input;
		TransparencyType.Type = 0;
	
		if (TransparencyZWriteType.Type==0)
		ShaderCode+="\nPass\n"
		+"{\n"
		+"	Name \"ALPHAMASK\"\n"
		+"	ColorMask 0\n";
		
		if (ShaderPassShells(SP))
		ShaderCode+="	cull "+ShellsCull.CodeNames[ShellsCull.Type]+"\n";
		else
		ShaderCode+="	cull "+TechCull.CodeNames[TechCull.Type]+"\n";

		ShaderCode+=GCLabTags(SP);

		ShaderCode+="	CGPROGRAM\n\n";
		ShaderCode+=GCUniforms(SG);	
		if (TransparencyZWriteType.Type==1){
			ShaderCode+=GCPragma(SG,SP);
			ShaderCode+=GCSurfaceOutput();
			ShaderCode+=GCInputs(SG);
		}
		else{
			ShaderCode+="	//The Shader Target defines the maximum capabilites of the shader (Number of math operators, texture reads, etc.)\n	#pragma target "+((int)TechShaderTarget.Float).ToString()+".0\n"+
			"	//Tell Unity which parts of the shader affect the vertexes or the pixel colors.\n"+
			"	#pragma vertex vert\n"+
            "	#pragma fragment frag\n"+
            "	#include \"UnityCG.cginc\" //Include some base Unity stuff.\n";
		}
		ShaderCode+=GCFunctions(SG);
		if (TransparencyZWriteType.Type==1)
		ShaderCode+=GCLighting(SG,SP);
		if (TransparencyZWriteType.Type==0)
		ShaderCode+=GCVertexMask(SG,SP,Dist);
		else
		ShaderCode+=GCVertex(SG,SP,Dist);
		if (TransparencyZWriteType.Type==0)
		ShaderCode+=GCFragmentMask(SG,SP,Dist);
		else
		ShaderCode+=GCFragment(SG,SP,Dist);

		ShaderCode+="	ENDCG\n";

		if ((TransparencyZWriteType.Type==0))
		ShaderCode+="}\n";
		
		//if (TransparencyZWrite.On&&TransparencyZWriteType.Type==1){
		TransparencyType.Type = OldTransType;
		//}

		return ShaderCode;
	}
Пример #45
0
	public string GCPassMask(ShaderGenerate SG,ShaderPass SP,float Dist){
		if (TransparencyZWrite.On&&TransparencyOn.On&&TransparencyType.Type==1)
		return GCPassMask_Real(SG,SP,Dist);
		return "";
	}
Пример #46
0
	public string GCVertexMask(ShaderGenerate SG, ShaderPass SP, float Dist){
		SG.InVertex = true;
		string shaderCode = "";
		shaderCode+="float4 vert(appdata_base v) : POSITION {\n";
		
		shaderCode+=GCVertexInternal(SG,SP,Dist);
		shaderCode+="	return mul (UNITY_MATRIX_MVP, v.vertex);\n";
		shaderCode+="}\n";
		SG.InVertex = false;
		SG.UsedBases.Clear();
		return shaderCode;
	}
Пример #47
0
	public string GCPass(ShaderGenerate SG,ShaderPass SP){
		return GCPass_Real(SG,SP,0f);
	}
Пример #48
0
		/// <summary>
		/// Parses an instance from a stream to a CGP file
		/// </summary>
		public RetroShaderPreset(Stream stream)
		{
			var content = new StreamReader(stream).ReadToEnd();
			Dictionary<string, string> dict = new Dictionary<string, string>();

			//parse the key-value-pair format of the file
			content = content.Replace("\r", "");
			foreach (var _line in content.Split('\n'))
			{
				var line = _line.Trim();
				if (line.StartsWith("#")) continue; //lines that are solely comments
				if (line == "") continue; //empty line
				int eq = line.IndexOf('=');
				var key = line.Substring(0, eq).Trim();
				var value = line.Substring(eq + 1).Trim();
				int quote = value.IndexOf('\"');
				if (quote != -1)
					value = value.Substring(quote + 1, value.IndexOf('\"', quote + 1) - (quote + 1));
				else
				{
					//remove comments from end of value. exclusive from above condition, since comments after quoted strings would be snipped by the quoted string extraction
					int hash = value.IndexOf('#');
					if (hash != -1)
						value = value.Substring(0, hash);
					value = value.Trim();
				}
				dict[key.ToLower()] = value;
			}

			//process the keys
			int nShaders = FetchInt(dict, "shaders", 0);
			for (int i = 0; i < nShaders; i++)
			{
				ShaderPass sp = new ShaderPass();
				sp.Index = i;
				Passes.Add(sp);

				sp.InputFilterLinear = FetchBool(dict, "filter_linear" + i, false); //Should this value not be defined, the filtering option is implementation defined.
				sp.OuputFloat = FetchBool(dict, "float_framebuffer" + i, false);
				sp.FrameCountMod = FetchInt(dict, "frame_count_mod" + i, 1);
				sp.ShaderPath = FetchString(dict, "shader" + i, "?"); //todo - change extension to .cg for better compatibility? just change .cg to .glsl transparently at last second?

				//If no scale type is assumed, it is assumed that it is set to "source" with scaleN set to 1.0.
				//It is possible to set scale_type_xN and scale_type_yN to specialize the scaling type in either direction. scale_typeN however overrides both of these.
				sp.ScaleTypeX = (ScaleType)Enum.Parse(typeof(ScaleType), FetchString(dict, "scale_type_x" + i, "Source"), true);
				sp.ScaleTypeY = (ScaleType)Enum.Parse(typeof(ScaleType), FetchString(dict, "scale_type_y" + i, "Source"), true);
				ScaleType st = (ScaleType)Enum.Parse(typeof(ScaleType), FetchString(dict, "scale_type" + i, "NotSet"), true);
				if (st != ScaleType.NotSet)
					sp.ScaleTypeX = sp.ScaleTypeY = st;

				//scaleN controls both scaling type in horizontal and vertical directions. If scaleN is defined, scale_xN and scale_yN have no effect.
				sp.Scale.X = FetchFloat(dict, "scale_x" + i, 1);
				sp.Scale.Y = FetchFloat(dict, "scale_y" + i, 1);
				float scale = FetchFloat(dict, "scale" + i, -999);
				if (scale != -999)
					sp.Scale.X = sp.Scale.Y = FetchFloat(dict, "scale" + i, 1);

				//TODO - LUTs
			}
		}
Пример #49
0
	public bool ShaderPassMask(ShaderPass SP){
		if (SP == ShaderPass.MaskBase||SP == ShaderPass.MaskLight||SP == ShaderPass.Mask)
		return true;
		return false;
	}
Пример #50
0
	public string GCVertexInternal(ShaderGenerate SG, ShaderPass SP, float Dist){
		string shaderCode = "";
		shaderCode+="	float SSShellDepth = "+Dist.ToString()+";\n";
		
		if (Dist>0){
			string Disp = "";
			if (ShellsDistance.Get()==ShellsDistance.Float.ToString()){
				if (ShellsEase.Get()!="1"){
					if (ShellsEase.Get()==ShellsEase.Float.ToString())
						Disp=(ShellsDistance.Float*Mathf.Pow(Dist,ShellsEase.Float)).ToString();
					else
						Disp=(ShellsDistance.Float.ToString()+"*pow("+Dist.ToString()+","+ShellsEase.Get()+")");
				}
				else
				Disp = (ShellsDistance.Float*Dist).ToString();
			}
			else{
				if (ShellsEase.Get()=="1")
				Disp=ShellsDistance.Get()+"*"+Dist.ToString();
				else
				Disp=(ShellsDistance.Get()+"*"+"pow("+Dist.ToString().ToString()+","+ShellsEase.Get()+")");
			}
			shaderCode+="	v.vertex.xyz += v.normal*("+Disp+");\n";
		}

		if (SG.UsedMapGenerate==true)
		shaderCode+=
		"	half3 blend = pow((abs(UnityObjectToWorldNormal(v.normal))),5);\n	blend /= blend.x+blend.y+blend.z;\n";
		
		if (ShaderLayersVertex.Count>0){
			shaderCode+="\n	float4 Vertex = v.vertex;\n";
			
			foreach(ShaderLayerList SLL in ShaderLayersMasks)
			{
				if (SG.UsedMasks[SLL]>0&&!SLL.IsLighting.On){
					shaderCode+=SLL.GCVariable();
					shaderCode+=GCLayers(SG,SLL.Name.Text,SLL,SLL.CodeName,SLL.EndTag.Text,SLL.Function,false,true);
				}
			}		
			
			shaderCode+=GCLayers(SG,"Vertex",ShaderLayersVertex,"Vertex","rgba","",false,true);
			shaderCode+="\n	v.vertex.rgb = Vertex;\n";
		}
		return shaderCode;
	}
Пример #51
0
	public bool ShaderPassShells(ShaderPass SP){
		if (SP == ShaderPass.ShellBase||SP == ShaderPass.ShellLight)
		return true;
		return false;
	}
Пример #52
0
	public bool ShaderPassLight(ShaderPass SP){
		if (SP == ShaderPass.Light||SP == ShaderPass.ShellLight)
		return true;
		return false;
	}
Пример #53
0
	public string GCPass(ShaderGenerate SG,ShaderPass SP,float Dist){
		return GCPass_Real(SG,SP,Dist);
	}
Пример #54
0
	public bool ShaderPassStandard(ShaderPass SP){
		if (SP == ShaderPass.Base||SP == ShaderPass.Light)
		return true;
		return false;
	}
Пример #55
0
        public void Render(RenderFrame frame)
        {
            if (SwapChain == null) return;

            /////////////////////////////////////////////////
            // update
            /////////////////////////////////////////////////
            foreach (var resource in frame.Resources)
            {
                switch (resource.RenderResourceType)
                {
                    case RenderResourceType.Texture:
                        //TextureManager.Ensure(device, resource as TextureResource);
                        break;

                    case RenderResourceType.Sampler:
                        //SamplerManager.Ensure(device, resource as SamplerResource);
                        break;

                    case RenderResourceType.Shader:
                        m_shaderManager.Ensure(D3DDevice, resource as ShaderResource);
                        break;

                    case RenderResourceType.VertexBuffer:
                        m_vertexBufferManager.Ensure(D3DDevice, resource as VertexBufferResource);
                        break;

                    case RenderResourceType.BlendState:
                        //BlendStateManager.Ensure(device, resource as BlendStateResource);
                        break;

                    case RenderResourceType.DepthStencilState:
                        //DepthStencilStateManager.Ensure(device, resource as DepthStencilStateResource);
                        break;

                    default:
                        throw new NotImplementedException(resource.ToString());
                }
            }

            /////////////////////////////////////////////////
            // render
            /////////////////////////////////////////////////
            m_pass = new ShaderPass();
            using (Backbuffer = SwapChain.GetBackBuffer<SharpDX.Direct3D11.Texture2D>(0))
            using (RTV = new SharpDX.Direct3D11.RenderTargetView(D3DDevice, Backbuffer))
            {
                var context = D3DDevice.ImmediateContext;
                foreach (var c in frame.Commands)
                {
                    switch (c.RenderCommandType)
                    {
                        /*
                        case RenderCommandType.RenderTargets_Set:
                            {
                                var command = c as RenderTargetsSetCommand;
                                var depthStencil = m_resources.TextureManager.Get(command.DepthStencil);
                                var renderTargets = m_resources.TextureManager.Get(command.RenderTargets);
                                context.OutputMerger.SetTargets(
                                    depthStencil != null ? depthStencil.DepthStencilView : null
                                    , renderTargets.Select(r => r.RenderTargetView).ToArray());

                            }
                            break;

                        case RenderCommandType.Viewport_Set:
                            {
                                var command = c as ViewportSetCommand;
                                context.Rasterizer.SetViewports(new SharpDX.ViewportF[] { command.Viewport });
                            }
                            break;
                            */

                        case RenderCommandType.Clear_Backbuffer:
                            {
                                var command = c as BackbufferClearCommand;
                                context.ClearRenderTargetView(RTV, command.Color.ToSharpDX());
                                context.OutputMerger.SetTargets((SharpDX.Direct3D11.DepthStencilView)null, new SharpDX.Direct3D11.RenderTargetView[] { RTV });
                                context.Rasterizer.SetViewports(new [] {
                                    new SharpDX.Mathematics.Interop.RawViewportF
                                    {
                                        X=0,
                                        Y=0,
                                        Width=Backbuffer.Description.Width,
                                        Height=Backbuffer.Description.Height,
                                    }
                                });
                            }
                            break;

                        /*
                    case RenderCommandType.Clear_Color:
                        {
                            var command = c as RenderTargetClearCommand;
                            var renderTarget = m_resources.TextureManager.Get(command.ResourceID);
                            if (renderTarget != null)
                            {
                                context.ClearRenderTargetView(renderTarget.RenderTargetView, command.Color);
                            }
                        }
                        break;

                    case RenderCommandType.Clear_Depth:
                        {
                            var command = c as DepthStencilClearCommand;
                            var depthStencil = m_resources.TextureManager.Get(command.ResourceID);
                            if (depthStencil != null)
                            {
                                context.ClearDepthStencilView(depthStencil.DepthStencilView
                                    , SharpDX.Direct3D11.DepthStencilClearFlags.Depth
                                    , command.Depth, command.Stencil);
                            }
                        }
                        break;
                        */

                        case RenderCommandType.VertexBuffer_Update:
                        {
                            var command = c as VertexBufferUpdateCommand;
                            var vertexBuffer = m_vertexBufferManager.Get(command.ResourceID);
                            if (vertexBuffer != null)
                            {
                                if (command.Ptr != IntPtr.Zero)
                                {
                                    var data = new SharpDX.DataBox(command.Ptr);
                                    context.UpdateSubresource(data, vertexBuffer.Vertices);
                                }
                            }
                        }
                        break;

                        case RenderCommandType.VertexBuffer_Set:
                            {
                                var command = c as VertexBufferSetCommand;
                                var vertexBuffer = m_vertexBufferManager.Get(command.ResourceID);
                                if (vertexBuffer != null)
                                {
                                    context.InputAssembler.PrimitiveTopology = vertexBuffer.Topology;

                                    context.InputAssembler.SetVertexBuffers(0,
                                        new SharpDX.Direct3D11.VertexBufferBinding(vertexBuffer.Vertices
                                            , vertexBuffer.Stride, 0));
                                    if (vertexBuffer.Indices != null)
                                    {
                                        context.InputAssembler.SetIndexBuffer(vertexBuffer.Indices, SharpDX.DXGI.Format.R32_UInt, 0);
                                    }

                                    m_vertexBuffer = vertexBuffer;
                                }
                            }
                            break;

                        case RenderCommandType.ShaderVriable_Set:
                            {
                                var command = c as ShaderVariableSetCommand;
                                m_pass.SetConstantVariable(command);
                            }
                            break;

                        /*
                    case RenderCommandType.ShaderTexture_Set:
                        {
                            var command = c as ShaderTextureSetCommand;
                            var texture = m_resources.TextureManager.Get(command.ResourceID);
                            if (texture != null)
                            {
                                m_pass.SetSRV(context, command.Key, texture.ShaderResourceView);
                            }
                        }
                        break;

                    case RenderCommandType.ShaderSampler_Set:
                        {
                            var command = c as ShaderSamplerSetCommand;
                            Pass.SetSampler(command);
                        }
                        break;
                        */

                        case RenderCommandType.Shader_Set:
                            {
                                var command = c as ShaderSetCommand;
                                switch (command.ShaderStage)
                                {
                                    case ShaderStage.Vertex:
                                        {
                                            var vertexShader = m_shaderManager.Get(command.ResourceID) as VertexShaderStage;
                                            if (vertexShader != null)
                                            {
                                                context.VertexShader.Set(vertexShader.Shader);
                                                //context.InputAssembler.InputLayout = vertexShader.VertexLayout;
                                                m_pass.VertexShader = vertexShader;
                                            }
                                        }
                                        break;

                                    case ShaderStage.Geometry:
                                        {
                                            var geometryShader = m_shaderManager.Get(command.ResourceID) as GeometryShaderStage;
                                            if (geometryShader != null)
                                            {
                                                context.GeometryShader.Set(geometryShader.Shader);
                                                m_pass.GeometryShader = geometryShader;
                                            }
                                        }
                                        break;

                                    case ShaderStage.Pixel:
                                        {
                                            var pixelShader = m_shaderManager.Get(command.ResourceID) as PixelShaderStage;
                                            if (pixelShader != null)
                                            {
                                                context.PixelShader.Set(pixelShader.Shader);
                                                m_pass.PixelShader = pixelShader;
                                            }
                                        }
                                        break;

                                    default:
                                        throw new NotImplementedException();
                                }
                            }
                            break;

                        case RenderCommandType.Shader_DrawSubMesh:
                            {
                                var command = c as ShaderDrawSubMeshCommand;
                                if (m_pass.VertexShader != null)
                                {
                                    context.InputAssembler.InputLayout = m_pass.VertexShader.VertexLayout;
                                    // 定数バッファの適用
                                    m_pass.Apply(context);

                                    if (m_vertexBuffer != null)
                                    {
                                        if (m_vertexBuffer.Indices != null)
                                        {
                                            context.DrawIndexed(command.Count, command.Offset, 0);
                                        }
                                        else
                                        {
                                            context.Draw(command.Count, command.Offset);
                                        }
                                    }
                                }
                            }
                            break;

                            /*
                        case RenderCommandType.BlendState_Set:
                            {
                                var command = c as BlendStateSetCommand;
                                var blendState = m_resources.BlendStateManager.Get(command.ResourceID);
                                if (blendState == null)
                                {
                                    return;
                                }
                                context.OutputMerger.SetBlendState(blendState.State, SharpDX.Color4.White);
                            }
                            break;

                        case RenderCommandType.DepthStencilState_Set:
                            {
                                var command = c as DepthStencilStateSetCommand;
                                var depthStencilState = m_resources.DepthStencilStateManager.Get(command.ResourceID);
                                if (depthStencilState == null)
                                {
                                    return;
                                }
                                context.OutputMerger.SetDepthStencilState(depthStencilState.State);
                            }
                            break;
                            */
                    }
                }
                context.Flush();
            }
            Backbuffer = null;
            RTV = null;

            /////////////////////////////////////////////////
            // flip
            /////////////////////////////////////////////////
            var flags = SharpDX.DXGI.PresentFlags.None;
            flags|=SharpDX.DXGI.PresentFlags.DoNotWait;
            SwapChain.Present(0, flags, new SharpDX.DXGI.PresentParameters());
        }