示例#1
0
        public static Vector3 GetOffset(Vector3 atPosition, Transform cameraTransform)
        {
            HB hb = HB.Instance;

            if (hb == null)
            {
                return(new Vector3(0.0f, 0.0f, 0.0f));
            }

            Vector3    offset;
            HBSettings settings = GetSettings();

#if UNITY_EDITOR
            if (settings.AttachToCameraInEditor)
            {
                offset = HBUtils.GetOffset(atPosition, settings, cameraTransform);
            }
            else
            {
                offset = HBUtils.GetOffset(atPosition, settings);
            }
#else
            offset = HBUtils.GetOffset(atPosition, settings, cameraTransform);
#endif

            return(offset);
        }
示例#2
0
        public static Mesh FixMesh(Mesh originalMesh, Vector3 extents)
        {
            Bounds bounds      = originalMesh.bounds;
            Bounds fixBounds   = new Bounds(bounds.center, extents * 2.0f);
            Mesh   fixVertices = HBUtils.BoundsToMesh(fixBounds);

            CombineInstance fixInstance = new CombineInstance();

            fixInstance.mesh         = fixVertices;
            fixInstance.subMeshIndex = 0;
            fixInstance.transform    = Matrix4x4.identity;

            CombineInstance[] combineInstances = new CombineInstance[originalMesh.subMeshCount];
            for (int i = 0; i < originalMesh.subMeshCount; ++i)
            {
                CombineInstance submeshInstance = new CombineInstance();
                submeshInstance.mesh      = Subdivider.ExtractSubmesh(originalMesh, i);
                submeshInstance.transform = Matrix4x4.identity;
                CombineInstance[] submeshInstances = new[] { fixInstance, submeshInstance };
                Mesh fixedSubmesh = new Mesh();
                fixedSubmesh.CombineMeshes(submeshInstances, true);

                CombineInstance meshInstance = new CombineInstance();
                meshInstance.mesh         = fixedSubmesh;
                meshInstance.transform    = Matrix4x4.identity;
                meshInstance.subMeshIndex = 0;
                combineInstances[i]       = meshInstance;
            }

            Mesh fixedMesh = new Mesh();

            fixedMesh.CombineMeshes(combineInstances, false);

            return(fixedMesh);
        }
示例#3
0
        public void Internal_Rollback(bool full)
        {
            DestroyHBCameras();

            FixBoundsRadius = 50.0f;
            Curvature       = 5.0f;
            Flatten         = 0.0f;
            HorizonXOffset  = 0.0f;
            HorizonYOffset  = 0.0f;
            HorizonZOffset  = 0.0f;

            AttachToCamera  = false;
            m_appliedRadius = 0.0f;

            Material[] materials = Materials;
            if (full)
            {
                HBUtils.Find(out Materials, out m_rendererGroups, new GameObject[0]);
            }
            else
            {
                HBUtils.Find(out Materials, out m_rendererGroups, ExcludeGameObjects);
            }
            HBUtils.HorizonBend(new HBSettings(BendingMode._HB_OFF));
            TryRollbackDefaultMaterial();
            ReplaceUIMaterials(materials, true, full);
            RendererGroupsIterate(renderer =>
            {
                if (renderer == null)
                {
                    return;
                }

                HBFixBounds fixBounds = renderer.GetComponent <HBFixBounds>();
                if (fixBounds != null)
                {
                    if (full || !fixBounds.Lock)
                    {
                        fixBounds.Rollback();
                        DestroyImmediate(fixBounds);
                    }
                }
            });

            HBUtils.ReplaceShaders(Materials, HBShaders, true);

            m_rendererGroups.Clear();

            if (LockMaterials)
            {
                Materials = materials;
            }
            else
            {
                Materials = new Material[0];
            }
        }
示例#4
0
        public static void ApplyFlatten(float flatten)
        {
            HB hb = HB.Instance;

            if (hb == null)
            {
                return;
            }
            hb.Flatten = flatten;
            HBUtils.HBFlatten(flatten);
        }
