protected override void OnDraw(LineCanvas canvas)
{
var pl = getPlane();
var p = GetEntity(0).CenterInPlane(null).Eval();
var lo = getPlane().projectVectorInto(getLabelOffset());
var dir = (lo - p).normalized;
float r = (float)value.exp.Eval() / 2f;
if (showAsRadius)
{
var rpt = p + dir * r;
var rdir = lo - rpt;
drawPointsDistance(p, p + dir * r, canvas, Camera.main, arrow0: false, arrow1: true);
canvas.DrawLine(rpt, lo);
}
else
{
drawPointsDistance(p - dir * r, p + dir * r, canvas, Camera.main);
}
//drawLabel(renderer, camera, "Ø" + getValueString());
}
protected override void OnDraw(LineCanvas canvas)
{
var e = GetEntity(0);
Vector3 p0 = e.PointOnInPlane(0.0, null).Eval();
Vector3 p1 = e.PointOnInPlane(1.0, null).Eval();
Vector3 t0 = e.TangentAtInPlane(0.0, null).Eval().normalized;
Vector3 t1 = e.TangentAtInPlane(1.0, null).Eval().normalized;
Vector3 n = e.plane.n.normalized;
Vector3 perp0 = Vector3.Cross(t0, n);
Vector3 perp1 = Vector3.Cross(t1, n);
float pix = getPixelSize();
canvas.DrawLine(p0, p0 + perp0 * 25f * pix);
canvas.DrawLine(p1, p1 + perp1 * 25f * pix);
e.DrawParamRange(canvas, 20f * pix, 0.0, 1.0, 0.05, null);
pos = e.OffsetAtInPlane(0.5, 30f * pix, null).Eval();
var ap0 = e.OffsetAtInPlane(0.0, 20f * pix, null).Eval();
var ap1 = e.OffsetAtInPlane(1.0, 20f * pix, null).Eval();
bool stroke = (ap0 - ap1).magnitude < (R_ARROW_W * 2f + 1f) * pix;
drawArrow(canvas, ap0, -e.TangentAtInPlane(0.0, null).Eval(), stroke);
drawArrow(canvas, ap1, e.TangentAtInPlane(1.0, null).Eval(), stroke);
}
protected override void OnDraw(LineCanvas canvas)
{
Vector3 p0p = GetPointInPlane(0, null).Eval();
Vector3 p1p = GetPointInPlane(1, null).Eval();
drawPointsDistance(p0p, p1p, canvas, Camera.main, false, true, true, 0);
}
protected override void OnDraw(LineCanvas canvas)
{
canvas.SetStyle("entities");
ForEachSegment((a, b) => {
canvas.DrawLine(a, b);
});
}
private static void WriteLine(this LineCanvas lc, MWord.Range range)
{
var canvas = range.Document.Shapes.AddCanvas((float)lc.Location.X, (float)lc.Location.Y, (float)lc.Size.Width, (float)lc.Size.Height, range);
canvas.WrapFormat.Type = WdWrapType.wdWrapInline;
foreach (var shape in lc.Shapes)
{
switch (shape)
{
case CurveCanvasShape ccs:
ccs.DrawShapeOnCanvas(canvas.CanvasItems);
break;
case LineCanvasShape lcs:
lcs.DrawShapeOnCanvas(canvas.CanvasItems);
break;
case TriangleCanvasShape tcs:
tcs.DrawShapeOnCanvas(canvas.CanvasItems);
break;
}
}
canvas.CanvasItems.SelectAll();
range.Application.Selection.Cut();
canvas.Delete();
range.PasteSpecial(DataType: WdPasteDataType.wdPasteEnhancedMetafile);
}
public void DrawTriangulation(LineCanvas canvas)
{
var ids = new List <List <Id> >();
var polygons = Sketch.GetPolygons(loops.Where(l => l.All(e => !e.isError)).ToList(), ref ids);
MeshUtils.DrawTriangulation(polygons, canvas);
}
void drawArcExtend(LineCanvas renderer, Vector3 p0, Vector3 p1,
Vector3 c, Vector3 to, Vector3 vz,
bool dash, float step)
{
float dd0 = Vector3.Dot(Vector3.Cross(p0 - c, p1 - c), vz);
bool greater180 = dd0 < 0;
Vector3 c0 = Vector3.Cross(to - c, p0 - c);
Vector3 c1 = Vector3.Cross(to - c, p1 - c);
float d0 = Vector3.Dot(c0, vz);
float d1 = Vector3.Dot(c1, vz);
if (greater180)
{
if (d0 < 0f || d1 > 0f)
{
return;
}
}
else
{
if (!(d1 < 0f || d0 > 0f))
{
return;
}
}
Vector3 from = p0;
if (length(to - p1) < length(to - p0))
{
from = p1;
}
drawArc(renderer, from, to, c, vz, dash, step);
}
protected override void OnDraw(LineCanvas canvas)
{
var c0 = GetEntity(0);
var c1 = GetEntity(1);
var c0c = c0.CenterInPlane(null).Eval();
var c1c = c1.CenterInPlane(null).Eval();
var c0r = (float)c0.Radius().Eval();
var c1r = (float)c1.Radius().Eval();
var dir = (c0c - c1c).normalized;
if (option == Option.FirstInside)
{
dir = -dir;
}
if (isCentersCoincident(c0, c1))
{
dir = c0c - getLabelOffset();
if (length(dir) < EPSILON)
{
dir = sketch.plane.u;
}
dir = normalize(dir);
}
var p0 = c0c - dir * c0r;
var dir2 = (p0 - c1c).normalized;
var p1 = c1c + dir2 * c1r;
drawPointsDistance(p0, p1, canvas, Camera.main, false, true, true, 0);
}
public static void DrawTriangulation(List <List <Vector3> > polygons, LineCanvas canvas)
{
foreach (var p in polygons)
{
var pv = new List <Vector3>(p);
/*var triangles = */ Triangulation.Triangulate(pv, canvas);
}
}
void DrawStroke(LineCanvas canvas, LineEntity line)
{
Vector3 dir = (line.p1.GetPosition() - line.p0.GetPosition()).normalized;
Vector3 perp = Vector3.Cross(dir, Vector3.forward);
Vector3 pos = (line.p1.GetPosition() + line.p0.GetPosition()) / 2f;
canvas.DrawLine(pos + perp, pos - perp);
}
void drawTangentCross(LineCanvas renderer, Vector3 pos, Vector3 dir, Vector3 pn, float pix)
{
float size = 10f * pix;
Vector3 perp = Vector3.Cross(dir, pn);
renderer.DrawLine(pos - perp * size, pos + perp * size);
renderer.DrawLine(pos - dir * size, pos + dir * size);
}
public SketchFeatureBase()
{
sketch = new Sketch();
sketch.feature = this;
sketch.is3d = true;
canvas = GameObject.Instantiate(EntityConfig.instance.lineCanvas);
go = new GameObject(GetType().Name);
canvas.parent = go;
}
public void DrawConstraints(LineCanvas canvas)
{
canvas.ClearStyle("constraints");
canvas.SetStyle("constraints");
foreach (var c in sketch.constraintList)
{
c.Draw(canvas);
}
}
protected override void OnDraw(LineCanvas canvas) {
var lip0 = lineP0Pos;
var lip1 = lineP1Pos;
var p0 = pointPos;
drawCameraCircle(canvas, Camera.main, p0, R_CIRLE_R * getPixelSize());
drawLineExtendInPlane(sketch.plane, canvas, lip0, lip1, p0, 6f * getPixelSize());
}
void DrawStroke(LineCanvas canvas, ValueConstraint c, int rpt)
{
ref_points[rpt] = c.pos;
if (rpt == 0)
{
Vector3 up = c.GetBasis().GetColumn(1);
pos = c.pos + up.normalized * getPixelSize() * 30f;
}
}
protected override void OnDraw(LineCanvas canvas)
{
DrawStroke(canvas, GetEntity(0), 0);
DrawStroke(canvas, GetEntity(1), 1);
if (DetailEditor.instance.hovered == this)
{
DrawReferenceLink(canvas, Camera.main);
}
}
protected override void OnDraw(LineCanvas canvas)
{
DrawStroke(canvas, GetConstraint(0) as ValueConstraint, 0);
DrawStroke(canvas, GetConstraint(1) as ValueConstraint, 1);
if (DetailEditor.instance.hovered == this)
{
DrawReferenceLink(canvas, Camera.main);
}
}
void DrawStroke(LineCanvas canvas, Vector3 p0, Vector3 p1, int rpt)
{
float len = (p1 - p0).magnitude;
float size = Mathf.Min(len, 20f * getPixelSize());
Vector3 dir = (p1 - p0).normalized * size / 2f;
Vector3 pos = (p1 + p0) / 2f;
ref_points[rpt] = sketch.plane.ToPlane(pos);
canvas.DrawLine(pos + dir, pos - dir);
}
protected override void OnUpdateDirty()
{
GameObject.Destroy(go);
go = new GameObject("ImportMeshFeature");
canvas = GameObject.Instantiate(EntityConfig.instance.lineCanvas, go.transform);
canvas.SetStyle("entities");
//foreach(var edge in edges) {
// canvas.DrawLine(edge.a, edge.b);
//}
//meshCheck.drawErrors(canvas);
/*
*
* var vertices = mesh.vertices;
* var triangles = mesh.GetTriangles(0);
* var edges = new HashSet<KeyValuePair<Vector3, Vector3>>();
* var antiEdges = new HashSet<KeyValuePair<Vector3, Vector3>>();
* var tris = new Dictionary<KeyValuePair<Vector3, Vector3>, int>();
* for(int i = 0; i < triangles.Length / 3; i++) {
* for(int j = 0; j < 3; j++) {
* var edge = new KeyValuePair<Vector3, Vector3>(
* Snap(vertices[triangles[i * 3 + j]], vertices),
* Snap(vertices[triangles[i * 3 + (j + 1) % 3]], vertices)
* );
* if(edge.Key == edge.Value) continue;
* tris[edge] = i * 3 + j;
* if(edges.Contains(edge)) continue;
* if(antiEdges.Contains(edge)) continue;
* var antiEdge = new KeyValuePair<Vector3, Vector3>(edge.Value, edge.Key);
* edges.Add(edge);
* antiEdges.Add(antiEdge);
* }
* }
*
* foreach(var edge in edges) {
* var anti = new KeyValuePair<Vector3, Vector3>(edge.Value, edge.Key);
* if(tris.ContainsKey(edge) && tris.ContainsKey(anti)) {
* var tri0 = tris[edge];
* var edg0 = tri0 % 3;
* tri0 -= edg0;
* var n0 = CalculateNormal(tri0, edg0, vertices, triangles);
*
* var tri1 = tris[anti];
* var edg1 = tri1 % 3;
* tri1 -= edg1;
* var n1 = CalculateNormal(tri1, edg1, vertices, triangles);
*
* if((n0 - n1).magnitude < 1e-4) continue;
* } else continue;
* canvas.DrawLine(edge.Key, edge.Value);
* }
*/
go.SetActive(visible);
}
void DrawStroke(LineCanvas canvas, IEntity line, int rpt)
{
var p0 = line.GetPointAtInPlane(0, null).Eval();
var p1 = line.GetPointAtInPlane(1, null).Eval();
Vector3 dir = (p1 - p0).normalized;
Vector3 perp = Vector3.Cross(dir, Vector3.forward) * 5f * getPixelSize();
Vector3 pos = (p1 + p0) / 2f;
ref_points[rpt] = pos;
canvas.DrawLine(pos + perp, pos - perp);
}
protected override void OnDraw(LineCanvas canvas)
{
var point = GetEntity(0);
var circle = GetEntity(1);
var pPos = point.GetPointAtInPlane(0, null).Eval();
var cCen = circle.CenterInPlane(null).Eval();
var cRad = (float)circle.Radius().Eval();
var dir = (pPos - cCen).normalized;
drawPointsDistance(pPos, cCen + dir * cRad, canvas, Camera.main, false, true, true, 0);
}
public static void DrawExtend(this IEntity e, LineCanvas canvas, double t, double step)
{
if (t < 0.0)
{
e.DrawParamRange(canvas, 0.0, t, 0.0, step, null);
}
else
if (t > 1.0)
{
e.DrawParamRange(canvas, 0.0, 1.0, t, step, null);
}
}
public static List <Vector3> Triangulate(List <Vector3> points, LineCanvas canvas = null)
{
List <Vector3> result = new List <Vector3>();
bool processed = true;
while (points.Count > 2 && processed)
{
processed = false;
for (int i = 0; i < points.Count; i++)
{
var a = points[(i - 1 + points.Count) % points.Count];
var b = points[i];
var c = points[(i + 1) % points.Count];
if (IsConvex(a, b, c))
{
bool contains = false;
for (int j = 0; j < points.Count; j++)
{
if (j == i || j == i - 1 || j == i + 1)
{
continue;
}
if (!TriangleContains2d(a, b, c, points[j]))
{
continue;
}
contains = true;
break;
}
if (!contains)
{
if (canvas)
{
canvas.DrawLine(a, b);
canvas.DrawLine(b, c);
canvas.DrawLine(c, a);
}
result.Add(a);
result.Add(b);
result.Add(c);
points.RemoveAt(i--);
processed = true;
if (points.Count < 3)
{
break;
}
}
}
}
}
return(result);
}
protected override void OnDraw(LineCanvas canvas)
{
var l0 = GetEntityOfType(IEntityType.Line, 0);
var l1 = GetEntityOfType(IEntityType.Line, 1);
DrawStroke(canvas, l0, 0);
DrawStroke(canvas, l1, 1);
if (DetailEditor.instance.hovered == this)
{
DrawReferenceLink(canvas, Camera.main);
}
}
void DrawStroke(LineCanvas canvas, IEntity pt0, IEntity pt1, int rpt)
{
var p0 = pt0.GetPointAtInPlane(0, null).Eval();
var p1 = pt1.GetPointAtInPlane(0, null).Eval();
float len = (p1 - p0).magnitude;
float size = Mathf.Min(len, 20f * getPixelSize());
Vector3 dir = (p1 - p0).normalized * size / 2f;
Vector3 pos = (p1 + p0) / 2f;
ref_points[rpt] = sketch.plane.ToPlane(pos);
canvas.DrawLine(pos + dir, pos - dir);
}
protected void drawCameraCircle(LineCanvas renderer, Camera camera, Vector3 pos, float size, int num_segments = 32)
{
float angle = 2f * Mathf.PI / (float)num_segments;
Vector3 r0 = camera.transform.right * size;
for (int i = 0; i < num_segments; i++)
{
Vector3 r1 = rotatedAbout(r0, camera.transform.forward, angle);
renderer.DrawLine(pos + r0, pos + r1);
r0 = r1;
}
}
protected void drawBasis(LineCanvas canvas)
{
var basis = GetBasis();
var pix = getPixelSize();
Vector3 vx = basis.GetColumn(0);
Vector3 vy = basis.GetColumn(1);
//Vector3 vz = basis.GetColumn(2);
Vector3 p = basis.GetColumn(3);
canvas.DrawLine(p, p + vx * 10f * pix);
canvas.DrawLine(p, p + vy * 10f * pix);
}
public void DrawConstraints(LineCanvas canvas)
{
canvas.ClearStyle("constraints");
canvas.SetStyle("constraints");
foreach (var c in sketch.constraintList)
{
if (!c.isVisible)
{
continue;
}
c.Draw(canvas);
}
}
protected override void OnDraw(LineCanvas canvas)
{
var pl = getPlane();
var p = pl.FromPlane(circle.center.pos);
var lo = getLabelOffset();
var dir = (lo - p).normalized;
float r = (float)value.exp.Eval() / 2f;
drawPointsDistance(p - dir * r, p + dir * r, canvas, Camera.main, false);
//drawLabel(renderer, camera, "Ø" + getValueString());
}
void DrawStroke(LineCanvas canvas, IEntity e, int rpt)
{
Vector3 dir = e.TangentAtInPlane(0.5, null).Eval();
Vector3 perp = Vector3.Cross(dir, Camera.main.transform.forward).normalized * 5f * getPixelSize();
Vector3 pos = e.PointOnInPlane(0.5, null).Eval();
ref_points[rpt] = sketch.plane.ToPlane(pos);
if (rpt == 0)
{
this.pos = e.OffsetAtInPlane(0.5, 20f * getPixelSize(), null).Eval();
}
canvas.DrawLine(pos + perp, pos - perp);
}
