/// <summary>
/// Blends two pipelines using an <see cref="CrossFadeEffect"/> instance
/// </summary>
/// <param name="pipeline">The second <see cref="PipelineBuilder"/> instance to blend</param>
/// <param name="factor">The cross fade factor to blend the input effects</param>
/// <param name="animation">The optional blur animation for the effect</param>
/// <param name="sorting">The sorting mode to use with the two input pipelines</param>
/// <remarks>Note that each pipeline can only contain a single instance of any of the built-in effects with animation support</remarks>
public PipelineBuilder Mix(PipelineBuilder pipeline, float factor, out EffectAnimation animation, Placement sorting = Placement.Foreground)
{
if (factor < 0 || factor > 1)
{
throw new ArgumentOutOfRangeException(nameof(factor), "The factor must be in the [0,1] range");
}
var(foreground, background) = sorting == Placement.Foreground ? (this, pipeline) : (pipeline, this);
async Task <IGraphicsEffectSource> Factory() => new CrossFadeEffect
{
CrossFade = factor,
Source1 = await foreground.SourceProducer(),
Source2 = await background.SourceProducer(),
Name = "Fade"
};
animation = (brush, value, ms) =>
{
if (value < 0 || value > 1)
{
throw new ArgumentOutOfRangeException(nameof(value), "The factor must be in the [0,1] range");
}
return(brush.StartAnimationAsync("Fade.CrossFade", value, TimeSpan.FromMilliseconds(ms)));
};
return(new PipelineBuilder(Factory, foreground, background, new[] { "Fade.CrossFade" }));
}
/// <summary>
/// Returns a new <see cref="PipelineBuilder"/> instance that implements the in-app backdrop acrylic effect
/// </summary>
/// <param name="tint">The tint color to use</param>
/// <param name="mix">The amount of tint to apply over the current effect</param>
/// <param name="tintAnimation">The animation to apply on the tint color of the effect</param>
/// <param name="blur">The amount of blur to apply to the acrylic brush</param>
/// <param name="blurAnimation">The animation to apply on the blur effect in the pipeline</param>
/// <param name="noiseRelativePath">The relative path for the noise texture to load (eg. "/Assets/noise.png")</param>
/// <param name="cache">The cache mode to use to load the image</param>
public static PipelineBuilder FromBackdropAcrylic(
Color tint, float mix, out EffectAnimation tintAnimation,
float blur, out EffectAnimation blurAnimation,
string noiseRelativePath, CacheMode cache = CacheMode.Default)
{
return(FromBackdropAcrylic(tint, mix, out tintAnimation, blur, out blurAnimation, noiseRelativePath.ToAppxUri(), cache));
}
public PipelineBuilder Shade(
Color color,
out EffectAnimation <Color> colorAnimation,
float mix,
out EffectAnimation <float> mixAnimation)
{
return(FromColor(color, out colorAnimation).CrossFade(this, mix, out mixAnimation));
}
/// <summary>
/// Returns a new <see cref="PipelineBuilder"/> instance that implements the in-app backdrop acrylic effect
/// </summary>
/// <param name="tint">The tint color to use</param>
/// <param name="mix">The amount of tint to apply over the current effect</param>
/// <param name="tintAnimation">The animation to apply on the tint color of the effect</param>
/// <param name="blur">The amount of blur to apply to the acrylic brush</param>
/// <param name="blurAnimation">The animation to apply on the blur effect in the pipeline</param>
/// <param name="noiseUri">The <see cref="Uri"/> for the noise texture to load for the acrylic effect</param>
/// <param name="cache">The cache mode to use to load the image</param>
public static PipelineBuilder FromBackdropAcrylic(
Color tint, float mix, out EffectAnimation tintAnimation,
float blur, out EffectAnimation blurAnimation,
Uri noiseUri, CacheMode cache = CacheMode.Default)
{
return(FromBackdropBrush()
.Tint(tint, mix, out tintAnimation)
.Blur(blur, out blurAnimation)
.Blend(FromTiles(noiseUri, cache: cache), BlendEffectMode.Overlay, Placement.Background));
}
/// <summary>
/// Returns a new <see cref="PipelineBuilder"/> instance that implements the host backdrop acrylic effect
/// </summary>
/// <param name="tint">The tint color to use</param>
/// <param name="tintAnimation">The animation to apply on the tint color of the effect</param>
/// <param name="mix">The amount of tint to apply over the current effect</param>
/// <param name="noiseUri">The <see cref="Uri"/> for the noise texture to load for the acrylic effect</param>
/// <param name="cache">The cache mode to use to load the image</param>
public static PipelineBuilder FromHostBackdropAcrylic(Color tint, float mix, out EffectAnimation tintAnimation, Uri noiseUri, CacheMode cache = CacheMode.Default)
{
return(FromHostBackdropBrush()
.Effect(source => new LuminanceToAlphaEffect {
Source = source
})
.Opacity(0.4f)
.Blend(FromHostBackdropBrush(), BlendEffectMode.Multiply)
.Tint(tint, mix, out tintAnimation)
.Blend(FromTiles(noiseUri, cache: cache), BlendEffectMode.Overlay, Placement.Background));
}
public static PipelineBuilder FromHdrColor(Vector4 color, out EffectAnimation <Vector4> animation)
{
string id = Guid.NewGuid().ToUppercaseAsciiLetters();
ValueTask <IGraphicsEffectSource> Factory() => new ValueTask <IGraphicsEffectSource>(new ColorSourceEffect
{
ColorHdr = color,
Name = id
});
animation = (brush, value, duration) => brush.StartAnimationAsync($"{id}.{nameof(ColorSourceEffect.ColorHdr)}", value, duration);
return(new PipelineBuilder(Factory, new[] { $"{id}.{nameof(ColorSourceEffect.ColorHdr)}" }));
}
public PipelineBuilder Exposure(float amount, out EffectAnimation <float> animation)
{
string id = Guid.NewGuid().ToUppercaseAsciiLetters();
async ValueTask <IGraphicsEffectSource> Factory() => new CanvasExposureEffect
{
Exposure = amount,
Source = await this.sourceProducer(),
Name = id
};
animation = (brush, value, duration) => brush.StartAnimationAsync($"{id}.{nameof(CanvasExposureEffect.Exposure)}", value, duration);
return(new PipelineBuilder(this, Factory, new[] { $"{id}.{nameof(CanvasExposureEffect.Exposure)}" }));
}
public PipelineBuilder HueRotation(float angle, out EffectAnimation <float> animation)
{
string id = Guid.NewGuid().ToUppercaseAsciiLetters();
async ValueTask <IGraphicsEffectSource> Factory() => new HueRotationEffect
{
Angle = angle,
Source = await this.sourceProducer(),
Name = id
};
animation = (brush, value, duration) => brush.StartAnimationAsync($"{id}.{nameof(HueRotationEffect.Angle)}", value, duration);
return(new PipelineBuilder(this, Factory, new[] { $"{id}.{nameof(HueRotationEffect.Angle)}" }));
}
public PipelineBuilder Tint(Color color, out EffectAnimation <Color> animation)
{
string id = Guid.NewGuid().ToUppercaseAsciiLetters();
async ValueTask <IGraphicsEffectSource> Factory() => new TintEffect
{
Color = color,
Source = await this.sourceProducer(),
Name = id
};
animation = (brush, value, duration) => brush.StartAnimationAsync($"{id}.{nameof(TintEffect.Color)}", value, duration);
return(new PipelineBuilder(this, Factory, new[] { $"{id}.{nameof(TintEffect.Color)}" }));
}
public PipelineBuilder Sepia(float intensity, out EffectAnimation <float> animation)
{
string id = Guid.NewGuid().ToUppercaseAsciiLetters();
async ValueTask <IGraphicsEffectSource> Factory() => new SepiaEffect
{
Intensity = intensity,
Source = await this.sourceProducer(),
Name = id
};
animation = (brush, value, duration) => brush.StartAnimationAsync($"{id}.{nameof(SepiaEffect.Intensity)}", value, duration);
return(new PipelineBuilder(this, Factory, new[] { $"{id}.{nameof(SepiaEffect.Intensity)}" }));
}
public PipelineBuilder CrossFade(PipelineBuilder pipeline, float factor, out EffectAnimation <float> animation)
{
string id = Guid.NewGuid().ToUppercaseAsciiLetters();
async ValueTask <IGraphicsEffectSource> Factory() => new CanvasCrossFadeEffect
{
CrossFade = factor,
Source1 = await this.sourceProducer(),
Source2 = await pipeline.sourceProducer(),
Name = id
};
animation = (brush, value, duration) => brush.StartAnimationAsync($"{id}.{nameof(CanvasCrossFadeEffect.CrossFade)}", value, duration);
return(new PipelineBuilder(Factory, this, pipeline, new[] { $"{id}.{nameof(CanvasCrossFadeEffect.CrossFade)}" }));
}
/// <summary>
/// Adds a new <see cref="GaussianBlurEffect"/> to the current pipeline
/// </summary>
/// <param name="blur">The initial blur amount</param>
/// <param name="animation">The optional blur animation for the effect</param>
/// <param name="mode">The <see cref="EffectBorderMode"/> parameter for the effect, defaults to <see cref="EffectBorderMode.Hard"/></param>
/// <param name="optimization">The <see cref="EffectOptimization"/> parameter to use, defaults to <see cref="EffectOptimization.Balanced"/></param>
/// <remarks>Note that each pipeline can only contain a single instance of any of the built-in effects with animation support</remarks>
public PipelineBuilder Blur(float blur, out EffectAnimation animation, EffectBorderMode mode = EffectBorderMode.Hard, EffectOptimization optimization = EffectOptimization.Balanced)
{
// Blur effect
async Task <IGraphicsEffectSource> Factory() => new GaussianBlurEffect
{
BlurAmount = blur,
BorderMode = mode,
Optimization = optimization,
Source = await SourceProducer(),
Name = "Blur"
};
animation = (brush, value, ms) => brush.StartAnimationAsync("Blur.BlurAmount", value, TimeSpan.FromMilliseconds(ms));
return(new PipelineBuilder(this, Factory, new[] { "Blur.BlurAmount" }));
}
public PipelineBuilder Blur(float blur, out EffectAnimation <float> animation, EffectBorderMode mode = EffectBorderMode.Hard, EffectOptimization optimization = EffectOptimization.Balanced)
{
string id = Guid.NewGuid().ToUppercaseAsciiLetters();
async ValueTask <IGraphicsEffectSource> Factory() => new GaussianBlurEffect
{
BlurAmount = blur,
BorderMode = mode,
Optimization = optimization,
Source = await this.sourceProducer(),
Name = id
};
animation = (brush, value, duration) => brush.StartAnimationAsync($"{id}.{nameof(GaussianBlurEffect.BlurAmount)}", value, duration);
return(new PipelineBuilder(this, Factory, new[] { $"{id}.{nameof(GaussianBlurEffect.BlurAmount)}" }));
}
public PipelineBuilder CrossFade(PipelineBuilder pipeline, float factor, out EffectAnimation <float> animation, Placement placement = Placement.Foreground)
{
var pipelines = GetMergePipeline(this, pipeline, placement);
string id = Guid.NewGuid().ToUppercaseAsciiLetters();
async ValueTask <IGraphicsEffectSource> Factory() => new CrossFadeEffect
{
CrossFade = factor,
Source1 = await pipelines.Foreground.sourceProducer(),
Source2 = await pipelines.Background.sourceProducer(),
Name = id
};
animation = (brush, value, duration) => brush.StartAnimationAsync($"{id}.{nameof(CrossFadeEffect.CrossFade)}", value, duration);
return(new PipelineBuilder(Factory, pipelines.Foreground, pipelines.Background, new[] { $"{id}.{nameof(CrossFadeEffect.CrossFade)}" }));
}
public static PipelineBuilder FromBackdropAcrylic(
Color tintColor,
out EffectAnimation <Color> tintAnimation,
float tintOpacity,
out EffectAnimation <float> tintOpacityAnimation,
float blurAmount,
out EffectAnimation <float> blurAmountAnimation,
Uri noiseUri,
CacheMode cacheMode = CacheMode.Default)
{
var pipeline =
FromBackdrop()
.Shade(tintColor, out tintAnimation, tintOpacity, out tintOpacityAnimation)
.Blur(blurAmount, out blurAmountAnimation);
if (noiseUri != null)
{
return(pipeline.Blend(FromTiles(noiseUri, cacheMode: cacheMode), BlendEffectMode.Overlay));
}
return(pipeline);
}
public static PipelineBuilder FromHostBackdropAcrylic(
Color tintColor,
out EffectAnimation <Color> tintColorAnimation,
float tintOpacity,
out EffectAnimation <float> tintOpacityAnimation,
Uri noiseUri,
CacheMode cacheMode = CacheMode.Default)
{
var pipeline =
FromHostBackdrop()
.LuminanceToAlpha()
.Opacity(0.4f)
.Blend(FromHostBackdrop(), BlendEffectMode.Multiply)
.Shade(tintColor, out tintColorAnimation, tintOpacity, out tintOpacityAnimation);
if (noiseUri != null)
{
return(pipeline.Blend(FromTiles(noiseUri, cacheMode: cacheMode), BlendEffectMode.Overlay));
}
return(pipeline);
}
public static PipelineBuilder FromBackdropAcrylic(
Color tint,
out EffectAnimation <Color> tintAnimation,
float mix,
out EffectAnimation <float> mixAnimation,
float blur,
out EffectAnimation <float> blurAnimation,
Uri noiseUri,
CacheMode cacheMode = CacheMode.Default)
{
var pipeline =
FromBackdrop()
.Shade(tint, out tintAnimation, mix, out mixAnimation)
.Blur(blur, out blurAnimation);
if (noiseUri != null)
{
return(pipeline.Blend(FromTiles(noiseUri, cacheMode: cacheMode), BlendEffectMode.Overlay, Placement.Background));
}
return(pipeline);
}
public PipelineBuilder TemperatureAndTint(
float temperature,
out EffectAnimation <float> temperatureAnimation,
float tint,
out EffectAnimation <float> tintAnimation)
{
string id = Guid.NewGuid().ToUppercaseAsciiLetters();
async ValueTask <IGraphicsEffectSource> Factory() => new TemperatureAndTintEffect
{
Temperature = temperature,
Tint = tint,
Source = await this.sourceProducer(),
Name = id
};
temperatureAnimation = (brush, value, duration) => brush.StartAnimationAsync($"{id}.{nameof(TemperatureAndTintEffect.Temperature)}", value, duration);
tintAnimation = (brush, value, duration) => brush.StartAnimationAsync($"{id}.{nameof(TemperatureAndTintEffect.Tint)}", value, duration);
return(new PipelineBuilder(this, Factory, new[] { $"{id}.{nameof(TemperatureAndTintEffect.Temperature)}", $"{id}.{nameof(TemperatureAndTintEffect.Tint)}" }));
}
/// <summary>
/// Adds a new <see cref="SaturationEffect"/> to the current pipeline
/// </summary>
/// <param name="saturation">The initial saturation amount for the new effect</param>
/// <param name="animation">The optional saturation animation for the effect</param>
/// <remarks>Note that each pipeline can only contain a single instance of any of the built-in effects with animation support</remarks>
public PipelineBuilder Saturation(float saturation, out EffectAnimation animation)
{
if (saturation < 0 || saturation > 1)
{
throw new ArgumentOutOfRangeException(nameof(saturation), "The saturation must be in the [0,1] range");
}
async Task <IGraphicsEffectSource> Factory() => new SaturationEffect
{
Saturation = saturation,
Source = await SourceProducer(),
Name = "Saturation"
};
animation = (brush, value, ms) =>
{
if (value < 0 || value > 1)
{
throw new ArgumentOutOfRangeException(nameof(value), "The saturation must be in the [0,1] range");
}
return(brush.StartAnimationAsync("Saturation.Saturation", value, TimeSpan.FromMilliseconds(ms)));
};
return(new PipelineBuilder(this, Factory, new[] { "Saturation.Saturation" }));
}
/// <summary>
/// Adds a new <see cref="OpacityEffect"/> to the current pipeline
/// </summary>
/// <param name="opacity">The opacity value to apply to the pipeline</param>
/// <param name="animation">The optional opacity animation for the effect</param>
/// <remarks>Note that each pipeline can only contain a single instance of any of the built-in effects with animation support</remarks>
public PipelineBuilder Opacity(float opacity, out EffectAnimation animation)
{
if (opacity < 0 || opacity > 1)
{
throw new ArgumentOutOfRangeException(nameof(opacity), "The opacity must be in the [0,1] range");
}
async Task <IGraphicsEffectSource> Factory() => new OpacityEffect
{
Opacity = opacity,
Source = await SourceProducer(),
Name = "Opacity"
};
animation = (brush, value, ms) =>
{
if (value < 0 || value > 1)
{
throw new ArgumentOutOfRangeException(nameof(value), "The opacity must be in the [0,1] range");
}
return(brush.StartAnimationAsync("Opacity.Opacity", value, TimeSpan.FromMilliseconds(ms)));
};
return(new PipelineBuilder(this, Factory, new[] { "Opacity.Opacity" }));
}
/// <summary>
/// Applies a tint color on the current pipeline
/// </summary>
/// <param name="color">The tint color to use</param>
/// <param name="mix">The initial amount of tint to apply over the current effect</param>
/// <param name="animation">The optional tint animation for the effect</param>
/// <remarks>Note that each pipeline can only contain a single instance of any of the built-in effects with animation support</remarks>
public PipelineBuilder Tint(Color color, float mix, out EffectAnimation animation) => FromColor(color).Mix(this, mix, out animation);
public override void relive()
{
blinkInScreen();
setDepth();
hpBar.resetView();
isDead = false;
data.isDead = false;
initData(data);
playAnim("Move");
this.gameObject.collider.enabled = true;
attackCount = Random.Range(40,60);
if(moveEftPrb){
gameObject.SetActiveRecursively(false);
GameObject moveEftObj = Instantiate(moveEftPrb, transform.position+new Vector3(0,56,-1), transform.rotation) as GameObject;
moveEftDoc = moveEftObj.GetComponent<EffectAnimation>();
// moveEftDoc.addFrameScript("enemyRemoteEft", 26, delayRelive);
delayRelive();
// Invoke("delayRelive", 0.5f);
}else{
//CancelInvoke("destroyThis");
toggleEnable();
}
}
