public override void OnVertexBuild(PQS.VertexBuildData data)
{
var height = (data.vertHeight - sphere.radiusMin) / (sphere.radiusMax - sphere.radiusMin);
height = Mathf.Clamp((float)height, 0, 1);
LandClass curLandClass = null;
LandClass nextLandClass = null;
for (var i = 0; i < landClasses.Length; i++)
{
var lc = landClasses[i];
if (height >= lc.altStart && height <= lc.altEnd)
{
curLandClass = lc;
if (lerp && i + 1 < landClasses.Length)
nextLandClass = landClasses[i + 1];
break;
}
}
if (curLandClass == null)
{
data.vertColor = Color.red;
}
else if (nextLandClass == null)
{
data.vertColor = Color.Lerp(data.vertColor, curLandClass.color, blend);
}
else
{
data.vertColor = Color.Lerp(data.vertColor, Color.Lerp(curLandClass.color, nextLandClass.color,
(float)((height - curLandClass.altStart) / (curLandClass.altEnd - curLandClass.altStart))), blend);
}
}
// Manipulate the terrain
public override void OnVertexBuildHeight(PQS.VertexBuildData data)
{
// Loop through the Deformations
foreach (Deformation deformation in deformations)
{
// Normalize the deformation position
Vector3d positionNorm = deformation.position.normalized;
// Get a "normalizer"
double normalized = deformation.position.normalized.x / deformation.position.x;
// Get the distance between the deformation and the VertexBuildData
float distance = (float)Vector3d.Distance(deformation.position.normalized, data.directionFromCenter);
// If we are near enough...
if (distance <= (deformation.width * 0.5) * normalized)
{
// ... lower height
double vertHeight = data.vertHeight - deformation.depth;
// If the body has an ocean, set a limit
if (sphere.mapOcean)
vertHeight = Math.Max(sphere.radius + 5d, vertHeight);
// Set the new height
data.vertHeight = vertHeight;
}
}
}
public new void OnVertexBuild(PQS.VertexBuildData data)
{
if (data.vertHeight < sphere.radius+5)
{
data.vertColor = Color.red;
}
}
public void OnVertexBuildHeight(PQS.VertexBuildData vbData)
{
if(vbData.vertHeight<minAlt)
{
minAlt=vbData.vertHeight;
//print("new minAlt "+minAlt);
}
}
internal void CloneFrom(PQS ocean)
{
FieldInfo[] fields = typeof(PQS).GetFields(BindingFlags.Public | BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.FlattenHierarchy);
foreach (FieldInfo f in fields)
{
f.SetValue(this, f.GetValue(ocean));
}
}
private PQS GetOcean()
{
if (_ocean == null || mainBody != part.vessel.mainBody)
{
mainBody = part.vessel.mainBody;
_ocean = mainBody.GetComponentsInChildren<PQS>(true).FirstOrDefault(p => p.name == mainBody.transform.name + "Ocean");
}
return _ocean;
}
// Add the management handler to the PQS
public static void AddHandler(PQS pqsVersion)
{
PQSMod_OnDemandHandler handler = new GameObject("OnDemandHandler").AddComponent<PQSMod_OnDemandHandler>();
handler.transform.parent = pqsVersion.transform;
UnityEngine.Object.DontDestroyOnLoad(handler);
handler.sphere = pqsVersion;
handler.order = 1;
handlers[pqsVersion] = handler;
}
/// <summary>
/// Returns the ground's altitude above sea level at this geo position.
/// </summary>
/// <returns></returns>
public ScalarValue GetTerrainAltitude()
{
double alt = 0.0;
PQS bodyPQS = Body.pqsController;
if (bodyPQS != null) // The sun has no terrain. Everything else has a PQScontroller.
{
// The PQS controller gives the theoretical ideal smooth surface curve terrain.
// The actual ground that exists in-game that you land on, however, is the terrain
// polygon mesh which is built dynamically from the PQS controller's altitude values,
// and it only approximates the PQS controller. The discrepancy between the two
// can be as high as 20 meters on relatively mild rolling terrain and is probably worse
// in mountainous terrain with steeper slopes. It also varies with the user terrain detail
// graphics setting.
// Therefore the algorithm here is this: Get the PQS ideal terrain altitude first.
// Then try using RayCast to get the actual terrain altitude, which will only work
// if the LAT/LONG is near the active vessel so the relevant terrain polygons are
// loaded. If the RayCast hit works, it overrides the PQS altitude.
// PQS controller ideal altitude value:
// -------------------------------------
// The vector the pqs GetSurfaceHeight method expects is a vector in the following
// reference frame:
// Origin = body center.
// X axis = LATLNG(0,0), Y axis = LATLNG(90,0)(north pole), Z axis = LATLNG(0,-90).
// Using that reference frame, you tell GetSurfaceHeight what the "up" vector is pointing through
// the spot on the surface you're querying for.
var bodyUpVector = new Vector3d(1, 0, 0);
bodyUpVector = QuaternionD.AngleAxis(Latitude, Vector3d.forward /*around Z axis*/) * bodyUpVector;
bodyUpVector = QuaternionD.AngleAxis(Longitude, Vector3d.down /*around -Y axis*/) * bodyUpVector;
alt = bodyPQS.GetSurfaceHeight(bodyUpVector) - bodyPQS.radius;
// Terrain polygon raycasting:
// ---------------------------
const double HIGH_AGL = 1000.0;
const double POINT_AGL = 800.0;
// a point hopefully above the terrain:
Vector3d worldRayCastStart = Body.GetWorldSurfacePosition(Latitude, Longitude, alt + HIGH_AGL);
// a point a bit below it, to aim down to the terrain:
Vector3d worldRayCastStop = Body.GetWorldSurfacePosition(Latitude, Longitude, alt + POINT_AGL);
RaycastHit hit;
if (Physics.Raycast(worldRayCastStart, (worldRayCastStop - worldRayCastStart), out hit, float.MaxValue, 1 << TERRAIN_MASK_BIT))
{
// Ensure hit is on the topside of planet, near the worldRayCastStart, not on the far side.
if (Mathf.Abs(hit.distance) < 3000)
{
// Okay a hit was found, use it instead of PQS alt:
alt = ((alt + HIGH_AGL) - hit.distance);
}
}
}
return(alt);
}
// Add the management handler to the PQS
public static void AddHandler(PQS pqsVersion)
{
PQSMod_OnDemandHandler handler = new GameObject("OnDemandHandler").AddComponent <PQSMod_OnDemandHandler>();
handler.transform.parent = pqsVersion.transform;
Object.DontDestroyOnLoad(handler);
handler.sphere = pqsVersion;
handler.order = 1;
Handlers[pqsVersion] = handler;
}
public static T[] GetPQSMods <T>(this PQS pqs) where T : PQSMod
{
List <T> mods = new List <T> ();
foreach (var mod in pqs.GetComponentsInChildren <T>())
{
mods.Add(mod);
}
return(mods.ToArray());
}
// Create the mod
public override void Create(PQS pqsVersion)
{
base.Create(pqsVersion);
// Construct the internal objects.
mod.curveMultiplier = new PQSMod_VertexHeightNoiseVertHeightCurve3.SimplexNoise();
mod.deformity = new PQSMod_VertexHeightNoiseVertHeightCurve3.SimplexNoise();
mod.ridgedAdd = new PQSMod_VertexHeightNoiseVertHeightCurve3.RidgedNoise();
mod.ridgedSub = new PQSMod_VertexHeightNoiseVertHeightCurve3.RidgedNoise();
}
} // So many ifs.....
// Cinically stolen from Waypoint Manager source code :D
private void PlaceTargetAtCursor()
{
CelestialBody targetBody = this.vessel.mainBody;
if (targetBody.pqsController == null)
{
return;
}
Ray mouseRay = PlanetariumCamera.Camera.ScreenPointToRay(Input.mousePosition);
mouseRay.origin = ScaledSpace.ScaledToLocalSpace(mouseRay.origin);
var bodyToOrigin = mouseRay.origin - targetBody.position;
double curRadius = targetBody.pqsController.radiusMax;
double lastRadius = 0;
int loops = 0;
while (loops < 50)
{
Vector3d relSurfacePosition;
if (PQS.LineSphereIntersection(bodyToOrigin, mouseRay.direction, curRadius, out relSurfacePosition))
{
var surfacePoint = targetBody.position + relSurfacePosition;
double alt = targetBody.pqsController.GetSurfaceHeight(
QuaternionD.AngleAxis(targetBody.GetLongitude(surfacePoint), Vector3d.down) * QuaternionD.AngleAxis(targetBody.GetLatitude(surfacePoint), Vector3d.forward) * Vector3d.right);
double error = Math.Abs(curRadius - alt);
if (error < (targetBody.pqsController.radiusMax - targetBody.pqsController.radiusMin) / 100)
{
targetLatitude = (targetBody.GetLatitude(surfacePoint) + 360) % 360;
targetLongitude = (targetBody.GetLongitude(surfacePoint) + 360) % 360;
return;
}
else
{
lastRadius = curRadius;
curRadius = alt;
loops++;
}
}
else
{
if (loops == 0)
{
break;
}
// Went too low, needs to try higher
else
{
curRadius = (lastRadius * 9 + curRadius) / 10;
loops++;
}
}
}
}
// Create the mod
public override void Create(PQS pqsVersion)
{
base.Create(pqsVersion);
// Create the base mod
PQSMod_VoronoiCraters clone =
Utility.FindBody(Injector.StockSystemPrefab.rootBody, "Mun").pqsVersion
.GetComponentsInChildren <PQSMod_VoronoiCraters>(true)[0];
Utility.CopyObjectFields(clone, Mod, false);
}
//HackHack
public static PQSMod AddPQSMod(PQS mainSphere, Type ofType)
{
var newgob = new GameObject();
var newComponent = (PQSMod)newgob.AddComponent(ofType);
newgob.name = ("" + ofType);
newgob.transform.parent = mainSphere.gameObject.transform;
newComponent.sphere = mainSphere;
return(newComponent);
}
/// <summary>
/// Corutine to rebuild parts of a PQS sphere
/// </summary>
public static IEnumerator RebuildSphere(PQ[] quads, PQS pqs)
{
for (Int32 i = 0; i < quads.Length; i++)
{
PQ quad = quads[i];
quad.isBuilt = false;
quad.isBuilt = pqs.BuildQuad(quad);
pqs.GetType().GetMethod("UpdateEdgeNormals", BindingFlags.Instance | BindingFlags.NonPublic).Invoke(pqs, new[] { quad });
yield return null;
}
}
public static void removeStockOceans()
{
Material invisibleOceanMaterial = new Material(ShaderReplacer.Instance.LoadedShaders[("Scatterer/invisible")]);
FakeOceanPQS[] fakes = (FakeOceanPQS[])FakeOceanPQS.FindObjectsOfType(typeof(FakeOceanPQS));
// if we haven't already added ocean disablers
if (fakes.Length == 0)
{
foreach (ScattererCelestialBody sctBody in Scatterer.Instance.planetsConfigsReader.scattererCelestialBodies)
{
if (sctBody.hasOcean)
{
bool removed = false;
var celBody = Scatterer.Instance.scattererCelestialBodiesManager.CelestialBodies.SingleOrDefault(_cb => _cb.bodyName == sctBody.celestialBodyName);
if (celBody == null)
{
celBody = Scatterer.Instance.scattererCelestialBodiesManager.CelestialBodies.SingleOrDefault(_cb => _cb.bodyName == sctBody.transformName);
}
if (celBody != null)
{
PQS pqs = celBody.pqsController;
if ((pqs != null) && (pqs.ChildSpheres != null) && (pqs.ChildSpheres.Count() != 0))
{
PQS ocean = pqs.ChildSpheres [0];
if (ocean != null)
{
//Add the material to hide it in the first few frames when switching back from map mode, and also just in case
ocean.surfaceMaterial = invisibleOceanMaterial;
ocean.surfaceMaterial.SetOverrideTag("IgnoreProjector", "True");
ocean.surfaceMaterial.SetOverrideTag("ForceNoShadowCasting", "True");
GameObject go = new GameObject();
FakeOceanPQS fakeOcean = go.AddComponent <FakeOceanPQS> ();
fakeOcean.Apply(ocean);
removed = true;
}
}
}
if (!removed)
{
Utils.LogDebug("Couldn't remove stock ocean for " + sctBody.celestialBodyName);
}
}
}
Utils.LogDebug("Removed stock oceans");
}
else
{
Utils.LogDebug("Stock oceans already removed");
}
}
public static PQSMod AddPQSMod( PQS mainSphere, Type ofType )
{
//HackHack
var newGObj = new GameObject();
var newComponent = (PQSMod)newGObj.AddComponent(ofType);
newGObj.name = (""+ofType);
newGObj.name.Replace( "PQSMod_", "_");
newGObj.transform.parent = mainSphere.gameObject.transform;
newComponent.sphere = mainSphere;
return newComponent;
}
// Runtime Constructor
public OceanLoader(PQS ocean)
{
this.ocean = ocean;
ocean.surfaceMaterial = new PQSOceanSurfaceQuadLoader(ocean.surfaceMaterial);
surfaceMaterial = ocean.surfaceMaterial;
surfaceMaterial.name = Guid.NewGuid().ToString();
fallbackMaterial = new PQSOceanSurfaceQuadFallbackLoader(ocean.fallbackMaterial);
ocean.fallbackMaterial = fallbackMaterial;
fallbackMaterial.name = Guid.NewGuid().ToString();
}
public static T AddMod <T>(PQS sphere, Int32 order) where T : PQSMod
{
GameObject modObject = new GameObject(typeof(T).Name);
modObject.transform.parent = sphere.transform;
T mod = modObject.AddComponent <T>();
mod.modEnabled = true;
mod.order = order;
mod.sphere = sphere;
return(mod);
}
public static void DumpPQS(PQS pqs)
{
// bool
print("PQS " + pqs.name);
print("buildTangents = " + pqs.buildTangents);
print("isActive = " + pqs.isActive);
print("isAlive = " + pqs.isAlive);
print("isBuildingMaps = " + pqs.isBuildingMaps);
print("isDisabled = " + pqs.isDisabled);
print("isStarted = " + pqs.isStarted);
print("isSubdivisionEnabled = " + pqs.isSubdivisionEnabled);
print("isThinking = " + pqs.isThinking);
print("quadAllowBuild = " + pqs.quadAllowBuild);
print("surfaceRelativeQuads = " + pqs.surfaceRelativeQuads);
print("useSharedMaterial = " + pqs.useSharedMaterial);
print("circumference = " + pqs.circumference);
// double
print("collapseAltitudeMax = " + pqs.collapseAltitudeMax);
print("collapseAltitudeValue = " + pqs.collapseAltitudeValue);
print("collapseDelta = " + pqs.collapseDelta);
print("collapseSeaLevelValue = " + pqs.collapseSeaLevelValue);
print("collapseThreshold = " + pqs.collapseThreshold);
print("detailAltitudeMax = " + pqs.detailAltitudeMax);
print("detailAltitudeQuads = " + pqs.detailAltitudeQuads);
print("detailDelta = " + pqs.detailDelta);
print("detailRad = " + pqs.detailRad);
print("detailSeaLevelQuads = " + pqs.detailSeaLevelQuads);
print("horizonAngle = " + pqs.horizonAngle);
print("horizonDistance = " + pqs.horizonDistance);
print("mapMaxHeight = " + pqs.mapMaxHeight);
print("mapOceanHeight = " + pqs.mapOceanHeight);
print("maxDetailDistance = " + pqs.maxDetailDistance);
print("minDetailDistance = " + pqs.minDetailDistance);
print("radius = " + pqs.radius);
print("radiusDelta = " + pqs.radiusDelta);
print("radiusMax = " + pqs.radiusMax);
print("radiusMin = " + pqs.radiusMin);
print("radiusSquared = " + pqs.radiusSquared);
print("subdivisionThreshold = " + pqs.subdivisionThreshold);
print("sx = " + pqs.sx);
print("sy = " + pqs.sy);
print("targetHeight = " + pqs.targetHeight);
print("targetSpeed = " + pqs.targetSpeed);
print("visibleAltitude = " + pqs.visibleAltitude);
print("visibleRadius = " + pqs.visibleRadius);
print("visRad = " + pqs.visRad);
print("visRadAltitudeMax = " + pqs.visRadAltitudeMax);
print("visRadAltitudeValue = " + pqs.visRadAltitudeValue);
print("visRadDelta = " + pqs.visRadDelta);
print("visRadSeaLevelValue = " + pqs.visRadSeaLevelValue);
print("parentSphere = " + pqs.parentSphere);
print("****************************************");
}
protected override void SetupPQS(PQS pqs)
{
//new heightmap
var height = pqs.GetPQSMod <PQSMod_VertexHeightMap> ();
height.heightMap = MapSO.CreateInstance <MapSO> ();
height.heightMapDeformity = 20000;
var heightMap = Utils.LoadTexture("Height/Moho_height.png");
height.heightMap.CreateMap(MapSO.MapDepth.Greyscale, heightMap);
GameObject.Destroy(heightMap);
//setup fine details
var simplexAbsolute = pqs.GetPQSMod <PQSMod_VertexSimplexHeightAbsolute> ();
simplexAbsolute.deformity = 100;
var simplex = pqs.GetPQSMod <PQSMod_VertexSimplexHeight> ();
simplex.modEnabled = false;
//remove old colormap
var noiseColor = pqs.GetPQSMod <PQSMod_VertexSimplexNoiseColor> ();
noiseColor.modEnabled = false;
var heightColor = pqs.GetPQSMod <PQSMod_HeightColorMap> ();
heightColor.modEnabled = false;
var _Color = pqs.transform.FindChild("_Color").gameObject;
var colorRamp = _Color.AddComponent <PQSMod_HeightColorRamp> ();
var ramp = new PQSMod_HeightColorRamp.ColorRamp();
ramp.Add(Utils.Color(101, 48, 37), Utils.Color(104, 65, 58), -100f);
ramp.Add(Utils.Color(118, 40, 25), Utils.Color(129, 64, 50), 3900f);
ramp.Add(Utils.Color(155, 123, 105), Utils.Color(121, 102, 91), 13000f);
ramp.Add(Utils.Color(90, 69, 57), Utils.Color(95, 79, 70), 17000f);
ramp.Add(Utils.Color(115, 105, 100), Utils.Color(152, 148, 145), 20000f);
ramp.Add(Utils.Color(115, 105, 100), Utils.Color(152, 148, 145), 100000f);
//TODO: make ramp
colorRamp.Ramp = ramp;
colorRamp.simplex = new Simplex(666, 6, 0.6, 6); //>:D
colorRamp.BaseColorBias = 0.1f;
colorRamp.modEnabled = true;
colorRamp.order = 202;
colorRamp.sphere = pqs;
pqs.RebuildSphere();
}
/// <summary>
/// Get the altitude of the surface at a point directly under where the vessel will be at
/// the specified time.
/// </summary>
/// <param name="vessel"></param>
/// <param name="universalTime"></param>
/// <param name="currentUniversalTime"></param>
/// <returns></returns>
private static double SurfaceAltitudeAtTime(Vessel vessel, double universalTime, double currentUniversalTime)
{
// Note that the actual *exact* surface height will be different from what this function returns.
// That's because this function simply uses the PQS controller, which gives a theoretical ideal
// smooth-surface-curve terrain. The actual game adds polygons into the mix, which can throw the
// number off by 20 meters or more. Useful discussion (and code to work around it) is here,
// in the GetTerrainAltitude function:
// https://github.com/KSP-KOS/KOS/blob/develop/src/kOS/Suffixed/GeoCoordinates.cs#L136
// Solving the problem to get a perfectly accurate number requires doing physics ray-casting.
// For the purposes of *this* mod, the ballpark figure from PQS is good enough, so we don't
// bother with the extra computation to get an exact number.
// Thanks to DMagic for pointing me at how SCANSat does these calculations:
// https://github.com/S-C-A-N/SCANsat/blob/release/SCANsat/SCANcontroller.cs#L2065-L2073
// If the main body has no PQS controller (e.g. the sun), all surface altitudes are implicitly zero.
PQS pqs = vessel.mainBody.pqsController;
if (pqs == null)
{
return(0);
}
// Where will the vessel be at that time?
Vector3d position = vessel.orbit.getPositionAtUT(universalTime);
// How much will the body have rotated by then?
double rotationDegrees = 0;
if (vessel.mainBody.rotates)
{
double numRotations = (universalTime - currentUniversalTime) / vessel.mainBody.rotationPeriod;
rotationDegrees = 360.0 * numRotations;
}
// What will the latitude and longitude be at that time, in radians?
double latitude = vessel.mainBody.GetLatitude(position);
double longitude = vessel.mainBody.GetLongitude(position) - rotationDegrees;
// Convert that to a unit radial vector.
Vector3d radialVector = new Vector3d(1, 0, 0);
radialVector = QuaternionD.AngleAxis(latitude, Vector3d.forward) * radialVector;
radialVector = QuaternionD.AngleAxis(longitude, Vector3d.down) * radialVector;
// Now we can get the surface height.
double surfaceHeight = pqs.GetSurfaceHeight(radialVector) - pqs.radius;
// If we're over water, then this altitude will be the height of the ocean floor,
// which we're not interested in. Report that as zero.
return((vessel.mainBody.ocean && (surfaceHeight < 0)) ? 0 : surfaceHeight);
}
private PQS GetOcean()
{
if (_ocean != null && _mainBody == Part.vessel.mainBody)
{
return(_ocean);
}
_mainBody = Part.vessel.mainBody;
_ocean = _mainBody.GetComponentsInChildren <PQS>(true)
.FirstOrDefault(p => p.name == _mainBody.transform.name + "Ocean");
return(_ocean);
}
/**
* Constructor for pre-existing PQS
*
* @param pqsVersion Existing PQS to augment
**/
public PQSLoader(PQS pqsVersion)
{
this.pqsVersion = pqsVersion;
// Get the required PQS information
transform = pqsVersion.GetComponentsInChildren <PQSMod_CelestialBodyTransform> (true).Where(mod => mod.transform.parent == pqsVersion.transform).FirstOrDefault();
lightDirection = pqsVersion.GetComponentsInChildren <PQSMod_MaterialSetDirection>(true).Where(mod => mod.transform.parent == pqsVersion.transform).FirstOrDefault();
uvs = pqsVersion.GetComponentsInChildren <PQSMod_UVPlanetRelativePosition>(true).Where(mod => mod.transform.parent == pqsVersion.transform).FirstOrDefault();
collider = pqsVersion.GetComponentsInChildren <PQSMod_QuadMeshColliders>(true).Where(mod => mod.transform.parent == pqsVersion.transform).FirstOrDefault();
// Create physics material editor
physicsMaterial = new PhysicsMaterialParser(collider.physicsMaterial);
}
// Create the mod
public override void Create(PQSMod_VoronoiCraters _mod, PQS pqsVersion)
{
base.Create(_mod, pqsVersion);
// Create the base mod if needed
if (mod.craterColourRamp == null)
{
PQSMod_VoronoiCraters clone =
Utility.FindBody(Injector.StockSystemPrefab.rootBody, "Mun").pqsVersion
.GetComponentsInChildren <PQSMod_VoronoiCraters>(true)[0] as PQSMod_VoronoiCraters;
Utility.CopyObjectFields(clone, base.mod, false);
}
}
// Creates the a PQSMod of type T with given PQS
public override void Create(PQS pqsVersion)
{
base.Create(pqsVersion);
// Create the callback list
LandClasses = new CallbackList <LandClassLoader>(e =>
{
Mod.landClasses = LandClasses.Where(landClass => !landClass.Delete)
.Select(landClass => landClass.Value).ToArray();
Mod.lcCount = Mod.landClasses.Length;
});
Mod.landClasses = new PQSMod_HeightBiomeMap.LandClass[Mod.lcCount = 0];
}
// Creates the a PQSMod of type T with given PQS
public override void Create(PQS pqsVersion)
{
base.Create(pqsVersion);
// Create the callback list
landClasses = new CallbackList <LandClassLoader> ((e) =>
{
mod.landClasses = landClasses.Where(landClass => !landClass.delete)
.Select(landClass => landClass.Value).ToArray();
mod.lcCount = mod.landClasses.Length;
});
mod.landClasses = new PQSMod_HeightColorMap2.LandClass[mod.lcCount = 0];
}
// Post apply event
void IParserEventSubscriber.PostApply(ConfigNode node)
{
// Should we remove the atmosphere
if (body.celestialBody.atmosphere && removeAtmosphere.value)
{
// Find atmosphere from ground and destroy the game object
AtmosphereFromGround atmosphere = body.scaledVersion.GetComponentsInChildren <AtmosphereFromGround>(true)[0];
atmosphere.transform.parent = null;
UnityEngine.Object.Destroy(atmosphere.gameObject);
// Destroy the light controller
MaterialSetDirection light = body.scaledVersion.GetComponentsInChildren <MaterialSetDirection>(true)[0];
UnityEngine.Object.Destroy(light);
// No more atmosphere :(
body.celestialBody.atmosphere = false;
}
// Should we remove the ocean?
if (body.celestialBody.ocean && removeOcean.value)
{
// Find atmosphere the ocean PQS
PQS ocean = body.pqsVersion.GetComponentsInChildren <PQS>(true).Where(pqs => pqs != body.pqsVersion).First();
PQSMod_CelestialBodyTransform cbt = body.pqsVersion.GetComponentsInChildren <PQSMod_CelestialBodyTransform>(true).First();
// Destroy the ocean PQS (this could be bad - destroying the secondary fades...)
cbt.planetFade.secondaryRenderers.Remove(ocean.gameObject);
cbt.secondaryFades = null;
ocean.transform.parent = null;
UnityEngine.Object.Destroy(ocean);
// No more ocean :(
body.celestialBody.ocean = false;
}
// Figure out what kind of body we are
if (body.scaledVersion.GetComponentsInChildren(typeof(ScaledSun), true).Length > 0)
{
type = BodyType.Star;
}
else if (body.celestialBody.atmosphere)
{
type = BodyType.Atmospheric;
}
else
{
type = BodyType.Vacuum;
}
Debug.Log("[Kopernicus]: Configuration.Template: Using Template \"" + body.celestialBody.bodyName + "\"");
}
// Runtime Constructor
public OceanLoader(PQS ocean)
{
this.ocean = ocean;
this.body = Part.GetComponentUpwards <CelestialBody>(ocean.gameObject);
pqsVersion = body.pqsController;
ocean.surfaceMaterial = new PQSOceanSurfaceQuadLoader(ocean.surfaceMaterial);
surfaceMaterial = ocean.surfaceMaterial;
surfaceMaterial.name = Guid.NewGuid().ToString();
fallbackMaterial = new PQSOceanSurfaceQuadFallbackLoader(ocean.fallbackMaterial);
ocean.fallbackMaterial = fallbackMaterial;
fallbackMaterial.name = Guid.NewGuid().ToString();
}
static Coordinates Search(CelestialBody body, Ray mouseRay)
{
if (body == null || body.pqsController == null)
{
return(null);
}
Vector3d relSurfacePosition;
Vector3d relOrigin = mouseRay.origin - body.position;
double curRadius = body.pqsController.radiusMax;
double lastRadius = 0;
double error = 0;
int loops = 0;
float st = Time.time;
while (loops < 50)
{
if (PQS.LineSphereIntersection(relOrigin, mouseRay.direction, curRadius, out relSurfacePosition))
{
var alt = body.pqsController.GetSurfaceHeight(relSurfacePosition);
if (body.ocean && alt < body.Radius)
{
alt = body.Radius;
}
error = Math.Abs(curRadius - alt);
if (error < (body.pqsController.radiusMax - body.pqsController.radiusMin) / 100)
{
return(Coordinates.SurfacePoint(body.position + relSurfacePosition, body));
}
else
{
lastRadius = curRadius;
curRadius = alt;
loops++;
}
}
else
{
if (loops == 0)
{
break;
}
else
{ // Went too low, needs to try higher
curRadius = (lastRadius * 9 + curRadius) / 10;
loops++;
}
}
}
return(null);
}
// Constructor for pre-existing PQS
public PQSLoader(PQS pqsVersion)
{
this.pqsVersion = pqsVersion;
// Get the required PQS information
transform = pqsVersion.GetComponentsInChildren <PQSMod_CelestialBodyTransform> (true).Where(mod => mod.transform.parent == pqsVersion.transform).FirstOrDefault();
lightDirection = pqsVersion.GetComponentsInChildren <PQSMod_MaterialSetDirection>(true).Where(mod => mod.transform.parent == pqsVersion.transform).FirstOrDefault();
uvs = pqsVersion.GetComponentsInChildren <PQSMod_UVPlanetRelativePosition>(true).Where(mod => mod.transform.parent == pqsVersion.transform).FirstOrDefault();
collider = pqsVersion.GetComponentsInChildren <PQSMod_QuadMeshColliders>(true).Where(mod => mod.transform.parent == pqsVersion.transform).FirstOrDefault();
// Create physics material editor
physicsMaterial = new PhysicsMaterialParser(collider.physicsMaterial);
// Clone the surface material of the PQS
if (PQSMainOptimised.UsesSameShader(pqsVersion.surfaceMaterial))
{
pqsVersion.surfaceMaterial = new PQSMainOptimisedLoader(pqsVersion.surfaceMaterial);
if (((PQSMainOptimisedLoader)pqsVersion.surfaceMaterial).globalDensity < 2)
{
((PQSMainOptimisedLoader)pqsVersion.surfaceMaterial).globalDensity = -8E-06f;
}
}
else if (PQSMainShader.UsesSameShader(pqsVersion.surfaceMaterial))
{
pqsVersion.surfaceMaterial = new PQSMainShaderLoader(pqsVersion.surfaceMaterial);
if (((PQSMainShaderLoader)pqsVersion.surfaceMaterial).globalDensity < 2)
{
((PQSMainShaderLoader)pqsVersion.surfaceMaterial).globalDensity = -8E-06f;
}
}
else if (PQSProjectionAerialQuadRelative.UsesSameShader(pqsVersion.surfaceMaterial))
{
pqsVersion.surfaceMaterial = new PQSProjectionAerialQuadRelativeLoader(pqsVersion.surfaceMaterial);
if (((PQSProjectionAerialQuadRelativeLoader)pqsVersion.surfaceMaterial).globalDensity < 2)
{
((PQSProjectionAerialQuadRelativeLoader)pqsVersion.surfaceMaterial).globalDensity = -8E-06f;
}
}
else if (PQSProjectionSurfaceQuad.UsesSameShader(pqsVersion.surfaceMaterial))
{
pqsVersion.surfaceMaterial = new PQSProjectionSurfaceQuadLoader(pqsVersion.surfaceMaterial);
}
surfaceMaterial = pqsVersion.surfaceMaterial;
surfaceMaterial.name = Guid.NewGuid().ToString();
// Clone the fallback material of the PQS
fallbackMaterial = new PQSProjectionFallbackLoader(pqsVersion.fallbackMaterial);
pqsVersion.fallbackMaterial = fallbackMaterial;
fallbackMaterial.name = Guid.NewGuid().ToString();
}
public override void Create(PQS pqsVersion)
{
base.Create(pqsVersion);
Shader blend1 = Shader.Find("Terrain/PQS/PQS Triplanar Zoom Rotation Texture Array - 1 Blend");
Shader blend2 = Shader.Find("Terrain/PQS/PQS Triplanar Zoom Rotation Texture Array - 2 Blend");
Shader blend3 = Shader.Find("Terrain/PQS/PQS Triplanar Zoom Rotation Texture Array - 3 Blend");
Shader blend4 = Shader.Find("Terrain/PQS/PQS Triplanar Zoom Rotation Texture Array - 4 Blend");
Mod.material1Blend = new Material(blend1);
Mod.material2Blend = new Material(blend2);
Mod.material3Blend = new Material(blend3);
Mod.material4Blend = new Material(blend4);
}
// Inspired by Hyperedit landing functions
// https://github.com/Ezriilc/HyperEdit
private Vector3d GetVesselPosition()
{
PQS pqs = vessel.mainBody.pqsController;
if (null == pqs)
{
return(ZERO);
}
double alt = pqs.GetSurfaceHeight(vessel.mainBody.GetRelSurfaceNVector(0, 0)) - vessel.mainBody.Radius;
alt = Math.Max(alt, 0); // Underwater!
return(vessel.mainBody.GetRelSurfacePosition(0, 0, alt));
}
public void Apply(PQS pqs)
{
if (pqs != null)
{
this.sphere = pqs;
this.transform.parent = pqs.transform;
this.requirements = PQS.ModiferRequirements.Default;
this.modEnabled = true;
this.order = 10;
this.transform.localPosition = Vector3.zero;
this.transform.localRotation = Quaternion.identity;
this.transform.localScale = Vector3.one;
}
}
public static void Button_Select( int i )
{
List<PQS> norm_PqsList = new List<PQS>();
foreach( PQS pqs in GameObject.FindObjectsOfType(typeof( PQS )) )
{
norm_PqsList.Add( pqs );
}
ReturnedPQS = norm_PqsList[i];
Debug.Log( "DEBUG: Selected "+ReturnedPQS.name+"\n");
PlanetToolsUiController.NewWindows[ "PQSSelector" ].ToggleWindow();
//PlanetToolsUiController.NewWindows[ "PQSSelector" ].ToggleWindow();
}
public static void Init()
{
if (!setup)
{
UnityEngine.Object[] celestialBodies = CelestialBody.FindObjectsOfType(typeof(CelestialBody));
foreach (CelestialBody cb in celestialBodies)
{
CelestialBodyList.Add(cb);
if (cb.name == "Kerbin")
{
CurrentPQS = cb.pqsController;
}
}
setup = true;
}
}
public void Update()
{
mainPQS = attachedTo.mainBody.gameObject.GetComponent <PQS>();
curPos = attachedTo.transform.position;
if (attachedTo.heightFromSurface < 100 && attachedTo.verticalSpeed > 100) //Allow planet impact if within range...
{
CanImpact = true;
attachedTo.rootPart.explode();
}
if (AsteriodType == 1)
{
//Comet stuff
}
}
// Create the mod
public override void Create(PQS pqsVersion)
{
// Call base
base.Create(pqsVersion);
// Create the base mod (I need to instance this one, because some parameters aren't loadable. :( )
PSystemBody body = Utility.FindBody(Injector.StockSystemPrefab.rootBody, "Laythe");
foreach (PQS ocean in body.pqsVersion.GetComponentsInChildren <PQS>(true))
{
if (ocean.name == "LaytheOcean")
{
Utility.CopyObjectFields(ocean.GetComponentsInChildren <PQSMod_OceanFX>(true)[0], Mod);
}
}
}
public static Coordinates GetMouseCoordinates(CelestialBody body)
{
Ray mouseRay = PlanetariumCamera.Camera.ScreenPointToRay(Input.mousePosition);
mouseRay.origin = ScaledSpace.ScaledToLocalSpace(mouseRay.origin);
Vector3d relOrigin = mouseRay.origin - body.position;
Vector3d relSurfacePosition;
double curRadius = body.pqsController.radiusMax;
double lastRadius = 0;
double error = 0;
int loops = 0;
float st = Time.time;
while (loops < 50)
{
if (PQS.LineSphereIntersection(relOrigin, mouseRay.direction, curRadius, out relSurfacePosition))
{
Vector3d surfacePoint = body.position + relSurfacePosition;
double alt = body.pqsController.GetSurfaceHeight(QuaternionD.AngleAxis(body.GetLongitude(surfacePoint), Vector3d.down) * QuaternionD.AngleAxis(body.GetLatitude(surfacePoint), Vector3d.forward) * Vector3d.right);
error = Math.Abs(curRadius - alt);
if (error < (body.pqsController.radiusMax - body.pqsController.radiusMin) / 100)
{
return(new Coordinates(body.GetLatitude(surfacePoint), MuUtils.ClampDegrees180(body.GetLongitude(surfacePoint))));
}
else
{
lastRadius = curRadius;
curRadius = alt;
loops++;
}
}
else
{
if (loops == 0)
{
break;
}
else
{ // Went too low, needs to try higher
curRadius = (lastRadius * 9 + curRadius) / 10;
loops++;
}
}
}
return(null);
}
static public void Button_Select(int i)
{
List <PQS> norm_PqsList = new List <PQS>();
foreach (PQS pqs in GameObject.FindObjectsOfType(typeof(PQS)))
{
norm_PqsList.Add(pqs);
}
ReturnedPQS = norm_PqsList[i];
Debug.Log("DEBUG: Selected " + ReturnedPQS.name + "\n");
PlanetToolsUiController.NewWindows["PQSSelector"].ToggleWindow();
//PlanetToolsUiController.NewWindows[ "PQSSelector" ].ToggleWindow();
}
// Manipulate the terrain
public override void OnVertexBuildHeight(PQS.VertexBuildData data)
{
// Loop through the Deformations
foreach (Deformation deformation in deformations)
{
// Get the angle between the two directions
Double cos = Vector3d.Dot(deformation.position.normalized, data.directionFromCenter);
// Determine the distance between the two points
Double distance = Math.Sqrt(data.vertHeight * data.vertHeight + deformation.altitude * deformation.altitude - 2 * data.vertHeight * deformation.altitude * cos);
// Determine whether the two positions are near enough
if (distance <= deformation.GetDiameter() * 10)
{
data.vertHeight -= deformation.GetDiameter() * (distance / deformation.GetDiameter()) * 0.5;
}
}
}
public CelestialObject(GameObject parentObject)
{
CelestialGameObject = parentObject;
CelestialBodyComponent = parentObject.GetComponentInChildren<CelestialBody>();
PQSComponent = parentObject.GetComponentInChildren<PQS>();
if (CelestialBodyComponent == null)
Extensions.LogError("Could not obtain CelestialBody component from: " + parentObject.name);
if (PQSComponent == null)
Extensions.LogError("Could not obtain PQS component from: " + parentObject.name);
}
private void InstantiateStatic(PQS celestialPQS, StaticObject stObject, bool freshObject = false)
{
#region Staitc Object Core Parameters
float visibilityRange = stObject.VisRange;
float localRotationAngle = stObject.RotAngle;
float radiusOffset = stObject.RadOffset;
string modelUrl = stObject.ModelUrl;
Vector3 orientDirection = stObject.Orientation;
Vector3 radialPosition = stObject.RadPosition;
if (radialPosition == Vector3.zero)
{
radialPosition =
_currentCelestialObj.CelestialBodyComponent.transform.InverseTransformPoint(
FlightGlobals.ActiveVessel.transform.position);
stObject.RadPosition = radialPosition;
}
if (orientDirection == Vector3.zero)
{
orientDirection = Vector3.up;
stObject.Orientation = orientDirection;
}
stObject.Latitude = GetLatitude(radialPosition);
stObject.Longitude = GetLongitude(radialPosition);
#endregion
// Instantiate
GameObject ktGameObject = GameDatabase.Instance.GetModel(modelUrl);
// Add the reference component.
var soModule = ktGameObject.AddComponent<StaticObjectModule>();
// Active the game object.
ktGameObject.SetActive(true);
// Set objects to layer 15 so that they collide correctly with Kerbals.
SetLayerRecursively(ktGameObject, 15);
// Set the parent object to the celestial component's GameObject.
ktGameObject.transform.parent = celestialPQS.transform;
// Obtain all active transforms in the static game object.
Transform[] gameObjectList = ktGameObject.GetComponentsInChildren<Transform>();
// Create a list of renderers to be manipulated by the default PQSCity class.
List<GameObject> rendererList =
(from t in gameObjectList where t.gameObject.renderer != null select t.gameObject).ToList();
// Create the LOD range.
_myLodRange = new PQSCity.LODRange
{
renderers = rendererList.ToArray(),
objects = new GameObject[0],
//new[] {staticGameObject}, // Todo: change to GameObject children.
visibleRange = visibilityRange
};
// Add the PQSCity class (extended by KerbTown).
var myCity = ktGameObject.AddComponent<PQSCityEx>();
// Assign PQSCity variables.
myCity.lod = new[] {_myLodRange};
myCity.frameDelta = 1;
myCity.repositionToSphere = true;
myCity.repositionToSphereSurface = false;
myCity.repositionRadial = radialPosition;
myCity.repositionRadiusOffset = radiusOffset;
myCity.reorientFinalAngle = localRotationAngle;
myCity.reorientToSphere = true;
myCity.reorientInitialUp = orientDirection;
myCity.sphere = celestialPQS;
myCity.order = 100;
myCity.modEnabled = true;
// Assign custom variables.
myCity.StaticObjectRef = stObject;
// Setup and orientate the PQSCity instanced object.
myCity.OnSetup();
myCity.Orientate();
// If the object was instantiated by "Create", override all renderers to active.
if (freshObject)
{
foreach (GameObject renObj in rendererList)
renObj.renderer.enabled = true;
}
// Add component references to the static object.
stObject.PQSCityComponent = myCity;
stObject.StaticGameObject = ktGameObject;
//stObject.ModuleReference = soModule;
// Add the static object as a reference to the StaticObjectModule
soModule.StaticObjectRef = stObject;
// Add remaining modules.
switch (stObject.ObjectID)
{
case "MushroomCave":
AddNativeComponent(ktGameObject, typeof (MushroomCave));
break;
case "PurplePathway":
AddNativeComponent(ktGameObject, typeof (PurplePathway));
break;
default:
AddModuleComponents(stObject);
break;
}
// Alter the Launch Site spawn object name if necessary.
// Todo: optimize
if (stObject.LaunchSiteName != "")
{
Transform launchSiteObject =
ktGameObject.transform.Cast<Transform>().FirstOrDefault(t => t.name.EndsWith("_spawn"));
if (launchSiteObject != null)
{
launchSiteObject.name = stObject.LaunchSiteName + "_spawn";
}
else
{
Extensions.LogWarning("Launch Site '" + ktGameObject.name + "'does not have a spawn transform.");
}
}
}
private bool PatchPQS(PQS pqs, ConfigNode node)
{
bool pqsChanged = false;
double oldR = pqs.radius;
if (node.HasValue("radius"))
double.TryParse(node.GetValue("radius"), out pqs.radius);
if (pqs.radius != oldR)
pqsChanged = true;
List<PQSMod> mods;
if (node.HasNode("Mods"))
{
mods = pqs.transform.GetComponentsInChildren<PQSMod>(true).Where(m => m.sphere == pqs).ToList<PQSMod>();
foreach (ConfigNode modNode in node.GetNode("Mods").nodes)
{
PQSMod delMod = null;
foreach (PQSMod m in mods)
{
Type mType = m.GetType();
if (mType.ToString() != modNode.name)
continue;
if (modNode.HasValue("name"))
if (m.name != modNode.GetValue("name"))
continue;
if(modNode.name != "PQSMod_CelestialBodyTransform") // not really a change
pqsChanged = true;
ParseObject(m, modNode);
if (mType == typeof(PQSCity) || mType == typeof(PQSMod_MapDecal) || mType == typeof(PQSMod_MapDecalTangent))
ModDecal(m, modNode);
delMod = m;
break;
}
// If we found the mod, remove from the list since we edited it.
if (delMod != null)
mods.Remove(delMod);
}
}
// Get the whole list again.
mods = pqs.transform.GetComponentsInChildren<PQSMod>(true).Where(m => m.sphere == pqs).ToList<PQSMod>();
if (node.HasNode("RemoveMods"))
{
List<GameObject> toCheck = new List<GameObject>();
foreach (ConfigNode modNode in node.GetNode("RemoveMods").nodes)
{
PQSMod delMod = null;
foreach (PQSMod m in mods)
{
Type mType = m.GetType();
if (mType.ToString() != modNode.name)
continue;
if (modNode.HasValue("name"))
if (m.name != modNode.GetValue("name"))
continue;
delMod = m;
break;
}
// If we found the mod, remove from the list since we edited it.
if (delMod != null)
{
pqsChanged = true;
toCheck.Add(delMod.gameObject);
mods.Remove(delMod);
delMod.sphere = null;
PQSMod.DestroyImmediate(delMod);
}
}
Utility.RemoveEmptyGO(toCheck);
}
// add some mods
if(node.HasNode("AddMods"))
{
AddModLoader newMods = Parser.CreateObjectFromConfigNode<AddModLoader>(node);
if (newMods.mods != null)
{
foreach (ModLoader loader in newMods.mods)
{
loader.mod.transform.parent = pqs.transform;
loader.mod.sphere = pqs;
loader.mod.transform.gameObject.SetLayerRecursive(Constants.GameLayers.LocalSpace);
}
}
}
// just in case, run setup for everyone.
mods = pqs.transform.GetComponentsInChildren<PQSMod>(true).Where(m => m.sphere == pqs).ToList<PQSMod>();
foreach (var m in mods)
{
m.OnSetup();
m.OnPostSetup();
}
try
{
pqs.RebuildSphere();
}
catch (Exception e)
{
Logger.Active.Log("Rebuild sphere for " + node.name + " failed: " + e.Message);
}
return pqsChanged;
}
// Re-arrange the Vertex Build order
public override void OnVertexBuild(PQS.VertexBuildData data)
{
// Do nothing
// base.OnVertexBuild(data);
}
static bool PQSisNotNull (PQS pqs)
{
return pqs;
}
//HackHack
public static PQSMod AddPQSMod( PQS mainSphere, Type ofType )
{
var newgob = new GameObject();
var newComponent = (PQSMod)newgob.AddComponent(ofType);
newgob.name = (""+ofType);
newgob.transform.parent = mainSphere.gameObject.transform;
newComponent.sphere = mainSphere;
return newComponent;
}
public override void OnVertexBuildHeight(PQS.VertexBuildData vbData)
{
var hei = Math.Sin(3.14159265358979 * vbData.v);
hei = Math.Pow(hei, power);
vbData.vertHeight = vbData.vertHeight + hei * offset;
}
/// <summary>
/// Find quads that are near a transform
/// </summary>
public static PQ[] FindNearbyQuads(PQS pqsVersion, Vector3d position, Int32 count)
{
IEnumerable<PQ> quads = pqsVersion.GetComponentsInChildren<PQ>(true);
quads = quads.OrderBy(q => Vector3.Distance(q.quadTransform.position, position)).Take(count);
return quads.ToArray();
}
//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();
}
//Initialization
public void Start()
{
m_radius=m_manager.GetRadius();
Rt = (Rt / Rg) * m_radius;
RL = (RL / Rg) * m_radius;
Rg = m_radius;
// old mesh, causes artifacts with aniso
// m_mesh = MeshFactory.MakePlane(2, 2, MeshFactory.PLANE.XY, false,false);
// m_mesh.bounds = new Bounds(parentCelestialBody.transform.position, new Vector3(1e8f,1e8f, 1e8f));
m_mesh = isoSphere.Create ();
m_mesh.bounds = new Bounds(parentCelestialBody.transform.position, new Vector3(1e8f,1e8f, 1e8f));
//The sky map is used to create a reflection of the sky for objects that need it (like the ocean)
// m_skyMap = new RenderTexture(512, 512, 0, RenderTextureFormat.ARGBHalf);
// m_skyMap.filterMode = FilterMode.Trilinear;
// m_skyMap.wrapMode = TextureWrapMode.Clamp;
// m_skyMap.anisoLevel = 9;
// m_skyMap.useMipMap = true;
// //m_skyMap.mipMapBias = -0.5f;
// m_skyMap.Create();
//Inscatter is responsible for the change in the sky color as the sun moves
//The raw file is a 4D array of 32 bit floats with a range of 0 to 1.589844
//As there is not such thing as a 4D texture the data is packed into a 3D texture
//and the shader manually performs the sample for the 4th dimension
m_inscatter = new RenderTexture(RES_MU_S * RES_NU, RES_MU * RES_R, 0, RenderTextureFormat.ARGBHalf);
m_inscatter.wrapMode = TextureWrapMode.Clamp;
m_inscatter.filterMode = FilterMode.Bilinear;
//Transmittance is responsible for the change in the sun color as it moves
//The raw file is a 2D array of 32 bit floats with a range of 0 to 1
m_transmit = new RenderTexture(TRANSMITTANCE_W, TRANSMITTANCE_H, 0, RenderTextureFormat.ARGBHalf);
m_transmit.wrapMode = TextureWrapMode.Clamp;
m_transmit.filterMode = FilterMode.Bilinear;
//Irradiance is responsible for the change in the sky color as the sun moves
//The raw file is a 2D array of 32 bit floats with a range of 0 to 1
m_irradiance = new RenderTexture(SKY_W, SKY_H, 0, RenderTextureFormat.ARGBHalf);
m_irradiance.wrapMode = TextureWrapMode.Clamp;
m_irradiance.filterMode = FilterMode.Bilinear;
initiateOrRestart ();
m_skyMaterial=new Material(ShaderTool.GetMatFromShader2("CompiledSky.shader"));
m_skyMaterialScaled=new Material(ShaderTool.GetMatFromShader2("CompiledSkyScaled.shader"));
//m_skyMapMaterial=new Material(ShaderTool.GetMatFromShader2("CompiledSkyMap.shader"));
//m_skyMaterial.renderQueue = 2000;
sunGlare = new Texture2D (512, 512);
black = new Texture2D (512, 512);
string codeBase = Assembly.GetExecutingAssembly().CodeBase;
UriBuilder uri = new UriBuilder(codeBase);
string path = Uri.UnescapeDataString(uri.Path);
path=Path.GetDirectoryName (path);
sunGlare.LoadImage(System.IO.File.ReadAllBytes(String.Format("{0}/{1}", path + m_filePath, "sunglare.png")));
black.LoadImage(System.IO.File.ReadAllBytes(String.Format("{0}/{1}", path + m_filePath, "black.png")));
if (sunGlare == null)
{
print ("SUNGLARE NULL");
}
else
{
sunGlare.wrapMode = TextureWrapMode.Clamp;
m_skyMaterial.SetTexture("_Sun_Glare", sunGlare);
}
m_skyMaterialScaled.SetTexture("_Sun_Glare", black);
InitUniforms(m_skyMaterial);
InitUniforms(m_skyMaterialScaled);
// InitUniforms(m_skyMapMaterial);
m_atmosphereMaterial = ShaderTool.GetMatFromShader2 ("CompiledAtmosphericScatter.shader");
//aniso defaults to to forceEnable on higher visual settings and causes artifacts
//no longer needed since I switched to the new mesh
//QualitySettings.anisotropicFiltering = AnisotropicFiltering.Enable;
CurrentPQS = parentCelestialBody.pqsController;
testPQS = parentCelestialBody.pqsController;
for (int j=0; j<7; j++)
{
debugSettings[j]=true;
}
// idekk = m_skyMaterial;
// Material[] materials = Resources.FindObjectsOfTypeAll<Material>();
// foreach(Material mat in materials)
// {
// if(mat.name == "EVE/Diffuse")
// {idekk=mat;
// print("DIFFUSE MATERIAL FOUND");}
//
//
// }
//
for (int j=0; j<10; j++)
{
additionalScales[j]=1f;
}
tester = new GameObject ();
MF = tester.AddComponent<MeshFilter>();
Mesh idmesh = MF.mesh;
idmesh.Clear ();
idmesh = m_mesh;
//
tester.layer = layer;
Transform celestialTransform = ScaledSpace.Instance.scaledSpaceTransforms.Single(t => t.name == parentCelestialBody.name);
// tester.transform.parent = parentCelestialBody.transform;
tester.transform.parent = celestialTransform;
MR = tester.AddComponent<MeshRenderer>();
// InitUniforms (m_skyMaterialScaled);
// SetUniforms(m_skyMaterialScaled);
//
// MR.sharedMaterial = m_skyMaterialScaled;
// MR.material =m_skyMaterialScaled;
MR.sharedMaterial = m_skyMaterial;
MR.material =m_skyMaterial;
MR.castShadows = false;
MR.receiveShadows = false;
MR.enabled = true;
// tester.transform.localPosition = Vector3.zero;
// tester.transform.localRotation = Quaternion.identity;
// tester.transform.localScale = Vector3.one;
// MR.enabled = true;
// pSystemBodies = (PSystemBody[])UnityEngine.Object.FindObjectsOfType(typeof(PSystemBody));
// print ("NUMBER FOUND");
// print (pSystemBodies.Length);
//
// kerbinPsystemBody=ScaledSpace.Instance.transform.FindChild("Kerbin").gameObject.GetComponentInChildren<ScaledSpaceFader>();
//
// if (kerbinPsystemBody == null) {
// print ("NULL");
// }
// else{
// print ("NOT NULL");
// print("fadeStart");
//
// print(kerbinPsystemBody.fadeStart);
//
// print("fadeEnd");
//
// print(kerbinPsystemBody.fadeEnd);
//
//
// }
}
// Build the height in the correct function
public override void OnVertexBuildHeight(PQS.VertexBuildData data)
{
// Tricky...
base.OnVertexBuild(data);
}
// Runtime Constructor
public OceanLoader(PQS ocean)
{
this.ocean = ocean;
ocean.surfaceMaterial = new PQSOceanSurfaceQuadLoader(ocean.surfaceMaterial);
surfaceMaterial = ocean.surfaceMaterial;
surfaceMaterial.name = Guid.NewGuid().ToString();
fallbackMaterial = new PQSOceanSurfaceQuadFallbackLoader(ocean.fallbackMaterial);
ocean.fallbackMaterial = fallbackMaterial;
fallbackMaterial.name = Guid.NewGuid().ToString();
}
//Scaled Space Updater
private void RegenerateModel(PQS bodyPQS, MeshFilter meshfilter_input)
{
var originalVert = meshfilter_input.mesh.vertices[0];
var originalHeight = (float)bodyPQS.GetSurfaceHeight(originalVert);
var scale = originalHeight / originalVert.magnitude;
bodyPQS.isBuildingMaps = true;
var newVerts = new Vector3[meshfilter_input.mesh.vertices.Count()];
for (int i = 0; i < meshfilter_input.mesh.vertices.Count(); i++)
{
var vertex = meshfilter_input.mesh.vertices[i];
var rootrad = (float)Math.Sqrt(vertex.x * vertex.x +
vertex.y * vertex.y +
vertex.z * vertex.z);
var radius = (float)bodyPQS.GetSurfaceHeight(vertex)/scale;
//radius = 1000;
newVerts[i] = vertex * (radius / rootrad);
}
bodyPQS.isBuildingMaps = false;
meshfilter_input.mesh.vertices = newVerts;
meshfilter_input.mesh.RecalculateNormals();
Utils.RecalculateTangents(meshfilter_input.mesh);
}
//Initialization
public void Start()
{
m_radius = m_manager.GetRadius();
Rt = (Rt / Rg) * m_radius;
RL = (RL / Rg) * m_radius;
Rg = m_radius;
m_mesh = MeshFactory.MakePlane(2, 2, MeshFactory.PLANE.XY, false, false);
m_mesh.bounds = new Bounds(parentCelestialBody.transform.position, new Vector3(1e8f, 1e8f, 1e8f));
//Inscatter is responsible for the change in the sky color as the sun moves
//The raw file is a 4D array of 32 bit floats with a range of 0 to 1.589844
//As there is not such thing as a 4D texture the data is packed into a 3D texture
//and the shader manually performs the sample for the 4th dimension
m_inscatter = new RenderTexture(RES_MU_S * RES_NU, RES_MU * RES_R, 0, RenderTextureFormat.ARGBHalf);
m_inscatter.wrapMode = TextureWrapMode.Clamp;
m_inscatter.filterMode = FilterMode.Bilinear;
//Transmittance is responsible for the change in the sun color as it moves
//The raw file is a 2D array of 32 bit floats with a range of 0 to 1
m_transmit = new RenderTexture(TRANSMITTANCE_W, TRANSMITTANCE_H, 0, RenderTextureFormat.ARGBHalf);
m_transmit.wrapMode = TextureWrapMode.Clamp;
m_transmit.filterMode = FilterMode.Bilinear;
//Irradiance is responsible for the change in the sky color as the sun moves
//The raw file is a 2D array of 32 bit floats with a range of 0 to 1
m_irradiance = new RenderTexture(SKY_W, SKY_H, 0, RenderTextureFormat.ARGBHalf);
m_irradiance.wrapMode = TextureWrapMode.Clamp;
m_irradiance.filterMode = FilterMode.Bilinear;
initiateOrRestart();
m_skyMaterialScaled = new Material(ShaderTool.GetMatFromShader2("CompiledSkyScaled.shader"));
m_skyMaterialScaled.renderQueue = 2004;
m_skyExtinction = new Material(ShaderTool.GetMatFromShader2("CompiledSkyExtinction.shader"));
m_skyExtinction.renderQueue = 2002;
sunGlare = new Texture2D(512, 512);
black = new Texture2D(512, 512);
// string codeBase = Assembly.GetExecutingAssembly().CodeBase;
// UriBuilder uri = new UriBuilder(codeBase);
// path = Uri.UnescapeDataString(uri.Path);
// path=Path.GetDirectoryName (path);
path = m_manager.GetCore().path;
sunGlare.LoadImage(System.IO.File.ReadAllBytes(String.Format("{0}/{1}", path + "/config/" + parentCelestialBody.name + m_filePath, "sunglare.png")));
black.LoadImage(System.IO.File.ReadAllBytes(String.Format("{0}/{1}", path + "/config/" + parentCelestialBody.name + m_filePath, "black.png")));
sunGlare.wrapMode = TextureWrapMode.Clamp;
m_skyMaterialScaled.SetTexture("_Sun_Glare", sunGlare);
InitUniforms(m_skyMaterialScaled);
InitUniforms(m_skyExtinction);
m_atmosphereMaterial = ShaderTool.GetMatFromShader2("CompiledAtmosphericScatter.shader");
CurrentPQS = parentCelestialBody.pqsController;
testPQS = parentCelestialBody.pqsController;
for (int j = 0; j < 10; j++) {
debugSettings[j] = true;
}
for (int j = 0; j < 10; j++) {
additionalScales[j] = 1f;
}
skyObject = new GameObject();
skyMF = skyObject.AddComponent < MeshFilter > ();
Mesh idmesh = skyMF.mesh;
idmesh.Clear();
idmesh = m_mesh;
//
skyObject.layer = layer;
// celestialTransform = ScaledSpace.Instance.scaledSpaceTransforms.Single(t => t.name == parentCelestialBody.name);
celestialTransform = ParentPlanetTransform;
// skyObject.transform.parent = parentCelestialBody.transform;
skyObject.transform.parent = celestialTransform;
skyMR = skyObject.AddComponent < MeshRenderer > ();
skyMR.sharedMaterial = m_skyMaterialScaled;
skyMR.material = m_skyMaterialScaled;
skyMR.castShadows = false;
skyMR.receiveShadows = false;
///same for skyextinct
skyExtinctObject = new GameObject();
skyExtinctMF = skyExtinctObject.AddComponent < MeshFilter > ();
idmesh = skyExtinctMF.mesh;
idmesh.Clear();
idmesh = m_mesh;
//
skyExtinctObject.layer = layer;
skyExtinctObject.transform.parent = celestialTransform;
skyExtinctMR = skyExtinctObject.AddComponent < MeshRenderer > ();
skyExtinctMR.sharedMaterial = m_skyExtinction;
skyExtinctMR.material = m_skyExtinction;
skyExtinctMR.castShadows = false;
skyExtinctMR.receiveShadows = false;
hp = new SimplePostProcessCube(10000, m_atmosphereMaterial);
atmosphereMesh = hp.GameObject;
atmosphereMesh.layer = 15;
atmosphereMeshrenderer = hp.GameObject.GetComponent < MeshRenderer > ();
atmosphereMeshrenderer.material = m_atmosphereMaterial;
celestialBodies = (CelestialBody[]) CelestialBody.FindObjectsOfType(typeof(CelestialBody));
}
public static void DumpPQS(PQS pqs)
{
// bool
print("PQS " + pqs.name);
print("buildTangents = " + pqs.buildTangents);
print("isActive = " + pqs.isActive);
print("isAlive = " + pqs.isAlive);
print("isBuildingMaps = " + pqs.isBuildingMaps);
print("isDisabled = " + pqs.isDisabled);
print("isStarted = " + pqs.isStarted);
print("isSubdivisionEnabled = " + pqs.isSubdivisionEnabled);
print("isThinking = " + pqs.isThinking);
print("quadAllowBuild = " + pqs.quadAllowBuild);
print("surfaceRelativeQuads = " + pqs.surfaceRelativeQuads);
print("useSharedMaterial = " + pqs.useSharedMaterial);
print("circumference = " + pqs.circumference);
// double
print("collapseAltitudeMax = " + pqs.collapseAltitudeMax);
print("collapseAltitudeValue = " + pqs.collapseAltitudeValue);
print("collapseDelta = " + pqs.collapseDelta);
print("collapseSeaLevelValue = " + pqs.collapseSeaLevelValue);
print("collapseThreshold = " + pqs.collapseThreshold);
print("detailAltitudeMax = " + pqs.detailAltitudeMax);
print("detailAltitudeQuads = " + pqs.detailAltitudeQuads);
print("detailDelta = " + pqs.detailDelta);
print("detailRad = " + pqs.detailRad);
print("detailSeaLevelQuads = " + pqs.detailSeaLevelQuads);
print("horizonAngle = " + pqs.horizonAngle);
print("horizonDistance = " + pqs.horizonDistance);
print("mapMaxHeight = " + pqs.mapMaxHeight);
print("mapOceanHeight = " + pqs.mapOceanHeight);
print("maxDetailDistance = " + pqs.maxDetailDistance);
print("minDetailDistance = " + pqs.minDetailDistance);
print("radius = " + pqs.radius);
print("radiusDelta = " + pqs.radiusDelta);
print("radiusMax = " + pqs.radiusMax);
print("radiusMin = " + pqs.radiusMin);
print("radiusSquared = " + pqs.radiusSquared);
print("subdivisionThreshold = " + pqs.subdivisionThreshold);
print("sx = " + pqs.sx);
print("sy = " + pqs.sy);
print("targetHeight = " + pqs.targetHeight);
print("targetSpeed = " + pqs.targetSpeed);
print("visibleAltitude = " + pqs.visibleAltitude);
print("visibleRadius = " + pqs.visibleRadius);
print("visRad = " + pqs.visRad);
print("visRadAltitudeMax = " + pqs.visRadAltitudeMax);
print("visRadAltitudeValue = " + pqs.visRadAltitudeValue);
print("visRadDelta = " + pqs.visRadDelta);
print("visRadSeaLevelValue = " + pqs.visRadSeaLevelValue);
print("parentSphere = " + pqs.parentSphere);
print("****************************************");
}
public override void OnVertexBuildHeight(PQS.VertexBuildData vbData)
{
vbData.vertHeight = vbData.vertHeight + offset;
}
public static void MatchVerts(Mesh mesh, PQS pqs, double oceanHeight, float scaleFactor)
{
ProfileTimer.Push("MatchVerts");
if (pqs == null)
{
MonoBehaviour.print("ERROR matching verts: pqs is null!");
return;
}
char sep = System.IO.Path.DirectorySeparatorChar;
pqs.isBuildingMaps = true;
Vector3[] vertices = new Vector3[mesh.vertexCount];
for (int i = 0; i < mesh.vertexCount; i++)
{
Vector3 v = mesh.vertices[i];
double height = pqs.GetSurfaceHeight(v);
if (height < oceanHeight)
height = oceanHeight;
vertices[i] = v.normalized * (float)(1000.0 * height / pqs.radius * scaleFactor);
}
pqs.isBuildingMaps = false;
mesh.vertices = vertices;
ProfileTimer.Pop("MatchVerts");
}
// Constructor for pre-existing PQS
public PQSLoader(PQS pqsVersion)
{
this.pqsVersion = pqsVersion;
// Get the required PQS information
transform = pqsVersion.GetComponentsInChildren<PQSMod_CelestialBodyTransform> (true).FirstOrDefault (mod => mod.transform.parent == pqsVersion.transform);
lightDirection = pqsVersion.GetComponentsInChildren<PQSMod_MaterialSetDirection> (true).FirstOrDefault (mod => mod.transform.parent == pqsVersion.transform);
uvs = pqsVersion.GetComponentsInChildren<PQSMod_UVPlanetRelativePosition> (true).FirstOrDefault (mod => mod.transform.parent == pqsVersion.transform);
collider = pqsVersion.GetComponentsInChildren<PQSMod_QuadMeshColliders> (true).FirstOrDefault (mod => mod.transform.parent == pqsVersion.transform);
// Create physics material editor
physicsMaterial = new PhysicsMaterialParser (collider.physicsMaterial);
// Clone the surface material of the PQS
if (PQSMainOptimised.UsesSameShader(pqsVersion.surfaceMaterial))
{
pqsVersion.surfaceMaterial = new PQSMainOptimisedLoader(pqsVersion.surfaceMaterial);
if (((PQSMainOptimisedLoader)pqsVersion.surfaceMaterial).globalDensity < 2)
((PQSMainOptimisedLoader)pqsVersion.surfaceMaterial).globalDensity = -8E-06f;
}
else if (PQSMainShader.UsesSameShader(pqsVersion.surfaceMaterial))
{
pqsVersion.surfaceMaterial = new PQSMainShaderLoader(pqsVersion.surfaceMaterial);
if (((PQSMainShaderLoader)pqsVersion.surfaceMaterial).globalDensity < 2)
((PQSMainShaderLoader)pqsVersion.surfaceMaterial).globalDensity = -8E-06f;
}
else if (PQSProjectionAerialQuadRelative.UsesSameShader(pqsVersion.surfaceMaterial))
{
pqsVersion.surfaceMaterial = new PQSProjectionAerialQuadRelativeLoader(pqsVersion.surfaceMaterial);
if (((PQSProjectionAerialQuadRelativeLoader)pqsVersion.surfaceMaterial).globalDensity < 2)
((PQSProjectionAerialQuadRelativeLoader)pqsVersion.surfaceMaterial).globalDensity = -8E-06f;
}
else if (PQSProjectionSurfaceQuad.UsesSameShader(pqsVersion.surfaceMaterial))
{
pqsVersion.surfaceMaterial = new PQSProjectionSurfaceQuadLoader(pqsVersion.surfaceMaterial);
}
surfaceMaterial = pqsVersion.surfaceMaterial;
surfaceMaterial.name = Guid.NewGuid ().ToString ();
// Clone the fallback material of the PQS
fallbackMaterial = new PQSProjectionFallbackLoader (pqsVersion.fallbackMaterial);
pqsVersion.fallbackMaterial = fallbackMaterial;
fallbackMaterial.name = Guid.NewGuid ().ToString ();
}
private static void AddMapSOs(List<MapSO> list, PQS pqs)
{
PQSMod[] mods = pqs.GetComponentsInChildren<PQSMod>(true) as PQSMod[];
foreach (PQSMod m in mods)
{
foreach (FieldInfo fi in m.GetType().GetFields())
{
// this _should_ get everything derived from it.
MapSO val = fi.GetValue(m) as MapSO;
if(val != null)
if(!list.Contains(val))
list.Add(val);
}
}
}
