Beispiel #1
0
    void Start()
    {
        // Setup food
        //FoodManager.instance.MakeMePartOfTheFood(gameObject); // skulle bruges til foodmanager'en for at samle en madret
        // Sæt rigid til at være madens rigidbody
        rigid = GetComponent <Rigidbody>();
        // Hvis der skal udregnes masse af dette mad, så gør dette:
        if (calculateMyMass)
        {
            rigid.mass = VolumeAndMass.MassOfMesh(GetComponent <MeshFilter>().mesh, density);
        }
        // Bliv ved med at forsøge at sætte omgivelsernes temperatur til 20, så, hvis intet påvirker temperaturen af maden, vil madens temperatur gå mod rumtemperatur (20 grader c)
        InvokeRepeating("SetRoomTemperature", 0.1f, 1f);
        // Fejlbesked, hvis maden ikke har fået sat et ID.
        if (ID == "unknown")
        {
            Debug.LogWarning(gameObject + " has the ID of: '" + ID + "'. Is this on purpose?");
        }
        // Gør så maden ikke har noget parent, da der kommer fejl idet maden har et parent. Grunden til at maden har et parent i editoren, er for at gøre det mere overskueligt for os selv.
        gameObject.transform.parent = null;

        // Hvis maden er mad som kan starte med at bygges på, så gør så den kan bygges på.
        if (canBeBuildOnFromStart)
        {
            canBeBuildOn = true;
        }
    }
    public static void Cut(GameObject _originalGameObject, Vector3 _contactPoint, Vector3 _direction, Material _cutMaterial = null, bool fill = true, bool _addRigidbody = false)
    {
        if (currentlyCutting)
        {
            return;
        }

        currentlyCutting = true;

        //We are instantiating a plane through our initial object to seperate the left and right side from each other
        Plane plane = new Plane(_originalGameObject.transform.InverseTransformDirection(-_direction), _originalGameObject.transform.InverseTransformPoint(_contactPoint));

        originalMesh = _originalGameObject.GetComponent <MeshFilter>().mesh;
        List <Vector3> addedVertices = new List <Vector3>();

        //We are getting two new generated meshes for our left and right side
        GeneratedMesh leftMesh  = new GeneratedMesh();
        GeneratedMesh rightMesh = new GeneratedMesh();

        //Some meshes use different submeshes to have multiple materials attached to them
        //in an early iteration I had an extra script to turn everything into one mesh to make my life a little easier
        //however the result was not great because I could only slice objects that had one single material
        int[] submeshIndices;
        int   triangleIndexA, triangleIndexB, triangleIndexC;

        for (int i = 0; i < originalMesh.subMeshCount; i++)
        {
            submeshIndices = originalMesh.GetTriangles(i);

            //We are now going through the submesh indices as triangles to determine on what side of the mesh they are.
            for (int j = 0; j < submeshIndices.Length; j += 3)
            {
                triangleIndexA = submeshIndices[j];
                triangleIndexB = submeshIndices[j + 1];
                triangleIndexC = submeshIndices[j + 2];

                MeshTriangle currentTriangle = GetTriangle(triangleIndexA, triangleIndexB, triangleIndexC, i);

                //We are now using the plane.getside function to see on which side of the cut our trianle is situated
                //or if it might be cut through
                bool triangleALeftSide = plane.GetSide(originalMesh.vertices[triangleIndexA]);
                bool triangleBLeftSide = plane.GetSide(originalMesh.vertices[triangleIndexB]);
                bool triangleCLeftSide = plane.GetSide(originalMesh.vertices[triangleIndexC]);

                //All three vertices are on the left side of the plane, so they need to be added to the left
                //mesh
                if (triangleALeftSide && triangleBLeftSide && triangleCLeftSide)
                {
                    leftMesh.AddTriangle(currentTriangle);
                }
                //All three vertices are on the right side of the mesh.
                else if (!triangleALeftSide && !triangleBLeftSide && !triangleCLeftSide)
                {
                    rightMesh.AddTriangle(currentTriangle);
                }
                else
                {
                    CutTriangle(plane, currentTriangle, triangleALeftSide, triangleBLeftSide, triangleCLeftSide, leftMesh, rightMesh, addedVertices);
                }
            }
        }

        //Filling our cut
        if (fill == true)
        {
            FillCut(addedVertices, plane, leftMesh, rightMesh);
        }

        // Generer de to nye meshes
        Mesh finishedLeftMesh  = leftMesh.GetGeneratedMesh();
        Mesh finishedRightMesh = rightMesh.GetGeneratedMesh();

        Debug.Log(finishedLeftMesh);

        Destroy(_originalGameObject.GetComponent <MeshCollider>());
        MeshCollider newCollider = _originalGameObject.AddComponent <MeshCollider>();

        newCollider.sharedMesh = finishedLeftMesh;
        newCollider.convex     = true;

        // Materials
        Material[] mats = new Material[finishedLeftMesh.subMeshCount];


        for (int i = 0; i < finishedLeftMesh.subMeshCount; i++)
        {
            mats[i] = _originalGameObject.GetComponent <MeshRenderer>().material;
        }
        _originalGameObject.GetComponent <MeshRenderer>().materials = mats;

        // Tildel mesh
        _originalGameObject.GetComponent <MeshFilter>().mesh = finishedLeftMesh;

        // Når meshet er tillagt, beregner vi den nye masse.
        _originalGameObject.GetComponent <Rigidbody>().mass = VolumeAndMass.MassOfMesh(finishedLeftMesh, _originalGameObject.GetComponent <Food>().density);
        // Opdater center of mass
        _originalGameObject.GetComponent <Rigidbody>().centerOfMass = _originalGameObject.GetComponent <MeshFilter>().mesh.bounds.center;


        GameObject rightGO = new GameObject();

        rightGO.transform.position   = _originalGameObject.transform.position + (_direction * .007f);
        rightGO.transform.rotation   = _originalGameObject.transform.rotation;
        rightGO.transform.localScale = _originalGameObject.transform.localScale;
        rightGO.AddComponent <MeshRenderer>();

        // Materials
        mats = new Material[finishedRightMesh.subMeshCount];
        for (int i = 0; i < finishedRightMesh.subMeshCount; i++)
        {
            mats[i] = _originalGameObject.GetComponent <MeshRenderer>().material;
        }
        rightGO.GetComponent <MeshRenderer>().materials = mats;

        // Tildel mesh
        rightGO.AddComponent <MeshFilter>().mesh = finishedRightMesh;

        // Tildel rigidbody
        if (rightGO.GetComponent <Rigidbody>() == null)
        {
            rightGO.AddComponent <Rigidbody>();
        }

        // Når meshet er tillagt, beregner vi den nye masse med samme densitet som det originale objekt (selvfølgelig).
        rightGO.GetComponent <Rigidbody>().mass = VolumeAndMass.MassOfMesh(finishedRightMesh, _originalGameObject.GetComponent <Food>().density);
        // Opdater center of mass
        rightGO.GetComponent <Rigidbody>().centerOfMass = rightGO.GetComponent <MeshFilter>().mesh.bounds.center;

        rightGO.AddComponent <MeshCollider>().sharedMesh = finishedRightMesh;
        rightGO.GetComponent <MeshCollider>().convex     = true;
        rightGO.tag = _originalGameObject.tag;

        // Opdater scripts
        Food newFoodScript    = rightGO.AddComponent <Food>();
        Food originFoodScript = _originalGameObject.GetComponent <Food>();

        UpdateFoodScript(newFoodScript, originFoodScript);

        rightGO.AddComponent <Throwable>();

        currentlyCutting = false;
    }