internal SCANanomaly(string s, double lon, double lat, PQSMod m)
{
name = s;
longitude = lon;
latitude = lat;
known = false;
mod = m;
}
/// <summary>
/// Changes the parameters of the PQSMod
/// </summary>
Boolean IPQSModTweaker.Tweak(CelestialBody body, PQSMod mod)
{
if (mod is T)
{
return(Tweak(body, (T)mod));
}
return(false);
}
internal SCANanomaly(string s, double lon, double lat, PQSMod m)
{
name = s;
longitude = lon;
latitude = lat;
known = false;
mod = m;
}
// Creates the a PQSMod of type T
void ICreatable <PQSMod> .Create(PQSMod value)
{
try
{
Create((T)value, PqsVersion);
}
catch
{
}
}
// Scale By Radius
void ScaleByRadius(PQSMod mod, double Resize)
{
FieldInfo scaleByRadius = mod.GetType().GetField("scaleDeformityByRadius");
if (scaleByRadius?.FieldType == typeof(bool) && (scaleByRadius?.GetValue(mod) as bool?) == true)
{
FieldInfo deformity = mod.GetType().GetField("heightMapDeformity");
if (deformity == null)
{
deformity = mod.GetType().GetField("deformity");
}
if (deformity?.FieldType == typeof(double))
{
deformity.SetValue(mod, (double)deformity.GetValue(mod) / Resize);
}
}
}
public BillboardObject(PQSMod template)
{
_mod = template as PQSMod_BillboardObject;
_mod.transform.parent = Utility.Deactivator;
base.mod = _mod;
}
public FlattenOcean(PQSMod template)
{
_mod = template as PQSMod_FlattenOcean;
_mod.transform.parent = Utility.Deactivator;
base.mod = _mod;
}
// Creates the a PQSMod of type T
void ICreatable <PQSMod> .Create(PQSMod value)
{
Create((T)value, PqsVersion);
}
public RemoveQuadMap(PQSMod template)
{
_mod = template as PQSMod_RemoveQuadMap;
_mod.transform.parent = Utility.Deactivator;
base.mod = _mod;
}
/// <summary>
/// Renders the Window
/// </summary>
protected override void Render(Int32 id)
{
// Call base
base.Render(id);
// Check for PQS
if (Current.pqsController == null)
{
Button(Localization.LOC_KITTOPIATECH_PQSEDITOR_ADD, () =>
{
// Create a new PQS
GameObject controllerRoot = new GameObject(Current.name);
controllerRoot.transform.parent = Current.transform;
PQS pqsVersion = controllerRoot.AddComponent <PQS>();
// I am at this time unable to determine some of the magic parameters which cause the PQS to work... (Or just lazy but who cares :P)
PSystemBody Laythe = Utility.FindBody(Injector.StockSystemPrefab.rootBody, "Laythe");
Utility.CopyObjectFields(Laythe.pqsVersion, pqsVersion);
pqsVersion.surfaceMaterial = Laythe.pqsVersion.surfaceMaterial;
// Create the fallback material (always the same shader)
pqsVersion.fallbackMaterial = new PQSProjectionFallbackLoader();
pqsVersion.fallbackMaterial.name = Guid.NewGuid().ToString();
// Create the celestial body transform
GameObject mod = new GameObject("_CelestialBody");
mod.transform.parent = controllerRoot.transform;
PQSMod_CelestialBodyTransform transform = mod.AddComponent <PQSMod_CelestialBodyTransform>();
transform.sphere = pqsVersion;
transform.forceActivate = false;
transform.deactivateAltitude = 115000;
transform.forceRebuildOnTargetChange = false;
transform.planetFade = new PQSMod_CelestialBodyTransform.AltitudeFade();
transform.planetFade.fadeFloatName = "_PlanetOpacity";
transform.planetFade.fadeStart = 100000.0f;
transform.planetFade.fadeEnd = 110000.0f;
transform.planetFade.valueStart = 0.0f;
transform.planetFade.valueEnd = 1.0f;
transform.planetFade.secondaryRenderers = new List <GameObject>();
transform.secondaryFades = new PQSMod_CelestialBodyTransform.AltitudeFade[0];
transform.requirements = PQS.ModiferRequirements.Default;
transform.modEnabled = true;
transform.order = 10;
// Create the material direction
mod = new GameObject("_Material_SunLight");
mod.transform.parent = controllerRoot.gameObject.transform;
PQSMod_MaterialSetDirection lightDirection = mod.AddComponent <PQSMod_MaterialSetDirection>();
lightDirection.sphere = pqsVersion;
lightDirection.valueName = "_sunLightDirection";
lightDirection.requirements = PQS.ModiferRequirements.Default;
lightDirection.modEnabled = true;
lightDirection.order = 100;
// Create the UV planet relative position
mod = new GameObject("_Material_SurfaceQuads");
mod.transform.parent = controllerRoot.transform;
PQSMod_UVPlanetRelativePosition uvs = mod.AddComponent <PQSMod_UVPlanetRelativePosition>();
uvs.sphere = pqsVersion;
uvs.requirements = PQS.ModiferRequirements.Default;
uvs.modEnabled = true;
uvs.order = 999999;
// Crete the quad mesh colliders
mod = new GameObject("QuadMeshColliders");
mod.transform.parent = controllerRoot.gameObject.transform;
PQSMod_QuadMeshColliders collider = mod.AddComponent <PQSMod_QuadMeshColliders>();
collider.sphere = pqsVersion;
collider.maxLevelOffset = 0;
collider.physicsMaterial = new PhysicMaterial();
collider.physicsMaterial.name = "Ground";
collider.physicsMaterial.dynamicFriction = 0.6f;
collider.physicsMaterial.staticFriction = 0.8f;
collider.physicsMaterial.bounciness = 0.0f;
collider.physicsMaterial.frictionCombine = PhysicMaterialCombine.Maximum;
collider.physicsMaterial.bounceCombine = PhysicMaterialCombine.Average;
collider.requirements = PQS.ModiferRequirements.Default;
collider.modEnabled = true;
collider.order = 100;
// Assing the new PQS
Current.pqsController = pqsVersion;
pqsVersion.transform.position = Current.transform.position;
pqsVersion.transform.localPosition = Vector3.zero;
// Set mode
_mode = Modes.List;
}, new Rect(20, index * distance + 10, 350, 20));
return;
}
// Mode List
if (_mode == Modes.List)
{
// Get the PQS-Spheres and their mods
IEnumerable <PQS> pqsList = Current.GetComponentsInChildren <PQS>(true);
IEnumerable <PQSMod> pqsModList = Current.GetComponentsInChildren <PQSMod>(true);
// Scroll
BeginScrollView(250, (pqsList.Count() + pqsModList.Count()) * distance + distance * 4, 20);
// Index
index = 0;
// Render
foreach (PQS pqs in pqsList)
{
Button(pqs.ToString(), () =>
{
_mode = Modes.PQS;
_sphere = pqs;
}, new Rect(20, index * distance + 10, 350, 20));
}
foreach (PQSMod mod in pqsModList)
{
Button(mod.ToString(), () =>
{
_mode = Modes.PQSMod;
_sphere = mod.sphere;
_mod = mod;
}, new Rect(20, index * distance + 10, 350, 20));
}
index++;
Button(Localization.LOC_KITTOPIATECH_PQSEDITOR_ADD_MOD, () => _mode = Modes.AddMod, new Rect(20, index * distance + 10, 350, 20));
if (Current.pqsController.ChildSpheres.All(s => s.name != Current.pqsController.name + "Ocean"))
{
Button(Localization.LOC_KITTOPIATECH_PQSEDITOR_ADD_OCEAN, () =>
{
// Generate the PQS object
GameObject gameObject = new GameObject("Ocean");
gameObject.layer = Constants.GameLayers.LocalSpace;
PQS ocean = gameObject.AddComponent <PQS>();
// Setup materials
PSystemBody Body = Utility.FindBody(Injector.StockSystemPrefab.rootBody, "Laythe");
foreach (PQS oc in Body.pqsVersion.GetComponentsInChildren <PQS>(true))
{
if (oc.name != "LaytheOcean")
{
continue;
}
// Copying Laythes Ocean-properties
Utility.CopyObjectFields <PQS>(oc, ocean);
}
// Load our new Material into the PQS
ocean.surfaceMaterial = new PQSOceanSurfaceQuadLoader(ocean.surfaceMaterial);
ocean.surfaceMaterial.name = Guid.NewGuid().ToString();
// Load fallback material into the PQS
ocean.fallbackMaterial = new PQSOceanSurfaceQuadFallbackLoader(ocean.fallbackMaterial);
ocean.fallbackMaterial.name = Guid.NewGuid().ToString();
// Create the UV planet relative position
GameObject mod = new GameObject("_Material_SurfaceQuads");
mod.transform.parent = gameObject.transform;
PQSMod_UVPlanetRelativePosition uvs = mod.AddComponent <PQSMod_UVPlanetRelativePosition>();
uvs.sphere = ocean;
uvs.requirements = PQS.ModiferRequirements.Default;
uvs.modEnabled = true;
uvs.order = 999999;
// Create the AerialPerspective Material
AerialPerspectiveMaterial mat = new AerialPerspectiveMaterial();
mat.Create(ocean);
// Create the OceanFX
OceanFX oceanFX = new OceanFX();
oceanFX.Create(ocean);
// Apply the Ocean
ocean.transform.parent = Current.pqsController.transform;
// Add the ocean PQS to the secondary renders of the CelestialBody Transform
PQSMod_CelestialBodyTransform transform = Current.pqsController.GetComponentsInChildren <PQSMod_CelestialBodyTransform>(true).FirstOrDefault(mod_ => mod_.transform.parent == Current.pqsController.transform);
transform.planetFade.secondaryRenderers.Add(ocean.gameObject);
typeof(PQS).GetField("_childSpheres", BindingFlags.Instance | BindingFlags.NonPublic)?.SetValue(Current.pqsController, null);
// Names!
ocean.name = Current.pqsController.name + "Ocean";
ocean.gameObject.name = Current.pqsController.name + "Ocean";
ocean.transform.name = Current.pqsController.name + "Ocean";
// Set up the ocean PQS
ocean.parentSphere = Current.pqsController;
ocean.transform.position = Current.pqsController.transform.position;
ocean.transform.localPosition = Vector3.zero;
ocean.radius = Current.Radius;
}, new Rect(20, index * distance + 10, 350, 20));
}
else
{
Button(Localization.LOC_KITTOPIATECH_PQSEDITOR_REMOVE_OCEAN, () =>
{
// Find atmosphere the ocean PQS
PQS ocean = Current.pqsController.GetComponentsInChildren <PQS>(true).First(pqs => pqs != Current.pqsController);
PQSMod_CelestialBodyTransform cbt = Current.pqsController.GetComponentsInChildren <PQSMod_CelestialBodyTransform>(true).First();
// Destroy the ocean PQS (this could be bad - destroying the secondary fades...)
cbt.planetFade.secondaryRenderers.Remove(ocean.gameObject);
typeof(PQS).GetField("_childSpheres", BindingFlags.Instance | BindingFlags.NonPublic)?.SetValue(Current.pqsController, null);
cbt.secondaryFades = new PQSMod_CelestialBodyTransform.AltitudeFade[0];
ocean.transform.parent = null;
UnityEngine.Object.Destroy(ocean);
}, new Rect(20, index * distance + 10, 350, 20));
}
// End Scroll
EndScrollView();
}
// Mode PQS
if (_mode == Modes.PQS)
{
// Scroll
BeginScrollView(250, Utils.GetScrollSize <PQS>() + Utils.GetScrollSize <HazardousOcean>() + distance * 1, 20);
// Index
index = 0;
// Render the PQS
RenderObject(_sphere);
// If it is an ocean, create an Hazardous Ocean button
if (PQSOceanSurfaceQuad.UsesSameShader(_sphere.surfaceMaterial))
{
Label("hazardousOcean"); index--;
if (_sphere.GetComponent <HazardousOcean>() != null)
{
Button(Localization.LOC_KITTOPIATECH_EDIT, () =>
{
UIController.Instance.SetEditedObject(KittopiaWindows.Curve, _sphere.GetComponent <HazardousOcean>().heatCurve ?? new FloatCurve(), c => _sphere.GetComponent <HazardousOcean>().heatCurve = c);
UIController.Instance.EnableWindow(KittopiaWindows.Curve);
}, new Rect(200, index * distance + 10, 75, 20)); index--;
Button(Localization.LOC_KITTOPIATECH_REMOVE, () => UnityEngine.Object.DestroyImmediate(_sphere.GetComponent <HazardousOcean>()), new Rect(285, index * distance + 10, 75, 20));
}
else
{
Button(Localization.LOC_KITTOPIATECH_PQSEDITOR_ADD_HAZOCEAN, () => _sphere.gameObject.AddComponent <HazardousOcean>(), new Rect(200, index * distance + 10, 170, 20));
}
}
index++;
// Rebuild
Button(Localization.LOC_KITTOPIATECH_PQSEDITOR_REBUILD, () => _sphere.RebuildSphere());
// End Scroll
EndScrollView();
}
// Mode PQSMod
if (_mode == Modes.PQSMod)
{
// Scroll
BeginScrollView(250, Utils.GetScrollSize(_mod.GetType()) + distance * 5, 20);
// Index
index = 0;
// Render the PQS
RenderObject(_mod);
index++;
// Rebuild
Button(Localization.LOC_KITTOPIATECH_PQSEDITOR_REBUILD, () => _sphere.RebuildSphere());
// Remove
Button(Localization.LOC_KITTOPIATECH_PQSEDITOR_REMOVE_MOD, () =>
{
_mod.sphere = null;
UnityEngine.Object.Destroy(_mod);
_mod = null;
// Hack
_sphere.SetupExternalRender();
_sphere.CloseExternalRender();
_mode = Modes.List;
});
// End Scroll
EndScrollView();
}
// Mode AddPQSMod
if (_mode == Modes.AddMod)
{
// Get all PQSMod types
List <Type> types = Parser.ModTypes.Where(t => t.IsSubclassOf(typeof(PQSMod))).ToList();
// Begin Scroll
BeginScrollView(250, types.Count * distance + 10, 20);
// Index
index = 0;
// Render the possible types
foreach (Type t in types)
{
Button(t.FullName, () =>
{
// Hack^6
GameObject pqsModObject = new GameObject(t.Name);
pqsModObject.transform.parent = Current.pqsController.transform;
PQSMod mod = pqsModObject.AddComponent(t) as PQSMod;
mod.sphere = Current.pqsController;
if (t == typeof(PQSMod_VoronoiCraters))
{
PQS mun = Utility.FindBody(Injector.StockSystemPrefab.rootBody, "Mun").pqsVersion;
PQSMod_VoronoiCraters craters = mun.GetComponentsInChildren <PQSMod_VoronoiCraters>()[0];
PQSMod_VoronoiCraters nc = pqsModObject.GetComponentsInChildren <PQSMod_VoronoiCraters>()[0];
nc.craterColourRamp = craters.craterColourRamp;
nc.craterCurve = craters.craterCurve;
nc.jitterCurve = craters.jitterCurve;
}
else if (t == typeof(PQSMod_VertexPlanet))
{
PQSMod_VertexPlanet vp = mod as PQSMod_VertexPlanet;
vp.landClasses = new [] { new PQSMod_VertexPlanet.LandClass("Class", 0, 1, Color.black, Color.white, 0) };
vp.continental = new PQSMod_VertexPlanet.SimplexWrapper(0, 0, 0, 0);
vp.continentalRuggedness = new PQSMod_VertexPlanet.SimplexWrapper(0, 0, 0, 0);
vp.continentalSharpness = new PQSMod_VertexPlanet.NoiseModWrapper(0, 0, 0, 0);
vp.continentalSharpnessMap = new PQSMod_VertexPlanet.SimplexWrapper(0, 0, 0, 0);
vp.terrainType = new PQSMod_VertexPlanet.SimplexWrapper(0, 0, 0, 0);
}
else if (t == typeof(PQSMod_HeightColorMap))
{
(mod as PQSMod_HeightColorMap).landClasses = new [] { new PQSMod_HeightColorMap.LandClass("Class", 0, 1, Color.black, Color.white, 0) };
}
else if (t == typeof(PQSMod_HeightColorMap2))
{
(mod as PQSMod_HeightColorMap2).landClasses = new[] { new PQSMod_HeightColorMap2.LandClass("Class", 0, 1, Color.black, Color.white, 0) };
}
else if (t == typeof(PQSMod_HeightColorMapNoise))
{
(mod as PQSMod_HeightColorMapNoise).landClasses = new[] { new PQSMod_HeightColorMapNoise.LandClass("Class", 0, 1, Color.black, Color.white, 0) };
}
else if (t == typeof(PQSLandControl))
{
PQSLandControl lc = mod as PQSLandControl;
lc.altitudeSimplex = new Simplex();
lc.scatters = new PQSLandControl.LandClassScatter[0];
lc.landClasses = new [] { new PQSLandControl.LandClass()
{
altitudeRange = new PQSLandControl.LerpRange(),
coverageSimplex = new Simplex(),
longitudeRange = new PQSLandControl.LerpRange(),
latitudeDoubleRange = new PQSLandControl.LerpRange(),
latitudeRange = new PQSLandControl.LerpRange(),
scatter = new PQSLandControl.LandClassScatterAmount[0]
} };
lc.latitudeSimplex = new Simplex();
lc.longitudeSimplex = new Simplex();
}
// Edit the mod
_mod = mod;
_sphere = mod.sphere;
_mode = Modes.PQSMod;
}, new Rect(20, index * distance + 10, 350, 20));
}
// End Scroll
EndScrollView();
}
}
public VertexColorNoiseRGB(PQSMod template)
{
_mod = template as PQSMod_VertexColorNoiseRGB;
_mod.transform.parent = Utility.Deactivator;
base.mod = _mod;
}
// Generate the scaled space mesh using PQS (all results use scale of 1)
public static Mesh ComputeScaledSpaceMesh(CelestialBody body, PQS pqs)
{
// We need to get the body for Jool (to steal it's mesh)
const Double rScaledJool = 1000.0f;
Double rMetersToScaledUnits = (Single)(rScaledJool / body.Radius);
// Generate a duplicate of the Jool mesh
Mesh mesh = DuplicateMesh(Templates.ReferenceGeosphere);
Logger.Active.Log(body);
Logger.Active.Log(pqs);
Logger.Active.Log(body.pqsController);
// If this body has a PQS, we can create a more detailed object
if (pqs != null)
{
// first we enable all maps
OnDemandStorage.EnableBody(body.bodyName);
// The game object the PQS is attached to
GameObject pqsVersionGameObject = null;
if (Injector.IsInPrefab)
{
// In order to generate the scaled space we have to enable the mods. Since this is
// a prefab they don't get disabled as kill game performance. To resolve this we
// clone the PQS, use it, and then delete it when done
pqsVersionGameObject = UnityEngine.Object.Instantiate(pqs.gameObject);
}
else
{
// At runtime we simply use the PQS that is active
pqsVersionGameObject = pqs.gameObject;
}
PQS pqsVersion = pqsVersionGameObject.GetComponent <PQS>();
// Load the PQS of the ocean
PQS pqsOcean = pqs.ChildSpheres?.FirstOrDefault();
// Deactivate blacklisted Mods
Type[] blacklist = { typeof(PQSMod_OnDemandHandler) };
foreach (PQSMod mod in pqsVersion.GetComponentsInChildren <PQSMod>(true)
.Where(m => m.enabled && blacklist.Contains(m.GetType())))
{
mod.modEnabled = false;
}
// Find the PQS mods and enable the PQS-sphere
PQSMod[] mods = pqsVersion.GetComponentsInChildren <PQSMod>(true)
.Where(m => m.modEnabled && m.transform.parent == pqsVersion.transform).OrderBy(m => m.order).ToArray();
foreach (PQSMod flatten in mods.Where(m => m is PQSMod_FlattenArea))
{
flatten.GetType().GetFields(BindingFlags.NonPublic | BindingFlags.Instance)
.First(f => f.FieldType == typeof(Boolean)).SetValue(flatten, true);
}
Logger.Active.Log(mods.Length);
// Do the same for the ocean
PQSMod[] oceanMods = new PQSMod[0];
if (pqsOcean != null)
{
oceanMods = pqsOcean.GetComponentsInChildren <PQSMod>(true)
.Where(m => m.modEnabled && m.transform.parent == pqsOcean.transform).OrderBy(m => m.order).ToArray();
foreach (PQSMod flatten in oceanMods.Where(m => m is PQSMod_FlattenArea))
{
flatten.GetType().GetFields(BindingFlags.NonPublic | BindingFlags.Instance)
.First(f => f.FieldType == typeof(Boolean)).SetValue(flatten, true);
}
pqsOcean.StartUpSphere();
pqsOcean.isBuildingMaps = true;
}
pqsVersion.StartUpSphere();
pqsVersion.isBuildingMaps = true;
// If we were able to find PQS mods
if (mods.Any())
{
// Generate the PQS modifications
Vector3[] vertices = mesh.vertices;
for (Int32 i = 0; i < mesh.vertexCount; i++)
{
// Get the UV coordinate of this vertex
Vector2 uv = mesh.uv[i];
// Since this is a geosphere, normalizing the vertex gives the direction from center center
Vector3 direction = vertices[i];
direction.Normalize();
// Build the vertex data object for the PQS mods
PQS.VertexBuildData vertex = new PQS.VertexBuildData();
vertex.directionFromCenter = direction;
vertex.vertHeight = body.Radius;
vertex.u = uv.x;
vertex.v = uv.y;
// Build from the PQS
foreach (PQSMod mod in mods)
{
mod.OnVertexBuildHeight(vertex);
}
// Check for sea level
if (pqsOcean != null)
{
// Build the vertex data object for the ocean
PQS.VertexBuildData vertexOcean = new PQS.VertexBuildData();
vertexOcean.directionFromCenter = direction;
vertexOcean.vertHeight = body.Radius;
vertexOcean.u = uv.x;
vertexOcean.v = uv.y;
// Build from the PQS
foreach (PQSMod mod in oceanMods)
{
mod.OnVertexBuildHeight(vertexOcean);
}
vertex.vertHeight = Math.Max(vertex.vertHeight, vertexOcean.vertHeight);
}
// Adjust the displacement
vertices[i] = direction * (Single)(vertex.vertHeight * rMetersToScaledUnits);
}
mesh.vertices = vertices;
mesh.RecalculateNormals();
mesh.RecalculateBounds();
}
// Cleanup
if (pqsOcean != null)
{
pqsOcean.isBuildingMaps = false;
pqsOcean.DeactivateSphere();
}
pqsVersion.isBuildingMaps = false;
pqsVersion.DeactivateSphere();
// If we are working with a copied PQS, clean it up
if (Injector.IsInPrefab)
{
UnityEngine.Object.Destroy(pqsVersionGameObject);
}
OnDemandStorage.DisableBody(body.bodyName);
}
// Return the generated scaled space mesh
return(mesh);
}
public VertexRidgedAltitudeCurve(PQSMod template)
{
_mod = template as PQSMod_VertexRidgedAltitudeCurve;
_mod.transform.parent = Utility.Deactivator;
base.mod = _mod;
}
public MaterialFadeAltitudeDouble(PQSMod template)
{
_mod = template as PQSMod_MaterialFadeAltitudeDouble;
_mod.transform.parent = Utility.Deactivator;
base.mod = _mod;
}
public VertexSimplexMultiChromatic(PQSMod template)
{
_mod = template as PQSMod_VertexSimplexMultiChromatic;
_mod.transform.parent = Utility.Deactivator;
base.mod = _mod;
}
public FlattenAreaTangential(PQSMod template)
{
_mod = template as PQSMod_FlattenAreaTangential;
_mod.transform.parent = Utility.Deactivator;
base.mod = _mod;
}
/// <summary>
/// Writes a PQS to a new config node
/// </summary>
public static void WritePQSToConfigNode(PQS pqsVersion, ref ConfigNode body, bool ocean)
{
ConfigNode pqs = null;
if (!ocean)
{
CelestialBody cb = pqsVersion.GetComponentInParent <CelestialBody>();
PQSLoader pqsLoader = new PQSLoader(cb);
pqs = WriteObjectToConfigNode("PQS", ref body, pqsLoader);
WriteObjectToConfigNode("Material", ref pqs, pqsLoader.surfaceMaterial);
WriteObjectToConfigNode("FallbackMaterial", ref pqs, pqsLoader.fallbackMaterial);
if (pqsLoader.physicsMaterial.Value != null)
{
WriteObjectToConfigNode("PhysicsMaterial", ref pqs, pqsLoader.physicsMaterial);
}
}
else
{
CelestialBody cb = pqsVersion.parentSphere.GetComponentInParent <CelestialBody>();
OceanLoader oceanLoader = new OceanLoader(cb);
pqs = WriteObjectToConfigNode("Ocean", ref body, oceanLoader);
pqs.AddValue("ocean", pqsVersion.parentSphere.mapOcean && cb.ocean);
pqs.AddValue("oceanColor", pqsVersion.parentSphere.mapOceanColor);
pqs.AddValue("oceanHeight", pqsVersion.parentSphere.mapOceanHeight);
pqs.AddValue("density", cb.oceanDensity);
WriteObjectToConfigNode("Material", ref pqs, oceanLoader.surfaceMaterial);
WriteObjectToConfigNode("FallbackMaterial", ref pqs, oceanLoader.fallbackMaterial);
WriteObjectToConfigNode("Fog", ref pqs, new FogLoader(Part.GetComponentUpwards <CelestialBody>(pqsVersion.gameObject)));
if (pqsVersion.gameObject.GetComponent <HazardousOcean>() != null)
{
pqsVersion.gameObject.GetComponent <HazardousOcean>().heatCurve.Save(pqs.AddNode("HazardousOcean"));
}
}
// Mods
IEnumerable <PQSMod> mods = pqsVersion.GetComponentsInChildren <PQSMod>(true).Where(m => (ocean || m.sphere == pqsVersion) && !(m is PQSCity) && !(m is PQSCity2));
// Get all loaded types
IEnumerable <Type> types = AssemblyLoader.loadedAssemblies.SelectMany(a => a.assembly.GetTypes());
if (mods.Count() != 0)
{
ConfigNode modsNode = pqs.AddNode("Mods");
foreach (PQSMod Mod in mods)
{
// Fix PQSMods
PQSMod mod = Mod;
Type loaderType = types.FirstOrDefault(t => t.Name == Mod.GetType().Name.Replace("PQSMod_", "").Replace("PQS", ""));
// No loader
if (loaderType == null)
{
continue;
}
// Create the loader
object loader = Activator.CreateInstance(loaderType);
// Reflection, because C# being silly... :/
PropertyInfo info = loaderType.GetProperty("mod");
if (info == null)
{
continue;
}
info.SetValue(loader, mod, null);
// Load
ConfigNode modNode = WriteObjectToConfigNode(loaderType.Name, ref modsNode, loader);
IEnumerable <PQSMod> existingMods = pqsVersion.GetComponentsInChildren <PQSMod>(true).Where(m => m.GetType() == mod.GetType() && m.sphere == pqsVersion && m.name == mod.name);
modNode.AddValue("index", existingMods.ToList().IndexOf(mod));
// Submods
PQSMod_HeightColorMap hcm = mod as PQSMod_HeightColorMap;
if (hcm?.landClasses != null)
{
ConfigNode landClasses = modNode.AddNode("LandClasses");
foreach (PQSMod_HeightColorMap.LandClass landClass in hcm.landClasses)
{
WriteObjectToConfigNode("Class", ref landClasses, new HeightColorMap.LandClassLoader(landClass));
}
}
PQSMod_HeightColorMap2 hcm2 = mod as PQSMod_HeightColorMap2;
if (hcm2?.landClasses != null)
{
ConfigNode landClasses = modNode.AddNode("LandClasses");
foreach (PQSMod_HeightColorMap2.LandClass landClass in hcm2.landClasses)
{
WriteObjectToConfigNode("Class", ref landClasses, new HeightColorMap2.LandClassLoader(landClass));
}
}
PQSMod_HeightColorMapNoise hcmNoise = mod as PQSMod_HeightColorMapNoise;
if (hcmNoise?.landClasses != null)
{
ConfigNode landClasses = modNode.AddNode("LandClasses");
foreach (PQSMod_HeightColorMapNoise.LandClass landClass in hcmNoise.landClasses)
{
WriteObjectToConfigNode("Class", ref landClasses, new HeightColorMapNoise.LandClassLoader(landClass));
}
}
if (mod is PQSLandControl)
{
PQSLandControl lc = mod as PQSLandControl;
if (lc.altitudeSimplex != null)
{
KopernicusSimplexWrapper lcaltsimpwrap = new KopernicusSimplexWrapper(lc.altitudeBlend, lc.altitudeOctaves, lc.altitudePersistance, lc.altitudeFrequency);
lcaltsimpwrap.seed = lc.altitudeSeed;
WriteObjectToConfigNode("altitudeSimplex", ref modNode, new VertexPlanet.SimplexLoader(lcaltsimpwrap));
}
if (lc.latitudeSimplex != null)
{
KopernicusSimplexWrapper lclatsimpwrap = new KopernicusSimplexWrapper(lc.latitudeBlend, lc.latitudeOctaves, lc.latitudePersistance, lc.latitudeFrequency);
lclatsimpwrap.seed = lc.latitudeSeed;
WriteObjectToConfigNode("latitudeSimplex", ref modNode, new VertexPlanet.SimplexLoader(lclatsimpwrap));
}
if (lc.longitudeSimplex != null)
{
KopernicusSimplexWrapper lclongsimpwrap = new KopernicusSimplexWrapper(lc.longitudeBlend, lc.longitudeOctaves, lc.longitudePersistance, lc.longitudeFrequency);
lclongsimpwrap.seed = lc.longitudeSeed;
WriteObjectToConfigNode("longitudeSimplex", ref modNode, new VertexPlanet.SimplexLoader(lclongsimpwrap));
}
if (lc.landClasses != null)
{
ConfigNode landClasses = modNode.AddNode("landClasses");
foreach (PQSLandControl.LandClass landClass in lc.landClasses)
{
ConfigNode lcNode = WriteObjectToConfigNode("Class", ref landClasses, new LandControl.LandClassLoader(landClass));
WriteObjectToConfigNode("altitudeRange", ref lcNode, new LandControl.LerpRangeLoader(landClass.altitudeRange));
KopernicusSimplexWrapper lccovsimpwrap = new KopernicusSimplexWrapper(landClass.coverageBlend, landClass.coverageOctaves, landClass.coveragePersistance, landClass.coverageFrequency);
lccovsimpwrap.seed = landClass.coverageSeed;
WriteObjectToConfigNode("coverageSimplex", ref lcNode, new VertexPlanet.SimplexLoader(lccovsimpwrap));
WriteObjectToConfigNode("latitudeDoubleRange", ref lcNode, new LandControl.LerpRangeLoader(landClass.latitudeDoubleRange));
WriteObjectToConfigNode("latitudeRange", ref lcNode, new LandControl.LerpRangeLoader(landClass.latitudeRange));
WriteObjectToConfigNode("longitudeRange", ref lcNode, new LandControl.LerpRangeLoader(landClass.longitudeRange));
KopernicusSimplexWrapper lcnoisesimpwrap = new KopernicusSimplexWrapper(landClass.noiseBlend, landClass.noiseOctaves, landClass.noisePersistance, landClass.noiseFrequency);
lcnoisesimpwrap.seed = landClass.noiseSeed;
WriteObjectToConfigNode("noiseSimplex", ref lcNode, new VertexPlanet.SimplexLoader(lcnoisesimpwrap));
if (landClass.scatter != null)
{
ConfigNode amount = lcNode.AddNode("scatters");
foreach (PQSLandControl.LandClassScatterAmount scatterAmount in landClass.scatter)
{
WriteObjectToConfigNode("Scatter", ref amount, new LandControl.LandClassScatterAmountLoader(scatterAmount));
}
}
}
}
if (lc.scatters != null)
{
ConfigNode scatters = modNode.AddNode("scatters");
foreach (PQSLandControl.LandClassScatter scatter in lc.scatters)
{
LandControl.LandClassScatterLoader classLoader = new LandControl.LandClassScatterLoader(scatter);
if (scatter.material.shader == new NormalDiffuse().shader)
{
classLoader.customMaterial = new NormalDiffuseLoader(scatter.material);
}
else if (scatter.material.shader == new NormalBumped().shader)
{
classLoader.customMaterial = new NormalBumpedLoader(scatter.material);
}
else if (scatter.material.shader == new NormalDiffuseDetail().shader)
{
classLoader.customMaterial = new NormalDiffuseDetailLoader(scatter.material);
}
else if (scatter.material.shader == new DiffuseWrapLoader().shader)
{
classLoader.customMaterial = new DiffuseWrapLoader(scatter.material);
}
else if (scatter.material.shader == new AlphaTestDiffuse().shader)
{
classLoader.customMaterial = new AlphaTestDiffuseLoader(scatter.material);
}
else if (scatter.material.shader == new AerialTransCutout().shader)
{
classLoader.customMaterial = new AerialTransCutoutLoader(scatter.material);
}
ConfigNode scatterNode = WriteObjectToConfigNode("Scatter", ref scatters, classLoader);
WriteObjectToConfigNode("Material", ref scatterNode, classLoader.customMaterial);
scatterNode.AddNode("Experiment");
}
}
}
if (mod is PQSMod_VertexPlanet)
{
PQSMod_VertexPlanet vp = mod as PQSMod_VertexPlanet;
WriteObjectToConfigNode("ContinentalSimplex", ref modNode, new PQSMod_VertexPlanet.SimplexWrapper(vp.continental));
WriteObjectToConfigNode("RuggednessSimplex", ref modNode, new PQSMod_VertexPlanet.SimplexWrapper(vp.continentalRuggedness));
WriteObjectToConfigNode("SharpnessNoise", ref modNode, new PQSMod_VertexPlanet.NoiseModWrapper(vp.continentalSharpness));
WriteObjectToConfigNode("SharpnessSimplexMap", ref modNode, new PQSMod_VertexPlanet.SimplexWrapper(vp.continentalSharpnessMap));
WriteObjectToConfigNode("TerrainTypeSimplex", ref modNode, new PQSMod_VertexPlanet.SimplexWrapper(vp.terrainType));
if (vp.landClasses != null)
{
ConfigNode landClasses = modNode.AddNode("LandClasses");
foreach (PQSMod_VertexPlanet.LandClass landClass in vp.landClasses)
{
ConfigNode classNode = WriteObjectToConfigNode("Class", ref landClasses, new VertexPlanet.LandClassLoader(landClass));
WriteObjectToConfigNode("SimplexNoiseMap", ref classNode, new PQSMod_VertexPlanet.SimplexWrapper(landClass.colorNoiseMap));
}
}
}
if (!(mod is PQSMod_OceanFX))
{
continue;
}
List <Texture2DParser> wm = (loader as OceanFX).watermain;
ConfigNode watermain = modNode.AddNode("Watermain");
foreach (Texture2DParser texture in wm)
{
watermain.AddValue("waterTex-" + wm.ToList().IndexOf(texture), texture.Value.name);
}
}
}
}
public VertexDefineCoastLine(PQSMod template)
{
_mod = template as PQSMod_VertexDefineCoastLine;
_mod.transform.parent = Utility.Deactivator;
base.mod = _mod;
}
public QuadEnhanceCoast(PQSMod template)
{
_mod = template as PQSMod_QuadEnhanceCoast;
_mod.transform.parent = Utility.Deactivator;
base.mod = _mod;
}
static void Duplicate(PQSMod[] pqsMods)
{
// Count pqsMods
int?n = pqsMods?.Length;
Debug.Log("EditorBuildings.Duplicate", "pqsMods found = " + (n ?? 0));
if (!(n > 0))
{
return;
}
// Find KSC
PQSCity ksc = SpaceCenter.Instance?.SpaceCenterTransform?.parent?.GetComponentInChildren <PQSCity>();
if (ksc == null)
{
return;
}
// Find Radius
float radius = (float)FlightGlobals.GetHomeBody().Radius;
// Initialize Lists
List <GameObject> objects = new List <GameObject>();
List <Vector3> vectors = new List <Vector3>();
List <Quaternion> quaternions = new List <Quaternion>();
for (int i = 0; i < n; i++)
{
PQSMod pqsMod = pqsMods[i];
if (pqsMod.GetType() == typeof(PQSCity) || pqsMod.GetType() == typeof(PQSCity2))
{
// Calculate position relative to KSC
Vector3 relativePosition = pqsMod.transform.position - VABposition;
// Check distance from KSC
double distance = relativePosition.magnitude;
// If the PQSMod is within the chosen range
if (pqsMod != ksc && distance < 2000)
{
Debug.Log("EditorBuildings.Duplicate", "pqsMod = " + pqsMod + ", distance = " + distance);
// Backup the original enabled state
bool backup = pqsMod.enabled;
// Disable the original PQSMod component
pqsMod.enabled = false;
// Instantiate GameObject
GameObject clone = Object.Instantiate(pqsMod.gameObject);
Debug.Log("EditorBuildings.Duplicate", "clone = " + clone);
// Disable the clone
clone.SetActive(false);
// Change to Layer 0
clone.SetLayerRecursive(0);
// Remove PQSMod component from the clone
Object.DestroyImmediate(clone.GetComponent <PQSMod>());
// Don't destroy object
Object.DontDestroyOnLoad(clone);
// Add clone to list
objects.Add(clone);
// Add clone position to list
vectors.Add(relativePosition);
// Add clone rotation to list
quaternions.Add(pqsMod.transform.rotation);
// Restore the original PQSMod enabled state
pqsMod.enabled = backup;
}
}
}
// Store lists to arrays
buildings = objects.ToArray();
Debug.Log("EditorBuildings.Duplicate", "buildings count = " + buildings?.Length);
positions = vectors.ToArray();
Debug.Log("EditorBuildings.Duplicate", "positions count = " + positions?.Length);
rotations = quaternions.ToArray();
Debug.Log("EditorBuildings.Duplicate", "rotations count = " + rotations?.Length);
}
// PostApply Event
void IParserEventSubscriber.PostApply(ConfigNode node)
{
// Assign the generated PQS to our new world
generatedBody.pqsVersion = pqsVersion;
generatedBody.pqsVersion.name = generatedBody.name;
generatedBody.pqsVersion.transform.name = generatedBody.name;
generatedBody.pqsVersion.gameObject.name = generatedBody.name;
generatedBody.pqsVersion.radius = generatedBody.celestialBody.Radius;
// Add an OnDemand Handler
OnDemand.OnDemandStorage.AddHandler(generatedBody.pqsVersion);
// Load mods
if (!node.HasNode("Mods"))
{
goto Debug;
}
List <PQSMod> patchedMods = new List <PQSMod>();
// Get all loaded types
List <Type> types = Injector.ModTypes;
// Load mods manually because of patching
foreach (ConfigNode mod in node.GetNode("Mods").nodes)
{
// get the mod type
if (types.Where(t => t.Name == mod.name).Count() == 0)
{
continue;
}
Type loaderType = types.FirstOrDefault(t => t.Name == mod.name);
string testName = mod.name != "LandControl" ? "PQSMod_" + mod.name : "PQSLandControl";
Type modType = types.FirstOrDefault(t => t.Name == testName);
if (loaderType == null || modType == null)
{
Debug.LogError("MOD NULL: Loadertype " + mod.name + " with mod type " + testName + " and null? " + (loaderType == null) + (modType == null));
continue;
}
// Do any PQS Mods already exist on this PQS matching this mod?
IEnumerable <PQSMod> existingMods = pqsVersion.GetComponentsInChildren <PQSMod>(true).Where(m => m.GetType().Equals(modType) &&
m.transform.parent == pqsVersion.transform);
// Create the loader
object loader = Activator.CreateInstance(loaderType);
// Reflection, because C# being silly... :/
MethodInfo createNew = loaderType.GetMethod("Create", Type.EmptyTypes);
MethodInfo create = loaderType.GetMethod("Create", new Type[] { modType });
if (existingMods.Count() > 0)
{
// Attempt to find a PQS mod we can edit that we have not edited before
PQSMod existingMod = existingMods.Where(m => !patchedMods.Contains(m) && (mod.HasValue("name") ? m.name == mod.GetValue("name") : true)).FirstOrDefault();
if (existingMod != null)
{
create.Invoke(loader, new[] { existingMod });
Parser.LoadObjectFromConfigurationNode(loader, mod);
patchedMods.Add(existingMod);
Logger.Active.Log("PQSLoader.PostApply(ConfigNode): Patched PQS Mod => " + modType);
}
else
{
createNew.Invoke(loader, null);
Parser.LoadObjectFromConfigurationNode(loader, mod);
Logger.Active.Log("PQSLoader.PostApply(ConfigNode): Added PQS Mod => " + modType);
}
}
else
{
createNew.Invoke(loader, null);
Parser.LoadObjectFromConfigurationNode(loader, mod);
Logger.Active.Log("PQSLoader.PostApply(ConfigNode): Added PQS Mod => " + modType);
}
}
Debug:
// ----------- DEBUG -------------
// Utility.DumpObjectProperties(pqsVersion.surfaceMaterial, " ---- Surface Material (Post PQS Loader) ---- ");
Utility.GameObjectWalk(pqsVersion.gameObject, " ");
// -------------------------------
}
public VertexColorMapBlend(PQSMod template)
{
_mod = template as PQSMod_VertexColorMapBlend;
_mod.transform.parent = Utility.Deactivator;
base.mod = _mod;
}
/// <summary>
/// Resets objects
/// </summary>
protected override void SetEditedObject()
{
_mod = null;
_sphere = null;
_mode = Modes.List;
}
// Creates the a PQSMod of type T with given PQS
void IModLoader.Create(PQSMod mod, PQS pqsVersion)
{
Create((T)mod, pqsVersion);
}
/// <summary>
/// Generates a PQS Setup + the Scaled Space Maps needed
/// </summary>
/// <returns></returns>
// ReSharper disable once InconsistentNaming
private static void GeneratePQS(ref ConfigNode node, String name, String folder, Planet planet, Color planetColor,
out Color average, out List <Color> biomes)
{
// Log
Console.WriteLine("Preparing to load PQS data");
// Create the node
ConfigNode pqs = new ConfigNode("PQS");
// TODO: Material Settings?
// Create a node for the mods
ConfigNode mods = new ConfigNode("Mods");
pqs.AddConfigNode(mods);
// Load the PQSDatabase and select a setup
ConfigNode pqsDatabase = Utility.Load("pqs");
List <PQSPreset> data = pqsDatabase.nodes.Select(n => Parser.CreateObjectFromConfigNode <PQSPreset>(n))
.ToList();
data = data.Where(d => ((planet.radius * 100) > d.MinRadius) && ((planet.radius * 100) < d.MaxRadius))
.ToList();
PQSPreset setup = data[Random.Next(0, data.Count)];
// Setup the interpreter
Interpreter interpreter = new Interpreter()
.SetVariable("planet", planet, typeof(Planet))
.SetVariable("pqsVersion", setup, typeof(PQSPreset))
.SetVariable("Random", Random, typeof(Random))
.SetVariable("Seed", Seed, typeof(Int32))
.SetVariable("Color", Utility.GenerateColor(), typeof(Color))
.Reference(typeof(Parser))
.Reference(typeof(Generator))
.Reference(typeof(Utility))
.Reference(typeof(Utils));
// Transfer the mod nodes and evaluate expressions
foreach (ConfigNode modNode in setup.Mods.nodes)
{
mods.AddConfigNode(Utility.Eval(modNode, interpreter));
}
// Create a new PQSObject
PQS pqsVersion = new PQS(planet.radius * 100);
List <PQSMod> patchedmods = new List <PQSMod>();
// Log
Console.WriteLine($"Created PQS Object for {name}");
// Get all loaded types
List <Type> types = AppDomain.CurrentDomain.GetAssemblies().SelectMany(a => a.GetTypes()).ToList();
// Load mods from Config
foreach (ConfigNode mod in mods.nodes)
{
// get the mod type
if (types.Count(t => t.Name == mod.name) == 0)
{
continue;
}
Type loaderType = types.FirstOrDefault(t => t.Name == mod.name);
String testName = mod.name != "LandControl" ? "PQSMod_" + mod.name : "PQSLandControl";
Type modType = types.FirstOrDefault(t => t.Name == testName);
if ((loaderType == null) || (modType == null))
{
continue;
}
// Do any PQS mods already exist on this PQS matching this mod?
IEnumerable <PQSMod> existingmods = pqsVersion.mods.Where(m => m.GetType() == modType);
// Create the loader
Object loader = Activator.CreateInstance(loaderType);
// Reflection, because C# being silly... :/
MethodInfo createNew = loaderType.GetMethod("Create", new[] { typeof(PQS) });
MethodInfo create = loaderType.GetMethod("Create", new[] { modType });
IList <PQSMod> pqsmods = existingmods as IList <PQSMod> ?? existingmods.ToList();
if (pqsmods.Any())
{
// Attempt to find a PQS mod we can edit that we have not edited before
PQSMod existingMod = pqsmods.FirstOrDefault(m => !patchedmods.Contains(m) &&
(!mod.HasValue("name") ||
(mod.HasValue("index")
? (pqsmods.ToList().IndexOf(m) ==
Int32.Parse(mod.GetValue("index"))) &&
(m.name == mod.GetValue("name"))
: m.name == mod.GetValue("name"))));
if (existingMod != null)
{
create.Invoke(loader, new Object[] { existingMod });
Parser.LoadObjectFromConfigurationNode(loader, mod);
patchedmods.Add(existingMod);
}
else
{
createNew.Invoke(loader, new Object[] { pqsVersion });
Parser.LoadObjectFromConfigurationNode(loader, mod);
}
}
else
{
createNew.Invoke(loader, new Object[] { pqsVersion });
Parser.LoadObjectFromConfigurationNode(loader, mod);
}
// Log
Console.WriteLine($"Created a new instance of {loaderType.Name} on {name}");
}
// Size
Int32 width = pqsVersion.radius >= 600000 ? 4096 : pqsVersion.radius <= 100000 ? 1024 : 2048;
// Biome colors
int numBiomes = Random.Next(2, 10);
biomes = new List <Color>(numBiomes);
for (int i = 0; i < numBiomes; i++)
{
biomes.Add(Utility.GenerateColor());
}
// Export ScaledSpace Maps
using (UnsafeBitmap diffuse = new UnsafeBitmap(width, width / 2))
{
using (UnsafeBitmap height = new UnsafeBitmap(width, width / 2))
{
using (UnsafeBitmap biomeMap = new UnsafeBitmap(width, width / 2))
{
Console.WriteLine("Exporting Scaled Space maps from the PQS. This could take a while...");
// Iterate over the PQS
pqsVersion.SetupSphere();
diffuse.LockBitmap();
height.LockBitmap();
biomeMap.LockBitmap();
for (Int32 i = 0; i < width; i++)
{
for (Int32 j = 0; j < (width / 2); j++)
{
// Create a VertexBuildData
VertexBuildData builddata = new VertexBuildData
{
directionFromCenter =
Quaternion.CreateFromAngleAxis((360d / width) * i,
Vector3.Up) *
Quaternion
.CreateFromAngleAxis(90d - ((180d / (width / 2.0)) * j),
Vector3.Right) *
Vector3.Forward,
vertHeight = pqsVersion.radius
};
// Build the maps
pqsVersion.OnVertexBuildHeight(builddata);
pqsVersion.OnVertexBuild(builddata);
builddata.vertColor.a = 1f;
Single h = Mathf.Clamp01((Single)((builddata.vertHeight - pqsVersion.radius) *
(1d / pqsVersion.radiusMax)));
Single h1 = Mathf.Clamp01((Single)((builddata.vertHeight - pqsVersion.radius) *
(1d / (pqsVersion.radiusMax != 0 ? pqsVersion.radiusMax : planet.radius))));
diffuse.SetPixel(i, j, builddata.vertColor);
height.SetPixel(i, j, new Color(h, h, h));
biomeMap.SetPixel(i, j, biomes[(int)(h1 * (numBiomes - 1))]);
}
}
diffuse.UnlockBitmap();
height.UnlockBitmap();
biomeMap.UnlockBitmap();
// Save the textures
Directory.CreateDirectory(Directory.GetCurrentDirectory() + "/systems/" + folder + "/PluginData/");
using (UnsafeBitmap normals = Utility.BumpToNormalMap(height, 9))
{
// TODO: Implement something to make strength dynamic
diffuse.Bitmap
.Save(Directory.GetCurrentDirectory() + "/systems/" + folder + "/PluginData/" + name + "_Texture.png",
ImageFormat.Png);
height.Bitmap
.Save(Directory.GetCurrentDirectory() + "/systems/" + folder + "/PluginData/" + name + "_Height.png",
ImageFormat.Png); // In case you need it :)
normals.Bitmap
.Save(Directory.GetCurrentDirectory() + "/systems/" + folder + "/PluginData/" + name + "_Normals.png",
ImageFormat.Png);
biomeMap.Bitmap
.Save(Directory.GetCurrentDirectory() + "/systems/" + folder + "/PluginData/" + name + "_Biomes.png",
ImageFormat.Png);
}
}
}
// Log
Console.WriteLine($"Saved maps to {Directory.GetCurrentDirectory() + "/systems/" + folder + "/PluginData/"}");
// Finish
node.AddConfigNode(pqs);
// Colors
average = Utility.GetAverageColor(diffuse.Bitmap);
}
}
// Post Apply
void IParserEventSubscriber.PostApply(ConfigNode node)
{
// Load the Killer Ocean, if it is there
if (hazardousOcean != null)
{
ocean.gameObject.AddComponent <HazardousOcean>().heatCurve = hazardousOcean;
}
// Apply the Ocean
ocean.transform.parent = generatedBody.pqsVersion.transform;
// Add the ocean PQS to the secondary renders of the CelestialBody Transform
PQSMod_CelestialBodyTransform transform = generatedBody.pqsVersion.GetComponentsInChildren <PQSMod_CelestialBodyTransform>(true).FirstOrDefault(mod => mod.transform.parent == generatedBody.pqsVersion.transform);
transform.planetFade.secondaryRenderers.Add(ocean.gameObject);
// Names!
ocean.name = generatedBody.pqsVersion.name + "Ocean";
ocean.gameObject.name = generatedBody.pqsVersion.name + "Ocean";
ocean.transform.name = generatedBody.pqsVersion.name + "Ocean";
// Set up the ocean PQS
pqsVersion = generatedBody.pqsVersion;
// Load mods
if (!node.HasNode("Mods"))
{
return;
}
List <PQSMod> patchedMods = new List <PQSMod>();
// Get all loaded types
List <Type> types = Injector.ModTypes;
// Load mods manually because of patching
foreach (ConfigNode mod in node.GetNode("Mods").nodes)
{
// get the mod type
if (types.All(t => t.Name != mod.name))
{
continue;
}
Type loaderType = types.FirstOrDefault(t => t.Name == mod.name);
string testName = mod.name != "LandControl" ? "PQSMod_" + mod.name : "PQSLandControl";
Type modType = types.FirstOrDefault(t => t.Name == testName);
if (loaderType == null || modType == null)
{
Debug.LogError("MOD NULL: Loadertype " + mod.name + " with mod type " + testName + " and null? " + (loaderType == null) + (modType == null));
continue;
}
// Do any PQS Mods already exist on this PQS matching this mod?
IEnumerable <PQSMod> existingMods = ocean.GetComponentsInChildren <PQSMod>(true).Where(m => m.GetType() == modType &&
m.transform.parent == ocean.transform);
// Create the loader
object loader = Activator.CreateInstance(loaderType);
// Reflection, because C# being silly... :/
MethodInfo createNew = loaderType.GetMethod("Create", new Type[] { typeof(PQS) });
MethodInfo create = loaderType.GetMethod("Create", new Type[] { modType, typeof(PQS) });
if (existingMods.Any())
{
// Attempt to find a PQS mod we can edit that we have not edited before
PQSMod existingMod = existingMods.FirstOrDefault(m => !patchedMods.Contains(m) && (mod.HasValue("name") ? m.name == mod.GetValue("name") : true));
if (existingMod != null)
{
create.Invoke(loader, new object[] { existingMod, ocean });
Parser.LoadObjectFromConfigurationNode(loader, mod, "Kopernicus");
patchedMods.Add(existingMod);
Logger.Active.Log("OceanLoader.PostApply(ConfigNode): Patched PQS Mod => " + modType);
}
else
{
createNew.Invoke(loader, new object[] { ocean });
Parser.LoadObjectFromConfigurationNode(loader, mod, "Kopernicus");
Logger.Active.Log("OceanLoader.PostApply(ConfigNode): Added PQS Mod => " + modType);
}
}
else
{
createNew.Invoke(loader, new object[] { ocean });
Parser.LoadObjectFromConfigurationNode(loader, mod, "Kopernicus");
Logger.Active.Log("OceanLoader.PostApply(ConfigNode): Added PQS Mod => " + modType);
}
}
}
public VertexSimplexNoiseColor(PQSMod template)
{
_mod = template as PQSMod_VertexSimplexNoiseColor;
_mod.transform.parent = Utility.Deactivator;
base.mod = _mod;
}
public TangentTextureRanges(PQSMod template)
{
_mod = template as PQSMod_TangentTextureRanges;
_mod.transform.parent = Utility.Deactivator;
base.mod = _mod;
}
public VertexHeightOblate(PQSMod template)
{
_mod = template as PQSMod_OblateFixed;
_mod.transform.parent = Utility.Deactivator;
base.mod = _mod;
}
public CreateSphereCollider(PQSMod template)
{
_mod = template as PQSMod_CreateSphereCollider;
_mod.transform.parent = Utility.Deactivator;
base.mod = _mod;
}
private void ModDecal(PQSMod m, ConfigNode node)
{
Type mType = m.GetType();
bool city = mType == typeof(PQSCity);
if (node.HasValue("latitude") && node.HasValue("longitude"))
{
// get the field to set
FieldInfo posField = null;
string fname = city ? "repositionRadial" : "position";
foreach(FieldInfo fi in mType.GetFields())
if (fi.Name == fname)
{
posField = fi;
break;
}
// Get the lat and long
double lat, lon;
double.TryParse(node.GetValue("latitude"), out lat);
double.TryParse(node.GetValue("longitude"), out lon);
Vector3 posV = Utility.LLAtoECEF(lat, lon, 0, m.sphere.radius);
if (posField != null)
posField.SetValue(m, posV);
}
if (city)
{
if (node.HasValue("lodvisibleRangeMult"))
{
PQSCity mod = m as PQSCity;
double dtmp;
if (double.TryParse(node.GetValue("lodvisibleRangeMult"), out dtmp))
foreach (PQSCity.LODRange l in mod.lod)
l.visibleRange = (float)(dtmp * l.visibleRange);
}
}
}
public MapDecal(PQSMod template)
{
_mod = template as PQSMod_MapDecal;
_mod.transform.parent = Utility.Deactivator;
base.mod = _mod;
}
public OceanFX(PQSMod template)
{
_mod = template as PQSMod_OceanFX;
_mod.transform.parent = Utility.Deactivator;
base.mod = _mod;
}
public HeightColorMapNoise(PQSMod template)
{
_mod = template as PQSMod_HeightColorMapNoise;
_mod.transform.parent = Utility.Deactivator;
base.mod = _mod;
}
public MaterialQuadRelative(PQSMod template)
{
_mod = template as PQSMod_MaterialQuadRelative;
_mod.transform.parent = Utility.Deactivator;
base.mod = _mod;
}
public AerialPerspectiveMaterial(PQSMod template)
{
_mod = template as PQSMod_AerialPerspectiveMaterial;
_mod.transform.parent = Utility.Deactivator;
base.mod = _mod;
}
public VertexSimplexHeightMap(PQSMod template)
{
_mod = template as PQSMod_VertexSimplexHeightMap;
_mod.transform.parent = Utility.Deactivator;
base.mod = _mod;
}
public VertexPlanet(PQSMod template)
{
_mod = template as PQSMod_VertexPlanet;
_mod.transform.parent = Utility.Deactivator;
base.mod = _mod;
}
public BlockActivation(PQSMod template)
{
_mod = template as PQSMod_BlockActivation;
_mod.transform.parent = Utility.Deactivator;
base.mod = _mod;
}
//PQS Modder PT1
private void PQSModderPT1()
{
//Todo: swap with switch?
if( pqsModderStage == 1 )
{
PQSModderPT2();
return;
}
if( pqsModderStage == 2 )
{
PQSModderPT3();
return;
}
if( pqsModderStage == 3 )
{
PQSAdderFunc();
return;
}
int yoffset = 280;
if( TemplateName == "" )
{
GUI.Label( new Rect( 20 , yoffset, 200, 20), "No planet selected!" );
return;
}
List<PQS> norm_PqsList = new List<PQS>();
foreach( PQS pqs in Utils.FindLocal(TemplateName).GetComponentsInChildren<PQS>() )
{
norm_PqsList.Add( pqs );
}
List<PQSMod> PqsList = new List<PQSMod>();
foreach( PQSMod pqs in Utils.FindLocal(TemplateName).GetComponentsInChildren(typeof( PQSMod )) )
{
PqsList.Add( pqs );
}
int trimmedScrollSize = ((PqsList.Count() + norm_PqsList.Count() )*30) + 90;
ScrollPosition2 = GUI.BeginScrollView( new Rect( 0, 260, 420, 250 ), ScrollPosition2 ,new Rect( 0,250,450,trimmedScrollSize));
foreach (PQS pqs in norm_PqsList)
{
if( GUI.Button( new Rect( 20, yoffset, 400, 20 ), ""+pqs ) )
{
//TemplateName = body.celestialBody.name;
pqstoMod = pqs;
pqsModderStage = 2;
}
yoffset += 30;
}
foreach (PQSMod pqs in PqsList)
{
if( GUI.Button( new Rect( 20, yoffset, 400, 20 ), ""+pqs ) )
{
//TemplateName = body.celestialBody.name;
pqsmodtoMod = pqs;
pqsModderStage = 1;
}if( GUI.Button( new Rect( 420, yoffset, 20, 20 ), "?" ) ){(NewWindows[ "HelpWindow" ] as HelpWindow).CustomToggle( ""+pqs.GetType() ); }
yoffset += 30;
}
yoffset += 30;
if( GUI.Button( new Rect( 20, yoffset, 400, 20 ), "Add new PQSMod" ) )
{
pqsModderStage = 3;
}if( GUI.Button( new Rect( 420, yoffset, 20, 20 ), "?" ) ){(NewWindows[ "HelpWindow" ] as HelpWindow).CustomToggle( "PQSAdder" ); }
GUI.EndScrollView();
}
public VertexHeightNoiseVertHeightCurve3(PQSMod template)
{
_mod = template as PQSMod_VertexHeightNoiseVertHeightCurve3;
_mod.transform.parent = Utility.Deactivator;
base.mod = _mod;
}
public SmoothLatitudeRange(PQSMod template)
{
_mod = template as PQSMod_SmoothLatitudeRange;
_mod.transform.parent = Utility.Deactivator;
base.mod = _mod;
}
public VoronoiCraters(PQSMod template)
{
_mod = template as PQSMod_VoronoiCraters;
_mod.transform.parent = Utility.Deactivator;
base.mod = _mod;
}
public AltitudeAlpha(PQSMod template)
{
_mod = template as PQSMod_AltitudeAlpha;
_mod.transform.parent = Utility.Deactivator;
base.mod = _mod;
}
