public static Quaternion Align(this Transform transform, Vector3 normAlignVector, TransformAxis alignmentAxis)
{
Vector3 axis = transform.up;
if (alignmentAxis != TransformAxis.PositiveY)
{
if (alignmentAxis == TransformAxis.PositiveX)
{
axis = transform.right;
}
else if (alignmentAxis == TransformAxis.NegativeX)
{
axis = -transform.right;
}
else if (alignmentAxis == TransformAxis.NegativeY)
{
axis = -transform.up;
}
else if (alignmentAxis == TransformAxis.PositiveZ)
{
axis = transform.forward;
}
else if (alignmentAxis == TransformAxis.NegativeZ)
{
axis = -transform.forward;
}
}
float alignment = Vector3.Dot(axis, normAlignVector);
if (1.0f - alignment < 1e-5f)
{
return(Quaternion.identity);
}
Vector3 rotAxis = Vector3.zero;
// Check if the alignment axis is aligned with the alignment vector in the opposite direction
if (alignment + 1.0f < 1e-5f)
{
if (alignmentAxis == TransformAxis.PositiveX)
{
rotAxis = transform.up;
}
else if (alignmentAxis == TransformAxis.NegativeX)
{
rotAxis = -transform.up;
}
else if (alignmentAxis == TransformAxis.PositiveY)
{
rotAxis = transform.right;
}
else if (alignmentAxis == TransformAxis.NegativeY)
{
rotAxis = -transform.right;
}
else if (alignmentAxis == TransformAxis.PositiveZ)
{
rotAxis = transform.up;
}
else if (alignmentAxis == TransformAxis.NegativeZ)
{
rotAxis = -transform.up;
}
}
else
{
rotAxis = Vector3.Normalize(Vector3.Cross(axis, normAlignVector));
}
float rotAngle = Vector3Ex.SignedAngle(axis, normAlignVector, rotAxis);
transform.Rotate(rotAxis, rotAngle, Space.World);
return(Quaternion.AngleAxis(rotAngle, rotAxis));
}
public static SnapResult SnapHierarchy(GameObject root, SnapConfig snapConfig)
{
const float collectEps = 1e-2f;
const float collectBoxScale = 1e-3f;
bool hierarchyHasMeshes = root.HierarchyHasMesh();
bool hierarchyHasSprites = root.HierarchyHasSprite();
if (!hierarchyHasMeshes && !hierarchyHasSprites)
{
Transform rootTransform = root.transform;
rootTransform.position = snapConfig.SurfaceHitPlane.ProjectPoint(rootTransform.position) + snapConfig.OffsetFromSurface * snapConfig.SurfaceHitNormal;
return(new SnapResult(snapConfig.SurfaceHitPlane, rootTransform.position));
}
var boundsQConfig = new ObjectBounds.QueryConfig();
boundsQConfig.ObjectTypes = GameObjectType.Sprite | GameObjectType.Mesh;
bool isSurfaceSpherical = snapConfig.SurfaceType == Type.SphericalMesh;
bool isSurfaceTerrain = snapConfig.SurfaceType == Type.UnityTerrain || snapConfig.SurfaceType == Type.TerrainMesh;
bool isSurfaceUnityTerrain = snapConfig.SurfaceType == Type.UnityTerrain;
var raycaster = CreateSurfaceRaycaster(snapConfig.SurfaceType, snapConfig.SurfaceObject, true);
if (snapConfig.SurfaceType != Type.SceneGrid)
{
Transform rootTransform = root.transform;
if (snapConfig.AlignAxis)
{
if (isSurfaceTerrain)
{
rootTransform.Align(Vector3.up, snapConfig.AlignmentAxis);
OBB hierarchyOBB = ObjectBounds.CalcHierarchyWorldOBB(root, boundsQConfig);
if (!hierarchyOBB.IsValid)
{
return(new SnapResult());
}
BoxFace pivotFace = BoxMath.GetMostAlignedFace(hierarchyOBB.Center, hierarchyOBB.Size, hierarchyOBB.Rotation, -Vector3.up);
var collectedVerts = ObjectVertexCollect.CollectHierarchyVerts(root, pivotFace, collectBoxScale, collectEps);
if (collectedVerts.Count != 0)
{
Vector3 vertsCenter = Vector3Ex.GetPointCloudCenter(collectedVerts);
Ray ray = new Ray(vertsCenter + Vector3.up * 1e-3f, -Vector3.up);
GameObjectRayHit surfaceHit = raycaster.Raycast(ray);
if (surfaceHit != null)
{
Vector3 alignmentAxis = surfaceHit.HitNormal;
if (isSurfaceUnityTerrain)
{
Terrain terrain = snapConfig.SurfaceObject.GetComponent <Terrain>();
alignmentAxis = terrain.GetInterpolatedNormal(surfaceHit.HitPoint);
}
Quaternion appliedRotation = rootTransform.Align(alignmentAxis, snapConfig.AlignmentAxis);
hierarchyOBB = ObjectBounds.CalcHierarchyWorldOBB(root, boundsQConfig);
appliedRotation.RotatePoints(collectedVerts, rootTransform.position);
Vector3 sitOnPlaneOffset = ObjectSurfaceSnap.CalculateSitOnSurfaceOffset(hierarchyOBB, new Plane(Vector3.up, surfaceHit.HitPoint), 0.1f);
rootTransform.position += sitOnPlaneOffset;
hierarchyOBB.Center += sitOnPlaneOffset;
Vector3Ex.OffsetPoints(collectedVerts, sitOnPlaneOffset);
Vector3 embedVector = ObjectSurfaceSnap.CalculateEmbedVector(collectedVerts, snapConfig.SurfaceObject, -Vector3.up, snapConfig.SurfaceType);
rootTransform.position += (embedVector + alignmentAxis * snapConfig.OffsetFromSurface);
return(new SnapResult(new Plane(alignmentAxis, surfaceHit.HitPoint), surfaceHit.HitPoint));
}
}
}
else
{
if (!isSurfaceSpherical)
{
rootTransform.Align(snapConfig.SurfaceHitNormal, snapConfig.AlignmentAxis);
OBB hierarchyOBB = ObjectBounds.CalcHierarchyWorldOBB(root, boundsQConfig);
if (!hierarchyOBB.IsValid)
{
return(new SnapResult());
}
BoxFace pivotFace = BoxMath.GetMostAlignedFace(hierarchyOBB.Center, hierarchyOBB.Size, hierarchyOBB.Rotation, -snapConfig.SurfaceHitNormal);
var collectedVerts = ObjectVertexCollect.CollectHierarchyVerts(root, pivotFace, collectBoxScale, collectEps);
if (collectedVerts.Count != 0)
{
Vector3 vertsCenter = Vector3Ex.GetPointCloudCenter(collectedVerts);
// Note: Cast the ray from far away enough so that we don't cast from the interior of the mesh.
// This can happen when the object is embedded inside the mesh surface.
AABB surfaceAABB = ObjectBounds.CalcMeshWorldAABB(snapConfig.SurfaceObject);
float sphereRadius = surfaceAABB.Extents.magnitude;
Vector3 rayOrigin = vertsCenter + snapConfig.SurfaceHitNormal * sphereRadius;
Ray ray = new Ray(rayOrigin, -snapConfig.SurfaceHitNormal);
GameObjectRayHit surfaceHit = raycaster.Raycast(ray);
if (surfaceHit != null)
{
Vector3 alignmentAxis = surfaceHit.HitNormal;
rootTransform.Align(alignmentAxis, snapConfig.AlignmentAxis);
hierarchyOBB = ObjectBounds.CalcHierarchyWorldOBB(root, boundsQConfig);
Vector3 sitOnPlaneOffset = ObjectSurfaceSnap.CalculateSitOnSurfaceOffset(hierarchyOBB, surfaceHit.HitPlane, 0.0f);
rootTransform.position += sitOnPlaneOffset;
rootTransform.position += alignmentAxis * snapConfig.OffsetFromSurface;
return(new SnapResult(new Plane(alignmentAxis, surfaceHit.HitPoint), surfaceHit.HitPoint));
}
else
{
Vector3 alignmentAxis = snapConfig.SurfaceHitNormal;
rootTransform.Align(alignmentAxis, snapConfig.AlignmentAxis);
hierarchyOBB = ObjectBounds.CalcHierarchyWorldOBB(root, boundsQConfig);
Vector3 sitOnPlaneOffset = ObjectSurfaceSnap.CalculateSitOnSurfaceOffset(hierarchyOBB, snapConfig.SurfaceHitPlane, 0.0f);
rootTransform.position += sitOnPlaneOffset;
rootTransform.position += alignmentAxis * snapConfig.OffsetFromSurface;
return(new SnapResult(snapConfig.SurfaceHitPlane, snapConfig.SurfaceHitPlane.ProjectPoint(vertsCenter)));
}
}
}
else
{
Transform surfaceObjectTransform = snapConfig.SurfaceObject.transform;
Vector3 sphereCenter = surfaceObjectTransform.position;
Vector3 radiusDir = (rootTransform.position - sphereCenter).normalized;
float sphereRadius = surfaceObjectTransform.lossyScale.GetMaxAbsComp() * 0.5f;
rootTransform.Align(radiusDir, snapConfig.AlignmentAxis);
OBB hierarchyOBB = ObjectBounds.CalcHierarchyWorldOBB(root, boundsQConfig);
if (!hierarchyOBB.IsValid)
{
return(new SnapResult());
}
BoxFace pivotFace = BoxMath.GetMostAlignedFace(hierarchyOBB.Center, hierarchyOBB.Size, hierarchyOBB.Rotation, -radiusDir);
var collectedVerts = ObjectVertexCollect.CollectHierarchyVerts(root, pivotFace, collectBoxScale, collectEps);
Vector3 sitPoint = sphereCenter + radiusDir * sphereRadius;
Plane sitPlane = new Plane(radiusDir, sitPoint);
Vector3 sitOnPlaneOffset = ObjectSurfaceSnap.CalculateSitOnSurfaceOffset(hierarchyOBB, sitPlane, 0.0f);
rootTransform.position += sitOnPlaneOffset;
hierarchyOBB.Center += sitOnPlaneOffset;
Vector3Ex.OffsetPoints(collectedVerts, sitOnPlaneOffset);
rootTransform.position += radiusDir * snapConfig.OffsetFromSurface;
return(new SnapResult(sitPlane, sitPoint));
}
}
}
else
{
OBB hierarchyOBB = ObjectBounds.CalcHierarchyWorldOBB(root, boundsQConfig);
if (!hierarchyOBB.IsValid)
{
return(new SnapResult());
}
if (isSurfaceTerrain || (!isSurfaceSpherical && snapConfig.SurfaceType == Type.Mesh))
{
Ray ray = new Ray(hierarchyOBB.Center, isSurfaceTerrain ? -Vector3.up : -snapConfig.SurfaceHitNormal);
GameObjectRayHit surfaceHit = raycaster.Raycast(ray);
if (surfaceHit != null)
{
Vector3 sitOnPlaneOffset = ObjectSurfaceSnap.CalculateSitOnSurfaceOffset(hierarchyOBB, surfaceHit.HitPlane, 0.0f);
rootTransform.position += sitOnPlaneOffset;
if (isSurfaceTerrain)
{
hierarchyOBB.Center += sitOnPlaneOffset;
BoxFace pivotFace = BoxMath.GetMostAlignedFace(hierarchyOBB.Center, hierarchyOBB.Size, hierarchyOBB.Rotation, -surfaceHit.HitNormal);
var collectedVerts = ObjectVertexCollect.CollectHierarchyVerts(root, pivotFace, collectBoxScale, collectEps);
Vector3 embedVector = ObjectSurfaceSnap.CalculateEmbedVector(collectedVerts, snapConfig.SurfaceObject, -Vector3.up, snapConfig.SurfaceType);
rootTransform.position += embedVector;
}
rootTransform.position += surfaceHit.HitNormal * snapConfig.OffsetFromSurface;
return(new SnapResult(surfaceHit.HitPlane, surfaceHit.HitPoint));
}
else
if (!isSurfaceSpherical && snapConfig.SurfaceType == Type.Mesh)
{
Vector3 sitOnPlaneOffset = ObjectSurfaceSnap.CalculateSitOnSurfaceOffset(hierarchyOBB, snapConfig.SurfaceHitPlane, 0.0f);
rootTransform.position += sitOnPlaneOffset;
rootTransform.position += snapConfig.SurfaceHitNormal * snapConfig.OffsetFromSurface;
return(new SnapResult(snapConfig.SurfaceHitPlane, snapConfig.SurfaceHitPlane.ProjectPoint(hierarchyOBB.Center)));
}
}
else
if (isSurfaceSpherical)
{
Transform surfaceObjectTransform = snapConfig.SurfaceObject.transform;
Vector3 sphereCenter = surfaceObjectTransform.position;
Vector3 radiusDir = (rootTransform.position - sphereCenter).normalized;
float sphereRadius = surfaceObjectTransform.lossyScale.GetMaxAbsComp() * 0.5f;
BoxFace pivotFace = BoxMath.GetMostAlignedFace(hierarchyOBB.Center, hierarchyOBB.Size, hierarchyOBB.Rotation, -radiusDir);
var collectedVerts = ObjectVertexCollect.CollectHierarchyVerts(root, pivotFace, collectBoxScale, collectEps);
Vector3 sitPoint = sphereCenter + radiusDir * sphereRadius;
Plane sitPlane = new Plane(radiusDir, sitPoint);
Vector3 sitOnPlaneOffset = ObjectSurfaceSnap.CalculateSitOnSurfaceOffset(hierarchyOBB, sitPlane, 0.0f);
rootTransform.position += sitOnPlaneOffset;
hierarchyOBB.Center += sitOnPlaneOffset;
Vector3Ex.OffsetPoints(collectedVerts, sitOnPlaneOffset);
rootTransform.position += radiusDir * snapConfig.OffsetFromSurface;
return(new SnapResult(sitPlane, sitPoint));
}
}
}
if (snapConfig.SurfaceType == Type.SceneGrid)
{
OBB hierarchyOBB = ObjectBounds.CalcHierarchyWorldOBB(root, boundsQConfig);
if (!hierarchyOBB.IsValid)
{
return(new SnapResult());
}
Transform rootTransform = root.transform;
if (snapConfig.AlignAxis)
{
rootTransform.Align(snapConfig.SurfaceHitNormal, snapConfig.AlignmentAxis);
hierarchyOBB = ObjectBounds.CalcHierarchyWorldOBB(root, boundsQConfig);
}
rootTransform.position += ObjectSurfaceSnap.CalculateSitOnSurfaceOffset(hierarchyOBB, snapConfig.SurfaceHitPlane, snapConfig.OffsetFromSurface);
return(new SnapResult(snapConfig.SurfaceHitPlane, snapConfig.SurfaceHitPlane.ProjectPoint(hierarchyOBB.Center)));
}
return(new SnapResult());
}
private void UpdateTransform(Camera camera)
{
Vector3 midAxisPos = _sceneGizmo.SceneGizmoCamera.LookAtPoint;
RTSceneGizmoCamera sceneGizmoCamera = _sceneGizmo.SceneGizmoCamera;
Vector3 axisDirection = _sceneGizmo.Gizmo.Transform.GetAxis3D(_axisDesc);
_zoomFactorTransform.Position3D = midAxisPos;
float zoomFactor = _cap.GetZoomFactor(camera);
Vector3 midCapSize = _sceneGizmo.LookAndFeel.MidCapType == GizmoCap3DType.Box ?
Vector3Ex.FromValue(_sceneGizmo.LookAndFeel.MidCapBoxSize * zoomFactor) : Vector3Ex.FromValue(_sceneGizmo.LookAndFeel.MidCapSphereRadius * 2.0f * zoomFactor);
Vector3 midBoxFaceCenter = BoxMath.CalcBoxFaceCenter(midAxisPos, midCapSize, Quaternion.identity, _midAxisBoxFace);
_cap.CapSlider3DInvert(axisDirection, midBoxFaceCenter);
}
/// <summary>
/// Allows the node to render itself for debugging purposes. The client
/// code is responsible for setting up the rendering material.
/// </summary>
/// <remarks>
/// This method is recursive and will draw the node's children also. Thus,
/// it is enough to call this method for the root of a sphere tree in order
/// to draw the entire tree.
/// </remarks>
public void DebugDraw()
{
// Draw the node
Matrix4x4 nodeTransform = Matrix4x4.TRS(_sphere.Center, Quaternion.identity, Vector3Ex.FromValue(_sphere.Radius));
Graphics.DrawMeshNow(MeshPool.Get.UnitSphere, nodeTransform);
// Draw the node's children
foreach (var child in _children)
{
child.DebugDraw();
}
}
public override void RenderSolid()
{
Graphics.DrawMeshNow(MeshPool.Get.UnitSphere, Matrix4x4.TRS(Center, Quaternion.identity, Vector3Ex.FromValue(Radius)));
}
public override AABB GetAABB()
{
return(new AABB(_center, Vector3Ex.FromValue(_radius * 2.0f)));
}
public void Inflate(float amount)
{
Size += Vector3Ex.FromValue(amount);
}
public EditorPrefabPreviewGen()
{
_boundsQConfig.ObjectTypes = GameObjectTypeHelper.AllCombined & (~GameObjectType.Terrain);
_boundsQConfig.NoVolumeSize = Vector3Ex.FromValue(1.0f);
}