コード例 #1
0
ファイル: Bloom.cs プロジェクト: yf885188/NeoAxisEngine
        /////////////////////////////////////////

        protected override void OnRender(ViewportRenderingContext context, Component_RenderingPipeline.IFrameData frameData, ref Component_Image actualTexture)
        {
            base.OnRender(context, frameData, ref actualTexture);

            //PixelFormat.A8R8G8B8 );

            //bright pass
            //!!!!или A8R8G8B8?
            //R8G8B8
            var brightTexture = context.RenderTarget2D_Alloc(actualTexture.Result.ResultSize, PixelFormat.A8R8G8B8);              //!!!! PixelFormat.R8G8B8 );
            {
                context.SetViewport(brightTexture.Result.GetRenderTarget().Viewports[0]);

                CanvasRenderer.ShaderItem shader = new CanvasRenderer.ShaderItem();
                shader.VertexProgramFileName   = @"Base\Shaders\EffectsCommon_vs.sc";
                shader.FragmentProgramFileName = @"Base\Shaders\Effects\Bloom\Bright_fs.sc";

                shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(0 /*"sourceTexture"*/, actualTexture,
                                                                                   TextureAddressingMode.Clamp, FilterOption.Linear, FilterOption.Linear, FilterOption.Point));
                shader.Parameters.Set("brightThreshold", (float)BrightThreshold);

                context.RenderQuadToCurrentViewport(shader);
            }

            //blur
            var pipeline    = (Component_RenderingPipeline_Basic)context.RenderingPipeline;
            var blurTexture = pipeline.GaussianBlur(context, this, brightTexture, BlurFactor, BlurDownscalingMode, BlurDownscalingValue);

            context.DynamicTexture_Free(brightTexture);

            //create final
            var finalTexture = context.RenderTarget2D_Alloc(actualTexture.Result.ResultSize, actualTexture.Result.ResultFormat);

            {
                context.SetViewport(finalTexture.Result.GetRenderTarget().Viewports[0]);

                CanvasRenderer.ShaderItem shader = new CanvasRenderer.ShaderItem();
                shader.VertexProgramFileName   = @"Base\Shaders\EffectsCommon_vs.sc";
                shader.FragmentProgramFileName = @"Base\Shaders\Effects\Bloom\Final_fs.sc";

                shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(0 /*"sourceTexture"*/, actualTexture,
                                                                                   TextureAddressingMode.Clamp, FilterOption.Point, FilterOption.Point, FilterOption.None));
                shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(1 /*"bloomTexture"*/, blurTexture,
                                                                                   TextureAddressingMode.Clamp, FilterOption.Point, FilterOption.Point, FilterOption.None));
                shader.Parameters.Set("intensity", (float)Intensity);
                shader.Parameters.Set("scale", (float)Scale);

                context.RenderQuadToCurrentViewport(shader);
            }

            //free old textures
            context.DynamicTexture_Free(actualTexture);
            context.DynamicTexture_Free(blurTexture);

            //update actual texture
            actualTexture = finalTexture;
        }
コード例 #2
0
ファイル: ToHDR.cs プロジェクト: zwiglm/NeoAxisEngine
        protected override void OnRender(ViewportRenderingContext context, Component_RenderingPipeline.IFrameData frameData, ref Component_Image actualTexture)
        {
            var demandFormat = PixelFormat.Float16RGBA;

            if (actualTexture.Result.ResultFormat != demandFormat)
            {
                var newTexture = context.RenderTarget2D_Alloc(actualTexture.Result.ResultSize, demandFormat);

                context.SetViewport(newTexture.Result.GetRenderTarget().Viewports[0]);

                CanvasRenderer.ShaderItem shader = new CanvasRenderer.ShaderItem();
                shader.VertexProgramFileName = @"Base\Shaders\EffectsCommon_vs.sc";
                //shader.VertexProgramFunctionName = "main_vp";
                shader.FragmentProgramFileName = @"Base\Shaders\Effects\ToHDR_fs.sc";
                //shader.FragmentProgramFunctionName = "main_fp";

                shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(0 /*"sourceTexture"*/, actualTexture,
                                                                                   TextureAddressingMode.Clamp, FilterOption.Point, FilterOption.Point, FilterOption.None));

                //var size = context.owner.DimensionsInPixels.Size;
                //shader.Parameters.Set( "viewportSize", new Vec4( size.X, size.Y, 1.0 / (double)size.X, 1.0 / (double)size.Y ).ToVec4F() );

                //Mat4F identity = Mat4F.Identity;
                //shader.Parameters.Set( "worldViewProjMatrix", ParameterType.Matrix4x4, 1, &identity, sizeof( Mat4F ) );

                context.RenderQuadToCurrentViewport(shader);

                //free old texture
                context.DynamicTexture_Free(actualTexture);

                actualTexture = newTexture;
            }
        }
コード例 #3
0
        protected override void OnRender(ViewportRenderingContext context, Component_RenderingPipeline.IFrameData frameData, ref Component_Image actualTexture)
        {
            var newTexture = context.RenderTarget2D_Alloc(actualTexture.Result.ResultSize, PixelFormat.A8R8G8B8);

            context.SetViewport(newTexture.Result.GetRenderTarget().Viewports[0]);

            CanvasRenderer.ShaderItem shader = new CanvasRenderer.ShaderItem();
            shader.VertexProgramFileName   = @"Base\Shaders\EffectsCommon_vs.sc";
            shader.FragmentProgramFileName = @"Base\Shaders\Effects\ToneMapping_fs.sc";

            shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(0 /*"sourceTexture"*/, actualTexture,
                                                                               TextureAddressingMode.Clamp, FilterOption.Point, FilterOption.Point, FilterOption.None));

            shader.Parameters.Set("u_tonemapping_parameters", new Vector4F((float)Intensity, (float)GammaInput, (float)Exposure, (float)GammaOutput));

            shader.Defines.Add(new CanvasRenderer.ShaderItem.DefineItem($"TONEMAPPING_METHOD_{Method.Value.ToString().ToUpper()}"));
            if (Method.Value == MethodEnum.Custom)
            {
                shader.Defines.Add(new CanvasRenderer.ShaderItem.DefineItem("CUSTOM_CODE", CustomCode.Value));
            }

            context.RenderQuadToCurrentViewport(shader);

            //free old texture
            context.DynamicTexture_Free(actualTexture);

            actualTexture = newTexture;
        }
コード例 #4
0
        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

        public virtual void ConvertToLDR(ViewportRenderingContext context, ref Component_Image actualTexture)
        {
            //!!!!может другие тоже форматы? провер¤ть на FloatXX?
            var demandFormat = PixelFormat.A8R8G8B8;

            if (actualTexture.Result.ResultFormat != demandFormat)
            {
                var newTexture = context.RenderTarget2D_Alloc(actualTexture.Result.ResultSize, demandFormat);

                context.SetViewport(newTexture.Result.GetRenderTarget().Viewports[0]);

                CanvasRenderer.ShaderItem shader = new CanvasRenderer.ShaderItem();
                shader.VertexProgramFileName   = @"Base\Shaders\EffectsCommon_vs.sc";
                shader.FragmentProgramFileName = @"Base\Shaders\Effects\ToLDR_fs.sc";

                shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(0 /*"sourceTexture"*/, actualTexture,
                                                                                   TextureAddressingMode.Clamp, FilterOption.Point, FilterOption.Point, FilterOption.None));

                //var size = context.owner.DimensionsInPixels.Size;
                //shader.Parameters.Set( "viewportSize", new Vec4( size.X, size.Y, 1.0 / (double)size.X, 1.0 / (double)size.Y ).ToVec4F() );

                //Mat4F identity = Mat4F.Identity;
                //shader.Parameters.Set( "worldViewProjMatrix", ParameterType.Matrix4x4, 1, &identity, sizeof( Mat4F ) );

                context.RenderQuadToCurrentViewport(shader);

                //free old texture
                context.DynamicTexture_Free(actualTexture);

                actualTexture = newTexture;
            }
        }
コード例 #5
0
        public void RenderDownscale(ViewportRenderingContext context, Component_RenderingPipeline.IFrameData frameData, Vector2I destinationSize, ref Component_Image actualTexture)
        {
            if (Technique.Value >= TechniqueEnum.SSAAx2 && Technique.Value <= TechniqueEnum.SSAAx4 && context.Owner.SizeInPixels != actualTexture.Result.ResultSize)
            {
                var rescaledTexture = context.RenderTarget2D_Alloc(context.Owner.SizeInPixels, actualTexture.Result.ResultFormat);

                //copy to scene texture with downscale
                {
                    context.SetViewport(rescaledTexture.Result.GetRenderTarget().Viewports[0]);

                    CanvasRenderer.ShaderItem shader = new CanvasRenderer.ShaderItem();
                    shader.VertexProgramFileName   = @"Base\Shaders\EffectsCommon_vs.sc";
                    shader.FragmentProgramFileName = @"Base\Shaders\Effects\DownscaleAntialiasing_fs.sc";

                    shader.Defines.Add(new CanvasRenderer.ShaderItem.DefineItem(Technique.Value.ToString().ToUpper()));

                    var multiplier = new Vector2F(1, 1) / destinationSize.ToVector2F() * (float)DownscaleSamplerMultiplier.Value;
                    shader.Parameters.Set("antialiasing_multiplier", multiplier);

                    shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(0 /*"sourceTexture"*/,
                                                                                       actualTexture, TextureAddressingMode.Clamp, FilterOption.Linear, FilterOption.Linear, FilterOption.None));

                    context.RenderQuadToCurrentViewport(shader);
                }

                context.DynamicTexture_Free(actualTexture);

                actualTexture = rescaledTexture;
            }
        }
コード例 #6
0
        protected override void OnRender(ViewportRenderingContext context, Component_RenderingPipeline.IFrameData frameData, ref Component_Image actualTexture)
        {
            base.OnRender(context, frameData, ref actualTexture);

            //create final
            var finalTexture = context.RenderTarget2D_Alloc(actualTexture.Result.ResultSize, PixelFormat.A8R8G8B8);

            {
                context.SetViewport(finalTexture.Result.GetRenderTarget().Viewports[0]);

                CanvasRenderer.ShaderItem shader = new CanvasRenderer.ShaderItem();
                shader.VertexProgramFileName   = @"Base\Shaders\EffectsCommon_vs.sc";
                shader.FragmentProgramFileName = @"Base\Shaders\Effects\ShowRenderTarget_fs.sc";

                string textureName = "";
                switch (Texture.Value)
                {
                case TextureType.Normal: textureName = "normalTexture"; break;

                case TextureType.Depth: textureName = "depthTexture"; break;

                case TextureType.MotionVector: textureName = "motionTexture"; break;
                }
                context.objectsDuringUpdate.namedTextures.TryGetValue(textureName, out var showTexture);
                if (showTexture == null)
                {
                    context.DynamicTexture_Free(finalTexture);
                    return;
                }

                shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(0 /*"sourceTexture"*/, actualTexture,
                                                                                   TextureAddressingMode.Clamp, FilterOption.Point, FilterOption.Point, FilterOption.None));
                shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(1 /*"showTexture"*/, showTexture,
                                                                                   TextureAddressingMode.Clamp, FilterOption.Point, FilterOption.Point, FilterOption.None));

                shader.Parameters.Set("intensity", (float)Intensity);
                shader.Parameters.Set("nearClipDistance", (float)context.Owner.CameraSettings.NearClipDistance);
                shader.Parameters.Set("farClipDistance", (float)context.Owner.CameraSettings.FarClipDistance);
                shader.Parameters.Set("mode", (float)Texture.Value);
                shader.Parameters.Set("depthMultiplier", (float)DepthMultiplier);
                shader.Parameters.Set("motionMultiplier", (float)MotionMultiplier);

                context.RenderQuadToCurrentViewport(shader);
            }

            //free old textures
            context.DynamicTexture_Free(actualTexture);

            //update actual texture
            actualTexture = finalTexture;
        }
コード例 #7
0
ファイル: MotionBlur.cs プロジェクト: zwiglm/NeoAxisEngine
        /////////////////////////////////////////

        protected override void OnRender(ViewportRenderingContext context, Component_RenderingPipeline.IFrameData frameData, ref Component_Image actualTexture)
        {
            context.objectsDuringUpdate.namedTextures.TryGetValue("motionTexture", out var motionTexture);

            if (motionTexture != null)
            {
                //create final
                var finalTexture = context.RenderTarget2D_Alloc(actualTexture.Result.ResultSize, actualTexture.Result.ResultFormat);
                {
                    context.SetViewport(finalTexture.Result.GetRenderTarget().Viewports[0]);

                    var shader = new CanvasRenderer.ShaderItem();
                    shader.VertexProgramFileName   = @"Base\Shaders\EffectsCommon_vs.sc";
                    shader.FragmentProgramFileName = @"Base\Shaders\Effects\MotionBlur_fs.sc";

                    shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(0 /*"sourceTexture"*/, actualTexture,
                                                                                       TextureAddressingMode.Clamp, FilterOption.Point, FilterOption.Point, FilterOption.None));
                    shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(1 /*"motionTexture"*/, motionTexture,
                                                                                       TextureAddressingMode.Clamp, FilterOption.Point, FilterOption.Point, FilterOption.None));
                    shader.Parameters.Set("intensity", (float)Intensity);

                    var multiplier = 0.0;
                    if (context.Owner.LastUpdateTimeStep != 0)
                    {
                        multiplier = (1.0 / context.Owner.LastUpdateTimeStep) / 45.0;
                    }
                    multiplier *= Multiplier.Value;

                    //fix initial rattling
                    if (context.Owner.LastUpdateTimeStep > 0.1)
                    {
                        multiplier = 0;
                    }

                    shader.Parameters.Set("motionBlurMultiplier", (float)multiplier);

                    var size = actualTexture.Result.ResultSize;
                    shader.Parameters.Set("viewportSize", new Vector4(size.X, size.Y, 1.0 / (double)size.X, 1.0 / (double)size.Y).ToVector4F());

                    context.RenderQuadToCurrentViewport(shader);
                }

                //free old textures
                context.DynamicTexture_Free(actualTexture);

                //update actual texture
                actualTexture = finalTexture;
            }
        }
