public void Update()
{
var player = getPlayerTransform();
var transform = getCameraTransform();
Vector3 playerPosition = player.position;
Torus.GetPoint(playerPosition, out TorusPointInfo pInfo);
Vector3 slope = -pInfo.minorCenterUp;
Vector3 playerUp = -pInfo.minorCenterForward;
Vector3 playerRight = -pInfo.minorCenterRight;
Vector3 targetPosition = playerPosition + slope * config.offset.z + playerUp * config.offset.y;
if (Application.isPlaying)
{
transform.position = Vector3.SmoothDamp(transform.position, targetPosition, ref velocity, config.smoothTime);
}
else
{
transform.position = targetPosition;
}
var lookAtTarget = playerPosition + slope * config.lootAtOffset.z + playerUp * config.lootAtOffset.y;
var lookAt = (lookAtTarget - transform.position).normalized;
var up = Vector3.Cross(playerRight, lookAt);
if (Application.isPlaying)
{
transform.rotation = QuaternionUtil.SmoothDamp(transform.rotation, Quaternion.LookRotation(lookAt, up), ref quaternionDeriv, config.smoothTime);
}
else
{
transform.rotation = Quaternion.LookRotation(lookAt, up);
}
}
void Update()
{
if (target)
{
Torus.GetPoint(target.position, out TorusPointInfo pInfo);
transform.position = pInfo.targetPoint + pInfo.minorCenterForward * offset.y + pInfo.minorCenterRight * offset.x + pInfo.minorCenterUp * offset.z;
transform.LookAt(target);
}
else
{
GameMain.ErrorTracking.Add($"{nameof(target)} not set on {nameof(DirectionalLightFollowPlayer)} GameObject={name}");
}
}
public void Update()
{
Reset();
if (Application.isPlaying && playerPhysicsConfig.enableMove)
{
Collide();
Rotate();
Move();
}
else
{
Torus.GetPoint(playerPhysicsConfig.debugMajorAngle, playerPhysicsConfig.debugMinorAngle, out TorusPointInfo pInfo);
transform.position = pInfo.targetPoint;
transform.rotation = Quaternion.LookRotation(-pInfo.minorCenterUp, -pInfo.minorCenterForward);
}
}
public void Update()
{
TorusPointInfo pi;
Camera cam = Camera.main;
if (!cam)
{
return;
}
// c = 2 pi r
// pi = c / (2 r)
minorIncrement = (objectSpawnerConfig.squareSize / (Torus.MinorRadius)) * Mathf.Rad2Deg;
majorIncrement = (objectSpawnerConfig.squareSize / (Torus.MajorRadius + Torus.MinorRadius)) * Mathf.Rad2Deg;
var minorPadding = (objectSpawnerConfig.padding / (Torus.MinorRadius)) * Mathf.Rad2Deg;
var majorPadding = (objectSpawnerConfig.padding / (Torus.MajorRadius + Torus.MinorRadius)) * Mathf.Rad2Deg;
minorIncrement = Mathf.Clamp(minorIncrement, 0.001f, 10f);
majorIncrement = Mathf.Clamp(majorIncrement, 0.001f, 10f);
Debug.Log($"minorIncrement:{minorIncrement} majorIncrement:{majorIncrement}");
Torus.SectionAngle angles;
Torus.ComputeCameraMinorMajorAngleOptions computeOptions;
computeOptions.majorIncrement = majorIncrement;
computeOptions.minorIncrement = minorIncrement;
computeOptions.majorPadding = majorPadding;
computeOptions.minorPadding = minorPadding;
computeOptions.landLayerMask = gameConfig.landLayerMask;
if (!Torus.ComputeCameraMinorMajorAngle(cam, computeOptions, out angles))
{
return;
}
float minMinorAngle = angles.minorStart;
float maxMinorAngle = angles.minorEnd;
float minMajorAngle = angles.majorStart;
float maxMajorAngle = angles.majorEnd;
//Torus.GetPoint(minMajorAngle, minMinorAngle, out pi);
//Debug.DrawLine(camPosition, pi.targetPoint, Color.cyan);
//Torus.GetPoint(minMajorAngle, maxMinorAngle, out pi);
//Debug.DrawLine(camPosition, pi.targetPoint, Color.cyan);
//Torus.GetPoint(maxMajorAngle, maxMinorAngle, out pi);
//Debug.DrawLine(camPosition, pi.targetPoint, Color.cyan);
//Torus.GetPoint(maxMajorAngle, minMinorAngle, out pi);
//Debug.DrawLine(camPosition, pi.targetPoint, Color.cyan);
int worldObjIdx = 0;
for (float fMa = minMajorAngle; fMa < maxMajorAngle; fMa += majorIncrement)
{
for (float fMi = minMinorAngle; fMi < maxMinorAngle; fMi += minorIncrement)
{
Torus.GetPoint(fMa, fMi, out pi);
var p = pi.targetPoint;
p *= objectSpawnerConfig.perlinScale;
float pn = (Perlin.Noise(p.x, p.y, p.z) + 1f) * .5f;
Random.InitState(p.GetHashCode());
var rdValue = Random.Range(objectSpawnerConfig.threshold, 1f);
if (!objectSpawnerConfig.filterByPerlin || (pn > objectSpawnerConfig.threshold /*&& rdValue > f*/))
{
Debug.DrawLine(pi.targetPoint, pi.targetPoint + (pi.minorCenterPoint - pi.targetPoint).normalized * pn * 2f, Color.red);
if (Application.isPlaying)
{
WorldObject wObj = worldObjects[worldObjIdx];
wObj.obj.transform.position = pi.targetPoint;
wObj.obj.transform.localScale = new Vector3(1, pn * 5f, 1);
wObj.obj.transform.rotation = Quaternion.LookRotation(-pi.minorCenterUp, -pi.minorCenterForward);
wObj.used = true;
worldObjects[worldObjIdx] = wObj;
worldObjIdx++;
if (worldObjIdx >= worldObjects.Count)
{
EditorApplication.isPaused = true;
}
}
}
}
}
if (Application.isPlaying)
{
while (worldObjects[worldObjIdx].used)
{
WorldObject wObj = worldObjects[worldObjIdx];
wObj.obj.transform.position = Vector3.zero;
wObj.obj.transform.localScale = Vector3.one;
wObj.obj.transform.rotation = Quaternion.identity;
wObj.used = false;
worldObjects[worldObjIdx] = wObj;
worldObjIdx++;
}
}
}
private void GenerateMesh(GenerateInputData inData)
{
int xSize = inData.xSize;
int ySize = inData.ySize;
Debug.Log($"generating {xSize}x{ySize} grid ...");
mesh = new Mesh();
Vector3[] vertices = new Vector3[(xSize + 1) * (ySize + 1)];
Vector3[] normals = new Vector3[(xSize + 1) * (ySize + 1)];
Vector2[] uv = new Vector2[vertices.Length];
Vector4[] tangents = new Vector4[vertices.Length];
Vector4 tangent = new Vector4(1f, 0f, 0f, -1f);
for (int i = 0, y = 0; y <= ySize; y++)
{
for (int x = 0; x <= xSize; x++, i++)
{
//vertices[i] = new Vector3(x, y);
float fMa = Mathf.Lerp(inData.minMajorAngle, inData.maxMajorAngle, (float)x / xSize);
float fMi = Mathf.Lerp(inData.minMinorAngle, inData.maxMinorAngle, (float)y / ySize);
Torus.GetPoint(fMa, fMi, out TorusPointInfo pi);
var p = pi.targetPoint;
p *= config.perlinScale;
float pF = (Perlin.Noise(p.x, p.y, p.z) + 1f) * config.perlinForce;
var finalPoint = pi.targetPoint + pF * -pi.minorCenterForward;
vertices[i] = finalPoint;
normals[i] = -pi.minorCenterForward;
//normals[i] = -Vector3.forward;
uv[i] = new Vector2((float)x / xSize, (float)y / ySize);
tangents[i] = tangent;
}
}
mesh.vertices = vertices;
int[] triangles = new int[xSize * ySize * 6];
for (int ti = 0, vi = 0, y = 0; y < ySize; y++, vi++)
{
for (int x = 0; x < xSize; x++, ti += 6, vi++)
{
triangles[ti] = vi;
triangles[ti + 3] = triangles[ti + 1] = vi + 1;
triangles[ti + 5] = triangles[ti + 2] = vi + xSize + 1;
triangles[ti + 4] = vi + xSize + 2;
}
}
mesh.triangles = triangles;
mesh.uv = uv;
mesh.normals = normals;
// mesh.RecalculateNormals();
if (!gameObject)
{
gameObject = new GameObject(gameObjectName);
gameObject.AddComponent <MeshFilter>();
gameObject.AddComponent <MeshRenderer>().sharedMaterial = config.material;
gameObject.AddComponent <MeshCollider>();
}
MeshFilter meshFilter = gameObject.GetComponent <MeshFilter>();
if (!meshFilter)
{
return;
}
meshFilter.sharedMesh = mesh;
MeshCollider meshCollider = gameObject.GetComponent <MeshCollider>();
if (!meshCollider)
{
return;
}
meshCollider.sharedMesh = mesh;
}