public static Vector3 GetOffset(Vector3 atPosition, Transform cameraTransform)
{
HB hb = HB.Instance;
if (hb == null)
{
return(new Vector3(0.0f, 0.0f, 0.0f));
}
Vector3 offset;
HBSettings settings = GetSettings();
#if UNITY_EDITOR
if (settings.AttachToCameraInEditor)
{
offset = HBUtils.GetOffset(atPosition, settings, cameraTransform);
}
else
{
offset = HBUtils.GetOffset(atPosition, settings);
}
#else
offset = HBUtils.GetOffset(atPosition, settings, cameraTransform);
#endif
return(offset);
}
private void OnDrawGizmos()
{
Vector3 position;
HBSettings settings = new HBSettings(BendingMode);
if (AttachToCamera)
{
if (Camera.main == null)
{
return;
}
position = Camera.main.transform.position + Vector3.Scale(new Vector3(HorizonXOffset, HorizonYOffset, HorizonZOffset), settings.Mask);
}
else
{
position = transform.position + Vector3.Scale(new Vector3(HorizonXOffset, HorizonYOffset, HorizonZOffset), settings.Mask);
}
if (FixBoundsRadius > 0.1f)
{
Handles.color = Color.yellow;
Handles.DrawWireDisc(position, settings.Up, FixBoundsRadius);
if (Mathf.Abs(m_appliedRadius - FixBoundsRadius) >= 0.2f)
{
Handles.Label(position + transform.forward * FixBoundsRadius, "Fix Bounds Radius");
}
}
if (m_appliedRadius > 0.1f)
{
Handles.color = Color.green;
Handles.DrawWireDisc(position, settings.Up, m_appliedRadius);
Handles.Label(position + transform.forward * m_appliedRadius, "Fixed Radius");
}
Gizmos.color = Color.magenta;
Handles.color = Color.magenta;
Handles.DrawWireDisc(position, settings.Up, Flatten);
if (Flatten > 0.1f)
{
Handles.Label(position + transform.forward * Flatten, "Flatten");
}
}
public static void ApplyAll(float curvature, float flatten, float horizonX, float horizonY, float horizonZ, Transform transform = null)
{
HB hb = HB.Instance;
if (hb == null)
{
return;
}
hb.Curvature = curvature;
hb.Flatten = flatten;
hb.HorizonXOffset = horizonX;
hb.HorizonYOffset = horizonY;
hb.HorizonZOffset = horizonZ;
HBSettings settings = GetSettings();
HBUtils.HorizonBend(settings, transform);
}
public Vector3 HBOffset()
{
HBSettings settings = new HBSettings(BendingMode, Curvature * HB.CURVATURE_FACTOR, Flatten, HorizonXOffset, HorizonYOffset, HorizonZOffset, false);
return(HBUtils.GetOffset(settings, FixBoundsRadius));
}
public static Vector3 GetOffset(HBSettings settings, float radius)
{
Vector3 atPoint = Vector3.Scale(new Vector3(settings.HorizonXOffset, settings.HorizonYOffset, settings.HorizonZOffset), settings.Mask) + settings.Gradient * radius;
return(HBUtils.GetOffset(atPoint, settings, null));
}
public static Vector3 GetOffset(Vector3 point, HBSettings settings, Transform camera = null)
{
if (settings.AttachToCameraInEditor)
{
if (camera == null)
{
throw new ArgumentNullException("camera");
}
point -= camera.position;
}
switch (settings.BendingMode)
{
case BendingMode._HB_XY_ZUP:
{
float d1 = Mathf.Max(0, Mathf.Abs(settings.HorizonXOffset - point.x) - settings.Flatten);
float d2 = Mathf.Max(0, Mathf.Abs(settings.HorizonYOffset - point.y) - settings.Flatten);
float offset = (d1 * d1 + d2 * d2) * settings.Curvature;
return(new Vector3(0.0f, 0.0f, offset));
}
case BendingMode._HB_X_ZUP:
{
float d1 = Mathf.Max(0, Mathf.Abs(settings.HorizonYOffset - point.y) - settings.Flatten);
float offset = d1 * d1 * settings.Curvature;
return(new Vector3(0.0f, 0.0f, offset));
}
case BendingMode._HB_Y_ZUP:
{
float d2 = Mathf.Max(0, Mathf.Abs(settings.HorizonXOffset - point.x) - settings.Flatten);
float offset = d2 * d2 * settings.Curvature;
return(new Vector3(0.0f, 0.0f, offset));
}
case BendingMode._HB_XZ_YUP:
{
float d1 = Mathf.Max(0, Mathf.Abs(settings.HorizonXOffset - point.x) - settings.Flatten);
float d2 = Mathf.Max(0, Mathf.Abs(settings.HorizonZOffset - point.z) - settings.Flatten);
float offset = (d1 * d1 + d2 * d2) * settings.Curvature;
return(new Vector3(0.0f, offset, 0.0f));
}
case BendingMode._HB_X_YUP:
{
float d1 = Mathf.Max(0, Mathf.Abs(settings.HorizonZOffset - point.z) - settings.Flatten);
float offset = d1 * d1 * settings.Curvature;
return(new Vector3(0.0f, offset, 0.0f));
}
case BendingMode._HB_Z_YUP:
{
float d2 = Mathf.Max(0, Mathf.Abs(settings.HorizonXOffset - point.x) - settings.Flatten);
float offset = d2 * d2 * settings.Curvature;
return(new Vector3(0.0f, offset, 0.0f));
}
case BendingMode._HB_YZ_XUP:
{
float d1 = Mathf.Max(0, Mathf.Abs(settings.HorizonYOffset - point.y) - settings.Flatten);
float d2 = Mathf.Max(0, Mathf.Abs(settings.HorizonZOffset - point.z) - settings.Flatten);
float offset = (d1 * d1 + d2 * d2) * settings.Curvature;
return(new Vector3(offset, 0.0f, 0.0f));
}
case BendingMode._HB_Y_XUP:
{
float d1 = Mathf.Max(0, Mathf.Abs(settings.HorizonZOffset - point.z) - settings.Flatten);
float offset = d1 * d1 * settings.Curvature;
return(new Vector3(offset, 0.0f, 0.0f));
}
case BendingMode._HB_Z_XUP:
{
float d2 = Mathf.Max(0, Mathf.Abs(settings.HorizonYOffset - point.y) - settings.Flatten);
float offset = d2 * d2 * settings.Curvature;
return(new Vector3(offset, 0.0f, 0.0f));
}
default:
{
return(new Vector3(0.0f, 0.0f, 0.0f));
}
}
}
private static bool GetNextRayOrigin(Ray ray, float stride, float curvatureRadius, HBSettings settings, Transform camera, out Vector3 nextRayOrigin)
{
Vector3 directionNorm = Vector3.Scale(ray.direction, settings.Mask);
directionNorm.Normalize();
Vector3 direction = directionNorm * stride + ray.origin;
Plane plane = new Plane(-directionNorm, direction);
Vector3 offset = GetOffset(direction, settings, camera);
float distanceToPlane;
if (plane.Raycast(ray, out distanceToPlane))
{
Vector3 result = ray.GetPoint(distanceToPlane) + offset;
nextRayOrigin = result;
return(true);
}
nextRayOrigin = new Vector3(Mathf.Infinity, Mathf.Infinity, Mathf.Infinity);
return(false);
}
private static void RayToRays(Transform cameraTransform, Ray ray, float stride, float curvatureRadius, HBSettings settings, out Ray[] rays, out float[] maxDistances)
{
if (stride <= 0.0f)
{
throw new ArgumentOutOfRangeException("stride", "stride <= 0.0");
}
float length = stride;
int raysCount = Mathf.CeilToInt(Mathf.Max(curvatureRadius - settings.Flatten, 0.0f) / stride);
if (settings.Flatten > 0)
{
length = settings.Flatten;
raysCount++;
}
rays = new Ray[raysCount];
maxDistances = new float[raysCount];
Vector3 prevOrigin = ray.origin + GetOffset(ray.origin, settings, cameraTransform);
for (int i = 0; i < raysCount; ++i)
{
Vector3 nextRayOrigin;
if (GetNextRayOrigin(ray, length, curvatureRadius, settings, cameraTransform, out nextRayOrigin))
{
rays[i] = new Ray(prevOrigin, nextRayOrigin - prevOrigin);
maxDistances[i] = (nextRayOrigin - prevOrigin).magnitude;
prevOrigin = nextRayOrigin;
length += stride;
}
else
{
rays[i] = new Ray(prevOrigin, ray.direction);
maxDistances[maxDistances.Length - 1] = Mathf.Infinity;
Array.Resize(ref rays, i + 1);
Array.Resize(ref maxDistances, i + 1);
break;
}
}
}
public static void ScreenPointToRays(Camera camera, float stride, float curvatureRadius, HBSettings settings, out Ray[] rays, out float[] maxDistances)
{
Ray ray = camera.ScreenPointToRay(Input.mousePosition);
RayToRays(camera.transform, ray, stride, curvatureRadius, settings, out rays, out maxDistances);
}
public static void CameraToRays(Transform cameraTransform, float stride, float curvatureRadius, HBSettings settings, out Ray[] rays, out float[] maxDistances)
{
Ray ray = new Ray(cameraTransform.position, cameraTransform.forward);
RayToRays(cameraTransform, ray, stride, curvatureRadius, settings, out rays, out maxDistances);
}
public static void HorizonBend(HBSettings settings, Transform transform = null)
{
HBCurvature(settings.Curvature);
HBFlatten(settings.Flatten);
HBHorizonOffset(settings.HorizonXOffset, settings.HorizonYOffset, settings.HorizonZOffset, transform);
}