public int AddStar(SGT_StarfieldStarData ssd)
{
var starsPerMesh = SGT_Helper.MeshVertexLimit / 4;
int rem; System.Math.DivRem(starfieldStarCount, starsPerMesh, out rem);
// Add new mesh
if (rem == 0)
{
}
// Add to mesh
else
{
var meshIndex = meshes.Length - 1;
var mesh = meshes[meshIndex];
var meshData = GetMeshData(mesh, meshIndex);
var v0 = meshData.Positions.Length;
meshData.AddPositions(new Vector3[4]);
meshData.AddNormals(new Vector3[4]);
meshData.AddColours(new Color[4]);
meshData.AddUv0s(new Vector2[4]);
meshData.AddUv1s(new Vector2[4]);
meshData.AddIndices(new int[6] {
v0, v0 + 1, v0 + 2, v0 + 3, v0 + 2, v0 + 1
});
meshData.Apply();
}
starfieldStarCount += 1;
return(starfieldStarCount - 1);
}
public SGT_StarfieldStarData ReadStar(int starIndex)
{
SGT_MeshData meshData;
int vertexIndex;
if (FindStar(starIndex, out meshData, out vertexIndex) == true)
{
var ssd = new SGT_StarfieldStarData();
var position = meshData.Positions[vertexIndex];
var uv0 = (meshData.Uv0s[vertexIndex] + meshData.Uv0s[vertexIndex + 3]) * 0.5f;
var uv1 = meshData.Uv1s[vertexIndex];
var colour = meshData.Colours[vertexIndex];
var normal = meshData.Normals[vertexIndex] + meshData.Normals[vertexIndex + 1];
ssd.Transform = starfieldGameObject.transform;
ssd.Position = position;
ssd.TextureIndex = packer.FindOutputIndex(uv0);
ssd.Angle = -Mathf.Atan2(normal.x, normal.y);
ssd.RadiusMin = uv1.x - uv1.y;
ssd.RadiusMax = uv1.x + uv1.y;
ssd.RadiusPulseRate = colour.r;
ssd.RadiusPulseOffset = colour.g;
return(ssd);
}
return(null);
}
public SGT_StarfieldStarData ReadStar(int starIndex)
{
SGT_MeshData meshData;
int vertexIndex;
if (FindStar(starIndex, out meshData, out vertexIndex) == true)
{
var ssd = new SGT_StarfieldStarData();
var position = meshData.Positions[vertexIndex];
var uv0 = (meshData.Uv0s[vertexIndex] + meshData.Uv0s[vertexIndex + 3]) * 0.5f;
var uv1 = meshData.Uv1s[vertexIndex];
var colour = meshData.Colours[vertexIndex];
var normal = meshData.Normals[vertexIndex] + meshData.Normals[vertexIndex + 1];
ssd.Transform = starfieldGameObject.transform;
ssd.Position = position;
ssd.TextureIndex = packer.FindOutputIndex(uv0);
ssd.Angle = -Mathf.Atan2(normal.x, normal.y);
ssd.RadiusMin = uv1.x - uv1.y;
ssd.RadiusMax = uv1.x + uv1.y;
ssd.RadiusPulseRate = colour.r;
ssd.RadiusPulseOffset = colour.g;
return ssd;
}
return null;
}
public int AddStar(SGT_StarfieldStarData ssd)
{
var starsPerMesh = SGT_Helper.MeshVertexLimit / 4;
int rem; System.Math.DivRem(starfieldStarCount, starsPerMesh, out rem);
// Add new mesh
if (rem == 0)
{
}
// Add to mesh
else
{
var meshIndex = meshes.Length - 1;
var mesh = meshes[meshIndex];
var meshData = GetMeshData(mesh, meshIndex);
var v0 = meshData.Positions.Length;
meshData.AddPositions(new Vector3[4]);
meshData.AddNormals(new Vector3[4]);
meshData.AddColours(new Color[4]);
meshData.AddUv0s(new Vector2[4]);
meshData.AddUv1s(new Vector2[4]);
meshData.AddIndices(new int[6] { v0, v0 + 1, v0 + 2, v0 + 3, v0 + 2, v0 + 1 });
meshData.Apply();
}
starfieldStarCount += 1;
return starfieldStarCount - 1;
}
private SGT_StarfieldStarData GenerateStar()
{
var starData = new SGT_StarfieldStarData();
var starVariant = GetStarVariant(weights.RandomIndex);
if (starVariant.Custom == true)
{
var baseRadius = Random.Range(starVariant.CustomRadiusMin, starVariant.CustomRadiusMax);
starData.RadiusMin = Mathf.Max(baseRadius - starVariant.CustomPulseRadiusMax, starVariant.CustomRadiusMin);
starData.RadiusMax = Mathf.Min(baseRadius + starVariant.CustomPulseRadiusMax, starVariant.CustomRadiusMax);
}
else
{
var baseRadius = Random.Range(starRadiusMin, starRadiusMax);
starData.RadiusMin = Mathf.Max(baseRadius - starPulseRadiusMax, starRadiusMin);
starData.RadiusMax = Mathf.Min(baseRadius + starPulseRadiusMax, starRadiusMax);
}
starData.Variant = starVariant;
starData.Position = GenerateStarPosition();
starData.RadiusPulseRate = Random.Range(0.0f, 1.0f);
starData.RadiusPulseOffset = Random.Range(0.0f, 1.0f);
starData.Angle = Random.Range(-Mathf.PI, Mathf.PI);
return(starData);
}
private SGT_StarfieldStarData GenerateStar()
{
var starData = new SGT_StarfieldStarData();
var starVariant = GetStarVariant(weights.RandomIndex);
if (starVariant.Custom == true)
{
var baseRadius = Random.Range(starVariant.CustomRadiusMin, starVariant.CustomRadiusMax);
starData.RadiusMin = Mathf.Max(baseRadius - starVariant.CustomPulseRadiusMax, starVariant.CustomRadiusMin);
starData.RadiusMax = Mathf.Min(baseRadius + starVariant.CustomPulseRadiusMax, starVariant.CustomRadiusMax);
}
else
{
var baseRadius = Random.Range(starRadiusMin, starRadiusMax);
starData.RadiusMin = Mathf.Max(baseRadius - starPulseRadiusMax, starRadiusMin);
starData.RadiusMax = Mathf.Min(baseRadius + starPulseRadiusMax, starRadiusMax);
}
starData.Variant = starVariant;
starData.Position = GenerateStarPosition();
starData.RadiusPulseRate = Random.Range(0.0f, 1.0f);
starData.RadiusPulseOffset = Random.Range(0.0f, 1.0f);
starData.Angle = Random.Range(-Mathf.PI, Mathf.PI);
return starData;
}
public override void OnInspector()
{
SGT_EditorGUI.Separator();
SGT_EditorGUI.BeginGroup("Starfield");
{
Target.StarfieldStarCount = SGT_EditorGUI.IntField("Star Count", "Amount of stars to generate in the starfield.", Target.StarfieldStarCount);
Target.StarfieldSeed = SGT_EditorGUI.SeedField("Seed", "The random seed to use when generating the starfield.", Target.StarfieldSeed);
Target.StarfieldRenderQueue = SGT_EditorGUI.IntField("Render Queue", "The render queue used by the starfield mesh.", Target.StarfieldRenderQueue);
Target.StarfieldObserver = SGT_EditorGUI.ObjectField("Observer", "The camera rendering this.", Target.StarfieldObserver, true);
Target.StarfieldInBackground = SGT_EditorGUI.BoolField("In Background", "Push stars into background?", Target.StarfieldInBackground);
Target.StarfieldAutoRegen = SGT_EditorGUI.BoolField("Auto Regen", null, Target.StarfieldAutoRegen);
if (Target.StarfieldAutoRegen == false)
{
SGT_EditorGUI.BeginFrozen(Target.Modified == true);
{
if (SGT_EditorGUI.Button("Regenerate") == true)
{
Target.Regenerate();
}
}
SGT_EditorGUI.EndFrozen();
}
}
SGT_EditorGUI.EndGroup();
SGT_EditorGUI.Separator();
SGT_EditorGUI.MarkNextFieldAsBold();
Target.Distribution = (SGT_StarfieldDistribution)SGT_EditorGUI.EnumField("Distribution", "The star placement distribution.", Target.Distribution);
SGT_EditorGUI.BeginIndent();
{
Target.DistributionRadius = SGT_EditorGUI.FloatField("Radius", "The size of the starfield across each axis.", Target.DistributionRadius);
switch (Target.Distribution)
{
case SGT_StarfieldDistribution.InSphere:
{
Target.DistributionOuter = SGT_EditorGUI.FloatField("Outer", "The minimum radius for stars in the starfield.", Target.DistributionOuter, 0.0f, 1.0f);
}
goto case SGT_StarfieldDistribution.OnSphere;
case SGT_StarfieldDistribution.EllipticalGalaxy:
{
}
goto case SGT_StarfieldDistribution.OnSphere;
case SGT_StarfieldDistribution.OnSphere:
{
Target.DistributionSymmetry = SGT_EditorGUI.FloatField("Symmetry", "A lower symmetry value will place more stars near the horizon/equator of the skysphere than at the poles.", Target.DistributionSymmetry, 0.0f, 1.0f);
}
break;
}
}
SGT_EditorGUI.EndIndent();
SGT_EditorGUI.Separator();
SGT_EditorGUI.BeginGroup("Packer");
{
for (var i = 0; i < Target.Packer.InputCount; i++)
{
var input = Target.Packer.GetInput(i);
SGT_EditorGUI.BeginIndent(true, 1);
{
input.Texture = SGT_EditorGUI.ObjectField("Texture", null, input.Texture);
SGT_EditorGUI.MarkNextFieldAsBold(input.Tilesheet == true);
input.Tilesheet = SGT_EditorGUI.BoolField("Tilesheet", "Is this texture a tilesheet?", input.Tilesheet);
if (input.Tilesheet == true)
{
SGT_EditorGUI.BeginIndent();
{
input.TilesheetTilesX = SGT_EditorGUI.IntField("Tiles X", "The amount of tiles in this texture on the x axis.", input.TilesheetTilesX);
input.TilesheetTilesY = SGT_EditorGUI.IntField("Tiles Y", "The amount of tiles in this texture on the y axis.", input.TilesheetTilesY);
}
SGT_EditorGUI.EndIndent();
}
if (SGT_EditorGUI.Button("Remove") == true)
{
Target.Packer.RemoveInput(i);
}
}
SGT_EditorGUI.EndIndent();
SGT_EditorGUI.Separator();
}
SGT_EditorGUI.BeginIndent(true, 1);
{
SGT_EditorGUI.MarkNextFieldAsError(Target.Packer.InputCount == 0);
var newTexture = SGT_EditorGUI.ObjectField <Texture2D>("Add Texture", null, null);
if (newTexture != null)
{
var pi = new SGT_PackerInput();
pi.Texture = newTexture;
Target.Packer.AddInput(pi);
}
}
SGT_EditorGUI.EndIndent();
}
SGT_EditorGUI.EndGroup();
SGT_EditorGUI.Separator();
SGT_EditorGUI.BeginGroup("Star");
{
Target.StarRadiusMin = SGT_EditorGUI.FloatField("Radius Min", "The minimum radius of a star.", Target.StarRadiusMin);
Target.StarRadiusMax = SGT_EditorGUI.FloatField("Radius Max", "The maximum radius of a star.", Target.StarRadiusMax);
Target.StarPulseRadiusMax = SGT_EditorGUI.FloatField("Pulse Radius Max", "The maximum amount a star's radius can change while pulsing (note: the final radius will always fall between the Star Radius Min/Max).", Target.StarPulseRadiusMax);
Target.StarPulseRateMax = SGT_EditorGUI.FloatField("Pulse Rate Max", "The maximum rate (speed) at which the stars can pulse.", Target.StarPulseRateMax);
}
SGT_EditorGUI.EndGroup();
SGT_EditorGUI.Separator();
editVariant = SGT_EditorGUI.BeginToggleGroup("Edit Star Variant", null, editVariant);
{
SGT_EditorGUI.MarkNextFieldAsBold();
editVariantIndex = SGT_EditorGUI.IntField("Index", "The star variant currently being edited.", editVariantIndex, 0, Target.StarVariantCount - 1);
var sv = Target.GetStarVariant(editVariantIndex);
var po = Target.Packer.GetOutput(editVariantIndex);
if (sv != null && po != null)
{
SGT_EditorGUI.BeginIndent();
{
SGT_EditorGUI.DrawFieldTexture("Preview", null, po.OutputTexture, po.Uv);
sv.SpawnProbability = SGT_EditorGUI.FloatField("Spawn Probability", null, sv.SpawnProbability, 0.0f, 1.0f);
if (sv.Custom == true)
{
SGT_EditorGUI.MarkNextFieldAsBold();
}
var oldCustom = sv.Custom;
sv.Custom = SGT_EditorGUI.BoolField("Custom", null, sv.Custom);
if (sv.Custom == true)
{
if (oldCustom == false)
{
sv.CustomRadiusMin = Target.StarRadiusMin;
sv.CustomRadiusMax = Target.StarRadiusMax;
sv.CustomPulseRadiusMax = Target.StarPulseRadiusMax;
sv.CustomPulseRateMax = Target.StarPulseRateMax;
}
SGT_EditorGUI.BeginIndent();
{
sv.CustomRadiusMin = SGT_EditorGUI.FloatField("Radius Min", null, sv.CustomRadiusMin);
sv.CustomRadiusMax = SGT_EditorGUI.FloatField("Radius Max", null, sv.CustomRadiusMax);
sv.CustomPulseRadiusMax = SGT_EditorGUI.FloatField("Pulse Radius Max", null, sv.CustomPulseRadiusMax);
sv.CustomPulseRateMax = SGT_EditorGUI.FloatField("Pulse Rate Max", null, sv.CustomPulseRateMax);
}
SGT_EditorGUI.EndIndent();
}
}
SGT_EditorGUI.EndIndent();
}
}
SGT_EditorGUI.EndToggleGroup();
SGT_EditorGUI.Separator();
editStar = SGT_EditorGUI.BeginToggleGroup("Edit Star", null, editStar);
{
SGT_EditorGUI.MarkNextFieldAsBold();
editStarIndex = SGT_EditorGUI.IntField("Index", "The star currently being edited.", editStarIndex, 0, Target.StarfieldStarCount - 1);
ssd = Target.ReadStar(editStarIndex);
if (ssd != null)
{
SGT_EditorGUI.BeginIndent();
{
ssd.Position = SGT_EditorGUI.Vector3Field("Position", null, ssd.Position);
ssd.TextureIndex = SGT_EditorGUI.IntField("Texture Index", null, ssd.TextureIndex, 0, Target.Packer.OutputCount - 1);
ssd.Angle = SGT_EditorGUI.FloatField("Angle", null, ssd.Angle, -Mathf.PI, Mathf.PI);
SGT_EditorGUI.BeginGroup("Radius");
{
ssd.RadiusMin = SGT_EditorGUI.FloatField("Min", null, ssd.RadiusMin);
ssd.RadiusMax = SGT_EditorGUI.FloatField("Max", null, ssd.RadiusMax);
ssd.RadiusPulseRate = SGT_EditorGUI.FloatField("Pulse Rate", null, ssd.RadiusPulseRate, 0.0f, 1.0f);
}
SGT_EditorGUI.EndGroup();
SGT_EditorGUI.Separator();
if (SGT_EditorGUI.Button("Normalize Position") == true)
{
ssd.Position = ssd.Position.normalized * Target.DistributionRadius;
}
if (SGT_EditorGUI.Button("Clamp Radius") == true)
{
ssd.RadiusMin = Mathf.Clamp(ssd.RadiusMin, Target.StarRadiusMin, Target.StarRadiusMax);
ssd.RadiusMax = Mathf.Clamp(ssd.RadiusMax, Target.StarRadiusMin, Target.StarRadiusMax);
}
if (SGT_EditorGUI.Button("Duplicate") == true)
{
editStarIndex = Target.AddStar(ssd);
}
Target.WriteStar(ssd, editStarIndex);
Target.ApplyStarChanges();
}
SGT_EditorGUI.EndIndent();
}
else
{
SGT_EditorGUI.HelpBox("Failed to read star data.", MessageType.Error);
}
}
SGT_EditorGUI.EndToggleGroup();
SGT_EditorGUI.Separator();
}
public void WriteStar(SGT_StarfieldStarData ssd, int starIndex)
{
if (ssd != null)
{
var po = packer.GetOutput(ssd.TextureIndex);
if (po != null)
{
SGT_MeshData meshData;
int vertexIndex;
if (FindStar(starIndex, out meshData, out vertexIndex) == true)
{
var v0 = vertexIndex;
var v1 = v0 + 1;
var v2 = v1 + 1;
var v3 = v2 + 1;
var position = ssd.Position;
var uv1 = new Vector2((ssd.RadiusMin + ssd.RadiusMax) * 0.5f, (ssd.RadiusMax - ssd.RadiusMin) * 0.5f);
var colour = new Color(ssd.RadiusPulseRate, ssd.RadiusPulseOffset, 0.0f, 0.0f);
var right = SGT_Helper.Rotate(Vector2.right * SGT_Helper.InscribedBox, ssd.Angle);
var up = SGT_Helper.Rotate(Vector2.up * SGT_Helper.InscribedBox, ssd.Angle);
if (meshData.Positions[v0] != position)
{
meshData.Positions[v0] = position;
meshData.Positions[v1] = position;
meshData.Positions[v2] = position;
meshData.Positions[v3] = position;
meshData.Modified = true;
}
if (meshData.Normals[v0] != SGT_Helper.NewVector3(-right + up, 0.0f))
{
meshData.Normals[v0] = SGT_Helper.NewVector3(-right + up, 0.0f);
meshData.Normals[v1] = SGT_Helper.NewVector3(right + up, 0.0f);
meshData.Normals[v2] = SGT_Helper.NewVector3(-right - up, 0.0f);
meshData.Normals[v3] = SGT_Helper.NewVector3(right - up, 0.0f);
meshData.Modified = true;
}
if (meshData.Uv0s[v0] != po.UvTopLeft && meshData.Uv0s[v3] != po.UvBottomRight)
{
meshData.Uv0s[v0] = po.UvTopLeft;
meshData.Uv0s[v1] = po.UvTopRight;
meshData.Uv0s[v2] = po.UvBottomLeft;
meshData.Uv0s[v3] = po.UvBottomRight;
meshData.Modified = true;
}
if (meshData.Uv1s[v0] != uv1)
{
meshData.Uv1s[v0] = uv1;
meshData.Uv1s[v1] = uv1;
meshData.Uv1s[v2] = uv1;
meshData.Uv1s[v3] = uv1;
meshData.Modified = true;
}
if (meshData.Colours[v0] != colour)
{
meshData.Colours[v0] = colour;
meshData.Colours[v1] = colour;
meshData.Colours[v2] = colour;
meshData.Colours[v3] = colour;
meshData.Modified = true;
}
}
}
}
}
public void WriteStar(SGT_StarfieldStarData ssd, int starIndex)
{
if (ssd != null)
{
var po = packer.GetOutput(ssd.TextureIndex);
if (po != null)
{
SGT_MeshData meshData;
int vertexIndex;
if (FindStar(starIndex, out meshData, out vertexIndex) == true)
{
var v0 = vertexIndex;
var v1 = v0 + 1;
var v2 = v1 + 1;
var v3 = v2 + 1;
var position = ssd.Position;
var uv1 = new Vector2((ssd.RadiusMin + ssd.RadiusMax) * 0.5f, (ssd.RadiusMax - ssd.RadiusMin) * 0.5f);
var colour = new Color(ssd.RadiusPulseRate, ssd.RadiusPulseOffset, 0.0f, 0.0f);
var right = SGT_Helper.Rotate(Vector2.right * SGT_Helper.InscribedBox, ssd.Angle);
var up = SGT_Helper.Rotate(Vector2.up * SGT_Helper.InscribedBox, ssd.Angle);
if (meshData.Positions[v0] != position)
{
meshData.Positions[v0] = position;
meshData.Positions[v1] = position;
meshData.Positions[v2] = position;
meshData.Positions[v3] = position;
meshData.Modified = true;
}
if (meshData.Normals[v0] != SGT_Helper.NewVector3(-right + up, 0.0f))
{
meshData.Normals[v0] = SGT_Helper.NewVector3(-right + up, 0.0f);
meshData.Normals[v1] = SGT_Helper.NewVector3( right + up, 0.0f);
meshData.Normals[v2] = SGT_Helper.NewVector3(-right - up, 0.0f);
meshData.Normals[v3] = SGT_Helper.NewVector3( right - up, 0.0f);
meshData.Modified = true;
}
if (meshData.Uv0s[v0] != po.UvTopLeft && meshData.Uv0s[v3] != po.UvBottomRight)
{
meshData.Uv0s[v0] = po.UvTopLeft;
meshData.Uv0s[v1] = po.UvTopRight;
meshData.Uv0s[v2] = po.UvBottomLeft;
meshData.Uv0s[v3] = po.UvBottomRight;
meshData.Modified = true;
}
if (meshData.Uv1s[v0] != uv1)
{
meshData.Uv1s[v0] = uv1;
meshData.Uv1s[v1] = uv1;
meshData.Uv1s[v2] = uv1;
meshData.Uv1s[v3] = uv1;
meshData.Modified = true;
}
if (meshData.Colours[v0] != colour)
{
meshData.Colours[v0] = colour;
meshData.Colours[v1] = colour;
meshData.Colours[v2] = colour;
meshData.Colours[v3] = colour;
meshData.Modified = true;
}
}
}
}
}
