Ejemplo n.º 1
0
        /// <summary>
        /// Registers the Aura Volume to the global manager
        /// </summary>
        /// <param name="auravolume">The Aura Volume to register</param>
        public void RegisterVolume(AuraVolume auraVolume)
        {
            if (!RegisteredVolumesList.Contains(auraVolume))
            {
                RegisteredVolumesList.Add(auraVolume);

                if (auraVolume.useAsLightProbesProxyVolume)
                {
                    RegisteredLightProbesProxyVolumesList.Add(auraVolume);
                }

                if (auraVolume.UsesTexture2DMasking)
                {
                    Texture2DMasksAtlasComposer.AddTexture(auraVolume.texture2DMask.texture);
                    Texture2DMasksAtlasComposer.Generate();
                    SetTexture2DMasksId();
                }

                if (auraVolume.UsesTexture3DMasking)
                {
                    Texture3DMasksAtlasComposer.AddTexture(auraVolume.texture3DMask.texture);
                    Texture3DMasksAtlasComposer.Generate();
                    SetTexture3DMasksId();
                }

                if (OnRegisterVolume != null)
                {
                    OnRegisterVolume(auraVolume);
                }
            }

            auraVolume.OnUninitialize += AuraVolume_OnUninitialize;
        }
Ejemplo n.º 2
0
 /// <summary>
 /// Sets the id of the AuraVolumes's Texture3D mask in the atlas
 /// </summary>
 private void SetTexture3DMaskId(AuraVolume auraVolume)
 {
     if (auraVolume.UsesTexture3DMasking)
     {
         auraVolume.texture3DMask.textureIndex = Texture3DMasksAtlasComposer.GetTextureIndex(auraVolume.texture3DMask.texture);
     }
 }
Ejemplo n.º 3
0
        /// <summary>
        /// Function called when the volume is being disabled
        /// </summary>
        private void AuraVolume_OnUninitialize(AuraVolume auraVolume)
        {
            if (RegisteredVolumesList.Contains(auraVolume))
            {
                if (RegisteredLightProbesProxyVolumesList.Contains(auraVolume))
                {
                    RegisteredLightProbesProxyVolumesList.Remove(auraVolume);
                }

                if (OnUnregisterVolume != null)
                {
                    OnUnregisterVolume(auraVolume);
                }

                if (Texture2DMasksAtlasComposer.RemoveTexture(auraVolume.texture2DMask.texture))
                {
                    SetTexture2DMasksId();
                    Texture2DMasksAtlasComposer.Generate();
                }

                if (Texture3DMasksAtlasComposer.RemoveTexture(auraVolume.texture3DMask.texture))
                {
                    SetTexture3DMasksId();
                    Texture3DMasksAtlasComposer.Generate();
                }

                RegisteredVolumesList.Remove(auraVolume);
            }

            auraVolume.OnUninitialize -= AuraVolume_OnUninitialize;
        }
