Example #1
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="gameTime"></param>
        internal void RenderShadow(GameTime gameTime, Viewport viewport, Matrix view, Matrix projection, RenderTargetSurface particleShadow, DepthStencilSurface depthBuffer)
        {
            if (rs.SkipParticleShadows)
            {
                return;
            }

            var colorTarget = particleShadow;
            var depthTarget = depthBuffer;

            RenderGeneric("Particles Shadow", gameTime, null, viewport, view, projection, colorTarget, depthTarget, null, Flags.DRAW_SHADOW);
        }
Example #2
0
        /// <summary>
        /// Renders sky with specified technique
        /// </summary>
        /// <param name="rendCtxt"></param>
        /// <param name="techName"></param>
        public void Render(GameTime gameTime, DepthStencilSurface depthBuffer, RenderTargetSurface hdrTarget, Matrix view, Matrix projection, RenderTarget2D cloudTarget, RenderTarget2D smallerCloudTarget)
        {
            var camera = Game.GetService <Camera>();

            var scale    = Matrix.Scaling(Params.SkySphereSize);
            var rotation = Matrix.Identity;

            var sunPos   = GetSunDirection();
            var sunColor = GetSunGlowColor();

            rs.ResetStates();

            //rs.DepthStencilState = depthBuffer==null? DepthStencilState.None : DepthStencilState.Default ;

            rs.SetViewport(0, 0, hdrTarget.Width, hdrTarget.Height);

            rs.SetTargets(depthBuffer, hdrTarget);

            var viewMatrix = view;
            var projMatrix = projection;

            skyConstsData.MatrixWVP    = scale * rotation * MathUtil.Transformation(viewMatrix.Right, viewMatrix.Up, viewMatrix.Backward) * projMatrix;
            skyConstsData.SunPosition  = sunPos;
            skyConstsData.SunColor     = sunColor;
            skyConstsData.Turbidity    = Params.SkyTurbidity;
            skyConstsData.Temperature  = Temperature.Get(Params.SunTemperature);
            skyConstsData.SkyIntensity = Params.SkyIntensity;

            skyConstsCB.SetData(skyConstsData);

            rs.VertexShaderConstants[0] = skyConstsCB;
            rs.PixelShaderConstants[0]  = skyConstsCB;


            //
            //	Sky :
            //
            SkyFlags flags = SkyFlags.PROCEDURAL_SKY;

            ApplyColorSpace(ref flags);

            rs.PipelineState = factory[(int)flags];

            for (int j = 0; j < skySphere.Meshes.Count; j++)
            {
                var mesh = skySphere.Meshes[j];

                rs.SetupVertexInput(vertexBuffers[j], indexBuffers[j]);
                rs.DrawIndexed(mesh.IndexCount, 0, 0);
            }



            //
            //	Clouds :
            //
            scale = Matrix.Scaling(Params.SkySphereSize, Params.SkySphereSize, Params.SkySphereSize);
            //scale		=	Matrix.Scaling( Params.SkySphereSize, Params.SkySphereSize * 0.1f, Params.SkySphereSize );
            skyConstsData.MatrixWVP    = scale * rotation * MathUtil.Transformation(viewMatrix.Right, viewMatrix.Up, viewMatrix.Backward) * projMatrix;
            skyConstsData.SunPosition  = sunPos;
            skyConstsData.SunColor     = GetSunLightColor();
            skyConstsData.Turbidity    = Params.SkyTurbidity;
            skyConstsData.Temperature  = Temperature.Get(Params.SunTemperature);
            skyConstsData.SkyIntensity = Params.SkyIntensity;
            skyConstsData.Ambient      = GetAmbientLevel().ToVector3();
            skyConstsData.Time         = (float)gameTime.Total.TotalSeconds;

            skyConstsCB.SetData(skyConstsData);

            rs.SetTargets(depthBuffer, hdrTarget);
//			rs.SetTargets( null, cloudTarget.Surface );

            flags = SkyFlags.CLOUDS;

            //int i = 0;
            for (int i = 0; i < 3; i++)
            {
                if (i == 0)
                {
                    flags = SkyFlags.CLOUDS | SkyFlags.A | SkyFlags.RED;
                }
                if (i == 1)
                {
                    flags = SkyFlags.CLOUDS | SkyFlags.B | SkyFlags.GREEN;
                }
                if (i == 2)
                {
                    flags = SkyFlags.CLOUDS | SkyFlags.C | SkyFlags.BLUE;
                }

                ApplyColorSpace(ref flags);

                rs.PipelineState           = factory[(int)flags];
                rs.PixelShaderResources[0] = clouds;
                rs.PixelShaderResources[1] = cirrus;
                rs.PixelShaderResources[2] = noise;
                rs.PixelShaderResources[3] = arrows;
                rs.PixelShaderSamplers[0]  = SamplerState.AnisotropicWrap;



                for (int j = 0; j < cloudSphere.Meshes.Count; j++)
                {
                    var mesh = cloudSphere.Meshes[j];

                    rs.SetupVertexInput(cloudVertexBuffers[j], cloudIndexBuffers[j]);
                    rs.DrawIndexed(mesh.IndexCount, 0, 0);
                }
            }
                        #if false
            //Blur
            var filter = Game.GetService <Filter>();

            //filter.RadialBlur(smallerCloudTarget.Surface, cloudTarget, new Vector2(0.5f, 0.5f), 1.0f, -0.2f);

            //if(Game.InputDevice.IsKeyDown(Keys.LeftButton))
            //{
            Vector4 sunProj = Vector4.Transform(new Vector4(sunPos, 0), viewMatrix);
            sunProj = Vector4.Transform(sunProj, projMatrix);
            sunProj = new Vector4(sunProj.X / sunProj.W, sunProj.Y / sunProj.W, sunProj.Z / sunProj.W, 1);
            Vector2 relSunPosition = new Vector2(0.5f, 0.5f);

            //if ( Math.Abs(sunProj.X ) < 1 && Math.Abs (sunProj.Y) < 1){
            relSunPosition = new Vector2((sunProj.X + 1) / 2, -(sunProj.Y - 1) / 2);
            //}

            //Log.Message(relSunPosition + "");
            filter.RadialBlur(smallerCloudTarget.Surface, cloudTarget, relSunPosition, 1.0f, -0.2f);
            //}



            flags = SkyFlags.BLUR_CLOUD;
            skyConstsData.MatrixWVP = Matrix.Identity;
            skyConstsCB.SetData(skyConstsData);

            rs.SetTargets(null, hdrTarget);

            ApplyColorSpace(ref flags);
            rs.VertexShaderConstants[0] = skyConstsCB;
            rs.PixelShaderConstants[0]  = skyConstsCB;

            rs.PipelineState           = factory[(int)flags];
            rs.PixelShaderResources[4] = cloudTarget;
            rs.PixelShaderSamplers[1]  = SamplerState.LinearWrap;

            var v0 = new VertexColorTextureTBN {
                Position = new Vector3(-1.0f, -1.0f, 0), TexCoord = new Vector2(0, 1),
            };
            var v1 = new VertexColorTextureTBN {
                Position = new Vector3(1.0f, 1.0f, 0), TexCoord = new Vector2(1, 0),
            };
            var v2 = new VertexColorTextureTBN {
                Position = new Vector3(-1.0f, 1.0f, 0), TexCoord = new Vector2(0, 0),
            };
            var v3 = new VertexColorTextureTBN {
                Position = new Vector3(-1.0f, -1.0f, 0), TexCoord = new Vector2(0, 1),
            };
            var v4 = new VertexColorTextureTBN {
                Position = new Vector3(1.0f, -1.0f, 0), TexCoord = new Vector2(1, 1),
            };
            var v5 = new VertexColorTextureTBN {
                Position = new Vector3(1.0f, 1.0f, 0), TexCoord = new Vector2(1, 0),
            };                                                                                                                                    //*/

            var data = new VertexColorTextureTBN[] { v0, v1, v2, v3, v4, v5 };
            //Log.Message(""+v0.TexCoord);
            vertexBufferBlur.SetData(data, 0, 6);
            //for ( int j=0; j<cloudSphere.Meshes.Count; j++) {
            //		var mesh = cloudSphere.Meshes[j];

            //		rs.SetupVertexInput( cloudVertexBuffers[j], cloudIndexBuffers[j] );
            //		rs.DrawIndexed( mesh.IndexCount, 0, 0 );
            //	}
            rs.SetupVertexInput(vertexBufferBlur, null);
            rs.Draw(6, 0);
#endif

            rs.ResetStates();
        }