コード例 #8
0
        /////////////////////////////////////////

        protected override void OnRender(ViewportRenderingContext context, Component_RenderingPipeline.IFrameData frameData, ref Component_Image actualTexture)
        {
            base.OnRender(context, frameData, ref actualTexture);

            //create final
            var finalTexture = context.RenderTarget2D_Alloc(actualTexture.Result.ResultSize, actualTexture.Result.ResultFormat);

            {
                context.SetViewport(finalTexture.Result.GetRenderTarget().Viewports[0]);

                CanvasRenderer.ShaderItem shader = new CanvasRenderer.ShaderItem();
                shader.VertexProgramFileName   = @"Base\Shaders\EffectsCommon_vs.sc";
                shader.FragmentProgramFileName = @"Base\Shaders\Effects\EdgeDetection_fs.sc";

                shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(0 /*"sourceTexture"*/, actualTexture,
                                                                                   TextureAddressingMode.Clamp, FilterOption.Point, FilterOption.Point, FilterOption.None));

                context.objectsDuringUpdate.namedTextures.TryGetValue("depthTexture", out var depthTexture);
                //if( depthTexture == null )
                //{
                //}
                shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(1 /*"depthTexture"*/, depthTexture,
                                                                                   TextureAddressingMode.Clamp, FilterOption.Point, FilterOption.Point, FilterOption.None));

                context.objectsDuringUpdate.namedTextures.TryGetValue("normalTexture", out var normalTexture);
                if (normalTexture == null)
                {
                    normalTexture = ResourceUtility.WhiteTexture2D;
                }
                shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(2 /*"normalTexture"*/, normalTexture,
                                                                                   TextureAddressingMode.Clamp, FilterOption.Point, FilterOption.Point, FilterOption.None));

                shader.Parameters.Set("intensity", (float)Intensity);
                shader.Parameters.Set("depthThreshold", (float)DepthThreshold);
                shader.Parameters.Set("normalsThreshold", (float)NormalsThreshold);
                shader.Parameters.Set("edgeColor", EdgeColor.Value.ToVector4F());
                shader.Parameters.Set("thickness", (float)Thickness);
                shader.Parameters.Set("maxDistance", (float)MaxDistance);

                context.RenderQuadToCurrentViewport(shader);
            }

            //free old textures
            context.DynamicTexture_Free(actualTexture);

            //update actual texture
            actualTexture = finalTexture;
        }
コード例 #9
0
ファイル: LensEffects.cs プロジェクト: zwiglm/NeoAxisEngine
        protected override void OnRender(ViewportRenderingContext context, Component_RenderingPipeline.IFrameData frameData, ref Component_Image actualTexture)
        {
            base.OnRender(context, frameData, ref actualTexture);

            var pipeline = context.RenderingPipeline as Component_RenderingPipeline_Basic;

            if (pipeline == null)
            {
                return;
            }
            var frameData2 = frameData as Component_RenderingPipeline_Basic.FrameData;

            if (frameData2 == null)
            {
                return;
            }
            if (Intensity.Value == 0)
            {
                return;
            }

            bool skip = true;

            foreach (var lightIndex in frameData2.LightsInFrustumSorted)
            {
                var lightItem = frameData2.Lights[lightIndex];

                if (lightItem.data.children != null)
                {
                    foreach (var child in lightItem.data.children)
                    {
                        var lensFlares = child as Component_LensFlares;
                        if (lensFlares != null)
                        {
                            skip = false;
                            break;
                        }
                    }
                }
            }
            if (skip)
            {
                return;
            }

            //init context data
            ViewportRenderingContextData contextData;

            if (context.anyData.TryGetValue("LensEffects", out var contextData2))
            {
                contextData = (ViewportRenderingContextData)contextData2;
            }
            else
            {
                contextData = new ViewportRenderingContextData();
                context.anyData["LensEffects"] = contextData;
            }

            //update context data light items
            contextData.Update(context.Owner.LastUpdateTimeStep, Intensity, FadeSpeed);

            //create copy
            var newTexture = context.RenderTarget2D_Alloc(actualTexture.Result.ResultSize, actualTexture.Result.ResultFormat, createSimple3DRenderer: true, createCanvasRenderer: true);

            var viewport = newTexture.Result.GetRenderTarget().Viewports[0];
            //!!!!double precision
            Matrix4F viewMatrix       = context.Owner.CameraSettings.ViewMatrix.ToMatrix4F();
            Matrix4F projectionMatrix = context.Owner.CameraSettings.ProjectionMatrix.ToMatrix4F();

            context.SetViewport(viewport, viewMatrix, projectionMatrix);

            pipeline.CopyToCurrentViewport(context, actualTexture);

            var simple3DRenderer = viewport.Simple3DRenderer;
            var canvasRenderer   = viewport.CanvasRenderer;

            //render
            foreach (var lightIndex in frameData2.LightsInFrustumSorted)
            {
                var lightItem = frameData2.Lights[lightIndex];

                if (lightItem.data.children != null)
                {
                    foreach (var child in lightItem.data.children)
                    {
                        var lensFlares = child as Component_LensFlares;
                        if (lensFlares != null)
                        {
                            var light = lightItem.data.Creator as Component_Light;
                            if (light != null)
                            {
                                CheckVisibilityScreenPosition(context, lightItem.data.Position, out var gotScreenPosition, out var insideScreen);

                                if (gotScreenPosition)
                                {
                                    //update
                                    {
                                        switch (CheckVisibilityMethod.Value)
                                        {
                                        case CheckVisibilityMethodEnum.OcclusionQuery:
                                        {
                                            var parameter = (contextData, light);
                                            if (RenderingSystem.TryCreateOcclusionQuery(OcclusionQueryCallback, parameter, out var query))
                                            {
                                                var thickness = context.Owner.Simple3DRenderer.GetThicknessByPixelSize(lightItem.data.Position, 5);
                                                var bounds    = new Bounds(lightItem.data.Position);
                                                bounds.Expand(thickness * 0.5);

                                                simple3DRenderer.SetColor(new ColorValue(1, 0, 0));
                                                simple3DRenderer.SetOcclusionQuery(query);
                                                simple3DRenderer.AddBounds(bounds, true);
                                                //simple3DRenderer.AddSphere( new Sphere( lightItem.data.Position, 0.5 ), 4, true );
                                                simple3DRenderer.SetOcclusionQuery(null);
                                            }
                                        }
                                        break;

                                        case CheckVisibilityMethodEnum.PhysicsRayCast:
                                            if (CheckVisibilityPhysics(context, lightItem.data.Position))
                                            {
                                                contextData.UpdateLastTimeVisible(light);
                                            }
                                            break;
                                        }
                                    }

                                    //render
                                    var intensity = contextData.GetIntensity(light);
                                    if (intensity > 0)
                                    {
                                        //simple3DRenderer.SetColor( new ColorValue( 1, 0, 0 ) );
                                        //simple3DRenderer.AddSphere( new Sphere( lightItem.data.Position, 0.5 ), 10, true );

                                        lensFlares.RenderUI(canvasRenderer, lightItem.data, context.Owner, intensity);
                                    }
                                }
                                else
                                {
                                    contextData.Remove(light);
                                }
                            }
                        }
                    }
                }
            }

            //render
            if (simple3DRenderer._ViewportRendering_PrepareRenderables())
            {
                simple3DRenderer._ViewportRendering_RenderToCurrentViewport(context);
                simple3DRenderer._Clear();
            }
            canvasRenderer._ViewportRendering_RenderToCurrentViewport(context, true, context.Owner.LastUpdateTime);


            //free old textures
            context.DynamicTexture_Free(actualTexture);

            //update actual texture
            actualTexture = newTexture;
        }
コード例 #10
0
        protected override void OnRender(ViewportRenderingContext context, Component_RenderingPipeline.IFrameData frameData, ref Component_Image actualTexture)
        {
            var result = Result as CompiledDataSimple;

            //!!!!так?
            if (result == null)
            {
                return;
            }

            if (result.vertexProgram == null || result.fragmentProgram == null)
            {
                return;
            }

            //!!!!валится если файла нет. или не указан.
            //!!!!!!как быстро проверять о том что файла нет? может из кеша шейдеров или типа того. как тогда обновлять
            //string shaderFile = Shader;
            //if( string.IsNullOrEmpty( shaderFile ) )
            //	return;

            //!!!!formats. т.е. эффект поддерживает и LDR и HDR. где еще
            //!!!!!можно по сути у эффекта указывать что он ожидает получить на входе. ну или это EffectsHDR, EffectsLDR
            var outputTexture = context.RenderTarget2D_Alloc(actualTexture.Result.ResultSize, actualTexture.Result.ResultFormat);

            context.SetViewport(outputTexture.Result.GetRenderTarget().Viewports[0]);

            CanvasRenderer.ShaderItem shader = new CanvasRenderer.ShaderItem();
            shader.CompiledVertexProgram   = result.vertexProgram;
            shader.CompiledFragmentProgram = result.fragmentProgram;

            //shader.VertexProgramFileName = shaderFile;
            //shader.VertexProgramFunctionName = "main_vp";
            //shader.FragmentProgramFileName = shaderFile;
            //shader.FragmentProgramFunctionName = "main_fp";

            //{
            //	var defines = new List<GuiRenderer.ShaderItem.DefineItem>();

            //	//defines.Add( new GuiRenderer.ShaderItem.DefineItem( "FRAGMENT_CODE_BODY", "color = float4(0,1,0,1);" ) );

            //	if( defines.Count != 0 )
            //		shader.Defines = defines.ToArray();
            //}

            shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(0 /*"sourceTexture"*/,
                                                                               actualTexture, TextureAddressingMode.Clamp, FilterOption.Point, FilterOption.Point, FilterOption.Point));
            //shader.Parameters.Set( "0"/*"sourceTexture"*/, new GpuMaterialPass.TextureParameterValue( actualTexture,
            //	TextureAddressingMode.Clamp, FilterOption.Point, FilterOption.Point, FilterOption.Point ) );

            var size = actualTexture.Result.ResultSize;

            shader.Parameters.Set("viewportSize", new Vector4(size.X, size.Y, 1.0 / (double)size.X, 1.0 / (double)size.Y).ToVector4F());

            //!!!!типы
            //bool, int, uint, dword, half, float, double
            //Vec2, Vec3, Vec4, VecxF, Mat2, 3, 4
            //Texture
            //Structs
            //arrays?
            //Structured Buffer
            //byte buffers

            //set shader parameters by properties
            foreach (var m in MetadataGetMembers())
            {
                var p = m as Metadata.Property;
                if (p != null)
                {
                    if (CanBeShaderParameter(this, p, out object value))
                    {
                        Component_Image texture = value as Component_Image;
                        if (texture != null)
                        {
                            foreach (Component_Image.BindSettingsAttribute attr in
                                     p.GetCustomAttributes(typeof(Component_Image.BindSettingsAttribute), true))
                            {
                                shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(attr.SamplerIndex,
                                                                                                   texture, attr.AddressingMode, attr.FilteringMin, attr.FilteringMag, attr.FilteringMip));
                                break;
                            }

                            //GpuMaterialPass.TextureParameterValue textureValue = null;

                            //int samplerIndex = -1;

                            //foreach( Component_Image.BindSettingsAttribute attr in p.GetCustomAttributes(
                            //	typeof( Component_Image.BindSettingsAttribute ), true ) )
                            //{
                            //	textureValue = new GpuMaterialPass.TextureParameterValue( texture,
                            //		attr.AddressingMode, attr.FilteringMin, attr.FilteringMag, attr.FilteringMip );
                            //	samplerIndex = attr.SamplerIndex;
                            //	break;
                            //}

                            //if( samplerIndex != -1 )
                            //	shader.Parameters.Set( samplerIndex.ToString(), textureValue );
                        }
                        else
                        {
                            //!!!!
                            //convert to float type
                            value = SimpleTypes.ConvertDoubleToFloat(value);
                            //ColorValuePowered: convert to ColorValue
                            if (value is ColorValuePowered)
                            {
                                value = ((ColorValuePowered)value).ToColorValue();
                            }

                            shader.Parameters.Set(p.Name, value);
                            shader.Parameters.Set(ToLowerFirstCharacter(p.Name), value);
                        }
                    }
                }
            }

            OnSetShaderParameters(context, frameData, actualTexture, shader);
            SetShaderParametersEvent?.Invoke(this, context, shader);

            context.RenderQuadToCurrentViewport(shader);

            //change actual texture
            context.DynamicTexture_Free(actualTexture);
            actualTexture = outputTexture;
        }