Ejemplo n.º 4
0
        private void OnEnable()
        {
            _volumeShapeProperty                 = serializedObject.FindProperty("volumeShape.shape");
            _falloffFadeProperty                 = serializedObject.FindProperty("volumeShape.fading.falloffExponent");
            _xPositiveCubeFadeProperty           = serializedObject.FindProperty("volumeShape.fading.xPositiveCubeFade");
            _xNegativeCubeFadeProperty           = serializedObject.FindProperty("volumeShape.fading.xNegativeCubeFade");
            _yPositiveCubeFadeProperty           = serializedObject.FindProperty("volumeShape.fading.yPositiveCubeFade");
            _yNegativeCubeFadeProperty           = serializedObject.FindProperty("volumeShape.fading.yNegativeCubeFade");
            _zPositiveCubeFadeProperty           = serializedObject.FindProperty("volumeShape.fading.zPositiveCubeFade");
            _zNegativeCubeFadeProperty           = serializedObject.FindProperty("volumeShape.fading.zNegativeCubeFade");
            _angularConeFadeProperty             = serializedObject.FindProperty("volumeShape.fading.angularConeFade");
            _distanceConeFadeProperty            = serializedObject.FindProperty("volumeShape.fading.distanceConeFade");
            _widthCylinderFadeProperty           = serializedObject.FindProperty("volumeShape.fading.widthCylinderFade");
            _yNegativeCylinderFadeProperty       = serializedObject.FindProperty("volumeShape.fading.yNegativeCylinderFade");
            _yPositiveCylinderFadeProperty       = serializedObject.FindProperty("volumeShape.fading.yPositiveCylinderFade");
            _distanceSphereFadeProperty          = serializedObject.FindProperty("volumeShape.fading.distanceSphereFade");
            _useAsLightProbesProxyVolumeProperty = serializedObject.FindProperty("useAsLightProbesProxyVolume");
            _lightProbesMultiplierProperty       = serializedObject.FindProperty("lightProbesMultiplier");
            _texture2DMaskBoolProperty           = serializedObject.FindProperty("texture2DMask.enable");
            _texture2DMaskTextureProperty        = serializedObject.FindProperty("texture2DMask.texture");
            _texture2DMaskTransformProperty      = serializedObject.FindProperty("texture2DMask.transform");
            _texture3DMaskBoolProperty           = serializedObject.FindProperty("texture3DMask.enable");
            _texture3DMaskTextureProperty        = serializedObject.FindProperty("texture3DMask.texture");
            _texture3DMaskTransformProperty      = serializedObject.FindProperty("texture3DMask.transform");
            _noiseMaskBoolProperty               = serializedObject.FindProperty("noiseMask.enable");
            _noiseMaskSpeedProperty              = serializedObject.FindProperty("noiseMask.speed");
            _noiseMaskTransformProperty          = serializedObject.FindProperty("noiseMask.transform");

            _densityInjectionTitleContent       = new GUIContent("Density", Aura.ResourcesCollection.densityIconTexture);
            _densityInjectionBoolProperty       = serializedObject.FindProperty("densityInjection.enable");
            _densityInjectionParametersProperty = serializedObject.FindProperty("densityInjection");

            _scatteringInjectionTitleContent       = new GUIContent("Scattering", Aura.ResourcesCollection.scatteringIconTexture);
            _scatteringInjectionBoolProperty       = serializedObject.FindProperty("scatteringInjection.enable");
            _scatteringInjectionParametersProperty = serializedObject.FindProperty("scatteringInjection");

            _lightInjectionTitleContent       = new GUIContent("Light", Aura.ResourcesCollection.illuminationColorIconTexture);
            _lightInjectionBoolProperty       = serializedObject.FindProperty("lightInjection.injectionParameters.enable");
            _lightInjectionColorProperty      = serializedObject.FindProperty("lightInjection.color");
            _lightInjectionParametersProperty = serializedObject.FindProperty("lightInjection.injectionParameters");

            _tintInjectionTitleContent       = new GUIContent("Tint", Aura.ResourcesCollection.tintIconTexture);
            _tintInjectionBoolProperty       = serializedObject.FindProperty("tintInjection.injectionParameters.enable");
            _tintInjectionColorProperty      = serializedObject.FindProperty("tintInjection.color");
            _tintInjectionParametersProperty = serializedObject.FindProperty("tintInjection.injectionParameters");

            _ambientInjectionTitleContent       = new GUIContent("Ambient Lighting", Aura.ResourcesCollection.illuminationIconTexture);
            _ambientInjectionBoolProperty       = serializedObject.FindProperty("ambientInjection.enable");
            _ambientInjectionParametersProperty = serializedObject.FindProperty("ambientInjection");

            _boostInjectionTitleContent       = new GUIContent("Boost", Aura.ResourcesCollection.boostIconTexture);
            _boostInjectionBoolProperty       = serializedObject.FindProperty("boostInjection.enable");
            _boostInjectionParametersProperty = serializedObject.FindProperty("boostInjection");

            _currentVolume = (AuraVolume)target;
        }
