// Use this for initialization
public void Init(SLO_Join j0, SLO_Join j1, SLO_Join j2, Material mat, float thickness, int index, TriMesh.Extrusion extrusion)
{
m_Join0 = j0;
m_Join1 = j1;
m_Join2 = j2;
m_Index = index;
gameObject.name = "Face " + index;
m_TriMesh = gameObject.AddComponent <TriMesh>() as TriMesh;
m_TriMesh.m_Mat = mat;
m_Thickness = thickness;
m_TriMesh.m_Thickness = m_Thickness * .001f;
// TODO: If edge is tube then the diameter should come from the edge to give a flush finish
m_InnerVerts = new Vector3[3];
m_InnerVerts = TriMeshTest1.FindInnerVertsForFace(j0.transform.position, j1.transform.position, j2.transform.position, ((m_Join0.Diameter / 2f) + m_TabTolerance) * .001f);
// need to put in code to handle inner, outer, center offset and line it up with joint tabs
m_TriMesh.CreateTri(m_InnerVerts[0], m_InnerVerts[1], m_InnerVerts[2], extrusion);
UpdateMeasurements();
// Make selectable
gameObject.tag = "Selectable";
gameObject.AddComponent <MeshCollider>();
}
public void Init(SLO_Edge edge, SLO_Join attachedJoin, SLO_Join lookAtJoin, float maxLength, float joinerMaxPercentageOfEdge)
{
m_Edge = edge;
m_AttachedJoin = attachedJoin;
m_LookAtJoin = lookAtJoin;
m_SleeveLength = maxLength;
m_JoinerMaxPercentageOfEdge = joinerMaxPercentageOfEdge;
m_TubeMesh = new GameObject("Tube Mesh").AddComponent <ProceduralMesh_Tube>();
m_TubeMesh.transform.SetParent(transform);
m_TubeMesh.Init();
m_TubeMesh.transform.localScale = Vector3.one;
m_TubeMesh.transform.localRotation = Quaternion.Euler(90, 0, 0);
m_TubeMesh.m_Renderer.material = SLOResourceManager.Instance.m_MatJoiner;
if (edge.m_Join0 == m_AttachedJoin)
{
edge.m_JoinArm0 = this;
}
else
{
edge.m_JoinArm1 = this;
}
transform.LookAt(LookAt);
UpdateArm();
}
// Create a tab by passing in 3 joins
public void CreateTab(SLO_Join j0, SLO_Join j1, SLO_Join j2)
{
SLO_Join_Tab newTab = new GameObject().AddComponent <SLO_Join_Tab>() as SLO_Join_Tab;
newTab.transform.position = j0.transform.position;
newTab.Init(this, j0, j1, j2, SLOResourceManager.Instance.m_MatJoiner, m_OuterTabs, m_InnerTabs);
m_Tabs.Add(newTab);
}
public void CreateCap(SLO_Join join)
{
print("Creating cap");
SLO_JoinCap newCap = new GameObject("Cap" + Caps.Count).AddComponent <SLO_JoinCap>();
newCap.transform.SetParent(transform);
newCap.Init(join);
Caps.Add(newCap);
}
public void CreateFace(SLO_Join j0, SLO_Join j1, SLO_Join j2)
{
SLO_Face newFace = new GameObject().AddComponent <SLO_Face>() as SLO_Face;
newFace.Init(j0, j1, j2, SLOResourceManager.Instance.m_MatFace, m_FaceThickness, m_Faces.Count, m_FaceExtrusionPlacement);
newFace.transform.SetParent(transform);
// Add to list
m_Faces.Add(newFace);
}
public Vector3 GetOppositeJoinPos(SLO_Join join)
{
if (join == m_Join0)
{
return(m_Join1.transform.position);
}
else
{
return(m_Join0.transform.position);
}
}
public Vector3 GetPositionAlongEdge(SLO_Join join, float distance)
{
if (join == m_Join0)
{
return((m_Join1.transform.position - m_Join0.transform.position).normalized * distance);
}
else
{
return((m_Join0.transform.position - m_Join1.transform.position).normalized * distance);
}
}
public void AddEdge(SLO_Edge edge, float maxJoinLength)
{
m_ConnectedEdges.Add(edge);
SLO_Join lookAtJoin = edge.m_Join0;
if (lookAtJoin.transform.position == transform.position)
{
lookAtJoin = edge.m_Join1;
}
// Create new arm
SLO_Join_Arm newArm = new GameObject("Join Arm").AddComponent <SLO_Join_Arm>();
newArm.name = "Join Arm";
newArm.transform.SetParent(transform);
newArm.Init(edge, this, lookAtJoin, maxJoinLength, m_MaxLengthPercentage);
m_Arms.Add(newArm);
}
public void Init(SLO_Join join)
{
m_Join = join;
m_TriFanMesh = gameObject.AddComponent <TriFanMesh>();
m_Transforms = new Transform[m_Join.ConnectedEdges.Count];
transform.SetParent(m_Join.transform);
transform.localPosition = Vector3.zero;
// Create transforms
for (int i = 0; i < m_Join.ConnectedEdges.Count; i++)
{
Transform t = new GameObject(i.ToString()).transform;
t.SetParent(transform);
m_Transforms[i] = t;
m_Transforms[i].position = m_Join.ConnectedEdges[i].GetOppositeJoinPos(m_Join);
}
m_TriFanMesh.Init(m_Transforms);
}
/*
* void OnMouseDown()
* {
* m_Object.SetSelectedObject(gameObject);
* }
*/
SLO_Edge FindEdgeConnectedToJoin(SLO_Join baseJoin, SLO_Join secondaryJoin)
{
foreach (SLO_Edge edge in baseJoin.ConnectedEdges)
{
if (baseJoin == edge.m_Join0)
{
if (secondaryJoin == edge.m_Join1)
{
return(edge);
}
}
else if (baseJoin == edge.m_Join1)
{
if (secondaryJoin == edge.m_Join0)
{
return(edge);
}
}
}
return(null);
}
public SLOObject ConvertMesh(MeshFilter meshfilter, bool addOuterTabs, bool addInnerTabs)
{
// Create new object
SLOObject sloObj = new GameObject("SLO Obj - ").AddComponent <SLOObject>();
sloObj.transform.position = Vector3.zero;
float m_EdgeDiameter = PlayerPrefs.GetFloat("m_EdgeDiameter", 9.5f);
float m_JoinerLength = PlayerPrefs.GetFloat("m_JoinerLength", 20);
float WallThickness = PlayerPrefs.GetFloat("WallThickness", 2);
Mesh mesh = meshfilter.mesh;
// Create array of edges
for (int i = 0; i < mesh.triangles.Length / 3; i++)
{
// Create edge for 0 - 1
sloObj.CreateEdge(mesh.vertices[mesh.triangles[(i * 3)]], mesh.vertices[mesh.triangles[(i * 3) + 1]]);
// Create edge for 1 - 2
sloObj.CreateEdge(mesh.vertices[mesh.triangles[(i * 3) + 1]], mesh.vertices[mesh.triangles[(i * 3) + 2]]);
// Create edge for 2 - 0
sloObj.CreateEdge(mesh.vertices[mesh.triangles[(i * 3) + 2]], mesh.vertices[mesh.triangles[(i * 3)]]);
}
#region Find and remove duplicate edges
// Check if any edges are the same and remove copies
// If edges share a vertex add them to the appropriate connection list
List <SLO_Edge> edgesToRemove = new List <SLO_Edge>();
for (int i = 0; i < sloObj.Edges.Count; i++)
{
SLO_Edge baseEdge = sloObj.Edges[i];
if (edgesToRemove.Contains(baseEdge))
{
continue;
}
for (int j = 0; j < sloObj.Edges.Count; j++)
{
if (j == i)
{
continue;
}
SLO_Edge compareEdge = sloObj.Edges[j];
if (edgesToRemove.Contains(compareEdge))
{
continue;
}
// If not same length then continue
if (baseEdge.Length != compareEdge.Length)
{
continue;
}
else if (baseEdge.m_VertexPos0 == compareEdge.m_VertexPos0 && baseEdge.m_VertexPos1 == compareEdge.m_VertexPos1)
{
edgesToRemove.Add(baseEdge);
}
else if (baseEdge.m_VertexPos0 == compareEdge.m_VertexPos1 && baseEdge.m_VertexPos1 == compareEdge.m_VertexPos0)
{
edgesToRemove.Add(baseEdge);
}
}
}
// Remove duplicate edges
foreach (SLO_Edge e in edgesToRemove)
{
if (e != null)
{
sloObj.Edges.Remove(e);
DestroyImmediate(e.gameObject);
}
}
#endregion
// Index the remaining edges
for (int i = 0; i < sloObj.Edges.Count; i++)
{
sloObj.Edges[i].m_Index = i;
sloObj.Edges[i].name = "Edge " + i;
}
// Find all unique verts
List <Vector3> uniqueVertPositions = new List <Vector3>();
for (int i = 0; i < mesh.vertices.Length; i++)
{
if (!uniqueVertPositions.Contains(mesh.vertices[i]))
{
uniqueVertPositions.Add(mesh.vertices[i]);
}
}
// Set to the transform of the mesh
sloObj.transform.position = transform.position;
// Create joiners for each unique vert
for (int i = 0; i < uniqueVertPositions.Count; i++)
{
sloObj.CreateJoiner(meshfilter.transform.TransformPoint(uniqueVertPositions[i]));
}
// Assign joiners to edges
for (int i = 0; i < sloObj.Edges.Count; i++)
{
for (int j = 0; j < sloObj.Joiners.Count; j++)
{
if (meshfilter.transform.TransformPoint(sloObj.Edges[i].m_VertexPos0) == sloObj.Joiners[j].transform.position)
{
sloObj.Edges[i].m_Join0 = sloObj.Joiners[j];
}
if (meshfilter.transform.TransformPoint(sloObj.Edges[i].m_VertexPos1) == sloObj.Joiners[j].transform.position)
{
sloObj.Edges[i].m_Join1 = sloObj.Joiners[j];
}
}
}
// Assign joiners to edges
for (int i = 0; i < sloObj.Edges.Count; i++)
{
sloObj.Edges[i].m_Join0.AddEdge(sloObj.Edges[i], m_JoinerLength);
sloObj.Edges[i].m_Join1.AddEdge(sloObj.Edges[i], m_JoinerLength);
}
// Initalize edges
for (int i = 0; i < sloObj.Edges.Count; i++)
{
sloObj.Edges[i].transform.position = sloObj.Edges[i].m_Join0.transform.position;
sloObj.Edges[i].transform.LookAt(sloObj.Edges[i].m_Join1.transform.position);
sloObj.Edges[i].transform.SetParent(sloObj.transform);
sloObj.Edges[i].AddEdgeMesh();
// sloObj.Edges[i].SetMaterial(SLOManager.Instance.m_MatEdge);
}
// Create faces
for (int i = 0; i < mesh.triangles.Length / 3f; i++)
{
int triIndex = (i * 3);
Vector3 v0 = meshfilter.transform.TransformPoint(mesh.vertices[mesh.triangles[triIndex]]);
Vector3 v1 = meshfilter.transform.TransformPoint(mesh.vertices[mesh.triangles[triIndex + 1]]);
Vector3 v2 = meshfilter.transform.TransformPoint(mesh.vertices[mesh.triangles[triIndex + 2]]);
SLO_Join j0 = sloObj.FindJoinFromPos(v0);
SLO_Join j1 = sloObj.FindJoinFromPos(v1);
SLO_Join j2 = sloObj.FindJoinFromPos(v2);
sloObj.CreateFace(j0, j1, j2);
}
for (int i = 0; i < sloObj.Faces.Count; i++)
{
int triIndex = (i * 3);
SLO_Join j0 = sloObj.Faces[i].Join0; // m_MeshParent.TransformPoint(m_Mesh.vertices[m_Mesh.triangles[triIndex]]);
SLO_Join j1 = sloObj.Faces[i].Join1; //m_MeshParent.TransformPoint(m_Mesh.vertices[m_Mesh.triangles[triIndex + 1]]);
SLO_Join j2 = sloObj.Faces[i].Join2; //m_MeshParent.TransformPoint(m_Mesh.vertices[m_Mesh.triangles[triIndex + 2]]);
// Tri 1
sloObj.CreateTab(j0, j1, j2);
sloObj.CreateTab(j1, j2, j0);
sloObj.CreateTab(j2, j0, j1);
}
sloObj.CreateCaps();
sloObj.RecalculateAllStats();
// Deactivate original meshfilter
meshfilter.transform.gameObject.SetActive(false);
return(sloObj);
}
// Use this for initialization
public void Init(SLOObject sloObj, SLO_Join j0, SLO_Join j1, SLO_Join j2, Material mat, bool makeInner, bool makeOuter)
{
#region Initialization of references
// Sets reference to SLO object
m_Object = sloObj;
// Set name
gameObject.name = "Tab";
// Setup the connect joins
m_BaseJoin = j0;
m_ConnctedJoin0 = j1;
m_ConnctedJoin1 = j2;
// Find arms
for (int i = 0; i < m_BaseJoin.m_Arms.Count; i++)
{
if (m_BaseJoin.m_Arms[i].LookAtJoin == m_ConnctedJoin0)
{
m_Arm12 = m_BaseJoin.m_Arms[i];
}
if (m_BaseJoin.m_Arms[i].LookAtJoin == m_ConnctedJoin1)
{
m_Arm13 = m_BaseJoin.m_Arms[i];
}
}
#endregion
#region Calculations
m_InnerVerts = TriMeshTest1.FindInnerVerts(m_BaseJoin.transform.position, m_ConnctedJoin0.transform.position, m_ConnctedJoin1.transform.position, (m_BaseJoin.Diameter / 2f) * .001f, m_BaseJoin.Length * .001f);
Vector3 v0 = m_InnerVerts[0];
Vector3 v1 = m_InnerVerts[1];
Vector3 v2 = m_InnerVerts[2];
// Get the normal of the triangle
m_Normal = Vector3.Cross(v1 - v0, v2 - v0).normalized;
// calculate the offset based on spacing
//Vector3 normalOffset = m_Normal * ((SpacingRadius / 2f)) * .001f;
#endregion
if (makeInner)
{
// FIND INNER VERTS HERE
m_TabInner = new GameObject().AddComponent <TriMesh>() as TriMesh;
m_TabInner.name = "Tab Inner";
m_TabInner.transform.SetParent(transform);
m_TabInner.transform.position = Vector3.zero;
m_TabInner.transform.rotation = Quaternion.identity;
m_TabInner.m_Mat = mat;
m_TabInner.m_Thickness = .001f;
m_TabInner.CreateTri(v0, v1, v2, TriMesh.Extrusion.Center);
}
if (makeOuter)
{
m_TabOuter = new GameObject().AddComponent <TriMesh>() as TriMesh;
m_TabOuter.name = "Tab Outer";
m_TabOuter.transform.SetParent(transform);
m_TabOuter.m_Mat = mat;
m_TabOuter.m_Thickness = .001f;
m_TabOuter.CreateTri(v0, v1, v2, TriMesh.Extrusion.Center);
}
//transform.SetParent (m_BaseJoin.transform );
}
public void SetSelectedJoint(SLO_Join join)
{
m_JointPosXInput.text = m_Manager.SelectedJoin.transform.position.x.ToString();
m_JointPosYInput.text = m_Manager.SelectedJoin.transform.position.y.ToString();
m_JointPosZInput.text = m_Manager.SelectedJoin.transform.position.z.ToString();
}
