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

417 lines
11 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
//-----------------------------------------------------------------------------
// Anything relating to plane polygons and triangles, and (generally, non-
// planar) meshes thereof.
//
// Copyright 2008-2013 Jonathan Westhues.
//-----------------------------------------------------------------------------
Add horizontal and vertical constraints. Those have their own 2d/3d issues, when the points are not all in the same coordinate system. All painful, of course. Also add continuous line drawing, and auto-constraining of line segments as I draw. [git-p4: depot-paths = "//depot/solvespace/": change = 1683]
2008-04-23 07:29:19 +00:00
Clean up includes and include guards. According to the C standard all preprocessor definitions starting with an underscore are reserved for standard and implementation use, so don't use those. Also, sort and unique include directives.
2018-07-12 18:48:51 +00:00
#ifndef SOLVESPACE_POLYGON_H
#define SOLVESPACE_POLYGON_H
Add horizontal and vertical constraints. Those have their own 2d/3d issues, when the points are not all in the same coordinate system. All painful, of course. Also add continuous line drawing, and auto-constraining of line segments as I draw. [git-p4: depot-paths = "//depot/solvespace/": change = 1683]
2008-04-23 07:29:19 +00:00
Replace the closed-form solutions for entity-entity splitting with a method that works on the piecewise linear segments, and then refines any intersections that it finds by Newton's method. So now I support cubics too, and circle-circle intersections, and the code is much simpler. [git-p4: depot-paths = "//depot/solvespace/": change = 2012]
2009-07-07 08:21:59 +00:00
class SPointList;
Add code to assemble the piecewise linear segments in a group into a polygon, and to fill that polygon. [git-p4: depot-paths = "//depot/solvespace/": change = 1686]
2008-04-25 07:04:09 +00:00
class SPolygon;
Add sweeps. The user specifies a trajectory and a section, in two separate groups. The section is swept normal to the trajectory, producing a mesh. I'm doing the triangles only now, not copying over any entities. Also fix a bug in the PNG export; rows are 4-aligned, so that was breaking when the width of the image wasn't divisible by four. Also fix a bug in lathes, where it generated overlapping triangles for one segment. And change the groups to record both "this mesh", the contribution due to the extrude/lathe/whatever, and the "running mesh", that we get after applying the requested Boolean op between "this mesh" and the previous group's "running mesh". I'll use that to make step and repeats step the mesh too. [git-p4: depot-paths = "//depot/solvespace/": change = 1801]
2008-06-21 10:18:20 +00:00
class SContour;
Add polygon triangulation, by cheating. I'm using the gl tesselator for that, and storing the triangles instead of rendering them immediately. Not sure if that's smart; in theory could change from implementation to implementation, but the results look much better than I would get myself. [git-p4: depot-paths = "//depot/solvespace/": change = 1733]
2008-05-22 10:28:28 +00:00
class SMesh;
Make coplanar faces work properly, by implementing a 2d BSP on each set of coplanar faces. The polygon count still gets stupid fast; I'm thinking I can fix that by adding some extra test planes at the top of the 3d BSP, to quickly cull out stuff that doesn't intersect us. [git-p4: depot-paths = "//depot/solvespace/": change = 1736]
2008-05-24 10:34:06 +00:00
class SBsp3;
Allow rendering solid outlines using a distinct style. A new button is added, "Show/hide outline of solid model". When the outline is hidden, it is rendered using the "solid edge" style. When the outline is shown, it is rendered using the "outline" style. In SolveSpace's true WYSIWYG tradition, the 2d view export follows the rendered view exactly. Moreover, shell edges are not rendered anymore, since there is not much need in them anymore and not drawing them lessens the overlap between various kinds of lines, which already includes entities, solid edges and outlines.
2016-03-14 16:14:24 +00:00
class SOutlineList;
Add code to assemble the piecewise linear segments in a group into a polygon, and to fill that polygon. [git-p4: depot-paths = "//depot/solvespace/": change = 1686]
2008-04-25 07:04:09 +00:00
Convert all enumerations to use `enum class`. Specifically, take the old code that looks like this: class Foo { enum { X = 1, Y = 2 }; int kind; } ... foo.kind = Foo::X; ... and convert it to this: class Foo { enum class Kind : uint32_t { X = 1, Y = 2 }; Kind kind; } ... foo.kind = Foo::Kind::X; (In some cases the enumeration would not be in the class namespace, such as when it is generally useful.) The benefits are as follows: * The type of the field gives a clear indication of intent, both to humans and tools (such as binding generators). * The compiler is able to automatically warn when a switch is not exhaustive; but this is currently suppressed by the default: ssassert(false, ...) idiom. * Integers and plain enums are weakly type checked: they implicitly convert into each other. This can hide bugs where type conversion is performed but not intended. Enum classes are strongly type checked. * Plain enums pollute parent namespaces; enum classes do not. Almost every defined enum we have already has a kind of ad-hoc namespacing via `NAMESPACE_`, which is now explicit. * Plain enums do not have a well-defined ABI size, which is important for bindings. Enum classes can have it, if specified. We specify the base type for all enums as uint32_t, which is a safe choice and allows us to not change the numeric values of any variants. This commit introduces absolutely no functional change to the code, just renaming and change of types. It handles almost all cases, except GraphicsWindow::pending.operation, which needs minor functional change.
2016-05-20 08:31:20 +00:00
enum class EarType : uint32_t {
UNKNOWN = 0,
NOT_EAR = 1,
EAR = 2
};
enum class BspClass : uint32_t {
POS = 100,
NEG = 101,
COPLANAR = 200
};
Abstract all (ex-OpenGL) drawing operations into a Canvas interface. This has several desirable consequences: * It is now possible to port SolveSpace to a later version of OpenGL, such as OpenGLES 2, so that it runs on platforms that only have that OpenGL version; * The majority of geometry is now rendered without references to the camera in C++ code, so a renderer can now submit it to the video card once and re-rasterize with a different projection matrix every time the projection is changed, avoiding expensive reuploads; * The DOGD (draw or get distance) interface is now a straightforward Canvas implementation; * There are no more direct references to SS.GW.(projection) in sketch rendering code, which allows rendering to multiple viewports; * There are no more unnecessary framebuffer flips on CPU on Cocoa and GTK; * The platform-dependent GL code is now confined to rendergl1.cpp. * The Microsoft and Apple headers required by it that are prone to identifier conflicts are no longer included globally; * The rendergl1.cpp implementation can now be omitted from compilation to run SolveSpace headless or with a different OpenGL version. Note these implementation details of Canvas: * GetCamera currently always returns a reference to the field `Camera camera;`. This is so that a future renderer that caches geometry in the video memory can define it as asserting, which would provide assurance against code that could accidentally put something projection-dependent in the cache; * Line and triangle rendering is specified through a level of indirection, hStroke and hFill. This is so that a future renderer that batches geometry could cheaply group identical styles. * DrawPixmap and DrawVectorText accept a (o,u,v) and not a matrix. This is so that a future renderer into an output format that uses 2d transforms (e.g. SVG) could easily derive those. Some additional internal changes were required to enable this: * Pixmap is now always passed as std::shared_ptr<{const ,}Pixmap>. This is so that the renderer could cache uploaded textures between API calls, which requires it to capture a (weak) reference. * The PlatformPathEqual function was properly extracted into platform-specific code. This is so that the <windows.h> header could be included only where needed (in platform/w32* as well as rendergl1.cpp). * The SBsp{2,3}::DebugDraw functions were removed. They can be rewritten using the Canvas API if they are ever needed. While no visual changes were originally intended, some minor fixes happened anyway: * The "emphasis" yellow line from top-left corner is now correctly rendered much wider. * The marquee rectangle is now pixel grid aligned. * The hidden entities now do not clobber the depth buffer, removing some minor artifacts. * The workplane "tab" now scales with the font used to render the workplane name. * The workplane name font is now taken from the normals style. * Workplane and constraint line stipple is insignificantly different. This is so that it can reuse the existing stipple codepaths; rendering of workplanes and constraints predates those. Some debug functionality was added: * In graphics window, an fps counter that becomes red when rendering under 60fps is drawn.
2016-05-31 00:55:13 +00:00
Convert all enumerations to use `enum class`. Specifically, take the old code that looks like this: class Foo { enum { X = 1, Y = 2 }; int kind; } ... foo.kind = Foo::X; ... and convert it to this: class Foo { enum class Kind : uint32_t { X = 1, Y = 2 }; Kind kind; } ... foo.kind = Foo::Kind::X; (In some cases the enumeration would not be in the class namespace, such as when it is generally useful.) The benefits are as follows: * The type of the field gives a clear indication of intent, both to humans and tools (such as binding generators). * The compiler is able to automatically warn when a switch is not exhaustive; but this is currently suppressed by the default: ssassert(false, ...) idiom. * Integers and plain enums are weakly type checked: they implicitly convert into each other. This can hide bugs where type conversion is performed but not intended. Enum classes are strongly type checked. * Plain enums pollute parent namespaces; enum classes do not. Almost every defined enum we have already has a kind of ad-hoc namespacing via `NAMESPACE_`, which is now explicit. * Plain enums do not have a well-defined ABI size, which is important for bindings. Enum classes can have it, if specified. We specify the base type for all enums as uint32_t, which is a safe choice and allows us to not change the numeric values of any variants. This commit introduces absolutely no functional change to the code, just renaming and change of types. It handles almost all cases, except GraphicsWindow::pending.operation, which needs minor functional change.
2016-05-20 08:31:20 +00:00
enum class EdgeKind : uint32_t {
NAKED_OR_SELF_INTER = 100,
SELF_INTER = 200,
TURNING = 300,
EMPHASIZED = 400,
SHARP = 500,
};
Rough file/save for SolveSpace; that's all done from a single table, relatively small code size. No user interface for it, though. [git-p4: depot-paths = "//depot/solvespace/": change = 1685]
2008-04-24 06:22:16 +00:00
class SEdge {
Add horizontal and vertical constraints. Those have their own 2d/3d issues, when the points are not all in the same coordinate system. All painful, of course. Also add continuous line drawing, and auto-constraining of line segments as I draw. [git-p4: depot-paths = "//depot/solvespace/": change = 1683]
2008-04-23 07:29:19 +00:00
public:
Add code to assemble the piecewise linear segments in a group into a polygon, and to fill that polygon. [git-p4: depot-paths = "//depot/solvespace/": change = 1686]
2008-04-25 07:04:09 +00:00
int tag;
Preparatory work for Boolean. Make the u and v coordinates of the trim curves for all surfaces lie between 0 and 1. And add routines to merge the curves and surfaces from two shells into one, and to split the trim curves into their piecewise linear segments and then reassemble them into trim curves. [git-p4: depot-paths = "//depot/solvespace/": change = 1905]
2009-01-25 11:52:29 +00:00
int auxA, auxB;
Rough file/save for SolveSpace; that's all done from a single table, relatively small code size. No user interface for it, though. [git-p4: depot-paths = "//depot/solvespace/": change = 1685]
2008-04-24 06:22:16 +00:00
Vector a, b;
Don't initialize the SEdges with ... = { ... }; use a special function for that. [git-p4: depot-paths = "//depot/solvespace/": change = 1759]
2008-05-30 08:01:19 +00:00
static SEdge From(Vector a, Vector b);
Add const qualifiers to functions where trivially possible. This will allow us in future to accept `const T &` anywhere it's necessary to reduce the amount of copying. This commit is quite conservative: it does not attempt very hard to refactor code that performs incidental mutation. In particular dogd and caches are not marked with the `mutable` keyword. dogd will be eliminated later, opening up more opportunities to add const qualifiers. This commit also doesn't introduce any uses of the newly added const qualifers. This will be done later.
2016-05-21 05:18:00 +00:00
bool EdgeCrosses(Vector a, Vector b, Vector *pi=NULL, SPointList *spl=NULL) const;
Rough file/save for SolveSpace; that's all done from a single table, relatively small code size. No user interface for it, though. [git-p4: depot-paths = "//depot/solvespace/": change = 1685]
2008-04-24 06:22:16 +00:00
};
class SEdgeList {
public:
Add menu item to center view at a point; and move non-ID list data structure from polygon.h into dsc.h, since it is used outside the polygon/mesh code. [git-p4: depot-paths = "//depot/solvespace/": change = 1892]
2009-01-13 06:56:05 +00:00
List<SEdge> l;
Rough file/save for SolveSpace; that's all done from a single table, relatively small code size. No user interface for it, though. [git-p4: depot-paths = "//depot/solvespace/": change = 1685]
2008-04-24 06:22:16 +00:00
Rewrite declarations of form f(void) as f(). In C++ there is no difference and newly added functions are all declared as f(), so this brings back consistency.
2016-05-05 05:54:05 +00:00
void Clear();
Add a new renderer that prepares geometry for 2d backends. SurfaceRenderer is a new renderer implementing the Canvas interface running entirely on the CPU; it projects strokes and triangles in the exact same way as OpenGL would, and it can be used for rendering into raster or vector 2d surfaces.
2016-07-21 20:27:53 +00:00
void AddEdge(Vector a, Vector b, int auxA=0, int auxB=0, int tag=0);
Add const qualifiers to functions where trivially possible. This will allow us in future to accept `const T &` anywhere it's necessary to reduce the amount of copying. This commit is quite conservative: it does not attempt very hard to refactor code that performs incidental mutation. In particular dogd and caches are not marked with the `mutable` keyword. dogd will be eliminated later, opening up more opportunities to add const qualifiers. This commit also doesn't introduce any uses of the newly added const qualifers. This will be done later.
2016-05-21 05:18:00 +00:00
bool AssemblePolygon(SPolygon *dest, SEdge *errorAt, bool keepDir=false) const;
Add sweeps. The user specifies a trajectory and a section, in two separate groups. The section is swept normal to the trajectory, producing a mesh. I'm doing the triangles only now, not copying over any entities. Also fix a bug in the PNG export; rows are 4-aligned, so that was breaking when the width of the image wasn't divisible by four. Also fix a bug in lathes, where it generated overlapping triangles for one segment. And change the groups to record both "this mesh", the contribution due to the extrude/lathe/whatever, and the "running mesh", that we get after applying the requested Boolean op between "this mesh" and the previous group's "running mesh". I'll use that to make step and repeats step the mesh too. [git-p4: depot-paths = "//depot/solvespace/": change = 1801]
2008-06-21 10:18:20 +00:00
bool AssembleContour(Vector first, Vector last, SContour *dest,
Add const qualifiers to functions where trivially possible. This will allow us in future to accept `const T &` anywhere it's necessary to reduce the amount of copying. This commit is quite conservative: it does not attempt very hard to refactor code that performs incidental mutation. In particular dogd and caches are not marked with the `mutable` keyword. dogd will be eliminated later, opening up more opportunities to add const qualifiers. This commit also doesn't introduce any uses of the newly added const qualifers. This will be done later.
2016-05-21 05:18:00 +00:00
SEdge *errorAt, bool keepDir) const;
Replace the closed-form solutions for entity-entity splitting with a method that works on the piecewise linear segments, and then refines any intersections that it finds by Newton's method. So now I support cubics too, and circle-circle intersections, and the code is much simpler. [git-p4: depot-paths = "//depot/solvespace/": change = 2012]
2009-07-07 08:21:59 +00:00
int AnyEdgeCrossings(Vector a, Vector b,
Add const qualifiers to functions where trivially possible. This will allow us in future to accept `const T &` anywhere it's necessary to reduce the amount of copying. This commit is quite conservative: it does not attempt very hard to refactor code that performs incidental mutation. In particular dogd and caches are not marked with the `mutable` keyword. dogd will be eliminated later, opening up more opportunities to add const qualifiers. This commit also doesn't introduce any uses of the newly added const qualifers. This will be done later.
2016-05-21 05:18:00 +00:00
Vector *pi=NULL, SPointList *spl=NULL) const;
bool ContainsEdgeFrom(const SEdgeList *sel) const;
bool ContainsEdge(const SEdge *se) const;
Include custom styled entities in the same plane when exporting section.
2019-05-13 14:34:22 +00:00
void CullExtraneousEdges(bool both=true);
The hidden line removal unnecessarily splits our edges, which bloats the output file size. So reassemble the edges whenever possible. [git-p4: depot-paths = "//depot/solvespace/": change = 1935]
2009-04-08 04:54:07 +00:00
void MergeCollinearSegments(Vector a, Vector b);
Add code to assemble the piecewise linear segments in a group into a polygon, and to fill that polygon. [git-p4: depot-paths = "//depot/solvespace/": change = 1686]
2008-04-25 07:04:09 +00:00
};
Add O(n*log(n)) self-intersection check for polygons. That was previously a major bottleneck, and is now at least 10x faster for a practical section. And fix a horrible uninit memory bug in the triangle kd-tree stuff; the split planes were apparently random. This would have slowed things down, but not caused an incorrect result; except when it ends up NaN, which is the reason I noticed. [git-p4: depot-paths = "//depot/solvespace/": change = 2073]
2009-11-09 11:51:38 +00:00
// A kd-tree element needs to go on a side of a node if it's when KDTREE_EPS
// of the boundary. So increasing this number never breaks anything, but may
// result in more duplicated elements. So it's conservative to be sloppy here.
#define KDTREE_EPS (20*LENGTH_EPS)
class SEdgeLl {
public:
SEdge *se;
SEdgeLl *next;
Rewrite declarations of form f(void) as f(). In C++ there is no difference and newly added functions are all declared as f(), so this brings back consistency.
2016-05-05 05:54:05 +00:00
static SEdgeLl *Alloc();
Add O(n*log(n)) self-intersection check for polygons. That was previously a major bottleneck, and is now at least 10x faster for a practical section. And fix a horrible uninit memory bug in the triangle kd-tree stuff; the split planes were apparently random. This would have slowed things down, but not caused an incorrect result; except when it ends up NaN, which is the reason I noticed. [git-p4: depot-paths = "//depot/solvespace/": change = 2073]
2009-11-09 11:51:38 +00:00
};
class SKdNodeEdges {
public:
int which; // whether c is x, y, or z
double c;
SKdNodeEdges *gt;
SKdNodeEdges *lt;
SEdgeLl *edges;
static SKdNodeEdges *From(SEdgeList *sel);
static SKdNodeEdges *From(SEdgeLl *sell);
Rewrite declarations of form f(void) as f(). In C++ there is no difference and newly added functions are all declared as f(), so this brings back consistency.
2016-05-05 05:54:05 +00:00
static SKdNodeEdges *Alloc();
Add O(n*log(n)) self-intersection check for polygons. That was previously a major bottleneck, and is now at least 10x faster for a practical section. And fix a horrible uninit memory bug in the triangle kd-tree stuff; the split planes were apparently random. This would have slowed things down, but not caused an incorrect result; except when it ends up NaN, which is the reason I noticed. [git-p4: depot-paths = "//depot/solvespace/": change = 2073]
2009-11-09 11:51:38 +00:00
int AnyEdgeCrossings(Vector a, Vector b, int cnt,
Add const qualifiers to functions where trivially possible. This will allow us in future to accept `const T &` anywhere it's necessary to reduce the amount of copying. This commit is quite conservative: it does not attempt very hard to refactor code that performs incidental mutation. In particular dogd and caches are not marked with the `mutable` keyword. dogd will be eliminated later, opening up more opportunities to add const qualifiers. This commit also doesn't introduce any uses of the newly added const qualifers. This will be done later.
2016-05-21 05:18:00 +00:00
Vector *pi=NULL, SPointList *spl=NULL) const;
Add O(n*log(n)) self-intersection check for polygons. That was previously a major bottleneck, and is now at least 10x faster for a practical section. And fix a horrible uninit memory bug in the triangle kd-tree stuff; the split planes were apparently random. This would have slowed things down, but not caused an incorrect result; except when it ends up NaN, which is the reason I noticed. [git-p4: depot-paths = "//depot/solvespace/": change = 2073]
2009-11-09 11:51:38 +00:00
};
Add code to assemble the piecewise linear segments in a group into a polygon, and to fill that polygon. [git-p4: depot-paths = "//depot/solvespace/": change = 1686]
2008-04-25 07:04:09 +00:00
class SPoint {
public:
int tag;
A very rough set of routines to triangulate by ear clipping. This is O(n^2), not perfectly robust, and the bridge-finding code is particularly bad. But it works, triangulates, and shouldn't ever generate zero-area triangles like gl does. [git-p4: depot-paths = "//depot/solvespace/": change = 1900]
2009-01-21 05:04:38 +00:00
Convert all enumerations to use `enum class`. Specifically, take the old code that looks like this: class Foo { enum { X = 1, Y = 2 }; int kind; } ... foo.kind = Foo::X; ... and convert it to this: class Foo { enum class Kind : uint32_t { X = 1, Y = 2 }; Kind kind; } ... foo.kind = Foo::Kind::X; (In some cases the enumeration would not be in the class namespace, such as when it is generally useful.) The benefits are as follows: * The type of the field gives a clear indication of intent, both to humans and tools (such as binding generators). * The compiler is able to automatically warn when a switch is not exhaustive; but this is currently suppressed by the default: ssassert(false, ...) idiom. * Integers and plain enums are weakly type checked: they implicitly convert into each other. This can hide bugs where type conversion is performed but not intended. Enum classes are strongly type checked. * Plain enums pollute parent namespaces; enum classes do not. Almost every defined enum we have already has a kind of ad-hoc namespacing via `NAMESPACE_`, which is now explicit. * Plain enums do not have a well-defined ABI size, which is important for bindings. Enum classes can have it, if specified. We specify the base type for all enums as uint32_t, which is a safe choice and allows us to not change the numeric values of any variants. This commit introduces absolutely no functional change to the code, just renaming and change of types. It handles almost all cases, except GraphicsWindow::pending.operation, which needs minor functional change.
2016-05-20 08:31:20 +00:00
EarType ear;
A very rough set of routines to triangulate by ear clipping. This is O(n^2), not perfectly robust, and the bridge-finding code is particularly bad. But it works, triangulates, and shouldn't ever generate zero-area triangles like gl does. [git-p4: depot-paths = "//depot/solvespace/": change = 1900]
2009-01-21 05:04:38 +00:00
Add code to assemble the piecewise linear segments in a group into a polygon, and to fill that polygon. [git-p4: depot-paths = "//depot/solvespace/": change = 1686]
2008-04-25 07:04:09 +00:00
Vector p;
Now we are actually marching. There seems to be either a numerical problem or a tendency to generate backwards edges or both, need to debug that. But it generates the curve, and begins to work. And change the edge classification. Now instead of testing for point-on-surface using the results of the raycasting, test for point-on-surface as a separate step. That stops us from picking up the additional numerical error from the surface-line intersection, which may be significant if the ray is parallel or almost parallel to the surface. [git-p4: depot-paths = "//depot/solvespace/": change = 1991]
2009-06-21 09:02:36 +00:00
Vector auxv;
Add horizontal and vertical constraints. Those have their own 2d/3d issues, when the points are not all in the same coordinate system. All painful, of course. Also add continuous line drawing, and auto-constraining of line segments as I draw. [git-p4: depot-paths = "//depot/solvespace/": change = 1683]
2008-04-23 07:29:19 +00:00
};
Add beginnings of marching surface intersection; I can find all the boundary points, at least. That required some changes to what gets passed around (for example because to project a point onto this inexact curve, we need to know which two surfaces it trims so that we can do a Newton's method on them). And fix stupidity in the way that I calculated edge normals; I just did normal in uv space, and there's no particular reason why that would be normal in xyz. So edges in long skinny surfaces failed, for example. [git-p4: depot-paths = "//depot/solvespace/": change = 1990]
2009-06-19 07:56:33 +00:00
class SPointList {
public:
List<SPoint> l;
Rewrite declarations of form f(void) as f(). In C++ there is no difference and newly added functions are all declared as f(), so this brings back consistency.
2016-05-05 05:54:05 +00:00
void Clear();
Add const qualifiers to functions where trivially possible. This will allow us in future to accept `const T &` anywhere it's necessary to reduce the amount of copying. This commit is quite conservative: it does not attempt very hard to refactor code that performs incidental mutation. In particular dogd and caches are not marked with the `mutable` keyword. dogd will be eliminated later, opening up more opportunities to add const qualifiers. This commit also doesn't introduce any uses of the newly added const qualifers. This will be done later.
2016-05-21 05:18:00 +00:00
bool ContainsPoint(Vector pt) const;
int IndexForPoint(Vector pt) const;
Group edges into chains (that don't intersect edges from the other contour, except at the ends of the chain), and classify the entire chain. That's much faster than going edge by edge. [git-p4: depot-paths = "//depot/solvespace/": change = 2002]
2009-06-27 05:53:56 +00:00
void IncrementTagFor(Vector pt);
Add beginnings of marching surface intersection; I can find all the boundary points, at least. That required some changes to what gets passed around (for example because to project a point onto this inexact curve, we need to know which two surfaces it trims so that we can do a Newton's method on them). And fix stupidity in the way that I calculated edge normals; I just did normal in uv space, and there's no particular reason why that would be normal in xyz. So edges in long skinny surfaces failed, for example. [git-p4: depot-paths = "//depot/solvespace/": change = 1990]
2009-06-19 07:56:33 +00:00
void Add(Vector pt);
};
Add horizontal and vertical constraints. Those have their own 2d/3d issues, when the points are not all in the same coordinate system. All painful, of course. Also add continuous line drawing, and auto-constraining of line segments as I draw. [git-p4: depot-paths = "//depot/solvespace/": change = 1683]
2008-04-23 07:29:19 +00:00
class SContour {
public:
Generate the group's polygon from the exact curves, not from edges; so now we've got the exact curve loops, with their direction standardized so that we can tell which direction is out. We still need the polygon in any case, since that's a convenient way to find each curve's winding number. And remove some more leftover code from mesh sweeps. [git-p4: depot-paths = "//depot/solvespace/": change = 1897]
2009-01-19 03:33:15 +00:00
int tag;
A very rough set of routines to triangulate by ear clipping. This is O(n^2), not perfectly robust, and the bridge-finding code is particularly bad. But it works, triangulates, and shouldn't ever generate zero-area triangles like gl does. [git-p4: depot-paths = "//depot/solvespace/": change = 1900]
2009-01-21 05:04:38 +00:00
int timesEnclosed;
Fix an issue with edge intersection testing: if a vertex from edge A touches edge B, but does not share a vertex with edge B, then that's an intersection. Adjust the ear clipping so that it generates strip-like triangulations, not fan-like. And rearrange deck chairs on the bridge-finding code, which is still pathetically slow. It may not be possible to get reasonable performance without kd tree type acceleration. [git-p4: depot-paths = "//depot/solvespace/": change = 1901]
2009-01-22 10:02:46 +00:00
Vector xminPt;
Add menu item to center view at a point; and move non-ID list data structure from polygon.h into dsc.h, since it is used outside the polygon/mesh code. [git-p4: depot-paths = "//depot/solvespace/": change = 1892]
2009-01-13 06:56:05 +00:00
List<SPoint> l;
Make the extrude command do a bit more; now I generate all the faces of the polyhedron. And shade the faces when I draw them, and fix up our projection matrix so that the depth testing works properly. [git-p4: depot-paths = "//depot/solvespace/": change = 1703]
2008-05-02 10:54:22 +00:00
Add sweeps. The user specifies a trajectory and a section, in two separate groups. The section is swept normal to the trajectory, producing a mesh. I'm doing the triangles only now, not copying over any entities. Also fix a bug in the PNG export; rows are 4-aligned, so that was breaking when the width of the image wasn't divisible by four. Also fix a bug in lathes, where it generated overlapping triangles for one segment. And change the groups to record both "this mesh", the contribution due to the extrude/lathe/whatever, and the "running mesh", that we get after applying the requested Boolean op between "this mesh" and the previous group's "running mesh". I'll use that to make step and repeats step the mesh too. [git-p4: depot-paths = "//depot/solvespace/": change = 1801]
2008-06-21 10:18:20 +00:00
void AddPoint(Vector p);
Add const qualifiers to functions where trivially possible. This will allow us in future to accept `const T &` anywhere it's necessary to reduce the amount of copying. This commit is quite conservative: it does not attempt very hard to refactor code that performs incidental mutation. In particular dogd and caches are not marked with the `mutable` keyword. dogd will be eliminated later, opening up more opportunities to add const qualifiers. This commit also doesn't introduce any uses of the newly added const qualifers. This will be done later.
2016-05-21 05:18:00 +00:00
void MakeEdgesInto(SEdgeList *el) const;
Rewrite declarations of form f(void) as f(). In C++ there is no difference and newly added functions are all declared as f(), so this brings back consistency.
2016-05-05 05:54:05 +00:00
void Reverse();
Add const qualifiers to functions where trivially possible. This will allow us in future to accept `const T &` anywhere it's necessary to reduce the amount of copying. This commit is quite conservative: it does not attempt very hard to refactor code that performs incidental mutation. In particular dogd and caches are not marked with the `mutable` keyword. dogd will be eliminated later, opening up more opportunities to add const qualifiers. This commit also doesn't introduce any uses of the newly added const qualifers. This will be done later.
2016-05-21 05:18:00 +00:00
Vector ComputeNormal() const;
double SignedAreaProjdToNormal(Vector n) const;
bool IsClockwiseProjdToNormal(Vector n) const;
bool ContainsPointProjdToNormal(Vector n, Vector p) const;
void OffsetInto(SContour *dest, double r) const;
void CopyInto(SContour *dest) const;
Rewrite declarations of form f(void) as f(). In C++ there is no difference and newly added functions are all declared as f(), so this brings back consistency.
2016-05-05 05:54:05 +00:00
void FindPointWithMinX();
Add const qualifiers to functions where trivially possible. This will allow us in future to accept `const T &` anywhere it's necessary to reduce the amount of copying. This commit is quite conservative: it does not attempt very hard to refactor code that performs incidental mutation. In particular dogd and caches are not marked with the `mutable` keyword. dogd will be eliminated later, opening up more opportunities to add const qualifiers. This commit also doesn't introduce any uses of the newly added const qualifers. This will be done later.
2016-05-21 05:18:00 +00:00
Vector AnyEdgeMidpoint() const;
A very rough set of routines to triangulate by ear clipping. This is O(n^2), not perfectly robust, and the bridge-finding code is particularly bad. But it works, triangulates, and shouldn't ever generate zero-area triangles like gl does. [git-p4: depot-paths = "//depot/solvespace/": change = 1900]
2009-01-21 05:04:38 +00:00
Add const qualifiers to functions where trivially possible. This will allow us in future to accept `const T &` anywhere it's necessary to reduce the amount of copying. This commit is quite conservative: it does not attempt very hard to refactor code that performs incidental mutation. In particular dogd and caches are not marked with the `mutable` keyword. dogd will be eliminated later, opening up more opportunities to add const qualifiers. This commit also doesn't introduce any uses of the newly added const qualifers. This will be done later.
2016-05-21 05:18:00 +00:00
bool IsEar(int bp, double scaledEps) const;
A very rough set of routines to triangulate by ear clipping. This is O(n^2), not perfectly robust, and the bridge-finding code is particularly bad. But it works, triangulates, and shouldn't ever generate zero-area triangles like gl does. [git-p4: depot-paths = "//depot/solvespace/": change = 1900]
2009-01-21 05:04:38 +00:00
bool BridgeToContour(SContour *sc, SEdgeList *el, List<Vector> *vl);
Discard intersection curves that lie entirely outside of one surface's domain of u, v in [0, 1]. Cache the starting guess when projecting a point into a ratpoly surface, to avoid brute force searching for a good one every time. Split edges even if they aren't quite inside the trim curve, since the trim boundaries are pwl, not exact; unnecessary splits won't hurt, but failure to split when necessary will. Make the triangulation code use a better (but not perfect) epsilon, to avoid "can't find ear" failures on very fine meshes. And turn on compiler optimization! I had somehow forgotten about that, and it's a ~2x improvement. [git-p4: depot-paths = "//depot/solvespace/": change = 2026]
2009-08-21 04:58:28 +00:00
void ClipEarInto(SMesh *m, int bp, double scaledEps);
When clipping ears to triangulate a curved surface, clip the ear that minimizes the chord tolerance. [git-p4: depot-paths = "//depot/solvespace/": change = 1921]
2009-02-27 14:05:08 +00:00
void UvTriangulateInto(SMesh *m, SSurface *srf);
Add horizontal and vertical constraints. Those have their own 2d/3d issues, when the points are not all in the same coordinate system. All painful, of course. Also add continuous line drawing, and auto-constraining of line segments as I draw. [git-p4: depot-paths = "//depot/solvespace/": change = 1683]
2008-04-23 07:29:19 +00:00
};
Back to opengl's tesselator for triangulation. I'll spend more time writing mine later. [git-p4: depot-paths = "//depot/solvespace/": change = 1810]
2008-06-26 07:28:29 +00:00
typedef struct {
Use C99 integer types and C++ boolean types/values This change comprehensively replaces the use of Microsoft-standard integer and boolean types with their C99/C++ standard equivalents, as the latter is more appropriate for a cross-platform application. With matter-of-course exceptions in the Win32-specific code, the types/values have been converted as follows: QWORD --> uint64_t SQWORD --> int64_t DWORD --> uint32_t SDWORD --> int32_t WORD --> uint16_t SWORD --> int16_t BYTE --> uint8_t BOOL --> bool TRUE --> true FALSE --> false The following related changes are also included: * Added C99 integer type definitions for Windows, as stdint.h is not available prior to Visual Studio 2010 * Changed types of some variables in the SolveSpace class from 'int' to 'bool', as they actually represent boolean settings * Implemented new Cnf{Freeze,Thaw}Bool() functions to support boolean variables in the Registry * Cnf{Freeze,Thaw}DWORD() are now Cnf{Freeze,Thaw}Int() * TtfFont::Get{WORD,DWORD}() are now TtfFont::Get{USHORT,ULONG}() (names inspired by the OpenType spec) * RGB colors are packed into an integer of type uint32_t (nee DWORD), but in a few places, these were represented by an int; these have been corrected to uint32_t
2013-10-02 05:45:13 +00:00
uint32_t face;
Rename RgbColor to RgbaColor.
2015-07-10 11:54:39 +00:00
RgbaColor color;
Back to opengl's tesselator for triangulation. I'll spend more time writing mine later. [git-p4: depot-paths = "//depot/solvespace/": change = 1810]
2008-06-26 07:28:29 +00:00
} STriMeta;
Rough file/save for SolveSpace; that's all done from a single table, relatively small code size. No user interface for it, though. [git-p4: depot-paths = "//depot/solvespace/": change = 1685]
2008-04-24 06:22:16 +00:00
class SPolygon {
public:
Add menu item to center view at a point; and move non-ID list data structure from polygon.h into dsc.h, since it is used outside the polygon/mesh code. [git-p4: depot-paths = "//depot/solvespace/": change = 1892]
2009-01-13 06:56:05 +00:00
List<SContour> l;
Fix some stupid bugs introduced with the new representation of workplanes. And fix up our polygon normals, so that everything gets shaded correctly (and so that later we can generate our STL files with correct normals). [git-p4: depot-paths = "//depot/solvespace/": change = 1706]
2008-05-05 09:47:23 +00:00
Vector normal;
Add code to assemble the piecewise linear segments in a group into a polygon, and to fill that polygon. [git-p4: depot-paths = "//depot/solvespace/": change = 1686]
2008-04-25 07:04:09 +00:00
Implement SPolygon::TriangulateInto.
2016-07-31 10:35:11 +00:00
Vector ComputeNormal() const;
Rewrite declarations of form f(void) as f(). In C++ there is no difference and newly added functions are all declared as f(), so this brings back consistency.
2016-05-05 05:54:05 +00:00
void AddEmptyContour();
Add const qualifiers to functions where trivially possible. This will allow us in future to accept `const T &` anywhere it's necessary to reduce the amount of copying. This commit is quite conservative: it does not attempt very hard to refactor code that performs incidental mutation. In particular dogd and caches are not marked with the `mutable` keyword. dogd will be eliminated later, opening up more opportunities to add const qualifiers. This commit also doesn't introduce any uses of the newly added const qualifers. This will be done later.
2016-05-21 05:18:00 +00:00
int WindingNumberForPoint(Vector p) const;
double SignedArea() const;
bool ContainsPoint(Vector p) const;
void MakeEdgesInto(SEdgeList *el) const;
Rewrite declarations of form f(void) as f(). In C++ there is no difference and newly added functions are all declared as f(), so this brings back consistency.
2016-05-05 05:54:05 +00:00
void FixContourDirections();
void Clear();
Add const qualifiers to functions where trivially possible. This will allow us in future to accept `const T &` anywhere it's necessary to reduce the amount of copying. This commit is quite conservative: it does not attempt very hard to refactor code that performs incidental mutation. In particular dogd and caches are not marked with the `mutable` keyword. dogd will be eliminated later, opening up more opportunities to add const qualifiers. This commit also doesn't introduce any uses of the newly added const qualifers. This will be done later.
2016-05-21 05:18:00 +00:00
bool SelfIntersecting(Vector *intersectsAt) const;
bool IsEmpty() const;
Vector AnyPoint() const;
void OffsetInto(SPolygon *dest, double r) const;
When clipping ears to triangulate a curved surface, clip the ear that minimizes the chord tolerance. [git-p4: depot-paths = "//depot/solvespace/": change = 1921]
2009-02-27 14:05:08 +00:00
void UvTriangulateInto(SMesh *m, SSurface *srf);
Add triangulation of surfaces with compound curvature; I just build a grid of quads, with adaptive spacing. The quads that lie entirely within the trim polygon are triangulated and knocked out from the polygon, and then the polygon is triangulated. That works okay, though rather slow. But there are issues with surfaces of revolution that touch the axis, since they end up with a singularity. That will require some thought. [git-p4: depot-paths = "//depot/solvespace/": change = 1951]
2009-05-08 08:33:04 +00:00
void UvGridTriangulateInto(SMesh *m, SSurface *srf);
Implement SPolygon::TriangulateInto.
2016-07-31 10:35:11 +00:00
void TriangulateInto(SMesh *m) const;
void InverseTransformInto(SPolygon *sp, Vector u, Vector v, Vector n) const;
Rip out the boundary rep csg stuff. I'll redo that with a triangle mesh approach. [git-p4: depot-paths = "//depot/solvespace/": change = 1732]
2008-05-21 03:58:14 +00:00
};
Add constructive solid geometry ops. These work to some extent, but not very well; I'm doing a b-rep, where the boundaries are complex polygons, and there's too many special cases. I should probably replace this with a triangle mesh solution. [git-p4: depot-paths = "//depot/solvespace/": change = 1731]
2008-05-19 09:23:49 +00:00
Rip out the boundary rep csg stuff. I'll redo that with a triangle mesh approach. [git-p4: depot-paths = "//depot/solvespace/": change = 1732]
2008-05-21 03:58:14 +00:00
class STriangle {
public:
Add color. Now each triangle has metadata, which are preserved in csg ops; so the union of a red part and a blue part has both red and blue faces. And some user interface to pick the color in the text window. The metadata also include a face, which will be an entity; I can use that to constrain against. But none of that is yet implemented. [git-p4: depot-paths = "//depot/solvespace/": change = 1757]
2008-05-30 06:09:41 +00:00
int tag;
STriMeta meta;
Allow indexed access to triangle vertices and normals.
2016-06-25 07:00:49 +00:00
union {
struct { Vector a, b, c; };
Vector vertices[3];
};
union {
struct { Vector an, bn, cn; };
Vector normals[3];
};
Add code to extrude a triangle mesh, and to perform Boolean ops on a triangle mesh in a BSP. That works, although it splits too often, the initial triangulations are not good quality, and coplanar faces are not yet handled. I'll do the coplanar thing tomorrow. [git-p4: depot-paths = "//depot/solvespace/": change = 1735]
2008-05-23 10:05:07 +00:00
Add color. Now each triangle has metadata, which are preserved in csg ops; so the union of a red part and a blue part has both red and blue faces. And some user interface to pick the color in the text window. The metadata also include a face, which will be an entity; I can use that to constrain against. But none of that is yet implemented. [git-p4: depot-paths = "//depot/solvespace/": change = 1757]
2008-05-30 06:09:41 +00:00
static STriangle From(STriMeta meta, Vector a, Vector b, Vector c);
Add const qualifiers to functions where trivially possible. This will allow us in future to accept `const T &` anywhere it's necessary to reduce the amount of copying. This commit is quite conservative: it does not attempt very hard to refactor code that performs incidental mutation. In particular dogd and caches are not marked with the `mutable` keyword. dogd will be eliminated later, opening up more opportunities to add const qualifiers. This commit also doesn't introduce any uses of the newly added const qualifers. This will be done later.
2016-05-21 05:18:00 +00:00
Vector Normal() const;
Rewrite declarations of form f(void) as f(). In C++ there is no difference and newly added functions are all declared as f(), so this brings back consistency.
2016-05-05 05:54:05 +00:00
void FlipNormal();
Add const qualifiers to functions where trivially possible. This will allow us in future to accept `const T &` anywhere it's necessary to reduce the amount of copying. This commit is quite conservative: it does not attempt very hard to refactor code that performs incidental mutation. In particular dogd and caches are not marked with the `mutable` keyword. dogd will be eliminated later, opening up more opportunities to add const qualifiers. This commit also doesn't introduce any uses of the newly added const qualifers. This will be done later.
2016-05-21 05:18:00 +00:00
double MinAltitude() const;
int WindingNumberForPoint(Vector p) const;
bool ContainsPoint(Vector p) const;
bool ContainsPointProjd(Vector n, Vector p) const;
Implement SPolygon::TriangulateInto.
2016-07-31 10:35:11 +00:00
STriangle Transform(Vector o, Vector u, Vector v) const;
Improve performance of face picking. This commit implements two improvements. First, it rewrites SMesh::FirstIntersectionWith() to use an optimal (as currently known) ray tracing algorithm. Second, it rejects triangles without an associated face entity outright.
2016-11-19 09:21:11 +00:00
bool Raytrace(const Vector &rayPoint, const Vector &rayDir,
double *t, Vector *inters) const;
Add a command to show center of mass, assuming uniform density.
2017-01-17 16:57:27 +00:00
double SignedVolume() const;
Avoid degenerate triangles when snapping to mesh. This can cause memory exhaustion when exporting to mesh with small (but not excessively small) chord tolerance.
2017-05-22 14:40:25 +00:00
bool IsDegenerate() const;
Rip out the boundary rep csg stuff. I'll redo that with a triangle mesh approach. [git-p4: depot-paths = "//depot/solvespace/": change = 1732]
2008-05-21 03:58:14 +00:00
};
class SBsp2 {
Add polygon triangulation, by cheating. I'm using the gl tesselator for that, and storing the triangles instead of rendering them immediately. Not sure if that's smart; in theory could change from implementation to implementation, but the results look much better than I would get myself. [git-p4: depot-paths = "//depot/solvespace/": change = 1733]
2008-05-22 10:28:28 +00:00
public:
Make coplanar faces work properly, by implementing a 2d BSP on each set of coplanar faces. The polygon count still gets stupid fast; I'm thinking I can fix that by adding some extra test planes at the top of the 3d BSP, to quickly cull out stuff that doesn't intersect us. [git-p4: depot-paths = "//depot/solvespace/": change = 1736]
2008-05-24 10:34:06 +00:00
Vector np; // normal to the plane
Vector no; // outer normal to the edge
double d;
Rip out the boundary rep csg stuff. I'll redo that with a triangle mesh approach. [git-p4: depot-paths = "//depot/solvespace/": change = 1732]
2008-05-21 03:58:14 +00:00
SEdge edge;
Add constructive solid geometry ops. These work to some extent, but not very well; I'm doing a b-rep, where the boundaries are complex polygons, and there's too many special cases. I should probably replace this with a triangle mesh solution. [git-p4: depot-paths = "//depot/solvespace/": change = 1731]
2008-05-19 09:23:49 +00:00
Add polygon triangulation, by cheating. I'm using the gl tesselator for that, and storing the triangles instead of rendering them immediately. Not sure if that's smart; in theory could change from implementation to implementation, but the results look much better than I would get myself. [git-p4: depot-paths = "//depot/solvespace/": change = 1733]
2008-05-22 10:28:28 +00:00
SBsp2 *pos;
SBsp2 *neg;
SBsp2 *more;
Add code to extrude a triangle mesh, and to perform Boolean ops on a triangle mesh in a BSP. That works, although it splits too often, the initial triangulations are not good quality, and coplanar faces are not yet handled. I'll do the coplanar thing tomorrow. [git-p4: depot-paths = "//depot/solvespace/": change = 1735]
2008-05-23 10:05:07 +00:00
Convert all enumerations to use `enum class`. Specifically, take the old code that looks like this: class Foo { enum { X = 1, Y = 2 }; int kind; } ... foo.kind = Foo::X; ... and convert it to this: class Foo { enum class Kind : uint32_t { X = 1, Y = 2 }; Kind kind; } ... foo.kind = Foo::Kind::X; (In some cases the enumeration would not be in the class namespace, such as when it is generally useful.) The benefits are as follows: * The type of the field gives a clear indication of intent, both to humans and tools (such as binding generators). * The compiler is able to automatically warn when a switch is not exhaustive; but this is currently suppressed by the default: ssassert(false, ...) idiom. * Integers and plain enums are weakly type checked: they implicitly convert into each other. This can hide bugs where type conversion is performed but not intended. Enum classes are strongly type checked. * Plain enums pollute parent namespaces; enum classes do not. Almost every defined enum we have already has a kind of ad-hoc namespacing via `NAMESPACE_`, which is now explicit. * Plain enums do not have a well-defined ABI size, which is important for bindings. Enum classes can have it, if specified. We specify the base type for all enums as uint32_t, which is a safe choice and allows us to not change the numeric values of any variants. This commit introduces absolutely no functional change to the code, just renaming and change of types. It handles almost all cases, except GraphicsWindow::pending.operation, which needs minor functional change.
2016-05-20 08:31:20 +00:00
void InsertTriangleHow(BspClass how, STriangle *tr, SMesh *m, SBsp3 *bsp3);
As we break things against the BSP, keep an arbitrary convex polygon, not just triangles. This helps to avoid needless splitting. Also test if an entire triangle got inserted in multiple pieces; if yes, back things out, and just insert the triangle. Also remove the extra partition stuff, since it didn't seem to help consistently, and this does. Still could do some better merging, in the case where an inserted triangle does not get fully inserted, but we can find a better triangulation than what the BSP naturally gives. [git-p4: depot-paths = "//depot/solvespace/": change = 1739]
2008-05-24 23:10:00 +00:00
void InsertTriangle(STriangle *tr, SMesh *m, SBsp3 *bsp3);
Add const qualifiers to functions where trivially possible. This will allow us in future to accept `const T &` anywhere it's necessary to reduce the amount of copying. This commit is quite conservative: it does not attempt very hard to refactor code that performs incidental mutation. In particular dogd and caches are not marked with the `mutable` keyword. dogd will be eliminated later, opening up more opportunities to add const qualifiers. This commit also doesn't introduce any uses of the newly added const qualifers. This will be done later.
2016-05-21 05:18:00 +00:00
Vector IntersectionWith(Vector a, Vector b) const;
Get rid of if(!this). According to the C++ standard, "this" is never NULL, so checks of the form "if(!this)" can be legally optimized out. This breaks SolveSpace on GCC 6, and probably on other compilers and configurations.
2016-03-25 14:16:58 +00:00
void InsertEdge(SEdge *nedge, Vector nnp, Vector out);
Add const qualifiers to functions where trivially possible. This will allow us in future to accept `const T &` anywhere it's necessary to reduce the amount of copying. This commit is quite conservative: it does not attempt very hard to refactor code that performs incidental mutation. In particular dogd and caches are not marked with the `mutable` keyword. dogd will be eliminated later, opening up more opportunities to add const qualifiers. This commit also doesn't introduce any uses of the newly added const qualifers. This will be done later.
2016-05-21 05:18:00 +00:00
static SBsp2 *InsertOrCreateEdge(SBsp2 *where, SEdge *nedge,
Vector nnp, Vector out);
Rewrite declarations of form f(void) as f(). In C++ there is no difference and newly added functions are all declared as f(), so this brings back consistency.
2016-05-05 05:54:05 +00:00
static SBsp2 *Alloc();
Rough file/save for SolveSpace; that's all done from a single table, relatively small code size. No user interface for it, though. [git-p4: depot-paths = "//depot/solvespace/": change = 1685]
2008-04-24 06:22:16 +00:00
};
Rip out the boundary rep csg stuff. I'll redo that with a triangle mesh approach. [git-p4: depot-paths = "//depot/solvespace/": change = 1732]
2008-05-21 03:58:14 +00:00
class SBsp3 {
Add horizontal and vertical constraints. Those have their own 2d/3d issues, when the points are not all in the same coordinate system. All painful, of course. Also add continuous line drawing, and auto-constraining of line segments as I draw. [git-p4: depot-paths = "//depot/solvespace/": change = 1683]
2008-04-23 07:29:19 +00:00
public:
Add code to extrude a triangle mesh, and to perform Boolean ops on a triangle mesh in a BSP. That works, although it splits too often, the initial triangulations are not good quality, and coplanar faces are not yet handled. I'll do the coplanar thing tomorrow. [git-p4: depot-paths = "//depot/solvespace/": change = 1735]
2008-05-23 10:05:07 +00:00
Vector n;
double d;
Rip out the boundary rep csg stuff. I'll redo that with a triangle mesh approach. [git-p4: depot-paths = "//depot/solvespace/": change = 1732]
2008-05-21 03:58:14 +00:00
STriangle tri;
SBsp3 *pos;
SBsp3 *neg;
Add constructive solid geometry ops. These work to some extent, but not very well; I'm doing a b-rep, where the boundaries are complex polygons, and there's too many special cases. I should probably replace this with a triangle mesh solution. [git-p4: depot-paths = "//depot/solvespace/": change = 1731]
2008-05-19 09:23:49 +00:00
Rip out the boundary rep csg stuff. I'll redo that with a triangle mesh approach. [git-p4: depot-paths = "//depot/solvespace/": change = 1732]
2008-05-21 03:58:14 +00:00
SBsp3 *more;
SBsp2 *edges;
Add code to extrude a triangle mesh, and to perform Boolean ops on a triangle mesh in a BSP. That works, although it splits too often, the initial triangulations are not good quality, and coplanar faces are not yet handled. I'll do the coplanar thing tomorrow. [git-p4: depot-paths = "//depot/solvespace/": change = 1735]
2008-05-23 10:05:07 +00:00
Rewrite declarations of form f(void) as f(). In C++ there is no difference and newly added functions are all declared as f(), so this brings back consistency.
2016-05-05 05:54:05 +00:00
static SBsp3 *Alloc();
Add a new renderer that prepares geometry for 2d backends. SurfaceRenderer is a new renderer implementing the Canvas interface running entirely on the CPU; it projects strokes and triangles in the exact same way as OpenGL would, and it can be used for rendering into raster or vector 2d surfaces.
2016-07-21 20:27:53 +00:00
static SBsp3 *FromMesh(const SMesh *m);
Add code to extrude a triangle mesh, and to perform Boolean ops on a triangle mesh in a BSP. That works, although it splits too often, the initial triangulations are not good quality, and coplanar faces are not yet handled. I'll do the coplanar thing tomorrow. [git-p4: depot-paths = "//depot/solvespace/": change = 1735]
2008-05-23 10:05:07 +00:00
Add const qualifiers to functions where trivially possible. This will allow us in future to accept `const T &` anywhere it's necessary to reduce the amount of copying. This commit is quite conservative: it does not attempt very hard to refactor code that performs incidental mutation. In particular dogd and caches are not marked with the `mutable` keyword. dogd will be eliminated later, opening up more opportunities to add const qualifiers. This commit also doesn't introduce any uses of the newly added const qualifers. This will be done later.
2016-05-21 05:18:00 +00:00
Vector IntersectionWith(Vector a, Vector b) const;
Add code to extrude a triangle mesh, and to perform Boolean ops on a triangle mesh in a BSP. That works, although it splits too often, the initial triangulations are not good quality, and coplanar faces are not yet handled. I'll do the coplanar thing tomorrow. [git-p4: depot-paths = "//depot/solvespace/": change = 1735]
2008-05-23 10:05:07 +00:00
Convert all enumerations to use `enum class`. Specifically, take the old code that looks like this: class Foo { enum { X = 1, Y = 2 }; int kind; } ... foo.kind = Foo::X; ... and convert it to this: class Foo { enum class Kind : uint32_t { X = 1, Y = 2 }; Kind kind; } ... foo.kind = Foo::Kind::X; (In some cases the enumeration would not be in the class namespace, such as when it is generally useful.) The benefits are as follows: * The type of the field gives a clear indication of intent, both to humans and tools (such as binding generators). * The compiler is able to automatically warn when a switch is not exhaustive; but this is currently suppressed by the default: ssassert(false, ...) idiom. * Integers and plain enums are weakly type checked: they implicitly convert into each other. This can hide bugs where type conversion is performed but not intended. Enum classes are strongly type checked. * Plain enums pollute parent namespaces; enum classes do not. Almost every defined enum we have already has a kind of ad-hoc namespacing via `NAMESPACE_`, which is now explicit. * Plain enums do not have a well-defined ABI size, which is important for bindings. Enum classes can have it, if specified. We specify the base type for all enums as uint32_t, which is a safe choice and allows us to not change the numeric values of any variants. This commit introduces absolutely no functional change to the code, just renaming and change of types. It handles almost all cases, except GraphicsWindow::pending.operation, which needs minor functional change.
2016-05-20 08:31:20 +00:00
void InsertHow(BspClass how, STriangle *str, SMesh *instead);
Get rid of if(!this). According to the C++ standard, "this" is never NULL, so checks of the form "if(!this)" can be legally optimized out. This breaks SolveSpace on GCC 6, and probably on other compilers and configurations.
2016-03-25 14:16:58 +00:00
void Insert(STriangle *str, SMesh *instead);
static SBsp3 *InsertOrCreate(SBsp3 *where, STriangle *str, SMesh *instead);
Add code to extrude a triangle mesh, and to perform Boolean ops on a triangle mesh in a BSP. That works, although it splits too often, the initial triangulations are not good quality, and coplanar faces are not yet handled. I'll do the coplanar thing tomorrow. [git-p4: depot-paths = "//depot/solvespace/": change = 1735]
2008-05-23 10:05:07 +00:00
Refactor insertion into BSP tree. Before this commit, inserting into BSP tree could easily overflow the stack because we allocate very large stack frames and, on convex geometries (e.g. a sphere), the BSP tree degenerates into a "BSP list", thus requiring one large stack frame per triangle. This can be reproduced by exporting a 2d shaded view of sphere. After this commit, the stack frames only contan a pointer to a supplementary data structure, and moreover it only allocates its fields on demand, conserving heap memory as well. As a side effect, an arbitrary classifier limit of 50 vertices is removed.
2016-04-30 11:54:59 +00:00
void InsertConvexHow(BspClass how, STriMeta meta, Vector *vertex, size_t n,
Add color. Now each triangle has metadata, which are preserved in csg ops; so the union of a red part and a blue part has both red and blue faces. And some user interface to pick the color in the text window. The metadata also include a face, which will be an entity; I can use that to constrain against. But none of that is yet implemented. [git-p4: depot-paths = "//depot/solvespace/": change = 1757]
2008-05-30 06:09:41 +00:00
SMesh *instead);
Refactor insertion into BSP tree. Before this commit, inserting into BSP tree could easily overflow the stack because we allocate very large stack frames and, on convex geometries (e.g. a sphere), the BSP tree degenerates into a "BSP list", thus requiring one large stack frame per triangle. This can be reproduced by exporting a 2d shaded view of sphere. After this commit, the stack frames only contan a pointer to a supplementary data structure, and moreover it only allocates its fields on demand, conserving heap memory as well. As a side effect, an arbitrary classifier limit of 50 vertices is removed.
2016-04-30 11:54:59 +00:00
SBsp3 *InsertConvex(STriMeta meta, Vector *vertex, size_t n, SMesh *instead);
As we break things against the BSP, keep an arbitrary convex polygon, not just triangles. This helps to avoid needless splitting. Also test if an entire triangle got inserted in multiple pieces; if yes, back things out, and just insert the triangle. Also remove the extra partition stuff, since it didn't seem to help consistently, and this does. Still could do some better merging, in the case where an inserted triangle does not get fully inserted, but we can find a better triangulation than what the BSP naturally gives. [git-p4: depot-paths = "//depot/solvespace/": change = 1739]
2008-05-24 23:10:00 +00:00
void InsertInPlane(bool pos2, STriangle *tr, SMesh *m);
Make coplanar faces work properly, by implementing a 2d BSP on each set of coplanar faces. The polygon count still gets stupid fast; I'm thinking I can fix that by adding some extra test planes at the top of the 3d BSP, to quickly cull out stuff that doesn't intersect us. [git-p4: depot-paths = "//depot/solvespace/": change = 1736]
2008-05-24 10:34:06 +00:00
Add const qualifiers to functions where trivially possible. This will allow us in future to accept `const T &` anywhere it's necessary to reduce the amount of copying. This commit is quite conservative: it does not attempt very hard to refactor code that performs incidental mutation. In particular dogd and caches are not marked with the `mutable` keyword. dogd will be eliminated later, opening up more opportunities to add const qualifiers. This commit also doesn't introduce any uses of the newly added const qualifers. This will be done later.
2016-05-21 05:18:00 +00:00
void GenerateInPaintOrder(SMesh *m) const;
Rip out the boundary rep csg stuff. I'll redo that with a triangle mesh approach. [git-p4: depot-paths = "//depot/solvespace/": change = 1732]
2008-05-21 03:58:14 +00:00
};
Add constructive solid geometry ops. These work to some extent, but not very well; I'm doing a b-rep, where the boundaries are complex polygons, and there's too many special cases. I should probably replace this with a triangle mesh solution. [git-p4: depot-paths = "//depot/solvespace/": change = 1731]
2008-05-19 09:23:49 +00:00
Rip out the boundary rep csg stuff. I'll redo that with a triangle mesh approach. [git-p4: depot-paths = "//depot/solvespace/": change = 1732]
2008-05-21 03:58:14 +00:00
class SMesh {
public:
Add menu item to center view at a point; and move non-ID list data structure from polygon.h into dsc.h, since it is used outside the polygon/mesh code. [git-p4: depot-paths = "//depot/solvespace/": change = 1892]
2009-01-13 06:56:05 +00:00
List<STriangle> l;
Add polygon triangulation, by cheating. I'm using the gl tesselator for that, and storing the triangles instead of rendering them immediately. Not sure if that's smart; in theory could change from implementation to implementation, but the results look much better than I would get myself. [git-p4: depot-paths = "//depot/solvespace/": change = 1733]
2008-05-22 10:28:28 +00:00
As we break things against the BSP, keep an arbitrary convex polygon, not just triangles. This helps to avoid needless splitting. Also test if an entire triangle got inserted in multiple pieces; if yes, back things out, and just insert the triangle. Also remove the extra partition stuff, since it didn't seem to help consistently, and this does. Still could do some better merging, in the case where an inserted triangle does not get fully inserted, but we can find a better triangulation than what the BSP naturally gives. [git-p4: depot-paths = "//depot/solvespace/": change = 1739]
2008-05-24 23:10:00 +00:00
bool flipNormal;
bool keepCoplanar;
bool atLeastOneDiscarded;
Add support for transparent solids. Some extra code is necessary to determine that the back faces should not be drawn in red for transparent solids. It is expected that the user will first ensure that the shell is watertight and then set the opacity; back faces are still drawn if the opacity is exactly 1. The savefile format is changed backwards-compatibly by stashing the alpha value in uppermost byte of 4-byte hex color value in Surface and Triangle clauses. The existing files have 00 in the high byte, so RgbColor::FromPackedInt treats that as "opaque".
2015-03-26 10:30:12 +00:00
bool isTransparent;
As we break things against the BSP, keep an arbitrary convex polygon, not just triangles. This helps to avoid needless splitting. Also test if an entire triangle got inserted in multiple pieces; if yes, back things out, and just insert the triangle. Also remove the extra partition stuff, since it didn't seem to help consistently, and this does. Still could do some better merging, in the case where an inserted triangle does not get fully inserted, but we can find a better triangulation than what the BSP naturally gives. [git-p4: depot-paths = "//depot/solvespace/": change = 1739]
2008-05-24 23:10:00 +00:00
Rewrite declarations of form f(void) as f(). In C++ there is no difference and newly added functions are all declared as f(), so this brings back consistency.
2016-05-05 05:54:05 +00:00
void Clear();
Add const qualifiers to functions where trivially possible. This will allow us in future to accept `const T &` anywhere it's necessary to reduce the amount of copying. This commit is quite conservative: it does not attempt very hard to refactor code that performs incidental mutation. In particular dogd and caches are not marked with the `mutable` keyword. dogd will be eliminated later, opening up more opportunities to add const qualifiers. This commit also doesn't introduce any uses of the newly added const qualifers. This will be done later.
2016-05-21 05:18:00 +00:00
void AddTriangle(const STriangle *st);
Add color. Now each triangle has metadata, which are preserved in csg ops; so the union of a red part and a blue part has both red and blue faces. And some user interface to pick the color in the text window. The metadata also include a face, which will be an entity; I can use that to constrain against. But none of that is yet implemented. [git-p4: depot-paths = "//depot/solvespace/": change = 1757]
2008-05-30 06:09:41 +00:00
void AddTriangle(STriMeta meta, Vector a, Vector b, Vector c);
Add const qualifiers to functions where trivially possible. This will allow us in future to accept `const T &` anywhere it's necessary to reduce the amount of copying. This commit is quite conservative: it does not attempt very hard to refactor code that performs incidental mutation. In particular dogd and caches are not marked with the `mutable` keyword. dogd will be eliminated later, opening up more opportunities to add const qualifiers. This commit also doesn't introduce any uses of the newly added const qualifers. This will be done later.
2016-05-21 05:18:00 +00:00
void AddTriangle(STriMeta meta, Vector n,
Vector a, Vector b, Vector c);
void DoBounding(Vector v, Vector *vmax, Vector *vmin) const;
void GetBounding(Vector *vmax, Vector *vmin) const;
As we break things against the BSP, keep an arbitrary convex polygon, not just triangles. This helps to avoid needless splitting. Also test if an entire triangle got inserted in multiple pieces; if yes, back things out, and just insert the triangle. Also remove the extra partition stuff, since it didn't seem to help consistently, and this does. Still could do some better merging, in the case where an inserted triangle does not get fully inserted, but we can find a better triangulation than what the BSP naturally gives. [git-p4: depot-paths = "//depot/solvespace/": change = 1739]
2008-05-24 23:10:00 +00:00
When a triangle gets split when it's added, retriangulate in an effort to reduce the number of pieces. [git-p4: depot-paths = "//depot/solvespace/": change = 1743]
2008-05-26 03:39:45 +00:00
void Simplify(int start);
As we break things against the BSP, keep an arbitrary convex polygon, not just triangles. This helps to avoid needless splitting. Also test if an entire triangle got inserted in multiple pieces; if yes, back things out, and just insert the triangle. Also remove the extra partition stuff, since it didn't seem to help consistently, and this does. Still could do some better merging, in the case where an inserted triangle does not get fully inserted, but we can find a better triangulation than what the BSP naturally gives. [git-p4: depot-paths = "//depot/solvespace/": change = 1739]
2008-05-24 23:10:00 +00:00
void AddAgainstBsp(SMesh *srcm, SBsp3 *bsp3);
Add ability to represent our surfaces as either a shell or a mesh, according to the user's preference. I templated the housekeeping stuff for Boolean operations and step and repeat, so it's relatively clean. Still need to add the stuff to make a mesh vertex-to-vertex, and to export sections of a mesh. [git-p4: depot-paths = "//depot/solvespace/": change = 1959]
2009-05-24 11:37:07 +00:00
void MakeFromUnionOf(SMesh *a, SMesh *b);
void MakeFromDifferenceOf(SMesh *a, SMesh *b);
void MakeFromCopyOf(SMesh *a);
Add const qualifiers to functions where trivially possible. This will allow us in future to accept `const T &` anywhere it's necessary to reduce the amount of copying. This commit is quite conservative: it does not attempt very hard to refactor code that performs incidental mutation. In particular dogd and caches are not marked with the `mutable` keyword. dogd will be eliminated later, opening up more opportunities to add const qualifiers. This commit also doesn't introduce any uses of the newly added const qualifers. This will be done later.
2016-05-21 05:18:00 +00:00
void MakeFromTransformationOf(SMesh *a, Vector trans,
Quaternion q, double scale);
Add ability to represent our surfaces as either a shell or a mesh, according to the user's preference. I templated the housekeeping stuff for Boolean operations and step and repeat, so it's relatively clean. Still need to add the stuff to make a mesh vertex-to-vertex, and to export sections of a mesh. [git-p4: depot-paths = "//depot/solvespace/": change = 1959]
2009-05-24 11:37:07 +00:00
void MakeFromAssemblyOf(SMesh *a, SMesh *b);
Put back the "snap to vertex" stuff to remove tee intersections that the BSP-based Booleans create. [git-p4: depot-paths = "//depot/solvespace/": change = 1960]
2009-05-28 07:07:54 +00:00
void MakeEdgesInPlaneInto(SEdgeList *sel, Vector n, double d);
Unify displayEdges and displayOutlines. This has the following benefits: * Less geometry to generate; we can do both in one pass; * Less geometry to draw; * Eliminate overdraw of outlines on top of emphasized edges; * In future, being able to seamlessly stitch stippled lines. The contour edges are now also drawn before emphasized edges; this makes intersections of contour and emphasized edges look better as the thinner emphasized edge doesn't clobber the depth buffer.
2016-06-26 06:39:27 +00:00
void MakeOutlinesInto(SOutlineList *sol, EdgeKind type);
Put back the "snap to vertex" stuff to remove tee intersections that the BSP-based Booleans create. [git-p4: depot-paths = "//depot/solvespace/": change = 1960]
2009-05-28 07:07:54 +00:00
Somewhat improve rendering of transparent meshes. After this commit, any transparent triangles are drawn last, which causes them to not clobber the depth buffer, and so if they overlap some opaque triangles, then these opaque triangles will be visible. There are still issues with overlapping transparent triangles, and with transparent triangles overlapping outlines and entities.
2016-12-05 03:11:34 +00:00
void PrecomputeTransparency();
Remove degenerate triangles when generating triangle mesh.
2017-02-04 10:47:39 +00:00
void RemoveDegenerateTriangles();
Somewhat improve rendering of transparent meshes. After this commit, any transparent triangles are drawn last, which causes them to not clobber the depth buffer, and so if they overlap some opaque triangles, then these opaque triangles will be visible. There are still issues with overlapping transparent triangles, and with transparent triangles overlapping outlines and entities.
2016-12-05 03:11:34 +00:00
Add const qualifiers to functions where trivially possible. This will allow us in future to accept `const T &` anywhere it's necessary to reduce the amount of copying. This commit is quite conservative: it does not attempt very hard to refactor code that performs incidental mutation. In particular dogd and caches are not marked with the `mutable` keyword. dogd will be eliminated later, opening up more opportunities to add const qualifiers. This commit also doesn't introduce any uses of the newly added const qualifers. This will be done later.
2016-05-21 05:18:00 +00:00
bool IsEmpty() const;
Add ability to represent our surfaces as either a shell or a mesh, according to the user's preference. I templated the housekeeping stuff for Boolean operations and step and repeat, so it's relatively clean. Still need to add the stuff to make a mesh vertex-to-vertex, and to export sections of a mesh. [git-p4: depot-paths = "//depot/solvespace/": change = 1959]
2009-05-24 11:37:07 +00:00
void RemapFaces(Group *g, int remap);
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 const qualifiers to functions where trivially possible. This will allow us in future to accept `const T &` anywhere it's necessary to reduce the amount of copying. This commit is quite conservative: it does not attempt very hard to refactor code that performs incidental mutation. In particular dogd and caches are not marked with the `mutable` keyword. dogd will be eliminated later, opening up more opportunities to add const qualifiers. This commit also doesn't introduce any uses of the newly added const qualifers. This will be done later.
2016-05-21 05:18:00 +00:00
uint32_t FirstIntersectionWith(Point2d mp) const;
Add a command to show center of mass, assuming uniform density.
2017-01-17 16:57:27 +00:00
Vector GetCenterOfMass() const;
Add horizontal and vertical constraints. Those have their own 2d/3d issues, when the points are not all in the same coordinate system. All painful, of course. Also add continuous line drawing, and auto-constraining of line segments as I draw. [git-p4: depot-paths = "//depot/solvespace/": change = 1683]
2008-04-23 07:29:19 +00:00
};
Now I can rename groups, using that same edit control in the text window. [git-p4: depot-paths = "//depot/solvespace/": change = 1750]
2008-05-27 09:52:36 +00:00
// A linked list of triangles
class STriangleLl {
public:
Move `Solve Once Now' to the Edit menu, and call it `Regenerate'; and fix some other problems with the menu labels. [git-p4: depot-paths = "//depot/solvespace/": change = 1815]
2008-06-30 09:34:03 +00:00
STriangle *tri;
Now I can rename groups, using that same edit control in the text window. [git-p4: depot-paths = "//depot/solvespace/": change = 1750]
2008-05-27 09:52:36 +00:00
STriangleLl *next;
Add routines to remove T intersections from the mesh, which are introduced by the bsp routines. It's usually, though not always, possible to generate a watertight mesh. The occasions where it's not look ugly, floating point issues, no quick fix. And use those to generate a list of edges where two different faces meet, which I can emphasize for cosmetic reasons (and some UI to specify whether to do that, and with what color). And make the right mouse button rotate the model, since that was previously doing nothing. [git-p4: depot-paths = "//depot/solvespace/": change = 1821]
2008-07-06 07:56:24 +00:00
Rewrite declarations of form f(void) as f(). In C++ there is no difference and newly added functions are all declared as f(), so this brings back consistency.
2016-05-05 05:54:05 +00:00
static STriangleLl *Alloc();
Now I can rename groups, using that same edit control in the text window. [git-p4: depot-paths = "//depot/solvespace/": change = 1750]
2008-05-27 09:52:36 +00:00
};
Allow rendering solid outlines using a distinct style. A new button is added, "Show/hide outline of solid model". When the outline is hidden, it is rendered using the "solid edge" style. When the outline is shown, it is rendered using the "outline" style. In SolveSpace's true WYSIWYG tradition, the 2d view export follows the rendered view exactly. Moreover, shell edges are not rendered anymore, since there is not much need in them anymore and not drawing them lessens the overlap between various kinds of lines, which already includes entities, solid edges and outlines.
2016-03-14 16:14:24 +00:00
class SOutline {
public:
int tag;
Vector a, b, nl, nr;
Factor in SOutlineList::FillOutlineTags.
2016-05-24 02:26:52 +00:00
bool IsVisible(Vector projDir) const;
Allow rendering solid outlines using a distinct style. A new button is added, "Show/hide outline of solid model". When the outline is hidden, it is rendered using the "solid edge" style. When the outline is shown, it is rendered using the "outline" style. In SolveSpace's true WYSIWYG tradition, the 2d view export follows the rendered view exactly. Moreover, shell edges are not rendered anymore, since there is not much need in them anymore and not drawing them lessens the overlap between various kinds of lines, which already includes entities, solid edges and outlines.
2016-03-14 16:14:24 +00:00
};
class SOutlineList {
public:
List<SOutline> l;
void Clear();
Unify displayEdges and displayOutlines. This has the following benefits: * Less geometry to generate; we can do both in one pass; * Less geometry to draw; * Eliminate overdraw of outlines on top of emphasized edges; * In future, being able to seamlessly stitch stippled lines. The contour edges are now also drawn before emphasized edges; this makes intersections of contour and emphasized edges look better as the thinner emphasized edge doesn't clobber the depth buffer.
2016-06-26 06:39:27 +00:00
void AddEdge(Vector a, Vector b, Vector nl, Vector nr, int tag = 0);
void ListTaggedInto(SEdgeList *el, int auxA = 0, int auxB = 0);
Allow rendering solid outlines using a distinct style. A new button is added, "Show/hide outline of solid model". When the outline is hidden, it is rendered using the "solid edge" style. When the outline is shown, it is rendered using the "outline" style. In SolveSpace's true WYSIWYG tradition, the 2d view export follows the rendered view exactly. Moreover, shell edges are not rendered anymore, since there is not much need in them anymore and not drawing them lessens the overlap between various kinds of lines, which already includes entities, solid edges and outlines.
2016-03-14 16:14:24 +00:00
void MakeFromCopyOf(SOutlineList *ol);
};
Add routines to remove T intersections from the mesh, which are introduced by the bsp routines. It's usually, though not always, possible to generate a watertight mesh. The occasions where it's not look ugly, floating point issues, no quick fix. And use those to generate a list of edges where two different faces meet, which I can emphasize for cosmetic reasons (and some UI to specify whether to do that, and with what color). And make the right mouse button rotate the model, since that was previously doing nothing. [git-p4: depot-paths = "//depot/solvespace/": change = 1821]
2008-07-06 07:56:24 +00:00
class SKdNode {
Now I can rename groups, using that same edit control in the text window. [git-p4: depot-paths = "//depot/solvespace/": change = 1750]
2008-05-27 09:52:36 +00:00
public:
Refactor SKdNode::FindEdgeOn. Extract output parameters into a separate structure.
2016-03-22 05:03:12 +00:00
struct EdgeOnInfo {
int count;
bool frontFacing;
bool intersectsMesh;
Only export sharp edges of the triangle mesh. Before this commit, "emphasized edges" were displayed as well as exported. An "emphasized edge" is an edge between triangles that come from different faces. They are helpful in the rendered display because they hint at the locations of faces, but not in the 2d export since they just clutter the drawing. After this commit, "emphasized edges" are displayed but "sharp edges" are exported. A "sharp edge" is an edge between triangles where the two matching vertexes have different normals, indicating a discontiguity in the surface. "Sharp edges" are also displayed while post-viewing the exported geometry.
2016-03-22 10:52:09 +00:00
STriangle *tr;
int ai;
int bi;
Refactor SKdNode::FindEdgeOn. Extract output parameters into a separate structure.
2016-03-22 05:03:12 +00:00
};
Add O(n*log(n)) self-intersection check for polygons. That was previously a major bottleneck, and is now at least 10x faster for a practical section. And fix a horrible uninit memory bug in the triangle kd-tree stuff; the split planes were apparently random. This would have slowed things down, but not caused an incorrect result; except when it ends up NaN, which is the reason I noticed. [git-p4: depot-paths = "//depot/solvespace/": change = 2073]
2009-11-09 11:51:38 +00:00
int which; // whether c is x, y, or z
Now I can rename groups, using that same edit control in the text window. [git-p4: depot-paths = "//depot/solvespace/": change = 1750]
2008-05-27 09:52:36 +00:00
double c;
Add routines to remove T intersections from the mesh, which are introduced by the bsp routines. It's usually, though not always, possible to generate a watertight mesh. The occasions where it's not look ugly, floating point issues, no quick fix. And use those to generate a list of edges where two different faces meet, which I can emphasize for cosmetic reasons (and some UI to specify whether to do that, and with what color). And make the right mouse button rotate the model, since that was previously doing nothing. [git-p4: depot-paths = "//depot/solvespace/": change = 1821]
2008-07-06 07:56:24 +00:00
SKdNode *gt;
SKdNode *lt;
Now I can rename groups, using that same edit control in the text window. [git-p4: depot-paths = "//depot/solvespace/": change = 1750]
2008-05-27 09:52:36 +00:00
Move `Solve Once Now' to the Edit menu, and call it `Regenerate'; and fix some other problems with the menu labels. [git-p4: depot-paths = "//depot/solvespace/": change = 1815]
2008-06-30 09:34:03 +00:00
STriangleLl *tris;
Add routines to remove T intersections from the mesh, which are introduced by the bsp routines. It's usually, though not always, possible to generate a watertight mesh. The occasions where it's not look ugly, floating point issues, no quick fix. And use those to generate a list of edges where two different faces meet, which I can emphasize for cosmetic reasons (and some UI to specify whether to do that, and with what color). And make the right mouse button rotate the model, since that was previously doing nothing. [git-p4: depot-paths = "//depot/solvespace/": change = 1821]
2008-07-06 07:56:24 +00:00
Rewrite declarations of form f(void) as f(). In C++ there is no difference and newly added functions are all declared as f(), so this brings back consistency.
2016-05-05 05:54:05 +00:00
static SKdNode *Alloc();
Add routines to remove T intersections from the mesh, which are introduced by the bsp routines. It's usually, though not always, possible to generate a watertight mesh. The occasions where it's not look ugly, floating point issues, no quick fix. And use those to generate a list of edges where two different faces meet, which I can emphasize for cosmetic reasons (and some UI to specify whether to do that, and with what color). And make the right mouse button rotate the model, since that was previously doing nothing. [git-p4: depot-paths = "//depot/solvespace/": change = 1821]
2008-07-06 07:56:24 +00:00
static SKdNode *From(SMesh *m);
Add O(n*log(n)) self-intersection check for polygons. That was previously a major bottleneck, and is now at least 10x faster for a practical section. And fix a horrible uninit memory bug in the triangle kd-tree stuff; the split planes were apparently random. This would have slowed things down, but not caused an incorrect result; except when it ends up NaN, which is the reason I noticed. [git-p4: depot-paths = "//depot/solvespace/": change = 2073]
2009-11-09 11:51:38 +00:00
static SKdNode *From(STriangleLl *tll);
Add routines to remove T intersections from the mesh, which are introduced by the bsp routines. It's usually, though not always, possible to generate a watertight mesh. The occasions where it's not look ugly, floating point issues, no quick fix. And use those to generate a list of edges where two different faces meet, which I can emphasize for cosmetic reasons (and some UI to specify whether to do that, and with what color). And make the right mouse button rotate the model, since that was previously doing nothing. [git-p4: depot-paths = "//depot/solvespace/": change = 1821]
2008-07-06 07:56:24 +00:00
void AddTriangle(STriangle *tr);
Add const qualifiers to functions where trivially possible. This will allow us in future to accept `const T &` anywhere it's necessary to reduce the amount of copying. This commit is quite conservative: it does not attempt very hard to refactor code that performs incidental mutation. In particular dogd and caches are not marked with the `mutable` keyword. dogd will be eliminated later, opening up more opportunities to add const qualifiers. This commit also doesn't introduce any uses of the newly added const qualifers. This will be done later.
2016-05-21 05:18:00 +00:00
void MakeMeshInto(SMesh *m) const;
void ListTrianglesInto(std::vector<STriangle *> *tl) const;
void ClearTags() const;
Add beginnings of stuff to represent surfaces as either meshes or exact surface shells. And add interference checking; I'll be lazy and just do that on the meshes, by modifying the self-intersection tester to ignore coplanar triangles (since that can happen in an assembly). [git-p4: depot-paths = "//depot/solvespace/": change = 1958]
2009-05-22 10:02:02 +00:00
Add const qualifiers to functions where trivially possible. This will allow us in future to accept `const T &` anywhere it's necessary to reduce the amount of copying. This commit is quite conservative: it does not attempt very hard to refactor code that performs incidental mutation. In particular dogd and caches are not marked with the `mutable` keyword. dogd will be eliminated later, opening up more opportunities to add const qualifiers. This commit also doesn't introduce any uses of the newly added const qualifers. This will be done later.
2016-05-21 05:18:00 +00:00
void FindEdgeOn(Vector a, Vector b, int cnt, bool coplanarIsInter, EdgeOnInfo *info) const;
Convert all enumerations to use `enum class`. Specifically, take the old code that looks like this: class Foo { enum { X = 1, Y = 2 }; int kind; } ... foo.kind = Foo::X; ... and convert it to this: class Foo { enum class Kind : uint32_t { X = 1, Y = 2 }; Kind kind; } ... foo.kind = Foo::Kind::X; (In some cases the enumeration would not be in the class namespace, such as when it is generally useful.) The benefits are as follows: * The type of the field gives a clear indication of intent, both to humans and tools (such as binding generators). * The compiler is able to automatically warn when a switch is not exhaustive; but this is currently suppressed by the default: ssassert(false, ...) idiom. * Integers and plain enums are weakly type checked: they implicitly convert into each other. This can hide bugs where type conversion is performed but not intended. Enum classes are strongly type checked. * Plain enums pollute parent namespaces; enum classes do not. Almost every defined enum we have already has a kind of ad-hoc namespacing via `NAMESPACE_`, which is now explicit. * Plain enums do not have a well-defined ABI size, which is important for bindings. Enum classes can have it, if specified. We specify the base type for all enums as uint32_t, which is a safe choice and allows us to not change the numeric values of any variants. This commit introduces absolutely no functional change to the code, just renaming and change of types. It handles almost all cases, except GraphicsWindow::pending.operation, which needs minor functional change.
2016-05-20 08:31:20 +00:00
void MakeCertainEdgesInto(SEdgeList *sel, EdgeKind how, bool coplanarIsInter,
Add const qualifiers to functions where trivially possible. This will allow us in future to accept `const T &` anywhere it's necessary to reduce the amount of copying. This commit is quite conservative: it does not attempt very hard to refactor code that performs incidental mutation. In particular dogd and caches are not marked with the `mutable` keyword. dogd will be eliminated later, opening up more opportunities to add const qualifiers. This commit also doesn't introduce any uses of the newly added const qualifers. This will be done later.
2016-05-21 05:18:00 +00:00
bool *inter, bool *leaky, int auxA = 0) const;
Unify displayEdges and displayOutlines. This has the following benefits: * Less geometry to generate; we can do both in one pass; * Less geometry to draw; * Eliminate overdraw of outlines on top of emphasized edges; * In future, being able to seamlessly stitch stippled lines. The contour edges are now also drawn before emphasized edges; this makes intersections of contour and emphasized edges look better as the thinner emphasized edge doesn't clobber the depth buffer.
2016-06-26 06:39:27 +00:00
void MakeOutlinesInto(SOutlineList *sel, EdgeKind tagKind) const;
Add hidden line and surface removal, and vector shaded surface export. So I calculate lighting for each triangle in the mesh, make a BSP, and then traverse it in-order and output those as SVG or EPS. And I test edges against the mesh, removing those portions of the edge that overlap a triangle in front of them (using the kd-tree to accelerate). [git-p4: depot-paths = "//depot/solvespace/": change = 1931]
2009-03-17 16:33:46 +00:00
Add a new renderer that prepares geometry for 2d backends. SurfaceRenderer is a new renderer implementing the Canvas interface running entirely on the CPU; it projects strokes and triangles in the exact same way as OpenGL would, and it can be used for rendering into raster or vector 2d surfaces.
2016-07-21 20:27:53 +00:00
void OcclusionTestLine(SEdge orig, SEdgeList *sel, int cnt) const;
void SplitLinesAgainstTriangle(SEdgeList *sel, STriangle *tr) const;
Put back the "snap to vertex" stuff to remove tee intersections that the BSP-based Booleans create. [git-p4: depot-paths = "//depot/solvespace/": change = 1960]
2009-05-28 07:07:54 +00:00
void SnapToMesh(SMesh *m);
void SnapToVertex(Vector v, SMesh *extras);
Now I can rename groups, using that same edit control in the text window. [git-p4: depot-paths = "//depot/solvespace/": change = 1750]
2008-05-27 09:52:36 +00:00
};
Factor out PolylineBuilder from DXF export code.
2016-06-24 09:06:30 +00:00
class PolylineBuilder {
public:
struct Edge;
struct Vertex {
Vector pos;
std::vector<Edge *> edges;
bool GetNext(uint32_t kind, Vertex **next, Edge **nextEdge);
bool GetNext(uint32_t kind, Vector plane, double d, Vertex **next, Edge **nextEdge);
size_t CountEdgesWithTagAndKind(int tag, uint32_t kind) const;
};
struct VertexPairHash {
size_t operator()(const std::pair<Vertex *, Vertex *> &v) const;
};
struct Edge {
Vertex *a;
Vertex *b;
uint32_t kind;
int tag;
union {
uintptr_t data;
SOutline *outline;
SEdge *edge;
};
Vertex *GetOtherVertex(Vertex *v) const;
bool GetStartAndNext(Vertex **start, Vertex **next, bool loop) const;
};
std::unordered_map<Vector, Vertex *, VectorHash, VectorPred> vertices;
std::unordered_map<std::pair<Vertex *, Vertex *>, Edge *, VertexPairHash> edgeMap;
std::vector<Edge *> edges;
~PolylineBuilder();
void Clear();
Vertex *AddVertex(const Vector &pos);
Edge *AddEdge(const Vector &p0, const Vector &p1, uint32_t kind, uintptr_t data = 0);
void Generate(
std::function<void(Vertex *start, Vertex *next, Edge *edge)> startFunc,
std::function<void(Vertex *next, Edge *edge)> nextFunc,
std::function<void(Edge *)> aloneFunc,
std::function<void()> endFunc = [](){});
Stitch outlines before display to preserve phase of stippling. Before this commit, the outlines are generated in an arbitrary order from the kd-tree. This worked just fine for continuous lines, but for stippling, especially on curves, this meant that most of the piecewise linear edges would have the stippling phase restart from zero, leading to a very poor appearance.
2016-10-11 10:38:21 +00:00
void MakeFromEdges(const SEdgeList &sel);
void MakeFromOutlines(const SOutlineList &sol);
void GenerateEdges(SEdgeList *sel);
void GenerateOutlines(SOutlineList *sol);
Factor out PolylineBuilder from DXF export code.
2016-06-24 09:06:30 +00:00
};
Add horizontal and vertical constraints. Those have their own 2d/3d issues, when the points are not all in the same coordinate system. All painful, of course. Also add continuous line drawing, and auto-constraining of line segments as I draw. [git-p4: depot-paths = "//depot/solvespace/": change = 1683]
2008-04-23 07:29:19 +00:00
#endif
Rough file/save for SolveSpace; that's all done from a single table, relatively small code size. No user interface for it, though. [git-p4: depot-paths = "//depot/solvespace/": change = 1685]
2008-04-24 06:22:16 +00:00