CompileOutputOperation() public method

Compile the final (output) operation. This is done seperately because this is combined with the input in chained filters.
public CompileOutputOperation ( CompositeTargetOperation finalState ) : void
finalState CompositeTargetOperation
return void
Ejemplo n.º 1
0
 ///<summary>
 ///    Recursively collect target states (except for final Pass).
 ///</summary>
 ///<param name="compiledState">This vector will contain a list of TargetOperation objects</param>
 public void CompileTargetOperations(List <CompositorTargetOperation> compiledState)
 {
     /// Collect targets of previous state
     if (previousInstance != null)
     {
         previousInstance.CompileTargetOperations(compiledState);
     }
     /// Texture targets
     foreach (CompositionTargetPass target in technique.TargetPasses)
     {
         CompositorTargetOperation ts = new CompositorTargetOperation(GetTargetForTex(target.OutputName));
         /// Set "only initial" flag, visibilityMask and lodBias according to CompositionTargetPass.
         ts.OnlyInitial    = target.OnlyInitial;
         ts.VisibilityMask = target.VisibilityMask;
         ts.LodBias        = target.LodBias;
         /// Check for input mode previous
         if (target.InputMode == CompositorInputMode.Previous)
         {
             /// Collect target state for previous compositor
             /// The TargetOperation for the final target is collected seperately as it is merged
             /// with later operations
             previousInstance.CompileOutputOperation(ts);
         }
         /// Collect passes of our own target
         CollectPasses(ts, target);
         compiledState.Add(ts);
     }
 }
        ///<summary>
        ///    Compile this Composition chain into a series of RenderTarget operations.
        ///</summary>
        protected void Compile()
        {
            ClearCompiledState();

            bool compositorsEnabled = false;

            /// Set previous CompositorInstance for each compositor in the list
            CompositorInstance lastComposition = originalScene;

            originalScene.PreviousInstance = null;
            CompositionPass pass = originalScene.Technique.OutputTarget.GetPass(0);

            pass.ClearBuffers = viewport.ClearBuffers;
            pass.ClearColor   = viewport.BackgroundColor;
            foreach (CompositorInstance instance in instances)
            {
                if (instance.Enabled)
                {
                    compositorsEnabled        = true;
                    instance.PreviousInstance = lastComposition;
                    lastComposition           = instance;
                }
            }

            /// Compile misc targets
            lastComposition.CompileTargetOperations(compiledState);

            /// Final target viewport (0)
            outputOperation.RenderSystemOperations.Clear();
            lastComposition.CompileOutputOperation(outputOperation);

            // Deal with viewport settings
            if (compositorsEnabled != anyCompositorsEnabled)
            {
                anyCompositorsEnabled = compositorsEnabled;
                if (anyCompositorsEnabled)
                {
                    // Save old viewport clearing options
                    oldClearEveryFrameBuffers = viewport.ClearBuffers;
                    // Don't clear anything every frame since we have our own clear ops
                    viewport.SetClearEveryFrame(false);
                }
                else
                {
                    // Reset clearing options
                    viewport.SetClearEveryFrame(oldClearEveryFrameBuffers > 0,
                                                oldClearEveryFrameBuffers);
                }
            }
            dirty = false;
        }