コード例 #11
0
ファイル: DepthOfField.cs プロジェクト: zwiglm/NeoAxisEngine
        /////////////////////////////////////////

        protected override void OnRender(ViewportRenderingContext context, Component_RenderingPipeline.IFrameData frameData, ref Component_Image actualTexture)
        {
            base.OnRender(context, frameData, ref actualTexture);

            //blur
            var pipeline    = (Component_RenderingPipeline_Basic)context.RenderingPipeline;
            var blurTexture = pipeline.GaussianBlur(context, this, actualTexture, BlurFactor, BlurDownscalingMode, BlurDownscalingValue);
            //context.RenderTarget_Free( brightTexture );

            ////horizontal blur
            //var texture1 = context.RenderTarget2D_Alloc( actualTexture.Result.ResultSize, actualTexture.Result.Format );
            //{
            //	context.SetViewport( texture1.Result.GetRenderTarget().Viewports[ 0 ] );

            //	CanvasRenderer.ShaderItem shader = new CanvasRenderer.ShaderItem();
            //	shader.VertexProgramFileName = @"Base\Shaders\EffectsCommon_vs.sc";
            //	shader.FragmentProgramFileName = @"Base\Shaders\Effects\Blur_fs.sc";
            //	//shader.FragmentProgramFileName = @"Base\Shaders\Effects\DepthOfField\Blur_fs.sc";

            //	shader.Parameters.Set( "0"/*"sourceTexture"*/, new GpuMaterialPass.TextureParameterValue( actualTexture,
            //		TextureAddressingMode.Clamp, FilterOption.Point, FilterOption.Point, FilterOption.Point ) );
            //	BlurSetShaderParameters( context, shader, true );

            //	context.RenderQuadToCurrentViewport( shader );
            //}

            ////vertical blur
            //var blurTexture = context.RenderTarget2D_Alloc( actualTexture.Result.ResultSize, texture1.Result.Format );
            //{
            //	context.SetViewport( blurTexture.Result.GetRenderTarget().Viewports[ 0 ] );

            //	CanvasRenderer.ShaderItem shader = new CanvasRenderer.ShaderItem();
            //	shader.VertexProgramFileName = @"Base\Shaders\EffectsCommon_vs.sc";
            //	shader.FragmentProgramFileName = @"Base\Shaders\Effects\Blur_fs.sc";
            //	//shader.FragmentProgramFileName = @"Base\Shaders\Effects\DepthOfField\Blur_fs.sc";

            //	shader.Parameters.Set( "0"/*"sourceTexture"*/, new GpuMaterialPass.TextureParameterValue( texture1,
            //		TextureAddressingMode.Clamp, FilterOption.Linear, FilterOption.Linear, FilterOption.Point ) );
            //	BlurSetShaderParameters( context, shader, false );

            //	context.RenderQuadToCurrentViewport( shader );
            //}

            ////free old texture
            //context.RenderTarget_Free( texture1 );

            //create final
            var finalTexture = context.RenderTarget2D_Alloc(actualTexture.Result.ResultSize, blurTexture.Result.ResultFormat);

            {
                context.SetViewport(finalTexture.Result.GetRenderTarget().Viewports[0]);

                CanvasRenderer.ShaderItem shader = new CanvasRenderer.ShaderItem();
                shader.VertexProgramFileName   = @"Base\Shaders\EffectsCommon_vs.sc";
                shader.FragmentProgramFileName = @"Base\Shaders\Effects\DepthOfField\Final_fs.sc";

                shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(0 /*"sourceTexture"*/, actualTexture,
                                                                                   TextureAddressingMode.Clamp, FilterOption.Point, FilterOption.Point, FilterOption.None));
                shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(1 /*"blurTexture"*/, blurTexture,
                                                                                   TextureAddressingMode.Clamp, FilterOption.Linear, FilterOption.Linear, FilterOption.Point));

                context.objectsDuringUpdate.namedTextures.TryGetValue("depthTexture", out Component_Image depthTexture);
                if (depthTexture == null)
                {
                    //!!!!
                }
                shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(2 /*"depthTexture"*/, depthTexture,
                                                                                   TextureAddressingMode.Clamp, FilterOption.Point, FilterOption.Point, FilterOption.None));

                Vector4 properties = new Vector4(FocalDistance, FocalSize, BackgroundTransitionLength, BlurForeground ? ForegroundTransitionLength : -1);
                shader.Parameters.Set("u_depthOfFieldProperties", properties.ToVector4F());
                shader.Parameters.Set("intensity", (float)Intensity);

                context.RenderQuadToCurrentViewport(shader);
            }

            //free old textures
            context.DynamicTexture_Free(actualTexture);
            context.DynamicTexture_Free(blurTexture);

            //update actual texture
            actualTexture = finalTexture;
        }
コード例 #12
0
        public static void RenderFXAA(ViewportRenderingContext context, Component_RenderingPipeline.IFrameData frameData, ref Component_Image actualTexture, double intensity)
        {
            //render luma

            //!!!!!A8R8G8B8  где еще. когда tonemapping
            //!!!!Specifically do FXAA after tonemapping.

            //!!!!? PixelFormat.Float16RGBA
            var lumaTexture = context.RenderTarget2D_Alloc(actualTexture.Result.ResultSize, PixelFormat.A8R8G8B8);

            {
                context.SetViewport(lumaTexture.Result.GetRenderTarget().Viewports[0]);

                CanvasRenderer.ShaderItem shader = new CanvasRenderer.ShaderItem();
                shader.VertexProgramFileName   = @"Base\Shaders\EffectsCommon_vs.sc";
                shader.FragmentProgramFileName = @"Base\Shaders\Effects\FXAA\Luma_fs.sc";

                shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(0 /*"sourceTexture"*/, actualTexture,
                                                                                   TextureAddressingMode.Clamp, FilterOption.Point, FilterOption.Point, FilterOption.None));

                //!!!!одно и тоже ставится

                //var size = context.owner.SizeInPixels;
                //shader.Parameters.Set( "viewportSize", new Vec4( size.X, size.Y, 1.0 / (double)size.X, 1.0 / (double)size.Y ).ToVec4F() );

                //Mat4F identity = Mat4F.Identity;
                //shader.Parameters.Set( "worldViewProjMatrix", ParameterType.Matrix4x4, 1, &identity, sizeof( Mat4F ) );

                context.RenderQuadToCurrentViewport(shader);
            }

            //free old texture
            context.DynamicTexture_Free(actualTexture);

            //render final
            {
                actualTexture = context.RenderTarget2D_Alloc(actualTexture.Result.ResultSize, PixelFormat.A8R8G8B8);

                context.SetViewport(actualTexture.Result.GetRenderTarget().Viewports[0]);

                CanvasRenderer.ShaderItem shader = new CanvasRenderer.ShaderItem();
                shader.VertexProgramFileName   = @"Base\Shaders\EffectsCommon_vs.sc";
                shader.FragmentProgramFileName = @"Base\Shaders\Effects\FXAA\Final_fs.sc";

                shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(0 /*"sourceTexture"*/, lumaTexture,
                                                                                   TextureAddressingMode.Clamp, FilterOption.Linear, FilterOption.Linear, FilterOption.Point));

                var size = actualTexture.Result.ResultSize;
                shader.Parameters.Set("viewportSize", new Vector4(size.X, size.Y, 1.0 / (double)size.X, 1.0 / (double)size.Y).ToVector4F());

                shader.Parameters.Set("intensity", (float)intensity);                  // Intensity );

                //Mat4F identity = Mat4F.Identity;
                //shader.Parameters.Set( "worldViewProjMatrix", ParameterType.Matrix4x4, 1, &identity, sizeof( Mat4F ) );

                context.RenderQuadToCurrentViewport(shader);
            }

            //free luma texture
            context.DynamicTexture_Free(lumaTexture);
        }
コード例 #13
0
        public virtual Component_Image GaussianBlur(ViewportRenderingContext context, Component_RenderingEffect forEffect, Component_Image sourceTexture, double blurFactor, DownscalingModeEnum downscalingMode, int downscalingValue)
        {
            Component_Image currentTexture = sourceTexture;

            //downscaling
            int downscalingValue2;

            if (downscalingMode == DownscalingModeEnum.Auto)
            {
                downscalingValue2 = (int)(blurFactor / 2.0 + 0.999);
                if (blurFactor <= 1)
                {
                    downscalingValue2 = 0;
                }
                //downscalingValue2 = (int)( Math.Pow( blurFactor, 1.0 / 1.1 ) ) - 1;
                //downscalingValue2 = (int)( Math.Sqrt( blurFactor ) ) - 1;
                //downscalingValue2 = (int)( blurFactor / 1.5 );
            }
            else
            {
                downscalingValue2 = downscalingValue;
            }
            for (int n = 0; n < downscalingValue2; n++)
            {
                var size = currentTexture.Result.ResultSize / 2;
                if (size.X < 1)
                {
                    size.X = 1;
                }
                if (size.Y < 1)
                {
                    size.Y = 1;
                }

                var texture = context.RenderTarget2D_Alloc(size, currentTexture.Result.ResultFormat);
                {
                    context.SetViewport(texture.Result.GetRenderTarget().Viewports[0]);

                    var shader = new CanvasRenderer.ShaderItem();
                    shader.VertexProgramFileName   = @"Base\Shaders\EffectsCommon_vs.sc";
                    shader.FragmentProgramFileName = @"Base\Shaders\Effects\Downscale2_fs.sc";

                    shader.Parameters.Set("sourceSizeInv", new Vector2F(1, 1) / currentTexture.Result.ResultSize.ToVector2F());

                    //shader.Parameters.Set( "0"/*"sourceTexture"*/, new GpuMaterialPass.TextureParameterValue( actualTexture,
                    //	TextureAddressingMode.Clamp, FilterOption.Point, FilterOption.Point, FilterOption.Point ) );
                    shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(0 /*"sourceTexture"*/, currentTexture,
                                                                                       TextureAddressingMode.Clamp, FilterOption.Linear, FilterOption.Linear, FilterOption.Point));

                    context.RenderQuadToCurrentViewport(shader);
                }

                if (currentTexture != sourceTexture)
                {
                    context.DynamicTexture_Free(currentTexture);
                }
                currentTexture = texture;
            }

            //horizontal blur
            //if( dimensions == BlurDimensionsEnum.HorizontalAndVertical || dimensions == BlurDimensionsEnum.Horizontal )
            {
                var texture = context.RenderTarget2D_Alloc(sourceTexture.Result.ResultSize, currentTexture.Result.ResultFormat);
                //var texture = context.RenderTarget2D_Alloc( currentTexture.Result.Size, currentTexture.Result.Format );
                {
                    context.SetViewport(texture.Result.GetRenderTarget().Viewports[0]);

                    var shader = new CanvasRenderer.ShaderItem();
                    shader.VertexProgramFileName   = @"Base\Shaders\EffectsCommon_vs.sc";
                    shader.FragmentProgramFileName = @"Base\Shaders\Effects\Blur_fs.sc";

                    shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(0 /*"sourceTexture"*/, currentTexture,
                                                                                       TextureAddressingMode.Clamp, FilterOption.Linear, FilterOption.Linear, FilterOption.Point));

                    var values = GaussianBlurMath.Calculate15(texture.Result.ResultSize, true, blurFactor);
                    shader.Parameters.Set("sampleOffsets", values.SampleOffsetsAsVec4Array);
                    shader.Parameters.Set("sampleWeights", values.SampleWeights);

                    context.RenderQuadToCurrentViewport(shader);
                }

                if (currentTexture != sourceTexture)
                {
                    context.DynamicTexture_Free(currentTexture);
                }
                currentTexture = texture;
            }

            //vertical blur
            //if( dimensions == BlurDimensionsEnum.HorizontalAndVertical || dimensions == BlurDimensionsEnum.Vertical )
            {
                var texture = context.RenderTarget2D_Alloc(sourceTexture.Result.ResultSize, currentTexture.Result.ResultFormat);
                //var texture = context.RenderTarget2D_Alloc( currentTexture.Result.Size, currentTexture.Result.Format );
                {
                    context.SetViewport(texture.Result.GetRenderTarget().Viewports[0]);

                    var shader = new CanvasRenderer.ShaderItem();
                    shader.VertexProgramFileName   = @"Base\Shaders\EffectsCommon_vs.sc";
                    shader.FragmentProgramFileName = @"Base\Shaders\Effects\Blur_fs.sc";

                    shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(0 /*"sourceTexture"*/, currentTexture,
                                                                                       TextureAddressingMode.Clamp, FilterOption.Linear, FilterOption.Linear, FilterOption.Point));

                    var values = GaussianBlurMath.Calculate15(texture.Result.ResultSize, false, blurFactor);
                    shader.Parameters.Set("sampleOffsets", values.SampleOffsetsAsVec4Array);
                    shader.Parameters.Set("sampleWeights", values.SampleWeights);

                    context.RenderQuadToCurrentViewport(shader);
                }

                if (currentTexture != sourceTexture)
                {
                    context.DynamicTexture_Free(currentTexture);
                }
                currentTexture = texture;
            }

            return(currentTexture);
        }
