public virtual void BeforeRender()
{
if (!this.lerpCacheIsValid)
{
byte startAlpha;
byte endAlpha;
if (this.AlphaOnly)
{
ComputeAlphaOnlyValuesFromColors(this.startColor, this.endColor, out startAlpha, out endAlpha);
}
else
{
startAlpha = this.startColor.A;
endAlpha = this.endColor.A;
}
this.lerpAlphas = new byte[256];
this.lerpColors = new ColorBgra[256];
for (int i = 0; i < 256; ++i)
{
byte a = (byte)i;
this.lerpColors[a] = ColorBgra.Blend(this.startColor, this.endColor, a);
this.lerpAlphas[a] = (byte)(startAlpha + ((endAlpha - startAlpha) * a) / 255);
}
this.lerpCacheIsValid = true;
}
}
private unsafe Color GetColorFromPoint(PointD point)
{
var pixels = GetPixelsFromPoint(point);
fixed(ColorBgra *ptr = pixels)
return(ColorBgra.Blend(ptr, pixels.Length).ToCairoColor());
}
protected override unsafe void OnRender(Rectangle[] rois, int startIndex, int length)
{
double radiusDelta = this.maxRadius - this.minRadius;
double effectiveRadiusDelta = radiusDelta;
if (threadRand == null)
{
threadRand = new Random(unchecked (System.Threading.Thread.CurrentThread.GetHashCode() ^
unchecked ((int)DateTime.Now.Ticks)));
}
ColorBgra *samples = stackalloc ColorBgra[sampleCount];
Random localRand = threadRand;
for (int r = startIndex; r < startIndex + length; ++r)
{
Rectangle roi = rois[r];
for (int y = roi.Top; y < roi.Bottom; ++y)
{
ColorBgra *dstPtr = DstArgs.Surface.GetPointAddressUnchecked(roi.Left, y);
for (int x = roi.Left; x < roi.Right; ++x)
{
for (int sampleIndex = 0; sampleIndex < sampleCount; ++sampleIndex)
{
double srcX;
double srcY;
while (true)
{
double angle = localRand.NextDouble() * Math.PI * 2.0;
double distanceDelta = localRand.NextDouble() * effectiveRadiusDelta;
double distance = distanceDelta + this.minRadius;
srcX = x + (Math.Cos(angle) * distance);
srcY = y + (Math.Sin(angle) * distance);
if (srcX >= 0 && srcX <= SrcArgs.Width && srcY >= 0 && srcY <= SrcArgs.Height)
{
break;
}
}
samples[sampleIndex] = SrcArgs.Surface.GetBilinearSample((float)srcX, (float)srcY);
}
ColorBgra result = ColorBgra.Blend(samples, sampleCount);
dstPtr->Bgra = result.Bgra;
++dstPtr;
}
}
}
}
public unsafe override void Render(ImageSurface src, ImageSurface dst, Gdk.Rectangle[] rois)
{
Gdk.Point[] pointOffsets = RecalcPointOffsets(Data.Fragments, Data.Rotation, Data.Distance);
int poLength = pointOffsets.Length;
Gdk.Point *pointOffsetsPtr = stackalloc Gdk.Point[poLength];
for (int i = 0; i < poLength; ++i)
{
pointOffsetsPtr[i] = pointOffsets[i];
}
ColorBgra *samples = stackalloc ColorBgra[poLength];
// Cache these for a massive performance boost
int src_width = src.Width;
int src_height = src.Height;
ColorBgra *src_data_ptr = (ColorBgra *)src.DataPtr;
foreach (Gdk.Rectangle rect in rois)
{
for (int y = rect.Top; y <= rect.GetBottom(); y++)
{
ColorBgra *dstPtr = dst.GetPointAddressUnchecked(rect.Left, y);
for (int x = rect.Left; x <= rect.GetRight(); x++)
{
int sampleCount = 0;
for (int i = 0; i < poLength; ++i)
{
int u = x - pointOffsetsPtr[i].X;
int v = y - pointOffsetsPtr[i].Y;
if (u >= 0 && u < src_width && v >= 0 && v < src_height)
{
samples[sampleCount] = src.GetPointUnchecked(src_data_ptr, src_width, u, v);
++sampleCount;
}
}
*dstPtr = ColorBgra.Blend(samples, sampleCount);
++dstPtr;
}
}
}
}
protected override unsafe void OnRender(Rectangle[] renderRects, int startIndex, int length)
{
Surface dst = DstArgs.Surface;
Surface src = SrcArgs.Surface;
int poLength = this.pointOffsets.Length;
Point *pointOffsets = stackalloc Point[poLength];
for (int i = 0; i < poLength; ++i)
{
pointOffsets[i] = this.pointOffsets[i];
}
ColorBgra *samples = stackalloc ColorBgra[poLength];
for (int n = startIndex; n < startIndex + length; ++n)
{
Rectangle rect = renderRects[n];
for (int y = rect.Top; y < rect.Bottom; y++)
{
ColorBgra *dstPtr = dst.GetPointAddressUnchecked(rect.Left, y);
for (int x = rect.Left; x < rect.Right; x++)
{
int sampleCount = 0;
for (int i = 0; i < poLength; ++i)
{
int u = x - pointOffsets[i].X;
int v = y - pointOffsets[i].Y;
if (u >= 0 && u < src.Bounds.Width && v >= 0 && v < src.Bounds.Height)
{
samples[sampleCount] = src.GetPointUnchecked(u, v);
++sampleCount;
}
}
*dstPtr = ColorBgra.Blend(samples, sampleCount);
++dstPtr;
}
}
}
}
private static unsafe ColorBgra SampleArea(Surface surface, RectInt32 sampleArea)
{
List <ColorBgra> items = new List <ColorBgra>();
for (int i = sampleArea.Top; i < sampleArea.Bottom; i++)
{
ColorBgra *pointAddressUnchecked = surface.GetPointAddressUnchecked(sampleArea.Left, i);
for (int j = sampleArea.Left; j < sampleArea.Right; j++)
{
items.Add(pointAddressUnchecked[0]);
pointAddressUnchecked++;
}
}
if (items.Count == 0)
{
return(ColorBgra.TransparentBlack);
}
return(ColorBgra.Blend(items.ToArrayEx <ColorBgra>()));
}
protected unsafe override void RenderLine(ISurface src, ISurface dst, Rectangle rect)
{
var pointOffsets = RecalcPointOffsets(fragments, rotation, distance);
int poLength = pointOffsets.Length;
Point *pointOffsetsPtr = stackalloc Point[poLength];
for (int i = 0; i < poLength; ++i)
{
pointOffsetsPtr[i] = pointOffsets[i];
}
ColorBgra *samples = stackalloc ColorBgra[poLength];
int src_width = src.Width;
int src_height = src.Height;
for (int y = rect.Top; y <= rect.Bottom; y++)
{
ColorBgra *dstPtr = dst.GetPointAddress(rect.Left, y);
for (int x = rect.Left; x <= rect.Right; x++)
{
int sampleCount = 0;
for (int i = 0; i < poLength; ++i)
{
int u = x - pointOffsetsPtr[i].X;
int v = y - pointOffsetsPtr[i].Y;
if (u >= 0 && u < src_width && v >= 0 && v < src_height)
{
samples[sampleCount] = src.GetPoint(u, v);
++sampleCount;
}
}
*dstPtr = ColorBgra.Blend(samples, sampleCount);
++dstPtr;
}
}
}
protected override unsafe void OnRender(Rectangle[] rois, int startIndex, int length)
{
Surface dst = DstArgs.Surface;
Surface src = SrcArgs.Surface;
ColorBgra *samples = stackalloc ColorBgra[this.points.Length];
for (int i = startIndex; i < startIndex + length; ++i)
{
Rectangle rect = rois[i];
for (int y = rect.Top; y < rect.Bottom; ++y)
{
ColorBgra *dstPtr = dst.GetPointAddressUnchecked(rect.Left, y);
for (int x = rect.Left; x < rect.Right; ++x)
{
int sampleCount = 0;
PointF a = new PointF((float)x + points[0].X, (float)y + points[0].Y);
PointF b = new PointF((float)x + points[points.Length - 1].X, (float)y + points[points.Length - 1].Y);
for (int j = 0; j < this.points.Length; ++j)
{
PointF pt = new PointF(this.points[j].X + (float)x, this.points[j].Y + (float)y);
if (pt.X >= 0 && pt.Y >= 0 && pt.X <= (src.Width - 1) && pt.Y <= (src.Height - 1))
{
samples[sampleCount] = src.GetBilinearSample(pt.X, pt.Y);
++sampleCount;
}
}
*dstPtr = ColorBgra.Blend(samples, sampleCount);
++dstPtr;
}
}
}
}
public unsafe override void Render(ImageSurface src, ImageSurface dst, Gdk.Rectangle[] rois)
{
PointD start = new PointD(0, 0);
double theta = ((double)(Data.Angle + 180) * 2 * Math.PI) / 360.0;
double alpha = (double)Data.Distance;
PointD end = new PointD((float)alpha * Math.Cos(theta), (float)(-alpha * Math.Sin(theta)));
if (Data.Centered)
{
start.X = -end.X / 2.0f;
start.Y = -end.Y / 2.0f;
end.X /= 2.0f;
end.Y /= 2.0f;
}
PointD[] points = new PointD[((1 + Data.Distance) * 3) / 2];
if (points.Length == 1)
{
points[0] = new PointD(0, 0);
}
else
{
for (int i = 0; i < points.Length; ++i)
{
float frac = (float)i / (float)(points.Length - 1);
points[i] = Utility.Lerp(start, end, frac);
}
}
ColorBgra *samples = stackalloc ColorBgra[points.Length];
ColorBgra *src_dataptr = (ColorBgra *)src.DataPtr;
int src_width = src.Width;
int src_height = src.Height;
foreach (Gdk.Rectangle rect in rois)
{
for (int y = rect.Top; y <= rect.GetBottom(); ++y)
{
ColorBgra *dstPtr = dst.GetPointAddressUnchecked(rect.Left, y);
for (int x = rect.Left; x <= rect.GetRight(); ++x)
{
int sampleCount = 0;
for (int j = 0; j < points.Length; ++j)
{
PointD pt = new PointD(points[j].X + (float)x, points[j].Y + (float)y);
if (pt.X >= 0 && pt.Y >= 0 && pt.X <= (src_width - 1) && pt.Y <= (src_height - 1))
{
samples[sampleCount] = src.GetBilinearSample(src_dataptr, src_width, src_height, (float)pt.X, (float)pt.Y);
++sampleCount;
}
}
*dstPtr = ColorBgra.Blend(samples, sampleCount);
++dstPtr;
}
}
}
}
/// <summary>
/// Replaces a portion of the destination bitmap with the surface bitmap using a brush as an alpha mask.
/// </summary>
/// <param name="surface">The surface contains the source bitmap. It will be drawn to dest.</param>
/// <param name="dest">The bitmap to edit.</param>
/// <param name="alphaMask">The brush used to draw.</param>
/// <param name="location">The location to draw the brush at.</param>
public static unsafe void OverwriteMasked(Surface surface, Bitmap dest, Bitmap alphaMask, Point location)
{
// Calculates the brush regions outside the bounding area of the surface.
int negativeX = location.X < 0 ? -location.X : 0;
int negativeY = location.Y < 0 ? -location.Y : 0;
int extraX = Math.Max(location.X + alphaMask.Width - surface.Width, 0);
int extraY = Math.Max(location.Y + alphaMask.Height - surface.Height, 0);
int adjWidth = alphaMask.Width - negativeX - extraX;
int adjHeight = alphaMask.Height - negativeY - extraY;
if (adjWidth < 1 || adjHeight < 1 ||
surface.Width != dest.Width || surface.Height != dest.Height)
{
return;
}
Rectangle adjBounds = new Rectangle(
location.X < 0 ? 0 : location.X,
location.Y < 0 ? 0 : location.Y,
adjWidth,
adjHeight);
BitmapData destData = dest.LockBits(
adjBounds,
ImageLockMode.ReadWrite,
dest.PixelFormat);
BitmapData alphaMaskData = alphaMask.LockBits(
new Rectangle(0, 0,
alphaMask.Width,
alphaMask.Height),
ImageLockMode.ReadOnly,
alphaMask.PixelFormat);
byte *destRow = (byte *)destData.Scan0;
byte *alphaMaskRow = (byte *)alphaMaskData.Scan0;
byte *srcRow = (byte *)surface.Scan0.Pointer;
float alphaFactor;
for (int y = 0; y < adjHeight; y++)
{
ColorBgra *alphaMaskPtr = (ColorBgra *)(alphaMaskRow + negativeX * 4 + ((negativeY + y) * alphaMaskData.Stride));
ColorBgra *srcPtr = (ColorBgra *)(srcRow + adjBounds.X * 4 + ((adjBounds.Y + y) * surface.Stride));
ColorBgra *destPtr = (ColorBgra *)(destRow + (y * destData.Stride));
for (int x = 0; x < adjWidth; x++)
{
ColorBgra newColor = ColorBgra.Blend(
destPtr->ConvertFromPremultipliedAlpha(),
*srcPtr,
alphaMaskPtr->A);
alphaFactor = newColor.A / 255f;
destPtr->B = (byte)Math.Ceiling(newColor.B * alphaFactor);
destPtr->G = (byte)Math.Ceiling(newColor.G * alphaFactor);
destPtr->R = (byte)Math.Ceiling(newColor.R * alphaFactor);
destPtr->A = newColor.A;
alphaMaskPtr++;
destPtr++;
srcPtr++;
}
}
dest.UnlockBits(destData);
alphaMask.UnlockBits(alphaMaskData);
}
public unsafe override void Render(ImageSurface src, ImageSurface dst, Gdk.Rectangle[] rois)
{
ColorBgra colPrimary = PintaCore.Palette.PrimaryColor.ToColorBgra();
ColorBgra colSecondary = PintaCore.Palette.SecondaryColor.ToColorBgra();
ColorBgra colTransparent = ColorBgra.Transparent;
int aaSampleCount = Data.Quality * Data.Quality;
Cairo.PointD *aaPoints = stackalloc Cairo.PointD[aaSampleCount];
Utility.GetRgssOffsets(aaPoints, aaSampleCount, Data.Quality);
ColorBgra *samples = stackalloc ColorBgra[aaSampleCount];
TransformData td;
foreach (Gdk.Rectangle rect in rois)
{
for (int y = rect.Top; y <= rect.GetBottom(); y++)
{
ColorBgra *dstPtr = dst.GetPointAddressUnchecked(rect.Left, y);
double relativeY = y - Data.CenterOffset.Y;
for (int x = rect.Left; x <= rect.GetRight(); x++)
{
double relativeX = x - Data.CenterOffset.X;
int sampleCount = 0;
for (int p = 0; p < aaSampleCount; ++p)
{
td.X = relativeX + aaPoints[p].X;
td.Y = relativeY - aaPoints[p].Y;
InverseTransform(ref td);
float sampleX = (float)(td.X + Data.CenterOffset.X);
float sampleY = (float)(td.Y + Data.CenterOffset.Y);
ColorBgra sample = colPrimary;
if (IsOnSurface(src, sampleX, sampleY))
{
sample = src.GetBilinearSample(sampleX, sampleY);
}
else
{
switch (Data.EdgeBehavior)
{
case WarpEdgeBehavior.Clamp:
sample = src.GetBilinearSampleClamped(sampleX, sampleY);
break;
case WarpEdgeBehavior.Wrap:
sample = src.GetBilinearSampleWrapped(sampleX, sampleY);
break;
case WarpEdgeBehavior.Reflect:
sample = src.GetBilinearSampleClamped(ReflectCoord(sampleX, src.Width), ReflectCoord(sampleY, src.Height));
break;
case WarpEdgeBehavior.Primary:
sample = colPrimary;
break;
case WarpEdgeBehavior.Secondary:
sample = colSecondary;
break;
case WarpEdgeBehavior.Transparent:
sample = colTransparent;
break;
case WarpEdgeBehavior.Original:
sample = src.GetColorBgra(x, y);
break;
default:
break;
}
}
samples[sampleCount] = sample;
++sampleCount;
}
*dstPtr = ColorBgra.Blend(samples, sampleCount);
++dstPtr;
}
}
}
}
protected unsafe override void RenderLine(ISurface src, ISurface dst, Rectangle rect)
{
ColorBgra colTransparent = ColorBgra.Transparent;
int aaSampleCount = quality * quality;
PointD *aaPoints = stackalloc PointD[aaSampleCount];
Utility.GetRgssOffsets(aaPoints, aaSampleCount, quality);
ColorBgra *samples = stackalloc ColorBgra[aaSampleCount];
TransformData td;
for (int y = rect.Top; y <= rect.Bottom; y++)
{
ColorBgra *dstPtr = dst.GetPointAddress(rect.Left, y);
double relativeY = y - center_offset.Y;
for (int x = rect.Left; x <= rect.Right; x++)
{
double relativeX = x - center_offset.X;
int sampleCount = 0;
for (int p = 0; p < aaSampleCount; ++p)
{
td.X = relativeX + aaPoints[p].X;
td.Y = relativeY - aaPoints[p].Y;
InverseTransform(ref td);
float sampleX = (float)(td.X + center_offset.X);
float sampleY = (float)(td.Y + center_offset.Y);
ColorBgra sample = primary_color;
if (IsOnSurface(src, sampleX, sampleY))
{
sample = Utility.GetBilinearSampleClamped(src, sampleX, sampleY);
}
else
{
switch (edge_behavior)
{
case WarpEdgeBehavior.Clamp:
sample = Utility.GetBilinearSampleClamped(src, sampleX, sampleY);
break;
case WarpEdgeBehavior.Wrap:
sample = Utility.GetBilinearSampleWrapped(src, sampleX, sampleY);
break;
case WarpEdgeBehavior.Reflect:
sample = Utility.GetBilinearSampleClamped(src, ReflectCoord(sampleX, src.Width), ReflectCoord(sampleY, src.Height));
break;
case WarpEdgeBehavior.Primary:
sample = primary_color;
break;
case WarpEdgeBehavior.Secondary:
sample = secondary_color;
break;
case WarpEdgeBehavior.Transparent:
sample = colTransparent;
break;
case WarpEdgeBehavior.Original:
sample = src.GetPoint(x, y);
break;
default:
break;
}
}
samples[sampleCount] = sample;
++sampleCount;
}
*dstPtr = ColorBgra.Blend(samples, sampleCount);
++dstPtr;
}
}
}
private void DrawChannel(Context g, ColorBgra color, int channel, long max, float mean)
{
var rect = new Rectangle(0, 0, AllocatedWidth, AllocatedHeight);
var l = (int)rect.X;
var t = (int)rect.Y;
var r = (int)(rect.X + rect.Width);
var b = (int)(rect.Y + rect.Height);
var entries = Histogram.Entries;
var hist = Histogram.HistogramValues[channel];
++max;
if (FlipHorizontal)
{
Utility.Swap(ref l, ref r);
}
if (!FlipVertical)
{
Utility.Swap(ref t, ref b);
}
var points = new PointD[entries + 2];
points[entries] = new PointD(Utility.Lerp(l, r, -1), Utility.Lerp(t, b, 20));
points[entries + 1] = new PointD(Utility.Lerp(l, r, -1), Utility.Lerp(b, t, 20));
for (var i = 0; i < entries; i += entries - 1)
{
points[i] = new PointD(
Utility.Lerp(l, r, (float)hist[i] / (float)max),
Utility.Lerp(t, b, (float)i / (float)entries));
CheckPoint(rect, points[i]);
}
var sum3 = hist[0] + hist[1];
for (var i = 1; i < entries - 1; ++i)
{
sum3 += hist[i + 1];
points[i] = new PointD(
Utility.Lerp(l, r, (float)(sum3) / (float)(max * 3.1f)),
Utility.Lerp(t, b, (float)i / (float)entries));
CheckPoint(rect, points[i]);
sum3 -= hist[i - 1];
}
var intensity = selected[channel] ? (byte)96 : (byte)32;
var pen_color = ColorBgra.Blend(ColorBgra.Black, color, intensity);
var brush_color = color;
brush_color.A = intensity;
g.LineWidth = 1;
g.Rectangle(rect);
g.Clip();
g.DrawPolygonal(points, pen_color.ToCairoColor());
g.FillPolygonal(points, brush_color.ToCairoColor());
}
protected unsafe override void OnRender(Rectangle[] rois, int startIndex, int length)
{
double twist = this.amount * this.amount * Math.Sign(this.amount);
Surface dst = DstArgs.Surface;
Surface src = SrcArgs.Surface;
float hw = dst.Width / 2.0f;
hw += (float)(hw * this.offset.First);
float hh = dst.Height / 2.0f;
hh += (float)(hh * this.offset.Second);
//*double maxrad = Math.Min(dst.Width / 2.0, dst.Height / 2.0);
double invmaxrad = 1.0 / Math.Min(dst.Width / 2.0, dst.Height / 2.0);
int aaLevel = this.quality;
int aaSamples = aaLevel * aaLevel;
PointF *aaPoints = stackalloc PointF[aaSamples];
Utility.GetRgssOffsets(aaPoints, aaSamples, aaLevel);
ColorBgra *samples = stackalloc ColorBgra[aaSamples];
for (int n = startIndex; n < startIndex + length; ++n)
{
Rectangle rect = rois[n];
for (int y = rect.Top; y < rect.Bottom; y++)
{
float j = y - hh;
ColorBgra *dstPtr = dst.GetPointAddressUnchecked(rect.Left, y);
ColorBgra *srcPtr = src.GetPointAddressUnchecked(rect.Left, y);
for (int x = rect.Left; x < rect.Right; x++)
{
float i = x - hw;
int sampleCount = 0;
for (int p = 0; p < aaSamples; ++p)
{
float u = i + aaPoints[p].X;
float v = j + aaPoints[p].Y;
double rad = Math.Sqrt(u * u + v * v);
double theta = Math.Atan2(v, u);
double t = 1 - ((rad * this.size) * invmaxrad);
t = (t < 0) ? 0 : (t * t * t);
theta += (t * twist) * inv100;
float sampleX = (hw + (float)(rad * Math.Cos(theta)));
float sampleY = (hh + (float)(rad * Math.Sin(theta)));
samples[sampleCount] = src.GetBilinearSampleClamped(sampleX, sampleY);
++sampleCount;
}
*dstPtr = ColorBgra.Blend(samples, sampleCount);
++dstPtr;
++srcPtr;
}
}
}
}
private void DrawToDrawingContext(IDrawingContext dc)
{
RectInt32 rect = base.ClientRectangle.ToRectInt32();
dc.Clear(new ColorRgba128Float?(this.BackColor));
using (dc.UseTranslateTransform(0.5f, 0.5f, MatrixMultiplyOrder.Append))
{
using (dc.UseAntialiasMode(AntialiasMode.PerPrimitive))
{
RectInt32 num2 = RectInt32.Inflate(rect, -2, -2);
int num3 = Math.Min(num2.Width, num2.Height);
PointInt32 center = new PointInt32(num2.X + (num3 / 2), num2.Y + (num3 / 2));
double radius = ((double)num3) / 2.0;
double scale = ((double)num3) / 3.0;
double num7 = ((double)num3) / 2.0;
double d = -MathUtil.DegreesToRadians(this.angle);
double num9 = Math.Cos(d);
double num10 = Math.Sin(d);
double rx = (this.rollAmount * Math.Cos(MathUtil.DegreesToRadians(this.rollDirection))) / 90.0;
double num12 = (this.rollAmount * Math.Sin(MathUtil.DegreesToRadians(this.rollDirection))) / 90.0;
double num13 = rx / (((num12 * num12) < 0.99) ? Math.Sqrt(1.0 - (num12 * num12)) : 1.0);
double num14 = num12 / (((rx * rx) < 0.99) ? Math.Sqrt(1.0 - (rx * rx)) : 1.0);
double thickness = (this.mouseEntered && !this.onSphere) ? 2.0 : 1.0;
if (this.ringOuterEllipseGeometry == null)
{
this.ringOuterEllipseGeometry = new EllipseGeometry();
}
if (this.ringInnerEllipseGeometry == null)
{
this.ringInnerEllipseGeometry = new EllipseGeometry();
}
if (this.ringFillGeometry == null)
{
this.ringFillGeometry = new CombinedGeometry(GeometryCombineMode.Exclude, this.ringOuterEllipseGeometry, this.ringInnerEllipseGeometry);
}
this.ringOuterEllipseGeometry.Center = center;
this.ringOuterEllipseGeometry.RadiusX = radius - 0.5;
this.ringOuterEllipseGeometry.RadiusY = radius - 0.5;
this.ringInnerEllipseGeometry.Center = center;
this.ringInnerEllipseGeometry.RadiusX = radius;
this.ringInnerEllipseGeometry.RadiusY = radius;
dc.FillGeometry(this.ringFillGeometry, ringFillBrush, null);
if (this.ringOutlinePen == null)
{
this.ringOutlinePen = new PaintDotNet.UI.Media.Pen();
}
this.ringOutlinePen.Brush = ringOutlineBrush;
this.ringOutlinePen.Thickness = thickness;
dc.DrawCircle(center, radius, this.ringOutlinePen);
double num16 = (this.mouseEntered && !this.onSphere) ? ((double)2) : ((double)1);
dc.DrawLine(center.X + (scale * num9), center.Y + (scale * num10), center.X + (num7 * num9), center.Y + (num7 * num10), thetaLineBrush, num16);
using (dc.UseTranslateTransform((float)center.X, (float)center.Y, MatrixMultiplyOrder.Prepend))
{
double num17 = (this.angle * 3.1415926535897931) / 180.0;
float num18 = (this.mouseEntered && this.onSphere) ? 1.5f : 1f;
int num19 = 0x18;
for (int i = 0; i >= (-num19 / 2); i--)
{
double num22 = (i * 3.1415926535897931) / ((double)num19);
double num23 = -num17 - 3.1415926535897931;
double xs = Math.Cos(num23) * Math.Cos(num22);
double ys = Math.Sin(num23) * Math.Cos(num22);
double zs = Math.Sin(num22);
double num30 = ((double)(i + (num19 / 2))) / ((double)(num19 / 2));
byte index = Int32Util.ClampToByte((int)(num30 * 255.0));
if (this.latBrushCache[index] == null)
{
ColorBgra bgra = ColorBgra.Blend(latGradStart, latGradEnd, index);
this.latBrushCache[index] = SolidColorBrushCache.Get((ColorRgba128Float)bgra);
}
SolidColorBrush brush = this.latBrushCache[index];
for (int k = -num19 * 6; k <= (num19 * 6); k++)
{
num23 = -num17 + ((k * 3.1415926535897931) / ((double)(num19 * 6)));
double num33 = Math.Cos(num22);
double num34 = Math.Sin(num22);
double xe = Math.Cos(num23) * Math.Cos(num22);
double ye = Math.Sin(num23) * Math.Cos(num22);
double ze = Math.Sin(num22);
double num35 = (this.mouseEntered && this.onSphere) ? 1.5 : 1.0;
this.Draw3DLine(dc, rx, -num12, scale, xs, ys, zs, xe, ye, ze, brush, num35);
xs = xe;
ys = ye;
zs = ze;
}
}
int num20 = 4;
for (int j = -num20; j < num20; j++)
{
double num37 = -num17 + ((j * 3.1415926535897931) / ((double)num20));
double num38 = -1.5707963267948966;
double num39 = Math.Cos(num37) * Math.Cos(num38);
double num40 = Math.Sin(num37) * Math.Cos(num38);
double num41 = Math.Sin(num38);
for (int m = -num20 * 4; m <= 0; m++)
{
num38 = (m * 3.1415926535897931) / ((double)(num20 * 8));
double num42 = Math.Cos(num37) * Math.Cos(num38);
double num43 = Math.Sin(num37) * Math.Cos(num38);
double num44 = Math.Sin(num38);
double num46 = (this.mouseEntered && this.onSphere) ? 2.0 : 1.0;
this.Draw3DLine(dc, rx, -num12, scale, num39, num40, num41, num42, num43, num44, lightBrush, num46);
num39 = num42;
num40 = num43;
num41 = num44;
}
}
}
dc.DrawCircle(center, scale, ringInlineBrush, thickness);
}
}
}
public override void Render(Surface src, Surface dst, Rectangle[] rois, int start, int len)
{
unsafe
{
double twist = _amount * _amount * Math.Sign(_amount);
float hw = dst.Width / 2.0f;
hw += (float)(hw * _offsetX);
float hh = dst.Height / 2.0f;
hh += (float)(hh * _offsetY);
//*double maxrad = Math.Min(dst.Width / 2.0, dst.Height / 2.0);
double invmaxrad = 1.0 / Math.Min(dst.Width / 2.0, dst.Height / 2.0);
int aaLevel = _quality;
int aaSamples = aaLevel * aaLevel;
PointF *aaPoints = stackalloc PointF[aaSamples];
PixelUtils.GetRgssOffsets(aaPoints, aaSamples, aaLevel);
ColorBgra *samples = stackalloc ColorBgra[aaSamples];
//TODO: review here
for (int n = start; n < start + len; ++n)
{
Rectangle rect = rois[n];
for (int y = rect.Top; y < rect.Bottom; y++)
{
float j = y - hh;
ColorBgra *dstPtr = dst.GetPointAddressUnchecked(rect.Left, y);
ColorBgra *srcPtr = src.GetPointAddressUnchecked(rect.Left, y);
for (int x = rect.Left; x < rect.Right; x++)
{
float i = x - hw;
int sampleCount = 0;
for (int p = 0; p < aaSamples; ++p)
{
float u = i + aaPoints[p].X;
float v = j + aaPoints[p].Y;
double rad = Math.Sqrt(u * u + v * v);
double theta = Math.Atan2(v, u);
double t = 1 - ((rad * _size) * invmaxrad);
t = (t < 0) ? 0 : (t * t * t);
theta += (t * twist) * INV100;
float sampleX = (hw + (float)(rad * Math.Cos(theta)));
float sampleY = (hh + (float)(rad * Math.Sin(theta)));
samples[sampleCount] = src.GetBilinearSampleClamped(sampleX, sampleY);
++sampleCount;
}
*dstPtr = ColorBgra.Blend(samples, sampleCount);
++dstPtr;
++srcPtr;
}
}
}
}
}
protected unsafe override void RenderLine(ISurface src, ISurface dst, Rectangle rect)
{
PointD start = new PointD(0, 0);
double theta = ((double)(angle + 180) * 2 * Math.PI) / 360.0;
double alpha = (double)distance;
PointD end = new PointD((float)alpha * Math.Cos(theta), (float)(-alpha * Math.Sin(theta)));
if (centered)
{
start.X = -end.X / 2.0f;
start.Y = -end.Y / 2.0f;
end.X /= 2.0f;
end.Y /= 2.0f;
}
PointD[] points = new PointD[((1 + distance) * 3) / 2];
if (points.Length == 1)
{
points[0] = new PointD(0, 0);
}
else
{
for (int i = 0; i < points.Length; ++i)
{
float frac = (float)i / (float)(points.Length - 1);
points[i] = Utility.Lerp(start, end, frac);
}
}
ColorBgra *samples = stackalloc ColorBgra[points.Length];
int src_width = src.Width;
int src_height = src.Height;
for (int y = rect.Top; y <= rect.Bottom; ++y)
{
ColorBgra *dstPtr = dst.GetPointAddress(rect.Left, y);
for (int x = rect.Left; x <= rect.Right; ++x)
{
int sampleCount = 0;
for (int j = 0; j < points.Length; ++j)
{
PointD pt = new PointD(points[j].X + (float)x, points[j].Y + (float)y);
if (pt.X >= 0 && pt.Y >= 0 && pt.X <= (src_width - 1) && pt.Y <= (src_height - 1))
{
samples[sampleCount] = Utility.GetBilinearSampleClamped(src, (float)pt.X, (float)pt.Y);
++sampleCount;
}
}
*dstPtr = ColorBgra.Blend(samples, sampleCount);
++dstPtr;
}
}
}
public override void Render(Surface src, Surface dst, Rectangle[] rois, int start, int len)
{
unsafe
{
int width = dst.Width;
int height = dst.Height;
float hw = width / 2.0f;
float hh = height / 2.0f;
int aaSampleCount = this.quality * this.quality;
PointF *aaPointsArray = stackalloc PointF[aaSampleCount];
PixelUtils.GetRgssOffsets(aaPointsArray, aaSampleCount, this.quality);
ColorBgra *samples = stackalloc ColorBgra[aaSampleCount];
for (int n = start; n < start + len; ++n)
{
Rectangle rect = rois[n];
for (int y = rect.Top; y < rect.Bottom; y++)
{
float j = y - hh;
ColorBgra *dstPtr = dst.GetPointAddressUnchecked(rect.Left, y);
for (int x = rect.Left; x < rect.Right; x++)
{
float i = x - hw;
for (int p = 0; p < aaSampleCount; ++p)
{
PointF pt = aaPointsArray[p];
float u1 = i + pt.X;
float v1 = j - pt.Y;
float s1 = cos * u1 + sin * v1;
float t1 = -sin * u1 + cos * v1;
float s2 = s1 + this.intensity * (float)Math.Tan(s1 * this.scale);
float t2 = t1 + this.intensity * (float)Math.Tan(t1 * this.scale);
float u2 = cos * s2 - sin * t2;
float v2 = sin * s2 + cos * t2;
float xSample = hw + u2;
float ySample = hh + v2;
samples[p] = src.GetBilinearSampleWrapped(xSample, ySample);
/*
* int xiSample = (int)xSample;
* int yiSample = (int)ySample;
*
* xiSample = (xiSample + width) % width;
* if (xiSample < 0) // This makes it a little faster
* {
* xiSample = (xiSample + width) % width;
* }
*
* yiSample = (yiSample + height) % height;
* if (yiSample < 0) // This makes it a little faster
* {
* yiSample = (yiSample + height) % height;
* }
*
* samples[p] = *src.GetPointAddressUnchecked(xiSample, yiSample);
*/
}
*dstPtr = ColorBgra.Blend(samples, aaSampleCount);
++dstPtr;
}
}
}
}
}
public override void Render(Surface src, Surface dst, Rectangle[] rois, int startIndex, int length)
{
ColorBgra colTransparent = ColorBgra.Transparent;
unsafe
{
int aaSampleCount = quality * quality;
PointF *aaPoints = stackalloc PointF[aaSampleCount];
PixelUtils.GetRgssOffsets(aaPoints, aaSampleCount, quality);
ColorBgra *samples = stackalloc ColorBgra[aaSampleCount];
TransformData td;
for (int n = startIndex; n < startIndex + length; ++n)
{
Rectangle rect = rois[n];
for (int y = rect.Top; y < rect.Bottom; y++)
{
ColorBgra *dstPtr = dst.GetPointAddressUnchecked(rect.Left, y);
double relativeY = y - this.yCenterOffset;
for (int x = rect.Left; x < rect.Right; x++)
{
double relativeX = x - this.xCenterOffset;
int sampleCount = 0;
for (int p = 0; p < aaSampleCount; ++p)
{
td.X = relativeX + aaPoints[p].X;
td.Y = relativeY - aaPoints[p].Y;
InverseTransform(ref td);
float sampleX = (float)(td.X + this.xCenterOffset);
float sampleY = (float)(td.Y + this.yCenterOffset);
ColorBgra sample = colPrimary;
if (IsOnSurface(src, sampleX, sampleY))
{
sample = src.GetBilinearSample(sampleX, sampleY);
}
else
{
switch (this.edgeBehavior)
{
case WarpEdgeBehavior.Clamp:
sample = src.GetBilinearSampleClamped(sampleX, sampleY);
break;
case WarpEdgeBehavior.Wrap:
sample = src.GetBilinearSampleWrapped(sampleX, sampleY);
break;
case WarpEdgeBehavior.Reflect:
sample = src.GetBilinearSampleClamped(
ReflectCoord(sampleX, src.Width),
ReflectCoord(sampleY, src.Height));
break;
case WarpEdgeBehavior.Primary:
sample = colPrimary;
break;
case WarpEdgeBehavior.Secondary:
sample = colSecondary;
break;
case WarpEdgeBehavior.Transparent:
sample = colTransparent;
break;
case WarpEdgeBehavior.Original:
sample = src[x, y];
break;
default:
break;
}
}
samples[sampleCount] = sample;
++sampleCount;
}
*dstPtr = ColorBgra.Blend(samples, sampleCount);
++dstPtr;
}
}
}
}
}
void brushcombobox_DrawItem(object sender, DrawItemEventArgs e)
{
e.DrawBackground();
if (e.State == DrawItemState.Selected)
{
e.DrawFocusRectangle();
}
if (e.Index == brushcombobox.Items.Count - 1)
{
e.Graphics.DrawString(brushcombobox.Items[e.Index].ToString(), e.Font, new SolidBrush(ColorBgra.Blend(new ColorBgra[] { ColorBgra.FromColor(e.ForeColor), ColorBgra.FromColor(e.BackColor) }).ToColor()), e.Bounds.X, e.Bounds.Y + 8);
}
else
{
if (e.Index >= 0)
{
if (droppingdown)
{
var image = brushcollection[e.Index].ThumbnailAlphaOnly.CreateAliasedBitmap();
e.Graphics.DrawImage(image, e.Bounds.X + (32 - image.Width) / 2, e.Bounds.Y + (32 - image.Height) / 2);
e.Graphics.DrawString(brushcollection[e.Index].Name, e.Font, new SolidBrush(e.ForeColor), e.Bounds.X + 32, e.Bounds.Y);
e.Graphics.DrawString(brushcollection[e.Index].NativeSizePrettyString, e.Font, new SolidBrush(ColorBgra.Blend(new ColorBgra[] { ColorBgra.FromColor(e.ForeColor), ColorBgra.FromColor(e.BackColor) }).ToColor()), e.Bounds.X + 64, e.Bounds.Y + 16);
}
else
{
var image = brushcollection[e.Index].ThumbnailAlphaOnly.CreateAliasedBitmap();
e.Graphics.DrawImage(image, e.Bounds.X + (32 - image.Width) / 4, e.Bounds.Y + (32 - image.Height) / 4, image.Width / 2, image.Height / 2);
e.Graphics.DrawString(brushcollection[e.Index].Name, e.Font, new SolidBrush(e.ForeColor), e.Bounds.X + 16, e.Bounds.Y);
}
}
}
}