zcy
/
solvespace
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
solvespace/group.cpp

790 lines
27 KiB
C++
Raw Normal View History

Bits and pieces of SolveSpace; zoom works now, and some stuff to draw planes that I will use to do the datum planes. Still haven't settled upon the request/entity/group structure, and that's the dependency before doing much real. [git-p4: depot-paths = "//depot/solvespace/": change = 1656]
2008-04-01 10:48:44 +00:00
#include "solvespace.h"
Add transformed points and normals with a rotation (as well as a 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]
2008-05-11 06:09:46 +00:00
const hParam Param::NO_PARAM = { 0 };
#define NO_PARAM (Param::NO_PARAM)
Bits and pieces of SolveSpace; zoom works now, and some stuff to draw planes that I will use to do the datum planes. Still haven't settled upon the request/entity/group structure, and that's the dependency before doing much real. [git-p4: depot-paths = "//depot/solvespace/": change = 1656]
2008-04-01 10:48:44 +00:00
Check in some SolveSpace stuff, even though I didn't make much progress. I want to change the sketch.h stuff fairly significantly, I think, before proceeding. [git-p4: depot-paths = "//depot/solvespace/": change = 1657]
2008-04-08 12:54:53 +00:00
const hGroup Group::HGROUP_REFERENCES = { 1 };
Add selectable faces, by associating an hEntity with the triangle's metadata. And add point-on-face constraints to go with that. Still needs some cleanup for the user interface. [git-p4: depot-paths = "//depot/solvespace/": change = 1766]
2008-06-02 03:31:37 +00:00
#define gs (SS.GW.gs)
Fix a gross memory leak: when switching to a new file, either after File -> New or File -> Open, I freed the Group structures themselves, but none of their children. [git-p4: depot-paths = "//depot/solvespace/": change = 2120]
2010-02-28 19:23:01 +00:00
//-----------------------------------------------------------------------------
// The group structure includes pointers to other dynamically-allocated
// memory. This clears and frees them all.
//-----------------------------------------------------------------------------
void Group::Clear(void) {
polyLoops.Clear();
bezierLoops.Clear();
bezierOpens.Clear();
thisMesh.Clear();
runningMesh.Clear();
thisShell.Clear();
runningShell.Clear();
displayMesh.Clear();
displayEdges.Clear();
impMesh.Clear();
impShell.Clear();
impEntity.Clear();
// remap is the only one that doesn't get recreated when we regen
remap.Clear();
}
Add the first `derived' group, that generates entities based on 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]
2008-04-27 09:03:01 +00:00
void Group::AddParam(IdList<Param,hParam> *param, hParam hp, double v) {
Param pa;
memset(&pa, 0, sizeof(pa));
pa.h = hp;
pa.val = v;
param->Add(&pa);
}
A monster change to add support for filled paths. This requires us to assemble Beziers into outer and inner loops, and find those loops made up of entities with filled styles. The open paths are maintained in a separate list, and we assemble as many closed paths as possible even when open paths exist. This changes many things. The coplanar check is now performed on the Beziers, not the resulting polygon. The way that the polygon is used to determine loop directions is also modified. Also fix the mouse behavior when dragging a point: drop it when the mouse is released, even if it is released outside the window, but don't drop it if the pointer is dragged out of and then back into our window. Also special-case SSurface::ClosestPointTo() for planes, for speed. [git-p4: depot-paths = "//depot/solvespace/": change = 2058]
2009-10-29 07:16:28 +00:00
bool Group::IsVisible(void) {
if(!visible) return false;
if(SS.GroupsInOrder(SS.GW.activeGroup, h)) return false;
return true;
}
Add the first `derived' group, that generates entities based on 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]
2008-04-27 09:03:01 +00:00
void Group::MenuGroup(int id) {
Group g;
We now have selective solve; a group (and all the groups afterward) 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]
2008-06-02 11:43:27 +00:00
ZERO(&g);
Add the first `derived' group, that generates entities based on 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]
2008-04-27 09:03:01 +00:00
g.visible = true;
Add helical sweeps. These aren't as parametric as I would have liked, but my more parametric attempts were very difficult to use. The pitch (both axial and radial) gets specified by typing a distance in a textbox. [git-p4: depot-paths = "//depot/solvespace/": change = 1804]
2008-06-23 08:25:17 +00:00
g.color = RGB(100, 100, 100);
A big nasty change, originally just to add paste transformed. So it does that, and adds a scale factor to that transformation (instead of just mirroring, as before), but also: * Replace the "import mirrored" mechanism with a scale factor, which if negative corresponds to a reflection as well. * Fix self-intersection checker to report a meaningful point when edges are collinear. * Don't blow an assertion on some types of invalid file; instead provide a nice error message to the user. * Clear the naked edges before each regen. * Don't create zero-length line segments by snapping a line segment's end to its beginning. [git-p4: depot-paths = "//depot/solvespace/": change = 2086]
2009-12-15 12:26:22 +00:00
g.scale = 1;
Add the first `derived' group, that generates entities based on 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]
2008-04-27 09:03:01 +00:00
Initial work on the assembly (`import') feature. I can import a 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]
2008-05-29 10:10:12 +00:00
if(id >= RECENT_IMPORT && id < (RECENT_IMPORT + MAX_RECENT)) {
strcpy(g.impFile, RecentFile[id-RECENT_IMPORT]);
id = GraphicsWindow::MNU_GROUP_IMPORT;
}
Find a memory corruption! I was getting a pointer into the entity list, and then adding a new entity to that list, and then looking at that pointer again. Not okay; the add operation might have forced a realloc. I have to watch for that. And add a "distance ratio" constraint, plus a new kind of group that comes with its own workplane. The workplane is not solved for; it's generated explicitly in terms of elements that are already solved. [git-p4: depot-paths = "//depot/solvespace/": change = 1716]
2008-05-11 10:40:37 +00:00
SS.GW.GroupSelection();
Add the first `derived' group, that generates entities based on 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]
2008-04-27 09:03:01 +00:00
switch(id) {
Little changes, more pwls in a circle, and make "same orientation" constraints work mod 180 degrees, so that it snaps to however the workplane was drawn (more vertical vs. more horizontal). [git-p4: depot-paths = "//depot/solvespace/": change = 1714]
2008-05-11 02:57:47 +00:00
case GraphicsWindow::MNU_GROUP_3D:
Find a memory corruption! I was getting a pointer into the entity list, and then adding a new entity to that list, and then looking at that pointer again. Not okay; the add operation might have forced a realloc. I have to watch for that. And add a "distance ratio" constraint, plus a new kind of group that comes with its own workplane. The workplane is not solved for; it's generated explicitly in terms of elements that are already solved. [git-p4: depot-paths = "//depot/solvespace/": change = 1716]
2008-05-11 10:40:37 +00:00
g.type = DRAWING_3D;
Little stuff: show polygon assembly errors only for draw-in-plane groups, rename "drawing" groups to "sketch" groups, and keep assembling even after finding an open curve. [git-p4: depot-paths = "//depot/solvespace/": change = 1835]
2008-07-13 09:57:46 +00:00
g.name.strcpy("sketch-in-3d");
Add the first `derived' group, that generates entities based on 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]
2008-04-27 09:03:01 +00:00
break;
Find a memory corruption! I was getting a pointer into the entity list, and then adding a new entity to that list, and then looking at that pointer again. Not okay; the add operation might have forced a realloc. I have to watch for that. And add a "distance ratio" constraint, plus a new kind of group that comes with its own workplane. The workplane is not solved for; it's generated explicitly in terms of elements that are already solved. [git-p4: depot-paths = "//depot/solvespace/": change = 1716]
2008-05-11 10:40:37 +00:00
case GraphicsWindow::MNU_GROUP_WRKPL:
g.type = DRAWING_WORKPLANE;
Little stuff: show polygon assembly errors only for draw-in-plane groups, rename "drawing" groups to "sketch" groups, and keep assembling even after finding an open curve. [git-p4: depot-paths = "//depot/solvespace/": change = 1835]
2008-07-13 09:57:46 +00:00
g.name.strcpy("sketch-in-plane");
Find a memory corruption! I was getting a pointer into the entity list, and then adding a new entity to that list, and then looking at that pointer again. Not okay; the add operation might have forced a realloc. I have to watch for that. And add a "distance ratio" constraint, plus a new kind of group that comes with its own workplane. The workplane is not solved for; it's generated explicitly in terms of elements that are already solved. [git-p4: depot-paths = "//depot/solvespace/": change = 1716]
2008-05-11 10:40:37 +00:00
if(gs.points == 1 && gs.n == 1) {
Add double-sided extrudes, and user interface for that. Also put the coordinate system (x, y, z normal vectors) in the bottom left corner of the screen at all times, and hide group-created workplanes except when that group is active, and activate that workplane when the group is activated. [git-p4: depot-paths = "//depot/solvespace/": change = 1726]
2008-05-17 08:02:39 +00:00
g.subtype = WORKPLANE_BY_POINT_ORTHO;
Find a memory corruption! I was getting a pointer into the entity list, and then adding a new entity to that list, and then looking at that pointer again. Not okay; the add operation might have forced a realloc. I have to watch for that. And add a "distance ratio" constraint, plus a new kind of group that comes with its own workplane. The workplane is not solved for; it's generated explicitly in terms of elements that are already solved. [git-p4: depot-paths = "//depot/solvespace/": change = 1716]
2008-05-11 10:40:37 +00:00
Vector u = SS.GW.projRight, v = SS.GW.projUp;
u = u.ClosestOrtho();
v = v.Minus(u.ScaledBy(v.Dot(u)));
v = v.ClosestOrtho();
Standardize naming of FromXxx (and XxxFrom) static methods to 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]
2008-06-01 08:45:11 +00:00
g.predef.q = Quaternion::From(u, v);
Add an axis-angle transformation (rotation about an arbitrary point), and use that to implement step and repeat rotating. [git-p4: depot-paths = "//depot/solvespace/": change = 1762]
2008-06-01 08:29:59 +00:00
g.predef.origin = gs.point[0];
Find a memory corruption! I was getting a pointer into the entity list, and then adding a new entity to that list, and then looking at that pointer again. Not okay; the add operation might have forced a realloc. I have to watch for that. And add a "distance ratio" constraint, plus a new kind of group that comes with its own workplane. The workplane is not solved for; it's generated explicitly in terms of elements that are already solved. [git-p4: depot-paths = "//depot/solvespace/": change = 1716]
2008-05-11 10:40:37 +00:00
} else if(gs.points == 1 && gs.lineSegments == 2 && gs.n == 3) {
Add double-sided extrudes, and user interface for that. Also put the coordinate system (x, y, z normal vectors) in the bottom left corner of the screen at all times, and hide group-created workplanes except when that group is active, and activate that workplane when the group is activated. [git-p4: depot-paths = "//depot/solvespace/": change = 1726]
2008-05-17 08:02:39 +00:00
g.subtype = WORKPLANE_BY_LINE_SEGMENTS;
Find a memory corruption! I was getting a pointer into the entity list, and then adding a new entity to that list, and then looking at that pointer again. Not okay; the add operation might have forced a realloc. I have to watch for that. And add a "distance ratio" constraint, plus a new kind of group that comes with its own workplane. The workplane is not solved for; it's generated explicitly in terms of elements that are already solved. [git-p4: depot-paths = "//depot/solvespace/": change = 1716]
2008-05-11 10:40:37 +00:00
Add an axis-angle transformation (rotation about an arbitrary point), and use that to implement step and repeat rotating. [git-p4: depot-paths = "//depot/solvespace/": change = 1762]
2008-06-01 08:29:59 +00:00
g.predef.origin = gs.point[0];
g.predef.entityB = gs.entity[0];
g.predef.entityC = gs.entity[1];
Find a memory corruption! I was getting a pointer into the entity list, and then adding a new entity to that list, and then looking at that pointer again. Not okay; the add operation might have forced a realloc. I have to watch for that. And add a "distance ratio" constraint, plus a new kind of group that comes with its own workplane. The workplane is not solved for; it's generated explicitly in terms of elements that are already solved. [git-p4: depot-paths = "//depot/solvespace/": change = 1716]
2008-05-11 10:40:37 +00:00
A monster change; move the parameter, entity, group, and constraint tables from SolveSpace to their own class. This is intended to simplify use of the constraint solver in a library. [git-p4: depot-paths = "//depot/solvespace/": change = 1942]
2009-04-19 05:53:16 +00:00
Vector ut = SK.GetEntity(g.predef.entityB)->VectorGetNum();
Vector vt = SK.GetEntity(g.predef.entityC)->VectorGetNum();
Find a memory corruption! I was getting a pointer into the entity list, and then adding a new entity to that list, and then looking at that pointer again. Not okay; the add operation might have forced a realloc. I have to watch for that. And add a "distance ratio" constraint, plus a new kind of group that comes with its own workplane. The workplane is not solved for; it's generated explicitly in terms of elements that are already solved. [git-p4: depot-paths = "//depot/solvespace/": change = 1716]
2008-05-11 10:40:37 +00:00
ut = ut.WithMagnitude(1);
vt = vt.WithMagnitude(1);
if(fabs(SS.GW.projUp.Dot(vt)) < fabs(SS.GW.projUp.Dot(ut))) {
SWAP(Vector, ut, vt);
Add an axis-angle transformation (rotation about an arbitrary point), and use that to implement step and repeat rotating. [git-p4: depot-paths = "//depot/solvespace/": change = 1762]
2008-06-01 08:29:59 +00:00
g.predef.swapUV = true;
Find a memory corruption! I was getting a pointer into the entity list, and then adding a new entity to that list, and then looking at that pointer again. Not okay; the add operation might have forced a realloc. I have to watch for that. And add a "distance ratio" constraint, plus a new kind of group that comes with its own workplane. The workplane is not solved for; it's generated explicitly in terms of elements that are already solved. [git-p4: depot-paths = "//depot/solvespace/": change = 1716]
2008-05-11 10:40:37 +00:00
}
Add an axis-angle transformation (rotation about an arbitrary point), and use that to implement step and repeat rotating. [git-p4: depot-paths = "//depot/solvespace/": change = 1762]
2008-06-01 08:29:59 +00:00
if(SS.GW.projRight.Dot(ut) < 0) g.predef.negateU = true;
if(SS.GW.projUp. Dot(vt) < 0) g.predef.negateV = true;
Find a memory corruption! I was getting a pointer into the entity list, and then adding a new entity to that list, and then looking at that pointer again. Not okay; the add operation might have forced a realloc. I have to watch for that. And add a "distance ratio" constraint, plus a new kind of group that comes with its own workplane. The workplane is not solved for; it's generated explicitly in terms of elements that are already solved. [git-p4: depot-paths = "//depot/solvespace/": change = 1716]
2008-05-11 10:40:37 +00:00
} else {
Better error messages when creating groups, too. [git-p4: depot-paths = "//depot/solvespace/": change = 1840]
2008-07-14 05:20:55 +00:00
Error("Bad selection for new sketch in workplane. This "
Edit Message() and Error() strings to use just \n, not \r\n, since my own dialog boxes don't require the carriage returns. [git-p4: depot-paths = "//depot/solvespace/": change = 2109]
2010-01-16 18:15:40 +00:00
"group can be created with:\n\n"
Better error messages when creating groups, too. [git-p4: depot-paths = "//depot/solvespace/": change = 1840]
2008-07-14 05:20:55 +00:00
" * a point (orthogonal to coordinate axes, "
Edit Message() and Error() strings to use just \n, not \r\n, since my own dialog boxes don't require the carriage returns. [git-p4: depot-paths = "//depot/solvespace/": change = 2109]
2010-01-16 18:15:40 +00:00
"through the point)\n"
Better error messages when creating groups, too. [git-p4: depot-paths = "//depot/solvespace/": change = 1840]
2008-07-14 05:20:55 +00:00
" * a point and two line segments (parallel to the "
Edit Message() and Error() strings to use just \n, not \r\n, since my own dialog boxes don't require the carriage returns. [git-p4: depot-paths = "//depot/solvespace/": change = 2109]
2010-01-16 18:15:40 +00:00
"lines, through the point)\n");
Find a memory corruption! I was getting a pointer into the entity list, and then adding a new entity to that list, and then looking at that pointer again. Not okay; the add operation might have forced a realloc. I have to watch for that. And add a "distance ratio" constraint, plus a new kind of group that comes with its own workplane. The workplane is not solved for; it's generated explicitly in terms of elements that are already solved. [git-p4: depot-paths = "//depot/solvespace/": change = 1716]
2008-05-11 10:40:37 +00:00
return;
}
break;
Add the first `derived' group, that generates entities based on 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]
2008-04-27 09:03:01 +00:00
case GraphicsWindow::MNU_GROUP_EXTRUDE:
Add STEP file export for 2d curves too, and disable extrusion not normal to the sketch. [git-p4: depot-paths = "//depot/solvespace/": change = 1981]
2009-06-11 05:57:23 +00:00
if(!SS.GW.LockedInWorkplane()) {
Error("Select a workplane (Sketch -> In Workplane) before "
"extruding. The sketch will be extruded normal to the "
"workplane.");
return;
}
Add the first `derived' group, that generates entities based on 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]
2008-04-27 09:03:01 +00:00
g.type = EXTRUDE;
Add transformed points and normals with a rotation (as well as a 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]
2008-05-11 06:09:46 +00:00
g.opA = SS.GW.activeGroup;
Add an axis-angle transformation (rotation about an arbitrary point), and use that to implement step and repeat rotating. [git-p4: depot-paths = "//depot/solvespace/": change = 1762]
2008-06-01 08:29:59 +00:00
g.predef.entityB = SS.GW.ActiveWorkplane();
Add step and repeat translate, with multiple copies; that all works 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]
2008-05-27 06:36:59 +00:00
g.subtype = ONE_SIDED;
Add the first `derived' group, that generates entities based on 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]
2008-04-27 09:03:01 +00:00
g.name.strcpy("extrude");
break;
Add preliminary lathe (solid of revolution) support. I'm generating just the mesh, no derived entities (but I suppose that I could turn all points into circles). And fix some bugs where equations didn't get unique IDs, and make it possible to lock on to the group's workplane automatically, if you press W while free in 3d with no workplane selected. [git-p4: depot-paths = "//depot/solvespace/": change = 1780]
2008-06-06 11:35:28 +00:00
case GraphicsWindow::MNU_GROUP_LATHE:
if(gs.points == 1 && gs.vectors == 1 && gs.n == 2) {
g.predef.origin = gs.point[0];
g.predef.entityB = gs.vector[0];
} else if(gs.lineSegments == 1 && gs.n == 1) {
A monster change; move the parameter, entity, group, and constraint tables from SolveSpace to their own class. This is intended to simplify use of the constraint solver in a library. [git-p4: depot-paths = "//depot/solvespace/": change = 1942]
2009-04-19 05:53:16 +00:00
g.predef.origin = SK.GetEntity(gs.entity[0])->point[0];
Add preliminary lathe (solid of revolution) support. I'm generating just the mesh, no derived entities (but I suppose that I could turn all points into circles). And fix some bugs where equations didn't get unique IDs, and make it possible to lock on to the group's workplane automatically, if you press W while free in 3d with no workplane selected. [git-p4: depot-paths = "//depot/solvespace/": change = 1780]
2008-06-06 11:35:28 +00:00
g.predef.entityB = gs.entity[0];
// since a line segment is a vector
} else {
Better error messages when creating groups, too. [git-p4: depot-paths = "//depot/solvespace/": change = 1840]
2008-07-14 05:20:55 +00:00
Error("Bad selection for new lathe group. This group can "
Edit Message() and Error() strings to use just \n, not \r\n, since my own dialog boxes don't require the carriage returns. [git-p4: depot-paths = "//depot/solvespace/": change = 2109]
2010-01-16 18:15:40 +00:00
"be created with:\n\n"
Better error messages when creating groups, too. [git-p4: depot-paths = "//depot/solvespace/": change = 1840]
2008-07-14 05:20:55 +00:00
" * a point and a line segment or normal "
"(revolved about an axis parallel to line / "
Edit Message() and Error() strings to use just \n, not \r\n, since my own dialog boxes don't require the carriage returns. [git-p4: depot-paths = "//depot/solvespace/": change = 2109]
2010-01-16 18:15:40 +00:00
"normal, through point)\n"
" * a line segment (revolved about line segment)\n");
Add preliminary lathe (solid of revolution) support. I'm generating just the mesh, no derived entities (but I suppose that I could turn all points into circles). And fix some bugs where equations didn't get unique IDs, and make it possible to lock on to the group's workplane automatically, if you press W while free in 3d with no workplane selected. [git-p4: depot-paths = "//depot/solvespace/": change = 1780]
2008-06-06 11:35:28 +00:00
return;
}
g.type = LATHE;
g.opA = SS.GW.activeGroup;
g.name.strcpy("lathe");
break;
Add sweeps. The user specifies a trajectory and a section, in two 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]
2008-06-21 10:18:20 +00:00
case GraphicsWindow::MNU_GROUP_SWEEP: {
g.type = SWEEP;
// Get the group one before the active group; that's our
// trajectory
int i;
A monster change; move the parameter, entity, group, and constraint tables from SolveSpace to their own class. This is intended to simplify use of the constraint solver in a library. [git-p4: depot-paths = "//depot/solvespace/": change = 1942]
2009-04-19 05:53:16 +00:00
for(i = 1; i < SK.group.n - 1; i++) {
Group *gnext = &(SK.group.elem[i+1]);
Add sweeps. The user specifies a trajectory and a section, in two 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]
2008-06-21 10:18:20 +00:00
if(gnext->h.v == SS.GW.activeGroup.v) {
A monster change; move the parameter, entity, group, and constraint tables from SolveSpace to their own class. This is intended to simplify use of the constraint solver in a library. [git-p4: depot-paths = "//depot/solvespace/": change = 1942]
2009-04-19 05:53:16 +00:00
g.opA = SK.group.elem[i].h;
Add sweeps. The user specifies a trajectory and a section, in two 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]
2008-06-21 10:18:20 +00:00
break;
}
}
A monster change; move the parameter, entity, group, and constraint tables from SolveSpace to their own class. This is intended to simplify use of the constraint solver in a library. [git-p4: depot-paths = "//depot/solvespace/": change = 1942]
2009-04-19 05:53:16 +00:00
if(i >= SK.group.n - 1) {
Add sweeps. The user specifies a trajectory and a section, in two 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]
2008-06-21 10:18:20 +00:00
Error("At least one sketch before the active sketch must "
"exist; that specifies the sweep trajectory.");
return;
}
// The active group is our section
g.opB = SS.GW.activeGroup;
g.name.strcpy("sweep");
break;
}
Add helical sweeps. These aren't as parametric as I would have liked, but my more parametric attempts were very difficult to use. The pitch (both axial and radial) gets specified by typing a distance in a textbox. [git-p4: depot-paths = "//depot/solvespace/": change = 1804]
2008-06-23 08:25:17 +00:00
case GraphicsWindow::MNU_GROUP_HELICAL: {
if(gs.points == 1 && gs.lineSegments == 1 && gs.n == 2) {
A monster change; move the parameter, entity, group, and constraint tables from SolveSpace to their own class. This is intended to simplify use of the constraint solver in a library. [git-p4: depot-paths = "//depot/solvespace/": change = 1942]
2009-04-19 05:53:16 +00:00
Vector pt = SK.GetEntity(gs.point[0])->PointGetNum();
Entity *ln = SK.GetEntity(gs.entity[0]);
Vector lpa = SK.GetEntity(ln->point[0])->PointGetNum();
Vector lpb = SK.GetEntity(ln->point[1])->PointGetNum();
Add helical sweeps. These aren't as parametric as I would have liked, but my more parametric attempts were very difficult to use. The pitch (both axial and radial) gets specified by typing a distance in a textbox. [git-p4: depot-paths = "//depot/solvespace/": change = 1804]
2008-06-23 08:25:17 +00:00
double d = pt.DistanceToLine(lpa, lpb.Minus(lpa));
if(d < LENGTH_EPS) {
Error("Point on helix can't lie on helix's axis!");
return;
}
g.predef.origin = gs.point[0];
g.predef.entityB = gs.entity[0];
} else {
Better error messages when creating groups, too. [git-p4: depot-paths = "//depot/solvespace/": change = 1840]
2008-07-14 05:20:55 +00:00
Error("Bad selection for helical sweep. This group can "
Edit Message() and Error() strings to use just \n, not \r\n, since my own dialog boxes don't require the carriage returns. [git-p4: depot-paths = "//depot/solvespace/": change = 2109]
2010-01-16 18:15:40 +00:00
"be created with:\n\n"
Better error messages when creating groups, too. [git-p4: depot-paths = "//depot/solvespace/": change = 1840]
2008-07-14 05:20:55 +00:00
" * a line segment and a point (line segment "
Edit Message() and Error() strings to use just \n, not \r\n, since my own dialog boxes don't require the carriage returns. [git-p4: depot-paths = "//depot/solvespace/": change = 2109]
2010-01-16 18:15:40 +00:00
"is axis of helix, point lies on helix)\n");
Add helical sweeps. These aren't as parametric as I would have liked, but my more parametric attempts were very difficult to use. The pitch (both axial and radial) gets specified by typing a distance in a textbox. [git-p4: depot-paths = "//depot/solvespace/": change = 1804]
2008-06-23 08:25:17 +00:00
return;
}
g.type = HELICAL_SWEEP;
g.subtype = RIGHT_HANDED;
g.valA = 3; // turns;
g.valB = 300/SS.GW.scale; // pitch along axis
g.valC = 0; // pitch in radius
g.opA = SS.GW.activeGroup;
g.name.strcpy("helical-sweep");
break;
}
Add an axis-angle transformation (rotation about an arbitrary point), and use that to implement step and repeat rotating. [git-p4: depot-paths = "//depot/solvespace/": change = 1762]
2008-06-01 08:29:59 +00:00
case GraphicsWindow::MNU_GROUP_ROT: {
if(gs.points == 1 && gs.n == 1 && SS.GW.LockedInWorkplane()) {
Fix stupidity in the rotate ops; first of all it was saving the axis of rotation numerically, so that the associative thing breaks, and then it also wasn't saving the point on the axis in the file, so that snapped back to (0, 0, 0) on reload. Now it goes off the hEntity for a point on the axis and a vector in its direction. [git-p4: depot-paths = "//depot/solvespace/": change = 1790]
2008-06-13 05:32:55 +00:00
g.predef.origin = gs.point[0];
A monster change; move the parameter, entity, group, and constraint tables from SolveSpace to their own class. This is intended to simplify use of the constraint solver in a library. [git-p4: depot-paths = "//depot/solvespace/": change = 1942]
2009-04-19 05:53:16 +00:00
Entity *w = SK.GetEntity(SS.GW.ActiveWorkplane());
Fix stupidity in the rotate ops; first of all it was saving the axis of rotation numerically, so that the associative thing breaks, and then it also wasn't saving the point on the axis in the file, so that snapped back to (0, 0, 0) on reload. Now it goes off the hEntity for a point on the axis and a vector in its direction. [git-p4: depot-paths = "//depot/solvespace/": change = 1790]
2008-06-13 05:32:55 +00:00
g.predef.entityB = w->Normal()->h;
Add an axis-angle transformation (rotation about an arbitrary point), and use that to implement step and repeat rotating. [git-p4: depot-paths = "//depot/solvespace/": change = 1762]
2008-06-01 08:29:59 +00:00
g.activeWorkplane = w->h;
} else if(gs.points == 1 && gs.vectors == 1 && gs.n == 2) {
Fix stupidity in the rotate ops; first of all it was saving the axis of rotation numerically, so that the associative thing breaks, and then it also wasn't saving the point on the axis in the file, so that snapped back to (0, 0, 0) on reload. Now it goes off the hEntity for a point on the axis and a vector in its direction. [git-p4: depot-paths = "//depot/solvespace/": change = 1790]
2008-06-13 05:32:55 +00:00
g.predef.origin = gs.point[0];
g.predef.entityB = gs.vector[0];
Add an axis-angle transformation (rotation about an arbitrary point), and use that to implement step and repeat rotating. [git-p4: depot-paths = "//depot/solvespace/": change = 1762]
2008-06-01 08:29:59 +00:00
} else {
Better error messages when creating groups, too. [git-p4: depot-paths = "//depot/solvespace/": change = 1840]
2008-07-14 05:20:55 +00:00
Error("Bad selection for new rotation. This group can "
Edit Message() and Error() strings to use just \n, not \r\n, since my own dialog boxes don't require the carriage returns. [git-p4: depot-paths = "//depot/solvespace/": change = 2109]
2010-01-16 18:15:40 +00:00
"be created with:\n\n"
Better error messages when creating groups, too. [git-p4: depot-paths = "//depot/solvespace/": change = 1840]
2008-07-14 05:20:55 +00:00
" * a point, while locked in workplane (rotate "
Edit Message() and Error() strings to use just \n, not \r\n, since my own dialog boxes don't require the carriage returns. [git-p4: depot-paths = "//depot/solvespace/": change = 2109]
2010-01-16 18:15:40 +00:00
"in plane, about that point)\n"
Better error messages when creating groups, too. [git-p4: depot-paths = "//depot/solvespace/": change = 1840]
2008-07-14 05:20:55 +00:00
" * a point and a line or a normal (rotate about "
"an axis through the point, and parallel to "
Edit Message() and Error() strings to use just \n, not \r\n, since my own dialog boxes don't require the carriage returns. [git-p4: depot-paths = "//depot/solvespace/": change = 2109]
2010-01-16 18:15:40 +00:00
"line / normal)\n");
Add an axis-angle transformation (rotation about an arbitrary point), and use that to implement step and repeat rotating. [git-p4: depot-paths = "//depot/solvespace/": change = 1762]
2008-06-01 08:29:59 +00:00
return;
}
Add transformed points and normals with a rotation (as well as a 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]
2008-05-11 06:09:46 +00:00
g.type = ROTATE;
g.opA = SS.GW.activeGroup;
Don't keep a dimension or group's user-entered numerical value as an Expr *, since that complicates multiple units and also memory management. Now it's just a double. [git-p4: depot-paths = "//depot/solvespace/": change = 1791]
2008-06-14 08:43:38 +00:00
g.valA = 3;
Add step and repeat translate, with multiple copies; that all works 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]
2008-05-27 06:36:59 +00:00
g.subtype = ONE_SIDED;
Add transformed points and normals with a rotation (as well as a 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]
2008-05-11 06:09:46 +00:00
g.name.strcpy("rotate");
break;
Add an axis-angle transformation (rotation about an arbitrary point), and use that to implement step and repeat rotating. [git-p4: depot-paths = "//depot/solvespace/": change = 1762]
2008-06-01 08:29:59 +00:00
}
Add transformed points and normals with a rotation (as well as a 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]
2008-05-11 06:09:46 +00:00
Add step and repeat translate, with multiple copies; that all works 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]
2008-05-27 06:36:59 +00:00
case GraphicsWindow::MNU_GROUP_TRANS:
g.type = TRANSLATE;
g.opA = SS.GW.activeGroup;
Don't keep a dimension or group's user-entered numerical value as an Expr *, since that complicates multiple units and also memory management. Now it's just a double. [git-p4: depot-paths = "//depot/solvespace/": change = 1791]
2008-06-14 08:43:38 +00:00
g.valA = 3;
Add step and repeat translate, with multiple copies; that all works 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]
2008-05-27 06:36:59 +00:00
g.subtype = ONE_SIDED;
Bits and pieces; option to not include original in step translates and rotates, auto-constrain translates in active workplane, speed up remap list search with a hash table, other stuff. [git-p4: depot-paths = "//depot/solvespace/": change = 1786]
2008-06-12 04:36:33 +00:00
g.predef.entityB = SS.GW.ActiveWorkplane();
g.activeWorkplane = SS.GW.ActiveWorkplane();
Add step and repeat translate, with multiple copies; that all works 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]
2008-05-27 06:36:59 +00:00
g.name.strcpy("translate");
break;
Initial work on the assembly (`import') feature. I can import a 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]
2008-05-29 10:10:12 +00:00
case GraphicsWindow::MNU_GROUP_IMPORT: {
g.type = IMPORTED;
g.opA = SS.GW.activeGroup;
if(strlen(g.impFile) == 0) {
if(!GetOpenFile(g.impFile, SLVS_EXT, SLVS_PATTERN)) return;
}
g.name.strcpy("import");
Add code to assemble two shells into one, without checking for any intersections or otherwise trying to make the result not self-intersecting. [git-p4: depot-paths = "//depot/solvespace/": change = 1955]
2009-05-20 03:04:36 +00:00
g.meshCombine = COMBINE_AS_ASSEMBLE;
Initial work on the assembly (`import') feature. I can import a 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]
2008-05-29 10:10:12 +00:00
break;
}
Add the first `derived' group, that generates entities based on 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]
2008-04-27 09:03:01 +00:00
default: oops();
}
Add TrueType font support to SolveSpace. This uses a modified version of the code from SketchFlat, with all arbitrary limits removed. The TTF text is its own entity, and that entity includes the font file basename and the text. That's an extra 128 bytes in the entity, which is around a 50% increase, kind of a shame. It was simple, though. [git-p4: depot-paths = "//depot/solvespace/": change = 1814]
2008-06-30 09:09:17 +00:00
SS.GW.ClearSelection();
Add undo/redo. This saves the param guesses, constraints, groups, and requests to a separate list. It's messy, because I have to make a deep copy (e.g. of the remap list for the groups, or Expr * stuff) of some things. Others (e.g. the polygon or mesh) will be regenerated, so they should be discarded, but they must not get double-freed. In any case, works superficially. And fix a few memory leaks unrelated to this, and remove some dead code. [git-p4: depot-paths = "//depot/solvespace/": change = 1775]
2008-06-04 10:22:30 +00:00
SS.UndoRemember();
Add TrueType font support to SolveSpace. This uses a modified version of the code from SketchFlat, with all arbitrary limits removed. The TTF text is its own entity, and that entity includes the font file basename and the text. That's an extra 128 bytes in the entity, which is around a 50% increase, kind of a shame. It was simple, though. [git-p4: depot-paths = "//depot/solvespace/": change = 1814]
2008-06-30 09:09:17 +00:00
A monster change; move the parameter, entity, group, and constraint tables from SolveSpace to their own class. This is intended to simplify use of the constraint solver in a library. [git-p4: depot-paths = "//depot/solvespace/": change = 1942]
2009-04-19 05:53:16 +00:00
SK.group.AddAndAssignId(&g);
Group *gg = SK.GetGroup(g.h);
Add preliminary lathe (solid of revolution) support. I'm generating just the mesh, no derived entities (but I suppose that I could turn all points into circles). And fix some bugs where equations didn't get unique IDs, and make it possible to lock on to the group's workplane automatically, if you press W while free in 3d with no workplane selected. [git-p4: depot-paths = "//depot/solvespace/": change = 1780]
2008-06-06 11:35:28 +00:00
if(gg->type == IMPORTED) {
Initial work on the assembly (`import') feature. I can import a 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]
2008-05-29 10:10:12 +00:00
SS.ReloadAllImported();
}
Add preliminary lathe (solid of revolution) support. I'm generating just the mesh, no derived entities (but I suppose that I could turn all points into circles). And fix some bugs where equations didn't get unique IDs, and make it possible to lock on to the group's workplane automatically, if you press W while free in 3d with no workplane selected. [git-p4: depot-paths = "//depot/solvespace/": change = 1780]
2008-06-06 11:35:28 +00:00
gg->clean = false;
SS.GW.activeGroup = gg->h;
Consolidate the code that determines whether an entity is visible 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]
2008-06-02 09:31:26 +00:00
SS.GenerateAll();
Add preliminary lathe (solid of revolution) support. I'm generating just the mesh, no derived entities (but I suppose that I could turn all points into circles). And fix some bugs where equations didn't get unique IDs, and make it possible to lock on to the group's workplane automatically, if you press W while free in 3d with no workplane selected. [git-p4: depot-paths = "//depot/solvespace/": change = 1780]
2008-06-06 11:35:28 +00:00
if(gg->type == DRAWING_WORKPLANE) {
Add TrueType font support to SolveSpace. This uses a modified version of the code from SketchFlat, with all arbitrary limits removed. The TTF text is its own entity, and that entity includes the font file basename and the text. That's an extra 128 bytes in the entity, which is around a 50% increase, kind of a shame. It was simple, though. [git-p4: depot-paths = "//depot/solvespace/": change = 1814]
2008-06-30 09:09:17 +00:00
// Can't set the active workplane for this one until after we've
// regenerated, because the workplane doesn't exist until then.
Add preliminary lathe (solid of revolution) support. I'm generating just the mesh, no derived entities (but I suppose that I could turn all points into circles). And fix some bugs where equations didn't get unique IDs, and make it possible to lock on to the group's workplane automatically, if you press W while free in 3d with no workplane selected. [git-p4: depot-paths = "//depot/solvespace/": change = 1780]
2008-06-06 11:35:28 +00:00
gg->activeWorkplane = gg->h.entity(0);
Find a memory corruption! I was getting a pointer into the entity list, and then adding a new entity to that list, and then looking at that pointer again. Not okay; the add operation might have forced a realloc. I have to watch for that. And add a "distance ratio" constraint, plus a new kind of group that comes with its own workplane. The workplane is not solved for; it's generated explicitly in terms of elements that are already solved. [git-p4: depot-paths = "//depot/solvespace/": change = 1716]
2008-05-11 10:40:37 +00:00
}
Add preliminary lathe (solid of revolution) support. I'm generating just the mesh, no derived entities (but I suppose that I could turn all points into circles). And fix some bugs where equations didn't get unique IDs, and make it possible to lock on to the group's workplane automatically, if you press W while free in 3d with no workplane selected. [git-p4: depot-paths = "//depot/solvespace/": change = 1780]
2008-06-06 11:35:28 +00:00
gg->Activate();
Change the workplanes a bit. Now the active workplane is per group, so e.g. a new extrude starts in free space, which is likely what you want. And default to an in-workplane group, and tweak the display of workplanes. [git-p4: depot-paths = "//depot/solvespace/": change = 1748]
2008-05-27 02:22:20 +00:00
SS.GW.AnimateOntoWorkplane();
Add preliminary lathe (solid of revolution) support. I'm generating just the mesh, no derived entities (but I suppose that I could turn all points into circles). And fix some bugs where equations didn't get unique IDs, and make it possible to lock on to the group's workplane automatically, if you press W while free in 3d with no workplane selected. [git-p4: depot-paths = "//depot/solvespace/": change = 1780]
2008-06-06 11:35:28 +00:00
TextWindow::ScreenSelectGroup(0, gg->h.v);
Improve convergence of constraints involving parallel vectors, by 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]
2008-06-03 18:28:41 +00:00
SS.later.showTW = true;
Add the first `derived' group, that generates entities based on 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]
2008-04-27 09:03:01 +00:00
}
Add support for the 3dconnexion six degree of freedom input devices (in my case, a SpaceNavigator). I can transform the view of the part, or transform a part in an assembly. Also fix up mouse wheel input, so that it works even if it comes in chunks of less than 120 units. [git-p4: depot-paths = "//depot/solvespace/": change = 2019]
2009-07-20 19:05:33 +00:00
void Group::TransformImportedBy(Vector t, Quaternion q) {
if(type != IMPORTED) oops();
hParam tx, ty, tz, qw, qx, qy, qz;
tx = h.param(0);
ty = h.param(1);
tz = h.param(2);
qw = h.param(3);
qx = h.param(4);
qy = h.param(5);
qz = h.param(6);
Quaternion qg = Quaternion::From(qw, qx, qy, qz);
qg = q.Times(qg);
Vector tg = Vector::From(tx, ty, tz);
tg = tg.Plus(t);
SK.GetParam(tx)->val = tg.x;
SK.GetParam(ty)->val = tg.y;
SK.GetParam(tz)->val = tg.z;
SK.GetParam(qw)->val = qg.w;
SK.GetParam(qx)->val = qg.vx;
SK.GetParam(qy)->val = qg.vy;
SK.GetParam(qz)->val = qg.vz;
}
Get rid of the command line from the text window; we'll say that's just for display, and any text entry will happen via some floating text box, same as entering a dimension on the sketch. Add the hover and selection mechanism, which now seems to work. Still not clear how to do imported parts, for assemblies and hierarchy. The handle formats may still have to change. [git-p4: depot-paths = "//depot/solvespace/": change = 1662]
2008-04-12 14:12:26 +00:00
char *Group::DescriptionString(void) {
static char ret[100];
if(name.str[0]) {
Tear apart the text window, mostly to beautify things. The foreground and background colours are now specified separately, and it's possible to insert half-line spaces. So now I have a window that lets me show/hide groups, and select the active one. [git-p4: depot-paths = "//depot/solvespace/": change = 1695]
2008-04-28 07:18:39 +00:00
sprintf(ret, "g%03x-%s", h.v, name.str);
Get rid of the command line from the text window; we'll say that's just for display, and any text entry will happen via some floating text box, same as entering a dimension on the sketch. Add the hover and selection mechanism, which now seems to work. Still not clear how to do imported parts, for assemblies and hierarchy. The handle formats may still have to change. [git-p4: depot-paths = "//depot/solvespace/": change = 1662]
2008-04-12 14:12:26 +00:00
} else {
Tear apart the text window, mostly to beautify things. The foreground and background colours are now specified separately, and it's possible to insert half-line spaces. So now I have a window that lets me show/hide groups, and select the active one. [git-p4: depot-paths = "//depot/solvespace/": change = 1695]
2008-04-28 07:18:39 +00:00
sprintf(ret, "g%03x-(unnamed)", h.v);
Get rid of the command line from the text window; we'll say that's just for display, and any text entry will happen via some floating text box, same as entering a dimension on the sketch. Add the hover and selection mechanism, which now seems to work. Still not clear how to do imported parts, for assemblies and hierarchy. The handle formats may still have to change. [git-p4: depot-paths = "//depot/solvespace/": change = 1662]
2008-04-12 14:12:26 +00:00
}
return ret;
}
Stipple the selected/hovered faces, instead of drawing them in solid red or yellow. And add user interface to `hide' the faces (i.e., to make them unselectable), defaulting to hidden in everything except extrudes or imports. [git-p4: depot-paths = "//depot/solvespace/": change = 1768]
2008-06-02 05:38:12 +00:00
void Group::Activate(void) {
if(type == EXTRUDE || type == IMPORTED) {
SS.GW.showFaces = true;
} else {
SS.GW.showFaces = false;
}
We now have selective solve; a group (and all the groups afterward) 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]
2008-06-02 11:43:27 +00:00
SS.MarkGroupDirty(h); // for good measure; shouldn't be needed
Improve convergence of constraints involving parallel vectors, by 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]
2008-06-03 18:28:41 +00:00
SS.later.generateAll = true;
SS.later.showTW = true;
Stipple the selected/hovered faces, instead of drawing them in solid red or yellow. And add user interface to `hide' the faces (i.e., to make them unselectable), defaulting to hidden in everything except extrudes or imports. [git-p4: depot-paths = "//depot/solvespace/": change = 1768]
2008-06-02 05:38:12 +00:00
}
Add the first `derived' group, that generates entities based on 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]
2008-04-27 09:03:01 +00:00
void Group::Generate(IdList<Entity,hEntity> *entity,
IdList<Param,hParam> *param)
{
Add a convenience command to draw a rectangle (as four line segments), add the toggle construction command, and color the lines differently depending on what group you're in. Also change dynamic memory stuff to use a Win32 heap for everything (no malloc), and validate that often. I think I've seen it crash, though I can't reproduce it. [git-p4: depot-paths = "//depot/solvespace/": change = 1708]
2008-05-07 04:17:29 +00:00
Vector gn = (SS.GW.projRight).Cross(SS.GW.projUp);
Add step and repeat translate, with multiple copies; that all works 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]
2008-05-27 06:36:59 +00:00
Vector gp = SS.GW.projRight.Plus(SS.GW.projUp);
Add an axis-angle transformation (rotation about an arbitrary point), and use that to implement step and repeat rotating. [git-p4: depot-paths = "//depot/solvespace/": change = 1762]
2008-06-01 08:29:59 +00:00
Vector gc = (SS.GW.offset).ScaledBy(-1);
Add a convenience command to draw a rectangle (as four line segments), add the toggle construction command, and color the lines differently depending on what group you're in. Also change dynamic memory stuff to use a Win32 heap for everything (no malloc), and validate that often. I think I've seen it crash, though I can't reproduce it. [git-p4: depot-paths = "//depot/solvespace/": change = 1708]
2008-05-07 04:17:29 +00:00
gn = gn.WithMagnitude(200/SS.GW.scale);
Add step and repeat translate, with multiple copies; that all works 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]
2008-05-27 06:36:59 +00:00
gp = gp.WithMagnitude(200/SS.GW.scale);
int a, i;
Add the first `derived' group, that generates entities based on 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]
2008-04-27 09:03:01 +00:00
switch(type) {
Find a memory corruption! I was getting a pointer into the entity list, and then adding a new entity to that list, and then looking at that pointer again. Not okay; the add operation might have forced a realloc. I have to watch for that. And add a "distance ratio" constraint, plus a new kind of group that comes with its own workplane. The workplane is not solved for; it's generated explicitly in terms of elements that are already solved. [git-p4: depot-paths = "//depot/solvespace/": change = 1716]
2008-05-11 10:40:37 +00:00
case DRAWING_3D:
break;
case DRAWING_WORKPLANE: {
Quaternion q;
Add double-sided extrudes, and user interface for that. Also put the coordinate system (x, y, z normal vectors) in the bottom left corner of the screen at all times, and hide group-created workplanes except when that group is active, and activate that workplane when the group is activated. [git-p4: depot-paths = "//depot/solvespace/": change = 1726]
2008-05-17 08:02:39 +00:00
if(subtype == WORKPLANE_BY_LINE_SEGMENTS) {
A monster change; move the parameter, entity, group, and constraint tables from SolveSpace to their own class. This is intended to simplify use of the constraint solver in a library. [git-p4: depot-paths = "//depot/solvespace/": change = 1942]
2009-04-19 05:53:16 +00:00
Vector u = SK.GetEntity(predef.entityB)->VectorGetNum();
Vector v = SK.GetEntity(predef.entityC)->VectorGetNum();
Find a memory corruption! I was getting a pointer into the entity list, and then adding a new entity to that list, and then looking at that pointer again. Not okay; the add operation might have forced a realloc. I have to watch for that. And add a "distance ratio" constraint, plus a new kind of group that comes with its own workplane. The workplane is not solved for; it's generated explicitly in terms of elements that are already solved. [git-p4: depot-paths = "//depot/solvespace/": change = 1716]
2008-05-11 10:40:37 +00:00
u = u.WithMagnitude(1);
Vector n = u.Cross(v);
v = (n.Cross(u)).WithMagnitude(1);
Add an axis-angle transformation (rotation about an arbitrary point), and use that to implement step and repeat rotating. [git-p4: depot-paths = "//depot/solvespace/": change = 1762]
2008-06-01 08:29:59 +00:00
if(predef.swapUV) SWAP(Vector, u, v);
if(predef.negateU) u = u.ScaledBy(-1);
if(predef.negateV) v = v.ScaledBy(-1);
Standardize naming of FromXxx (and XxxFrom) static methods to 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]
2008-06-01 08:45:11 +00:00
q = Quaternion::From(u, v);
Add double-sided extrudes, and user interface for that. Also put the coordinate system (x, y, z normal vectors) in the bottom left corner of the screen at all times, and hide group-created workplanes except when that group is active, and activate that workplane when the group is activated. [git-p4: depot-paths = "//depot/solvespace/": change = 1726]
2008-05-17 08:02:39 +00:00
} else if(subtype == WORKPLANE_BY_POINT_ORTHO) {
Find a memory corruption! I was getting a pointer into the entity list, and then adding a new entity to that list, and then looking at that pointer again. Not okay; the add operation might have forced a realloc. I have to watch for that. And add a "distance ratio" constraint, plus a new kind of group that comes with its own workplane. The workplane is not solved for; it's generated explicitly in terms of elements that are already solved. [git-p4: depot-paths = "//depot/solvespace/": change = 1716]
2008-05-11 10:40:37 +00:00
// Already given, numerically.
Add an axis-angle transformation (rotation about an arbitrary point), and use that to implement step and repeat rotating. [git-p4: depot-paths = "//depot/solvespace/": change = 1762]
2008-06-01 08:29:59 +00:00
q = predef.q;
Find a memory corruption! I was getting a pointer into the entity list, and then adding a new entity to that list, and then looking at that pointer again. Not okay; the add operation might have forced a realloc. I have to watch for that. And add a "distance ratio" constraint, plus a new kind of group that comes with its own workplane. The workplane is not solved for; it's generated explicitly in terms of elements that are already solved. [git-p4: depot-paths = "//depot/solvespace/": change = 1716]
2008-05-11 10:40:37 +00:00
} else oops();
Entity normal;
memset(&normal, 0, sizeof(normal));
normal.type = Entity::NORMAL_N_COPY;
normal.numNormal = q;
normal.point[0] = h.entity(2);
normal.group = h;
normal.h = h.entity(1);
entity->Add(&normal);
Entity point;
memset(&point, 0, sizeof(point));
point.type = Entity::POINT_N_COPY;
A monster change; move the parameter, entity, group, and constraint tables from SolveSpace to their own class. This is intended to simplify use of the constraint solver in a library. [git-p4: depot-paths = "//depot/solvespace/": change = 1942]
2009-04-19 05:53:16 +00:00
point.numPoint = SK.GetEntity(predef.origin)->PointGetNum();
Find a memory corruption! I was getting a pointer into the entity list, and then adding a new entity to that list, and then looking at that pointer again. Not okay; the add operation might have forced a realloc. I have to watch for that. And add a "distance ratio" constraint, plus a new kind of group that comes with its own workplane. The workplane is not solved for; it's generated explicitly in terms of elements that are already solved. [git-p4: depot-paths = "//depot/solvespace/": change = 1716]
2008-05-11 10:40:37 +00:00
point.group = h;
point.h = h.entity(2);
entity->Add(&point);
Entity wp;
memset(&wp, 0, sizeof(wp));
wp.type = Entity::WORKPLANE;
wp.normal = normal.h;
wp.point[0] = point.h;
wp.group = h;
wp.h = h.entity(0);
entity->Add(&wp);
break;
}
Add the first `derived' group, that generates entities based on 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]
2008-04-27 09:03:01 +00:00
Add selectable faces, by associating an hEntity with the triangle's metadata. And add point-on-face constraints to go with that. Still needs some cleanup for the user interface. [git-p4: depot-paths = "//depot/solvespace/": change = 1766]
2008-06-02 03:31:37 +00:00
case EXTRUDE: {
Add a convenience command to draw a rectangle (as four line segments), add the toggle construction command, and color the lines differently depending on what group you're in. Also change dynamic memory stuff to use a Win32 heap for everything (no malloc), and validate that often. I think I've seen it crash, though I can't reproduce it. [git-p4: depot-paths = "//depot/solvespace/": change = 1708]
2008-05-07 04:17:29 +00:00
AddParam(param, h.param(0), gn.x);
AddParam(param, h.param(1), gn.y);
AddParam(param, h.param(2), gn.z);
Add double-sided extrudes, and user interface for that. Also put the coordinate system (x, y, z normal vectors) in the bottom left corner of the screen at all times, and hide group-created workplanes except when that group is active, and activate that workplane when the group is activated. [git-p4: depot-paths = "//depot/solvespace/": change = 1726]
2008-05-17 08:02:39 +00:00
int ai, af;
Add step and repeat translate, with multiple copies; that all works 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]
2008-05-27 06:36:59 +00:00
if(subtype == ONE_SIDED) {
ai = 0; af = 2;
} else if(subtype == TWO_SIDED) {
Add double-sided extrudes, and user interface for that. Also put the coordinate system (x, y, z normal vectors) in the bottom left corner of the screen at all times, and hide group-created workplanes except when that group is active, and activate that workplane when the group is activated. [git-p4: depot-paths = "//depot/solvespace/": change = 1726]
2008-05-17 08:02:39 +00:00
ai = -1; af = 1;
} else oops();
Add selectable faces, by associating an hEntity with the triangle's metadata. And add point-on-face constraints to go with that. Still needs some cleanup for the user interface. [git-p4: depot-paths = "//depot/solvespace/": change = 1766]
2008-06-02 03:31:37 +00:00
// Get some arbitrary point in the sketch, that will be used
// as a reference when defining top and bottom faces.
hEntity pt = { 0 };
Add the first `derived' group, that generates entities based on 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]
2008-04-27 09:03:01 +00:00
for(i = 0; i < entity->n; i++) {
Entity *e = &(entity->elem[i]);
if(e->group.v != opA.v) continue;
Add selectable faces, by associating an hEntity with the triangle's metadata. And add point-on-face constraints to go with that. Still needs some cleanup for the user interface. [git-p4: depot-paths = "//depot/solvespace/": change = 1766]
2008-06-02 03:31:37 +00:00
if(e->IsPoint()) pt = e->h;
Treatment of numerical faces was screwy, exporting stuff in numXXX. So fix that, and now I can simplify what's exported for an entity. And add an extra measurement (face-face distance/angle), and some other little stuff. [git-p4: depot-paths = "//depot/solvespace/": change = 1789]
2008-06-13 04:41:27 +00:00
e->CalculateNumerical(false);
Add double-sided extrudes, and user interface for that. Also put the coordinate system (x, y, z normal vectors) in the bottom left corner of the screen at all times, and hide group-created workplanes except when that group is active, and activate that workplane when the group is activated. [git-p4: depot-paths = "//depot/solvespace/": change = 1726]
2008-05-17 08:02:39 +00:00
hEntity he = e->h; e = NULL;
// As soon as I call CopyEntity, e may become invalid! That
// adds entities, which may cause a realloc.
A monster change; move the parameter, entity, group, and constraint tables from SolveSpace to their own class. This is intended to simplify use of the constraint solver in a library. [git-p4: depot-paths = "//depot/solvespace/": change = 1942]
2009-04-19 05:53:16 +00:00
CopyEntity(entity, SK.GetEntity(he), ai, REMAP_BOTTOM,
Add transformed points and normals with a rotation (as well as a 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]
2008-05-11 06:09:46 +00:00
h.param(0), h.param(1), h.param(2),
NO_PARAM, NO_PARAM, NO_PARAM, NO_PARAM,
Add an axis-angle transformation (rotation about an arbitrary point), and use that to implement step and repeat rotating. [git-p4: depot-paths = "//depot/solvespace/": change = 1762]
2008-06-01 08:29:59 +00:00
true, false);
A monster change; move the parameter, entity, group, and constraint tables from SolveSpace to their own class. This is intended to simplify use of the constraint solver in a library. [git-p4: depot-paths = "//depot/solvespace/": change = 1942]
2009-04-19 05:53:16 +00:00
CopyEntity(entity, SK.GetEntity(he), af, REMAP_TOP,
Add double-sided extrudes, and user interface for that. Also put the coordinate system (x, y, z normal vectors) in the bottom left corner of the screen at all times, and hide group-created workplanes except when that group is active, and activate that workplane when the group is activated. [git-p4: depot-paths = "//depot/solvespace/": change = 1726]
2008-05-17 08:02:39 +00:00
h.param(0), h.param(1), h.param(2),
NO_PARAM, NO_PARAM, NO_PARAM, NO_PARAM,
Add an axis-angle transformation (rotation about an arbitrary point), and use that to implement step and repeat rotating. [git-p4: depot-paths = "//depot/solvespace/": change = 1762]
2008-06-01 08:29:59 +00:00
true, false);
Major speedups, mostly by playing nicer with OpenGL; batch things up more. Also change from stupid linear search lists to sorted binary search lists, remove a stupid bug where I double-generated entities, and don't do the triple drawing of entities (since offsets on the Z buffer were doing the same job already). [git-p4: depot-paths = "//depot/solvespace/": change = 1776]
2008-06-06 07:50:08 +00:00
MakeExtrusionLines(entity, he);
Add transformed points and normals with a rotation (as well as a 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]
2008-05-11 06:09:46 +00:00
}
Add selectable faces, by associating an hEntity with the triangle's metadata. And add point-on-face constraints to go with that. Still needs some cleanup for the user interface. [git-p4: depot-paths = "//depot/solvespace/": change = 1766]
2008-06-02 03:31:37 +00:00
// Remapped versions of that arbitrary point will be used to
// provide points on the plane faces.
Major speedups, mostly by playing nicer with OpenGL; batch things up more. Also change from stupid linear search lists to sorted binary search lists, remove a stupid bug where I double-generated entities, and don't do the triple drawing of entities (since offsets on the Z buffer were doing the same job already). [git-p4: depot-paths = "//depot/solvespace/": change = 1776]
2008-06-06 07:50:08 +00:00
MakeExtrusionTopBottomFaces(entity, pt);
Add transformed points and normals with a rotation (as well as a 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]
2008-05-11 06:09:46 +00:00
break;
Add selectable faces, by associating an hEntity with the triangle's metadata. And add point-on-face constraints to go with that. Still needs some cleanup for the user interface. [git-p4: depot-paths = "//depot/solvespace/": change = 1766]
2008-06-02 03:31:37 +00:00
}
Add transformed points and normals with a rotation (as well as a 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]
2008-05-11 06:09:46 +00:00
Add preliminary lathe (solid of revolution) support. I'm generating just the mesh, no derived entities (but I suppose that I could turn all points into circles). And fix some bugs where equations didn't get unique IDs, and make it possible to lock on to the group's workplane automatically, if you press W while free in 3d with no workplane selected. [git-p4: depot-paths = "//depot/solvespace/": change = 1780]
2008-06-06 11:35:28 +00:00
case LATHE: {
break;
}
Add sweeps. The user specifies a trajectory and a section, in two 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]
2008-06-21 10:18:20 +00:00
case SWEEP: {
break;
}
Add helical sweeps. These aren't as parametric as I would have liked, but my more parametric attempts were very difficult to use. The pitch (both axial and radial) gets specified by typing a distance in a textbox. [git-p4: depot-paths = "//depot/solvespace/": change = 1804]
2008-06-23 08:25:17 +00:00
case HELICAL_SWEEP: {
break;
}
Add step and repeat translate, with multiple copies; that all works 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]
2008-05-27 06:36:59 +00:00
case TRANSLATE: {
// The translation vector
AddParam(param, h.param(0), gp.x);
AddParam(param, h.param(1), gp.y);
AddParam(param, h.param(2), gp.z);
Don't keep a dimension or group's user-entered numerical value as an Expr *, since that complicates multiple units and also memory management. Now it's just a double. [git-p4: depot-paths = "//depot/solvespace/": change = 1791]
2008-06-14 08:43:38 +00:00
int n = (int)valA, a0 = 0;
Bits and pieces; option to not include original in step translates and rotates, auto-constrain translates in active workplane, speed up remap list search with a hash table, other stuff. [git-p4: depot-paths = "//depot/solvespace/": change = 1786]
2008-06-12 04:36:33 +00:00
if(subtype == ONE_SIDED && skipFirst) {
a0++; n++;
}
for(a = a0; a < n; a++) {
Add step and repeat translate, with multiple copies; that all works 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]
2008-05-27 06:36:59 +00:00
for(i = 0; i < entity->n; i++) {
Entity *e = &(entity->elem[i]);
if(e->group.v != opA.v) continue;
Treatment of numerical faces was screwy, exporting stuff in numXXX. So fix that, and now I can simplify what's exported for an entity. And add an extra measurement (face-face distance/angle), and some other little stuff. [git-p4: depot-paths = "//depot/solvespace/": change = 1789]
2008-06-13 04:41:27 +00:00
e->CalculateNumerical(false);
Major speedups, mostly by playing nicer with OpenGL; batch things up more. Also change from stupid linear search lists to sorted binary search lists, remove a stupid bug where I double-generated entities, and don't do the triple drawing of entities (since offsets on the Z buffer were doing the same job already). [git-p4: depot-paths = "//depot/solvespace/": change = 1776]
2008-06-06 07:50:08 +00:00
CopyEntity(entity, e,
Add an axis-angle transformation (rotation about an arbitrary point), and use that to implement step and repeat rotating. [git-p4: depot-paths = "//depot/solvespace/": change = 1762]
2008-06-01 08:29:59 +00:00
a*2 - (subtype == ONE_SIDED ? 0 : (n-1)),
(a == (n - 1)) ? REMAP_LAST : a,
Add step and repeat translate, with multiple copies; that all works 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]
2008-05-27 06:36:59 +00:00
h.param(0), h.param(1), h.param(2),
NO_PARAM, NO_PARAM, NO_PARAM, NO_PARAM,
Add an axis-angle transformation (rotation about an arbitrary point), and use that to implement step and repeat rotating. [git-p4: depot-paths = "//depot/solvespace/": change = 1762]
2008-06-01 08:29:59 +00:00
true, false);
Add step and repeat translate, with multiple copies; that all works 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]
2008-05-27 06:36:59 +00:00
}
}
break;
}
Add an axis-angle transformation (rotation about an arbitrary point), and use that to implement step and repeat rotating. [git-p4: depot-paths = "//depot/solvespace/": change = 1762]
2008-06-01 08:29:59 +00:00
case ROTATE: {
// The center of rotation
AddParam(param, h.param(0), gc.x);
AddParam(param, h.param(1), gc.y);
AddParam(param, h.param(2), gc.z);
Add transformed points and normals with a rotation (as well as a 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]
2008-05-11 06:09:46 +00:00
// The rotation quaternion
Make rotations default to 360/n degrees (uniform about a circle) if no constraints set the rotation. [git-p4: depot-paths = "//depot/solvespace/": change = 1827]
2008-07-09 06:13:49 +00:00
AddParam(param, h.param(3), 30*PI/180);
Add an axis-angle transformation (rotation about an arbitrary point), and use that to implement step and repeat rotating. [git-p4: depot-paths = "//depot/solvespace/": change = 1762]
2008-06-01 08:29:59 +00:00
AddParam(param, h.param(4), gn.x);
AddParam(param, h.param(5), gn.y);
AddParam(param, h.param(6), gn.z);
Add transformed points and normals with a rotation (as well as a 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]
2008-05-11 06:09:46 +00:00
Don't keep a dimension or group's user-entered numerical value as an Expr *, since that complicates multiple units and also memory management. Now it's just a double. [git-p4: depot-paths = "//depot/solvespace/": change = 1791]
2008-06-14 08:43:38 +00:00
int n = (int)valA, a0 = 0;
Bits and pieces; option to not include original in step translates and rotates, auto-constrain translates in active workplane, speed up remap list search with a hash table, other stuff. [git-p4: depot-paths = "//depot/solvespace/": change = 1786]
2008-06-12 04:36:33 +00:00
if(subtype == ONE_SIDED && skipFirst) {
a0++; n++;
}
for(a = a0; a < n; a++) {
Add an axis-angle transformation (rotation about an arbitrary point), and use that to implement step and repeat rotating. [git-p4: depot-paths = "//depot/solvespace/": change = 1762]
2008-06-01 08:29:59 +00:00
for(i = 0; i < entity->n; i++) {
Entity *e = &(entity->elem[i]);
if(e->group.v != opA.v) continue;
Add transformed points and normals with a rotation (as well as a 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]
2008-05-11 06:09:46 +00:00
Treatment of numerical faces was screwy, exporting stuff in numXXX. So fix that, and now I can simplify what's exported for an entity. And add an extra measurement (face-face distance/angle), and some other little stuff. [git-p4: depot-paths = "//depot/solvespace/": change = 1789]
2008-06-13 04:41:27 +00:00
e->CalculateNumerical(false);
Major speedups, mostly by playing nicer with OpenGL; batch things up more. Also change from stupid linear search lists to sorted binary search lists, remove a stupid bug where I double-generated entities, and don't do the triple drawing of entities (since offsets on the Z buffer were doing the same job already). [git-p4: depot-paths = "//depot/solvespace/": change = 1776]
2008-06-06 07:50:08 +00:00
CopyEntity(entity, e,
Add an axis-angle transformation (rotation about an arbitrary point), and use that to implement step and repeat rotating. [git-p4: depot-paths = "//depot/solvespace/": change = 1762]
2008-06-01 08:29:59 +00:00
a*2 - (subtype == ONE_SIDED ? 0 : (n-1)),
(a == (n - 1)) ? REMAP_LAST : a,
h.param(0), h.param(1), h.param(2),
h.param(3), h.param(4), h.param(5), h.param(6),
false, true);
}
Initial work on the assembly (`import') feature. I can import a 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]
2008-05-29 10:10:12 +00:00
}
break;
Add an axis-angle transformation (rotation about an arbitrary point), and use that to implement step and repeat rotating. [git-p4: depot-paths = "//depot/solvespace/": change = 1762]
2008-06-01 08:29:59 +00:00
}
Initial work on the assembly (`import') feature. I can import a 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]
2008-05-29 10:10:12 +00:00
case IMPORTED:
// The translation vector
AddParam(param, h.param(0), gp.x);
AddParam(param, h.param(1), gp.y);
AddParam(param, h.param(2), gp.z);
// The rotation quaternion
AddParam(param, h.param(3), 1);
AddParam(param, h.param(4), 0);
AddParam(param, h.param(5), 0);
AddParam(param, h.param(6), 0);
for(i = 0; i < impEntity.n; i++) {
Entity *ie = &(impEntity.elem[i]);
Major speedups, mostly by playing nicer with OpenGL; batch things up more. Also change from stupid linear search lists to sorted binary search lists, remove a stupid bug where I double-generated entities, and don't do the triple drawing of entities (since offsets on the Z buffer were doing the same job already). [git-p4: depot-paths = "//depot/solvespace/": change = 1776]
2008-06-06 07:50:08 +00:00
CopyEntity(entity, ie, 0, 0,
Add transformed points and normals with a rotation (as well as a 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]
2008-05-11 06:09:46 +00:00
h.param(0), h.param(1), h.param(2),
h.param(3), h.param(4), h.param(5), h.param(6),
Add an axis-angle transformation (rotation about an arbitrary point), and use that to implement step and repeat rotating. [git-p4: depot-paths = "//depot/solvespace/": change = 1762]
2008-06-01 08:29:59 +00:00
false, false);
Add the first `derived' group, that generates entities based on 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]
2008-04-27 09:03:01 +00:00
}
break;
default: oops();
}
}
Add an axis-angle transformation (rotation about an arbitrary point), and use that to implement step and repeat rotating. [git-p4: depot-paths = "//depot/solvespace/": change = 1762]
2008-06-01 08:29:59 +00:00
void Group::AddEq(IdList<Equation,hEquation> *l, Expr *expr, int index) {
Equation eq;
eq.e = expr;
eq.h = h.equation(index);
l->Add(&eq);
}
Add transformed points and normals with a rotation (as well as a 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]
2008-05-11 06:09:46 +00:00
void Group::GenerateEquations(IdList<Equation,hEquation> *l) {
Fix point-on-circle constraints to work with arcs too, and lock extrudes normal to workplane if a workplane is active when the extrusion is created. [git-p4: depot-paths = "//depot/solvespace/": change = 1724]
2008-05-16 06:34:06 +00:00
Equation eq;
Add an axis-angle transformation (rotation about an arbitrary point), and use that to implement step and repeat rotating. [git-p4: depot-paths = "//depot/solvespace/": change = 1762]
2008-06-01 08:29:59 +00:00
ZERO(&eq);
if(type == IMPORTED) {
Add transformed points and normals with a rotation (as well as a 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]
2008-05-11 06:09:46 +00:00
// Normalize the quaternion
ExprQuaternion q = {
Standardize naming of FromXxx (and XxxFrom) static methods to 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]
2008-06-01 08:45:11 +00:00
Expr::From(h.param(3)),
Expr::From(h.param(4)),
Expr::From(h.param(5)),
Expr::From(h.param(6)) };
AddEq(l, (q.Magnitude())->Minus(Expr::From(1)), 0);
Add an axis-angle transformation (rotation about an arbitrary point), and use that to implement step and repeat rotating. [git-p4: depot-paths = "//depot/solvespace/": change = 1762]
2008-06-01 08:29:59 +00:00
} else if(type == ROTATE) {
// The axis and center of rotation are specified numerically
Standardize naming of FromXxx (and XxxFrom) static methods to 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]
2008-06-01 08:45:11 +00:00
#define EC(x) (Expr::From(x))
#define EP(x) (Expr::From(h.param(x)))
A monster change; move the parameter, entity, group, and constraint tables from SolveSpace to their own class. This is intended to simplify use of the constraint solver in a library. [git-p4: depot-paths = "//depot/solvespace/": change = 1942]
2009-04-19 05:53:16 +00:00
ExprVector orig = SK.GetEntity(predef.origin)->PointGetExprs();
Fix stupidity in the rotate ops; first of all it was saving the axis of rotation numerically, so that the associative thing breaks, and then it also wasn't saving the point on the axis in the file, so that snapped back to (0, 0, 0) on reload. Now it goes off the hEntity for a point on the axis and a vector in its direction. [git-p4: depot-paths = "//depot/solvespace/": change = 1790]
2008-06-13 05:32:55 +00:00
AddEq(l, (orig.x)->Minus(EP(0)), 0);
AddEq(l, (orig.y)->Minus(EP(1)), 1);
AddEq(l, (orig.z)->Minus(EP(2)), 2);
Add an axis-angle transformation (rotation about an arbitrary point), and use that to implement step and repeat rotating. [git-p4: depot-paths = "//depot/solvespace/": change = 1762]
2008-06-01 08:29:59 +00:00
// param 3 is the angle, which is free
A monster change; move the parameter, entity, group, and constraint tables from SolveSpace to their own class. This is intended to simplify use of the constraint solver in a library. [git-p4: depot-paths = "//depot/solvespace/": change = 1942]
2009-04-19 05:53:16 +00:00
Vector axis = SK.GetEntity(predef.entityB)->VectorGetNum();
Fix stupidity in the rotate ops; first of all it was saving the axis of rotation numerically, so that the associative thing breaks, and then it also wasn't saving the point on the axis in the file, so that snapped back to (0, 0, 0) on reload. Now it goes off the hEntity for a point on the axis and a vector in its direction. [git-p4: depot-paths = "//depot/solvespace/": change = 1790]
2008-06-13 05:32:55 +00:00
axis = axis.WithMagnitude(1);
AddEq(l, (EC(axis.x))->Minus(EP(4)), 3);
AddEq(l, (EC(axis.y))->Minus(EP(5)), 4);
AddEq(l, (EC(axis.z))->Minus(EP(6)), 5);
Fix point-on-circle constraints to work with arcs too, and lock extrudes normal to workplane if a workplane is active when the extrusion is created. [git-p4: depot-paths = "//depot/solvespace/": change = 1724]
2008-05-16 06:34:06 +00:00
} else if(type == EXTRUDE) {
Add an axis-angle transformation (rotation about an arbitrary point), and use that to implement step and repeat rotating. [git-p4: depot-paths = "//depot/solvespace/": change = 1762]
2008-06-01 08:29:59 +00:00
if(predef.entityB.v != Entity::FREE_IN_3D.v) {
Initial work on the assembly (`import') feature. I can import a 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]
2008-05-29 10:10:12 +00:00
// The extrusion path is locked along a line, normal to the
// specified workplane.
A monster change; move the parameter, entity, group, and constraint tables from SolveSpace to their own class. This is intended to simplify use of the constraint solver in a library. [git-p4: depot-paths = "//depot/solvespace/": change = 1942]
2009-04-19 05:53:16 +00:00
Entity *w = SK.GetEntity(predef.entityB);
Fix point-on-circle constraints to work with arcs too, and lock extrudes normal to workplane if a workplane is active when the extrusion is created. [git-p4: depot-paths = "//depot/solvespace/": change = 1724]
2008-05-16 06:34:06 +00:00
ExprVector u = w->Normal()->NormalExprsU();
ExprVector v = w->Normal()->NormalExprsV();
ExprVector extruden = {
Standardize naming of FromXxx (and XxxFrom) static methods to 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]
2008-06-01 08:45:11 +00:00
Expr::From(h.param(0)),
Expr::From(h.param(1)),
Expr::From(h.param(2)) };
Add an axis-angle transformation (rotation about an arbitrary point), and use that to implement step and repeat rotating. [git-p4: depot-paths = "//depot/solvespace/": change = 1762]
2008-06-01 08:29:59 +00:00
AddEq(l, u.Dot(extruden), 0);
AddEq(l, v.Dot(extruden), 1);
Fix point-on-circle constraints to work with arcs too, and lock extrudes normal to workplane if a workplane is active when the extrusion is created. [git-p4: depot-paths = "//depot/solvespace/": change = 1724]
2008-05-16 06:34:06 +00:00
}
Bits and pieces; option to not include original in step translates and rotates, auto-constrain translates in active workplane, speed up remap list search with a hash table, other stuff. [git-p4: depot-paths = "//depot/solvespace/": change = 1786]
2008-06-12 04:36:33 +00:00
} else if(type == TRANSLATE) {
if(predef.entityB.v != Entity::FREE_IN_3D.v) {
A monster change; move the parameter, entity, group, and constraint tables from SolveSpace to their own class. This is intended to simplify use of the constraint solver in a library. [git-p4: depot-paths = "//depot/solvespace/": change = 1942]
2009-04-19 05:53:16 +00:00
Entity *w = SK.GetEntity(predef.entityB);
Bits and pieces; option to not include original in step translates and rotates, auto-constrain translates in active workplane, speed up remap list search with a hash table, other stuff. [git-p4: depot-paths = "//depot/solvespace/": change = 1786]
2008-06-12 04:36:33 +00:00
ExprVector n = w->Normal()->NormalExprsN();
ExprVector trans;
trans = ExprVector::From(h.param(0), h.param(1), h.param(2));
// The translation vector is parallel to the workplane
AddEq(l, trans.Dot(n), 0);
}
Add transformed points and normals with a rotation (as well as a 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]
2008-05-11 06:09:46 +00:00
}
}
Add the first `derived' group, that generates entities based on 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]
2008-04-27 09:03:01 +00:00
hEntity Group::Remap(hEntity in, int copyNumber) {
Bits and pieces; option to not include original in step translates and rotates, auto-constrain translates in active workplane, speed up remap list search with a hash table, other stuff. [git-p4: depot-paths = "//depot/solvespace/": change = 1786]
2008-06-12 04:36:33 +00:00
// A hash table is used to accelerate the search
int hash = ((unsigned)(in.v*61 + copyNumber)) % REMAP_PRIME;
int i = remapCache[hash];
if(i >= 0 && i < remap.n) {
EntityMap *em = &(remap.elem[i]);
if(em->input.v == in.v && em->copyNumber == copyNumber) {
return h.entity(em->h.v);
}
}
// but if we don't find it in the hash table, then linear search
Add the first `derived' group, that generates entities based on 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]
2008-04-27 09:03:01 +00:00
for(i = 0; i < remap.n; i++) {
EntityMap *em = &(remap.elem[i]);
if(em->input.v == in.v && em->copyNumber == copyNumber) {
// We already have a mapping for this entity.
Bits and pieces; option to not include original in step translates and rotates, auto-constrain translates in active workplane, speed up remap list search with a hash table, other stuff. [git-p4: depot-paths = "//depot/solvespace/": change = 1786]
2008-06-12 04:36:33 +00:00
remapCache[hash] = i;
Add the first `derived' group, that generates entities based on 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]
2008-04-27 09:03:01 +00:00
return h.entity(em->h.v);
}
}
Bits and pieces; option to not include original in step translates and rotates, auto-constrain translates in active workplane, speed up remap list search with a hash table, other stuff. [git-p4: depot-paths = "//depot/solvespace/": change = 1786]
2008-06-12 04:36:33 +00:00
// And if we still don't find it, then create a new entry.
Add the first `derived' group, that generates entities based on 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]
2008-04-27 09:03:01 +00:00
EntityMap em;
em.input = in;
em.copyNumber = copyNumber;
remap.AddAndAssignId(&em);
return h.entity(em.h.v);
}
Major speedups, mostly by playing nicer with OpenGL; batch things up more. Also change from stupid linear search lists to sorted binary search lists, remove a stupid bug where I double-generated entities, and don't do the triple drawing of entities (since offsets on the Z buffer were doing the same job already). [git-p4: depot-paths = "//depot/solvespace/": change = 1776]
2008-06-06 07:50:08 +00:00
void Group::MakeExtrusionLines(IdList<Entity,hEntity> *el, hEntity in) {
A monster change; move the parameter, entity, group, and constraint tables from SolveSpace to their own class. This is intended to simplify use of the constraint solver in a library. [git-p4: depot-paths = "//depot/solvespace/": change = 1942]
2009-04-19 05:53:16 +00:00
Entity *ep = SK.GetEntity(in);
Add double-sided extrudes, and user interface for that. Also put the coordinate system (x, y, z normal vectors) in the bottom left corner of the screen at all times, and hide group-created workplanes except when that group is active, and activate that workplane when the group is activated. [git-p4: depot-paths = "//depot/solvespace/": change = 1726]
2008-05-17 08:02:39 +00:00
Entity en;
Add selectable faces, by associating an hEntity with the triangle's metadata. And add point-on-face constraints to go with that. Still needs some cleanup for the user interface. [git-p4: depot-paths = "//depot/solvespace/": change = 1766]
2008-06-02 03:31:37 +00:00
ZERO(&en);
if(ep->IsPoint()) {
// A point gets extruded to form a line segment
en.point[0] = Remap(ep->h, REMAP_TOP);
en.point[1] = Remap(ep->h, REMAP_BOTTOM);
en.group = h;
Now actually export the line styles, for PDF, EPS, and SVG file formats, with the proper color and width. This may need a bit of cleanup for stuff like the hidden line removal, which currently loses the style. Also fix a bug in the test for arcs of a circle. A second-order Bezier with collinear control points really is an arc, but it's an arc with infinite radius so stuff tends to blow up. So return false for that one. [git-p4: depot-paths = "//depot/solvespace/": change = 2030]
2009-09-22 05:46:30 +00:00
en.construction = ep->construction;
en.style = ep->style;
Add selectable faces, by associating an hEntity with the triangle's metadata. And add point-on-face constraints to go with that. Still needs some cleanup for the user interface. [git-p4: depot-paths = "//depot/solvespace/": change = 1766]
2008-06-02 03:31:37 +00:00
en.h = Remap(ep->h, REMAP_PT_TO_LINE);
en.type = Entity::LINE_SEGMENT;
Major speedups, mostly by playing nicer with OpenGL; batch things up more. Also change from stupid linear search lists to sorted binary search lists, remove a stupid bug where I double-generated entities, and don't do the triple drawing of entities (since offsets on the Z buffer were doing the same job already). [git-p4: depot-paths = "//depot/solvespace/": change = 1776]
2008-06-06 07:50:08 +00:00
el->Add(&en);
Add selectable faces, by associating an hEntity with the triangle's metadata. And add point-on-face constraints to go with that. Still needs some cleanup for the user interface. [git-p4: depot-paths = "//depot/solvespace/": change = 1766]
2008-06-02 03:31:37 +00:00
} else if(ep->type == Entity::LINE_SEGMENT) {
// A line gets extruded to form a plane face; an endpoint of the
// original line is a point in the plane, and the line is in the plane.
A monster change; move the parameter, entity, group, and constraint tables from SolveSpace to their own class. This is intended to simplify use of the constraint solver in a library. [git-p4: depot-paths = "//depot/solvespace/": change = 1942]
2009-04-19 05:53:16 +00:00
Vector a = SK.GetEntity(ep->point[0])->PointGetNum();
Vector b = SK.GetEntity(ep->point[1])->PointGetNum();
Add selectable faces, by associating an hEntity with the triangle's metadata. And add point-on-face constraints to go with that. Still needs some cleanup for the user interface. [git-p4: depot-paths = "//depot/solvespace/": change = 1766]
2008-06-02 03:31:37 +00:00
Vector ab = b.Minus(a);
en.param[0] = h.param(0);
en.param[1] = h.param(1);
en.param[2] = h.param(2);
en.numPoint = a;
Treatment of numerical faces was screwy, exporting stuff in numXXX. So fix that, and now I can simplify what's exported for an entity. And add an extra measurement (face-face distance/angle), and some other little stuff. [git-p4: depot-paths = "//depot/solvespace/": change = 1789]
2008-06-13 04:41:27 +00:00
en.numNormal = Quaternion::From(0, ab.x, ab.y, ab.z);
Add selectable faces, by associating an hEntity with the triangle's metadata. And add point-on-face constraints to go with that. Still needs some cleanup for the user interface. [git-p4: depot-paths = "//depot/solvespace/": change = 1766]
2008-06-02 03:31:37 +00:00
en.group = h;
Now actually export the line styles, for PDF, EPS, and SVG file formats, with the proper color and width. This may need a bit of cleanup for stuff like the hidden line removal, which currently loses the style. Also fix a bug in the test for arcs of a circle. A second-order Bezier with collinear control points really is an arc, but it's an arc with infinite radius so stuff tends to blow up. So return false for that one. [git-p4: depot-paths = "//depot/solvespace/": change = 2030]
2009-09-22 05:46:30 +00:00
en.construction = ep->construction;
en.style = ep->style;
Add selectable faces, by associating an hEntity with the triangle's metadata. And add point-on-face constraints to go with that. Still needs some cleanup for the user interface. [git-p4: depot-paths = "//depot/solvespace/": change = 1766]
2008-06-02 03:31:37 +00:00
en.h = Remap(ep->h, REMAP_LINE_TO_FACE);
en.type = Entity::FACE_XPROD;
Major speedups, mostly by playing nicer with OpenGL; batch things up more. Also change from stupid linear search lists to sorted binary search lists, remove a stupid bug where I double-generated entities, and don't do the triple drawing of entities (since offsets on the Z buffer were doing the same job already). [git-p4: depot-paths = "//depot/solvespace/": change = 1776]
2008-06-06 07:50:08 +00:00
el->Add(&en);
Add selectable faces, by associating an hEntity with the triangle's metadata. And add point-on-face constraints to go with that. Still needs some cleanup for the user interface. [git-p4: depot-paths = "//depot/solvespace/": change = 1766]
2008-06-02 03:31:37 +00:00
}
}
Major speedups, mostly by playing nicer with OpenGL; batch things up more. Also change from stupid linear search lists to sorted binary search lists, remove a stupid bug where I double-generated entities, and don't do the triple drawing of entities (since offsets on the Z buffer were doing the same job already). [git-p4: depot-paths = "//depot/solvespace/": change = 1776]
2008-06-06 07:50:08 +00:00
void Group::MakeExtrusionTopBottomFaces(IdList<Entity,hEntity> *el, hEntity pt)
{
Add selectable faces, by associating an hEntity with the triangle's metadata. And add point-on-face constraints to go with that. Still needs some cleanup for the user interface. [git-p4: depot-paths = "//depot/solvespace/": change = 1766]
2008-06-02 03:31:37 +00:00
if(pt.v == 0) return;
A monster change; move the parameter, entity, group, and constraint tables from SolveSpace to their own class. This is intended to simplify use of the constraint solver in a library. [git-p4: depot-paths = "//depot/solvespace/": change = 1942]
2009-04-19 05:53:16 +00:00
Group *src = SK.GetGroup(opA);
A monster change to add support for filled paths. This requires us to assemble Beziers into outer and inner loops, and find those loops made up of entities with filled styles. The open paths are maintained in a separate list, and we assemble as many closed paths as possible even when open paths exist. This changes many things. The coplanar check is now performed on the Beziers, not the resulting polygon. The way that the polygon is used to determine loop directions is also modified. Also fix the mouse behavior when dragging a point: drop it when the mouse is released, even if it is released outside the window, but don't drop it if the pointer is dragged out of and then back into our window. Also special-case SSurface::ClosestPointTo() for planes, for speed. [git-p4: depot-paths = "//depot/solvespace/": change = 2058]
2009-10-29 07:16:28 +00:00
Vector n = src->polyLoops.normal;
Add selectable faces, by associating an hEntity with the triangle's metadata. And add point-on-face constraints to go with that. Still needs some cleanup for the user interface. [git-p4: depot-paths = "//depot/solvespace/": change = 1766]
2008-06-02 03:31:37 +00:00
Entity en;
ZERO(&en);
en.type = Entity::FACE_NORMAL_PT;
Add double-sided extrudes, and user interface for that. Also put the coordinate system (x, y, z normal vectors) in the bottom left corner of the screen at all times, and hide group-created workplanes except when that group is active, and activate that workplane when the group is activated. [git-p4: depot-paths = "//depot/solvespace/": change = 1726]
2008-05-17 08:02:39 +00:00
en.group = h;
Add selectable faces, by associating an hEntity with the triangle's metadata. And add point-on-face constraints to go with that. Still needs some cleanup for the user interface. [git-p4: depot-paths = "//depot/solvespace/": change = 1766]
2008-06-02 03:31:37 +00:00
en.numNormal = Quaternion::From(0, n.x, n.y, n.z);
en.point[0] = Remap(pt, REMAP_TOP);
en.h = Remap(Entity::NO_ENTITY, REMAP_TOP);
Major speedups, mostly by playing nicer with OpenGL; batch things up more. Also change from stupid linear search lists to sorted binary search lists, remove a stupid bug where I double-generated entities, and don't do the triple drawing of entities (since offsets on the Z buffer were doing the same job already). [git-p4: depot-paths = "//depot/solvespace/": change = 1776]
2008-06-06 07:50:08 +00:00
el->Add(&en);
Add selectable faces, by associating an hEntity with the triangle's metadata. And add point-on-face constraints to go with that. Still needs some cleanup for the user interface. [git-p4: depot-paths = "//depot/solvespace/": change = 1766]
2008-06-02 03:31:37 +00:00
en.point[0] = Remap(pt, REMAP_BOTTOM);
en.h = Remap(Entity::NO_ENTITY, REMAP_BOTTOM);
Major speedups, mostly by playing nicer with OpenGL; batch things up more. Also change from stupid linear search lists to sorted binary search lists, remove a stupid bug where I double-generated entities, and don't do the triple drawing of entities (since offsets on the Z buffer were doing the same job already). [git-p4: depot-paths = "//depot/solvespace/": change = 1776]
2008-06-06 07:50:08 +00:00
el->Add(&en);
Add double-sided extrudes, and user interface for that. Also put the coordinate system (x, y, z normal vectors) in the bottom left corner of the screen at all times, and hide group-created workplanes except when that group is active, and activate that workplane when the group is activated. [git-p4: depot-paths = "//depot/solvespace/": change = 1726]
2008-05-17 08:02:39 +00:00
}
Major speedups, mostly by playing nicer with OpenGL; batch things up more. Also change from stupid linear search lists to sorted binary search lists, remove a stupid bug where I double-generated entities, and don't do the triple drawing of entities (since offsets on the Z buffer were doing the same job already). [git-p4: depot-paths = "//depot/solvespace/": change = 1776]
2008-06-06 07:50:08 +00:00
void Group::CopyEntity(IdList<Entity,hEntity> *el,
Entity *ep, int timesApplied, int remap,
Add an axis-angle transformation (rotation about an arbitrary point), and use that to implement step and repeat rotating. [git-p4: depot-paths = "//depot/solvespace/": change = 1762]
2008-06-01 08:29:59 +00:00
hParam dx, hParam dy, hParam dz,
Add transformed points and normals with a rotation (as well as a 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]
2008-05-11 06:09:46 +00:00
hParam qw, hParam qvx, hParam qvy, hParam qvz,
Add an axis-angle transformation (rotation about an arbitrary point), and use that to implement step and repeat rotating. [git-p4: depot-paths = "//depot/solvespace/": change = 1762]
2008-06-01 08:29:59 +00:00
bool asTrans, bool asAxisAngle)
A big change, to add a concept of normals. These are "oriented 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]
2008-05-05 06:18:01 +00:00
{
Add the first `derived' group, that generates entities based on 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]
2008-04-27 09:03:01 +00:00
Entity en;
Put information about which requests generate which entities, and how many points are associated with each, into a single table. [git-p4: depot-paths = "//depot/solvespace/": change = 2056]
2009-10-22 14:02:08 +00:00
ZERO(&en);
Add the first `derived' group, that generates entities based on 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]
2008-04-27 09:03:01 +00:00
en.type = ep->type;
Add interpolating splines: both periodic splines (that form a loop), and open-ended splines, with their tangents specified at their endpoints. Also change constraint solver matrix size to 1024, on the theory that a power of two will generate better array indexing, and replace fabs() with my own function that for some reason is faster. [git-p4: depot-paths = "//depot/solvespace/": change = 2055]
2009-10-21 04:46:01 +00:00
en.extraPoints = ep->extraPoints;
Add an axis-angle transformation (rotation about an arbitrary point), and use that to implement step and repeat rotating. [git-p4: depot-paths = "//depot/solvespace/": change = 1762]
2008-06-01 08:29:59 +00:00
en.h = Remap(ep->h, remap);
en.timesApplied = timesApplied;
Add the first `derived' group, that generates entities based on 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]
2008-04-27 09:03:01 +00:00
en.group = h;
Various tweaks, including a numerical improvement, to make the epsilon in the csg stuff meaningfully apply everywhere to the length. [git-p4: depot-paths = "//depot/solvespace/": change = 1742]
2008-05-25 14:36:03 +00:00
en.construction = ep->construction;
Now actually export the line styles, for PDF, EPS, and SVG file formats, with the proper color and width. This may need a bit of cleanup for stuff like the hidden line removal, which currently loses the style. Also fix a bug in the test for arcs of a circle. A second-order Bezier with collinear control points really is an arc, but it's an arc with infinite radius so stuff tends to blow up. So return false for that one. [git-p4: depot-paths = "//depot/solvespace/": change = 2030]
2009-09-22 05:46:30 +00:00
en.style = ep->style;
Put information about which requests generate which entities, and how many points are associated with each, into a single table. [git-p4: depot-paths = "//depot/solvespace/": change = 2056]
2009-10-22 14:02:08 +00:00
en.str.strcpy(ep->str.str);
en.font.strcpy(ep->font.str);
Add the first `derived' group, that generates entities based on 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]
2008-04-27 09:03:01 +00:00
switch(ep->type) {
case Entity::WORKPLANE:
// Don't copy these.
return;
Find a memory corruption! I was getting a pointer into the entity list, and then adding a new entity to that list, and then looking at that pointer again. Not okay; the add operation might have forced a realloc. I have to watch for that. And add a "distance ratio" constraint, plus a new kind of group that comes with its own workplane. The workplane is not solved for; it's generated explicitly in terms of elements that are already solved. [git-p4: depot-paths = "//depot/solvespace/": change = 1716]
2008-05-11 10:40:37 +00:00
case Entity::POINT_N_COPY:
Add transformed points and normals with a rotation (as well as a 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]
2008-05-11 06:09:46 +00:00
case Entity::POINT_N_TRANS:
case Entity::POINT_N_ROT_TRANS:
Add an axis-angle transformation (rotation about an arbitrary point), and use that to implement step and repeat rotating. [git-p4: depot-paths = "//depot/solvespace/": change = 1762]
2008-06-01 08:29:59 +00:00
case Entity::POINT_N_ROT_AA:
Add the first `derived' group, that generates entities based on 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]
2008-04-27 09:03:01 +00:00
case Entity::POINT_IN_3D:
case Entity::POINT_IN_2D:
Add an axis-angle transformation (rotation about an arbitrary point), and use that to implement step and repeat rotating. [git-p4: depot-paths = "//depot/solvespace/": change = 1762]
2008-06-01 08:29:59 +00:00
if(asTrans) {
Add transformed points and normals with a rotation (as well as a 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]
2008-05-11 06:09:46 +00:00
en.type = Entity::POINT_N_TRANS;
en.param[0] = dx;
en.param[1] = dy;
en.param[2] = dz;
} else {
Add an axis-angle transformation (rotation about an arbitrary point), and use that to implement step and repeat rotating. [git-p4: depot-paths = "//depot/solvespace/": change = 1762]
2008-06-01 08:29:59 +00:00
if(asAxisAngle) {
en.type = Entity::POINT_N_ROT_AA;
} else {
en.type = Entity::POINT_N_ROT_TRANS;
}
Add transformed points and normals with a rotation (as well as a 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]
2008-05-11 06:09:46 +00:00
en.param[0] = dx;
en.param[1] = dy;
en.param[2] = dz;
en.param[3] = qw;
en.param[4] = qvx;
en.param[5] = qvy;
en.param[6] = qvz;
A big change, to add a concept of normals. These are "oriented 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]
2008-05-05 06:18:01 +00:00
}
A big nasty change, originally just to add paste transformed. So it does that, and adds a scale factor to that transformation (instead of just mirroring, as before), but also: * Replace the "import mirrored" mechanism with a scale factor, which if negative corresponds to a reflection as well. * Fix self-intersection checker to report a meaningful point when edges are collinear. * Don't blow an assertion on some types of invalid file; instead provide a nice error message to the user. * Clear the naked edges before each regen. * Don't create zero-length line segments by snapping a line segment's end to its beginning. [git-p4: depot-paths = "//depot/solvespace/": change = 2086]
2009-12-15 12:26:22 +00:00
en.numPoint = (ep->actPoint).ScaledBy(scale);
A big change, to add a concept of normals. These are "oriented 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]
2008-05-05 06:18:01 +00:00
break;
Add transformed points and normals with a rotation (as well as a 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]
2008-05-11 06:09:46 +00:00
case Entity::NORMAL_N_COPY:
case Entity::NORMAL_N_ROT:
Add an axis-angle transformation (rotation about an arbitrary point), and use that to implement step and repeat rotating. [git-p4: depot-paths = "//depot/solvespace/": change = 1762]
2008-06-01 08:29:59 +00:00
case Entity::NORMAL_N_ROT_AA:
A big change, to add a concept of normals. These are "oriented 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]
2008-05-05 06:18:01 +00:00
case Entity::NORMAL_IN_3D:
case Entity::NORMAL_IN_2D:
Add an axis-angle transformation (rotation about an arbitrary point), and use that to implement step and repeat rotating. [git-p4: depot-paths = "//depot/solvespace/": change = 1762]
2008-06-01 08:29:59 +00:00
if(asTrans) {
Add transformed points and normals with a rotation (as well as a 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]
2008-05-11 06:09:46 +00:00
en.type = Entity::NORMAL_N_COPY;
} else {
Add an axis-angle transformation (rotation about an arbitrary point), and use that to implement step and repeat rotating. [git-p4: depot-paths = "//depot/solvespace/": change = 1762]
2008-06-01 08:29:59 +00:00
if(asAxisAngle) {
en.type = Entity::NORMAL_N_ROT_AA;
} else {
en.type = Entity::NORMAL_N_ROT;
}
Add transformed points and normals with a rotation (as well as a 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]
2008-05-11 06:09:46 +00:00
en.param[0] = qw;
en.param[1] = qvx;
en.param[2] = qvy;
en.param[3] = qvz;
}
Initial work on the assembly (`import') feature. I can import a 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]
2008-05-29 10:10:12 +00:00
en.numNormal = ep->actNormal;
A big nasty change, originally just to add paste transformed. So it does that, and adds a scale factor to that transformation (instead of just mirroring, as before), but also: * Replace the "import mirrored" mechanism with a scale factor, which if negative corresponds to a reflection as well. * Fix self-intersection checker to report a meaningful point when edges are collinear. * Don't blow an assertion on some types of invalid file; instead provide a nice error message to the user. * Clear the naked edges before each regen. * Don't create zero-length line segments by snapping a line segment's end to its beginning. [git-p4: depot-paths = "//depot/solvespace/": change = 2086]
2009-12-15 12:26:22 +00:00
if(scale < 0) en.numNormal = en.numNormal.Mirror();
Add option to mirror imported geometry, including the shell, mesh, and parametric entities. Also consolidate the text screen functions to change group options into a single function for everything. [git-p4: depot-paths = "//depot/solvespace/": change = 2051]
2009-10-09 12:57:10 +00:00
Add an axis-angle transformation (rotation about an arbitrary point), and use that to implement step and repeat rotating. [git-p4: depot-paths = "//depot/solvespace/": change = 1762]
2008-06-01 08:29:59 +00:00
en.point[0] = Remap(ep->point[0], remap);
Add the first `derived' group, that generates entities based on 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]
2008-04-27 09:03:01 +00:00
break;
Add transformed points and normals with a rotation (as well as a 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]
2008-05-11 06:09:46 +00:00
case Entity::DISTANCE_N_COPY:
Add a diameter constraint, and add a `distance' entity that I can remap when I copy circle entities, in order to make the radius numerical somehow (analogy with the POINT_ and NORMAL_XFRMD) thing. [git-p4: depot-paths = "//depot/solvespace/": change = 1710]
2008-05-07 08:19:37 +00:00
case Entity::DISTANCE:
Add transformed points and normals with a rotation (as well as a 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]
2008-05-11 06:09:46 +00:00
en.type = Entity::DISTANCE_N_COPY;
A big nasty change, originally just to add paste transformed. So it does that, and adds a scale factor to that transformation (instead of just mirroring, as before), but also: * Replace the "import mirrored" mechanism with a scale factor, which if negative corresponds to a reflection as well. * Fix self-intersection checker to report a meaningful point when edges are collinear. * Don't blow an assertion on some types of invalid file; instead provide a nice error message to the user. * Clear the naked edges before each regen. * Don't create zero-length line segments by snapping a line segment's end to its beginning. [git-p4: depot-paths = "//depot/solvespace/": change = 2086]
2009-12-15 12:26:22 +00:00
en.numDistance = ep->actDistance*fabs(scale);
Add a diameter constraint, and add a `distance' entity that I can remap when I copy circle entities, in order to make the radius numerical somehow (analogy with the POINT_ and NORMAL_XFRMD) thing. [git-p4: depot-paths = "//depot/solvespace/": change = 1710]
2008-05-07 08:19:37 +00:00
break;
Add selectable faces, by associating an hEntity with the triangle's metadata. And add point-on-face constraints to go with that. Still needs some cleanup for the user interface. [git-p4: depot-paths = "//depot/solvespace/": change = 1766]
2008-06-02 03:31:37 +00:00
case Entity::FACE_NORMAL_PT:
case Entity::FACE_XPROD:
case Entity::FACE_N_ROT_TRANS:
Make step and repeats step the mesh, as well as the entities. This requires new entitiy types for the faces, by translation or by axis-angle rotation. [git-p4: depot-paths = "//depot/solvespace/": change = 1802]
2008-06-21 22:49:57 +00:00
case Entity::FACE_N_TRANS:
case Entity::FACE_N_ROT_AA:
if(asTrans) {
en.type = Entity::FACE_N_TRANS;
en.param[0] = dx;
en.param[1] = dy;
en.param[2] = dz;
} else {
if(asAxisAngle) {
en.type = Entity::FACE_N_ROT_AA;
} else {
en.type = Entity::FACE_N_ROT_TRANS;
}
en.param[0] = dx;
en.param[1] = dy;
en.param[2] = dz;
en.param[3] = qw;
en.param[4] = qvx;
en.param[5] = qvy;
en.param[6] = qvz;
}
A big nasty change, originally just to add paste transformed. So it does that, and adds a scale factor to that transformation (instead of just mirroring, as before), but also: * Replace the "import mirrored" mechanism with a scale factor, which if negative corresponds to a reflection as well. * Fix self-intersection checker to report a meaningful point when edges are collinear. * Don't blow an assertion on some types of invalid file; instead provide a nice error message to the user. * Clear the naked edges before each regen. * Don't create zero-length line segments by snapping a line segment's end to its beginning. [git-p4: depot-paths = "//depot/solvespace/": change = 2086]
2009-12-15 12:26:22 +00:00
en.numPoint = (ep->actPoint).ScaledBy(scale);
en.numNormal = (ep->actNormal).ScaledBy(scale);
Add selectable faces, by associating an hEntity with the triangle's metadata. And add point-on-face constraints to go with that. Still needs some cleanup for the user interface. [git-p4: depot-paths = "//depot/solvespace/": change = 1766]
2008-06-02 03:31:37 +00:00
break;
Put information about which requests generate which entities, and how many points are associated with each, into a single table. [git-p4: depot-paths = "//depot/solvespace/": change = 2056]
2009-10-22 14:02:08 +00:00
default: {
int i, points;
bool hasNormal, hasDistance;
EntReqTable::GetEntityInfo(ep->type, ep->extraPoints,
NULL, &points, &hasNormal, &hasDistance);
for(i = 0; i < points; i++) {
en.point[i] = Remap(ep->point[i], remap);
}
if(hasNormal) en.normal = Remap(ep->normal, remap);
if(hasDistance) en.distance = Remap(ep->distance, remap);
break;
}
Add the first `derived' group, that generates entities based on 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]
2008-04-27 09:03:01 +00:00
}
Show a progress message when regenerating is slow. And update the version number to 1.4, don't include force-hidden entities when building the loops, and don't show force-hidden entities when that entity gets copied. [git-p4: depot-paths = "//depot/solvespace/": change = 1983]
2009-06-14 04:36:38 +00:00
// If the entity came from an imported file where it was invisible then
// ep->actiVisble will be false, and we should hide it. Or if the entity
// came from a copy (e.g. step and repeat) of a force-hidden imported
// entity, then we also want to hide it.
en.forceHidden = (!ep->actVisible) || ep->forceHidden;
Treatment of numerical faces was screwy, exporting stuff in numXXX. So fix that, and now I can simplify what's exported for an entity. And add an extra measurement (face-face distance/angle), and some other little stuff. [git-p4: depot-paths = "//depot/solvespace/": change = 1789]
2008-06-13 04:41:27 +00:00
Major speedups, mostly by playing nicer with OpenGL; batch things up more. Also change from stupid linear search lists to sorted binary search lists, remove a stupid bug where I double-generated entities, and don't do the triple drawing of entities (since offsets on the Z buffer were doing the same job already). [git-p4: depot-paths = "//depot/solvespace/": change = 1776]
2008-06-06 07:50:08 +00:00
el->Add(&en);
Add the first `derived' group, that generates entities based on 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]
2008-04-27 09:03:01 +00:00
}