コード例 #14
0
        unsafe protected override void OnRender(ViewportRenderingContext context, Component_RenderingPipeline.IFrameData frameData, ref Component_Image actualTexture)
        {
            base.OnRender(context, frameData, ref actualTexture);

            //is not supported
            if (!context.RenderingPipeline.GetUseMultiRenderTargets())
            {
                return;
            }

            //downscale for SSAA
            var actualTextureSource = actualTexture;

            if (actualTexture.Result.ResultSize != context.Owner.SizeInPixels)
            {
                actualTexture = context.RenderTarget2D_Alloc(context.Owner.SizeInPixels, actualTextureSource.Result.ResultFormat);

                //copy to scene texture with downscale
                context.SetViewport(actualTexture.Result.GetRenderTarget().Viewports[0]);

                CanvasRenderer.ShaderItem shader = new CanvasRenderer.ShaderItem();
                shader.VertexProgramFileName   = @"Base\Shaders\EffectsCommon_vs.sc";
                shader.FragmentProgramFileName = @"Base\Shaders\Effects\Downscale2_fs.sc";

                shader.Parameters.Set("sourceSizeInv", new Vector2F(1, 1) / actualTextureSource.Result.ResultSize.ToVector2F());

                shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(0 /*"sourceTexture"*/,
                                                                                   actualTextureSource, TextureAddressingMode.Clamp, FilterOption.Linear, FilterOption.Linear, FilterOption.None));

                context.RenderQuadToCurrentViewport(shader);
            }

            // Setup Constants:

            Vector2F viewportPixelSize        = new Vector2F(1.0f / (float)actualTexture.Result.ResultSize.X, 1.0f / (float)actualTexture.Result.ResultSize.Y);
            Vector2F halfViewportPixelSize    = new Vector2F(1.0f / ((float)actualTexture.Result.ResultSize.X * 0.5f), 1.0f / ((float)actualTexture.Result.ResultSize.Y * 0.5f));
            Vector4F quarterViewportPixelSize = new Vector4F(1.0f / ((float)actualTexture.Result.ResultSize.X * 0.25f), 1.0f / ((float)actualTexture.Result.ResultSize.Y * 0.25f), (float)((actualTexture.Result.ResultSize.X / 4) * (actualTexture.Result.ResultSize.Y / 4)), 0.0f);
            Vector2F viewport2xPixelSize      = new Vector2F(viewportPixelSize.X * 2.0f, viewportPixelSize.Y * 2.0f);

            Matrix4F projectionMatrix = context.Owner.CameraSettings.ProjectionMatrix.ToMatrix4F();

            float depthLinearizeMul = -projectionMatrix[3][2];
            float depthLinearizeAdd = projectionMatrix[2][2];

            if (depthLinearizeMul * depthLinearizeAdd < 0.0f)
            {
                depthLinearizeAdd = -depthLinearizeAdd;
            }

            Vector2F depthUnpackConsts = new Vector2F(depthLinearizeMul, depthLinearizeAdd);

            float tanHalfFOVY = 1.0f / projectionMatrix[1][1];
            float tanHalfFOVX = 1.0F / projectionMatrix[0][0];

            Vector2F cameraTanHalfFOV = new Vector2F(tanHalfFOVX, tanHalfFOVY);

            Vector2F NDCToViewMul = new Vector2F(cameraTanHalfFOV.X * 2.0f, cameraTanHalfFOV.Y * -2.0f);
            Vector2F NDCToViewAdd = new Vector2F(cameraTanHalfFOV.X * -1.0f, cameraTanHalfFOV.Y * 1.0f);

            Matrix4F itViewMatrix = (context.Owner.CameraSettings.ViewMatrix.GetInverse().ToMatrix4F()).GetTranspose();

            // Effect Params:

            float effectSamplingRadiusNearLimit = (float)Radius * 1.2f;

            if (Quality.Value == QualityEnum.Low)
            {
                effectSamplingRadiusNearLimit *= 1.50f;
            }

            effectSamplingRadiusNearLimit /= tanHalfFOVY;

            float effectSamplingRadiusNearLimitRec = 1.0f / effectSamplingRadiusNearLimit;

            Vector4F effectRadiusParams = new Vector4F((float)Radius, -1.0f / (float)Radius, effectSamplingRadiusNearLimitRec, 0.0f);

            float effectFadeOutMul = -1.0f / ((float)FadeOutTo - (float)FadeOutFrom);
            float effectFadeOutAdd = (float)FadeOutFrom / ((float)FadeOutTo - (float)FadeOutFrom) + 1.0f;

            float detailAOStrength     = (float)DetailStrength;
            float effectShadowStrength = (float)Multiplier;
            float effectShadowClamp    = 1.0f;
            float effectShadowPow      = (float)Power;

            float invSharpness = 1.0f - (float)Sharpness;

            if (invSharpness < 0.0f)
            {
                invSharpness = 0.0f;
            }
            if (invSharpness > 1.0f)
            {
                invSharpness = 1.0f;
            }

            // First Pass: Prepare 4 Depth half-Buffers:

            Component_Image[] halfDepths = new Component_Image[4];
            for (int i = 0; i < 4; i++)
            {
                halfDepths[i] = context.RenderTarget2D_Alloc(actualTexture.Result.ResultSize / 2, PixelFormat.Float16R);
            }

            var fourDepthsMRT = context.MultiRenderTarget_Create(new[] {
                new MultiRenderTarget.Item(halfDepths[0]),
                new MultiRenderTarget.Item(halfDepths[1]),
                new MultiRenderTarget.Item(halfDepths[2]),
                new MultiRenderTarget.Item(halfDepths[3])
            });

            {
                context.SetViewport(fourDepthsMRT.Viewports[0], Matrix4F.Identity, Matrix4F.Identity, FrameBufferTypes.All, ColorValue.Zero);

                CanvasRenderer.ShaderItem shader = new CanvasRenderer.ShaderItem();
                shader.VertexProgramFileName   = @"Base\Shaders\EffectsCommon_vs.sc";
                shader.FragmentProgramFileName = @"Base\Shaders\Effects\ASSAO\PrepareDepths_fs.sc";

                context.objectsDuringUpdate.namedTextures.TryGetValue("depthTexture", out Component_Image depthTexture);

                shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(0, depthTexture,
                                                                                   TextureAddressingMode.Clamp, FilterOption.Point, FilterOption.Point, FilterOption.None));

                shader.Parameters.Set("depthUnpackConsts", depthUnpackConsts);
                //!!!!use actualTextureSource size?
                shader.Parameters.Set("viewportPixelSize", viewportPixelSize);

                context.RenderQuadToCurrentViewport(shader);
            }

            // Second Pass: prepare 4 Mip-Maps for each Half-Depth-Map:

            Component_Image[,] depthMipMaps = null;

            if (Quality.Value > QualityEnum.Medium)
            {
                Vector2I[] mipMapSizes = new Vector2I[4];                   // Setup Mip-Map sizes:

                mipMapSizes[0] = new Vector2I(actualTexture.Result.ResultSize / 2);
                for (int m = 1; m < 4; m++)
                {
                    mipMapSizes[m] = new Vector2I(mipMapSizes[m - 1] / 2);
                }

                // Prepare MipMaps textures:

                depthMipMaps = new Component_Image[4, 4];

                for (int d = 0; d < 4; d++)
                {
                    depthMipMaps[d, 0] = halfDepths[d];                         // MipMaps 0 is original halfDepthMaps
                    for (int m = 1; m < 4; m++)
                    {
                        depthMipMaps[d, m] = context.RenderTarget2D_Alloc(mipMapSizes[m], PixelFormat.Float16R);
                    }
                }

                for (int m = 1; m < 4; m++)                  // Mip-Maps loop
                {
                    var fourDepthsMipsMRT = context.MultiRenderTarget_Create(new[] {
                        new MultiRenderTarget.Item(depthMipMaps[0, m]),
                        new MultiRenderTarget.Item(depthMipMaps[1, m]),
                        new MultiRenderTarget.Item(depthMipMaps[2, m]),
                        new MultiRenderTarget.Item(depthMipMaps[3, m])
                    });

                    context.SetViewport(fourDepthsMipsMRT.Viewports[0], Matrix4F.Identity, Matrix4F.Identity, FrameBufferTypes.All, ColorValue.Zero);

                    CanvasRenderer.ShaderItem shader = new CanvasRenderer.ShaderItem();
                    shader.VertexProgramFileName   = @"Base\Shaders\EffectsCommon_vs.sc";
                    shader.FragmentProgramFileName = @"Base\Shaders\Effects\ASSAO\PrepareDepthMips_fs.sc";

                    // For current Mip-Map generation using previous Mip-Map:

                    float    prevMipLevel  = (float)(m - 1);
                    var      prevMipSize   = mipMapSizes[m - 1];
                    Vector4F prevMipParams = new Vector4F(1.0f / (float)prevMipSize.X, 1.0f / (float)prevMipSize.Y, prevMipLevel, 0.0f);

                    for (int i = 0; i < 4; i++)
                    {
                        // previous MipMap as input:
                        shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(i, depthMipMaps[i, m - 1],
                                                                                           TextureAddressingMode.Clamp, FilterOption.Point, FilterOption.Point, FilterOption.None));
                    }
                    shader.Parameters.Set("prevMipParams", prevMipParams);
                    shader.Parameters.Set("effectRadiusParams", effectRadiusParams);

                    context.RenderQuadToCurrentViewport(shader);
                }
            }

            Component_Image SSAOTextureArray = new Component_Image();

            Component_Image SSAOBaseTextureArray = null;

            if (Quality.Value == QualityEnum.HighestAdaptive)
            {
                SSAOBaseTextureArray = new Component_Image();
                SSAOBaseTextureArray = context.RenderTarget2D_Alloc(actualTexture.Result.ResultSize / 2, PixelFormat.R8G8_UInt, 0, false, /*0,*/ 4);
            }

            Component_Image importanceMap     = null;
            Component_Image averageImportance = null;

            // Generate Importance Map for Highest/Adaptive Quality mode:
            if (Quality.Value == QualityEnum.HighestAdaptive)
            {
                // 4 SSAO passes:

                for (int pass = 0; pass < 4; pass++)
                {
                    Vector4F[] patternRotScaleMatrices;
                    GeneratePatternRotScaleMatrices(pass, out patternRotScaleMatrices);

                    Vector2F perPassFullResCoordOffset = new Vector2F((float)(pass % 2), (float)(pass / 2));

                    {
                        context.SetViewport(SSAOBaseTextureArray.Result.GetRenderTarget(0, pass).Viewports[0],
                                            Matrix4F.Identity, Matrix4F.Identity, FrameBufferTypes.All, ColorValue.Zero);

                        CanvasRenderer.ShaderItem shader = new CanvasRenderer.ShaderItem();
                        shader.VertexProgramFileName   = @"Base\Shaders\EffectsCommon_vs.sc";
                        shader.FragmentProgramFileName = @"Base\Shaders\Effects\ASSAO\GenerateSSAO_AdaptiveBase_fs.sc";

                        context.objectsDuringUpdate.namedTextures.TryGetValue("normalTexture", out Component_Image normalTexture);

                        for (int m = 0; m < 4; m++)
                        {
                            shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(m, depthMipMaps[pass, m],
                                                                                               TextureAddressingMode.Clamp, FilterOption.Point, FilterOption.Point, FilterOption.None));
                        }

                        shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(4, halfDepths[pass],
                                                                                           TextureAddressingMode.Mirror, FilterOption.Point, FilterOption.Point, FilterOption.None));

                        shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(5, normalTexture,
                                                                                           TextureAddressingMode.Clamp, FilterOption.Point, FilterOption.Point, FilterOption.None));

                        shader.Parameters.Set("NDCToViewMul", NDCToViewMul);
                        shader.Parameters.Set("NDCToViewAdd", NDCToViewAdd);
                        shader.Parameters.Set("effectRadiusParams", effectRadiusParams);
                        shader.Parameters.Set("viewportPixelSize", viewportPixelSize);
                        shader.Parameters.Set("viewport2xPixelSize", viewport2xPixelSize);
                        shader.Parameters.Set("halfViewportPixelSize", halfViewportPixelSize);
                        shader.Parameters.Set("perPassFullResCoordOffset", perPassFullResCoordOffset);
                        shader.Parameters.Set("patternRotScaleMatrices", patternRotScaleMatrices);
                        shader.Parameters.Set("effectFadeOutMul", effectFadeOutMul);
                        shader.Parameters.Set("effectFadeOutAdd", effectFadeOutAdd);
                        shader.Parameters.Set("effectShadowStrength", effectShadowStrength);
                        shader.Parameters.Set("effectShadowClamp", effectShadowClamp);
                        shader.Parameters.Set("effectShadowPow", effectShadowPow);
                        shader.Parameters.Set("detailAOStrength", detailAOStrength);
                        shader.Parameters.Set("itViewMatrix", itViewMatrix);

                        context.RenderQuadToCurrentViewport(shader);
                    }
                }

                // Importance Map Generation:
                importanceMap = context.RenderTarget2D_Alloc(actualTexture.Result.ResultSize / 4, PixelFormat.L8);
                {
                    context.SetViewport(importanceMap.Result.GetRenderTarget().Viewports[0],
                                        Matrix4F.Identity, Matrix4F.Identity, FrameBufferTypes.All, ColorValue.Zero);

                    CanvasRenderer.ShaderItem shader = new CanvasRenderer.ShaderItem();
                    shader.VertexProgramFileName   = @"Base\Shaders\EffectsCommon_vs.sc";
                    shader.FragmentProgramFileName = @"Base\Shaders\Effects\ASSAO\GenerateImportanceMap_fs.sc";

                    shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(0, SSAOBaseTextureArray,
                                                                                       TextureAddressingMode.Clamp, FilterOption.Point, FilterOption.Point, FilterOption.None));

                    shader.Parameters.Set("halfViewportPixelSize", halfViewportPixelSize);
                    shader.Parameters.Set("effectShadowStrength", effectShadowStrength);
                    shader.Parameters.Set("effectShadowPow", effectShadowPow);

                    context.RenderQuadToCurrentViewport(shader);
                }

                // Importance Map Post-Process A:
                var importanceMapPong = context.RenderTarget2D_Alloc(actualTexture.Result.ResultSize / 4, PixelFormat.L8);
                {
                    context.SetViewport(importanceMapPong.Result.GetRenderTarget().Viewports[0],
                                        Matrix4F.Identity, Matrix4F.Identity, FrameBufferTypes.All, ColorValue.Zero);

                    CanvasRenderer.ShaderItem shader = new CanvasRenderer.ShaderItem();
                    shader.VertexProgramFileName   = @"Base\Shaders\EffectsCommon_vs.sc";
                    shader.FragmentProgramFileName = @"Base\Shaders\Effects\ASSAO\PostProcessImportanceMapA_fs.sc";

                    shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(0, importanceMap,
                                                                                       TextureAddressingMode.Clamp, FilterOption.Linear, FilterOption.Linear, FilterOption.None));

                    shader.Parameters.Set("quarterViewportPixelSize", quarterViewportPixelSize);

                    context.RenderQuadToCurrentViewport(shader);
                }

                // Importance Map Post-Process B:
                {
                    context.SetViewport(importanceMap.Result.GetRenderTarget().Viewports[0],
                                        Matrix4F.Identity, Matrix4F.Identity, FrameBufferTypes.All, ColorValue.Zero);

                    CanvasRenderer.ShaderItem shader = new CanvasRenderer.ShaderItem();
                    shader.VertexProgramFileName   = @"Base\Shaders\EffectsCommon_vs.sc";
                    shader.FragmentProgramFileName = @"Base\Shaders\Effects\ASSAO\PostProcessImportanceMapB_fs.sc";

                    shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(0, importanceMapPong,
                                                                                       TextureAddressingMode.Clamp, FilterOption.Linear, FilterOption.Linear, FilterOption.None));

                    shader.Parameters.Set("quarterViewportPixelSize", quarterViewportPixelSize);

                    context.RenderQuadToCurrentViewport(shader);
                }

                context.DynamicTexture_Free(importanceMapPong);

                // Get Average Importance Pass:
                averageImportance = context.RenderTarget2D_Alloc(new Vector2I(1, 1), PixelFormat.L8);
                {
                    context.SetViewport(averageImportance.Result.GetRenderTarget().Viewports[0],
                                        Matrix4F.Identity, Matrix4F.Identity, FrameBufferTypes.All, ColorValue.Zero);

                    CanvasRenderer.ShaderItem shader = new CanvasRenderer.ShaderItem();
                    shader.VertexProgramFileName   = @"Base\Shaders\EffectsCommon_vs.sc";
                    shader.FragmentProgramFileName = @"Base\Shaders\Effects\ASSAO\GetAverageImportance_fs.sc";

                    shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(0, importanceMap,
                                                                                       TextureAddressingMode.Clamp, FilterOption.Point, FilterOption.Point, FilterOption.None));

                    shader.Parameters.Set("quarterViewportPixelSize", quarterViewportPixelSize);

                    context.RenderQuadToCurrentViewport(shader);
                }
            }

            // Third Pass: Generate 4 SSAO buffers:

            Component_Image blurPingTexture = null, blurPongTexture = null;

            if (BlurAmount.Value > 0)
            {
                blurPingTexture = context.RenderTarget2D_Alloc(actualTexture.Result.ResultSize / 2, PixelFormat.R8G8_UInt);
                blurPongTexture = context.RenderTarget2D_Alloc(actualTexture.Result.ResultSize / 2, PixelFormat.R8G8_UInt);
            }

            SSAOTextureArray = context.RenderTarget2D_Alloc(actualTexture.Result.ResultSize / 2, PixelFormat.R8G8_UInt, 0, false, /*0,*/ 4);

            for (int pass = 0; pass < 4; pass++)
            {
                Vector4F[] patternRotScaleMatrices;
                GeneratePatternRotScaleMatrices(pass, out patternRotScaleMatrices);

                Vector2F perPassFullResCoordOffset = new Vector2F((float)(pass % 2), (float)(pass / 2));

                {
                    if (BlurAmount.Value == 0)
                    {
                        context.SetViewport(SSAOTextureArray.Result.GetRenderTarget(0, pass).Viewports[0],
                                            Matrix4F.Identity, Matrix4F.Identity, FrameBufferTypes.All, ColorValue.Zero);
                    }
                    else
                    {
                        context.SetViewport(blurPingTexture.Result.GetRenderTarget().Viewports[0],
                                            Matrix4F.Identity, Matrix4F.Identity, FrameBufferTypes.All, ColorValue.Zero);
                    }

                    CanvasRenderer.ShaderItem shader = new CanvasRenderer.ShaderItem();
                    shader.VertexProgramFileName = @"Base\Shaders\EffectsCommon_vs.sc";

                    if (Quality.Value == QualityEnum.Low)
                    {
                        shader.FragmentProgramFileName = @"Base\Shaders\Effects\ASSAO\GenerateSSAO_LQ_fs.sc";
                    }
                    else if (Quality.Value == QualityEnum.Medium)
                    {
                        shader.FragmentProgramFileName = @"Base\Shaders\Effects\ASSAO\GenerateSSAO_MQ_fs.sc";
                    }
                    else if (Quality.Value == QualityEnum.High)
                    {
                        shader.FragmentProgramFileName = @"Base\Shaders\Effects\ASSAO\GenerateSSAO_HQ_fs.sc";
                    }
                    else if (Quality.Value == QualityEnum.HighestAdaptive)
                    {
                        shader.FragmentProgramFileName = @"Base\Shaders\Effects\ASSAO\GenerateSSAO_HAQ_fs.sc";
                    }

                    context.objectsDuringUpdate.namedTextures.TryGetValue("normalTexture", out Component_Image normalTexture);

                    if (Quality.Value > QualityEnum.Medium)
                    {
                        for (int m = 0; m < 4; m++)
                        {
                            shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(m, depthMipMaps[pass, m],
                                                                                               TextureAddressingMode.Clamp, FilterOption.Point, FilterOption.Point, FilterOption.None));
                        }

                        shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(4, halfDepths[pass],
                                                                                           TextureAddressingMode.Mirror, FilterOption.Point, FilterOption.Point, FilterOption.None));

                        shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(5, normalTexture,
                                                                                           TextureAddressingMode.Clamp, FilterOption.Point, FilterOption.Point, FilterOption.None));

                        if (Quality.Value == QualityEnum.HighestAdaptive)
                        {
                            shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(6, importanceMap,
                                                                                               TextureAddressingMode.Clamp, FilterOption.Linear, FilterOption.Linear, FilterOption.None));
                            shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(7, averageImportance,
                                                                                               TextureAddressingMode.Clamp, FilterOption.Point, FilterOption.Point, FilterOption.None));
                            shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(8, SSAOBaseTextureArray,
                                                                                               TextureAddressingMode.Clamp, FilterOption.Point, FilterOption.Point, FilterOption.None));
                        }
                    }
                    else
                    {
                        shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(0, halfDepths[pass],
                                                                                           TextureAddressingMode.Clamp, FilterOption.Point, FilterOption.Point, FilterOption.None));

                        shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(1, halfDepths[pass],
                                                                                           TextureAddressingMode.Mirror, FilterOption.Point, FilterOption.Point, FilterOption.None));

                        shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(2, normalTexture,
                                                                                           TextureAddressingMode.Clamp, FilterOption.Point, FilterOption.Point, FilterOption.None));
                    }

                    shader.Parameters.Set("NDCToViewMul", NDCToViewMul);
                    shader.Parameters.Set("NDCToViewAdd", NDCToViewAdd);
                    shader.Parameters.Set("effectRadiusParams", effectRadiusParams);
                    shader.Parameters.Set("viewportPixelSize", viewportPixelSize);
                    shader.Parameters.Set("viewport2xPixelSize", viewport2xPixelSize);
                    shader.Parameters.Set("halfViewportPixelSize", halfViewportPixelSize);
                    shader.Parameters.Set("perPassFullResCoordOffset", perPassFullResCoordOffset);
                    shader.Parameters.Set("patternRotScaleMatrices", patternRotScaleMatrices);
                    shader.Parameters.Set("effectFadeOutMul", effectFadeOutMul);
                    shader.Parameters.Set("effectFadeOutAdd", effectFadeOutAdd);
                    shader.Parameters.Set("effectShadowStrength", effectShadowStrength);
                    shader.Parameters.Set("effectShadowClamp", effectShadowClamp);
                    shader.Parameters.Set("effectShadowPow", effectShadowPow);
                    shader.Parameters.Set("detailAOStrength", detailAOStrength);
                    shader.Parameters.Set("itViewMatrix", itViewMatrix);

                    if (Quality.Value == QualityEnum.HighestAdaptive)
                    {
                        shader.Parameters.Set("adaptiveSampleCountLimit", (float)AdaptiveQualityLimit);
                        shader.Parameters.Set("passNumber", (float)pass);
                    }

                    context.RenderQuadToCurrentViewport(shader);
                }

                if (Quality.Value > QualityEnum.Medium)
                {
                    // Free Mip-Maps Targets for this Pass:
                    for (int m = 0; m < 4; m++)
                    {
                        context.DynamicTexture_Free(depthMipMaps[pass, m]);
                    }
                }
                else
                {
                    context.DynamicTexture_Free(halfDepths[pass]);
                }

                // Blur SSAO Texture:

                if (BlurAmount.Value > 0)
                {
                    int wideBlursRemaining = Math.Max(0, BlurAmount.Value - 2);

                    for (int i = 0; i < BlurAmount.Value; i++)
                    {
                        if (i == (BlurAmount.Value - 1))
                        {
                            context.SetViewport(SSAOTextureArray.Result.GetRenderTarget(0, pass).Viewports[0],
                                                Matrix4F.Identity, Matrix4F.Identity, FrameBufferTypes.All, ColorValue.Zero);
                        }
                        else
                        {
                            context.SetViewport(blurPongTexture.Result.GetRenderTarget().Viewports[0],
                                                Matrix4F.Identity, Matrix4F.Identity, FrameBufferTypes.All, ColorValue.Zero);
                        }

                        CanvasRenderer.ShaderItem shader = new CanvasRenderer.ShaderItem();
                        shader.VertexProgramFileName = @"Base\Shaders\EffectsCommon_vs.sc";

                        if (Quality.Value > QualityEnum.Low)
                        {
                            if (wideBlursRemaining > 0)
                            {
                                shader.FragmentProgramFileName = @"Base\Shaders\Effects\ASSAO\SmartBlurWide_fs.sc";
                                wideBlursRemaining--;
                            }
                            else
                            {
                                shader.FragmentProgramFileName = @"Base\Shaders\Effects\ASSAO\SmartBlur_fs.sc";
                            }
                        }
                        else
                        {
                            shader.FragmentProgramFileName = @"Base\Shaders\Effects\ASSAO\NonSmartBlur_fs.sc";
                        }

                        if (Quality.Value > QualityEnum.Low)
                        {
                            shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(0, blurPingTexture,
                                                                                               TextureAddressingMode.Mirror, FilterOption.Point, FilterOption.Point, FilterOption.None));
                            shader.Parameters.Set("invSharpness", invSharpness);
                        }
                        else
                        {
                            shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(0, blurPingTexture,
                                                                                               TextureAddressingMode.Clamp, FilterOption.Linear, FilterOption.Linear, FilterOption.None));
                        }

                        shader.Parameters.Set("halfViewportPixelSize", halfViewportPixelSize);

                        context.RenderQuadToCurrentViewport(shader);

                        // Swap Ping-Pong Blur textures:
                        var tmp_tex = blurPingTexture;
                        blurPingTexture = blurPongTexture;
                        blurPongTexture = tmp_tex;
                    }
                }
            }

            if (Quality.Value == QualityEnum.HighestAdaptive)
            {
                context.DynamicTexture_Free(SSAOBaseTextureArray);
            }

            if (Quality.Value == QualityEnum.HighestAdaptive)
            {
                context.DynamicTexture_Free(importanceMap);
                context.DynamicTexture_Free(averageImportance);
            }

            if (BlurAmount.Value > 0)
            {
                // Free Blur ping/pong Targets:
                context.DynamicTexture_Free(blurPingTexture);
                context.DynamicTexture_Free(blurPongTexture);
            }

            // 4th Pass: Apply 4 SSAO Textures to Final SSAO Result:

            var FullSSAOTexture = context.RenderTarget2D_Alloc(actualTexture.Result.ResultSize, PixelFormat.R8G8_UInt);

            {
                context.SetViewport(FullSSAOTexture.Result.GetRenderTarget().Viewports[0],
                                    Matrix4F.Identity, Matrix4F.Identity, FrameBufferTypes.All, ColorValue.Zero);

                CanvasRenderer.ShaderItem shader = new CanvasRenderer.ShaderItem();
                shader.VertexProgramFileName = @"Base\Shaders\EffectsCommon_vs.sc";

                if (Quality.Value > QualityEnum.Low)
                {
                    shader.FragmentProgramFileName = @"Base\Shaders\Effects\ASSAO\Apply_fs.sc";
                }
                else
                {
                    shader.FragmentProgramFileName = @"Base\Shaders\Effects\ASSAO\Apply_noSmart_fs.sc";
                }

                if (Quality.Value > QualityEnum.Low)
                {
                    shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(0, SSAOTextureArray,
                                                                                       TextureAddressingMode.Clamp, FilterOption.Point, FilterOption.Point, FilterOption.None));

                    shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(1, SSAOTextureArray,
                                                                                       TextureAddressingMode.Clamp, FilterOption.Linear, FilterOption.Linear, FilterOption.None));
                }
                else
                {
                    shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(0, SSAOTextureArray,
                                                                                       TextureAddressingMode.Clamp, FilterOption.Linear, FilterOption.Linear, FilterOption.None));
                }

                if (Quality.Value > QualityEnum.Low)
                {
                    shader.Parameters.Set("invSharpness", invSharpness);
                    shader.Parameters.Set("halfViewportPixelSize", halfViewportPixelSize);
                }

                context.RenderQuadToCurrentViewport(shader);
            }

            // Free SSAO Texture Array Target:
            context.DynamicTexture_Free(SSAOTextureArray);

            // 5th Final Pass:
            var finalTexture = context.RenderTarget2D_Alloc(actualTextureSource.Result.ResultSize, actualTextureSource.Result.ResultFormat);

            {
                context.SetViewport(finalTexture.Result.GetRenderTarget().Viewports[0]);

                CanvasRenderer.ShaderItem shader = new CanvasRenderer.ShaderItem();
                shader.VertexProgramFileName   = @"Base\Shaders\EffectsCommon_vs.sc";
                shader.FragmentProgramFileName = @"Base\Shaders\Effects\ASSAO\Final_fs.sc";

                shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(0, actualTextureSource,
                                                                                   TextureAddressingMode.Clamp, FilterOption.Point, FilterOption.Point, FilterOption.None));

                shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(1, FullSSAOTexture,
                                                                                   TextureAddressingMode.Clamp, FilterOption.Point, FilterOption.Point, FilterOption.None));

                shader.Parameters.Set("intensity", (float)Intensity);
                shader.Parameters.Set("showAO", ShowAO ? 1.0f : -1.0f);

                context.RenderQuadToCurrentViewport(shader);
            }

            // Free Targets:
            context.DynamicTexture_Free(actualTexture);
            if (actualTextureSource != actualTexture)
            {
                context.DynamicTexture_Free(actualTextureSource);
            }
            context.DynamicTexture_Free(FullSSAOTexture);

            // Update actual Texture:
            actualTexture = finalTexture;
        }
