private void DrawArcEditor(CylinderSurface surface) { float radious = surface.Radious; arcHandle.angle = surface.Angle; arcHandle.radius = radious; Matrix4x4 handleMatrix = Matrix4x4.TRS( surface.StartPoint, Quaternion.LookRotation(surface.StartAngleDir, surface.Direction), Vector3.one ); using (new Handles.DrawingScope(handleMatrix)) { EditorGUI.BeginChangeCheck(); arcHandle.DrawHandle(); if (EditorGUI.EndChangeCheck()) { Undo.RecordObject(surface, "Change Cylinder Properties"); surface.Angle = arcHandle.angle; radious = arcHandle.radius; } } }
void DrawAngleHandle(TwirlDeformer twirl) { var radiusDistanceOffset = HandleUtility.GetHandleSize(twirl.Axis.position + twirl.Axis.right * twirl.Outer) * DeformEditorSettings.ScreenspaceSliderHandleCapSize * 2f; angleHandle.angle = twirl.Angle; angleHandle.radius = twirl.Outer + radiusDistanceOffset; angleHandle.fillColor = Color.clear; angleHandle.angleHandleColor = DeformEditorSettings.SolidHandleColor; angleHandle.radiusHandleColor = Color.clear; var matrix = Matrix4x4.TRS(twirl.transform.position, twirl.transform.rotation, twirl.transform.lossyScale); using (new Handles.DrawingScope(matrix)) { DeformHandles.Circle(Vector3.zero, Vector3.forward, Vector3.right, angleHandle.radius); Handles.color = DeformEditorSettings.SolidHandleColor; using (var check = new EditorGUI.ChangeCheckScope()) { using (new Handles.DrawingScope(matrix * Matrix4x4.Rotate(Quaternion.LookRotation(Vector3.right, Vector3.forward)))) { angleHandle.DrawHandle(); if (check.changed) { Undo.RecordObject(twirl, "Changed Angle"); twirl.Angle = angleHandle.angle; } } } } }
private void DrawAngleHandle(BendDeformer bend) { var handleRotation = bend.Axis.rotation * Quaternion.Euler(-90, 0f, 0f); // There's some weird issue where if you pass the normal lossyScale, the handle's scale on the y axis is changed when the transform's z axis is changed. // My simple solution is to swap the y and z. var handleScale = new Vector3 ( x: bend.Axis.lossyScale.x, y: bend.Axis.lossyScale.z, z: bend.Axis.lossyScale.y ); var matrix = Matrix4x4.TRS(bend.Axis.position + bend.Axis.up * bend.Bottom * bend.Axis.lossyScale.y, handleRotation, handleScale); var radiusDistanceOffset = HandleUtility.GetHandleSize(bend.Axis.position + bend.Axis.up * bend.Top) * DeformEditorSettings.ScreenspaceSliderHandleCapSize * 2f; angleHandle.angle = bend.Angle; angleHandle.radius = (bend.Top - bend.Bottom) + radiusDistanceOffset; angleHandle.fillColor = Color.clear; using (new Handles.DrawingScope(DeformEditorSettings.SolidHandleColor, matrix)) { using (var check = new EditorGUI.ChangeCheckScope()) { angleHandle.DrawHandle(); if (check.changed) { Undo.RecordObject(bend, "Changed Angle"); bend.Angle = angleHandle.angle; } } } }
private void DrawArcEditor(HandGhost ghost) { CylinderSurface cylinder = ghost.SnapPoseVolume.Volume; float radious = cylinder.Radious; topArc.angle = cylinder.Angle; topArc.radius = radious; Matrix4x4 handleMatrix = Matrix4x4.TRS( cylinder.StartPoint, Quaternion.LookRotation(cylinder.StartAngleDir, cylinder.Direction), Vector3.one ); using (new Handles.DrawingScope(handleMatrix)) { EditorGUI.BeginChangeCheck(); Handles.color = Color.white; topArc.DrawHandle(); if (EditorGUI.EndChangeCheck()) { Undo.RecordObject(ghost, "Change Cylinder Properties"); cylinder.Angle = topArc.angle; radious = topArc.radius; } } }
// the OnSceneGUI callback uses the Scene view camera for drawing handles by default protected virtual void OnSceneGUI() { ProjectileExample projectileExample = (ProjectileExample)target; // copy the target object's data to the handle m_ArcHandle.angle = projectileExample.elevationAngle; m_ArcHandle.radius = projectileExample.impulse; // set the handle matrix so that angle extends upward from target's facing direction along ground Vector3 handleDirection = projectileExample.facingDirection; Vector3 handleNormal = Vector3.Cross(handleDirection, Vector3.up); // https://docs.unity3d.com/ScriptReference/Matrix4x4.TRS.html Matrix4x4 handleMatrix = Matrix4x4.TRS( projectileExample.transform.position, Quaternion.LookRotation(handleDirection, handleNormal), Vector3.one ); using (new Handles.DrawingScope(handleMatrix)) { // draw the handle EditorGUI.BeginChangeCheck(); m_ArcHandle.DrawHandle(); if (EditorGUI.EndChangeCheck()) { // record the target object before setting new values so changes can be undone/redone Undo.RecordObject(projectileExample, "Change Projectile Properties"); // copy the handle's updated data back to the target object projectileExample.elevationAngle = m_ArcHandle.angle; projectileExample.impulse = m_ArcHandle.radius; } } }
public static void ArcHandle(Vector3 center, Quaternion rotation, Vector3 size, ref float angle, ref float radius, Color fillColor, Color wireframeColor) { Matrix4x4 trs = Matrix4x4.TRS(center, rotation, size); using (new Handles.DrawingScope(trs)) { arcHandle.angle = angle; arcHandle.radius = radius; arcHandle.radiusHandleColor = Color.white; arcHandle.fillColor = fillColor; arcHandle.wireframeColor = wireframeColor; arcHandle.DrawHandle(); angle = arcHandle.angle; radius = arcHandle.radius; } }
void OnSceneGUI() { Matrix4x4 handleMatrix = Matrix4x4.TRS(fOVVisualize.transform.position, fOVVisualize.transform.rotation, Vector3.one); arcHandle.angle = fOVVisualize.angle; arcHandle.radius = fOVVisualize.radius; Handles.color = fOVVisualize.colorFov; using (new Handles.DrawingScope(handleMatrix)) { Handles.DrawLine(Vector3.zero, Vector3.up * arcHandle.radius); arcHandle.DrawHandle(); } fOVVisualize.radius = arcHandle.radius; fOVVisualize.angle = arcHandle.angle; }
// the OnMultiGUI callback uses the scene view camera for drawing handles by default public override void OnMultiEdit(List <Object> targetList) { // Only render this stuff if we are selecting one object. if (targetList.Count == 1) { ProjectileArc arc = (ProjectileArc)target; Matrix4x4 handleMatrix; SetUpArcHandle( ref m_ArcHandle, out handleMatrix, arc ); using (new Handles.DrawingScope(handleMatrix)) { // draw the handle EditorGUI.BeginChangeCheck(); m_ArcHandle.DrawHandle(); if (EditorGUI.EndChangeCheck()) { // record the target object before setting new values so changes can be undone/redone Undo.RecordObject(arc, "Change Projectile Arc Angle"); // Just change the one handle; this usually is what runs arc.fullAngle = m_ArcHandle.angle; } } // TODO: Make this render the lines even when multiple things are selected Handles.color = fireLineColor; // Draw lines foreach (FirePoint point in arc.points) { //Debug.Log(point.position + " faces " + point.rotation.eulerAngles); Vector3 startPoint = point.position; Vector3 endPoint = startPoint + (point.rotation * Vector3.forward * FIRE_LINE_LENGTH * HandleUtility.GetHandleSize(point.position)); Handles.DrawLine(startPoint, endPoint); } } }
private void OnSceneGUI() { if (!target) { return; } Color oldColor = Handles.color; AIPerception perception = target as AIPerception; float halfFOV = perception.fovAngle * 0.5f; float coneDir = -90f; Quaternion leftRayRotation = Quaternion.AngleAxis(-halfFOV + coneDir, Vector3.up); Quaternion rightRayRotation = Quaternion.AngleAxis(halfFOV + coneDir, Vector3.up); Vector3 leftRayDir = leftRayRotation * perception.transform.right * perception.perceptionRadius; Vector3 rightRayDir = rightRayRotation * perception.transform.right * perception.perceptionRadius; arcHandle.angle = perception.fovAngle; arcHandle.radius = perception.perceptionRadius; Vector3 handleDir = leftRayDir; Vector3 handleNormal = Vector3.Cross(handleDir, perception.transform.forward); Matrix4x4 handleMatrix = Matrix4x4.TRS( perception.transform.position, Quaternion.LookRotation(handleDir, handleNormal), Vector3.one); using (new Handles.DrawingScope(handleMatrix)) { EditorGUI.BeginChangeCheck(); arcHandle.DrawHandle(); if (EditorGUI.EndChangeCheck()) { Undo.RecordObject(perception, "Changed perception properties"); perception.fovAngle = Mathf.Clamp(arcHandle.angle, 0f, 359f); perception.perceptionRadius = Mathf.Max(arcHandle.radius, 1f); } } Handles.color = new Color(1f, 0f, 0f, 0.15f); Handles.DrawSolidArc(perception.transform.position, Vector3.up, rightRayDir, 360f - perception.fovAngle, perception.perceptionRadius); Handles.color = oldColor; }
private void DrawAngleHandles(TwistDeformer twist) { startAngleHandle.angle = twist.StartAngle; startAngleHandle.radius = HandleUtility.GetHandleSize(twist.transform.position) * DeformEditorSettings.ScreenspaceAngleHandleSize; startAngleHandle.fillColor = Color.clear; endAngleHandle.angle = twist.EndAngle; endAngleHandle.radius = HandleUtility.GetHandleSize(twist.transform.position) * DeformEditorSettings.ScreenspaceAngleHandleSize; endAngleHandle.fillColor = Color.clear; var normal = -twist.Axis.forward; var direction = twist.Axis.right; var bottomMatrix = Matrix4x4.TRS(twist.transform.position + (twist.Axis.forward * twist.Bottom * twist.Axis.lossyScale.z), Quaternion.LookRotation(direction, normal), Vector3.one); var topMatrix = Matrix4x4.TRS(twist.transform.position + (twist.Axis.forward * twist.Top * twist.Axis.lossyScale.z), Quaternion.LookRotation(direction, normal), Vector3.one); using (new Handles.DrawingScope(Handles.matrix)) { Handles.color = DeformEditorSettings.SolidHandleColor; Handles.matrix = bottomMatrix; using (var check = new EditorGUI.ChangeCheckScope()) { startAngleHandle.DrawHandle(); if (check.changed) { Undo.RecordObject(twist, "Changed Start Angle"); twist.StartAngle = startAngleHandle.angle; } } Handles.matrix = topMatrix; using (var check = new EditorGUI.ChangeCheckScope()) { endAngleHandle.DrawHandle(); if (check.changed) { Undo.RecordObject(twist, "Changed End Angle"); twist.EndAngle = endAngleHandle.angle; } } } }
void OnSceneGUI() { m_Target = (ArcHandleDemo)target; Matrix4x4 handleMatrix = Matrix4x4.TRS( m_Target.transform.position, m_Target.transform.rotation, Vector3.one ); m_Arc.angle = m_Target.Angle; m_Arc.radius = m_Target.Radius; Handles.color = Color.white; using (new Handles.DrawingScope(handleMatrix)) { m_Arc.DrawHandle(); } m_Target.Angle = m_Arc.angle; m_Target.Radius = m_Arc.radius; }
private void DrawHandles() { var tf = m_Comp.transform; // Latitude North & Max. Distance. Vector3 fwd = tf.forward; Vector3 normal = Vector3.Cross(fwd, tf.up); Matrix4x4 matrix = Matrix4x4.TRS( tf.position, Quaternion.LookRotation(fwd, normal), Vector3.one ); using (new Handles.DrawingScope(matrix)) { EditorGUI.BeginChangeCheck(); { m_ArcHandleLatN.angle = m_Comp.LatAngleNorth; m_ArcHandleLatN.radius = m_Comp.MaxDistance; m_ArcHandleLatN.DrawHandle(); } if (EditorGUI.EndChangeCheck()) { RecordUpdate(); if (m_Comp.LatAngleNorth != m_ArcHandleLatN.angle) { m_Comp.LatAngleNorth = m_ArcHandleLatN.angle; } else if (m_Comp.MaxDistance != m_ArcHandleLatN.radius) { m_Comp.MaxDistance = m_ArcHandleLatN.radius; } } } // Latitude South & Max. Distance. normal = Vector3.Cross(fwd, -tf.up); matrix = Matrix4x4.TRS( tf.position, Quaternion.LookRotation(fwd, normal), Vector3.one ); using (new Handles.DrawingScope(matrix)) { EditorGUI.BeginChangeCheck(); { m_ArcHandleLatS.angle = m_Comp.LatAngleSouth; m_ArcHandleLatS.radius = m_Comp.MaxDistance; m_ArcHandleLatS.DrawHandle(); } if (EditorGUI.EndChangeCheck()) { RecordUpdate(); if (m_Comp.LatAngleSouth != m_ArcHandleLatS.angle) { m_Comp.LatAngleSouth = m_ArcHandleLatS.angle; } else if (m_Comp.MaxDistance != m_ArcHandleLatS.radius) { m_Comp.MaxDistance = m_ArcHandleLatS.radius; } } } // Longitude & Max. Distance. normal = Vector3.Cross(fwd, tf.right); matrix = Matrix4x4.TRS( tf.position, Quaternion.LookRotation(fwd, normal), Vector3.one ); using (new Handles.DrawingScope(matrix)) { EditorGUI.BeginChangeCheck(); { m_ArcHandleLon.angle = m_Comp.LonAngle; m_ArcHandleLon.radius = m_Comp.MaxDistance; m_ArcHandleLon.DrawHandle(); } if (EditorGUI.EndChangeCheck()) { RecordUpdate(); if (m_Comp.LonAngle != m_ArcHandleLon.angle) { m_Comp.LonAngle = m_ArcHandleLon.angle; } else if (m_Comp.MaxDistance != m_ArcHandleLon.radius) { m_Comp.MaxDistance = m_ArcHandleLon.radius; } } } // Minimum Distance. float min = m_Comp.MinDistance; EditorGUI.BeginChangeCheck(); { min = Handles.RadiusHandle(tf.rotation, tf.position, min); } if (EditorGUI.EndChangeCheck()) { RecordUpdate(); m_Comp.MinDistance = min; } }
void DrawHandle(int i) { Vector3 handlePosition = MathUtility.TransformPoint(bezierPath[i], creator.transform, bezierPath.Space); float anchorHandleSize = GetHandleDiameter(globalDisplaySettings.anchorSize * data.bezierHandleScale, bezierPath[i]); float controlHandleSize = GetHandleDiameter(globalDisplaySettings.controlSize * data.bezierHandleScale, bezierPath[i]); bool isAnchorPoint = i % 3 == 0; bool isInteractive = isAnchorPoint || bezierPath.ControlPointMode != BezierPath.ControlMode.Automatic; float handleSize = (isAnchorPoint) ? anchorHandleSize : controlHandleSize; bool doTransformHandle = i == handleIndexToDisplayAsTransform; PathHandle.HandleColours handleColours = (isAnchorPoint) ? splineAnchorColours : splineControlColours; if (i == handleIndexToDisplayAsTransform) { handleColours.defaultColour = (isAnchorPoint) ? globalDisplaySettings.anchorSelected : globalDisplaySettings.controlSelected; } var cap = capFunctions[(isAnchorPoint) ? globalDisplaySettings.anchorShape : globalDisplaySettings.controlShape]; PathHandle.HandleInputType handleInputType; handlePosition = PathHandle.DrawHandle(handlePosition, bezierPath.Space, isInteractive, handleSize, cap, handleColours, out handleInputType, i); if (doTransformHandle) { // Show normals rotate tool if (data.showNormals && Tools.current == Tool.Rotate && isAnchorPoint && bezierPath.Space == PathSpace.xyz) { Handles.color = handlesStartCol; int attachedControlIndex = (i == bezierPath.NumPoints - 1) ? i - 1 : i + 1; Vector3 dir = (bezierPath[attachedControlIndex] - handlePosition).normalized; float handleRotOffset = (360 + bezierPath.GlobalNormalsAngle) % 360; anchorAngleHandle.radius = handleSize * 3; anchorAngleHandle.angle = handleRotOffset + bezierPath.GetAnchorNormalAngle(i / 3); Vector3 handleDirection = Vector3.Cross(dir, Vector3.up); Matrix4x4 handleMatrix = Matrix4x4.TRS( handlePosition, Quaternion.LookRotation(handleDirection, dir), Vector3.one ); using (new Handles.DrawingScope(handleMatrix)) { // draw the handle EditorGUI.BeginChangeCheck(); anchorAngleHandle.DrawHandle(); if (EditorGUI.EndChangeCheck()) { Undo.RecordObject(creator, "Set angle"); bezierPath.SetAnchorNormalAngle(i / 3, anchorAngleHandle.angle - handleRotOffset); } } } else { handlePosition = Handles.DoPositionHandle(handlePosition, Quaternion.identity); } } switch (handleInputType) { case PathHandle.HandleInputType.LMBDrag: draggingHandleIndex = i; handleIndexToDisplayAsTransform = -1; Repaint(); break; case PathHandle.HandleInputType.LMBRelease: draggingHandleIndex = -1; handleIndexToDisplayAsTransform = -1; Repaint(); break; case PathHandle.HandleInputType.LMBClick: draggingHandleIndex = -1; if (Event.current.shift) { handleIndexToDisplayAsTransform = -1; // disable move tool if new point added } else { if (handleIndexToDisplayAsTransform == i) { handleIndexToDisplayAsTransform = -1; // disable move tool if clicking on point under move tool } else { handleIndexToDisplayAsTransform = i; } } Repaint(); break; case PathHandle.HandleInputType.LMBPress: if (handleIndexToDisplayAsTransform != i) { handleIndexToDisplayAsTransform = -1; Repaint(); } break; } Vector3 localHandlePosition = MathUtility.InverseTransformPoint(handlePosition, creator.transform, bezierPath.Space); if (bezierPath[i] != localHandlePosition) { Undo.RecordObject(creator, "Move point"); bezierPath.MovePoint(i, localHandlePosition); } }
protected virtual void OnSceneGUI(SceneView sceneView) { MeleeWep wep = target as MeleeWep; m_ArcHandle.angle = wep.arcAngle; m_ArcHandle.radius = wep.arcRadius; m_ArcHandleUp.angle = wep.knockBackAngle; m_ArcHandleUp.radius = wep.knockBackForce; if (GameObject.FindGameObjectWithTag("Player") == null) { return; } Transform player = GameObject.FindGameObjectWithTag("Player").GetComponent <Transform>(); Vector3 handleDirection = player.forward; Matrix4x4 handleMatrix = Matrix4x4.TRS( player.position, Quaternion.LookRotation(player.forward, player.up), Vector3.one ); using (new Handles.DrawingScope(handleMatrix)) { EditorGUI.BeginChangeCheck(); m_ArcHandle.DrawHandle(); if (EditorGUI.EndChangeCheck()) { // record the target object before setting new values so changes can be undone/redone Undo.RecordObject(wep, "Change Projectile Properties"); // copy the handle's updated data back to the target object wep.arcAngle = m_ArcHandle.angle; wep.arcRadius = m_ArcHandle.radius; EditorUtility.SetDirty(wep); } } handleMatrix = Matrix4x4.TRS( player.position, Quaternion.LookRotation(player.forward, -player.up), Vector3.one ); using (new Handles.DrawingScope(handleMatrix)) { EditorGUI.BeginChangeCheck(); m_ArcHandle.DrawHandle(); if (EditorGUI.EndChangeCheck()) { // record the target object before setting new values so changes can be undone/redone Undo.RecordObject(wep, "Change Projectile Properties"); // copy the handle's updated data back to the target object wep.arcAngle = m_ArcHandle.angle; wep.arcRadius = m_ArcHandle.radius; EditorUtility.SetDirty(wep); } } handleMatrix = Matrix4x4.TRS( player.position, Quaternion.LookRotation(player.forward, -player.right), Vector3.one ); using (new Handles.DrawingScope(handleMatrix)) { EditorGUI.BeginChangeCheck(); m_ArcHandleUp.DrawHandle(); if (EditorGUI.EndChangeCheck()) { // record the target object before setting new values so changes can be undone/redone Undo.RecordObject(wep, "Change Projectile Properties"); // copy the handle's updated data back to the target object wep.knockBackAngle = m_ArcHandleUp.angle; wep.knockBackForce = m_ArcHandleUp.radius; EditorUtility.SetDirty(wep); } } AssetDatabase.SaveAssets(); }
void OnSceneGUI() { Color origCol = Handles.color; Handles.color = s_GizmoColor; Matrix4x4 orgMatrix = Handles.matrix; EditorGUI.BeginChangeCheck(); foreach (UIParticle uip in _particles) { ParticleSystem ps = uip.cachedParticleSystem; if (!ps || !uip.canvas) { continue; } var shapeModule = ps.shape; var mainModule = ps.main; ParticleSystemShapeType type = shapeModule.shapeType; Matrix4x4 transformMatrix = new Matrix4x4(); if (mainModule.scalingMode == ParticleSystemScalingMode.Local) { transformMatrix.SetTRS(ps.transform.position, ps.transform.rotation, ps.transform.localScale); } else if (mainModule.scalingMode == ParticleSystemScalingMode.Hierarchy) { transformMatrix = ps.transform.localToWorldMatrix; } else { transformMatrix.SetTRS(ps.transform.position, ps.transform.rotation, ps.transform.lossyScale); } bool isBox = (type == ParticleSystemShapeType.Box || type == ParticleSystemShapeType.BoxShell || type == ParticleSystemShapeType.BoxEdge || type == ParticleSystemShapeType.Rectangle); Vector3 emitterScale = isBox ? Vector3.one : shapeModule.scale; Matrix4x4 emitterMatrix = Matrix4x4.TRS(shapeModule.position, Quaternion.Euler(shapeModule.rotation), emitterScale); transformMatrix *= emitterMatrix; Handles.matrix = transformMatrix; if (uip.canvas.renderMode == RenderMode.ScreenSpaceOverlay || ps.main.scalingMode == ParticleSystemScalingMode.Hierarchy) { Handles.matrix = Handles.matrix * Matrix4x4.Scale(Vector3.one * uip.scale); } else { Handles.matrix = Handles.matrix * Matrix4x4.Scale(uip.canvas.rootCanvas.transform.localScale * uip.scale); } if (type == ParticleSystemShapeType.Sphere) { // Thickness Handles.color *= s_ShapeGizmoThicknessTint; EditorGUI.BeginChangeCheck(); //float radiusThickness = Handles.DoSimpleRadiusHandle (Quaternion.identity, Vector3.zero, shapeModule.radius * (1.0f - shapeModule.radiusThickness), false, shapeModule.arc); float radiusThickness = Handles.RadiusHandle(Quaternion.identity, Vector3.zero, shapeModule.radius * (1.0f - shapeModule.radiusThickness), false); if (EditorGUI.EndChangeCheck()) { Undo.RecordObject(ps, "Sphere Thickness Handle Change"); shapeModule.radiusThickness = 1.0f - (radiusThickness / shapeModule.radius); } // Sphere Handles.color = s_GizmoColor; EditorGUI.BeginChangeCheck(); //float radius = Handles.DoSimpleRadiusHandle (Quaternion.identity, Vector3.zero, shapeModule.radius, false, shapeModule.arc); float radius = Handles.RadiusHandle(Quaternion.identity, Vector3.zero, shapeModule.radius, false); if (EditorGUI.EndChangeCheck()) { Undo.RecordObject(ps, "Sphere Handle Change"); shapeModule.radius = radius; } // Texture //Matrix4x4 textureTransform = transformMatrix * Matrix4x4.TRS (Vector3.zero, Quaternion.identity, Vector3.one * shapeModule.radius * 2.0f); //OnSceneViewTextureGUI (shapeModule, s_SphereMesh, false, s_SphereTextureMaterial, textureTransform); } else if (type == ParticleSystemShapeType.Circle) { // Thickness EditorGUI.BeginChangeCheck(); _arcHandle.angle = shapeModule.arc; _arcHandle.radius = shapeModule.radius * (1.0f - shapeModule.radiusThickness); _arcHandle.SetColorWithRadiusHandle(s_ShapeGizmoThicknessTint, 0f); _arcHandle.angleHandleColor = Color.clear; using (new Handles.DrawingScope(Handles.matrix * s_ArcHandleOffsetMatrix)) _arcHandle.DrawHandle(); if (EditorGUI.EndChangeCheck()) { Undo.RecordObject(ps, "Circle Thickness Handle Change"); shapeModule.radiusThickness = 1.0f - (_arcHandle.radius / shapeModule.radius); } // Circle EditorGUI.BeginChangeCheck(); _arcHandle.radius = shapeModule.radius; _arcHandle.SetColorWithRadiusHandle(Color.white, 0f); using (new Handles.DrawingScope(Handles.matrix * s_ArcHandleOffsetMatrix)) _arcHandle.DrawHandle(); if (EditorGUI.EndChangeCheck()) { Undo.RecordObject(ps, "Circle Handle Change"); shapeModule.radius = _arcHandle.radius; shapeModule.arc = _arcHandle.angle; } // Texture //Matrix4x4 textureTransform = transformMatrix * Matrix4x4.TRS (Vector3.zero, Quaternion.Euler (90.0f, 0.0f, 180.0f), Vector3.one * shapeModule.radius * 2.0f); //OnSceneViewTextureGUI (shapeModule, s_CircleMesh, true, s_TextureMaterial, textureTransform); } else if (type == ParticleSystemShapeType.Hemisphere) { // Thickness Handles.color *= s_ShapeGizmoThicknessTint; EditorGUI.BeginChangeCheck(); //float radiusThickness = Handles.DoSimpleRadiusHandle (Quaternion.identity, Vector3.zero, shapeModule.radius * (1.0f - shapeModule.radiusThickness), true, shapeModule.arc); //float radiusThickness = Call<float> (typeof (Handles), "DoSimpleRadiusHandle", Quaternion.identity, Vector3.zero, shapeModule.radius * (1.0f - shapeModule.radiusThickness), true, shapeModule.arc); float radiusThickness = Handles.RadiusHandle(Quaternion.identity, Vector3.zero, shapeModule.radius * (1.0f - shapeModule.radiusThickness), true); if (EditorGUI.EndChangeCheck()) { Undo.RecordObject(ps, "Hemisphere Thickness Handle Change"); shapeModule.radiusThickness = 1.0f - (radiusThickness / shapeModule.radius); } // Hemisphere Handles.color = s_GizmoColor; EditorGUI.BeginChangeCheck(); //float radius = Handles.DoSimpleRadiusHandle (Quaternion.identity, Vector3.zero, shapeModule.radius, true, shapeModule.arc); float radius = Handles.RadiusHandle(Quaternion.identity, Vector3.zero, shapeModule.radius, true); if (EditorGUI.EndChangeCheck()) { Undo.RecordObject(ps, "Hemisphere Handle Change"); shapeModule.radius = radius; } // Texture //Matrix4x4 textureTransform = transformMatrix * Matrix4x4.TRS (Vector3.zero, Quaternion.identity, Vector3.one * shapeModule.radius * 2.0f); //OnSceneViewTextureGUI (shapeModule, s_HemisphereMesh, false, s_SphereTextureMaterial, textureTransform); } else if (type == ParticleSystemShapeType.Cone) { // Thickness Handles.color *= s_ShapeGizmoThicknessTint; EditorGUI.BeginChangeCheck(); float angleThickness = Mathf.Lerp(shapeModule.angle, 0.0f, shapeModule.radiusThickness); Vector3 radiusThicknessAngleRange = new Vector3(shapeModule.radius * (1.0f - shapeModule.radiusThickness), angleThickness, mainModule.startSpeedMultiplier); //radiusThicknessAngleRange = Handles.ConeFrustrumHandle (Quaternion.identity, Vector3.zero, radiusThicknessAngleRange, Handles.ConeHandles.Radius); #if UNITY_2018_3_OR_NEWER radiusThicknessAngleRange = Call <Vector3> (typeof(Handles), "ConeFrustrumHandle", Quaternion.identity, Vector3.zero, radiusThicknessAngleRange, 1); #else radiusThicknessAngleRange = Call <Vector3> (typeof(Handles), "ConeFrustrumHandle", Quaternion.identity, Vector3.zero, radiusThicknessAngleRange); #endif if (EditorGUI.EndChangeCheck()) { Undo.RecordObject(ps, "Cone Thickness Handle Change"); shapeModule.radiusThickness = 1.0f - (radiusThicknessAngleRange.x / shapeModule.radius); } // Cone Handles.color = s_GizmoColor; EditorGUI.BeginChangeCheck(); Vector3 radiusAngleRange = new Vector3(shapeModule.radius, shapeModule.angle, mainModule.startSpeedMultiplier); //radiusAngleRange = Handles.ConeFrustrumHandle (Quaternion.identity, Vector3.zero, radiusAngleRange); #if UNITY_2018_3_OR_NEWER radiusAngleRange = Call <Vector3> (typeof(Handles), "ConeFrustrumHandle", Quaternion.identity, Vector3.zero, radiusAngleRange, 7); #else radiusAngleRange = Call <Vector3> (typeof(Handles), "ConeFrustrumHandle", Quaternion.identity, Vector3.zero, radiusAngleRange); #endif if (EditorGUI.EndChangeCheck()) { Undo.RecordObject(ps, "Cone Handle Change"); shapeModule.radius = radiusAngleRange.x; shapeModule.angle = radiusAngleRange.y; mainModule.startSpeedMultiplier = radiusAngleRange.z; } // Texture //Matrix4x4 textureTransform = transformMatrix * Matrix4x4.TRS (Vector3.zero, Quaternion.Euler (90.0f, 0.0f, 180.0f), Vector3.one * shapeModule.radius * 2.0f); //OnSceneViewTextureGUI (shapeModule, s_CircleMesh, true, s_TextureMaterial, textureTransform); } else if (type == ParticleSystemShapeType.ConeVolume) { // Thickness Handles.color *= s_ShapeGizmoThicknessTint; EditorGUI.BeginChangeCheck(); float angleThickness = Mathf.Lerp(shapeModule.angle, 0.0f, shapeModule.radiusThickness); Vector3 radiusThicknessAngleLength = new Vector3(shapeModule.radius * (1.0f - shapeModule.radiusThickness), angleThickness, shapeModule.length); //radiusThicknessAngleLength = Handles.ConeFrustrumHandle (Quaternion.identity, Vector3.zero, radiusThicknessAngleLength, Handles.ConeHandles.Radius); #if UNITY_2018_3_OR_NEWER radiusThicknessAngleLength = Call <Vector3> (typeof(Handles), "ConeFrustrumHandle", Quaternion.identity, Vector3.zero, radiusThicknessAngleLength, 1); #else radiusThicknessAngleLength = Call <Vector3> (typeof(Handles), "ConeFrustrumHandle", Quaternion.identity, Vector3.zero, radiusThicknessAngleLength); #endif if (EditorGUI.EndChangeCheck()) { Undo.RecordObject(ps, "Cone Volume Thickness Handle Change"); shapeModule.radiusThickness = 1.0f - (radiusThicknessAngleLength.x / shapeModule.radius); } // Cone Handles.color = s_GizmoColor; EditorGUI.BeginChangeCheck(); Vector3 radiusAngleLength = new Vector3(shapeModule.radius, shapeModule.angle, shapeModule.length); //radiusAngleLength = Handles.ConeFrustrumHandle (Quaternion.identity, Vector3.zero, radiusAngleLength); #if UNITY_2018_3_OR_NEWER radiusAngleLength = Call <Vector3> (typeof(Handles), "ConeFrustrumHandle", Quaternion.identity, Vector3.zero, radiusAngleLength, 7); #else radiusAngleLength = Call <Vector3> (typeof(Handles), "ConeFrustrumHandle", Quaternion.identity, Vector3.zero, radiusAngleLength); #endif if (EditorGUI.EndChangeCheck()) { Undo.RecordObject(ps, "Cone Volume Handle Change"); shapeModule.radius = radiusAngleLength.x; shapeModule.angle = radiusAngleLength.y; shapeModule.length = radiusAngleLength.z; } // Texture //Matrix4x4 textureTransform = transformMatrix * Matrix4x4.TRS (Vector3.zero, Quaternion.Euler (90.0f, 0.0f, 180.0f), Vector3.one * shapeModule.radius * 2.0f); //OnSceneViewTextureGUI (shapeModule, s_CircleMesh, true, s_TextureMaterial, textureTransform); } else if (type == ParticleSystemShapeType.Box || type == ParticleSystemShapeType.BoxShell || type == ParticleSystemShapeType.BoxEdge) { EditorGUI.BeginChangeCheck(); _boxBoundsHandle.center = Vector3.zero; _boxBoundsHandle.size = shapeModule.scale; _boxBoundsHandle.DrawHandle(); if (EditorGUI.EndChangeCheck()) { Undo.RecordObject(ps, "Box Handle Change"); shapeModule.scale = _boxBoundsHandle.size; } //Matrix4x4 textureTransform = transformMatrix * Matrix4x4.TRS (new Vector3 (0.0f, 0.0f, -m_BoxBoundsHandle.size.z * 0.5f), Quaternion.identity, m_BoxBoundsHandle.size); //OnSceneViewTextureGUI (shapeModule, s_QuadMesh, true, s_TextureMaterial, textureTransform); } else if (type == ParticleSystemShapeType.Donut) { // Radius EditorGUI.BeginChangeCheck(); _arcHandle.radius = shapeModule.radius; _arcHandle.angle = shapeModule.arc; _arcHandle.SetColorWithRadiusHandle(Color.white, 0f); _arcHandle.wireframeColor = Color.clear; using (new Handles.DrawingScope(Handles.matrix * s_ArcHandleOffsetMatrix)) _arcHandle.DrawHandle(); if (EditorGUI.EndChangeCheck()) { Undo.RecordObject(ps, "Donut Handle Change"); shapeModule.radius = _arcHandle.radius; shapeModule.arc = _arcHandle.angle; } // Donut extents using (new Handles.DrawingScope(Handles.matrix * s_ArcHandleOffsetMatrix)) { float excessAngle = shapeModule.arc % 360f; float angle = Mathf.Abs(shapeModule.arc) >= 360f ? 360f : excessAngle; Handles.DrawWireArc(new Vector3(0.0f, shapeModule.donutRadius, 0.0f), Vector3.up, Vector3.forward, angle, shapeModule.radius); Handles.DrawWireArc(new Vector3(0.0f, -shapeModule.donutRadius, 0.0f), Vector3.up, Vector3.forward, angle, shapeModule.radius); Handles.DrawWireArc(Vector3.zero, Vector3.up, Vector3.forward, angle, shapeModule.radius + shapeModule.donutRadius); Handles.DrawWireArc(Vector3.zero, Vector3.up, Vector3.forward, angle, shapeModule.radius - shapeModule.donutRadius); if (shapeModule.arc != 360.0f) { Quaternion arcRotation = Quaternion.AngleAxis(shapeModule.arc, Vector3.up); Vector3 capCenter = arcRotation * Vector3.forward * shapeModule.radius; Handles.DrawWireDisc(capCenter, arcRotation * Vector3.right, shapeModule.donutRadius); } } // Donut thickness _sphereBoundsHandle.axes = PrimitiveBoundsHandle.Axes.X | PrimitiveBoundsHandle.Axes.Y; _sphereBoundsHandle.radius = shapeModule.donutRadius * (1.0f - shapeModule.radiusThickness); _sphereBoundsHandle.center = Vector3.zero; _sphereBoundsHandle.SetColor(s_ShapeGizmoThicknessTint); const float handleInterval = 90.0f; int numOuterRadii = Mathf.Max(1, (int)Mathf.Ceil(shapeModule.arc / handleInterval)); Matrix4x4 donutRadiusStartMatrix = Matrix4x4.TRS(new Vector3(shapeModule.radius, 0.0f, 0.0f), Quaternion.Euler(90.0f, 0.0f, 0.0f), Vector3.one); for (int i = 0; i < numOuterRadii; i++) { EditorGUI.BeginChangeCheck(); using (new Handles.DrawingScope(Handles.matrix * (Matrix4x4.Rotate(Quaternion.Euler(0.0f, 0.0f, handleInterval * i)) * donutRadiusStartMatrix))) _sphereBoundsHandle.DrawHandle(); if (EditorGUI.EndChangeCheck()) { Undo.RecordObject(ps, "Donut Radius Thickness Handle Change"); shapeModule.radiusThickness = 1.0f - (_sphereBoundsHandle.radius / shapeModule.donutRadius); } } // Donut radius _sphereBoundsHandle.radius = shapeModule.donutRadius; _sphereBoundsHandle.SetColor(Color.white); for (int i = 0; i < numOuterRadii; i++) { EditorGUI.BeginChangeCheck(); using (new Handles.DrawingScope(Handles.matrix * (Matrix4x4.Rotate(Quaternion.Euler(0.0f, 0.0f, handleInterval * i)) * donutRadiusStartMatrix))) _sphereBoundsHandle.DrawHandle(); if (EditorGUI.EndChangeCheck()) { Undo.RecordObject(ps, "Donut Radius Handle Change"); shapeModule.donutRadius = _sphereBoundsHandle.radius; } } // Texture //Matrix4x4 textureTransform = transformMatrix * Matrix4x4.TRS (new Vector3 (shapeModule.radius, 0.0f, 0.0f), Quaternion.Euler (180.0f, 0.0f, 180.0f), Vector3.one * shapeModule.donutRadius * 2.0f); //OnSceneViewTextureGUI (shapeModule, s_CircleMesh, true, s_TextureMaterial, textureTransform); } else if (type == ParticleSystemShapeType.SingleSidedEdge) { EditorGUI.BeginChangeCheck(); //float radius = Handles.DoSimpleEdgeHandle (Quaternion.identity, Vector3.zero, shapeModule.radius); float radius = Call <float> (typeof(Handles), "DoSimpleEdgeHandle", Quaternion.identity, Vector3.zero, shapeModule.radius); if (EditorGUI.EndChangeCheck()) { Undo.RecordObject(ps, "Edge Handle Change"); shapeModule.radius = radius; } } else if (type == ParticleSystemShapeType.Mesh) { Mesh mesh = shapeModule.mesh; if (mesh) { bool orgWireframeMode = GL.wireframe; GL.wireframe = true; s_Material.SetPass(0); Graphics.DrawMeshNow(mesh, transformMatrix); GL.wireframe = orgWireframeMode; //OnSceneViewTextureGUI (shapeModule, mesh, false, s_TextureMaterial, transformMatrix); } } else if (type == ParticleSystemShapeType.Rectangle) { EditorGUI.BeginChangeCheck(); _boxBoundsHandle.center = Vector3.zero; _boxBoundsHandle.size = new Vector3(shapeModule.scale.x, shapeModule.scale.y, 0.0f); _boxBoundsHandle.DrawHandle(); if (EditorGUI.EndChangeCheck()) { Undo.RecordObject(ps, "Rectangle Handle Change"); shapeModule.scale = new Vector3(_boxBoundsHandle.size.x, _boxBoundsHandle.size.y, 0.0f); } //OnSceneViewTextureGUI (shapeModule, s_QuadMesh, true, s_TextureMaterial, transformMatrix * Matrix4x4.Scale (m_BoxBoundsHandle.size)); } else if (type == ParticleSystemShapeType.Sprite) { Sprite sprite = shapeModule.sprite; if (sprite) { if (!_spriteMesh) { _spriteMesh = new Mesh(); _spriteMesh.name = "ParticleSpritePreview"; _spriteMesh.hideFlags |= HideFlags.HideAndDontSave; } _spriteMesh.vertices = Array.ConvertAll(sprite.vertices, i => (Vector3)i); _spriteMesh.uv = sprite.uv; _spriteMesh.triangles = Array.ConvertAll(sprite.triangles, i => (int)i); bool orgWireframeMode = GL.wireframe; GL.wireframe = true; s_Material.SetPass(0); Graphics.DrawMeshNow(_spriteMesh, transformMatrix); GL.wireframe = orgWireframeMode; //OnSceneViewTextureGUI (shapeModule, m_SpriteMesh, false, s_TextureMaterial, transformMatrix); } } } Handles.color = origCol; Handles.matrix = orgMatrix; }
override public void OnSceneViewGUI() { Color origCol = Handles.color; Handles.color = s_ShapeGizmoColor; Matrix4x4 orgMatrix = Handles.matrix; EditorGUI.BeginChangeCheck(); foreach (ParticleSystem ps in m_ParticleSystemUI.m_ParticleSystems) { var shapeModule = ps.shape; var mainModule = ps.main; ParticleSystemShapeType type = shapeModule.shapeType; Matrix4x4 transformMatrix = new Matrix4x4(); if (mainModule.scalingMode == ParticleSystemScalingMode.Local) { transformMatrix.SetTRS(ps.transform.position, ps.transform.rotation, ps.transform.localScale); } else if (mainModule.scalingMode == ParticleSystemScalingMode.Hierarchy) { transformMatrix = ps.transform.localToWorldMatrix; } else { transformMatrix.SetTRS(ps.transform.position, ps.transform.rotation, ps.transform.lossyScale); } bool isBox = (type == ParticleSystemShapeType.Box || type == ParticleSystemShapeType.BoxShell || type == ParticleSystemShapeType.BoxEdge || type == ParticleSystemShapeType.Rectangle); Vector3 emitterScale = isBox ? Vector3.one : shapeModule.scale; Matrix4x4 emitterMatrix = Matrix4x4.TRS(shapeModule.position, Quaternion.Euler(shapeModule.rotation), emitterScale); transformMatrix *= emitterMatrix; Handles.matrix = transformMatrix; if (type == ParticleSystemShapeType.Sphere) { EditorGUI.BeginChangeCheck(); float radius = Handles.DoSimpleRadiusHandle(Quaternion.identity, Vector3.zero, shapeModule.radius, false); if (EditorGUI.EndChangeCheck()) { Undo.RecordObject(ps, "Sphere Handle Change"); shapeModule.radius = radius; } Matrix4x4 textureTransform = transformMatrix * Matrix4x4.TRS(Vector3.zero, Quaternion.identity, Vector3.one * shapeModule.radius * 2.0f); OnSceneViewTextureGUI(shapeModule, s_SphereMesh, false, s_SphereTextureMaterial, textureTransform); } else if (type == ParticleSystemShapeType.Circle) { EditorGUI.BeginChangeCheck(); m_ArcHandle.radius = shapeModule.radius; m_ArcHandle.angle = shapeModule.arc; m_ArcHandle.SetColorWithRadiusHandle(Color.white, 0f); using (new Handles.DrawingScope(Handles.matrix * s_ArcHandleOffsetMatrix)) m_ArcHandle.DrawHandle(); if (EditorGUI.EndChangeCheck()) { Undo.RecordObject(ps, "Circle Handle Change"); shapeModule.radius = m_ArcHandle.radius; shapeModule.arc = m_ArcHandle.angle; } Matrix4x4 textureTransform = transformMatrix * Matrix4x4.TRS(Vector3.zero, Quaternion.Euler(90.0f, 0.0f, 180.0f), Vector3.one * shapeModule.radius * 2.0f); OnSceneViewTextureGUI(shapeModule, s_CircleMesh, true, s_TextureMaterial, textureTransform); } else if (type == ParticleSystemShapeType.Hemisphere) { EditorGUI.BeginChangeCheck(); float radius = Handles.DoSimpleRadiusHandle(Quaternion.identity, Vector3.zero, shapeModule.radius, true); if (EditorGUI.EndChangeCheck()) { Undo.RecordObject(ps, "Hemisphere Handle Change"); shapeModule.radius = radius; } Matrix4x4 textureTransform = transformMatrix * Matrix4x4.TRS(Vector3.zero, Quaternion.identity, Vector3.one * shapeModule.radius * 2.0f); OnSceneViewTextureGUI(shapeModule, s_HemisphereMesh, false, s_SphereTextureMaterial, textureTransform); } else if (type == ParticleSystemShapeType.Cone) { EditorGUI.BeginChangeCheck(); Vector3 radiusAngleRange = new Vector3(shapeModule.radius, shapeModule.angle, mainModule.startSpeedMultiplier); radiusAngleRange = Handles.ConeFrustrumHandle(Quaternion.identity, Vector3.zero, radiusAngleRange); if (EditorGUI.EndChangeCheck()) { Undo.RecordObject(ps, "Cone Handle Change"); shapeModule.radius = radiusAngleRange.x; shapeModule.angle = radiusAngleRange.y; mainModule.startSpeedMultiplier = radiusAngleRange.z; } Matrix4x4 textureTransform = transformMatrix * Matrix4x4.TRS(Vector3.zero, Quaternion.Euler(90.0f, 0.0f, 180.0f), Vector3.one * shapeModule.radius * 2.0f); OnSceneViewTextureGUI(shapeModule, s_CircleMesh, true, s_TextureMaterial, textureTransform); } else if (type == ParticleSystemShapeType.ConeVolume) { EditorGUI.BeginChangeCheck(); Vector3 radiusAngleLength = new Vector3(shapeModule.radius, shapeModule.angle, shapeModule.length); radiusAngleLength = Handles.ConeFrustrumHandle(Quaternion.identity, Vector3.zero, radiusAngleLength); if (EditorGUI.EndChangeCheck()) { Undo.RecordObject(ps, "Cone Volume Handle Change"); shapeModule.radius = radiusAngleLength.x; shapeModule.angle = radiusAngleLength.y; shapeModule.length = radiusAngleLength.z; } Matrix4x4 textureTransform = transformMatrix * Matrix4x4.TRS(Vector3.zero, Quaternion.Euler(90.0f, 0.0f, 180.0f), Vector3.one * shapeModule.radius * 2.0f); OnSceneViewTextureGUI(shapeModule, s_CircleMesh, true, s_TextureMaterial, textureTransform); } else if (type == ParticleSystemShapeType.Box || type == ParticleSystemShapeType.BoxShell || type == ParticleSystemShapeType.BoxEdge) { EditorGUI.BeginChangeCheck(); m_BoxBoundsHandle.center = Vector3.zero; m_BoxBoundsHandle.size = shapeModule.scale; m_BoxBoundsHandle.DrawHandle(); if (EditorGUI.EndChangeCheck()) { Undo.RecordObject(ps, "Box Handle Change"); shapeModule.scale = m_BoxBoundsHandle.size; } Matrix4x4 textureTransform = transformMatrix * Matrix4x4.TRS(new Vector3(0.0f, 0.0f, -m_BoxBoundsHandle.size.z * 0.5f), Quaternion.identity, m_BoxBoundsHandle.size); OnSceneViewTextureGUI(shapeModule, s_QuadMesh, true, s_TextureMaterial, textureTransform); } else if (type == ParticleSystemShapeType.Donut) { // radius EditorGUI.BeginChangeCheck(); m_ArcHandle.radius = shapeModule.radius; m_ArcHandle.angle = shapeModule.arc; m_ArcHandle.SetColorWithRadiusHandle(Color.white, 0f); m_ArcHandle.wireframeColor = Color.clear; using (new Handles.DrawingScope(Handles.matrix * s_ArcHandleOffsetMatrix)) m_ArcHandle.DrawHandle(); if (EditorGUI.EndChangeCheck()) { Undo.RecordObject(ps, "Donut Handle Change"); shapeModule.radius = m_ArcHandle.radius; shapeModule.arc = m_ArcHandle.angle; } // donut extents using (new Handles.DrawingScope(Handles.matrix * s_ArcHandleOffsetMatrix)) { float excessAngle = shapeModule.arc % 360f; float angle = Mathf.Abs(shapeModule.arc) >= 360f ? 360f : excessAngle; Handles.DrawWireArc(new Vector3(0.0f, shapeModule.donutRadius, 0.0f), Vector3.up, Vector3.forward, angle, shapeModule.radius); Handles.DrawWireArc(new Vector3(0.0f, -shapeModule.donutRadius, 0.0f), Vector3.up, Vector3.forward, angle, shapeModule.radius); Handles.DrawWireArc(Vector3.zero, Vector3.up, Vector3.forward, angle, shapeModule.radius + shapeModule.donutRadius); Handles.DrawWireArc(Vector3.zero, Vector3.up, Vector3.forward, angle, shapeModule.radius - shapeModule.donutRadius); if (shapeModule.arc != 360.0f) { Quaternion arcRotation = Quaternion.AngleAxis(shapeModule.arc, Vector3.up); Vector3 capCenter = arcRotation * Vector3.forward * shapeModule.radius; Handles.DrawWireDisc(capCenter, arcRotation * Vector3.right, shapeModule.donutRadius); } } // donut radius m_SphereBoundsHandle.axes = PrimitiveBoundsHandle.Axes.X | PrimitiveBoundsHandle.Axes.Y; m_SphereBoundsHandle.radius = shapeModule.donutRadius; m_SphereBoundsHandle.center = Vector3.zero; m_SphereBoundsHandle.SetColor(Color.white); float handleInterval = 90.0f; int numOuterRadii = Mathf.Max(1, (int)Mathf.Ceil(shapeModule.arc / handleInterval)); Matrix4x4 donutRadiusStartMatrix = Matrix4x4.TRS(new Vector3(shapeModule.radius, 0.0f, 0.0f), Quaternion.Euler(90.0f, 0.0f, 0.0f), Vector3.one); for (int i = 0; i < numOuterRadii; i++) { EditorGUI.BeginChangeCheck(); using (new Handles.DrawingScope(Handles.matrix * (Matrix4x4.Rotate(Quaternion.Euler(0.0f, 0.0f, handleInterval * i)) * donutRadiusStartMatrix))) m_SphereBoundsHandle.DrawHandle(); if (EditorGUI.EndChangeCheck()) { Undo.RecordObject(ps, "Donut Radius Handle Change"); shapeModule.donutRadius = m_SphereBoundsHandle.radius; } } // texture Matrix4x4 textureTransform = transformMatrix * Matrix4x4.TRS(new Vector3(shapeModule.radius, 0.0f, 0.0f), Quaternion.Euler(180.0f, 0.0f, 180.0f), Vector3.one * shapeModule.donutRadius * 2.0f); OnSceneViewTextureGUI(shapeModule, s_CircleMesh, true, s_TextureMaterial, textureTransform); } else if (type == ParticleSystemShapeType.SingleSidedEdge) { EditorGUI.BeginChangeCheck(); float radius = Handles.DoSimpleEdgeHandle(Quaternion.identity, Vector3.zero, shapeModule.radius); if (EditorGUI.EndChangeCheck()) { Undo.RecordObject(ps, "Edge Handle Change"); shapeModule.radius = radius; } } else if (type == ParticleSystemShapeType.Mesh) { Mesh mesh = shapeModule.mesh; if (mesh) { bool orgWireframeMode = GL.wireframe; GL.wireframe = true; s_Material.SetPass(0); Graphics.DrawMeshNow(mesh, transformMatrix); GL.wireframe = orgWireframeMode; OnSceneViewTextureGUI(shapeModule, mesh, false, s_TextureMaterial, transformMatrix); } } else if (type == ParticleSystemShapeType.Rectangle) { EditorGUI.BeginChangeCheck(); m_BoxBoundsHandle.center = Vector3.zero; m_BoxBoundsHandle.size = new Vector3(shapeModule.scale.x, shapeModule.scale.y, 0.0f); m_BoxBoundsHandle.DrawHandle(); if (EditorGUI.EndChangeCheck()) { Undo.RecordObject(ps, "Rectangle Handle Change"); shapeModule.scale = new Vector3(m_BoxBoundsHandle.size.x, m_BoxBoundsHandle.size.y, 0.0f); } OnSceneViewTextureGUI(shapeModule, s_QuadMesh, true, s_TextureMaterial, transformMatrix * Matrix4x4.Scale(m_BoxBoundsHandle.size)); } else if (type == ParticleSystemShapeType.Sprite) { Sprite sprite = shapeModule.sprite; if (sprite) { if (!m_SpriteMesh) { m_SpriteMesh = new Mesh(); m_SpriteMesh.name = "ParticleSpritePreview"; m_SpriteMesh.hideFlags |= HideFlags.HideAndDontSave; } m_SpriteMesh.vertices = Array.ConvertAll(sprite.vertices, i => (Vector3)i); m_SpriteMesh.uv = sprite.uv; m_SpriteMesh.triangles = Array.ConvertAll(sprite.triangles, i => (int)i); bool orgWireframeMode = GL.wireframe; GL.wireframe = true; s_Material.SetPass(0); Graphics.DrawMeshNow(m_SpriteMesh, transformMatrix); GL.wireframe = orgWireframeMode; OnSceneViewTextureGUI(shapeModule, m_SpriteMesh, false, s_TextureMaterial, transformMatrix); } } } if (EditorGUI.EndChangeCheck()) { m_ParticleSystemUI.m_ParticleEffectUI.m_Owner.Repaint(); } Handles.color = origCol; Handles.matrix = orgMatrix; }
void DrawHandle(int i) { var handlePosition = BezierPath[i]; var anchorHandleSize = GetHandleDiameter( _globalDisplaySettings.anchorSize * Data.bezierHandleScale, BezierPath[i]); var controlHandleSize = GetHandleDiameter( _globalDisplaySettings.controlSize * Data.bezierHandleScale, BezierPath[i]); var isAnchorPoint = i % 3 == 0; var isInteractive = isAnchorPoint || BezierPath.ControlPointMode != BezierPath.ControlMode.Automatic; var handleSize = (isAnchorPoint) ? anchorHandleSize : controlHandleSize; var doTransformHandle = i == _handleIndexToDisplayAsTransform; var handleColours = (isAnchorPoint) ? _splineAnchorColours : _splineControlColours; var cap = _capFunctions[(isAnchorPoint) ? _globalDisplaySettings.anchorShape : _globalDisplaySettings.controlShape]; PathHandle.HandleInputType handleInputType; handlePosition = PathHandle.DrawHandle( handlePosition, BezierPath.Space, isInteractive, handleSize, cap, handleColours, out handleInputType, i); if (doTransformHandle) { // Show normals rotate tool if (Data.showNormals && Tools.current == Tool.Rotate && isAnchorPoint && BezierPath.Space == PathSpace.Xyz) { Handles.color = _handlesStartCol; var attachedControlIndex = (i == BezierPath.NumPoints - 1) ? i - 1 : i + 1; var dir = (BezierPath[attachedControlIndex] - handlePosition).normalized; var handleRotOffset = (360 + BezierPath.GlobalNormalsAngle) % 360; _anchorAngleHandle.radius = handleSize * 3; _anchorAngleHandle.angle = handleRotOffset + BezierPath.GetAnchorNormalAngle(i / 3); var handleDirection = Vector3.Cross(dir, Vector3.up); var handleMatrix = Matrix4x4.TRS( handlePosition, Quaternion.LookRotation(handleDirection, dir), Vector3.one); using (new Handles.DrawingScope(handleMatrix)) { // draw the handle EditorGUI.BeginChangeCheck(); _anchorAngleHandle.DrawHandle(); if (EditorGUI.EndChangeCheck()) { Undo.RecordObject(_creator, "Set angle"); BezierPath.SetAnchorNormalAngle(i / 3, _anchorAngleHandle.angle - handleRotOffset); } } } else { handlePosition = Handles.DoPositionHandle(handlePosition, Quaternion.identity); } } switch (handleInputType) { case PathHandle.HandleInputType.LmbDrag: _draggingHandleIndex = i; _handleIndexToDisplayAsTransform = -1; break; case PathHandle.HandleInputType.LmbRelease: _draggingHandleIndex = -1; _handleIndexToDisplayAsTransform = -1; break; case PathHandle.HandleInputType.LmbClick: if (Event.current.shift) { _handleIndexToDisplayAsTransform = -1; // disable move tool if new point added } else { if (_handleIndexToDisplayAsTransform == i) { _handleIndexToDisplayAsTransform = -1; // disable move tool if clicking on point under move tool } else { _handleIndexToDisplayAsTransform = i; } } break; case PathHandle.HandleInputType.LmbPress: if (_handleIndexToDisplayAsTransform != i) { _handleIndexToDisplayAsTransform = -1; } break; } if (BezierPath[i] != handlePosition) { Undo.RecordObject(_creator, "Move point"); BezierPath.MovePoint(i, handlePosition); } }
void DrawHandle(int i) { Vector3 handlePosition = bezierPath[i]; float anchorHandleSize = GetHandleDiameter(globalDisplaySettings.anchorSize * data.bezierHandleScale, bezierPath[i]); float controlHandleSize = GetHandleDiameter(globalDisplaySettings.controlSize * data.bezierHandleScale, bezierPath[i]); bool isAnchorPoint = i % 3 == 0; bool isInteractive = isAnchorPoint || bezierPath.ControlPointMode != BezierPath.ControlMode.Automatic; float handleSize = (isAnchorPoint) ? anchorHandleSize : controlHandleSize; bool doTransformHandle = i == handleIndexToDisplayAsTransform; PathHandle.HandleColours handleColours = (isAnchorPoint) ? splineAnchorColours : splineControlColours; if (i == handleIndexToDisplayAsTransform) { handleColours.defaultColour = (isAnchorPoint) ? globalDisplaySettings.anchorSelected : globalDisplaySettings.controlSelected; } var cap = capFunctions[(isAnchorPoint) ? globalDisplaySettings.anchorShape : globalDisplaySettings.controlShape]; PathHandle.HandleInputType handleInputType; handlePosition = PathHandle.DrawHandle(handlePosition, bezierPath.Space, isInteractive, handleSize, cap, handleColours, out handleInputType, i); if (doTransformHandle) { // Show normals rotate tool if (data.showNormals && Tools.current == Tool.Rotate && isAnchorPoint && bezierPath.Space == PathSpace.xyz) { Handles.color = handlesStartCol; int attachedControlIndex = (i == bezierPath.NumPoints - 1) ? i - 1 : i + 1; Vector3 dir = (bezierPath[attachedControlIndex] - handlePosition).normalized; float handleRotOffset = (360 + bezierPath.GlobalNormalsAngle) % 360; anchorAngleHandle.radius = handleSize * 3; anchorAngleHandle.angle = handleRotOffset + bezierPath.GetAnchorNormalAngle(i / 3); Vector3 handleDirection = Vector3.Cross(dir, Vector3.up); Matrix4x4 handleMatrix = Matrix4x4.TRS( handlePosition, Quaternion.LookRotation(handleDirection, dir), Vector3.one ); using (new Handles.DrawingScope(handleMatrix)) { // draw the handle EditorGUI.BeginChangeCheck(); anchorAngleHandle.DrawHandle(); if (EditorGUI.EndChangeCheck()) { Undo.RecordObject(creator, "Set angle"); bezierPath.SetAnchorNormalAngle(i / 3, anchorAngleHandle.angle - handleRotOffset); } } } else { handlePosition = Handles.DoPositionHandle(handlePosition, Quaternion.identity); } } switch (handleInputType) { case PathHandle.HandleInputType.LMBDrag: draggingHandleIndex = i; handleIndexToDisplayAsTransform = -1; Repaint(); break; case PathHandle.HandleInputType.LMBRelease: draggingHandleIndex = -1; handleIndexToDisplayAsTransform = -1; Repaint(); break; case PathHandle.HandleInputType.LMBClick: if (Event.current.shift) { handleIndexToDisplayAsTransform = -1; // disable move tool if new point added } else { if (handleIndexToDisplayAsTransform == i) { handleIndexToDisplayAsTransform = -1; // disable move tool if clicking on point under move tool } else { handleIndexToDisplayAsTransform = i; } } Repaint(); break; case PathHandle.HandleInputType.LMBPress: if (handleIndexToDisplayAsTransform != i) { handleIndexToDisplayAsTransform = -1; Repaint(); } break; } if (bezierPath[i] != handlePosition) { Undo.RecordObject(creator, "Move point"); bezierPath.MovePoint(i, handlePosition); // If the use is holding alt, try and mirror the control point. if (Event.current.modifiers == EventModifiers.Alt) { // 0 = Anchor, 1 = Left Control, 2 = Right Control var pointType = i % 3; // If we are selecting a control point if (pointType != 0) { // If we are selecting the left control point if (pointType == 2) { // If the path doesn't loop and the user is selecting the last control point there isn't a control point to mirror if (i < bezierPath.NumPoints - 2 && !bezierPath.IsClosed) { return; } // Get the index of this control's anchor. var anchorIndex = (i + 1) % bezierPath.NumPoints; var anchorPoint = bezierPath[anchorIndex]; // Get the index of the anchors other control. // We don't have to loop this index b/c if it's the last control, it's anchors index will be 1. var otherControlPointIndex = anchorIndex + 1; // Move the other control point to the opposite of the selected control point's position relative to it's anchor. bezierPath.MovePoint(otherControlPointIndex, anchorPoint - (handlePosition - anchorPoint)); } // If we are selecting the right control point else if (pointType == 1) { // If the path doesn't loop and the user is selecting the first control point there isn't a control point to mirror. if (i > 1 && !bezierPath.IsClosed) { return; } // Get the index of this control's anchor. var anchorIndex = i - 1; var anchorPoint = bezierPath[anchorIndex]; // Get the index of the anchors other control. var otherControlPointIndex = anchorIndex - 1; // Make sure to loop this index back around if it is < 1. if (otherControlPointIndex < 0) { otherControlPointIndex = bezierPath.NumPoints - Mathf.Abs(otherControlPointIndex); } // Move the other control point to the opposite of the selected control point's position relative to it's anchor. bezierPath.MovePoint(otherControlPointIndex, anchorPoint - (handlePosition - anchorPoint)); } } } } }