public void Init(SLOObject sloObj, Vector3 vertexPos0, Vector3 vertexPos1)
        {
            m_Object = sloObj;

            m_VertexPos0 = vertexPos0;
            m_VertexPos1 = vertexPos1;

            m_Length = (vertexPos0 - vertexPos1).magnitude;

            gameObject.tag = "Selectable";
        }
        public void Init(SLOObject sloObj, int index, Vector3 pos, float joinerRadius, Material mat)
        {
            m_Object = sloObj;

            m_Index    = index;
            m_Diameter = joinerRadius;

            transform.position = pos;

            // TODO: save ref to spheref or scaling
            m_SphereMesh = GameObject.CreatePrimitive(PrimitiveType.Sphere).GetComponent <MeshRenderer>();
            m_SphereMesh.gameObject.SetParentAndZero(transform);
            m_SphereMesh.transform.localScale = Vector3.one * (m_Diameter / 1000f);
            m_SphereMesh.GetComponent <MeshRenderer>().material = mat;

            SphereCollider collider = gameObject.AddComponent <SphereCollider>();

            collider.radius = m_Diameter * .001f;

            gameObject.tag = "Selectable";
        }
示例#3
0
        void Update()
        {
            if (Input.GetKeyDown(KeyCode.C))
            {
                m_SelectedSLOObject = m_MeshConvertor.ConvertMesh(m_MeshFilterTest, true, true);
            }

            // Testing
            if (Input.GetKeyDown(KeyCode.Delete))
            {
                if (m_SelectedComponentType == ComponentType.Face)
                {
                    SLO_Face face = m_SelectedComponent.GetComponent <SLO_Face>();

                    m_SelectedSLOObject.Faces.Remove(face);

                    // TODO: Remove tabs?

                    Destroy(face.gameObject);

                    m_GUI.m_SelectedElement = null;
                }
                else if (m_SelectedComponentType == ComponentType.Edge)
                {
                    SLO_Edge edge = m_SelectedComponent.GetComponent <SLO_Edge>();

                    // Remove form list
                    m_SelectedSLOObject.Edges.Remove(edge);

                    edge.Delete();

                    // set gui back to null
                    m_GUI.m_SelectedElement = null;
                }
            }
        }
示例#4
0
        // Uber hax, fix with maths later
        void LayFacesFlat(SLOObject sloObject)
        {
            // reference to faces from the object
            List <SLO_Face> faces = sloObject.Faces;

            GameObject parent = new GameObject("_Flat faces parent");

            parent.transform.position = Vector3.right * 5;
            TriMesh[] flatFaces   = new TriMesh[faces.Count];
            float     xPos        = 7;
            float     yPos        = 0;
            float     prevTriDist = 0;
            float     largestTri  = 0;

            // For all faces
            for (int i = 0; i < faces.Count; i++)
            {
                // Create a new trimesh
                TriMesh newTriMesh = new GameObject(parent.name + " - Flat face " + i).AddComponent <TriMesh>();
                newTriMesh.gameObject.layer = 8;
                Vector3 midPoint = (faces[i].Join0.transform.position + faces[i].Join1.transform.position + faces[i].Join2.transform.position) / 3f;

                newTriMesh.CreateTri(
                    newTriMesh.transform.TransformPoint(faces[i].Join0.transform.position - midPoint),
                    newTriMesh.transform.TransformPoint(faces[i].Join1.transform.position - midPoint),
                    newTriMesh.transform.TransformPoint(faces[i].Join2.transform.position - midPoint),
                    TriMesh.Extrusion.None);

                // Apply material
                newTriMesh.GetComponent <MeshRenderer>().material = SLOResourceManager.Instance.m_MatFace;

                #region Spacing and placement
                // Get max vertex distance on x to make sure next tri is spaced accordingly
                float maxVertDistance = 0;
                for (int j = 0; j < 3; j++)
                {
                    float dist = Vector3.Distance(newTriMesh.transform.position, newTriMesh.transform.TransformPoint(newTriMesh.BaseVerts[j]));
                    if (dist > maxVertDistance)
                    {
                        maxVertDistance = dist;
                    }
                }
                xPos += maxVertDistance + prevTriDist;

                prevTriDist = maxVertDistance;

                newTriMesh.transform.rotation = Quaternion.FromToRotation(faces[i].Normal, -Vector3.forward);

                if (maxVertDistance > largestTri)
                {
                    largestTri = maxVertDistance;
                }

                if (i == faces.Count / 3)
                {
                    xPos = 7;
                    yPos = largestTri * 2f;
                }
                else if (i == (int)(faces.Count / 3) * 2)
                {
                    xPos = 7;
                    yPos = largestTri * 4f;
                }

                Vector3 offset = new Vector3(xPos, yPos, -1);

                newTriMesh.transform.position = offset;
                newTriMesh.transform.parent   = parent.transform;
                #endregion

                TextMesh edgeLength0 = new GameObject("Textmesh").AddComponent <TextMesh>();
                edgeLength0.name             = "Edge text v0-v1";
                edgeLength0.gameObject.layer = 8;
                edgeLength0.transform.SetParent(newTriMesh.transform);
                edgeLength0.transform.position   = newTriMesh.Edge01MidPoint;
                edgeLength0.transform.localScale = Vector3.one * .02f;
                edgeLength0.text = faces[i].Edge2Length.ToString("##");

                TextMesh edgeLength1 = new GameObject("Textmesh").AddComponent <TextMesh>();
                edgeLength1.name             = "Edge text v1-v2";
                edgeLength1.gameObject.layer = 8;
                edgeLength1.transform.SetParent(newTriMesh.transform);
                edgeLength1.transform.position   = newTriMesh.Edge12MidPoint;
                edgeLength1.transform.localScale = Vector3.one * .02f;
                edgeLength1.text = faces[i].Edge1Length.ToString("##");

                TextMesh edgeLength2 = new GameObject("Textmesh").AddComponent <TextMesh>();
                edgeLength2.name             = "Edge text v2-v0";
                edgeLength2.gameObject.layer = 8;
                edgeLength2.transform.SetParent(newTriMesh.transform);
                edgeLength2.transform.position   = newTriMesh.Edge20MidPoint;
                edgeLength2.transform.localScale = Vector3.one * .02f;
                edgeLength2.text = faces[i].Edge0Length.ToString("##");

                flatFaces[i] = newTriMesh;
            }
        }
        // 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 );
        }