Initial commit

2026-06-02 20:24:26 -07:00 · 2022-01-22 20:13:49 -08:00
parent f9d23e5bcf
commit 687473573d
878 changed files with 70957 additions and 0 deletions
@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: 32648b2beb0d5ff438a79aa97cd1b1a9
+folderAsset: yes
+timeCreated: 1457191637
+licenseType: Free
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: 7bfb3f51474066d41bd9bd4b08f148ea
+folderAsset: yes
+timeCreated: 1457269144
+licenseType: Free
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
@@ -0,0 +1,57 @@
+fileFormatVersion: 2
+guid: 34a11416a6b53ee4795f603273b9a46d
+timeCreated: 1457269160
+licenseType: Free
+TextureImporter:
+  fileIDToRecycleName: {}
+  serializedVersion: 2
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 1
+    linearTexture: 0
+    correctGamma: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 0
+  cubemapConvolution: 0
+  cubemapConvolutionSteps: 7
+  cubemapConvolutionExponent: 1.5
+  seamlessCubemap: 0
+  textureFormat: -1
+  maxTextureSize: 2048
+  textureSettings:
+    filterMode: -1
+    aniso: -1
+    mipBias: -1
+    wrapMode: -1
+  nPOTScale: 1
+  lightmap: 0
+  rGBM: 0
+  compressionQuality: 50
+  allowsAlphaSplitting: 0
+  spriteMode: 0
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spritePixelsToUnits: 100
+  alphaIsTransparency: 0
+  textureType: -1
+  buildTargetSettings: []
+  spriteSheet:
+    sprites: []
+    outline: []
+  spritePackingTag: 
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
@@ -0,0 +1,57 @@
+fileFormatVersion: 2
+guid: 152cd48aa35f97f45b3522bf745d7712
+timeCreated: 1457269160
+licenseType: Free
+TextureImporter:
+  fileIDToRecycleName: {}
+  serializedVersion: 2
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 1
+    linearTexture: 0
+    correctGamma: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 0
+  cubemapConvolution: 0
+  cubemapConvolutionSteps: 7
+  cubemapConvolutionExponent: 1.5
+  seamlessCubemap: 0
+  textureFormat: -1
+  maxTextureSize: 2048
+  textureSettings:
+    filterMode: -1
+    aniso: -1
+    mipBias: -1
+    wrapMode: -1
+  nPOTScale: 1
+  lightmap: 0
+  rGBM: 0
+  compressionQuality: 50
+  allowsAlphaSplitting: 0
+  spriteMode: 0
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spritePixelsToUnits: 100
+  alphaIsTransparency: 0
+  textureType: -1
+  buildTargetSettings: []
+  spriteSheet:
+    sprites: []
+    outline: []
+  spritePackingTag: 
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
@@ -0,0 +1,94 @@
+using System.Collections.Generic;
+using UnityEditor;
+using UnityEngine;
+
+namespace SimpleLightProbePlacer.Editor
+{
+    [CustomEditor(typeof(LightProbeGroupControl))]
+    public class LightProbeGroupControlEditor : UnityEditor.Editor
+    {
+        public override void OnInspectorGUI()
+        {
+            var control = (LightProbeGroupControl)target;
+
+            if (GUILayout.Button("Delete All Light Probes"))
+            {
+                Undo.RecordObject(control.LightProbeGroup, "Light Probe Group - delete all");
+                control.DeleteAll();
+            }
+
+            if (control.LightProbeGroup != null)
+            {
+                string message = "Light Probes count: {0}\nMerged Probes: {1}";
+                message = string.Format(message, control.LightProbeGroup.probePositions.Length, control.MergedProbes);
+
+                EditorGUILayout.HelpBox(message, MessageType.Info);
+            }
+
+            if (GUILayout.Button("Create Light Probes"))
+            {
+                Undo.RecordObject(control.LightProbeGroup, "Light Probe Group - create");
+                control.Create();
+            }
+        
+            GUILayout.Space(10);
+
+            if (GUILayout.Button("Merge Closest Light Probes"))
+            {
+                Undo.RecordObject(control.LightProbeGroup, "Light Probe Group - merge");
+                control.Merge();
+            }
+
+            EditorGUI.BeginChangeCheck();
+
+            var mergeDist = EditorGUILayout.Slider("Merge distance", control.MergeDistance, 0, 10);
+        
+            GUILayout.Space(20);
+            EditorGUILayout.LabelField("Point Light Settings", EditorStyles.boldLabel);
+
+            var useLights = EditorGUILayout.Toggle("Use Point Lights", control.UsePointLights);
+        
+            GUI.enabled = control.UsePointLights;
+            var lightRange = EditorGUILayout.FloatField("Range", control.PointLightRange);
+            GUI.enabled = true;
+        
+            if (EditorGUI.EndChangeCheck())
+            {
+                Undo.RecordObject(control, "Light Probe Group Control changes");
+            
+                control.MergeDistance = mergeDist;
+                control.UsePointLights = useLights;
+                control.PointLightRange = lightRange;
+
+                EditorUtility.SetDirty(target);
+            }
+        }
+
+        [MenuItem("GameObject/Light/Light Probe Group Control")]
+        private static void CreateLightProbeGroupControl(MenuCommand menuCommand)
+        {
+            var go = new GameObject("Light Probe Group Control");
+
+            go.AddComponent<LightProbeGroupControl>();
+            GameObjectUtility.SetParentAndAlign(go, menuCommand.context as GameObject);
+            Undo.RegisterCreatedObjectUndo(go, "Create Light Probe Group Control");
+
+            Selection.activeGameObject = go;
+        }
+        
+        [DrawGizmo(GizmoType.Selected | GizmoType.InSelectionHierarchy | GizmoType.Active)]
+        private static void DrawGizmoPointLight(Light light, GizmoType gizmoType)
+        {
+            var control = FindObjectOfType<LightProbeGroupControl>();
+        
+            if (control == null || !control.UsePointLights || light.type != LightType.Point) return;
+        
+            List<Vector3> probes = LightProbeGroupControl.CreatePositionsAround(light.transform, control.PointLightRange);
+
+            for (int i = 0; i < probes.Count; i++)
+            {
+                Gizmos.DrawIcon(probes[i], "NONE", false);
+            }
+        }
+    }
+}
@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 66045cdc4e8e7c844a763795dc422257
+timeCreated: 1457268398
+licenseType: Free
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
@@ -0,0 +1,92 @@
+using UnityEditor;
+using UnityEngine;
+
+namespace SimpleLightProbePlacer.Editor
+{
+    [CanEditMultipleObjects, CustomEditor(typeof(LightProbeVolume))]
+    public class LightProbeVolumeEditor : UnityEditor.Editor
+    {
+        public override void OnInspectorGUI()
+        {
+            var volume = (LightProbeVolume)target;
+
+            EditorGUI.BeginChangeCheck();
+
+            GUILayout.Space(10);
+            EditorGUILayout.LabelField("Volume", EditorStyles.boldLabel);
+            var origin = EditorGUILayout.Vector3Field("Origin", volume.Origin);
+            var size = EditorGUILayout.Vector3Field("Size", volume.Size);
+
+            GUILayout.Space(10);
+            EditorGUILayout.LabelField("Density", EditorStyles.boldLabel);
+            var type = (LightProbeVolumeType)EditorGUILayout.EnumPopup("Density Type", volume.Type);
+            
+            float densityMin = volume.Type == LightProbeVolumeType.Fixed ? 1 : 0.1f;
+            float densityMax = volume.Type == LightProbeVolumeType.Fixed ? 100 : 50;
+        
+            var density = volume.Density;
+            density.x = EditorGUILayout.Slider("DensityX", volume.Density.x, densityMin, densityMax);
+            density.y = EditorGUILayout.Slider("DensityY", volume.Density.y, densityMin, densityMax);
+            density.z = EditorGUILayout.Slider("DensityZ", volume.Density.z, densityMin, densityMax);
+
+            if (EditorGUI.EndChangeCheck())
+            {
+                Undo.RecordObject(target, "Light Probe Volume changes");
+
+                volume.Density = density;
+                volume.Type = type;
+                volume.Volume = new Volume(origin, size);
+
+                EditorUtility.SetDirty(target);
+            }
+        }
+    
+        private void OnSceneGUI()
+        {
+            var lightProbeVolume = (LightProbeVolume)target;
+
+            var volume = TransformVolume.EditorVolumeControl(lightProbeVolume, 0.1f, LightProbeVolume.EditorColor);
+
+            if (volume != lightProbeVolume.Volume)
+            {
+                Undo.RecordObject(target, "Light Probe Volume changes");
+                lightProbeVolume.Volume = volume;
+                EditorUtility.SetDirty(target);
+            }
+        }
+
+        [DrawGizmo(GizmoType.Selected | GizmoType.InSelectionHierarchy | GizmoType.Active)]
+        private static void DrawGizmoVolume(LightProbeVolume volume, GizmoType gizmoType)
+        {
+            var color = LightProbeVolume.EditorColor;
+            Gizmos.color = color;
+            Gizmos.matrix = Matrix4x4.TRS(volume.transform.position, volume.transform.rotation, Vector3.one);
+            Gizmos.DrawWireCube(volume.Origin, volume.Size);
+            
+            if (gizmoType != (GizmoType.Selected | GizmoType.InSelectionHierarchy | GizmoType.Active)) return;
+            
+            color.a = 0.25f;
+            Gizmos.color = color;
+            Gizmos.DrawCube(volume.Origin, volume.Size);
+
+            var probes = volume.CreatePositions();
+
+            for (int i = 0; i < probes.Count; i++)
+            {
+                Gizmos.DrawIcon(probes[i], "NONE", false);
+            }
+        }
+
+        [MenuItem("GameObject/Light/Light Probe Volume")]
+        private static void CreateLightProbeVolume(MenuCommand menuCommand)
+        {
+            var go = new GameObject("Light Probe Volume");
+
+            go.AddComponent<LightProbeVolume>();
+            GameObjectUtility.SetParentAndAlign(go, menuCommand.context as GameObject);
+            Undo.RegisterCreatedObjectUndo(go, "Create Light Probe Volume");
+
+            Selection.activeGameObject = go;
+        }
+    }
+}
@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: ed7bb5f68f00e944da65fd411da6fd53
+timeCreated: 1457260999
+licenseType: Free
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: fb0bc3e0b33493443b1caeaaee1a0196
+folderAsset: yes
+timeCreated: 1457191632
+licenseType: Free
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
@@ -0,0 +1,153 @@
+using UnityEngine;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace SimpleLightProbePlacer
+{
+    [RequireComponent(typeof(LightProbeGroup))]
+    [AddComponentMenu("Rendering/Light Probe Group Control")]
+    public class LightProbeGroupControl : MonoBehaviour
+    {
+        [SerializeField] private float m_mergeDistance = 0.5f;
+        [SerializeField] private bool m_usePointLights = true;
+        [SerializeField] private float m_pointLightRange = 1;
+        
+        public float MergeDistance { get { return m_mergeDistance; } set { m_mergeDistance = value; } }
+        public int MergedProbes { get { return m_mergedProbes; } }
+        public bool UsePointLights { get { return m_usePointLights; } set { m_usePointLights = value; } }
+        public float PointLightRange { get { return m_pointLightRange; } set { m_pointLightRange = value; } }
+
+        public LightProbeGroup LightProbeGroup
+        {
+            get
+            {
+                if (m_lightProbeGroup != null) return m_lightProbeGroup;
+                return m_lightProbeGroup = GetComponent<LightProbeGroup>();
+            }
+        }
+
+        private int m_mergedProbes;
+        private LightProbeGroup m_lightProbeGroup;
+
+        public void DeleteAll()
+        {
+            LightProbeGroup.probePositions = null;
+            m_mergedProbes = 0;
+        }
+
+        public void Create()
+        {
+            DeleteAll();
+
+            List<Vector3> positions = CreatePositions();
+            positions.AddRange(CreateAroundPointLights(m_pointLightRange));
+            positions = MergeClosestPositions(positions, m_mergeDistance, out m_mergedProbes);
+
+            ApplyPositions(positions);
+        }
+
+        public void Merge()
+        {
+            if (LightProbeGroup.probePositions == null) return;
+
+            List<Vector3> positions = MergeClosestPositions(LightProbeGroup.probePositions.ToList(), m_mergeDistance, out m_mergedProbes);
+            positions = positions.Select(x => transform.TransformPoint(x)).ToList();
+
+            ApplyPositions(positions);
+        }
+
+        private void ApplyPositions(List<Vector3> positions)
+        {
+            LightProbeGroup.probePositions = positions.Select(x => transform.InverseTransformPoint(x)).ToArray();
+        }
+
+        private static List<Vector3> CreatePositions()
+        {
+            var lightProbeVolumes = FindObjectsOfType<LightProbeVolume>();
+
+            if (lightProbeVolumes.Length == 0) return new List<Vector3>();
+
+            List<Vector3> probes = new List<Vector3>();
+
+            for (int i = 0; i < lightProbeVolumes.Length; i++)
+            {
+                probes.AddRange(lightProbeVolumes[i].CreatePositions());
+            }
+
+            return probes;
+        }
+
+        private static List<Vector3> CreateAroundPointLights(float range)
+        {
+            var lights = FindObjectsOfType<Light>().Where(x => x.type == LightType.Point).ToList();
+
+            if (lights.Count == 0) return new List<Vector3>();
+
+            List<Vector3> probes = new List<Vector3>();
+
+            for (int i = 0; i < lights.Count; i++)
+            {
+                probes.AddRange(CreatePositionsAround(lights[i].transform, range));
+            }
+
+            return probes;
+        }
+
+        private static List<Vector3> MergeClosestPositions(List<Vector3> positions, float distance, out int mergedCount)
+        {
+            if (positions == null)
+            {
+                mergedCount = 0;
+                return new List<Vector3>();
+            }
+
+            int exist = positions.Count;
+            bool done = false;
+
+            while (!done)
+            {
+                Dictionary<Vector3, List<Vector3>> closest = new Dictionary<Vector3, List<Vector3>>();
+
+                for (int i = 0; i < positions.Count; i++)
+                {
+                    List<Vector3> points = positions.Where(x => (x - positions[i]).magnitude < distance).ToList();
+                    if (points.Count > 0 && !closest.ContainsKey(positions[i]))
+                    {
+                        closest.Add(positions[i], points);
+                    }
+                }
+
+                positions.Clear();
+                List<Vector3> keys = closest.Keys.ToList();
+
+                for (int i = 0; i < keys.Count; i++)
+                {
+                    var center = closest[keys[i]].Aggregate(Vector3.zero, (result, target) => result + target) / closest[keys[i]].Count;
+                    if (!positions.Exists(x => x == center)) positions.Add(center);
+                }
+
+                done = positions.Select(x => positions.Where(y => y != x && (y - x).magnitude < distance)).All(x => !x.Any());
+            }
+
+            mergedCount = exist - positions.Count;
+            return positions;
+        }
+
+        public static List<Vector3> CreatePositionsAround(Transform transform, float range)
+        {
+            Vector3[] corners =
+            {
+                new Vector3(-0.5f, 0.5f, -0.5f),
+                new Vector3(-0.5f, 0.5f, 0.5f),
+                new Vector3(0.5f, 0.5f, 0.5f),
+                new Vector3(0.5f, 0.5f, -0.5f),
+                new Vector3(-0.5f, -0.5f, -0.5f),
+                new Vector3(-0.5f, -0.5f, 0.5f),
+                new Vector3(0.5f, -0.5f, 0.5f),
+                new Vector3(0.5f, -0.5f, -0.5f)
+            };
+
+            return corners.Select(x => transform.TransformPoint(x * range)).ToList();
+        }
+    }
+}
@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 9e58b2a5f02556c4897347a45818c57a
+timeCreated: 1457269174
+licenseType: Free
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {fileID: 2800000, guid: 34a11416a6b53ee4795f603273b9a46d, type: 3}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
@@ -0,0 +1,97 @@
+using UnityEngine;
+using System.Collections.Generic;
+
+namespace SimpleLightProbePlacer
+{
+    public enum LightProbeVolumeType { Fixed, Float }
+
+    [AddComponentMenu("Rendering/Light Probe Volume")]
+    public class LightProbeVolume : TransformVolume
+    {
+        [SerializeField] private LightProbeVolumeType m_type = LightProbeVolumeType.Fixed;
+        [SerializeField] private Vector3 m_densityFixed = Vector3.one;
+        [SerializeField] private Vector3 m_densityFloat = Vector3.one;
+
+        public LightProbeVolumeType Type { get { return m_type; } set { m_type = value; } }
+        public Vector3 Density
+        {
+            get { return m_type == LightProbeVolumeType.Fixed ? m_densityFixed : m_densityFloat; }
+            set
+            {
+                if (m_type == LightProbeVolumeType.Fixed) m_densityFixed = value;
+                else m_densityFloat = value;
+            }
+        }
+
+        public static Color EditorColor { get { return new Color(1, 0.9f, 0.25f); } }
+
+        public List<Vector3> CreatePositions()
+        {
+            return CreatePositions(m_type);
+        }
+
+        public List<Vector3> CreatePositions(LightProbeVolumeType type)
+        {
+            return type == LightProbeVolumeType.Fixed
+                ? CreatePositionsFixed(transform, Origin, Size, Density)
+                : CreatePositionsFloat(transform, Origin, Size, Density);
+        }
+
+        public static List<Vector3> CreatePositionsFixed(Transform volumeTransform, Vector3 origin, Vector3 size, Vector3 density)
+        {
+            List<Vector3> posList = new List<Vector3>();
+            var offset = origin;
+
+            var moveX = size.x / Mathf.FloorToInt(density.x);
+            var moveY = size.y / Mathf.FloorToInt(density.y);
+            var moveZ = size.z / Mathf.FloorToInt(density.z);
+
+            offset -= size * 0.5f;
+
+            for (int x = 0; x <= density.x; x++)
+            {
+                for (int y = 0; y <= density.y; y++)
+                {
+                    for (int z = 0; z <= density.z; z++)
+                    {
+                        var probePos = offset + new Vector3(x * moveX, y * moveY, z * moveZ);
+                        probePos = volumeTransform.TransformPoint(probePos);
+                        posList.Add(probePos);
+                    }
+                }
+            }
+
+            return posList;
+        }
+
+        public static List<Vector3> CreatePositionsFloat(Transform volumeTransform, Vector3 origin, Vector3 size, Vector3 density)
+        {
+            List<Vector3> posList = new List<Vector3>();
+            var offset = origin;
+            
+            var stepX = Mathf.FloorToInt(size.x / density.x);
+            var stepY = Mathf.FloorToInt(size.y / density.y);
+            var stepZ = Mathf.FloorToInt(size.z / density.z);
+
+            offset -= size * 0.5f;
+            offset.x += (size.x - stepX * density.x) * 0.5f;
+            offset.y += (size.y - stepY * density.y) * 0.5f;
+            offset.z += (size.z - stepZ * density.z) * 0.5f;
+
+            for (int x = 0; x <= stepX; x++)
+            {
+                for (int y = 0; y <= stepY; y++)
+                {
+                    for (int z = 0; z <= stepZ; z++)
+                    {
+                        var probePos = offset + new Vector3(x * density.x, y * density.y, z * density.z);
+                        probePos = volumeTransform.TransformPoint(probePos);
+                        posList.Add(probePos);
+                    }
+                }
+            }
+
+            return posList;
+        }
+    }
+}
@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 6ce72b8e8fac84047a96f26f2b28d1d9
+timeCreated: 1457269185
+licenseType: Free
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {fileID: 2800000, guid: 152cd48aa35f97f45b3522bf745d7712, type: 3}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
@@ -0,0 +1,197 @@
+using UnityEngine;
+using System.Collections.Generic;
+using System.Linq;
+
+#if UNITY_EDITOR
+using UnityEditor;
+#endif
+
+namespace SimpleLightProbePlacer
+{
+    [AddComponentMenu("")]
+    public class TransformVolume : MonoBehaviour
+    {
+        [SerializeField] private Volume m_volume = new Volume(Vector3.zero, Vector3.one);
+
+        public Volume Volume { get { return m_volume; } set { m_volume = value; } }
+        public Vector3 Origin { get { return m_volume.Origin; } }
+        public Vector3 Size { get { return m_volume.Size; } }
+
+        public bool IsInBounds(Vector3[] points)
+        {
+            return GetBounds().Intersects(GetBounds(points));
+        }
+
+        public bool IsOnBorder(Vector3[] points)
+        {
+            if (points.All(x => !IsInVolume(x))) return false;
+
+            return !points.All(IsInVolume);
+        }
+
+        public bool IsInVolume(Vector3[] points)
+        {
+            return points.All(IsInVolume);
+        }
+
+        public bool IsInVolume(Vector3 position)
+        {
+            for (int i = 0; i < 6; i++)
+            {
+                var plane = new Plane(GetSideDirection(i), GetSidePosition(i));
+
+                if (plane.GetSide(position)) return false;
+            }
+
+            return true;
+        }
+
+        public Vector3[] GetCorners()
+        {
+            Vector3[] corners =
+            {
+                new Vector3(-0.5f, 0.5f, -0.5f),
+                new Vector3(-0.5f, 0.5f, 0.5f),
+                new Vector3(0.5f, 0.5f, 0.5f),
+                new Vector3(0.5f, 0.5f, -0.5f),
+                new Vector3(-0.5f, -0.5f, -0.5f),
+                new Vector3(-0.5f, -0.5f, 0.5f),
+                new Vector3(0.5f, -0.5f, 0.5f),
+                new Vector3(0.5f, -0.5f, -0.5f)
+            };
+
+            for (int i = 0; i < corners.Length; i++)
+            {
+                corners[i].x *= m_volume.Size.x;
+                corners[i].y *= m_volume.Size.y;
+                corners[i].z *= m_volume.Size.z;
+
+                corners[i] = transform.TransformPoint(m_volume.Origin + corners[i]);
+            }
+
+            return corners;
+        }
+
+        public Bounds GetBounds()
+        {
+            return GetBounds(GetCorners());
+        }
+
+        public Bounds GetBounds(Vector3[] points)
+        {
+            var center = points.Aggregate(Vector3.zero, (result, point) => result + point) / points.Length;
+            var bounds = new Bounds(center, Vector3.zero);
+
+            for (int i = 0; i < points.Length; i++)
+            {
+                bounds.Encapsulate(points[i]);
+            }
+
+            return bounds;
+        }
+
+        public GameObject[] GetGameObjectsInBounds(LayerMask layerMask)
+        {
+            MeshRenderer[] meshRenderers = FindObjectsOfType<MeshRenderer>();
+
+            List<GameObject> list = new List<GameObject>();
+
+            Bounds bounds = GetBounds();
+
+            for (int i = 0; i < meshRenderers.Length; i++)
+            {
+                if (meshRenderers[i].gameObject == transform.gameObject) continue;
+                if (meshRenderers[i].GetComponent<TransformVolume>() != null) continue;
+                if ((1 << meshRenderers[i].gameObject.layer & layerMask.value) == 0) continue;
+
+                if (bounds.Intersects(meshRenderers[i].bounds))
+                {
+                    list.Add(meshRenderers[i].gameObject);
+                }
+            }
+
+            return list.ToArray();
+        }
+
+        public Vector3 GetSideDirection(int side)
+        {
+            Vector3[] sides = new Vector3[6];
+
+            var right = Vector3.right;
+            var up = Vector3.up;
+            var forward = Vector3.forward;
+
+            sides[0] = right;
+            sides[1] = -right;
+            sides[2] = up;
+            sides[3] = -up;
+            sides[4] = forward;
+            sides[5] = -forward;
+
+            return transform.TransformDirection(sides[side]);
+        }
+
+        public Vector3 GetSidePosition(int side)
+        {
+            Vector3[] sides = new Vector3[6];
+
+            var right = Vector3.right;
+            var up = Vector3.up;
+            var forward = Vector3.forward;
+
+            sides[0] = right;
+            sides[1] = -right;
+            sides[2] = up;
+            sides[3] = -up;
+            sides[4] = forward;
+            sides[5] = -forward;
+
+            return transform.TransformPoint(sides[side] * GetSizeAxis(side) + m_volume.Origin);
+        }
+
+        public float GetSizeAxis(int side)
+        {
+            switch (side)
+            {
+                case 0:
+                case 1: return m_volume.Size.x * 0.5f;
+                case 2:
+                case 3: return m_volume.Size.y * 0.5f;
+                default: return m_volume.Size.z * 0.5f;
+            }
+        }
+
+#if UNITY_EDITOR
+        public static Volume EditorVolumeControl(TransformVolume transformVolume, float handleSize, Color color)
+        {
+            Vector3 origin, size;
+            Vector3[] controlHandles = new Vector3[6];
+            var transform = transformVolume.transform;
+
+            Handles.color = color;
+
+            for (int i = 0; i < controlHandles.Length; i++)
+            {
+                controlHandles[i] = transformVolume.GetSidePosition(i);
+            }
+
+            controlHandles[0] = Handles.Slider(controlHandles[0], transform.right, handleSize, Handles.DotHandleCap, 1);
+            controlHandles[1] = Handles.Slider(controlHandles[1], transform.right, handleSize, Handles.DotHandleCap, 1);
+            controlHandles[2] = Handles.Slider(controlHandles[2], transform.up, handleSize, Handles.DotHandleCap, 1);
+            controlHandles[3] = Handles.Slider(controlHandles[3], transform.up, handleSize, Handles.DotHandleCap, 1);
+            controlHandles[4] = Handles.Slider(controlHandles[4], transform.forward, handleSize, Handles.DotHandleCap, 1);
+            controlHandles[5] = Handles.Slider(controlHandles[5], transform.forward, handleSize, Handles.DotHandleCap, 1);
+
+            origin.x = transform.InverseTransformPoint((controlHandles[0] + controlHandles[1]) * 0.5f).x;
+            origin.y = transform.InverseTransformPoint((controlHandles[2] + controlHandles[3]) * 0.5f).y;
+            origin.z = transform.InverseTransformPoint((controlHandles[4] + controlHandles[5]) * 0.5f).z;
+            
+            size.x = transform.InverseTransformPoint(controlHandles[0]).x - transform.InverseTransformPoint(controlHandles[1]).x;
+            size.y = transform.InverseTransformPoint(controlHandles[2]).y - transform.InverseTransformPoint(controlHandles[3]).y;
+            size.z = transform.InverseTransformPoint(controlHandles[4]).z - transform.InverseTransformPoint(controlHandles[5]).z;
+
+            return new Volume(origin, size);
+        }
+#endif
+    }
+}
@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: d839bef4d4110b244bf82bcec581a66d
+timeCreated: 1457258829
+licenseType: Free
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
@@ -0,0 +1,54 @@
+using UnityEngine;
+
+namespace SimpleLightProbePlacer
+{
+    [System.Serializable]
+    public struct Volume
+    {
+        [SerializeField] private Vector3 m_origin;
+        [SerializeField] private Vector3 m_size;
+
+        public Vector3 Origin { get { return m_origin; } }
+        public Vector3 Size { get { return m_size; } }
+        
+        public Volume(Vector3 origin, Vector3 size)
+        {
+            m_origin = origin;
+            m_size = size;
+        }
+
+        public static bool operator ==(Volume left, Volume right)
+        {
+            return left.Equals(right);
+        }
+
+        public static bool operator !=(Volume left, Volume right)
+        {
+            return !left.Equals(right);
+        }
+
+        public bool Equals(Volume other)
+        {
+            return Origin == other.Origin && Size == other.Size;
+        }
+
+        public override bool Equals(object obj)
+        {
+            if (ReferenceEquals(null, obj)) return false;
+            return obj is Volume && Equals((Volume) obj);
+        }
+
+        public override int GetHashCode()
+        {
+            unchecked
+            {
+                return (Origin.GetHashCode() * 397) ^ Size.GetHashCode();
+            }
+        }
+
+        public override string ToString()
+        {
+            return string.Format("Origin: {0}, Size: {1}", Origin, Size);
+        }
+    }
+}
@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: f270f689c223be84f93d18074813ab7f
+timeCreated: 1457259045
+licenseType: Free
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: