Beispiel #1
0
    protected override void CalculateAsteroids(out List <SgtBeltAsteroid> asteroids, out bool pool)
    {
        asteroids = new List <SgtBeltAsteroid>();
        pool      = true;

        SgtHelper.BeginRandomSeed(Seed);
        {
            for (var i = 0; i < AsteroidCount; i++)
            {
                var variant = GetRandomAsteroidVariant();

                if (variant != null)
                {
                    var asteroid   = SgtClassPool <SgtBeltAsteroid> .Pop() ?? new SgtBeltAsteroid(); asteroids.Add(asteroid);
                    var distance01 = Random.value;

                    asteroid.MainTex       = variant.MainTex;
                    asteroid.HeightTex     = variant.HeightTex;
                    asteroid.Color         = Color.white;
                    asteroid.Radius        = Random.Range(AsteroidRadiusMin, AsteroidRadiusMax);
                    asteroid.Height        = Random.Range(-Thickness, Thickness);
                    asteroid.Angle         = Random.Range(0.0f, Mathf.PI * 2.0f);
                    asteroid.Spin          = Random.Range(-AsteroidSpin, AsteroidSpin);
                    asteroid.OrbitAngle    = Random.Range(0.0f, Mathf.PI * 2.0f);
                    asteroid.OrbitSpeed    = Mathf.Lerp(InnerSpeed, OuterSpeed, distance01);
                    asteroid.OrbitDistance = Mathf.Lerp(InnerRadius, OuterRadius, distance01);
                }
            }
        }
        SgtHelper.EndRandomSeed();
    }
    protected override void CalculateStars(out List <SgtStarfieldStar> stars, out bool pool)
    {
        stars = tempStars; tempStars.Clear();
        pool  = true;

        SgtHelper.BeginRandomSeed(Seed);
        {
            var armStep   = 360.0f * SgtHelper.Reciprocal(ArmCount);
            var twistStep = 360.0f * Twist;

            for (var i = 0; i < StarCount; i++)
            {
                var star      = SgtClassPool <SgtStarfieldStar> .Pop() ?? new SgtStarfieldStar(); stars.Add(star);
                var position  = Random.insideUnitSphere;
                var magnitude = 1 - (Random.insideUnitSphere).magnitude;

                position *= (1 - magnitude) * Thickness.Evaluate(Random.value);

                position += Quaternion.AngleAxis(i * armStep + magnitude * twistStep, Vector3.up) * Vector3.forward * magnitude;

                star.Sprite      = GetRandomStarSprite();
                star.Color       = Color.white;
                star.Radius      = Random.Range(StarRadiusMin, StarRadiusMax);
                star.Angle       = Random.Range(0.0f, Mathf.PI * 2.0f);
                star.Position    = position * Radius;
                star.PulseRange  = Random.value * StarPulseMax;
                star.PulseSpeed  = Random.value;
                star.PulseOffset = Random.value;
            }
        }
        SgtHelper.EndRandomSeed();
    }
    protected override void CalculateStars(out List <SgtStarfieldStar> stars, out bool pool)
    {
        stars = tempStars; tempStars.Clear();
        pool  = true;

        SgtHelper.BeginRandomSeed(Seed);
        {
            for (var i = 0; i < StarCount; i++)
            {
                var star     = SgtClassPool <SgtStarfieldStar> .Pop() ?? new SgtStarfieldStar(); stars.Add(star);
                var position = default(Vector3);

                position.x = Random.Range(-Size.x, Size.x);
                position.y = Random.Range(-Size.y, Size.y);
                position.z = Random.Range(-Size.z, Size.z);

                star.Sprite      = GetRandomStarSprite();
                star.Color       = Color.white;
                star.Radius      = Random.Range(StarRadiusMin, StarRadiusMax);
                star.Angle       = Random.Range(0.0f, Mathf.PI * 2.0f);
                star.Position    = position;
                star.PulseRange  = Random.value * StarPulseMax;
                star.PulseSpeed  = Random.value;
                star.PulseOffset = Random.value;
            }
        }
        SgtHelper.EndRandomSeed();
    }