Ejemplo n.º 5
0
        /// <summary>
        /// Applies the "Forest" preset
        /// </summary>
        public static void ApplyForestPreset()
        {
            AuraCamera[] auraCameras = Aura.AddAuraToCameras(1);
            for (int i = 0; i < auraCameras.Length; ++i)
            {
                auraCameras[i].frustumSettings.BaseSettings.useDensity              = true;
                auraCameras[i].frustumSettings.BaseSettings.density                 = 0.3f;
                auraCameras[i].frustumSettings.BaseSettings.useScattering           = true;
                auraCameras[i].frustumSettings.BaseSettings.scattering              = 0.75f;
                auraCameras[i].frustumSettings.BaseSettings.useAmbientLighting      = true;
                auraCameras[i].frustumSettings.BaseSettings.ambientLightingStrength = 1.0f;
            }

            RenderSettings.fog         = false;
            RenderSettings.ambientMode = AmbientMode.Trilight;
            Color tmp;

            ColorUtility.TryParseHtmlString("#406381", out tmp);
            RenderSettings.ambientSkyColor = tmp;
            ColorUtility.TryParseHtmlString("#37402C", out tmp);
            RenderSettings.ambientEquatorColor = tmp;
            ColorUtility.TryParseHtmlString("#212420", out tmp);
            RenderSettings.ambientGroundColor = tmp;

            AuraLight[] directionalLights = Aura.AddAuraToDirectionalLights(1);
            for (int i = 0; i < directionalLights.Length; ++i)
            {
                Vector3 tmpRotation = directionalLights[i].transform.rotation.eulerAngles;
                tmpRotation.x = 50.0f;
                directionalLights[i].transform.rotation = Quaternion.Euler(tmpRotation);

                directionalLights[i].GetComponent <Light>().color     = Color.HSVToRGB(0.12f, 0.35f, 1.0f);
                directionalLights[i].GetComponent <Light>().intensity = 1.0f;

                directionalLights[i].strength = 0.5f;
                directionalLights[i].enableOutOfPhaseColor = false;
            }

            DeletePresetVolumes();

            AuraVolume globalVolume = AuraVolume.CreateGameObject(_presetVolumesName, VolumeType.Global).GetComponent <AuraVolume>();

            globalVolume.noiseMask.enable          = true;
            globalVolume.noiseMask.speed           = 0.15f;
            globalVolume.noiseMask.transform.space = Space.World;
            globalVolume.noiseMask.transform.scale = Vector3.one * 3.0f;
            globalVolume.densityInjection.enable   = true;
            globalVolume.densityInjection.strength = 0.1f;
            globalVolume.densityInjection.noiseMaskLevelParameters.contrast       = 15.0f;
            globalVolume.densityInjection.noiseMaskLevelParameters.outputLowValue = 0.0f;
            globalVolume.densityInjection.noiseMaskLevelParameters.outputHiValue  = -1.0f;
            globalVolume.lightInjection.injectionParameters.enable = false;
            globalVolume.scatteringInjection.enable = false;
        }
Ejemplo n.º 6
0
        /// <summary>
        /// Generic method for crating a GameObject with a AuraVolume component assigned
        /// </summary>
        /// <param name="name">Name of the created GameObject</param>
        /// <param name="shape">Desired volume shape</param>
        /// <returns>The created AuraVolume gameObject</returns>
        public static GameObject CreateGameObject(string name, VolumeType shape)
        {
            GameObject newGameObject = new GameObject(name);

            newGameObject.transform.localScale = Vector3.one * 3.0f;
            AuraVolume auraVolume = newGameObject.AddComponent <AuraVolume>();

            auraVolume.volumeShape.shape = shape;
            SetDefaultValues(auraVolume);

            return(newGameObject);
        }
