public static bool GetModPlane(int index, ref PlanetRawData __instance, ref short __result)
{
Patch.Debug("scaleFactor " + __instance.GetFactoredScale(), LogLevel.Debug,
Patch.DebugGetModPlane);
Patch.Debug("index " + index, LogLevel.Debug,
Patch.DebugGetModPlane);
Patch.Debug("__instance.modData.Length " + __instance.modData.Length, LogLevel.Debug,
Patch.DebugGetModPlane);
Patch.Debug(
"test " + ((__instance.modData[index >> 1] >> (((index & 1) << 2) + 2)) & 3) * 133, LogLevel.Debug,
Patch.DebugGetModPlane);
float baseHeight = 20;
baseHeight += __instance.GetFactoredScale() * 200 * 100;
Patch.Debug("baseHeight " + baseHeight, LogLevel.Debug,
Patch.DebugGetModPlane);
__result = (short)(((__instance.modData[index >> 1] >> (((index & 1) << 2) + 2)) & 3) * 133 +
baseHeight);
Patch.Debug("GetModPlane __result " + __result, LogLevel.Debug,
Patch.DebugGetModPlane);
return(false);
}
public static bool ComputeFlattenTerrainReform(
Vector3[] points,
Vector3 center,
float radius,
int pointsCount,
float fade0 = 3f,
float fade1 = 1f)
{
Patch.Debug("ComputeFlattenTerrainReform", LogLevel.Debug,
Patch.DebugPlanetFactory);
return(true);
}
public static bool GetReformIndexForPosition(ref PlatformSystem __instance, Vector3 pos, ref int __result)
{
pos.Normalize();
var num1 = Mathf.Asin(pos.y);
var num2 = Mathf.Atan2(pos.x, -pos.z);
//float f1 = num1 / (2* (float)Math.PI) * (float) __instance.segment;
var f1 = num1 / 6.283185f * __instance.segment;
float longitudeSegmentCount = PlatformSystem.DetermineLongitudeSegmentCount(Mathf.FloorToInt(Mathf.Abs(f1)), __instance.segment);
// float f2 = num2 / (2* (float)Math.PI) * longitudeSegmentCount;
var f2 = num2 / 6.283185f * longitudeSegmentCount;
var f3 = Mathf.Round(f1 * 10f);
var f4 = Mathf.Round(f2 * 10f);
var num3 = Mathf.Abs(f3);
var num4 = Mathf.Abs(f4);
if (num3 % 2.0 != 1.0)
{
num3 = Mathf.FloorToInt(Mathf.Abs(f1) * 10f);
if (num3 % 2.0 != 1.0)
{
++num3;
}
}
var num5 = (double)f3 < 0.0 ? -num3 : num3;
if (num4 % 2.0 != 1.0)
{
num4 = Mathf.FloorToInt(Mathf.Abs(f2) * 10f);
if (num4 % 2.0 != 1.0)
{
++num4;
}
}
var num6 = (double)f4 < 0.0 ? -num4 : num4;
var _latitudeSeg = num5 / 10f;
var _longitudeSeg = num6 / 10f;
float num7 = __instance.latitudeCount / 10;
__result = (double)_latitudeSeg >= (double)num7 || (double)_latitudeSeg <= -(double)num7 ? -1 : __instance.GetReformIndexForSegment(_latitudeSeg, _longitudeSeg);
Patch.Debug("PlatformSystem - __result --> " + __result, LogLevel.Debug, true);
return(false);
}
public static void ReworkUpdate(ref PlanetAtmoBlur instance)
{
Patch.Debug("ReworkPlanetAtmoBlur", LogLevel.Debug, Patch.DebugAtmoBlur);
instance.cam.fieldOfView = Camera.main.fieldOfView;
if (GameMain.localPlanet != null && GameMain.localPlanet.type != EPlanetType.Gas)
{
Patch.Debug("GameMain.localPlanet" + GameMain.localPlanet, LogLevel.Debug, Patch.DebugAtmoBlur);
instance.blurMat.SetVector("_PlanetRadius",
new Vector4(200f * GameMain.localPlanet.GetScaleFactored(), 200f * GameMain.localPlanet.GetScaleFactored(), 240f * GameMain.localPlanet.GetScaleFactored(),
Mathf.Clamp01((float)((1100.0 - GameMain.mainPlayer.position.magnitude) / 600.0))));
Patch.Debug("instance.blurMat" + instance.blurMat.GetVector("_PlanetRadius"), LogLevel.Debug, Patch.DebugAtmoBlur);
}
else
{
instance.blurMat.SetVector("_PlanetRadius", new Vector4(200f, 200f, 200f, 0.0f));
Patch.Debug("else" + instance.blurMat.GetVector("_PlanetRadius"), LogLevel.Debug, Patch.DebugAtmoBlur);
}
Shader.SetGlobalTexture("_Global_AtmoBlurTex", instance.planetAtmoBlurRTex);
}
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 QueryModifiedHeight(ref PlanetRawData __instance,
ref float __result, Vector3 vpos)
{
Patch.Debug("QueryModifiedHeight ", LogLevel.Debug,
Patch.DebugPlanetRawData);
vpos.Normalize();
var index1 = __instance.indexMap[__instance.PositionHash(vpos)];
var radiusPrecision =
(float)(3.14159274101257 / (__instance.precision * 2) * 1.20000004768372);
Patch.Debug("radiusPrecision " + radiusPrecision, LogLevel.Debug,
Patch.DebugPlanetRawData);
var radiusPrecisionSq = radiusPrecision * radiusPrecision;
Patch.Debug("radiusPrecisionSq " + radiusPrecisionSq, LogLevel.Debug,
Patch.DebugPlanetRawData);
var magnetudeOnPrecisionDummy = 0.0f;
var HeightTimePrecision = 0.0f;
var stride = __instance.stride;
for (var index2 = -1; index2 <= 3; ++index2)
{
for (var index3 = -1; index3 <= 3; ++index3)
{
var index4 = index1 + index2 + index3 * stride;
if ((uint)index4 < __instance.dataLength)
{
var sqrMagnitude = (__instance.vertices[index4] - vpos).sqrMagnitude;
Patch.Debug("sqrMagnitude " + sqrMagnitude, LogLevel.Debug,
Patch.DebugPlanetRawData);
if (sqrMagnitude <= (double)radiusPrecisionSq)
{
var magnetudeOnPrecision =
(float)(1.0 - Mathf.Sqrt(sqrMagnitude) / (double)radiusPrecision);
Patch.Debug("MagnetudeOnPrecision " + magnetudeOnPrecision, LogLevel.Debug,
Patch.DebugPlanetRawData);
magnetudeOnPrecision *= __instance.GetFactoredScale();
Patch.Debug("MagnetudeOnPrecision Patched " + magnetudeOnPrecision,
LogLevel.Debug,
Patch.DebugPlanetRawData);
var modLevel = __instance.GetModLevel(index4);
float heightDataFinal = __instance.heightData[index4];
Patch.Debug("heightDataFinal First " + heightDataFinal, LogLevel.Debug,
Patch.DebugPlanetRawData);
if (modLevel > 0)
{
// try patching here
var modPlane = __instance.GetModPlaneInt(index4);
Patch.Debug("modPlane " + modPlane, LogLevel.Debug,
Patch.DebugPlanetRawData);
if (modLevel == 3)
{
heightDataFinal = modPlane;
Patch.Debug("heightDataFinal Second " + heightDataFinal, LogLevel.Debug,
Patch.DebugPlanetRawData);
}
else
{
var num7 = modLevel * 0.3333333f;
heightDataFinal =
(float)(__instance.heightData[index4] * (1.0 - num7) +
modPlane * (double)num7);
Patch.Debug("heightDataFinal Third " + heightDataFinal, LogLevel.Debug,
Patch.DebugPlanetRawData);
}
}
Patch.Debug("__result num6 " + heightDataFinal, LogLevel.Debug,
Patch.DebugPlanetRawData);
magnetudeOnPrecisionDummy += magnetudeOnPrecision;
HeightTimePrecision += heightDataFinal * magnetudeOnPrecision;
Patch.Debug("heightDataFinal Third " + heightDataFinal, LogLevel.Debug,
Patch.DebugPlanetRawData);
}
}
}
}
if (magnetudeOnPrecisionDummy != 0.0)
{
__result = (float)(HeightTimePrecision / (double)magnetudeOnPrecisionDummy *
0.00999999977648258);
Patch.Debug("__result magnetudeOnPrecisionDummy" + __result, LogLevel.Debug,
Patch.DebugPlanetRawData);
return(false);
}
Debug.LogWarning("bad query");
__result = __instance.heightData[0] * 0.01f;
Patch.Debug("__result bad query" + __result, LogLevel.Debug,
Patch.DebugPlanetRawData);
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 UpdateUniversalPosition(ref PlanetSimulator __instance, ref StarSimulator ___star, ref bool ___isLocal, ref Transform ___lookCamera, Vector3 playerLPos, VectorLF3 playerUPos, Vector3 cameraPos)
{
if (__instance.planetData == null || __instance.planetData.loading || __instance.planetData.factoryLoading)
{
return(false);
}
__instance.SetLayers();
var localPlanet = GameMain.localPlanet;
var flag1 = ___isLocal != (localPlanet == __instance.planetData);
___isLocal = localPlanet == __instance.planetData;
var flag2 = PlanetSimulator.sOptionCastShadow != __instance.optionCastShadow;
if (flag1 || flag2)
{
foreach (var renderer in __instance.surfaceRenderer)
{
renderer.receiveShadows = ___isLocal;
renderer.shadowCastingMode = !___isLocal || !PlanetSimulator.sOptionCastShadow
? ShadowCastingMode.Off
: ShadowCastingMode.On;
}
__instance.optionCastShadow = PlanetSimulator.sOptionCastShadow;
}
__instance.reformRenderer.receiveShadows = ___isLocal;
var flag3 = ___isLocal && __instance.planetData.type != EPlanetType.Gas;
if (__instance.sphereCollider.enabled == flag3)
{
foreach (var collider in __instance.surfaceCollider)
{
collider.enabled = flag3;
}
if (__instance.oceanCollider != null)
{
__instance.oceanCollider.enabled = flag3;
}
__instance.sphereCollider.enabled = !flag3;
}
var uPosition = __instance.planetData.uPosition;
var quaternion = Quaternion.identity;
VectorLF3 vectorLf3;
if (localPlanet != null)
{
quaternion = localPlanet.runtimeRotation;
if (localPlanet == __instance.planetData)
{
vectorLf3 = VectorLF3.zero;
}
else
{
var v = uPosition - localPlanet.uPosition;
vectorLf3 = Maths.QInvRotateLF(quaternion, v);
}
}
else
{
vectorLf3 = uPosition - playerUPos;
}
var vscale = 1f;
Vector3 vpos;
UniverseSimulator.VirtualMapping(vectorLf3.x, vectorLf3.y, vectorLf3.z, cameraPos, out vpos, out vscale);
var vector3_1 = Vector3.one * vscale;
if (__instance.transform.localPosition != vpos)
{
__instance.transform.localPosition = vpos;
}
if (__instance.planetData == localPlanet)
{
if (__instance.transform.localPosition.sqrMagnitude > 0.0)
{
__instance.transform.localPosition = Vector3.zero;
}
if (__instance.transform.localRotation != Quaternion.identity)
{
__instance.transform.localRotation = Quaternion.identity;
}
}
else
{
__instance.transform.localRotation =
Quaternion.Inverse(quaternion) * __instance.planetData.runtimeRotation;
}
if (__instance.transform.localScale != vector3_1)
{
__instance.transform.localScale = vector3_1;
}
var vector3_2 = Quaternion.Inverse(quaternion) *
(__instance.planetData.star.uPosition - __instance.planetData.uPosition).normalized;
var lhs = ___lookCamera.localPosition - __instance.transform.localPosition;
var magnitude = lhs.magnitude;
var localRotation = __instance.transform.localRotation;
var vector4_1 = new Vector4(localRotation.x, localRotation.y, localRotation.z, localRotation.w);
if (__instance.surfaceRenderer != null && __instance.surfaceRenderer.Length > 0)
{
var sharedMaterial = __instance.surfaceRenderer[0].sharedMaterial;
sharedMaterial.SetVector("_SunDir", vector3_2);
sharedMaterial.SetVector("_Rotation",
new Vector4(localRotation.x, localRotation.y, localRotation.z, localRotation.w));
sharedMaterial.SetFloat("_Distance", magnitude);
}
if (__instance.reformRenderer != null &&
__instance.reformMat != null && __instance.planetData.factory != null)
{
var platformSystem = __instance.planetData.factory.platformSystem;
var reformOffsetsBuffer = platformSystem.reformOffsetsBuffer;
var reformDataBuffer = platformSystem.reformDataBuffer;
__instance.reformMat.SetFloat("_LatitudeCount", platformSystem.latitudeCount);
__instance.reformMat.SetVector("_SunDir", vector3_2);
__instance.reformMat.SetFloat("_Distance", magnitude);
__instance.reformMat.SetVector("_Rotation", vector4_1);
if (platformSystem.reformData != null && reformDataBuffer != null)
{
reformOffsetsBuffer.SetData(platformSystem.reformOffsets);
reformDataBuffer.SetData(platformSystem.reformData);
__instance.reformMat.SetBuffer("_OffsetsBuffer", reformOffsetsBuffer);
__instance.reformMat.SetBuffer("_DataBuffer", reformDataBuffer);
}
}
if (!(__instance.atmoTrans0 != null))
{
return(false);
}
__instance.atmoTrans0.rotation = ___lookCamera.localRotation;
Vector4 vector4_2 = !(GameCamera.generalTarget == null)
? GameCamera.generalTarget.position
: Vector3.zero;
// ********************************* Fix Here for release :)
var positionOffset = 0;
if (localPlanet != null)
{
if (localPlanet.type != EPlanetType.Gas)
{
positionOffset = Mathf.RoundToInt(Mathf.Abs(localPlanet.radius - 200) / 2);
}
}
Patch.Debug("positionOffset " + positionOffset, LogLevel.Debug, Patch.DebugAtmoBlur);
__instance.atmoTrans1.localPosition = new Vector3(0, 0,
Mathf.Clamp(Vector3.Dot(lhs, ___lookCamera.forward) + 10f / __instance.planetData.GetScaleFactored(), 0.0f, Math.Max(320f, 320f * __instance.planetData.GetScaleFactored())));
var num1 = Mathf.Clamp01(8000f * __instance.planetData.GetScaleFactored() / magnitude);
var num2 = Mathf.Clamp01(4000f * __instance.planetData.GetScaleFactored() / magnitude);
var atmoMatRadiusParam = __instance.atmoMatRadiusParam;
atmoMatRadiusParam.z = atmoMatRadiusParam.x +
(float)((__instance.atmoMatRadiusParam.z - (double)__instance.atmoMatRadiusParam.x) *
(2.70000004768372 - num2 * 1.70000004768372));
Patch.Debug("__instance.atmoTrans1 " + __instance.atmoTrans1.localScale, LogLevel.Debug, Patch.DebugAtmoBlur);
var vector4_3 = atmoMatRadiusParam * vscale * __instance.planetData.GetScaleFactored();
Patch.Debug("vector4_3 " + __instance.planetData.name + vector4_3, LogLevel.Debug, Patch.DebugAtmoBlur);
__instance.atmoMat.SetVector("_PlanetPos", __instance.transform.localPosition);
__instance.atmoMat.SetVector("_SunDir", vector3_2);
__instance.atmoMat.SetVector("_PlanetRadius", vector4_3);
__instance.atmoMat.SetColor("_Color4", ___star.sunAtmosColor);
__instance.atmoMat.SetColor("_Sky4", ___star.sunriseAtmosColor);
__instance.atmoMat.SetVector("_LocalPos", vector4_2);
__instance.atmoMat.SetFloat("_SunRiseScatterPower",
Mathf.Max(60f * __instance.planetData.GetScaleFactored(),
(float)((magnitude - __instance.planetData.realRadius * 2.0) * 0.180000007152557)));
__instance.atmoMat.SetFloat("_IntensityControl", num1);
__instance.atmoMat.renderQueue = __instance.planetData != localPlanet ? 2989 : 2991;
return(false);
}
public static bool FlattenTerrainReform(
ref PlanetFactory __instance,
ref Dictionary <int, int> ___tmp_levelChanges,
ref int[] ___tmp_entity_ids,
ref int[] ___tmp_ids,
Vector3 center,
float radius,
int reformSize,
bool veinBuried,
float fade0 = 3f)
{
if (___tmp_ids == null)
{
___tmp_ids = new int[1024];
}
if (___tmp_entity_ids == null)
{
___tmp_entity_ids = new int[1024];
}
Array.Clear(___tmp_ids, 0, ___tmp_ids.Length);
Array.Clear(___tmp_entity_ids, 0, ___tmp_entity_ids.Length);
var zero = Vector3.zero;
var data = __instance.planet.data;
var heightData = data.heightData;
var num1 = Mathf.Min(9f,
Mathf.Abs((float)((heightData[data.QueryIndex(center)] -
__instance.planet.realRadius * 100.0) * 0.00999999977648258 * 2.0)));
fade0 += num1;
var areaRadius = radius + fade0;
var num2 = (short)(__instance.planet.realRadius * 100.0);
var levelized = __instance.planet.levelized;
var plane = Mathf.RoundToInt(
(float)((center.magnitude - (double)__instance.planet.realRadius) /
1.33333325386047));
var num3 = plane * 133 + num2 - 60;
var num4 = (float)(__instance.planet.radius * 100.0 - 20.0);
foreach (var tmpLevelChange in ___tmp_levelChanges)
{
if (tmpLevelChange.Value > 0)
{
var num5 = heightData[tmpLevelChange.Key];
if (levelized)
{
if (num5 >= num3)
{
if (data.GetModLevel(tmpLevelChange.Key) < 3)
{
data.SetModPlane(tmpLevelChange.Key, plane);
}
__instance.planet.AddHeightMapModLevel(tmpLevelChange.Key, tmpLevelChange.Value);
}
}
else
{
__instance.planet.AddHeightMapModLevel(tmpLevelChange.Key, tmpLevelChange.Value);
}
if (num5 < (double)num4)
{
__instance.planet.landPercentDirty = true;
}
}
}
if (__instance.planet.UpdateDirtyMeshes())
{
__instance.RenderLocalPlanetHeightmap();
}
radius -= reformSize * 0.15f;
var nearColliderLogic = __instance.planet.physics.nearColliderLogic;
var vegetablesInAreaNonAlloc =
nearColliderLogic.GetVegetablesInAreaNonAlloc(center, areaRadius, ___tmp_ids);
var num6 = radius * radius;
for (var index = 0; index < vegetablesInAreaNonAlloc; ++index)
{
var tmpId = ___tmp_ids[index];
var vector3 = __instance.vegePool[tmpId].pos - center;
if (vector3.x * (double)vector3.x + vector3.y * (double)vector3.y +
vector3.z * (double)vector3.z <= num6 + 2.20000004768372)
{
__instance.RemoveVegeWithComponents(tmpId);
}
else
{
var num5 = data.QueryModifiedHeight(__instance.vegePool[tmpId].pos) - 0.03f;
__instance.vegePool[tmpId].pos = __instance.vegePool[tmpId].pos.normalized * num5;
GameMain.gpuiManager.AlterModel(__instance.vegePool[tmpId].modelIndex,
__instance.vegePool[tmpId].modelId, tmpId, __instance.vegePool[tmpId].pos,
__instance.vegePool[tmpId].rot, false);
}
}
var num7 = 50f;
var num8 = !veinBuried
? nearColliderLogic.GetVeinsInOceanInAreaNonAlloc(center, areaRadius, ___tmp_ids)
: nearColliderLogic.GetVeinsInAreaNonAlloc(center, areaRadius, ___tmp_ids);
for (var index1 = 0; index1 < num8; ++index1)
{
var tmpId = ___tmp_ids[index1];
var pos = __instance.veinPool[tmpId].pos;
var num5 = __instance.planet.realRadius + 0.2f;
var vector3_1 = pos.normalized * num5 - center;
if (vector3_1.x * (double)vector3_1.x + vector3_1.y * (double)vector3_1.y +
vector3_1.z * (double)vector3_1.z <= num6 + 2.0)
{
var physics = __instance.planet.physics;
var colliderId = __instance.veinPool[tmpId].colliderId;
var colliderData = physics.GetColliderData(colliderId);
if (veinBuried)
{
num5 -= num7;
}
else
{
var center1 = pos.normalized * num5;
if (nearColliderLogic.GetEntitiesInAreaWhenReformNonAlloc(center1, colliderData.radius,
___tmp_entity_ids) > 0)
{
num5 = pos.magnitude;
}
}
var vector3_2 = colliderData.pos.normalized * num5;
var index2 = colliderId >> 20;
var index3 = colliderId & 1048575;
physics.colChunks[index2].colliderPool[index3].pos = vector3_2;
__instance.veinPool[tmpId].pos = pos.normalized * num5;
physics.RefreshColliders();
GameMain.gpuiManager.AlterModel(__instance.veinPool[tmpId].modelIndex,
__instance.veinPool[tmpId].modelId, tmpId, __instance.veinPool[tmpId].pos, false);
}
}
___tmp_levelChanges.Clear();
Array.Clear(___tmp_ids, 0, ___tmp_ids.Length);
Array.Clear(___tmp_ids, 0, ___tmp_entity_ids.Length);
GameMain.gpuiManager.SyncAllGPUBuffer();
Debug.Log("FlattenTerrainReform -- Begining ");
Patch.Debug("FlattenTerrainReform ", LogLevel.Debug,
Patch.DebugPlanetFactory);
return(false);
}
public static bool FlattenTerrain(
ref PlanetFactory __instance,
ref int __result,
ref Dictionary <int, int> ___tmp_levelChanges,
ref int[] ___tmp_ids,
Vector3 pos,
Quaternion rot,
Bounds bound,
float fade0 = 6f,
float fade1 = 1f,
bool removeVein = false,
bool lift = false)
{
Debug.Log("FlattenTerrain -- Begining ");
Patch.Debug("FlattenTerrain -- Begining ", LogLevel.Debug,
Patch.DebugPlanetFactory);
if (___tmp_levelChanges == null)
{
___tmp_levelChanges = new Dictionary <int, int>();
}
if (___tmp_ids == null)
{
___tmp_ids = new int[1024];
}
___tmp_levelChanges.Clear();
Array.Clear(___tmp_ids, 0, ___tmp_ids.Length);
bound.extents = new Vector3(bound.extents.x, bound.extents.y + 0.5f, bound.extents.z);
var quaternion1 = rot;
quaternion1.w = -quaternion1.w;
var quaternion2 = Maths.SphericalRotation(pos, 22.5f);
var realRadius = __instance.planet.realRadius;
Patch.Debug("realRadius -- " + realRadius, LogLevel.Debug,
Patch.DebugPlanetFactory);
var areaRadius = bound.extents.magnitude + fade0;
Patch.Debug("areaRadius -- " + areaRadius, LogLevel.Debug,
Patch.DebugPlanetFactory);
var areaRadiusSq = areaRadius * areaRadius;
Patch.Debug("areaRadiusSq -- " + areaRadiusSq, LogLevel.Debug,
Patch.DebugPlanetFactory);
// Def something related to that that mess up everything
//areaRadiusSq *= scaleFactor;
Patch.Debug("Patching areaRadiusSq -- " + areaRadiusSq, LogLevel.Debug,
Patch.DebugPlanetFactory);
var circlePeriphery = (float)(realRadius * 3.14159274101257 /
(__instance.planet.precision * 2.0));
Patch.Debug("circlePeriphery -- " + circlePeriphery, LogLevel.Debug,
Patch.DebugPlanetFactory);
var levelAffected =
Mathf.CeilToInt(
(float)(areaRadius * 1.41400003433228 / circlePeriphery + 0.5));
Patch.Debug("levelAffected -- " + levelAffected, LogLevel.Debug,
Patch.DebugPlanetFactory);
var vector3Array = new Vector3[9] {
pos,
pos + quaternion2 * (new Vector3(0.0f, 0.0f, 1.414f) * areaRadius),
pos + quaternion2 * (new Vector3(0.0f, 0.0f, -1.414f) * areaRadius),
pos + quaternion2 * (new Vector3(1.414f, 0.0f, 0.0f) * areaRadius),
pos + quaternion2 * (new Vector3(-1.414f, 0.0f, 0.0f) * areaRadius),
pos + quaternion2 * (new Vector3(1f, 0.0f, 1f) * areaRadius),
pos + quaternion2 * (new Vector3(-1f, 0.0f, -1f) * areaRadius),
pos + quaternion2 * (new Vector3(1f, 0.0f, -1f) * areaRadius),
pos + quaternion2 * (new Vector3(-1f, 0.0f, 1f) * areaRadius)
};
var stride = __instance.planet.data.stride;
Patch.Debug("stride -- " + stride, LogLevel.Debug,
Patch.DebugPlanetFactory);
var dataLength = __instance.planet.data.dataLength;
Patch.Debug("dataLength -- " + dataLength, LogLevel.Debug,
Patch.DebugPlanetFactory);
var vertices = __instance.planet.data.vertices;
Patch.Debug("vertices -- " + vertices, LogLevel.Debug,
Patch.DebugPlanetFactory);
var heightData = __instance.planet.data.heightData;
Patch.Debug("heightData -- " + heightData, LogLevel.Debug,
Patch.DebugPlanetFactory);
var radiusHeight100 = (short)(__instance.planet.realRadius * 100.0);
Patch.Debug("radiusHeight100 -- " + radiusHeight100, LogLevel.Debug,
Patch.DebugPlanetFactory);
var fRoundToInt = 0;
foreach (var vpos in vector3Array)
{
var posIndex = __instance.planet.data.QueryIndex(vpos);
for (var index1 = -levelAffected; index1 <= levelAffected; ++index1)
{
var strideIndex = posIndex + index1 * stride;
if (strideIndex >= 0 && strideIndex < dataLength)
{
for (var index2 = -levelAffected; index2 <= levelAffected; ++index2)
{
var index3 = strideIndex + index2;
if ((uint)index3 < dataLength &&
(lift || heightData[index3] > radiusHeight100))
{
Vector3 vector3_1;
vector3_1.x = vertices[index3].x * realRadius;
vector3_1.y = vertices[index3].y * realRadius;
vector3_1.z = vertices[index3].z * realRadius;
Vector3 vector3_2;
vector3_2.x = vector3_1.x - pos.x;
vector3_2.y = vector3_1.y - pos.y;
vector3_2.z = vector3_1.z - pos.z;
if (vector3_2.x * (double)vector3_2.x +
vector3_2.y * (double)vector3_2.y +
vector3_2.z * (double)vector3_2.z < areaRadiusSq &&
!___tmp_levelChanges.ContainsKey(index3))
{
Patch.Debug("vector3_2 less than areaRadiusSq -- " + vector3_2,
LogLevel.Debug,
Patch.DebugPlanetFactoryDeep);
vector3_1 = quaternion1 * (vector3_1 - pos);
Patch.Debug("vector3_1 less than areaRadiusSq -- " + vector3_1,
LogLevel.Debug,
Patch.DebugPlanetFactoryDeep);
if (bound.Contains(vector3_1))
{
___tmp_levelChanges[index3] = 3;
}
else
{
var boundDistance = Vector3.Distance(bound.ClosestPoint(vector3_1),
vector3_1);
var boundDistanceFade =
(int)((fade0 - (double)boundDistance) /
(fade0 - (double)fade1) * 3.0 + 0.5);
if (boundDistanceFade < 0)
{
boundDistanceFade = 0;
}
else if (boundDistanceFade > 3)
{
boundDistanceFade = 3;
}
var modLevel = __instance.planet.data.GetModLevel(index3);
Patch.Debug("modLevel -- " + modLevel, LogLevel.Debug,
Patch.DebugPlanetFactoryDeep);
var boundDiff = boundDistanceFade - modLevel;
Patch.Debug("boundDiff -- " + boundDiff, LogLevel.Debug,
Patch.DebugPlanetFactoryDeep);
if (boundDistanceFade >= modLevel && boundDiff != 0)
{
___tmp_levelChanges[index3] = boundDistanceFade;
var currentHeightData = heightData[index3] * 0.01f;
Patch.Debug("currentHeightData -- " + currentHeightData,
LogLevel.Debug,
Patch.DebugPlanetFactoryDeep);
var currentHeightDataOnRadius =
realRadius - currentHeightData;
Patch.Debug(
"currentHeightDataOnRadius -- " + currentHeightDataOnRadius,
LogLevel.Debug,
Patch.DebugPlanetFactoryDeep);
//anomaly here
//currentHeightDataOnRadius *= scaleFactor;
Patch.Debug(
"Patching currentHeightDataOnRadius -- " +
currentHeightDataOnRadius, LogLevel.Debug,
Patch.DebugPlanetFactoryDeep);
var f = (float)(100.0 * boundDiff *
currentHeightDataOnRadius *
0.333333313465118);
Patch.Debug("f -- " + f, LogLevel.Debug,
Patch.DebugPlanetFactoryDeep);
fRoundToInt += -Mathf.FloorToInt(f);
}
}
}
}
}
}
}
}
var levelized = __instance.planet.levelized;
var plane = Mathf.RoundToInt(
(float)((pos.magnitude - (double)__instance.planet.realRadius) /
1.33333325386047));
Patch.Debug("plane -- " + plane, LogLevel.Debug,
Patch.DebugPlanetFactory);
var num13 = plane * 133 + radiusHeight100 - 60;
Patch.Debug("num13 -- " + num13, LogLevel.Debug,
Patch.DebugPlanetFactory);
foreach (var tmpLevelChange in ___tmp_levelChanges)
{
if (tmpLevelChange.Value > 0)
{
if (levelized)
{
if (heightData[tmpLevelChange.Key] >= num13)
{
if (__instance.planet.data.GetModLevel(tmpLevelChange.Key) < 3)
{
Patch.Debug("SetModPlane -- plane" + plane, LogLevel.Debug,
Patch.DebugPlanetFactoryDeep);
Patch.Debug(
"SetModPlane -- heightData[tmpLevelChange.Key]" +
heightData[tmpLevelChange.Key], LogLevel.Debug,
Patch.DebugPlanetFactoryDeep);
__instance.planet.data.SetModPlane(tmpLevelChange.Key, plane);
}
Patch.Debug(
"If AddHeightMapModLevel -- tmpLevelChange.Value" + tmpLevelChange.Value,
LogLevel.Debug,
Patch.DebugPlanetFactoryDeep);
Patch.Debug(
"If AddHeightMapModLevel -- heightData[tmpLevelChange.Key]" +
heightData[tmpLevelChange.Key], LogLevel.Debug,
Patch.DebugPlanetFactoryDeep);
__instance.planet.AddHeightMapModLevel(tmpLevelChange.Key, tmpLevelChange.Value);
}
}
else
{
Patch.Debug(
"Else AddHeightMapModLevel -- tmpLevelChange.Value" + tmpLevelChange.Value,
LogLevel.Debug,
Patch.DebugPlanetFactoryDeep);
Patch.Debug(
"Else AddHeightMapModLevel -- heightData[tmpLevelChange.Key]" +
heightData[tmpLevelChange.Key], LogLevel.Debug,
Patch.DebugPlanetFactoryDeep);
__instance.planet.AddHeightMapModLevel(tmpLevelChange.Key, tmpLevelChange.Value);
}
}
}
var flag = __instance.planet.UpdateDirtyMeshes();
if (GameMain.isRunning && flag)
{
__instance.RenderLocalPlanetHeightmap();
}
bound.extents += new Vector3(1.5f, 1.5f, 1.5f);
var nearColliderLogic = __instance.planet.physics.nearColliderLogic;
var vegetablesInAreaNonAlloc =
nearColliderLogic.GetVegetablesInAreaNonAlloc(pos, areaRadius, ___tmp_ids);
for (var index = 0; index < vegetablesInAreaNonAlloc; ++index)
{
var tmpId = ___tmp_ids[index];
var pos1 = __instance.vegePool[tmpId].pos;
var point = quaternion1 * (pos1 - pos);
if (bound.Contains(point))
{
__instance.RemoveVegeWithComponents(tmpId);
}
else
{
var num6 = __instance.planet.data.QueryModifiedHeight(__instance.vegePool[tmpId].pos);
Patch.Debug(
"num6 -- __instance.planet.data.QueryModifiedHeight(__instance.vegePool[tmpId].pos) - 0.03f + heightData[tmpLevelChange.Key]" +
num6, LogLevel.Debug,
Patch.DebugPlanetFactory);
__instance.vegePool[tmpId].pos = __instance.vegePool[tmpId].pos.normalized * num6;
Patch.Debug("__instance.vegePool[tmpId].pos -- _" + __instance.vegePool[tmpId].pos,
LogLevel.Debug,
Patch.DebugPlanetFactory);
GameMain.gpuiManager.AlterModel(__instance.vegePool[tmpId].modelIndex,
__instance.vegePool[tmpId].modelId, tmpId, __instance.vegePool[tmpId].pos,
__instance.vegePool[tmpId].rot,
false);
}
}
var veinsInAreaNonAlloc = nearColliderLogic.GetVeinsInAreaNonAlloc(pos, areaRadius, ___tmp_ids);
for (var index = 0; index < veinsInAreaNonAlloc; ++index)
{
var tmpId = ___tmp_ids[index];
var pos1 = __instance.veinPool[tmpId].pos;
if (removeVein && bound.Contains(pos1))
{
__instance.RemoveVeinWithComponents(tmpId);
}
else if (pos1.magnitude > (double)__instance.planet.realRadius)
{
var num6 = __instance.planet.data.QueryModifiedHeight(pos1) - 0.13f;
__instance.veinPool[tmpId].pos = pos1.normalized * num6;
GameMain.gpuiManager.AlterModel(__instance.veinPool[tmpId].modelIndex,
__instance.veinPool[tmpId].modelId, tmpId, __instance.veinPool[tmpId].pos, false);
}
}
___tmp_levelChanges.Clear();
Array.Clear(___tmp_ids, 0, ___tmp_ids.Length);
GameMain.gpuiManager.SyncAllGPUBuffer();
__result = fRoundToInt;
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;
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);
}