Example #3
0
        /// <summary>
        ///
        /// </summary>
        void RenderGeneric(string passName, GameTime gameTime, Camera camera, Viewport viewport, Matrix view, Matrix projection, RenderTargetSurface colorTarget, DepthStencilSurface depthTarget, ShaderResource depthValues, Flags flags)
        {
            var device = Game.GraphicsDevice;

            using (new PixEvent(passName)) {
                device.ResetStates();

                //
                //	Setup images :
                //
                if (Images != null && !Images.IsDisposed)
                {
                    imagesCB.SetData(Images.GetNormalizedRectangles(MaxImages));
                }

                SetupGPUParameters(0, renderWorld, view, projection, flags);
                device.ComputeShaderConstants[0] = paramsCB;

                //
                //	Render
                //
                using (new PixEvent("Drawing")) {
                    //	target and viewport :
                    device.SetTargets(depthTarget, colorTarget);
                    device.SetViewport(viewport);

                    //	params CB :
                    device.ComputeShaderConstants[0]  = paramsCB;
                    device.VertexShaderConstants[0]   = paramsCB;
                    device.GeometryShaderConstants[0] = paramsCB;
                    device.PixelShaderConstants[0]    = paramsCB;

                    //	atlas CB :
                    device.VertexShaderConstants[1]   = imagesCB;
                    device.GeometryShaderConstants[1] = imagesCB;
                    device.PixelShaderConstants[1]    = imagesCB;

                    //	sampler & textures :
                    device.PixelShaderSamplers[0] = SamplerState.LinearClamp4Mips;

                    device.PixelShaderResources[0]    = Images == null? rs.WhiteTexture.Srv : Images.Texture.Srv;
                    device.PixelShaderResources[5]    = depthValues;
                    device.GeometryShaderResources[1] = simulationBuffer;
                    device.GeometryShaderResources[2] = simulationBuffer;
                    device.GeometryShaderResources[3] = sortParticlesBuffer;
                    device.GeometryShaderResources[4] = particleLighting;

                    //	setup PS :
                    device.PipelineState = factory[(int)flags];

                    //	GPU time : 0.81 ms	-> 0.91 ms
                    device.Draw(MaxSimulatedParticles, 0);
                }
            }
        }
