public MyVoxelMaterialDefinition GetMaterialForPosition(ref Vector3 pos, float lodSize, out byte biomeValue, bool preciseOrePositions)
{
MaterialSampleParams @params;
biomeValue = 0;
this.GetPositionParams(ref pos, lodSize, out @params, false);
MyVoxelMaterialDefinition material = null;
float num = !preciseOrePositions ? ((@params.SurfaceDepth / Math.Max((float)(lodSize * 0.5f), (float)1f)) + 0.5f) : (@params.SurfaceDepth + 0.5f);
if (this.m_oreMap != null)
{
List <PlanetOre> list;
byte key = this.m_oreMap.Faces[@params.Face].GetValue(@params.Texcoord.X, @params.Texcoord.Y);
if (this.m_ores.TryGetValue(key, out list))
{
using (List <PlanetOre> .Enumerator enumerator = list.GetEnumerator())
{
while (true)
{
if (!enumerator.MoveNext())
{
break;
}
PlanetOre current = enumerator.Current;
if ((current.Start <= -num) && ((current.Start + current.Depth) >= -num))
{
return(current.Material);
}
}
}
}
}
PlanetMaterial layeredMaterialForPosition = this.GetLayeredMaterialForPosition(ref @params, out biomeValue);
float num2 = @params.SurfaceDepth / lodSize;
if (!layeredMaterialForPosition.HasLayers)
{
if (num2 >= -layeredMaterialForPosition.Depth)
{
material = layeredMaterialForPosition.Material;
}
}
else
{
VoxelMaterial[] layers = layeredMaterialForPosition.Layers;
for (int i = 0; i < layers.Length; i++)
{
if (num2 >= -layers[i].Depth)
{
material = layeredMaterialForPosition.Layers[i].Material;
break;
}
}
}
if (material == null)
{
material = this.m_subsurfaceMaterial.FirstOrDefault;
}
return(material);
}
public void Close()
{
if (m_providerForRules == this)
{
m_providerForRules = null;
}
// Clear to speed up collection
m_blendingTileset = null;
m_subsurfaceMaterial = null;
m_generator = null;
m_biomeMap = null;
m_biomes = null;
m_materials = null;
m_planetShape = null;
m_ores = null;
m_materialMap = null;
m_oreMap = null;
m_biomeMap = null;
m_occlusionMap = null;
Closed = true;
}
public PlanetMaterial GetLayeredMaterialForPosition(ref MaterialSampleParams ps, out byte biomeValue)
{
if (ps.DistanceToCenter < 0.01)
{
biomeValue = 0xff;
return(this.m_defaultMaterial);
}
byte key = 0;
PlanetMaterial defaultMaterial = null;
byte num2 = 0;
if (this.m_biomeMap != null)
{
num2 = this.m_biomeMap.Faces[ps.Face].GetValue(ps.Texcoord.X, ps.Texcoord.Y);
}
if (this.m_biomePixelSize < ps.LodSize)
{
if (this.m_materialMap != null)
{
key = this.m_materialMap.Faces[ps.Face].GetValue(ps.Texcoord.X, ps.Texcoord.Y);
}
}
else if (this.m_materialMap != null)
{
key = this.ComputeMapBlend(ps.Texcoord, ps.Face, ref m_materialBC, this.m_materialMap.Faces[ps.Face]);
}
this.m_materials.TryGetValue(key, out defaultMaterial);
if ((defaultMaterial == null) && (this.m_biomes != null))
{
List <PlanetMaterialRule> list = m_rangeBiomes[key];
if ((list != null) && (list.Count != 0))
{
float height = (ps.SampledHeight - this.m_planetShape.MinHillHeight) * this.m_invHeightRange;
foreach (PlanetMaterialRule rule in list)
{
if (rule.Check(height, ps.Latitude, ps.Longitude, ps.Normal.Z))
{
defaultMaterial = rule;
break;
}
}
}
}
if (defaultMaterial == null)
{
defaultMaterial = this.m_defaultMaterial;
}
biomeValue = num2;
return(defaultMaterial);
}
public void Close()
{
this.m_blendingTileset = null;
this.m_subsurfaceMaterial = null;
this.m_generator = null;
this.m_biomeMap = null;
this.m_biomes = null;
this.m_materials = null;
this.m_planetShape = null;
this.m_ores = null;
this.m_materialMap = null;
this.m_oreMap = null;
this.m_biomeMap = null;
this.Maps = null;
this.Closed = true;
}
public MyPlanetMaterialProvider(MyPlanetGeneratorDefinition generatorDef, MyPlanetShapeProvider planetShape, MyCubemap[] maps)
{
this.m_materials = new Dictionary <byte, PlanetMaterial>(generatorDef.SurfaceMaterialTable.Length);
for (int i = 0; i < generatorDef.SurfaceMaterialTable.Length; i++)
{
byte num2 = generatorDef.SurfaceMaterialTable[i].Value;
this.m_materials[num2] = new PlanetMaterial(generatorDef.SurfaceMaterialTable[i], generatorDef.MinimumSurfaceLayerDepth);
}
this.m_defaultMaterial = new PlanetMaterial(generatorDef.DefaultSurfaceMaterial, generatorDef.MinimumSurfaceLayerDepth);
this.m_subsurfaceMaterial = (generatorDef.DefaultSubSurfaceMaterial == null) ? this.m_defaultMaterial : new PlanetMaterial(generatorDef.DefaultSubSurfaceMaterial, generatorDef.MinimumSurfaceLayerDepth);
this.m_planetShape = planetShape;
this.Maps = maps;
this.m_materialMap = maps[0];
this.m_biomeMap = maps[1];
this.m_oreMap = maps[2];
if (this.m_materialMap != null)
{
this.m_mapResolutionMinusOne = this.m_materialMap.Resolution - 1;
}
this.m_generator = generatorDef;
this.m_invHeightRange = 1f / (this.m_planetShape.MaxHillHeight - this.m_planetShape.MinHillHeight);
this.m_biomePixelSize = ((float)((planetShape.MaxHillHeight + planetShape.Radius) * 3.1415926535897931)) / ((this.m_mapResolutionMinusOne + 1) * 2f);
this.m_hashCode = generatorDef.FolderName.GetHashCode();
if ((this.m_generator.MaterialGroups != null) && (this.m_generator.MaterialGroups.Length != 0))
{
this.m_biomes = new Dictionary <byte, PlanetBiome>();
foreach (MyPlanetMaterialGroup group in this.m_generator.MaterialGroups)
{
this.m_biomes[group.Value] = new PlanetBiome(group, this.m_generator.MinimumSurfaceLayerDepth);
}
}
if (MyHeightMapLoadingSystem.Static != null)
{
this.m_blendingTileset = MyHeightMapLoadingSystem.Static.GetTerrainBlendTexture(this.m_generator.MaterialBlending);
}
this.m_ores = new Dictionary <byte, List <PlanetOre> >();
foreach (MyPlanetOreMapping mapping in this.m_generator.OreMappings)
{
MyVoxelMaterialDefinition material = GetMaterial(mapping.Type);
if (material != null)
{
PlanetOre item = new PlanetOre {
Depth = mapping.Depth,
Start = mapping.Start,
Value = mapping.Value,
Material = material,
ColorInfluence = mapping.ColorInfluence
};
if (mapping.ColorShift != null)
{
item.TargetColor = new Vector3?(mapping.ColorShift.Value.ColorToHSV());
}
if (!this.m_ores.ContainsKey(mapping.Value))
{
List <PlanetOre> list1 = new List <PlanetOre>();
list1.Add(item);
List <PlanetOre> list = list1;
this.m_ores.Add(mapping.Value, list);
}
this.m_ores[mapping.Value].Add(item);
}
}
this.Closed = false;
}
public void GetMaterialForPositionDebug(ref Vector3 pos, out MyPlanetStorageProvider.SurfacePropertiesExtended props)
{
MaterialSampleParams @params;
this.GetPositionParams(ref pos, 1f, out @params, true);
props.Position = pos;
props.Gravity = [email protected];
props.Material = this.m_defaultMaterial.FirstOrDefault;
props.Slope = @params.Normal.Z;
props.HeightRatio = this.m_planetShape.AltitudeToRatio(@params.SampledHeight);
props.Depth = @params.SurfaceDepth;
props.Latitude = @params.Latitude;
props.Longitude = @params.Longitude;
props.Altitude = @params.DistanceToCenter - this.m_planetShape.Radius;
props.GroundHeight = @params.SampledHeight + this.m_planetShape.Radius;
props.Face = @params.Face;
props.Texcoord = @params.Texcoord;
props.BiomeValue = 0;
props.MaterialValue = 0;
props.OreValue = 0;
props.EffectiveRule = null;
props.Biome = null;
props.Ore = new PlanetOre();
props.Origin = MyPlanetStorageProvider.SurfacePropertiesExtended.MaterialOrigin.Default;
PlanetMaterial defaultMaterial = null;
if (this.m_oreMap != null)
{
List <PlanetOre> list;
props.OreValue = this.m_oreMap.Faces[@params.Face].GetValue(@params.Texcoord.X, @params.Texcoord.Y);
if (this.m_ores.TryGetValue(props.OreValue, out list))
{
foreach (PlanetOre ore in list)
{
props.Ore = ore;
if ((ore.Start <= [email protected]) && ((ore.Start + ore.Depth) >= [email protected]))
{
props.Material = ore.Material;
props.Origin = MyPlanetStorageProvider.SurfacePropertiesExtended.MaterialOrigin.Ore;
break;
}
}
}
}
if (@params.DistanceToCenter >= 0.01)
{
byte key = 0;
if (this.m_biomePixelSize < @params.LodSize)
{
if (this.m_materialMap != null)
{
key = this.m_materialMap.Faces[@params.Face].GetValue(@params.Texcoord.X, @params.Texcoord.Y);
}
}
else if (this.m_materialMap != null)
{
key = this.ComputeMapBlend(@params.Texcoord, @params.Face, ref m_materialBC, this.m_materialMap.Faces[@params.Face]);
}
this.m_materials.TryGetValue(key, out defaultMaterial);
props.Origin = MyPlanetStorageProvider.SurfacePropertiesExtended.MaterialOrigin.Map;
props.MaterialValue = key;
if ((defaultMaterial == null) && (this.m_biomes != null))
{
PlanetBiome biome;
this.m_biomes.TryGetValue(key, out biome);
props.Biome = biome;
if ((biome != null) && biome.IsValid)
{
foreach (PlanetMaterialRule rule in biome.Rules)
{
if (rule.Check(props.HeightRatio, @params.Latitude, @params.Longitude, @params.Normal.Z))
{
defaultMaterial = rule;
props.Origin = MyPlanetStorageProvider.SurfacePropertiesExtended.MaterialOrigin.Rule;
break;
}
}
}
}
if (defaultMaterial == null)
{
defaultMaterial = this.m_defaultMaterial;
props.Origin = MyPlanetStorageProvider.SurfacePropertiesExtended.MaterialOrigin.Default;
}
byte num2 = 0;
if (this.m_biomeMap != null)
{
num2 = this.m_biomeMap.Faces[@params.Face].GetValue(@params.Texcoord.X, @params.Texcoord.Y);
}
props.BiomeValue = num2;
float num3 = @params.SurfaceDepth + 0.5f;
if (!defaultMaterial.HasLayers)
{
if (num3 >= -defaultMaterial.Depth)
{
props.Material = defaultMaterial.Material;
}
}
else
{
VoxelMaterial[] layers = defaultMaterial.Layers;
for (int i = 0; i < layers.Length; i++)
{
if (num3 >= -layers[i].Depth)
{
props.Material = defaultMaterial.Layers[i].Material;
break;
}
}
}
props.EffectiveRule = defaultMaterial;
}
}
public MyPlanetMaterialProvider(MyPlanetGeneratorDefinition generatorDef, MyPlanetShapeProvider planetShape)
{
m_materials = new Dictionary <byte, PlanetMaterial>(generatorDef.SurfaceMaterialTable.Length);
for (int i = 0; i < generatorDef.SurfaceMaterialTable.Length; ++i)
{
byte materialValue = (byte)generatorDef.SurfaceMaterialTable[i].Value;
m_materials[materialValue] = new PlanetMaterial(generatorDef.SurfaceMaterialTable[i]);
}
m_defaultMaterial = new PlanetMaterial(generatorDef.DefaultSurfaceMaterial);
if (generatorDef.DefaultSubSurfaceMaterial != null)
{
m_subsurfaceMaterial = new PlanetMaterial(generatorDef.DefaultSubSurfaceMaterial);
}
else
{
m_subsurfaceMaterial = m_defaultMaterial;
}
m_planetShape = planetShape;
MyCubemap[] maps;
MyHeightMapLoadingSystem.Static.GetPlanetMaps(generatorDef.FolderName, generatorDef.Context, generatorDef.PlanetMaps, out maps);
m_materialMap = maps[0];
m_biomeMap = maps[1];
m_oreMap = maps[2];
m_occlusionMap = maps[3];
if (m_biomeMap != null)
{
m_mapResolutionMinusOne = m_biomeMap.Resolution - 1;
}
m_generator = generatorDef;
m_invHeightRange = 1 / (m_planetShape.MaxHillHeight - m_planetShape.MinHillHeight);
m_biomePixelSize = (float)((planetShape.MaxHillHeight + planetShape.Radius) * Math.PI) / ((float)(m_mapResolutionMinusOne + 1) * 2);
m_hashCode = generatorDef.FolderName.GetHashCode();
// Material groups
if (m_generator.MaterialGroups != null && m_generator.MaterialGroups.Length > 0)
{
m_biomes = new Dictionary <byte, PlanetBiome>();
foreach (var group in m_generator.MaterialGroups)
{
m_biomes.Add(group.Value, new PlanetBiome(group));
}
}
m_blendingTileset = MyHeightMapLoadingSystem.Static.GetTerrainBlendTexture(m_generator.MaterialBlending);
m_ores = new Dictionary <byte, PlanetOre>();
foreach (var mapping in m_generator.OreMappings)
{
var mat = GetMaterial(mapping.Type);
if (mat != null)
{
if (m_ores.ContainsKey(mapping.Value))
{
string message = String.Format("Value {0} is already mapped to another ore.", mapping.Value);
Debug.Fail(message);
MyLog.Default.WriteLine(message);
}
else
{
m_ores[mapping.Value] = new PlanetOre()
{
Depth = mapping.Depth,
Start = mapping.Start,
Value = mapping.Value,
Material = mat
};
}
}
}
Closed = false;
}
public PlanetMaterial GetLayeredMaterialForPosition(ref MaterialSampleParams ps, out byte spawnsItems, ref byte occlusion)
{
if (ps.DistanceToCenter < 0.01)
{
spawnsItems = 255;
occlusion = 0;
return(m_defaultMaterial);
}
Byte roundedMaterial = 0;
PlanetMaterial voxelMaterial = null;
byte spawns = 0;
bool computeOcclusion = m_occlusionMap != null && ps.SurfaceDepth > -(ps.LodSize * 2) && occlusion != 0;
if (m_biomeMap != null)
{
spawns = m_biomeMap.Faces[ps.Face].GetValue(ps.Texcoord.X, ps.Texcoord.Y);
}
if (m_biomePixelSize < ps.LodSize)
{
if (m_materialMap != null)
{
roundedMaterial = m_materialMap.Faces[ps.Face].GetValue(ps.Texcoord.X, ps.Texcoord.Y);
}
if (computeOcclusion)
{
occlusion = m_occlusionMap.Faces[ps.Face].GetValue(ps.Texcoord.X, ps.Texcoord.Y);
}
else
{
occlusion = 0;
}
}
else
{
if (m_biomeMap != null)
{
roundedMaterial = ComputeMapBlend(ps.Texcoord, ps.Face, ref m_materialBC,
m_materialMap.Faces[ps.Face]);
}
if (computeOcclusion)
{
occlusion = ComputeMapBlend(ps.Texcoord, ps.Face, ref m_occlusionBC,
m_occlusionMap.Faces[ps.Face]);
}
else
{
occlusion = 0;
}
}
m_materials.TryGetValue(roundedMaterial, out voxelMaterial);
if (MyFakes.ENABLE_DEFINITION_ENVIRONMENTS && voxelMaterial == null && m_biomes != null)
{
var rules = m_rangeBiomes[roundedMaterial];
if (rules != null && rules.Count != 0)
{
float height = (ps.SampledHeight - m_planetShape.MinHillHeight) * m_invHeightRange;
foreach (var rule in rules)
{
if (rule.Check(height, ps.Latitude, ps.Longitude, ps.Normal.Z))
{
voxelMaterial = rule;
break;
}
}
}
}
if (voxelMaterial == null)
{
voxelMaterial = m_defaultMaterial;
}
spawnsItems = spawns;
return(voxelMaterial);
}
public MyVoxelMaterialDefinition GetMaterialForPosition(ref Vector3 pos, float lodSize, out byte biomeValue, ref byte occlusion)
{
biomeValue = 0;
MaterialSampleParams ps;
GetPositionParams(ref pos, lodSize, out ps);
MyVoxelMaterialDefinition def = null;
float oreDepth = ps.SurfaceDepth / Math.Max(lodSize * .5f, 1f) + .5f; // Hack to preserve position for ore detector.
// Ore depositis from map come first.
if (m_oreMap != null)
{
byte ore = m_oreMap.Faces[ps.Face].GetValue(ps.Texcoord.X, ps.Texcoord.Y);
PlanetOre om;
if (m_ores.TryGetValue(ore, out om))
{
if (om.Start <= -oreDepth && om.Start + om.Depth >= -oreDepth)
{
occlusion = 0;
return(om.Material);
}
}
}
PlanetMaterial voxelMaterial = GetLayeredMaterialForPosition(ref ps, out biomeValue, ref occlusion);
// Extend depth to compensate for lod rounding
float voxelDepth = ps.SurfaceDepth / lodSize;
// Check layers
if (voxelMaterial.HasLayers)
{
var layers = voxelMaterial.Layers;
for (int i = 0; i < layers.Length; i++)
{
if (voxelDepth >= -layers[i].Depth)
{
def = voxelMaterial.Layers[i].Material;
break;
}
}
}
// Check single layered
else
{
if (voxelDepth >= -voxelMaterial.Depth)
{
def = voxelMaterial.Material;
}
}
if (def == null)
{
def = m_subsurfaceMaterial.FirstOrDefault;
}
return(def);
}
public unsafe void GetMaterialForPositionDebug(ref Vector3 pos, out MyPlanetStorageProvider.SurfacePropertiesExtended props)
{
byte spawns = 0;
MaterialSampleParams ps;
GetPositionParams(ref pos, 1.0f, out ps, true);
props.Position = pos;
props.Gravity = ps.Gravity;
props.Material = m_defaultMaterial.FirstOrDefault;
props.Slope = ps.Normal.Z;
props.HeightRatio = m_planetShape.AltitudeToRatio(ps.SampledHeight);
props.Depth = ps.SurfaceDepth;
props.Latitude = ps.Latitude;
props.Longitude = ps.Longitude;
props.Altitude = ps.DistanceToCenter - m_planetShape.Radius;
props.Face = ps.Face;
props.Texcoord = ps.Texcoord;
props.BiomeValue = 0;
props.MaterialValue = 0;
props.OcclusionValue = 0;
props.OreValue = 0;
props.EffectiveRule = null;
props.Biome = null;
props.Ore = new PlanetOre();
props.Origin = MyPlanetStorageProvider.SurfacePropertiesExtended.MaterialOrigin.Default;
PlanetMaterial voxelMaterial = null;
// Ore depositis from map come first.
if (m_oreMap != null)
{
props.OreValue = m_oreMap.Faces[ps.Face].GetValue(ps.Texcoord.X, ps.Texcoord.Y);
PlanetOre om;
if (m_ores.TryGetValue(props.OreValue, out om))
{
props.Ore = om;
if (om.Start <= -ps.SurfaceDepth && om.Start + om.Depth >= -ps.SurfaceDepth)
{
props.Material = om.Material;
props.Origin = MyPlanetStorageProvider.SurfacePropertiesExtended.MaterialOrigin.Ore;
}
}
}
if (ps.DistanceToCenter < 0.01)
{
return;
}
Byte roundedMaterial = 0;
if (m_biomePixelSize < ps.LodSize)
{
if (m_materialMap != null)
{
m_materialMap.Faces[ps.Face].GetValue((int)ps.Texcoord.X, (int)ps.Texcoord.Y, out roundedMaterial);
}
if (m_occlusionMap != null)
{
m_occlusionMap.Faces[ps.Face].GetValue((int)ps.Texcoord.X, (int)ps.Texcoord.Y, out props.OcclusionValue);
}
}
else
{
if (m_biomeMap != null)
{
roundedMaterial = ComputeMapBlend(ps.Texcoord, ps.Face, ref m_materialBC,
m_materialMap.Faces[ps.Face]);
}
if (m_occlusionMap != null)
{
props.OcclusionValue = ComputeMapBlend(ps.Texcoord, ps.Face, ref m_occlusionBC,
m_occlusionMap.Faces[ps.Face]);
}
}
m_materials.TryGetValue(roundedMaterial, out voxelMaterial);
props.Origin = MyPlanetStorageProvider.SurfacePropertiesExtended.MaterialOrigin.Map;
props.MaterialValue = roundedMaterial;
if (voxelMaterial == null && m_biomes != null)
{
PlanetBiome b;
m_biomes.TryGetValue(roundedMaterial, out b);
props.Biome = b;
// When the sample material is zero calculate the material using the definition rules;
if (MyFakes.ENABLE_DEFINITION_ENVIRONMENTS && b != null && b.IsValid)
{
foreach (var rule in b.Rules)
{
if (rule.Check(props.HeightRatio, ps.Latitude, ps.Longitude, ps.Normal.Z))
{
voxelMaterial = rule;
props.Origin = MyPlanetStorageProvider.SurfacePropertiesExtended.MaterialOrigin.Rule;
break;
}
}
}
}
if (voxelMaterial == null)
{
voxelMaterial = m_defaultMaterial;
props.Origin = MyPlanetStorageProvider.SurfacePropertiesExtended.MaterialOrigin.Default;
}
props.BiomeValue = spawns;
// calc depth with what we already have
float voxelDepth = ps.SurfaceDepth + .5f;
// Check layers
if (voxelMaterial.HasLayers)
{
var layers = voxelMaterial.Layers;
for (int i = 0; i < layers.Length; i++)
{
if (voxelDepth >= -layers[i].Depth)
{
props.Material = voxelMaterial.Layers[i].Material;
break;
}
}
}
// Check single layered
else
{
if (voxelDepth >= -voxelMaterial.Depth)
{
props.Material = voxelMaterial.Material;
}
}
props.EffectiveRule = voxelMaterial;
}