Beispiel #4
0
    protected override void CalculateAsteroids(out List <SgtBeltAsteroid> asteroids, out bool pool)
    {
        asteroids = new List <SgtBeltAsteroid>();
        pool      = true;

        SgtHelper.BeginRandomSeed(Seed);
        {
            for (var i = 0; i < AsteroidCount; i++)
            {
                var variant = GetRandomAsteroidVariant();

                if (variant != null)
                {
                    var asteroid   = SgtClassPool <SgtBeltAsteroid> .Pop() ?? new SgtBeltAsteroid(); asteroids.Add(asteroid);
                    var distance01 = Random.value;
                    var offset     = SpeedNoiseDistribution.Evaluate(distance01);

                    asteroid.MainTex       = variant.MainTex;
                    asteroid.HeightTex     = variant.HeightTex;
                    asteroid.Color         = Color.white;
                    asteroid.Radius        = RadiusDistribution.Evaluate(Random.value);
                    asteroid.Height        = HeightDistribution.Evaluate(Random.value);
                    asteroid.Angle         = Random.Range(0.0f, Mathf.PI * 2.0f);
                    asteroid.Spin          = SpinDistribution.Evaluate(Random.value);
                    asteroid.OrbitAngle    = Random.Range(0.0f, Mathf.PI * 2.0f);
                    asteroid.OrbitSpeed    = SpeedDistribution.Evaluate(distance01) + Random.Range(-offset, offset);
                    asteroid.OrbitDistance = DistanceDistribution.Evaluate(distance01);
                }
            }
        }
        SgtHelper.EndRandomSeed();
    }
Beispiel #5
0
    public SgtCustomBelt MakeEditableCopy(int layer, Transform parent, Vector3 localPosition, Quaternion localRotation, Vector3 localScale)
    {
#if UNITY_EDITOR
        SgtHelper.BeginUndo("Create Editable Belt Copy");
#endif
        var gameObject = SgtHelper.CreateGameObject("Editable Belt Copy", layer, parent, localPosition, localRotation, localScale);
        var customBelt = SgtHelper.AddComponent <SgtCustomBelt>(gameObject, false);
        var quads      = new List <SgtBeltAsteroid>();
        var quadCount  = BeginQuads();

        for (var i = 0; i < quadCount; i++)
        {
            var asteroid = SgtClassPool <SgtBeltAsteroid> .Pop() ?? new SgtBeltAsteroid();

            NextQuad(ref asteroid, i);

            quads.Add(asteroid);
        }

        EndQuads();

        // Copy common settings
        if (Lights != null)
        {
            customBelt.Lights = new List <Light>(Lights);
        }

        if (Shadows != null)
        {
            customBelt.Shadows = new List <SgtShadow>(Shadows);
        }

        customBelt.Color         = Color;
        customBelt.Brightness    = Brightness;
        customBelt.MainTex       = MainTex;
        customBelt.HeightTex     = HeightTex;
        customBelt.Layout        = Layout;
        customBelt.LayoutColumns = LayoutColumns;
        customBelt.LayoutRows    = LayoutRows;

        if (Rects != null)
        {
            customBelt.Rects = new List <Rect>(Rects);
        }

        customBelt.RenderQueue       = RenderQueue;
        customBelt.RenderQueueOffset = RenderQueueOffset;
        customBelt.OrbitOffset       = OrbitOffset;
        customBelt.OrbitSpeed        = OrbitSpeed;

        // Copy custom settings
        customBelt.Asteroids = quads;

        // Update
        customBelt.UpdateMaterial();
        customBelt.UpdateMeshesAndModels();

        return(customBelt);
    }
