public static Sector Make(GameObject body, OWRigidbody rigidbody, IPlanetConfig config)
{
GameObject sectorGO = new GameObject();
sectorGO.SetActive(false);
sectorGO.transform.parent = body.transform;
SphereShape SS = sectorGO.AddComponent <SphereShape>();
SS.SetCollisionMode(Shape.CollisionMode.Volume);
SS.SetLayer(Shape.Layer.Sector);
SS.layerMask = -1;
SS.pointChecksOnly = true;
SS.radius = config.AtmoEndSize + 10;
SS.center = Vector3.zero;
/*OWTriggerVolume trigVol = */ sectorGO.AddComponent <OWTriggerVolume>();
Sector S = sectorGO.AddComponent <Sector>();
S.SetValue("_name", Sector.Name.Unnamed);
S.SetValue("__attachedOWRigidbody", rigidbody);
S.SetValue("_subsectors", new List <Sector>());
sectorGO.SetActive(true);
Logger.Log("Finished building sector", Logger.LogType.Log);
return(S);
}
public static void Make(GameObject body, Sector sector, IPlanetConfig config)
{
GameObject waterGO = new GameObject();
waterGO.SetActive(false);
waterGO.layer = 15;
waterGO.transform.parent = body.transform;
waterGO.transform.localScale = new Vector3(config.WaterSize / 2, config.WaterSize / 2, config.WaterSize / 2);
waterGO.DestroyAllComponents <SphereCollider>();
TessellatedSphereRenderer TSR = waterGO.AddComponent <TessellatedSphereRenderer>();
TSR.tessellationMeshGroup = GameObject.Find("Ocean_GD").GetComponent <TessellatedSphereRenderer>().tessellationMeshGroup;
TSR.sharedMaterials = GameObject.Find("Ocean_GD").GetComponent <TessellatedSphereRenderer>().sharedMaterials;
TSR.maxLOD = 7;
TSR.LODBias = 2;
TSR.LODRadius = 2f;
TessSphereSectorToggle TSST = waterGO.AddComponent <TessSphereSectorToggle>();
TSST.SetValue("_sector", sector);
OceanEffectController OEC = waterGO.AddComponent <OceanEffectController>();
OEC.SetValue("_sector", sector);
OEC.SetValue("_ocean", TSR);
// Because assetbundles were a bitch...
/*
* GameObject fog1 = new GameObject();
* fog1.transform.parent = waterBase.transform;
* fog1.transform.localScale = new Vector3(1, 1, 1);
* fog1.AddComponent<MeshFilter>().mesh = GameObject.Find("CloudsTopLayer_GD").GetComponent<MeshFilter>().mesh;
* fog1.AddComponent<MeshRenderer>().material = new Material(Shader.Find("Sprites/Default"));
* fog1.GetComponent<MeshRenderer>().material.color = new Color32(0, 75, 50, 5);
*
* GameObject fog2 = new GameObject();
* fog2.transform.parent = waterBase.transform;
* fog2.transform.localScale = new Vector3(1.001f, 1.001f, 1.001f);
* fog2.AddComponent<MeshFilter>().mesh = GameObject.Find("CloudsTopLayer_GD").GetComponent<MeshFilter>().mesh;
* fog2.AddComponent<MeshRenderer>().material = new Material(Shader.Find("Sprites/Default"));
* fog2.GetComponent<MeshRenderer>().material.color = new Color32(0, 75, 50, 5);
*
* GameObject fog3 = new GameObject();
* fog3.transform.parent = fog2.transform;
* fog3.transform.localScale = new Vector3(1.001f, 1.001f, 1.001f);
* fog3.AddComponent<MeshFilter>().mesh = GameObject.Find("CloudsTopLayer_GD").GetComponent<MeshFilter>().mesh;
* fog3.AddComponent<MeshRenderer>().material = new Material(Shader.Find("Sprites/Default"));
* fog3.GetComponent<MeshRenderer>().material.color = new Color32(0, 75, 50, 5);
*/
waterGO.SetActive(true);
Logger.Log("Finished building water", Logger.LogType.Log);
}
public static MTuple Make(GameObject body, AstroObject primaryBody, IPlanetConfig config)
{
Rigidbody RB = body.AddComponent <Rigidbody>();
RB.mass = 10000;
RB.drag = 0f;
RB.angularDrag = 0f;
RB.useGravity = false;
RB.isKinematic = true;
RB.interpolation = RigidbodyInterpolation.None;
RB.collisionDetectionMode = CollisionDetectionMode.Discrete;
OWRigidbody OWRB = body.AddComponent <OWRigidbody>();
OWRB.SetValue("_kinematicSimulation", true);
OWRB.SetValue("_autoGenerateCenterOfMass", true);
OWRB.SetIsTargetable(true);
OWRB.SetValue("_maintainOriginalCenterOfMass", true);
OWRB.SetValue("_rigidbody", RB);
InitialMotion IM = body.AddComponent <InitialMotion>();
IM.SetPrimaryBody(primaryBody.GetAttachedOWRigidbody());
IM.SetValue("_orbitAngle", config.OrbitAngle);
IM.SetValue("_isGlobalAxis", false);
IM.SetValue("_initAngularSpeed", 0.02f);
IM.SetValue("_initLinearSpeed", 0f);
DetectorBuilder.Make(body, primaryBody);
AstroObject AO = body.AddComponent <AstroObject>();
AO.SetValue("_type", AstroObject.Type.Planet);
AO.SetValue("_name", AstroObject.Name.None);
AO.SetValue("_primaryBody", primaryBody);
if (config.HasGravity)
{
GravityVolume GV = GravityBuilder.Make(body, config.SurfaceAcceleration, config.GroundSize, config.GroundSize);
AO.SetValue("_gravityVolume", GV);
}
if (config.IsTidallyLocked)
{
RotateToAstroObject RTAO = body.AddComponent <RotateToAstroObject>();
RTAO.SetValue("_astroObjectLock", primaryBody);
}
Logger.Log("Finished building base", Logger.LogType.Log);
return(new MTuple(AO, OWRB));
}
public static void Make(GameObject body, IPlanetConfig config)
{
MapMarker MM = body.AddComponent <MapMarker>();
MM.SetValue("_labelID", (UITextType)Utility.AddToUITable.Add(config.Name));
if (config.IsMoon)
{
MM.SetValue("_markerType", MM.GetType().GetNestedType("MarkerType", BindingFlags.NonPublic).GetField("Moon").GetValue(MM));
}
else
{
MM.SetValue("_markerType", MM.GetType().GetNestedType("MarkerType", BindingFlags.NonPublic).GetField("Planet").GetValue(MM));
}
Logger.Log("Finished building map marker", Logger.LogType.Log);
}
public static GameObject GenerateBody(IPlanetConfig config)
{
Logger.Log("Begin generation sequence of [" + config.Name + "] ...", Logger.LogType.Log);
var body = new GameObject(config.Name);
body.SetActive(false);
GeometryBuilder.Make(body, config.GroundSize);
var outputTuple = BaseBuilder.Make(body, Locator.GetAstroObject(AstroObject.StringIDToAstroObjectName(config.PrimaryBody)), config);
var owRigidbody = (OWRigidbody)outputTuple.Items[1];
RFVolumeBuilder.Make(body, owRigidbody, config);
if (config.HasMapMarker)
{
MarkerBuilder.Make(body, config);
}
var sector = MakeSector.Make(body, owRigidbody, config);
if (config.HasClouds)
{
CloudsBuilder.Make(body, sector, config);
SunOverrideBuilder.Make(body, sector, config);
}
AirBuilder.Make(body, config.TopCloudSize / 2, config.HasRain);
if (config.HasWater)
{
WaterBuilder.Make(body, sector, config);
}
EffectsBuilder.Make(body, sector);
VolumesBuilder.Make(body, config);
AmbientLightBuilder.Make(body, sector, config);
AtmosphereBuilder.Make(body, config);
Logger.Log("Generation of [" + config.Name + "] completed.", Logger.LogType.Log);
return(body);
}
public static void Make(GameObject body, Sector sector, IPlanetConfig config)
{
GameObject overrideGO = new GameObject();
overrideGO.SetActive(false);
overrideGO.transform.parent = body.transform;
GiantsDeepSunOverrideVolume GDSOV = overrideGO.AddComponent <GiantsDeepSunOverrideVolume>();
GDSOV.SetValue("_sector", sector);
GDSOV.SetValue("_cloudsOuterRadius", config.TopCloudSize / 2);
GDSOV.SetValue("_cloudsInnerRadius", config.BottomCloudSize / 2);
GDSOV.SetValue("_waterOuterRadius", config.WaterSize / 2);
GDSOV.SetValue("_waterInnerRadius", 402.5f);
overrideGO.SetActive(true);
Logger.Log("Finished building sun override.", Logger.LogType.Log);
}
public static void CreateBody(IPlanetConfig config)
{
var planet = Main.GenerateBody(config);
planet.transform.parent = Locator.GetRootTransform();
planet.transform.position = Locator.GetAstroObject(AstroObject.StringIDToAstroObjectName(config.PrimaryBody)).gameObject.transform.position + config.Position.ToVector3();
planet.SetActive(true);
planet.GetComponent <OWRigidbody>().SetVelocity(Locator.GetCenterOfTheUniverse().GetOffsetVelocity());
var primary = Locator.GetAstroObject(AstroObject.StringIDToAstroObjectName(config.PrimaryBody)).GetAttachedOWRigidbody();
var initialMotion = primary.GetComponent <InitialMotion>();
if (initialMotion != null)
{
planet.GetComponent <OWRigidbody>().AddVelocityChange(-initialMotion.GetInitVelocity());
planet.GetComponent <OWRigidbody>().AddVelocityChange(primary.GetVelocity());
}
}
public static void Make(GameObject body, IPlanetConfig config)
{
GameObject volumesGO = new GameObject();
volumesGO.SetActive(false);
volumesGO.transform.parent = body.transform;
GameObject rulesetGO = new GameObject();
rulesetGO.SetActive(false);
rulesetGO.transform.parent = volumesGO.transform;
SphereShape SS = rulesetGO.AddComponent <SphereShape>();
SS.SetCollisionMode(Shape.CollisionMode.Volume);
SS.SetLayer(Shape.Layer.Sector);
SS.layerMask = -1;
SS.pointChecksOnly = true;
SS.radius = config.TopCloudSize;
/*OWTriggerVolume trigvol = */ rulesetGO.AddComponent <OWTriggerVolume>();
PlanetoidRuleset PR = rulesetGO.AddComponent <PlanetoidRuleset>();
PR.SetValue("_altitudeFloor", config.GroundSize);
PR.SetValue("_altitudeCeiling", config.TopCloudSize);
EffectRuleset ER = rulesetGO.AddComponent <EffectRuleset>();
ER.SetValue("_type", EffectRuleset.BubbleType.Underwater);
ER.SetValue("_material", GameObject.Find("RulesetVolumes_GD").GetComponent <RulesetVolume>().GetValue <Material>("_material"));
ER.SetValue("_cloudMaterial", GameObject.Find("RulesetVolumes_GD").GetComponent <RulesetVolume>().GetValue <Material>("_cloudMaterial"));
rulesetGO.SetActive(true);
volumesGO.SetActive(true);
Logger.Log("Finished building volumes", Logger.LogType.Log);
}
public static void Make(GameObject body, OWRigidbody rigidbody, IPlanetConfig config)
{
GameObject rfGO = new GameObject("RFVolume");
rfGO.transform.parent = body.transform;
rfGO.layer = 19;
rfGO.SetActive(false);
SphereCollider SC = rfGO.AddComponent <SphereCollider>();
SC.isTrigger = true;
SC.radius = config.AtmoEndSize * 2;
ReferenceFrameVolume RFV = rfGO.AddComponent <ReferenceFrameVolume>();
ReferenceFrame RV = new ReferenceFrame(rigidbody);
RV.SetValue("_minSuitTargetDistance", 300);
RV.SetValue("_maxTargetDistance", 0);
RV.SetValue("_autopilotArrivalDistance", 1000);
RV.SetValue("_autoAlignmentDistance", 1000);
//Utility.AddDebugShape.AddSphere(rfGO, 1000, new Color32(0, 255, 0, 128));
RV.SetValue("_hideLandingModePrompt", false);
RV.SetValue("_matchAngularVelocity", true);
RV.SetValue("_minMatchAngularVelocityDistance", 70);
RV.SetValue("_maxMatchAngularVelocityDistance", 400);
RV.SetValue("_bracketsRadius", 300);
RFV.SetValue("_referenceFrame", RV);
RFV.SetValue("_minColliderRadius", 300);
RFV.SetValue("_maxColliderRadius", config.AtmoEndSize * 2);
RFV.SetValue("_isPrimaryVolume", true);
RFV.SetValue("_isCloseRangeVolume", false);
rfGO.SetActive(true);
Logger.Log("Finished building rfvolume", Logger.LogType.Log);
}
public static void Make(GameObject body, Sector sector, IPlanetConfig config)
{
GameObject lightGO = new GameObject();
lightGO.SetActive(false);
lightGO.transform.parent = body.transform;
Light L = lightGO.AddComponent <Light>();
L.type = LightType.Point;
L.range = config.AtmoEndSize + 10;
L.color = config.LightTint.ToColor32();
L.intensity = 0.8f;
L.shadows = LightShadows.None;
L.cookie = GameObject.Find("AmbientLight_GD").GetComponent <Light>().cookie;
SectorLightsCullGroup SLCG = lightGO.AddComponent <SectorLightsCullGroup>();
SLCG.SetSector(sector);
lightGO.SetActive(true);
Logger.Log("Finished building ambient light", Logger.LogType.Log);
}
public static void Make(GameObject body, Sector sector, IPlanetConfig config)
{
GameObject cloudsMainGO = new GameObject();
cloudsMainGO.SetActive(false);
cloudsMainGO.transform.parent = body.transform;
GameObject cloudsTopGO = new GameObject();
cloudsTopGO.SetActive(false);
cloudsTopGO.transform.parent = cloudsMainGO.transform;
cloudsTopGO.transform.localScale = new Vector3(config.TopCloudSize / 2, config.TopCloudSize / 2, config.TopCloudSize / 2);
//AddDebugShape.AddSphere(cloudsTopGO, config.TopCloudSize/2, new Color32(255, 0, 255, 128));
MeshFilter topMF = cloudsTopGO.AddComponent <MeshFilter>();
topMF.mesh = GameObject.Find("CloudsTopLayer_GD").GetComponent <MeshFilter>().mesh;
var tempArray = new Material[2];
MeshRenderer topMR = cloudsTopGO.AddComponent <MeshRenderer>();
for (int i = 0; i < 2; i++)
{
tempArray[i] = GameObject.Instantiate(GameObject.Find("CloudsTopLayer_GD").GetComponent <MeshRenderer>().sharedMaterials[i]);
}
topMR.sharedMaterials = tempArray;
foreach (var material in topMR.sharedMaterials)
{
material.SetColor("_Color", config.TopCloudTint.ToColor32());
var image = ImageUtilities.LoadImage(Main.helper.Manifest.ModFolderPath + "clouds_top.png");
image = ImageUtilities.TintImage(image, config.TopCloudTint.ToColor32());
material.SetTexture("_MainTex", image);
image = ImageUtilities.LoadImage(Main.helper.Manifest.ModFolderPath + "clouds_top_ramp.png");
image = ImageUtilities.TintImage(image, config.TopCloudTint.ToColor32());
material.SetTexture("_RampTex", image);
image = ImageUtilities.LoadImage(Main.helper.Manifest.ModFolderPath + "clouds_cap.png");
image = ImageUtilities.TintImage(image, config.TopCloudTint.ToColor32());
material.SetTexture("_CapTex", image);
}
RotateTransform topRT = cloudsTopGO.AddComponent <RotateTransform>();
topRT.SetValue("_localAxis", Vector3.up);
topRT.SetValue("degreesPerSecond", 10);
topRT.SetValue("randomizeRotationRate", false);
/*
* SectorCullGroup scg = cloudsTop.AddComponent<SectorCullGroup>();
* scg.SetValue("_sector", MainClass.SECTOR);
* scg.SetValue("_occlusionCulling", true);
* scg.SetValue("_dynamicCullingBounds", false);
* scg.SetValue("_particleSystemSuspendMode", CullGroup.ParticleSystemSuspendMode.Pause);
* scg.SetValue("_waitForStreaming", false);
*/
GameObject cloudsBottomGO = new GameObject();
cloudsBottomGO.SetActive(false);
cloudsBottomGO.transform.parent = cloudsMainGO.transform;
cloudsBottomGO.transform.localScale = new Vector3(config.BottomCloudSize / 2, config.BottomCloudSize / 2, config.BottomCloudSize / 2);
TessellatedSphereRenderer bottomTSR = cloudsBottomGO.AddComponent <TessellatedSphereRenderer>();
bottomTSR.tessellationMeshGroup = GameObject.Find("CloudsBottomLayer_GD").GetComponent <TessellatedSphereRenderer>().tessellationMeshGroup;
bottomTSR.sharedMaterials = GameObject.Find("CloudsBottomLayer_GD").GetComponent <TessellatedSphereRenderer>().sharedMaterials;
bottomTSR.maxLOD = 6;
bottomTSR.LODBias = 0;
bottomTSR.LODRadius = 1f;
foreach (Material material in bottomTSR.sharedMaterials)
{
material.SetColor("_Color", config.BottomCloudTint.ToColor32());
}
TessSphereSectorToggle bottomTSST = cloudsBottomGO.AddComponent <TessSphereSectorToggle>();
bottomTSST.SetValue("_sector", sector);
GameObject cloudsFluidGO = new GameObject();
cloudsFluidGO.SetActive(false);
cloudsFluidGO.layer = 17;
cloudsFluidGO.transform.parent = cloudsMainGO.transform;
SphereCollider fluidSC = cloudsFluidGO.AddComponent <SphereCollider>();
fluidSC.isTrigger = true;
fluidSC.radius = config.TopCloudSize / 2;
OWShellCollider fluidOWSC = cloudsFluidGO.AddComponent <OWShellCollider>();
fluidOWSC.SetValue("_innerRadius", config.BottomCloudSize);
CloudLayerFluidVolume fluidCLFV = cloudsFluidGO.AddComponent <CloudLayerFluidVolume>();
fluidCLFV.SetValue("_layer", 5);
fluidCLFV.SetValue("_priority", 1);
fluidCLFV.SetValue("_density", 1.2f);
fluidCLFV.SetValue("_fluidType", FluidVolume.Type.CLOUD);
fluidCLFV.SetValue("_allowShipAutoroll", true);
fluidCLFV.SetValue("_disableOnStart", false);
cloudsTopGO.SetActive(true);
cloudsBottomGO.SetActive(true);
cloudsFluidGO.SetActive(true);
cloudsMainGO.SetActive(true);
Logger.Log("Finished building clouds.", Logger.LogType.Log);
}
public MarshmallowBody(IPlanetConfig config)
{
Config = config;
}
public static void Make(GameObject body, IPlanetConfig config)
{
GameObject atmoGO = new GameObject();
atmoGO.SetActive(false);
atmoGO.name = "Atmosphere";
atmoGO.transform.parent = body.transform;
if (config.HasFog)
{
GameObject fogGO = new GameObject();
fogGO.SetActive(false);
fogGO.name = "FogSphere";
fogGO.transform.parent = atmoGO.transform;
fogGO.transform.localScale = new Vector3((config.TopCloudSize / 2) + 10, (config.TopCloudSize / 2) + 10, (config.TopCloudSize / 2) + 10);
MeshFilter MF = fogGO.AddComponent <MeshFilter>();
MF.mesh = GameObject.Find("Atmosphere_GD/FogSphere").GetComponent <MeshFilter>().mesh;
MeshRenderer MR = fogGO.AddComponent <MeshRenderer>();
MR.materials = GameObject.Find("Atmosphere_GD/FogSphere").GetComponent <MeshRenderer>().materials;
MR.allowOcclusionWhenDynamic = true;
PlanetaryFogController PFC = fogGO.AddComponent <PlanetaryFogController>();
PFC.fogLookupTexture = GameObject.Find("Atmosphere_GD/FogSphere").GetComponent <PlanetaryFogController>().fogLookupTexture;
PFC.fogRadius = (config.WaterSize / 2) + 50;
PFC.fogDensity = config.FogDensity;
PFC.fogExponent = 1f;
PFC.fogColorRampTexture = GameObject.Find("Atmosphere_GD/FogSphere").GetComponent <PlanetaryFogController>().fogColorRampTexture;
PFC.fogColorRampIntensity = 1f;
PFC.fogTint = config.FogTint.ToColor32();
fogGO.SetActive(true);
}
//Logger.Log("Re-add LOD atmosphere!", Logger.LogType.Todo);
GameObject atmo = GameObject.Instantiate(GameObject.Find("Atmosphere_TH/AtmoSphere"));
atmo.transform.parent = atmoGO.transform;
atmo.transform.localPosition = Vector3.zero;
atmo.transform.localScale = new Vector3(config.TopCloudSize, config.TopCloudSize, config.TopCloudSize);
/*
* GameObject lod1 = new GameObject();
* lod1.transform.parent = atmo.transform;
* lod1.transform.localPosition = Vector3.zero;
* MeshFilter f1 = lod1.AddComponent<MeshFilter>();
* f1.mesh = GameObject.Find("Atmosphere_LOD1").GetComponent<MeshFilter>().mesh;
* MeshRenderer r1 = lod1.AddComponent<MeshRenderer>();
* r1.material = mat;
*
* GameObject lod2 = new GameObject();
* lod2.transform.parent = atmo.transform;
* lod2.transform.localPosition = Vector3.zero;
* MeshFilter f2 = lod2.AddComponent<MeshFilter>();
* f2.mesh = GameObject.Find("Atmosphere_LOD2").GetComponent<MeshFilter>().mesh;
* MeshRenderer r2 = lod2.AddComponent<MeshRenderer>();
* r2.material = mat;
*
* GameObject lod3 = new GameObject();
* lod3.transform.parent = atmo.transform;
* lod3.transform.localPosition = Vector3.zero;
* MeshFilter f3 = lod3.AddComponent<MeshFilter>();
* f3.mesh = GameObject.Find("Atmosphere_LOD3").GetComponent<MeshFilter>().mesh;
* MeshRenderer r3 = lod3.AddComponent<MeshRenderer>();
* r3.material = mat;
*/
// THIS F*****G THING. do NOT ask why i have done this. IT WORKS.
// This creates an LOD group in the worst way possible. i am so sorry.
/*
* LODGroup lodg = atmo.AddComponent<LODGroup>();
*
* LOD[] lodlist = new LOD[4];
* Renderer[] t0 = { r0 };
* Renderer[] t1 = { r1 };
* Renderer[] t2 = { r2 };
* Renderer[] t3 = { r3 };
* LOD one = new LOD(1, t0);
* LOD two = new LOD(0.7f, t1);
* LOD three = new LOD(0.27f, t2);
* LOD four = new LOD(0.08f, t3);
* lodlist[0] = one;
* lodlist[1] = two;
* lodlist[2] = three;
* lodlist[3] = four;
*
* lodg.SetLODs(lodlist);
* lodg.fadeMode = LODFadeMode.None;
*/
atmo.SetActive(true);
atmoGO.SetActive(true);
Logger.Log("Finished building atmosphere.", Logger.LogType.Log);
}