Esempio n. 1
0
    private void EndRegeneration()
    {
        for (var i = groups.Count - 1; i >= 0; i--)
        {
            var group = groups[i];

            if (group.Asteroids.Count > 0)
            {
                group.Asteroids.Clear();                 // No longer needed, and they've already been pooled in RegenerateMeshes()

                for (var j = group.Models.Count - 1; j >= 0; j--)
                {
                    var model = group.Models[j];

                    if (model.Mesh == null)
                    {
                        SgtBeltModel.Pool(model);

                        group.Models.RemoveAt(j);
                    }
                }
            }
            else
            {
                SgtBeltGroup.Pool(group);

                groups.RemoveAt(i);
            }
        }
    }
    public static void MarkForDestruction(SgtBeltModel model)
    {
        if (model != null)
        {
            model.Group = null;

            model.gameObject.SetActive(true);
        }
    }
    protected virtual void OnDestroy()
    {
        for (var i = Models.Count - 1; i >= 0; i--)
        {
            SgtBeltModel.MarkForDestruction(Models[i]);
        }

        Models.Clear();
    }
    public static void MarkForDestruction(SgtBeltModel model)
    {
        if (model != null)
        {
            model.Group = null;

            model.gameObject.SetActive(true);
        }
    }
    public static void Pool(SgtBeltModel model)
    {
        if (model != null)
        {
            model.Group = null;

            model.PoolMeshNow();

            SgtComponentPool <SgtBeltModel> .Add(model);
        }
    }
    public static void Pool(SgtBeltModel model)
    {
        if (model != null)
        {
            model.Group = null;

            model.PoolMeshNow();

            SgtComponentPool<SgtBeltModel>.Add(model);
        }
    }
    public static void Pool(SgtBeltGroup group)
    {
        if (group != null)
        {
            group.Belt      = null;
            group.MainTex   = null;
            group.HeightTex = null;
            group.Material  = null;

            for (var i = group.Models.Count - 1; i >= 0; i--)
            {
                SgtBeltModel.Pool(group.Models[i]);
            }

            group.Models.Clear();

            SgtComponentPool <SgtBeltGroup> .Add(group);
        }
    }
Esempio n. 8
0
    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;
                }
            }
        }
    }