Beispiel #6
0
    public SgtCustomStarfield MakeEditableCopy(int layer, Transform parent, Vector3 localPosition, Quaternion localRotation, Vector3 localScale)
    {
#if UNITY_EDITOR
        SgtHelper.BeginUndo("Create Editable Starfield Copy");
#endif
        var gameObject      = SgtHelper.CreateGameObject("Editable Starfield Copy", layer, parent, localPosition, localRotation, localScale);
        var customStarfield = SgtHelper.AddComponent <SgtCustomStarfield>(gameObject, false);
        var quads           = new List <SgtPointStar>();
        var starCount       = BeginQuads();

        for (var i = 0; i < starCount; i++)
        {
            var quad = SgtClassPool <SgtPointStar> .Pop() ?? new SgtPointStar();

            NextQuad(ref quad, i);

            quads.Add(quad);
        }

        EndQuads();

        // Copy common settings
        customStarfield.Color             = Color;
        customStarfield.Brightness        = Brightness;
        customStarfield.MainTex           = MainTex;
        customStarfield.Layout            = Layout;
        customStarfield.LayoutColumns     = LayoutColumns;
        customStarfield.LayoutRows        = LayoutRows;
        customStarfield.RenderQueue       = RenderQueue;
        customStarfield.RenderQueueOffset = RenderQueueOffset;
        customStarfield.FollowCameras     = FollowCameras;
        customStarfield.Softness          = Softness;
        customStarfield.Wrap              = Wrap;
        customStarfield.WrapSize          = WrapSize;
        customStarfield.Stretch           = Stretch;
        customStarfield.StretchVector     = StretchVector;
        customStarfield.StretchScale      = StretchScale;
        customStarfield.FadeNear          = FadeNear;
        customStarfield.FadeNearRadius    = FadeNearRadius;
        customStarfield.FadeNearThickness = FadeNearThickness;
        customStarfield.FadeNearTex       = FadeNearTex;
        customStarfield.FadeFar           = FadeFar;
        customStarfield.FadeFarRadius     = FadeFarRadius;
        customStarfield.FadeFarThickness  = FadeFarThickness;
        customStarfield.FadeFarTex        = FadeFarTex;
        customStarfield.Pulse             = Pulse;
        customStarfield.PulseOffset       = PulseOffset;
        customStarfield.PulseSpeed        = PulseSpeed;

        // Copy custom settings
        customStarfield.Stars = quads;

        // Update
        customStarfield.UpdateMaterial();
        customStarfield.UpdateMeshesAndModels();

        return(customStarfield);
    }
    public SgtCustomStarfield MakeEditableCopy(int layer, Transform parent, Vector3 localPosition, Quaternion localRotation, Vector3 localScale)
    {
#if UNITY_EDITOR
        SgtHelper.BeginUndo("Create Editable Starfield Copy");
#endif

        var gameObject      = SgtHelper.CreateGameObject("Editable Starfield Copy", layer, parent, localPosition, localRotation, localScale);
        var customStarfield = SgtHelper.AddComponent <SgtCustomStarfield>(gameObject, false);
        var stars           = default(List <SgtStarfieldStar>);
        var pool            = default(bool);

        CalculateStars(out stars, out pool);

        if (stars != null)
        {
            if (pool == true)
            {
                customStarfield.Stars = stars;
            }
            else
            {
                for (var i = 0; i < stars.Count; i++)
                {
                    var star = stars[i];

                    if (star != null)
                    {
                        var newStar = SgtClassPool <SgtStarfieldStar> .Pop() ?? new SgtStarfieldStar(); customStarfield.Stars.Add(star);

                        newStar.CopyFrom(star);
                    }
                }
            }
        }

        customStarfield.Color             = Color;
        customStarfield.Brightness        = Brightness;
        customStarfield.RenderQueue       = RenderQueue;
        customStarfield.RenderQueueOffset = RenderQueueOffset;
        customStarfield.Age                = Age;
        customStarfield.TimeScale          = TimeScale;
        customStarfield.Softness           = Softness;
        customStarfield.AutoRegenerate     = AutoRegenerate;
        customStarfield.StretchToObservers = StretchToObservers;
        customStarfield.StretchOverride    = StretchOverride;
        customStarfield.StretchVector      = StretchVector;
        customStarfield.StretchScale       = StretchScale;
        customStarfield.FadeNear           = FadeNear;
        customStarfield.FadeNearRadius     = FadeNearRadius;
        customStarfield.FadeNearThickness  = FadeNearThickness;
        customStarfield.FadeFar            = FadeFar;
        customStarfield.FadeFarRadius      = FadeFarRadius;
        customStarfield.FadeFarThickness   = FadeFarThickness;
        customStarfield.FollowObservers    = FollowObservers;
        customStarfield.AllowPulse         = AllowPulse;

        return(customStarfield);
    }
