/// <summary>
        /// Render method is called directly by renderer. Depending on stage, post process can do various things
        /// </summary>
        /// <param name="postProcessStage">Stage indicating in which part renderer currently is.</param>public override void RenderAfterBlendLights()
        public override Texture Render(PostProcessStage postProcessStage, Texture source, Texture availableRenderTarget)
        {
            switch (postProcessStage)
            {
            case PostProcessStage.AlphaBlended:
            {
                var halfRT = MyRender.GetRenderTarget(MyRenderTargets.AuxiliaryHalf0);

                MyRender.SetRenderTarget(halfRT, null);
                BlendState.Opaque.Apply();
                RasterizerState.CullNone.Apply();
                DepthStencilState.None.Apply();

                MyEffectGodRays effectGodRays = MyRender.GetEffect(MyEffects.GodRays) as MyEffectGodRays;

                effectGodRays.SetDiffuseTexture(source);
                effectGodRays.SetDepthTexture(MyRender.GetRenderTarget(MyRenderTargets.Depth));
                effectGodRays.SetFrustumCorners(MyRender.GetShadowRenderer().GetFrustumCorners());
                effectGodRays.SetView((Matrix)MyRenderCamera.ViewMatrix);
                effectGodRays.SetWorldViewProjection((Matrix)MyRenderCamera.ViewProjectionMatrix);
                effectGodRays.SetDensity(Density);
                effectGodRays.SetDecay(Decay);

                effectGodRays.SetWeight(Weight * (1 - MyRender.FogProperties.FogMultiplier));
                effectGodRays.SetExposition(Exposition);
                effectGodRays.SetLightPosition(15000f * -MyRender.Sun.Direction);
                effectGodRays.SetLightDirection(MyRender.Sun.Direction);
                effectGodRays.SetCameraPos((Vector3)MyRenderCamera.Position);

                MyRender.GetFullscreenQuad().Draw(effectGodRays);

                if (ApplyBlur)
                {
                    var auxTarget = MyRender.GetRenderTarget(MyRenderTargets.AuxiliaryHalf1010102);

                    var blurEffect = MyRender.GetEffect(MyEffects.GaussianBlur) as MyEffectGaussianBlur;
                    blurEffect.SetHalfPixel(halfRT.GetLevelDescription(0).Width, halfRT.GetLevelDescription(0).Height);

                    // Apply vertical gaussian blur
                    MyRender.SetRenderTarget(auxTarget, null);
                    blurEffect.BlurAmount = 1;
                    blurEffect.SetSourceTexture(halfRT);
                    blurEffect.SetHeightForVerticalPass(halfRT.GetLevelDescription(0).Height);
                    MyRender.GetFullscreenQuad().Draw(blurEffect);

                    // Apply horizontal gaussian blur
                    MyRender.SetRenderTarget(halfRT, null);
                    blurEffect.BlurAmount = 1;
                    blurEffect.SetSourceTexture(auxTarget);
                    blurEffect.SetWidthForHorisontalPass(auxTarget.GetLevelDescription(0).Width);
                    MyRender.GetFullscreenQuad().Draw(blurEffect);
                }

                // Additive
                MyRender.SetRenderTarget(availableRenderTarget, null);
                //MySandboxGame.Static.GraphicsDevice.Clear(ClearFlags.All, new SharpDX.ColorBGRA(0), 1, 0);
                BlendState.Opaque.Apply();
                MyRender.Blit(source, true);

                var upscaleEffect = MyRender.GetEffect(MyEffects.Scale) as MyEffectScale;
                upscaleEffect.SetScale(new Vector2(2));
                upscaleEffect.SetTechnique(MyEffectScale.Technique.HWScale);
                MyStateObjects.Additive_NoAlphaWrite_BlendState.Apply();

                upscaleEffect.SetSourceTextureMod(halfRT);
                MyRender.GetFullscreenQuad().Draw(upscaleEffect);

                return(availableRenderTarget);
            }
            }

            return(source);
        }
Ejemplo n.º 2
0
            public void Draw(MyEffectDistantImpostors effect, MyImpostorType impostorType)
            {
                if (!ImpostorProperties.Enabled)
                {
                    return;
                }

                if (impostorType != ImpostorProperties.ImpostorType)
                {
                    return;
                }

                if (ImpostorProperties.ImpostorType == MyImpostorType.Billboards)
                {
                    if (m_trianglesCount <= 0)
                    {
                        return;
                    }

                    m_animationTime += ImpostorProperties.AnimationSpeed;

                    Device device = MyRender.GraphicsDevice;

                    Matrix worldMatrix = Matrix.Identity;

                    if (ImpostorProperties.AnimationSpeed.X > 0)
                    {
                        worldMatrix *= Matrix.CreateRotationX(m_animationTime.X);
                    }
                    if (ImpostorProperties.AnimationSpeed.Y > 0)
                    {
                        worldMatrix *= Matrix.CreateRotationX(m_animationTime.Y);
                    }
                    if (ImpostorProperties.AnimationSpeed.Z > 0)
                    {
                        worldMatrix *= Matrix.CreateRotationX(m_animationTime.Z);
                    }

                    worldMatrix.Translation = (Vector3)MyRenderCamera.Position * 0.5f;
                    effect.SetWorldMatrix(worldMatrix);

                    MyTexture2D texture = null;
                    if (ImpostorProperties.Material != null)
                    {
                        texture = MyTransparentGeometry.GetTexture(ImpostorProperties.Material);
                    }
                    effect.SetImpostorTexture(texture);
                    device.SetStreamSource(0, m_vertexBuffer, 0, MyVertexFormatPositionTextureColor.Stride);
                    device.VertexDeclaration = MyVertexFormatPositionTextureColor.VertexDeclaration;

                    effect.SetTechnique(MyEffectDistantImpostors.Technique.ColoredLit);

                    effect.Begin();
                    device.DrawPrimitives(PrimitiveType.TriangleList, 0, m_trianglesCount);
                    effect.End();
                    MyPerformanceCounter.PerCameraDrawWrite.TotalDrawCalls++;
                }
                else if (ImpostorProperties.ImpostorType == MyImpostorType.Nebula)
                {
                    m_animationTime += ImpostorProperties.AnimationSpeed * MyRenderConstants.RENDER_STEP_IN_MILLISECONDS / 20.0f;

                    BlendState.NonPremultiplied.Apply();
                    RasterizerState.CullCounterClockwise.Apply();
                    DepthStencilState.None.Apply();

                    MyRender.Blit(MyRender.GetRenderTarget(MyRenderTargets.AuxiliaryHalf0), true);
                }
            }