Пример #1
0
    private Vector3 CalculateQuadPosition(MeshDataset dataset, GameObject quad, Vector4 face)
    {
        Vector3 position = Vector3.zero;

        for (int vertIndex = 0; vertIndex < 4; vertIndex++)
        {
            int datasetVertIndex = Mathf.RoundToInt(face[vertIndex]);
            position += dataset.vertices[datasetVertIndex];
        }
        return(position / 4.0f);
    }
Пример #2
0
    private Vector3 CalculateQuadNormal(MeshDataset dataset, GameObject quad, Vector4 face)
    {
        List <Vector3> datasetVertices = new List <Vector3>();

        for (int vertIndex = 0; vertIndex < 4; vertIndex++)
        {
            int datasetVertIndex = Mathf.RoundToInt(face[vertIndex]);
            datasetVertices.Add(dataset.vertices[datasetVertIndex]);
        }

        return(Vector3.Cross(datasetVertices[1] - datasetVertices[0], datasetVertices[2] - datasetVertices[1]));
    }
Пример #3
0
    private void ApplyMaterial(MeshDataset dataset, GameObject quad, Vector4 face, Vector3 normal)
    {
        Color    color    = dataset.colors[Mathf.RoundToInt(face[0])];
        Renderer renderer = quad.GetComponentInChildren <Renderer>();

        for (int i = 0; i < materials.Length; i++)
        {
            Color paletteColor = palette.GetPixel(i, 0) * 255;
            if (paletteColor.r == color.r && paletteColor.g == color.g && paletteColor.b == color.b)
            {
                renderer.sharedMaterial = materials[i];
                break;
            }
        }
    }
Пример #4
0
    public GameObject GenerateMesh(string meshFile, string meshName, Vector3 scale)
    {
        MeshDataset dataset = new MeshDataset(meshFile);

        Vector3 max = new Vector3(int.MinValue, int.MinValue, int.MinValue);
        Vector3 min = new Vector3(int.MaxValue, int.MaxValue, int.MaxValue);

        // Creates root object to hold all the instantiated quads
        GameObject rootObject = new GameObject();

        rootObject.name = meshName;

        for (int faceIdx = 0; faceIdx < dataset.numFaces; faceIdx++)
        {
            Vector4    face = dataset.faces[faceIdx];
            GameObject quad = GameObject.Instantiate(quadToInstantiate, rootObject.transform, true) as GameObject;
            quad.transform.parent = rootObject.transform;

            Vector3 normal = CalculateQuadNormal(dataset, quad, face);
            quad.transform.position      = CalculateQuadPosition(dataset, quad, face);
            quad.transform.localRotation = CalculateQuadRotation(normal);
            ApplyMaterial(dataset, quad, face, normal);

            min = Vector3.Min(min, quad.transform.position);
            max = Vector3.Max(max, quad.transform.position);
        }

        rootObject.transform.localScale = scale;
        MeshProperties mp = rootObject.AddComponent <MeshProperties>();

        mp.min = Vector3.Scale(min, scale);
        mp.max = Vector3.Scale(max, scale);

        rootObject.tag = "LevelRoot";
        BoxCollider nextLevelTrigger = rootObject.AddComponent <BoxCollider>();

        nextLevelTrigger.size      = new Vector3(10, 2, 10);
        nextLevelTrigger.isTrigger = true;

        return(rootObject);
    }