Ejemplo n.º 7
0
 /// <summary>
 /// Set default values
 /// </summary>
 /// <param name="auraVolume"></param>
 private static void SetDefaultValues(AuraVolume auraVolume)
 {
     auraVolume.volumeShape.fading.falloffExponent       = 3.0f;
     auraVolume.volumeShape.fading.xPositiveCubeFade     = 0.25f;
     auraVolume.volumeShape.fading.xNegativeCubeFade     = 0.25f;
     auraVolume.volumeShape.fading.yPositiveCubeFade     = 0.25f;
     auraVolume.volumeShape.fading.yNegativeCubeFade     = 0.25f;
     auraVolume.volumeShape.fading.zPositiveCubeFade     = 0.25f;
     auraVolume.volumeShape.fading.zNegativeCubeFade     = 0.25f;
     auraVolume.volumeShape.fading.angularConeFade       = 0.5f;
     auraVolume.volumeShape.fading.distanceConeFade      = 0.5f;
     auraVolume.volumeShape.fading.widthCylinderFade     = 0.5f;
     auraVolume.volumeShape.fading.yNegativeCylinderFade = 0.25f;
     auraVolume.volumeShape.fading.yPositiveCylinderFade = 0.25f;
     auraVolume.volumeShape.fading.distanceSphereFade    = 0.5f;
     auraVolume.texture2DMask.SetDefaultValues();
     auraVolume.texture3DMask.SetDefaultValues();
     auraVolume.noiseMask.speed                     = 0.125f;
     auraVolume.noiseMask.transform.scale           = Vector3.one * 5.0f;
     auraVolume.densityInjection.useNoiseMask       = true;
     auraVolume.densityInjection.useNoiseMaskLevels = true;
     auraVolume.densityInjection.noiseMaskLevelParameters.SetDefaultValues();
     auraVolume.densityInjection.noiseMaskLevelParameters.contrast = 5.0f;
     auraVolume.densityInjection.useTexture2DMask = true;
     auraVolume.densityInjection.texture2DMaskLevelParameters.SetDefaultValues();
     auraVolume.densityInjection.useTexture3DMask = true;
     auraVolume.densityInjection.texture3DMaskLevelParameters.SetDefaultValues();
     auraVolume.densityInjection.enable                = true; // To have something visible when a volume is added
     auraVolume.densityInjection.strength              = 5.0f; // To have something visible when a volume is added
     auraVolume.scatteringInjection.useNoiseMask       = true;
     auraVolume.scatteringInjection.useNoiseMaskLevels = true;
     auraVolume.scatteringInjection.noiseMaskLevelParameters.SetDefaultValues();
     auraVolume.scatteringInjection.noiseMaskLevelParameters.contrast       = 3.0f;
     auraVolume.scatteringInjection.noiseMaskLevelParameters.outputLowValue = -1.0f;
     auraVolume.scatteringInjection.useTexture2DMask = true;
     auraVolume.scatteringInjection.texture2DMaskLevelParameters.SetDefaultValues();
     auraVolume.scatteringInjection.texture2DMaskLevelParameters.outputLowValue = -1.0f;
     auraVolume.scatteringInjection.useTexture3DMask = true;
     auraVolume.scatteringInjection.texture3DMaskLevelParameters.SetDefaultValues();
     auraVolume.scatteringInjection.texture3DMaskLevelParameters.outputLowValue = -1.0f;
     auraVolume.scatteringInjection.strength = 0.25f;
     auraVolume.lightInjection.injectionParameters.useNoiseMask       = true;
     auraVolume.lightInjection.injectionParameters.useNoiseMaskLevels = true;
     auraVolume.lightInjection.injectionParameters.noiseMaskLevelParameters.SetDefaultValues();
     auraVolume.lightInjection.injectionParameters.noiseMaskLevelParameters.contrast = 5.0f;
     auraVolume.lightInjection.injectionParameters.useTexture2DMask = true;
     auraVolume.lightInjection.injectionParameters.texture2DMaskLevelParameters.SetDefaultValues();
     auraVolume.lightInjection.injectionParameters.useTexture3DMask = true;
     auraVolume.lightInjection.injectionParameters.texture3DMaskLevelParameters.SetDefaultValues();
     auraVolume.lightInjection.injectionParameters.strength = 1;
     auraVolume.lightInjection.color = Color.white;
 }
Ejemplo n.º 8
0
        static void DrawGizmoForAuraVolume(AuraVolume component, GizmoType gizmoType)
        {
            bool isFaded = (int)gizmoType == (int)GizmoType.NonSelected || (int)gizmoType == (int)GizmoType.NotInSelectionHierarchy || (int)gizmoType == (int)GizmoType.NonSelected + (int)GizmoType.NotInSelectionHierarchy;

            if (isFaded && !AuraEditorPrefs.DisplayGizmosWhenUnselected || !isFaded && !AuraEditorPrefs.DisplayGizmosWhenSelected)
            {
                return;
            }

            float opacity = isFaded ? 0.5f : 1.0f;

            DrawGizmo(component, opacity);
        }
