some magic numbers. This would be trivial to break, but still more
difficult than patching the binary to skip the check...
[git-p4: depot-paths = "//depot/solvespace/": change = 1853]
theorem; it's evaluated as a surface integral over each triangle.
And don't regenerate the emphasized edges unless we have to;
specifically, don't do it when the only dirty group is the
drawing group.
[git-p4: depot-paths = "//depot/solvespace/": change = 1849]
And fix a bug; wasn't asking the user whether to save before
abandoning file when a new file was opened recent.
[git-p4: depot-paths = "//depot/solvespace/": change = 1830]
based on a chord tolerance. And rewrite the pwl circles to work
against a chord tolerance too (which they really were doing before,
but in funny units).
Also make "assemble" combine type do a union after interference
checking; was previously just copying, which meant that coplanar
faces could break subsequent operations.
And make right-clicking effectively toggle shift key, instead of
forcing it on; so you can pan or rotate with either right or middle
button.
[git-p4: depot-paths = "//depot/solvespace/": change = 1829]
where it was, move the export (DXF, PNG, STL) stuff to export.cpp,
and move the regen/solve stuff to generate.cpp.
[git-p4: depot-paths = "//depot/solvespace/": change = 1825]
all coordinates are divided by that number as we export.
And add functions to store a float in the registry. I'm using those
for the scale factor, and also to replace the crazy scaled integers
that I was using for light positions etc. before.
[git-p4: depot-paths = "//depot/solvespace/": change = 1824]
specify the plane from which we want to grab the triangles. Shared
edges are then removed with the same code used to check for
watertight meshes, and the remaining edges are assembled into
polygons.
[git-p4: depot-paths = "//depot/solvespace/": change = 1823]
introduced by the bsp routines. It's usually, though not always,
possible to generate a watertight mesh. The occasions where it's
not look ugly, floating point issues, no quick fix.
And use those to generate a list of edges where two different faces
meet, which I can emphasize for cosmetic reasons (and some UI to
specify whether to do that, and with what color).
And make the right mouse button rotate the model, since that was
previously doing nothing.
[git-p4: depot-paths = "//depot/solvespace/": change = 1821]
that to try to find them if we can't find them by absolute path.
This is intended to make everything still work if you copy an
entire directory tree of files that import each other.
Also add a mechanism to not paint the scene if we're not sure it's
consistent; otherwise got some crashes on startup. And disable both
text and graphic window when displaying a modal dialog, wasn't
doing that always.
[git-p4: depot-paths = "//depot/solvespace/": change = 1808]
separate groups. The section is swept normal to the trajectory,
producing a mesh. I'm doing the triangles only now, not copying
over any entities.
Also fix a bug in the PNG export; rows are 4-aligned, so that was
breaking when the width of the image wasn't divisible by four. Also
fix a bug in lathes, where it generated overlapping triangles for
one segment.
And change the groups to record both "this mesh", the contribution
due to the extrude/lathe/whatever, and the "running mesh", that we
get after applying the requested Boolean op between "this mesh" and
the previous group's "running mesh". I'll use that to make step and
repeats step the mesh too.
[git-p4: depot-paths = "//depot/solvespace/": change = 1801]
that perspective in the gl matrices, and also everywhere that I
check mouse pointer positions against the model, and for the zoom
to fit.
[git-p4: depot-paths = "//depot/solvespace/": change = 1796]
user-visible text. And make points hoverable/selectable even when
GW.showPoints is false, and zoom to fit before regenerating on file
open, because then we're at the right zoom level (and will use the
right pwl tolerance).
[git-p4: depot-paths = "//depot/solvespace/": change = 1788]
to save our registry stuff (because we were calling exit() instead
of doing a PostQuitMessage()), and a misclassification of triangles
coplanar with the test surface, when the test surface contained
zero-area triangles.
[git-p4: depot-paths = "//depot/solvespace/": change = 1773]
using the initial numerical guess of whichever vector is already
known to choose our projection planes.
And add a mechanism to defer showing the text window or
regenerating, in order to simplify dependencies on valid actives.
Also yes/no/cancel when about to abandon an unsaved file, and a
bugfix when rotating a rot/trans point.
[git-p4: depot-paths = "//depot/solvespace/": change = 1772]
becomes dirty when the user makes a change, and only the dirty
groups get solved. That's a huge effective speedup.
Also add delete function for groups. That has an interesting issue;
it actually ends up recursing on GenerateAll(), since GenerateAll()
calls ClearSuper(), ClearSuper() might need to recreate a group (if
all the groups were deleted), and that would activate the group,
which calls GenerateAll. The right solution is probably a deferred
execution mechanism, where you can schedule something to happen
before we go idle, but not do it right now.
[git-p4: depot-paths = "//depot/solvespace/": change = 1771]
in one place. And remove the ability to disable the solver, since
that's unlikely to be anything but confusing (and in any case, was
badly implemented). This is in preparation for selective solving,
of only the dirty groups.
[git-p4: depot-paths = "//depot/solvespace/": change = 1769]
create a `new' stack-allocated instance of an object; just From,
possibly different versions with different arg types.
[git-p4: depot-paths = "//depot/solvespace/": change = 1763]
more starting work on the selectable faces, and fiddling in an
attempt to remove dependencies when stuff gets deleted.
[git-p4: depot-paths = "//depot/solvespace/": change = 1760]
part, including all of its entities and the triangle mesh. These
are transformed by a rotation and translation, and appear in the
sketch; the transformation may be set with constraints.
[git-p4: depot-paths = "//depot/solvespace/": change = 1756]
recently opened files, that is saved in the registry and displayed
in a separate popup menu.
[git-p4: depot-paths = "//depot/solvespace/": change = 1752]
nicely. And to do that, I've added the user interface to show an
edit control in the text window.
[git-p4: depot-paths = "//depot/solvespace/": change = 1749]
and in the case of a singular Jacobian, report which constraints
can be removed to fix it. Also a mechanism to hover and select
entities and constraints from the text window.
[git-p4: depot-paths = "//depot/solvespace/": change = 1746]
implement that. Also make solver work only between the first and
last visible group; earlier can just work from previous solve
result, and later don't matter.
There's some issues with the csg code; it will eventually produce
an open mesh, which is very bad. Not sure whether that's a logic
bug, or a numerical issue; still generating absurd triangles pretty
routinely.
[git-p4: depot-paths = "//depot/solvespace/": change = 1741]
as a constraint on the direction cosine, rather than driving the
dot product against a rotated vector to zero. The drawing is the
ugly part; to do that for skew lines, I gave up.
Also add a function to clear non-existent items on the selection
after solving, since that could have caused an oops().
[git-p4: depot-paths = "//depot/solvespace/": change = 1727]
sketch (e.g., a line whose length is constrained gets deleted, but
the constraint is left behind; or the point that's the origin for a
drawing group in plane gets deleted), then deleted the dependencies
too.
[git-p4: depot-paths = "//depot/solvespace/": change = 1725]
translation; or equivalently, rotation about an arbitrary axis).
Those will be important for step and repeats, and for imported
parts.
Also fix a terrible memory corruption bug: I was freeing the remap
list after I loaded it from the file, but the code that put that
into the SS.group list made only a shallow copy.
[git-p4: depot-paths = "//depot/solvespace/": change = 1715]
constraints. And generate the constraint equations for entities
(e.g., that our unit quaternions have magnitude one). Numerical
troubles there, but it sort of works. Also some stuff to draw
projection lines with projected constraints, and to auto-insert
more constraints as you draw.
[git-p4: depot-paths = "//depot/solvespace/": change = 1711]
vectors", represented by unit quaternions. This permits me to add
circles, where the normal defines the plane of the circle.
Still many things painful. The interface for editing normals is not
so intuitive, and it's not yet clear how I would e.g. export a
circle entity and recreate it properly, since that entity has a
param not associated with a normal or point.
And the transformed points/normals do not yet support rotations.
That will be necessary soon.
[git-p4: depot-paths = "//depot/solvespace/": change = 1705]
faces of the polyhedron. And shade the faces when I draw them, and
fix up our projection matrix so that the depth testing works
properly.
[git-p4: depot-paths = "//depot/solvespace/": change = 1703]
other entities. This requires a new point type, for a point that's
defined as a transformation of some other point. All works nicely,
I think. There's ugliness because entities are no longer guaranteed
to have a parent request.
Also speed up display of the text window, by caching brushes
instead of recreating for each character (!), and add a bit more
user interface in the text window.
[git-p4: depot-paths = "//depot/solvespace/": change = 1692]
workplane: a free constraint works in three-space (e.g. true
distance), and a constraint in a workplane works in that plane
(e.g. projected distance). And make the solver go automatically,
though solver itself has lots of pieces missing.
[git-p4: depot-paths = "//depot/solvespace/": change = 1691]
locked on to the XY plane. And simplify the handling of colors in
the text window: identify them by a character, not an integer ID,
since the character is easier to remember.
[git-p4: depot-paths = "//depot/solvespace/": change = 1687]
and point-in-plane. These work, but the equation is still stupid,
solving everything at once and not substituting trivial equations.
[git-p4: depot-paths = "//depot/solvespace/": change = 1677]
take the partial derivatives, and run the Newton's method. This
seems to sort of work with a single distance constraint.
[git-p4: depot-paths = "//depot/solvespace/": change = 1675]
points are now entities like any others; so a line segment request
will generate three entities, the line segment and its endpoints. I
think that's cleaner.
When I do step and repeats (and imports, and other similar), I'll
need a consistent way to assign those entity ids. That assignment
must not change if the sketch is edited. I don't have a clean way
to do that; best thought right now is to keep a record of what maps
have been used previously, and not pick a new map as long as it's
possible to use one that was used previously.
This all means that more crap gets pushed in to the Entity
structure, so that they can keep track of what solver variables
define them. Still seems better, though. I'm closer to ready
to start solving.
[git-p4: depot-paths = "//depot/solvespace/": change = 1673]
Jonathan Westhues