Esempio n. 1
0
 void FinishConstruction()
 {
     //Make the material solid, and make it have collisions
     //GetComponent<PlatformStress>().UpdateMaterial(solidMaterial);
     m.material = solidMaterial;
     GetComponent <Collider>().isTrigger = false;
     platformStress = GetComponent <PlatformStress>();
 }
Esempio n. 2
0
 private void Awake()
 {
     mesh               = GetComponent <MeshFilter>().mesh;
     meshCollider       = GetComponent <BoxCollider>();
     m                  = GetComponent <MeshRenderer>();
     materials          = GetComponent <MeshRenderer>().materials;
     canvas             = GameObject.Find("Canvas");
     resourceManager    = GameObject.Find("DataManager").GetComponent <DataManager>();
     solidMaterial      = m.material;
     ghostMaterial      = m.material;
     intersectingPanels = new List <GameObject>();
     platformStress     = GetComponent <PlatformStress>();
 }
Esempio n. 3
0
    public static GameObject CreatePlane(Vector3[] points, bool collider, Material mat, Material ghost)
    {
        GameObject go           = new GameObject("Plane");
        Vector3    averagePoint = Vector3.zero;

        foreach (Vector3 point in points)
        {
            averagePoint += point;
        }
        averagePoint         /= points.Length;
        go.transform.position = averagePoint;
        MeshFilter   mf = go.AddComponent(typeof(MeshFilter)) as MeshFilter;
        MeshRenderer mr = go.AddComponent(typeof(MeshRenderer)) as MeshRenderer;
        Mesh         m  = new Mesh();

        Vector3 normalN = GetNormal(points);
        Vector3 up      = Vector3.Normalize((points[0] + points[3]) / 2 - ((points[1] + points[2]) / 2));

        go.transform.rotation = Quaternion.LookRotation(normalN, up);

        Vector3 normal = GetNormal(points) * 0.01f;

        Vector3[] transformPoints = new Vector3[] {
            go.transform.InverseTransformPoint(points[0] + normal),
            go.transform.InverseTransformPoint(points[1] + normal),
            go.transform.InverseTransformPoint(points[2] + normal),
            go.transform.InverseTransformPoint(points[3] + normal),
            go.transform.InverseTransformPoint(points[0] + -normal),
            go.transform.InverseTransformPoint(points[1] + -normal),
            go.transform.InverseTransformPoint(points[2] + -normal),
            go.transform.InverseTransformPoint(points[3] + -normal),
        };


        m.vertices = transformPoints;

        Vector2[] uvValues = new Vector2[] {
            new Vector2(transformPoints[0].x - 0.5f, transformPoints[0].y - 0.5f),
            new Vector2(transformPoints[1].x - 0.5f, transformPoints[1].y - 0.5f),
            new Vector2(transformPoints[2].x - 0.5f, transformPoints[2].y - 0.5f),
            new Vector2(transformPoints[3].x - 0.5f, transformPoints[3].y - 0.5f),
        };

        m.uv = new Vector2[] {
            uvValues[0],
            uvValues[1],
            uvValues[2],
            uvValues[3],
            uvValues[0],
            uvValues[1],
            uvValues[2],
            uvValues[3],
        };
        m.triangles = new int[] {
            0, 1, 2,
            0, 2, 3,
            6, 5, 4,
            4, 7, 6,
        };

        mf.mesh = m;

        if (collider)
        {
            go.AddComponent <BoxCollider>().isTrigger = true;
        }

        mr.material = ghost;

        m.RecalculateNormals();
        m.RecalculateBounds();
        m.Optimize();

        PlatformStress st = go.AddComponent(typeof(PlatformStress)) as PlatformStress;
        PlatformHealth hp = go.AddComponent(typeof(PlatformHealth)) as PlatformHealth;
        PanelScript    ps = go.AddComponent(typeof(PanelScript)) as PanelScript;

        ps.solidMaterial = mat;
        ps.ghostMaterial = ghost;
        Rigidbody rb = go.AddComponent(typeof(Rigidbody)) as Rigidbody;

        rb.isKinematic = true;

        go.tag   = "Build";
        go.layer = IGNORERAYCAST;

        return(go);
    }