Ejemplo n.º 9
0
        /// <summary>
        /// Draws a "Box" gizmo
        /// </summary>
        /// <param name="component">The target component</param>
        /// <param name="alpha">The base opacity</param>
        private static void DrawBox(AuraVolume component, float alpha)
        {
            float thickness = CustomGizmo.pixelWidth;
            Color color     = CustomGizmo.color;

            color.a *= alpha;
            CustomGizmo.DrawCube(component.transform.localToWorldMatrix, color, thickness);

            float xPos = (1.0f - component.volumeShape.fading.xPositiveCubeFade) * 2 - 1;
            float xNeg = component.volumeShape.fading.xNegativeCubeFade * 2 - 1;
            float yPos = (1.0f - component.volumeShape.fading.yPositiveCubeFade) * 2 - 1;
            float yNeg = component.volumeShape.fading.yNegativeCubeFade * 2 - 1;
            float zPos = (1.0f - component.volumeShape.fading.zPositiveCubeFade) * 2 - 1;
            float zNeg = component.volumeShape.fading.zNegativeCubeFade * 2 - 1;

            Vector3 customPointA = new Vector3(xNeg, yPos, zNeg) * 0.5f;
            Vector3 customPointB = new Vector3(xPos, yPos, zNeg) * 0.5f;
            Vector3 customPointC = new Vector3(xPos, yNeg, zNeg) * 0.5f;
            Vector3 customPointD = new Vector3(xNeg, yNeg, zNeg) * 0.5f;
            Vector3 customPointE = new Vector3(xNeg, yPos, zPos) * 0.5f;
            Vector3 customPointF = new Vector3(xPos, yPos, zPos) * 0.5f;
            Vector3 customPointG = new Vector3(xPos, yNeg, zPos) * 0.5f;
            Vector3 customPointH = new Vector3(xNeg, yNeg, zPos) * 0.5f;

            CustomGizmo.DrawLineSegment(CustomGizmo.cubeCornerA, new Vector3(xNeg, yPos, zNeg) * 0.5f, component.transform.localToWorldMatrix, color, thickness);
            CustomGizmo.DrawLineSegment(CustomGizmo.cubeCornerB, new Vector3(xPos, yPos, zNeg) * 0.5f, component.transform.localToWorldMatrix, color, thickness);
            CustomGizmo.DrawLineSegment(CustomGizmo.cubeCornerC, new Vector3(xPos, yNeg, zNeg) * 0.5f, component.transform.localToWorldMatrix, color, thickness);
            CustomGizmo.DrawLineSegment(CustomGizmo.cubeCornerD, new Vector3(xNeg, yNeg, zNeg) * 0.5f, component.transform.localToWorldMatrix, color, thickness);
            CustomGizmo.DrawLineSegment(CustomGizmo.cubeCornerE, new Vector3(xNeg, yPos, zPos) * 0.5f, component.transform.localToWorldMatrix, color, thickness);
            CustomGizmo.DrawLineSegment(CustomGizmo.cubeCornerF, new Vector3(xPos, yPos, zPos) * 0.5f, component.transform.localToWorldMatrix, color, thickness);
            CustomGizmo.DrawLineSegment(CustomGizmo.cubeCornerG, new Vector3(xPos, yNeg, zPos) * 0.5f, component.transform.localToWorldMatrix, color, thickness);
            CustomGizmo.DrawLineSegment(CustomGizmo.cubeCornerH, new Vector3(xNeg, yNeg, zPos) * 0.5f, component.transform.localToWorldMatrix, color, thickness);

            CustomGizmo.DrawLineSegment(customPointA, customPointB, component.transform.localToWorldMatrix, color, thickness);
            CustomGizmo.DrawLineSegment(customPointB, customPointC, component.transform.localToWorldMatrix, color, thickness);
            CustomGizmo.DrawLineSegment(customPointC, customPointD, component.transform.localToWorldMatrix, color, thickness);
            CustomGizmo.DrawLineSegment(customPointD, customPointA, component.transform.localToWorldMatrix, color, thickness);
            CustomGizmo.DrawLineSegment(customPointE, customPointF, component.transform.localToWorldMatrix, color, thickness);

            CustomGizmo.DrawLineSegment(customPointF, customPointG, component.transform.localToWorldMatrix, color, thickness);
            CustomGizmo.DrawLineSegment(customPointG, customPointH, component.transform.localToWorldMatrix, color, thickness);
            CustomGizmo.DrawLineSegment(customPointH, customPointE, component.transform.localToWorldMatrix, color, thickness);
            CustomGizmo.DrawLineSegment(customPointE, customPointF, component.transform.localToWorldMatrix, color, thickness);

            CustomGizmo.DrawLineSegment(customPointA, customPointE, component.transform.localToWorldMatrix, color, thickness);
            CustomGizmo.DrawLineSegment(customPointB, customPointF, component.transform.localToWorldMatrix, color, thickness);
            CustomGizmo.DrawLineSegment(customPointC, customPointG, component.transform.localToWorldMatrix, color, thickness);
            CustomGizmo.DrawLineSegment(customPointD, customPointH, component.transform.localToWorldMatrix, color, thickness);
        }
Ejemplo n.º 10
0
        /// <summary>
        /// Draws a "Global" gizmo
        /// </summary>
        /// <param name="component">The target component</param>
        /// <param name="alpha">The base opacity</param>
        private static void DrawGlobal(AuraVolume component, float alpha)
        {
            Color color = CustomGizmo.color;

            color.a = CustomGizmo.color.a * alpha;
            const int   circlesAmount = 10;
            const float maxWidth      = 5.0f;

            for (int i = 1; i <= circlesAmount; ++i)
            {
                float ratio       = (float)i / (float)circlesAmount;
                float curvedRatio = Mathf.Pow(ratio, 2.5f);
                CustomGizmo.DrawCircle(component.transform.localToWorldMatrix, Matrix4x4.TRS(Vector3.zero, Quaternion.identity, Vector3.one * maxWidth * curvedRatio), color, CustomGizmo.pixelWidth);
            }
        }
