public void GenerateMesh(Pair2D pair)
{
List <Mesh2DTriangle> trianglesList = new List <Mesh2DTriangle>();
trianglesList.Add(Max2DMesh.CreateLineNew(pair, lineWidth, transform.position.z + lineOffset));
mesh = Max2DMesh.ExportMesh2(trianglesList);
}
static public Mesh GenerateMesh(List <Vector2D> complexSlicerPointsList, Transform transform, float lineWidth, float minVertexDistance, float zPosition, float squareSize, float lineEndWidth, float vertexSpace, Slicer2DLineEndingType endingType, int edges)
{
Mesh2DMesh trianglesList = new Mesh2DMesh();
float size = squareSize;
Vector2D vA, vB;
List <Pair2D> list = Pair2D.GetList(complexSlicerPointsList, false);
foreach (Pair2D pair in list)
{
vA = new Vector2D(pair.A);
vB = new Vector2D(pair.B);
vA.Push(Vector2D.Atan2(pair.A, pair.B), -minVertexDistance * vertexSpace);
vB.Push(Vector2D.Atan2(pair.A, pair.B), minVertexDistance * vertexSpace);
trianglesList.Add(Max2DMesh.CreateLine(new Pair2D(vA, vB), transform.localScale, lineWidth, zPosition));
}
Pair2D linearPair = Pair2D.Zero();
linearPair.A = new Vector2D(complexSlicerPointsList.First());
linearPair.B = new Vector2D(complexSlicerPointsList.Last());
GenerateSquare(trianglesList, linearPair.A, size, transform, lineEndWidth, zPosition, endingType, edges);
GenerateSquare(trianglesList, linearPair.B, size, transform, lineEndWidth, zPosition, endingType, edges);
return(Max2DMesh.Export(trianglesList));
}
public void Draw()
{
//material.color = color;
material.SetColor("_Emission", color);
Max2DMesh.Draw(mesh, material);
}
public void DrawTrajectory()
{
Polygon2D trajectory = new Polygon2D();
//trajectory.AddPoint(0, 0);
Vector2 pos = spawner.transform.position;
Vector2 gravity = Physics2D.gravity;
Vector2 force = spawner.transform.right * applyForce;
float timer = 0;
while (timer < 3)
{
float delta = 0.1f;
trajectory.AddPoint(pos);
pos += force * delta;
force += gravity * delta;
timer += delta;
}
Mesh mesh = Max2DMesh.CreatePolygon(transform, trajectory, -3f, 1f, false);
Max2DMesh.Draw(mesh, trajectoryMaterial);
}
static public Mesh GenerateComplexMesh(List <Vector2D> complexSlicerPointsList, Transform transform, float lineWidth, float minVertexDistance, float zPosition, float squareSize, float lineEndWidth, float vertexSpace)
{
List <Mesh2DSubmesh> trianglesList = new List <Mesh2DSubmesh>();
Pair2D pair = Pair2D.Zero();
for (int i = 0; i < complexSlicerPointsList.Count; i++)
{
pair.A = complexSlicerPointsList[i];
pair.B = complexSlicerPointsList[(i + 1) % complexSlicerPointsList.Count];
vA.x = pair.A.x;
vA.y = pair.A.y;
vB.x = pair.B.x;
vB.y = pair.B.y;
vA.Push(Vector2D.Atan2(pair.A, pair.B), -minVertexDistance * vertexSpace);
vB.Push(Vector2D.Atan2(pair.A, pair.B), minVertexDistance * vertexSpace);
trianglesList.Add(Max2DMesh.CreateLine(new Pair2D(vA, vB), transform, lineWidth, zPosition));
}
return(Max2DMesh.Export(trianglesList));
}
static public Mesh GenerateTrackerMesh(Vector2D pos, Dictionary <Slicer2D, SlicerTrackerObject> trackerList, Transform transform, float lineWidth, float zPosition, float squareSize, Slicer2DLineEndingType endingType, int edges)
{
Mesh2DMesh trianglesList = new Mesh2DMesh();
float size = squareSize;
GenerateSquare(trianglesList, pos, size, transform, lineWidth, zPosition, endingType, edges);
trianglesList.Add(Max2DMesh.CreateLine(new Pair2D(pos, pos), transform.localScale, lineWidth, zPosition));
foreach (KeyValuePair <Slicer2D, SlicerTrackerObject> trackerPair in trackerList)
{
SlicerTrackerObject tracker = trackerPair.Value;
if (trackerPair.Key != null && tracker.tracking)
{
List <Vector2D> pointListWorld = Vector2DList.PointsToWorldSpace(trackerPair.Key.transform, tracker.pointsList);
pointListWorld.Add(pos);
List <Pair2D> pairList = Pair2D.GetList(pointListWorld, false);
foreach (Pair2D pair in pairList)
{
trianglesList.Add(Max2DMesh.CreateLine(pair, transform.localScale, lineWidth, zPosition));
}
}
}
return(Max2DMesh.Export(trianglesList));
}
static public Mesh GeneratePointMesh(Pair2D linearPair, Transform transform, float lineWidth, float zPosition)
{
Mesh2DMesh trianglesList = new Mesh2DMesh();
trianglesList.Add(Max2DMesh.CreateLine(linearPair, transform.localScale, lineWidth, zPosition));
return(Max2DMesh.Export(trianglesList));
}
public void GenerateMesh()
{
lineWidthSet = lineWidth;
if (GetPolygon() != null)
{
mesh = Max2DMesh.GeneratePolygon2DMeshNew(transform, GetPolygon(), lineOffset, lineWidth, edgeCollider2D == false);
}
}
void Update()
{
trackerObject.Update(transform.position);
mesh = Slicer2DVisualsMesh.Linear.GenerateTrackerMesh(trackerObject.trackerList, transform, lineWidth, transform.position.z + 0.001f);
//Max2D.SetColor (Color.black);
Max2DMesh.Draw(mesh, GetStaticMaterial());
}
void Update()
{
trackerObject.Update(transform.position);
mesh = Max2DMesh.GenerateComplexTrackerMesh(trackerObject.trackerList, transform, lineWidth, transform.position.z + 0.001f);
Max2D.SetColor(Color.black);
Max2DMesh.Draw(mesh, Max2D.lineMaterial);
}
static public Mesh GetMesh()
{
if (mesh == null)
{
List <Mesh2DTriangle> triangles = new List <Mesh2DTriangle>();
triangles.Add(Max2DMesh.CreateBox(0.25f));
mesh = Max2DMesh.ExportMesh2(triangles);
}
return(mesh);
}
static public Mesh GetMesh()
{
if (mesh == null)
{
Mesh2DMesh triangles = new Mesh2DMesh();
triangles.Add(Max2DMesh.Legacy.CreateBox(0.125f));
mesh = Max2DMesh.Export(triangles);
}
return(mesh);
}
public void GenerateMesh()
{
lineWidthSet = lineWidth;
if (mesh != null)
{
DestroyImmediate(mesh);
}
mesh = Max2DMesh.CreatePolygon(transform, GetPolygon(), lineOffset, lineWidth, edgeCollider == false);
}
public void Draw()
{
//material.color = color;
material.SetColor("_Emission", color);
if (mesh == null)
{
return;
}
Max2DMesh.Draw(mesh, transform, material);
}
static public Mesh GenerateMesh(Pair2D linearPair, Transform transform, float lineWidth, float zPosition, float size, float lineEndWidth, Slicer2DLineEndingType endingType, int edges)
{
Mesh2DMesh trianglesList = new Mesh2DMesh();
trianglesList.Add(Max2DMesh.CreateLine(linearPair, transform.localScale, lineWidth, zPosition));
GenerateSquare(trianglesList, linearPair.A, size, transform, lineEndWidth, zPosition, endingType, edges);
GenerateSquare(trianglesList, linearPair.B, size, transform, lineEndWidth, zPosition, endingType, edges);
return(Max2DMesh.Export(trianglesList));
}
static public Mesh CreatePolygon(Transform transform, Polygon2D polygon, float lineOffset, float lineWidth, bool connectedLine)
{
Mesh2DMesh trianglesList = new Mesh2DMesh();
int count = polygon.pointsList.Count;
int lastID = count - 1;
int startID = 0;
if (connectedLine == false)
{
lastID = 0;
startID = 1;
}
Pair2D p = pair2D;
p.A = polygon.pointsList[lastID];
for (int i = startID; i < count; i++)
{
p.B = polygon.pointsList[i];
trianglesList.Add(Max2DMesh.CreateLine(p, transform.localScale, lineWidth, lineOffset));
p.A = p.B;
}
foreach (Polygon2D hole in polygon.holesList)
{
count = hole.pointsList.Count;
lastID = count - 1;
startID = 0;
if (connectedLine == false)
{
lastID = 0;
startID = 1;
}
p.A = hole.pointsList[lastID];
for (int i = startID; i < count; i++)
{
p.B = hole.pointsList[i];
trianglesList.Add(Max2DMesh.CreateLine(p, transform.localScale, lineWidth, lineOffset));
p.A = p.B;
}
}
return(Max2DMesh.Export(trianglesList));
}
static public Mesh GenerateCutMesh(Pair2D linearPair, float cutSize, Transform transform, float lineWidth, float zPosition)
{
Mesh2DMesh trianglesList = new Mesh2DMesh();
LinearCut linearCutLine = LinearCut.Create(linearPair, cutSize);
foreach (Pair2D pair in Pair2D.GetList(linearCutLine.GetPointsList(), true))
{
trianglesList.Add(Max2DMesh.CreateLine(pair, transform.localScale, lineWidth, zPosition));
}
return(Max2DMesh.Export(trianglesList));
}
static public Mesh GenerateCutMesh(List <Vector2D> complexSlicerPointsList, float cutSize, Transform transform, float lineWidth, float zPosition)
{
Mesh2DMesh trianglesList = new Mesh2DMesh();
ComplexCut complexCutLine = ComplexCut.Create(complexSlicerPointsList, cutSize);
foreach (Pair2D pair in Pair2D.GetList(complexCutLine.GetPointsList(), true))
{
trianglesList.Add(Max2DMesh.CreateLine(pair, transform.localScale, lineWidth, zPosition));
}
return(Max2DMesh.Export(trianglesList));
}
public void Draw()
{
if (customColor)
{
material.SetColor("_Emission", color);
Max2DMesh.Draw(mesh, transform, material, orderInLayer);
}
else
{
Max2D.Check();
Max2D.lineMaterial.SetColor("_Emission", Color.black);
Max2DMesh.Draw(mesh, transform, Max2D.lineMaterial, orderInLayer);
}
}
static public Mesh GenerateCreateMesh(Vector2D pos, Polygon2D.PolygonType polygonType, float polygonSize, Slicer2DCreateControllerObject.CreateType createType, List <Vector2D> complexSlicerPointsList, Pair2D linearPair, float minVertexDistance, Transform transform, float lineWidth, float zPosition, float squareSize, Slicer2DLineEndingType endingType, int edges)
{
Mesh2DMesh trianglesList = new Mesh2DMesh();
float size = squareSize;
if (createType == Slicer2DCreateControllerObject.CreateType.Slice)
{
if (complexSlicerPointsList.Count > 0)
{
linearPair.A = new Vector2D(complexSlicerPointsList.First());
linearPair.B = new Vector2D(complexSlicerPointsList.Last());
GenerateSquare(trianglesList, linearPair.A, size, transform, lineWidth, zPosition, endingType, edges);
GenerateSquare(trianglesList, linearPair.B, size, transform, lineWidth, zPosition, endingType, edges);
Vector2D vA, vB;
foreach (Pair2D pair in Pair2D.GetList(complexSlicerPointsList, true))
{
vA = new Vector2D(pair.A);
vB = new Vector2D(pair.B);
vA.Push(Vector2D.Atan2(pair.A, pair.B), -minVertexDistance / 5);
vB.Push(Vector2D.Atan2(pair.A, pair.B), minVertexDistance / 5);
trianglesList.Add(Max2DMesh.CreateLine(new Pair2D(vA, vB), transform.localScale, lineWidth, zPosition));
}
}
}
else
{
Polygon2D poly = Polygon2D.Create(polygonType, polygonSize).ToOffset(pos);
Vector2D vA, vB;
foreach (Pair2D pair in Pair2D.GetList(poly.pointsList, true))
{
vA = new Vector2D(pair.A);
vB = new Vector2D(pair.B);
vA.Push(Vector2D.Atan2(pair.A, pair.B), -minVertexDistance / 5);
vB.Push(Vector2D.Atan2(pair.A, pair.B), minVertexDistance / 5);
trianglesList.Add(Max2DMesh.CreateLine(new Pair2D(vA, vB), transform.localScale, lineWidth, zPosition));
}
}
return(Max2DMesh.Export(trianglesList));
}
public void DrawLine(Pair2D pair)
{
Mesh meshBorder = Max2DMesh.GenerateLinearMesh(pair, transform, lineWidth * 2f * visualScale, zPosition + 0.001f, 0, lineWidth * 2f * visualScale);
Mesh mesh = Max2DMesh.GenerateLinearMesh(pair, transform, lineWidth * visualScale, zPosition, 0, lineWidth * 2f * visualScale);
lineMaterial.SetColor("_Emission", Color.black);
Max2DMesh.Draw(Max2DMesh.GenerateLinearMesh(new Pair2D(pair.A, pair.A), transform, lineWidth * 10f * visualScale, zPosition + 0.001f, 0, lineWidth * 10f * visualScale), lineMaterialBorder);
Max2DMesh.Draw(Max2DMesh.GenerateLinearMesh(new Pair2D(pair.B, pair.B), transform, lineWidth * 10f * visualScale, zPosition + 0.001f, 0, lineWidth * 10f * visualScale), lineMaterialBorder);
Max2DMesh.Draw(meshBorder, lineMaterialBorder);
lineMaterial.SetColor("_Emission", slicerColor);
Max2DMesh.Draw(Max2DMesh.GenerateLinearMesh(new Pair2D(pair.A, pair.A), transform, lineWidth * 5f * visualScale, zPosition + 0.001f, 0, lineWidth * 5f * visualScale), lineMaterial);
Max2DMesh.Draw(Max2DMesh.GenerateLinearMesh(new Pair2D(pair.B, pair.B), transform, lineWidth * 5f * visualScale, zPosition + 0.001f, 0, lineWidth * 5f * visualScale), lineMaterial);
Max2DMesh.Draw(mesh, lineMaterial);
}
public void DrawLine(Pair2D pair)
{
Mesh meshBorder = Slicer2DVisualsMesh.Linear.GenerateMesh(pair, transform, lineWidth * 2f * visualScale, zPosition + 0.001f, 0, lineWidth * 2f * visualScale, visuals.lineEndingType, visuals.lineEndingEdgeCount);
Mesh mesh = Slicer2DVisualsMesh.Linear.GenerateMesh(pair, transform, lineWidth * visualScale, zPosition, 0, lineWidth * 2f * visualScale, visuals.lineEndingType, visuals.lineEndingEdgeCount);
lineMaterial.SetColor(Color.black);
Max2DMesh.Draw(Slicer2DVisualsMesh.Linear.GenerateMesh(new Pair2D(pair.A, pair.A), transform, lineWidth * 10f * visualScale, zPosition + 0.001f, 0, lineWidth * 10f * visualScale, visuals.lineEndingType, visuals.lineEndingEdgeCount), lineMaterialBorder.material);
Max2DMesh.Draw(Slicer2DVisualsMesh.Linear.GenerateMesh(new Pair2D(pair.B, pair.B), transform, lineWidth * 10f * visualScale, zPosition + 0.001f, 0, lineWidth * 10f * visualScale, visuals.lineEndingType, visuals.lineEndingEdgeCount), lineMaterialBorder.material);
Max2DMesh.Draw(meshBorder, lineMaterialBorder.material);
lineMaterial.SetColor(slicerColor);
Max2DMesh.Draw(Slicer2DVisualsMesh.Linear.GenerateMesh(new Pair2D(pair.A, pair.A), transform, lineWidth * 5f * visualScale, zPosition + 0.001f, 0, lineWidth * 5f * visualScale, visuals.lineEndingType, visuals.lineEndingEdgeCount), lineMaterial.material);
Max2DMesh.Draw(Slicer2DVisualsMesh.Linear.GenerateMesh(new Pair2D(pair.B, pair.B), transform, lineWidth * 5f * visualScale, zPosition + 0.001f, 0, lineWidth * 5f * visualScale, visuals.lineEndingType, visuals.lineEndingEdgeCount), lineMaterial.material);
Max2DMesh.Draw(mesh, lineMaterial.material);
}
public void Draw(Pair2D pair)
{
List <Mesh2DTriangle> trianglesList = new List <Mesh2DTriangle>();
trianglesList.Add(Max2DMesh.CreateLineNew(pair, lineWidth, transform.position.z + lineOffset));
Mesh mesh = Max2DMesh.ExportMesh(trianglesList);
if (customColor)
{
material.SetColor("_Emission", color);
Max2DMesh.Draw(mesh, material);
}
else
{
Max2DMesh.Draw(mesh, Max2D.lineMaterial);
}
}
public void Draw(Pair2D pair)
{
Mesh2DMesh trianglesList = new Mesh2DMesh();
trianglesList.Add(Max2DMesh.CreateLine(pair, new Vector3(1, 1, 1), lineWidth, transform.position.z + lineOffset));
Mesh mesh = Max2DMesh.Export(trianglesList);
if (customColor)
{
material.SetColor(color);
Max2DMesh.Draw(mesh, GetMaterial().material);
}
else
{
Max2DMesh.Draw(mesh, GetStaticMaterial().material);
}
}
static public Mesh GenerateLinearMesh(Pair2D linearPair, Transform transform, float lineWidth, float zPosition, float squareSize, float lineEndWidth)
{
List <Mesh2DSubmesh> trianglesList = new List <Mesh2DSubmesh>();
float size = squareSize;
trianglesList.Add(Max2DMesh.CreateLine(linearPair, transform, lineWidth, zPosition));
trianglesList.Add(Max2DMesh.CreateLine(new Pair2D(new Vector2D(linearPair.A.x - size, linearPair.A.y - size), new Vector2D(linearPair.A.x + size, linearPair.A.y - size)), transform, lineEndWidth, zPosition));
trianglesList.Add(Max2DMesh.CreateLine(new Pair2D(new Vector2D(linearPair.A.x - size, linearPair.A.y - size), new Vector2D(linearPair.A.x - size, linearPair.A.y + size)), transform, lineEndWidth, zPosition));
trianglesList.Add(Max2DMesh.CreateLine(new Pair2D(new Vector2D(linearPair.A.x + size, linearPair.A.y + size), new Vector2D(linearPair.A.x + size, linearPair.A.y - size)), transform, lineEndWidth, zPosition));
trianglesList.Add(Max2DMesh.CreateLine(new Pair2D(new Vector2D(linearPair.A.x + size, linearPair.A.y + size), new Vector2D(linearPair.A.x - size, linearPair.A.y + size)), transform, lineEndWidth, zPosition));
trianglesList.Add(Max2DMesh.CreateLine(new Pair2D(new Vector2D(linearPair.B.x - size, linearPair.B.y - size), new Vector2D(linearPair.B.x + size, linearPair.B.y - size)), transform, lineEndWidth, zPosition));
trianglesList.Add(Max2DMesh.CreateLine(new Pair2D(new Vector2D(linearPair.B.x - size, linearPair.B.y - size), new Vector2D(linearPair.B.x - size, linearPair.B.y + size)), transform, lineEndWidth, zPosition));
trianglesList.Add(Max2DMesh.CreateLine(new Pair2D(new Vector2D(linearPair.B.x + size, linearPair.B.y + size), new Vector2D(linearPair.B.x + size, linearPair.B.y - size)), transform, lineEndWidth, zPosition));
trianglesList.Add(Max2DMesh.CreateLine(new Pair2D(new Vector2D(linearPair.B.x + size, linearPair.B.y + size), new Vector2D(linearPair.B.x - size, linearPair.B.y + size)), transform, lineEndWidth, zPosition));
return(Max2DMesh.Export(trianglesList));
}
public void Draw()
{
if (customColor)
{
if (material != null)
{
material.SetColor("_Emission", color);
Max2DMesh.Draw(mesh, transform, material);
}
}
else
{
Max2D.Check();
if (staticMaterial != null)
{
staticMaterial.SetColor("_Emission", Color.black);
Max2DMesh.Draw(mesh, transform, staticMaterial);
}
}
}
static public Mesh GeneratePolygonMesh(Vector2D pos, Polygon2D.PolygonType polygonType, float polygonSize, float minVertexDistance, Transform transform, float lineWidth, float zPosition)
{
Mesh2DMesh trianglesList = new Mesh2DMesh();
Polygon2D slicePolygon = Polygon2D.Create(polygonType, polygonSize).ToOffset(pos);
Vector2D vA, vB;
foreach (Pair2D pair in Pair2D.GetList(slicePolygon.pointsList, true))
{
vA = new Vector2D(pair.A);
vB = new Vector2D(pair.B);
vA.Push(Vector2D.Atan2(pair.A, pair.B), -minVertexDistance / 5);
vB.Push(Vector2D.Atan2(pair.A, pair.B), minVertexDistance / 5);
trianglesList.Add(Max2DMesh.CreateLine(new Pair2D(vA, vB), transform.localScale, lineWidth, zPosition));
}
return(Max2DMesh.Export(trianglesList));
}
static public Mesh GeneratePolygon2DMesh(Transform transform, Polygon2D polygon, float lineOffset, float lineWidth, bool connectedLine)
{
Mesh2DMesh trianglesList = new Mesh2DMesh();
Polygon2D poly = polygon;
foreach (Pair2D p in Pair2D.GetList(poly.pointsList, connectedLine))
{
trianglesList.Add(Max2DMesh.CreateLine(p, transform.localScale, lineWidth, lineOffset));
}
foreach (Polygon2D hole in poly.holesList)
{
foreach (Pair2D p in Pair2D.GetList(hole.pointsList, connectedLine))
{
trianglesList.Add(Max2DMesh.CreateLine(p, transform.localScale, lineWidth, lineOffset));
}
}
return(Max2DMesh.Export(trianglesList));
}
public void Draw()
{
if (lineBorder && meshBorder.Count > 0)
{
if (meshBorder.Count > 0)
{
foreach (Mesh m in meshBorder)
{
Max2DMesh.Draw(m, GetBorderMaterial());
}
}
}
if (mesh.Count > 0)
{
foreach (Mesh m in mesh)
{
Max2DMesh.Draw(m, GetFillMaterial());
}
}
if (customEndingsPosition.Count > 0)
{
Matrix4x4 matrix;
foreach (Pair2D pair in customEndingsPosition)
{
Polygon2D polyA = Polygon2D.CreateFromRect(new Vector2(1, 1));
//polyA.ToOffset(pair.A);
Mesh mA = polyA.CreateMesh(new Vector2(2, 2), Vector2.zero);
matrix = Matrix4x4.TRS(pair.A.ToVector3(zPosition), Quaternion.Euler(0, 0, 0), new Vector3(1, 1, 1));
Graphics.DrawMesh(mA, matrix, customEndingImageMaterial, 0);
matrix = Matrix4x4.TRS(pair.B.ToVector3(zPosition), Quaternion.Euler(0, 0, 0), new Vector3(1, 1, 1));
Graphics.DrawMesh(mA, matrix, customEndingImageMaterial, 0);
}
}
}
public void Draw()
{
SmartMaterial mat;
if (customColor)
{
mat = GetMaterial();
if (mat != null)
{
mat.SetColor(color);
Max2DMesh.Draw(mesh, transform, mat.material);
}
}
else
{
mat = GetStaticMaterial();
if (mat != null)
{
Max2DMesh.Draw(mesh, transform, mat.material);
}
}
}