コード例 #15
0
ファイル: GaussianBlur.cs プロジェクト: zwiglm/NeoAxisEngine
        /////////////////////////////////////////

        protected override void OnRender(ViewportRenderingContext context, Component_RenderingPipeline.IFrameData frameData, ref Component_Image actualTexture)
        {
            base.OnRender(context, frameData, ref actualTexture);

            //blur
            var pipeline    = (Component_RenderingPipeline_Basic)context.RenderingPipeline;
            var blurTexture = pipeline.GaussianBlur(context, this, actualTexture, BlurFactor, DownscalingMode, DownscalingValue);

            //create final
            var finalTexture = context.RenderTarget2D_Alloc(actualTexture.Result.ResultSize, actualTexture.Result.ResultFormat);

            {
                context.SetViewport(finalTexture.Result.GetRenderTarget().Viewports[0]);

                var shader = new CanvasRenderer.ShaderItem();
                shader.VertexProgramFileName   = @"Base\Shaders\EffectsCommon_vs.sc";
                shader.FragmentProgramFileName = @"Base\Shaders\Lerp_fs.sc";

                shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(0 /*"source1Texture"*/, actualTexture,
                                                                                   TextureAddressingMode.Clamp, FilterOption.Point, FilterOption.Point, FilterOption.None));
                shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(1 /*"source2Texture"*/, blurTexture,
                                                                                   TextureAddressingMode.Clamp, FilterOption.Point, FilterOption.Point, FilterOption.None));
                shader.Parameters.Set("intensity", (float)Intensity);

                context.RenderQuadToCurrentViewport(shader);
            }

            //free old textures
            context.DynamicTexture_Free(actualTexture);
            context.DynamicTexture_Free(blurTexture);

            //update actual texture
            actualTexture = finalTexture;



            //////////////

            //int downscaling;
            //if( DownscalingMode.Value == DownscalingModeEnum.Auto )
            //	downscaling = (int)( BlurFactor / 1.5 );
            //else
            //	downscaling = Downscaling;

            ////var dimensions = BlurDimensions.Value;
            ////var downscaling = Math.Max( Downscaling.Value, 1 );
            ////var size = context.Owner.SizeInPixels / downscaling;

            //List<Component_Texture> textureToFree = new List<Component_Texture>();
            //Component_Texture currentTexture = actualTexture;

            ////Component_Texture textureDownscalingd = null;
            ////Component_Texture textureH = null;
            ////Component_Texture textureV = null;

            ////downscaling
            //for( int n = 0; n < downscaling; n++ )
            //{
            //	var texture = context.RenderTarget2D_Alloc( currentTexture.Result.Size / 2, currentTexture.Result.Format );
            //	{
            //		context.SetViewport( texture.Result.GetRenderTarget().Viewports[ 0 ] );

            //		var shader = new CanvasRenderer.ShaderItem();
            //		shader.VertexProgramFileName = @"Base\Shaders\EffectsCommon_vs.sc";
            //		shader.FragmentProgramFileName = @"Base\Shaders\Effects\Downscale2_fs.sc";

            //		shader.Parameters.Set( "sourceSizeInv", new Vec2F( 1, 1 ) / currentTexture.Result.Size.ToVec2F() );

            //		//shader.Parameters.Set( "0"/*"sourceTexture"*/, new GpuMaterialPass.TextureParameterValue( actualTexture,
            //		//	TextureAddressingMode.Clamp, FilterOption.Point, FilterOption.Point, FilterOption.Point ) );
            //		shader.Parameters.Set( "0"/*"sourceTexture"*/, new GpuMaterialPass.TextureParameterValue( currentTexture,
            //			TextureAddressingMode.Clamp, FilterOption.Linear, FilterOption.Linear, FilterOption.Point ) );

            //		context.RenderQuadToCurrentViewport( shader );
            //	}

            //	currentTexture = texture;
            //	textureToFree.Add( texture );
            //}

            ////horizontal blur
            ////if( dimensions == BlurDimensionsEnum.HorizontalAndVertical || dimensions == BlurDimensionsEnum.Horizontal )
            //{
            //	var texture = context.RenderTarget2D_Alloc( actualTexture.Result.Size, currentTexture.Result.Format );
            //	//var texture = context.RenderTarget2D_Alloc( currentTexture.Result.Size, currentTexture.Result.Format );
            //	{
            //		context.SetViewport( texture.Result.GetRenderTarget().Viewports[ 0 ] );

            //		var shader = new CanvasRenderer.ShaderItem();
            //		shader.VertexProgramFileName = @"Base\Shaders\EffectsCommon_vs.sc";
            //		shader.FragmentProgramFileName = @"Base\Shaders\Effects\Blur_fs.sc";

            //		shader.Parameters.Set( "0"/*"sourceTexture"*/, new GpuMaterialPass.TextureParameterValue( currentTexture,
            //			TextureAddressingMode.Clamp, FilterOption.Linear, FilterOption.Linear, FilterOption.Point ) );
            //		SetShaderParameters( shader, texture.Result.Size, true );

            //		context.RenderQuadToCurrentViewport( shader );
            //	}

            //	currentTexture = texture;
            //	textureToFree.Add( texture );
            //}

            ////vertical blur
            ////if( dimensions == BlurDimensionsEnum.HorizontalAndVertical || dimensions == BlurDimensionsEnum.Vertical )
            //{
            //	var texture = context.RenderTarget2D_Alloc( actualTexture.Result.Size, currentTexture.Result.Format );
            //	//var texture = context.RenderTarget2D_Alloc( currentTexture.Result.Size, currentTexture.Result.Format );
            //	{
            //		context.SetViewport( texture.Result.GetRenderTarget().Viewports[ 0 ] );

            //		var shader = new CanvasRenderer.ShaderItem();
            //		shader.VertexProgramFileName = @"Base\Shaders\EffectsCommon_vs.sc";
            //		shader.FragmentProgramFileName = @"Base\Shaders\Effects\Blur_fs.sc";

            //		shader.Parameters.Set( "0"/*"sourceTexture"*/, new GpuMaterialPass.TextureParameterValue( currentTexture,
            //			TextureAddressingMode.Clamp, FilterOption.Linear, FilterOption.Linear, FilterOption.Point ) );
            //		SetShaderParameters( shader, texture.Result.Size, false );

            //		context.RenderQuadToCurrentViewport( shader );
            //	}

            //	currentTexture = texture;
            //	textureToFree.Add( texture );
            //}

            //////horizontal blur
            ////if( dimensions == BlurDimensionsEnum.HorizontalAndVertical || dimensions == BlurDimensionsEnum.Horizontal )
            ////{
            ////	textureH = context.RenderTarget2D_Alloc( size, actualTexture.Result.Format );
            ////	{
            ////		context.SetViewport( textureH.Result.GetRenderTarget().Viewports[ 0 ] );

            ////		var shader = new CanvasRenderer.ShaderItem();
            ////		shader.VertexProgramFileName = @"Base\Shaders\EffectsCommon_vs.sc";
            ////		shader.FragmentProgramFileName = @"Base\Shaders\Effects\Blur_fs.sc";

            ////		shader.Parameters.Set( "0"/*"sourceTexture"*/, new GpuMaterialPass.TextureParameterValue( actualTexture,
            ////			TextureAddressingMode.Clamp, FilterOption.Linear, FilterOption.Linear, FilterOption.Point ) );
            ////		SetShaderParameters( shader, size, true );

            ////		context.RenderQuadToCurrentViewport( shader );
            ////	}
            ////}

            //////vertical blur
            ////if( dimensions == BlurDimensionsEnum.HorizontalAndVertical || dimensions == BlurDimensionsEnum.Vertical )
            ////{
            ////	textureV = context.RenderTarget2D_Alloc( size, actualTexture.Result.Format );
            ////	{
            ////		context.SetViewport( textureV.Result.GetRenderTarget().Viewports[ 0 ] );

            ////		var shader = new CanvasRenderer.ShaderItem();
            ////		shader.VertexProgramFileName = @"Base\Shaders\EffectsCommon_vs.sc";
            ////		shader.FragmentProgramFileName = @"Base\Shaders\Effects\Blur_fs.sc";

            ////		shader.Parameters.Set( "0"/*"sourceTexture"*/, new GpuMaterialPass.TextureParameterValue( textureH != null ? textureH : actualTexture,
            ////			TextureAddressingMode.Clamp, FilterOption.Linear, FilterOption.Linear, FilterOption.Point ) );
            ////		SetShaderParameters( shader, size, false );

            ////		context.RenderQuadToCurrentViewport( shader );
            ////	}
            ////}

            //////free old texture
            ////if( textureH != null && textureV != null )
            ////{
            ////	context.RenderTarget_Free( textureH );
            ////	textureH = null;
            ////}

            ////create final
            //var finalTexture = context.RenderTarget2D_Alloc( actualTexture.Result.ResultSize, actualTexture.Result.Format );
            //{
            //	context.SetViewport( finalTexture.Result.GetRenderTarget().Viewports[ 0 ] );

            //	var shader = new CanvasRenderer.ShaderItem();
            //	shader.VertexProgramFileName = @"Base\Shaders\EffectsCommon_vs.sc";
            //	shader.FragmentProgramFileName = @"Base\Shaders\Lerp_fs.sc";

            //	shader.Parameters.Set( "0"/*"source1Texture"*/, new GpuMaterialPass.TextureParameterValue( actualTexture,
            //		TextureAddressingMode.Clamp, FilterOption.Point, FilterOption.Point, FilterOption.None ) );
            //	shader.Parameters.Set( "1"/*"source2Texture"*/, new GpuMaterialPass.TextureParameterValue( currentTexture,
            //		TextureAddressingMode.Clamp, FilterOption.Point, FilterOption.Point, FilterOption.None ) );
            //	shader.Parameters.Set( "intensity", (float)Intensity );

            //	context.RenderQuadToCurrentViewport( shader );
            //}

            ////free old textures
            //context.RenderTarget_Free( actualTexture );
            //foreach( var texture in textureToFree )
            //	context.RenderTarget_Free( texture );
            ////if( textureH != null )
            ////	context.RenderTarget_Free( textureH );
            ////if( textureV != null )
            ////	context.RenderTarget_Free( textureV );

            ////update actual texture
            //actualTexture = finalTexture;
        }
