public static bool SetPlanetData(ref PlanetSimulator __instance, ref Transform ___lookCamera,
ref UniverseSimulator ___universe, ref StarSimulator ___star, PlanetData planet)
{
__instance.planetData = planet;
if (__instance.planetData.atmosMaterial != null)
{
__instance.atmoTrans0 = new GameObject("Atmosphere")
{
layer = 31
}.transform;
__instance.atmoTrans0.parent = __instance.transform;
__instance.atmoTrans0.localPosition = Vector3.zero;
if (planet.GetScaleFactored() >= 1)
{
__instance.atmoTrans0.localScale *= planet.GetScaleFactored();
}
else
{
__instance.atmoTrans0.localScale /= planet.GetScaleFactored();
}
var primitive = GameObject.CreatePrimitive(PrimitiveType.Quad);
primitive.layer = 31;
__instance.atmoTrans1 = primitive.transform;
__instance.atmoTrans1.parent = __instance.atmoTrans0;
__instance.atmoTrans1.localPosition = Vector3.zero;
Object.Destroy(primitive.GetComponent <Collider>());
var component = primitive.GetComponent <Renderer>();
var atmosMaterial = __instance.planetData.atmosMaterial;
component.sharedMaterial = atmosMaterial;
__instance.atmoMat = atmosMaterial;
component.shadowCastingMode = ShadowCastingMode.Off;
component.receiveShadows = false;
component.lightProbeUsage = LightProbeUsage.Off;
component.motionVectorGenerationMode = MotionVectorGenerationMode.ForceNoMotion;
__instance.atmoTrans1.localScale = Vector3.one * (planet.realRadius * 5f * planet.GetScaleFactored());
__instance.atmoMatRadiusParam = __instance.atmoMat.GetVector("_PlanetRadius");
}
___lookCamera = Camera.main.transform;
___universe = GameMain.universeSimulator;
___star = ___universe.FindStarSimulator(planet.star);
return(false);
}
public static void AddFactoredRadius(this PlanetRawData planetRawData, PlanetData planet)
{
FactoredRadius[planetRawData] = planet.GetScaleFactored();
}
public static PlanetData ReworkCreatePlanet(
ref GalaxyData galaxy,
ref StarData star,
ref GameDesc gameDesc,
int index,
int orbitAround,
int orbitIndex,
int number,
bool gasGiant,
int info_seed,
int gen_seed)
{
Patch.Debug("ReworkCreatePlanet", LogLevel.Debug,
Patch.DebugReworkPlanetGen);
var planetData = new PlanetData();
var mainSeed = new Random(info_seed);
//Base data of the planet :
planetData.index = index;
planetData.galaxy = star.galaxy;
planetData.star = star;
planetData.seed = gen_seed;
// Index of the thing it's orbiting around , 0 for star , anything else mean it's a moon
planetData.orbitAround = orbitAround;
// Current orbit Index around the planet
planetData.orbitIndex = orbitIndex;
// index of the planet in the system ?
planetData.number = number;
// Global Id of the entity
planetData.id = star.id * 100 + planetData.index + 1;
var stars = galaxy.stars;
Patch.Debug("Basic Information Setup", LogLevel.Debug,
Patch.DebugReworkPlanetGen);
var randomNumber1 = mainSeed.NextDouble();
var randomNumber2 = mainSeed.NextDouble();
var randomNumber3 = mainSeed.NextDouble();
var randomNumber4 = mainSeed.NextDouble();
var randomNumber5 = mainSeed.NextDouble();
var randomNumber6 = mainSeed.NextDouble();
var randomNumber7 = mainSeed.NextDouble();
var randomNumber8 = mainSeed.NextDouble();
var randomNumber9 = mainSeed.NextDouble();
var randomNumber10 = mainSeed.NextDouble();
var randomNumber11 = mainSeed.NextDouble();
var randomNumber12 = mainSeed.NextDouble();
var randomNumber13 = mainSeed.NextDouble();
var randomNumber14 = mainSeed.NextDouble();
// Orbit definition
Patch.Debug("Orbit definition", LogLevel.Debug,
Patch.DebugReworkPlanetGen);
var baselineOrbitVariation = Mathf.Pow(1.2f, (float)(randomNumber1 * (randomNumber2 - 0.5) * 0.5));
var orbitInclination =
UnityRandom.Range(0, Patch.MaxOrbitInclination.Value) * MathUtils.RangePlusMinusOne(mainSeed);
Patch.Debug("Rotation definition", LogLevel.Debug,
Patch.DebugReworkPlanetGen);
// rotation period
planetData.rotationPeriod = randomNumber8 * randomNumber9 * Patch.RotationPeriodVariabilityFactor.Value +
Patch.RotationPeriodBaseTime.Value;
// Planet
Patch.Debug("Body Stuff", LogLevel.Debug,
Patch.DebugReworkPlanetGen);
//orbit longitude
planetData.orbitLongitude = (float)(randomNumber4 * 360.0);
//runtimeOrbitRotation
planetData.runtimeOrbitRotation = Quaternion.AngleAxis(planetData.orbitLongitude, Vector3.up) *
Quaternion.AngleAxis(orbitInclination, Vector3.forward);
planetData.runtimeSystemRotation = planetData.runtimeOrbitRotation * Quaternion.AngleAxis(planetData.obliquity, Vector3.forward);
if (planetData.IsNotAMoon())
{
Patch.Debug("Planets Stuff", LogLevel.Debug,
Patch.DebugReworkPlanetGen);
//orbit
var baselineOrbitSize = Patch.OrbitRadiusPlanetArray[orbitIndex] * star.orbitScaler;
var orbitSize = (float)((baselineOrbitVariation - 1.0) / Mathf.Max(1f, baselineOrbitSize) + 1.0);
planetData.orbitRadius = baselineOrbitSize * orbitSize;
// orbit Inclination + periods
planetData.orbitInclination = orbitInclination;
planetData.orbitalPeriod = Math.Sqrt(pi2Rad * planetData.orbitRadius *
planetData.orbitRadius * planetData.orbitRadius /
(1.35385519905204E-06 * star.mass));
//rotation period
if (planetData.IsGasGiant() || planetData.star.type == EStarType.NeutronStar)
{
planetData.rotationPeriod *= 0.200000002980232;
}
else if (planetData.star.type == EStarType.BlackHole)
{
planetData.rotationPeriod *= 0.150000005960464;
}
planetData.sunDistance = planetData.orbitRadius;
// rotation period
planetData.rotationPeriod = 1.0 / (1.0 / planetData.orbitalPeriod * 2);
//Tidal Lock Management
if (randomNumber13 < Patch.ChanceTidalLock.Value)
{
if (randomNumber13 < Patch.ChanceTidalLock1.Value)
{
planetData.obliquity *= 0.01f;
planetData.rotationPeriod = planetData.orbitalPeriod;
planetData.IsTidallyLocked(TidalLevel.TidalLocked);
}
else if (randomNumber13 < Patch.ChanceTidalLock2.Value)
{
planetData.obliquity *= 0.1f;
planetData.rotationPeriod = planetData.orbitalPeriod * 0.5;
planetData.IsTidallyLocked(TidalLevel.TidalLocked2);
}
else
{
planetData.obliquity *= 0.2f;
planetData.rotationPeriod = planetData.orbitalPeriod * 0.25;
planetData.IsTidallyLocked(TidalLevel.TidalLocked4);
}
}
Patch.Debug("Planets Stuff Done", LogLevel.Debug,
Patch.DebugReworkPlanetGen);
}
// Moon
else
{
// the previous algo is using the number of the planet it's orbiting around, not the actual index --> so minus 1
orbitAround -= 1;
Patch.Debug("Moon Stuff", LogLevel.Debug,
Patch.DebugReworkPlanetGen);
//affect the data of the planet of the moon
Patch.Debug("orbitAround " + orbitAround, LogLevel.Debug, Patch.DebugReworkPlanetGen);
planetData.orbitAroundPlanet = star.planets[orbitAround];
Patch.Debug("orbitAround id : " + star.planets[orbitAround].index, LogLevel.Debug, Patch.DebugReworkPlanetGen);
var orbitRadiusScaled = Patch.OrbitRadiusArrayMoons[orbitIndex] * star.orbitScaler *
Mathf.Lerp(baselineOrbitVariation, 1f, 0.5f) *
planetData.orbitAroundPlanet.GetGasGiantOrbitScaler();
//orbit
planetData.orbitRadius = orbitRadiusScaled;
Patch.Debug("orbitRadius " + planetData.orbitRadius, LogLevel.Debug, Patch.DebugReworkPlanetGen);
// orbit Inclination + periods
planetData.orbitInclination = orbitInclination * Patch.MoonOrbitInclinationFactor.Value;
Patch.Debug("orbitInclination " + planetData.orbitInclination, LogLevel.Debug,
Patch.DebugReworkPlanetGen);
planetData.orbitalPeriod = Math.Sqrt(pi2Rad * planetData.orbitRadius *
planetData.orbitRadius * planetData.orbitRadius / 1.08308421068537E-08);
Patch.Debug("orbitalPeriod " + planetData.orbitalPeriod, LogLevel.Debug, Patch.DebugReworkPlanetGen);
planetData.rotationPeriod *= Mathf.Pow(planetData.orbitRadius, 0.25f);
Patch.Debug("rotationPeriod " + planetData.rotationPeriod, LogLevel.Debug, Patch.DebugReworkPlanetGen);
// distance = planet of the moon
planetData.sunDistance = planetData.orbitAroundPlanet.orbitRadius;
Patch.Debug("sunDistance " + planetData.sunDistance, LogLevel.Debug, Patch.DebugReworkPlanetGen);
// rotation period
planetData.rotationPeriod =
1.0 / (1.0 / planetData.orbitAroundPlanet.orbitalPeriod + 1.0 / planetData.rotationPeriod);
Patch.Debug("rotationPeriod - 2 " + planetData.rotationPeriod, LogLevel.Debug,
Patch.DebugReworkPlanetGen);
Patch.Debug("Tidal Lock " + planetData.rotationPeriod, LogLevel.Debug, Patch.DebugReworkPlanetGen);
//Tidal Lock Management
if (randomNumber13 < Patch.ChanceTidalLock.Value)
{
if (randomNumber13 < Patch.ChanceTidalLock1.Value)
{
planetData.obliquity *= 0.01f;
planetData.rotationPeriod = planetData.orbitAroundPlanet.orbitalPeriod;
planetData.IsTidallyLocked(TidalLevel.TidalLocked);
}
else if (randomNumber13 < Patch.ChanceTidalLock2.Value)
{
planetData.obliquity *= 0.1f;
planetData.rotationPeriod = planetData.orbitAroundPlanet.orbitalPeriod * 0.5;
planetData.IsTidallyLocked(TidalLevel.TidalLocked2);
}
else
{
planetData.obliquity *= 0.2f;
planetData.rotationPeriod = planetData.orbitAroundPlanet.orbitalPeriod * 0.25;
planetData.IsTidallyLocked(TidalLevel.TidalLocked4);
}
}
Patch.Debug("End Tidal Lock " + planetData.rotationPeriod, LogLevel.Debug, Patch.DebugReworkPlanetGen);
//runtimeOrbitRotation
planetData.runtimeOrbitRotation = planetData.orbitAroundPlanet.runtimeOrbitRotation *
planetData.runtimeOrbitRotation;
Patch.Debug("runtimeOrbitRotation " + planetData.runtimeOrbitRotation, LogLevel.Debug,
Patch.DebugReworkPlanetGen);
Patch.Debug("Moon Stuff Done", LogLevel.Debug,
Patch.DebugReworkPlanetGen);
}
Patch.Debug("Body orbit Phase", LogLevel.Debug,
Patch.DebugReworkPlanetGen);
// orbit phase
planetData.orbitPhase = (float)(randomNumber5 * 360.0);
Patch.Debug("Body Rotation Phase", LogLevel.Debug,
Patch.DebugReworkPlanetGen);
//rotation phase
planetData.rotationPhase = (float)(randomNumber10 * 360.0);
Patch.Debug("Body Orbit Obliquity", LogLevel.Debug,
Patch.DebugReworkPlanetGen);
// orbit obliquity
Patch.Debug("Body Obliquity Modification", LogLevel.Debug,
Patch.DebugReworkPlanetGen);
if (randomNumber13 < Patch.ChancePlanetLaySide.Value)
{
planetData.obliquity = (float)randomNumber6 * MathUtils.RangePlusMinusOne(mainSeed) *
Patch.LaySideBaseAngle.Value;
planetData.obliquity += Patch.LaySideAddingAngle.Value * MathUtils.RangePlusMinusOne(mainSeed);
planetData.HasLayingObliquity();
}
else if (randomNumber13 < Patch.ChanceBigObliquity.Value)
{
planetData.obliquity = (float)randomNumber6 * MathUtils.RangePlusMinusOne(mainSeed) *
Patch.BigObliquityBaseAngle.Value;
planetData.obliquity += Patch.BigObliquityAddingAngle.Value * MathUtils.RangePlusMinusOne(mainSeed);
}
else
{
planetData.obliquity = (float)randomNumber6 * MathUtils.RangePlusMinusOne(mainSeed) *
Patch.StandardObliquityAngle.Value;
}
Patch.Debug("Body runtimeSystemRotation", LogLevel.Debug,
Patch.DebugReworkPlanetGen);
//runtimeOrbitRotation obliquity adjustment
planetData.runtimeSystemRotation = planetData.runtimeOrbitRotation *
Quaternion.AngleAxis(planetData.obliquity, Vector3.forward);
Patch.Debug("Body Retrograde", LogLevel.Debug,
Patch.DebugReworkPlanetGen);
//Define if the orbit is retrograde
if (randomNumber14 < Patch.ChanceRetrogradeOrbit.Value)
{
planetData.HasRetrogradeOrbit();
}
Patch.Debug("Body Neutron Star", LogLevel.Debug,
Patch.DebugReworkPlanetGen);
// Anomaly around neutron stars
if (planetData.star.type == EStarType.NeutronStar)
{
planetData.OrbitAroundNeutronStar();
}
Patch.Debug("Body Type Definition", LogLevel.Debug,
Patch.DebugReworkPlanetGen);
// type of the planet :
if (gasGiant)
{
Patch.Debug("Body is Gas Giant", LogLevel.Debug,
Patch.DebugReworkPlanetGen);
planetData.type = EPlanetType.Gas;
planetData.habitableBias = 100f;
}
else
{
Patch.Debug("Body TypeDefinition ( planet / Moon )", LogLevel.Debug,
Patch.DebugReworkPlanetGen);
var sunDistance = planetData.sunDistance;
var ratioHabitableDistance = Patch.HabitabilityBaseConstant.Value;
Patch.Debug("Body Habitability", LogLevel.Debug,
Patch.DebugReworkPlanetGen);
if (star.habitableRadius > 0.0 && sunDistance > 0.0)
{
ratioHabitableDistance = sunDistance / star.habitableRadius;
}
Patch.Debug("Star Habitability radius ", LogLevel.Debug,
Patch.DebugReworkPlanetGen);
var minRadiusHabitable = star.habitableRadius - Patch.HabitableRadiusAreaBaseline.Value;
var maxRadiusHabitable = star.habitableRadius + Patch.HabitableRadiusAreaBaseline.Value;
if (planetData.sunDistance < maxRadiusHabitable && planetData.sunDistance > minRadiusHabitable)
{
planetData.habitableBias = Patch.ChanceBeingHabitable.Value;
}
Patch.Debug("Body Temperature ( planet / Moon )", LogLevel.Debug,
Patch.DebugReworkPlanetGen);
planetData.temperatureBias =
(float)(1.20000004768372 / (ratioHabitableDistance + 0.200000002980232) - 1.0);
if (randomNumber11 < planetData.habitableBias)
{
Patch.Debug("Body Type Ocean ( planet / Moon )", LogLevel.Debug,
Patch.DebugReworkPlanetGen);
planetData.type = EPlanetType.Ocean;
++star.galaxy.habitableCount;
}
else if (ratioHabitableDistance < Patch.VolcanoPlanetDistanceRatio.Value)
{
Patch.Debug("Body Type Volcano ( planet / Moon )", LogLevel.Debug,
Patch.DebugReworkPlanetGen);
planetData.type = EPlanetType.Vocano;
}
else if (ratioHabitableDistance > Patch.IcePlanetDistanceRatio.Value)
{
Patch.Debug("Body Type Ice ( planet / Moon )", LogLevel.Debug,
Patch.DebugReworkPlanetGen);
planetData.type = EPlanetType.Ice;
}
else
{
Patch.Debug("Body Type Desert ( planet / Moon )", LogLevel.Debug,
Patch.DebugReworkPlanetGen);
planetData.type = EPlanetType.Desert;
}
Patch.Debug("Body Type Defined ( planet / Moon )", LogLevel.Debug,
Patch.DebugReworkPlanetGen);
}
Patch.Debug("Body Luminosity( planet / Moon )", LogLevel.Debug,
Patch.DebugReworkPlanetGen);
//Luminosity
planetData.luminosity = Mathf.Pow(planetData.star.lightBalanceRadius / (planetData.sunDistance + 0.01f), 0.6f);
if (planetData.luminosity > 1.0)
{
planetData.luminosity = Mathf.Log(planetData.luminosity) + 1f;
planetData.luminosity = Mathf.Log(planetData.luminosity) + 1f;
planetData.luminosity = Mathf.Log(planetData.luminosity) + 1f;
}
planetData.luminosity = Mathf.Round(planetData.luminosity * 100f) / 100f;
Patch.Debug("Body Size Def ( planet / Moon )", LogLevel.Debug,
Patch.DebugReworkPlanetGen);
//Size related stuff :
if (planetData.type == EPlanetType.Gas)
{
var radiusGasGiantWanted = PatchSize.VanillaGasGiantSize;
if (PatchSize.EnableResizingFeature.Value)
{
//Default : 0.25
var minScalingGasGiantRatio =
(PatchSize.BaseGasGiantSize.Value - PatchSize.BaseGasGiantSizeVariationFactor.Value) /
(PatchSize.BaseGasGiantSize.Value + PatchSize.BaseGasGiantSizeVariationFactor.Value);
radiusGasGiantWanted = PatchSize.BaseGasGiantSize.Value +
MathUtils.RangePlusMinusOne(mainSeed) *
PatchSize.BaseGasGiantSizeVariationFactor.Value;
radiusGasGiantWanted -= radiusGasGiantWanted % 10;
}
planetData.scale = PatchSize.VanillaGasGiantScale;
planetData.radius = radiusGasGiantWanted / planetData.scale;
planetData.precision = 64;
planetData.segment = 2;
}
else if (planetData.type != EPlanetType.None)
{
if (PatchSize.EnableResizingFeature.Value)
{
var radiusTelluricWanted = PatchSize.VanillaTelluricSize;
if (planetData.IsNotAMoon())
{
radiusTelluricWanted = PatchSize.BaseTelluricSize.Value +
MathUtils.RangePlusMinusOne(mainSeed) *
PatchSize.BaseTelluricSizeVariationFactor.Value;
}
else
{
//A moon can only be smaller than it's host
if (planetData.orbitAroundPlanet.type != EPlanetType.Gas)
{
radiusTelluricWanted = planetData.orbitAroundPlanet.radius -
(float)mainSeed.NextDouble() *
PatchSize.BaseTelluricSizeVariationFactor.Value;
// clamp to avoid weird sizes
radiusTelluricWanted = Mathf.Clamp(radiusTelluricWanted,
PatchSize.MinTelluricSize.Value,
planetData.orbitAroundPlanet.radius);
}
else
{
radiusTelluricWanted = PatchSize.BaseTelluricSize.Value +
MathUtils.RangePlusMinusOne(mainSeed) *
PatchSize.BaseTelluricSizeVariationFactor.Value;
}
}
radiusTelluricWanted -= radiusTelluricWanted % 10;
planetData.radius = Mathf.RoundToInt(radiusTelluricWanted);
Patch.Debug(" planetData.radius" + planetData.radius, LogLevel.Debug,
Patch.DebugReworkPlanetGenDeep);
planetData.scale = planetData.GetScaleFactored();
Patch.Debug(" planetData.scale" + planetData.scale, LogLevel.Debug,
Patch.DebugReworkPlanetGenDeep);
planetData.precision = planetData.GetPrecisionFactored();
Patch.Debug(" planetData.precision" + planetData.precision, LogLevel.Debug,
Patch.DebugReworkPlanetGenDeep);
}
else
{
planetData.radius = PatchSize.VanillaTelluricSize;
planetData.scale = PatchSize.VanillaTelluricScale;
planetData.precision = PatchSize.VanillaTelluricPrecision;
}
planetData.segment = 5;
}
else
{
planetData.radius = PatchSize.VanillaTelluricSize;
planetData.precision = 64;
planetData.segment = 2;
}
star.planets[planetData.index] = planetData;
planetData.star = star;
Patch.Debug("Body Theme Def ( planet / Moon )", LogLevel.Debug, Patch.DebugReworkPlanetGen);
Patch.Debug("planetData \n" +
"planetData.star.index " + planetData.star.index + "\n" +
"planetData.index " + planetData.index + "\n" +
"planetData.temperatureBias " + planetData.temperatureBias + "\n" +
"planetData.planets " + planetData.star.planets + "\n" +
"planetData.planets index : " + planetData.star.planets[planetData.index].type + "\n" +
"planetData.planets Lenght " + planetData.star.planets.Length + "\n" +
"planetData.type " + planetData.type + "\n" +
"planetData.mod_x " + planetData.mod_x + "\n" +
"planetData.mod_y " + planetData.mod_y + "\n" +
"planetData.algoId " + planetData.algoId + "\n"
, LogLevel.Debug, Patch.DebugReworkPlanetGen);
star.galaxy.astroPoses[planetData.id].uRadius = planetData.realRadius;
Patch.Debug("ReworkCreatePlanet Done !", LogLevel.Debug,
Patch.DebugReworkPlanetGen);
return(planetData);
}
public static bool UpdateDirtyMesh(ref PlanetData __instance, ref bool __result, int dirtyIdx)
{
Patch.Debug("UpdateDirtyMesh", LogLevel.Debug,
Patch.DebugGeneral);
Patch.Debug("UpdateDirtyMesh Start :", LogLevel.Debug,
Patch.DebugPlanetData);
Patch.Debug("scaleFactor updateDirtyMesh :" + __instance.GetScaleFactored(), LogLevel.Debug,
Patch.DebugPlanetData);
if (__instance.dirtyFlags[dirtyIdx])
{
__instance.dirtyFlags[dirtyIdx] = false;
var precisionOnSegment = __instance.precision / __instance.segment;
Patch.Debug("precisionOnSegment :" + precisionOnSegment, LogLevel.Debug,
Patch.DebugPlanetData);
var segmentSquared = __instance.segment * __instance.segment;
Patch.Debug("segmentSquared :" + segmentSquared, LogLevel.Debug,
Patch.DebugPlanetData);
var dirtyIOnSSqu = dirtyIdx / segmentSquared;
var dirtyIOnSSquModulo = dirtyIOnSSqu % 2;
var dirtyIOnSSquByTwo = dirtyIOnSSqu / 2;
var dirtyIModuloSegmentSquared = dirtyIdx % segmentSquared;
var DIMSQMod = dirtyIModuloSegmentSquared % __instance.segment * precisionOnSegment +
dirtyIOnSSquModulo * __instance.data.substride;
Patch.Debug("DIMSQMod :" + DIMSQMod, LogLevel.Debug,
Patch.DebugPlanetData);
var DIMSQBy = dirtyIModuloSegmentSquared / __instance.segment * precisionOnSegment +
dirtyIOnSSquByTwo * __instance.data.substride;
Patch.Debug("DIMSQBy :" + DIMSQBy, LogLevel.Debug,
Patch.DebugPlanetData);
var stride = __instance.data.stride;
var radiusOffset = __instance.radius;
Patch.Debug("radiusOffset :" + radiusOffset, LogLevel.Debug,
Patch.DebugPlanetData);
var mesh = __instance.meshes[dirtyIdx];
var vertices = mesh.vertices;
var normals = mesh.normals;
var IndexGeo = 0;
for (var i = DIMSQBy; i <= DIMSQBy + precisionOnSegment; i++)
{
for (var j = DIMSQMod; j <= DIMSQMod + precisionOnSegment; j++)
{
var strideIndexLoop = j + i * stride;
var heightDataNormalized =
__instance.data.heightData[strideIndexLoop] * 0.01f;
Patch.Debug("heightDataNormalized :" + heightDataNormalized, LogLevel.Debug,
Patch.DebugPlanetDataDeep);
var thirdOdModLevel =
__instance.data.GetModLevel(strideIndexLoop) * 0.3333333f;
Patch.Debug("thirdOdModLevel :" + thirdOdModLevel, LogLevel.Debug,
Patch.DebugPlanetDataDeep);
var copyOfRadiusOffset = radiusOffset;
if (thirdOdModLevel > 0f)
{
copyOfRadiusOffset = __instance.data.GetModPlane(strideIndexLoop) *
__instance.GetScaleFactored() * 0.01f;
}
//patched copyOfRadiusOffset
// copyOfRadiusOffset *= scaleFactor;
Patch.Debug("copyOfRadiusOffset :" + copyOfRadiusOffset, LogLevel.Debug,
Patch.DebugPlanetDataDeep);
var ploup = heightDataNormalized * (1f - thirdOdModLevel) +
copyOfRadiusOffset * thirdOdModLevel;
Patch.Debug("ploup :" + ploup, LogLevel.Debug,
Patch.DebugPlanetDataDeep);
if (ploup > __instance.radius)
{
ploup -= (float)0.2 * __instance.GetScaleFactored();
if (ploup < __instance.radius)
{
ploup = __instance.radius + 0.2f;
}
}
vertices[IndexGeo].x = __instance.data.vertices[strideIndexLoop].x * ploup;
vertices[IndexGeo].y = __instance.data.vertices[strideIndexLoop].y * ploup;
vertices[IndexGeo].z = __instance.data.vertices[strideIndexLoop].z * ploup;
normals[IndexGeo].x =
__instance.data.normals[strideIndexLoop].x * (1f - thirdOdModLevel) +
__instance.data.vertices[strideIndexLoop].x * thirdOdModLevel;
normals[IndexGeo].y =
__instance.data.normals[strideIndexLoop].y * (1f - thirdOdModLevel) +
__instance.data.vertices[strideIndexLoop].y * thirdOdModLevel;
normals[IndexGeo].z =
__instance.data.normals[strideIndexLoop].z * (1f - thirdOdModLevel) +
__instance.data.vertices[strideIndexLoop].z * thirdOdModLevel;
normals[IndexGeo].Normalize();
IndexGeo++;
}
}
mesh.vertices = vertices;
mesh.normals = normals;
__instance.meshColliders[dirtyIdx].sharedMesh = null;
__instance.meshColliders[dirtyIdx].sharedMesh = mesh;
__result = true;
return(false);
}
__result = false;
return(false);
}
public static bool ModelingPlanetMain(PlanetData planet,
ref Camera ___heightmapCamera,
ref List <Mesh> ___tmpMeshList,
ref PlanetData ___currentModelingPlanet,
ref int ___currentModelingStage,
ref int ___currentModelingSeamNormal,
ref PlanetData ___currentFactingPlanet,
ref int ___currentFactingStage,
ref List <MeshRenderer> ___tmpMeshRendererList,
ref List <MeshCollider> ___tmpMeshColliderList,
ref Collider ___tmpOceanCollider,
ref List <Vector3> ___tmpVerts,
ref List <Vector3> ___tmpNorms,
ref List <Vector4> ___tmpTgnts,
ref VegeProto[] ___vegeProtos,
ref List <Vector2> ___tmpUvs,
ref List <Vector4> ___tmpUv2s,
ref List <int> ___tmpTris,
ref GameObject ___tmpPlanetGameObject,
ref GameObject ___tmpPlanetBodyGameObject,
ref GameObject ___tmpPlanetReformGameObject,
ref MeshRenderer ___tmpPlanetReformRenderer)
{
Patch.Debug("ModelingPlanetMain", LogLevel.Debug,
Patch.DebugGeneral);
var themeProto = LDB.themes.Select(planet.theme);
planet.data.AddFactoredRadius(planet);
Patch.Debug("Planet " + planet.name, LogLevel.Debug,
Patch.DebugPlanetModelingManager);
Patch.Debug("Planet Modeling Main Start :", LogLevel.Debug,
Patch.DebugPlanetModelingManager);
Patch.Debug("Planet radius :" + planet.radius, LogLevel.Debug,
Patch.DebugPlanetModelingManager);
Patch.Debug("Planet RealRadius :" + planet.realRadius, LogLevel.Debug,
Patch.DebugPlanetModelingManager);
Patch.Debug("Planet precision :" + planet.precision, LogLevel.Debug,
Patch.DebugPlanetModelingManager);
Patch.Debug("Planet Scale :" + planet.scale, LogLevel.Debug,
Patch.DebugPlanetModelingManager);
Patch.Debug("Planet Algo :" + planet.algoId, LogLevel.Debug,
Patch.DebugPlanetModelingManager);
Patch.Debug("Planet RealRadius :" + planet.realRadius, LogLevel.Debug,
Patch.DebugPlanetModelingManager);
Patch.Debug("Planet Scale :" + planet.scale, LogLevel.Debug,
Patch.DebugPlanetModelingManager);
Patch.Debug("Planet scaleFactor :" + planet.GetScaleFactored(), LogLevel.Debug,
Patch.DebugPlanetModelingManager);
Patch.Debug("Planet Scale :" + planet.radius, LogLevel.Debug,
Patch.DebugPlanetModelingManager);
//data.heightData = scaledHeightData;
if (___currentModelingStage == 2)
{
var planetPrecisionBySegment = planet.precision / planet.segment;
var planetPrecision = planet.precision;
var data = planet.data;
var planetScale = planet.scale;
// float planetRadiusScaled = (float) (planet.radius * (double) planetScale + 0.200000002980232);
var planetRadiusScaled = (float)(planet.radius * (double)planetScale + 0.200000002980232);
Patch.Debug("planetRadiusScaled " + planetRadiusScaled, LogLevel.Debug,
Patch.DebugPlanetModelingManager);
// planetRadiusScaled *= scaleFactor;
Patch.Debug("planetRadiusScaled Patched " + planetRadiusScaled, LogLevel.Debug,
Patch.DebugPlanetModelingManager);
var stride = data.stride;
var num6 = 0;
var stateOfTheGame = !GameMain.isLoading ? 2 : 3;
var num8 = 0;
for (var index1 = 0; index1 < 4; ++index1)
{
var num9 = index1 % 2 * (planetPrecision + 1);
var num10 = index1 / 2 * (planetPrecision + 1);
for (var index2 = 0; index2 < planetPrecision; index2 += planetPrecisionBySegment)
{
for (var index3 = 0; index3 < planetPrecision; index3 += planetPrecisionBySegment)
{
if (num8 == 0 && num6 < ___tmpMeshList.Count)
{
++num6;
}
else
{
var mesh = new Mesh();
___tmpMeshList.Add(mesh);
___tmpVerts.Clear();
___tmpNorms.Clear();
___tmpTgnts.Clear();
___tmpUvs.Clear();
___tmpUv2s.Clear();
var gameObject = new GameObject("Surface");
gameObject.layer = 30;
gameObject.transform.SetParent(___tmpPlanetBodyGameObject.transform, false);
for (var index4 = index2;
index4 <= index2 + planetPrecisionBySegment &&
index4 <= planetPrecision;
++index4)
{
for (var index5 = index3;
index5 <= index3 + planetPrecisionBySegment &&
index5 <= planetPrecision;
++index5)
{
var num11 = num9 + index5;
var num12 = num10 + index4;
var index6 = num11 + num12 * stride;
var num13 = index6;
if (index4 == 0)
{
var num14 = (index1 + 3) % 4;
var num15 = num14 % 2 * (planetPrecision + 1);
var num16 = num14 / 2 * (planetPrecision + 1);
var num17 = planetPrecision;
var num18 = planetPrecision - index5;
num13 = num15 + num17 + (num16 + num18) * stride;
}
else if (index5 == 0)
{
var num14 = (index1 + 3) % 4;
var num15 = num14 % 2 * (planetPrecision + 1);
var num16 = num14 / 2 * (planetPrecision + 1);
var num17 = planetPrecision - index4;
var num18 = planetPrecision;
num13 = num15 + num17 + (num16 + num18) * stride;
}
if (index4 == planetPrecision)
{
var num14 = (index1 + 1) % 4;
var num15 = num14 % 2 * (planetPrecision + 1);
var num16 = num14 / 2 * (planetPrecision + 1);
var num17 = 0;
var num18 = planetPrecision - index5;
num13 = num15 + num17 + (num16 + num18) * stride;
}
else if (index5 == planetPrecision)
{
var num14 = (index1 + 1) % 4;
var num15 = num14 % 2 * (planetPrecision + 1);
var num16 = num14 / 2 * (planetPrecision + 1);
var num17 = planetPrecision - index4;
var num18 = 0;
num13 = num15 + num17 + (num16 + num18) * stride;
}
Patch.Debug("data.heightData[index6] : " + data.heightData[index6],
LogLevel.Debug,
Patch.DebugPlanetModelingManagerDeep);
var heightDataScaled = data.heightData[index6] * 0.01f;
//If GasGiant
if (planet.type == EPlanetType.Gas)
{
heightDataScaled *= planetScale;
}
Patch.Debug("heightDataScaled : " + heightDataScaled,
LogLevel.Debug,
Patch.DebugPlanetModelingManagerDeep);
var thirdOfModLevel = data.GetModLevel(index6) * 0.3333333f;
Patch.Debug("thirdOfModLevel : " + thirdOfModLevel,
LogLevel.Debug,
Patch.DebugPlanetModelingManagerDeep);
if (thirdOfModLevel > 0.0)
{
//data.GetModPlane(index6)) 20000 + * 0.01f --> 200 +
Patch.Debug(
"data.GetModPlane(index6) : " + data.GetModPlaneInt(index6),
LogLevel.Debug,
Patch.DebugPlanetModelingManagerDeep);
var modPlanePatched = data.GetModPlaneInt(index6);
Patch.Debug("patch modPlane: " + modPlanePatched,
LogLevel.Debug,
Patch.DebugPlanetModelingManagerDeep);
planetRadiusScaled = modPlanePatched * 0.01f;
Patch.Debug(
"planetRadiusScaled is modified : " + planetRadiusScaled,
LogLevel.Debug,
Patch.DebugPlanetModelingManagerDeep);
}
// final height modification ?
var finalHeight = (float)(heightDataScaled * (1.0 - thirdOfModLevel) + planetRadiusScaled * (double)thirdOfModLevel);
Patch.Debug("finalHeight : " + finalHeight, LogLevel.Debug,
Patch.DebugPlanetModelingManagerDeep);
var vector3_1 = data.vertices[index6] * finalHeight;
___tmpVerts.Add(vector3_1);
___tmpNorms.Add(data.vertices[index6]);
var vector3_2 = Vector3.Cross(data.vertices[index6], Vector3.up).normalized;
if (vector3_2.sqrMagnitude == 0.0)
{
vector3_2 = Vector3.right;
}
___tmpTgnts.Add(new Vector4(vector3_2.x, vector3_2.y, vector3_2.z, 1f));
___tmpUvs.Add(new Vector2((num11 + 0.5f) / stride, (num12 + 0.5f) / stride));
___tmpUv2s.Add(new Vector4(data.biomoData[index6] * 0.01f, data.temprData[index6] * 0.01f, index6 + 0.3f, num13 + 0.3f));
}
}
mesh.indexFormat = IndexFormat.UInt16;
mesh.SetVertices(___tmpVerts);
mesh.SetNormals(___tmpNorms);
mesh.SetTangents(___tmpTgnts);
mesh.SetUVs(0, ___tmpUvs);
mesh.SetUVs(1, ___tmpUv2s);
mesh.SetTriangles(___tmpTris, 0, true, 0);
mesh.RecalculateNormals();
mesh.GetNormals(___tmpNorms);
for (var index4 = 0; index4 < ___tmpNorms.Count; ++index4)
{
var z = (int)___tmpUv2s[index4].z;
var w = (int)___tmpUv2s[index4].w;
data.normals[z] = data.normals[z] + ___tmpNorms[index4];
data.normals[w] = data.normals[w] + ___tmpNorms[index4];
}
var meshFilter2 = gameObject.AddComponent <MeshFilter>();
var meshRenderer = gameObject.AddComponent <MeshRenderer>();
var meshCollider = gameObject.AddComponent <MeshCollider>();
meshFilter2.sharedMesh = mesh;
meshRenderer.sharedMaterial = planet.terrainMaterial;
meshRenderer.shadowCastingMode = ShadowCastingMode.Off;
meshRenderer.receiveShadows = false;
meshRenderer.lightProbeUsage = LightProbeUsage.Off;
meshCollider.sharedMesh = mesh;
___tmpMeshRendererList.Add(meshRenderer);
___tmpMeshColliderList.Add(meshCollider);
++num8;
if (num8 == stateOfTheGame)
{
return(false);
}
}
}
}
}
var num23 = !GameMain.isLoading ? 5 : 15;
for (var index1 = 0; index1 < ___tmpMeshList.Count; ++index1)
{
var num9 = index1 / num23;
if (num9 >= ___currentModelingSeamNormal)
{
if (num9 > ___currentModelingSeamNormal)
{
++___currentModelingSeamNormal;
return(false);
}
var tmpMesh = ___tmpMeshList[index1];
___tmpNorms.Clear();
___tmpUv2s.Clear();
var vertexCount = tmpMesh.vertexCount;
tmpMesh.GetUVs(1, ___tmpUv2s);
for (var index2 = 0; index2 < vertexCount; ++index2)
{
var z = (int)___tmpUv2s[index2].z;
___tmpNorms.Add(data.normals[z].normalized);
}
tmpMesh.SetNormals(___tmpNorms);
}
}
___currentModelingStage = 3;
}
return(true);
}
public static bool ModelingPlanetMain(PlanetData planet,
ref Camera ___heightmapCamera,
ref List <Mesh> ___tmpMeshList,
ref PlanetData ___currentModelingPlanet,
ref int ___currentModelingStage,
ref int ___currentModelingSeamNormal,
ref PlanetData ___currentFactingPlanet,
ref int ___currentFactingStage,
ref List <MeshRenderer> ___tmpMeshRendererList,
ref List <MeshCollider> ___tmpMeshColliderList,
ref Collider ___tmpOceanCollider,
ref List <Vector3> ___tmpVerts,
ref List <Vector3> ___tmpNorms,
ref List <Vector4> ___tmpTgnts,
ref VegeProto[] ___vegeProtos,
ref List <Vector2> ___tmpUvs,
ref List <Vector4> ___tmpUv2s,
ref List <int> ___tmpTris,
ref GameObject ___tmpPlanetGameObject,
ref GameObject ___tmpPlanetBodyGameObject,
ref GameObject ___tmpPlanetReformGameObject,
ref MeshRenderer ___tmpPlanetReformRenderer)
{
Patch.Debug("ModelingPlanetMain", LogLevel.Debug,
Patch.DebugGeneral);
var themeProto = LDB.themes.Select(planet.theme);
planet.data.AddFactoredRadius(planet);
Patch.Debug("Planet " + planet.name, LogLevel.Debug,
Patch.DebugPlanetModelingManager);
Patch.Debug("Planet Modeling Main Start :", LogLevel.Debug,
Patch.DebugPlanetModelingManager);
Patch.Debug("Planet radius :" + planet.radius, LogLevel.Debug,
Patch.DebugPlanetModelingManager);
Patch.Debug("Planet RealRadius :" + planet.realRadius, LogLevel.Debug,
Patch.DebugPlanetModelingManager);
Patch.Debug("Planet precision :" + planet.precision, LogLevel.Debug,
Patch.DebugPlanetModelingManager);
Patch.Debug("Planet Scale :" + planet.scale, LogLevel.Debug,
Patch.DebugPlanetModelingManager);
Patch.Debug("Planet Algo :" + planet.algoId, LogLevel.Debug,
Patch.DebugPlanetModelingManager);
Patch.Debug("Planet RealRadius :" + planet.realRadius, LogLevel.Debug,
Patch.DebugPlanetModelingManager);
Patch.Debug("Planet Scale :" + planet.scale, LogLevel.Debug,
Patch.DebugPlanetModelingManager);
Patch.Debug("Planet scaleFactor :" + planet.GetScaleFactored(), LogLevel.Debug,
Patch.DebugPlanetModelingManager);
Patch.Debug("Planet Scale :" + planet.radius, LogLevel.Debug,
Patch.DebugPlanetModelingManager);
//data.heightData = scaledHeightData;
var planetPrecisionBySegment = planet.precision / planet.segment;
switch (___currentModelingStage)
{
case 0: {
Patch.Debug("___currentModelingStage :" + 0, LogLevel.Debug,
Patch.DebugPlanetModelingManager);
if (___tmpMeshList == null)
{
___tmpMeshList = new List <Mesh>(100);
___tmpMeshRendererList = new List <MeshRenderer>(100);
___tmpMeshColliderList = new List <MeshCollider>(100);
___tmpOceanCollider = null;
___tmpVerts = new List <Vector3>(1700);
___tmpNorms = new List <Vector3>(1700);
___tmpTgnts = new List <Vector4>(1700);
___tmpUvs = new List <Vector2>(1700);
___tmpUv2s = new List <Vector4>(1700);
___tmpTris = new List <int>(10000);
}
if (planet.heightmap == null)
{
planet.heightmap = new RenderTexture(
new RenderTextureDescriptor(512, 512, RenderTextureFormat.RGHalf, 0)
{
dimension = TextureDimension.Cube,
useMipMap = false,
autoGenerateMips = false
});
}
if (___heightmapCamera == null)
{
var gameObject = new GameObject("Heightmap Camera");
___heightmapCamera = gameObject.AddComponent <Camera>();
___heightmapCamera.cullingMask = 1073741824;
___heightmapCamera.enabled = false;
___heightmapCamera.farClipPlane = 900f;
___heightmapCamera.nearClipPlane = 10f;
___heightmapCamera.renderingPath = RenderingPath.Forward;
___heightmapCamera.allowDynamicResolution = false;
___heightmapCamera.allowMSAA = false;
___heightmapCamera.allowHDR = true;
___heightmapCamera.depthTextureMode = DepthTextureMode.None;
___heightmapCamera.clearFlags = CameraClearFlags.Color;
___heightmapCamera.backgroundColor = Color.black;
___heightmapCamera.depth = 0.0f;
___heightmapCamera.SetReplacementShader(Configs.builtin.heightmapShader, "ReplaceTag");
gameObject.SetActive(false);
}
if (planet.terrainMaterial == null)
{
if (themeProto != null &&
themeProto.terrainMat != null)
{
planet.terrainMaterial =
Instantiate(themeProto.terrainMat);
planet.terrainMaterial.name = planet.displayName + " Terrain";
planet.terrainMaterial.SetFloat("_Radius", planet.realRadius);
}
else
{
planet.terrainMaterial =
Instantiate(Configs.builtin.planetSurfaceMatProto);
}
}
if (planet.oceanMaterial == null)
{
if (themeProto != null &&
themeProto.oceanMat != null)
{
planet.oceanMaterial =
Instantiate(themeProto.oceanMat);
planet.oceanMaterial.name = planet.displayName + " Ocean";
planet.oceanMaterial.SetFloat("_Radius", planet.realRadius);
}
else
{
planet.oceanMaterial = null;
}
}
if (planet.atmosMaterial == null)
{
if (themeProto != null &&
themeProto.atmosMat != null)
{
planet.atmosMaterial =
Instantiate(themeProto.atmosMat);
planet.atmosMaterial.name = planet.displayName + " Atmos";
}
else
{
planet.atmosMaterial = null;
}
}
if (planet.reformMaterial == null)
{
planet.reformMaterial =
Instantiate(Configs.builtin.planetReformMatProto);
}
if (planet.ambientDesc == null)
{
planet.ambientDesc =
themeProto == null || !(themeProto.ambientDesc !=
null)
? null
: themeProto.ambientDesc;
}
if (planet.ambientSfx == null &&
themeProto != null &&
themeProto.ambientSfx != null)
{
planet.ambientSfx = themeProto.ambientSfx;
planet.ambientSfxVolume = themeProto.SFXVolume;
}
if (planet.minimapMaterial == null)
{
planet.minimapMaterial =
themeProto == null || !(themeProto.minimapMat !=
null)
? Instantiate(Configs.builtin.planetMinimapDefault)
: Instantiate(themeProto.minimapMat);
planet.minimapMaterial.name = planet.displayName + " Minimap";
planet.minimapMaterial.SetTexture("_HeightMap", planet.heightmap);
}
___tmpMeshList.Clear();
___tmpMeshRendererList.Clear();
___tmpMeshColliderList.Clear();
___tmpOceanCollider = null;
___tmpTris.Clear();
___currentModelingStage = 1;
break;
}
case 1: {
Patch.Debug("___currentModelingStage :" + 1, LogLevel.Debug,
Patch.DebugPlanetModelingManager);
___tmpPlanetGameObject = new GameObject(planet.displayName);
___tmpPlanetGameObject.layer = 31;
GameMain.universeSimulator.SetPlanetSimulator(
___tmpPlanetGameObject.AddComponent <PlanetSimulator>(), planet);
___tmpPlanetGameObject.transform.localPosition = Vector3.zero;
___tmpPlanetBodyGameObject = new GameObject("Planet Body");
___tmpPlanetBodyGameObject.transform.SetParent(___tmpPlanetGameObject.transform, false);
___tmpPlanetBodyGameObject.layer = 31;
___tmpPlanetReformGameObject = new GameObject("Terrain Reform");
___tmpPlanetReformGameObject.transform.SetParent(___tmpPlanetBodyGameObject.transform,
false);
___tmpPlanetReformGameObject.layer = 14;
var meshFilter1 = ___tmpPlanetReformGameObject.AddComponent <MeshFilter>();
___tmpPlanetReformRenderer = ___tmpPlanetReformGameObject.AddComponent <MeshRenderer>();
meshFilter1.sharedMesh = Configs.builtin.planetReformMesh;
___tmpPlanetReformRenderer.sharedMaterial = planet.reformMaterial;
___tmpPlanetReformRenderer.receiveShadows = false;
___tmpPlanetReformRenderer.lightProbeUsage = LightProbeUsage.Off;
___tmpPlanetReformRenderer.shadowCastingMode = ShadowCastingMode.Off;
// radius x2 = diameter
var planetReformDiameter =
(float)((planet.realRadius + 0.200000002980232 + 0.025000000372529) * 2.0);
Patch.Debug("planetReformDiameter :" + planetReformDiameter, LogLevel.Debug,
Patch.DebugPlanetModelingManager);
planetReformDiameter /= 2;
Patch.Debug("Try patching reform Diameter / 2 :" + planetReformDiameter,
LogLevel.Debug,
Patch.DebugPlanetModelingManager);
___tmpPlanetReformRenderer.transform.localScale = new Vector3(planetReformDiameter,
planetReformDiameter, planetReformDiameter);
___tmpPlanetReformRenderer.transform.rotation = Quaternion.identity;
if (planet.waterItemId != 0)
{
var gameObject =
Instantiate(Configs.builtin.oceanSphere,
___tmpPlanetBodyGameObject.transform);
gameObject.name = "Ocean Sphere";
gameObject.layer = 31;
gameObject.transform.localPosition = Vector3.zero;
gameObject.transform.localScale = Vector3.one *
(float)((planet.realRadius +
(double)planet.waterHeight) * 2.0);
Patch.Debug("Ocean Sphere Scale : realRadius : " + planet.realRadius +
" water height " + planet.waterHeight + " x 2 ", LogLevel.Debug,
Patch.DebugPlanetModelingManager);
Patch.Debug("Ocean Sphere Scale :" + gameObject.transform.localScale,
LogLevel.Debug,
Patch.DebugPlanetModelingManager);
var component = gameObject.GetComponent <Renderer>();
___tmpOceanCollider = gameObject.GetComponent <Collider>();
if (component != null)
{
component.enabled = planet.oceanMaterial !=
null;
component.shadowCastingMode = ShadowCastingMode.Off;
component.receiveShadows = false;
component.lightProbeUsage = LightProbeUsage.Off;
component.sharedMaterial = planet.oceanMaterial;
}
}
Patch.Debug(
"Planet Precision : " + planet.precision + " Planet Segments " + planet.segment,
LogLevel.Debug,
Patch.DebugPlanetModelingManager);
var planetPrecisionBySegmentPlusOne = planetPrecisionBySegment + 1;
Patch.Debug("Planet tris Generation", LogLevel.Debug,
Patch.DebugPlanetModelingManager);
for (var index1 = 0; index1 < planetPrecisionBySegment; ++index1)
{
for (var index2 = 0; index2 < planetPrecisionBySegment; ++index2)
{
___tmpTris.Add(index1 + 1 + (index2 + 1) * planetPrecisionBySegmentPlusOne);
___tmpTris.Add(index1 + (index2 + 1) * planetPrecisionBySegmentPlusOne);
___tmpTris.Add(index1 + index2 * planetPrecisionBySegmentPlusOne);
___tmpTris.Add(index1 + index2 * planetPrecisionBySegmentPlusOne);
___tmpTris.Add(index1 + 1 + index2 * planetPrecisionBySegmentPlusOne);
___tmpTris.Add(index1 + 1 + (index2 + 1) * planetPrecisionBySegmentPlusOne);
}
}
Patch.Debug("___currentModelingStage end of 1", LogLevel.Debug,
Patch.DebugPlanetModelingManager);
___currentModelingStage = 2;
break;
}
case 2: {
var planetPrecision = planet.precision;
var data = planet.data;
var planetScale = planet.scale;
// float planetRadiusScaled = (float) (planet.radius * (double) planetScale + 0.200000002980232);
var planetRadiusScaled =
(float)(planet.radius + 0.200000002980232);
Patch.Debug("planetRadiusScaled " + planetRadiusScaled, LogLevel.Debug,
Patch.DebugPlanetModelingManager);
// planetRadiusScaled *= scaleFactor;
Patch.Debug("planetRadiusScaled Patched " + planetRadiusScaled, LogLevel.Debug,
Patch.DebugPlanetModelingManager);
var stride = data.stride;
var num6 = 0;
var stateOfTheGame = !GameMain.isLoading ? 2 : 3;
var num8 = 0;
for (var index1 = 0; index1 < 4; ++index1)
{
var num9 = index1 % 2 * (planetPrecision + 1);
var num10 = index1 / 2 * (planetPrecision + 1);
for (var index2 = 0; index2 < planetPrecision; index2 += planetPrecisionBySegment)
{
for (var index3 = 0; index3 < planetPrecision; index3 += planetPrecisionBySegment)
{
if (num8 == 0 && num6 < ___tmpMeshList.Count)
{
++num6;
}
else
{
var mesh = new Mesh();
___tmpMeshList.Add(mesh);
___tmpVerts.Clear();
___tmpNorms.Clear();
___tmpTgnts.Clear();
___tmpUvs.Clear();
___tmpUv2s.Clear();
var gameObject = new GameObject("Surface");
gameObject.layer = 30;
gameObject.transform.SetParent(___tmpPlanetBodyGameObject.transform, false);
for (var index4 = index2;
index4 <= index2 + planetPrecisionBySegment &&
index4 <= planetPrecision;
++index4)
{
for (var index5 = index3;
index5 <= index3 + planetPrecisionBySegment &&
index5 <= planetPrecision;
++index5)
{
var num11 = num9 + index5;
var num12 = num10 + index4;
var index6 = num11 + num12 * stride;
var num13 = index6;
if (index4 == 0)
{
var num14 = (index1 + 3) % 4;
var num15 = num14 % 2 * (planetPrecision + 1);
var num16 = num14 / 2 * (planetPrecision + 1);
var num17 = planetPrecision;
var num18 = planetPrecision - index5;
num13 = num15 + num17 + (num16 + num18) * stride;
}
else if (index5 == 0)
{
var num14 = (index1 + 3) % 4;
var num15 = num14 % 2 * (planetPrecision + 1);
var num16 = num14 / 2 * (planetPrecision + 1);
var num17 = planetPrecision - index4;
var num18 = planetPrecision;
num13 = num15 + num17 + (num16 + num18) * stride;
}
if (index4 == planetPrecision)
{
var num14 = (index1 + 1) % 4;
var num15 = num14 % 2 * (planetPrecision + 1);
var num16 = num14 / 2 * (planetPrecision + 1);
var num17 = 0;
var num18 = planetPrecision - index5;
num13 = num15 + num17 + (num16 + num18) * stride;
}
else if (index5 == planetPrecision)
{
var num14 = (index1 + 1) % 4;
var num15 = num14 % 2 * (planetPrecision + 1);
var num16 = num14 / 2 * (planetPrecision + 1);
var num17 = planetPrecision - index4;
var num18 = 0;
num13 = num15 + num17 + (num16 + num18) * stride;
}
var heightDataScaled = data.heightData[index6] * 0.01f;
if (planet.type == EPlanetType.Gas)
{
heightDataScaled *= planetScale;
}
Patch.Debug("heightDataScaled : " + heightDataScaled,
LogLevel.Debug,
Patch.DebugPlanetModelingManagerDeep);
var thirdOfModLevel =
data.GetModLevel(index6) * 0.3333333f;
Patch.Debug("thirdOfModLevel : " + thirdOfModLevel,
LogLevel.Debug,
Patch.DebugPlanetModelingManagerDeep);
if (thirdOfModLevel > 0.0)
{
//data.GetModPlane(index6)) 20000 + * 0.01f --> 200 +
Patch.Debug(
"data.GetModPlane(index6) : " + data.GetModPlane(index6),
LogLevel.Debug,
Patch.DebugPlanetModelingManagerDeep);
var modPlanePatched = data.GetModPlane(index6) *
planet.GetScaleFactored();
Patch.Debug("patch modPlane: " + modPlanePatched,
LogLevel.Debug,
Patch.DebugPlanetModelingManagerDeep);
planetRadiusScaled = modPlanePatched * 0.01f *
planetScale;
Patch.Debug(
"planetRadiusScaled is modified : " + planetRadiusScaled,
LogLevel.Debug,
Patch.DebugPlanetModelingManagerDeep);
}
// final height modification ?
var finalHeight =
(float)(heightDataScaled *
(1.0 - thirdOfModLevel) +
planetRadiusScaled *
(double)thirdOfModLevel);
Patch.Debug("finalHeight : " + finalHeight, LogLevel.Debug,
Patch.DebugPlanetModelingManagerDeep);
var vector3_1 = data.vertices[index6] * finalHeight;
___tmpVerts.Add(vector3_1);
___tmpNorms.Add(data.vertices[index6]);
var vector3_2 = Vector3.Cross(data.vertices[index6], Vector3.up)
.normalized;
if (vector3_2.sqrMagnitude == 0.0)
{
vector3_2 = Vector3.right;
}
___tmpTgnts.Add(new Vector4(vector3_2.x, vector3_2.y, vector3_2.z,
1f));
___tmpUvs.Add(new Vector2((num11 + 0.5f) / stride,
(num12 + 0.5f) / stride));
___tmpUv2s.Add(new Vector4(data.biomoData[index6] * 0.01f,
data.temprData[index6] * 0.01f, index6 + 0.3f,
num13 + 0.3f));
}
}
mesh.indexFormat = IndexFormat.UInt16;
mesh.SetVertices(___tmpVerts);
mesh.SetNormals(___tmpNorms);
mesh.SetTangents(___tmpTgnts);
mesh.SetUVs(0, ___tmpUvs);
mesh.SetUVs(1, ___tmpUv2s);
mesh.SetTriangles(___tmpTris, 0, true, 0);
mesh.RecalculateNormals();
mesh.GetNormals(___tmpNorms);
for (var index4 = 0; index4 < ___tmpNorms.Count; ++index4)
{
var z = (int)___tmpUv2s[index4].z;
var w = (int)___tmpUv2s[index4].w;
data.normals[z] = data.normals[z] + ___tmpNorms[index4];
data.normals[w] = data.normals[w] + ___tmpNorms[index4];
}
var meshFilter2 = gameObject.AddComponent <MeshFilter>();
var meshRenderer = gameObject.AddComponent <MeshRenderer>();
var meshCollider = gameObject.AddComponent <MeshCollider>();
meshFilter2.sharedMesh = mesh;
meshRenderer.sharedMaterial = planet.terrainMaterial;
meshRenderer.shadowCastingMode = ShadowCastingMode.Off;
meshRenderer.receiveShadows = false;
meshRenderer.lightProbeUsage = LightProbeUsage.Off;
meshCollider.sharedMesh = mesh;
___tmpMeshRendererList.Add(meshRenderer);
___tmpMeshColliderList.Add(meshCollider);
++num8;
if (num8 == stateOfTheGame)
{
return(false);
}
}
}
}
}
var num23 = !GameMain.isLoading ? 5 : 15;
for (var index1 = 0; index1 < ___tmpMeshList.Count; ++index1)
{
var num9 = index1 / num23;
if (num9 >= ___currentModelingSeamNormal)
{
if (num9 > ___currentModelingSeamNormal)
{
++___currentModelingSeamNormal;
return(false);
}
var tmpMesh = ___tmpMeshList[index1];
___tmpNorms.Clear();
___tmpUv2s.Clear();
var vertexCount = tmpMesh.vertexCount;
tmpMesh.GetUVs(1, ___tmpUv2s);
for (var index2 = 0; index2 < vertexCount; ++index2)
{
var z = (int)___tmpUv2s[index2].z;
___tmpNorms.Add(data.normals[z].normalized);
}
tmpMesh.SetNormals(___tmpNorms);
}
}
___currentModelingStage = 3;
break;
}
case 3: {
___tmpPlanetBodyGameObject.SetActive(true);
___tmpPlanetReformGameObject.SetActive(true);
___heightmapCamera.transform.localPosition = ___tmpPlanetGameObject.transform.localPosition;
___heightmapCamera.RenderToCubemap(planet.heightmap, 63);
___currentModelingStage = 4;
break;
}
case 4: {
Patch.Debug("___currentModelingStage start of 4", LogLevel.Debug,
Patch.DebugPlanetModelingManager);
if (planet.wanted)
{
Patch.Debug("planet.wanted is True", LogLevel.Debug,
Patch.DebugPlanetModelingManager);
planet.gameObject = ___tmpPlanetGameObject;
planet.bodyObject = ___tmpPlanetBodyGameObject;
var component = ___tmpPlanetGameObject.GetComponent <PlanetSimulator>();
component.surfaceRenderer = new Renderer[___tmpMeshRendererList.Count];
component.surfaceCollider = new Collider[___tmpMeshColliderList.Count];
for (var index = 0; index < ___tmpMeshList.Count; ++index)
{
planet.meshes[index] = ___tmpMeshList[index];
planet.meshRenderers[index] = ___tmpMeshRendererList[index];
planet.meshColliders[index] = ___tmpMeshColliderList[index];
}
for (var index = 0; index < ___tmpMeshRendererList.Count; ++index)
{
___tmpMeshRendererList[index].gameObject.layer = 31;
___tmpMeshRendererList[index].sharedMaterial = planet.terrainMaterial;
___tmpMeshRendererList[index].receiveShadows = false;
___tmpMeshRendererList[index].shadowCastingMode = ShadowCastingMode.Off;
component.surfaceRenderer[index] = ___tmpMeshRendererList[index];
component.surfaceCollider[index] = ___tmpMeshColliderList[index];
}
component.oceanCollider = ___tmpOceanCollider;
component.sphereCollider = ___tmpPlanetBodyGameObject.AddComponent <SphereCollider>();
if (component.sphereCollider != null)
{
component.sphereCollider.enabled = false;
}
component.sphereCollider.radius = planet.realRadius;
component.reformRenderer = ___tmpPlanetReformRenderer;
component.reformMat = planet.reformMaterial;
var sharedMaterial = component.surfaceRenderer[0].sharedMaterial;
if (planet.type != EPlanetType.Gas)
{
component.reformMat.SetColor("_AmbientColor0",
sharedMaterial.GetColor("_AmbientColor0"));
component.reformMat.SetColor("_AmbientColor1",
sharedMaterial.GetColor("_AmbientColor1"));
component.reformMat.SetColor("_AmbientColor2",
sharedMaterial.GetColor("_AmbientColor2"));
component.reformMat.SetColor("_LightColorScreen",
sharedMaterial.GetColor("_LightColorScreen"));
component.reformMat.SetFloat("_Multiplier", sharedMaterial.GetFloat("_Multiplier"));
component.reformMat.SetFloat("_AmbientInc", sharedMaterial.GetFloat("_AmbientInc"));
}
___tmpPlanetGameObject.transform.localPosition = Vector3.zero;
___heightmapCamera.transform.localPosition = Vector3.zero;
___tmpPlanetBodyGameObject.SetActive(true);
___tmpPlanetReformGameObject.SetActive(true);
___tmpPlanetGameObject = null;
___tmpPlanetBodyGameObject = null;
___tmpPlanetReformGameObject = null;
___tmpPlanetReformRenderer = null;
___tmpMeshList.Clear();
___tmpMeshRendererList.Clear();
___tmpMeshColliderList.Clear();
___tmpOceanCollider = null;
___tmpTris.Clear();
___tmpVerts.Clear();
___tmpNorms.Clear();
___tmpTgnts.Clear();
___tmpUvs.Clear();
___tmpUv2s.Clear();
___currentModelingPlanet = null;
___currentModelingStage = 0;
___currentModelingSeamNormal = 0;
planet.NotifyLoaded();
if (!planet.star.loaded)
{
break;
}
planet.star.NotifyLoaded();
Patch.Debug("___currentModelingStage end of 4", LogLevel.Debug,
Patch.DebugPlanetModelingManager);
break;
}
for (var index = 0; index < ___tmpMeshList.Count; ++index)
{
Destroy(___tmpMeshList[index]);
}
Destroy(___tmpPlanetGameObject);
___tmpPlanetGameObject = null;
___tmpPlanetBodyGameObject = null;
___tmpPlanetReformGameObject = null;
___tmpPlanetReformRenderer = null;
___tmpMeshList.Clear();
___tmpTris.Clear();
___tmpVerts.Clear();
___tmpNorms.Clear();
___tmpTgnts.Clear();
___tmpUvs.Clear();
___tmpUv2s.Clear();
___currentModelingPlanet = null;
___currentModelingStage = 0;
___currentModelingSeamNormal = 0;
break;
}
}
return(false);
}
