private unsafe void RenderPixelGrid(Cairo.ImageSurface dst, Gdk.Point offset)
{
EnsureLookupTablesCreated();
// Draw horizontal lines
var dst_ptr = (ColorBgra *)dst.DataPtr;
int dstHeight = dst.Height;
int dstWidth = dst.Width;
int dstStride = dst.Stride;
int sTop = d2sLookupY[offset.Y];
int sBottom = d2sLookupY[offset.Y + dstHeight];
for (int srcY = sTop; srcY <= sBottom; ++srcY)
{
int dstY = s2dLookupY[srcY];
int dstRow = dstY - offset.Y;
if (dstRow >= 0 && dstRow < dstHeight)
{
ColorBgra *dstRowPtr = dst.GetRowAddressUnchecked(dst_ptr, dstWidth, dstRow);
ColorBgra *dstRowEndPtr = dstRowPtr + dstWidth;
dstRowPtr += offset.X & 1;
while (dstRowPtr < dstRowEndPtr)
{
*dstRowPtr = ColorBgra.Black;
dstRowPtr += 2;
}
}
}
// Draw vertical lines
int sLeft = d2sLookupX[offset.X];
int sRight = d2sLookupX[offset.X + dstWidth];
for (int srcX = sLeft; srcX <= sRight; ++srcX)
{
int dstX = s2dLookupX[srcX];
int dstCol = dstX - offset.X;
if (dstCol >= 0 && dstCol < dstWidth)
{
byte *dstColPtr = (byte *)dst.GetPointAddress(dstCol, 0);
byte *dstColEndPtr = dstColPtr + dstStride * dstHeight;
dstColPtr += (offset.Y & 1) * dstStride;
while (dstColPtr < dstColEndPtr)
{
*((ColorBgra *)dstColPtr) = ColorBgra.Black;
dstColPtr += 2 * dstStride;
}
}
}
}
private unsafe void RenderPixelGrid(Cairo.ImageSurface dst, Point offset)
{
// Draw horizontal lines
var dst_ptr = (ColorBgra *)dst.DataPtr;
var dstHeight = dst.Height;
var dstWidth = dst.Width;
var dstStride = dst.Stride;
var sTop = D2SLookupY[offset.Y];
var sBottom = D2SLookupY[offset.Y + dstHeight];
for (var srcY = sTop; srcY <= sBottom; ++srcY)
{
var dstY = S2DLookupY[srcY];
var dstRow = dstY - offset.Y;
if (dstRow >= 0 && dstRow < dstHeight)
{
var dstRowPtr = dst.GetRowAddressUnchecked(dst_ptr, dstWidth, dstRow);
var dstRowEndPtr = dstRowPtr + dstWidth;
dstRowPtr += offset.X & 1;
while (dstRowPtr < dstRowEndPtr)
{
*dstRowPtr = ColorBgra.Black;
dstRowPtr += 2;
}
}
}
// Draw vertical lines
var sLeft = D2SLookupX[offset.X];
var sRight = D2SLookupX[offset.X + dstWidth];
for (var srcX = sLeft; srcX <= sRight; ++srcX)
{
var dstX = S2DLookupX[srcX];
var dstCol = dstX - offset.X;
if (dstCol >= 0 && dstCol < dstWidth)
{
var dstColPtr = (byte *)dst.GetPointAddress(dstCol, 0);
var dstColEndPtr = dstColPtr + dstStride * dstHeight;
dstColPtr += (offset.Y & 1) * dstStride;
while (dstColPtr < dstColEndPtr)
{
*((ColorBgra *)dstColPtr) = ColorBgra.Black;
dstColPtr += 2 * dstStride;
}
}
}
}
/// <summary>
/// Provides a default implementation for performing dst = F(lhs, rhs) over some rectangle of interest.
/// </summary>
/// <param name="dst">The Surface to write pixels to.</param>
/// <param name="dstOffset">The pixel offset that defines the upper-left of the rectangle-of-interest for the dst Surface.</param>
/// <param name="lhs">The Surface to read pixels from for the lhs parameter given to the method <b>ColorBgra Apply(ColorBgra, ColorBgra)</b>b>.</param></param>
/// <param name="lhsOffset">The pixel offset that defines the upper-left of the rectangle-of-interest for the lhs Surface.</param>
/// <param name="rhs">The Surface to read pixels from for the rhs parameter given to the method <b>ColorBgra Apply(ColorBgra, ColorBgra)</b></param>
/// <param name="rhsOffset">The pixel offset that defines the upper-left of the rectangle-of-interest for the rhs Surface.</param>
/// <param name="roiSize">The size of the rectangles-of-interest for all Surfaces.</param>
public void Apply(Cairo.ImageSurface dst, Point dstOffset,
Cairo.ImageSurface lhs, Point lhsOffset,
Cairo.ImageSurface rhs, Point rhsOffset,
Size roiSize)
{
// Bounds checking only enabled in Debug builds.
#if DEBUG
// Create bounding rectangles for each Surface
Rectangle dstRect = new Rectangle(dstOffset, roiSize);
Rectangle lhsRect = new Rectangle(lhsOffset, roiSize);
Rectangle rhsRect = new Rectangle(rhsOffset, roiSize);
// Clip those rectangles to those Surface's bounding rectangles
Rectangle dstClip = Rectangle.Intersect(dstRect, dst.GetBounds());
Rectangle lhsClip = Rectangle.Intersect(lhsRect, lhs.GetBounds());
Rectangle rhsClip = Rectangle.Intersect(rhsRect, rhs.GetBounds());
// If any of those Rectangles actually got clipped, then throw an exception
if (dstRect != dstClip)
{
throw new ArgumentOutOfRangeException("roiSize", "Destination roi out of bounds");
}
if (lhsRect != lhsClip)
{
throw new ArgumentOutOfRangeException("roiSize", "lhs roi out of bounds");
}
if (rhsRect != rhsClip)
{
throw new ArgumentOutOfRangeException("roiSize", "rhs roi out of bounds");
}
#endif
// Cache the width and height properties
int width = roiSize.Width;
int height = roiSize.Height;
// Do the work.
unsafe {
for (int row = 0; row < height; ++row)
{
ColorBgra *dstPtr = dst.GetPointAddress(dstOffset.X, dstOffset.Y + row);
ColorBgra *lhsPtr = lhs.GetPointAddress(lhsOffset.X, lhsOffset.Y + row);
ColorBgra *rhsPtr = rhs.GetPointAddress(rhsOffset.X, rhsOffset.Y + row);
Apply(dstPtr, lhsPtr, rhsPtr, width);
}
}
}
public override void Apply(Cairo.ImageSurface dst, Point dstOffset, Cairo.ImageSurface src, Point srcOffset, int roiLength)
{
Apply(dst.GetPointAddress(dstOffset), src.GetPointAddress(srcOffset), roiLength);
}
public unsafe void Render(Cairo.ImageSurface dst, Gdk.Point offset)
{
if (cr.ScaleFactor > new ScaleFactor(1, 2))
{
return;
}
int[] d2SLookupX = cr.Dst2SrcLookupX;
int[] d2SLookupY = cr.Dst2SrcLookupY;
int[] s2DLookupX = cr.Src2DstLookupX;
int[] s2DLookupY = cr.Src2DstLookupY;
ColorBgra[] blackAndWhite = new ColorBgra[2] {
ColorBgra.White, ColorBgra.Black
};
// draw horizontal lines
int dstHeight = dst.Height;
int dstWidth = dst.Width;
int dstStride = dst.Stride;
int sTop = d2SLookupY[offset.Y];
int sBottom = d2SLookupY[offset.Y + dstHeight];
dst.Flush();
for (int srcY = sTop; srcY <= sBottom; ++srcY)
{
int dstY = s2DLookupY[srcY];
int dstRow = dstY - offset.Y;
if (dstRow >= 0 && dstRow < dstHeight)
{
ColorBgra *dstRowPtr = dst.GetRowAddressUnchecked(dstRow);
ColorBgra *dstRowEndPtr = dstRowPtr + dstWidth;
dstRowPtr += offset.X & 1;
while (dstRowPtr < dstRowEndPtr)
{
*dstRowPtr = ColorBgra.Black;
dstRowPtr += 2;
}
}
}
// draw vertical lines
int sLeft = d2SLookupX[offset.X];
int sRight = d2SLookupX[offset.X + dstWidth];
for (int srcX = sLeft; srcX <= sRight; ++srcX)
{
int dstX = s2DLookupX[srcX];
int dstCol = dstX - offset.X;
if (dstCol >= 0 && dstCol < dstWidth)
{
byte *dstColPtr = (byte *)dst.GetPointAddress(dstCol, 0);
byte *dstColEndPtr = dstColPtr + dstStride * dstHeight;
dstColPtr += (offset.Y & 1) * dstStride;
while (dstColPtr < dstColEndPtr)
{
*((ColorBgra *)dstColPtr) = ColorBgra.Black;
dstColPtr += 2 * dstStride;
}
}
}
dst.MarkDirty();
}
