public RenderImage(
Image image = null,
float?width = null,
float?height = null,
float scale = 1.0f,
Color color = null,
BlendMode colorBlendMode = BlendMode.srcIn,
BoxFit?fit = null,
AlignmentGeometry alignment = null,
ImageRepeat repeat = ImageRepeat.noRepeat,
Rect centerSlice = null,
bool matchTextDirection = false,
TextDirection?textDirection = null,
bool invertColors = false,
FilterQuality filterQuality = FilterQuality.low
)
{
D.assert(alignment != null);
_image = image;
_width = width;
_height = height;
_scale = scale;
_color = color;
_colorBlendMode = colorBlendMode;
_fit = fit;
_repeat = repeat;
_centerSlice = centerSlice;
_alignment = alignment ?? Alignment.center;
_invertColors = invertColors;
_filterQuality = filterQuality;
_textDirection = textDirection;
_matchTextDirection = matchTextDirection;
_updateColorFilter();
}
public static ImageFilter CreateImage(Image image, Rect src, Rect dst, FilterQuality filterQuality)
{
return(new ImageImageFilter()
{
Image = image,
Src = src,
Dst = dst,
FilterQuality = filterQuality
});
}
public static Image asset(
string name,
Key key = null,
AssetBundle bundle = null,
ImageFrameBuilder frameBuilder = null,
ImageErrorWidgetBuilder errorBuilder = null,
float?scale = null,
float?width = null,
float?height = null,
Color color = null,
BlendMode colorBlendMode = BlendMode.srcIn,
BoxFit?fit = null,
Alignment alignment = null,
ImageRepeat repeat = ImageRepeat.noRepeat,
Rect centerSlice = null,
bool matchTextDirection = false,
bool gaplessPlayback = false,
string package = null,
FilterQuality filterQuality = FilterQuality.low,
int?cacheWidth = default,
int?cacheHeight = null
)
{
var _scale = scale ?? 1.0f;
var _image = scale != null
? (AssetBundleImageProvider) new ExactAssetImage(assetName: name, bundle: bundle, scale: _scale)
: new AssetImage(assetName: name, bundle: bundle);
var _Image = ResizeImage.resizeIfNeeded(cacheWidth: cacheWidth, cacheHeight: cacheHeight, provider: _image);
return(new Image(
key: key,
image: _Image,
frameBuilder: frameBuilder,
null,
errorBuilder: errorBuilder,
width: width,
height: height,
color: color,
colorBlendMode: colorBlendMode,
fit: fit,
alignment: alignment,
repeat: repeat,
centerSlice: centerSlice,
matchTextDirection: matchTextDirection,
gaplessPlayback: gaplessPlayback,
filterQuality: filterQuality
));
}
public static Image network(
string src,
Key key = null,
float scale = 1.0f,
ImageFrameBuilder frameBuilder = null,
ImageLoadingBuilder loadingBuilder = null,
ImageErrorWidgetBuilder errorBuilder = null,
float?width = null,
float?height = null,
Color color = null,
BlendMode colorBlendMode = BlendMode.srcIn,
BoxFit?fit = null,
AlignmentGeometry alignment = null,
ImageRepeat repeat = ImageRepeat.noRepeat,
Rect centerSlice = null,
bool gaplessPlayback = false,
bool matchTextDirection = false,
FilterQuality filterQuality = FilterQuality.low,
IDictionary <string, string> headers = null,
int?cacheWidth = null,
int?cacheHeight = null
)
{
var image = ResizeImage.resizeIfNeeded(cacheWidth: cacheWidth, cacheHeight: cacheHeight,
new NetworkImage(url: src, scale: scale, headers: headers));
return(new Image(
key: key,
image: image,
frameBuilder: frameBuilder,
loadingBuilder: loadingBuilder,
errorBuilder: errorBuilder,
width: width,
height: height,
color: color,
colorBlendMode: colorBlendMode,
fit: fit,
alignment: alignment,
repeat: repeat,
centerSlice: centerSlice,
matchTextDirection: matchTextDirection,
gaplessPlayback: gaplessPlayback,
filterQuality: filterQuality
));
}
public static AVMI.BitmapInterpolationMode ToBitmapInterpolationMode(this FilterQuality filterQuality)
{
switch (filterQuality)
{
default:
case FilterQuality.None:
return(AVMI.BitmapInterpolationMode.Default);
case FilterQuality.Low:
return(AVMI.BitmapInterpolationMode.LowQuality);
case FilterQuality.Medium:
return(AVMI.BitmapInterpolationMode.MediumQuality);
case FilterQuality.High:
return(AVMI.BitmapInterpolationMode.HighQuality);
}
}
public static Image memory(
byte[] bytes,
Key key = null,
float scale = 1.0f,
ImageFrameBuilder frameBuilder = null,
ImageErrorWidgetBuilder errorBuilder = null,
float?width = null,
float?height = null,
Color color = null,
BlendMode colorBlendMode = BlendMode.srcIn,
BoxFit?fit = null,
Alignment alignment = null,
ImageRepeat repeat = ImageRepeat.noRepeat,
Rect centerSlice = null,
bool matchTextDirection = false,
bool gaplessPlayback = false,
FilterQuality filterQuality = FilterQuality.low,
int?cacheWidth = default,
int?cacheHeight = null
)
{
// ResizeImage.resizeIfNeeded(cacheWidth, cacheHeight, MemoryImage(bytes, scale: scale));
var memoryImage = new MemoryImage(bytes: bytes, scale: scale);
return(new Image(
key: key,
ResizeImage.resizeIfNeeded(cacheWidth: cacheWidth, cacheHeight: cacheHeight,
new MemoryImage(bytes: bytes, scale: scale)),
frameBuilder: frameBuilder,
null,
errorBuilder: errorBuilder,
width: width,
height: height,
color: color,
colorBlendMode: colorBlendMode,
fit: fit,
alignment: alignment,
repeat: repeat,
centerSlice: centerSlice,
matchTextDirection: matchTextDirection,
gaplessPlayback: gaplessPlayback,
filterQuality: filterQuality
));
}
public Paint()
{
Style = PaintStyle.Fill;
IsAntialias = false;
StrokeWidth = 0;
StrokeCap = StrokeCap.Butt;
StrokeJoin = StrokeJoin.Miter;
StrokeMiter = 4;
Typeface = null;
TextSize = 12;
TextAlign = TextAlign.Left;
LcdRenderText = false;
SubpixelText = false;
TextEncoding = TextEncoding.Utf8;
Color = new Color(0x00, 0x00, 0x00, 0xFF);
Shader = null;
ColorFilter = null;
ImageFilter = null;
PathEffect = null;
BlendMode = BlendMode.SrcOver;
FilterQuality = FilterQuality.None;
}
public Image(
Key key = null,
ImageProvider image = null,
ImageFrameBuilder frameBuilder = null,
ImageLoadingBuilder loadingBuilder = null,
ImageErrorWidgetBuilder errorBuilder = null,
float?width = null,
float?height = null,
Color color = null,
BlendMode colorBlendMode = BlendMode.srcIn,
BoxFit?fit = null,
AlignmentGeometry alignment = null,
ImageRepeat repeat = ImageRepeat.noRepeat,
Rect centerSlice = null,
bool matchTextDirection = false,
bool gaplessPlayback = false,
FilterQuality filterQuality = FilterQuality.low
) : base(key: key)
{
D.assert(image != null);
this.image = image;
this.frameBuilder = frameBuilder;
this.loadingBuilder = loadingBuilder;
this.errorBuilder = errorBuilder;
this.width = width;
this.height = height;
this.color = color;
this.colorBlendMode = colorBlendMode;
this.fit = fit;
this.alignment = alignment ?? Alignment.center;
this.repeat = repeat;
this.centerSlice = centerSlice;
this.gaplessPlayback = gaplessPlayback;
this.filterQuality = filterQuality;
this.matchTextDirection = matchTextDirection;
}
public static void paintImage(
Canvas canvas = null,
Rect rect = null,
Image image = null,
float scale = 1.0f,
ColorFilter colorFilter = null,
BoxFit?fit = null,
Alignment alignment = null,
Rect centerSlice = null,
ImageRepeat repeat = ImageRepeat.noRepeat,
bool flipHorizontally = false,
bool invertColors = false,
FilterQuality filterQuality = FilterQuality.low
)
{
D.assert(canvas != null);
D.assert(rect != null);
D.assert(image != null);
alignment = alignment ?? Alignment.center;
if (rect.isEmpty)
{
return;
}
Size outputSize = rect.size;
Size inputSize = new Size(image.width, image.height);
Offset sliceBorder = null;
if (centerSlice != null)
{
sliceBorder = new Offset(
centerSlice.left + inputSize.width - centerSlice.right,
centerSlice.top + inputSize.height - centerSlice.bottom
);
outputSize -= sliceBorder;
inputSize -= sliceBorder;
}
fit = fit ?? (centerSlice == null ? BoxFit.scaleDown : BoxFit.fill);
D.assert(centerSlice == null || (fit != BoxFit.none && fit != BoxFit.cover),
() => $"centerSlice was used with a BoxFit {fit} that is not supported.");
FittedSizes fittedSizes = FittedSizes.applyBoxFit(fit.Value, inputSize / scale, outputSize);
Size sourceSize = fittedSizes.source * scale;
Size destinationSize = fittedSizes.destination;
if (centerSlice != null)
{
outputSize += sliceBorder;
destinationSize += sliceBorder;
D.assert(sourceSize == inputSize,
() =>
$"centerSlice was used with a BoxFit {fit} that does not guarantee that the image is fully visible.");
}
if (repeat != ImageRepeat.noRepeat && destinationSize == outputSize)
{
repeat = ImageRepeat.noRepeat;
}
Paint paint = new Paint();
if (colorFilter != null)
{
paint.colorFilter = colorFilter;
}
if (sourceSize != destinationSize)
{
paint.filterQuality = filterQuality;
}
paint.invertColors = invertColors;
float halfWidthDelta = (outputSize.width - destinationSize.width) / 2.0f;
float halfHeightDelta = (outputSize.height - destinationSize.height) / 2.0f;
float dx = halfWidthDelta + (flipHorizontally ? -alignment.x : alignment.x) * halfWidthDelta;
float dy = halfHeightDelta + alignment.y * halfHeightDelta;
Offset destinationPosition = rect.topLeft.translate(dx, dy);
Rect destinationRect = destinationPosition & destinationSize;
bool needSave = repeat != ImageRepeat.noRepeat || flipHorizontally;
if (needSave)
{
canvas.save();
}
if (flipHorizontally)
{
float dxInside = -(rect.left + rect.width / 2.0f);
canvas.translate(-dxInside, 0.0f);
canvas.scale(-1.0f, 1.0f);
canvas.translate(dxInside, 0.0f);
}
if (repeat != ImageRepeat.noRepeat)
{
canvas.clipRect(rect);
}
if (centerSlice == null)
{
Rect sourceRect = alignment.inscribe(
sourceSize, Offset.zero & inputSize
);
if (repeat == ImageRepeat.noRepeat)
{
canvas.drawImageRect(image, sourceRect, destinationRect, paint);
}
else
{
foreach (Rect tileRect in _generateImageTileRects(rect, destinationRect, repeat))
{
canvas.drawImageRect(image, sourceRect, tileRect, paint);
}
}
}
else
{
if (repeat == ImageRepeat.noRepeat)
{
canvas.drawImageNine(image, centerSlice, destinationRect, paint);
}
else
{
foreach (Rect tileRect in _generateImageTileRects(rect, destinationRect, repeat))
{
canvas.drawImageNine(image, centerSlice, tileRect, paint);
}
}
}
if (needSave)
{
canvas.restore();
}
}
/// <summary>
/// Imposta i filtri per le textures
/// </summary>
/// <param name="quality"></param>
/// <returns></returns>
public bool SetFilterQuality(FilterQuality quality)
{
switch (quality)
{
case FilterQuality.None:
device.SamplerState[0].MinFilter = TextureFilter.None;
device.SamplerState[0].MagFilter = TextureFilter.None;
return true;
case FilterQuality.Point:
device.SamplerState[0].MinFilter = TextureFilter.Point;
device.SamplerState[0].MagFilter = TextureFilter.Point;
return true;
case FilterQuality.Linear:
device.SamplerState[0].MinFilter = TextureFilter.Linear;
device.SamplerState[0].MagFilter = TextureFilter.Linear;
return true;
case FilterQuality.Anisotropic:
device.SamplerState[0].MinFilter = TextureFilter.Anisotropic;
device.SamplerState[0].MagFilter = TextureFilter.Anisotropic;
return true;
case FilterQuality.PyramidalQuad:
device.SamplerState[0].MinFilter = TextureFilter.PyramidalQuad;
device.SamplerState[0].MagFilter = TextureFilter.PyramidalQuad;
return true;
case FilterQuality.GaussianQuad:
device.SamplerState[0].MinFilter = TextureFilter.GaussianQuad;
device.SamplerState[0].MagFilter = TextureFilter.GaussianQuad;
return true;
default:
return false;
}
}
