private void Init(float size, float radius, float detail)
{
if (material == null)
{
material = SgtHelper.CreateTempMaterial(SgtHelper.ShaderNamePrefix + "Lightning");
}
if (meshFilter == null)
{
meshFilter = gameObject.AddComponent <MeshFilter>();
}
if (meshRenderer == null)
{
meshRenderer = gameObject.AddComponent <MeshRenderer>();
}
SgtProceduralMesh.Clear();
{
mesh = SgtObjectPool <Mesh> .Add(mesh);
AddVertices(size, radius, detail);
AddIndices();
mesh = SgtProceduralMesh.SplitSingle(HideFlags.DontSave);
mesh.RecalculateBounds();
meshFilter.sharedMesh = mesh;
meshRenderer.sharedMaterial = material;
}
SgtProceduralMesh.Discard();
}
private void AddIndices(int innerOffset, int innerSides, int outerOffset, int outerSides)
{
var stepInner = 1.0f / innerSides;
var stepOuter = 1.0f / outerSides;
var indexInner = 0;
var indexOuter = 0;
var progress = 0.0f;
var remainingInner = innerSides;
var remainingOuter = outerSides;
if (remainingInner == 1)
{
remainingInner = 0;
}
while (remainingInner > 0 || remainingOuter > 0)
{
var targetInner = (indexInner + 1) * stepInner;
var targetOuter = (indexOuter + 1) * stepOuter;
var remainderInner = targetInner - progress;
var remainderOuter = targetOuter - progress;
if (remainderInner <= remainderOuter && remainingInner > 0)
{
SgtProceduralMesh.PushIndex(innerOffset + indexInner % innerSides);
SgtProceduralMesh.PushIndex(outerOffset + indexOuter % outerSides);
SgtProceduralMesh.PushIndex(innerOffset + (indexInner + 1) % innerSides);
progress = targetInner;
remainingInner -= 1;
indexInner += 1;
}
if (remainderInner >= remainderOuter && remainingOuter > 0)
{
SgtProceduralMesh.PushIndex(outerOffset + (indexOuter + 1) % outerSides);
SgtProceduralMesh.PushIndex(innerOffset + indexInner % innerSides);
SgtProceduralMesh.PushIndex(outerOffset + indexOuter % outerSides);
progress = targetOuter;
remainingOuter -= 1;
indexOuter += 1;
}
}
}
protected virtual void RegenerateMesh()
{
mesh = SgtObjectPool <Mesh> .Add(mesh, m => m.Clear());
SgtProceduralMesh.Clear();
{
if (SegmentDetail >= 3)
{
var angleTotal = SgtHelper.Divide(Mathf.PI * 2.0f, SegmentCount);
var angleStep = SgtHelper.Divide(angleTotal, SegmentDetail);
var coordStep = SgtHelper.Reciprocal(SegmentDetail);
for (var i = 0; i <= SegmentDetail; i++)
{
var coord = coordStep * i;
var angle = angleStep * i;
var sin = Mathf.Sin(angle);
var cos = Mathf.Cos(angle);
SgtProceduralMesh.PushPosition(sin * InnerRadius, 0.0f, cos * InnerRadius);
SgtProceduralMesh.PushPosition(sin * OuterRadius, 0.0f, cos * OuterRadius);
SgtProceduralMesh.PushNormal(Vector3.up);
SgtProceduralMesh.PushNormal(Vector3.up);
SgtProceduralMesh.PushCoord1(0.0f, coord);
SgtProceduralMesh.PushCoord1(1.0f, coord);
}
}
}
SgtProceduralMesh.SplitStrip(HideFlags.DontSave);
mesh = SgtProceduralMesh.Pop(); SgtProceduralMesh.Discard();
if (mesh != null)
{
var bounds = mesh.bounds;
mesh.bounds = SgtHelper.NewBoundsCenter(bounds, bounds.center + bounds.center.normalized * BoundsShift);
}
}
protected override void RegenerateMesh()
{
mesh = SgtObjectPool <Mesh> .Add(mesh, m => m.Clear());
SgtProceduralMesh.Clear();
{
if (SegmentDetail >= 3)
{
var angleTotal = SgtHelper.Divide(Mathf.PI * 2.0f, SegmentCount);
var angleStep = SgtHelper.Divide(angleTotal, SegmentDetail);
var coordStep = SgtHelper.Reciprocal(SegmentDetail);
for (var i = 0; i <= SegmentDetail; i++)
{
var coord = coordStep * i;
var angle = angleStep * i;
var sin = Mathf.Sin(angle);
var cos = Mathf.Cos(angle);
var iPos = new Vector3(sin * InnerRadius, 0.0f, cos * InnerRadius);
var oPos = new Vector3(sin * OuterRadius, 0.0f, cos * OuterRadius);
SgtProceduralMesh.PushPosition(iPos);
SgtProceduralMesh.PushPosition(oPos);
SgtProceduralMesh.PushNormal(Vector3.up);
SgtProceduralMesh.PushNormal(Vector3.up);
SgtProceduralMesh.PushCoord1(0.0f, coord * InnerRadius);
SgtProceduralMesh.PushCoord1(1.0f, coord * OuterRadius);
SgtProceduralMesh.PushCoord2(InnerRadius, 0.0f);
SgtProceduralMesh.PushCoord2(OuterRadius, 0.0f);
}
}
}
SgtProceduralMesh.SplitStrip(HideFlags.DontSave);
mesh = SgtProceduralMesh.Pop(); SgtProceduralMesh.Discard();
}
private void AddRing(float size, float sizeMax, float radius, float resolution)
{
var sides = (int)(Mathf.Sin(size) * resolution);
if (SgtProceduralMesh.PositionCount + sides < 65000)
{
var extents = (size / sizeMax) * 0.5f;
if (sides < 5)
{
if (size > 0.0f)
{
sides = 5;
}
else
{
sides = 1;
}
}
var angleStep = SgtHelper.Reciprocal(sides) * Mathf.PI * 2.0f;
for (var i = 0; i < sides; i++)
{
var angle = i * angleStep;
var x = radius * Mathf.Sin(angle) * Mathf.Sin(size);
var y = radius * Mathf.Cos(angle) * Mathf.Sin(size);
var z = radius * Mathf.Cos(size);
var u = 0.5f + Mathf.Sin(angle) * extents;
var v = 0.5f + Mathf.Cos(angle) * extents;
SgtProceduralMesh.PushPosition(x, y, z);
SgtProceduralMesh.PushCoord1(u, v);
}
ringSides.Add(sides);
}
}
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;
}
}
}
}
