protected override void SetAxis(AxisSign axisSign)
{
Vector3 axis = new Vector3();
axis[(int)outAxis] = (float)axisSign * output.joystickMaxDegrees;
output.SetStickAxis(new VirtualJoystick.StickAxis(axis));
}
public static PlaneQuadrantId GetQuadrantFromAxesSigns(PlaneId planeId, AxisSign firstAxisSign, AxisSign secondAxisSign)
{
PlaneQuadrantInfo quadrantInfo = _planeInfo[(int)planeId].
QuadrantInfo.FindAll(item => item.FirstAxisSign == firstAxisSign && item.SecondAxisSign == secondAxisSign)[0];
return(quadrantInfo.Quadrant);
}
public IEnumerator Emit(AxisSign axisSign)
{
SetAxis(axisSign);
yield return(new WaitForSecondsRealtime(0.1f));
SetAxis(AxisSign.Reset);
}
protected override void SetAxis(AxisSign axisSign)
{
Vector3 axis = new Vector3();
axis[(int)outAxis] = (float)axisSign;
vJoyInterface.instance.SetThrusters(new Virtual6DOFController.ThrusterAxis(axis));
}
/// <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);
}
/// <summary>
/// This function can be used to link the slider's direction axis to one its transform
/// axes. For example, if you wish the direction axis to always point along the slider's
/// transform up vector, you would call MapDirection(1, AxisSign.Positive). Linking the
/// direction axis to the slider's transform like this has the advantage that no matter
/// how the slider is rotated, the direction axis will follow. The function has no effect
/// if the slider is currently involved in a drag operation.
/// </summary>
/// <param name="axisIndex">
/// The index of the slider transform axis which will act as the direction axis. The format
/// is: 0->X, 1->Y, 2->Z.
/// </param>
/// <param name="axisSign">
/// The sign of the axis. Allows you to differentiate between positive and negative axes.
/// </param>
public void MapDirection(int axisIndex, AxisSign axisSign)
{
if (IsDragged)
{
return;
}
_directionAxisMap.Map(_transform, axisIndex, axisSign);
}
private GizmoCap3DLookAndFeel GetAxisCapLookAndFeel(int axisIndex, AxisSign axisSign)
{
if (axisSign == AxisSign.Positive)
{
return(_axesCapsLookAndFeel[axisIndex]);
}
return(_axesCapsLookAndFeel[axisIndex + 3]);
}
protected override void SetAxis(AxisSign axisSign)
{
Vector3 axis = new Vector3();
axis[(int)outAxis] = (float)axisSign;
vJoyInterface.instance.SetMapTranslationAxis(axis);
}
protected override void SetAxis(AxisSign axisSign)
{
Vector3 axis = new Vector3();
axis[(int)outAxis] = (float)axisSign;
output.SetMapTranslationAxis(axis);
}
public void Map(GizmoTransform transform, int axisIndex, AxisSign axisSign)
{
if (transform == null)
{
return;
}
_mappedAxisDesc = new AxisDescriptor(axisIndex, axisSign);
_transform = transform;
}
public Vector2 GetAxis2D(int axisIndex, AxisSign axisSign)
{
Vector2 axis = _axes2D[axisIndex];
if (axisSign == AxisSign.Negative)
{
axis = -axis;
}
return(axis);
}
public void AlignAxis3D(int axisIndex, AxisSign axisSign, Vector3 axis)
{
if (CanChange3D)
{
Vector3 axisToAlign = GetAxis3D(axisIndex, axisSign);
Vector3 perpAxis = GetAxis3D((axisIndex + 1) % 3, axisSign);
Quaternion alignRotation = QuaternionEx.FromToRotation3D(axisToAlign, axis, perpAxis);
Rotation3D = alignRotation * _rotation3D;
}
}
public void SetExtrudeSliderVisible(int axisIndex, AxisSign axisSign, bool isVisible)
{
if (axisSign == AxisSign.Positive)
{
_extrudeSliderVis[axisIndex] = isVisible;
}
else
{
_extrudeSliderVis[3 + axisIndex] = isVisible;
}
}
public bool IsExtrudeSliderVisible(int axisIndex, AxisSign axisSign)
{
if (axisSign == AxisSign.Positive)
{
return(_extrudeSliderVis[axisIndex]);
}
else
{
return(_extrudeSliderVis[3 + axisIndex]);
}
}
protected override void SetAxis(AxisSign axisSign)
{
if (outAxis == Axis.Yaw)
{
output.SetMapYawAxis((float)axisSign);
}
else
{
output.SetMapPitchAxis((float)axisSign);
}
}
protected override void SetAxis(AxisSign axisSign)
{
if (outAxis == Axis.Yaw)
{
vJoyInterface.instance.SetMapYawAxis((float)axisSign);
}
else
{
vJoyInterface.instance.SetMapPitchAxis((float)axisSign);
}
}
private GizmoLineSlider3DSettings GetSglSliderSettings(int axisIndex, AxisSign axisSign)
{
if (axisSign == AxisSign.Positive)
{
return(_sglSliderSettings[axisIndex]);
}
else
{
return(_sglSliderSettings[3 + axisIndex]);
}
}
private GizmoLineSlider2DLookAndFeel GetMvSliderLookAndFeel(int axisIndex, AxisSign axisSign)
{
if (axisSign == AxisSign.Positive)
{
return(_mvSglSliderLookAndFeel[axisIndex]);
}
else
{
return(_mvSglSliderLookAndFeel[2 + axisIndex]);
}
}
public void AlignAxis2D(int axisIndex, AxisSign axisSign, Vector2 axis)
{
if (CanChange3D)
{
Vector2 axisToAlign = GetAxis2D(axisIndex, axisSign);
Quaternion alignRotation = QuaternionEx.FromToRotation2D(axisToAlign, axis);
float angle = alignRotation.ConvertTo2DRotation();
ChangeRotation2D(_rotation2DDegrees + angle);
}
}
private GizmoLineSlider3DLookAndFeel GetSglSliderLookAndFeel(int axisIndex, AxisSign axisSign)
{
if (axisSign == AxisSign.Positive)
{
return(_sglSlidersLookAndFeel[axisIndex]);
}
else
{
return(_sglSlidersLookAndFeel[3 + axisIndex]);
}
}
public bool IsMvSliderCapVisible(int axisIndex, AxisSign axisSign)
{
if (axisSign == AxisSign.Positive)
{
return(_mvSglSliderCapVis[axisIndex]);
}
else
{
return(_mvSglSliderCapVis[2 + axisIndex]);
}
}
public void SetMvSliderCapVisible(int axisIndex, AxisSign axisSign, bool isVisible)
{
if (axisSign == AxisSign.Positive)
{
_mvSglSliderCapVis[axisIndex] = isVisible;
}
else
{
_mvSglSliderCapVis[2 + axisIndex] = isVisible;
}
}
private GizmoCap2DLookAndFeel GetTickLookAndFeel(int axisIndex, AxisSign axisSign)
{
if (axisSign == AxisSign.Positive)
{
return(_tickLookAndFeel[axisIndex]);
}
else
{
return(_tickLookAndFeel[axisIndex + 3]);
}
}
public static Vector3 GetWorldAxis(Axis axis, AxisSign axisSign)
{
if (axis == Axis.X)
{
return(axisSign == AxisSign.Positive ? Vector3.right : -Vector3.right);
}
else if (axis == Axis.Y)
{
return(axisSign == AxisSign.Positive ? Vector3.up : -Vector3.up);
}
else
{
return(axisSign == AxisSign.Positive ? Vector3.forward : -Vector3.forward);
}
}
private void DrawMvSliderCapVisibilityControls(AxisSign axisSign, UnityEngine.Object undoRecordObject)
{
var content = new GUIContent();
EditorGUILayout.BeginHorizontal();
string[] sliderLabels = axisSign == AxisSign.Positive ? new string[] { "+X", "+Y" } : new string[] { "-X", "-Y" };
for (int sliderIndex = 0; sliderIndex < 2; ++sliderIndex)
{
content.text = sliderLabels[sliderIndex];
content.tooltip = "Toggle visibility for the " + sliderLabels[sliderIndex] + " cap.";
bool isVisible = IsMvSliderCapVisible(sliderIndex, axisSign);
bool newBool = EditorGUILayout.ToggleLeft(content, isVisible, GUILayout.Width(60.0f));
if (newBool != isVisible)
{
EditorUndoEx.Record(undoRecordObject);
SetMvSliderCapVisible(sliderIndex, axisSign, newBool);
}
}
EditorGUILayout.EndHorizontal();
}
public PlaneQuadrantId Get3DQuadrantFacingCamera(PlaneId planeId, Camera camera)
{
int axisIndex0 = PlaneIdHelper.PlaneIdToFirstAxisIndex(planeId);
int axisIndex1 = PlaneIdHelper.PlaneIdToSecondAxisIndex(planeId);
AxisSign sign0 = AxisSign.Positive;
AxisSign sign1 = AxisSign.Positive;
Vector3 axis0 = GetAxis3D(axisIndex0, sign0);
Vector3 axis1 = GetAxis3D(axisIndex1, sign1);
if (!camera.IsPointFacingCamera(Position3D, axis0))
{
sign0 = AxisSign.Negative;
}
if (!camera.IsPointFacingCamera(Position3D, axis1))
{
sign1 = AxisSign.Negative;
}
return(PlaneIdHelper.GetQuadrantFromAxesSigns(planeId, sign0, sign1));
}
public void ConnectSliderSettings(GizmoLineSlider3D slider, int axisIndex, AxisSign axisSign)
{
slider.SharedSettings = GetSglSliderSettings(axisIndex, axisSign);
}
public void ConnectSliderLookAndFeel(GizmoLineSlider3D slider, int axisIndex, AxisSign axisSign)
{
slider.SharedLookAndFeel = GetSglSliderLookAndFeel(axisIndex, axisSign);
}
public void ConnectTickLookAndFeel(GizmoCap2D tick, int axisIndex, AxisSign axisSign)
{
tick.SharedLookAndFeel = GetTickLookAndFeel(axisIndex, axisSign);
}
public AxisDescriptor(int axisIndex, bool isNegative)
{
_sign = isNegative ? AxisSign.Negative : AxisSign.Positive;
_index = axisIndex;
}
