internal HistoryData(int Capacity, IColorType Color)
{
m_Color = Color.GetAsRGBA_Bytes();
m_Capacity = Capacity;
m_Data = new TwoSidedStack <double>();
Reset();
}
internal HistoryData(int capacity, IColorType lineColor)
{
this.lineColor = lineColor.GetAsRGBA_Bytes();
this.capacity = capacity;
data = new List <double>();
Reset();
}
internal HistoryData(int Capacity, IColorType Color)
{
m_Color = Color.GetAsRGBA_Bytes();
m_Capacity = Capacity;
m_Data = new TwoSidedStack<double>();
Reset();
}
public override void Render(IVertexSource vertexSource, int pathIndexToRender, IColorType colorIn)
{
PreRender();
if (DoEdgeAntiAliasing)
{
DrawAAShape(vertexSource, colorIn);
}
else
{
vertexSource.rewind(pathIndexToRender);
Affine transform = GetTransform();
if (!transform.is_identity())
{
vertexSource = new VertexSourceApplyTransform(vertexSource, transform);
}
RGBA_Bytes colorBytes = colorIn.GetAsRGBA_Bytes();
GL.Color4(colorBytes.red, colorBytes.green, colorBytes.blue, colorBytes.alpha);
renderNowTesselator.Clear();
VertexSourceToTesselator.SendShapeToTesselator(renderNowTesselator, vertexSource);
}
PopOrthoProjection();
}
internal HistoryData(int capacity, IColorType lineColor)
{
this.lineColor = lineColor.GetAsRGBA_Bytes();
this.capacity = capacity;
data = new List<double>();
Reset();
}
public override void Render(IVertexSource vertexSource, int pathIndexToRender, IColorType colorIn)
{
PushOrthoProjection();
GL.BlendFunc(BlendingFactorSrc.SrcAlpha, BlendingFactorDest.OneMinusSrcAlpha);
GL.Enable(EnableCap.Blend);
vertexSource.rewind(pathIndexToRender);
RGBA_Bytes colorBytes = colorIn.GetAsRGBA_Bytes();
GL.Color4(colorBytes.red, colorBytes.green, colorBytes.blue, colorBytes.alpha);
Affine transform = GetTransform();
if (!transform.is_identity())
{
vertexSource = new VertexSourceApplyTransform(vertexSource, transform);
}
if (DoEdgeAntiAliasing)
{
DrawAAShape(vertexSource);
}
else
{
renderNowTesselator.Clear();
Graphics2DOpenGL.SendShapeToTesselator(renderNowTesselator, vertexSource);
}
PopOrthoProjection();
}
//--------------------------------------------------------------------
public span_image_filter_rgb_bilinear_clip(IImageBufferAccessor src,
IColorType back_color,
ISpanInterpolator inter)
: base(src, inter, null)
{
m_OutsideSourceColor = back_color.GetAsRGBA_Bytes();
}
public void DrawAACircle(Vector2 start, double radius, IColorType colorIn)
{
RGBA_Bytes colorBytes = colorIn.GetAsRGBA_Bytes();
GL.Color4(colorBytes.red, colorBytes.green, colorBytes.blue, colorBytes.alpha);
Affine transform = GetTransform();
if (!transform.is_identity())
{
transform.transform(ref start);
}
// now draw the end rounds
int numSegments = 12;
double anglePerSegment = MathHelper.Tau / numSegments;
Vector2 currentOffset = new Vector2(0, radius);
Vector2 curveStart = start + currentOffset;
for (int i = 0; i < numSegments; i++)
{
currentOffset.Rotate(anglePerSegment);
Vector2 curveEnd = start + currentOffset;
triangleEddgeInfo.Draw1EdgeTriangle(curveStart, curveEnd, start);
curveStart = curveEnd;
}
}
public SpanImageFilterRGBABilinearClip(IRasterBufferAccessor src,
IColorType back_color, ISpanInterpolator inter) : base(src, inter, null)
{
m_back_color = back_color.GetAsRGBA_Bytes();
OrderR = src.PixelFormat.Blender.OrderR;
OrderG = src.PixelFormat.Blender.OrderG;
OrderB = src.PixelFormat.Blender.OrderB;
OrderA = src.PixelFormat.Blender.OrderA;
}
public override void OnDraw(Graphics2D graphics2D)
{
RoundedRect backgroundRect = new RoundedRect(LocalBounds, 4);
graphics2D.Render(backgroundRect, backgroundColor.GetAsRGBA_Bytes());
graphics2D.Render(new Stroke(backgroundRect), borderColor.GetAsRGBA_Bytes());
base.OnDraw(graphics2D);
}
public override void Clear(IColorType color)
{
Affine transform = GetTransform();
RoundedRect clearRect = new RoundedRect(new RectangleDouble(
cachedClipRect.Left - transform.tx, cachedClipRect.Bottom - transform.ty,
cachedClipRect.Right - transform.tx, cachedClipRect.Top - transform.ty), 0);
Render(clearRect, color.GetAsRGBA_Bytes());
}
public override void Clear(IColorType color)
{
Affine transform = GetTransform();
RoundedRect clearRect = new RoundedRect(new RectangleDouble(
0 - transform.tx, width - transform.ty,
0 - transform.tx, height - transform.ty), 0);
Render(clearRect, color.GetAsRGBA_Bytes());
}
public override void FillRectangle(double left, double bottom, double right, double top, IColorType fillColor)
{
// This only works for translation. If we have a rotation or scale in the transform this will have some problems.
Affine transform = GetTransform();
double fastLeft = left;
double fastBottom = bottom;
double fastRight = right;
double fastTop = top;
transform.transform(ref fastLeft, ref fastBottom);
transform.transform(ref fastRight, ref fastTop);
if (fastLeft == (int)fastLeft &&
fastBottom == (int)fastBottom &&
fastRight == (int)fastRight &&
fastTop == (int)fastTop)
{
PushOrthoProjection();
GL.Disable(EnableCap.Texture2D);
GL.BlendFunc(BlendingFactorSrc.SrcAlpha, BlendingFactorDest.OneMinusSrcAlpha);
GL.Enable(EnableCap.Blend);
GL.Color4(fillColor.Red0To255, fillColor.Green0To255, fillColor.Blue0To255, fillColor.Alpha0To255);
GL.Begin(BeginMode.Triangles);
// triangel 1
{
GL.Vertex2(fastLeft, fastBottom);
GL.Vertex2(fastRight, fastBottom);
GL.Vertex2(fastRight, fastTop);
}
// triangel 2
{
GL.Vertex2(fastLeft, fastBottom);
GL.Vertex2(fastRight, fastTop);
GL.Vertex2(fastLeft, fastTop);
}
GL.End();
PopOrthoProjection();
}
else
{
RoundedRect rect = new RoundedRect(left, bottom, right, top, 0);
Render(rect, fillColor.GetAsRGBA_Bytes());
}
}
public override void Render(IVertexSource vertexSource, int pathIndexToRender, IColorType colorBytes)
{
rasterizer.reset();
Affine transform = GetTransform();
if (!transform.is_identity())
{
vertexSource = new VertexSourceApplyTransform(vertexSource, transform);
}
rasterizer.add_path(vertexSource, pathIndexToRender);
if (destImageByte != null)
{
scanlineRenderer.RenderSolid(destImageByte, rasterizer, m_ScanlineCache, colorBytes.GetAsRGBA_Bytes());
DestImage.MarkImageChanged();
}
else
{
scanlineRenderer.RenderSolid(destImageFloat, rasterizer, m_ScanlineCache, colorBytes.GetAsRGBA_Floats());
destImageFloat.MarkImageChanged();
}
}
public void DrawAAShape(IVertexSource vertexSource, IColorType colorIn)
{
vertexSource.rewind(0);
Affine transform = GetTransform();
if (!transform.is_identity())
{
vertexSource = new VertexSourceApplyTransform(vertexSource, transform);
}
RGBA_Bytes colorBytes = colorIn.GetAsRGBA_Bytes();
GL.Color4(colorBytes.red, colorBytes.green, colorBytes.blue, colorBytes.alpha);
triangleEddgeInfo.Clear();
VertexSourceToTesselator.SendShapeToTesselator(triangleEddgeInfo, vertexSource);
// now render it
triangleEddgeInfo.RenderLastToGL();
}
public void DrawAALine(Vector2 start, Vector2 end, double halfWidth, IColorType colorIn)
{
RGBA_Bytes colorBytes = colorIn.GetAsRGBA_Bytes();
GL.Color4(colorBytes.red, colorBytes.green, colorBytes.blue, colorBytes.alpha);
Affine transform = GetTransform();
if (!transform.is_identity())
{
transform.transform(ref start);
transform.transform(ref end);
}
GL.Begin(BeginMode.Triangles);
Vector2 widthRightOffset = (end - start).GetPerpendicularRight().GetNormal() * halfWidth / 2;
triangleEddgeInfo.Draw2EdgeTriangle(start - widthRightOffset, end - widthRightOffset, end + widthRightOffset);
triangleEddgeInfo.Draw2EdgeTriangle(end + widthRightOffset, start + widthRightOffset, start - widthRightOffset);
GL.End();
}
public void DrawAALineRounded(Vector2 start, Vector2 end, double halfWidth, IColorType colorIn)
{
RGBA_Bytes colorBytes = colorIn.GetAsRGBA_Bytes();
GL.Color4(colorBytes.red, colorBytes.green, colorBytes.blue, colorBytes.alpha);
Affine transform = GetTransform();
if (!transform.is_identity())
{
transform.transform(ref start);
transform.transform(ref end);
}
//GL.Begin(BeginMode.Triangles);
Vector2 widthRightOffset = (end - start).GetPerpendicularRight().GetNormal() * halfWidth / 2;
// draw the main line part
triangleEddgeInfo.Draw1EdgeTriangle(start - widthRightOffset, end - widthRightOffset, end + widthRightOffset);
triangleEddgeInfo.Draw1EdgeTriangle(end + widthRightOffset, start + widthRightOffset, start - widthRightOffset);
// now draw the end rounds
int numSegments = 5;
Vector2 endCurveStart = end + widthRightOffset;
Vector2 startCurveStart = start + widthRightOffset;
for (int i = 0; i < numSegments + 1; i++)
{
Vector2 endCurveEnd = end + Vector2.Rotate(widthRightOffset, i * Math.PI / numSegments);
triangleEddgeInfo.Draw1EdgeTriangle(endCurveStart, endCurveEnd, end);
endCurveStart = endCurveEnd;
Vector2 startCurveEnd = start + Vector2.Rotate(widthRightOffset, -i * Math.PI / numSegments);
triangleEddgeInfo.Draw1EdgeTriangle(startCurveStart, startCurveEnd, start);
startCurveStart = startCurveEnd;
}
//GL.End();
}
public override void Clear(IColorType iColor)
{
RectangleDouble clippingRect = GetClippingRect();
RectangleInt clippingRectInt = new RectangleInt((int)clippingRect.Left, (int)clippingRect.Bottom, (int)clippingRect.Right, (int)clippingRect.Top);
if (DestImage != null)
{
RGBA_Bytes color = iColor.GetAsRGBA_Bytes();
int width = DestImage.Width;
int height = DestImage.Height;
byte[] buffer = DestImage.GetBuffer();
switch (DestImage.BitDepth)
{
case 8:
{
byte byteColor = (byte)iColor.Red0To255;
for (int y = clippingRectInt.Bottom; y < clippingRectInt.Top; y++)
{
int bufferOffset = DestImage.GetBufferOffsetXY((int)clippingRect.Left, y);
int bytesBetweenPixels = DestImage.GetBytesBetweenPixelsInclusive();
for (int x = 0; x < clippingRectInt.Width; x++)
{
buffer[bufferOffset] = color.blue;
bufferOffset += bytesBetweenPixels;
}
}
}
break;
case 24:
for (int y = clippingRectInt.Bottom; y < clippingRectInt.Top; y++)
{
int bufferOffset = DestImage.GetBufferOffsetXY((int)clippingRect.Left, y);
int bytesBetweenPixels = DestImage.GetBytesBetweenPixelsInclusive();
for (int x = 0; x < clippingRectInt.Width; x++)
{
buffer[bufferOffset + 0] = color.blue;
buffer[bufferOffset + 1] = color.green;
buffer[bufferOffset + 2] = color.red;
bufferOffset += bytesBetweenPixels;
}
}
break;
case 32:
{
for (int y = clippingRectInt.Bottom; y < clippingRectInt.Top; y++)
{
int bufferOffset = DestImage.GetBufferOffsetXY((int)clippingRect.Left, y);
int bytesBetweenPixels = DestImage.GetBytesBetweenPixelsInclusive();
for (int x = 0; x < clippingRectInt.Width; x++)
{
buffer[bufferOffset + 0] = color.blue;
buffer[bufferOffset + 1] = color.green;
buffer[bufferOffset + 2] = color.red;
buffer[bufferOffset + 3] = color.alpha;
bufferOffset += bytesBetweenPixels;
}
}
}
break;
default:
throw new NotImplementedException();
}
}
else // it is a float
{
if (DestImageFloat == null)
{
throw new Exception("You have to have either a byte or float DestImage.");
}
RGBA_Floats color = iColor.GetAsRGBA_Floats();
int width = DestImageFloat.Width;
int height = DestImageFloat.Height;
float[] buffer = DestImageFloat.GetBuffer();
switch (DestImageFloat.BitDepth)
{
case 128:
for (int y = 0; y < height; y++)
{
int bufferOffset = DestImageFloat.GetBufferOffsetXY(clippingRectInt.Left, y);
int bytesBetweenPixels = DestImageFloat.GetFloatsBetweenPixelsInclusive();
for (int x = 0; x < clippingRectInt.Width; x++)
{
buffer[bufferOffset + 0] = color.blue;
buffer[bufferOffset + 1] = color.green;
buffer[bufferOffset + 2] = color.red;
buffer[bufferOffset + 3] = color.alpha;
bufferOffset += bytesBetweenPixels;
}
}
break;
default:
throw new NotImplementedException();
}
}
}
public override void FillRectangle(double left, double bottom, double right, double top, IColorType fillColor)
{
RoundedRect rect = new RoundedRect(left, bottom, right, top, 0);
Render(rect, fillColor.GetAsRGBA_Bytes());
}
public override void Clear(IColorType color)
{
Affine transform = GetTransform();
RoundedRect clearRect = new RoundedRect(new RectangleDouble(
0 - transform.tx, width - transform.ty,
0 - transform.tx, height - transform.ty), 0);
Render(clearRect, color.GetAsRGBA_Bytes());
}
public void background_color(IColorType v) { m_OutsideSourceColor = v.GetAsRGBA_Bytes(); }
public void background_color(IColorType v)
{
m_back_color = v.GetAsRGBA_Bytes();
}
public override void Render(IVertexSource vertexSource, int pathIndexToRender, IColorType colorIn)
{
PreRender();
if (DoEdgeAntiAliasing)
{
DrawAAShape(vertexSource, colorIn);
}
else
{
vertexSource.rewind(pathIndexToRender);
Affine transform = GetTransform();
if (!transform.is_identity())
{
vertexSource = new VertexSourceApplyTransform(vertexSource, transform);
}
RGBA_Bytes colorBytes = colorIn.GetAsRGBA_Bytes();
GL.Color4(colorBytes.red, colorBytes.green, colorBytes.blue, colorBytes.alpha);
renderNowTesselator.Clear();
VertexSourceToTesselator.SendShapeToTesselator(renderNowTesselator, vertexSource);
}
PopOrthoProjection();
}
public void color(IColorType c)
{
m_color = c.GetAsRGBA_Bytes();
}
public override void FillRectangle(double left, double bottom, double right, double top, IColorType fillColor)
{
RoundedRect rect = new RoundedRect(left, bottom, right, top, 0);
Render(rect, fillColor.GetAsRGBA_Bytes());
}
public void active_color(IColorType c)
{
activeColor = c.GetAsRGBA_Bytes();
}
public void background_color(IColorType v)
{
m_OutsideSourceColor = v.GetAsRGBA_Bytes();
}
public override void Render(IVertexSource vertexSource, int pathIndexToRender, IColorType colorIn)
{
PushOrthoProjection();
GL.BlendFunc(BlendingFactorSrc.SrcAlpha, BlendingFactorDest.OneMinusSrcAlpha);
GL.Enable(EnableCap.Blend);
vertexSource.rewind(pathIndexToRender);
RGBA_Bytes colorBytes = colorIn.GetAsRGBA_Bytes();
GL.Color4(colorBytes.red, colorBytes.green, colorBytes.blue, colorBytes.alpha);
Affine transform = GetTransform();
if (!transform.is_identity())
{
vertexSource = new VertexSourceApplyTransform(vertexSource, transform);
}
if (DoEdgeAntiAliasing)
{
DrawAAShape(vertexSource);
}
else
{
renderNowTesselator.Clear();
Graphics2DOpenGL.SendShapeToTesselator(renderNowTesselator, vertexSource);
}
PopOrthoProjection();
}
//--------------------------------------------------------------------
public span_image_filter_rgb_bilinear_clip(IRasterBufferAccessor src,
IColorType back_color,
ISpanInterpolator inter)
: base(src, inter, null)
{
m_back_color = back_color.GetAsRGBA_Bytes();
OrderR = src.PixelFormat.Blender.OrderR;
OrderG = src.PixelFormat.Blender.OrderG;
OrderB = src.PixelFormat.Blender.OrderB;
OrderA = src.PixelFormat.Blender.OrderA;
}
public void DrawAACircle(Vector2 start, double radius, IColorType colorIn)
{
RGBA_Bytes colorBytes = colorIn.GetAsRGBA_Bytes();
GL.Color4(colorBytes.red, colorBytes.green, colorBytes.blue, colorBytes.alpha);
Affine transform = GetTransform();
if (!transform.is_identity())
{
transform.transform(ref start);
}
// now draw the end rounds
int numSegments = 12;
double anglePerSegment = MathHelper.Tau / numSegments;
Vector2 currentOffset = new Vector2(0, radius);
Vector2 curveStart = start + currentOffset;
for (int i = 0; i < numSegments; i++)
{
currentOffset.Rotate(anglePerSegment);
Vector2 curveEnd = start + currentOffset;
triangleEddgeInfo.Draw1EdgeTriangle(curveStart, curveEnd, start);
curveStart = curveEnd;
}
}
public span_image_filter_rgba_bilinear_clip(IImageBufferAccessor src,
IColorType back_color, ISpanInterpolator inter)
: base(src, inter, null)
{
m_OutsideSourceColor = back_color.GetAsRGBA_Bytes();
}
public void DrawAALineRounded(Vector2 start, Vector2 end, double halfWidth, IColorType colorIn)
{
RGBA_Bytes colorBytes = colorIn.GetAsRGBA_Bytes();
GL.Color4(colorBytes.red, colorBytes.green, colorBytes.blue, colorBytes.alpha);
Affine transform = GetTransform();
if (!transform.is_identity())
{
transform.transform(ref start);
transform.transform(ref end);
}
//GL.Begin(BeginMode.Triangles);
Vector2 widthRightOffset = (end - start).GetPerpendicularRight().GetNormal() * halfWidth / 2;
// draw the main line part
triangleEddgeInfo.Draw1EdgeTriangle(start - widthRightOffset, end - widthRightOffset, end + widthRightOffset);
triangleEddgeInfo.Draw1EdgeTriangle(end + widthRightOffset, start + widthRightOffset, start - widthRightOffset);
// now draw the end rounds
int numSegments = 5;
Vector2 endCurveStart = end + widthRightOffset;
Vector2 startCurveStart = start + widthRightOffset;
for (int i = 0; i < numSegments+1; i++)
{
Vector2 endCurveEnd = end + Vector2.Rotate(widthRightOffset, i * Math.PI / numSegments);
triangleEddgeInfo.Draw1EdgeTriangle(endCurveStart, endCurveEnd, end);
endCurveStart = endCurveEnd;
Vector2 startCurveEnd = start + Vector2.Rotate(widthRightOffset, -i * Math.PI / numSegments);
triangleEddgeInfo.Draw1EdgeTriangle(startCurveStart, startCurveEnd, start);
startCurveStart = startCurveEnd;
}
//GL.End();
}
//--------------------------------------------------------------------
public void Colors(IColorType c1, IColorType c2, IColorType c3)
{
m_coord[0].Color = c1.GetAsRGBA_Bytes();
m_coord[1].Color = c2.GetAsRGBA_Bytes();
m_coord[2].Color = c3.GetAsRGBA_Bytes();
}
public void background_color(IColorType v)
{
m_back_color = v.GetAsRGBA_Bytes();
}
public void DrawAALine(Vector2 start, Vector2 end, double halfWidth, IColorType colorIn)
{
RGBA_Bytes colorBytes = colorIn.GetAsRGBA_Bytes();
GL.Color4(colorBytes.red, colorBytes.green, colorBytes.blue, colorBytes.alpha);
Affine transform = GetTransform();
if (!transform.is_identity())
{
transform.transform(ref start);
transform.transform(ref end);
}
GL.Begin(BeginMode.Triangles);
Vector2 widthRightOffset = (end-start).GetPerpendicularRight().GetNormal() * halfWidth/2;
triangleEddgeInfo.Draw2EdgeTriangle(start - widthRightOffset, end - widthRightOffset, end + widthRightOffset);
triangleEddgeInfo.Draw2EdgeTriangle(end + widthRightOffset, start + widthRightOffset, start - widthRightOffset);
GL.End();
}
public void DrawAAShape(IVertexSource vertexSource, IColorType colorIn)
{
vertexSource.rewind(0);
Affine transform = GetTransform();
if (!transform.is_identity())
{
vertexSource = new VertexSourceApplyTransform(vertexSource, transform);
}
RGBA_Bytes colorBytes = colorIn.GetAsRGBA_Bytes();
GL.Color4(colorBytes.red, colorBytes.green, colorBytes.blue, colorBytes.alpha);
triangleEddgeInfo.Clear();
VertexSourceToTesselator.SendShapeToTesselator(triangleEddgeInfo, vertexSource);
// now render it
triangleEddgeInfo.RenderLastToGL();
}
public override void Clear(IColorType iColor)
{
RectangleDouble clippingRect = GetClippingRect();
RectangleInt clippingRectInt = new RectangleInt((int)clippingRect.Left, (int)clippingRect.Bottom, (int)clippingRect.Right, (int)clippingRect.Top);
if (DestImage != null)
{
RGBA_Bytes color = iColor.GetAsRGBA_Bytes();
int width = DestImage.Width;
int height = DestImage.Height;
byte[] buffer = DestImage.GetBuffer();
switch (DestImage.BitDepth)
{
case 8:
{
byte byteColor = (byte)iColor.Red0To255;
for (int y = clippingRectInt.Bottom; y < clippingRectInt.Top; y++)
{
int bufferOffset = DestImage.GetBufferOffsetXY((int)clippingRect.Left, y);
int bytesBetweenPixels = DestImage.GetBytesBetweenPixelsInclusive();
for (int x = 0; x < clippingRectInt.Width; x++)
{
buffer[bufferOffset] = color.blue;
bufferOffset += bytesBetweenPixels;
}
}
}
break;
case 24:
for (int y = clippingRectInt.Bottom; y < clippingRectInt.Top; y++)
{
int bufferOffset = DestImage.GetBufferOffsetXY((int)clippingRect.Left, y);
int bytesBetweenPixels = DestImage.GetBytesBetweenPixelsInclusive();
for (int x = 0; x < clippingRectInt.Width; x++)
{
buffer[bufferOffset + 0] = color.blue;
buffer[bufferOffset + 1] = color.green;
buffer[bufferOffset + 2] = color.red;
bufferOffset += bytesBetweenPixels;
}
}
break;
case 32:
{
for (int y = clippingRectInt.Bottom; y < clippingRectInt.Top; y++)
{
int bufferOffset = DestImage.GetBufferOffsetXY((int)clippingRect.Left, y);
int bytesBetweenPixels = DestImage.GetBytesBetweenPixelsInclusive();
for (int x = 0; x < clippingRectInt.Width; x++)
{
buffer[bufferOffset + 0] = color.blue;
buffer[bufferOffset + 1] = color.green;
buffer[bufferOffset + 2] = color.red;
buffer[bufferOffset + 3] = color.alpha;
bufferOffset += bytesBetweenPixels;
}
}
}
break;
default:
throw new NotImplementedException();
}
}
else // it is a float
{
if (DestImageFloat == null)
{
throw new Exception("You have to have either a byte or float DestImage.");
}
RGBA_Floats color = iColor.GetAsRGBA_Floats();
int width = DestImageFloat.Width;
int height = DestImageFloat.Height;
float[] buffer = DestImageFloat.GetBuffer();
switch (DestImageFloat.BitDepth)
{
case 128:
for (int y = 0; y < height; y++)
{
int bufferOffset = DestImageFloat.GetBufferOffsetXY(clippingRectInt.Left, y);
int bytesBetweenPixels = DestImageFloat.GetFloatsBetweenPixelsInclusive();
for (int x = 0; x < clippingRectInt.Width; x++)
{
buffer[bufferOffset + 0] = color.blue;
buffer[bufferOffset + 1] = color.green;
buffer[bufferOffset + 2] = color.red;
buffer[bufferOffset + 3] = color.alpha;
bufferOffset += bytesBetweenPixels;
}
}
break;
default:
throw new NotImplementedException();
}
}
}
public override void FillRectangle(double left, double bottom, double right, double top, IColorType fillColor)
{
// This only works for translation. If we have a rotation or scale in the transform this will have some problems.
Affine transform = GetTransform();
double fastLeft = left;
double fastBottom = bottom;
double fastRight = right;
double fastTop = top;
transform.transform(ref fastLeft, ref fastBottom);
transform.transform(ref fastRight, ref fastTop);
if (fastLeft == (int)fastLeft
&& fastBottom == (int)fastBottom
&& fastRight == (int)fastRight
&& fastTop == (int)fastTop)
{
PushOrthoProjection();
GL.Disable(EnableCap.Texture2D);
GL.BlendFunc(BlendingFactorSrc.SrcAlpha, BlendingFactorDest.OneMinusSrcAlpha);
GL.Enable(EnableCap.Blend);
GL.Color4(fillColor.Red0To255, fillColor.Green0To255, fillColor.Blue0To255, fillColor.Alpha0To255);
GL.Begin(BeginMode.Triangles);
// triangel 1
{
GL.Vertex2(fastLeft, fastBottom);
GL.Vertex2(fastRight, fastBottom);
GL.Vertex2(fastRight, fastTop);
}
// triangel 2
{
GL.Vertex2(fastLeft, fastBottom);
GL.Vertex2(fastRight, fastTop);
GL.Vertex2(fastLeft, fastTop);
}
GL.End();
PopOrthoProjection();
}
else
{
RoundedRect rect = new RoundedRect(left, bottom, right, top, 0);
Render(rect, fillColor.GetAsRGBA_Bytes());
}
}
public override void Render(IVertexSource vertexSource, int pathIndexToRender, IColorType colorBytes)
{
rasterizer.reset();
Affine transform = GetTransform();
if (!transform.is_identity())
{
vertexSource = new VertexSourceApplyTransform(vertexSource, transform);
}
rasterizer.add_path(vertexSource, pathIndexToRender);
if (destImageByte != null)
{
scanlineRenderer.RenderSolid(destImageByte, rasterizer, m_ScanlineCache, colorBytes.GetAsRGBA_Bytes());
DestImage.MarkImageChanged();
}
else
{
scanlineRenderer.RenderSolid(destImageFloat, rasterizer, m_ScanlineCache, colorBytes.GetAsRGBA_Floats());
destImageFloat.MarkImageChanged();
}
}
//--------------------------------------------------------------------
public void colors(IColorType c1, IColorType c2, IColorType c3)
{
m_coord[0].color = c1.GetAsRGBA_Bytes();
m_coord[1].color = c2.GetAsRGBA_Bytes();
m_coord[2].color = c3.GetAsRGBA_Bytes();
}
public void active_color(IColorType c)
{
activeColor = c.GetAsRGBA_Bytes();
}
public void FillRectangle(double left, double bottom, double right, double top, IColorType fillColor)
{
if (right < left || top < bottom)
{
throw new ArgumentException();
}
RoundedRect rect = new RoundedRect(left, bottom, right, top, 0);
Render(rect, fillColor.GetAsRGBA_Bytes());
}
