public static BrushMesh CreateBox(Vector3 size, ChiselBrushMaterial brushMaterial)
{
var chiselSurface = new ChiselSurface();
chiselSurface.brushMaterial = brushMaterial;
return(BrushMeshFactory.CreateBox(Vector3.one, in chiselSurface));
}
public static bool GenerateBoxAsset(CSGBrushMeshAsset brushMeshAsset, UnityEngine.Vector3 min, UnityEngine.Vector3 max, CSGSurfaceAsset[] surfaceAssets, SurfaceFlags surfaceFlags = SurfaceFlags.None)
{
if (!BoundsExtensions.IsValid(min, max))
{
brushMeshAsset.Clear();
return(false);
}
if (surfaceAssets.Length != 6)
{
brushMeshAsset.Clear();
return(false);
}
if (min.x > max.x)
{
float x = min.x; min.x = max.x; max.x = x;
}
if (min.y > max.y)
{
float y = min.y; min.y = max.y; max.y = y;
}
if (min.z > max.z)
{
float z = min.z; min.z = max.z; max.z = z;
}
brushMeshAsset.Polygons = CreateBoxAssetPolygons(surfaceAssets, surfaceFlags);
brushMeshAsset.HalfEdges = boxHalfEdges.ToArray();
brushMeshAsset.Vertices = BrushMeshFactory.CreateBoxVertices(min, max);
brushMeshAsset.CalculatePlanes();
brushMeshAsset.SetDirty();
return(true);
}
public static bool GenerateSphereSubMesh(CSGBrushSubMesh subMesh, Vector3 diameterXYZ, float offsetY, bool generateFromCenter, Matrix4x4 transform, int horzSegments, int vertSegments, CSGSurfaceAsset[] surfaceAssets, SurfaceDescription[] surfaceDescriptions)
{
if (diameterXYZ.x == 0 ||
diameterXYZ.y == 0 ||
diameterXYZ.z == 0)
{
subMesh.Clear();
return(false);
}
var brushMesh = BrushMeshFactory.CreateSphere(diameterXYZ, offsetY, generateFromCenter, horzSegments, vertSegments);
subMesh.HalfEdges = brushMesh.halfEdges;
subMesh.Vertices = brushMesh.vertices;
subMesh.Polygons = new CSGBrushSubMesh.Polygon[brushMesh.polygons.Length];
for (int i = 0; i < brushMesh.polygons.Length; i++)
{
subMesh.Polygons[i] = new CSGBrushSubMesh.Polygon
{
surfaceID = i,
edgeCount = brushMesh.polygons[i].edgeCount,
firstEdge = brushMesh.polygons[i].firstEdge,
surfaceAsset = i < surfaceAssets.Length ? surfaceAssets[i] : surfaceAssets[0],
description = i < surfaceDescriptions.Length ? surfaceDescriptions[i] : surfaceDescriptions[0],
};
}
return(true);
}
public static void CreateBox(Vector3 size, ChiselBrushMaterial brushMaterial, out BrushMesh box)
{
var chiselSurface = new ChiselSurface();
chiselSurface.brushMaterial = brushMaterial;
BrushMeshFactory.CreateBox(Vector3.one, in chiselSurface, out box);
}
public static bool GenerateBoxSubMesh(CSGBrushSubMesh subMesh, UnityEngine.Vector3 min, UnityEngine.Vector3 max, CSGSurfaceAsset[] surfaceAssets, SurfaceDescription[] surfaceDescriptions)
{
if (!BoundsExtensions.IsValid(min, max))
{
return(false);
}
if (surfaceAssets.Length != 6 ||
surfaceDescriptions.Length != 6)
{
return(false);
}
if (min.x > max.x)
{
float x = min.x; min.x = max.x; max.x = x;
}
if (min.y > max.y)
{
float y = min.y; min.y = max.y; max.y = y;
}
if (min.z > max.z)
{
float z = min.z; min.z = max.z; max.z = z;
}
subMesh.Polygons = CreateBoxAssetPolygons(surfaceAssets, surfaceDescriptions);
subMesh.HalfEdges = boxHalfEdges.ToArray();
subMesh.Vertices = BrushMeshFactory.CreateBoxVertices(min, max);
return(true);
}
public static bool GenerateSphereVertices(CSGSphereDefinition definition, ref Vector3[] vertices)
{
definition.Validate();
var transform = Matrix4x4.TRS(Vector3.zero, Quaternion.AngleAxis(definition.rotation, Vector3.up), Vector3.one);
BrushMeshFactory.CreateSphereVertices(definition.diameterXYZ, definition.offsetY, definition.generateFromCenter, definition.horizontalSegments, definition.verticalSegments, ref vertices);
return(true);
}
static Vector3[] vertices = null; // TODO: store this per instance? or just allocate every frame?
protected override void OnScene(SceneView sceneView, ChiselHemisphere generator)
{
var baseColor = UnityEditor.Handles.yAxisColor;
var isDisabled = UnitySceneExtensions.SceneHandles.disabled;
var focusControl = UnitySceneExtensions.SceneHandleUtility.focusControl;
var normal = Vector3.up;
if (!BrushMeshFactory.GenerateHemisphereVertices(ref generator.definition, ref vertices))
{
return;
}
UnityEditor.Handles.color = ChiselCylinderEditor.GetColorForState(baseColor, false, false, isDisabled);
DrawOutline(generator.definition, vertices, lineMode: LineMode.ZTest);
UnityEditor.Handles.color = ChiselCylinderEditor.GetColorForState(baseColor, false, true, isDisabled);
DrawOutline(generator.definition, vertices, lineMode: LineMode.NoZTest);
var topPoint = normal * generator.DiameterXYZ.y;
var radius2D = new Vector2(generator.definition.diameterXYZ.x, generator.definition.diameterXYZ.z) * 0.5f;
if (generator.DiameterXYZ.y < 0)
{
normal = -normal;
}
EditorGUI.BeginChangeCheck();
{
UnityEditor.Handles.color = baseColor;
// TODO: make it possible to (optionally) size differently in x & z
radius2D.x = UnitySceneExtensions.SceneHandles.RadiusHandle(normal, Vector3.zero, radius2D.x);
var topId = GUIUtility.GetControlID(s_TopHash, FocusType.Passive);
{
var isTopBackfaced = false; // TODO: how to do this?
var topHasFocus = (focusControl == topId);
UnityEditor.Handles.color = ChiselCylinderEditor.GetColorForState(baseColor, topHasFocus, isTopBackfaced, isDisabled);
topPoint = UnitySceneExtensions.SceneHandles.DirectionHandle(topId, topPoint, normal);
}
}
if (EditorGUI.EndChangeCheck())
{
Undo.RecordObject(target, "Modified " + generator.NodeTypeName);
var diameter = generator.DiameterXYZ;
diameter.y = topPoint.y;
diameter.x = radius2D.x * 2.0f;
diameter.z = radius2D.x * 2.0f;
generator.DiameterXYZ = diameter;
}
}
public IEnumerator CreateBrushContainerAsset_IsPartOfManager()
{
var chiselSurface = new ChiselSurface();
var box = BrushMeshFactory.CreateBox(Vector3.one, in chiselSurface);
yield return(null);
var instance = BrushMeshInstance.Create(box);
Assert.IsTrue(instance.Valid);
instance.Destroy();
}
public void Init()
{
CompactHierarchyManager.Clear();
BrushMeshFactory.CreateBox(Vector3.one, 0, out var brushMesh);
var surfaceDefinition = new ChiselSurfaceDefinition();
surfaceDefinition.EnsureSize(6);
var brushMeshHash = BrushMeshManager.RegisterBrushMesh(brushMesh, surfaceDefinition);
dummyBrushMeshInstance = new BrushMeshInstance {
brushMeshHash = brushMeshHash
};
}
public IEnumerator CreateBrushContainerAsset_IsPartOfManager()
{
var surfaceDefinition = new ChiselSurfaceDefinition();
surfaceDefinition.EnsureSize(6);
BrushMeshFactory.CreateBox(Vector3.one, 0, out BrushMesh box);
yield return(null);
var instance = BrushMeshInstance.Create(box, in surfaceDefinition);
Assert.IsTrue(instance.Valid);
instance.Destroy();
}
public IEnumerator CreateBrushMeshAsset_IsPartOfManager()
{
var layers = new SurfaceLayers
{
layerUsage = LayerUsageFlags.None
};
var box = BrushMeshFactory.CreateBox(Vector3.one, layers, SurfaceFlags.None);
yield return(null);
var instance = BrushMeshInstance.Create(box);
Assert.IsTrue(instance.Valid);
instance.Destroy();
}
public static bool GenerateBoxAsset(CSGBrushMeshAsset brushMeshAsset, UnityEngine.Vector3 min, UnityEngine.Vector3 max, CSGSurfaceAsset[] surfaceAssets, SurfaceDescription[] surfaceDescriptions)
{
if (!BoundsExtensions.IsValid(min, max))
{
brushMeshAsset.Clear();
Debug.LogError("bounds is of an invalid size " + (max - min));
return(false);
}
if (surfaceDescriptions == null || surfaceDescriptions.Length != 6)
{
brushMeshAsset.Clear();
Debug.LogError("surfaceDescriptions needs to be an array of length 6");
return(false);
}
if (surfaceAssets == null || surfaceAssets.Length != 6)
{
brushMeshAsset.Clear();
Debug.LogError("surfaceAssets needs to be an array of length 6");
return(false);
}
if (min.x > max.x)
{
float x = min.x; min.x = max.x; max.x = x;
}
if (min.y > max.y)
{
float y = min.y; min.y = max.y; max.y = y;
}
if (min.z > max.z)
{
float z = min.z; min.z = max.z; max.z = z;
}
brushMeshAsset.Polygons = CreateBoxAssetPolygons(surfaceAssets, surfaceDescriptions);
brushMeshAsset.HalfEdges = boxHalfEdges.ToArray();
brushMeshAsset.Vertices = BrushMeshFactory.CreateBoxVertices(min, max);
brushMeshAsset.CalculatePlanes();
brushMeshAsset.SetDirty();
return(true);
}
protected override void OnScene(SceneView sceneView, ChiselTorus generator)
{
var baseColor = UnityEditor.Handles.yAxisColor;
var isDisabled = UnitySceneExtensions.SceneHandles.disabled;
var focusControl = UnitySceneExtensions.SceneHandleUtility.focusControl;
var normal = Vector3.up;
Vector3[] vertices = null;
if (!BrushMeshFactory.GenerateTorusVertices(generator.definition, ref vertices))
{
return;
}
UnityEditor.Handles.color = ChiselCylinderEditor.GetColorForState(baseColor, false, false, isDisabled);
DrawOutline(generator.definition, vertices, lineMode: LineMode.ZTest);
UnityEditor.Handles.color = ChiselCylinderEditor.GetColorForState(baseColor, false, true, isDisabled);
DrawOutline(generator.definition, vertices, lineMode: LineMode.NoZTest);
var outerRadius = generator.definition.outerDiameter * 0.5f;
var innerRadius = generator.definition.innerDiameter * 0.5f;
var topPoint = normal * (generator.definition.tubeHeight * 0.5f);
var bottomPoint = normal * (-generator.definition.tubeHeight * 0.5f);
EditorGUI.BeginChangeCheck();
{
UnityEditor.Handles.color = baseColor;
outerRadius = UnitySceneExtensions.SceneHandles.RadiusHandle(normal, Vector3.zero, outerRadius);
innerRadius = UnitySceneExtensions.SceneHandles.RadiusHandle(normal, Vector3.zero, innerRadius);
bottomPoint = UnitySceneExtensions.SceneHandles.DirectionHandle(bottomPoint, -normal);
topPoint = UnitySceneExtensions.SceneHandles.DirectionHandle(topPoint, normal);
}
if (EditorGUI.EndChangeCheck())
{
Undo.RecordObject(target, "Modified " + generator.NodeTypeName);
generator.definition.outerDiameter = outerRadius * 2.0f;
generator.definition.innerDiameter = innerRadius * 2.0f;
generator.definition.tubeHeight = (topPoint.y - bottomPoint.y);
// TODO: handle sizing down
generator.OnValidate();
}
}
protected override void OnScene(ChiselStadium generator)
{
var baseColor = UnityEditor.Handles.yAxisColor;
var isDisabled = UnitySceneExtensions.SceneHandles.disabled;
var focusControl = UnitySceneExtensions.SceneHandleUtility.focusControl;
var upVector = Vector3.up;
var rightVector = Vector3.right;
var forwardVector = Vector3.forward;
Vector3[] vertices = null;
if (!BrushMeshFactory.GenerateStadiumVertices(generator.definition, ref vertices))
{
return;
}
UnityEditor.Handles.color = ChiselCylinderEditor.GetColorForState(baseColor, false, false, isDisabled);
DrawOutline(generator.definition, vertices, lineMode: LineMode.ZTest);
UnityEditor.Handles.color = ChiselCylinderEditor.GetColorForState(baseColor, false, true, isDisabled);
DrawOutline(generator.definition, vertices, lineMode: LineMode.NoZTest);
var height = generator.definition.height;
var length = generator.definition.length;
var diameter = generator.definition.diameter;
var sides = generator.definition.sides;
var firstTopSide = generator.definition.firstTopSide;
var lastTopSide = generator.definition.lastTopSide;
var firstBottomSide = generator.definition.firstBottomSide;
var lastBottomSide = generator.definition.lastBottomSide;
var haveRoundedTop = generator.definition.haveRoundedTop;
var haveRoundedBottom = generator.definition.haveRoundedBottom;
var haveCenter = generator.definition.haveCenter;
var topLength = generator.definition.topLength;
var bottomLength = generator.definition.bottomLength;
var midY = height * 0.5f;
var halfLength = length * 0.5f;
var midZ = ((halfLength - (haveRoundedTop ? topLength : 0)) - (halfLength - (haveRoundedBottom ? bottomLength : 0))) * -0.5f;
// haveCenter ? ((vertices[firstTopSide].z + vertices[firstBottomSide].z) * 0.5f) : 0;
var topPoint = new Vector3(0, height, midZ);
var bottomPoint = new Vector3(0, 0, midZ);
var frontPoint = new Vector3(0, midY, halfLength);
var backPoint = new Vector3(0, midY, -halfLength);
var leftPoint = new Vector3(diameter * 0.5f, midY, midZ);
var rightPoint = new Vector3(diameter * -0.5f, midY, midZ);
EditorGUI.BeginChangeCheck();
{
var topId = GUIUtility.GetControlID(s_TopHash, FocusType.Passive);
{
var isTopBackfaced = ChiselCylinderEditor.IsSufaceBackFaced(topPoint, upVector);
var topHasFocus = (focusControl == topId);
UnityEditor.Handles.color = ChiselCylinderEditor.GetColorForState(baseColor, topHasFocus, isTopBackfaced, isDisabled);
topPoint = UnitySceneExtensions.SceneHandles.DirectionHandle(topId, topPoint, upVector);
//if (generator.definition.haveRoundedTop)
{
var thickness = topHasFocus ? kCapLineThicknessSelected : kCapLineThickness;
UnityEditor.Handles.color = ChiselCylinderEditor.GetColorForState(baseColor, topHasFocus, true, isDisabled);
ChiselOutlineRenderer.DrawLineLoop(vertices, sides, sides, lineMode: LineMode.NoZTest, thickness: thickness);
if (haveRoundedTop)
{
ChiselOutlineRenderer.DrawLine(vertices[sides + firstTopSide], vertices[sides + lastTopSide], lineMode: LineMode.NoZTest, thickness: kVertLineThickness);
}
if (haveRoundedBottom && haveCenter)
{
ChiselOutlineRenderer.DrawLine(vertices[sides + firstBottomSide], vertices[sides + lastBottomSide], lineMode: LineMode.NoZTest, thickness: kVertLineThickness);
}
UnityEditor.Handles.color = ChiselCylinderEditor.GetColorForState(baseColor, topHasFocus, false, isDisabled);
ChiselOutlineRenderer.DrawLineLoop(vertices, sides, sides, lineMode: LineMode.ZTest, thickness: thickness);
if (haveRoundedTop)
{
ChiselOutlineRenderer.DrawLine(vertices[sides + firstTopSide], vertices[sides + lastTopSide], lineMode: LineMode.ZTest, thickness: kVertLineThickness);
}
if (haveRoundedBottom && haveCenter)
{
ChiselOutlineRenderer.DrawLine(vertices[sides + firstBottomSide], vertices[sides + lastBottomSide], lineMode: LineMode.ZTest, thickness: kVertLineThickness);
}
}
}
var bottomId = GUIUtility.GetControlID(s_BottomHash, FocusType.Passive);
{
var isBottomBackfaced = ChiselCylinderEditor.IsSufaceBackFaced(bottomPoint, -upVector);
var bottomHasFocus = (focusControl == bottomId);
UnityEditor.Handles.color = ChiselCylinderEditor.GetColorForState(baseColor, bottomHasFocus, isBottomBackfaced, isDisabled);
bottomPoint = UnitySceneExtensions.SceneHandles.DirectionHandle(bottomId, bottomPoint, -upVector);
//if (haveRoundedBottom)
{
var thickness = bottomHasFocus ? kCapLineThicknessSelected : kCapLineThickness;
UnityEditor.Handles.color = ChiselCylinderEditor.GetColorForState(baseColor, bottomHasFocus, true, isDisabled);
ChiselOutlineRenderer.DrawLineLoop(vertices, 0, sides, lineMode: LineMode.NoZTest, thickness: thickness);
if (haveRoundedTop)
{
ChiselOutlineRenderer.DrawLine(vertices[firstTopSide], vertices[lastTopSide], lineMode: LineMode.NoZTest, thickness: kVertLineThickness);
}
if (haveRoundedBottom && haveCenter)
{
ChiselOutlineRenderer.DrawLine(vertices[firstBottomSide], vertices[lastBottomSide], lineMode: LineMode.NoZTest, thickness: kVertLineThickness);
}
UnityEditor.Handles.color = ChiselCylinderEditor.GetColorForState(baseColor, bottomHasFocus, false, isDisabled);
ChiselOutlineRenderer.DrawLineLoop(vertices, 0, sides, lineMode: LineMode.ZTest, thickness: thickness);
if (haveRoundedTop)
{
ChiselOutlineRenderer.DrawLine(vertices[firstTopSide], vertices[lastTopSide], lineMode: LineMode.ZTest, thickness: kVertLineThickness);
}
if (haveRoundedBottom && haveCenter)
{
ChiselOutlineRenderer.DrawLine(vertices[firstBottomSide], vertices[lastBottomSide], lineMode: LineMode.ZTest, thickness: kVertLineThickness);
}
}
}
var frontId = GUIUtility.GetControlID(s_TopHash, FocusType.Passive);
{
var isTopBackfaced = ChiselCylinderEditor.IsSufaceBackFaced(frontPoint, forwardVector);
var frontHasFocus = (focusControl == frontId);
UnityEditor.Handles.color = ChiselCylinderEditor.GetColorForState(baseColor, frontHasFocus, isTopBackfaced, isDisabled);
frontPoint = UnitySceneExtensions.SceneHandles.DirectionHandle(frontId, frontPoint, forwardVector);
}
var backId = GUIUtility.GetControlID(s_BottomHash, FocusType.Passive);
{
var isBottomBackfaced = ChiselCylinderEditor.IsSufaceBackFaced(backPoint, -forwardVector);
var backHasFocus = (focusControl == backId);
UnityEditor.Handles.color = ChiselCylinderEditor.GetColorForState(baseColor, backHasFocus, isBottomBackfaced, isDisabled);
backPoint = UnitySceneExtensions.SceneHandles.DirectionHandle(backId, backPoint, -forwardVector);
}
var leftId = GUIUtility.GetControlID(s_TopHash, FocusType.Passive);
{
var isTopBackfaced = ChiselCylinderEditor.IsSufaceBackFaced(leftPoint, rightVector);
var leftHasFocus = (focusControl == leftId);
UnityEditor.Handles.color = ChiselCylinderEditor.GetColorForState(baseColor, leftHasFocus, isTopBackfaced, isDisabled);
leftPoint = UnitySceneExtensions.SceneHandles.DirectionHandle(leftId, leftPoint, rightVector);
}
var rightId = GUIUtility.GetControlID(s_BottomHash, FocusType.Passive);
{
var isBottomBackfaced = ChiselCylinderEditor.IsSufaceBackFaced(rightPoint, -rightVector);
var rightHasFocus = (focusControl == rightId);
UnityEditor.Handles.color = ChiselCylinderEditor.GetColorForState(baseColor, rightHasFocus, isBottomBackfaced, isDisabled);
rightPoint = UnitySceneExtensions.SceneHandles.DirectionHandle(rightId, rightPoint, -rightVector);
}
}
if (EditorGUI.EndChangeCheck())
{
Undo.RecordObject(target, "Modified " + generator.NodeTypeName);
generator.definition.height = topPoint.y - bottomPoint.y;
generator.definition.length = Mathf.Max(0, frontPoint.z - backPoint.z);
generator.definition.diameter = leftPoint.x - rightPoint.x;
generator.OnValidate();
// TODO: handle sizing in some directions (needs to modify transformation?)
}
}
static Vector3[] vertices = null; // TODO: store this per instance? or just allocate every frame?
protected override void OnScene(ChiselCapsule generator)
{
var baseColor = UnityEditor.Handles.yAxisColor;
var isDisabled = UnitySceneExtensions.SceneHandles.disabled;
var focusControl = UnitySceneExtensions.SceneHandleUtility.focusControl;
var normal = Vector3.up;
if (!BrushMeshFactory.GenerateCapsuleVertices(ref generator.definition, ref vertices))
{
return;
}
UnityEditor.Handles.color = ChiselCylinderEditor.GetColorForState(baseColor, false, false, isDisabled);
DrawOutline(generator.definition, vertices, lineMode: LineMode.ZTest);
UnityEditor.Handles.color = ChiselCylinderEditor.GetColorForState(baseColor, false, true, isDisabled);
DrawOutline(generator.definition, vertices, lineMode: LineMode.NoZTest);
var topLoopID = GUIUtility.GetControlID(s_TopLoopHash, FocusType.Keyboard);
var bottomLoopID = GUIUtility.GetControlID(s_BottomLoopHash, FocusType.Keyboard);
var topPoint = normal * (generator.definition.offsetY + generator.Height);
var bottomPoint = normal * (generator.definition.offsetY);
var middlePoint = normal * (generator.definition.offsetY + (generator.Height * 0.5f));
var radius2D = new Vector2(generator.definition.diameterX, generator.definition.diameterZ) * 0.5f;
var topHeight = generator.definition.topHeight;
var bottomHeight = generator.definition.bottomHeight;
var maxTopHeight = generator.definition.height - bottomHeight;
var maxBottomHeight = generator.definition.height - topHeight;
if (generator.Height < 0)
{
normal = -normal;
}
EditorGUI.BeginChangeCheck();
{
UnityEditor.Handles.color = baseColor;
// TODO: make it possible to (optionally) size differently in x & z
radius2D.x = UnitySceneExtensions.SceneHandles.RadiusHandle(normal, middlePoint, radius2D.x);
var topId = GUIUtility.GetControlID(s_TopHash, FocusType.Passive);
{
var isTopBackfaced = ChiselCylinderEditor.IsSufaceBackFaced(topPoint, normal);
var topHasFocus = (focusControl == topId);
UnityEditor.Handles.color = ChiselCylinderEditor.GetColorForState(baseColor, topHasFocus, isTopBackfaced, isDisabled);
topPoint = UnitySceneExtensions.SceneHandles.DirectionHandle(topId, topPoint, normal);
var topLoopHasFocus = (topHasFocus && !generator.HaveRoundedTop) || (focusControl == topLoopID);
var thickness = topLoopHasFocus ? kCapLineThicknessSelected : kCapLineThickness;
UnityEditor.Handles.color = ChiselCylinderEditor.GetColorForState(baseColor, topLoopHasFocus, true, isDisabled);
ChiselOutlineRenderer.DrawLineLoop(vertices, generator.definition.topVertexOffset, generator.definition.sides, lineMode: LineMode.NoZTest, thickness: thickness);
UnityEditor.Handles.color = ChiselCylinderEditor.GetColorForState(baseColor, topLoopHasFocus, false, isDisabled);
ChiselOutlineRenderer.DrawLineLoop(vertices, generator.definition.topVertexOffset, generator.definition.sides, lineMode: LineMode.ZTest, thickness: thickness);
{
var prevGUIChanged = GUI.changed;
for (int j = generator.definition.sides - 1, i = 0; i < generator.definition.sides; j = i, i++)
{
GUI.changed = false;
var from = vertices[j + generator.definition.topVertexOffset];
var to = vertices[i + generator.definition.topVertexOffset];
var edgeOffset = UnitySceneExtensions.SceneHandles.Edge1DHandleOffset(topLoopID, UnitySceneExtensions.Axis.Y, from, to, capFunction: null);
if (GUI.changed)
{
topHeight = Mathf.Clamp(topHeight - edgeOffset, 0, maxTopHeight);
prevGUIChanged = true;
}
}
GUI.changed = prevGUIChanged;
}
}
var bottomId = GUIUtility.GetControlID(s_BottomHash, FocusType.Passive);
{
var isBottomBackfaced = ChiselCylinderEditor.IsSufaceBackFaced(bottomPoint, -normal);
var bottomHasFocus = (focusControl == bottomId);
UnityEditor.Handles.color = ChiselCylinderEditor.GetColorForState(baseColor, bottomHasFocus, isBottomBackfaced, isDisabled);
bottomPoint = UnitySceneExtensions.SceneHandles.DirectionHandle(bottomId, bottomPoint, -normal);
var bottomLoopHasFocus = (bottomHasFocus && !generator.HaveRoundedBottom) || (focusControl == bottomLoopID);
var thickness = bottomLoopHasFocus ? kCapLineThicknessSelected : kCapLineThickness;
UnityEditor.Handles.color = ChiselCylinderEditor.GetColorForState(baseColor, bottomLoopHasFocus, true, isDisabled);
ChiselOutlineRenderer.DrawLineLoop(vertices, generator.definition.bottomVertexOffset, generator.definition.sides, lineMode: LineMode.NoZTest, thickness: thickness);
UnityEditor.Handles.color = ChiselCylinderEditor.GetColorForState(baseColor, bottomLoopHasFocus, false, isDisabled);
ChiselOutlineRenderer.DrawLineLoop(vertices, generator.definition.bottomVertexOffset, generator.definition.sides, lineMode: LineMode.ZTest, thickness: thickness);
{
var prevGUIChanged = GUI.changed;
for (int j = generator.definition.sides - 1, i = 0; i < generator.definition.sides; j = i, i++)
{
GUI.changed = false;
var from = vertices[j + generator.definition.bottomVertexOffset];
var to = vertices[i + generator.definition.bottomVertexOffset];
var edgeOffset = UnitySceneExtensions.SceneHandles.Edge1DHandleOffset(bottomLoopID, UnitySceneExtensions.Axis.Y, from, to, capFunction: null);
if (GUI.changed)
{
bottomHeight = Mathf.Clamp(bottomHeight + edgeOffset, 0, maxBottomHeight);
prevGUIChanged = true;
}
}
GUI.changed = prevGUIChanged;
}
}
}
if (EditorGUI.EndChangeCheck())
{
Undo.RecordObject(target, "Modified " + generator.NodeTypeName);
generator.definition.diameterX = radius2D.x * 2.0f;
generator.definition.height = topPoint.y - bottomPoint.y;
generator.definition.diameterZ = radius2D.x * 2.0f;
generator.definition.offsetY = bottomPoint.y;
generator.definition.topHeight = topHeight;
generator.definition.bottomHeight = bottomHeight;
generator.OnValidate();
// TODO: handle sizing down (needs to modify transformation?)
}
}
protected override void OnScene(SceneView sceneView, ChiselSpiralStairs generator)
{
var normal = Vector3.up;
var topDirection = Vector3.forward;
var lowDirection = Vector3.forward;
var originalOuterDiameter = generator.OuterDiameter;
var originalInnerDiameter = generator.InnerDiameter;
var originalStartAngle = generator.StartAngle;
var originalStepHeight = generator.StepHeight;
var originalRotation = generator.Rotation;
var originalHeight = generator.Height;
var originalOrigin = generator.Origin;
var cylinderTop = new ChiselCircleDefinition(1, originalOrigin.y + originalHeight);
var cylinderLow = new ChiselCircleDefinition(1, originalOrigin.y);
var originalTopPoint = normal * cylinderTop.height;
var originalLowPoint = normal * cylinderLow.height;
var originalMidPoint = (originalTopPoint + originalLowPoint) * 0.5f;
var outerDiameter = originalOuterDiameter;
var innerDiameter = originalInnerDiameter;
var topPoint = originalTopPoint;
var lowPoint = originalLowPoint;
var midPoint = originalMidPoint;
var startAngle = originalStartAngle;
var rotation = originalRotation;
EditorGUI.BeginChangeCheck();
{
var startRotateEdgeID = GUIUtility.GetControlID("SpiralStairsStartAngle".GetHashCode(), FocusType.Keyboard);
var endRotateEdgeID = GUIUtility.GetControlID("SpiralStairsEndAngle".GetHashCode(), FocusType.Keyboard);
// TODO: properly show things as backfaced
// TODO: temporarily show inner or outer diameter as disabled when resizing one or the other
// TODO: FIXME: why aren't there any arrows?
topPoint = UnitySceneExtensions.SceneHandles.DirectionHandle(topPoint, normal, snappingStep: originalStepHeight);
topPoint.y = Mathf.Max(lowPoint.y + originalStepHeight, topPoint.y);
lowPoint = UnitySceneExtensions.SceneHandles.DirectionHandle(lowPoint, -normal, snappingStep: originalStepHeight);
lowPoint.y = Mathf.Min(topPoint.y - originalStepHeight, lowPoint.y);
float minOuterDiameter = innerDiameter + ChiselSpiralStairsDefinition.kMinStairsDepth;
outerDiameter = Mathf.Max(minOuterDiameter, UnitySceneExtensions.SceneHandles.RadiusHandle(Vector3.up, topPoint, outerDiameter * 0.5f, renderDisc: false) * 2.0f);
outerDiameter = Mathf.Max(minOuterDiameter, UnitySceneExtensions.SceneHandles.RadiusHandle(Vector3.up, lowPoint, outerDiameter * 0.5f, renderDisc: false) * 2.0f);
float maxInnerDiameter = outerDiameter - ChiselSpiralStairsDefinition.kMinStairsDepth;
innerDiameter = Mathf.Min(maxInnerDiameter, UnitySceneExtensions.SceneHandles.RadiusHandle(Vector3.up, midPoint, innerDiameter * 0.5f, renderDisc: false) * 2.0f);
startAngle = RotatedEdge2DHandle(startRotateEdgeID, startAngle, lowPoint, outerDiameter * 0.5f, normal, lowDirection, Vector3.Cross(normal, lowDirection));
rotation = RotatedEdge2DHandle(endRotateEdgeID, startAngle + rotation, topPoint, outerDiameter * 0.5f, normal, topDirection, Vector3.Cross(normal, topDirection)) - startAngle;
// TODO: somehow put this into a separate renderer
cylinderTop.diameterZ = cylinderTop.diameterX = cylinderLow.diameterZ = cylinderLow.diameterX = originalInnerDiameter;
BrushMeshFactory.GetConicalFrustumVertices(cylinderLow, cylinderTop, 0, generator.InnerSegments, ref innerVertices);
cylinderTop.diameterZ = cylinderTop.diameterX = cylinderLow.diameterZ = cylinderLow.diameterX = originalOuterDiameter;
BrushMeshFactory.GetConicalFrustumVertices(cylinderLow, cylinderTop, 0, generator.OuterSegments, ref outerVertices);
var originalColor = UnityEditor.Handles.yAxisColor;
var color = Color.Lerp(originalColor, UnitySceneExtensions.SceneHandles.staticColor, UnitySceneExtensions.SceneHandles.staticBlend);
var outlineColor = Color.black;
outlineColor.a = color.a;
UnityEditor.Handles.color = outlineColor;
{
var sides = generator.OuterSegments;
for (int i = 0, j = sides - 1; i < sides; j = i, i++)
{
var t0 = outerVertices[i];
var t1 = outerVertices[j];
var b0 = outerVertices[i + sides];
var b1 = outerVertices[j + sides];
UnityEditor.Handles.DrawAAPolyLine(3.0f, t0, b0);
UnityEditor.Handles.DrawAAPolyLine(3.0f, t0, t1);
UnityEditor.Handles.DrawAAPolyLine(3.0f, b0, b1);
}
}
{
var sides = generator.InnerSegments;
for (int i = 0, j = sides - 1; i < sides; j = i, i++)
{
var t0 = innerVertices[i];
var t1 = innerVertices[j];
var b0 = innerVertices[i + sides];
var b1 = innerVertices[j + sides];
UnityEditor.Handles.DrawAAPolyLine(3.0f, t0, b0);
UnityEditor.Handles.DrawAAPolyLine(3.0f, t0, t1);
UnityEditor.Handles.DrawAAPolyLine(3.0f, b0, b1);
}
}
UnityEditor.Handles.color = originalColor;
{
var sides = generator.OuterSegments;
for (int i = 0, j = sides - 1; i < sides; j = i, i++)
{
var t0 = outerVertices[i];
var t1 = outerVertices[j];
var b0 = outerVertices[i + sides];
var b1 = outerVertices[j + sides];
UnityEditor.Handles.DrawAAPolyLine(2.0f, t0, b0);
UnityEditor.Handles.DrawAAPolyLine(2.0f, t0, t1);
UnityEditor.Handles.DrawAAPolyLine(2.0f, b0, b1);
}
}
{
var sides = generator.InnerSegments;
for (int i = 0, j = sides - 1; i < sides; j = i, i++)
{
var t0 = innerVertices[i];
var t1 = innerVertices[j];
var b0 = innerVertices[i + sides];
var b1 = innerVertices[j + sides];
UnityEditor.Handles.DrawAAPolyLine(2.0f, t0, b0);
UnityEditor.Handles.DrawAAPolyLine(2.0f, t0, t1);
UnityEditor.Handles.DrawAAPolyLine(2.0f, b0, b1);
var m0 = (t0 + b0) * 0.5f;
var m1 = (t1 + b1) * 0.5f;
UnityEditor.Handles.DrawDottedLine(m0, m1, 4.0f);
}
}
}
if (EditorGUI.EndChangeCheck())
{
Undo.RecordObject(target, "Modified " + generator.NodeTypeName);
generator.OuterDiameter = outerDiameter;
generator.InnerDiameter = innerDiameter;
generator.StartAngle = startAngle;
generator.Rotation = rotation;
if (topPoint != originalTopPoint)
{
generator.Height = topPoint.y - lowPoint.y;
}
if (lowPoint != originalLowPoint)
{
generator.Height = topPoint.y - lowPoint.y;
var newOrigin = originalOrigin;
newOrigin.y += lowPoint.y - originalLowPoint.y;
generator.Origin = newOrigin;
}
generator.OnValidate();
}
}
public void ShowInstance()
{
var tempTop = generator.Top;
var tempBottom = generator.Bottom;
var sides = generator.Sides;
var topId = GUIUtility.GetControlID(s_TopHash, FocusType.Passive);
var bottomId = GUIUtility.GetControlID(s_BottomHash, FocusType.Passive);
var focusControl = UnitySceneExtensions.SceneHandleUtility.focusControl;
var color = UnityEditor.Handles.yAxisColor;
var isDisabled = UnitySceneExtensions.SceneHandles.disabled;
if (!generator.IsEllipsoid)
{
tempTop.diameterZ = tempTop.diameterX; tempBottom.diameterZ = tempBottom.diameterX;
}
EditorGUI.BeginChangeCheck();
{
switch (generator.Type)
{
case CylinderShapeType.Cylinder:
{
if (generator.IsEllipsoid)
{
UnitySceneExtensions.SceneHandles.Radius2DHandle(topPoint, normal, ref bottomXVector, ref bottomZVector, renderDisc: false);
UnitySceneExtensions.SceneHandles.Radius2DHandle(bottomPoint, -normal, ref bottomXVector, ref bottomZVector, renderDisc: false);
}
else
{
bottomXVector = UnitySceneExtensions.SceneHandles.Radius2DHandle(topPoint, normal, bottomXVector, renderDisc: false);
bottomXVector = UnitySceneExtensions.SceneHandles.Radius2DHandle(bottomPoint, -normal, bottomXVector, renderDisc: false);
bottomZVector = bottomXVector;
}
topXVector = bottomXVector;
topZVector = bottomZVector;
tempTop.diameterX = tempBottom.diameterX;
tempTop.diameterZ = tempBottom.diameterZ;
break;
}
case CylinderShapeType.ConicalFrustum:
{
if (generator.IsEllipsoid)
{
UnitySceneExtensions.SceneHandles.Radius2DHandle(topPoint, normal, ref topXVector, ref topZVector, renderDisc: false);
UnitySceneExtensions.SceneHandles.Radius2DHandle(bottomPoint, -normal, ref bottomXVector, ref bottomZVector, renderDisc: false);
}
else
{
UnitySceneExtensions.SceneHandles.Radius2DHandle(topPoint, normal, ref topXVector, ref topXVector, renderDisc: false);
UnitySceneExtensions.SceneHandles.Radius2DHandle(bottomPoint, -normal, ref bottomXVector, ref bottomXVector, renderDisc: false);
bottomXVector = UnitySceneExtensions.SceneHandles.Radius2DHandle(bottomPoint, -normal, bottomXVector, renderDisc: false);
bottomZVector = bottomXVector;
}
break;
}
case CylinderShapeType.Cone:
{
if (generator.IsEllipsoid)
{
UnitySceneExtensions.SceneHandles.Radius2DHandle(bottomPoint, -normal, ref bottomXVector, ref bottomZVector, renderDisc: false);
}
else
{
bottomXVector = UnitySceneExtensions.SceneHandles.Radius2DHandle(bottomPoint, -normal, bottomXVector, renderDisc: false);
bottomZVector = bottomXVector;
}
topXVector = bottomXVector;
topZVector = bottomZVector;
tempTop.diameterX = 0;
tempTop.diameterZ = 0;
break;
}
}
// TODO: add cylinder horizon "side-lines"
}
if (EditorGUI.EndChangeCheck())
{
topZVector.y = 0;
topXVector.y = 0;
bottomZVector.y = 0;
bottomXVector.y = 0;
Undo.RecordObject(generator, "Modified " + generator.NodeTypeName);
if (!generator.IsEllipsoid)
{
if (prevBottomXVector != bottomXVector)
{
bottomZVector = Vector3.Cross(normal, bottomXVector.normalized) * bottomXVector.magnitude;
}
if (prevTopXVector != topXVector)
{
topZVector = Vector3.Cross(normal, topXVector.normalized) * topXVector.magnitude;
}
}
if (prevTopXVector != topXVector)
{
generator.Rotation = Utilities.GeometryMath.SignedAngle(Vector3.right, topXVector.normalized, Vector3.up);
}
else if (prevBottomXVector != bottomXVector)
{
generator.Rotation = Utilities.GeometryMath.SignedAngle(Vector3.right, bottomXVector.normalized, Vector3.up);
}
if (generator.IsEllipsoid)
{
generator.BottomDiameterX = bottomXVector.magnitude * 2.0f;
generator.BottomDiameterZ = bottomZVector.magnitude * 2.0f;
generator.TopDiameterX = topXVector.magnitude * 2.0f;
generator.TopDiameterZ = topZVector.magnitude * 2.0f;
}
else
{
if (prevBottomZVector != bottomZVector)
{
generator.BottomDiameterX = bottomZVector.magnitude * 2.0f;
generator.BottomDiameterZ = bottomZVector.magnitude * 2.0f;
}
else
{
generator.BottomDiameterX = bottomXVector.magnitude * 2.0f;
generator.BottomDiameterZ = bottomXVector.magnitude * 2.0f;
}
if (prevTopZVector != topZVector)
{
generator.TopDiameterX = topZVector.magnitude * 2.0f;
generator.TopDiameterZ = topZVector.magnitude * 2.0f;
}
else
{
generator.TopDiameterX = topXVector.magnitude * 2.0f;
generator.TopDiameterZ = topXVector.magnitude * 2.0f;
}
}
}
const float kLineDash = 2.0f;
const float kLineThickness = 1.0f;
const float kCircleThickness = 1.5f;
const float kCapLineThickness = 2.0f;
const float kCapLineThicknessSelected = 2.5f;
const int kMaxOutlineSides = 32;
const int kMinimumSides = 8;
var baseColor = UnityEditor.Handles.yAxisColor;
BrushMeshFactory.GetConicalFrustumVertices(tempBottom, tempTop, generator.Rotation, sides, ref vertices);
if (generator.TopHeight < generator.BottomHeight)
{
normal = -normal;
}
var isTopBackfaced = IsSufaceBackFaced(topPoint, normal);
var topHasFocus = (focusControl == topId);
var topThickness = topHasFocus ? kCapLineThicknessSelected : kCapLineThickness;
var isBottomBackfaced = IsSufaceBackFaced(bottomPoint, -normal);
var bottomHasFocus = (focusControl == bottomId);
var bottomThickness = bottomHasFocus ? kCapLineThicknessSelected : kCapLineThickness;
UnityEditor.Handles.color = GetColorForState(baseColor, bottomHasFocus, isBottomBackfaced, isDisabled);
ChiselOutlineRenderer.DrawLineLoop(vertices, 0, sides, thickness: bottomThickness);
UnityEditor.Handles.color = GetColorForState(baseColor, topHasFocus, isTopBackfaced, isDisabled);
ChiselOutlineRenderer.DrawLineLoop(vertices, sides, sides, thickness: topThickness);
UnityEditor.Handles.color = GetColorForState(baseColor, false, false, isDisabled);
for (int i = 0; i < sides; i++)
{
ChiselOutlineRenderer.DrawLine(vertices[i], vertices[i + sides], lineMode: LineMode.ZTest, thickness: kLineThickness);
}
UnityEditor.Handles.color = GetColorForState(baseColor, false, true, isDisabled);
for (int i = 0; i < sides; i++)
{
ChiselOutlineRenderer.DrawLine(vertices[i], vertices[i + sides], lineMode: LineMode.NoZTest, thickness: kLineThickness);
}
/*
* var point0 = camera.WorldToScreenPoint(topPoint);
* var direction = camera.ScreenToWorldPoint(point0 - Vector3.right);
* var point1 = camera.WorldToScreenPoint(point0 - (direction * tempTop.diameterX));
* var size = Mathf.Max(point1.x - point0.x, point1.y - point0.y);
*/
// TODO: figure out how to reduce the sides of the circle depending on radius & distance
int outlineSides = kMaxOutlineSides;
if (sides <= kMinimumSides)
{
BrushMeshFactory.GetConicalFrustumVertices(tempBottom, tempTop, generator.Rotation, outlineSides, ref dottedVertices);
UnityEditor.Handles.color = GetColorForState(baseColor, topHasFocus, false, isDisabled);
ChiselOutlineRenderer.DrawLineLoop(dottedVertices, outlineSides, outlineSides, lineMode: LineMode.ZTest, thickness: kCircleThickness, dashSize: kLineDash);
UnityEditor.Handles.color = GetColorForState(baseColor, topHasFocus, true, isDisabled);
ChiselOutlineRenderer.DrawLineLoop(dottedVertices, outlineSides, outlineSides, lineMode: LineMode.NoZTest, thickness: kCircleThickness, dashSize: kLineDash);
UnityEditor.Handles.color = GetColorForState(baseColor, bottomHasFocus, false, isDisabled);
ChiselOutlineRenderer.DrawLineLoop(dottedVertices, 0, outlineSides, lineMode: LineMode.ZTest, thickness: kCircleThickness, dashSize: kLineDash);
UnityEditor.Handles.color = GetColorForState(baseColor, bottomHasFocus, true, isDisabled);
ChiselOutlineRenderer.DrawLineLoop(dottedVertices, 0, outlineSides, lineMode: LineMode.NoZTest, thickness: kCircleThickness, dashSize: kLineDash);
}
EditorGUI.BeginChangeCheck();
{
UnityEditor.Handles.color = GetColorForState(baseColor, bottomHasFocus, isBottomBackfaced, isDisabled);
bottomPoint = UnitySceneExtensions.SceneHandles.DirectionHandle(bottomId, bottomPoint, -normal);
UnityEditor.Handles.color = GetColorForState(baseColor, topHasFocus, isTopBackfaced, isDisabled);
topPoint = UnitySceneExtensions.SceneHandles.DirectionHandle(topId, topPoint, normal);
}
if (EditorGUI.EndChangeCheck())
{
Undo.RecordObject(generator, "Modified " + generator.NodeTypeName);
generator.TopHeight = Vector3.Dot(Vector3.up, topPoint);
generator.BottomHeight = Vector3.Dot(Vector3.up, bottomPoint);
}
}
protected override void OnScene(SceneView sceneView, ChiselRevolvedShape generator)
{
var baseColor = UnityEditor.Handles.yAxisColor;
var isDisabled = UnitySceneExtensions.SceneHandles.disabled;
var focusControl = UnitySceneExtensions.SceneHandleUtility.focusControl;
var normal = Vector3.forward;
var shape = generator.Shape;
var controlPoints = shape.controlPoints;
/*
* for (int p0 = controlPoints.Length - 1, p1 = 0; p1 < controlPoints.Length; p0 = p1, p1++)
* {
* var point0 = controlPoints[p0].position;
* var point1 = controlPoints[p1].position;
*
* }
*/
var shapeVertices = new List <Vector2>();
var shapeSegmentIndices = new List <int>();
BrushMeshFactory.GetPathVertices(generator.definition.shape, generator.definition.curveSegments, shapeVertices, shapeSegmentIndices);
var horzSegments = generator.definition.revolveSegments;
var horzDegreePerSegment = generator.definition.totalAngle / horzSegments;
var horzOffset = generator.definition.startAngle;
var noZTestcolor = ChiselCylinderEditor.GetColorForState(baseColor, false, true, isDisabled);
var zTestcolor = ChiselCylinderEditor.GetColorForState(baseColor, false, false, isDisabled);
for (int h = 1, pr = 0; h < horzSegments + 1; pr = h, h++)
{
var hDegree0 = (pr * horzDegreePerSegment) + horzOffset;
var hDegree1 = (h * horzDegreePerSegment) + horzOffset;
var rotation0 = Quaternion.AngleAxis(hDegree0, normal);
var rotation1 = Quaternion.AngleAxis(hDegree1, normal);
for (int p0 = controlPoints.Length - 1, p1 = 0; p1 < controlPoints.Length; p0 = p1, p1++)
{
var point0 = controlPoints[p0].position;
//var point1 = controlPoints[p1].position;
var vertexA = rotation0 * new Vector3(point0.x, 0, point0.y);
var vertexB = rotation1 * new Vector3(point0.x, 0, point0.y);
//var vertexC = rotation0 * new Vector3(point1.x, 0, point1.y);
UnityEditor.Handles.color = noZTestcolor;
ChiselOutlineRenderer.DrawLine(vertexA, vertexB, lineMode: LineMode.NoZTest, thickness: kHorzLineThickness);//, dashSize: kLineDash);
UnityEditor.Handles.color = zTestcolor;
ChiselOutlineRenderer.DrawLine(vertexA, vertexB, lineMode: LineMode.ZTest, thickness: kHorzLineThickness); //, dashSize: kLineDash);
}
for (int v0 = shapeVertices.Count - 1, v1 = 0; v1 < shapeVertices.Count; v0 = v1, v1++)
{
var point0 = shapeVertices[v0];
var point1 = shapeVertices[v1];
var vertexA = rotation0 * new Vector3(point0.x, 0, point0.y);
var vertexB = rotation0 * new Vector3(point1.x, 0, point1.y);
UnityEditor.Handles.color = noZTestcolor;
ChiselOutlineRenderer.DrawLine(vertexA, vertexB, lineMode: LineMode.NoZTest, thickness: kHorzLineThickness, dashSize: kLineDash);
UnityEditor.Handles.color = zTestcolor;
ChiselOutlineRenderer.DrawLine(vertexA, vertexB, lineMode: LineMode.ZTest, thickness: kHorzLineThickness, dashSize: kLineDash);
}
}
EditorGUI.BeginChangeCheck();
{
// TODO: make this work non grid aligned so we can place it upwards
UnityEditor.Handles.color = baseColor;
shape = UnitySceneExtensions.SceneHandles.Curve2DHandle(Matrix4x4.TRS(Vector3.zero, Quaternion.AngleAxis(90, Vector3.right), Vector3.one), shape);
UnityEditor.Handles.DrawDottedLine(normal * 10, normal * -10, 4.0f);
}
if (EditorGUI.EndChangeCheck())
{
Undo.RecordObject(target, "Modified " + generator.NodeTypeName);
generator.Shape = shape;
}
}
public static void CreateBox(Vector3 size, int descriptionIndex, out BrushMesh box)
{
BrushMeshFactory.CreateBox(size, descriptionIndex, out box);
}
public static BrushMesh CreateBox(Vector3 size, SurfaceLayers layers)
{
return(BrushMeshFactory.CreateBox(Vector3.one, layers));
}
static Vector3[] vertices = null; // TODO: store this per instance? or just allocate every frame?
protected override void OnScene(ChiselSphere generator)
{
var baseColor = UnityEditor.Handles.yAxisColor;
var isDisabled = UnitySceneExtensions.SceneHandles.disabled;
var focusControl = UnitySceneExtensions.SceneHandleUtility.focusControl;
var normal = Vector3.up;
if (!BrushMeshFactory.GenerateSphereVertices(generator.definition, ref vertices))
{
return;
}
UnityEditor.Handles.color = ChiselCylinderEditor.GetColorForState(baseColor, false, false, isDisabled);
DrawOutline(generator.definition, vertices, lineMode: LineMode.ZTest);
UnityEditor.Handles.color = ChiselCylinderEditor.GetColorForState(baseColor, false, true, isDisabled);
DrawOutline(generator.definition, vertices, lineMode: LineMode.NoZTest);
Vector3 center, topPoint, bottomPoint;
if (!generator.GenerateFromCenter)
{
center = normal * (generator.definition.offsetY + (generator.DiameterXYZ.y * 0.5f));
topPoint = normal * (generator.definition.offsetY + generator.DiameterXYZ.y);
bottomPoint = normal * (generator.definition.offsetY);
}
else
{
center = normal * (generator.definition.offsetY);
topPoint = normal * (generator.definition.offsetY + (generator.DiameterXYZ.y * 0.5f));
bottomPoint = normal * (generator.definition.offsetY + (generator.DiameterXYZ.y * -0.5f));
}
if (generator.DiameterXYZ.y < 0)
{
normal = -normal;
}
var radius2D = new Vector2(generator.definition.diameterXYZ.x, generator.definition.diameterXYZ.z) * 0.5f;
EditorGUI.BeginChangeCheck();
{
UnityEditor.Handles.color = baseColor;
// TODO: make it possible to (optionally) size differently in x & z
radius2D.x = UnitySceneExtensions.SceneHandles.RadiusHandle(normal, center, radius2D.x);
var bottomId = GUIUtility.GetControlID(s_BottomHash, FocusType.Passive);
{
var isBottomBackfaced = false; // TODO: how to do this?
var bottomHasFocus = (focusControl == bottomId);
UnityEditor.Handles.color = ChiselCylinderEditor.GetColorForState(baseColor, bottomHasFocus, isBottomBackfaced, isDisabled);
bottomPoint = UnitySceneExtensions.SceneHandles.DirectionHandle(bottomId, bottomPoint, -normal);
}
var topId = GUIUtility.GetControlID(s_TopHash, FocusType.Passive);
{
var isTopBackfaced = false; // TODO: how to do this?
var topHasFocus = (focusControl == topId);
UnityEditor.Handles.color = ChiselCylinderEditor.GetColorForState(baseColor, topHasFocus, isTopBackfaced, isDisabled);
topPoint = UnitySceneExtensions.SceneHandles.DirectionHandle(topId, topPoint, normal);
}
}
if (EditorGUI.EndChangeCheck())
{
Undo.RecordObject(target, "Modified " + generator.NodeTypeName);
var diameter = generator.DiameterXYZ;
diameter.y = topPoint.y - bottomPoint.y;
diameter.x = radius2D.x * 2.0f;
diameter.z = radius2D.x * 2.0f;
generator.definition.offsetY = bottomPoint.y;
generator.DiameterXYZ = diameter;
// TODO: handle sizing down (needs to modify transformation?)
}
}
