public static GravityVolume Make(GameObject body, float surfaceAccel, float upperSurface, float lowerSurface)
{
GameObject gravityGO = new GameObject();
gravityGO.transform.parent = body.transform;
gravityGO.name = "GravityWell";
gravityGO.layer = 17;
gravityGO.SetActive(false);
GravityVolume GV = gravityGO.AddComponent<GravityVolume>();
GV.SetValue("_cutoffAcceleration", 0.1f);
GV.SetValue("_falloffType", GV.GetType().GetNestedType("FalloffType", BindingFlags.NonPublic).GetField("linear").GetValue(GV));
GV.SetValue("_alignmentRadius", 1.5f * upperSurface);
//Utility.AddDebugShape.AddSphere(gravityGO, 1.5f * upperSurface, new Color32(255, 0, 0, 128));
GV.SetValue("_upperSurfaceRadius", upperSurface);
GV.SetValue("_lowerSurfaceRadius", lowerSurface);
GV.SetValue("_layer", 3);
GV.SetValue("_priority", 0);
GV.SetValue("_alignmentPriority", 0);
GV.SetValue("_surfaceAcceleration", surfaceAccel);
GV.SetValue("_inheritable", false);
GV.SetValue("_isPlanetGravityVolume", true);
GV.SetValue("_cutoffRadius", 55f);
SphereCollider SC = gravityGO.AddComponent<SphereCollider>();
SC.isTrigger = true;
SC.radius = 4 * upperSurface;
OWCollider OWC = gravityGO.AddComponent<OWCollider>();
OWC.SetLODActivationMask(DynamicOccupant.Player);
gravityGO.SetActive(true);
Logger.Log("Finished building gravity", Logger.LogType.Log);
return GV;
}
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 void Make(GameObject body, float airScale, bool isRaining)
{
GameObject airGO = new GameObject();
airGO.SetActive(false);
airGO.layer = 17;
airGO.transform.parent = body.transform;
SphereCollider SC = airGO.AddComponent <SphereCollider>();
SC.isTrigger = true;
SC.radius = airScale;
SimpleFluidVolume SFV = airGO.AddComponent <SimpleFluidVolume>();
SFV.SetValue("_layer", 5);
SFV.SetValue("_priority", 1);
SFV.SetValue("_density", 1.2f);
SFV.SetValue("_fluidType", FluidVolume.Type.AIR);
SFV.SetValue("_allowShipAutoroll", true);
SFV.SetValue("_disableOnStart", false);
if (isRaining)
{
VisorRainEffectVolume VREF = airGO.AddComponent <VisorRainEffectVolume>();
VREF.SetValue("_rainDirection", VisorRainEffectVolume.RainDirection.Radial);
VREF.SetValue("_layer", 0);
VREF.SetValue("_priority", 0);
AudioSource AS = airGO.AddComponent <AudioSource>();
AS.mute = false;
AS.bypassEffects = false;
AS.bypassListenerEffects = false;
AS.bypassReverbZones = false;
AS.playOnAwake = false;
AS.loop = true;
AS.priority = 128;
AS.volume = 0.35f;
AS.pitch = 1f;
AS.panStereo = 0f;
AS.spatialBlend = 0f;
AS.reverbZoneMix = 1f;
OWAudioSource OWAS = airGO.AddComponent <OWAudioSource>();
OWAS.SetAudioLibraryClip(AudioType.GD_RainAmbient_LP);
OWAS.SetClipSelectionType(OWAudioSource.ClipSelectionOnPlay.RANDOM);
OWAS.SetTrack(OWAudioMixer.TrackName.Environment);
/*AudioVolume av = */ airGO.AddComponent <AudioVolume>();
}
airGO.SetActive(true);
Logger.Log("Finished building air.", Logger.LogType.Log);
}
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 void Make(GameObject body, float groundScale)
{
GameObject groundGO = GameObject.CreatePrimitive(PrimitiveType.Sphere);
groundGO.transform.parent = body.transform;
groundGO.transform.localScale = new Vector3(groundScale / 2, groundScale / 2, groundScale / 2);
groundGO.GetComponent <MeshFilter>().mesh = GameObject.Find("CloudsTopLayer_GD").GetComponent <MeshFilter>().mesh;
groundGO.GetComponent <SphereCollider>().radius = 1f;
groundGO.SetActive(true);
/*
* GameObject sphere = new GameObject();
* Debug.LogError("1");
* sphere.SetActive(false);
* Debug.LogError("2");
* MeshFilter mf = sphere.AddComponent<MeshFilter>();
* Debug.LogError("3");
* mf.mesh = mesh;
* Debug.LogError("4");
* MeshRenderer mr = sphere.AddComponent<MeshRenderer>();
* Debug.LogError("5");
* mr.material = new Material(Shader.Find("Standard"));
* Debug.LogError("6");
* sphere.transform.parent = body.transform;
* Debug.LogError("7");
* sphere.transform.localScale = new Vector3(groundScale / 2, groundScale / 2, groundScale / 2);
* Debug.LogError("8");
* sphere.SetActive(true);
* Debug.LogError("9");
*/
/*
* var geo = MainClass.assetBundle.LoadAsset<GameObject>("PLANET");
* GameObject temp = GameObject.CreatePrimitive(PrimitiveType.Sphere);
* geo.GetComponent<Renderer>().material = temp.GetComponent<Renderer>().material;
* GameObject.Destroy(temp);
* geo.transform.parent = body.transform;
* geo.transform.localScale = new Vector3(1,1,1);
* geo.transform.localPosition = new Vector3(0, 0, 0);
* Debug.LogError(geo.name);
* Debug.LogError(geo.GetComponent<MeshFilter>().mesh.name);
* Debug.LogError(geo.transform.parent.name);
* geo.SetActive(true);
*
*/
Logger.Log("Finished building geometry", Logger.LogType.Log);
}
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 Make(GameObject body, AstroObject primaryBody)
{
GameObject detectorGO = new GameObject();
detectorGO.SetActive(false);
detectorGO.name = "FieldDetector";
detectorGO.transform.parent = body.transform;
detectorGO.layer = 20;
ConstantForceDetector CFD = detectorGO.AddComponent <ConstantForceDetector>();
ForceVolume[] temp = new ForceVolume[1];
temp[0] = primaryBody.GetAttachedOWRigidbody().GetAttachedGravityVolume();
CFD.SetValue("_detectableFields", temp);
CFD.SetValue("_inheritElement0", true);
detectorGO.SetActive(true);
Logger.Log("Finished building detector", Logger.LogType.Log);
}
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)
{
GameObject effectsGO = new GameObject();
effectsGO.SetActive(false);
effectsGO.transform.parent = body.transform;
SectorCullGroup SCG = effectsGO.AddComponent <SectorCullGroup>();
SCG.SetValue("_sector", sector);
SCG.SetValue("_particleSystemSuspendMode", CullGroup.ParticleSystemSuspendMode.Stop);
SCG.SetValue("_occlusionCulling", false);
SCG.SetValue("_dynamicCullingBounds", false);
SCG.SetValue("_waitForStreaming", false);
var rainGO = GameObject.Instantiate(GameObject.Find("Effects_GD_Rain"));
rainGO.transform.parent = effectsGO.transform;
rainGO.transform.localPosition = Vector3.zero;
effectsGO.SetActive(true);
rainGO.SetActive(true);
Logger.Log("Finished building effects", Logger.LogType.Log);
}
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);
}
