private void OnLeftModeChanged(TransformMode newMode, TransformMode previousMode)
{
if (newMode != TransformMode.Scale)
{
DisengageScaleTool(false, ref leftStickActive, ref leftLineRenderer);
}
}
IEnumerator PlaySkillCoroutine(SkillType skillType)
{
if (IsWalking)
{
animator.SetBool("Walk", false);
yield return(null);
}
switch (skillType)
{
case SkillType.SKILL_1:
{
animator.SetTrigger("Skill1");
}
break;
case SkillType.SKILL_2:
{
animator.SetTrigger("Skill2");
}
break;
case SkillType.TRANSFORM:
{
animator.SetTrigger("Transform");
currentMode = currentMode == TransformMode.NORMAL ? TransformMode.DRAGON : TransformMode.NORMAL;
animator.SetInteger("Mode", (int)currentMode);
}
break;
}
}
private void buttonOK_Click(object sender, System.EventArgs e)
{
_jpegQualityFactor = (int)jpegQualityFactorNumericUpDown.Value;
_tranformMode = (TransformMode)TransformModeComboBox.SelectedIndex;
this.DialogResult = DialogResult.OK;
this.Close();
}
public BrushPreset(BrushPreset other)
{
Reset();
prefabs = new List <GameObject>(other.prefabs);
name = other.name;
brushSize = other.brushSize;
eraseBrushSize = other.eraseBrushSize;
brushSpacing = other.brushSpacing;
positionOffset = other.positionOffset;
orientationTransformMode = other.orientationTransformMode;
orientationMode = other.orientationMode;
flipOrientation = other.flipOrientation;
rotation = other.rotation;
randomizeOrientation = other.randomizeOrientation;
scaleTransformMode = other.scaleTransformMode;
scaleMode = other.scaleMode;
scaleUniformMin = other.scaleUniformMin;
scaleUniformMax = other.scaleUniformMax;
scalePerAxisMin = other.scalePerAxisMin;
scalePerAxisMax = other.scalePerAxisMax;
}
private bool IsModeActive(Hand hand, TransformMode mode)
{
bool returnValue = AtomicModeController.Instance.HasFlag((hand == Hand.Right) ? AtomicModeController.Instance.currentRightMode : AtomicModeController.Instance.currentLeftMode, mode);
Debug.Log("Is " + hand + " " + mode + " Active? " + returnValue);
return(returnValue);
}
public static void ResetToParent(Transform transform, Transform parent,
TransformMode transformMode =
TransformMode.localPosition | TransformMode.localRotation | TransformMode.localScale)
{
transform.SetParent(parent);
Reset(transform, transformMode);
}
private void AdjustRotation(Transform xf, TransformMode mode, Quaternion original)
{
if (mode != TransformMode.DoNothing)
{
xf.localRotation = (mode == TransformMode.KeepOriginal) ? original : Quaternion.identity;
}
}
private void AdjustPosition(Transform xf, TransformMode mode, Vector3 original)
{
if (mode != TransformMode.DoNothing)
{
xf.localPosition = (mode == TransformMode.KeepOriginal) ? original : Vector3.zero;
}
}
private void Update()
{
if (m_Target)
{
if (Input.GetKeyDown(KeyCode.W))
{
m_CurrentHandle = m_PositionHandle;
m_TransformMode = TransformMode.Position;
}
else if (Input.GetKeyDown(KeyCode.E))
{
m_CurrentHandle = m_RotationHandle;
m_TransformMode = TransformMode.Rotation;
}
else if (Input.GetKeyDown(KeyCode.R))
{
m_CurrentHandle = m_ScaleHandle;
m_TransformMode = TransformMode.Scale;
}
if (!m_MouseDonw)
{
m_SelectedAxis = m_CurrentHandle.SelectedAxis();
}
ControlTarget();
}
}
void JumpToNextLegalTransformMode()
{
if (carriedObject.GetComponent <GroupHolder>() != null)
{
transformMode = TransformMode.Off;
return;
}
while (true)
{
if (transformMode == TransformMode.Off)
{
break;
}
if (transformMode == TransformMode.RotateHorizontally && carriedObject.GetComponent <Pickupable>().canRotateHorizontally)
{
break;
}
if (transformMode == TransformMode.RotateVertically && carriedObject.GetComponent <Pickupable>().canRotateVertically)
{
break;
}
if (transformMode == TransformMode.Scale && carriedObject.GetComponent <Pickupable>().canScale)
{
break;
}
if ((transformMode == TransformMode.ScaleX || transformMode == TransformMode.ScaleY || transformMode == TransformMode.ScaleZ) && carriedObject.GetComponent <Pickupable>().canScaleXYZ)
{
break;
}
transformMode = transformMode.Next();
}
}
private void OnLeftModeChanged(TransformMode newMode, TransformMode previousMode)
{
if (newMode != TransformMode.Translate)
{
DisengageTranslationTool(false);
}
}
private void OnRightModeChanged(TransformMode newMode, TransformMode previousMode)
{
if (newMode != TransformMode.Scale)
{
DisengageScaleTool(true, ref rightStickActive, ref rightLineRenderer);
}
}
/// <summary>
/// 重置
/// </summary>
/// <param name="transform"></param>
public static void Reset(Transform transform,
TransformMode transformMode =
TransformMode.localPosition | TransformMode.localRotation | TransformMode.localScale)
{
if (transformMode.Contains(TransformMode.localPosition))
{
transform.localPosition = Vector3.zero;
}
if (transformMode.Contains(TransformMode.localRotation))
{
transform.localRotation = Quaternion.identity;
}
if (transformMode.Contains(TransformMode.localScale))
{
transform.localScale = Vector3.one;
}
if (transformMode.Contains(TransformMode.position))
{
transform.position = Vector3.zero;
}
if (transformMode.Contains(TransformMode.rotation))
{
transform.rotation = Quaternion.identity;
}
}
public void CopyFrom(BrushSettings other)
{
brushRadius = other.brushRadius;
brushSpacing = other.brushSpacing;
brushOverlapCheckMode = other.brushOverlapCheckMode;
brushOverlapDistance = other.brushOverlapDistance;
brushOverlapCheckObjects = other.brushOverlapCheckObjects;
brushOverlapCheckLayers = other.brushOverlapCheckLayers;
surfaceOffset = other.surfaceOffset;
orientationTransformMode = other.orientationTransformMode;
orientationMode = other.orientationMode;
alongBrushStroke = other.alongBrushStroke;
rotation = other.rotation;
randomizeOrientationX = other.randomizeOrientationX;
randomizeOrientationY = other.randomizeOrientationY;
randomizeOrientationZ = other.randomizeOrientationZ;
scaleTransformMode = other.scaleTransformMode;
scaleMode = other.scaleMode;
scaleUniformMin = other.scaleUniformMin;
scaleUniformMax = other.scaleUniformMax;
scalePerAxisMin = other.scalePerAxisMin;
scalePerAxisMax = other.scalePerAxisMax;
pinFixedRotation = other.pinFixedRotation;
pinFixedRotationValue = other.pinFixedRotationValue;
pinFixedScale = other.pinFixedScale;
pinFixedScaleValue = other.pinFixedScaleValue;
placeScale = other.placeScale;
placeEulerAngles = other.placeEulerAngles;
multibrushEnabled = other.multibrushEnabled;
multibrushPaintSelectedSlot = other.multibrushPaintSelectedSlot;
multibrushMode = other.multibrushMode;
multibrushPattern = other.multibrushPattern;
multibrushPatternContinue = other.multibrushPatternContinue;
for (int i = 0; i < kNumMultibrushSlots; i++)
{
multibrushSlots[i] = other.multibrushSlots[i];
}
slopeEnabled = other.slopeEnabled;
slopeAngleMin = other.slopeAngleMin;
slopeAngleMax = other.slopeAngleMax;
slopeVector = other.slopeVector;
slopeVectorCustom = other.slopeVectorCustom;
slopeVectorFlip = other.slopeVectorFlip;
gridEnabled = other.gridEnabled;
gridOrigin = other.gridOrigin;
gridStep = other.gridStep;
gridPlane = other.gridPlane;
gridNormal = other.gridNormal;
gridAngle = other.gridAngle;
}
private void OnLeftModeChanged(TransformMode newMode, TransformMode previousMode)
{
if (newMode != TransformMode.Translate)
{
ToggleTranslateToolVisibility(false, false);
ToggleTranslateToolColliders(false, false);
}
}
public void ResetScale()
{
scaleTransformMode = TransformMode.Relative;
scaleMode = AxisMode.Uniform;
scaleUniformMin = 1.0f;
scaleUniformMax = 1.0f;
scalePerAxisMin = new Vector3(1, 1, 1);
scalePerAxisMax = new Vector3(1, 1, 1);
}
public GcmAuthenticatedCryptographicTransform(byte[] key, TransformMode mode)
{
TransformMode = mode;
#if NETSTANDARD2_1_OR_GREATER || NETCOREAPP3_1_OR_GREATER
_gcm = new AesGcm(key);
#else
_gcm = new AesGcmWindows(key);
#endif
}
public void ResetOrientation()
{
orientationTransformMode = TransformMode.Relative;
orientationMode = OrientationMode.AlongSurfaceNormal;
flipOrientation = false;
rotation = new Vector3(0, 0, 0);
randomizeOrientationX = 0.0f;
randomizeOrientationY = 0.0f;
randomizeOrientationZ = 0.0f;
}
void HandleCarry()
{
if (carrying)
{
PoseCarryingObject();
if (Input.GetButtonDown("TransSnap") && transformMode != TransformMode.Off)
{
transformSnapMode = transformSnapMode.Next();
UpdateModeText();
}
if (Input.GetButtonDown("Submit"))
{
transformMode = transformMode.Next();
UpdateModeText();
}
if (transformMode != TransformMode.Off)
{
HandleTransform();
}
if (Input.GetButtonDown("Fire1"))
{
PutDownCarryingObject();
UpdateModeText();
}
else if (Input.GetButtonDown("Fire2") && !controller.isMultiplayer)
{
PutCarryingIntoBackPack();
ShowBackPackItem();
UpdateModeText();
}
}
else
{
if (Input.GetButtonDown("Fire1"))
{
PickupAnObject();
UpdateModeText();
}
}
for (int i = 0; i < backPackCapacity; i++)
{
if (Input.GetKeyDown(KeyCode.Alpha1 + i) && backPack[i] != null)
{
if (carrying)
{
SwitchCarriedWithBackPack(i);
}
else
{
TakeOutFromBackPack(i);
}
UpdateModeText();
}
}
}
public void ResetPrecisePlace()
{
ppOrientationMode = PrecisePlaceOrientationMode.AlongSurfaceNormal;
ppFlipOrientation = false;
ppFixedRotation = false;
ppFixedRotationValue = new Vector3(0, 0, 0);
ppFixedRotationTransformMode = TransformMode.Relative;
ppFixedScale = false;
ppFixedScaleValue = new Vector3(1, 1, 1);
ppFixedScaleTransformMode = TransformMode.Relative;
}
public static Vector3 TransformPoint(this Transform transform, Vector3 pos, TransformMode m_TransformMode)
{
switch (m_TransformMode)
{
case TransformMode.Local: return(transform.TransformPointLocal(pos));
case TransformMode.WorldSpaceUnscaled: return(transform.TransformPointUnscaled(pos));
case TransformMode.LocalUnscaled: return(transform.TransformPointLocalUnscaled(pos));
}
return(transform.TransformPoint(pos));//WorldSpace
}
private void optionsToolStripMenuItem_Click(object sender, EventArgs e)
{
using (OptionsForm optionsForm = new OptionsForm())
{
optionsForm.JpegQualityFactor = _jpegQualityFactor;
optionsForm.TransformMode = _transformMode;
if (DialogResult.OK == optionsForm.ShowDialog())
{
_jpegQualityFactor = optionsForm.JpegQualityFactor;
_transformMode = optionsForm.TransformMode;
}
}
}
//ここからインターフェースで呼び出されるであろう関数群***********************************************************************************************************************************************************
public void Change_Mode()
{
Button_Clicked();
if (mode_ == TransformMode.Translate)
{
Mode_.transform.Find("Text").gameObject.GetComponent <Text>().text = "回転";
mode_ = TransformMode.Rotate;
}
else if (mode_ == TransformMode.Rotate)
{
Mode_.transform.Find("Text").gameObject.GetComponent <Text>().text = "移動";
mode_ = TransformMode.Translate;
}
}
/// <summary>
/// Get the display name of a given transform mode
/// </summary>
/// <param name="mode"></param>
/// <returns></returns>
private string GetTransformModeName(TransformMode mode)
{
switch (mode)
{
case TransformMode.TRANSLATE:
return("Translate");
case TransformMode.SCALE:
return("Scale");
case TransformMode.ROTATE:
return("Rotate");
default:
return(string.Empty);
}
}
//ここからインターフェースで呼び出されるであろう関数群***********************************************************************************************************************************************************
public void Change_Mode()
{
Button_Clicked();
if (mode_ == TransformMode.Translate)
{
Current_Mode.GetComponent <Image>().sprite = Resources.Load <Sprite>("Button/Rotate_Mode");
//Debug.Log("Change_Mode");
mode_ = TransformMode.Rotate;
}
else if (mode_ == TransformMode.Rotate)
{
Current_Mode.GetComponent <Image>().sprite = Resources.Load <Sprite>("Button/Transform_Mode");
//Debug.Log("Change_Mode");
mode_ = TransformMode.Translate;
}
}
GizmoMode ConvertToGizmoMode(TransformMode mode)
{
switch (mode)
{
case TransformMode.Rotate:
return(GizmoMode.Rotate);
case TransformMode.Scale:
return(GizmoMode.NonUniformScale);
case TransformMode.Translate:
return(GizmoMode.Translate);
default:
throw new System.Exception();
}
}
private int GetHighlightIndex(TransformMode mode)
{
switch (mode)
{
case TransformMode.Create: return(0);
case TransformMode.Rotate: return(1);
case TransformMode.Translate: return(2);
case TransformMode.Scale: return(3);
case TransformMode.Text: return(4);
default: return(2);
}
}
private void TransMouseDown(PointF downPos, Keys modifierKeys)
{
mouseDownPos = downPos;
fixAspect = ((modifierKeys & Keys.Shift) == Keys.Shift);
if (IsInside(transBeziers.TransformRectange.TopLeft, downPos))
{
tmode = TransformMode.ExpandTopLeft;
}
else if (IsInside(transBeziers.TransformRectange.TopRight, downPos))
{
tmode = TransformMode.ExpandTopRight;
}
else if (IsInside(transBeziers.TransformRectange.BottomLeft, downPos))
{
tmode = TransformMode.ExpandBottomLeft;
}
else if (IsInside(transBeziers.TransformRectange.BottomRight, downPos))
{
tmode = TransformMode.ExpandBottomRight;
}
else if (IsInside(transBeziers.TransformRectange.TopMiddle, downPos))
{
tmode = TransformMode.ExpandTop;
}
else if (IsInside(transBeziers.TransformRectange.BottomMiddle, downPos))
{
tmode = TransformMode.ExpandBottom;
}
else if (IsInside(transBeziers.TransformRectange.LeftMiddle, downPos))
{
tmode = TransformMode.ExpandLeft;
}
else if (IsInside(transBeziers.TransformRectange.RightMiddle, downPos))
{
tmode = TransformMode.ExpandRight;
}
else if (IsInside(transBeziers.TransformRectange, downPos) && (modifierKeys & Keys.Control) == Keys.Control)
{
tmode = TransformMode.Move;
}
else
{
tmode = TransformMode.Rotate;
}
}
public static void SetTransformMode(string val)
{
switch (val)
{
case NAME_TRANSLATE:
MODE = TransformMode.Translate;
break;
case NAME_ROTATE:
MODE = TransformMode.Rotate;
break;
default:
MODE = TransformMode.Scale;
break;
}
stateManager.GetActiveGameObject().GetComponent<Transformable>().initializeElements();
}
private void OnRightControllerStateChanged(HandGestureState current, HandGestureState previous)
{
if (current == HandGestureState.SqueezeAll && !_rightModeMenuActive)
{
_rightModeMenuActive = true;
_potentialRightMode = currentRightMode;
_rightPositionMarker.position = _rightHandMarker.transform.position + _rightHand.PointerPose.forward * 0.2f;
_rightPositionMarker.LookAt(new Vector3(rightCam.transform.position.x, _rightPositionMarker.position.y, rightCam.transform.position.z));
ToggleVisibility(true, true);
}
else if (current != HandGestureState.SqueezeAll && _rightModeMenuActive)
{
_rightModeMenuActive = false;
TransformMode previousMode = currentRightMode;
currentRightMode = _potentialRightMode;
RightModeChanged?.Invoke(currentRightMode, previousMode);
ToggleVisibility(false, true);
}
}
/// <summary>
/// Update the transform of the currently selected snowman scene node
/// </summary>
/// <param name="speed"></param>
private void UpdateNodeTransform(int speed)
{
TransformMode currentTransformMode = transformModeOptions[transformModeIndex];
TransformAxis currentTransformAxis = transformAxisOptions[transformAxisIndex];
switch (currentTransformMode)
{
case TransformMode.TRANSLATE:
TranslateNode(currentTransformAxis, speed);
break;
case TransformMode.SCALE:
ScaleNode(currentTransformAxis, speed);
break;
case TransformMode.ROTATE:
RotateNode(currentTransformAxis, speed);
break;
}
}
bool ProcessMouseClick(List<AnimationTrack> tracks, PointF p)
{
foreach (AnimationTrack track in tracks)
{
if (track.AnimTracks.Count > 0 && ProcessMouseClick(track.AnimTracks, p))
return true;
// check the mouse position.
PointF[] helperPoints = GetHelperPoints(track);
PointF[] helperBound = new PointF[] {
helperPoints[0],
helperPoints[1],
helperPoints[2],
helperPoints[3]};
// inside: move mode.
GraphicsPath path = new GraphicsPath();
path.StartFigure();
path.AddLines(helperBound);
path.CloseFigure();
mTransformMode = TransformMode.Move;
if (path.IsVisible(p))
{
mAnimationControl.SelectAnimationTrack(track);
return true;
}
}
return false;
}
Cursor SetupTransformMode(PointF p)
{
// check the mouse position.
PointF[] helperPoints = GetHelperPoints(mAnimTrack);
PointF[] helperBound = new PointF[] {
helperPoints[0],
helperPoints[1],
helperPoints[2],
helperPoints[3],
helperPoints[0]};
// check the center.
mTransformMode = TransformMode.Center;
if (MathHelper.DistanceSqr(helperPoints[4], p) < CursorDetectDistance)
return Cursors.Hand;
// inside: move mode.
GraphicsPath path = new GraphicsPath();
path.StartFigure();
path.AddLines(helperBound);
path.CloseFigure();
mTransformMode = TransformMode.Move;
if (path.IsVisible(p))
return Cursors.SizeAll;
// outside:
mTransformMode = TransformMode.Edge0;
for (int i = 0; i < 4; i++)
{
PointF p0 = helperBound[i];
PointF p1 = helperBound[i + 1];
double distanceSqr = MathHelper.LinePointDistSqr(p0, p1, p, true);
if (distanceSqr < CursorDetectDistance)
{
double angle = Math.Atan2(p1.Y - p0.Y, p1.X - p0.X);
if (angle < 0) angle += Math.PI;
double range = angle * 8 / Math.PI;
if (range < 1)
return Cursors.SizeNS;
if (range < 3)
return Cursors.SizeNESW;
if (range < 5)
return Cursors.SizeWE;
if (range < 7)
return Cursors.SizeNWSE;
return Cursors.SizeNS;
}
mTransformMode++;
}
mTransformMode = TransformMode.Rotate;
return mRotateCursor;
}