コード例 #16
0
ファイル: LightShafts.cs プロジェクト: zwiglm/NeoAxisEngine
        //!!!!
        //!!!!need per camera context
        //double smoothIntensityFactorLastUpdate;
        //double? smoothIntensityFactor;

        /////////////////////////////////////////

        protected override void OnRender(ViewportRenderingContext context, Component_RenderingPipeline.IFrameData frameData, ref Component_Image actualTexture)
        {
            base.OnRender(context, frameData, ref actualTexture);

            var cameraSettings = context.Owner.CameraSettings;

            bool    lightFound    = false;
            Vector3 lightPosition = Vector3.Zero;

            if (OverrideDirection.Value != Vector3.Zero)
            {
                lightFound    = true;
                lightPosition = cameraSettings.Position - OverrideDirection.Value.GetNormalize() * cameraSettings.FarClipDistance;
            }
            else
            {
                if (Light.ReferenceSpecified)
                {
                    var light = Light.Value;
                    if (light != null)
                    {
                        lightFound = true;
                        if (light.Type.Value == Component_Light.TypeEnum.Directional)
                        {
                            lightPosition = cameraSettings.Position - light.TransformV.Rotation.GetForward() * cameraSettings.FarClipDistance;
                        }
                        else
                        {
                            lightPosition = light.TransformV.Position;
                        }
                    }
                }
                else
                {
                    var frameData2 = frameData as Component_RenderingPipeline_Basic.FrameData;
                    if (frameData2 != null)
                    {
                        foreach (var lightIndex in frameData2.LightsInFrustumSorted)
                        {
                            var item = frameData2.Lights[lightIndex];
                            if (item.data.Type == Component_Light.TypeEnum.Directional)
                            {
                                lightFound    = true;
                                lightPosition = cameraSettings.Position - item.data.Rotation.GetForward() * (float)cameraSettings.FarClipDistance;
                                break;
                            }
                        }
                    }
                }
            }

            if (!lightFound)
            {
                return;
            }
            if (!context.Owner.CameraSettings.ProjectToScreenCoordinates(lightPosition, out var screenLightPosition))
            {
                return;
            }

            //calculate intensity factor by the sun position on the screen.
            double demandIntensityFactor = 0;
            {
                Degree angle = 0;
                if (lightPosition != cameraSettings.Position)
                {
                    angle = MathAlgorithms.GetVectorsAngle(cameraSettings.Rotation.GetForward(),
                                                           (lightPosition - cameraSettings.Position).GetNormalize()).InDegrees();
                }
                else
                {
                    angle = 10000;
                }

                var curve = new CurveLine();
                curve.AddPoint(0, new Vector3(1, 0, 0));
                curve.AddPoint(60, new Vector3(1, 0, 0));
                curve.AddPoint(75, new Vector3(0, 0, 0));
                curve.AddPoint(90, new Vector3(0, 0, 0));
                var angleFactor = curve.CalculateValueByTime(angle).X;

                var curve2 = new CurveLine();
                curve2.AddPoint(-0.2, new Vector3(0, 0, 0));
                curve2.AddPoint(-0.1, new Vector3(1, 0, 0));
                curve2.AddPoint(1.1, new Vector3(1, 0, 0));
                curve2.AddPoint(1.2, new Vector3(0, 0, 0));
                var heightFactor = curve2.CalculateValueByTime(screenLightPosition.Y).X;

                demandIntensityFactor = angleFactor * heightFactor;

                //const float screenFadingBorder = .1f;

                //double minDistance = 1;

                //for( int axis = 0; axis < 2; axis++ )
                //{
                //	if( screenLightPosition[ axis ] < screenFadingBorder )
                //	{
                //		var d = screenLightPosition[ axis ];
                //		if( d < minDistance )
                //			minDistance = d;
                //	}
                //	else if( screenLightPosition[ axis ] > 1.0f - screenFadingBorder )
                //	{
                //		var d = 1.0f - screenLightPosition[ axis ];
                //		if( d < minDistance )
                //			minDistance = d;
                //	}
                //}
                //needIntensityFactor = minDistance / screenFadingBorder;
                //MathEx.Saturate( ref needIntensityFactor );

                ////clamp screenLightPosition
                //if( !new Rectangle( 0, 0, 1, 1 ).Contains( screenLightPosition ) )
                //{
                //	if( MathAlgorithms.IntersectRectangleLine( new Rectangle( .0001f, .0001f, .9999f, .9999f ),
                //		new Vector2( .5f, .5f ), screenLightPosition, out var intersectPoint1, out var intersectPoint2 ) != 0 )
                //	{
                //		screenLightPosition = intersectPoint1;
                //	}
                //}
            }

            var smoothIntensityFactor = demandIntensityFactor;
            ////update smooth intensity factor
            //if( smoothIntensityFactor == null )
            //	smoothIntensityFactor = needIntensityFactor;
            //if( smoothIntensityFactorLastUpdate != context.Owner.LastUpdateTime )
            //{
            //	smoothIntensityFactorLastUpdate = context.Owner.LastUpdateTime;

            //	const double smoothSpeed = 1;
            //	var step = context.Owner.LastUpdateTimeStep * smoothSpeed;

            //	if( needIntensityFactor > smoothIntensityFactor )
            //	{
            //		smoothIntensityFactor += step;
            //		if( smoothIntensityFactor > needIntensityFactor )
            //			smoothIntensityFactor = needIntensityFactor;
            //	}
            //	else
            //	{
            //		smoothIntensityFactor -= step;
            //		if( smoothIntensityFactor < needIntensityFactor )
            //			smoothIntensityFactor = needIntensityFactor;
            //	}
            //}

            //get result intensity
            var resultIntensity = Intensity.Value * smoothIntensityFactor;

            if (resultIntensity <= 0)
            {
                return;
            }

            double divisor = 9.0 - Resolution;

            if (divisor <= 1)
            {
                divisor = 1;
            }
            var sizeFloat = actualTexture.Result.ResultSize.ToVector2() / divisor;
            var size      = new Vector2I((int)sizeFloat.X, (int)sizeFloat.Y);

            //scattering pass
            var scatteringTexture = context.RenderTarget2D_Alloc(size, PixelFormat.A8R8G8B8);              //!!!! PixelFormat.R8G8B8 );
            {
                context.SetViewport(scatteringTexture.Result.GetRenderTarget().Viewports[0]);

                CanvasRenderer.ShaderItem shader = new CanvasRenderer.ShaderItem();
                shader.VertexProgramFileName   = @"Base\Shaders\EffectsCommon_vs.sc";
                shader.FragmentProgramFileName = @"Base\Shaders\Effects\LightShafts\Scattering_fs.sc";

                context.objectsDuringUpdate.namedTextures.TryGetValue("depthTexture", out var depthTexture);
                if (depthTexture == null)
                {
                    //!!!!
                }

                shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(0 /*"depthTexture"*/, depthTexture,
                                                                                   TextureAddressingMode.Clamp, FilterOption.Point, FilterOption.Point, FilterOption.None));
                shader.Parameters.Set("screenLightPosition", screenLightPosition.ToVector2F());
                shader.Parameters.Set("decay", (float)Decay);
                shader.Parameters.Set("density", (float)Density);

                context.RenderQuadToCurrentViewport(shader);
            }

            //blur pass
            var blurTexture = context.RenderTarget2D_Alloc(size, PixelFormat.A8R8G8B8);              //!!!! PixelFormat.R8G8B8 );

            {
                context.SetViewport(blurTexture.Result.GetRenderTarget().Viewports[0]);

                CanvasRenderer.ShaderItem shader = new CanvasRenderer.ShaderItem();
                shader.VertexProgramFileName   = @"Base\Shaders\EffectsCommon_vs.sc";
                shader.FragmentProgramFileName = @"Base\Shaders\Effects\LightShafts\Blur_fs.sc";

                //!!!!Linear?
                shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(0 /*"scatteringTexture"*/, scatteringTexture,
                                                                                   TextureAddressingMode.Clamp, FilterOption.Linear, FilterOption.Linear, FilterOption.None));
                shader.Parameters.Set("color", Color.Value.ToVector3F());
                shader.Parameters.Set("screenLightPosition", screenLightPosition.ToVector2F());
                shader.Parameters.Set("blurFactor", (float)BlurFactor);

                context.RenderQuadToCurrentViewport(shader);
            }

            //free old textures
            context.DynamicTexture_Free(scatteringTexture);

            //create final
            var finalTexture = context.RenderTarget2D_Alloc(actualTexture.Result.ResultSize, actualTexture.Result.ResultFormat);

            {
                context.SetViewport(finalTexture.Result.GetRenderTarget().Viewports[0]);

                CanvasRenderer.ShaderItem shader = new CanvasRenderer.ShaderItem();
                shader.VertexProgramFileName   = @"Base\Shaders\EffectsCommon_vs.sc";
                shader.FragmentProgramFileName = @"Base\Shaders\Effects\LightShafts\Final_fs.sc";

                shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(0 /*"sourceTexture"*/, actualTexture,
                                                                                   TextureAddressingMode.Clamp, FilterOption.Point, FilterOption.Point, FilterOption.None));
                shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(1 /*"blurTexture"*/, blurTexture,
                                                                                   TextureAddressingMode.Clamp, FilterOption.Linear, FilterOption.Linear, FilterOption.None));
                shader.Parameters.Set("intensity", (float)resultIntensity);

                context.RenderQuadToCurrentViewport(shader);
            }

            //free old textures
            context.DynamicTexture_Free(actualTexture);
            context.DynamicTexture_Free(blurTexture);

            //update actual texture
            actualTexture = finalTexture;
        }
