public override void OnPointerMoved(DesignCanvas canvas, PointerRoutedEventArgs args)
{
base.OnPointerMoved(canvas, args);
if (_origin.HasValue)
{
var pos = canvas.FromClientPosition(args.GetCurrentPoint(canvas).Position);
if (args.KeyModifiers.HasFlag(VirtualKeyModifiers.Shift))
{
pos = ClampToOrigin(pos, _origin.Value);
}
if (_shouldMoveOrigin)
{
_origin = new Point(
_origin.Value.X + pos.X - _anchor.X,
_origin.Value.Y + pos.Y - _anchor.Y);
}
_anchor = pos;
_points = Slicing.IntersectPaths(canvas.Layer, _origin.Value.ToVector2(), _anchor.ToVector2());
canvas.Invalidate();
}
Cursor = args.KeyModifiers.HasFlag(VirtualKeyModifiers.Menu) ? Cursors.KnifeWithPlus : DefaultCursor;
canvas.InvalidateCursor();
}
private void PointSlice(Vector2 pos)
{
float rotation = 0;
switch (sliceRotation)
{
case SliceRotation.Random:
rotation = UnityEngine.Random.Range(0, Mathf.PI * 2);
break;
case SliceRotation.Vertical:
rotation = Mathf.PI / 2f;
break;
case SliceRotation.Horizontal:
rotation = Mathf.PI;
break;
}
List <Slice2D> results = Slicing.PointSliceAll(pos.ToVector2D(), rotation, sliceLayer);
foreach (Slice2D id in results)
{
eventHandler.Perform(id);
}
}
private bool LinearSlice(Pair2D slice)
{
if (sliceJoints)
{
Slicer2D.Controller.Joints.LinearSliceJoints(slice);
}
List <Slice2D> results = Slicing.LinearSliceAll(slice, sliceLayer);
bool result = false;
foreach (Slice2D id in results)
{
if (id.GetGameObjects().Count > 0)
{
result = true;
}
eventHandler.Perform(id);
}
if (addForce == true)
{
foreach (Slice2D id in results)
{
AddForce.LinearSlice(id, addForceAmount);
}
}
return(result);
}
public void Update(Vector2 pos)
{
float scroll = UnityEngine.Input.GetAxis("Mouse ScrollWheel");
float newCutSize = cutSize + scroll;
if (newCutSize > 0.05f)
{
cutSize = newCutSize;
}
if (input.GetInputClicked())
{
linearPair.a = pos;
}
if (input.GetInputHolding())
{
linearPair.b = pos;
}
if (input.GetInputReleased())
{
LinearCut linearCutLine = LinearCut.Create(linearPair, cutSize * visuals.visualScale);
Slicing.LinearCutSliceAll(linearCutLine, sliceLayer);
}
}
private void PolygonSlice(Vector2 pos)
{
Polygon2D.defaultCircleVerticesCount = edgeCount;
Polygon2D slicePolygon = Polygon2D.Create(polygonType, polygonSize * visuals.visualScale);
Slicing.PolygonSliceAll(pos.ToVector2D(), slicePolygon, polygonDestroy, sliceLayer);
}
public void Draw(Transform transform)
{
if (input.GetVisualsEnabled() == false)
{
return;
}
visuals.Clear();
for (int id = 0; id < 10; id++)
{
if (input.GetInputHolding(id))
{
if (startSliceIfPossible == false || startedSlice == true)
{
Pair2 pair = linearPair[id];
if (autocompleteDisplay)
{
pair = GetPair(id);
}
// If Stripped Line
if (strippedLinear)
{
Vector2List linearPoints = GetLinearVertices(pair, minVertexDistance * visuals.visualScale);
if (linearPoints.Count() > 1)
{
visuals.GenerateComplexMesh(linearPoints);
}
}
else
{
visuals.GenerateLinearMesh(pair);
}
if (displayCollisions)
{
List <Slice2D> results = Slicing.LinearSliceAll(linearPair[id].ToPair2D(), sliceLayer, false);
foreach (Slice2D slice in results)
{
foreach (Vector2D collision in slice.GetCollisions())
{
Pair2 p = new Pair2(collision.ToVector2(), collision.ToVector2());
visuals.GenerateLinearMesh(p);
}
}
}
}
}
}
visuals.Draw();
return;
}
static void Main(string[] args)
{
Slicing.Run();
MemoryAndOwnership.Run();
UnmanagedHeap.Run();
StackAndHeap.Run();
RefStructs.Run();
UsageOfMySpan.Run();
}
internal void InjectSlice(Element element)
{
Slicing slicing = GetSlicingForElement(element);
if (slicing != null)
{
element.Discriminator = slicing.Discriminator;
element.Slice = ++slicing.Count;
}
}
private void HarvestSlicing(Element target)
{
Slicing slicing = GetSlicingForElement(target);
if (slicing != null)
{
target.Discriminator = slicing.Discriminator;
target.Slice = ++slicing.Count;
}
}
IList <Vector2> GetPointsWithEndpoints(Data.Layer layer, bool addIntersections = true)
{
var origin = _origin.Value.ToVector2();
var anchor = _anchor.ToVector2();
return(addIntersections switch
{
true => Enumerable.Concat(Slicing.IntersectPaths(layer, origin, anchor), new Vector2[] { origin, anchor })
.OrderBy(point => (point - origin).LengthSquared())
.ToArray(),
false => new Vector2[] { origin, anchor }
});
public override void OnPointerReleased(DesignCanvas canvas, PointerRoutedEventArgs args)
{
if (_points != null)
{
var layer = canvas.Layer;
layer.ClearSelection();
Slicing.SlicePaths(layer, _origin.Value.ToVector2(), _anchor.ToVector2(),
breakPaths: !args.KeyModifiers.HasFlag(VirtualKeyModifiers.Menu));
}
base.OnPointerReleased(canvas, args);
}
public void Update(Vector2 pos)
{
float scroll = UnityEngine.Input.GetAxis("Mouse ScrollWheel");
float newCutSize = cutSize + scroll;
if (newCutSize > 0.05f)
{
cutSize = newCutSize;
}
if (input.GetInputClicked())
{
pointsList.Clear();
pointsList.Add(new Vector2D(pos));
}
if (pointsList.Count < 1)
{
return;
}
if (input.GetInputHolding())
{
Vector2 posMove = pointsList.Last().ToVector2();
int loopCount = 0;
while ((Vector2.Distance(posMove, pos) > minVertexDistance * visuals.visualScale))
{
float direction = (float)Vector2D.Atan2(pos, posMove);
posMove = posMove.Push(direction, minVertexDistance * visuals.visualScale);
pointsList.Add(new Vector2D(posMove));
loopCount++;
if (loopCount > 150)
{
break;
}
}
}
if (input.GetInputReleased())
{
ComplexCut complexCutLine = ComplexCut.Create(GetList(), cutSize * visuals.visualScale);
Slicing.ComplexCutSliceAll(complexCutLine, sliceLayer);
pointsList.Clear();
}
}
public void PrepareSlices(Hl7.Fhir.Model.StructureDefinition source)
{
if (source.Snapshot == null)
{
throw Error.Argument("source", "Structure must have a differential representation");
}
foreach (Hl7.Fhir.Model.ElementDefinition e in source.Snapshot.Element)
{
if (e.Slicing != null)
{
Slicing s = PrepareSlice(e);
Slicings.Add(s);
}
}
}
public void Slice()
{
float timer = Time.realtimeSinceStartup;
foreach (Transform t in transform)
{
Polygon2D poly = Polygon2DList.CreateFromGameObject(t.gameObject)[0].ToWorldSpace(t);
Slicing.ComplexSliceAll(poly.pointsList, Layer.Create());
}
Destroy(gameObject);
Debug.Log(name + " in " + (Time.realtimeSinceStartup - timer) * 1000 + "ms");
}
private Slicing PrepareSlice(Hl7.Fhir.Model.ElementDefinition source)
{
Slicing slicing = new Slicing();
slicing.Path = new Path(source.Path);
//TODO: Support multiple discriminators
if (source.Slicing.Discriminator.Count() > 1)
{
throw Error.NotImplemented("Multiple discriminators not yet implemented");
}
//TODO: Support discriminator-less matching!
slicing.Discriminator = new Path(source.Slicing.Discriminator.First());
return(slicing);
}
void Explode(Vector2D pos)
{
List <Slice2D> results = Slicing.ExplodeInPointAll(pos, sliceLayer);
foreach (Slice2D id in results)
{
eventHandler.Perform(id);
}
if (addForce == true)
{
foreach (Slice2D id in results)
{
AddForce.ExplodeInPoint(id, addForceAmount, pos);
}
}
}
static Slice1Impl() // CSSliceCreator.cs:303
{ // CSSliceCreator.cs:304
// CSSliceCreator.cs:329
// Instantiate slicing discriminator
{ // CSSliceCreator.cs:334
ISliceDiscriminator <Observation.ComponentComponent>[] discriminators = // CSSliceCreator.cs:335
new ISliceDiscriminator <Observation.ComponentComponent> [1]; // CSSliceCreator.cs:336
{ // CSSliceCreator.cs:113
/// Define discriminator'
/// {
/// "type": "value",
/// "path": "code"
/// }
var sliceOnValueDiscriminator = new SliceOnValueDiscriminator <Observation.ComponentComponent, CodeableConcept>() // CSSliceCreator.cs:116
{ // CSSliceCreator.cs:117
Path = "code", // CSSliceCreator.cs:118
ValueFilter = ValueFilterComponentSlice1Code // CSSliceCreator.cs:119
}; // CSSliceCreator.cs:120
{ // ElementFixCode.cs:767
CodeableConcept temp = new CodeableConcept(); // ElementFixCode.cs:768
temp.Coding = new List <Coding>(); // ElementFixCode.cs:774
{ // ElementFixCode.cs:777
var temp2 = new Coding(); // ElementFixCode.cs:778
temp2.SystemElement = new FhirUri(); // ElementFixCode.cs:781
temp2.SystemElement.Value = "http://www.test.com/SliceSystem"; // ElementFixCode.cs:783
temp2.CodeElement = new Code(); // ElementFixCode.cs:797
temp2.CodeElement.Value = "Slice1Code"; // ElementFixCode.cs:799
temp.Coding.Add(temp2); // ElementFixCode.cs:826
} // ElementFixCode.cs:827
sliceOnValueDiscriminator.Pattern = temp; // ElementFixCode.cs:842
} // ElementFixCode.cs:843
discriminators[0] = sliceOnValueDiscriminator; // CSSliceCreator.cs:126
} // CSSliceCreator.cs:127
slicing = new Slicing <Observation.ComponentComponent> // CSSliceCreator.cs:346
{ // CSSliceCreator.cs:347
Discriminators = discriminators // CSSliceCreator.cs:348
}; // CSSliceCreator.cs:349
} // CSSliceCreator.cs:350
} // CSSliceCreator.cs:306
internal Slicing GetSlicingForElement(Element element)
{
Slicing slicing = Slicings.FirstOrDefault(s => s.Path.Equals(element.Path));
return(slicing);
}
public Tensor <Type> this[params Slice[] slices] => Slicing <Type> .Create(this, slices.Select(s => (XSlice)s).ToList());
public Tensor <Type> this[IReadOnlyList <XSlice> slices] => Slicing <Type> .Create(this, slices);
public void setSliceState(Slicing slicuru)
{
sliceState = slicuru;
updateFood();
}
// Start is called before the first frame update
void Start()
{
player = GameObject.FindGameObjectWithTag("Player").GetComponent <Slicing>();
}
public Tensor <Type> this[params XSlice[] slices] => Slicing <Type> .Create(this, slices);
