public void TagPolyVerts(DPoly dp)
{
for (int i = 0; i < dp.vert.Count; i++)
{
vert_info[dp.vert[i]].tag = true;
}
}
public void PolysTriangulateFan(bool mark_them = false)
{
List <DPoly> polys = GetMarkedPolys();
for (int i = 0; i < polys.Count; i++)
{
// Add the center as a vert
int center_vert = vertex.Count;
Vector3 center_pos = polys[i].FindCenter(this);
Vector2 center_uv = polys[i].FindUVCenter();
AddVertexEditor(center_pos, false);
// Create a new triangle for each vert
List <int> vrts = new List <int>();
for (int j = 0; j < polys[i].vert.Count; j++)
{
vrts.Clear();
vrts.Add(center_vert);
vrts.Add(polys[i].vert[j]);
vrts.Add(polys[i].vert[(j + 1) % polys[i].vert.Count]);
DPoly dp = new DPoly(vrts, polys[i].tex_index, this, false);
dp.tex_uv[0] = center_uv;
dp.tex_uv[1] = polys[i].tex_uv[j];
dp.tex_uv[2] = polys[i].tex_uv[(j + 1) % polys[i].vert.Count];
dp.marked = mark_them;
polygon.Add(dp);
}
}
// Remove the old polys
for (int i = 0; i < polys.Count; i++)
{
polygon.Remove(polys[i]);
}
}
public void CopyPolygonSameVerts(DPoly src_dp)
{
DPoly new_dp = new DPoly(src_dp);
polygon.Add(new_dp);
new_dp.marked = src_dp.marked;
}
// Can you combine this poly with the passed in one
public static bool CanCombinePolys(DPoly p1, DPoly p2, DMesh dm)
{
// First check for two shared verts
int count = 0;
for (int i = 0; i < p1.num_verts; i++)
{
for (int j = 0; j < p2.num_verts; j++)
{
if (p1.vert[i] == p2.vert[j])
{
count += 1;
}
}
}
if (count != 2)
{
return(false);
}
// Check for normals that align
Vector3 n1 = CalculatePolyNormal(p1, dm);
Vector3 n2 = CalculatePolyNormal(p2, dm);
if (Vector3.Dot(n1, n2) >= 0.995f)
{
return(true);
}
else
{
return(false);
}
}
public void BuildMarkedGeometry()
{
GL.PushMatrix();
GL.DeleteLists(GL_MARKED, 1);
GL.NewList(GL_MARKED, ListMode.Compile);
{
for (int i = 0; i < editor.m_dmesh.polygon.Count; i++)
{
DPoly dp = editor.m_dmesh.polygon[i];
if (dp.marked)
{
GL.Begin(PrimitiveType.Polygon);
GL.Color3(C_marked);
CreatePolygon(dp, editor.m_dmesh);
GL.End();
}
}
// Verts
GL.Begin(PrimitiveType.Points);
GL.Color3(C_marked);
for (int i = 0; i < editor.m_dmesh.vertex.Count; i++)
{
if (editor.m_dmesh.vert_info[i].marked)
{
CreateVertexPoint(editor.m_dmesh.vertex[i]);
}
}
GL.End();
}
GL.EndList();
GL.PopMatrix();
}
public void PolysTriangulateVert(bool mark_them = false)
{
List <DPoly> polys = GetMarkedPolys();
for (int i = 0; i < polys.Count; i++)
{
// Create a new triangle for each vert - 2
List <int> vrts = new List <int>();
for (int j = 1; j < polys[i].vert.Count - 1; j++)
{
vrts.Clear();
vrts.Add(polys[i].vert[0]);
vrts.Add(polys[i].vert[j]);
vrts.Add(polys[i].vert[j + 1]);
DPoly dp = new DPoly(vrts, polys[i].tex_index, this, false);
dp.tex_uv[0] = polys[i].tex_uv[0];
dp.tex_uv[1] = polys[i].tex_uv[j];
dp.tex_uv[2] = polys[i].tex_uv[j + 1];
dp.marked = mark_them;
polygon.Add(dp);
}
}
// Remove the old polys
for (int i = 0; i < polys.Count; i++)
{
polygon.Remove(polys[i]);
}
}
public void CreatePolygon(DPoly poly, DMesh mesh)
{
for (int i = 0; i < poly.num_verts; i++) {
GL.TexCoord2(poly.tex_uv[i]);
GL.Normal3(poly.normal[i]);
GL.Vertex3(mesh.vertex[poly.vert[i]]);
}
}
public static Vector3 CalculatePolyNormal(DPoly p, DMesh dm)
{
Vector3 n = Vector3.Zero;
n = Utility.FindNormal(dm.vertex[p.vert[0]], dm.vertex[p.vert[1]], dm.vertex[p.vert[2]]);
return(n);
}
public void CreateVertNormals(DPoly poly, DMesh mesh)
{
Vector3 v;
for (int i = 0; i < poly.num_verts; i++) {
v = mesh.vertex[poly.vert[i]];
CreateLine(v, v + poly.normal[i] * 0.1f);
}
}
public void CopyMarkedPolys(DMesh src, bool all = false, bool tag_new = false)
{
// Tag all the src verts in marked polys
List <int> old_vert_index = new List <int>();
List <int> new_vert_index = new List <int>();
src.TagAllVerts(false);
ClearAllMarkedPoly();
foreach (DPoly dp in src.polygon)
{
if (dp.marked || all)
{
for (int i = 0; i < dp.num_verts; i++)
{
src.vert_info[dp.vert[i]].tag = true;
}
}
}
// Copy all tagged verts to me
// - And create lists for conversion
for (int i = 0; i < src.vertex.Count; i++)
{
if (src.vert_info[i].tag)
{
old_vert_index.Add(i);
new_vert_index.Add(vertex.Count);
vertex.Add(src.vertex[i]);
vert_info.Add(new DVert());
}
}
// Copy all marked polys to me (converting vert idxs in process)
foreach (DPoly old_dp in src.polygon)
{
if (old_dp.marked || all)
{
DPoly new_dp = new DPoly(old_dp);
polygon.Add(new_dp);
new_dp.marked = true;
new_dp.tag = tag_new;
for (int i = 0; i < new_dp.num_verts; i++)
{
int old_index = new_dp.vert[i];
old_index = FindIdxInList(old_index, old_vert_index);
if (old_index > -1 && old_index < new_vert_index.Count)
{
new_dp.vert[i] = new_vert_index[old_index];
}
else
{
Utility.DebugPopup("This is bad, copy-paste failed", "ERROR!");
}
}
}
}
}
public void ConvertTrisToPolysRaw()
{
polygon.Clear();
foreach (DTriangle t in triangle)
{
DPoly p = new DPoly(t);
polygon.Add(p);
}
}
public void ExtrudeMarkedVerts(float dist)
{
List <int> verts = GetMarkedVerts();
if (verts.Count > 1)
{
ClearAllMarkedPoly();
// Figure out which direction to go (lesser of X/Y/Z)
Vector3 min, max;
GetVertBounds(verts, out min, out max);
Vector3 diff = max - min;
Vector3 extrude_vec = (max.Y < 0f ? -Vector3.UnitY : Vector3.UnitY);
if (diff.X < diff.Y && diff.X < diff.Z)
{
extrude_vec = (max.X < 0f ? -Vector3.UnitX : Vector3.UnitX);
}
else if (diff.Z < diff.Y && diff.Z < diff.X)
{
extrude_vec = (max.X < 0f ? -Vector3.UnitZ : Vector3.UnitZ);
}
extrude_vec *= dist;
int first_vert = vertex.Count;
// Create the new verts in the extrude direction
foreach (int idx in verts)
{
AddVertexEditor(vertex[idx] + extrude_vec);
}
// Create a new polygon for each vert except the last
List <int> v_list = new List <int>();
for (int i = 0; i < verts.Count - 1; i++)
{
v_list.Clear();
v_list.Add(verts[i]);
v_list.Add(verts[(i + 1)]);
v_list.Add(first_vert + (i + 1));
v_list.Add(first_vert + i);
DPoly new_poly = new DPoly(v_list, -1, this);
new_poly.marked = true;
polygon.Add(new_poly);
}
// Unmarked the old verts and mark the new ones
for (int i = 0; i < verts.Count; i++)
{
vert_info[verts[i]].marked = false;
vert_info[first_vert + i].marked = true;
}
}
else
{
editor.AddOutputText("Must mark at least two verts to extrude");
}
}
public void ReverseWindingOrder()
{
DPoly flip_tri = new DPoly(this);
ClearLists();
for (int i = 0; i < num_verts; i++)
{
vert.Add(flip_tri.vert[num_verts - 1 - i]);
normal.Add(flip_tri.normal[num_verts - 1 - i]);
tex_uv.Add(flip_tri.tex_uv[num_verts - 1 - i]);
}
}
public int FindSharedVertNotThisOne(DPoly dp, int idx)
{
for (int i = 0; i < num_verts; i++)
{
if (dp.vert.Contains(vert[i]) && vert[i] != idx)
{
return(vert[i]);
}
}
return(-1);
}
public void UVAlignToPoly()
{
if (selected_poly > -1)
{
TagAllPolys(false);
DPoly dp = polygon[selected_poly];
dp.tag = true;
UVAlignAdjacentMarkedPolys(dp);
}
}
public bool SharesAllVerts(DPoly dp)
{
for (int i = 0; i < dp.num_verts; i++)
{
if (!vert.Contains(dp.vert[i]))
{
return(false);
}
}
return(true);
}
public void CreatePolyFromVerts(int v_start, int v_end)
{
List <int> v_idx = new List <int>();
for (int i = v_start; i < v_end; i++)
{
v_idx.Add(i);
}
DPoly poly = new DPoly(v_idx, -1, this);
poly.marked = true;
polygon.Add(poly);
num_marked_polys += 1;
}
public bool SharesSomeVerts(DPoly dp)
{
int count = 0;
for (int i = 0; i < dp.num_verts; i++)
{
if (vert.Contains(dp.vert[i]))
{
count += 1;
}
}
return(count >= 1);
}
public void SplitPolygonByVerts(DPoly dp, int verts0, int verts1)
{
// Get the two sets of verts (those after v0, those after v1)
List <int> verts_after0 = dp.GetVertsStartUpTo(verts0, verts1);
List <int> verts_after1 = dp.GetVertsStartUpTo(verts1, verts0);
// Then make a new polygon copy
int new_poly_idx = polygon.Count;
CopyPolygonSameVerts(dp);
// Remove unneeded verts from both
dp.RemoveVertList(verts_after0);
polygon[new_poly_idx].RemoveVertList(verts_after1);
}
public void CreateTriFromVerts(int v1, int v2, int v3, bool marked = true)
{
List <int> v_idx = new List <int>();
v_idx.Add(v1);
v_idx.Add(v2);
v_idx.Add(v3);
DPoly poly = new DPoly(v_idx, -1, this);
if (marked)
{
poly.marked = true;
num_marked_polys += 1;
}
polygon.Add(poly);
}
public void MarkDuplicatePolys()
{
TagAllPolys(false);
ClearAllMarkedPoly();
for (int i = 0; i < polygon.Count; i++)
{
for (int j = i + 1; j < polygon.Count; j++)
{
if (DPoly.HasThreeOrMoreCloseVerts(polygon[i], polygon[j], this))
{
polygon[i].marked = true;
}
}
}
}
public DPoly(DPoly src)
{
num_verts = src.num_verts;
ClearLists();
for (int i = 0; i < num_verts; i++)
{
vert.Add(src.vert[i]);
normal.Add(src.normal[i]);
tex_uv.Add(src.tex_uv[i]);
}
tex_index = src.tex_index;
flags = src.flags;
smoothing = src.smoothing;
marked = src.marked;
}
public void BuildSelectedGeometry()
{
GL.PushMatrix();
GL.DeleteLists(GL_SELECT, 1);
GL.NewList(GL_SELECT, ListMode.Compile);
{
GL.Begin(PrimitiveType.Polygon);
int idx = editor.m_dmesh.selected_poly;
if (idx > -1 && idx < editor.m_dmesh.polygon.Count)
{
DPoly dp = editor.m_dmesh.polygon[idx];
if (editor.m_edit_mode == EditMode.POLY)
{
GL.Color3(dp.marked ? C_select_marked_main : C_select_main);
}
else
{
GL.Color3(dp.marked ? C_select_marked : C_select);
}
CreatePolygon(dp, editor.m_dmesh);
}
GL.End();
// Verts
GL.Begin(PrimitiveType.Points);
idx = editor.m_dmesh.selected_vert;
if (idx > -1 && idx < editor.m_dmesh.vertex.Count)
{
Vector3 v = editor.m_dmesh.vertex[idx];
DVert dv = editor.m_dmesh.vert_info[idx];
if (editor.m_edit_mode == EditMode.VERT)
{
GL.Color3(dv.marked ? C_select_marked_main : C_select_main);
}
else
{
GL.Color3(dv.marked ? C_select_marked : C_select);
}
CreateVertexPoint(v);
}
GL.End();
}
GL.EndList();
GL.PopMatrix();
}
// Recursive alignment
public void UVAlignAdjacentMarkedPolys(DPoly dp)
{
List <DPoly> poly_list = GetMarkedPolys();
for (int i = 0; i < poly_list.Count; i++)
{
if (!poly_list[i].tag)
{
if (DPoly.HasTwoOrMoreSharedVerts(dp, poly_list[i]))
{
poly_list[i].tag = true;
poly_list[i].UVAlignToPoly(dp, this);
UVAlignAdjacentMarkedPolys(poly_list[i]);
}
}
}
}
public void MaybeCutPolygon(GLView view, bool dont_cut = false)
{
if (m_dmesh.selected_poly > -1 && m_dmesh.selected_poly < m_dmesh.polygon.Count)
{
DPoly dp = m_dmesh.polygon[m_dmesh.selected_poly];
SaveStateForUndo("Maybe cut polygon");
Vector3 pos = ScreenToWorldPos(view.m_mouse_pos, view, false);
if (m_cut_poly_state == 0)
{
m_cut_polyvert_start = dp.GetClosestEdgeFV(view, m_dmesh, pos, -1, true);
m_cut_poly_state = 1;
}
else
{
m_cut_polyvert_end = dp.GetClosestEdgeFV(view, m_dmesh, pos, m_cut_polyvert_start);
int v1 = dp.vert[m_cut_polyvert_start];
int v2 = dp.vert[(m_cut_polyvert_start + 1) % dp.num_verts];
int v3 = dp.vert[m_cut_polyvert_end];
int v4 = dp.vert[(m_cut_polyvert_end + 1) % dp.num_verts];
// Add the verts
DPoly.AddedVert = -1;
dp.MaybeAddVertBetween(v1, v2, m_dmesh);
int new_v0 = DPoly.AddedVert;
DPoly.AddedVert = -1;
dp.MaybeAddVertBetween(v3, v4, m_dmesh);
int new_v1 = DPoly.AddedVert;
m_cut_poly_state = 0;
if (!dont_cut)
{
m_dmesh.SplitPolygonByVerts(dp, new_v0, new_v1);
}
AddOutputText("Cut a polygon");
}
RefreshGeometry(true);
}
else
{
AddOutputText("Select a polygon to cut");
}
}
public static bool HasThreeOrMoreCloseVerts(DPoly p1, DPoly p2, DMesh dm)
{
int count = 0;
for (int i = 0; i < p1.num_verts; i++)
{
for (int j = 0; j < p2.num_verts; j++)
{
if (Utility.AlmostOverlapping(dm.vertex[p1.vert[i]], dm.vertex[p2.vert[j]]))
{
count += 1;
}
}
}
return(count >= 3);
}
public static bool HasTwoOrMoreSharedVerts(DPoly p1, DPoly p2)
{
int count = 0;
for (int i = 0; i < p1.num_verts; i++)
{
for (int j = 0; j < p2.num_verts; j++)
{
if (p1.vert[i] == p2.vert[j])
{
count += 1;
}
}
}
return(count >= 2);
}
public void SmoothSharedVerts(DPoly dp)
{
should_normalize = true;
dp.should_normalize = true;
for (int i = 0; i < num_verts; i++)
{
for (int j = 0; j < dp.num_verts; j++)
{
// Verts match
if (vert[i] == dp.vert[j])
{
// Add the normals, these will get normalized after all are smoothed
normal[i] += dp.face_normal;
dp.normal[j] += face_normal;
}
}
}
}
public void CreateQuadFromVerts(int v1, int v2, int v3, int v4, bool marked = true, bool tagged = false)
{
List <int> v_idx = new List <int>();
v_idx.Add(v1);
v_idx.Add(v2);
v_idx.Add(v3);
v_idx.Add(v4);
DPoly poly = new DPoly(v_idx, -1, this);
poly.tag = tagged;
if (marked)
{
poly.marked = true;
num_marked_polys += 1;
}
polygon.Add(poly);
}
public void DeserializePolys(JObject root)
{
// Just initialize vert info
for (int i = 0; i < vertex.Count; i++)
{
DVert d_vert = new DVert();
vert_info.Add(d_vert);
}
JObject j_polys = root["polys"].GetObject();
foreach (var kvp in j_polys)
{
JObject j_poly = kvp.Value.GetObject();
DPoly d_poly = new DPoly(j_poly);
polygon.Add(d_poly);
}
}
