AutoTrack() private method

private AutoTrack ( ) : void
return void
Exemplo n.º 1
0
		/// <summary>
		///		Prompts the class to send its contents to the renderer.
		/// </summary>
		/// <remarks>
		///		This method prompts the scene manager to send the
		///		contents of the scene it manages to the rendering
		///		pipeline, possibly preceded by some sorting, culling
		///		or other scene management tasks. Note that this method is not normally called
		///		directly by the user application; it is called automatically
		///		by the engine's rendering loop.
		/// </remarks>
		/// <param name="camera">Pointer to a camera from whose viewpoint the scene is to be rendered.</param>
		/// <param name="viewport">The target viewport</param>
		/// <param name="showOverlays">Whether or not any overlay objects should be rendered</param>
		protected internal void RenderScene( Camera camera, Viewport viewport, bool showOverlays )
		{
			// let the engine know this is the current scene manager
			Root.Instance.SceneManager = this;

			if ( this.IsShadowTechniqueInUse )
			{
				// initialize shadow volume materials
				this.InitShadowVolumeMaterials();
			}

			// Perform a quick pre-check to see whether we should override far distance
			// When using stencil volumes we have to use infinite far distance
			// to prevent dark caps getting clipped
			if ( this.IsShadowTechniqueStencilBased &&
				 camera.Far != 0 &&
				 this.targetRenderSystem.Capabilities.HasCapability( Capabilities.InfiniteFarPlane ) &&
				 this.shadowUseInfiniteFarPlane )
			{
				// infinite far distance
				camera.Far = 0.0f;
			}

			this.cameraInProgress = camera;
			this.hasCameraChanged = true;

			// Update the scene, only do this once per frame
			ulong thisFrameNumber = Root.Instance.CurrentFrameCount;
			if ( thisFrameNumber != this.lastFrameNumber )
			{
				// Update animations
				this.ApplySceneAnimations();
				// Update controllers
				ControllerManager.Instance.UpdateAll();
				this.lastFrameNumber = thisFrameNumber;
			}

			// Update scene graph for this camera (can happen multiple times per frame)
			this.UpdateSceneGraph( camera );

			// Auto-track nodes
			foreach ( SceneNode sn in autoTrackingSceneNodes.Values )
			{
				sn.AutoTrack();
			}

			// ask the camera to auto track if it has a target
			camera.AutoTrack();

			// Are we using any shadows at all?
			if ( this.IsShadowTechniqueInUse && this.illuminationStage != IlluminationRenderStage.RenderToTexture &&
				 viewport.ShowShadows && this.findVisibleObjects )
			{
				// Locate any lights which could be affecting the frustum
				this.FindLightsAffectingFrustum( camera );

				if ( this.IsShadowTechniqueTextureBased )
				{
					// *******
					// WARNING
					// *******
					// This call will result in re-entrant calls to this method
					// therefore anything which comes before this is NOT
					// guaranteed persistent. Make sure that anything which
					// MUST be specific to this camera / target is done
					// AFTER THIS POINT
					this.PrepareShadowTextures( camera, viewport );
					// reset the cameras because of the re-entrant call
					this.cameraInProgress = camera;
					this.hasCameraChanged = true;
				}
			}

			// Invert vertex winding?
			this.targetRenderSystem.InvertVertexWinding = camera.IsReflected;

			// Tell params about viewport
			this.autoParamDataSource.Viewport = viewport;
			// Set the viewport
			this.SetViewport( viewport );

			// set the current camera for use in the auto GPU program params
			this.autoParamDataSource.Camera = camera;

			// Set autoparams for finite dir light extrusion
			this.autoParamDataSource.SetShadowDirLightExtrusionDistance( this.shadowDirLightExtrudeDist );

			// sets the current ambient light color for use in auto GPU program params
			this.autoParamDataSource.AmbientLight = this.ambientColor;
			// Tell rendersystem
			this.targetRenderSystem.AmbientLight = this.ambientColor;

			// Tell params about render target
			this.autoParamDataSource.RenderTarget = viewport.Target;

			// set fog params
			float fogScale = 1f;
			if ( this.fogMode == FogMode.None )
			{
				fogScale = 0f;
			}
			this.autoParamDataSource.FogParams = new Vector4( this.fogStart, this.fogEnd, fogScale, 0 );

			// set the time in the auto param data source
			//autoParamDataSource.Time = ((float)Root.Instance.Timer.Milliseconds) / 1000f;

			// Set camera window clipping planes (if any)
			if ( this.targetRenderSystem.Capabilities.HasCapability( Capabilities.UserClipPlanes ) )
			{
				// TODO: Add ClipPlanes to RenderSystem.cs
				if ( camera.IsWindowSet )
				{
				    targetRenderSystem.ResetClipPlanes();
					IList<Plane> planeList = camera.WindowPlanes;
					for ( ushort i = 0; i < 4; ++i )
					{
					    targetRenderSystem.AddClipPlane( planeList[ i ] );

						//this.targetRenderSystem.EnableClipPlane( i, true );
						//this.targetRenderSystem.SetClipPlane( i, planeList[ i ] );
					}
				}
				// this disables any user-set clipplanes... this should be done manually
				//else
				//{
				//    for (ushort i = 0; i < 4; ++i)
				//    {
				//        targetRenderSystem.EnableClipPlane(i, false);
				//    }
				//}
			}

			// Prepare render queue for receiving new objects
			this.PrepareRenderQueue();

			// Parse the scene and tag visibles
			if ( this.findVisibleObjects )
			{
				if ( this.PreFindVisibleObjects != null )
					PreFindVisibleObjects( this, this.illuminationStage, viewport );
				this.FindVisibleObjects( camera, this.illuminationStage == IlluminationRenderStage.RenderToTexture );
				if ( this.PostFindVisibleObjects != null )
					PostFindVisibleObjects( this, this.illuminationStage, viewport );
			}

			// Add overlays, if viewport deems it
			if ( viewport.ShowOverlays && this.illuminationStage != IlluminationRenderStage.RenderToTexture )
			{
				// Queue overlays for rendering
				OverlayManager.Instance.QueueOverlaysForRendering( camera, this.GetRenderQueue(), viewport );
			}

			// queue overlays and skyboxes for rendering
			if ( viewport.ShowSkies && this.findVisibleObjects &&
				 this.illuminationStage != IlluminationRenderStage.RenderToTexture )
			{
				this.QueueSkiesForRendering( camera );
			}

			// begin frame geometry count
			this.targetRenderSystem.BeginGeometryCount();

			// clear the device if need be
			if ( viewport.ClearEveryFrame )
			{
				this.targetRenderSystem.ClearFrameBuffer( viewport.ClearBuffers, viewport.BackgroundColor );
			}

			// being a frame of animation
			this.targetRenderSystem.BeginFrame();

			// use the camera's current scene detail level
			this.targetRenderSystem.PolygonMode = camera.PolygonMode;

			// Set initial camera state
			this.targetRenderSystem.ProjectionMatrix = camera.ProjectionMatrixRS;
			this.targetRenderSystem.ViewMatrix = camera.ViewMatrix;

			// render all visible objects
			this.RenderVisibleObjects();

			// end the current frame
			this.targetRenderSystem.EndFrame();

			// Notify camera of the number of rendered faces
			camera.NotifyRenderedFaces( this.targetRenderSystem.FaceCount );

			// Notify camera of the number of rendered batches
			camera.NotifyRenderedBatches( this.targetRenderSystem.BatchCount );
		}
        /// <summary>
        ///		Prompts the class to send its contents to the renderer.
        /// </summary>
        /// <remarks>
        ///		This method prompts the scene manager to send the
        ///		contents of the scene it manages to the rendering
        ///		pipeline, possibly preceded by some sorting, culling
        ///		or other scene management tasks. Note that this method is not normally called
        ///		directly by the user application; it is called automatically
        ///		by the engine's rendering loop.
        /// </remarks>
        /// <param name="camera">Pointer to a camera from whose viewpoint the scene is to be rendered.</param>
        /// <param name="viewport">The target viewport</param>
        /// <param name="showOverlays">Whether or not any overlay objects should be rendered</param>
        internal void RenderScene(Camera camera, Viewport viewport, bool showOverlays)
        {
            renderSceneMeter.Enter();

            // let the engine know this is the current scene manager
            Root.Instance.SceneManager = this;

            if (IsShadowTechniqueInUse) {
                // initialize shadow volume materials
                InitShadowVolumeMaterials();
            }

            // Perform a quick pre-check to see whether we should override far distance
            // When using stencil volumes we have to use infinite far distance
            // to prevent dark caps getting clipped
            if (IsShadowTechniqueStencilBased &&
                camera.Far != 0 &&
                targetRenderSystem.Caps.CheckCap(Capabilities.InfiniteFarPlane) &&
                shadowUseInfiniteFarPlane) {

                // infinite far distance
                camera.Far = 0.0f;
            }

            cameraInProgress = camera;
            hasCameraChanged = true;

            // Update the scene, only do this once per frame
            ulong thisFrameNumber = Root.Instance.CurrentFrameCount;
            if (thisFrameNumber != lastFrameNumber) {
                // Update animations
                animationsMeter.Enter();
                ApplySceneAnimations();
                animationsMeter.Exit();
                // Update controllers
                ControllerManager.Instance.UpdateAll();
                lastFrameNumber = thisFrameNumber;
            }

            // Update scene graph for this camera (can happen multiple times per frame)
            UpdateSceneGraph(camera);

            // Auto-track nodes
            for(int i = 0; i < autoTrackingSceneNodes.Count; i++) {
                autoTrackingSceneNodes[i].AutoTrack();
            }

            // ask the camera to auto track if it has a target
            camera.AutoTrack();

            // Are we using any shadows at all?
            if (IsShadowTechniqueInUse && illuminationStage != IlluminationRenderStage.RenderToTexture &&
                viewport.ShadowsEnabled && findVisibleObjects) {
                // Locate any lights which could be affecting the frustum
                FindLightsAffectingFrustum(camera);

                if (IsShadowTechniqueTextureBased) {
                    // *******
                    // WARNING
                    // *******
                    // This call will result in re-entrant calls to this method
                    // therefore anything which comes before this is NOT
                    // guaranteed persistent. Make sure that anything which
                    // MUST be specific to this camera / target is done
                    // AFTER THIS POINT
                    PrepareShadowTextures(camera, viewport);
                    // reset the cameras because of the re-entrant call
                    cameraInProgress = camera;
                    hasCameraChanged = true;
                }
            }

            // Invert vertex winding?
            targetRenderSystem.InvertVertexWinding = camera.IsReflected;

            // Tell params about viewport
            autoParamDataSource.Viewport = viewport;
            // Set the viewport
            SetViewport(viewport);

            // set the current camera for use in the auto GPU program params
            autoParamDataSource.Camera = camera;

            // Set autoparams for finite dir light extrusion
            autoParamDataSource.SetShadowDirLightExtrusionDistance(shadowDirLightExtrudeDist);

            // sets the current ambient light color for use in auto GPU program params
            autoParamDataSource.AmbientLight = ambientColor;
            // Tell rendersystem
            targetRenderSystem.AmbientLight = ambientColor;

            // Tell params about render target
            autoParamDataSource.RenderTarget = viewport.Target;

            // set fog params
            float fogScale = 1f;
            if (fogMode == FogMode.None)
            {
                fogScale = 0f;
            }
            autoParamDataSource.FogParams = new Vector4(fogStart, fogEnd, fogScale, 0);

            // set the time in the auto param data source
            // autoParamDataSource.Time = ((float)Root.Instance.Timer.Milliseconds) / 1000f;

            // Set camera window clipping planes (if any)
            if (targetRenderSystem.Caps.CheckCap(Capabilities.UserClipPlanes)) {
                // TODO: Add ClipPlanes to RenderSystem.cs
                /*
                if (camera.IsWindowSet)
                {
                    PlaneList planeList = camera.WindowPlanes;
                    for (ushort i = 0; i < 4; ++i)
                    {
                        targetRenderSystem.EnableClipPlane(i, true);
                        targetRenderSystem.SetClipPlane(i, planeList[i]);
                    }
                }
                else
                {
                    for (ushort i = 0; i < 4; ++i)
                    {
                        targetRenderSystem.EnableClipPlane(i, false);
                    }
                }
                */
            }

            // Prepare render queue for receiving new objects
            PrepareRenderQueue();

            // Parse the scene and tag visibles
            if (findVisibleObjects) {
                VisibleObjectsBoundsInfo bounds;
                if (!camVisibleObjectsMap.TryGetValue(camera, out bounds))
                    Debug.Assert(false, "Should never fail to find a visible object bound for a camera, " +
                        "did you override SceneManager.CreateCamera or something?");
                else {
                    bounds.Reset();
                    findVisibleMeter.Enter();
                    FindVisibleObjects(camera, bounds, illuminationStage == IlluminationRenderStage.RenderToTexture);
                    findVisibleMeter.Exit();
                    autoParamDataSource.MainCamBoundsInfo = bounds;
                }
            }

            // Add overlays, if viewport deems it
            if(viewport.OverlaysEnabled && illuminationStage != IlluminationRenderStage.RenderToTexture) {
                // Queue overlays for rendering
                OverlayManager.Instance.QueueOverlaysForRendering(camera, GetRenderQueue(), viewport);
            }

            // queue overlays and skyboxes for rendering
            if (viewport.SkiesEnabled && findVisibleObjects &&
                illuminationStage != IlluminationRenderStage.RenderToTexture)
                QueueSkiesForRendering(camera);

            // begin frame geometry count
            targetRenderSystem.BeginGeometryCount();

            // Clear the viewport if required
            if (currentViewport.ClearEveryFrame)
                targetRenderSystem.ClearFrameBuffer(currentViewport.ClearBuffers, currentViewport.BackgroundColor);

            // being a frame of animation
            targetRenderSystem.BeginFrame();

            // use the camera's current scene detail level
            targetRenderSystem.RasterizationMode = camera.SceneDetail;

            // Set initial camera state
            targetRenderSystem.ProjectionMatrix = camera.ProjectionMatrixRS;
            targetRenderSystem.ViewMatrix = camera.ViewMatrix;

            // render all visible objects
            renderVisibleMeter.Enter();
            RenderVisibleObjects();
            renderVisibleMeter.Exit();

            // end the current frame
            targetRenderSystem.EndFrame();

            // Notify camera of the number of rendered faces
            camera.NotifyRenderedFaces(targetRenderSystem.FacesRendered);

            renderSceneMeter.Exit();
        }