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

877 lines
30 KiB
C++
Raw Normal View History

Changes in preparation for the release of SolveSpace under the GPL, to add that license, and change all copyright notices to me, not Useful Subset, LLC. [git-p4: depot-paths = "//depot/solvespace/": change = 2211]
2013-07-28 22:08:34 +00:00
//-----------------------------------------------------------------------------
// Implementation of the Group class, which represents a set of entities and
// constraints that are solved together, in some cases followed by another
// operation, like to extrude surfaces from the entities or to step and
// repeat them parametrically.
//
// Copyright 2008-2013 Jonathan Westhues.
//-----------------------------------------------------------------------------
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) {
Replace all ZERO and memset with C++11 brace-initialization. This will allow us to use non-POD classes inside these objects in future and is otherwise functionally equivalent, as well as more concise. Note that there are some subtleties with handling of brace-initialization. Specifically: On aggregates (e.g. simple C-style structures) using an empty brace-initializer zero-initializes the aggregate, i.e. it makes all members zero. On non-aggregates an empty brace-initializer calls the default constructor. And if the constructor doesn't explicitly initialize the members (which the auto-generated constructor doesn't) then the members will be constructed but otherwise uninitialized. So, what is an aggregate class? To quote the C++ standard (C++03 8.5.1 §1): An aggregate is an array or a class (clause 9) with no user-declared constructors (12.1), no private or protected non-static data members (clause 11), no base classes (clause 10), and no virtual functions (10.3). In SolveSpace, we only have to handle the case of base classes; Constraint and Entity have those. Thus, they had to gain a default constructor that does nothing but initializes the members to zero.
2015-03-27 15:31:23 +00:00
Param pa = {};
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
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) {
Replace all ZERO and memset with C++11 brace-initialization. This will allow us to use non-POD classes inside these objects in future and is otherwise functionally equivalent, as well as more concise. Note that there are some subtleties with handling of brace-initialization. Specifically: On aggregates (e.g. simple C-style structures) using an empty brace-initializer zero-initializes the aggregate, i.e. it makes all members zero. On non-aggregates an empty brace-initializer calls the default constructor. And if the constructor doesn't explicitly initialize the members (which the auto-generated constructor doesn't) then the members will be constructed but otherwise uninitialized. So, what is an aggregate class? To quote the C++ standard (C++03 8.5.1 §1): An aggregate is an array or a class (clause 9) with no user-declared constructors (12.1), no private or protected non-static data members (clause 11), no base classes (clause 10), and no virtual functions (10.3). In SolveSpace, we only have to handle the case of base classes; Constraint and Entity have those. Thus, they had to gain a default constructor that does nothing but initializes the members to zero.
2015-03-27 15:31:23 +00:00
Group 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;
Renamed the RGB() macro to RGBi() to avoid collisions with Microsoft Microsoft defines an RGB() macro that at one point was compatible with our version (returning a packed integer containing 8-bit red, green and blue channels), but is no longer, and the incompatibility led to an awkward situation in w32main.cpp where we had to restore Microsoft's form of the macro in order for the commctrl.h header to compile. By renaming the macro to RGBi()---analogous to the RGBf() macro we already define---we avoid the hassle entirely.
2013-12-02 06:25:09 +00:00
g.color = RGBi(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)) {
Rewrite all path handling with std::string. What do we gain from this? Several things. * First, usage of PATH_MAX (the POSIX constant) is eliminated. PATH_MAX is actually a lie; Linux and OS X (and probably other BSDs too) do not have an actual path length limit. Linux claims 4096, OS X claims 1024, but it is trivial to construct paths that are longer. * Second, while Windows does enforce a limit of MAX_PATH (the Win32 constant) for its ASCII functions, the Unicode variants, when used with UNC paths, do not have this restriction. The capability to use UNC paths is useful by itself, as it allows to access files on network shares directly. * Third, representing paths as std::string will make it easier to interoperate with *W WinAPI functions later.
2015-12-27 01:03:24 +00:00
g.impFile = RecentFile[id-RECENT_IMPORT];
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
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;
Replace NameStr with std::string. This removes the arbitrary 64 byte restriction (which effectively limits us to as little as 16 Unicode characters with CJK encodings), makes classes smaller, and is easier to use. As a consequence of making the length of all ex-NameStr fields unbounded, all functions that returned a buffer derived from those were changed to return std::string. Then, functions that are contextually similar to the ones described above were changed to return std::string. Then, functions that now happened to mostly take an std::string argument converted to a C string were changed to accept std::string. This has produced a bit of churn, but is probably for the better.
2015-11-06 08:40:12 +00:00
g.name = "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;
Replace NameStr with std::string. This removes the arbitrary 64 byte restriction (which effectively limits us to as little as 16 Unicode characters with CJK encodings), makes classes smaller, and is easier to use. As a consequence of making the length of all ex-NameStr fields unbounded, all functions that returned a buffer derived from those were changed to return std::string. Then, functions that are contextually similar to the ones described above were changed to return std::string. Then, functions that now happened to mostly take an std::string argument converted to a C string were changed to accept std::string. This has produced a bit of churn, but is probably for the better.
2015-11-06 08:40:12 +00:00
g.name = "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))) {
Use C++ std::{min,max,swap} instead of custom ones. The main benefit is that std::swap will ensure that the type of arguments is copy-constructible and move-constructible. It is more concise as well. When min and max are defined as macros, they will conflict with STL header files included by other C++ libraries; in this case STL will #undef any other definition.
2015-03-27 15:43:28 +00:00
swap(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;
Replace NameStr with std::string. This removes the arbitrary 64 byte restriction (which effectively limits us to as little as 16 Unicode characters with CJK encodings), makes classes smaller, and is easier to use. As a consequence of making the length of all ex-NameStr fields unbounded, all functions that returned a buffer derived from those were changed to return std::string. Then, functions that are contextually similar to the ones described above were changed to return std::string. Then, functions that now happened to mostly take an std::string argument converted to a C string were changed to accept std::string. This has produced a bit of churn, but is probably for the better.
2015-11-06 08:40:12 +00:00
g.name = "extrude";
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 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;
Replace NameStr with std::string. This removes the arbitrary 64 byte restriction (which effectively limits us to as little as 16 Unicode characters with CJK encodings), makes classes smaller, and is easier to use. As a consequence of making the length of all ex-NameStr fields unbounded, all functions that returned a buffer derived from those were changed to return std::string. Then, functions that are contextually similar to the ones described above were changed to return std::string. Then, functions that now happened to mostly take an std::string argument converted to a C string were changed to accept std::string. This has produced a bit of churn, but is probably for the better.
2015-11-06 08:40:12 +00:00
g.name = "lathe";
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
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;
Replace NameStr with std::string. This removes the arbitrary 64 byte restriction (which effectively limits us to as little as 16 Unicode characters with CJK encodings), makes classes smaller, and is easier to use. As a consequence of making the length of all ex-NameStr fields unbounded, all functions that returned a buffer derived from those were changed to return std::string. Then, functions that are contextually similar to the ones described above were changed to return std::string. Then, functions that now happened to mostly take an std::string argument converted to a C string were changed to accept std::string. This has produced a bit of churn, but is probably for the better.
2015-11-06 08:40:12 +00:00
g.name = "rotate";
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 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();
Replace NameStr with std::string. This removes the arbitrary 64 byte restriction (which effectively limits us to as little as 16 Unicode characters with CJK encodings), makes classes smaller, and is easier to use. As a consequence of making the length of all ex-NameStr fields unbounded, all functions that returned a buffer derived from those were changed to return std::string. Then, functions that are contextually similar to the ones described above were changed to return std::string. Then, functions that now happened to mostly take an std::string argument converted to a C string were changed to accept std::string. This has produced a bit of churn, but is probably for the better.
2015-11-06 08:40:12 +00:00
g.name = "translate";
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;
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;
Rewrite all path handling with std::string. What do we gain from this? Several things. * First, usage of PATH_MAX (the POSIX constant) is eliminated. PATH_MAX is actually a lie; Linux and OS X (and probably other BSDs too) do not have an actual path length limit. Linux claims 4096, OS X claims 1024, but it is trivial to construct paths that are longer. * Second, while Windows does enforce a limit of MAX_PATH (the Win32 constant) for its ASCII functions, the Unicode variants, when used with UNC paths, do not have this restriction. The capability to use UNC paths is useful by itself, as it allows to access files on network shares directly. * Third, representing paths as std::string will make it easier to interoperate with *W WinAPI functions later.
2015-12-27 01:03:24 +00:00
if(g.impFile.empty()) {
Simplify file saving code. There is no need to record default file format choice, as the first one is selected when an empty string is passed.
2016-01-11 08:44:56 +00:00
if(!GetOpenFile(g.impFile, "", SLVS_PATTERN)) return;
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
}
Assign default name of import group based on name of imported file. [git-p4: depot-paths = "//depot/solvespace/": change = 2133]
2010-05-03 05:38:25 +00:00
// Assign the default name of the group based on the name of
// the imported file.
Rewrite all path handling with std::string. What do we gain from this? Several things. * First, usage of PATH_MAX (the POSIX constant) is eliminated. PATH_MAX is actually a lie; Linux and OS X (and probably other BSDs too) do not have an actual path length limit. Linux claims 4096, OS X claims 1024, but it is trivial to construct paths that are longer. * Second, while Windows does enforce a limit of MAX_PATH (the Win32 constant) for its ASCII functions, the Unicode variants, when used with UNC paths, do not have this restriction. The capability to use UNC paths is useful by itself, as it allows to access files on network shares directly. * Third, representing paths as std::string will make it easier to interoperate with *W WinAPI functions later.
2015-12-27 01:03:24 +00:00
std::string groupName = g.impFile;
size_t pos;
Rigorously treat paths on every platform. After this commit, SolveSpace deals with paths as follows: * Paths are generally treated as opaque platform-specific strings. This helps on Linux, because paths on Linux don't have any specific encoding and it helps to avoid any operations on them. * The UI in some places wants to get a basename. In this case, the newly introduced PATH_SEP is used. This allows to treat backslash as a regular character, which it is on Linux and OS X. * The only place where any nontrivial operations on paths are performed is the g->impFile/impFileRel logic. Specifically, when saved, g->impFile always contains an absolute path with separators of the current platform, and g->impFileRel always contains a relative path with UNIX separators. This allows to treat backslash as a regular character. Old files will contain g->impFileRel with Windows separators; these are detected by looking for a drive letter in g->impFile and in that case mapping Windows separators to UNIX ones. There is no need to treat UNIX separators (forward slashes) in any special way on Windows because there is no way on Windows, not even via UNC paths, to create or address a directory entry with a forward slash in its name.
2015-12-27 06:35:46 +00:00
pos = groupName.rfind(PATH_SEP);
if(pos != std::string::npos)
groupName.erase(0, pos + 1);
Rewrite all path handling with std::string. What do we gain from this? Several things. * First, usage of PATH_MAX (the POSIX constant) is eliminated. PATH_MAX is actually a lie; Linux and OS X (and probably other BSDs too) do not have an actual path length limit. Linux claims 4096, OS X claims 1024, but it is trivial to construct paths that are longer. * Second, while Windows does enforce a limit of MAX_PATH (the Win32 constant) for its ASCII functions, the Unicode variants, when used with UNC paths, do not have this restriction. The capability to use UNC paths is useful by itself, as it allows to access files on network shares directly. * Third, representing paths as std::string will make it easier to interoperate with *W WinAPI functions later.
2015-12-27 01:03:24 +00:00
pos = groupName.rfind('.');
if(pos != std::string::npos)
groupName.erase(pos);
Use size_t for indexing where appropriate. MSVC (rightly) complains about this.
2016-02-12 05:25:19 +00:00
for(size_t i = 0; i < groupName.length(); i++) {
Rasterize non-ASCII glyphs in the UI. Now it is possible to give non-ASCII names to groups as well as see non-ASCII filenames of imported files. In the future this makes localization possible. This works for LTR languages, such as European and CJK, but not RTL such as Arabic. Does Arabic even exist in monospaced form? I have no idea.
2015-11-05 19:39:27 +00:00
if(!(isalnum(groupName[i]) || (unsigned)groupName[i] >= 0x80)) {
// convert punctuation to dashes
Rewrite all path handling with std::string. What do we gain from this? Several things. * First, usage of PATH_MAX (the POSIX constant) is eliminated. PATH_MAX is actually a lie; Linux and OS X (and probably other BSDs too) do not have an actual path length limit. Linux claims 4096, OS X claims 1024, but it is trivial to construct paths that are longer. * Second, while Windows does enforce a limit of MAX_PATH (the Win32 constant) for its ASCII functions, the Unicode variants, when used with UNC paths, do not have this restriction. The capability to use UNC paths is useful by itself, as it allows to access files on network shares directly. * Third, representing paths as std::string will make it easier to interoperate with *W WinAPI functions later.
2015-12-27 01:03:24 +00:00
groupName[i] = '-';
Assign default name of import group based on name of imported file. [git-p4: depot-paths = "//depot/solvespace/": change = 2133]
2010-05-03 05:38:25 +00:00
}
}
Rewrite all path handling with std::string. What do we gain from this? Several things. * First, usage of PATH_MAX (the POSIX constant) is eliminated. PATH_MAX is actually a lie; Linux and OS X (and probably other BSDs too) do not have an actual path length limit. Linux claims 4096, OS X claims 1024, but it is trivial to construct paths that are longer. * Second, while Windows does enforce a limit of MAX_PATH (the Win32 constant) for its ASCII functions, the Unicode variants, when used with UNC paths, do not have this restriction. The capability to use UNC paths is useful by itself, as it allows to access files on network shares directly. * Third, representing paths as std::string will make it easier to interoperate with *W WinAPI functions later.
2015-12-27 01:03:24 +00:00
if(groupName.length() > 0) {
Replace NameStr with std::string. This removes the arbitrary 64 byte restriction (which effectively limits us to as little as 16 Unicode characters with CJK encodings), makes classes smaller, and is easier to use. As a consequence of making the length of all ex-NameStr fields unbounded, all functions that returned a buffer derived from those were changed to return std::string. Then, functions that are contextually similar to the ones described above were changed to return std::string. Then, functions that now happened to mostly take an std::string argument converted to a C string were changed to accept std::string. This has produced a bit of churn, but is probably for the better.
2015-11-06 08:40:12 +00:00
g.name = groupName;
Assign default name of import group based on name of imported file. [git-p4: depot-paths = "//depot/solvespace/": change = 2133]
2010-05-03 05:38:25 +00:00
} else {
Replace NameStr with std::string. This removes the arbitrary 64 byte restriction (which effectively limits us to as little as 16 Unicode characters with CJK encodings), makes classes smaller, and is easier to use. As a consequence of making the length of all ex-NameStr fields unbounded, all functions that returned a buffer derived from those were changed to return std::string. Then, functions that are contextually similar to the ones described above were changed to return std::string. Then, functions that now happened to mostly take an std::string argument converted to a C string were changed to accept std::string. This has produced a bit of churn, but is probably for the better.
2015-11-06 08:40:12 +00:00
g.name = "import";
Assign default name of import group based on name of imported file. [git-p4: depot-paths = "//depot/solvespace/": change = 2133]
2010-05-03 05:38:25 +00:00
}
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
Add new group after active group, not after all groups.
2016-02-17 10:31:15 +00:00
bool afterActive = false;
for(int i = 0; i < SK.groupOrder.n; i++) {
Group *gi = SK.GetGroup(SK.groupOrder.elem[i]);
if(afterActive)
gi->order += 1;
if(gi->h.v == SS.GW.activeGroup.v) {
g.order = gi->order + 1;
afterActive = true;
}
}
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);
Add a GTK2/3 port. In principle, GTK3 is the way forward, and GTK2 is officially deprecated, though still maintained. In practice however, GTK3 is often unbearably buggy; e.g. on my system, combo boxes don't ever roll up in GTK3 windows. So I have added support for both. This required a few minor changes to the core, namely: * GTK wants to know beforehand whether a menu item is a check menu item or a regular one. * GTK doesn't give us an easy way to execute something after any event is processed, so an explicit idle timer is added. This is a no-op on Win32. * A few function signatures were const'ed, since GTK expects immutable strings when converting to Glib::ustring.
2015-03-18 17:02:11 +00:00
SS.ScheduleShowTW();
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);
Trim trailing whitespace.
2015-03-29 00:30:52 +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
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;
}
Replace NameStr with std::string. This removes the arbitrary 64 byte restriction (which effectively limits us to as little as 16 Unicode characters with CJK encodings), makes classes smaller, and is easier to use. As a consequence of making the length of all ex-NameStr fields unbounded, all functions that returned a buffer derived from those were changed to return std::string. Then, functions that are contextually similar to the ones described above were changed to return std::string. Then, functions that now happened to mostly take an std::string argument converted to a C string were changed to accept std::string. This has produced a bit of churn, but is probably for the better.
2015-11-06 08:40:12 +00:00
std::string Group::DescriptionString(void) {
if(name.empty()) {
return ssprintf("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
} else {
Replace NameStr with std::string. This removes the arbitrary 64 byte restriction (which effectively limits us to as little as 16 Unicode characters with CJK encodings), makes classes smaller, and is easier to use. As a consequence of making the length of all ex-NameStr fields unbounded, all functions that returned a buffer derived from those were changed to return std::string. Then, functions that are contextually similar to the ones described above were changed to return std::string. Then, functions that now happened to mostly take an std::string argument converted to a C string were changed to accept std::string. This has produced a bit of churn, but is probably for the better.
2015-11-06 08:40:12 +00:00
return ssprintf("g%03x-%s", h.v, name.c_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
}
}
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) {
Generate primitives for lathe groups. The primitives that are generated are circles from points and faces from axis-perpendicular line segments.
2015-10-31 08:22:26 +00:00
if(type == EXTRUDE || type == IMPORTED || type == LATHE || type == TRANSLATE || type == ROTATE) {
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
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
Add a GTK2/3 port. In principle, GTK3 is the way forward, and GTK2 is officially deprecated, though still maintained. In practice however, GTK3 is often unbearably buggy; e.g. on my system, combo boxes don't ever roll up in GTK3 windows. So I have added support for both. This required a few minor changes to the core, namely: * GTK wants to know beforehand whether a menu item is a check menu item or a regular one. * GTK doesn't give us an easy way to execute something after any event is processed, so an explicit idle timer is added. This is a no-op on Win32. * A few function signatures were const'ed, since GTK expects immutable strings when converting to Glib::ustring.
2015-03-18 17:02:11 +00:00
SS.ScheduleGenerateAll();
SS.ScheduleShowTW();
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);
Use C++ std::{min,max,swap} instead of custom ones. The main benefit is that std::swap will ensure that the type of arguments is copy-constructible and move-constructible. It is more concise as well. When min and max are defined as macros, they will conflict with STL header files included by other C++ libraries; in this case STL will #undef any other definition.
2015-03-27 15:43:28 +00:00
if(predef.swapUV) swap(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
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();
Replace all ZERO and memset with C++11 brace-initialization. This will allow us to use non-POD classes inside these objects in future and is otherwise functionally equivalent, as well as more concise. Note that there are some subtleties with handling of brace-initialization. Specifically: On aggregates (e.g. simple C-style structures) using an empty brace-initializer zero-initializes the aggregate, i.e. it makes all members zero. On non-aggregates an empty brace-initializer calls the default constructor. And if the constructor doesn't explicitly initialize the members (which the auto-generated constructor doesn't) then the members will be constructed but otherwise uninitialized. So, what is an aggregate class? To quote the C++ standard (C++03 8.5.1 §1): An aggregate is an array or a class (clause 9) with no user-declared constructors (12.1), no private or protected non-static data members (clause 11), no base classes (clause 10), and no virtual functions (10.3). In SolveSpace, we only have to handle the case of base classes; Constraint and Entity have those. Thus, they had to gain a default constructor that does nothing but initializes the members to zero.
2015-03-27 15:31:23 +00:00
Entity normal = {};
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
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);
Replace all ZERO and memset with C++11 brace-initialization. This will allow us to use non-POD classes inside these objects in future and is otherwise functionally equivalent, as well as more concise. Note that there are some subtleties with handling of brace-initialization. Specifically: On aggregates (e.g. simple C-style structures) using an empty brace-initializer zero-initializes the aggregate, i.e. it makes all members zero. On non-aggregates an empty brace-initializer calls the default constructor. And if the constructor doesn't explicitly initialize the members (which the auto-generated constructor doesn't) then the members will be constructed but otherwise uninitialized. So, what is an aggregate class? To quote the C++ standard (C++03 8.5.1 §1): An aggregate is an array or a class (clause 9) with no user-declared constructors (12.1), no private or protected non-static data members (clause 11), no base classes (clause 10), and no virtual functions (10.3). In SolveSpace, we only have to handle the case of base classes; Constraint and Entity have those. Thus, they had to gain a default constructor that does nothing but initializes the members to zero.
2015-03-27 15:31:23 +00:00
Entity point = {};
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.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);
Replace all ZERO and memset with C++11 brace-initialization. This will allow us to use non-POD classes inside these objects in future and is otherwise functionally equivalent, as well as more concise. Note that there are some subtleties with handling of brace-initialization. Specifically: On aggregates (e.g. simple C-style structures) using an empty brace-initializer zero-initializes the aggregate, i.e. it makes all members zero. On non-aggregates an empty brace-initializer calls the default constructor. And if the constructor doesn't explicitly initialize the members (which the auto-generated constructor doesn't) then the members will be constructed but otherwise uninitialized. So, what is an aggregate class? To quote the C++ standard (C++03 8.5.1 §1): An aggregate is an array or a class (clause 9) with no user-declared constructors (12.1), no private or protected non-static data members (clause 11), no base classes (clause 10), and no virtual functions (10.3). In SolveSpace, we only have to handle the case of base classes; Constraint and Entity have those. Thus, they had to gain a default constructor that does nothing but initializes the members to zero.
2015-03-27 15:31:23 +00:00
Entity wp = {};
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
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: {
Generate primitives for lathe groups. The primitives that are generated are circles from points and faces from axis-perpendicular line segments.
2015-10-31 08:22:26 +00:00
Vector axis_pos = SK.GetEntity(predef.origin)->PointGetNum();
Vector axis_dir = SK.GetEntity(predef.entityB)->VectorGetNum();
AddParam(param, h.param(0), axis_dir.x);
AddParam(param, h.param(1), axis_dir.y);
AddParam(param, h.param(2), axis_dir.z);
// Remapped entity index.
int ai = 1;
for(i = 0; i < entity->n; i++) {
Entity *e = &(entity->elem[i]);
if(e->group.v != opA.v) continue;
e->CalculateNumerical(false);
hEntity he = e->h;
// As soon as I call CopyEntity, e may become invalid! That
// adds entities, which may cause a realloc.
CopyEntity(entity, SK.GetEntity(predef.origin), 0, ai,
h.param(0), h.param(1), h.param(2),
NO_PARAM, NO_PARAM, NO_PARAM, NO_PARAM,
true, false);
CopyEntity(entity, SK.GetEntity(he), 0, REMAP_LATHE_START,
h.param(0), h.param(1), h.param(2),
NO_PARAM, NO_PARAM, NO_PARAM, NO_PARAM,
true, false);
CopyEntity(entity, SK.GetEntity(he), 0, REMAP_LATHE_END,
h.param(0), h.param(1), h.param(2),
NO_PARAM, NO_PARAM, NO_PARAM, NO_PARAM,
true, false);
MakeLatheCircles(entity, param, he, axis_pos, axis_dir, ai);
ai++;
}
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
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);
Trim trailing whitespace.
2015-03-29 00:30:52 +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
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 a setting that permits a group to include redundant constraints. This setting is generally useful, but it especially shines when assembling, since the "same orientation" and "parallel" constraints remove three and two rotational degrees of freedom, which makes them impossible to use with 3d "point on line" constraint that removes two spatial and two rotational degrees of freedom. The setting is not enabled for all imported groups by default because it exhibits some edge case failures. For example: * draw two line segments sharing a point, * constrain lengths of line segments, * constrain line segments perpendicular, * constrain line segments to a 90° angle. This is a truly degenerate case and so it is not considered very important. However, we can fix this later by using Eigen::SparseQR.
2016-01-21 15:01:43 +00:00
bool Group::IsSolvedOkay() {
return this->solved.how == System::SOLVED_OKAY ||
Enable and mollify -Wunused-variable. In my (whitequark's) experience this warning tends to expose copy-paste errors with a high SNR, so making a few fragments slightly less symmetric is worth it. Also mollify -Wlogical-op-parentheses while we're at it.
2016-02-14 00:36:54 +00:00
(this->allowRedundant && this->solved.how == System::REDUNDANT_OKAY);
Add a setting that permits a group to include redundant constraints. This setting is generally useful, but it especially shines when assembling, since the "same orientation" and "parallel" constraints remove three and two rotational degrees of freedom, which makes them impossible to use with 3d "point on line" constraint that removes two spatial and two rotational degrees of freedom. The setting is not enabled for all imported groups by default because it exhibits some edge case failures. For example: * draw two line segments sharing a point, * constrain lengths of line segments, * constrain line segments perpendicular, * constrain line segments to a 90° angle. This is a truly degenerate case and so it is not considered very important. However, we can fix this later by using Eigen::SparseQR.
2016-01-21 15:01:43 +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
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) {
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(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);
Miscellaneous adjustments for warnings and code quality This commit contains a grab bag of minor changes not worth committing individually: * Replaced raw Latin-1 characters with octal escapes to avoid source-file encoding issues * Undefined some convenience macros after they've served their purpose * Rewrote SEdge::From() to avoid confusing less-capable C++ compilers * Have oops() print a newline at the end of its message * Removed "static" keyword from the Bernstein() function definition, as it has a non-static prototype in srf/surface.h * Added casts (and changed a variable type) to quell warnings about integer size and signedness * Simplified an expression with our handy arraylen() macro
2013-09-19 06:35:56 +00:00
#undef EC
#undef EP
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
Replace all ZERO and memset with C++11 brace-initialization. This will allow us to use non-POD classes inside these objects in future and is otherwise functionally equivalent, as well as more concise. Note that there are some subtleties with handling of brace-initialization. Specifically: On aggregates (e.g. simple C-style structures) using an empty brace-initializer zero-initializes the aggregate, i.e. it makes all members zero. On non-aggregates an empty brace-initializer calls the default constructor. And if the constructor doesn't explicitly initialize the members (which the auto-generated constructor doesn't) then the members will be constructed but otherwise uninitialized. So, what is an aggregate class? To quote the C++ standard (C++03 8.5.1 §1): An aggregate is an array or a class (clause 9) with no user-declared constructors (12.1), no private or protected non-static data members (clause 11), no base classes (clause 10), and no virtual functions (10.3). In SolveSpace, we only have to handle the case of base classes; Constraint and Entity have those. Thus, they had to gain a default constructor that does nothing but initializes the members to zero.
2015-03-27 15:31:23 +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
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
}
}
Generate primitives for lathe groups. The primitives that are generated are circles from points and faces from axis-perpendicular line segments.
2015-10-31 08:22:26 +00:00
void Group::MakeLatheCircles(IdList<Entity,hEntity> *el, IdList<Param,hParam> *param, hEntity in, Vector pt, Vector axis, int ai) {
Entity *ep = SK.GetEntity(in);
Entity en = {};
if(ep->IsPoint()) {
// A point gets revolved to form an arc.
en.point[0] = Remap(predef.origin, ai);
en.point[1] = Remap(ep->h, REMAP_LATHE_START);
en.point[2] = Remap(ep->h, REMAP_LATHE_END);
// Get arc center and point on arc.
Entity *pc = SK.GetEntity(en.point[0]);
Entity *pp = SK.GetEntity(en.point[1]);
// Project arc point to the revolution axis and use it for arc center.
double k = pp->numPoint.Minus(pt).Dot(axis) / axis.Dot(axis);
pc->numPoint = pt.Plus(axis.ScaledBy(k));
// Create arc entity.
en.group = h;
en.construction = ep->construction;
en.style = ep->style;
en.h = Remap(ep->h, REMAP_PT_TO_ARC);
en.type = Entity::ARC_OF_CIRCLE;
// Generate a normal.
Entity n = {};
n.workplane = en.workplane;
n.h = Remap(ep->h, REMAP_PT_TO_NORMAL);
n.group = en.group;
n.style = en.style;
n.type = Entity::NORMAL_N_COPY;
// Create basis for the normal.
Vector nu = pp->numPoint.Minus(pc->numPoint).WithMagnitude(1.0);
Vector nv = nu.Cross(axis).WithMagnitude(1.0);
n.numNormal = Quaternion::From(nv, nu);
// The point determines where the normal gets displayed on-screen;
// it's entirely cosmetic.
n.point[0] = en.point[0];
el->Add(&n);
en.normal = n.h;
el->Add(&en);
} else if(ep->type == Entity::LINE_SEGMENT) {
// An axis-perpendicular line gets revolved to form a face.
Vector a = SK.GetEntity(ep->point[0])->PointGetNum();
Vector b = SK.GetEntity(ep->point[1])->PointGetNum();
Vector u = b.Minus(a).WithMagnitude(1.0);
// Check for perpendicularity: calculate cosine of the angle
// between axis and line direction and check that
// cos(angle) == 0 <-> angle == +-90 deg.
if(fabs(u.Dot(axis) / axis.Magnitude()) < ANGLE_COS_EPS) {
en.param[0] = h.param(0);
en.param[1] = h.param(1);
en.param[2] = h.param(2);
Vector v = axis.Cross(u).WithMagnitude(1.0);
Vector n = u.Cross(v);
en.numNormal = Quaternion::From(0, n.x, n.y, n.z);
en.group = h;
en.construction = ep->construction;
en.style = ep->style;
en.h = Remap(ep->h, REMAP_LINE_TO_FACE);
en.type = Entity::FACE_NORMAL_PT;
en.point[0] = ep->point[0];
el->Add(&en);
}
}
}
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
Replace all ZERO and memset with C++11 brace-initialization. This will allow us to use non-POD classes inside these objects in future and is otherwise functionally equivalent, as well as more concise. Note that there are some subtleties with handling of brace-initialization. Specifically: On aggregates (e.g. simple C-style structures) using an empty brace-initializer zero-initializes the aggregate, i.e. it makes all members zero. On non-aggregates an empty brace-initializer calls the default constructor. And if the constructor doesn't explicitly initialize the members (which the auto-generated constructor doesn't) then the members will be constructed but otherwise uninitialized. So, what is an aggregate class? To quote the C++ standard (C++03 8.5.1 §1): An aggregate is an array or a class (clause 9) with no user-declared constructors (12.1), no private or protected non-static data members (clause 11), no base classes (clause 10), and no virtual functions (10.3). In SolveSpace, we only have to handle the case of base classes; Constraint and Entity have those. Thus, they had to gain a default constructor that does nothing but initializes the members to zero.
2015-03-27 15:31:23 +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
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
{
Replace all ZERO and memset with C++11 brace-initialization. This will allow us to use non-POD classes inside these objects in future and is otherwise functionally equivalent, as well as more concise. Note that there are some subtleties with handling of brace-initialization. Specifically: On aggregates (e.g. simple C-style structures) using an empty brace-initializer zero-initializes the aggregate, i.e. it makes all members zero. On non-aggregates an empty brace-initializer calls the default constructor. And if the constructor doesn't explicitly initialize the members (which the auto-generated constructor doesn't) then the members will be constructed but otherwise uninitialized. So, what is an aggregate class? To quote the C++ standard (C++03 8.5.1 §1): An aggregate is an array or a class (clause 9) with no user-declared constructors (12.1), no private or protected non-static data members (clause 11), no base classes (clause 10), and no virtual functions (10.3). In SolveSpace, we only have to handle the case of base classes; Constraint and Entity have those. Thus, they had to gain a default constructor that does nothing but initializes the members to zero.
2015-03-27 15:31:23 +00:00
Entity 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;
Replace NameStr with std::string. This removes the arbitrary 64 byte restriction (which effectively limits us to as little as 16 Unicode characters with CJK encodings), makes classes smaller, and is easier to use. As a consequence of making the length of all ex-NameStr fields unbounded, all functions that returned a buffer derived from those were changed to return std::string. Then, functions that are contextually similar to the ones described above were changed to return std::string. Then, functions that now happened to mostly take an std::string argument converted to a C string were changed to accept std::string. This has produced a bit of churn, but is probably for the better.
2015-11-06 08:40:12 +00:00
en.str = ep->str;
en.font = ep->font;
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
Trim trailing whitespace.
2015-03-29 00:30:52 +00:00
// came from a copy (e.g. step and repeat) of a force-hidden imported
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
// 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
}