Ejemplo n.º 11
0
        /// <summary>
        /// Draws a "Layer" gizmo
        /// </summary>
        /// <param name="component">The target component</param>
        /// <param name="alpha">The base opacity</param>
        private static void DrawLayer(AuraVolume component, float alpha)
        {
            Color color = CustomGizmo.color;

            color.a *= alpha;

            int count = 15;

            for (int i = 0; i < count; ++i)
            {
                float ratio       = 1.0f - ((float)i / (float)count);
                float scaleFactor = 1.0f; // Mathf.Lerp(0.5f, 10.0f, ratio);
                //ratio = 1 - Mathf.Pow(ratio, component.volumeShape.fading.falloffExponent);
                CustomGizmo.DrawSquare(component.transform.localToWorldMatrix, Matrix4x4.TRS(Vector3.up * ratio, Quaternion.identity, Vector3.one * scaleFactor), color, CustomGizmo.pixelWidth);
            }
        }
Ejemplo n.º 12
0
        /// <summary>
        /// Draws a "Cone" gizmo
        /// </summary>
        /// <param name="component">The target component</param>
        /// <param name="alpha">The base opacity</param>
        private static void DrawCone(AuraVolume component, float alpha)
        {
            float thickness = CustomGizmo.pixelWidth;
            Color color     = CustomGizmo.color;

            color.a *= alpha;
            CustomGizmo.DrawCone(component.transform.localToWorldMatrix, color, thickness);

            float z  = 1.0f - component.volumeShape.fading.distanceConeFade;
            float xy = Mathf.Lerp(0, 1.0f - component.volumeShape.fading.angularConeFade, z);

            CustomGizmo.DrawLineSegment(new Vector3(0.0f, 0.5f, 1), new Vector3(0, xy * 0.5f, z), component.transform.localToWorldMatrix, color, thickness);
            CustomGizmo.DrawLineSegment(new Vector3(0.0f, -0.5f, 1), new Vector3(0, -xy * 0.5f, z), component.transform.localToWorldMatrix, color, thickness);
            CustomGizmo.DrawLineSegment(new Vector3(0.5f, 0.0f, 1), new Vector3(xy * 0.5f, 0.0f, z), component.transform.localToWorldMatrix, color, thickness);
            CustomGizmo.DrawLineSegment(new Vector3(-0.5f, 0.0f, 1), new Vector3(-xy * 0.5f, 0.0f, z), component.transform.localToWorldMatrix, color, thickness);

            CustomGizmo.DrawCone(component.transform.localToWorldMatrix, Vector3.zero, Quaternion.identity, new Vector3(xy, xy, z), color, thickness);
        }
Ejemplo n.º 13
0
        /// <summary>
        /// Draws a "Sphere" gizmo
        /// </summary>
        /// <param name="component">The target component</param>
        /// <param name="alpha">The base opacity</param>
        private static void DrawSphere(AuraVolume component, float alpha)
        {
            float thickness = CustomGizmo.pixelWidth;
            Color color     = CustomGizmo.color;

            color.a *= alpha;
            CustomGizmo.DrawSphere(component.transform.localToWorldMatrix, color, CustomGizmo.pixelWidth);

            float x = 1.0f - component.volumeShape.fading.distanceSphereFade;

            CustomGizmo.DrawLineSegment(Vector3.up * 0.5f, Vector3.up * x * 0.5f, component.transform.localToWorldMatrix, color, thickness);
            CustomGizmo.DrawLineSegment(Vector3.down * 0.5f, Vector3.down * x * 0.5f, component.transform.localToWorldMatrix, color, thickness);
            CustomGizmo.DrawLineSegment(Vector3.left * 0.5f, Vector3.left * x * 0.5f, component.transform.localToWorldMatrix, color, thickness);
            CustomGizmo.DrawLineSegment(Vector3.right * 0.5f, Vector3.right * x * 0.5f, component.transform.localToWorldMatrix, color, thickness);
            CustomGizmo.DrawLineSegment(Vector3.back * 0.5f, Vector3.back * x * 0.5f, component.transform.localToWorldMatrix, color, thickness);
            CustomGizmo.DrawLineSegment(Vector3.forward * 0.5f, Vector3.forward * x * 0.5f, component.transform.localToWorldMatrix, color, thickness);

            CustomGizmo.DrawSphere(component.transform.localToWorldMatrix, Vector3.zero, Quaternion.identity, Vector3.one * x, color, thickness);
        }
