/// <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); }
///<summary> /// Apply a compositor. Initially, the filter is enabled. ///</summary> ///<param name="filter">Filter to apply</param> ///<param name="addPosition">Position in filter chain to insert this filter at; defaults to the end (last applied filter)</param> ///<param name="technique">Technique to use; CompositorChain::BEST (default) chooses to the best one /// available (first technique supported) ///</param> ///<param name="scheme"></param> private CompositorInstance AddCompositor(Compositor filter, int addPosition, int technique, string scheme) { filter.Touch(); CompositionTechnique tech = filter.GetSupportedTechniqueByScheme(scheme); if (tech == null) { LogManager.Instance.DefaultLog.Write("CompositorChain: Compositor " + filter.Name + " has no supported techniques."); } var t = new CompositorInstance(tech, this); if (addPosition == lastCompositor) { addPosition = this.instances.Count; } else { Debug.Assert(addPosition <= this.instances.Count, "Index out of bounds."); } this.instances.Insert(addPosition, t); this.dirty = true; this.anyCompositorsEnabled = true; return(t); }
///<summary> /// Create a new technique, and return a pointer to it. ///</summary> public CompositionTechnique CreateTechnique() { var t = new CompositionTechnique(this); this.techniques.Add(t); this.compilationRequired = true; return(t); }
public CompositionTargetPass(CompositionTechnique parent) { this.parent = parent; inputMode = CompositorInputMode.None; passes = new List <CompositionPass>(); onlyInitial = false; visibilityMask = 0xFFFFFFFF; lodBias = 1.0f; materialScheme = MaterialManager.DefaultSchemeName; }
public CompositorInstance(Compositor filter, CompositionTechnique technique, CompositorChain chain) { this.compositor = filter; this.technique = technique; this.chain = chain; this.enabled = false; localTextures = new Dictionary <string, Texture>(); renderSystemOperations = new List <QueueIDAndOperation>(); listeners = new List <CompositorInstanceListener>(); }
public CompositionTargetPass(CompositionTechnique parent) { this.parent = parent; this.inputMode = CompositorInputMode.None; this.passes = new List <CompositionPass>(); this.onlyInitial = false; this.visibilityMask = 0xFFFFFFFF; this.lodBias = 1.0f; this.materialScheme = MaterialManager.DefaultSchemeName; ShadowsEnabled = true; if (Root.Instance.RenderSystem != null) { this.materialScheme = Root.Instance.RenderSystem.DefaultViewportMaterialScheme; } }
///<summary> /// Apply a compositor. Initially, the filter is enabled. ///</summary> ///<param name="filter">Filter to apply</param> ///<param name="addPosition">Position in filter chain to insert this filter at; defaults to the end (last applied filter)</param> ///<param name="technique">Technique to use; CompositorChain::BEST (default) chooses to the best one /// available (first technique supported) ///</param> CompositorInstance AddCompositor(Compositor filter, int addPosition, int technique) { // Init on demand if (originalScene == null) { viewport.Target.BeforeUpdate += BeforeRenderTargetUpdate; // viewport.Target.AfterUpdate += AfterRenderTargetUpdate; viewport.Target.BeforeViewportUpdate += BeforeViewportUpdate; viewport.Target.AfterViewportUpdate += AfterViewportUpdate; /// Create base "original scene" compositor Compositor baseCompositor = (Compositor)CompositorManager.Instance.LoadExisting("Ogre/Scene"); originalScene = baseCompositor.GetSupportedTechnique(0).CreateInstance(this); } filter.Touch(); if (technique >= filter.SupportedTechniques.Count) { /// Warn user LogManager.Instance.Write("CompositorChain: Compositor " + filter.Name + " has no supported techniques."); return(null); } CompositionTechnique tech = filter.GetSupportedTechnique(technique); CompositorInstance t = tech.CreateInstance(this); if (addPosition == lastCompositor) { instances.Add(t); } else { Debug.Assert(addPosition <= instances.Count); instances.Insert(addPosition, t); } dirty = true; anyCompositorsEnabled = true; return(t); }
///<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(); }
public CompositorInstance( CompositionTechnique technique, CompositorChain chain ) { this.compositor = technique.Parent; this.technique = technique; this.chain = chain; this.enabled = false; var logicName = technique.CompositorLogicName; if ( !String.IsNullOrEmpty( logicName ) ) { CompositorManager.Instance.CompositorLogics[ logicName ].CompositorInstanceCreated( this ); } this.localTextures = new Dictionary<string, Texture>(); this.renderSystemOperations = new List<QueueIDAndOperation>(); }
/// <see cref="Translator.Translate"/> public override void Translate( ScriptCompiler compiler, AbstractNode node ) { ObjectAbstractNode obj = (ObjectAbstractNode)node; Compositor compositor = (Compositor)obj.Parent.Context; _Technique = compositor.CreateTechnique(); obj.Context = _Technique; foreach ( AbstractNode i in obj.Children ) { if ( i is ObjectAbstractNode ) { _processNode( compiler, i ); } else if ( i is PropertyAbstractNode ) { PropertyAbstractNode prop = (PropertyAbstractNode)i; switch ( (Keywords)prop.Id ) { #region ID_TEXTURE case Keywords.ID_TEXTURE: { int atomIndex = 1; AbstractNode it = getNodeAt( prop.Values, 0 ); if ( it is AtomAbstractNode ) { compiler.AddError( CompileErrorCode.InvalidParameters, prop.File, prop.Line ); return; } // Save the first atom, should be name AtomAbstractNode atom0 = (AtomAbstractNode)it; int width = 0, height = 0; float widthFactor = 1.0f, heightFactor = 1.0f; bool widthSet = false, heightSet = false, formatSet = false; bool pooled = false; bool hwGammaWrite = false; bool fsaa = true; CompositionTechnique.TextureScope scope = CompositionTechnique.TextureScope.Local; List<PixelFormat> formats = new List<PixelFormat>(); while ( atomIndex < prop.Values.Count ) { it = getNodeAt( prop.Values, atomIndex++ ); if ( !(it is AtomAbstractNode) ) { compiler.AddError( CompileErrorCode.InvalidParameters, prop.File, prop.Line ); return; } AtomAbstractNode atom = (AtomAbstractNode)it; switch ( (Keywords)atom.Id ) { case Keywords.ID_TARGET_WIDTH: width = 0; widthSet = true; break; case Keywords.ID_TARGET_HEIGHT: height = 0; heightSet = true; break; case Keywords.ID_TARGET_WIDTH_SCALED: case Keywords.ID_TARGET_HEIGHT_SCALED: { bool pSetFlag = false; int pSize = 0; float pFactor = 0; if ( atom.Id == (uint)Keywords.ID_TARGET_WIDTH_SCALED ) { pSetFlag = widthSet; pSize = width; pFactor = widthFactor; } else { pSetFlag = heightSet; pSize = height; pFactor = heightFactor; } // advance to next to get scaling it = getNodeAt( prop.Values, atomIndex++ ); if ( it == null || !(it is AtomAbstractNode) ) { compiler.AddError( CompileErrorCode.InvalidParameters, prop.File, prop.Line ); return; } atom = (AtomAbstractNode)it; if ( !atom.IsNumber ) { compiler.AddError( CompileErrorCode.InvalidParameters, prop.File, prop.Line ); return; } pSize = 0; pFactor = atom.Number; pSetFlag = true; } break; case Keywords.ID_POOLED: pooled = true; break; case Keywords.ID_SCOPE_LOCAL: scope = CompositionTechnique.TextureScope.Local; break; case Keywords.ID_SCOPE_CHAIN: scope = CompositionTechnique.TextureScope.Chain; break; case Keywords.ID_SCOPE_GLOBAL: scope = CompositionTechnique.TextureScope.Global; break; case Keywords.ID_GAMMA: hwGammaWrite = true; break; case Keywords.ID_NO_FSAA: fsaa = false; break; default: if ( atom.IsNumber ) { if ( atomIndex == 2 ) { width = (int)atom.Number; widthSet = true; } else if ( atomIndex == 3 ) { height = (int)atom.Number; heightSet = true; } else { compiler.AddError( CompileErrorCode.InvalidParameters, prop.File, prop.Line ); return; } } else { // pixel format? PixelFormat format = PixelUtil.GetFormatFromName( atom.Value, true ); if ( format == PixelFormat.Unknown ) { compiler.AddError( CompileErrorCode.InvalidParameters, prop.File, prop.Line ); return; } formats.Add( format ); formatSet = true; } break; } } if ( !widthSet || !heightSet || !formatSet ) { compiler.AddError( CompileErrorCode.StringExpected, prop.File, prop.Line ); return; } // No errors, create CompositionTechnique.TextureDefinition def = _Technique.CreateTextureDefinition( atom0.Value ); def.Width = width; def.Height = height; def.WidthFactor = widthFactor; def.HeightFactor = heightFactor; def.PixelFormats = formats; def.HwGammaWrite = hwGammaWrite; def.Fsaa = fsaa; def.Pooled = pooled; def.Scope = scope; } break; #endregion ID_TEXTURE #region ID_TEXTURE_REF case Keywords.ID_TEXTURE_REF: if ( prop.Values.Count == 0 ) { compiler.AddError( CompileErrorCode.StringExpected, prop.File, prop.Line ); } else if ( prop.Values.Count != 3 ) { compiler.AddError( CompileErrorCode.InvalidParameters, prop.File, prop.Line, "texture_ref only supports 3 argument" ); } else { string texName = string.Empty, refCompName = string.Empty, refTexName = string.Empty; AbstractNode it = getNodeAt( prop.Values, 0 ); if ( !getString( it, out texName ) ) { compiler.AddError( CompileErrorCode.InvalidParameters, prop.File, prop.Line, "texture_ref must have 3 string arguments" ); } it = getNodeAt( prop.Values, 1 ); if ( !getString( it, out refCompName ) ) { compiler.AddError( CompileErrorCode.InvalidParameters, prop.File, prop.Line, "texture_ref must have 3 string arguments" ); } it = getNodeAt( prop.Values, 2 ); if ( !getString( it, out refTexName ) ) { compiler.AddError( CompileErrorCode.InvalidParameters, prop.File, prop.Line, "texture_ref must have 3 string arguments" ); } CompositionTechnique.TextureDefinition refTexDef = _Technique.CreateTextureDefinition( texName ); refTexDef.ReferenceCompositorName = refCompName; refTexDef.ReferenceTextureName = refTexName; } break; #endregion ID_TEXTURE_REF #region ID_SCHEME case Keywords.ID_SCHEME: if ( prop.Values.Count == 0 ) { compiler.AddError( CompileErrorCode.StringExpected, prop.File, prop.Line ); } else if ( prop.Values.Count > 1 ) { compiler.AddError( CompileErrorCode.FewerParametersExpected, prop.File, prop.Line, "scheme only supports 1 argument" ); } else { AbstractNode i0 = getNodeAt( prop.Values, 0 ); string scheme = string.Empty; if ( getString( i0, out scheme ) ) _Technique.SchemeName = scheme; else compiler.AddError( CompileErrorCode.InvalidParameters, prop.File, prop.Line, "scheme must have 1 string argument" ); } break; #endregion ID_SCHEME #region ID_COMPOSITOR_LOGIC case Keywords.ID_COMPOSITOR_LOGIC: if ( prop.Values.Count == 0 ) { compiler.AddError( CompileErrorCode.StringExpected, prop.File, prop.Line ); } else if ( prop.Values.Count > 1 ) { compiler.AddError( CompileErrorCode.FewerParametersExpected, prop.File, prop.Line, "compositor logic only supports 1 argument" ); } else { AbstractNode i0 = getNodeAt( prop.Values, 0 ); string logicName = string.Empty; if ( getString( i0, out logicName ) ) _Technique.CompositorLogicName = logicName; else compiler.AddError( CompileErrorCode.InvalidParameters, prop.File, prop.Line, "compositor logic must have 1 string argument" ); } break; #endregion ID_COMPOSITOR_LOGIC default: compiler.AddError( CompileErrorCode.UnexpectedToken, prop.File, prop.Line, "token \"" + prop.Name + "\" is not recognized" ); break; } } } }
public CompositionTechniqueTranslator() : base() { _Technique = null; }
public CompositionTargetPass( CompositionTechnique parent ) { this.parent = parent; this.inputMode = CompositorInputMode.None; this.passes = new List<CompositionPass>(); this.onlyInitial = false; this.visibilityMask = 0xFFFFFFFF; this.lodBias = 1.0f; this.materialScheme = MaterialManager.DefaultSchemeName; ShadowsEnabled = true; if ( Root.Instance.RenderSystem != null ) { this.materialScheme = Root.Instance.RenderSystem.DefaultViewportMaterialScheme; } }
public CompositorInstance(Compositor filter, CompositionTechnique technique, CompositorChain chain) { this.compositor = filter; this.technique = technique; this.chain = chain; this.enabled = false; localTextures = new Dictionary<string, Texture>(); renderSystemOperations = new List<QueueIDAndOperation>(); listeners = new List<CompositorInstanceListener>(); }
public CompositionTargetPass(CompositionTechnique parent) { this.parent = parent; inputMode = CompositorInputMode.None; passes = new List<CompositionPass>(); onlyInitial = false; visibilityMask = 0xFFFFFFFF; lodBias = 1.0f; materialScheme = MaterialManager.DefaultSchemeName; }
///<summary> /// Create a new technique, and return a pointer to it. ///</summary> public CompositionTechnique CreateTechnique() { CompositionTechnique t = new CompositionTechnique( this ); techniques.Add( t ); compilationRequired = true; return t; }