Beispiel #8
0
    private void ClearShells()
    {
        for (var i = shells.Count - 1; i >= 0; i--)
        {
            SgtClassPool <Shell> .Add(shells[i]);
        }

        shells.Clear();
    }
Beispiel #9
0
    protected override void CalculateStars(out List <SgtStarfieldStar> stars, out bool pool)
    {
        var texture = SourceTex as Texture2D;

        stars = tempStars; tempStars.Clear();
        pool  = true;

        if (texture != null && Resolution > 0.0f && Resolution <= 1.0f)
        {
#if UNITY_EDITOR
            SgtHelper.MakeTextureReadable(texture);
            SgtHelper.MakeTextureTruecolor(texture);
#endif
            var samplesX = Mathf.FloorToInt(SourceTex.width * Resolution);
            var samplesY = Mathf.FloorToInt(SourceTex.height * Resolution);
            var stepX    = SgtHelper.Reciprocal(samplesX);
            var stepY    = SgtHelper.Reciprocal(samplesY);
            var halfSize = Size * 0.5f;
            var scale    = SgtHelper.Divide(SourceTex.width, samplesX);

            SgtHelper.BeginRandomSeed(Seed);
            {
                for (var y = 0; y < samplesY; y++)
                {
                    for (var x = 0; x < samplesX; x++)
                    {
                        var fracX = x * stepX;
                        var fracY = y * stepY;
                        var pixel = texture.GetPixelBilinear(fracX, fracY);
                        var gray  = pixel.grayscale;

                        if (gray > Threshold)
                        {
                            var star     = SgtClassPool <SgtStarfieldStar> .Pop() ?? new SgtStarfieldStar(); stars.Add(star);
                            var position = -halfSize + Random.insideUnitSphere * Jitter * StarRadiusMax * scale;

                            position.x += Size.x * fracX;
                            position.y += Size.y * GetHeight(pixel);
                            position.z += Size.z * fracY;

                            star.Sprite      = GetRandomStarSprite();
                            star.Color       = pixel;
                            star.Radius      = Random.Range(StarRadiusMin, StarRadiusMax) * scale;
                            star.Angle       = Random.Range(0.0f, Mathf.PI * 2.0f);
                            star.Position    = position;
                            star.PulseRange  = Random.value * StarPulseMax;
                            star.PulseSpeed  = Random.value;
                            star.PulseOffset = Random.value;
                        }
                    }
                }
            }
            SgtHelper.EndRandomSeed();
        }
    }
Beispiel #10
0
    private Shell AddShell(long detail)
    {
        var shell = SgtClassPool <Shell> .Pop() ?? new Shell();

        shell.Detail = detail;
        shell.Inner  = default(SgtBoundsL);

        shells.Add(shell);

        return(shell);
    }
Beispiel #11
0
    protected override void OnDestroy()
    {
        base.OnDestroy();

        if (Asteroids != null)
        {
            for (var i = Asteroids.Count - 1; i >= 0; i--)
            {
                SgtClassPool <SgtBeltAsteroid> .Add(Asteroids[i]);
            }
        }
    }
    protected override void OnDestroy()
    {
        base.OnDestroy();

        if (Stars != null)
        {
            for (var i = Stars.Count - 1; i >= 0; i--)
            {
                SgtClassPool <SgtPointStar> .Add(Stars[i]);
            }
        }
    }