Ejemplo n.º 14
0
        /// <summary>
        /// Draws the gizmo
        /// </summary>
        /// <param name="component">The target component</param>
        /// <param name="opacity">The gizmo opacity</param>
        private static void DrawGizmo(AuraVolume component, float opacity)
        {
            switch (component.volumeShape.shape)
            {
            case VolumeType.Global:
            {
                DrawGlobal(component, opacity);
            }
            break;

            case VolumeType.Layer:
            {
                DrawLayer(component, opacity);
            }
            break;

            case VolumeType.Box:
            {
                DrawBox(component, opacity);
            }
            break;

            case VolumeType.Sphere:
            {
                DrawSphere(component, opacity);
            }
            break;

            case VolumeType.Cylinder:
            {
                DrawCylinder(component, opacity);
            }
            break;

            case VolumeType.Cone:
            {
                DrawCone(component, opacity);
            }
            break;
            }
        }
Ejemplo n.º 15
0
        /// <summary>
        /// Draws a "Cylinder" gizmo
        /// </summary>
        /// <param name="component">The target component</param>
        /// <param name="alpha">The base opacity</param>
        private static void DrawCylinder(AuraVolume component, float alpha)
        {
            float thickness = CustomGizmo.pixelWidth;
            Color color     = CustomGizmo.color;

            color.a *= alpha;
            CustomGizmo.DrawCylinder(component.transform.localToWorldMatrix, color, thickness);

            float x    = 1.0f - component.volumeShape.fading.widthCylinderFade;
            float yPos = (1.0f - component.volumeShape.fading.yPositiveCylinderFade) * 2 - 1;
            float yNeg = component.volumeShape.fading.yNegativeCylinderFade * 2 - 1;

            CustomGizmo.DrawLineSegment(new Vector3(0.5f, 0.5f, 0), new Vector3(x, yPos, 0) * 0.5f, component.transform.localToWorldMatrix, color, thickness);
            CustomGizmo.DrawLineSegment(new Vector3(-0.5f, 0.5f, 0), new Vector3(-x, yPos, 0) * 0.5f, component.transform.localToWorldMatrix, color, thickness);
            CustomGizmo.DrawLineSegment(new Vector3(0.5f, -0.5f, 0), new Vector3(x, yNeg, 0) * 0.5f, component.transform.localToWorldMatrix, color, thickness);
            CustomGizmo.DrawLineSegment(new Vector3(-0.5f, -0.5f, 0), new Vector3(-x, yNeg, 0) * 0.5f, component.transform.localToWorldMatrix, color, thickness);
            CustomGizmo.DrawLineSegment(new Vector3(0.0f, 0.5f, 0.5f), new Vector3(0, yPos, x) * 0.5f, component.transform.localToWorldMatrix, color, thickness);
            CustomGizmo.DrawLineSegment(new Vector3(0.0f, 0.5f, -0.5f), new Vector3(0, yPos, -x) * 0.5f, component.transform.localToWorldMatrix, color, thickness);
            CustomGizmo.DrawLineSegment(new Vector3(0.0f, -0.5f, 0.5f), new Vector3(0, yNeg, x) * 0.5f, component.transform.localToWorldMatrix, color, thickness);
            CustomGizmo.DrawLineSegment(new Vector3(0.0f, -0.5f, -0.5f), new Vector3(0, yNeg, -x) * 0.5f, component.transform.localToWorldMatrix, color, thickness);

            CustomGizmo.DrawCylinder(component.transform.localToWorldMatrix, (Vector3.up * ((1.0f - component.volumeShape.fading.yPositiveCylinderFade) + component.volumeShape.fading.yNegativeCylinderFade) * 0.5f) - Vector3.up * 0.5f, Quaternion.identity, new Vector3(x, 1.0f - component.volumeShape.fading.yPositiveCylinderFade - component.volumeShape.fading.yNegativeCylinderFade, x), color, thickness);
        }
Ejemplo n.º 16
0
 /// <summary>
 /// Returns an array with all the aura volumes
 /// </summary>
 /// <returns>An array with the aura volumes</returns>
 public static AuraVolume[] GetAuraVolumes()
 {
     return(AuraVolume.FindObjectsOfType <AuraVolume>());
 }
