public void Render(Renderers.RendererDestinationData destData, int tick) { for (int i = 0; i < ashes.Count; i++) { ashes[i].UpdateLocation(); destData.Blit(ashes[i], new Point(ashes[i].X, ashes[i].Y)); } }
public virtual void Deselect() { IsSelected = false; IsFocused = false; MatPropBlock.SetColor(ColorTint, StartColor); Renderers.ForEach(renderer => { renderer.SetPropertyBlock(MatPropBlock); }); }
public void Render(Renderers.RendererDestinationData destData, int tick) { for (int i = 0; i < raindrops.Count; i++) { raindrops[i].UpdateLocation(2); destData.Blit(raindrops[i], new Point(raindrops[i].X, raindrops[i].Y)); } }
public void Draw(Renderers.Renderer render, Rectangle r, Color col) { if (m_Texture == null) return; render.DrawColor = col; if (r.Width < m_Width && r.Height < m_Height) { render.DrawTexturedRect(m_Texture, r, m_Rects[0].uv[0], m_Rects[0].uv[1], m_Rects[8].uv[2], m_Rects[8].uv[3]); return; } DrawRect(render, 0, r.X, r.Y, m_Margin.Left, m_Margin.Top); DrawRect(render, 1, r.X + m_Margin.Left, r.Y, r.Width - m_Margin.Left - m_Margin.Right, m_Margin.Top); DrawRect(render, 2, (r.X + r.Width) - m_Margin.Right, r.Y, m_Margin.Right, m_Margin.Top); DrawRect(render, 3, r.X, r.Y + m_Margin.Top, m_Margin.Left, r.Height - m_Margin.Top - m_Margin.Bottom); DrawRect(render, 4, r.X + m_Margin.Left, r.Y + m_Margin.Top, r.Width - m_Margin.Left - m_Margin.Right, r.Height - m_Margin.Top - m_Margin.Bottom); DrawRect(render, 5, (r.X + r.Width) - m_Margin.Right, r.Y + m_Margin.Top, m_Margin.Right, r.Height - m_Margin.Top - m_Margin.Bottom); DrawRect(render, 6, r.X, (r.Y + r.Height) - m_Margin.Bottom, m_Margin.Left, m_Margin.Bottom); DrawRect(render, 7, r.X + m_Margin.Left, (r.Y + r.Height) - m_Margin.Bottom, r.Width - m_Margin.Left - m_Margin.Right, m_Margin.Bottom); DrawRect(render, 8, (r.X + r.Width) - m_Margin.Right, (r.Y + r.Height) - m_Margin.Bottom, m_Margin.Right, m_Margin.Bottom); }
public void Adds_to_an_empty_chain() { Renderers.Clear(); Config.Append <NewRenderer>(); Renderers.Single().ShouldBeType <NewRenderer>(); }
public override void Apply( Renderers.Renderer renderer, Primitives.VisualItem item ) { Primitives.DelegateVisitor visitor = new Primitives.DelegateVisitor(); visitor.VisitBoundsMarkerDelegate = delegate( Primitives.BoundsMarker marker ) { Primitives.VisualItem to = CreateItem( marker ); if( to != null ) { to.Style.MergeWith( marker.Style ); } marker.Parent.Replace( marker, to ); }; visitor.VisitPointMarkerDelegate = delegate( Primitives.PointMarker marker ) { Primitives.VisualItem to = CreateItem( marker ); if( to != null ) { to.Style.MergeWith( marker.Style ); } marker.Parent.Replace( marker, to ); }; item.Visit( visitor ); }
private void InstallBindingsToSubContainer(DiContainer subContainer) { subContainer.BindInstance(new InitialState(ShouldRenderInitialValue, InitialValue)).AsCached(); subContainer.BindInterfacesTo <NumberRendererUseCase>().AsCached(); subContainer.BindInterfacesTo <InitializationController>().AsCached(); switch (RendererType) { case RendererType.SpriteRenderer: subContainer.BindInterfacesTo <NumberRenderingPresenter <SpriteRenderer, Sprite> >().AsCached(); subContainer.BindInterfacesTo <NumberRendererForSpriteRenderer>().FromNewComponentOn(gameObject).AsCached(); subContainer.Bind <IList <SpriteRenderer> >().FromInstance(Renderers.Select(x => x.GetComponent <SpriteRenderer>()).ToList()).AsCached(); subContainer.BindInstance(Sprites).AsCached(); break; case RendererType.UIImage: subContainer.BindInterfacesTo <NumberRenderingPresenter <Image, Sprite> >().AsCached(); subContainer.BindInterfacesTo <NumberRendererForUIImage>().FromNewComponentOn(gameObject).AsCached(); subContainer.Bind <IList <Image> >().FromInstance(Renderers.Select(x => x.GetComponent <Image>()).ToList()).AsCached(); subContainer.BindInstance(Sprites).AsCached(); break; case RendererType.UIRawImage: subContainer.BindInterfacesTo <NumberRenderingPresenter <RawImage, Texture> >().AsCached(); subContainer.BindInterfacesTo <NumberRendererForUIRawImage>().FromNewComponentOn(gameObject).AsCached(); subContainer.Bind <IList <RawImage> >().FromInstance(Renderers.Select(x => x.GetComponent <RawImage>()).ToList()).AsCached(); subContainer.BindInstance(Textures).AsCached(); break; default: throw new ArgumentOutOfRangeException(); } subContainer.BindInstance(EmptyDigitType).AsCached(); subContainer.BindInstance(ShouldRenderInitialValue).AsCached(); subContainer.BindInstance(InitialValue).AsCached(); }
/// <summary> /// Initializes a new instance of the <see cref="Texture"/> class. /// </summary> /// <param name="renderer">Renderer to use.</param> public Texture(Renderers.Renderer renderer) { m_Renderer = renderer; Width = 4; Height = 4; Failed = false; }
private void AddDefaultRenderers(Func <RenderContext, bool> renderCallback) { Renderers.Add(new StandardShadowMapRenderer(renderCallback)); Renderers.Add(new CubeMapShadowMapRenderer(renderCallback)); Renderers.Add(new CascadedShadowMapRenderer(renderCallback)); Renderers.Add(new CompositeShadowMapRenderer(Renderers)); }
public void Render(Renderers.RendererDestinationData destData, int tick) { for (int i = 0; i < snowflakes.Count; i++) { snowflakes[i].UpdateLocation(1); destData.Blit(snowflakes[i], new Point(snowflakes[i].X, snowflakes[i].Y)); } }
/// <summary> /// Adds the Forward or Deferred SunBurn Renderers to the SunBurn SceneInterface. /// </summary> /// <param name = "renderer">Forward or Deferred</param> /// <remarks> /// This method needs to be called once ideally in the overrided CreateSceneInterface() method. /// </remarks> protected void CreateRenderer(Renderers renderer) { #if SUNBURN_PRO && !WINDOWS_PHONE switch (renderer) { case Renderers.Forward: { _sceneInterface.AddManager(new RenderManager(_sceneInterface)); _sceneInterface.AddManager(new ShadowMapManager(_sceneInterface)); break; } case Renderers.Deferred: { _sceneInterface.AddManager(new DeferredRenderManager(_sceneInterface)); _sceneInterface.AddManager(new DeferredShadowMapManager(_sceneInterface)); break; } } #else _sceneInterface.AddManager(new RenderManager(_sceneInterface)); #if !WINDOWS_PHONE _sceneInterface.AddManager(new ShadowMapManager(_sceneInterface)); #endif #endif }
public void Clear() { if (Renderers != null) { Renderers.Clear(); Renderers = null; } if (Materials != null) { for (int i = 0; i < Materials.Count; i++) { Object.Destroy(Materials[i]); } Materials.Clear(); Materials = null; } if (renderTextureCreated) { CommandBuffer.ReleaseTemporaryRT(tmpRenderTextureID); renderTextureCreated = false; } else { if (CommandBuffer != null) { attachedCamera.RemoveCommandBuffer(CameraEvent.BeforeImageEffects, CommandBuffer); CommandBuffer.Dispose(); CommandBuffer = null; } } //TODO: resettare anche la RenderTexture? }
private void RendererDiscoverer_ItemAdded(object sender, RendererDiscovererItemAddedEventArgs e) { if (!Renderers.Contains(e.RendererItem)) { Renderers.Add(e.RendererItem); } }
public void Collect(RenderContext context) { var renderFrame = Output.GetRenderFrame(context); context.Tags.Set(RenderFrame.Current, renderFrame); Renderers.Collect(context); }
// // This method is invoked when the application has loaded and is ready to run. In this // method you should instantiate the window, load the UI into it and then make the window // visible. // // You have 17 seconds to return from this method, or iOS will terminate your application. // public override bool FinishedLaunching(UIApplication app, NSDictionary options) { Popup.Init(); global::Xamarin.Forms.Forms.Init(); Renderers.Init(); DeviceOrientationImplementation.Init(); //DependencyService.Register<ToastNotificatorImplementation>(); //ToastNotificatorImplementation.Init(); ImageCircleRenderer.Init(); if (!Resolver.IsSet) { SetIoc(); } LoadApplication(new MasTicket.App()); MessagingCenter.Subscribe <Page, string>(this, "Share", (sender, arg) => { Share(arg); }); MessagingCenter.Subscribe <Page>(this, "LogOutFace", (sender) => { LogOutFace(); }); //ShareImplementation.ExcludedUIActivityTypes = new List<NSString> { UIActivityType.PostToFacebook }; Facebook.CoreKit.AppEvents.ActivateApp(); return(base.FinishedLaunching(app, options)); }
public void DrawCenter(Renderers.Renderer render, Rectangle r) { if (m_Texture == null) return; DrawCenter(render, r, Color.White); }
public void Write(AssetWriter writer) { Renderers.Write(writer); if (IsAlign(writer.Version)) { writer.AlignStream(); } Systems.Write(writer); if (IsAlign(writer.Version)) { writer.AlignStream(); } if (HasProbesets(writer.Version)) { Probesets.Write(writer); writer.AlignStream(); } SystemAtlases.Write(writer); if (IsAlign(writer.Version)) { writer.AlignStream(); } if (HasTerrainChunks(writer.Version)) { TerrainChunks.Write(writer); if (IsAlign(writer.Version)) { writer.AlignStream(); } } }
public void Adds_before_the_last_item_in_the_chain() { Config.Before <LastRenderer>().Add <NewRenderer>(); Renderers.Reverse(); Renderers.Skip(1).First().ShouldBeType <NewRenderer>(); }
protected virtual void Dispose(bool cleanManagedResources) { if (cleanManagedResources) { Renderers.ForEach(renderer => renderer.Dispose()); CompRenderers.ToList().ForEach(renderer => renderer.Value.Dispose()); } }
public virtual void TryHighlight(Color highlightColor) { if (!IsSelected) { MatPropBlock.SetColor(ColorTint, highlightColor); Renderers.ForEach(renderer => { renderer.SetPropertyBlock(MatPropBlock); }); } }
public void Draw(Renderers.Renderer render, Rectangle r, Color col) { if (m_Texture == null) return; render.DrawColor = col; render.DrawTexturedRect(m_Texture, r, m_uv[0], m_uv[1], m_uv[2], m_uv[3]); }
protected override void Apply( Renderers.Renderer renderer, Primitives.Path path ) { Factories.SoftShadow softShadow = new Factories.SoftShadow( renderer, _offset, _extent, _color ); Primitives.VisualItem shadow = softShadow.Create( path ); path.Parent.AddFront( shadow ); }
private void RenderTemplates_SelectionChanged(object sender, SelectionChangedEventArgs e) { var template = RenderTemplates.SelectedValue as string; Renderers.Clear(); Renderers.AddRange(TemplateHelper.GetRenderers(template)); SelectedRenderer = GetSelectedRenderer(template); }
public virtual void Select(Color selectionColor) { Timing.KillCoroutines(CoroutineName); jiggleAnim.Animate(CoroutineName); SFXManager.Instance.Play(SFXType.PLEPlaceObject, transform.position); IsSelected = true; MatPropBlock.SetColor(ColorTint, selectionColor); Renderers.ForEach(renderer => { renderer.SetPropertyBlock(MatPropBlock); }); }
protected override void DisposeImpl() { foreach (var o in Renderers.ToList()) { RemoveRenderer(o); } _nativeStream.Dispose(); }
protected override void OnCreate(Bundle bundle) { base.OnCreate(bundle); Xamarin.Forms.Forms.Init(this, bundle); Renderers.Init(); SetPage(App.GetMainPage()); }
// Constructor #region Constructors public MainPage() { InitializeComponent(); Forms.Init(); Renderers.Init(); Content = PagedCarouselPage.Sample.App.GetMainPage().ConvertPageToUIElement(this); }
/// <summary> /// Initializes a new instance of the <see cref="Font"/> class. /// </summary> /// <param name="renderer">Renderer to use.</param> /// <param name="faceName">Face name.</param> /// <param name="size">Font size.</param> public Font(Renderers.Renderer renderer, String faceName, int size = 10) { m_Renderer = renderer; FaceName = faceName; Size = size; Smooth = false; //Bold = false; //DropShadow = false; }
public YAMLNode ExportYAML(IExportContainer container) { YAMLMappingNode node = new YAMLMappingNode(); node.Add(ScreenRelativeHeightName, ScreenRelativeHeight); node.Add(FadeTransitionWidthName, FadeTransitionWidth); node.Add(RenderersName, Renderers.ExportYAML(container)); return(node); }
public static void Unload(Terraria3D instance) { UITerraria3D.Unload(); instance.Scene = null; instance.LayerManager?.Dispose(); instance.LayerManager = null; Renderers.Unload(); InputTerraria3D.Unload(); }
private Renderers CreateRenderers() { Renderers renderers = new Renderers(); renderers.GameplayR = GameplayRendererObject; renderers.CharacterSelectR = CharacterSelectRenderer; renderers.MainMenuR = MainMenuRenderer; return(renderers); }
public void DrawCenter(Renderers.Renderer render, Rectangle r, Color col) { r.X += (int)((r.Width - m_Width) * 0.5); r.Y += (int)((r.Height - m_Height) * 0.5); r.Width = m_Width; r.Height = m_Height; Draw(render, r, col); }
/// <summary> /// Sets the clip plane for the teleportable object's material /// </summary> /// <param name="sourcePosition">The position of the plane</param> /// <param name="sourceNormal">The normal of the plane</param> /// <param name="destPosition">The position of the plane</param> /// <param name="destNormal">The normal of the plane</param> /// <param name="DopplegangerOnly">Is the clip transform only being applied to the doppleganger?</param> public void SetClipPlane(Vector3 sourcePosition, Vector3 sourceNormal, Vector3 destPosition, Vector3 destNormal, bool DopplegangerOnly = false) { if (!initialized) { return; } using (var r = Renderers.GetEnumerator()) { while (r.MoveNext()) { var key = r.Current.Key; if (key && !DopplegangerOnly) { var rms = SharedMaterialsCache.GetSharedMaterials(key); for (var i = 0; i < rms.Length; i++) { var rm = rms[i]; if (!rm) { continue; } rm.SetVector(Keywords.ShaderKeys.ClipPos, sourcePosition); rm.SetVector(Keywords.ShaderKeys.ClipVec, sourceNormal); if (!rm.HasProperty(Keywords.ShaderKeys.ClipPos) && SKSGlobalRenderSettings.Clipping) { Debug.LogWarning( "Valid pixel-perfect material not set on teleportable. Object will be able to" + " be seen through the back of portals unless this is replaced."); } } } var dr = r.Current.Value; if (dr) { var rms = SharedMaterialsCache.GetSharedMaterials(dr); for (var i = 0; i < rms.Length; i++) { var rm = rms[i]; if (!rm) { continue; } rm.SetVector(Keywords.ShaderKeys.ClipPos, destPosition); rm.SetVector(Keywords.ShaderKeys.ClipVec, destNormal); if (!rm.HasProperty(Keywords.ShaderKeys.ClipPos) && SKSGlobalRenderSettings.Clipping) { Debug.LogWarning( "Valid pixel-perfect material not set on teleportable. Object will be able to" + "be seen through the back of portals unless this is replaced."); } } } } } }
protected virtual void RenderGame(float interpolation) { RenderOnEndActions.Clear(); Renderers.ForEach(r => r.Render()); CompRenderers.ToList() .ForEach(r => r.Value.Render(Game.Entities.GetWithComponent(r.Key), interpolation) ); RenderOnEndActions.ForEach(renderOnEnd => renderOnEnd()); }
// // This method is invoked when the application has loaded and is ready to run. In this // method you should instantiate the window, load the UI into it and then make the window // visible. // // You have 17 seconds to return from this method, or iOS will terminate your application. // public override bool FinishedLaunching(UIApplication app, NSDictionary options) { global::Xamarin.Forms.Forms.Init(); Renderers.Init(); this.LoadApplication(new App()); return(base.FinishedLaunching(app, options)); }
protected virtual Option <IMenuModel> CreateItem(object item, Option <IMenuModel> parent) { Ensure.That(item, nameof(item)).IsNotNull(); var label = Optional(item) .Bind(c => Renderers.Find(r => r.CanRender(c)).Map(r => r.Render(c))) .HeadOrNone(); return(label.Map <IMenuModel>(v => new MenuModel(v.Key, v.DisplayName, item, parent))); }
protected override void Apply( Renderers.Renderer renderer, Primitives.Path path ) { double index = int.Parse( path.Style.GetExtra( "RowIndex" ) ); double count = int.Parse( path.Style.GetExtra( "RowCount" ) ); Paint.Color color = Paint.Color.Combine( _baseColor, Paint.Color.White, 1 - index / (count * 1.5) ); path.Pen = new Paint.Pens.SolidPen( Paint.Color.White, 2 ); path.Brush = new Paint.Brushes.SolidBrush( color ); }
// -------------------------------------------------------------------- public void UpdateRenderers(Entity e) { Renderers.Clear(); if (e != null) { e.Root.GetComponentsInChildren <MeshRenderer>(Renderers); } UpdateBounds(); }
public bool RunRenderers() { if (!BuilderStateMachine.IsEvaluated) { DataContext.ASTHandlerExceptions.Add(new QLError("previous step not completed successfuly")); return(false); } BuilderStateMachine.IsRendered = RunHandlerLevel(Renderers.ToArray()); return(BuilderStateMachine.IsRendered); }
public YAMLNode ExportYAML(IExportContainer container) { YAMLMappingNode node = new YAMLMappingNode(); node.Add("m_Renderers", Renderers.ExportYAML(container)); node.Add("m_Systems", Systems.ExportYAML(container)); node.Add("m_Probesets", Probesets.ExportYAML(container)); node.Add("m_SystemAtlases", SystemAtlases.ExportYAML(container)); node.Add("m_TerrainChunks", TerrainChunks.ExportYAML(container)); return(node); }
void EnableAllMeshes(bool isEnabled) { Renderers.ForEach(renderer => { renderer.enabled = isEnabled; SkinnedMeshRenderer meshRenderer = renderer as SkinnedMeshRenderer; if (meshRenderer != null) { meshRenderer.updateWhenOffscreen = isEnabled; } }); }
public static void Load(Terraria3D instance) { var mode = Reflection.CurrentGraphicsProfile; Renderers.Load(); instance.Scene = new Scene3D(); instance.LayerManager = new LayerManager(); UITerraria3D.Load(); Hooks.Initialize(); InputTerraria3D.Load(); }
public override void Apply( Renderers.Renderer renderer, Primitives.VisualItem item ) { Primitives.DelegateVisitor visitor = new Primitives.DelegateVisitor(); visitor.VisitTextDelegate = delegate( Primitives.Text text ) { Apply( renderer, text ); }; item.Visit( visitor ); }
public override void Apply( Renderers.Renderer renderer, Primitives.VisualItem item ) { Primitives.DelegateVisitor visitor = new Primitives.DelegateVisitor(); visitor.VisitPathDelegate = delegate( Primitives.Path path ) { Apply( renderer, path ); }; item.Visit( visitor ); }
public Types.Rectangle GetBounds( Renderers.Renderer renderer ) { if( _bounds == null ) { _bounds = CalculateBounds( renderer ); if( _bounds == null ) { throw new InvalidOperationException(); } } return _bounds; }
public void Apply( Renderers.Renderer renderer, Primitives.Container container ) { foreach( KeyValuePair<string, Modifier> kvp in _modifiers ) { Lookup lookup = new Lookup( container ); string style = kvp.Key; Modifier modifier = kvp.Value; Primitives.VisualItem[] items = lookup.GetVisualItems( style ); foreach( Primitives.VisualItem item in items ) { modifier.Apply( renderer, item ); } } }
protected override void Apply( Renderers.Renderer renderer, Primitives.Text text ) { if( _fontFamily != null ) { text.FontFamily = _fontFamily; } if( _fontSizeInPoints != null ) { text.FontSizePoints = _fontSizeInPoints.Value; } if( _fontStyleFlags != null ) { text.FontStyle = _fontStyleFlags.Value; } }
public SoftShadow( Renderers.Renderer renderer, Types.Point offset, double extent, Paint.Color color ) { if( renderer == null ) { throw new ArgumentNullException( "renderer" ); } if( offset == null ) { throw new ArgumentNullException( "offset" ); } if( extent <= 0 ) { throw new ArgumentException( "Extent must be greater than zero.", "extent" ); } if( color == null ) { throw new ArgumentNullException( "color" ); } _renderer = renderer; _offset = offset; _extent = extent; _color = color; }
public Simple(Renderers.Renderer renderer) : base(renderer) { m_colBorderColor = Color.FromArgb(255, 80, 80, 80); //m_colBG = Color.FromArgb(255, 248, 248, 248); m_colBGDark = Color.FromArgb(255, 235, 235, 235); m_colControl = Color.FromArgb(255, 240, 240, 240); m_colControlBright = Color.FromArgb(255, 255, 255, 255); m_colControlDark = Color.FromArgb(255, 214, 214, 214); m_colControlDarker = Color.FromArgb(255, 180, 180, 180); m_colControlOutlineNormal = Color.FromArgb(255, 112, 112, 112); m_colControlOutlineLight = Color.FromArgb(255, 144, 144, 144); m_colControlOutlineLighter = Color.FromArgb(255, 210, 210, 210); m_colHighlightBG = Color.FromArgb(255, 192, 221, 252); m_colHighlightBorder = Color.FromArgb(255, 51, 153, 255); m_colToolTipBackground = Color.FromArgb(255, 255, 255, 225); m_colToolTipBorder = Color.FromArgb(255, 0, 0, 0); m_colModal = Color.FromArgb(150, 25, 25, 25); }
public Simple(Renderers.Renderer renderer, Font defaultFont) : base(renderer,defaultFont) { m_colBorderColor = new Color(80, 80, 80, 255); //m_colBG = new Color( 248, 248, 248); m_colBGDark = new Color(235, 235, 235, 255); m_colControl = new Color(240, 240, 240, 255); m_colControlBright = new Color(255, 255, 255, 255); m_colControlDark = new Color(214, 214, 214, 255); m_colControlDarker = new Color(180, 180, 180, 255); m_colControlOutlineNormal = new Color(112, 112, 112, 255); m_colControlOutlineLight = new Color(144, 144, 144, 255); m_colControlOutlineLighter = new Color(210, 210, 210, 255); m_colHighlightBG = new Color(192, 221, 252, 255); m_colHighlightBorder = new Color(51, 153, 255, 255); m_colToolTipBackground = new Color(255, 255, 225, 255); m_colToolTipBorder = new Color(0, 0, 0, 255); m_colModal = new Color(25, 25, 25, 150); }
/// <summary> /// Initializes a new instance of the <see cref="Font"/> class. /// </summary> public Font(Renderers.Renderer renderer) : this(renderer, "Arial", 10) { }
public void Render(Renderers.RendererDestinationData destData, int tick) { // We don't need to render anything as this overlay isn't animated and always remains the same destData.Blit(buffer, new Point(0, 0)); if (tick > tickCount.Tick + minDisplayTime) { //if (Renderers.Screen.ScreenRenderer.RenderOptions.Map.Loaded && Renderers.Screen.ScreenRenderer.RenderOptions.Map == Maps.MapHelper.Maps[Enums.MapID.TempActive]) { if (Renderers.Screen.ScreenRenderer.RenderOptions.Map.Name == this.mapName) { Renderers.Screen.ScreenRenderer.RenderOptions.ScreenOverlay = null; } //} MinTimePassed = true; } }
public abstract void Apply( Renderers.Renderer renderer, Primitives.VisualItem item );
public void DrawCenter(Renderers.Renderer render, Rectangle r) { DrawCenter(render, r, Color.White); }
protected override Types.Rectangle CalculateBounds( Renderers.Renderer renderer ) { return _rectangle; }
public void Draw(Renderers.Renderer render, Rectangle r, Color col) { render.DrawColor = col; render.DrawTexturedRect(_imageHandle, r, m_uv[0], m_uv[1], m_uv[2], m_uv[3]); }
public void Render(Renderers.RendererDestinationData destData, int tick) { // We don't need to render anything as this overlay isn't animated and always remains the same destData.Blit(buffer, new Point(0, 0)); }
public void Render(Renderers.RendererDestinationData destData, int tick) { // We don't need to render anything as this overlay isn't animated and always remains the same int add = (((tick / 4) % 8) - 4)*6; if (add < 0) { add *= -1; } for (int i = 0; i < buffer.Length; i++) { buffer[i].Alpha = (byte)(32 + add); destData.Blit(buffer[i], new Point(0, 0)); } }
/// <summary> /// Initializes a new instance of the <see cref="Skin"/> class. /// </summary> /// <param name="renderer">Renderer to use.</param> protected Skin(Renderers.Renderer renderer, Font defaultFont) { m_DefaultFont = defaultFont; m_Renderer = renderer; }
protected abstract void Apply( Renderers.Renderer renderer, Primitives.Text text );