Beispiel #13
0
    public static void Clear <T>(List <T> cameraStates)
        where T : SgtCameraState
    {
        if (cameraStates != null)
        {
            for (var i = cameraStates.Count - 1; i >= 0; i--)
            {
                SgtClassPool <T> .Add(cameraStates[i]);
            }

            cameraStates.Clear();
        }
    }
    protected override void CalculateStars(out List <SgtStarfieldStar> stars, out bool pool)
    {
        stars = tempStars; tempStars.Clear();
        pool  = true;

        SgtHelper.BeginRandomSeed(Seed);
        {
            for (var i = 0; i < StarCount; i++)
            {
                var star     = SgtClassPool <SgtStarfieldStar> .Pop() ?? new SgtStarfieldStar(); stars.Add(star);
                var x        = Random.Range(-0.5f, 0.5f);
                var y        = Random.Range(-0.5f, 0.5f);
                var z        = Random.Range(Offset * 0.5f, 0.5f);
                var position = default(Vector3);

                if (Random.value >= 0.5f)
                {
                    z = -z;
                }

                switch (Random.Range(0, 3))
                {
                case 0: position = new Vector3(z, x, y); break;

                case 1: position = new Vector3(x, z, y); break;

                case 2: position = new Vector3(x, y, z); break;
                }

                star.Sprite      = GetRandomStarSprite();
                star.Color       = Color.white;
                star.Radius      = Random.Range(StarRadiusMin, StarRadiusMax);
                star.Angle       = Random.Range(0.0f, Mathf.PI * 2.0f);
                star.Position    = Vector3.Scale(position, Extents);
                star.PulseRange  = Random.value * StarPulseMax;
                star.PulseSpeed  = Random.value;
                star.PulseOffset = Random.value;
            }
        }
        SgtHelper.EndRandomSeed();
    }
Beispiel #15
0
    public SgtCustomStarfield MakeEditableCopy(Transform parent, Vector3 localPosition, Quaternion localRotation, Vector3 localScale)
    {
#if UNITY_EDITOR
        SgtHelper.BeginUndo("Create Editable Starfield Copy");
#endif

        var gameObject      = SgtHelper.CreateGameObject("Editable Starfield Copy", parent, localPosition, localRotation, localScale);
        var customStarfield = SgtHelper.AddComponent <SgtCustomStarfield>(gameObject, false);
        var stars           = default(List <SgtStarfieldStar>);
        var pool            = default(bool);

        CalculateStars(out stars, out pool);

        if (stars != null)
        {
            if (pool == true)
            {
                customStarfield.Stars = stars;
            }
            else
            {
                for (var i = 0; i < stars.Count; i++)
                {
                    var star = stars[i];

                    if (star != null)
                    {
                        var newStar = SgtClassPool <SgtStarfieldStar> .Pop() ?? new SgtStarfieldStar(); customStarfield.Stars.Add(star);

                        newStar.CopyFrom(star);
                    }
                }
            }
        }

        customStarfield.Color           = Color;
        customStarfield.Brightness      = Brightness;
        customStarfield.FollowObservers = FollowObservers;

        return(customStarfield);
    }
    public SgtCustomBelt MakeEditableCopy(int layer, Transform parent, Vector3 localPosition, Quaternion localRotation, Vector3 localScale)
    {
#if UNITY_EDITOR
        SgtHelper.BeginUndo("Create Editable Belt Copy");
#endif
        var gameObject = SgtHelper.CreateGameObject("Editable Belt Copy", layer, parent, localPosition, localRotation, localScale);
        var customBelt = SgtHelper.AddComponent <SgtCustomBelt>(gameObject, false);
        var asteroids  = default(List <SgtBeltAsteroid>);
        var pool       = default(bool);

        CalculateAsteroids(out asteroids, out pool);

        if (asteroids != null)
        {
            if (pool == true)
            {
                customBelt.Asteroids = asteroids;
            }
            else
            {
                for (var i = 0; i < asteroids.Count; i++)
                {
                    var asteroid = asteroids[i];

                    if (asteroid != null)
                    {
                        var newAsteroid = SgtClassPool <SgtBeltAsteroid> .Pop() ?? new SgtBeltAsteroid(); customBelt.Asteroids.Add(asteroid);

                        newAsteroid.CopyFrom(asteroid);
                    }
                }
            }
        }

        customBelt.Color      = Color;
        customBelt.Brightness = Brightness;

        return(customBelt);
    }
    protected override void CalculateStars(out List <SgtStarfieldStar> stars, out bool pool)
    {
        stars = tempStars; tempStars.Clear();
        pool  = true;

        SgtHelper.BeginRandomSeed(Seed);
        {
            for (var i = 0; i < StarCount; i++)
            {
                var star     = SgtClassPool <SgtStarfieldStar> .Pop() ?? new SgtStarfieldStar(); stars.Add(star);
                var position = Random.insideUnitSphere;

                position.y *= Symmetry;

                star.Sprite   = GetRandomStarSprite();
                star.Color    = Color.white;
                star.Radius   = Random.Range(StarRadiusMin, StarRadiusMax);
                star.Angle    = Random.Range(0.0f, Mathf.PI * 2.0f);
                star.Position = position.normalized * Radius;
            }
        }
        SgtHelper.EndRandomSeed();
    }
