VolumeTransformTester.cs

using UnityEngine;
using EyE.Unity.Tools;
 
namespace EyE.Unity.Examples
{
  
    public class VolumeTransformTester : MonoBehaviour
    {
        public int arraySize = 10;
        public GameObject objToAarray;
        public GameObject[,,] objArray;
        public float offset;
        public float sphereRadius;
 
        public bool useSphereVolume;
        private bool lastUseSphereVolume;
        public bool useBoxSurfaceVolume;
        private bool lastUseBoxSurfaceVolume;
 
 
        void Start()
        {
            lastUseSphereVolume = useSphereVolume;
            lastUseBoxSurfaceVolume = useBoxSurfaceVolume;
 
            Vector3 center = new Vector3((arraySize - 1) * offset, (arraySize - 1) * offset, (arraySize - 1) * offset) * 0.5f;
            objArray = new GameObject[arraySize, arraySize, arraySize];
            for (int x = 0; x < arraySize; x++)
            {
                for (int y = 0; y < arraySize; y++)
                {
                    for (int z = 0; z < arraySize; z++)
                    {
                        GameObject newObj = GameObject.Instantiate(objToAarray);
                        objArray[x, y, z] = newObj;
                        Vector3 pos = new Vector3(x * offset, y * offset, z * offset);
                        pos -= center;
                        if (useSphereVolume)
                            pos = VolumeTransforms.TransformBoxVolumeToSphericalVolume(pos, arraySize * offset, sphereRadius);
                        if (useBoxSurfaceVolume)
                            pos = VolumeTransforms.GetCubeSurfacePointInDirection(pos.normalized, arraySize * offset);
                        newObj.transform.position = pos;
                        newObj.GetComponent<MeshRenderer>().material.color = new Color((float)x / (float)arraySize, (float)y / (float)arraySize, (float)z / (float)arraySize);
                    }
                }
            }
        }
 
 
        void RecomputePos()
        {
            Vector3 center = new Vector3((arraySize - 1) * offset, (arraySize - 1) * offset, (arraySize - 1) * offset) * 0.5f;
 
            for (int x = 0; x < arraySize; x++)
            {
                for (int y = 0; y < arraySize; y++)
                {
                    for (int z = 0; z < arraySize; z++)
                    {
                        GameObject existingObj = objArray[x, y, z];
                        Vector3 pos = new Vector3(x * offset, y * offset, z * offset);
                        pos -= center;
                        if (useSphereVolume)
                            pos = VolumeTransforms.TransformBoxVolumeToSphericalVolume(pos, arraySize * offset, sphereRadius);
                        if (useBoxSurfaceVolume)
                            pos = VolumeTransforms.GetCubeSurfacePointInDirection(pos.normalized, arraySize * offset);
                        existingObj.transform.position = pos;
                    }
                }
            }
        }
 
 
        void Update()
        {
            if ((useSphereVolume != lastUseSphereVolume) ||
                (useBoxSurfaceVolume != lastUseBoxSurfaceVolume))
            {
                lastUseSphereVolume = useSphereVolume;
                lastUseBoxSurfaceVolume = useBoxSurfaceVolume;
                RecomputePos();
            }
        }
    }
}