/// <summary> /// Create's a new Composition technique /// </summary> /// <param name="parent">parent of this technique</param> public CompositionTechnique(Compositor parent) { this.parent = parent; this.outputTarget = new CompositionTargetPass(this); this.textureDefinitions = new List <TextureDefinition>(); this.targetPasses = new List <CompositionTargetPass>(); }
public CompositionPass(CompositionTargetPass parent) { this.parent = parent; this.type = CompositorPassType.RenderQuad; this.identifier = 0; this.firstRenderQueue = RenderQueueGroupID.Background; this.lastRenderQueue = RenderQueueGroupID.SkiesLate; this.materialSchemeName = string.Empty; this.clearBuffers = FrameBufferType.Color | FrameBufferType.Depth; this.clearColor = new ColorEx(0f, 0f, 0f, 0f); this.clearDepth = 1.0f; this.clearStencil = 0; this.stencilCheck = false; this.stencilFunc = CompareFunction.AlwaysPass; this.stencilRefValue = 0; this.stencilMask = 0x7FFFFFFF; this.stencilFailOp = StencilOperation.Keep; this.stencilDepthFailOp = StencilOperation.Keep; this.stencilPassOp = StencilOperation.Keep; this.stencilTwoSidedOperation = false; this.quadCornerModified = false; this.quadLeft = -1; this.quadTop = 1; this.quadRight = 1; this.quadBottom = -1; this.quadFarCorners = false; this.quadFarCornersViewSpace = false; }
/// <summary> /// Create's a new target pass. /// </summary> /// <returns>pointer to a new target pass</returns> public virtual CompositionTargetPass CreateTargetPass() { var t = new CompositionTargetPass(this); this.targetPasses.Add(t); return(t); }
///<summary> /// Create a new target pass, and return a pointer to it. ///</summary> public CompositionTargetPass CreateTargetPass() { CompositionTargetPass t = new CompositionTargetPass(this); targetPasses.Add(t); return(t); }
/// <summary> /// Create "default compositor" /// </summary> protected void CreateOriginalScene() { this.originalSceneMaterial = this.viewport.MaterialScheme; string compName = "Axiom/Scene/" + this.originalSceneMaterial; var scene = (Compositor)CompositorManager.Instance.GetByName(compName); if (scene == null) { scene = (Compositor)CompositorManager.Instance.Create(compName, ResourceGroupManager.InternalResourceGroupName); CompositionTechnique t = scene.CreateTechnique(); t.SchemeName = string.Empty; CompositionTargetPass tp = t.OutputTarget; tp.VisibilityMask = 0xFFFFFFFF; { CompositionPass pass = tp.CreatePass(); pass.Type = CompositorPassType.Clear; } { CompositionPass pass = tp.CreatePass(); pass.Type = CompositorPassType.RenderScene; //Render everything, including skies pass.FirstRenderQueue = RenderQueueGroupID.Background; pass.LastRenderQueue = RenderQueueGroupID.SkiesLate; } scene = (Compositor)CompositorManager.Instance.Load(compName, ResourceGroupManager.InternalResourceGroupName); } this.originalScene = new CompositorInstance(scene.GetSupportedTechniqueByScheme(), this); }
public CompositionTechnique(Compositor parent) { this.parent = parent; textureDefinitions = new List<CompositionTextureDefinition>(); targetPasses = new List<CompositionTargetPass>(); outputTarget = new CompositionTargetPass(this); instances = new List<CompositorInstance>(); }
protected override void dispose(bool disposeManagedResources) { if (!IsDisposed) { if (disposeManagedResources) { return; RemoveAllTextureDefinitions(); RemoveAllTargetPasses(); this.outputTarget.Dispose(); this.outputTarget = null; } } base.dispose(disposeManagedResources); }
///<summary> /// Compile the final (output) operation. This is done seperately because this /// is combined with the input in chained filters. ///</summary> public void CompileOutputOperation(CompositorTargetOperation finalState) { /// Final target CompositionTargetPass tpass = technique.OutputTarget; /// Logical-and together the visibilityMask, and multiply the lodBias finalState.VisibilityMask &= tpass.VisibilityMask; finalState.LodBias *= tpass.LodBias; if (tpass.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(finalState); } /// Collect passes CollectPasses(finalState, tpass); }
public CompositionPass(CompositionTargetPass parent) { this.parent = parent; type = CompositorPassType.RenderQuad; identifier = 0; firstRenderQueue = RenderQueueGroupID.SkiesEarly; lastRenderQueue = RenderQueueGroupID.SkiesLate; clearBuffers = FrameBuffer.Color | FrameBuffer.Depth; clearColor = new ColorEx(0f, 0f, 0f, 0f); clearDepth = 1.0f; clearStencil = 0; stencilCheck = false; stencilFunc = CompareFunction.AlwaysPass; stencilRefValue = 0; stencilMask = (int)0x7FFFFFFF; stencilFailOp = StencilOperation.Keep; stencilDepthFailOp = StencilOperation.Keep; stencilPassOp = StencilOperation.Keep; stencilTwoSidedOperation = false; }
///<summary> /// Intialises the Compositor manager, which also triggers it to /// parse all available .compositor scripts. ///</summary> public void Initialize() { Compositor scene = (Compositor)Create("Ogre/Scene"); CompositionTechnique t = scene.CreateTechnique(); CompositionTargetPass tp = t.OutputTarget; tp.VisibilityMask = 0xFFFFFFFF; CompositionPass pass = tp.CreatePass(); pass.Type = CompositorPassType.Clear; CompositionPass nextPass = tp.CreatePass(); nextPass.Type = CompositorPassType.RenderScene; /// Render everything, including skies pass.FirstRenderQueue = RenderQueueGroupID.SkiesEarly; pass.LastRenderQueue = RenderQueueGroupID.SkiesLate; chains = new Dictionary <Viewport, CompositorChain>(); // parse all compositing scripts ParseAllSources(); }
/// <see cref="Translator.Translate"/> public override void Translate( ScriptCompiler compiler, AbstractNode node ) { var obj = (ObjectAbstractNode)node; var technique = (CompositionTechnique)obj.Parent.Context; if ( obj.Id == (uint)Keywords.ID_TARGET ) { this._Target = technique.CreateTargetPass(); if ( !string.IsNullOrEmpty( obj.Name ) ) { this._Target.OutputName = obj.Name; } } else if ( obj.Id == (uint)Keywords.ID_TARGET_OUTPUT ) { this._Target = technique.OutputTarget; } obj.Context = this._Target; foreach ( var i in obj.Children ) { if ( i is ObjectAbstractNode ) { processNode( compiler, i ); } else if ( i is PropertyAbstractNode ) { var prop = (PropertyAbstractNode)i; switch ( (Keywords)prop.Id ) { #region ID_INPUT case Keywords.ID_INPUT: if ( prop.Values.Count == 0 ) { compiler.AddError( CompileErrorCode.StringExpected, prop.File, prop.Line ); return; } else if ( prop.Values.Count > 1 ) { compiler.AddError( CompileErrorCode.FewerParametersExpected, prop.File, prop.Line ); return; } else { if ( prop.Values[ 0 ] is AtomAbstractNode ) { var atom = (AtomAbstractNode)prop.Values[ 0 ]; switch ( (Keywords)atom.Id ) { case Keywords.ID_NONE: this._Target.InputMode = CompositorInputMode.None; break; case Keywords.ID_PREVIOUS: this._Target.InputMode = CompositorInputMode.Previous; break; default: compiler.AddError( CompileErrorCode.InvalidParameters, prop.File, prop.Line ); break; } } else { compiler.AddError( CompileErrorCode.InvalidParameters, prop.File, prop.Line ); } } break; #endregion ID_INPUT #region ID_ONLY_INITIAL case Keywords.ID_ONLY_INITIAL: if ( prop.Values.Count == 0 ) { compiler.AddError( CompileErrorCode.StringExpected, prop.File, prop.Line ); return; } else if ( prop.Values.Count > 1 ) { compiler.AddError( CompileErrorCode.FewerParametersExpected, prop.File, prop.Line ); return; } else { var val = false; if ( getBoolean( prop.Values[ 0 ], out val ) ) { this._Target.OnlyInitial = val; } else { compiler.AddError( CompileErrorCode.InvalidParameters, prop.File, prop.Line ); } } break; #endregion ID_ONLY_INITIAL #region ID_VISIBILITY_MASK case Keywords.ID_VISIBILITY_MASK: if ( prop.Values.Count == 0 ) { compiler.AddError( CompileErrorCode.StringExpected, prop.File, prop.Line ); return; } else if ( prop.Values.Count > 1 ) { compiler.AddError( CompileErrorCode.FewerParametersExpected, prop.File, prop.Line ); return; } else { uint val; if ( getUInt( prop.Values[ 0 ], out val ) ) { this._Target.VisibilityMask = val; } else { compiler.AddError( CompileErrorCode.InvalidParameters, prop.File, prop.Line ); } } break; #endregion ID_VISIBILITY_MASK #region ID_LOD_BIAS case Keywords.ID_LOD_BIAS: if ( prop.Values.Count == 0 ) { compiler.AddError( CompileErrorCode.StringExpected, prop.File, prop.Line ); return; } else if ( prop.Values.Count > 1 ) { compiler.AddError( CompileErrorCode.FewerParametersExpected, prop.File, prop.Line ); return; } else { float val; if ( getFloat( prop.Values[ 0 ], out val ) ) { this._Target.LodBias = val; } else { compiler.AddError( CompileErrorCode.InvalidParameters, prop.File, prop.Line ); } } break; #endregion ID_LOD_BIAS #region ID_MATERIAL_SCHEME case Keywords.ID_MATERIAL_SCHEME: if ( prop.Values.Count == 0 ) { compiler.AddError( CompileErrorCode.StringExpected, prop.File, prop.Line ); return; } else if ( prop.Values.Count > 1 ) { compiler.AddError( CompileErrorCode.FewerParametersExpected, prop.File, prop.Line ); return; } else { string val; if ( getString( prop.Values[ 0 ], out val ) ) { this._Target.MaterialScheme = val; } else { compiler.AddError( CompileErrorCode.InvalidParameters, prop.File, prop.Line ); } } break; #endregion ID_MATERIAL_SCHEME #region ID_SHADOWS_ENABLED case Keywords.ID_SHADOWS_ENABLED: if ( prop.Values.Count == 0 ) { compiler.AddError( CompileErrorCode.StringExpected, prop.File, prop.Line ); return; } else if ( prop.Values.Count > 1 ) { compiler.AddError( CompileErrorCode.FewerParametersExpected, prop.File, prop.Line ); return; } else { bool val; if ( getBoolean( prop.Values[ 0 ], out val ) ) { this._Target.ShadowsEnabled = val; } else { compiler.AddError( CompileErrorCode.InvalidParameters, prop.File, prop.Line ); } } break; #endregion ID_SHADOWS_ENABLED default: compiler.AddError( CompileErrorCode.UnexpectedToken, prop.File, prop.Line, "token \"" + prop.Name + "\" is not recognized" ); break; } } } }
public CompositionTargetPassTranslator() : base() { this._Target = null; }
///<summary> /// Collect rendering passes. Here, passes are converted into render target operations /// and queued with queueRenderSystemOp. ///</summary> protected void CollectPasses(CompositorTargetOperation finalState, CompositionTargetPass target) { /// Here, passes are converted into render target operations Pass targetpass; Technique srctech; Material srcmat; foreach (CompositionPass pass in target.Passes) { switch(pass.Type) { case CompositorPassType.Clear: QueueRenderSystemOp(finalState, new RSClearOperation( pass.ClearBuffers, pass.ClearColor, pass.ClearDepth, pass.ClearStencil)); break; case CompositorPassType.Stencil: QueueRenderSystemOp(finalState, new RSStencilOperation( pass.StencilCheck, pass.StencilFunc, pass.StencilRefValue, pass.StencilMask, pass.StencilFailOp, pass.StencilDepthFailOp, pass.StencilPassOp, pass.StencilTwoSidedOperation )); break; case CompositorPassType.RenderScene: if((int)pass.FirstRenderQueue < (int)finalState.CurrentQueueGroupID) { /// Mismatch -- warn user /// XXX We could support repeating the last queue, with some effort LogManager.Instance.Write("Warning in compilation of Compositor " + compositor.Name + ": Attempt to render queue " + pass.FirstRenderQueue + " before "+ finalState.CurrentQueueGroupID); } /// Add render queues for(RenderQueueGroupID x=pass.FirstRenderQueue; x<=pass.LastRenderQueue; ++x) { Debug.Assert(x>=0); finalState.RenderQueues[(int)x] = true; } finalState.CurrentQueueGroupID = (RenderQueueGroupID)((int)pass.LastRenderQueue + 1); finalState.FindVisibleObjects = true; finalState.MaterialScheme = target.MaterialScheme; break; case CompositorPassType.RenderQuad: srcmat = pass.Material; if(srcmat == null) { /// No material -- warn user LogManager.Instance.Write("Warning in compilation of Compositor " + compositor.Name + ": No material defined for composition pass"); break; } srcmat.Load(); if(srcmat.SupportedTechniques.Count == 0) { /// No supported techniques -- warn user LogManager.Instance.Write("Warning in compilation of Compositor " + compositor.Name + ": material " + srcmat.Name + " has no supported techniques"); break; } srctech = srcmat.GetBestTechnique(0); /// Create local material Material localMat = CreateLocalMaterial(); /// Copy and adapt passes from source material for (int i=0; i<srctech.NumPasses; i++) { Pass srcpass = srctech.GetPass(i); /// Create new target pass targetpass = localMat.GetTechnique(0).CreatePass(); srcpass.CopyTo(targetpass); /// Set up inputs int numInputs = pass.GetNumInputs(); for (int x = 0; x < numInputs; x++) { string inp = pass.Inputs[x]; if (inp != string.Empty) { if (x < targetpass.NumTextureUnitStages) targetpass.GetTextureUnitState(x).SetTextureName(GetSourceForTex(inp)); else { /// Texture unit not there LogManager.Instance.Write("Warning in compilation of Compositor " + compositor.Name + ": material " + srcmat.Name + " texture unit " + x + " out of bounds"); } } } } QueueRenderSystemOp(finalState, new RSQuadOperation(this, pass.Identifier, localMat)); break; } } }
///<summary> /// Collect rendering passes. Here, passes are converted into render target operations /// and queued with queueRenderSystemOp. ///</summary> protected void CollectPasses( CompositeTargetOperation finalState, CompositionTargetPass target ) { // Here, passes are converted into render target operations Pass targetPass = null; Technique srctech = null; Material mat = null, srcmat = null; foreach ( var pass in target.Passes ) { switch ( pass.Type ) { case CompositorPassType.Clear: { QueueRenderSystemOp( finalState, new RSClearOperation( pass.ClearBuffers, pass.ClearColor, pass.ClearDepth, pass.ClearStencil ) ); } break; case CompositorPassType.Stencil: { QueueRenderSystemOp( finalState, new RSStencilOperation( pass.StencilCheck, pass.StencilFunc, pass.StencilRefValue, pass.StencilMask, pass.StencilFailOp, pass.StencilDepthFailOp, pass.StencilPassOp, pass.StencilTwoSidedOperation ) ); } break; case CompositorPassType.RenderScene: { if ( pass.FirstRenderQueue < finalState.CurrentQueueGroupId ) { // Mismatch -- warn user // XXX We could support repeating the last queue, with some effort LogManager.Instance.Write( "Warning in compilation of Compositor {0}: Attempt to render queue {1} before {2}.", this.compositor.Name, pass.FirstRenderQueue, finalState.CurrentQueueGroupId ); } RSSetSchemeOperation setSchemeOperation = null; if ( pass.MaterialScheme != string.Empty ) { //Add the triggers that will set the scheme and restore it each frame finalState.CurrentQueueGroupId = pass.FirstRenderQueue; setSchemeOperation = new RSSetSchemeOperation( pass.MaterialScheme ); QueueRenderSystemOp( finalState, setSchemeOperation ); } // Add render queues for ( var x = (int)pass.FirstRenderQueue; x < (int)pass.LastRenderQueue; x++ ) { Debug.Assert( x >= 0 ); finalState.RenderQueues.Set( x, true ); } finalState.CurrentQueueGroupId = pass.LastRenderQueue + 1; if ( setSchemeOperation != null ) { //Restoring the scheme after the queues have been rendered QueueRenderSystemOp( finalState, new RSRestoreSchemeOperation( setSchemeOperation ) ); } finalState.FindVisibleObjects = true; finalState.MaterialScheme = target.MaterialScheme; finalState.ShadowsEnabled = target.ShadowsEnabled; } break; case CompositorPassType.RenderQuad: { srcmat = pass.Material; if ( srcmat == null ) { // No material -- warn user LogManager.Instance.Write( "Warning in compilation of Compositor {0}: No material defined for composition pass.", this.compositor.Name ); break; } srcmat.Load(); if ( srcmat.SupportedTechniques.Count == 0 ) { // No supported techniques -- warn user LogManager.Instance.Write( "Warning in compilation of Compositor {0}: material {1} has no supported techniques.", this.compositor.Name, srcmat.Name ); break; } srctech = srcmat.GetBestTechnique( 0 ); // Create local material mat = CreateLocalMaterial( srcmat.Name ); // Copy and adapt passes from source material for ( var i = 0; i < srctech.PassCount; i++ ) { var srcpass = srctech.GetPass( i ); // Create new target pass targetPass = mat.GetTechnique( 0 ).CreatePass(); srcpass.CopyTo( targetPass ); // Set up inputs for ( var x = 0; x < pass.InputsCount; x++ ) { var inp = pass.GetInput( x ); if ( !string.IsNullOrEmpty( inp.Name ) ) { if ( x < targetPass.TextureUnitStatesCount ) { targetPass.GetTextureUnitState( x ).SetTextureName( GetTextureInstance( inp.Name, inp.MrtIndex ).Name ); } else { // Texture unit not there LogManager.Instance.Write( "Warning in compilation of Compositor {0}: material {1} texture unit {2} out of bounds.", this.compositor.Name, srcmat.Name, x ); } } } //end for inputs.length } //end for passcount var rsQuadOperation = new RSQuadOperation( this, pass.Identifier, mat ); float left, top, right, bottom; if ( pass.GetQuadCorners( out left, out top, out right, out bottom ) ) { rsQuadOperation.SetQuadCorners( left, top, right, bottom ); } rsQuadOperation.SetQuadFarCorners( pass.QuadFarCorners, pass.QuadFarCornersViewSpace ); QueueRenderSystemOp( finalState, rsQuadOperation ); } break; case CompositorPassType.RenderCustom: { var customOperation = CompositorManager.Instance.CustomCompositionPasses[ pass.CustomType ].CreateOperation( this, pass ); QueueRenderSystemOp( finalState, customOperation ); } break; } } }
///<summary> /// Create a new target pass, and return a pointer to it. ///</summary> public CompositionTargetPass CreateTargetPass() { CompositionTargetPass t = new CompositionTargetPass(this); targetPasses.Add(t); return t; }
protected override void dispose( bool disposeManagedResources ) { if ( !IsDisposed ) { if ( disposeManagedResources ) { return; RemoveAllTextureDefinitions(); RemoveAllTargetPasses(); this.outputTarget.Dispose(); this.outputTarget = null; } } base.dispose( disposeManagedResources ); }
///<summary> /// Collect rendering passes. Here, passes are converted into render target operations /// and queued with queueRenderSystemOp. ///</summary> protected void CollectPasses(CompositorTargetOperation finalState, CompositionTargetPass target) { /// Here, passes are converted into render target operations Pass targetpass; Technique srctech; Material srcmat; foreach (CompositionPass pass in target.Passes) { switch (pass.Type) { case CompositorPassType.Clear: QueueRenderSystemOp(finalState, new RSClearOperation( pass.ClearBuffers, pass.ClearColor, pass.ClearDepth, pass.ClearStencil)); break; case CompositorPassType.Stencil: QueueRenderSystemOp(finalState, new RSStencilOperation( pass.StencilCheck, pass.StencilFunc, pass.StencilRefValue, pass.StencilMask, pass.StencilFailOp, pass.StencilDepthFailOp, pass.StencilPassOp, pass.StencilTwoSidedOperation )); break; case CompositorPassType.RenderScene: if ((int)pass.FirstRenderQueue < (int)finalState.CurrentQueueGroupID) { /// Mismatch -- warn user /// XXX We could support repeating the last queue, with some effort LogManager.Instance.Write("Warning in compilation of Compositor " + compositor.Name + ": Attempt to render queue " + pass.FirstRenderQueue + " before " + finalState.CurrentQueueGroupID); } /// Add render queues for (RenderQueueGroupID x = pass.FirstRenderQueue; x <= pass.LastRenderQueue; ++x) { Debug.Assert(x >= 0); finalState.RenderQueues[(int)x] = true; } finalState.CurrentQueueGroupID = (RenderQueueGroupID)((int)pass.LastRenderQueue + 1); finalState.FindVisibleObjects = true; finalState.MaterialScheme = target.MaterialScheme; break; case CompositorPassType.RenderQuad: srcmat = pass.Material; if (srcmat == null) { /// No material -- warn user LogManager.Instance.Write("Warning in compilation of Compositor " + compositor.Name + ": No material defined for composition pass"); break; } srcmat.Load(); if (srcmat.SupportedTechniques.Count == 0) { /// No supported techniques -- warn user LogManager.Instance.Write("Warning in compilation of Compositor " + compositor.Name + ": material " + srcmat.Name + " has no supported techniques"); break; } srctech = srcmat.GetBestTechnique(0); /// Create local material Material localMat = CreateLocalMaterial(); /// Copy and adapt passes from source material for (int i = 0; i < srctech.NumPasses; i++) { Pass srcpass = srctech.GetPass(i); /// Create new target pass targetpass = localMat.GetTechnique(0).CreatePass(); srcpass.CopyTo(targetpass); /// Set up inputs int numInputs = pass.GetNumInputs(); for (int x = 0; x < numInputs; x++) { string inp = pass.Inputs[x]; if (inp != string.Empty) { if (x < targetpass.NumTextureUnitStages) { targetpass.GetTextureUnitState(x).SetTextureName(GetSourceForTex(inp)); } else { /// Texture unit not there LogManager.Instance.Write("Warning in compilation of Compositor " + compositor.Name + ": material " + srcmat.Name + " texture unit " + x + " out of bounds"); } } } } QueueRenderSystemOp(finalState, new RSQuadOperation(this, pass.Identifier, localMat)); break; } } }
public CompositionPass( CompositionTargetPass parent ) { this.parent = parent; type = CompositorPassType.RenderQuad; identifier = 0; firstRenderQueue = RenderQueueGroupID.Background; lastRenderQueue = RenderQueueGroupID.SkiesLate; materialSchemeName = string.Empty; clearBuffers = FrameBufferType.Color | FrameBufferType.Depth; clearColor = new ColorEx( 0f, 0f, 0f, 0f ); clearDepth = 1.0f; clearStencil = 0; stencilCheck = false; stencilFunc = CompareFunction.AlwaysPass; stencilRefValue = 0; stencilMask = 0x7FFFFFFF; stencilFailOp = StencilOperation.Keep; stencilDepthFailOp = StencilOperation.Keep; stencilPassOp = StencilOperation.Keep; stencilTwoSidedOperation = false; quadCornerModified = false; quadLeft = -1; quadTop = 1; quadRight = 1; quadBottom = -1; quadFarCorners = false; quadFarCornersViewSpace = false; }
/// <summary> /// Create's a new target pass. /// </summary> /// <returns>pointer to a new target pass</returns> public virtual CompositionTargetPass CreateTargetPass() { var t = new CompositionTargetPass( this ); this.targetPasses.Add( t ); return t; }