Intersect Clip is not working

[Trumpet-Weasel]

Hi, I have been attempting to apply this library to the Unity Game Engine to mask colliders. I have been following the documentation and have created the code below to attempt to use the clipper functions to adjust points of a PolygonCollider2D. However, nothing appears to happen when the code executes, am I missing something?
`

public PolygonCollider2D maskingCol;
public PolygonCollider2D normalCol;

private void Start()
{
    Paths64 subj = new Paths64();
    subj.Add(Clipper.MakePath(GetPointsInPoly2D(normalCol)));
    Paths64 clip = new Paths64();
    clip.Add(Clipper.MakePath(GetPointsInPoly2D(maskingCol)));

    Paths64 solution = Clipper.Intersect(subj, clip, FillRule.Positive);
    ConvertToCollider(solution);
}

int[] GetPointsInPoly2D(PolygonCollider2D PC)
{
    List<int> Points = new List<int>();
    foreach (Vector2 v in PC.points)
    {
        Points.Add((int)v.x);
        Points.Add((int)v.y);
    }

    return Points.ToArray();
}

void ConvertToCollider(Paths64 solution)
{
    List<Vector2> colliderPoints = new List<Vector2>();

    foreach (Path64 path in solution)
    {
        Vector2[] pathPoints = new Vector2[path.Count];
        for (int i = 0; i < path.Count; i++)
        {
            pathPoints[i] = new Vector2(path[i].X, path[i].Y);
        }
        colliderPoints.AddRange(pathPoints);
    }
    normalCol.SetPath(0, colliderPoints.ToArray());
}`

[Trumpet-Weasel]

Never mind, I figured out there was a bunch of things wrong with the code. In particular:

• The points needed to be adjusted taking the transform values of the collider object into account.
• The points should be scaled by a scale factor to ensure more accuracy upon conversion into integers.

Below is my revised code that should clip a collider appropriately. Hope this helps somebody!
`
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using Clipper2Lib;

public class TheProperPolygonClipper : MonoBehaviour
{
[Header("Assigning")]
public PolygonCollider2D subjCol; //The cookie dough
public PolygonCollider2D clipCol; //The cookie cutter
public PolygonCollider2D outputCol; //The cut cookie dough
public enum MaskInteractionOps {VisibleInsideMask, VisibleOutsideMask }
public MaskInteractionOps MaskInteraction;

[Header("Debugging")]
public List<Path> debugSubjPoints = new List<Path>();
public List<Path> debugClipPoints = new List<Path>();
public List<Path> debugClippedPoints = new List<Path>();

float scale = 1000000;

// Start is called before the first frame update
void Update()
{
    //Get tho polygon collider points and place them into lists of vector2's, floats, and scaled integers.
    List<Path> subjPoints = PolygonColliderPointsToPointData(subjCol);
    List<Path> clipPoints = PolygonColliderPointsToPointData(clipCol);

    debugSubjPoints = subjPoints;
    debugClipPoints = clipPoints;

    //Turn the points into paths64 values
    Paths64 subj = new Paths64();
    Paths64 clip = new Paths64();

    foreach (Path P in subjPoints)
    {
        subj.Add(Clipper.MakePath(P.scaledPoints.ToArray()));
    }

    foreach (Path P in clipPoints)
    {
        clip.Add(Clipper.MakePath(P.scaledPoints.ToArray()));
    }

    //Performs a clip
    Paths64 solution = new Paths64();
    if (MaskInteraction == MaskInteractionOps.VisibleOutsideMask)
    {
        solution = Clipper.Difference(subj, clip, FillRule.NonZero);
    }
    else
    {
        solution = Clipper.Intersect(subj, clip, FillRule.NonZero);
    }

    //Puts the cut points onto another collider
    List<List<Vector2>> pointsAfterClip = Paths64ToListListVector2(solution);

    AddPointsToPolygonCollider(pointsAfterClip, outputCol);
}

private List<Vector2> m_Path = new List<Vector2>();
List<Path> PolygonColliderPointsToPointData(PolygonCollider2D PC)
{
    List<Path> ListToReturn = new List<Path>();

    for (int i = 0; i < PC.pathCount; i++)
    {
        m_Path.Clear();

        PC.GetPath(i, m_Path);

        Path currentPath = new Path();

        foreach (var point in m_Path)
        {
            var worldPoint = PC.transform.localToWorldMatrix.MultiplyPoint(point);
            currentPath.PointsAsVector2.Add(worldPoint);
        }

        ListToReturn.Add(currentPath);
    }

    for (int i = 0; i < ListToReturn.Count; i++)
    {
        foreach(Vector2 V in ListToReturn[i].PointsAsVector2)
        {
            ListToReturn[i].pointsAsFloats.Add(V.x);
            ListToReturn[i].pointsAsFloats.Add(V.y);
        }
    }

    for (int i = 0; i < ListToReturn.Count; i++)
    {
        foreach(float f in ListToReturn[i].pointsAsFloats)
        {
            ListToReturn[i].scaledPoints.Add((int)(f * scale));
        }
    }

    return ListToReturn;
}

//A class containing the points as vector2's, the points as a list of floats, and a list of scaled ints.
[System.Serializable]
public class Path
{
    public List<Vector2> PointsAsVector2 = new List<Vector2>();
    public List<float> pointsAsFloats = new List<float>();
    public List<int> scaledPoints = new List<int>();
}

List<List<Vector2>> Paths64ToListListVector2(Paths64 p)
{
    List<List<Vector2>> listToReturn = new List<List<Vector2>>();
    for(int i = 0; i < p.Count; i++)
    {
        List<Vector2> pathList = new List<Vector2>();
        Path64 path = p[i];
        foreach(Point64 point in path)
        {
            pathList.Add(new Vector2(point.X / scale, point.Y / scale));
        }
        listToReturn.Add(pathList);
    }
    return listToReturn;
}

void AddPointsToPolygonCollider(List<List<Vector2>> points, PolygonCollider2D PC)
{
    PC.pathCount = 0;

    for (int i = 0; i < points.Count; i++)
    {
        List<Vector2> worldPath = points[i];
        Vector2[] localPath = new Vector2[worldPath.Count];

        for (int j = 0; j < worldPath.Count; j++)
        {
            localPath[j] = transform.InverseTransformPoint(worldPath[j]);
        }

        PC.SetPath(i, localPath);
    }
}

}

`