public PainterMesh.MeshPoint InsertIntoTriangle(PainterMesh.Triangle a, Vector3 pos)
{
// Debug.Log("Inserting into triangle");
var newVrt = new PainterMesh.MeshPoint(a.vertexes[0].meshPoint, pos);
var w = a.DistanceToWeight(pos);
var newV20 = a.vertexes[0].GetUv(0) * w.x + a.vertexes[1].GetUv(0) * w.y + a.vertexes[2].GetUv(0) * w.z;
var newV21 = a.vertexes[0].GetUv(1) * w.x + a.vertexes[1].GetUv(1) * w.y + a.vertexes[2].GetUv(1) * w.z;
var newUv = new PainterMesh.Vertex(newVrt, newV20, newV21);
a.AssignWeightedData(newUv, w);
meshPoints.Add(newVrt);
var b = new PainterMesh.Triangle(a.vertexes).CopySettingsFrom(a);
var c = new PainterMesh.Triangle(a.vertexes).CopySettingsFrom(a);
a.Replace(0, newUv); //uvpnts[0] = newUV;
b.Replace(1, newUv); // uvpnts[1] = newUV;
c.Replace(2, newUv); // uvpnts[2] = newUV;
triangles.Add(b);
triangles.Add(c);
if (Cfg.pixelPerfectMeshEditing)
{
newVrt.PixPerfect();
}
Dirty = true;
return(newVrt);
}
public override void AssignText(MarkerWithText markers, PainterMesh.MeshPoint point)
{
var selected = MeshMGMT.GetSelectedVertex();
if (point.vertices.Count > 1 || selected == point)
{
if (selected == point)
{
markers.textm.text = (point.vertices.Count > 1) ? (
Path.Combine((point.vertices.IndexOf(MeshMGMT.SelectedUv) + 1).ToString(), point.vertices.Count +
(point.smoothNormal ? "s" : ""))
) : "";
}
else
{
markers.textm.text = point.vertices.Count +
(point.smoothNormal ? "s" : "");
}
}
else
{
markers.textm.text = "";
}
}
public bool DeleteVertexHeal(PainterMesh.MeshPoint vertex)
{
var trs = new PainterMesh.Triangle[3];
var cnt = 0;
foreach (var t in editedMesh.triangles)
{
if (!t.Includes(vertex))
{
continue;
}
if (cnt == 3)
{
return(false);
}
trs[cnt] = t;
cnt++;
}
if (cnt != 3)
{
return(false);
}
trs[0].MergeAround(trs[1], vertex);
editedMesh.triangles.Remove(trs[1]);
editedMesh.triangles.Remove(trs[2]);
editedMesh.meshPoints.Remove(vertex);
editedMesh.NullPointedSelected();
return(true);
}
public void SwapLine(PainterMesh.MeshPoint a, PainterMesh.MeshPoint b)
{
NullPointedSelected();
var trs = new PainterMesh.Triangle[2];
var cnt = 0;
foreach (var tmp in triangles)
{
if (!tmp.Includes(a, b))
{
continue;
}
if (cnt == 2)
{
return;
}
trs[cnt] = tmp;
cnt++;
}
if (cnt != 2)
{
return;
}
var nol0 = trs[0].GetNotOneOf(a, b);
var nol1 = trs[1].GetNotOneOf(a, b);
trs[0].Replace(trs[0].GetByVertex(a), nol1);
trs[1].Replace(trs[1].GetByVertex(b), nol0);
}
public override void AssignText(MarkerWithText markers, PainterMesh.MeshPoint point)
{
var vrt = MeshMGMT.GetSelectedVertex();
if (point.vertices.Count > 1 || vrt == point)
{
var tex = MeshEditorManager.target.meshRenderer.sharedMaterial.mainTexture;
if (vrt == point)
{
var text = (point.vertices.Count > 1) ? ((point.vertices.IndexOf(MeshMGMT.SelectedUv) + 1) + "/" + point.vertices.Count + (point.smoothNormal ? "s" : "")) : "";
float tSize = !tex ? 128 : tex.width;
text += ("uv: " + (MeshMGMT.SelectedUv.EditedUv.x * tSize) + "," + (MeshMGMT.SelectedUv.EditedUv.y * tSize));
markers.textm.text = text;
}
else
{
markers.textm.text = point.vertices.Count +
(point.smoothNormal ? "s" : "");
}
}
else
{
markers.textm.text = "";
}
}
private void Line(PainterMesh.MeshPoint a, PainterMesh.MeshPoint b, Color colA, Color colB)
{
Vector3 v3a = a.WorldPos;
Vector3 v3b = b.WorldPos;
Vector3 diff = (v3b - v3a) / 2;
Line(v3a, v3a + diff, colA);
Line(v3b, v3b - diff, colB);
}
public void MoveVertexToGrid(PainterMesh.MeshPoint vp)
{
UpdateLocalSpaceMousePosition();
var diff = onGridLocal - vp.localPos;
diff.Scale(GridNavigator.Inst().GetGridPerpendicularVector());
vp.localPos += diff;
}
public bool IsInTriangleSet(PainterMesh.MeshPoint vertex)
{
for (var i = 0; i < triVertices; i++)
{
if (triangleSet[i].meshPoint == vertex)
{
return(true);
}
}
return(false);
}
public void DisconnectDragged()
{
Debug.Log("Disconnecting dragged");
var temp = new PainterMesh.MeshPoint(SelectedUv.meshPoint);
editedMesh.meshPoints.Add(temp);
SelectedUv.AssignToNewVertex(temp);
editedMesh.Dirty = true;//_Mesh.GenerateMesh(_targetPiece);
}
public PainterMesh.Vertex GetUvPointAFromLine(PainterMesh.MeshPoint a, PainterMesh.MeshPoint b)
{
foreach (var t in triangles)
{
if (t.Includes(a) && t.Includes(b))
{
return(t.GetByVertex(a));
}
}
return(null);
}
private bool SameTriangleAsPointed(PainterMesh.MeshPoint uvi)
{
if (PointedUv == null)
{
return(false);
}
foreach (PainterMesh.Triangle t in editedMesh.triangles)
{
if (t.Includes(uvi) && t.Includes(PointedUv))
{
return(true);
}
}
return(false);
}
public bool SetAllUVsShared(PainterMesh.MeshPoint pnt)
{
if (pnt.vertices.Count == 1)
{
return(false);
}
while (pnt.vertices.Count > 1)
{
if (!MoveTriangle(pnt.vertices[1], pnt.vertices[0]))
{
break;
}
}
Dirty = true;
return(true);
}
public void Merge(PainterMesh.MeshPoint pointA, PainterMesh.MeshPoint pointB)
{
if (pointA == pointB)
{
return;
}
pointA.StripPointData_StageForDeleteFrom(pointB);
/*foreach (var buv in pointB.vertices)
* {
* var uvs = new Vector2[] { buv.GetUv(0), buv.GetUv(1) };
* pointA.vertices.Add(buv);
* buv.meshPoint = pointA;
* buv.SetUvIndexBy(uvs);
* }*/
meshPoints.Remove(pointB);
}
public PainterMesh.MeshPoint InsertIntoTriangleUniqueVertices(PainterMesh.Triangle a, Vector3 localPos)
{
var newVrt = new PainterMesh.MeshPoint(a.vertexes[0].meshPoint, localPos);
meshPoints.Add(newVrt);
var newUv = new PainterMesh.Vertex[3]; // (newVrt);
var w = a.DistanceToWeight(localPos);
//var newV20 = a.vertexes[0].GetUv(0) * w.x + a.vertexes[1].GetUv(0) * w.y + a.vertexes[2].GetUv(0) * w.z;
//var newV21 = a.vertexes[0].GetUv(1) * w.x + a.vertexes[1].GetUv(1) * w.y + a.vertexes[2].GetUv(1) * w.z;
//Color col = a.uvpnts[0]._color * w.x + a.uvpnts[1]._color * w.y + a.uvpnts[2]._color * w.z;
for (var i = 0; i < 3; i++)
{
newUv[i] = new PainterMesh.Vertex(newVrt);//, newV20, newV21);
a.AssignWeightedData(newUv[i], w);
}
var b = new PainterMesh.Triangle(a.vertexes).CopySettingsFrom(a);
var c = new PainterMesh.Triangle(a.vertexes).CopySettingsFrom(a);
a.vertexes[0] = newUv[0];
b.vertexes[1] = newUv[1];
c.vertexes[2] = newUv[2];
triangles.Add(b);
triangles.Add(c);
a.MakeTriangleVertexUnique(a.vertexes[1]);
b.MakeTriangleVertexUnique(b.vertexes[2]);
c.MakeTriangleVertexUnique(c.vertexes[0]);
if (Cfg.pixelPerfectMeshEditing)
{
newVrt.PixPerfect();
}
Dirty = true;
return(newVrt);
}
public PainterMesh.MeshPoint GetClosestToPos(Vector3 pos)
{
PainterMesh.MeshPoint closest = null;
float dist = 0;
foreach (var v in meshPoints)
{
var newDist = Vector3.Distance(v.localPos, pos);
if (closest != null && !(dist > newDist))
{
continue;
}
dist = newDist;
closest = v;
}
return(closest);
}
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 virtual void AssignText(MarkerWithText markers, PainterMesh.MeshPoint point) => markers.textm.text = "";
private void BreakMesh(Mesh mesh)
{
if (!mesh)
{
return;
}
meshName = mesh.name;
QcSharp.timer.Start("Breaking mesh");
var vCnt = mesh.vertices.Length;
meshPoints = new List <PainterMesh.MeshPoint>();
var vertices = mesh.vertices;
var cols = mesh.colors;
var bW = mesh.boneWeights;
var uv1 = mesh.uv;
var uv2 = mesh.uv2;
bindPoses = mesh.bindposes;
var gotUv1 = (uv1 != null) && (uv1.Length == vCnt);
var gotUv2 = (uv2 != null) && (uv2.Length == vCnt);
var gotColors = (cols != null) && (cols.Length == vCnt);
gotBoneWeights = (bW != null) && (bW.Length == vCnt);
for (var i = 0; i < vCnt; i++)
{
var v = new PainterMesh.MeshPoint(vertices[i]);
meshPoints.Add(v);
var uv = new PainterMesh.Vertex(meshPoints[i], gotUv1 ? uv1[i] : Vector2.zero, gotUv2 ? uv2[i] : Vector2.zero);
}
if (gotColors)
{
for (var i = 0; i < vCnt; i++)
{
var p = meshPoints[i];
p.vertices[0].color = cols[i];
}
}
// "Got Colors".TimerEnd_Restart();
if (gotBoneWeights)
{
for (var i = 0; i < vCnt; i++)
{
var p = meshPoints[i];
p.vertices[0].boneWeight = bW[i];
}
}
// "Gote Bone Weights".TimerEnd_Restart();
shapes = new List <string>();
for (var s = 0; s < mesh.blendShapeCount; s++)
{
for (var v = 0; v < vCnt; v++)
{
meshPoints[v].shapes.Add(new List <PainterMesh.BlendFrame>());
}
shapes.Add(mesh.GetBlendShapeName(s));
for (var f = 0; f < mesh.GetBlendShapeFrameCount(s); f++)
{
blendWeights[s][f] = mesh.GetBlendShapeFrameWeight(s, f);
var normals = new Vector3[vCnt];
var pos = new Vector3[vCnt];
var tng = new Vector3[vCnt];
mesh.GetBlendShapeFrameVertices(s, f, pos, normals, tng);
for (var v = 0; v < vCnt; v++)
{
meshPoints[v].shapes.TryGetLast().Add(new PainterMesh.BlendFrame(pos[v], normals[v], tng[v]));
}
}
}
triangles = new List <PainterMesh.Triangle>();
var points = new PainterMesh.Vertex[3];
subMeshCount = Mathf.Max(1, mesh.subMeshCount);
baseVertex = new List <uint>();
// "Blend Shapes Done".TimerEnd_Restart();
for (var s = 0; s < subMeshCount; s++)
{
baseVertex.Add(mesh.GetBaseVertex(s));
var indices = mesh.GetTriangles(s);
var tCnt = indices.Length / 3;
for (var i = 0; i < tCnt; i++)
{
for (var e = 0; e < 3; e++)
{
points[e] = meshPoints[indices[i * 3 + e]].vertices[0];
}
var t = new PainterMesh.Triangle(points)
{
subMeshIndex = s
};
triangles.Add(t);
}
}
// "Triangles done".TimerEnd_Restart();
if (vCnt > 50)
{
// Debug.Log("Using caching to merge vertex points.");
var mSize = mesh.bounds;
float coef = 10000f / mesh.bounds.size.magnitude;
UnNullableLists <PainterMesh.MeshPoint> distanceGroups = new UnNullableLists <PainterMesh.MeshPoint>();
for (var i = 0; i < vCnt; i++)
{
var p = meshPoints[i];
distanceGroups[Mathf.FloorToInt(p.localPos.magnitude * coef)].Add(p);
}
var grps = distanceGroups.GetAllObjsNoOrder();
// Debug.Log("Got {0} groups".F(grps.Count));
foreach (var groupList in grps)
{
var cnt = groupList.Count;
for (var aInd = 0; aInd < cnt; aInd++)
{
var aPoint = groupList[aInd];
for (var bInd = aInd + 1; bInd < cnt; bInd++)
{
var bPoint = groupList[bInd];
if (bPoint.localPos.Equals(aPoint.localPos))
{
aPoint.StripPointData_StageForDeleteFrom(bPoint);
groupList.RemoveAt(bInd);
bInd--;
cnt--;
}
}
}
}
distanceGroups.Clear();
DeleteStagedMeshPoints();
}
else
{
for (var i = 0; i < vCnt; i++)
{
var main = meshPoints[i];
for (var j = i + 1; j < vCnt; j++)
{
// if (!((meshPoints[j].localPos - main.localPos).magnitude < float.Epsilon)) continue;
if (meshPoints[j].localPos.Equals(main.localPos))
{
Merge(i, j);
j--;
vCnt = meshPoints.Count;
}
}
}
}
QcSharp.timer.End("Breaking mesh done", 1);
mesh = new Mesh();
Dirty = true;
}
public PainterMesh.MeshPoint InsertIntoLine(PainterMesh.MeshPoint a, PainterMesh.MeshPoint b, Vector3 pos)
{
var dstA = Vector3.Distance(pos, a.localPos);
var dstB = Vector3.Distance(pos, b.localPos);
var sum = dstA + dstB;
float weightA = dstB / sum;
float weightB = dstA / sum;
pos = (a.localPos * dstB + b.localPos * dstA) / sum;
var newVrt = new PainterMesh.MeshPoint(a, pos);
meshPoints.Add(newVrt);
var pointTris = a.Triangles();
for (int i = 0; i < pointTris.Count; i++)
{
var tr = pointTris[i];
if (!tr.Includes(b))
{
continue;
}
var auv = tr.GetByVertex(a);
var buv = tr.GetByVertex(b);
var splitUv = tr.GetNotOneOf(a, b);
if (auv == null || buv == null)
{
Debug.LogError("Didn't found a uv");
continue;
}
// var uv = (auv.GetUv(0) * weightA + buv.GetUv(0) * weightA);
// var uv1 = (auv.GetUv(1) * weightA + buv.GetUv(1) * weightA);
// Vertex newUv = null;
// if (Cfg.newVerticesUnique || newVrt.vertices.IsNullOrEmpty())
// newUv = new Vertex(newVrt);
/*else
* {
* foreach (var t in newVrt.vertices)
* if (t.SameUv(uv, uv1))
* newUv = t;
* }*/
//if (newUv == null)
PainterMesh.Vertex newUv = new PainterMesh.Vertex(newVrt);
tr.AssignWeightedData(newUv, tr.DistanceToWeight(pos));
var trb = new PainterMesh.Triangle(tr.vertexes).CopySettingsFrom(tr);
triangles.Add(trb);
tr.Replace(auv, newUv);
if (Cfg.newVerticesUnique)
{
var split = new PainterMesh.Vertex(splitUv);
trb.Replace(splitUv, split);
var newB = new PainterMesh.Vertex(newUv);
trb.Replace(buv, newB);
}
else
{
trb.Replace(buv, newUv);
}
}
Dirty = true;
if (Cfg.pixelPerfectMeshEditing)
{
newVrt.PixPerfect();
}
return(newVrt);
}
public void DRAW_Lines(bool isGizmoCall)
{
GizmoLines = isGizmoCall;
if (!target)
{
return;
}
if (MeshTool.ShowTriangles)
{
if ((PointedTriangle != null) && ((PointedTriangle != SelectedTriangle) || (!MeshTool.ShowSelectedTriangle)))
{
OutlineTriangle(PointedTriangle, Color.cyan, Color.gray);
}
if ((SelectedTriangle != null) && (MeshTool.ShowSelectedTriangle))
{
OutlineTriangle(SelectedTriangle, Color.blue, Color.white);
}
}
if (MeshTool.ShowLines)
{
if (PointedLine != null)
{
Line(PointedLine.points[0].meshPoint, PointedLine.points[1].meshPoint, Color.green);
}
var dv = EditedMesh._draggedVertices;
if (dv.Count > 0)
{
for (int i = 0; i < dv.Count; i++)
{
var a = dv[i];
for (int j = 0; j < dv.Count; j++)
{
Line(a, dv[j], Color.cyan); //var b = dv[j];
}
}
}
for (int i = 0; i < Mathf.Min(verticesShowMax, editedMesh.meshPoints.Count); i++)
{
PainterMesh.MeshPoint vp = editedMesh.meshPoints[i];
if (SameTriangleAsPointed(vp))
{
Line(vp, PointedUv.meshPoint, Color.yellow);
}
}
}
if (MeshTool.ShowVertices)
{
if (PointedUv != null)
{
for (int i = 0; i < editedMesh.triangles.Count; i++)
{
PainterMesh.Triangle td = editedMesh.triangles[i];
if (td.Includes(PointedUv))
{
Line(td.vertexes[1].meshPoint, td.vertexes[0].meshPoint, Color.yellow);
Line(td.vertexes[1].meshPoint, td.vertexes[2].meshPoint, Color.yellow);
Line(td.vertexes[2].meshPoint, td.vertexes[0].meshPoint, Color.yellow);
}
}
}
}
}
private void Line(PainterMesh.MeshPoint a, PainterMesh.MeshPoint b, Color colA) => Line(a.WorldPos, b.WorldPos, colA);