Ejemplo n.º 17
0
        static void HierarchyWindowItemOnGUI(int instanceID, Rect selectionRect)
        {
            if (AuraEditorPrefs.DisplayButtonsInHierarchy)
            {
                GameObject gameObject = (GameObject)EditorUtility.InstanceIDToObject(instanceID);

                if (gameObject != null)
                {
                    float  size = selectionRect.height;
                    Rect   rect = new Rect(selectionRect.x + selectionRect.width, selectionRect.y, size, size);
                    string tooltip;
                    bool   state;


                    //// Cameras

                    Camera     camera     = gameObject.GetComponent <Camera>();
                    AuraCamera auraCamera = gameObject.GetComponent <AuraCamera>();
                    if (camera != null && auraCamera == null)
                    {
                        tooltip = "Add Aura Camera Component";
                        rect.x -= size;

                        if (GUI.Button(rect, new GUIContent(Aura.ResourcesCollection.addIconTexture, tooltip), GuiStyles.ButtonImageOnlyNoBorder))
                        {
                            gameObject.AddComponent <AuraCamera>();
                        }
                    }

                    if (auraCamera != null)
                    {
                        state   = auraCamera.enabled;
                        tooltip = (state ? "Disable" : "Enable") + " Aura Camera";
                        rect.x -= size;

                        if (GUI.Button(rect, new GUIContent(Aura.ResourcesCollection.cameraMiniIconTexture, tooltip), state ? GuiStyles.ButtonPressedImageOnlyNoBorder : GuiStyles.ButtonImageOnlyNoBorder)) // TODO : MAKE THIS A GENERIC HELPER
                        {
                            auraCamera.enabled = !state;
                        }
                    }

                    //// Lights

                    Light     light     = gameObject.GetComponent <Light>();
                    AuraLight auraLight = gameObject.GetComponent <AuraLight>();
                    if (light != null && auraLight == null)
                    {
                        tooltip = "Add Aura Light Component";
                        rect.x -= size;

                        if (GUI.Button(rect, new GUIContent(Aura.ResourcesCollection.addIconTexture, tooltip), GuiStyles.ButtonImageOnlyNoBorder))
                        {
                            gameObject.AddComponent <AuraLight>();
                        }
                    }

                    if (auraLight != null && auraLight.Type != LightType.Area)
                    {
                        state   = auraLight.enabled;
                        tooltip = (state ? "Disable" : "Enable") + " Aura Light";
                        rect.x -= size;
                        Texture2D texture = Aura.ResourcesCollection.pointLightMiniIconTexture;
                        switch (auraLight.Type)
                        {
                        case LightType.Directional:
                        {
                            texture = Aura.ResourcesCollection.directionalLightMiniIconTexture;
                        }
                        break;

                        case LightType.Spot:
                        {
                            texture = Aura.ResourcesCollection.spotLightMiniIconTexture;
                        }
                        break;
                        }

                        if (GUI.Button(rect, new GUIContent(texture, tooltip), state ? GuiStyles.ButtonPressedImageOnlyNoBorder : GuiStyles.ButtonImageOnlyNoBorder)) // TODO : MAKE THIS A GENERIC HELPER
                        {
                            auraLight.enabled = !state;
                        }
                    }

                    //// Volumes

                    AuraVolume auraVolume = gameObject.GetComponent <AuraVolume>();
                    if (auraVolume != null)
                    {
                        state   = auraVolume.enabled;
                        tooltip = (state ? "Disable" : "Enable") + " Aura Volume";
                        rect.x -= size;

                        if (GUI.Button(rect, new GUIContent(Aura.ResourcesCollection.shapeMiniIconTexture, tooltip), state ? GuiStyles.ButtonPressedImageOnlyNoBorder : GuiStyles.ButtonImageOnlyNoBorder)) // TODO : MAKE THIS A GENERIC HELPER
                        {
                            auraVolume.enabled = !state;
                        }
                    }

                    //// Sprites

                    SpriteRenderer spriteRenderer = gameObject.GetComponent <SpriteRenderer>();
                    AuraSprite     auraSprite     = gameObject.GetComponent <AuraSprite>();
                    if (spriteRenderer != null && auraSprite == null)
                    {
                        tooltip = "Add Aura Sprite Component";
                        rect.x -= size;

                        if (GUI.Button(rect, new GUIContent(Aura.ResourcesCollection.addIconTexture, tooltip), GuiStyles.ButtonImageOnlyNoBorder))
                        {
                            gameObject.AddComponent <AuraSprite>();
                        }
                    }

                    if (auraSprite != null)
                    {
                        tooltip = "Aura Sprite";
                        rect.x -= size;
                        GUI.Label(rect, new GUIContent(Aura.ResourcesCollection.spriteMiniIconTexture, tooltip), GuiStyles.ButtonPressedImageOnlyNoBorder);
                    }
                }
            }
        }
Ejemplo n.º 18
0
 /// <summary>
 /// Called when a volume unregisters from the global list
 /// </summary>
 /// <param name="auraVolume">The unregistering volume</param>
 private void VolumesCommonDataManager_OnUnregisterVolume(AuraVolume auraVolume)
 {
     _culler.Unregister(auraVolume);
 }