private void SwichEnterTypeInSceneGUI()
{
for (int i = 0; i < Monsterpoint.MonsterPointdataList.Count; i++)
{
Handles.CubeCap(0, Monsterpoint.MonsterPointdataList[i].Effpos, Quaternion.identity, 0.3f);
switch (Monsterpoint.MonsterPointdataList[i].Entertype)
{
case MonsterEnterType.StayIdle:
//Handles.CircleCap(0, Monsterpoint.transform.position, Quaternion.EulerRotation(20.45f,0,0), Monsterpoint.MonsterPointdataList[i].StayIdleSize);
break;
case MonsterEnterType.RunAround:
for (int j = 0; j < Monsterpoint.MonsterPointdataList[i].RunAroundCount; j++)
{
Handles.SphereCap(0,Monsterpoint.MonsterPointdataList[i].RunAroundPoints[j], Quaternion.identity, 0.3f);
}
break;
}
}
}
static void DrawPointSceneGUI(BezierPoint point)
{
Handles.Label(point.position + new Vector3(0, HandleUtility.GetHandleSize(point.position) * 0.4f, 0), point.gameObject.name);
Handles.color = Color.green;
Vector3 newPosition = Handles.FreeMoveHandle(point.position, point.transform.rotation, HandleUtility.GetHandleSize(point.position) * 0.1f, Vector3.zero, Handles.RectangleHandleCap);
if (newPosition != point.position)
{
Undo.RegisterCompleteObjectUndo(point.transform, "Move Point");
point.transform.position = newPosition;
}
if (point.handleStyle != BezierPoint.HandleStyle.None)
{
Handles.color = Color.cyan;
Vector3 newGlobal1 = Handles.FreeMoveHandle(point.globalHandle1, point.transform.rotation, HandleUtility.GetHandleSize(point.globalHandle1) * 0.075f, Vector3.zero, Handles.CircleHandleCap);
if (point.globalHandle1 != newGlobal1)
{
Undo.RegisterCompleteObjectUndo(point, "Move Handle");
point.globalHandle1 = newGlobal1;
if (point.handleStyle == BezierPoint.HandleStyle.Connected)
{
point.globalHandle2 = -(newGlobal1 - point.position) + point.position;
}
}
Vector3 newGlobal2 = Handles.FreeMoveHandle(point.globalHandle2, point.transform.rotation, HandleUtility.GetHandleSize(point.globalHandle2) * 0.075f, Vector3.zero, Handles.CircleHandleCap);
if (point.globalHandle2 != newGlobal2)
{
Undo.RegisterCompleteObjectUndo(point, "Move Handle");
point.globalHandle2 = newGlobal2;
if (point.handleStyle == BezierPoint.HandleStyle.Connected)
{
point.globalHandle1 = -(newGlobal2 - point.position) + point.position;
}
}
Handles.color = Color.yellow;
Handles.DrawLine(point.position, point.globalHandle1);
Handles.DrawLine(point.position, point.globalHandle2);
}
}
public static void DrawSpline(CatmullRomUniform spline, Transform owner)
{
List <Vector3> interPts = spline.InterPoints;
List <Vector3> tangents = spline.InterTangents;
List <Vector3> ups = spline.InterUps;
Vector3 p0, p1;
Vector3 prevBino = Vector3.right;
p0 = owner.TransformPoint(interPts[0]);
for (int i = 0; i < interPts.Count; ++i)
{
Vector3 tan = owner.TransformDirection(tangents[i]).normalized;
Vector3 up = owner.TransformDirection(ups[i]).normalized;
Vector3 bino = Vector3.Cross(up, tan).normalized;
if (bino == Vector3.zero)
{
bino = prevBino;
}
else
{
prevBino = bino;
}
if (ms_drawArrow)
{
Handles.DrawLine(p0, p0 + (bino - tan) * ms_arrowLineLen);
Handles.DrawLine(p0, p0 - (bino + tan) * ms_arrowLineLen);
}
if (ms_drawUp)
{
Handles.DrawLine(p0, p0 + up * ms_arrowLineLen);
}
if (i + 1 < interPts.Count)
{
p1 = owner.TransformPoint(interPts[i + 1]);
Handles.DrawLine(p0, p1);
p0 = p1;
}
}
}
public static void DrawCatmullPath(List<Transform> points, InterpolationFunc sampler, int samples)
{
if (!PreDrawPath(points, 4))
return;
float sampleInterval = 1.0f / (float)samples;
int p0, p1, p2, p3;
for (int i = 0; i < points.Count; ++i)
{
p1 = i;
p0 = p1 - 1;
if (p0 < 0)
p0 = points.Count - 1;
p2 = p1 + 1;
if (p2 >= points.Count)
p2 = 0;
p3 = p2 + 1;
if (p3 >= points.Count)
p3 = 0;
Vector3 sample, prevSample;
prevSample = points[p1].position;
for (int j = 1; j <= samples; ++j)
{
float t = j * sampleInterval;
sample = sampler(points[p0].position,
points[p1].position,
points[p2].position,
points[p3].position, t);
Handles.DrawLine(prevSample, sample);
prevSample = sample;
}
}
}
public static void DrawSelector(ColorKeyframe keyframe)
{
int hint = (ControlHint * keyframe.MarkerIndex) + keyframe.MarkerIndex;
int controlId = GUIUtility.GetControlID(hint, FocusType.Passive);
Vector3 offsetPosition = keyframe.Position + new Vector3(0, keyframe.Offset, 0);
float size = 0.0175f;
float hitboxSize = 1.5f * size;
// -- DOT & LINE -- //
Handles.color = Palette.Translucent;
Handles.DrawLine(keyframe.Position, offsetPosition);
CustomHandles.DrawDisc(offsetPosition, size * 0.5f, keyframe.LightColor);
// -- SELECTION -- //
if (CustomHandles.SelectableButton(offsetPosition, hitboxSize, keyframe.LightColor))
{
Selection.activeObject = keyframe;
}
bool selected = Selection.activeObject == keyframe;
if (selected)
{
CustomHandles.DrawCircle(offsetPosition, hitboxSize, keyframe.LightColor);
}
/// -- MOVEMENT -- //
EditorGUI.BeginChangeCheck();
Vector3 newPosition = Handles.FreeMoveHandle(controlId, offsetPosition, Quaternion.identity, size, DefaultSnap, CustomHandles.NullCap);
if (EditorGUI.EndChangeCheck() && selected)
{
Undo.RecordObject(keyframe, "Change Color Keyframe");
Vector3 delta = (newPosition - offsetPosition);
ApplyDelta(keyframe, keyframe.Tangent, delta);
keyframe.Drone.UpdateView();
TimelineEditor.Refresh(RefreshReason.ContentsModified);
}
}
private static void RenderCustomGizmo(Transform objectTransform, GizmoType gizmoType)
{
var path = objectTransform.GetComponent <UnitPath>();
if (path != null)
{
var p0 = objectTransform.TransformPoint(path[0]);
for (var i = 1; i < path.Count; i += 3)
{
var p1 = objectTransform.TransformPoint(path[i]);
var p2 = objectTransform.TransformPoint(path[i + 1]);
var p3 = objectTransform.TransformPoint(path[i + 2]);
Handles.DrawBezier(p0, p3, p1, p2, Color.white, null, 2.0f);
p0 = p3;
}
}
}
private void OnSceneGUI()
{
curve = target as BezierCurve;
handleTransform = curve.transform;
handleRotation = Tools.pivotRotation == PivotRotation.Local ? handleTransform.rotation : Quaternion.identity;
Vector3 p0 = ShowPoint(0);
Vector3 p1 = ShowPoint(1);
Vector3 p2 = ShowPoint(2);
Vector3 p3 = ShowPoint(3);
Handles.color = Color.gray;
Handles.DrawLine(p0, p1);
Handles.DrawLine(p2, p3);
ShowDirections();
Handles.DrawBezier(p0, p3, p1, p2, Color.white, null, 5f);
}
void OnDrawGizmosSelected()
{
Gizmos.color = Color.white;
Gizmos.DrawSphere(StartNode.RootNode.transform.position, 0.25f);
Handles.Label(StartNode.RootNode.transform.position + Vector3.up, "0");
Gizmos.color = Color.red;
Gizmos.DrawSphere(StartNode.AfterNode.transform.position, 0.1f);
Handles.Label(StartNode.AfterNode.transform.position + Vector3.up, "0_");
Gizmos.DrawLine(StartNode.RootNode.position, StartNode.AfterNode.position);
Gizmos.color = Color.black;
Gizmos.DrawSphere(EndNode.RootNode.transform.position, 0.25f);
Handles.Label(EndNode.RootNode.transform.position + Vector3.up, (MidNodes.Count + 1).ToString());
Gizmos.color = Color.cyan;
Gizmos.DrawSphere(EndNode.BeforeNode.transform.position, 0.1f);
Handles.Label(EndNode.BeforeNode.transform.position + Vector3.up, "_" + (MidNodes.Count + 1));
Gizmos.DrawLine(EndNode.RootNode.position, EndNode.BeforeNode.position);
for (int i = 0; i < MidNodes.Count; i++)
{
Gizmos.color = Color.cyan;
Gizmos.DrawSphere(MidNodes[i].BeforeNode.transform.position, 0.1f);
Handles.Label(MidNodes[i].BeforeNode.transform.position + Vector3.up, "_" + (i + 1));
Gizmos.DrawLine(MidNodes[i].RootNode.transform.position, MidNodes[i].BeforeNode.transform.position);
Gizmos.color = Color.Lerp(Color.white, Color.black, (float)(i + 1) / (MidNodes.Count + 1));
Gizmos.DrawSphere(MidNodes[i].RootNode.transform.position, 0.25f);
Handles.Label(MidNodes[i].RootNode.transform.position + Vector3.up, (i + 1).ToString());
Gizmos.color = Color.red;
Gizmos.DrawSphere(MidNodes[i].AfterNode.transform.position, 0.1f);
Handles.Label(MidNodes[i].AfterNode.transform.position + Vector3.up, (i + 1) + "_");
Gizmos.DrawLine(MidNodes[i].RootNode.transform.position, MidNodes[i].AfterNode.transform.position);
}
}
private void OnSceneGUI()
{
FieldOfView fov = (FieldOfView)target;
Handles.color = Color.white;
Handles.DrawWireArc(fov.transform.position, Vector3.forward, Vector2.up, 360, fov.viewRadius);
Vector2 viewAngleA = fov.DirectionFromAngle(-fov.viewAngle / 2, false);
Vector2 viewAngleB = fov.DirectionFromAngle(fov.viewAngle / 2, false);
Handles.DrawLine(fov.transform.position, fov.transform.position + (Vector3)viewAngleA * fov.viewRadius);
Handles.DrawLine(fov.transform.position, fov.transform.position + (Vector3)viewAngleB * fov.viewRadius);
Handles.color = Color.red;
foreach (Transform visibleTarget in fov.visibleTargets)
{
Handles.DrawLine(fov.transform.position, visibleTarget.position);
}
}
public virtual void OnSceneGUI()
{
if (!SceneEditor.ShowGizmos)
{
return;
}
Waypoint _waypoint = (Waypoint)target;
Handles.color = Color.yellow;
_waypoint.transform.position = Handles.FreeMoveHandle(_waypoint.transform.position,
Quaternion.identity,
0.4f,
Vector3.zero,
Handles.CylinderHandleCap);
Undo.RecordObject(_waypoint.transform, "Waypoint Position");
}
private void DrawPlane()
{
Handles.zTest = UnityEngine.Rendering.CompareFunction.LessEqual;
Vector3 tangent1 = PlaneTangent * planePreviewSize.x;
Vector3 tangent2 = Vector3.Cross(PlaneTangent, PlaneNormal) * planePreviewSize.y;
Handles.DrawSolidRectangleWithOutline
(
new Vector3[]
{
tangent1 + tangent2 + PlanePoint,
tangent1 - tangent2 + PlanePoint,
-tangent1 - tangent2 + PlanePoint,
-tangent1 + tangent2 + PlanePoint
},
planeColor,
planeColor
);
}
internal virtual void OnSceneGUI()
{
Tools.current = Tool.Custom;
Bezier t = target as Bezier;
EditorGUI.BeginChangeCheck();
t.StartPosition = Handles.PositionHandle(t.startPosition, Quaternion.identity);
t.EndPosition = Handles.PositionHandle(t.endPosition, Quaternion.identity);
t.startTangent = Handles.PositionHandle(t.startTangent, Quaternion.identity);
t.endTangent = Handles.PositionHandle(t.endTangent, Quaternion.identity);
if (EditorGUI.EndChangeCheck())
{
EditorUtility.SetDirty(t);
if (!t.startPosition.Equals(t.endPosition))
{
t.Points = Handles.MakeBezierPoints(t.startPosition, t.endPosition, t.startTangent, t.endTangent, Mathf.CeilToInt(Vector3.Distance(t.startPosition, t.endPosition)));
}
}
}
// Can be used to draw graphics in the scene view of our component
private void OnSceneGUI()
{
// target is an Object type inherited from Editor class
// that is the object we inspect in the scene and is being casted
// as a Line during runtime
Line line = target as Line;
// Handles operates in world space while points
// are in local space of line
// need to convert from local to world space
Transform handleTransform = line.transform;
Vector3 p0 = handleTransform.TransformPoint(line.p0);
Vector3 p1 = handleTransform.TransformPoint(line.p1);
// Rotation handle
Quaternion handleRotation = Tools.pivotRotation == PivotRotation.Local ?
handleTransform.rotation : Quaternion.identity;
Handles.color = Color.white;
Handles.DrawLine(p0, p1);
// Add rotation handles
// Update handle positions
EditorGUI.BeginChangeCheck();
p0 = Handles.DoPositionHandle(p0, handleRotation);
if (EditorGUI.EndChangeCheck())
{
// Enables Undo Operation in Unity Editor
Undo.RecordObject(line, "Move Point");
EditorUtility.SetDirty(line);
line.p0 = handleTransform.InverseTransformPoint(p0);
}
EditorGUI.BeginChangeCheck();
p1 = Handles.DoPositionHandle(p1, handleRotation);
if (EditorGUI.EndChangeCheck())
{
// Enables Undo Operation in Unity Editor
Undo.RecordObject(line, "Move Point");
EditorUtility.SetDirty(line);
line.p1 = handleTransform.InverseTransformPoint(p1);
}
}
static void DrawGizmoForMyScript(MapBehaviour mapBehaviour, GizmoType gizmoType)
{
if (!mapBehaviour.VisualizeSlots)
{
return;
}
if (mapBehaviour.Map == null)
{
return;
}
foreach (var slot in mapBehaviour.Map.GetAllSlots())
{
if (slot.Collapsed || slot.Modules.Count == Module.All.Length)
{
continue;
}
Handles.Label(mapBehaviour.GetWorldspacePosition(slot.Position), slot.Modules.Count.ToString());
}
}
void OnSceneGUI()
{
Light2D l = (Light2D)target;
EditorUtility.SetSelectedWireframeHidden(l.renderer, true);
Handles.color = Color.green;
float widgetSize = Vector3.Distance(l.transform.position, SceneView.lastActiveSceneView.camera.transform.position) * 0.05f;
float rad = (l.LightRadius / 2f);
Handles.DrawWireDisc(l.transform.position, l.transform.forward, rad);
l.LightRadius = Handles.ScaleValueHandle(l.LightRadius, l.transform.TransformPoint(Vector3.right * rad), Quaternion.identity, widgetSize, Handles.CubeCap, 1);
Handles.color = Color.red;
Vector3 sPos = l.transform.TransformDirection(Mathf.Cos(Mathf.Deg2Rad * l.SweepStart), Mathf.Sin(Mathf.Deg2Rad * l.SweepStart), 0);
Handles.DrawWireArc(l.transform.position, l.transform.forward, sPos, l.SweepSize, (rad * 0.8f));
l.SweepSize = Mathf.Clamp((int)Handles.ScaleValueHandle(l.SweepSize, l.transform.position + sPos * (rad * 0.8f), Quaternion.identity, widgetSize, Handles.SphereCap, 1), 0, 360);
}
public override void OnSceneGui()
{
float radius = PropertyValue;
var monoTransform = mono.transform;
bool relativeSpace = attribute.Space == Space.Self;
if (relativeSpace)
{
radius *= monoTransform.localScale.magnitude;
}
var pos = monoTransform.position;
Handles.color = attribute.Color;
Handles.DrawWireDisc(pos, relativeSpace ? monoTransform.forward : Vector3.forward, radius);
Handles.DrawWireDisc(pos, relativeSpace ? monoTransform.up : Vector3.up, radius);
Handles.DrawWireDisc(pos, relativeSpace ? monoTransform.right : Vector3.right, radius);
}
public override void OnPaintSceneGUI(GridLayout grid, GameObject brushTarget, BoundsInt position, GridBrushBase.Tool tool, bool executing)
{
base.OnPaintSceneGUI(grid, brushTarget, position, tool, executing);
if (lineBrush.lineStartActive)
{
Tilemap tilemap = brushTarget.GetComponent<Tilemap>();
if (tilemap != null)
lastTilemap = tilemap;
// Draw preview tiles for tilemap
Vector2Int startPos = new Vector2Int(lineBrush.lineStart.x, lineBrush.lineStart.y);
Vector2Int endPos = new Vector2Int(position.x, position.y);
if (startPos == endPos)
PaintPreview(grid, brushTarget, position.min);
else
{
foreach (var point in LineBrush.GetPointsOnLine(startPos, endPos, lineBrush.fillGaps))
{
Vector3Int paintPos = new Vector3Int(point.x, point.y, position.z);
PaintPreview(grid, brushTarget, paintPos);
}
}
if (Event.current.type == EventType.Repaint)
{
var min = lineBrush.lineStart;
var max = lineBrush.lineStart + position.size;
// Draws a box on the picked starting position
GL.PushMatrix();
GL.MultMatrix(GUI.matrix);
GL.Begin(GL.LINES);
Handles.color = Color.blue;
Handles.DrawLine(new Vector3(min.x, min.y, min.z), new Vector3(max.x, min.y, min.z));
Handles.DrawLine(new Vector3(max.x, min.y, min.z), new Vector3(max.x, max.y, min.z));
Handles.DrawLine(new Vector3(max.x, max.y, min.z), new Vector3(min.x, max.y, min.z));
Handles.DrawLine(new Vector3(min.x, max.y, min.z), new Vector3(min.x, min.y, min.z));
GL.End();
GL.PopMatrix();
}
}
}
static void Gizmos_CapturePoint(ReflectionProbe target)
{
if (sphere == null)
{
sphere = Resources.GetBuiltinResource <Mesh>("New-Sphere.fbx");
}
if (material == null)
{
material = new Material(Shader.Find("Debug/ReflectionProbePreview"));
}
var probe = target.GetComponent <HDAdditionalReflectionData>();
var probePositionSettings = ProbeCapturePositionSettings.ComputeFrom(probe, null);
HDRenderUtilities.ComputeCameraSettingsFromProbeSettings(
probe.settings, probePositionSettings, probe.texture,
out CameraSettings cameraSettings, out CameraPositionSettings cameraPositionSettings
);
var capturePosition = cameraPositionSettings.position;
material.SetTexture("_Cubemap", probe.texture);
material.SetPass(0);
Graphics.DrawMeshNow(sphere, Matrix4x4.TRS(capturePosition, Quaternion.identity, Vector3.one * capturePointPreviewSize));
var ray = new Ray(capturePosition, Vector3.down);
if (Physics.Raycast(ray, out RaycastHit hit))
{
var startPoint = capturePosition - Vector3.up * 0.5f * capturePointPreviewSize;
var c = InfluenceVolumeUI.k_GizmoThemeColorBase;
c.a = 0.8f;
Handles.color = c;
Handles.zTest = UnityEngine.Rendering.CompareFunction.LessEqual;
Handles.DrawLine(startPoint, hit.point);
Handles.DrawWireDisc(hit.point, hit.normal, 0.5f);
c.a = 0.25f;
Handles.color = c;
Handles.zTest = UnityEngine.Rendering.CompareFunction.Greater;
Handles.DrawLine(capturePosition, hit.point);
Handles.DrawWireDisc(hit.point, hit.normal, 0.5f);
}
}
void DrawVertexPathSceneEditor()
{
Color bezierCol = globalDisplaySettings.bezierPath;
bezierCol.a *= .5f;
if (data.showBezierPathInVertexMode)
{
for (int i = 0; i < bezierPath.NumSegments; i++)
{
Vector3[] points = bezierPath.GetPointsInSegment(i);
for (int j = 0; j < points.Length; j++)
{
points[j] = MathUtility.TransformPoint(points[j], creator.transform, bezierPath.Space);
}
Handles.DrawBezier(points[0], points[3], points[1], points[2], bezierCol, null, 2);
}
}
Handles.color = globalDisplaySettings.vertexPath;
for (int i = 0; i < creator.path.NumPoints; i++)
{
int nextIndex = (i + 1) % creator.path.NumPoints;
if (nextIndex != 0 || bezierPath.IsClosed)
{
Handles.DrawLine(creator.path.GetPoint(i), creator.path.GetPoint(nextIndex));
}
}
if (data.showNormalsInVertexMode)
{
Handles.color = globalDisplaySettings.normals;
Vector3[] normalLines = new Vector3[creator.path.NumPoints * 2];
for (int i = 0; i < creator.path.NumPoints; i++)
{
normalLines[i * 2] = creator.path.GetPoint(i);
normalLines[i * 2 + 1] = creator.path.GetPoint(i) + creator.path.localNormals[i] * globalDisplaySettings.normalsLength;
}
Handles.DrawLines(normalLines);
}
}
private static void OnSceneGUI(SceneView sceneView) {
if (cachedValidationErrors_ == null) {
return;
}
Handles.BeginGUI();
// BEGIN SCENE GUI
float yPosition = 0.0f;
foreach (IValidationError error in cachedValidationErrors_) {
var componentError = error as IComponentValidationError;
// NOTE (darren): it's possible that OnSceneGUI gets called after
// the prefab is destroyed - don't do anything in that case
if (componentError == null || componentError.Component == null) {
continue;
}
var linkRect = new Rect(kErrorWidth - kLinkWidth - kLinkPadding, yPosition + kLinkPadding, kLinkWidth, kErrorHeight - kLinkPadding);
if (GUI.Button(linkRect, "Link")) {
LinkValidationError(componentError);
}
var rect = new Rect(0.0f, yPosition, kErrorWidth, kErrorHeight);
var errorDescription = string.Format("{0}->{1}.{2}", componentError.Component.gameObject.name, error.ObjectType.Name, error.MemberInfo.Name);
if (GUI.Button(rect, errorDescription, kButtonStyle)) {
Selection.activeGameObject = componentError.Component.gameObject;
}
if (GUI.Button(linkRect, "Link")) {
// empty (no-action) button for the visual look
// NOTE (darren): it appears the order in which GUI.button is
// called determines the ordering for which button consumes the touch
// but also the order is used to render :)
}
yPosition += kErrorHeight + kErrorSpacingHeight;
}
// END SCENE GUI
Handles.EndGUI();
}
private void ShowTangentPoint(int index)
{
if (m_selectedIndex != index)
{
return;
}
Vector3 point = SelectSpline.GetLocationAtSplineInputKey(index, ESplineCoordinateSpace.World);
float size = HandleUtility.GetHandleSize(point);
Vector3 Location = SelectSpline.GetLocationAtSplinePoint(index, ESplineCoordinateSpace.World);
Vector3 LeaveTangent = SelectSpline.GetLeaveTangentAtSplinePoint(index, ESplineCoordinateSpace.World);
Vector3 ArriveTangent = SelectSpline.GetArriveTangentAtSplinePoint(index, ESplineCoordinateSpace.World);
DrawTangent(index, Location, ArriveTangent, -1, size);
DrawTangent(index, Location, LeaveTangent, 1, size);
//Arrive:-1,Leave:1
if (m_selectedTangentIndex == 1)
{
EditorGUI.BeginChangeCheck();
LeaveTangent = Handles.DoPositionHandle(Location + LeaveTangent, handleRotation);
if (EditorGUI.EndChangeCheck())
{
Undo.RecordObject(SelectSpline, "移动离开切线点");
EditorUtility.SetDirty(SelectSpline);
SelectSpline.SetTangentsAtSplinePoint(index, ArriveTangent, LeaveTangent - Location, ESplineCoordinateSpace.World);
}
}
//Arrive:-1,Leave:1
if (m_selectedTangentIndex == -1)
{
EditorGUI.BeginChangeCheck();
ArriveTangent = Handles.DoPositionHandle(Location - ArriveTangent, handleRotation);
if (EditorGUI.EndChangeCheck())
{
Undo.RecordObject(SelectSpline, "移动进入切线点");
EditorUtility.SetDirty(SelectSpline);
SelectSpline.SetTangentsAtSplinePoint(index, -1 * (ArriveTangent - Location), LeaveTangent, ESplineCoordinateSpace.World);
}
}
}
protected override void OnSceneGUI()
{
base.OnSceneGUI();
if (Event.current.type == EventType.Repaint)
{
if (m_LookAtAction.IsPlacedOnBrick())
{
var start = m_LookAtAction.GetBrickCenter();
var direction = m_LookAtAction.GetBrickRotation() * Vector3.right;
var end = start + direction * 3.2f;
Handles.color = Color.green;
Handles.DrawDottedLine(start, end, 5.0f);
var angleRange = m_SpeedProp.intValue * m_TimeProp.floatValue;
var rotate = (LookAtAction.Rotate)m_RotateProp.enumValueIndex;
switch (rotate)
{
case LookAtAction.Rotate.Horizontally:
{
DrawRange(start, direction, Vector3.up, angleRange, m_LookAtAction.GetHorizontalRotatedAngle());
break;
}
case LookAtAction.Rotate.Vertically:
{
var rotationAxis = Vector3.Cross(direction, Vector3.up);
DrawRange(start, direction, rotationAxis, angleRange, m_LookAtAction.GetVerticalRotatedAngle());
break;
}
case LookAtAction.Rotate.Freely:
{
DrawRange(start, direction, Vector3.up, angleRange, m_LookAtAction.GetHorizontalRotatedAngle());
var rotationAxis = Vector3.Cross(direction, Vector3.up);
DrawRange(start, direction, rotationAxis, angleRange, m_LookAtAction.GetVerticalRotatedAngle());
break;
}
}
}
}
}
void OnSceneGUI()
{
Undo.SetSnapshotTarget(_target, "distance tool undo");
//lables and handles:
float distance = Vector3.Distance(_target.startPoint, _target.endPoint);
float scalePerPixel = distance * _target.pixelPerUnit;
if (_target.scaleToPixels)
{
Handles.Label(_target.endPoint, " Distance from Start point: " + distance + " - Scale per pixel: " + scalePerPixel + "px", style);
}
else
{
Handles.Label(_target.endPoint, " Distance from Start point: " + distance, style);
}
//allow adjustment undo:
_target.startPoint = Handles.PositionHandle(_target.startPoint, Quaternion.identity);
_target.endPoint = Handles.PositionHandle(_target.endPoint, Quaternion.identity);
}
protected override void DrawHandles(SerializedPlanarReflectionProbe serialized, Editor owner)
{
base.DrawHandles(serialized, owner);
SceneViewOverlay_Window(EditorGUIUtility.TrTextContent(target.name), OnOverlayGUI, -100, target);
if (serialized.probeSettings.mode.intValue != (int)ProbeSettings.Mode.Realtime)
{
using (new Handles.DrawingScope(Matrix4x4.TRS(serialized.target.transform.position, serialized.target.transform.rotation, Vector3.one)))
{
var referencePosition = serialized.localReferencePosition.vector3Value;
EditorGUI.BeginChangeCheck();
referencePosition = Handles.PositionHandle(referencePosition, Quaternion.identity);
if (EditorGUI.EndChangeCheck())
{
serialized.localReferencePosition.vector3Value = referencePosition;
}
}
}
}
public void Draw()
{
Handles.DrawBezier(
m_InPoint.GetGlobalCenter(),
m_OutPoint.GetGlobalCenter(),
m_InPoint.GetGlobalCenter() + Vector2.left * 50f,
m_OutPoint.GetGlobalCenter() - Vector2.left * 50f,
Color.white,
null,
2f
);
if (Handles.Button((m_InPoint.GetGlobalCenter() + m_OutPoint.GetGlobalCenter()) * 0.5f, Quaternion.identity, 4, 8, Handles.RectangleHandleCap))
{
if (m_OnClickRemoveConnection != null)
{
m_OnClickRemoveConnection(this);
}
}
}
void OnSceneGUI()
{
var component = target as VRMFirstPerson;
var head = component.FirstPersonBone;
if (head == null)
{
return;
}
var worldOffset = head.localToWorldMatrix.MultiplyPoint(component.FirstPersonOffset);
worldOffset = Handles.PositionHandle(worldOffset, head.rotation);
Handles.Label(worldOffset, "FirstPersonOffset");
component.FirstPersonOffset = head.worldToLocalMatrix.MultiplyPoint(worldOffset);
}
private void DrawSelectionAxisReferenceLines(Transform transform)
{
Color originalColor = Handles.color;
Color lineColor = GridSettings.instance.axisReferenceStyle == ReferenceLineStyle.SingleColor ?
GridSettings.instance.axisReferenceColor : GetAxisColor(m_axis);
lineColor.a = 1f;
Handles.color = lineColor;
Vector3 gridPosition = m_gridData.WorldToGridPosition(transform.position);
Vector3 planePosition = Vector3.Scale(gridPosition, Vector3.one - AxisUtil.GetVector(m_axis));
if (!Mathf.Approximately(gridPosition.GetComponent(aAxis), 0f) &&
!Mathf.Approximately(gridPosition.GetComponent(bAxis), 0f))
{
Handles.DrawLine(gridPosition, planePosition);
}
Handles.color = originalColor;
}
public static void DrawString(string text, Vector3 worldPos, Color?colour = null)
{
#if UNITY_EDITOR
var defaultColor = GUI.color;
Handles.BeginGUI();
if (colour.HasValue)
{
GUI.color = colour.Value;
}
var view = SceneView.currentDrawingSceneView;
Vector3 screenPos = view.camera.WorldToScreenPoint(worldPos);
Vector2 size = GUI.skin.label.CalcSize(new GUIContent(text));
GUI.Label(new Rect(screenPos.x - (size.x / 2), -screenPos.y + view.position.height + 4, size.x, size.y), text);
Handles.EndGUI();
GUI.color = defaultColor;
#endif
}
private void DrawPrefabPalette(SokobanEditorSetup target)
{
Handles.BeginGUI();
GUILayout.BeginArea(new Rect(target.Position.x, target.Position.y, target.Width, target.Height), EditorStyles.helpBox);
if (GUILayout.Button("Загрузить список префабов"))
{
target.LoadResources();
}
GUILayout.TextArea("установить выбранный префаб ЛКМ, убрать префаб Shift+ЛКМ");
GUILayout.BeginHorizontal();
GUILayout.TextField("Выбор префаба: ");
target.Index = EditorGUILayout.Popup(target.Index, target.PrefabNames);
GUILayout.EndHorizontal();
GUILayout.EndArea();
Handles.EndGUI();
}
private void SetPositionHandle(int index, Quaternion handleRotation)
{
var point = _spline.GetPointTransformed(index, _self.transform);
if (EditorApplication.isPlaying)
{
point = _spline.GetPoint(index);
}
EditorGUI.BeginChangeCheck();
var p = Handles.PositionHandle(point, handleRotation);
if (EditorGUI.EndChangeCheck())
{
Undo.RecordObject(_self, "Move Point");
EditorSceneManager.MarkSceneDirty(SceneManager.GetActiveScene());
EditorUtility.SetDirty(_self);
_spline.SetTransformedPoint(index, p, _self.transform);
}
}
public MonoDebugSession()
: base(true)
{
_variableHandles = new Handles<ObjectValue[]>();
_frameHandles = new Handles<Mono.Debugging.Client.StackFrame>();
_seenThreads = new Dictionary<int, Thread>();
Configuration.Current.MaxConnectionAttempts = 10;
Configuration.Current.ConnectionAttemptInterval = 500;
// install an event handler in SDB
Debugger.Callback = (type, threadinfo, text) => {
int tid;
switch (type) {
case "TargetStopped":
Stopped();
SendEvent(CreateStoppedEvent("step", threadinfo));
break;
case "TargetHitBreakpoint":
Stopped();
SendEvent(CreateStoppedEvent("breakpoint", threadinfo));
break;
case "TargetExceptionThrown":
case "TargetUnhandledException":
Stopped();
ExceptionInfo ex = Debugger.ActiveException;
if (ex != null) {
_exception = ex.Instance;
}
SendEvent(CreateStoppedEvent("exception", threadinfo, Debugger.ActiveException.Message));
break;
case "TargetExited":
Terminate("target exited");
break;
case "TargetThreadStarted":
tid = (int)threadinfo.Id;
lock (_seenThreads) {
_seenThreads[tid] = new Thread(tid, threadinfo.Name);
}
SendEvent(new ThreadEvent("started", tid));
break;
case "TargetThreadStopped":
tid = (int)threadinfo.Id;
lock (_seenThreads) {
_seenThreads.Remove(tid);
}
SendEvent(new ThreadEvent("exited", tid));
break;
case "Output":
SendOutput("stdout", text);
break;
case "ErrorOutput":
SendOutput("stderr", text);
break;
default:
SendEvent(new Event(type));
break;
}
};
}
extern static IntPtr GetStdHandle (Handles handle);
public void when_a_ClaimDisbursedEvent_is_received()
{
var mongoServer = MongoServer.Create("mongodb://localhost/wf1_read_model?safe=true");
var mongoDb = mongoServer.GetDatabase("wf1_read_model", SafeMode.True);
_eventHandler = new ClaimDisbursedEventHandler(mongoDb);
}
internal static void drawRotationHandle(
Graphics g, Color rgb, Color rgbDis,
RectangleF rc, float rotationAngle,
Handles mask, bool showDsbl, float size)
{
bool draw = true;
System.Drawing.Pen pen = new System.Drawing.Pen(Color.Black, 0);
System.Drawing.Brush enbBrush = new System.Drawing.SolidBrush(rgb);
System.Drawing.Brush dsbBrush = new System.Drawing.SolidBrush(rgbDis);
System.Drawing.Brush brush;
// determine whether this handle should be drawn
if ((mask & Handles.Rotate) != 0)
{
brush = enbBrush;
}
else
{
brush = dsbBrush;
draw = false;
}
if (draw)
{
PointF center = getCenter(rc);
PointF[] rotPoints = new PointF[] {
new PointF(center.X, rc.Top - 6 * Constants.getMillimeter(g.PageUnit)),
new PointF(center.X, rc.Top) };
// apply rotation
if (rotationAngle != 0)
{
Matrix rotation = new Matrix();
rotation.RotateAt(rotationAngle, center);
rotation.TransformPoints(rotPoints);
rotation.Dispose();
}
PointF point = rotPoints[0];
g.FillEllipse(brush,
point.X - 2.8F*size/4, point.Y - 2.8F*size/4, 2.8F*size/2, 2.8F*size/2);
g.DrawEllipse(pen,
point.X - 2.8F*size/4, point.Y - 2.8F*size/4, 2.8F*size/2, 2.8F*size/2);
System.Drawing.Pen rotMarker =
new System.Drawing.Pen(brush, 0);
rotMarker.DashStyle = DashStyle.Dot;
g.DrawLine(rotMarker, point, rotPoints[1]);
rotMarker.Dispose();
}
pen.Dispose();
enbBrush.Dispose();
dsbBrush.Dispose();
}
static IntPtr GetStdHandle (Handles handle)
{
throw new System.NotImplementedException();
}
internal override void restoreProperties(ItemProperties props)
{
NodeProperties nprops = (NodeProperties)props;
anchorPattern = nprops.anchorPattern;
expanded = nprops.expanded;
expandable = nprops.expandable;
obstacle = nprops.obstacle;
Constraints = nprops.contraints == null ?
null : (NodeConstraints)nprops.contraints.Clone();
enabledHandles = nprops.enabledHandles;
boolValues = nprops.boolValues;
base.restoreProperties(props);
}
internal static void drawSquareHandles(Graphics g,
Handles mask, Color rgb, Color rgbDis, bool showDsbl,
RectangleF rc, float rotationAngle, HandlesStyle st, float size)
{
PointF center = getCenter(rc);
// select pen and brush for drawing the selection handles
System.Drawing.Pen pen = new System.Drawing.Pen(Color.Black, 0);
System.Drawing.Brush enbBrush = new System.Drawing.SolidBrush(rgb);
System.Drawing.Brush dsbBrush = new System.Drawing.SolidBrush(rgbDis);
System.Drawing.Brush brush;
// calculate selection handles coordinates
PointF[] handlePoints = new PointF[10];
handlePoints[0] = new PointF(rc.Left, rc.Top);
handlePoints[1] = new PointF(rc.Right, rc.Top);
handlePoints[2] = new PointF(rc.Right, rc.Bottom);
handlePoints[3] = new PointF(rc.Left, rc.Bottom);
handlePoints[4] = new PointF(center.X, rc.Top);
handlePoints[5] = new PointF(rc.Right, center.Y);
handlePoints[6] = new PointF(center.X, rc.Bottom);
handlePoints[7] = new PointF(rc.Left, center.Y);
handlePoints[8] = center;
handlePoints[9] = new PointF(
center.X, rc.Top - 6 * Constants.getMillimeter(g.PageUnit));
// apply rotation
if (rotationAngle != 0)
{
Matrix rotation = new Matrix();
rotation.RotateAt(rotationAngle, center);
rotation.TransformPoints(handlePoints);
rotation.Dispose();
}
// draw the handles
float hsize = size / 2;
for (int h = 0; h <= 9; h++)
{
bool draw = true;
// determine whether this handle should be drawn
if (((long)mask & (1 << h)) != 0)
{
brush = enbBrush;
}
else
{
brush = dsbBrush;
draw = showDsbl && h != 9;
}
if (draw)
{
PointF point = handlePoints[h];
// the side and corner handles
if (h < 8)
{
g.FillRectangle(brush,
point.X - hsize, point.Y - hsize, size, size);
g.DrawRectangle(pen,
point.X - hsize, point.Y - hsize, size, size);
}
// the center handle
else if (h == 8)
{
if (st == HandlesStyle.EasyMove)
{
//g.FillEllipse(brush,
// point.X - size, point.Y - size, 2*size, 2*size);
//g.DrawEllipse(pen,
// point.X - size, point.Y - size, 2*size, 2*size);
}
if (st == HandlesStyle.SquareHandles)
{
g.FillRectangle(brush,
point.X - hsize, point.Y - hsize, size, size);
g.DrawRectangle(pen,
point.X - hsize, point.Y - hsize, size, size);
}
}
// the rotation handle
else if (h == 9)
{
g.FillEllipse(brush,
point.X - 2.8F*size/4, point.Y - 2.8F*size/4, 2.8F*size/2, 2.8F*size/2);
g.DrawEllipse(pen,
point.X - 2.8F*size/4, point.Y - 2.8F*size/4, 2.8F*size/2, 2.8F*size/2);
System.Drawing.Pen rotMarker =
new System.Drawing.Pen(brush, 0);
rotMarker.DashStyle = DashStyle.Dot;
g.DrawLine(rotMarker, point, handlePoints[4]);
rotMarker.Dispose();
}
}
}
//cleanup
pen.Dispose();
enbBrush.Dispose();
dsbBrush.Dispose();
}
public SDBDebugSession(Action<DebugEvent> callback) : base(true)
{
_callback = callback;
_variableHandles = new Handles<ObjectValue[]>();
_frameHandles = new Handles<Mono.Debugging.Client.StackFrame>();
_seenThreads = new Dictionary<int, Thread>();
Configuration.Current.MaxConnectionAttempts = 10;
Configuration.Current.ConnectionAttemptInterval = 500;
Debugger.Callback = (type, sourceLocation, threadinfo, text) => {
int tid;
switch (type) {
case "TargetStopped":
Stopped();
callback.Invoke(CreateStoppedEvent("step", sourceLocation, threadinfo));
break;
case "TargetHitBreakpoint":
Stopped();
callback.Invoke(CreateStoppedEvent("breakpoint", sourceLocation, threadinfo));
break;
case "TargetExceptionThrown":
case "TargetUnhandledException":
Stopped();
ExceptionInfo ex = Debugger.ActiveException;
if (ex != null) {
_exception = ex.Instance;
}
callback.Invoke(CreateStoppedEvent("exception", sourceLocation, threadinfo, Debugger.ActiveException.Message));
break;
case "TargetExited":
Terminate("target exited");
break;
case "TargetThreadStarted":
tid = (int)threadinfo.Id;
lock (_seenThreads) {
_seenThreads[tid] = new Thread(tid, threadinfo.Name);
}
callback.Invoke(new ThreadEvent("started", tid));
break;
case "TargetThreadStopped":
tid = (int)threadinfo.Id;
lock (_seenThreads) {
_seenThreads.Remove(tid);
}
callback.Invoke(new ThreadEvent("exited", tid));
break;
case "Output":
SendOutput(OutputEvent.Category.stdout, text);
break;
case "ErrorOutput":
SendOutput(OutputEvent.Category.stderr, text);
break;
default:
callback.Invoke(new DebugEvent(type));
break;
}
};
// the Soft Debugger is ready to accept breakpoints immediately (so it doesn't have to wait until the target is known)
callback.Invoke(new InitializedEvent());
}
internal static bool pointInHandle(PointF pt, ref int handle,
RectangleF rc, float rotationAngle, Handles mask,
float ht, HandlesStyle st, float handleSize, GraphicsUnit measureUnit)
{
if (rotationAngle != 0)
pt = rotatePointAt(pt, getCenter(rc), -rotationAngle);
if (st == HandlesStyle.MoveOnly || st == HandlesStyle.InvisibleMove)
{
handle = 8;
return rc.Contains(pt) && (mask & Handles.Move) != 0;
}
if (st == HandlesStyle.SquareHandles || st == HandlesStyle.HatchHandles ||
st == HandlesStyle.EasyMove)
{
PointF[] pts = new PointF[10];
//the corner points
pts[0].X = rc.X;
pts[0].Y = rc.Y;
pts[1].X = rc.Right;
pts[1].Y = rc.Y;
pts[2].X = rc.Right;
pts[2].Y = rc.Bottom;
pts[3].X = rc.X;
pts[3].Y = rc.Bottom;
//the side points
pts[4].X = (pts[0].X + pts[1].X) / 2;
pts[4].Y = pts[0].Y;
pts[5].X = pts[1].X;
pts[5].Y = (pts[1].Y + pts[2].Y) / 2;
pts[6].X = pts[4].X;
pts[6].Y = pts[2].Y;
pts[7].X = pts[0].X;
pts[7].Y = pts[5].Y;
//the center point
pts[8].X = pts[4].X;
pts[8].Y = pts[5].Y;
// the rotation handle
pts[9].X = pts[4].X;
pts[9].Y = pts[4].Y - 6*Constants.getMillimeter(measureUnit);
//if (st == HandlesStyle.EasyMove && (Distance(pts[8], pt) < 1.5 * handleSize))
// return false;
for (int i = 0; i < 10; ++i)
{
if (Math.Abs(pts[i].X - pt.X) <= (handleSize/2) &&
Math.Abs(pts[i].Y - pt.Y) <= (handleSize/2) &&
((long)mask & (1 << i)) != 0)
{
handle = i;
return true;
}
}
if (st == HandlesStyle.EasyMove && rc.Contains(pt) && (mask & Handles.Move) != 0)
{
handle = 8;
return true;
}
rc.Inflate(handleSize / 2, handleSize / 2);
if (st == HandlesStyle.HatchHandles && rc.Contains(pt) &&
(mask & Handles.Move) != 0)
{
rc.Inflate(- handleSize, - handleSize);
handle = 8;
return !rc.Contains(pt);
}
}
else
{
// check the corners
PointF[] ptCorner = new PointF[4];
ptCorner[0].X = rc.Left;
ptCorner[0].Y = rc.Top;
ptCorner[1].X = rc.Right;
ptCorner[1].Y = rc.Top;
ptCorner[2].X = rc.Right;
ptCorner[2].Y = rc.Bottom;
ptCorner[3].X = rc.Left;
ptCorner[3].Y = rc.Bottom;
for (int i = 0; i < 4; ++i)
{
if (Math.Abs(ptCorner[i].X - pt.X) <= (handleSize/2) &&
Math.Abs(ptCorner[i].Y - pt.Y) <= (handleSize/2) &&
((long)mask & (1 << i)) != 0)
{
handle = i;
return true;
}
}
//the side points
rc.Inflate(Constants.getSelPtTest(measureUnit)*2, Constants.getSelPtTest(measureUnit)*2);
if (Utilities.pointInRect(pt, rc))
{
float inflate = -Constants.getSelPtTest(measureUnit)*2;
rc.Inflate(inflate, inflate);
if (Math.Abs(rc.Top - pt.Y) <= (handleSize/2) &&
(mask & Handles.ResizeTopCenter) != 0)
{
handle = 4;
return true;
}
if (Math.Abs(rc.Right - pt.X) <= (handleSize/2) &&
(mask & Handles.ResizeMiddleRight) != 0)
{
handle = 5;
return true;
}
if (Math.Abs(rc.Bottom - pt.Y) <= (handleSize/2) &&
(mask & Handles.ResizeBottomCenter) != 0)
{
handle = 6;
return true;
}
if (Math.Abs(rc.Left - pt.X) <= (handleSize/2) &&
(mask & Handles.ResizeMiddleLeft) != 0)
{
handle = 7;
return true;
}
}
// the rotation handle
PointF rotHandle = new PointF(
(ptCorner[0].X + ptCorner[1].X) / 2,
ptCorner[0].Y - 6*Constants.getMillimeter(measureUnit));
if (Math.Abs(rotHandle.X - pt.X) <= (handleSize/2) &&
Math.Abs(rotHandle.Y - pt.Y) <= (handleSize/2) &&
(mask & Handles.Rotate) != 0)
{
handle = 9;
return true;
}
// check if the point is in the title area
RectangleF rcCpt = rc;
if (ht != 0)
rcCpt.Height = ht;
else
rcCpt.Inflate(- handleSize * 2, - handleSize * 2);
if (Utilities.pointInRect(pt, rcCpt) && (mask & Handles.Move) != 0)
{
handle = 8;
return true;
}
}
return false;
}
internal static void drawSelHandles(
Graphics g, Color rgb, Color rgbDis,
RectangleF rc, float rotationAngle,
Handles mask, bool showDsbl, HandlesStyle st, float size)
{
// these styles must not be painted
if (st == HandlesStyle.Invisible ||
st == HandlesStyle.InvisibleMove)
return;
// draw square selection handles for these styles
if (st == HandlesStyle.SquareHandles ||
st == HandlesStyle.SquareHandles2 ||
st == HandlesStyle.EasyMove)
{
drawSquareHandles(g, mask, rgb, rgbDis, showDsbl,
rc, rotationAngle, st, size);
return;
}
PointF center = getCenter(rc);
if (st == HandlesStyle.DashFrame)
{
try
{
// drawing with a dashed pen sometimes throws a generic exception
// in GDIPLUS.DLL, so catch everything or everyone will blame us;
System.Drawing.Pen pen = new System.Drawing.Pen(rgb, 0);
pen.DashStyle = DashStyle.Dash;
if (rotationAngle == 0)
{
g.DrawRectangle(pen, rc.X, rc.Y, rc.Width, rc.Height);
}
else
{
GraphicsPath path = rotateRectAt(rc, center, rotationAngle);
g.DrawPath(pen, path);
path.Dispose();
}
pen.Dispose();
drawRotationHandle(g, rgb, rgbDis,
rc, rotationAngle, mask, showDsbl, size);
}
catch (Exception)
{
// sometimes the exception says 'out of memory'
GC.Collect();
}
return;
}
if (st == HandlesStyle.HatchFrame)
{
rc.Inflate(size / 2, size / 2);
System.Drawing.Drawing2D.HatchBrush hatchBrush =
new System.Drawing.Drawing2D.HatchBrush(
HatchStyle.BackwardDiagonal, Color.Black, Color.White);
RectangleF[] rects = new RectangleF[] {
new RectangleF(rc.Left + size, rc.Top, rc.Width - 2 * size, size),
new RectangleF(rc.Left + size, rc.Bottom - size, rc.Width - 2 * size, size),
new RectangleF(rc.Left, rc.Top, size, rc.Height),
new RectangleF(rc.Right - size, rc.Top, size, rc.Height) };
if (rotationAngle == 0)
{
for (int i = 0; i < 4; ++i)
g.FillRectangle(hatchBrush, rects[i]);
}
else
{
for (int i = 0; i < 4; ++i)
{
GraphicsPath path = rotateRectAt(
rects[i], center, rotationAngle);
g.FillPath(hatchBrush, path);
path.Dispose();
}
}
hatchBrush.Dispose();
drawRotationHandle(g, rgb, rgbDis,
rc, rotationAngle, mask, showDsbl, size);
return;
}
if (st == HandlesStyle.HatchHandles || st == HandlesStyle.HatchHandles2 ||
st == HandlesStyle.HatchHandles3 || st == HandlesStyle.MoveOnly)
{
RectangleF rch = rc;
rch.Inflate(size / 4, size / 4);
System.Drawing.Drawing2D.HatchBrush hatchBrush = null;
if (st == HandlesStyle.HatchHandles3 || st == HandlesStyle.MoveOnly)
hatchBrush = new System.Drawing.Drawing2D.HatchBrush(
HatchStyle.Percent50, Color.Black, Color.FromArgb(50, Color.Black));
else
hatchBrush = new System.Drawing.Drawing2D.HatchBrush(
HatchStyle.BackwardDiagonal, Color.Black, Color.White);
RectangleF[] rects = new RectangleF[] {
new RectangleF(rch.Left + size*2/4, rch.Top, rch.Width - size, size*2/4),
new RectangleF(rch.Left + size*2/4, rch.Bottom - size*2/4, rch.Width - size, size*2/4),
new RectangleF(rch.Left, rch.Top, size*2/4, rch.Height),
new RectangleF(rch.Right - size*2/4, rch.Top, size*2/4, rch.Height) };
if (rotationAngle == 0)
{
for (int i = 0; i < 4; ++i)
g.FillRectangle(hatchBrush, rects[i]);
}
else
{
for (int i = 0; i < 4; ++i)
{
GraphicsPath path = rotateRectAt(
rects[i], center, rotationAngle);
g.FillPath(hatchBrush, path);
path.Dispose();
}
}
hatchBrush.Dispose();
if (st == HandlesStyle.MoveOnly)
return;
drawSquareHandles(g, mask, rgb, rgbDis, showDsbl,
rc, rotationAngle, st, size);
return;
}
}
