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 );
