private static Quaternion CreateRandomRotation(MyRandom self)
{
Quaternion q = new Quaternion(
self.NextFloat() * 2f - 1f,
self.NextFloat() * 2f - 1f,
self.NextFloat() * 2f - 1f,
self.NextFloat() * 2f - 1f);
q.Normalize();
return q;
}
private static Vector3 CreateRandomPointOnBox(MyRandom self, float boxSize)
{
Vector3 result = Vector3.Zero;
switch (self.Next() & 6)
{// each side of a box
case 0: return new Vector3(0f, self.NextFloat(), self.NextFloat());
case 1: return new Vector3(1f, self.NextFloat(), self.NextFloat());
case 2: return new Vector3(self.NextFloat(), 0f, self.NextFloat());
case 3: return new Vector3(self.NextFloat(), 1f, self.NextFloat());
case 4: return new Vector3(self.NextFloat(), self.NextFloat(), 0f);
case 5: return new Vector3(self.NextFloat(), self.NextFloat(), 1f);
}
result *= boxSize;
return result;
}
private static Vector3 CreateRandomPointInBox(MyRandom self, float boxSize)
{
return new Vector3(
self.NextFloat() * boxSize,
self.NextFloat() * boxSize,
self.NextFloat() * boxSize);
}
private static MyMaterialLayer[] CreateMaterialLayers(MyPlanetDefinition planetDefinition, bool isHostile, MyRandom random, float averagePlanetRadius, float hillHalfDeviation, float canyonHalfDeviation, ref float outerRadius, ref float innerRadius)
{
int numLayers = random.Next((int)planetDefinition.NumLayers.Min, (int)planetDefinition.NumLayers.Max);
float startHeight = averagePlanetRadius - canyonHalfDeviation;
outerRadius = averagePlanetRadius + hillHalfDeviation;
innerRadius = averagePlanetRadius - canyonHalfDeviation;
int layerOffset = 0;
MyMaterialLayer southPoleLayer = CreatePoleLayer(random, planetDefinition.SouthPole, startHeight, outerRadius, ref layerOffset);
MyMaterialLayer northPoleLayer = CreatePoleLayer(random, planetDefinition.NorthPole, startHeight, outerRadius, ref layerOffset);
MyMaterialLayer[] materialLayers = new MyMaterialLayer[numLayers + layerOffset];
float endAngle = 1;
float startAngle = -1;
int currentLayer = 0;
if (southPoleLayer != null)
{
materialLayers[currentLayer] = southPoleLayer;
endAngle = southPoleLayer.StartAngle;
currentLayer++;
}
if (northPoleLayer != null)
{
materialLayers[currentLayer] = northPoleLayer;
northPoleLayer.EndAngle = northPoleLayer.StartAngle;
northPoleLayer.StartAngle = -1.0f;
northPoleLayer.AngleEndDeviation = northPoleLayer.AngleStartDeviation;
northPoleLayer.AngleStartDeviation = 0.0f;
startAngle = northPoleLayer.EndAngle;
}
float step = (outerRadius - innerRadius) / materialLayers.Length;
float organicHeightEnd = random.NextFloat(planetDefinition.OrganicHeightEnd.Min, planetDefinition.OrganicHeightEnd.Max);
float metalsHeightEnd = random.NextFloat(planetDefinition.MetalsHeightEndHostile.Min, planetDefinition.MetalsHeightEndHostile.Max);
float floraMaterialSpawnProbability = random.NextFloat(planetDefinition.FloraMaterialSpawnProbability.Min, planetDefinition.FloraMaterialSpawnProbability.Max);
float metalsSpawnProbability = random.NextFloat(planetDefinition.MetalsSpawnProbability.Min, planetDefinition.MetalsSpawnProbability.Max);
float metalsSpawnValue = random.NextFloat(0, 1);
for (int i = layerOffset; i < materialLayers.Length; ++i)
{
float layerHeight = random.NextFloat(0, step);
materialLayers[i] = new MyMaterialLayer();
materialLayers[i].StartHeight = startHeight;
materialLayers[i].EndHeight = startHeight + layerHeight;
materialLayers[i].StartAngle = startAngle;
materialLayers[i].EndAngle = endAngle;
materialLayers[i].HeightStartDeviation = random.NextFloat(0, 100.0f / (float)(i + 1));
materialLayers[i].AngleStartDeviation = 0;
materialLayers[i].HeightEndDeviation = random.NextFloat(0, 100.0f / (float)(i + 1));
materialLayers[i].AngleEndDeviation = 0;
MyVoxelMaterialDefinition materialDefinition = null;
if (m_materialsByOreType.ContainsKey("Stone") == true)
{
materialDefinition = m_materialsByOreType["Stone"][random.Next() % m_materialsByOreType["Stone"].Count];
}
if (planetDefinition.HasAtmosphere && isHostile == false)
{
if ((outerRadius - startHeight) > ((outerRadius - innerRadius) * (1 - organicHeightEnd)))
{
float value = random.NextFloat(0, 1);
if (value > floraMaterialSpawnProbability)
{
materialDefinition = m_organicMaterials[random.Next() % m_organicMaterials.Count];
}
else
{
materialDefinition = m_spawningMaterials[random.Next() % m_spawningMaterials.Count];
}
}
}
else
{
if (metalsSpawnValue < metalsSpawnProbability)
{
if ((outerRadius - startHeight) > ((outerRadius - innerRadius) * (1 - metalsHeightEnd)))
{
MyOreProbability probablity = GetOre(random.NextFloat(0, 1));
if (probablity != null)
{
materialLayers[i].EndHeight = materialLayers[i].StartHeight - 1;
materialLayers[i].HeightStartDeviation *= probablity.Probability;
materialLayers[i].HeightEndDeviation *= probablity.Probability;
materialDefinition = m_materialsByOreType[probablity.OreName][random.Next() % m_materialsByOreType[probablity.OreName].Count];
}
}
}
}
materialLayers[i].MaterialDefinition = materialDefinition;
startHeight += layerHeight;
}
return materialLayers;
}
private static MyMaterialLayer CreatePoleLayer(MyRandom random, MyPoleParams poleParams, float startHeight, float outerRadius, ref int layerOffset)
{
if (m_materialsByOreType.ContainsKey("Ice") == false)
{
return null;
}
MyMaterialLayer poleLayer = null;
float poleProbability = random.NextFloat(0, 1);
if (poleParams != null && poleProbability < poleParams.Probability)
{
layerOffset++;
poleLayer = new MyMaterialLayer();
poleLayer.StartHeight = startHeight;
poleLayer.EndHeight = outerRadius;
poleLayer.MaterialDefinition = m_materialsByOreType["Ice"][random.Next() % m_materialsByOreType["Ice"].Count];
poleLayer.HeightEndDeviation = 0;
poleLayer.HeightStartDeviation = 0;
poleLayer.StartAngle = random.NextFloat(poleParams.Angle.Min, poleParams.Angle.Max);
poleLayer.EndAngle = 1.0f;
poleLayer.AngleStartDeviation = random.NextFloat(poleParams.AngleDeviation.Min, poleParams.AngleDeviation.Max);
}
return poleLayer;
}
private static MyCsgShapePlanetHillAttributes FillValues(MyStructureParams input, MyRandom random)
{
MyCsgShapePlanetHillAttributes outputValues = new MyCsgShapePlanetHillAttributes();
outputValues.BlendTreshold = random.NextFloat(input.BlendSize.Min, input.BlendSize.Max);
outputValues.Treshold = random.NextFloat(input.Treshold.Min, input.Treshold.Max);
outputValues.Frequency = random.NextFloat(input.Frequency.Min, input.Frequency.Max);
outputValues.SizeRatio = random.NextFloat(input.SizeRatio.Min, input.SizeRatio.Max);
outputValues.NumNoises = random.Next((int)input.NumNoises.Min, (int)input.NumNoises.Max);
return outputValues;
}