Example #4
0
        /// <summary>
        ///
        /// </summary>
        internal void Render(RenderTargetSurface colorBuffer, DepthStencilSurface depthBuffer, Camera camera)
        {
            DrawTracers();

            if (!vertexDataAccum.Any())
            {
                return;
            }

            if (Game.RenderSystem.SkipDebugRendering)
            {
                vertexDataAccum.Clear();
                return;
            }

            var dev = Game.GraphicsDevice;

            dev.ResetStates();

            dev.SetTargets(depthBuffer, colorBuffer);


            var a = camera.GetProjectionMatrix(StereoEye.Mono).M11;
            var b = camera.GetProjectionMatrix(StereoEye.Mono).M22;
            var w = (float)colorBuffer.Width;
            var h = (float)colorBuffer.Height;

            constData.View         = camera.GetViewMatrix(StereoEye.Mono);
            constData.Projection   = camera.GetProjectionMatrix(StereoEye.Mono);
            constData.ViewPosition = camera.GetCameraPosition4(StereoEye.Mono);
            constData.PixelSize    = new Vector4(1 / w / a, 1 / b / h, 1 / w, 1 / h);
            constBuffer.SetData(constData);

            dev.SetupVertexInput(vertexBuffer, null);
            dev.VertexShaderConstants[0]   = constBuffer;
            dev.PixelShaderConstants[0]    = constBuffer;
            dev.GeometryShaderConstants[0] = constBuffer;

            var flags = new[] { RenderFlags.SOLID, RenderFlags.GHOST };


            foreach (var flag in flags)
            {
                dev.PipelineState = factory[(int)flag];

                int numDPs = MathUtil.IntDivUp(vertexDataAccum.Count, vertexBufferSize);

                for (int i = 0; i < numDPs; i++)
                {
                    int numVerts = i < numDPs - 1 ? vertexBufferSize : vertexDataAccum.Count % vertexBufferSize;

                    if (numVerts == 0)
                    {
                        break;
                    }

                    vertexDataAccum.CopyTo(i * vertexBufferSize, vertexArray, 0, numVerts);

                    vertexBuffer.SetData(vertexArray, 0, numVerts);

                    dev.Draw(numVerts, 0);
                }
            }

            vertexDataAccum.Clear();
        }