b2cdbe8c8d
A previous attempt to fix this was done in 0128b8679. However, it was
not rigorous. The added offset was dependent on font size and it
introduced an error into edit control positioning. Further, it is
irrelevant to non-workplanes.
After this commit, the workplane drawing code adds a fixed offset
instead. Also, the "tab" is enlarged to not overlap with #XY etc.
725 lines
24 KiB
C++
725 lines
24 KiB
C++
//-----------------------------------------------------------------------------
|
|
// Draw a representation of an entity on-screen, in the case of curves up
|
|
// to our chord tolerance, or return the distance from the user's mouse pointer
|
|
// to the entity for selection.
|
|
//
|
|
// Copyright 2008-2013 Jonathan Westhues.
|
|
//-----------------------------------------------------------------------------
|
|
#include "solvespace.h"
|
|
|
|
std::string Entity::DescriptionString(void) {
|
|
if(h.isFromRequest()) {
|
|
Request *r = SK.GetRequest(h.request());
|
|
return r->DescriptionString();
|
|
} else {
|
|
Group *g = SK.GetGroup(h.group());
|
|
return g->DescriptionString();
|
|
}
|
|
}
|
|
|
|
void Entity::LineDrawOrGetDistance(Vector a, Vector b, bool maybeFat, int data) {
|
|
if(dogd.drawing) {
|
|
// Draw lines from active group in front of those from previous
|
|
ssglDepthRangeOffset((group.v == SS.GW.activeGroup.v) ? 4 : 3);
|
|
// Narrow lines are drawn as lines, but fat lines must be drawn as
|
|
// filled polygons, to get the line join style right.
|
|
ssglStippledLine(a, b, dogd.lineWidth, dogd.stippleType, dogd.stippleScale, maybeFat);
|
|
ssglDepthRangeOffset(0);
|
|
} else {
|
|
Point2d ap = SS.GW.ProjectPoint(a);
|
|
Point2d bp = SS.GW.ProjectPoint(b);
|
|
|
|
double d = dogd.mp.DistanceToLine(ap, bp.Minus(ap), true);
|
|
// A little bit easier to select in the active group
|
|
if(group.v == SS.GW.activeGroup.v) d -= 1;
|
|
if(d < dogd.dmin) {
|
|
dogd.dmin = d;
|
|
dogd.data = data;
|
|
}
|
|
}
|
|
dogd.refp = (a.Plus(b)).ScaledBy(0.5);
|
|
}
|
|
|
|
void Entity::DrawAll(bool drawAsHidden) {
|
|
// This handles points as a special case, because I seem to be able
|
|
// to get a huge speedup that way, by consolidating stuff to gl.
|
|
int i;
|
|
if(SS.GW.showPoints) {
|
|
double s = 3.5/SS.GW.scale;
|
|
Vector r = SS.GW.projRight.ScaledBy(s);
|
|
Vector d = SS.GW.projUp.ScaledBy(s);
|
|
ssglColorRGB(Style::Color(Style::DATUM));
|
|
ssglDepthRangeOffset(6);
|
|
glBegin(GL_QUADS);
|
|
for(i = 0; i < SK.entity.n; i++) {
|
|
Entity *e = &(SK.entity.elem[i]);
|
|
if(!e->IsPoint()) continue;
|
|
if(!(SK.GetGroup(e->group)->IsVisible())) continue;
|
|
if(e->forceHidden) continue;
|
|
|
|
Vector v = e->PointGetNum();
|
|
|
|
// If we're analyzing the sketch to show the degrees of freedom,
|
|
// then we draw big colored squares over the points that are
|
|
// free to move.
|
|
bool free = false;
|
|
if(e->type == POINT_IN_3D) {
|
|
Param *px = SK.GetParam(e->param[0]),
|
|
*py = SK.GetParam(e->param[1]),
|
|
*pz = SK.GetParam(e->param[2]);
|
|
|
|
free = (px->free) || (py->free) || (pz->free);
|
|
} else if(e->type == POINT_IN_2D) {
|
|
Param *pu = SK.GetParam(e->param[0]),
|
|
*pv = SK.GetParam(e->param[1]);
|
|
|
|
free = (pu->free) || (pv->free);
|
|
}
|
|
if(free) {
|
|
Vector re = r.ScaledBy(2.5), de = d.ScaledBy(2.5);
|
|
|
|
ssglColorRGB(Style::Color(Style::ANALYZE));
|
|
ssglVertex3v(v.Plus (re).Plus (de));
|
|
ssglVertex3v(v.Plus (re).Minus(de));
|
|
ssglVertex3v(v.Minus(re).Minus(de));
|
|
ssglVertex3v(v.Minus(re).Plus (de));
|
|
ssglColorRGB(Style::Color(Style::DATUM));
|
|
}
|
|
|
|
ssglVertex3v(v.Plus (r).Plus (d));
|
|
ssglVertex3v(v.Plus (r).Minus(d));
|
|
ssglVertex3v(v.Minus(r).Minus(d));
|
|
ssglVertex3v(v.Minus(r).Plus (d));
|
|
}
|
|
glEnd();
|
|
ssglDepthRangeOffset(0);
|
|
}
|
|
|
|
for(i = 0; i < SK.entity.n; i++) {
|
|
Entity *e = &(SK.entity.elem[i]);
|
|
if(e->IsPoint()) {
|
|
continue; // already handled
|
|
}
|
|
e->Draw(drawAsHidden);
|
|
}
|
|
}
|
|
|
|
void Entity::Draw(bool drawAsHidden) {
|
|
hStyle hs = Style::ForEntity(h);
|
|
dogd.lineWidth = Style::Width(hs);
|
|
if(drawAsHidden) {
|
|
dogd.stippleType = Style::PatternType({ Style::HIDDEN_EDGE });
|
|
dogd.stippleScale = Style::StippleScaleMm({ Style::HIDDEN_EDGE });
|
|
} else {
|
|
dogd.stippleType = Style::PatternType(hs);
|
|
dogd.stippleScale = Style::StippleScaleMm(hs);
|
|
}
|
|
ssglLineWidth((float)dogd.lineWidth);
|
|
ssglColorRGB(Style::Color(hs));
|
|
|
|
dogd.drawing = true;
|
|
DrawOrGetDistance();
|
|
}
|
|
|
|
void Entity::GenerateEdges(SEdgeList *el, bool includingConstruction) {
|
|
if(construction && !includingConstruction) return;
|
|
|
|
SBezierList *sbl = GetOrGenerateBezierCurves();
|
|
|
|
int i, j;
|
|
for(i = 0; i < sbl->l.n; i++) {
|
|
SBezier *sb = &(sbl->l.elem[i]);
|
|
|
|
List<Vector> lv = {};
|
|
sb->MakePwlInto(&lv);
|
|
for(j = 1; j < lv.n; j++) {
|
|
el->AddEdge(lv.elem[j-1], lv.elem[j], style.v, i);
|
|
}
|
|
lv.Clear();
|
|
}
|
|
|
|
}
|
|
|
|
SBezierList *Entity::GetOrGenerateBezierCurves() {
|
|
if(beziers.l.n == 0)
|
|
GenerateBezierCurves(&beziers);
|
|
return &beziers;
|
|
}
|
|
|
|
SEdgeList *Entity::GetOrGenerateEdges() {
|
|
if(edges.l.n != 0) {
|
|
if(EXACT(edgesChordTol == SS.ChordTolMm()))
|
|
return &edges;
|
|
edges.l.Clear();
|
|
}
|
|
if(edges.l.n == 0)
|
|
GenerateEdges(&edges, /*includingConstruction=*/true);
|
|
edgesChordTol = SS.ChordTolMm();
|
|
return &edges;
|
|
}
|
|
|
|
BBox Entity::GetOrGenerateScreenBBox(bool *hasBBox) {
|
|
SBezierList *sbl = GetOrGenerateBezierCurves();
|
|
|
|
// We don't bother with bounding boxes for normals, workplanes, etc.
|
|
*hasBBox = (IsPoint() || sbl->l.n > 0);
|
|
if(!*hasBBox) return {};
|
|
|
|
if(screenBBoxValid)
|
|
return screenBBox;
|
|
|
|
if(IsPoint()) {
|
|
Vector proj = SS.GW.ProjectPoint3(PointGetNum());
|
|
screenBBox = BBox::From(proj, proj);
|
|
} else if(sbl->l.n > 0) {
|
|
Vector first = SS.GW.ProjectPoint3(sbl->l.elem[0].ctrl[0]);
|
|
screenBBox = BBox::From(first, first);
|
|
for(int i = 0; i < sbl->l.n; i++) {
|
|
SBezier *sb = &sbl->l.elem[i];
|
|
for(int i = 0; i <= sb->deg; i++) {
|
|
screenBBox.Include(SS.GW.ProjectPoint3(sb->ctrl[i]));
|
|
}
|
|
}
|
|
} else oops();
|
|
|
|
// Enlarge the bounding box to consider selection radius.
|
|
screenBBox.minp.x -= SELECTION_RADIUS;
|
|
screenBBox.minp.y -= SELECTION_RADIUS;
|
|
screenBBox.maxp.x += SELECTION_RADIUS;
|
|
screenBBox.maxp.y += SELECTION_RADIUS;
|
|
|
|
screenBBoxValid = true;
|
|
return screenBBox;
|
|
}
|
|
|
|
double Entity::GetDistance(Point2d mp) {
|
|
dogd.drawing = false;
|
|
dogd.mp = mp;
|
|
dogd.dmin = 1e12;
|
|
|
|
DrawOrGetDistance();
|
|
|
|
return dogd.dmin;
|
|
}
|
|
|
|
Vector Entity::GetReferencePos(void) {
|
|
dogd.drawing = false;
|
|
|
|
dogd.refp = SS.GW.offset.ScaledBy(-1);
|
|
DrawOrGetDistance();
|
|
|
|
return dogd.refp;
|
|
}
|
|
|
|
bool Entity::IsStylable() {
|
|
if(IsPoint()) return false;
|
|
if(IsWorkplane()) return false;
|
|
if(IsNormal()) return false;
|
|
return true;
|
|
}
|
|
|
|
bool Entity::IsVisible(void) {
|
|
Group *g = SK.GetGroup(group);
|
|
|
|
if(g->h.v == Group::HGROUP_REFERENCES.v && IsNormal()) {
|
|
// The reference normals are always shown
|
|
return true;
|
|
}
|
|
if(!(g->IsVisible())) return false;
|
|
|
|
// Don't check if points are hidden; this gets called only for
|
|
// selected or hovered points, and those should always be shown.
|
|
if(IsNormal() && !SS.GW.showNormals) return false;
|
|
|
|
if(!SS.GW.showWorkplanes) {
|
|
if(IsWorkplane() && !h.isFromRequest()) {
|
|
if(g->h.v != SS.GW.activeGroup.v) {
|
|
// The group-associated workplanes are hidden outside
|
|
// their group.
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
|
|
if(style.v) {
|
|
Style *s = Style::Get(style);
|
|
if(!s->visible) return false;
|
|
}
|
|
|
|
if(forceHidden) return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
void Entity::CalculateNumerical(bool forExport) {
|
|
if(IsPoint()) actPoint = PointGetNum();
|
|
if(IsNormal()) actNormal = NormalGetNum();
|
|
if(type == DISTANCE || type == DISTANCE_N_COPY) {
|
|
actDistance = DistanceGetNum();
|
|
}
|
|
if(IsFace()) {
|
|
actPoint = FaceGetPointNum();
|
|
Vector n = FaceGetNormalNum();
|
|
actNormal = Quaternion::From(0, n.x, n.y, n.z);
|
|
}
|
|
if(forExport) {
|
|
// Visibility in copied linked entities follows source file
|
|
actVisible = IsVisible();
|
|
} else {
|
|
// Copied entities within a file are always visible
|
|
actVisible = true;
|
|
}
|
|
}
|
|
|
|
bool Entity::PointIsFromReferences(void) {
|
|
return h.request().IsFromReferences();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Compute a cubic, second derivative continuous, interpolating spline. Same
|
|
// routine for periodic splines (in a loop) or open splines (with specified
|
|
// end tangents).
|
|
//-----------------------------------------------------------------------------
|
|
void Entity::ComputeInterpolatingSpline(SBezierList *sbl, bool periodic) {
|
|
static const int MAX_N = BandedMatrix::MAX_UNKNOWNS;
|
|
int ep = extraPoints;
|
|
|
|
// The number of unknowns to solve for.
|
|
int n = periodic ? 3 + ep : ep;
|
|
if(n >= MAX_N) oops();
|
|
// The number of on-curve points, one more than the number of segments.
|
|
int pts = periodic ? 4 + ep : 2 + ep;
|
|
|
|
int i, j, a;
|
|
|
|
// The starting and finishing control points that define our end tangents
|
|
// (if the spline isn't periodic), and the on-curve points.
|
|
Vector ctrl_s = Vector::From(0, 0, 0);
|
|
Vector ctrl_f = Vector::From(0, 0, 0);
|
|
Vector pt[MAX_N+4];
|
|
if(periodic) {
|
|
for(i = 0; i < ep + 3; i++) {
|
|
pt[i] = SK.GetEntity(point[i])->PointGetNum();
|
|
}
|
|
pt[i++] = SK.GetEntity(point[0])->PointGetNum();
|
|
} else {
|
|
ctrl_s = SK.GetEntity(point[1])->PointGetNum();
|
|
ctrl_f = SK.GetEntity(point[ep+2])->PointGetNum();
|
|
j = 0;
|
|
pt[j++] = SK.GetEntity(point[0])->PointGetNum();
|
|
for(i = 2; i <= ep + 1; i++) {
|
|
pt[j++] = SK.GetEntity(point[i])->PointGetNum();
|
|
}
|
|
pt[j++] = SK.GetEntity(point[ep+3])->PointGetNum();
|
|
}
|
|
|
|
// The unknowns that we will be solving for, a set for each coordinate.
|
|
double Xx[MAX_N], Xy[MAX_N], Xz[MAX_N];
|
|
// For a cubic Bezier section f(t) as t goes from 0 to 1,
|
|
// f' (0) = 3*(P1 - P0)
|
|
// f' (1) = 3*(P3 - P2)
|
|
// f''(0) = 6*(P0 - 2*P1 + P2)
|
|
// f''(1) = 6*(P3 - 2*P2 + P1)
|
|
for(a = 0; a < 3; a++) {
|
|
BandedMatrix bm = {};
|
|
bm.n = n;
|
|
|
|
for(i = 0; i < n; i++) {
|
|
int im, it, ip;
|
|
if(periodic) {
|
|
im = WRAP(i - 1, n);
|
|
it = i;
|
|
ip = WRAP(i + 1, n);
|
|
} else {
|
|
im = i;
|
|
it = i + 1;
|
|
ip = i + 2;
|
|
}
|
|
// All of these are expressed in terms of a constant part, and
|
|
// of X[i-1], X[i], and X[i+1]; so let these be the four
|
|
// components of that vector;
|
|
Vector4 A, B, C, D, E;
|
|
// The on-curve interpolated point
|
|
C = Vector4::From((pt[it]).Element(a), 0, 0, 0);
|
|
// control point one back, C - X[i]
|
|
B = C.Plus(Vector4::From(0, 0, -1, 0));
|
|
// control point one forward, C + X[i]
|
|
D = C.Plus(Vector4::From(0, 0, 1, 0));
|
|
// control point two back
|
|
if(i == 0 && !periodic) {
|
|
A = Vector4::From(ctrl_s.Element(a), 0, 0, 0);
|
|
} else {
|
|
// pt[im] + X[i-1]
|
|
A = Vector4::From(pt[im].Element(a), 1, 0, 0);
|
|
}
|
|
// control point two forward
|
|
if(i == (n - 1) && !periodic) {
|
|
E = Vector4::From(ctrl_f.Element(a), 0, 0, 0);
|
|
} else {
|
|
// pt[ip] - X[i+1]
|
|
E = Vector4::From((pt[ip]).Element(a), 0, 0, -1);
|
|
}
|
|
// Write the second derivatives of each segment, dropping constant
|
|
Vector4 fprev_pp = (C.Minus(B.ScaledBy(2))).Plus(A),
|
|
fnext_pp = (C.Minus(D.ScaledBy(2))).Plus(E),
|
|
eq = fprev_pp.Minus(fnext_pp);
|
|
|
|
bm.B[i] = -eq.w;
|
|
if(periodic) {
|
|
bm.A[i][WRAP(i-2, n)] = eq.x;
|
|
bm.A[i][WRAP(i-1, n)] = eq.y;
|
|
bm.A[i][i] = eq.z;
|
|
} else {
|
|
// The wrapping would work, except when n = 1 and everything
|
|
// wraps to zero...
|
|
if(i > 0) bm.A[i][i - 1] = eq.x;
|
|
bm.A[i][i] = eq.y;
|
|
if(i < (n-1)) bm.A[i][i + 1] = eq.z;
|
|
}
|
|
}
|
|
bm.Solve();
|
|
double *X = (a == 0) ? Xx :
|
|
(a == 1) ? Xy :
|
|
Xz;
|
|
memcpy(X, bm.X, n*sizeof(double));
|
|
}
|
|
|
|
for(i = 0; i < pts - 1; i++) {
|
|
Vector p0, p1, p2, p3;
|
|
if(periodic) {
|
|
p0 = pt[i];
|
|
int iw = WRAP(i - 1, n);
|
|
p1 = p0.Plus(Vector::From(Xx[iw], Xy[iw], Xz[iw]));
|
|
} else if(i == 0) {
|
|
p0 = pt[0];
|
|
p1 = ctrl_s;
|
|
} else {
|
|
p0 = pt[i];
|
|
p1 = p0.Plus(Vector::From(Xx[i-1], Xy[i-1], Xz[i-1]));
|
|
}
|
|
if(periodic) {
|
|
p3 = pt[i+1];
|
|
int iw = WRAP(i, n);
|
|
p2 = p3.Minus(Vector::From(Xx[iw], Xy[iw], Xz[iw]));
|
|
} else if(i == (pts - 2)) {
|
|
p3 = pt[pts-1];
|
|
p2 = ctrl_f;
|
|
} else {
|
|
p3 = pt[i+1];
|
|
p2 = p3.Minus(Vector::From(Xx[i], Xy[i], Xz[i]));
|
|
}
|
|
SBezier sb = SBezier::From(p0, p1, p2, p3);
|
|
sbl->l.Add(&sb);
|
|
}
|
|
}
|
|
|
|
void Entity::GenerateBezierCurves(SBezierList *sbl) {
|
|
SBezier sb;
|
|
|
|
int i = sbl->l.n;
|
|
|
|
switch(type) {
|
|
case LINE_SEGMENT: {
|
|
Vector a = SK.GetEntity(point[0])->PointGetNum();
|
|
Vector b = SK.GetEntity(point[1])->PointGetNum();
|
|
sb = SBezier::From(a, b);
|
|
sb.entity = h.v;
|
|
sbl->l.Add(&sb);
|
|
break;
|
|
}
|
|
case CUBIC:
|
|
ComputeInterpolatingSpline(sbl, false);
|
|
break;
|
|
|
|
case CUBIC_PERIODIC:
|
|
ComputeInterpolatingSpline(sbl, true);
|
|
break;
|
|
|
|
case CIRCLE:
|
|
case ARC_OF_CIRCLE: {
|
|
Vector center = SK.GetEntity(point[0])->PointGetNum();
|
|
Quaternion q = SK.GetEntity(normal)->NormalGetNum();
|
|
Vector u = q.RotationU(), v = q.RotationV();
|
|
double r = CircleGetRadiusNum();
|
|
double thetaa, thetab, dtheta;
|
|
|
|
if(r < LENGTH_EPS) {
|
|
// If a circle or an arc gets dragged through zero radius,
|
|
// then we just don't generate anything.
|
|
break;
|
|
}
|
|
|
|
if(type == CIRCLE) {
|
|
thetaa = 0;
|
|
thetab = 2*PI;
|
|
dtheta = 2*PI;
|
|
} else {
|
|
ArcGetAngles(&thetaa, &thetab, &dtheta);
|
|
}
|
|
int i, n;
|
|
if(dtheta > (3*PI/2 + 0.01)) {
|
|
n = 4;
|
|
} else if(dtheta > (PI + 0.01)) {
|
|
n = 3;
|
|
} else if(dtheta > (PI/2 + 0.01)) {
|
|
n = 2;
|
|
} else {
|
|
n = 1;
|
|
}
|
|
dtheta /= n;
|
|
|
|
for(i = 0; i < n; i++) {
|
|
double s, c;
|
|
|
|
c = cos(thetaa);
|
|
s = sin(thetaa);
|
|
// The start point of the curve, and the tangent vector at
|
|
// that start point.
|
|
Vector p0 = center.Plus(u.ScaledBy( r*c)).Plus(v.ScaledBy(r*s)),
|
|
t0 = u.ScaledBy(-r*s). Plus(v.ScaledBy(r*c));
|
|
|
|
thetaa += dtheta;
|
|
|
|
c = cos(thetaa);
|
|
s = sin(thetaa);
|
|
Vector p2 = center.Plus(u.ScaledBy( r*c)).Plus(v.ScaledBy(r*s)),
|
|
t2 = u.ScaledBy(-r*s). Plus(v.ScaledBy(r*c));
|
|
|
|
// The control point must lie on both tangents.
|
|
Vector p1 = Vector::AtIntersectionOfLines(p0, p0.Plus(t0),
|
|
p2, p2.Plus(t2),
|
|
NULL);
|
|
|
|
SBezier sb = SBezier::From(p0, p1, p2);
|
|
sb.weight[1] = cos(dtheta/2);
|
|
sbl->l.Add(&sb);
|
|
}
|
|
break;
|
|
}
|
|
|
|
case TTF_TEXT: {
|
|
Vector topLeft = SK.GetEntity(point[0])->PointGetNum();
|
|
Vector botLeft = SK.GetEntity(point[1])->PointGetNum();
|
|
Vector n = Normal()->NormalN();
|
|
Vector v = topLeft.Minus(botLeft);
|
|
Vector u = (v.Cross(n)).WithMagnitude(v.Magnitude());
|
|
|
|
SS.fonts.PlotString(font, str, sbl, botLeft, u, v);
|
|
break;
|
|
}
|
|
|
|
default:
|
|
// Not a problem, points and normals and such don't generate curves
|
|
break;
|
|
}
|
|
|
|
// Record our style for all of the Beziers that we just created.
|
|
for(; i < sbl->l.n; i++) {
|
|
sbl->l.elem[i].auxA = style.v;
|
|
}
|
|
}
|
|
|
|
void Entity::DrawOrGetDistance(void) {
|
|
// If we're about to perform hit testing on an entity, consider
|
|
// whether the pointer is inside its bounding box first.
|
|
if(!dogd.drawing) {
|
|
bool hasBBox;
|
|
BBox box = GetOrGenerateScreenBBox(&hasBBox);
|
|
if(hasBBox && !box.Contains(dogd.mp))
|
|
return;
|
|
}
|
|
|
|
if(!IsVisible()) return;
|
|
|
|
switch(type) {
|
|
case POINT_N_COPY:
|
|
case POINT_N_TRANS:
|
|
case POINT_N_ROT_TRANS:
|
|
case POINT_N_ROT_AA:
|
|
case POINT_IN_3D:
|
|
case POINT_IN_2D: {
|
|
Vector v = PointGetNum();
|
|
dogd.refp = v;
|
|
|
|
if(dogd.drawing) {
|
|
double s = 3.5;
|
|
Vector r = SS.GW.projRight.ScaledBy(s/SS.GW.scale);
|
|
Vector d = SS.GW.projUp.ScaledBy(s/SS.GW.scale);
|
|
|
|
ssglColorRGB(Style::Color(Style::DATUM));
|
|
ssglDepthRangeOffset(6);
|
|
glBegin(GL_QUADS);
|
|
ssglVertex3v(v.Plus (r).Plus (d));
|
|
ssglVertex3v(v.Plus (r).Minus(d));
|
|
ssglVertex3v(v.Minus(r).Minus(d));
|
|
ssglVertex3v(v.Minus(r).Plus (d));
|
|
glEnd();
|
|
ssglDepthRangeOffset(0);
|
|
} else {
|
|
Point2d pp = SS.GW.ProjectPoint(v);
|
|
dogd.dmin = pp.DistanceTo(dogd.mp) - 6;
|
|
}
|
|
break;
|
|
}
|
|
|
|
case NORMAL_N_COPY:
|
|
case NORMAL_N_ROT:
|
|
case NORMAL_N_ROT_AA:
|
|
case NORMAL_IN_3D:
|
|
case NORMAL_IN_2D: {
|
|
int i;
|
|
for(i = 0; i < 2; i++) {
|
|
if(i == 0 && !SS.GW.showNormals) {
|
|
// When the normals are hidden, we will continue to show
|
|
// the coordinate axes at the bottom left corner, but
|
|
// not at the origin.
|
|
continue;
|
|
}
|
|
|
|
hRequest hr = h.request();
|
|
// Always draw the x, y, and z axes in red, green, and blue;
|
|
// brighter for the ones at the bottom left of the screen,
|
|
// dimmer for the ones at the model origin.
|
|
int f = (i == 0 ? 100 : 255);
|
|
if(hr.v == Request::HREQUEST_REFERENCE_XY.v) {
|
|
if(dogd.drawing)
|
|
ssglColorRGB(RGBi(0, 0, f));
|
|
} else if(hr.v == Request::HREQUEST_REFERENCE_YZ.v) {
|
|
if(dogd.drawing)
|
|
ssglColorRGB(RGBi(f, 0, 0));
|
|
} else if(hr.v == Request::HREQUEST_REFERENCE_ZX.v) {
|
|
if(dogd.drawing)
|
|
ssglColorRGB(RGBi(0, f, 0));
|
|
} else {
|
|
if(dogd.drawing)
|
|
ssglColorRGB(Style::Color(Style::NORMALS));
|
|
if(i > 0) break;
|
|
}
|
|
|
|
Quaternion q = NormalGetNum();
|
|
Vector tail;
|
|
if(i == 0) {
|
|
tail = SK.GetEntity(point[0])->PointGetNum();
|
|
if(dogd.drawing)
|
|
ssglLineWidth(1);
|
|
} else {
|
|
// Draw an extra copy of the x, y, and z axes, that's
|
|
// always in the corner of the view and at the front.
|
|
// So those are always available, perhaps useful.
|
|
double s = SS.GW.scale;
|
|
double h = 60 - SS.GW.height/2;
|
|
double w = 60 - SS.GW.width/2;
|
|
tail = SS.GW.projRight.ScaledBy(w/s).Plus(
|
|
SS.GW.projUp. ScaledBy(h/s)).Minus(SS.GW.offset);
|
|
if(dogd.drawing) {
|
|
ssglDepthRangeLockToFront(true);
|
|
ssglLineWidth(2);
|
|
}
|
|
}
|
|
|
|
Vector v = (q.RotationN()).WithMagnitude(50/SS.GW.scale);
|
|
Vector tip = tail.Plus(v);
|
|
LineDrawOrGetDistance(tail, tip);
|
|
|
|
v = v.WithMagnitude(12/SS.GW.scale);
|
|
Vector axis = q.RotationV();
|
|
LineDrawOrGetDistance(tip,tip.Minus(v.RotatedAbout(axis, 0.6)));
|
|
LineDrawOrGetDistance(tip,tip.Minus(v.RotatedAbout(axis,-0.6)));
|
|
}
|
|
if(dogd.drawing)
|
|
ssglDepthRangeLockToFront(false);
|
|
break;
|
|
}
|
|
|
|
case DISTANCE:
|
|
case DISTANCE_N_COPY:
|
|
// These are used only as data structures, nothing to display.
|
|
break;
|
|
|
|
case WORKPLANE: {
|
|
Vector p;
|
|
p = SK.GetEntity(point[0])->PointGetNum();
|
|
|
|
Vector u = Normal()->NormalU();
|
|
Vector v = Normal()->NormalV();
|
|
|
|
double s = (min(SS.GW.width, SS.GW.height))*0.45/SS.GW.scale;
|
|
|
|
Vector us = u.ScaledBy(s);
|
|
Vector vs = v.ScaledBy(s);
|
|
|
|
Vector pp = p.Plus (us).Plus (vs);
|
|
Vector pm = p.Plus (us).Minus(vs);
|
|
Vector mm = p.Minus(us).Minus(vs), mm2 = mm;
|
|
Vector mp = p.Minus(us).Plus (vs);
|
|
|
|
if(dogd.drawing) {
|
|
ssglLineWidth(1);
|
|
ssglColorRGB(Style::Color(Style::NORMALS));
|
|
glEnable(GL_LINE_STIPPLE);
|
|
glLineStipple(3, 0x1111);
|
|
}
|
|
|
|
if(!h.isFromRequest()) {
|
|
mm = mm.Plus(v.ScaledBy(70/SS.GW.scale));
|
|
mm2 = mm2.Plus(u.ScaledBy(70/SS.GW.scale));
|
|
LineDrawOrGetDistance(mm2, mm);
|
|
}
|
|
LineDrawOrGetDistance(pp, pm);
|
|
LineDrawOrGetDistance(pm, mm2);
|
|
LineDrawOrGetDistance(mp, mm);
|
|
LineDrawOrGetDistance(pp, mp);
|
|
|
|
if(dogd.drawing)
|
|
glDisable(GL_LINE_STIPPLE);
|
|
|
|
std::string str = DescriptionString().substr(5);
|
|
double th = Style::DefaultTextHeight();
|
|
if(dogd.drawing) {
|
|
Vector o = mm2.Plus(u.ScaledBy(3/SS.GW.scale)).Plus(
|
|
v.ScaledBy(3/SS.GW.scale));
|
|
ssglWriteText(str, th, o, u, v, NULL, NULL);
|
|
} else {
|
|
Vector pos = mm2.Plus(u.ScaledBy(ssglStrWidth(str, th)/2)).Plus(
|
|
v.ScaledBy(ssglStrCapHeight(th)/2));
|
|
Point2d pp = SS.GW.ProjectPoint(pos);
|
|
dogd.dmin = min(dogd.dmin, pp.DistanceTo(dogd.mp) - 10);
|
|
// If a line lies in a plane, then select the line, not
|
|
// the plane.
|
|
dogd.dmin += 3;
|
|
}
|
|
break;
|
|
}
|
|
|
|
case LINE_SEGMENT:
|
|
case CIRCLE:
|
|
case ARC_OF_CIRCLE:
|
|
case CUBIC:
|
|
case CUBIC_PERIODIC:
|
|
case TTF_TEXT:
|
|
// Nothing but the curve(s).
|
|
break;
|
|
|
|
case FACE_NORMAL_PT:
|
|
case FACE_XPROD:
|
|
case FACE_N_ROT_TRANS:
|
|
case FACE_N_TRANS:
|
|
case FACE_N_ROT_AA:
|
|
// Do nothing; these are drawn with the triangle mesh
|
|
break;
|
|
|
|
default:
|
|
oops();
|
|
}
|
|
|
|
// And draw the curves; generate the rational polynomial curves for
|
|
// everything, then piecewise linearize them, and display those.
|
|
SEdgeList *sel = GetOrGenerateEdges();
|
|
dogd.data = -1;
|
|
for(int i = 0; i < sel->l.n; i++) {
|
|
SEdge *se = &(sel->l.elem[i]);
|
|
LineDrawOrGetDistance(se->a, se->b, true, se->auxB);
|
|
}
|
|
}
|
|
|