C# RenderContext.PushTagAndRestore方法代码示例

        protected override void DrawCore(RenderContext context)
        {
            using (var t1 = context.PushTagAndRestore(SceneCameraSlotCollection.Current, Cameras))
            {
                // Draw the layers
                Layers.Draw(context);

                // Draw the master track
                Master.Draw(context);
            }
        }

        protected override void DrawCore(RenderContext context)
        {
            if (!Enabled || Output == null)
            {
                return;
            }

            // Sets the input of the layer (== last Current)
            var currentRenderFrame = context.Tags.Get(RenderFrame.Current);
            
            // Sets the output of the layer 
            // Master is always going to use the Master frame for the current frame.
            var renderFrame = Output.GetRenderFrame(context);

            using (var t1 = context.PushTagAndRestore(CurrentInput, currentRenderFrame))
            {
                context.Tags.Set(RenderFrame.Current, renderFrame);
                Renderers.Draw(context);
            }
        }

        protected override void DrawCore(RenderContext context, RenderFrame output)
        {
            // Early exit if some properties are null
            if (Mode == null)
            {
                return;
            }

            // Gets the current camera state from the slot
            var camera = context.GetCameraFromSlot(Camera);

            // Draw this camera.
            using (context.PushTagAndRestore(Current, this))
            using (context.PushTagAndRestore(CameraComponentRenderer.Current, camera))
            {
                // Run all pre-renderers
                foreach (var renderer in PreRenderers)
                {
                    renderer.Draw(context);
                }

                // Draw the scene based on its drawing mode (e.g. implementation forward or deferred... etc.)
                Mode.Draw(context);

                // Run all post-renderers
                foreach (var renderer in PostRenderers)
                {
                    renderer.Draw(context);
                }
            }
        }

        /// <summary>
        /// Draws this scene instance with the specified context and <see cref="RenderFrame"/>.
        /// </summary>
        /// <param name="context">The context.</param>
        /// <param name="toFrame">To frame.</param>
        /// <param name="compositorOverride">The compositor overload. Set this value to by-pass the default compositor of a scene.</param>
        /// <exception cref="System.ArgumentNullException">
        /// context
        /// or
        /// toFrame
        /// </exception>
        public void Draw(RenderContext context, RenderFrame toFrame, ISceneGraphicsCompositor compositorOverride = null)
        {
            if (context == null) throw new ArgumentNullException("context");
            if (toFrame == null) throw new ArgumentNullException("toFrame");

            // If no scene, then we can return immediately
            if (Scene == null)
            {
                return;
            }

            var graphicsDevice = context.GraphicsDevice;

            bool hasGraphicsBegin = false;

            // Update global time
            var gameTime = context.Time;
            context.GraphicsDevice.Parameters.Set(GlobalKeys.Time, (float)gameTime.Total.TotalSeconds);
            context.GraphicsDevice.Parameters.Set(GlobalKeys.TimeStep, (float)gameTime.Elapsed.TotalSeconds);

            try
            {
                graphicsDevice.Begin();
                hasGraphicsBegin = true;

                // Always clear the state of the GraphicsDevice to make sure a scene doesn't start with a wrong setup 
                graphicsDevice.ClearState();

                // Draw the main scene using the current compositor (or the provided override)
                var graphicsCompositor = compositorOverride ?? Scene.Settings.GraphicsCompositor;
                if (graphicsCompositor != null)
                {
                    // Push context (pop after using)
                    using (context.PushTagAndRestore(RenderFrame.Current, toFrame))
                    using (context.PushTagAndRestore(SceneGraphicsLayer.Master, toFrame))
                    using (context.PushTagAndRestore(Current, this))
                    using (context.PushTagAndRestore(CameraRendererMode.RendererTypesKey, RendererTypes))
                    {
                        graphicsCompositor.Draw(context);
                    }
                }
            }
            catch (Exception ex)
            {
                Log.Error("An exception occurred while rendering", ex);
            }
            finally
            {
                if (hasGraphicsBegin)
                {
                    graphicsDevice.End();
                }
            }
        }