public VectorInkStroke(Stroke stroke, Wacom.Ink.Geometry.VectorBrush vectorBrush, PipelineData pipelineData)
{
Id = stroke.Id;
PathPointProperties ppp = stroke.Style.PathPointProperties;
Color = MediaColor.FromArgb(
ppp.Alpha.HasValue ? (byte)(ppp.Alpha * 255.0f) : byte.MinValue,
ppp.Red.HasValue ? (byte)(ppp.Red * 255.0f) : byte.MinValue,
ppp.Green.HasValue ? (byte)(ppp.Green * 255.0f) : byte.MinValue,
ppp.Blue.HasValue ? (byte)(ppp.Blue * 255.0f) : byte.MinValue);
Spline = stroke.Spline;
Layout = stroke.Layout;
VectorBrush = vectorBrush;
Polygon = PolygonUtil.ConvertPolygon(pipelineData.Merged.Addition);
SimplPoly = pipelineData.Merged.Addition;
SensorDataOffset = stroke.SensorDataOffset;
SensorDataMappings = stroke.SensorDataMappings;
SensorDataId = stroke.SensorDataId;
Attributes attribs = new Attributes(Color);
if (ppp.Size.HasValue)
{
attribs.Size = ppp.Size.Value;
}
Constants = attribs;
}
public void UpdateSpline(Spline newSpline)
{
var result = mInkBuilder.AddWholePath(newSpline, Layout, VectorBrush);
Spline = newSpline;
SimplPoly = result.Merged.Addition;
Polygon = PolygonUtil.ConvertPolygon(SimplPoly);
}
private void OnSpatialModelStrokeAdded(object sender, IInkStroke stroke)
{
VectorSplineInkBuilder inkBuilder = new VectorSplineInkBuilder();
var result = inkBuilder.AddWholePath(stroke.Spline, stroke.Layout, stroke.VectorBrush);
var vectStroke = (VectorInkStroke)stroke;
vectStroke.SimplPoly = result.Merged.Addition;
vectStroke.Polygon = PolygonUtil.ConvertPolygon(vectStroke.SimplPoly);
lock (mDryStrokeLock)
{
mDryStrokes.Add(vectStroke);
}
}
protected override void RenderNewStrokeSegment()
{
ProcessorResult <List <PolygonVertices> > result;
lock (mInkBuilderLock)
{
if (mInkBuilder.HasNewPoints)
{
result = mInkBuilder.GetPolygons();
if (result.Addition == null || result.Prediction == null)
{
return;
}
}
else
{
return;
}
}
PolygonUtil.ConvertPolygon(result.Addition, mAddedPolygon);
PolygonUtil.ConvertPolygon(result.Prediction, mPredictedPolygon);
// Draw the added stroke
mRenderingContext.SetTarget(mCurrentStrokeLayer);
Rect addedStrokeRect = mRenderingContext.FillPolygon(mAddedPolygon, BrushColor, Wacom.Ink.Rendering.BlendMode.Max);
// Measure the predicted stroke
Rect predictedStrokeRect = mRenderingContext.MeasurePolygonBounds(mPredictedPolygon);
// Calculate the rect for this frame
Rect updateRect = mDirtyRectManager.GetUpdateRect(addedStrokeRect, predictedStrokeRect);
// Draw the predicted stroke
mRenderingContext.SetTarget(mPrelimPathLayer);
mRenderingContext.DrawLayerAtPoint(mCurrentStrokeLayer, updateRect, new Point(updateRect.X, updateRect.Y), Wacom.Ink.Rendering.BlendMode.Copy);
mRenderingContext.FillPolygon(mPredictedPolygon, BrushColor, Wacom.Ink.Rendering.BlendMode.Max);
// Reconstruct the scene under the current stroke (only within the updated rect)
mRenderingContext.SetTarget(mSceneLayer, updateRect);
mRenderingContext.ClearColor(BackgroundColor);
mRenderingContext.DrawLayerAtPoint(mAllStrokesLayer, updateRect, new Point(updateRect.X, updateRect.Y), Wacom.Ink.Rendering.BlendMode.SourceOver);
// Blend the current stroke on top (only within the updated rect)
mRenderingContext.DrawLayerAtPoint(mPrelimPathLayer, updateRect, new Point(updateRect.X, updateRect.Y), Wacom.Ink.Rendering.BlendMode.SourceOver);
}
protected override void StoreCurrentStroke(string pointerDeviceType)
{
var polygons = mInkBuilder.PolygonSimplifier.AllData;
var mergedPolygons = PolygonUtils.MergePolygons(polygons);
Wacom.Ink.Rendering.Polygon polygon = PolygonUtil.ConvertPolygon(mergedPolygons);
mDryStrokes.Add(new DryStroke {
mPolygon = polygon, mColor = BrushColor
});
mRenderingContext.SetTarget(mAllStrokesLayer);
mRenderingContext.DrawLayer(mCurrentStrokeLayer, null, Wacom.Ink.Rendering.BlendMode.SourceOver);
mRenderingContext.SetTarget(mCurrentStrokeLayer);
mRenderingContext.ClearColor(Colors.Transparent);
mDirtyRectManager.Reset();
mSerializer.EncodeCurrentStroke(pointerDeviceType, mInkBuilder, BrushColor);
}
private DryStroke CreateDryStrokeFromVectorBrush(DecodedVectorInkBuilder decodedVectorInkBuilder, Wacom.Ink.Serialization.Model.VectorBrush vectorBrush, Stroke stroke)
{
Wacom.Ink.Geometry.VectorBrush vb;
if (vectorBrush.BrushPolygons.Count > 0)
{
vb = new Wacom.Ink.Geometry.VectorBrush(vectorBrush.BrushPolygons.ToArray());
}
else if (vectorBrush.BrushPrototypeURIs.Count > 0)
{
List <BrushPolygon> brushPolygons = new List <BrushPolygon>(vectorBrush.BrushPrototypeURIs.Count);
foreach (var uri in vectorBrush.BrushPrototypeURIs)
{
brushPolygons.Add(new BrushPolygon(uri.MinScale, ShapeUriResolver.ResolveShape(uri.ShapeUri)));
}
vb = new Wacom.Ink.Geometry.VectorBrush(brushPolygons.ToArray());
}
else
{
throw new ArgumentException("Missing vector brush information! Expected BrushPolygons, BrushPolyhedrons or BrushPrototypeURIs.");
}
var result = decodedVectorInkBuilder.AddWholePath(stroke.Spline, stroke.Layout, vb);
var ppp = stroke.Style.PathPointProperties;
DryStroke dryStroke = new DryStroke
{
mPolygon = PolygonUtil.ConvertPolygon(result.Addition),
mColor = MediaColor.FromArgb(
ppp.Alpha.HasValue ? (byte)(ppp.Alpha * 255.0f) : byte.MinValue,
ppp.Red.HasValue ? (byte)(ppp.Red * 255.0f) : byte.MinValue,
ppp.Green.HasValue ? (byte)(ppp.Green * 255.0f) : byte.MinValue,
ppp.Blue.HasValue ? (byte)(ppp.Blue * 255.0f) : byte.MinValue)
};
return(dryStroke);
}