示例#5
0
        public static void ApplyCurvature(float curvature)
        {
            HB hb = HB.Instance;

            if (hb == null)
            {
                return;
            }
            hb.Curvature = curvature;
            HBUtils.HBCurvature(curvature * CURVATURE_FACTOR);
        }
示例#6
0
 private void FixBoundsSkinned()
 {
     if (OverrideBounds)
     {
         HBUtils.FixSkinned(SkinnedMesh, OriginalSkinnedAABB, SkinnedBounds);
     }
     else
     {
         HBUtils.FixSkinned(SkinnedMesh, OriginalSkinnedAABB, transform, HBOffset());
     }
 }
示例#7
0
        public static void FixSkinned(SkinnedMeshRenderer skinned, float fixBoundsRadius)
        {
            HB hb = HB.Instance;

            if (hb == null)
            {
                return;
            }

            Vector3 hbOffset = HBUtils.GetOffset(GetSettings(), fixBoundsRadius);

            HBUtils.FixSkinned(skinned, skinned.localBounds, skinned.transform, hbOffset);
        }
示例#8
0
        public static void FixMesh(MeshFilter meshFilter, float fixBoundsRadius)
        {
            HB hb = HB.Instance;

            if (hb == null)
            {
                return;
            }

            Vector3 hbOffset = HBUtils.GetOffset(GetSettings(), fixBoundsRadius);

            meshFilter.sharedMesh = HBUtils.FixMesh(meshFilter.sharedMesh, meshFilter.transform, hbOffset);
        }
示例#9
0
        public static void ScreenPointToRays(Camera camera, out Ray[] rays, out float[] maxDistances)
        {
            HB hb = HB.Instance;

            if (hb == null)
            {
                Ray ray = camera.ScreenPointToRay(Input.mousePosition);
                rays         = new[] { ray };
                maxDistances = new[] { Mathf.Infinity };
                return;
            }

            HBUtils.ScreenPointToRays(camera, hb.RaycastStride, hb.FixBoundsRadius, GetSettings(), out rays, out maxDistances);
        }
示例#10
0
        public static void CameraToRays(Transform camerTransform, out Ray[] rays, out float[] maxDistances)
        {
            HB hb = HB.Instance;

            if (hb == null)
            {
                Ray ray = new Ray(camerTransform.position, camerTransform.forward);
                rays         = new[] { ray };
                maxDistances = new[] { Mathf.Infinity };
                return;
            }

            HBUtils.CameraToRays(camerTransform, hb.RaycastStride, hb.FixBoundsRadius, GetSettings(), out rays, out maxDistances);
        }
示例#11
0
        public static void ApplyHorizonOffset(float horizonX, float horizonY, float horizonZ, Transform transform = null)
        {
            HB hb = HB.Instance;

            if (hb == null)
            {
                return;
            }

            hb.HorizonXOffset = horizonX;
            hb.HorizonYOffset = horizonY;
            hb.HorizonZOffset = horizonZ;
            HBUtils.HBHorizonOffset(horizonX, horizonY, horizonZ, transform);
        }
示例#12
0
        public static void ApplyAll(float curvature, float flatten, float horizonX, float horizonY, float horizonZ, Transform transform = null)
        {
            HB hb = HB.Instance;

            if (hb == null)
            {
                return;
            }

            hb.Curvature      = curvature;
            hb.Flatten        = flatten;
            hb.HorizonXOffset = horizonX;
            hb.HorizonYOffset = horizonY;
            hb.HorizonZOffset = horizonZ;

            HBSettings settings = GetSettings();

            HBUtils.HorizonBend(settings, transform);
        }
