protected bool HandleMessage(Message message)
{
lock (Sync) switch (message.Opcode)
{
case 1: OnString?.Invoke(Encoding.UTF8.GetString(message.Payload)); return(true);
case 2: OnBinary?.Invoke(message.Payload); return(true);
case 8:
if (message.Length < 2)
{
FinishClose(); return(true);
}
ushort code = (ushort)(message.Payload[0] * 256 + message.Payload[1]);
string reason = Encoding.UTF8.GetString(PrimitiveBuffer.Slice(message.Payload, 2, message.Length));
if (RecvClose && message.Length > 2)
{
return(false);
}
if (message.Length > 2)
{
return(FinishClose(code, reason));
}
return(FinishClose(code));
case 9: OnPing?.Invoke(message.Payload); return(true);
case 10: OnPong?.Invoke(message.Payload); return(true);
default: return(false);
}
}
public void PerformLayout(RenderContext localRenderContext)
{
if (!_performLayout)
{
return;
}
_performLayout = false;
// Setup background brush
if (Background != null)
{
SizeF actualSize = new SizeF((float)ActualWidth, (float)ActualHeight);
RectangleF rect = new RectangleF(ActualPosition.X /*- 0.5f*/, ActualPosition.Y /*- 0.5f*/,
actualSize.Width /*+ 0.5f*/, actualSize.Height /*+ 0.5f*/);
PositionColoredTextured[] verts = new PositionColoredTextured[6];
verts[0].Position = new Vector3(rect.Left, rect.Top, 1.0f);
verts[1].Position = new Vector3(rect.Left, rect.Bottom, 1.0f);
verts[2].Position = new Vector3(rect.Right, rect.Bottom, 1.0f);
verts[3].Position = new Vector3(rect.Left, rect.Top, 1.0f);
verts[4].Position = new Vector3(rect.Right, rect.Top, 1.0f);
verts[5].Position = new Vector3(rect.Right, rect.Bottom, 1.0f);
Background.SetupBrush(this, ref verts, localRenderContext.ZOrder, true);
PrimitiveBuffer.SetPrimitiveBuffer(ref _backgroundContext, ref verts, PrimitiveType.TriangleList);
}
else
{
PrimitiveBuffer.DisposePrimitiveBuffer(ref _backgroundContext);
}
}
protected override bool BeginRenderBrushOverride(PrimitiveBuffer primitiveContext, RenderContext renderContext)
{
if (Texture == null)
{
return(false);
}
Matrix finalTransform = renderContext.Transform.Clone();
if (_refresh)
{
RefreshEffectParameters();
_effect = ContentManager.Instance.GetEffect(_simplemode ? EFFECT_TILE_SIMPLE : EFFECT_TILE);
_refresh = false;
}
if (_simplemode)
{
SetSimpleEffectParameters(renderContext);
}
else
{
SetEffectParameters(renderContext);
}
_effect.StartRender(Texture, finalTransform);
return(true);
}
protected override bool BeginRenderBrushOverride(PrimitiveBuffer primitiveContext, RenderContext renderContext)
{
ISharpDXVideoPlayer player;
if (!GetPlayer(out player))
{
return(false);
}
if (!RefreshEffectParameters(player))
{
return(false);
}
lock (player.SurfaceLock)
{
Texture texture = player.Texture;
if (texture == null)
{
return(false);
}
_texture = texture;
}
// Handling of multipass (3D) rendering, transformed rect contains the clipped area of the source image (i.e. left side in Side-By-Side mode).
RectangleF tranformedRect;
GraphicsDevice.RenderPipeline.GetVideoClip(_videoTextureClip, out tranformedRect);
return(_imageContext.StartRender(renderContext, _scaledVideoSize, _texture, tranformedRect, BorderColor, _lastFrameData));
}
void DeallocateCursor()
{
if (_cursorContext != null)
{
PrimitiveBuffer.DisposePrimitiveBuffer(ref _cursorContext);
}
}
void UpdateCursorShape(RectangleF cursorBounds, float zPos)
{
DeallocateCursor();
PositionColoredTextured[] verts = PositionColoredTextured.CreateQuad_Fan(
cursorBounds.Left /*- 0.5f*/, cursorBounds.Top /*- 0.5f*/, cursorBounds.Right /*- 0.5f*/, cursorBounds.Bottom /*- 0.5f*/,
0, 0, 0, 0, zPos, Color);
if (_cursorBrushInvalid && _cursorBrush != null)
{
_cursorBrush.Deallocate();
_cursorBrush.Dispose();
_cursorBrush = null;
}
if (_cursorBrush == null)
{
_cursorBrush = new SolidColorBrush {
Color = Color
}
}
;
_cursorBrushInvalid = false;
_cursorBrush.SetupBrush(this, ref verts, zPos, false);
PrimitiveBuffer.SetPrimitiveBuffer(ref _cursorContext, ref verts, PrimitiveType.TriangleFan);
_cursorShapeInvalid = false;
}
protected override bool BeginRenderBrushOverride(PrimitiveBuffer primitiveContext, RenderContext renderContext)
{
// Clear last context
_lastBeginContext = null;
bool result = false;
foreach (var brushContext in _brushContexts)
{
// We can only begin a new render pass if the previous ended
if (_lastBeginContext != null && brushContext.IsValid())
{
_lastBeginContext.Render(0);
_lastBeginContext.EndRender();
_lastBeginContext = null;
}
var currentResult = brushContext.BeginRenderBrushOverride(primitiveContext, renderContext);
result |= currentResult;
if (currentResult)
{
_lastBeginContext = brushContext;
}
}
return(result);
}
public SpriteBatch()
{
var accessor = Properties.Access();
var bufferCapacity = accessor.GetInt("sprite.batch.buffer.capacity");
var indexCapacity = accessor.GetInt("sprite.batch.index.capacity");
buffer = new PrimitiveBuffer(bufferCapacity, indexCapacity);
GLUtilities.AllocateBuffers(bufferCapacity, indexCapacity, out bufferId, out indexId, GL_DYNAMIC_DRAW);
// These two shaders (owned by the sprite batch) can be completed here (in terms of binding a buffer).
// External shaders are bound when first applied.
spriteShader = new Shader(bufferId, indexId);
spriteShader.Attach(ShaderTypes.Vertex, "Sprite.vert");
spriteShader.Attach(ShaderTypes.Fragment, "Sprite.frag");
spriteShader.AddAttribute <float>(2, GL_FLOAT);
spriteShader.AddAttribute <float>(2, GL_FLOAT);
spriteShader.AddAttribute <byte>(4, GL_UNSIGNED_BYTE, ShaderAttributeFlags.IsNormalized);
spriteShader.Initialize();
primitiveShader = new Shader(bufferId, indexId);
primitiveShader.Attach(ShaderTypes.Vertex, "Primitives2D.vert");
primitiveShader.Attach(ShaderTypes.Fragment, "Primitives.frag");
primitiveShader.AddAttribute <float>(2, GL_FLOAT);
primitiveShader.AddAttribute <byte>(4, GL_UNSIGNED_BYTE, ShaderAttributeFlags.IsNormalized);
primitiveShader.Initialize();
}
protected override bool BeginRenderBrushOverride(PrimitiveBuffer primitiveContext, RenderContext renderContext)
{
ISlimDXVideoPlayer player;
if (!GetPlayer(out player))
{
return(false);
}
if (!RefreshEffectParameters(player))
{
return(false);
}
lock (player.SurfaceLock)
{
Surface playerSurface = player.Surface;
if (playerSurface == null)
{
return(false);
}
DeviceEx device = SkinContext.Device;
SurfaceDescription desc = playerSurface.Description;
SurfaceDescription?textureDesc = _texture == null ? new SurfaceDescription?() : _texture.GetLevelDescription(0);
if (!textureDesc.HasValue || textureDesc.Value.Width != desc.Width || textureDesc.Value.Height != desc.Height)
{
TryDispose(ref _texture);
_texture = new Texture(device, desc.Width, desc.Height, 1, Usage.RenderTarget, Format.A8R8G8B8, Pool.Default);
}
using (Surface target = _texture.GetSurfaceLevel(0))
device.StretchRectangle(playerSurface, target, TextureFilter.None);
}
return(_imageContext.StartRender(renderContext, _scaledVideoSize, _texture, _videoTextureClip, BorderColor.ToArgb(), _lastFrameData));
}
protected void PerformLayoutBackground(RectangleF innerBorderRect, RenderContext context)
{
// Setup background brush
if (Background != null)
{
// TODO: Draw background only in the inner rectangle (outer rect minus BorderThickness)
using (GraphicsPath path = CreateBorderRectPath(innerBorderRect))
{
// Some backgrounds might not be closed (subclasses sometimes create open background shapes,
// for example GroupBox). To create a completely filled background, we need a closed figure.
path.CloseFigure();
PositionColoredTextured[] verts;
float centerX, centerY;
PointF[] pathPoints = path.PathPoints;
TriangulateHelper.CalcCentroid(pathPoints, out centerX, out centerY);
TriangulateHelper.FillPolygon_TriangleList(pathPoints, centerX, centerY, 1, out verts);
Background.SetupBrush(this, ref verts, context.ZOrder, true);
PrimitiveBuffer.SetPrimitiveBuffer(ref _backgroundContext, ref verts, PrimitiveType.TriangleList);
}
}
else
{
PrimitiveBuffer.DisposePrimitiveBuffer(ref _backgroundContext);
}
}
public SpriteBatch()
{
const int BufferCapacity = 30000;
const int IndexCapacity = 3000;
buffer = new PrimitiveBuffer(BufferCapacity, IndexCapacity);
GLUtilities.AllocateBuffers(BufferCapacity, IndexCapacity, out bufferId, out indexBufferId,
GL_DYNAMIC_DRAW);
// These two shaders (owned by the sprite batch) can be completed here (in terms of binding a buffer).
// External shaders are bound when first applied.
spriteShader = new Shader();
spriteShader.Attach(ShaderTypes.Vertex, "Sprite.vert");
spriteShader.Attach(ShaderTypes.Fragment, "Sprite.frag");
spriteShader.AddAttribute <float>(2, GL_FLOAT);
spriteShader.AddAttribute <float>(2, GL_FLOAT);
spriteShader.AddAttribute <byte>(4, GL_UNSIGNED_BYTE, false, true);
spriteShader.CreateProgram();
spriteShader.Bind(bufferId, indexBufferId);
primitiveShader = new Shader();
primitiveShader.Attach(ShaderTypes.Vertex, "Primitives2D.vert");
primitiveShader.Attach(ShaderTypes.Fragment, "Primitives.frag");
primitiveShader.CreateProgram();
primitiveShader.AddAttribute <float>(2, GL_FLOAT);
primitiveShader.AddAttribute <byte>(4, GL_UNSIGNED_BYTE, false, true);
primitiveShader.Bind(bufferId, indexBufferId);
MessageSystem.Subscribe(this, CoreMessageTypes.ResizeWindow, (messageType, data, dt) => { OnResize(); });
}
public bool BeginRenderBrush(PrimitiveBuffer primitiveContext, RenderContext renderContext)
{
if (_vertsBounds.IsEmpty)
{
return(false);
}
return(BeginRenderBrushOverride(primitiveContext, renderContext));
}
protected override bool BeginRenderBrushOverride(PrimitiveBuffer primitiveContext, RenderContext renderContext)
{
Allocate();
if (_tex != null)
{
_tex.Bind(0);
}
return(base.BeginRenderBrushOverride(primitiveContext, renderContext));
}
public static byte[] FlipMask(byte[] payload, byte[] mask)
{
byte[] copied = PrimitiveBuffer.Slice(payload, 0, (ulong)payload.LongLength);
for (long i = 0; i < copied.LongLength; i++)
{
copied[i] ^= mask[i & 3];
}
return(copied);
}
// Allocate/Deallocate of Children not necessary because UIElement handles all direct children
public override void Deallocate()
{
base.Deallocate();
if (Background != null)
{
Background.Deallocate();
}
PrimitiveBuffer.DisposePrimitiveBuffer(ref _backgroundContext);
}
public virtual ulong Read(byte[] destination, ulong start = 0)
{
lock (Sync)
{
ulong length = Math.Min(BufferedReadable, (ulong)destination.LongLength);
byte[] data = Readable.Read(length);
PrimitiveBuffer.Copy(data, 0, destination, start, length);
ReadCount += length;
return(length);
}
}
public virtual ulong Read(byte[] destination, ulong start = 0)
{
lock (Sync)
{
ulong length = BufferedReadable;
byte[] data = Buffer.Read(length);
PrimitiveBuffer.Copy(data, 0, destination, start, length);
ReadCount += length;
return(length);
}
}
protected override bool BeginRenderBrushOverride(PrimitiveBuffer primitiveBuffer, RenderContext renderContext)
{
Matrix finalTransform = renderContext.Transform.Clone();
Color4 v = ColorConverter.FromColor(Color);
v.Alpha *= (float)(Opacity * renderContext.Opacity);
_effect = ContentManager.Instance.GetEffect(EFFECT_SOLID);
_effect.Parameters[PARAM_SOLIDCOLOR] = v;
_effect.StartRender(finalTransform);
return(true);
}
public PrimitiveRenderer3D(Camera3D camera = null, uint bufferCapacity = 0, uint indexCapacity = 0)
{
this.camera = camera;
buffer = new PrimitiveBuffer(BufferFrequencies.Static, BufferUsages.Draw, out bufferId, out indexId,
bufferCapacity, indexCapacity);
defaultShader = new Shader(bufferId, indexId);
defaultShader.Attach(ShaderTypes.Vertex, "Primitives3D.vert");
defaultShader.Attach(ShaderTypes.Fragment, "Primitives.frag");
defaultShader.AddAttribute <float>(3, GL_FLOAT);
defaultShader.AddAttribute <byte>(4, GL_UNSIGNED_BYTE, true);
defaultShader.Initialize();
}
protected override bool BeginRenderBrushOverride(PrimitiveBuffer primitiveContext, RenderContext renderContext)
{
FrameworkElement fe = _preparedVisual;
if (fe == null)
{
return(false);
}
_visualTexture.AllocateRenderTarget((int)_vertsBounds.Width, (int)_vertsBounds.Height);
UpdateRenderTarget(fe);
return(base.BeginRenderBrushOverride(primitiveContext, renderContext));
}
public override void Deallocate()
{
base.Deallocate();
if (Fill != null)
{
Fill.Deallocate();
}
if (Stroke != null)
{
Stroke.Deallocate();
}
PrimitiveBuffer.DisposePrimitiveBuffer(ref _fillContext);
PrimitiveBuffer.DisposePrimitiveBuffer(ref _strokeContext);
}
private void RunSetGeometryInstanceToMainShader(int count,
ref TopLevelAccelerationBuffer bvhBuffer,
ref SortedList <ISIdx, ObjectLevelAccelerationGeometryBuffer> objectLvAccGeoBuffers,
ref SortedList <ISIdx, ObjectLevelAccelerationGeometryMappingCollectionBuffer> objectLvAccGeoMapBuffers,
ref PrimitiveBuffer primitiveBuffer,
ref WorldToLocalBuffer worldToPrimitiveBuffer,
string[] intersectShaderNames,
ref SortedList <ISIdx, GeometryInstanceBuffer> geoInsBuffers,
ref TopLevelAccelerationGeometryMappingCollectionBuffer topLevelAccGeoMapColBuffer)
{
m_mainShader.SetInt("_NumOfPrimitive", count);
m_mainShader.SetBuffer(kIndex, "_Primitives", primitiveBuffer);
m_mainShader.SetBuffer(kIndex, "_WorldToPrimitives", worldToPrimitiveBuffer);
m_mainShader.SetBuffer(kIndex, "_BVHTree", bvhBuffer);
m_mainShader.SetBuffer(kIndex, "_TopLevelAccelerationGeometryMapping", topLevelAccGeoMapColBuffer);
empty = new ComputeBuffer(1, sizeof(float));
for (int intersectIdx = 0; intersectIdx < intersectShaderNames.Length; intersectIdx++)
{
if (geoInsBuffers.ContainsKey(intersectIdx))
{
m_mainShader.SetBuffer(kIndex, $"_{intersectShaderNames[intersectIdx]}", geoInsBuffers[intersectIdx]);
}
else
{
m_mainShader.SetBuffer(kIndex, $"_{intersectShaderNames[intersectIdx]}", empty);
}
}
// -
// -
// -
// -
// -
var objectLvAccGeoBuffersIter = objectLvAccGeoBuffers.GetEnumerator();
while (objectLvAccGeoBuffersIter.MoveNext())
{
m_mainShader.SetBuffer(kIndex, $"_{intersectShaderNames[objectLvAccGeoBuffersIter.Current.Key]}GeometryData", objectLvAccGeoBuffersIter.Current.Value);
}
var objectLvAccGeoMapBuffersIter = objectLvAccGeoMapBuffers.GetEnumerator();
while (objectLvAccGeoMapBuffersIter.MoveNext())
{
m_mainShader.SetBuffer(kIndex, $"_{intersectShaderNames[objectLvAccGeoMapBuffersIter.Current.Key]}GeometryMapping", objectLvAccGeoMapBuffersIter.Current.Value);
}
}
protected override bool BeginRenderBrushOverride(PrimitiveBuffer primitiveContext, RenderContext renderContext)
{
if (_gradientBrushTexture == null || _refresh)
{
_gradientBrushTexture = BrushCache.Instance.GetGradientBrush(GradientStops);
if (_gradientBrushTexture == null)
{
return(false);
}
}
Matrix finalTransform = renderContext.Transform.Clone();
if (_refresh)
{
_refresh = false;
_gradientBrushTexture = BrushCache.Instance.GetGradientBrush(GradientStops);
_effect = ContentManager.Instance.GetEffect("radialgradient");
g_focus = new float[] { GradientOrigin.X, GradientOrigin.Y };
g_center = new float[] { Center.X, Center.Y };
g_radius = new float[] { (float)RadiusX, (float)RadiusY };
if (MappingMode == BrushMappingMode.Absolute)
{
g_focus[0] /= _vertsBounds.Width;
g_focus[1] /= _vertsBounds.Height;
g_center[0] /= _vertsBounds.Width;
g_center[1] /= _vertsBounds.Height;
g_radius[0] /= _vertsBounds.Width;
g_radius[1] /= _vertsBounds.Height;
}
g_relativetransform = RelativeTransform == null ? Matrix.Identity : Matrix.Invert(RelativeTransform.GetTransform());
}
_effect.Parameters[PARAM_RELATIVE_TRANSFORM] = g_relativetransform;
_effect.Parameters[PARAM_TRANSFORM] = GetCachedFinalBrushTransform();
_effect.Parameters[PARAM_FOCUS] = g_focus;
_effect.Parameters[PARAM_CENTER] = g_center;
_effect.Parameters[PARAM_RADIUS] = g_radius;
_effect.Parameters[PARAM_OPACITY] = (float)(Opacity * renderContext.Opacity);
GraphicsDevice.Device.SetSamplerState(0, SamplerState.AddressU, SpreadAddressMode);
_effect.StartRender(_gradientBrushTexture.Texture, finalTransform);
return(true);
}
// Allocation/Deallocation of _initializedContent not necessary because UIElement handles all direct children
public override void Deallocate()
{
base.Deallocate();
if (BorderBrush != null)
{
BorderBrush.Deallocate();
}
if (Background != null)
{
Background.Deallocate();
}
_performLayout = true;
PrimitiveBuffer.DisposePrimitiveBuffer(ref _backgroundContext);
PrimitiveBuffer.DisposePrimitiveBuffer(ref _borderContext);
}
public PrimitiveRenderer3D(Camera3D camera, int bufferSize, int indexSize)
{
this.camera = camera;
buffer = new PrimitiveBuffer(bufferSize, indexSize);
GLUtilities.AllocateBuffers(bufferSize, indexSize, out bufferId, out indexId, GL_DYNAMIC_DRAW);
shader = new Shader(bufferId, indexId);
shader.Attach(ShaderTypes.Vertex, "Primitives3D.vert");
shader.Attach(ShaderTypes.Fragment, "Primitives.frag");
shader.AddAttribute <float>(3, GL_FLOAT);
shader.AddAttribute <byte>(4, GL_UNSIGNED_BYTE, ShaderAttributeFlags.IsNormalized);
shader.Initialize();
}
protected override bool BeginRenderBrushOverride(PrimitiveBuffer primitiveContext, RenderContext renderContext)
{
if (_gradientBrushTexture == null || _refresh)
{
_gradientBrushTexture = BrushCache.Instance.GetGradientBrush(GradientStops);
if (_gradientBrushTexture == null)
{
return(false);
}
}
Matrix finalTransform = renderContext.Transform.Clone();
if (_refresh)
{
_refresh = false;
_effect = ContentManager.Instance.GetEffect(EFFECT_LINEARGRADIENT);
g_startpoint = new float[] { StartPoint.X, StartPoint.Y };
g_endpoint = new float[] { EndPoint.X, EndPoint.Y };
if (MappingMode == BrushMappingMode.Absolute)
{
g_startpoint[0] /= _vertsBounds.Width;
g_startpoint[1] /= _vertsBounds.Height;
g_endpoint[0] /= _vertsBounds.Width;
g_endpoint[1] /= _vertsBounds.Height;
}
g_framesize = new float[] { _vertsBounds.Width, _vertsBounds.Height };
if (RelativeTransform != null)
{
Matrix m = RelativeTransform.GetTransform();
m.Transform(ref g_startpoint[0], ref g_startpoint[1]);
m.Transform(ref g_endpoint[0], ref g_endpoint[1]);
}
}
_effect.Parameters[PARAM_FRAMESIZE] = g_framesize;
_effect.Parameters[PARAM_TRANSFORM] = GetCachedFinalBrushTransform();
_effect.Parameters[PARAM_OPACITY] = (float)(Opacity * renderContext.Opacity);
_effect.Parameters[PARAM_STARTPOINT] = g_startpoint;
_effect.Parameters[PARAM_ENDPOINT] = g_endpoint;
GraphicsDevice.Device.SetSamplerState(0, SamplerState.AddressU, SpreadAddressMode);
_effect.StartRender(_gradientBrushTexture.Texture, finalTransform);
return(true);
}
public string ReadStringZT(Encoding encoding, byte size)
{
PrimitiveBuffer buffer = new PrimitiveBuffer();
ulong block = size / 8u;
while (true)
{
byte[] read = NonBlockingUnsafeRead(block);
if (read == null || read.All((v) => v == 0))
{
break;
}
buffer.Write(read);
}
return(encoding.GetString(buffer.Read(buffer.Length)));
}
public bool BeginRenderBrushOverride(PrimitiveBuffer primitiveContext, RenderContext renderContext)
{
_primitiveContext = primitiveContext;
_renderStarted = false;
if (!IsValid())
{
return(false);
}
_renderStarted = true;
// Handling of multipass (3D) rendering, transformed rect contains the clipped area of the source image (i.e. left side in Side-By-Side mode).
RectangleF tranformedRect;
GraphicsDevice.RenderPipeline.GetVideoClip(_videoTextureClip, out tranformedRect);
return(_imageContext.StartRender(renderContext, _scaledVideoSize, _texture, tranformedRect, _parentBrush.BorderColor, _lastFrameData));
}
private void RunLoadGeometryToBuffer(SceneParseResult sceneParseResult,
ref TopLevelAccelerationBuffer topLevelAcc,
ref SortedList <ISIdx, ObjectLevelAccelerationGeometryBuffer> objectLvAccGeoBuffers,
ref SortedList <ISIdx, ObjectLevelAccelerationGeometryMappingCollectionBuffer> objectLvAccGeoMapBuffers,
ref PrimitiveBuffer primitiveBuffer,
ref WorldToLocalBuffer worldToPrimitiveBuffer,
ref SortedList <ISIdx, GeometryInstanceBuffer> gemoetryInstanceBuffers,
ref TopLevelAccelerationGeometryMappingCollectionBuffer topLevelAccGeoMap)
{
LoadBufferWithGeometryInstances(sceneParseResult,
bvhBuffer: ref topLevelAcc,
objectLvAccGeoBuffers: ref objectLvAccGeoBuffers,
objectLvAccGeoMapBuffers: ref objectLvAccGeoMapBuffers,
primitiveBuffer: ref primitiveBuffer,
worldToPrimitiveBuffer: ref worldToPrimitiveBuffer,
gemoetryInstanceBuffers: ref gemoetryInstanceBuffers,
topLevelAccGeoMapColBuffer: ref topLevelAccGeoMap);
}
protected override void DoPerformLayout(RenderContext context)
{
base.DoPerformLayout(context);
// Setup brushes
if (Fill != null || (Stroke != null && StrokeThickness > 0))
{
using (GraphicsPath path = CreateRectanglePath(_innerRect))
{
if (path.PointCount == 0)
{
return;
}
PointF[] pathPoints = path.PathPoints;
PositionColoredTextured[] verts;
float centerX = _innerRect.Width / 2 + _innerRect.Left;
float centerY = _innerRect.Height / 2 + _innerRect.Top;
if (Fill != null)
{
TriangulateHelper.FillPolygon_TriangleList(pathPoints, centerX, centerY, 1, out verts);
Fill.SetupBrush(this, ref verts, context.ZOrder, true);
PrimitiveBuffer.SetPrimitiveBuffer(ref _fillContext, ref verts, PrimitiveType.TriangleList);
}
else
{
PrimitiveBuffer.DisposePrimitiveBuffer(ref _fillContext);
}
if (Stroke != null && StrokeThickness > 0)
{
TriangulateHelper.TriangulateStroke_TriangleList(pathPoints, (float)StrokeThickness, true, 1, StrokeLineJoin, out verts);
Stroke.SetupBrush(this, ref verts, context.ZOrder, true);
PrimitiveBuffer.SetPrimitiveBuffer(ref _strokeContext, ref verts, PrimitiveType.TriangleList);
}
else
{
PrimitiveBuffer.DisposePrimitiveBuffer(ref _strokeContext);
}
}
}
}