コード例 #17
0
        //private void Pipeline_RenderBegin( Component_RenderingPipeline_Basic sender, ViewportRenderingContext context, Component_RenderingPipeline_Basic.FrameData frameData )
        //{
        //	if( EnabledInHierarchy && sender.UseRenderTargets )
        //	{
        //		//frameData.GenerateIBLSpecularTexture = true;
        //		//frameData.DeferredSpecularIBLItensity = 1.0 - Intensity;
        //	}
        //}

        private void Pipeline_RenderDeferredShadingEnd(Component_RenderingPipeline_Basic sender, ViewportRenderingContext context, Component_RenderingPipeline_Basic.FrameData frameData, ref Component_Image sceneTexture)
        {
            if (EnabledInHierarchy && sender.GetUseMultiRenderTargets())
            {
                var actualTexture = sceneTexture;

                var pipeline = (Component_RenderingPipeline_Basic)context.RenderingPipeline;

                Vector3 cameraPos = context.Owner.CameraSettings.Position;
                //!!!!double
                Vector3F cameraPosition = cameraPos.ToVector3F();

                //!!!!double
                Matrix4F projectionMatrix = context.Owner.CameraSettings.ProjectionMatrix.ToMatrix4F();
                Matrix4F viewMatrix       = context.Owner.CameraSettings.ViewMatrix.ToMatrix4F();

                Matrix4F viewProjMatrix    = projectionMatrix * viewMatrix;
                Matrix4F invViewProjMatrix = viewProjMatrix.GetInverse();

                float aspectRatio = (float)context.Owner.CameraSettings.AspectRatio;
                float fov         = (float)context.Owner.CameraSettings.FieldOfView;
                float zNear       = (float)context.Owner.CameraSettings.NearClipDistance;
                float zFar        = (float)context.Owner.CameraSettings.FarClipDistance;

                var ambientLight      = frameData.Lights[frameData.LightsInFrustumSorted[0]];
                var ambientLightPower = ambientLight.data.Power;

                var reflectionTexture = context.RenderTarget2D_Alloc(actualTexture.Result.ResultSize, actualTexture.Result.ResultFormat);
                {
                    context.SetViewport(reflectionTexture.Result.GetRenderTarget().Viewports[0]);

                    CanvasRenderer.ShaderItem shader = new CanvasRenderer.ShaderItem();
                    shader.VertexProgramFileName   = @"Base\Shaders\EffectsCommon_vs.sc";
                    shader.FragmentProgramFileName = @"Base\Shaders\Effects\ScreenSpaceReflection\SSR_fs.sc";

                    int maxSteps = 50;
                    switch (Quality.Value)
                    {
                    case QualityEnum.Lowest: maxSteps = 20; break;

                    case QualityEnum.Low: maxSteps = 50; break;

                    case QualityEnum.Medium: maxSteps = 80; break;

                    case QualityEnum.High: maxSteps = 120; break;

                    case QualityEnum.Highest: maxSteps = 160; break;
                    }

                    shader.Defines.Add(new CanvasRenderer.ShaderItem.DefineItem("MAX_STEPS", maxSteps.ToString()));

                    context.objectsDuringUpdate.namedTextures.TryGetValue("gBuffer0Texture", out var gBuffer0Texture);
                    context.objectsDuringUpdate.namedTextures.TryGetValue("depthTexture", out var depthTexture);
                    context.objectsDuringUpdate.namedTextures.TryGetValue("normalTexture", out var normalTexture);
                    context.objectsDuringUpdate.namedTextures.TryGetValue("gBuffer2Texture", out var gBuffer2Texture);

                    //!!!!reflection probes?
                    pipeline.GetBackgroundEnvironmentTextures(context, frameData, /*true, */ out var environmentTexture, out var environmentTextureIBL);

                    shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(0, depthTexture,
                                                                                       TextureAddressingMode.Clamp, FilterOption.Point, FilterOption.Point, FilterOption.None));

                    shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(1, actualTexture,
                                                                                       TextureAddressingMode.Clamp, FilterOption.Point, FilterOption.Point, FilterOption.None));

                    shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(2, normalTexture,
                                                                                       TextureAddressingMode.Clamp, FilterOption.Point, FilterOption.Point, FilterOption.None));

                    //!!!!rotation, multiplier

                    shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(3, environmentTexture.Value.texture,
                                                                                       TextureAddressingMode.Clamp, FilterOption.Linear, FilterOption.Linear, FilterOption.Linear));

                    shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(4, environmentTextureIBL.Value.texture,
                                                                                       TextureAddressingMode.Clamp, FilterOption.Linear, FilterOption.Linear, FilterOption.Linear));

                    shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(5, Component_RenderingPipeline_Basic.BrdfLUT,
                                                                                       TextureAddressingMode.Clamp, FilterOption.Linear, FilterOption.Linear, FilterOption.Linear));

                    shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(6, gBuffer2Texture,
                                                                                       TextureAddressingMode.Clamp, FilterOption.Point, FilterOption.Point, FilterOption.Point));

                    shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(7, gBuffer0Texture,
                                                                                       TextureAddressingMode.Clamp, FilterOption.Point, FilterOption.Point, FilterOption.Point));

                    //!!!часть параметров есть UniformsGeneral.sh

                    shader.Parameters.Set("viewProj", viewProjMatrix);
                    shader.Parameters.Set("invViewProj", invViewProjMatrix);
                    shader.Parameters.Set("cameraPosition", cameraPosition);
                    shader.Parameters.Set("edgeFactorPower", (float)EdgeFactorPower);

                    shader.Parameters.Set("colorTextureSize", new Vector4F((float)actualTexture.Result.ResultSize.X, (float)actualTexture.Result.ResultSize.Y, 0.0f, 0.0f));
                    shader.Parameters.Set("zNear", zNear);
                    shader.Parameters.Set("zFar", zFar);
                    shader.Parameters.Set("fov", fov);
                    shader.Parameters.Set("aspectRatio", aspectRatio);

                    context.RenderQuadToCurrentViewport(shader);
                }

                var min = BlurRoughnessMin.Value;
                var max = BlurRoughnessMax.Value;
                if (min > max)
                {
                    min = max;
                }
                var blurRoughnessMin = pipeline.GaussianBlur(context, this, reflectionTexture, min, BlurDownscalingMode, BlurDownscalingValue);
                var blurRoughnessMax = pipeline.GaussianBlur(context, this, reflectionTexture, max, BlurDownscalingMode, BlurDownscalingValue);
                //// Blur Pass:
                //var bluredReflection = pipeline.GaussianBlur( context, this, reflectionTexture, BlurFactorOnMaxRoughness, BlurDownscalingMode, BlurDownscalingValue );

                // Final Pass:
                var finalTexture = context.RenderTarget2D_Alloc(actualTexture.Result.ResultSize, actualTexture.Result.ResultFormat);
                {
                    context.SetViewport(finalTexture.Result.GetRenderTarget().Viewports[0]);

                    CanvasRenderer.ShaderItem shader = new CanvasRenderer.ShaderItem();
                    shader.VertexProgramFileName   = @"Base\Shaders\EffectsCommon_vs.sc";
                    shader.FragmentProgramFileName = @"Base\Shaders\Effects\ScreenSpaceReflection\SSR_Apply_fs.sc";

                    context.objectsDuringUpdate.namedTextures.TryGetValue("gBuffer0Texture", out var gBuffer0Texture);
                    context.objectsDuringUpdate.namedTextures.TryGetValue("depthTexture", out var depthTexture);
                    context.objectsDuringUpdate.namedTextures.TryGetValue("normalTexture", out var normalTexture);
                    context.objectsDuringUpdate.namedTextures.TryGetValue("gBuffer2Texture", out var gBuffer2Texture);

                    //!!!!reflection probes?
                    pipeline.GetBackgroundEnvironmentTextures(context, frameData, /*true, */ out var environmentTexture, out var environmentTextureIBL);

                    shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(0, actualTexture,
                                                                                       TextureAddressingMode.Clamp, FilterOption.Point, FilterOption.Point, FilterOption.None));

                    shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(1, blurRoughnessMin,
                                                                                       TextureAddressingMode.Clamp, FilterOption.Point, FilterOption.Point, FilterOption.None));

                    shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(2, blurRoughnessMax,
                                                                                       TextureAddressingMode.Clamp, FilterOption.Point, FilterOption.Point, FilterOption.None));

                    //shader.Parameters.Set( "1", new GpuMaterialPass.TextureParameterValue( reflectionTexture,
                    //	TextureAddressingMode.Clamp, FilterOption.Point, FilterOption.Point, FilterOption.None ) );

                    //shader.Parameters.Set( "2", new GpuMaterialPass.TextureParameterValue( bluredReflection,
                    //	TextureAddressingMode.Clamp, FilterOption.Point, FilterOption.Point, FilterOption.None ) );

                    shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(3, depthTexture,
                                                                                       TextureAddressingMode.Clamp, FilterOption.Point, FilterOption.Point, FilterOption.None));

                    shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(4, normalTexture,
                                                                                       TextureAddressingMode.Clamp, FilterOption.Point, FilterOption.Point, FilterOption.None));

                    //!!!!rotation, multiplier

                    shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(5, environmentTexture.Value.texture,
                                                                                       TextureAddressingMode.Clamp, FilterOption.Linear, FilterOption.Linear, FilterOption.Linear));

                    shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(6, environmentTextureIBL.Value.texture,
                                                                                       TextureAddressingMode.Clamp, FilterOption.Linear, FilterOption.Linear, FilterOption.Linear));

                    shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(7, Component_RenderingPipeline_Basic.BrdfLUT,
                                                                                       TextureAddressingMode.Clamp, FilterOption.Linear, FilterOption.Linear, FilterOption.Linear));

                    shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(8, gBuffer2Texture,
                                                                                       TextureAddressingMode.Clamp, FilterOption.Point, FilterOption.Point, FilterOption.Point));

                    shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(9, gBuffer0Texture,
                                                                                       TextureAddressingMode.Clamp, FilterOption.Point, FilterOption.Point, FilterOption.Point));

                    shader.Parameters.Set("invViewProj", invViewProjMatrix);
                    shader.Parameters.Set("cameraPosition", cameraPosition);
                    shader.Parameters.Set("intensity", (float)Intensity);
                    shader.Parameters.Set("ambientLightPower", ambientLightPower);

                    context.RenderQuadToCurrentViewport(shader);
                }

                // Free Targets:
                context.DynamicTexture_Free(reflectionTexture);
                context.DynamicTexture_Free(blurRoughnessMin);
                context.DynamicTexture_Free(blurRoughnessMax);
                //context.RenderTarget_Free( bluredReflection );
                context.DynamicTexture_Free(actualTexture);

                // Update actual Texture:
                actualTexture = finalTexture;

                //result
                sceneTexture = actualTexture;
            }
        }