示例#13
0
        private void FixMesh(bool global)
        {
            Mesh fixedMesh;

            if (OverrideBounds)
            {
                fixedMesh = HBUtils.FixMesh(OriginalMesh, Bounds);
            }
            else
            {
                fixedMesh = HBUtils.FixMesh(OriginalMesh, transform, HBOffset());
            }

            if (IsGlobalSettingOverriden())
            {
                fixedMesh.name = OriginalMesh.name + " HB Local";
                SetMesh(fixedMesh, true, false);
            }
            else
            {
                if (global)
                {
                    fixedMesh.name = OriginalMesh.name + " HB Global";
                    IsMeshFixed    = true;
                    IsBoundsFixed  = false;
                    if (HB.Instance == null)
                    {
                        throw new System.InvalidOperationException("HB.Instance is null");
                    }
                    HB.Instance.Internal_UpdateMeshInGroup(this, fixedMesh);
                }
                else
                {
                    fixedMesh.name = OriginalMesh.name + " HB Local";
                    SetMesh(fixedMesh, true, false);
                }
            }
        }
示例#14
0
        public void Internal_Apply()
        {
            m_rendererGroups.Clear();

            if (m_defaultMaterial == null)
            {
                GameObject cube = GameObject.CreatePrimitive(PrimitiveType.Cube);
                m_defaultMaterial = cube.GetComponent <Renderer>().sharedMaterial;
                DestroyImmediate(cube);
            }

            if (m_defaultParticle == null)
            {
                GameObject particles = new GameObject();
                particles.AddComponent <ParticleSystem>();
                m_defaultParticle = particles.GetComponent <Renderer>().sharedMaterial;
                DestroyImmediate(particles);
            }


            m_appliedRadius = FixBoundsRadius;
            Material[] materials;

            EditorUtility.DisplayProgressBar("Horizon Bend", "Searching for materials", 0.1f);
            HBUtils.Find(out materials, out m_rendererGroups, ExcludeGameObjects);
            if (!LockMaterials)
            {
                Materials = materials;
            }

            EditorUtility.DisplayProgressBar("Horizon Bend", "Replacing default materials", 0.2f);
            Materials = ReplaceUIMaterials(Materials, false, false);
            TryRelpaceDefaultMaterials();

            EditorUtility.DisplayProgressBar("Horizon Bend", "Replacing shaders", 0.3f);
            HBUtils.ReplaceShaders(Materials, HBShaders, false);

            EditorUtility.DisplayProgressBar("Horizon Bend", "Cleaning materials", 0.4f);
            Materials = HBUtils.Trim(Materials, m_rendererGroups, CustomShaders);
            CreateHBCameras();

            EditorUtility.DisplayProgressBar("Horizon Bend", "Fixing Bounds", 0.5f);
            CreateHBFixBounds();
            FixBounds();

            EditorUtility.DisplayProgressBar("Horizon Bend", "Completed", 1.0f);

            Transform fakeCameraTransform = null;
            bool      attachToCamera      = true;

            if (!AttachToCamera)
            {
                fakeCameraTransform = transform;
                attachToCamera      = false;
            }

            HBUtils.HorizonBend(new HBSettings(BendingMode, Curvature * CURVATURE_FACTOR, Flatten, HorizonXOffset, HorizonYOffset, HorizonZOffset, attachToCamera), fakeCameraTransform);
            HBUtils.HBMode(BendingMode);

            EditorUtility.ClearProgressBar();
        }
示例#15
0
        public void FixBounds(bool global)
        {
            if (MeshFilter == null)
            {
                if (SkinnedMesh == null)
                {
                    Debug.LogError("m_fixBounds.MeshFilter is null. Unable to FixBounds. GameObject " + name);
                }
                return;
            }

            if (OriginalMesh == null)
            {
                if (SkinnedMesh == null)
                {
                    Debug.LogError("m_fixBounds.OriginalMesh is null. Unable to FixBounds. GameObject " + name);
                }
                return;
            }

            if (gameObject.isStatic)
            {
                FixMesh(global);
            }
            else
            {
                Mesh fixedMesh;
                if (OverrideBounds)
                {
                    fixedMesh = HBUtils.FixBounds(OriginalMesh, Bounds);
                }
                else
                {
                    fixedMesh = HBUtils.FixBounds(OriginalMesh, transform, HBOffset());
                }

                if (IsGlobalSettingOverriden())
                {
                    fixedMesh.name = OriginalMesh.name + " HB Local";
                    SetMesh(fixedMesh, false, true);
                }
                else
                {
                    if (global)
                    {
                        fixedMesh.name = OriginalMesh.name + " HB Global";
                        IsMeshFixed    = false;
                        IsBoundsFixed  = true;

                        if (HB.Instance == null)
                        {
                            throw new System.InvalidOperationException("HB.Instance is null");
                        }
                        HB.Instance.Internal_UpdateMeshInGroup(this, fixedMesh);
                    }
                    else
                    {
                        fixedMesh.name = OriginalMesh.name + " HB Local";
                        SetMesh(fixedMesh, false, true);
                    }
                }
            }
        }
