public void RefreshPosition()
{
if (_targetObjects == null || _gizmo.IsDragged)
{
return;
}
GizmoTransform gizmoTransform = Gizmo.Transform;
if (_transformPivot == GizmoObjectTransformPivot.ObjectGroupCenter ||
_targetPivotObject == null)
{
gizmoTransform.Position3D = GetTargetObjectGroupWorldAABB().Center;
}
else
if (_transformPivot == GizmoObjectTransformPivot.ObjectMeshPivot)
{
if (_targetPivotObject == null)
{
gizmoTransform.Position3D = GetTargetObjectGroupWorldAABB().Center;
}
else
{
gizmoTransform.Position3D = _targetPivotObject.transform.position;
}
}
else
if (_transformPivot == GizmoObjectTransformPivot.ObjectCenterPivot)
{
if (_targetPivotObject == null)
{
gizmoTransform.Position3D = GetTargetObjectGroupWorldAABB().Center;
}
else
{
var boundsQConfig = GetObjectBoundsQConfig();
AABB worldAABB = ObjectBounds.CalcWorldAABB(_targetPivotObject, boundsQConfig);
if (worldAABB.IsValid)
{
gizmoTransform.Position3D = worldAABB.Center;
}
}
}
if (_transformPivot == GizmoObjectTransformPivot.CustomWorldPivot)
{
gizmoTransform.Position3D = _customWorldPivot;
}
else
if (_transformPivot == GizmoObjectTransformPivot.CustomObjectLocalPivot)
{
if (_targetPivotObject == null)
{
gizmoTransform.Position3D = GetTargetObjectGroupWorldAABB().Center;
}
else
{
gizmoTransform.Position3D = _targetPivotObject.transform.TransformPoint(GetObjectCustomLocalPivot(_targetPivotObject));
}
}
}
public void SetZoomFactorTransform(GizmoTransform zoomFactorTransform)
{
foreach (var slider in _sliders)
{
slider.SetZoomFactorTransform(zoomFactorTransform);
}
}
public void RemoveTargetTransform(GizmoTransform transform)
{
if (!IsActive)
{
_targetTransforms.Remove(transform);
}
}
public void SetZoomFactorTransform(GizmoTransform zoomFactorTransform)
{
foreach (var cap in _caps)
{
cap.SetZoomFactorTransform(zoomFactorTransform);
}
}
public void RefreshRotation()
{
if (_targetObjects == null || _gizmo.IsDragged)
{
return;
}
GizmoTransform gizmoTransform = Gizmo.Transform;
if (_transformSpace == GizmoSpace.Global)
{
gizmoTransform.Rotation3D = Quaternion.identity;
}
else
{
if (_targetPivotObject == null)
{
gizmoTransform.Rotation3D = Quaternion.identity;
}
else
{
gizmoTransform.Rotation3D = _targetPivotObject.transform.rotation;
}
}
}
private void OnGizmoTransformChanged(GizmoTransform gizmoTransform, GizmoTransform.ChangeData changeData)
{
if (changeData.ChangeReason == GizmoTransform.ChangeReason.ParentChange ||
changeData.TRSDimension == GizmoDimension.Dim3D)
{
UpdateCamLookSlider(Gizmo.GetWorkCamera());
}
}
private void OnTransformChanged(GizmoTransform transform, GizmoTransform.ChangeData changeData)
{
if (changeData.ChangeReason == GizmoTransform.ChangeReason.ParentChange ||
changeData.TRSDimension == GizmoDimension.Dim3D)
{
_controllers[(int)LookAndFeel.CapType].UpdateTransforms(GetZoomFactor(Gizmo.GetWorkCamera()));
}
}
public void AddTargetTransform(GizmoTransform transform)
{
if (!IsActive &&
!ContainsTargetTransform(transform))
{
_targetTransforms.Add(transform);
}
}
/// <summary>
/// Similar to 'MapDirection', but this function applies to the slider's drag rotation axis.
/// This is the axis around which the slider will rotate during a rotation session. The other
/// difference is that this function requires you to pass a transform and the rest of the
/// parameters identify the axis inside this transform. The function has no effect if the slider
/// is currently involved in a drag operation.
/// </summary>
public void MapDragRotationAxis(GizmoTransform mapTransform, int axisIndex, AxisSign axisSign)
{
if (IsDragged)
{
return;
}
_dragRotationAxisMap.Map(mapTransform, axisIndex, axisSign);
}
private void OnTransformChanged(GizmoTransform transform, GizmoTransform.ChangeData changeData)
{
if (changeData.TRSDimension == GizmoDimension.Dim2D ||
changeData.ChangeReason == GizmoTransform.ChangeReason.ParentChange)
{
_controllers[(int)LookAndFeel.PlaneType].UpdateTransforms();
}
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="gizmo">The gizmo which owns the handle.</param>
/// <param name="id">The handle id. Must be unique at gizmo scope.</param>
public GizmoHandle(Gizmo gizmo, int id)
{
_id = id;
_gizmo = gizmo;
_zoomFactorTransform = _gizmo.Transform;
SetHoverable(true);
SetVisible(true);
}
private void OnTransformChanged(GizmoTransform transform, GizmoTransform.ChangeData changeData)
{
if (changeData.TRSDimension == GizmoDimension.Dim2D ||
changeData.ChangeReason == GizmoTransform.ChangeReason.ParentChange)
{
_controllers[(int)LookAndFeel.LineType].UpdateTransforms();
_cap2D.CapSlider2D(GetRealDirection(), GetRealEndPosition());
}
}
public void Map(GizmoTransform transform, int axisIndex, AxisSign axisSign)
{
if (transform == null || axisIndex > 1)
{
return;
}
_mappedAxisDesc = new AxisDescriptor(axisIndex, axisSign);
_transform = transform;
}
/// <summary>
/// Allows you to set the zoom factor transform. The world position of this transform is used
/// by the 'GetZoomFactor' function to calculate the handle zoom factor. If null is specified,
/// the function will set the zoom factor transform to the transform of the owner gizmo.
/// </summary>
public void SetZoomFactorTransform(GizmoTransform transform)
{
if (transform == null)
{
_zoomFactorTransform = _gizmo.Transform;
}
else
{
_zoomFactorTransform = transform;
}
}
public bool IsChildOf(GizmoTransform transform)
{
GizmoTransform parent = Parent;
while (parent != transform && parent != null)
{
parent = parent.Parent;
}
return(parent != null);
}
private void OnTransformChanged(GizmoTransform transform, GizmoTransform.ChangeData changeData)
{
if (changeData.ChangeReason == GizmoTransform.ChangeReason.ParentChange ||
changeData.TRSDimension == GizmoDimension.Dim3D)
{
Camera camera = Gizmo.GetWorkCamera();
float zoomFactor = GetZoomFactor(camera);
_controllers[(int)LookAndFeel.LineType].UpdateTransforms(zoomFactor);
_cap3D.CapSlider3D(GetRealDirection(), GetRealEndPosition(zoomFactor));
}
}
public void Snapshot(GizmoTransform transform)
{
if (transform == null)
{
return;
}
_transform = transform;
_parentTransform = transform.Parent;
_localPosition3D = transform.LocalPosition3D;
_localRotation3D = transform.LocalRotation3D;
_localPosition2D = transform.LocalPosition2D;
_localRotation2D_Degrees = transform.LocalRotation2DDegrees;
}
public void AddTargetTransform(GizmoTransform transform, GizmoDragChannel dragChannel)
{
if (dragChannel == GizmoDragChannel.Offset)
{
_dblAxisOffsetDrag.AddTargetTransform(transform);
}
else if (dragChannel == GizmoDragChannel.Rotation)
{
_rotationDrag.AddTargetTransform(transform);
}
else if (_dragChannel == GizmoDragChannel.Scale)
{
_scaleDrag.AddTargetTransform(transform);
}
}
public void RemoveTargetTransform(GizmoTransform transform, GizmoDragChannel dragChannel)
{
if (dragChannel == GizmoDragChannel.Offset)
{
_offsetDrag.RemoveTargetTransform(transform);
}
else if (dragChannel == GizmoDragChannel.Rotation)
{
_rotationDrag.RemoveTargetTransform(transform);
}
else if (_dragChannel == GizmoDragChannel.Scale)
{
_scaleDrag.RemoveTargetTransform(transform);
}
}
public void MakeSliderPlane(GizmoTransform sliderPlaneTransform, PlaneId planeId, GizmoLineSlider3D firstAxisSlider, GizmoLineSlider3D secondAxisSlider, Camera camera)
{
PlaneQuadrantId quadrantId = sliderPlaneTransform.Get3DQuadrantFacingCamera(planeId, camera);
AlignToQuadrant(sliderPlaneTransform, planeId, quadrantId, true);
Vector3 firstQdrAxis = sliderPlaneTransform.GetAxis3D(PlaneIdHelper.GetFirstAxisDescriptor(planeId, quadrantId));
Vector3 secondQdrAxis = sliderPlaneTransform.GetAxis3D(PlaneIdHelper.GetSecondAxisDescriptor(planeId, quadrantId));
Vector3 sliderOffset = firstQdrAxis * secondAxisSlider.GetRealSizeAlongDirection(camera, firstQdrAxis) * 0.5f +
secondQdrAxis * firstAxisSlider.GetRealSizeAlongDirection(camera, secondQdrAxis) * 0.5f;
if (LookAndFeel.PlaneType == GizmoPlane3DType.Quad)
{
SetQuadCornerPosition(QuadCorner.BottomLeft, sliderPlaneTransform.Position3D + sliderOffset);
}
}
public void AlignToQuadrant(GizmoTransform transform, PlaneId planeId, PlaneQuadrantId quadrantId, bool alignXToFirstAxis)
{
Plane plane = transform.GetPlane3D(planeId, quadrantId);
if (alignXToFirstAxis)
{
AxisDescriptor secondAxisDesc = PlaneIdHelper.GetSecondAxisDescriptor(planeId, quadrantId);
Vector3 secondAxis = Gizmo.Transform.GetAxis3D(secondAxisDesc);
_transform.Rotation3D = Quaternion.LookRotation(plane.normal, secondAxis);
}
else
{
AxisDescriptor firstAxisDesc = PlaneIdHelper.GetFirstAxisDescriptor(planeId, quadrantId);
Vector3 firstAxis = Gizmo.Transform.GetAxis3D(firstAxisDesc);
_transform.Rotation3D = Quaternion.LookRotation(plane.normal, firstAxis);
}
}
protected void ApplyDrag()
{
List <GizmoTransform> parents = GizmoTransform.FilterParentsOnly(_targetTransforms);
if (DragChannel == GizmoDragChannel.Offset)
{
foreach (var parentTransform in parents)
{
parentTransform.Position3D = parentTransform.Position3D + _relativeDragOffset;
}
}
else
if (DragChannel == GizmoDragChannel.Rotation)
{
foreach (var parentTransform in parents)
{
parentTransform.Rotation3D = _relativeDragRotation * parentTransform.Rotation3D;
}
}
}
public void SetParent(GizmoTransform newParent)
{
if (!CanChange3D)
{
return;
}
if (_parent == newParent)
{
return;
}
var oldParent = _parent;
if (oldParent != null)
{
oldParent._children.Remove(this);
}
_parent = newParent;
_parent._children.Add(this);
OnParentChanged();
}
private void OnGizmoTransformChanged(GizmoTransform transform, GizmoTransform.ChangeData changeData)
{
Update2DGizmoPosition();
}
public void Unmap()
{
_transform = null;
}
public void RemoveTargetTransform(GizmoTransform transform)
{
_offsetDrag.RemoveTargetTransform(transform);
_rotationDrag.RemoveTargetTransform(transform);
_scaleDrag.RemoveTargetTransform(transform);
}
public bool ContainsTargetTransform(GizmoTransform transform)
{
return(_targetTransforms.Contains(transform));
}
public void AddTargetTransform(GizmoTransform transform)
{
_dblAxisOffsetDrag.AddTargetTransform(transform);
_rotationDrag.AddTargetTransform(transform);
_scaleDrag.AddTargetTransform(transform);
}
/// <summary>
/// Sets the zoom factor transform. The world position of the zoom factor transform is
/// used to calculate a slider zoom factor. The zoom factor is used in order to allow
/// the slider to maintain a constant size regardless of its distance from the camera.
/// </summary>
/// <param name="transform">
/// The zoom factor transform. If null, the function will default to using the transform
/// of the owner gizmo instead.
/// </param>
public void SetZoomFactorTransform(GizmoTransform transform)
{
Handle.SetZoomFactorTransform(transform);
}