コード例 #18
0
        /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

        protected override void OnRender(ViewportRenderingContext context, Component_RenderingPipeline.IFrameData frameData, ref Component_Image actualTexture)
        {
            var result = Result as CompiledDataCodeGenerated;

            //!!!!так?
            if (result == null)
            {
                return;
            }

            if (result.vertexProgram == null || result.fragmentProgram == null)
            {
                return;
            }

            //!!!!валится если файла нет. или не указан.
            //!!!!!!как быстро проверять о том что файла нет? может из кеша шейдеров или типа того. как тогда обновлять
            //string shaderFile = Shader;
            //if( string.IsNullOrEmpty( shaderFile ) )
            //	return;

            //!!!!formats. т.е. эффект поддерживает и LDR и HDR. где еще
            //!!!!!можно по сути у эффекта указывать что он ожидает получить на входе. ну или это EffectsHDR, EffectsLDR
            var outputTexture = context.RenderTarget2D_Alloc(actualTexture.Result.ResultSize, actualTexture.Result.ResultFormat);

            context.SetViewport(outputTexture.Result.GetRenderTarget().Viewports[0]);

            CanvasRenderer.ShaderItem shader = new CanvasRenderer.ShaderItem();
            shader.CompiledVertexProgram   = result.vertexProgram;
            shader.CompiledFragmentProgram = result.fragmentProgram;

            //shader.VertexProgramFileName = shaderFile;
            //shader.VertexProgramFunctionName = "main_vp";
            //shader.FragmentProgramFileName = shaderFile;
            //shader.FragmentProgramFunctionName = "main_fp";

            //{
            //	var defines = new List<GuiRenderer.ShaderItem.DefineItem>();

            //	//defines.Add( new GuiRenderer.ShaderItem.DefineItem( "FRAGMENT_CODE_BODY", "color = float4(0,1,0,1);" ) );

            //	if( defines.Count != 0 )
            //		shader.Defines = defines.ToArray();
            //}

            shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(0 /*"sourceTexture"*/,
                                                                               actualTexture, TextureAddressingMode.Clamp, FilterOption.Point, FilterOption.Point, FilterOption.Point));
            //shader.Parameters.Set( "0"/*"sourceTexture"*/, new GpuMaterialPass.TextureParameterValue( actualTexture,
            //	TextureAddressingMode.Clamp, FilterOption.Point, FilterOption.Point, FilterOption.Point ) );

            unsafe
            {
                Vector4F value = Vector4F.One;
                if (!Color.ReferenceSpecified)
                {
                    value = Color.Value.ToVector4F();
                }
                shader.Parameters.Set("u_paramColor", ParameterType.Vector4, 1, &value, sizeof(Vector4F));
            }

            //!!!!пока так
            if (result.fragmentGeneratedCode != null)
            {
                //!!!!copy code из MaterialStandard

                //var materialParameters = materialData.GetShaderParameters();
                var code = result.fragmentGeneratedCode;

                //foreach( var code in codes )
                //{
                if (code.parameters != null)
                {
                    foreach (var item in code.parameters)
                    {
                        //!!!!надо ссылки сконвертить или как-то так? чтобы работало, если это в типе

                        var value = item.component.GetValue();
                        if (value != null)
                        {
                            //!!!!
                            //convert to float type
                            value = SimpleTypes.ConvertDoubleToFloat(value);
                            //ColorValuePowered: convert to ColorValue
                            if (value is ColorValuePowered)
                            {
                                value = ((ColorValuePowered)value).ToColorValue();
                            }

                            shader.Parameters /*container*/.Set(item.nameInShader, value);
                        }
                    }
                }

                if (code.textures != null)
                {
                    foreach (var item in code.textures)
                    {
                        //!!!!надо ссылки сконвертить или как-то так? чтобы работало, если это в типе

                        //!!!!не только 2D

                        Component_Image texture = item.component.Texture;
                        if (texture == null)
                        {
                            texture = ResourceUtility.WhiteTexture2D;
                        }

                        //!!!!options

                        shader.Parameters.Set(new ViewportRenderingContext.BindTextureData(item.textureRegister,
                                                                                           texture, TextureAddressingMode.Wrap, FilterOption.Linear, FilterOption.Linear, FilterOption.Linear));

                        ////!!!!
                        //var textureValue = new GpuMaterialPass.TextureParameterValue( texture,
                        //	TextureAddressingMode.Wrap, FilterOption.Linear, FilterOption.Linear, FilterOption.Linear );
                        ////!!!!
                        //ParameterType parameterType = ParameterType.Texture2D;

                        //shader.Parameters/*container*/.Set( item.textureRegister.ToString(), textureValue, parameterType );
                        ////shader.Parameters/*container*/.Set( item.nameInShader, textureValue, parameterType );
                    }
                }
                //}
            }

            var size = actualTexture.Result.ResultSize;

            shader.Parameters.Set("viewportSize", new Vector4(size.X, size.Y, 1.0 / (double)size.X, 1.0 / (double)size.Y).ToVector4F());

            shader.Parameters.Set("intensity", (float)Intensity.Value);

            //!!!!auto parameters
            //if( result.fragmentGeneratedCode != null )
            {
                //!!!!не так потом

                shader.Parameters.Set("param_viewportSize", new Vector2F(size.X, size.Y));

                //foreach( var item in result.fragmentGeneratedCode.autoConstantParameters )
                //{
                //}
            }

            context.RenderQuadToCurrentViewport(shader);

            //change actual texture
            context.DynamicTexture_Free(actualTexture);
            actualTexture = outputTexture;
        }