示例#16
0
 public static void FixMesh(MeshFilter meshFilter, Vector3 extents)
 {
     meshFilter.sharedMesh = HBUtils.FixMesh(meshFilter.sharedMesh, extents);
 }
示例#17
0
        public Vector3 HBOffset()
        {
            HBSettings settings = new HBSettings(BendingMode, Curvature * HB.CURVATURE_FACTOR, Flatten, HorizonXOffset, HorizonYOffset, HorizonZOffset, false);

            return(HBUtils.GetOffset(settings, FixBoundsRadius));
        }
示例#18
0
 public static void FixSkinned(SkinnedMeshRenderer skinned, Vector3 extents)
 {
     HBUtils.FixSkinned(skinned, skinned.localBounds, extents);
 }
示例#19
0
        private void Update()
        {
            if (Application.isPlaying)
            {
                return;
            }

            bool positionChanged = false;

            if (m_previosPosition != transform.position)
            {
                positionChanged   = !AttachToCamera;
                m_previosPosition = transform.position;
            }

            if (RaycastStride < 0.01f)
            {
                RaycastStride = 0.01f;
            }

            if (m_previousRadius != FixBoundsRadius)
            {
                if (FixBoundsRadius < 0)
                {
                    FixBoundsRadius = 0;
                }

                m_previousRadius = FixBoundsRadius;
            }
            if (m_previousCurvature != Curvature)
            {
                HBUtils.HBCurvature(Curvature * CURVATURE_FACTOR);
                m_previousCurvature = Curvature;
            }

            if (m_previousFlatten != Flatten)
            {
                if (Flatten < 0)
                {
                    Flatten = 0;
                }
                HBUtils.HBFlatten(Flatten);
                m_previousFlatten = Flatten;
            }

            if (m_previousHorizonZOffset != HorizonZOffset || m_previousHorizonYOffset != HorizonYOffset || m_previousHorizonXOffset != HorizonXOffset || positionChanged)
            {
                if (AttachToCamera)
                {
                    HBUtils.HBHorizonOffset(HorizonXOffset, HorizonYOffset, HorizonZOffset);
                }
                else
                {
                    HBUtils.HBHorizonOffset(HorizonXOffset, HorizonYOffset, HorizonZOffset, transform);
                }

                m_previousHorizonZOffset = HorizonZOffset;
                m_previousHorizonYOffset = HorizonYOffset;
                m_previousHorizonXOffset = HorizonXOffset;
            }

            if (m_previousMode != BendingMode)
            {
                HBUtils.HBMode(BendingMode);
                m_previousMode = BendingMode;
            }

            if (m_prevCameraTracking != AttachToCamera)
            {
                if (AttachToCamera)
                {
                    HBUtils.HBHorizonOffset(HorizonXOffset, HorizonYOffset, HorizonZOffset);
                }
                else
                {
                    HBUtils.HBHorizonOffset(HorizonXOffset, HorizonYOffset, HorizonZOffset, transform);
                }

                m_prevCameraTracking = AttachToCamera;
            }
        }
示例#20
0
        public static Vector3 GetOffset(HBSettings settings, float radius)
        {
            Vector3 atPoint = Vector3.Scale(new Vector3(settings.HorizonXOffset, settings.HorizonYOffset, settings.HorizonZOffset), settings.Mask) + settings.Gradient * radius;

            return(HBUtils.GetOffset(atPoint, settings, null));
        }