private void FixedUpdate()
{
if (rb && rb.position != lastRbPosition)
{
// Some system didnt set position thru FloatingOriginTransform, probably Unity physics, lets compensate for it
bigPosition = VisualSceneOrigin + rb.position;
lastRbPosition = rb.position;
}
}
// mass in g of air/atmosphere per m^3 at position, can be used to calculate drag
public float GetAirDensityAt(BigPosition position)
{
var p = ProceduralPlanets.main.GetClosestPlanet(position);
if (p == null)
{
return(0);
}
var d = BigPosition.Distance(position, p.BigPosition);
return(p.GetGravityAtDistanceFromCenter(d));
}
public Vector3 GetGravityAt(BigPosition position)
{
var p = ProceduralPlanets.main.GetClosestPlanet(position);
if (p == null)
{
return(Vector3.zero);
}
var d = BigPosition.Distance(position, p.BigPosition);
var v = (p.BigPosition - position).normalized;
return(p.GetGravityAtDistanceFromCenter(d) * v.ToVector3());
}
public Planet GetClosestPlanet(BigPosition position)
{
Planet closestPlanet = null;
var closestDistance = double.MaxValue;
foreach (var p in allPlanets)
{
var d = BigPosition.Distance(p.BigPosition, position) - p.planetConfig.radiusStart;
if (d < closestDistance)
{
closestDistance = d;
closestPlanet = p;
}
}
return(closestPlanet);
}
private float GetSizeOnScreen(Planet.PointOfInterest data)
{
var myPos = rangePosToCalculateScreenSizeOn_localToPlanet.CenterPos + planet.BigPosition;
var distanceToCamera = BigPosition.Distance(myPos, data.pos);
// TODO: this is world space, doesnt take into consideration rotation, not good,
// but we dont care about rotation, we want to have correct detail even if we are looking at chunk from side?
var sphere = rangePosToCalculateScreenSizeOn_localToPlanet.ToBoundingSphere();
var radiusWorldSpace = sphere.radius;
var fov = data.fieldOfView;
var cot = 1.0 / Mathf.Tan(fov / 2f * Mathf.Deg2Rad);
var radiusCameraSpace = radiusWorldSpace * cot / distanceToCamera;
lastDistanceToCamera = distanceToCamera;
lastRadiusWorldSpace = radiusWorldSpace;
return((float)radiusCameraSpace);
}
private void FixedUpdate()
{
if (this.transform.position.sqrMagnitude > 1000 * 1000)
{
MyProfiler.BeginSample("Floating origin / scene origin changed");
var worldPosDelta = new BigPosition(transform.position).KeepOnlySectorPos();
VisualSceneOrigin += worldPosDelta;
this.transform.position -= worldPosDelta;
foreach (var i in floatingTransforms)
{
i.SceneOriginChanged(VisualSceneOrigin);
}
MyProfiler.EndSample();
}
}
public void AddCrater(BigPosition bigPosition, float radius)
{
var planetLocalPos = this.BigPosition.Towards(bigPosition).ToVector3();
craters.cpuBuffer[craters.nextIndex] = new Vector4(planetLocalPos.x, planetLocalPos.y, planetLocalPos.z, radius);
++craters.nextIndex;
if (craters.nextIndex >= craters.cpuBuffer.Length)
{
craters.nextIndex = 0;
}
craters.gpuBuffer.SetData(craters.cpuBuffer);
foreach (var c in CollectAllChunks())
{
var s = c.rangePosToCalculateScreenSizeOn_localToPlanet.ToBoundingSphere();
if (Vector3.Distance(s.center, planetLocalPos) < s.radius + radius)
{
c.MarkForRefresh();
}
}
}
public void SceneOriginChanged(BigPosition newSceneOrigin)
{
transform.position = bigPosition - newSceneOrigin;
}
void UpdatePosition(float deltaTime)
{
var rotation = transform.rotation;
var position = transform.position;
var rb = GetComponent <Rigidbody>();
if (rb)
{
rotation = rb.rotation;
position = rb.position;
}
if (Input.GetKeyDown(KeyCode.F5))
{
savedPosition1 = position;
savedRotation1 = rotation;
}
if (Input.GetKeyDown(KeyCode.F6))
{
position = transform.position = savedPosition1;
rotation = transform.rotation = savedRotation1;
}
if (Input.GetKeyDown(KeyCode.F7))
{
savedPosition2 = position;
savedRotation2 = rotation;
}
if (Input.GetKeyDown(KeyCode.F8))
{
position = transform.position = savedPosition2;
rotation = transform.rotation = savedRotation2;
}
if (Input.GetKeyDown(KeyCode.G))
{
walkOnPlanet = !walkOnPlanet;
}
if (Input.GetKeyDown(KeyCode.T))
{
MoveToClosestPlanetSurface();
}
var mouseDelta = Vector2.zero;
if (!Cursor.visible)
{
mouseDelta = new Vector2(Input.GetAxis("Mouse X"), Input.GetAxis("Mouse Y"));
}
var scrollWheelDelta = Input.mouseScrollDelta.y;
if (Input.GetKeyDown(KeyCode.Escape))
{
/*if (Scene.Engine.WindowState == WindowState.Fullscreen)
* {
* Scene.Engine.WindowState = WindowState.Normal;
* }
* else*/
if (!Cursor.visible)
{
Cursor.lockState = CursorLockMode.None;
Cursor.visible = true;
}
else
{
Application.Quit();
}
}
if (Input.GetMouseButtonDown(0))
{
if (Cursor.visible)
{
Cursor.lockState = CursorLockMode.Locked;
Cursor.visible = false;
}
}
var planet = ProceduralPlanets.main.GetClosestPlanet(floatingOrigin.BigPosition);
if (planet != null)
{
if (Input.GetKeyDown(KeyCode.F))
{
RaycastHit hit;
if (Physics.Raycast(this.transform.position + this.transform.forward * 5, this.transform.forward, out hit, 100000.0f))
{
BigPosition bigPosition = hit.point + FloatingOriginCamera.main.VisualSceneOrigin;
planet.AddCrater(bigPosition, Random.Range(hit.distance * 0.3f, hit.distance * 0.5f));
}
}
{
RaycastHit hit;
if (Physics.Raycast(position, planet.Center - position, out hit, planet.planetConfig.radiusStart, ~LayerMask.GetMask("Ignore Raycast")))
{
distanceToClosestPlanet = Vector3.Distance(hit.point, position);
}
}
if (Input.GetKeyDown(KeyCode.R))
{
planet.markedForRegeneration = true;
}
}
else
{
distanceToClosestPlanet = float.MaxValue;
}
//if (Cursor.lockState)
{
if (scrollWheelDelta > 0)
{
cameraSpeedModifier *= 1.3f;
}
if (scrollWheelDelta < 0)
{
cameraSpeedModifier /= 1.3f;
}
cameraSpeedModifier = Mathf.Clamp(cameraSpeedModifier, 1, 100000);
float currentSpeed = cameraSpeedModifier;
if (!walkOnPlanet && speedBasedOnDistanceToPlanet)
{
var s = Mathf.Clamp(distanceToClosestPlanet, 1, 30000);
var planetSpeedModifier = (1 + (float)s / 5.0f);
currentSpeed *= planetSpeedModifier;
}
if (Input.GetKey(KeyCode.LeftShift))
{
currentSpeed *= 5;
}
var targetForce = Vector3.zero;
targetForce += Vector3.forward * Input.GetAxis("Vertical");
targetForce += Vector3.right * Input.GetAxis("Horizontal");
if (Input.GetKey(KeyCode.Space))
{
targetForce += Vector3.up;
}
if (Input.GetKey(KeyCode.LeftControl))
{
targetForce -= Vector3.up;
}
if (walkOnPlanet && distanceToClosestPlanet > 2.5f)
{
currentSpeed *= 0.1f;
}
targetForce = targetForce.normalized * currentSpeed;
float pitchDelta = 0;
float yawDelta = 0;
float rollDelta = 0;
float c = mouseSensitivty * (float)deltaTime;
yawDelta += mouseDelta.x * c;
pitchDelta -= mouseDelta.y * c;
if (Input.GetKey(KeyCode.Q))
{
rollDelta += c;
}
if (Input.GetKey(KeyCode.E))
{
rollDelta -= c;
}
if (planet != null && Input.GetKeyDown(KeyCode.C))
{
rotation = Quaternion.LookRotation(planet.Center - position);
}
if (planet != null && walkOnPlanet)
{
var up = (position - planet.Center).normalized;
var forward = walkOnPlanet_lastForward;
if (walkOnPlanet_isFirstRun)
{
walkOnPlanet_lastUp = up;
var pointOnPlanet = position - planet.Center;
forward = rotation * Vector3.forward;
}
else
{
var upDeltaAngle = Vector3.Angle(up, walkOnPlanet_lastUp);
var upDeltaRot = Quaternion.Inverse(Quaternion.AngleAxis(upDeltaAngle, Vector3.Cross(up, walkOnPlanet_lastUp)));
forward = upDeltaRot * forward;
}
var left = Vector3.Cross(up, forward);
var rotDelta = Quaternion.identity;
rotDelta = rotDelta * Quaternion.AngleAxis(pitchDelta, left);
forward = Quaternion.AngleAxis(pitchDelta, left) * forward;
if (walkOnPlanet_clampUpDownRotation)
{
// clamping up down rotation
var maxUpDownAngle = 80;
var minUp = 90 - maxUpDownAngle;
var maxDown = 90 + maxUpDownAngle;
var angle = Vector3.Angle(forward, up);
if (angle < minUp)
{
forward = Quaternion.AngleAxis(minUp, left) * up;
}
else if (angle > maxDown)
{
forward = Quaternion.AngleAxis(maxDown, left) * up;
}
}
rotDelta = rotDelta * Quaternion.AngleAxis(yawDelta, up);
forward = Quaternion.AngleAxis(yawDelta, up) * forward;
forward.Normalize();
rotation = Quaternion.LookRotation(forward, up);
walkOnPlanet_lastForward = forward;
walkOnPlanet_lastUp = up;
walkOnPlanet_isFirstRun = false;
}
else
{
var rotDelta =
Quaternion.AngleAxis(pitchDelta, new Vector3(1, 0, 0)) *
Quaternion.AngleAxis(yawDelta, new Vector3(0, 1, 0)) *
Quaternion.AngleAxis(rollDelta, new Vector3(0, 0, 1));
rotation = rotation * rotDelta;
walkOnPlanet_isFirstRun = true;
}
targetForce = rotation * targetForce;
if (rb)
{
// change friction based on whether we want to move or not
var targetFriction = 1;
if (targetForce.sqrMagnitude > 0)
{
targetFriction = 0;
}
physicMaterial.dynamicFriction = targetFriction;
physicMaterial.staticFriction = targetFriction;
rb.AddForce(targetForce * deltaTime, ForceMode.VelocityChange);
rb.MoveRotation(rotation);
//rb.drag = Mathf.InverseLerp(100, 10, distanceToClosestPlanet); // change "air density" based on distance to planet
}
else // UNTESTED
{
currentVelocity += targetForce * velocityChangeSpeed * (float)deltaTime;
currentVelocity = Vector3.Lerp(currentVelocity, Vector3.zero, (float)deltaTime);
position += currentVelocity * (float)deltaTime;
SetPosRot(position, rotation);
}
// light toggle
if (Input.GetKeyDown(KeyCode.L))
{
foreach (var l in GetComponentsInChildren <Light>())
{
l.enabled = !l.enabled;
}
}
}
}
