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); }
// 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; }