private void OutlineTriangle(PainterMesh.Triangle t, Color colA, Color colB)
{
//bool vrt = tool == VertexPositionTool.inst;
Line(t.vertexes[0], t.vertexes[1], t.dominantCorner[0] ? colA : colB, t.dominantCorner[1] ? colA : colB);
Line(t.vertexes[1], t.vertexes[2], t.dominantCorner[1] ? colA : colB, t.dominantCorner[2] ? colA : colB);
Line(t.vertexes[0], t.vertexes[2], t.dominantCorner[0] ? colA : colB, t.dominantCorner[2] ? colA : colB);
}
public bool GiveTriangleUniqueVertices(PainterMesh.Triangle triangle)
{
var change = false;
// Mistake here somewhere
var changed = new PainterMesh.Vertex[3];
for (var i = 0; i < 3; i++)
{
var uvi = triangle.vertexes[i];
if (uvi.triangles.Count > 1)
{
changed[i] = new PainterMesh.Vertex(uvi);
change = true;
}
else
{
changed[i] = uvi;
}
}
if (change)
{
triangle.Set(changed);
}
Dirty |= change;
return(change);
}
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 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 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 Vector2 OffsetTileFromTriangle(PainterMesh.Triangle t)
{
Vector2 uv = Vector2.zero;
var trgPos = MeshEditorManager.targetTransform.position;
var diffs = new Vector3[3];
for (var i = 0; i < 3; i++)
{
diffs[i] = t.vertexes[0].meshPoint.WorldPos - trgPos;
}
/* switch (GridNavigator.Inst().gSide) {
* case Gridside.xy:
* uv.x = diff.x;
* uv.y = diff.y;
* break;
* case Gridside.xz:
* uv.x = diff.x;
* uv.y = diff.z;
* break;
* case Gridside.zy:
* uv.x = diff.z;
* uv.y = diff.y;
* break;
* }
*
* uv = (uv + offset);
*
* uv.Scale(tiling);*/
return(uv);
}
private void ProcessPointOnALine(PainterMesh.Vertex a, PainterMesh.Vertex b, PainterMesh.Triangle t)
{
if (EditorInputManager.GetMouseButtonDown(1))
{
SelectedLine = new PainterMesh.LineData(t, a, b);
UpdateLocalSpaceMousePosition();
}
PointedLine = new PainterMesh.LineData(t, new[] { a, b });
}
public void NullPointedSelected()
{
pointedUv = null;
pointedLine = null;
pointedTriangle = null;
selectedUv = null;
selectedLine = null;
selectedTriangle = null;
triVertices = 0;
}
public void MakeTriangleVertUnique(PainterMesh.Triangle tris, PainterMesh.Vertex pnt)
{
if (pnt.triangles.Count == 1)
{
return;
}
var nuv = new PainterMesh.Vertex(pnt.meshPoint, pnt);
tris.Replace(pnt, nuv);
Dirty = true;
}
public bool SetAllVerticesShared(PainterMesh.Triangle tri)
{
var changed = false;
for (var i = 0; i < 3; i++)
{
changed |= SetAllUVsShared(tri[i]);
}
if (changed)
{
Dirty = true;
}
return(changed);
}
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 void AddToTrisSet(PainterMesh.Vertex nuv)
{
triangleSet[triVertices] = nuv;
triVertices++;
if (triVertices == 3)
{
foreach (var t in triangles)
{
if (t.IsSamePoints(triangleSet))
{
t.Set(triangleSet);
Dirty = true;
triVertices = 0;
return;
}
}
}
if (triVertices < 3)
{
return;
}
var td = new PainterMesh.Triangle(triangleSet);
triangles.Add(td);
if (!EditorInputManager.Control)
{
MakeTriangleVertUnique(td, triangleSet[0]);
MakeTriangleVertUnique(td, triangleSet[1]);
MakeTriangleVertUnique(td, triangleSet[2]);
}
triVertices = 0;
Dirty = true;
}
private bool ProcessLinesOnTriangle(PainterMesh.Triangle t)
{
t.wasProcessed = true;
const float precision = 0.05f;
var acc = (targetTransform.InverseTransformPoint(CurrentViewTransform().position) - collisionPosLocal).magnitude;
acc *= precision;
var v0 = t.vertexes[0];
var v1 = t.vertexes[1];
var v2 = t.vertexes[2];
var v0p = v0.meshPoint.distanceToPointed;
var v1p = v1.meshPoint.distanceToPointed;
var v2p = v2.meshPoint.distanceToPointed;
if (QcMath.IsPointOnLine(v0p, v1p, Vector3.Distance(v0.LocalPos, v1.LocalPos), acc))
{
ProcessPointOnALine(v0, v1, t);
return(true);
}
if (QcMath.IsPointOnLine(v1p, v2p, Vector3.Distance(v1.LocalPos, v2.LocalPos), acc))
{
ProcessPointOnALine(v1, v2, t);
return(true);
}
if (QcMath.IsPointOnLine(v2p, v0p, Vector3.Distance(v2.LocalPos, v0.LocalPos), acc))
{
ProcessPointOnALine(v2, v0, t);
return(true);
}
return(false);
}
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 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);
}
}
}
}
}
public void ClearLastPointed()
{
lastFramePointedUv = null;
lastFramePointedLine = null;
lastFramePointedTriangle = null;
}
public void SetLastPointed(PainterMesh.Triangle t)
{
ClearLastPointed();
lastFramePointedTriangle = t;
}
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);
}
