public bool FlipChanelOnLine(ColorChanel chan, MeshPoint other)
{
float val = 1;
if (Cfg.makeVerticesUniqueOnEdgeColoring)
{
EditedMesh.GiveLineUniqueVerticesRefreshTriangleListing(new LineData(this, other));
}
foreach (var u in vertices)
{
if (u.ConnectedTo(other))
{
val *= chan.GetValueFrom(u.color) * chan.GetValueFrom(u.GetConnectedUVinVertex(other).color);
}
}
val = (val > 0.9f) ? 0 : 1;
SetChanel(chan, other, val);
other.SetChanel(chan, this, val);
EditedMesh.Dirty = true;
return(val == 1);
}
public override bool MouseEventPointedTriangle()
{
var m = MeshMGMT;
if (EditorInputManager.GetMouseButtonDown(0))
{
m.Dragging = true;
_originalPosition = GridNavigator.collisionPos;
GridNavigator.onGridPos = GridNavigator.collisionPos;
_draggedVertices.Clear();
foreach (var uv in PointedTriangle.vertexes)
{
_draggedVertices.Add(uv.meshPoint);
}
}
if (!_addToTrianglesAndLines || !EditorInputManager.GetMouseButtonUp(0) || !(m.DragDelay > 0) ||
!_draggedVertices.Contains(PointedTriangle))
{
return(false);
}
if (Cfg.newVerticesUnique)
{
EditedMesh.InsertIntoTriangleUniqueVertices(m.PointedTriangle, m.collisionPosLocal);
}
else
{
EditedMesh.InsertIntoTriangle(m.PointedTriangle, m.collisionPosLocal);
}
return(false);
}
public bool FlipChanelOnLine(ColorChanel chan, MeshPoint other)
{
float val = 1;
if (Cfg.MakeVericesUniqueOnEdgeColoring)
{
EditedMesh.GiveLineUniqueVerticles_RefreshTrisListing(new LineData(this, other));
}
foreach (Vertex u in uvpoints)
{
if (u.ConnectedTo(other))
{
val *= u._color.GetChanel(chan) * u.GetConnectedUVinVert(other)._color.GetChanel(chan);
}
}
val = (val > 0.9f) ? 0 : 1;
SetChanel(chan, other, val);
other.SetChanel(chan, this, val);
EditedMesh.Dirty = true;
return(val == 1);
}
// will also remove any triangles which are using the verts
public static void RemoveVerts(List <int> vertsToRemove, Mesh mesh)
{
EditedMesh meshEdit = new EditedMesh();
Dictionary <int, int> vertRemapping = new Dictionary <int, int>();
for (int vert = 0; vert < mesh.vertices.Length; ++vert)
{
if (!vertsToRemove.Contains(vert))
{
vertRemapping.Add(vert, meshEdit.verts.Count);
meshEdit.verts.Add(mesh.vertices[vert]);
}
}
for (int triangleIndex = 0; triangleIndex < mesh.triangles.Length; triangleIndex += NumVertsPerTriangle)
{
if (!vertsToRemove.Contains(mesh.triangles[triangleIndex]) &&
!vertsToRemove.Contains(mesh.triangles[triangleIndex + 1]) &&
!vertsToRemove.Contains(mesh.triangles[triangleIndex + 2])) // if none of this triangles verts are being removed, keep triangle
{
meshEdit.triangleIndecis.Add(vertRemapping[mesh.triangles[triangleIndex]]);
meshEdit.triangleIndecis.Add(vertRemapping[mesh.triangles[triangleIndex + 1]]);
meshEdit.triangleIndecis.Add(vertRemapping[mesh.triangles[triangleIndex + 2]]);
}
}
meshEdit.CopyTo(mesh);
}
public override void KeysEventPointedVertex()
{
var m = MeshMGMT;
if (KeyCode.Delete.IsDown())
{
if (!EditorInputManager.Control)
{
if (m.PointedUv.meshPoint.vertices.Count == 1)
{
if (!m.DeleteVertexHeal(MeshMGMT.PointedUv.meshPoint))
{
EditedMesh.DeleteUv(MeshMGMT.PointedUv);
}
}
else
{
while (m.PointedUv.meshPoint.vertices.Count > 1)
{
EditedMesh.MoveTriangle(m.PointedUv.meshPoint.vertices[1], m.PointedUv.meshPoint.vertices[0]);
}
}
}
else
{
EditedMesh.DeleteUv(m.PointedUv);
}
EditedMesh.Dirty = true;
}
}
public override bool MouseEventPointedLine()
{
if (EditorInputManager.GetMouseButton(0))
{
if (_mergeUnMerge)
{
if (!EditorInputManager.Shift)
{
EditedMesh.AllVerticesShared(PointedLine);
}
else
{
Dirty |= PointedLine.GiveUniqueVerticesToTriangles();
}
}
else
{
for (var i = 0; i < 2; i++)
{
Dirty |= PointedLine[i].SetSmoothNormal(!EditorInputManager.Shift);
}
}
}
return(false);
}
// triangleVertIndecis must be a multiple of three, each triangle must have three vert indecis
public static void AddTriangles(List <int> triangleVertIndecis, Mesh mesh)
{
EditedMesh meshEdit = new EditedMesh(mesh);
meshEdit.AddTriangles(triangleVertIndecis);
meshEdit.CopyTo(mesh);
}
public override bool MouseEventPointedLine()
{
var m = MeshMGMT;
if (EditorInputManager.GetMouseButtonDown(0))
{
m.Dragging = true;
_originalPosition = GridNavigator.collisionPos;
GridNavigator.onGridPos = GridNavigator.collisionPos;
_draggedVertices.Clear();
foreach (var uv in PointedLine.points)
{
_draggedVertices.Add(uv.meshPoint);
}
}
if (EditorInputManager.GetMouseButtonUp(0))
{
if (_addToTrianglesAndLines && m.DragDelay > 0 && _draggedVertices.Contains(PointedLine))
{
EditedMesh.InsertIntoLine(MeshMGMT.PointedLine.points[0].meshPoint, MeshMGMT.PointedLine.points[1].meshPoint, MeshMGMT.collisionPosLocal);
}
}
return(false);
}
public bool MeshToolInspection(MeshToolBase currentTool)
{
if (currentTool is VertexEdgeTool && MeshEditorManager.target.IsAtlased())
{
"ATL_tex_Chanal:".edit(80, ref TriangleAtlasTool.Inst.curAtlasChanel);
if ("Auto Edge".Click().nl())
{
EditedMesh.TagTrianglesUnprocessed();
foreach (var t in EditedMesh.triangles)
if (!t.wasProcessed)
{
t.wasProcessed = true;
var ntris = t.GetNeighboringTrianglesUnprocessed();
foreach (var nt in ntris)
if (t.textureNo[TriangleAtlasTool.Inst.curAtlasChanel] !=
nt.textureNo[TriangleAtlasTool.Inst.curAtlasChanel])
{
var ln = t.LineWith(nt);
if (ln != null) VertexEdgeTool.PutEdgeOnLine(ln);
else Debug.Log("null line discoveredd");
}
}
EditedMesh.Dirty = true;
}
}
return false;
}
void OnClickDetected()
{
var m = MeshMGMT;
if (ShowVertices && m.TriVertices < 3 && m.SelectedUv != null && !EditedMesh.IsInTriangleSet(m.SelectedUv.meshPoint))
{
EditedMesh.AddToTrisSet(m.SelectedUv);
}
}
public static void DuplicateVerts(List <int> vertsToDuplicate, Mesh mesh)
{
EditedMesh meshEdit = new EditedMesh(mesh);
for (int index = 0; index < vertsToDuplicate.Count; ++index)
{
meshEdit.verts.Add(mesh.vertices[vertsToDuplicate[index]]);
}
meshEdit.CopyTo(mesh);
}
// snap the vert to a length along the axis
public static void SnapVertsOnAxis(List <int> vertsToMove, Vector3 snapAxis, float snapLength, Mesh mesh)
{
EditedMesh meshEdit = new EditedMesh(mesh);
Vector3 snapAxisNormalized = snapAxis.normalized;
for (int index = 0; index < vertsToMove.Count; ++index)
{
float fixUpLength = snapLength - Vector3.Dot(meshEdit.verts[vertsToMove[index]], snapAxisNormalized);
meshEdit.verts[vertsToMove[index]] = meshEdit.verts[vertsToMove[index]] + snapAxisNormalized * fixUpLength;
}
meshEdit.CopyTo(mesh);
}
public static void MoveVerts(List <int> vertsToMove, Vector3 delta, Mesh mesh)
{
EditedMesh meshEdit = new EditedMesh(mesh);
int vertsToMoveCount = vertsToMove.Count;
for (int index = 0; index < vertsToMoveCount; ++index)
{
meshEdit.verts[vertsToMove[index]] += delta;
}
meshEdit.CopyTo(mesh);
}
public override bool MouseEventPointedLine()
{
var a = PointedLine.points[0];
var b = PointedLine.points[1];
MeshMGMT.AssignSelected(
Vector3.Distance(MeshMGMT.collisionPosLocal, a.LocalPos) <
Vector3.Distance(MeshMGMT.collisionPosLocal, b.LocalPos)
? EditedMesh.GetUvPointAFromLine(a.meshPoint, b.meshPoint)
: EditedMesh.GetUvPointAFromLine(b.meshPoint, a.meshPoint));
return(false);
}
public override bool Inspect()
{
var m = MeshMGMT;
"OnClick:".write(60);
if ((_mergeUnMerge ? "Merging (Shift: Unmerge)" : "Smoothing (Shift: Unsmoothing)").Click().nl())
{
_mergeUnMerge = !_mergeUnMerge;
}
if ("Sharp All".Click())
{
foreach (MeshPoint vr in EditedMesh.meshPoints)
{
vr.smoothNormal = false;
}
EditedMesh.Dirty = true;
Cfg.newVerticesSmooth = false;
}
if ("Smooth All".Click().nl())
{
foreach (var vr in EditedMesh.meshPoints)
{
vr.smoothNormal = true;
}
EditedMesh.Dirty = true;
Cfg.newVerticesSmooth = true;
}
if ("All shared".Click())
{
EditedMesh.AllVerticesShared();
EditedMesh.Dirty = true;
Cfg.newVerticesUnique = false;
}
if ("All unique".Click().nl())
{
foreach (var t in EditedMesh.triangles)
{
EditedMesh.GiveTriangleUniqueVertices(t);
}
Cfg.newVerticesUnique = true;
}
return(false);
}
// reverse the winding order of the triangle
public static void ChangeTrianglesWinding(List <int> trianglesToChange, Mesh mesh)
{
EditedMesh meshEdit = new EditedMesh(mesh);
for (int triangle = 0; triangle < trianglesToChange.Count; ++triangle)
{
int firstTriangleIndex = trianglesToChange[triangle] * NumVertsPerTriangle;
int temp = meshEdit.triangleIndecis[firstTriangleIndex];
meshEdit.triangleIndecis[firstTriangleIndex] = meshEdit.triangleIndecis[firstTriangleIndex + 2];
meshEdit.triangleIndecis[firstTriangleIndex + 2] = temp;
}
meshEdit.CopyTo(mesh);
}
public static void AddUnitTriangle(Mesh mesh)
{
int currentNumVerts = mesh.vertices.Length;
EditedMesh meshEdit = new EditedMesh(mesh);
meshEdit.AddVerts(new List <Vector3>()
{
Vector3.zero, new Vector3(-1f, 0f, 0f), new Vector3(0f, 0f, 1f)
});
meshEdit.AddTriangles(new List <int>()
{
currentNumVerts, currentNumVerts + 1, currentNumVerts + 2
});
meshEdit.CopyTo(mesh);
}
public override bool MouseEventPointedLine()
{
Vertex a = PointedLine.pnts[0];
Vertex b = PointedLine.pnts[1];
if (Vector3.Distance(MeshMGMT.collisionPosLocal, a.Pos) < Vector3.Distance(MeshMGMT.collisionPosLocal, b.Pos))
{
MeshMGMT.AssignSelected(EditedMesh.GetUVpointAFromLine(a.meshPoint, b.meshPoint));
}
else
{
MeshMGMT.AssignSelected(EditedMesh.GetUVpointAFromLine(b.meshPoint, a.meshPoint));
}
return(false);
}
public static void RemoveUnusedVerts(Mesh mesh)
{
EditedMesh meshEdit = new EditedMesh();
Dictionary <int, int> vertRemapping = new Dictionary <int, int>();
for (int triangleIndex = 0; triangleIndex < mesh.triangles.Length; ++triangleIndex)
{
int vert = mesh.triangles[triangleIndex];
if (!vertRemapping.ContainsKey(vert))
{
vertRemapping.Add(vert, meshEdit.verts.Count);
meshEdit.verts.Add(mesh.vertices[vert]);
}
meshEdit.triangleIndecis.Add(vertRemapping[vert]);
}
meshEdit.CopyTo(mesh);
}
// triangle zero, will mean the first triangle (three triangle indecis) are deleted, triangle index 1, the second triangle deleted
public static void RemoveTriangles(List <int> trianglesToRemove, Mesh mesh)
{
EditedMesh meshEdit = new EditedMesh();
meshEdit.AddVerts(mesh.vertices);
for (int triangle = 0; triangle < CalculateNumTriangles(mesh); ++triangle)
{
if (!trianglesToRemove.Contains(triangle))
{
int startingTriangleIndex = triangle * NumVertsPerTriangle;
meshEdit.triangleIndecis.Add(mesh.triangles[startingTriangleIndex]);
meshEdit.triangleIndecis.Add(mesh.triangles[startingTriangleIndex + 1]);
meshEdit.triangleIndecis.Add(mesh.triangles[startingTriangleIndex + 2]);
}
}
meshEdit.CopyTo(mesh);
}
public bool SetAllUVsShared()
{
if (uvpoints.Count == 1)
{
return(false);
}
while (uvpoints.Count > 1)
{
if (!EditedMesh.MoveTris(uvpoints[1], uvpoints[0]))
{
break;
}
}
return(true);
}
public override void KeysEventPointedLine()
{
if ((KeyCode.Backspace.IsDown()))
{
var a = PointedLine.points[0];
var b = PointedLine.points[1];
if (!EditorInputManager.Control)
{
EditedMesh.SwapLine(a.meshPoint, b.meshPoint);
}
else
{
EditedMesh.DeleteLine(PointedLine);
}
EditedMesh.Dirty = true;
}
}
public static bool PutEdgesBetweenSubmeshes()
{
if (MeshMGMT.target.IsAtlased())
{
"ATL_tex_Chanal:".edit(80, ref TriangleAtlasTool.Inst.curAtlasChanel);
if ("Auto Edge".Click().nl())
{
EditedMesh.TagTrianglesUnprocessed();
foreach (var t in EditedMesh.triangles)
{
if (!t.wasProcessed)
{
t.wasProcessed = true;
var ntris = t.GetNeighboringTrianglesUnprocessed();
foreach (var nt in ntris)
{
if (t.textureNo[TriangleAtlasTool.Inst.curAtlasChanel] != nt.textureNo[TriangleAtlasTool.Inst.curAtlasChanel])
{
var ln = t.LineWith(nt);
if (ln != null)
{
VertexEdgeTool.PutEdgeOnLine(ln);
}
else
{
Debug.Log("null line discoveredd");
}
}
}
}
}
EditedMesh.Dirty = true;
}
}
return(false);
}
public override bool MouseEventPointedTriangle()
{
if (EditorInputManager.GetMouseButton(0))
{
if (MergeUnmerge)
{
if (EditorInputManager.getShiftKey())
{
EditedMesh.Dirty |= PointedTris.SetAllVerticesShared();
}
else
{
EditedMesh.Dirty |= EditedMesh.GiveTriangleUniqueVerticles(PointedTris);
}
}
else
{
EditedMesh.Dirty |= PointedTris.SetSmoothVertices(!EditorInputManager.getShiftKey());
}
}
return(false);
}
public override bool MouseEventPointedVertex()
{
if (EditorInputManager.GetMouseButton(0))
{
if (_mergeUnMerge)
{
if (EditorInputManager.Shift)
{
EditedMesh.SetAllUVsShared(PointedVertex); // .SetAllVerticesShared();
}
else
{
EditedMesh.Dirty |= PointedVertex.AllPointsUnique(); //editedMesh.GiveTriangleUniqueVertices(pointedTriangle);
}
}
else
{
EditedMesh.Dirty |= PointedVertex.SetSmoothNormal(!EditorInputManager.Shift);
}
}
return(false);
}
public static void DuplicateTriangles(List <int> trianglesToDuplicate, Mesh mesh)
{
EditedMesh meshEdit = new EditedMesh(mesh);
// go over all the trianles, making copies of all the verts which are used
Dictionary <int, int> vertRemapping = new Dictionary <int, int>();
for (int index = 0; index < trianglesToDuplicate.Count; ++index)
{
int startingTriangleIndex = trianglesToDuplicate[index] * NumVertsPerTriangle;
for (int triangleVert = 0; triangleVert < NumVertsPerTriangle; ++triangleVert)
{
int vertIndex = mesh.triangles[startingTriangleIndex + triangleVert];
if (!vertRemapping.ContainsKey(vertIndex))
{
vertRemapping.Add(vertIndex, meshEdit.verts.Count);
meshEdit.verts.Add(mesh.vertices[vertIndex]);
}
meshEdit.triangleIndecis.Add(vertRemapping[vertIndex]);
}
}
meshEdit.CopyTo(mesh);
}
// all triangles will be updated
public static int FuseVerts(List <int> vertsToFuse, Mesh mesh)
{
if (vertsToFuse.Count > 1)
{
EditedMesh meshEdit = new EditedMesh();
List <int> vertsToRemove = new List <int>();
int vertToKeep = mesh.vertices.Length;
for (int vert = 0; vert < vertsToFuse.Count; ++vert)
{
vertsToRemove.Add(vertsToFuse[vert]);
if (vertsToFuse[vert] < vertToKeep)
{
vertToKeep = vertsToFuse[vert];
}
}
vertsToRemove.Remove(vertToKeep);
Dictionary <int, int> vertRemapping = new Dictionary <int, int>();
for (int vert = 0; vert < mesh.vertices.Length; ++vert)
{
if (vertsToRemove.Contains(vert))
{
vertRemapping.Add(vert, vertToKeep);
}
else
{
vertRemapping.Add(vert, meshEdit.verts.Count);
meshEdit.verts.Add(mesh.vertices[vert]);
}
}
meshEdit.RemapTriangleIndecis(mesh, vertRemapping);
meshEdit.CopyTo(mesh);
return(vertToKeep);
}
return(IndexInvalid);
}
public static void MoveTriangles(List <int> trianglesToMove, Vector3 delta, Mesh mesh)
{
EditedMesh meshEdit = new EditedMesh(mesh);
HashSet <int> editedVerts = new HashSet <int>();
int trianglesToMoveCount = trianglesToMove.Count;
for (int index = 0; index < trianglesToMoveCount; ++index)
{
int triangle = trianglesToMove[index];
int startingTriangleIndex = triangle * NumVertsPerTriangle;
for (int triangleIndex = 0; triangleIndex < NumVertsPerTriangle; ++triangleIndex)
{
int vertIndex = meshEdit.triangleIndecis[startingTriangleIndex + triangleIndex];
if (!editedVerts.Contains(vertIndex))
{
editedVerts.Add(vertIndex);
meshEdit.verts[vertIndex] += delta;
}
}
}
meshEdit.CopyTo(mesh);
}
public PainterMesh.MeshPoint CreatePointAndFocus(Vector3 pos)
{
var hold = new PainterMesh.MeshPoint(pos, true);
new PainterMesh.Vertex(hold);
editedMesh.meshPoints.Add(hold);
if (!EditorInputManager.Control)
{
EditedMesh.AddToTrisSet(hold.vertices[0]);
}
if (Cfg.pixelPerfectMeshEditing)
{
hold.PixPerfect();
}
GridNavigator.collisionPos = pos;
UpdateLocalSpaceMousePosition();
return(hold);
}
public static void FuseCloseVerts(List <int> vertsToFuse, Mesh mesh, float distSqr)
{
EditedMesh meshEdit = new EditedMesh();
Dictionary <int, int> vertRemapping = new Dictionary <int, int>();
for (int vert = 0; vert < mesh.vertices.Length; ++vert)
{
if (vertRemapping.ContainsKey(vert)) // already been remapped
{
continue;
}
vertRemapping.Add(vert, meshEdit.verts.Count);
meshEdit.verts.Add(mesh.vertices[vert]);
if (!vertsToFuse.Contains(vert))
{
continue; // not interested in fusing this vert
}
Vector3 vertPos = mesh.vertices[vert];
for (int vertToCompare = vert + 1; vertToCompare < mesh.vertices.Length; ++vertToCompare)
{
if (!vertsToFuse.Contains(vertToCompare))
{
continue; // not interested in fusing this vert
}
if ((vertPos - mesh.vertices[vertToCompare]).sqrMagnitude < distSqr)
{
vertRemapping.Add(vertToCompare, vertRemapping[vert]);
}
}
}
meshEdit.RemapTriangleIndecis(mesh, vertRemapping);
meshEdit.CopyTo(mesh);
}
