public override void OnEdit(IChiselHandles handles)
{
var normal = Vector3.up;
float3[] vertices = null;
if (BrushMeshFactory.GenerateTorusVertices(this, ref vertices))
{
var baseColor = handles.color;
handles.color = handles.GetStateColor(baseColor, false, false);
DrawOutline(handles, this, vertices, lineMode: LineMode.ZTest);
handles.color = handles.GetStateColor(baseColor, false, true);
DrawOutline(handles, this, vertices, lineMode: LineMode.NoZTest);
handles.color = baseColor;
}
var outerRadius = settings.outerDiameter * 0.5f;
var innerRadius = settings.InnerDiameter * 0.5f;
var topPoint = normal * (settings.tubeHeight * 0.5f);
var bottomPoint = normal * (-settings.tubeHeight * 0.5f);
handles.DoRadiusHandle(ref outerRadius, normal, float3.zero);
handles.DoRadiusHandle(ref innerRadius, normal, float3.zero);
handles.DoDirectionHandle(ref bottomPoint, -normal);
handles.DoDirectionHandle(ref topPoint, normal);
if (handles.modified)
{
settings.outerDiameter = outerRadius * 2.0f;
settings.InnerDiameter = innerRadius * 2.0f;
settings.tubeHeight = (topPoint.y - bottomPoint.y);
// TODO: handle sizing down
}
}
static Vector3[] vertices = null; // TODO: store this per instance? or just allocate every frame?
public void OnEdit(IChiselHandles handles)
{
var baseColor = handles.color;
var normal = Vector3.up;
if (BrushMeshFactory.GenerateHemisphereVertices(ref this, ref vertices))
{
handles.color = handles.GetStateColor(baseColor, false, false);
DrawOutline(handles, this, vertices, lineMode: LineMode.ZTest);
handles.color = handles.GetStateColor(baseColor, false, true);
DrawOutline(handles, this, vertices, lineMode: LineMode.NoZTest);
handles.color = baseColor;
}
var topPoint = normal * this.diameterXYZ.y;
var radius2D = new Vector2(this.diameterXYZ.x, this.diameterXYZ.z) * 0.5f;
if (this.diameterXYZ.y < 0)
{
normal = -normal;
}
bool previousModified;
previousModified = handles.modified;
{
handles.color = baseColor;
// TODO: make it possible to (optionally) size differently in x & z
handles.DoRadiusHandle(ref radius2D.x, normal, Vector3.zero);
{
var isTopBackfaced = false; // TODO: how to do this?
handles.backfaced = isTopBackfaced;
handles.DoDirectionHandle(ref topPoint, normal);
handles.backfaced = false;
}
}
if (previousModified != handles.modified)
{
var diameter = this.diameterXYZ;
diameter.y = topPoint.y;
diameter.x = radius2D.x * 2.0f;
diameter.z = radius2D.x * 2.0f;
this.diameterXYZ = diameter;
}
}
public void OnEdit(IChiselHandles handles)
{
var baseColor = handles.color;
var noZTestcolor = handles.GetStateColor(baseColor, false, true);
var zTestcolor = handles.GetStateColor(baseColor, false, false);
path.UpgradeIfNecessary();
for (int i = 0; i < path.segments.Length; i++)
{
var pathPoint = path.segments[i];
var currMatrix = pathPoint.ToMatrix();
handles.color = baseColor;
handles.DoShapeHandle(ref shape, currMatrix);
if (i == 0)
{
if (handles.DoDirectionHandle(ref pathPoint.position, -(pathPoint.rotation * Vector3.forward)))
{
path.segments[i] = pathPoint;
path = new ChiselPath(path);
}
}
else
if (i == path.segments.Length - 1)
{
if (handles.DoDirectionHandle(ref pathPoint.position, (pathPoint.rotation * Vector3.forward)))
{
path.segments[i] = pathPoint;
path = new ChiselPath(path);
}
}
// Draw lines between different segments
if (i + 1 < path.segments.Length)
{
var nextPoint = path.segments[i + 1];
var nextMatrix = nextPoint.ToMatrix();
var controlPoints = shape.controlPoints;
for (int c = 0; c < controlPoints.Length; c++)
{
var controlPoint = controlPoints[c].position;
var pointA = currMatrix.MultiplyPoint(controlPoint);
var pointB = nextMatrix.MultiplyPoint(controlPoint);
handles.color = noZTestcolor;
handles.DrawLine(pointA, pointB, lineMode: LineMode.NoZTest, thickness: kCapLineThickness, dashSize: kLineDash);
handles.color = zTestcolor;
handles.DrawLine(pointA, pointB, lineMode: LineMode.ZTest, thickness: kCapLineThickness, dashSize: kLineDash);
}
{
var pointA = currMatrix.MultiplyPoint(Vector3.zero);
var pointB = nextMatrix.MultiplyPoint(Vector3.zero);
handles.color = zTestcolor;
handles.DrawLine(pointA, pointB, lineMode: LineMode.NoZTest, thickness: kCapLineThickness, dashSize: kLineDash);
handles.color = zTestcolor;
handles.DrawLine(pointA, pointB, lineMode: LineMode.ZTest, thickness: kCapLineThickness, dashSize: kLineDash);
}
handles.color = baseColor;
}
// TODO: cannot rotate so far that one path plane intersects with shape on another plane
// ... or just fail when it's wrong?
}
for (int i = 0; i < path.segments.Length; i++)
{
var pathPoint = path.segments[i];
if (handles.DoPathPointHandle(ref pathPoint))
{
var originalSegments = path.segments;
var newPath = new ChiselPath(new ChiselPathPoint[originalSegments.Length]);
System.Array.Copy(originalSegments, newPath.segments, originalSegments.Length);
newPath.segments[i] = pathPoint;
path = newPath;
}
}
// TODO: draw curved path
}
static Vector3[] vertices = null; // TODO: store this per instance? or just allocate every frame?
public void OnEdit(IChiselHandles handles)
{
var baseColor = handles.color;
var normal = Vector3.up;
if (BrushMeshFactory.GenerateCapsuleVertices(ref this, ref vertices))
{
handles.color = handles.GetStateColor(baseColor, false, false);
DrawOutline(handles, this, vertices, lineMode: LineMode.ZTest);
handles.color = handles.GetStateColor(baseColor, false, true);
DrawOutline(handles, this, vertices, lineMode: LineMode.NoZTest);
handles.color = baseColor;
}
var topPoint = normal * (this.offsetY + this.height);
var bottomPoint = normal * (this.offsetY);
var middlePoint = normal * (this.offsetY + (this.height * 0.5f));
var radius2D = new Vector2(this.diameterX, this.diameterZ) * 0.5f;
var topHeight = this.topHeight;
var bottomHeight = this.bottomHeight;
var maxTopHeight = this.height - bottomHeight;
var maxBottomHeight = this.height - topHeight;
if (this.height < 0)
{
normal = -normal;
}
var prevModified = handles.modified;
{
handles.color = baseColor;
// TODO: make it possible to (optionally) size differently in x & z
var radius2Dx = radius2D.x;
handles.DoRadiusHandle(ref radius2Dx, normal, middlePoint);
radius2D.x = radius2Dx;
{
var isTopBackfaced = handles.IsSufaceBackFaced(topPoint, normal);
var topLoopHasFocus = false;
handles.backfaced = isTopBackfaced;
for (int j = this.sides - 1, i = 0; i < this.sides; j = i, i++)
{
var from = vertices[j + this.topVertexOffset];
var to = vertices[i + this.topVertexOffset];
if (handles.DoEdgeHandle1DOffset(out var edgeOffset, UnitySceneExtensions.Axis.Y, from, to, renderLine: false))
{
topHeight = Mathf.Clamp(topHeight - edgeOffset, 0, maxTopHeight);
}
topLoopHasFocus = topLoopHasFocus || handles.lastHandleHadFocus;
}
handles.color = baseColor;
handles.DoDirectionHandle(ref topPoint, normal);
var topHasFocus = handles.lastHandleHadFocus;
handles.backfaced = false;
topLoopHasFocus = topLoopHasFocus || (topHasFocus && !this.haveRoundedTop);
var thickness = topLoopHasFocus ? kCapLineThicknessSelected : kCapLineThickness;
handles.color = handles.GetStateColor(baseColor, topLoopHasFocus, true);
handles.DrawLineLoop(vertices, this.topVertexOffset, this.sides, lineMode: LineMode.NoZTest, thickness: thickness);
handles.color = handles.GetStateColor(baseColor, topLoopHasFocus, false);
handles.DrawLineLoop(vertices, this.topVertexOffset, this.sides, lineMode: LineMode.ZTest, thickness: thickness);
}
{
var isBottomBackfaced = handles.IsSufaceBackFaced(bottomPoint, -normal);
var bottomLoopHasFocus = false;
handles.backfaced = isBottomBackfaced;
for (int j = this.sides - 1, i = 0; i < this.sides; j = i, i++)
{
var from = vertices[j + this.bottomVertexOffset];
var to = vertices[i + this.bottomVertexOffset];
if (handles.DoEdgeHandle1DOffset(out var edgeOffset, UnitySceneExtensions.Axis.Y, from, to, renderLine: false))
{
bottomHeight = Mathf.Clamp(bottomHeight + edgeOffset, 0, maxBottomHeight);
}
bottomLoopHasFocus = bottomLoopHasFocus || handles.lastHandleHadFocus;
}
handles.color = baseColor;
handles.DoDirectionHandle(ref bottomPoint, -normal);
var bottomHasFocus = handles.lastHandleHadFocus;
handles.backfaced = false;
bottomLoopHasFocus = bottomLoopHasFocus || (bottomHasFocus && !this.haveRoundedBottom);
var thickness = bottomLoopHasFocus ? kCapLineThicknessSelected : kCapLineThickness;
handles.color = handles.GetStateColor(baseColor, bottomLoopHasFocus, true);
handles.DrawLineLoop(vertices, this.bottomVertexOffset, this.sides, lineMode: LineMode.NoZTest, thickness: thickness);
handles.color = handles.GetStateColor(baseColor, bottomLoopHasFocus, false);
handles.DrawLineLoop(vertices, this.bottomVertexOffset, this.sides, lineMode: LineMode.ZTest, thickness: thickness);
}
}
if (prevModified != handles.modified)
{
this.diameterX = radius2D.x * 2.0f;
this.height = topPoint.y - bottomPoint.y;
this.diameterZ = radius2D.x * 2.0f;
this.offsetY = bottomPoint.y;
this.topHeight = topHeight;
this.bottomHeight = bottomHeight;
// TODO: handle sizing down (needs to modify transformation?)
}
}
public void OnEdit(IChiselHandles handles)
{
var baseColor = handles.color;
var upVector = Vector3.up;
var rightVector = Vector3.right;
var forwardVector = Vector3.forward;
Vector3[] vertices = null;
if (BrushMeshFactory.GenerateStadiumVertices(this, ref vertices))
{
handles.color = handles.GetStateColor(baseColor, false, false);
DrawOutline(handles, this, vertices, lineMode: LineMode.ZTest);
handles.color = handles.GetStateColor(baseColor, false, true);
DrawOutline(handles, this, vertices, lineMode: LineMode.NoZTest);
handles.color = baseColor;
}
var height = this.height;
var length = this.length;
var diameter = this.diameter;
var sides = this.sides;
var firstTopSide = this.firstTopSide;
var lastTopSide = this.lastTopSide;
var firstBottomSide = this.firstBottomSide;
var lastBottomSide = this.lastBottomSide;
var haveRoundedTop = this.haveRoundedTop;
var haveRoundedBottom = this.haveRoundedBottom;
var haveCenter = this.haveCenter;
var topLength = this.topLength;
var bottomLength = this.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);
{
{
var isTopBackfaced = handles.IsSufaceBackFaced(topPoint, upVector);
handles.backfaced = isTopBackfaced;
handles.DoDirectionHandle(ref topPoint, upVector);
var topHasFocus = handles.lastHandleHadFocus;
handles.backfaced = false;
//if (this.haveRoundedTop)
{
var thickness = topHasFocus ? kCapLineThicknessSelected : kCapLineThickness;
handles.color = handles.GetStateColor(handles.color, topHasFocus, true);
handles.DrawLineLoop(vertices, sides, sides, lineMode: LineMode.NoZTest, thickness: thickness);
if (haveRoundedTop)
{
handles.DrawLine(vertices[sides + firstTopSide], vertices[sides + lastTopSide], lineMode: LineMode.NoZTest, thickness: kVertLineThickness);
}
if (haveRoundedBottom && haveCenter)
{
handles.DrawLine(vertices[sides + firstBottomSide], vertices[sides + lastBottomSide], lineMode: LineMode.NoZTest, thickness: kVertLineThickness);
}
handles.color = handles.GetStateColor(handles.color, topHasFocus, false);
handles.DrawLineLoop(vertices, sides, sides, lineMode: LineMode.ZTest, thickness: thickness);
if (haveRoundedTop)
{
handles.DrawLine(vertices[sides + firstTopSide], vertices[sides + lastTopSide], lineMode: LineMode.ZTest, thickness: kVertLineThickness);
}
if (haveRoundedBottom && haveCenter)
{
handles.DrawLine(vertices[sides + firstBottomSide], vertices[sides + lastBottomSide], lineMode: LineMode.ZTest, thickness: kVertLineThickness);
}
}
}
{
var isBottomBackfaced = handles.IsSufaceBackFaced(bottomPoint, -upVector);
handles.backfaced = isBottomBackfaced;
handles.DoDirectionHandle(ref bottomPoint, -upVector);
var bottomHasFocus = handles.lastHandleHadFocus;
handles.backfaced = false;
//if (this.haveRoundedBottom)
{
var thickness = bottomHasFocus ? kCapLineThicknessSelected : kCapLineThickness;
handles.color = handles.GetStateColor(baseColor, bottomHasFocus, true);
handles.DrawLineLoop(vertices, 0, sides, lineMode: LineMode.NoZTest, thickness: thickness);
if (haveRoundedTop)
{
handles.DrawLine(vertices[firstTopSide], vertices[lastTopSide], lineMode: LineMode.NoZTest, thickness: kVertLineThickness);
}
if (haveRoundedBottom && haveCenter)
{
handles.DrawLine(vertices[firstBottomSide], vertices[lastBottomSide], lineMode: LineMode.NoZTest, thickness: kVertLineThickness);
}
handles.color = handles.GetStateColor(baseColor, bottomHasFocus, false);
handles.DrawLineLoop(vertices, 0, sides, lineMode: LineMode.ZTest, thickness: thickness);
if (haveRoundedTop)
{
handles.DrawLine(vertices[firstTopSide], vertices[lastTopSide], lineMode: LineMode.ZTest, thickness: kVertLineThickness);
}
if (haveRoundedBottom && haveCenter)
{
handles.DrawLine(vertices[firstBottomSide], vertices[lastBottomSide], lineMode: LineMode.ZTest, thickness: kVertLineThickness);
}
}
}
{
var isTopBackfaced = handles.IsSufaceBackFaced(frontPoint, forwardVector);
handles.backfaced = isTopBackfaced;
handles.DoDirectionHandle(ref frontPoint, forwardVector);
handles.backfaced = false;
}
{
var isBottomBackfaced = handles.IsSufaceBackFaced(backPoint, -forwardVector);
handles.backfaced = isBottomBackfaced;
handles.DoDirectionHandle(ref backPoint, -forwardVector);
handles.backfaced = false;
}
{
var isTopBackfaced = handles.IsSufaceBackFaced(leftPoint, rightVector);
handles.backfaced = isTopBackfaced;
handles.DoDirectionHandle(ref leftPoint, rightVector);
handles.backfaced = false;
}
{
var isBottomBackfaced = handles.IsSufaceBackFaced(rightPoint, -rightVector);
handles.backfaced = isBottomBackfaced;
handles.DoDirectionHandle(ref rightPoint, -rightVector);
handles.backfaced = false;
}
}
if (handles.modified)
{
this.height = topPoint.y - bottomPoint.y;
this.length = Mathf.Max(0, frontPoint.z - backPoint.z);
this.diameter = leftPoint.x - rightPoint.x;
// TODO: handle sizing in some directions (needs to modify transformation?)
}
}
static Vector3[] vertices = null; // TODO: store this per instance? or just allocate every frame?
public void OnEdit(IChiselHandles handles)
{
var baseColor = handles.color;
var normal = Vector3.up;
if (BrushMeshFactory.GenerateSphereVertices(this, ref vertices))
{
handles.color = handles.GetStateColor(baseColor, false, false);
DrawOutline(handles, this, vertices, lineMode: LineMode.ZTest);
handles.color = handles.GetStateColor(baseColor, false, true);
DrawOutline(handles, this, vertices, lineMode: LineMode.NoZTest);
handles.color = baseColor;
}
Vector3 center, topPoint, bottomPoint;
if (!this.generateFromCenter)
{
center = normal * (this.offsetY + (this.diameterXYZ.y * 0.5f));
topPoint = normal * (this.offsetY + this.diameterXYZ.y);
bottomPoint = normal * (this.offsetY);
}
else
{
center = normal * (this.offsetY);
topPoint = normal * (this.offsetY + (this.diameterXYZ.y * 0.5f));
bottomPoint = normal * (this.offsetY + (this.diameterXYZ.y * -0.5f));
}
if (this.diameterXYZ.y < 0)
{
normal = -normal;
}
var radius2D = new Vector2(this.diameterXYZ.x, this.diameterXYZ.z) * 0.5f;
{
// TODO: make it possible to (optionally) size differently in x & z
var radiusX = radius2D.x;
handles.DoRadiusHandle(ref radiusX, normal, center);
radius2D.x = radiusX;
{
var isBottomBackfaced = false; // TODO: how to do this?
handles.backfaced = isBottomBackfaced;
handles.DoDirectionHandle(ref bottomPoint, -normal);
handles.backfaced = false;
}
{
var isTopBackfaced = false; // TODO: how to do this?
handles.backfaced = isTopBackfaced;
handles.DoDirectionHandle(ref topPoint, normal);
handles.backfaced = false;
}
}
if (handles.modified)
{
var diameter = this.diameterXYZ;
diameter.y = topPoint.y - bottomPoint.y;
diameter.x = radius2D.x * 2.0f;
diameter.z = radius2D.x * 2.0f;
this.offsetY = bottomPoint.y;
this.diameterXYZ = diameter;
// TODO: handle sizing down (needs to modify transformation?)
}
}
public void OnEdit(IChiselHandles handles)
{
var baseColor = handles.color;
var normal = Vector3.forward;
var controlPoints = shape.controlPoints;
var shapeVertices = new List <Vector2>();
var shapeSegmentIndices = new List <int>();
BrushMeshFactory.GetPathVertices(this.shape, this.curveSegments, shapeVertices, shapeSegmentIndices);
var horzSegments = this.revolveSegments;
var horzDegreePerSegment = this.totalAngle / horzSegments;
var horzOffset = this.startAngle;
var noZTestcolor = handles.GetStateColor(baseColor, false, true);
var zTestcolor = handles.GetStateColor(baseColor, false, false);
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);
handles.color = noZTestcolor;
handles.DrawLine(vertexA, vertexB, lineMode: LineMode.NoZTest, thickness: kHorzLineThickness);//, dashSize: kLineDash);
handles.color = zTestcolor;
handles.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);
handles.color = noZTestcolor;
handles.DrawLine(vertexA, vertexB, lineMode: LineMode.NoZTest, thickness: kHorzLineThickness, dashSize: kLineDash);
handles.color = zTestcolor;
handles.DrawLine(vertexA, vertexB, lineMode: LineMode.ZTest, thickness: kHorzLineThickness, dashSize: kLineDash);
}
}
handles.color = baseColor;
{
// TODO: make this work non grid aligned so we can place it upwards
handles.DoShapeHandle(ref shape);
handles.DrawLine(normal * 10, normal * -10, dashSize: 4.0f);
}
}