Beispiel #18
0
    public static T Save <T>(ref List <T> cameraStates, Camera camera)
        where T : SgtCameraState, new()
    {
        if (cameraStates == null)
        {
            cameraStates = new List <T>();
        }

        for (var i = cameraStates.Count - 1; i >= 0; i--)
        {
            var cameraState = cameraStates[i];

            if (cameraState == null)
            {
                cameraStates.RemoveAt(i); continue;
            }

            if (cameraState.Camera == null)
            {
                SgtClassPool <T> .Add(cameraState); cameraStates.RemoveAt(i); continue;
            }

            if (cameraState.Camera == camera)
            {
                return(cameraState);
            }
        }

        var newCameraState = SgtClassPool <T> .Pop() ?? new T();

        newCameraState.Camera = camera;

        cameraStates.Add(newCameraState);

        return(newCameraState);
    }
    protected override void CalculateStars(out List <SgtStarfieldStar> stars, out bool pool)
    {
        stars = tempStars; tempStars.Clear();
        pool  = true;

        SgtHelper.BeginRandomSeed(Seed);
        {
            for (var i = 0; i < StarCount; i++)
            {
                var star      = SgtClassPool <SgtStarfieldStar> .Pop() ?? new SgtStarfieldStar(); stars.Add(star);
                var position  = Random.insideUnitSphere;
                var magnitude = Offset;

                if (Inverse == true)
                {
                    magnitude += (1.0f - position.magnitude) * (1.0f - Offset);
                }
                else
                {
                    magnitude += position.magnitude * (1.0f - Offset);
                }

                position.y *= Symmetry;

                star.Sprite      = GetRandomStarSprite();
                star.Color       = Color.white;
                star.Radius      = Random.Range(StarRadiusMin, StarRadiusMax);
                star.Angle       = Random.Range(0.0f, Mathf.PI * 2.0f);
                star.Position    = position.normalized * magnitude * Radius;
                star.PulseRange  = Random.value * StarPulseMax;
                star.PulseSpeed  = Random.value;
                star.PulseOffset = Random.value;
            }
        }
        SgtHelper.EndRandomSeed();
    }
    protected override void RegenerateMeshes()
    {
        var stars = default(List <SgtStarfieldStar>);
        var pool  = default(bool);

        CalculateStars(out stars, out pool);

        if (stars != null)
        {
            // Sort stars into groups
            for (var i = stars.Count - 1; i >= 0; i--)
            {
                var star = stars[i];

                if (star != null)
                {
                    var group = GetGroup(star.Sprite);

                    group.Stars.Add(star);
                }
            }

            // Pool stars?
            if (pool == true)
            {
                SgtClassPool <SgtStarfieldStar> .Add(stars);
            }

            // Build groups
            for (var i = groups.Count - 1; i >= 0; i--)
            {
                var group = groups[i];

                if (group.Stars.Count > 0)
                {
                    var groupStars = group.Stars;
                    var minMaxSet  = false;
                    var min        = default(Vector3);
                    var max        = default(Vector3);

                    SgtProceduralMesh.Clear();

                    for (var j = groupStars.Count - 1; j >= 0; j--)
                    {
                        var star     = groupStars[j];
                        var position = star.Position;
                        var radius   = star.Radius;
                        var uv       = SgtHelper.CalculateSpriteUV(star.Sprite);
                        var rotation = Quaternion.FromToRotation(Vector3.back, position.normalized) * Quaternion.Euler(0.0f, 0.0f, star.Angle);
                        var up       = rotation * Vector3.up * radius;
                        var right    = rotation * Vector3.right * radius;

                        ExpandBounds(ref minMaxSet, ref min, ref max, position, radius);

                        SgtProceduralMesh.PushPosition(position - up - right);
                        SgtProceduralMesh.PushPosition(position - up + right);
                        SgtProceduralMesh.PushPosition(position + up - right);
                        SgtProceduralMesh.PushPosition(position + up + right);

                        SgtProceduralMesh.PushColor(star.Color, 4);

                        SgtProceduralMesh.PushCoord1(uv.x, uv.y);
                        SgtProceduralMesh.PushCoord1(uv.z, uv.y);
                        SgtProceduralMesh.PushCoord1(uv.x, uv.w);
                        SgtProceduralMesh.PushCoord1(uv.z, uv.w);
                    }

                    var bounds = SgtHelper.NewBoundsFromMinMax(min, max);

                    SgtProceduralMesh.SplitQuads(HideFlags.DontSave);

                    var meshCount = SgtProceduralMesh.Count;

                    // Copy meshes
                    for (var j = 0; j < meshCount; j++)
                    {
                        var mesh  = SgtProceduralMesh.Pop();
                        var model = group.Models.Count > j ? group.Models[j] : SgtStarfieldModel.Create(group);

                        mesh.bounds = bounds;

                        model.Mesh = mesh;
                    }
                }
            }
        }
    }
    protected virtual void RegenerateMeshes()
    {
        var stars = default(List <SgtStarfieldStar>);
        var pool  = default(bool);

        CalculateStars(out stars, out pool);

        if (stars != null)
        {
            // Sort stars into groups
            for (var i = stars.Count - 1; i >= 0; i--)
            {
                var star = stars[i];

                if (star != null)
                {
                    var group = GetGroup(star.Sprite);

                    group.Stars.Add(star);
                }
            }

            // Pool stars?
            if (pool == true)
            {
                SgtClassPool <SgtStarfieldStar> .Add(stars);
            }

            // Build groups
            for (var i = groups.Count - 1; i >= 0; i--)
            {
                var group = groups[i];

                if (group.Stars.Count > 0)
                {
                    var groupStars = group.Stars;
                    var minMaxSet  = false;
                    var min        = default(Vector3);
                    var max        = default(Vector3);

                    SgtProceduralMesh.Clear();

                    for (var j = groupStars.Count - 1; j >= 0; j--)
                    {
                        var star     = groupStars[j];
                        var position = star.Position;
                        var radius   = star.Radius;
                        var uv       = SgtHelper.CalculateSpriteUV(star.Sprite);
                        var angle    = star.Angle / Mathf.PI;

                        ExpandBounds(ref minMaxSet, ref min, ref max, position, radius);

                        SgtProceduralMesh.PushPosition(position, 4);

                        SgtProceduralMesh.PushColor(star.Color, 4);

                        SgtProceduralMesh.PushNormal(-1.0f, 1.0f, angle);
                        SgtProceduralMesh.PushNormal(1.0f, 1.0f, angle);
                        SgtProceduralMesh.PushNormal(-1.0f, -1.0f, angle);
                        SgtProceduralMesh.PushNormal(1.0f, -1.0f, angle);

                        SgtProceduralMesh.PushTangent(star.PulseOffset, star.PulseSpeed, star.PulseRange, 0.0f, 4);

                        SgtProceduralMesh.PushCoord1(uv.x, uv.y);
                        SgtProceduralMesh.PushCoord1(uv.z, uv.y);
                        SgtProceduralMesh.PushCoord1(uv.x, uv.w);
                        SgtProceduralMesh.PushCoord1(uv.z, uv.w);

                        SgtProceduralMesh.PushCoord2(radius, 0.5f);
                        SgtProceduralMesh.PushCoord2(radius, -0.5f);
                        SgtProceduralMesh.PushCoord2(radius, 0.5f);
                        SgtProceduralMesh.PushCoord2(radius, -0.5f);
                    }

                    var bounds = SgtHelper.NewBoundsFromMinMax(min, max);

                    SgtProceduralMesh.SplitQuads(HideFlags.DontSave);

                    var meshCount = SgtProceduralMesh.Count;

                    // Copy meshes
                    for (var j = 0; j < meshCount; j++)
                    {
                        var mesh  = SgtProceduralMesh.Pop();
                        var model = group.Models.Count > j ? group.Models[j] : SgtStarfieldModel.Create(group);

                        mesh.bounds = bounds;

                        model.Mesh = mesh;
                    }
                }
            }
        }
    }
    private void RegenerateMeshes()
    {
        var asteroids = default(List <SgtBeltAsteroid>);
        var pool      = default(bool);

        CalculateAsteroids(out asteroids, out pool);

        if (asteroids != null)
        {
            // Sort asteroids into groups
            for (var i = asteroids.Count - 1; i >= 0; i--)
            {
                var asteroid = asteroids[i];

                if (asteroid != null)
                {
                    var group = GetGroup(asteroid.MainTex, asteroid.HeightTex);

                    group.Asteroids.Add(asteroid);
                }
            }

            // Pool asteroids?
            if (pool == true)
            {
                SgtClassPool <SgtBeltAsteroid> .Add(asteroids);
            }

            // Build groups
            for (var i = groups.Count - 1; i >= 0; i--)
            {
                var group          = groups[i];
                var groupAsteroids = group.Asteroids;
                var maxWidth       = 0.0f;
                var maxHeight      = 0.0f;

                SgtProceduralMesh.Clear();

                for (var j = groupAsteroids.Count - 1; j >= 0; j--)
                {
                    var asteroid = groupAsteroids[j];
                    var radius   = asteroid.Radius;
                    var distance = asteroid.OrbitDistance;
                    var height   = asteroid.Height;
                    var uv       = SgtHelper.CalculateSpriteUV(asteroid.MainTex);

                    maxWidth  = Mathf.Max(maxWidth, distance + radius);
                    maxHeight = Mathf.Max(maxHeight, height + radius);

                    SgtProceduralMesh.PushPosition(asteroid.OrbitAngle, distance, asteroid.OrbitSpeed, 4);

                    SgtProceduralMesh.PushColor(asteroid.Color, 4);

                    SgtProceduralMesh.PushNormal(-1.0f, 1.0f, 0.0f);
                    SgtProceduralMesh.PushNormal(1.0f, 1.0f, 0.0f);
                    SgtProceduralMesh.PushNormal(-1.0f, -1.0f, 0.0f);
                    SgtProceduralMesh.PushNormal(1.0f, -1.0f, 0.0f);

                    SgtProceduralMesh.PushTangent(asteroid.Angle / Mathf.PI, asteroid.Spin / Mathf.PI, 0.0f, 0.0f, 4);

                    SgtProceduralMesh.PushCoord1(uv.x, uv.y);
                    SgtProceduralMesh.PushCoord1(uv.z, uv.y);
                    SgtProceduralMesh.PushCoord1(uv.x, uv.w);
                    SgtProceduralMesh.PushCoord1(uv.z, uv.w);

                    SgtProceduralMesh.PushCoord2(radius, height, 4);
                }

                var bounds = new Bounds(Vector3.zero, new Vector3(maxWidth * 2.0f, maxHeight * 2.0f, maxWidth * 2.0f));

                SgtProceduralMesh.SplitQuads(HideFlags.DontSave);

                var meshCount = SgtProceduralMesh.Count;

                // Copy meshes
                for (var j = 0; j < meshCount; j++)
                {
                    var mesh  = SgtProceduralMesh.Pop();
                    var model = group.Models.Count > j ? group.Models[j] : SgtBeltModel.Create(group);

                    mesh.bounds = bounds;

                    model.Mesh = mesh;
                }
            }
        }
    }