void Run()
    {
        string[] splits = input.Split(' ');
        size = new Vector3Int(
            Convert.ToInt32(splits[3] + splits[2] + splits[1] + splits[0], 16),
            Convert.ToInt32(splits[7] + splits[6] + splits[5] + splits[4], 16),
            Convert.ToInt32(splits[11] + splits[10] + splits[9] + splits[8], 16));
        RenderVoxel[,,] voxelArray = new RenderVoxel[size.x, size.y, size.z];
        int x = 0;
        int y = 0;
        int z = 0;

        for (int i = 16; i < splits.Length; i += 2)
        {
            int n     = Convert.ToInt32(splits[i], 16) + 1;
            int color = Convert.ToInt32(splits[i + 1], 16);
            for (int k = 0; k < n; k++)
            {
                x++;
                if (x == size.x)
                {
                    y++;
                    x = 0;
                    if (y == size.y)
                    {
                        y = 0;
                        z++;
                    }
                }
                if (color == 0)
                {
                    continue;
                }
                if (z >= size.z)
                {
                    break;
                }
                voxelArray[x, y, z] = new RenderVoxel(color);
            }
        }

        MagicaRenderer renderer      = new MagicaRenderer();
        MeshAndColors  meshAndColors = renderer.createMeshFromVoxelArray(voxelArray, Vector3.zero);
        GameObject     go            = new GameObject();

        Color32[] colors = new Color32[meshAndColors.colors.Count];
        for (int i = 0; i < meshAndColors.colors.Count; i++)
        {
            int c = meshAndColors.colors[i];
            colors[i] = new Color(c / 256f, c / 256f, c / 256f, 1);
        }
        meshAndColors.mesh.colors32                 = colors;
        (go.AddComponent <MeshFilter>()).mesh       = meshAndColors.mesh;
        (go.AddComponent <MeshRenderer>()).material = Resources.Load("VertexShading", typeof(Material)) as Material;
    }
Exemple #2
0
 public void Import(bool importOnlyValidAssets)
 {
     try
     {
         MagicaRenderer renderer = new MagicaRenderer();
         if (importOnlyValidAssets)
         {
             GameObject root = renderer.ImportMagicaVoxelFileAssets(importPath);
             DestroyImmediate(root);
         }
         else
         {
             renderer.ImportMagicaVoxelFile(importPath);
         }
     }
     catch (Exception e)
     {
         Debug.LogError(e);
     }
 }
Exemple #3
0
    public void importVoxelVehicle()
    {
        MagicaRenderer renderer = new MagicaRenderer();
        GameObject     parent   = renderer.ImportMagicaVoxelFile(vehicleFilePath);

        parent.name = parent.name + " - Vehicle";

        GameObject        body     = null;
        List <GameObject> wheels   = new List <GameObject>();
        List <GameObject> children = new List <GameObject>();

        foreach (Transform child in parent.transform)
        {
            children.Add(child.gameObject);
            if (child.gameObject.name.StartsWith("wheel_"))
            {
                wheels.Add(child.gameObject);
            }
            else if (child.gameObject.name == ("body"))
            {
                body = child.gameObject;
            }
        }

        if (body != null)
        {
            parent.AddComponent <Vehicle>();

            Vector3 center = body.transform.position;
            foreach (Transform child in parent.transform)
            {
                child.position -= center;
            }

            ObjectAttributes bodyAttributes = body.GetComponent <ObjectAttributes>();
        }
    }
    public void Reload()
    {
        try
        {
            MagicaRenderer renderer = new MagicaRenderer();
            if (voxObject.Equals(""))
            {
                gameObject.name = "<vox " + teardownName + " " + file + ">";
                GameObject importedObject = renderer.ImportMagicaVoxelFile(file);
                Transform  voxObject      = importedObject.transform;
                voxObject.parent = transform;
                voxObject.transform.localPosition = Vector3.zero;
                voxObject.transform.localRotation = Quaternion.identity;
            }
            else
            {
                gameObject.name = "<vox " + teardownName + " " + file + " " + this.voxObject + ">";
                GameObject importedObject = renderer.ImportMagicaVoxelFileObject(file, this.voxObject);
                Transform  voxObject      = importedObject.transform;
                if (importedObject.transform.childCount > 0)
                {
                    voxObject = importedObject.transform.GetChild(0);
                }
                voxObject.transform.parent        = transform;
                voxObject.transform.localPosition = Vector3.zero;
                voxObject.transform.localRotation = Quaternion.identity;
                DestroyImmediate(importedObject);
            }

            setObjectNames(renderer.GetObjectNames(file));
        }
        catch (Exception e)
        {
            Debug.LogError(e);
        }
    }