Example #1
0
        private void Refraction_AfterUpdate(object sender, RenderTargetUpdateEventArgs e)
        {
            planeEnt.IsVisible = true;

            for (int i = 0; i < aboveWaterEnts.Count; i++)
            {
                ((Entity)aboveWaterEnts[i]).IsVisible = true;
            }
        }
Example #2
0
        private void Reflection_AfterUpdate(object sender, RenderTargetUpdateEventArgs e)
        {
            planeEnt.IsVisible = true;

            for (int i = 0; i < belowWaterEnts.Count; i++)
            {
                ((Entity)belowWaterEnts[i]).IsVisible = true;
            }

            theCam.DisableReflection();
        }
Example #3
0
        private void Reflection_BeforeUpdate(object sender, RenderTargetUpdateEventArgs e)
        {
            planeEnt.IsVisible = false;

            for (int i = 0; i < belowWaterEnts.Count; i++)
            {
                ((Entity)belowWaterEnts[i]).IsVisible = false;
            }

            theCam.EnableReflection(reflectionPlane);
        }
        ///<summary>
        ///    @see RenderTargetListener.PreRenderTargetUpdate
        ///</summary>
        public void BeforeRenderTargetUpdate(object sender, RenderTargetUpdateEventArgs evt)
        {
            /// Compile if state is dirty
            if (dirty)
            {
                Compile();
            }

            // Do nothing if no compositors enabled
            if (!anyCompositorsEnabled)
            {
                return;
            }

            /// Update dependent render targets; this is done in the preRenderTarget
            /// and not the preViewportUpdate for a reason: at this time, the
            /// target Rendertarget will not yet have been set as current.
            /// ( RenderSystem::setViewport(...) ) if it would have been, the rendering
            /// order would be screwed up and problems would arise with copying rendertextures.
            Camera cam = viewport.Camera;

            /// Iterate over compiled state
            foreach (CompositorTargetOperation op in compiledState)
            {
                /// Skip if this is a target that should only be initialised initially
                if (op.OnlyInitial && op.HasBeenRendered)
                {
                    continue;
                }
                op.HasBeenRendered = true;
                /// Setup and render
                PreTargetOperation(op, op.Target.GetViewport(0), cam);
                op.Target.Update();
                PostTargetOperation(op, op.Target.GetViewport(0), cam);
            }
        }
        ///<summary>
        ///    @see RenderTargetListener.PreRenderTargetUpdate
        ///</summary>
        public void BeforeRenderTargetUpdate(object sender, RenderTargetUpdateEventArgs evt)
        {
            /// Compile if state is dirty
            if(dirty)
                Compile();

            // Do nothing if no compositors enabled
            if (!anyCompositorsEnabled)
                return;

            /// Update dependent render targets; this is done in the preRenderTarget
            /// and not the preViewportUpdate for a reason: at this time, the
            /// target Rendertarget will not yet have been set as current.
            /// ( RenderSystem::setViewport(...) ) if it would have been, the rendering
            /// order would be screwed up and problems would arise with copying rendertextures.
            Camera cam = viewport.Camera;
            /// Iterate over compiled state
            foreach (CompositorTargetOperation op in compiledState) {
                /// Skip if this is a target that should only be initialised initially
                if(op.OnlyInitial && op.HasBeenRendered)
                    continue;
                op.HasBeenRendered = true;
                /// Setup and render
                PreTargetOperation(op, op.Target.GetViewport(0), cam);
                op.Target.Update();
                PostTargetOperation(op, op.Target.GetViewport(0), cam);
            }
        }
        private void Refraction_BeforeUpdate(object sender, RenderTargetUpdateEventArgs e)
        {
            planeEnt.IsVisible = false;

            for(int i = 0; i < aboveWaterEnts.Count; i++) {
                ((Entity)aboveWaterEnts[i]).IsVisible = false;
            }
        }
        private void Reflection_BeforeUpdate(object sender, RenderTargetUpdateEventArgs e)
        {
            planeEnt.IsVisible = false;

            for(int i = 0; i < belowWaterEnts.Count; i++) {
                ((Entity)belowWaterEnts[i]).IsVisible = false;
            }

            theCam.EnableReflection(reflectionPlane);
        }
        private void Reflection_AfterUpdate(object sender, RenderTargetUpdateEventArgs e)
        {
            planeEnt.IsVisible = true;

            for(int i = 0; i < belowWaterEnts.Count; i++) {
                ((Entity)belowWaterEnts[i]).IsVisible = true;
            }

            theCam.DisableReflection();
        }
 /// <summary>
 ///		Hides the render target plane prior to the update.
 /// </summary>
 /// <param name="sender"></param>
 /// <param name="e"></param>
 private void rttTex_BeforeUpdate(object sender, RenderTargetUpdateEventArgs e)
 {
     planeEntity.IsVisible = false;
 }
 /// <summary>
 ///		Shows the render target plane again after the update.
 /// </summary>
 /// <param name="sender"></param>
 /// <param name="e"></param>
 private void rttTex_AfterUpdate(object sender, RenderTargetUpdateEventArgs e)
 {
     planeEntity.IsVisible = true;
 }
Example #11
0
 /// <summary>
 ///		Shows the render target plane again after the update.
 /// </summary>
 /// <param name="sender"></param>
 /// <param name="e"></param>
 private void rttTex_AfterUpdate(object sender, RenderTargetUpdateEventArgs e)
 {
     planeEntity.IsVisible = true;
 }
Example #12
0
 /// <summary>
 ///		Hides the render target plane prior to the update.
 /// </summary>
 /// <param name="sender"></param>
 /// <param name="e"></param>
 private void rttTex_BeforeUpdate(object sender, RenderTargetUpdateEventArgs e)
 {
     planeEntity.IsVisible = false;
 }