public MyPlanetEnvironmentMapping(PlanetEnvironmentItemMapping map)
{
Rule = map.Rule;
Items = new MyMaterialEnvironmentItem[map.Items.Length];
if (Items.Length <= 0)
{
CumulativeIntervals = null;
TotalFrequency = 0;
return;
}
TotalFrequency = 0;
for (int i = 0; i < map.Items.Length; i++)
{
var item = map.Items[i];
MyObjectBuilderType type;
if (item.TypeId != null && MyObjectBuilderType.TryParse(item.TypeId, out type))
{
if (!typeof(MyObjectBuilder_BotDefinition).IsAssignableFrom((Type)type) && !typeof(MyObjectBuilder_VoxelMapStorageDefinition).IsAssignableFrom((Type)type) && !typeof(MyObjectBuilder_EnvironmentItems).IsAssignableFrom((Type)type))
{
MyLog.Default.WriteLine(String.Format("Object builder type {0} is not supported for environment items.", item.TypeId));
Items[i].Frequency = 0; // This should disable this item
}
else
{
Items[i] = new MyMaterialEnvironmentItem()
{
Definition = new MyDefinitionId(type, item.SubtypeId),
Frequency = map.Items[i].Density,
IsDetail = map.Items[i].IsDetail,
IsBot = typeof(MyObjectBuilder_BotDefinition).IsAssignableFrom((Type)type),
IsVoxel = typeof(MyObjectBuilder_VoxelMapStorageDefinition).IsAssignableFrom((Type)type),
IsEnvironemntItem = typeof(MyObjectBuilder_EnvironmentItems).IsAssignableFrom((Type)type),
BaseColor = map.Items[i].BaseColor,
ColorSpread = map.Items[i].ColorSpread,
MaxRoll = (float)Math.Cos(MathHelper.ToDegrees(map.Items[i].MaxRoll)),
Offset = map.Items[i].Offset,
GroupId = map.Items[i].GroupId,
GroupIndex = map.Items[i].GroupIndex,
ModifierId = map.Items[i].ModifierId,
ModifierIndex = map.Items[i].ModifierIndex
};
}
}
else
{
MyLog.Default.WriteLine(String.Format("Object builder type {0} does not exist.", item.TypeId));
Items[i].Frequency = 0; // This should disable this item
}
}
ComputeDistribution();
}
public MyPlanetEnvironmentMapping(PlanetEnvironmentItemMapping map)
{
this.Rule = map.Rule;
this.Items = new MyMaterialEnvironmentItem[map.Items.Length];
if (this.Items.Length == 0)
{
this.CumulativeIntervals = null;
this.TotalFrequency = 0f;
}
else
{
this.TotalFrequency = 0f;
for (int i = 0; i < map.Items.Length; i++)
{
MyObjectBuilderType type;
MyPlanetEnvironmentItemDef def = map.Items[i];
if ((def.TypeId == null) || !MyObjectBuilderType.TryParse(def.TypeId, out type))
{
MyLog.Default.WriteLine($"Object builder type {def.TypeId} does not exist.");
this.Items[i].Frequency = 0f;
}
else if ((!typeof(MyObjectBuilder_BotDefinition).IsAssignableFrom((Type)type) && !typeof(MyObjectBuilder_VoxelMapStorageDefinition).IsAssignableFrom((Type)type)) && !typeof(MyObjectBuilder_EnvironmentItems).IsAssignableFrom((Type)type))
{
MyLog.Default.WriteLine($"Object builder type {def.TypeId} is not supported for environment items.");
this.Items[i].Frequency = 0f;
}
else
{
MyMaterialEnvironmentItem item1 = new MyMaterialEnvironmentItem();
item1.Definition = new MyDefinitionId(type, def.SubtypeId);
item1.Frequency = map.Items[i].Density;
item1.IsDetail = map.Items[i].IsDetail;
item1.IsBot = typeof(MyObjectBuilder_BotDefinition).IsAssignableFrom((Type)type);
item1.IsVoxel = typeof(MyObjectBuilder_VoxelMapStorageDefinition).IsAssignableFrom((Type)type);
item1.IsEnvironemntItem = typeof(MyObjectBuilder_EnvironmentItems).IsAssignableFrom((Type)type);
item1.BaseColor = map.Items[i].BaseColor;
item1.ColorSpread = map.Items[i].ColorSpread;
item1.MaxRoll = (float)Math.Cos((double)MathHelper.ToDegrees(map.Items[i].MaxRoll));
item1.Offset = map.Items[i].Offset;
item1.GroupId = map.Items[i].GroupId;
item1.GroupIndex = map.Items[i].GroupIndex;
item1.ModifierId = map.Items[i].ModifierId;
item1.ModifierIndex = map.Items[i].ModifierIndex;
this.Items[i] = item1;
}
}
this.ComputeDistribution();
}
}
protected override void Init(MyObjectBuilder_DefinitionBase builder)
{
base.Init(builder);
var ob = builder as MyObjectBuilder_PlanetGeneratorDefinition;
if (ob.InheritFrom != null && ob.InheritFrom.Length > 0)
{
InheritFrom(ob.InheritFrom);
}
if (ob.PlanetMaps.HasValue)
{
PlanetMaps = ob.PlanetMaps.Value;
}
if (ob.HasAtmosphere.HasValue)
{
HasAtmosphere = ob.HasAtmosphere.Value;
}
if (ob.CloudLayers != null)
{
CloudLayers = ob.CloudLayers;
}
if (ob.SoundRules != null)
{
SoundRules = new MyPlanetEnvironmentalSoundRule[ob.SoundRules.Length];
for (int ruleIndex = 0; ruleIndex < ob.SoundRules.Length; ++ruleIndex)
{
MyPlanetEnvironmentalSoundRule sr;
sr = new MyPlanetEnvironmentalSoundRule()
{
Latitude = ob.SoundRules[ruleIndex].Latitude,
Height = ob.SoundRules[ruleIndex].Height,
SunAngleFromZenith = ob.SoundRules[ruleIndex].SunAngleFromZenith,
EnvironmentSound = MyStringHash.GetOrCompute(ob.SoundRules[ruleIndex].EnvironmentSound)
};
sr.Latitude.ConvertToSine();
sr.SunAngleFromZenith.ConvertToCosine();
SoundRules[ruleIndex] = sr;
}
}
if (ob.MusicCategories != null)
{
MusicCategories = ob.MusicCategories;
}
if (ob.HillParams.HasValue)
{
HillParams = ob.HillParams.Value;
}
if (ob.Atmosphere != null)
{
Atmosphere = ob.Atmosphere;
}
if (ob.GravityFalloffPower.HasValue)
{
GravityFalloffPower = ob.GravityFalloffPower.Value;
}
if (ob.HostileAtmosphereColorShift != null)
{
HostileAtmosphereColorShift = ob.HostileAtmosphereColorShift;
}
if (ob.MaterialsMaxDepth.HasValue)
{
MaterialsMaxDepth = ob.MaterialsMaxDepth.Value;
}
if (ob.MaterialsMinDepth.HasValue)
{
MaterialsMinDepth = ob.MaterialsMinDepth.Value;
}
if (ob.CustomMaterialTable != null && ob.CustomMaterialTable.Length > 0)
{
SurfaceMaterialTable = new MyPlanetMaterialDefinition[ob.CustomMaterialTable.Length];
for (int i = 0; i < SurfaceMaterialTable.Length; i++)
{
SurfaceMaterialTable[i] = ob.CustomMaterialTable[i].Clone() as MyPlanetMaterialDefinition;
if (SurfaceMaterialTable[i].Material == null && !SurfaceMaterialTable[i].HasLayers)
{
MyLog.Default.WriteLine("Custom material does not contain any material ids.");
}
else if (SurfaceMaterialTable[i].HasLayers)
{
// Make the depth cumulative so we don't have to calculate it later.
// If we want we can even binary search it.
float depth = SurfaceMaterialTable[i].Layers[0].Depth;
for (int j = 1; j < SurfaceMaterialTable[i].Layers.Length; j++)
{
SurfaceMaterialTable[i].Layers[j].Depth += depth;
depth = SurfaceMaterialTable[i].Layers[j].Depth;
}
}
}
}
if (ob.DistortionTable != null && ob.DistortionTable.Length > 0)
{
DistortionTable = ob.DistortionTable;
}
if (ob.DefaultSurfaceMaterial != null)
{
DefaultSurfaceMaterial = ob.DefaultSurfaceMaterial;
}
if (ob.DefaultSubSurfaceMaterial != null)
{
DefaultSubSurfaceMaterial = ob.DefaultSubSurfaceMaterial;
}
if (ob.SurfaceGravity.HasValue)
{
SurfaceGravity = ob.SurfaceGravity.Value;
}
if (ob.AtmosphereSettings != null)
{
AtmosphereSettings = ob.AtmosphereSettings;
}
// Folder name is not inherited to avoid weirdness.
FolderName = ob.FolderName != null ? ob.FolderName : ob.Id.SubtypeName;
if (ob.ComplexMaterials != null && ob.ComplexMaterials.Length > 0)
{
MaterialGroups = new MyPlanetMaterialGroup[ob.ComplexMaterials.Length];
for (int k = 0; k < ob.ComplexMaterials.Length; k++)
{
MaterialGroups[k] = ob.ComplexMaterials[k].Clone() as MyPlanetMaterialGroup;
var group = MaterialGroups[k];
var matRules = group.MaterialRules;
List <int> badMaterials = new List <int>();
for (int i = 0; i < matRules.Length; i++)
{
if (matRules[i].Material == null && (matRules[i].Layers == null || matRules[i].Layers.Length == 0))
{
MyLog.Default.WriteLine("Material rule does not contain any material ids.");
badMaterials.Add(i);
continue;
}
else if (matRules[i].Layers != null && matRules[i].Layers.Length != 0)
{
// Make the depth cumulative so we don't have to calculate it later.
// If we want we can even binary search it.
float depth = matRules[i].Layers[0].Depth;
for (int j = 1; j < matRules[i].Layers.Length; j++)
{
matRules[i].Layers[j].Depth += depth;
depth = matRules[i].Layers[j].Depth;
}
}
// We use the cosine later so we precompute it here.
matRules[i].Slope.ConvertToCosine();
matRules[i].Latitude.ConvertToSine();
matRules[i].Longitude.ConvertToCosineLongitude();
}
if (badMaterials.Count > 0)
{
matRules = matRules.RemoveIndices(badMaterials);
}
group.MaterialRules = matRules;
}
}
if (ob.EnvironmentItems != null && ob.EnvironmentItems.Length > 0)
{
MaterialEnvironmentMappings = new Dictionary <int, Dictionary <string, List <MyPlanetEnvironmentMapping> > >();
for (int i = 0; i < ob.EnvironmentItems.Length; i++)
{
PlanetEnvironmentItemMapping map = ob.EnvironmentItems[i];
if (map.Rule != null)
{
map.Rule = map.Rule.Clone() as MyPlanetSurfaceRule;
}
else
{
map.Rule = new MyPlanetSurfaceRule();
}
map.Rule.Slope.ConvertToCosine();
map.Rule.Latitude.ConvertToSine();
map.Rule.Longitude.ConvertToCosineLongitude();
// If the mapping does not assign a material it is ignored
if (map.Materials == null)
{
break;
}
if (map.Biomes == null)
{
map.Biomes = m_arrayOfZero;
}
foreach (var biome in map.Biomes)
{
Dictionary <string, List <MyPlanetEnvironmentMapping> > matmap;
if (MaterialEnvironmentMappings.ContainsKey(biome))
{
matmap = MaterialEnvironmentMappings[biome];
}
else
{
matmap = new Dictionary <string, List <MyPlanetEnvironmentMapping> >();
MaterialEnvironmentMappings.Add(biome, matmap);
}
foreach (var material in map.Materials)
{
if (!matmap.ContainsKey(material))
{
matmap.Add(material, new List <MyPlanetEnvironmentMapping>());
}
matmap[material].Add(new MyPlanetEnvironmentMapping(map));
}
}
}
}
if (ob.OreMappings != null)
{
OreMappings = ob.OreMappings;
}
if (ob.MaterialBlending.HasValue)
{
MaterialBlending = ob.MaterialBlending.Value;
}
if (ob.SurfaceDetail != null)
{
Detail = ob.SurfaceDetail;
}
if (ob.AnimalSpawnInfo != null)
{
AnimalSpawnInfo = ob.AnimalSpawnInfo;
}
if (ob.NightAnimalSpawnInfo != null)
{
NightAnimalSpawnInfo = ob.NightAnimalSpawnInfo;
}
if (ob.SectorDensity.HasValue)
{
SectorDensity = ob.SectorDensity.Value;
}
}
